flaschengeist-frontend/src/store/modules/userManager.js

import url from '@/plugins/routes'
import axios from 'axios'
const timeout = 20000
const state = {
  users: [],
  status: [],
  usersLoading: false,
  statusLoading: false
}

const mutations = {
  setUsers: (state, users) => {
    state.users = users
  },
  setStatus: (state, status) => {
    state.status = status
  },
  updateUser: (state, user) => {
    let exists = state.users.find(a => {
      return a.username === user.username
    })
    if (exists) {
      exists.firstname = user.firstname
      exists.lastname = user.lastname
      exists.mail = user.mail
      exists.statusgroup = user.statusgroup
      exists.voting = user.voting
      exists.workgroups = user.workgroup
    } else {
      state.users.push({
        username: user.username,
        firstname: user.firstname,
        lastname: user.lastname,
        mail: user.mail,
        statusgroup: user.statusgroup,
        voting: user.voting,
        workgroups: user.workgroups
      })
    }
  },
  updateStatus: (state, status) => {
    let exists = state.status.find(a => {
      return a.id === status.id
    })
    if (exists) {
      exists.name = status.name
    } else {
      state.status.push(status)
    }
  },
  deleteStatus: (state, status) => {
    let index = state.status.indexOf(
      state.status.find(a => {
        return a.id === status.id
      })
    )
    state.status.splice(index, 1)
  },
  setUsersLoading: (state, value) => {
    state.usersLoading = value
  },
  setStatusLoading: (state, value) => {
    state.statusLoading = value
  },
  updateWorkgroups: (state, { id, workgroups }) => {
    let exists = state.users.find(a => {
      return a.id === id
    })
    if (exists) {
      exists.workgroups = workgroups
    }
  }
}

const actions = {
  async getUsers({ commit, rootState, dispatch }) {
    try {
      commit('setUsersLoading', true)
      const response = await axios.get(url.getUsers, {
        headers: { Token: rootState.login.user.accessToken },
        timeout
      })
      commit('setUsers', response.data)
      commit('setUsersLoading', false)
      dispatch('getLifetime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      commit('setUsersLoading', false)
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async getUsersWithExtern({ commit, rootState, dispatch }) {
    try {
      commit('setUsersLoading', true)
      const response = await axios.get(url.getUsers + '?extern=1', {
        headers: { Token: rootState.login.user.accessToken },
        timeout
      })
      commit('setUsers', response.data)
      commit('setUsersLoading', false)
      dispatch('getLifetime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      commit('setUsersLoading', false)
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async getStatus({ commit, rootState, dispatch }) {
    try {
      commit('setStatusLoading', true)
      const response = await axios.get(url.user.getAllStatus, {
        headers: { Token: rootState.login.user.accessToken },
        timeout
      })
      commit('setStatus', response.data)
      commit('setStatusLoading', false)
      dispatch('getLifetime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      commit('setStatusLoading', false)
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async updateStatusUser({ commit, rootState, dispatch }, data) {
    try {
      commit('setUsersLoading', true)
      const response = await axios.post(
        url.vorstand.um.updateStatusUser,
        { ...data },
        { headers: { Token: rootState.login.user.accessToken }, timeout }
      )
      commit('updateUser', response.data)
      commit('setUsersLoading', false)
      dispatch('getLifetime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      commit('setUsersLoading', false)
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async updateVoting({ commit, rootState, dispatch }, data) {
    try {
      commit('setUsersLoading', true)
      const response = await axios.post(
        url.vorstand.um.updateVoting,
        { ...data },
        { headers: { Token: rootState.login.user.accessToken }, timeout }
      )
      commit('updateUser', response.data)
      commit('setUsersLoading', false)
      dispatch('getLifetime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      commit('setUsersLoading', false)
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async updateWorkgroups({ commit, rootState, dispatch }, data) {
    try {
      commit('setUsersLoading', true)
      const response = await axios.post(
        url.vorstand.um.updateWorkgroups,
        { ...data },
        { headers: { Token: rootState.login.user.accessToken }, timeout }
      )
      commit('updateWorkgroups', { id: data.id, workgroups: response.data })
      commit('setUsersLoading', false)
      dispatch('getLifetime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      commit('setUsersLoading', false)
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  }
}

const getters = {
  users: state => {
    return state.users
  },
  status: state => {
    return state.status
  },
  usersLoading: state => {
    return state.usersLoading
  },
  statusLoading: state => {
    return state.statusLoading
  }
}

export default {
  namespaced: true,
  state,
  mutations,
  actions,
  getters
}