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

import axios from 'axios'
import url from '@/plugins/routes'

const state = {
  users: [],
  allUsers: [],
  filter: '',
  usersLoading: false,
  allUsersLoading: false,
  message: [],
  menu: false
}

const mutations = {
  setAllUsers: (state, users) => {
    state.allUsers = []
    state.allUsers = users
    for (let i = 0; i < state.allUsers.length; i++) {
      state.allUsers[i].fullName =
        state.allUsers[i].firstname + ' ' + state.allUsers[i].lastname
    }
  },
  setUsers: (state, users) => {
    for (let user in users) {
      let existuser = state.users.find(a => {
        return user === a.username
      })

      if (existuser) {
        existuser.sername = users[user].username
        existuser.firstname = users[user].firstname
        existuser.lastname = users[user].lastname
        existuser.locked = users[user].locked
        existuser.amount = users[user].amount
        existuser.type = users[user].type
      } else {
        state.users.push({
          username: users[user].username,
          firstname: users[user].firstname,
          lastname: users[user].lastname,
          locked: users[user].locked,
          amount: users[user].amount,
          type: users[user].type,
          loading: false
        })
      }
    }
    mutations.sortUsers(state)
  },
  updateUser: (state, data) => {
    let index = state.users.indexOf(
      state.users.find(a => {
        return a.username === data.username
      })
    )
    if (data.loading !== undefined) state.users[index].loading = data.loading
  },
  sortUsers: state => {
    state.users = state.users.sort((a, b) => {
      if (a.lastname > b.lastname) return 1
      if (a.lastname < b.lastname) return -1
      if (a.firstname > b.firstname) return 1
      if (a.firstname < b.firstname) return -1
      return 0
    })
  },
  setFilter: (state, filter) => {
    state.filter = filter
  },
  setUsersLoading: (state, value) => {
    state.usersLoading = value
  },
  setAllUsersLoading: (state, value) => {
    state.allUsersLoading = value
  },
  addMessage: (state, data) => {
    var message = ''
    if (data.error) {
      message =
        'Konnte ' +
        (data.amount / 100).toFixed(2) +
        '€ zu ' +
        data.user.firstname +
        ' ' +
        data.user.lastname +
        ' hinzufügen.'
    } else {
      message =
        '' +
        (data.amount / 100).toFixed(2) +
        '€ wurde zu ' +
        data.user.firstname +
        ' ' +
        data.user.lastname +
        ' hinzugefügt.'
    }
    state.message.unshift({
      message: message,
      user: data.user,
      error: data.error,
      storno: false,
      loading: false,
      visible: true,
      amount: data.amount,
      date: new Date()
    })
  },
  updateMessage: (state, data) => {
    var message = state.message.find(msg => {
      return msg.date - data.date === 0 ? true : false
    })
    if (message) {
      if (data.storno !== undefined) message.storno = data.storno
      if (data.loading !== undefined) message.loading = data.loading
    }
  },
  setMenu: (state, value) => {
    state.menu = value
  }
}

const actions = {
  // eslint-disable-next-line no-unused-vars
  async getUsers({ commit, rootState, dispatch }) {
    commit('setUsersLoading', true)
    try {
      const response = await axios.get(url.bar, {
        headers: { Token: rootState.login.user.accessToken }
      })
      commit('setUsers', response.data)
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
    commit('setUsersLoading', false)
  },
  async addAmount({ commit, rootState, dispatch }, data) {
    try {
      commit('updateUser', { username: data.username, loading: true })
    } catch (e) {
      //error
    }
    try {
      const response = await axios.post(
        url.barAddAmount,
        { userId: data.username, amount: data.amount },
        { headers: { Token: rootState.login.user.accessToken } }
      )
      commit('setUsers', { [response.data.username]: response.data })
      commit('addMessage', {
        user: data.user,
        amount: data.amount,
        error: false
      })
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      commit('addMessage', {
        user: data.user,
        amount: data.amount,
        error: true
      })
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
    try {
      commit('updateUser', { username: data.username, loading: false })
    } catch (e) {
      //error
    }
  },
  async addCreditList({ commit, rootState, dispatch }, data) {
    try {
      commit('updateUser', { username: data.username, loading: true })
    } catch (e) {
      //error
    }
    try {
      const response = await axios.post(
        url.barGetUser,
        { userId: data.username },
        { headers: { Token: rootState.login.user.accessToken } }
      )
      commit('setUsers', { [response.data.username]: response.data })
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
    try {
      commit('updateUser', { username: data.username, loading: false })
    } catch {
      //error
    }
  },
  async getAllUsers({ commit, rootState, dispatch }) {
    commit('setAllUsersLoading', true)
    try {
      const response = await axios.get(url.searchUser, {
        headers: { Token: rootState.login.user.accessToken }
      })
      commit('setAllUsers', response.data)
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.response)
        if (e.response.data === 401) dispatch('logout', null, { root: true })
    }
    commit('setAllUsersLoading', false)
  },
  async storno({ commit, rootState, dispatch }, data) {
    commit('updateMessage', { date: data.date, loading: true })
    try {
      const response = await axios.post(
        url.barU.storno,
        {
          userId: data.username,
          amount: data.amount
        },
        { headers: { Token: rootState.login.user.accessToken } }
      )
      commit('setUsers', { [response.data.username]: response.data })
      commit('updateMessage', { date: data.date, storno: true })
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
    commit('updateMessage', { date: data.date, loading: false })
  },
  setFilter({ commit }, data) {
    commit('setFilter', data)
  },
  activateMenu({ commit }) {
    commit('setMenu', true)
  },
  deactivateMenu({ commit }) {
    commit('setMenu', false)
  }
}

const getters = {
  users: state => {
    return state.users
  },
  allUsers: state => {
    return state.allUsers
  },
  filter: state => {
    return state.filter
  },
  usersLoading: state => {
    return state.usersLoading
  },
  allUsersLoading: state => {
    return state.allUsersLoading
  },
  messages: state => {
    return state.message
  },
  menu: state => {
    return state.menu
  }
}

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