[Vue] store/account-users.js

account-users.js

export const state = () => ({
    accountUsers: [],
    accountUsersLoading: false,

    accountUsersTotalCount: 0,
    accountUsersCurrentPage: 1,
    accountUsersPerPage: 10,
    accountUsersFilter: null,
    accountUsersSearch: null,

    updateAccountUserLoading: false,
    enableAccountUserLoading: false,
    disableAccountUserLoading: false,
    resendAccountUserVerifictionLoading: false,
    removeAccountUserLoading: false,
    createAccountUserLoading: false,
})

export const getters = {
    accountUsers: (state) => state.accountUsers,
    accountUsersLoading: (state) => state.accountUsersLoading,

    accountUsersTotalCount: (state) => state.accountUsersTotalCount,
    accountUsersCurrentPage: (state) => state.accountUsersCurrentPage,
    accountUsersPerPage: (state) => state.accountUsersPerPage,
    accountUsersFilter: (state) => state.accountUsersFilter,
    accountUsersSearch: (state) => state.accountUsersSearch,

    updateAccountUserLoading: (state) => state.updateAccountUserLoading,
    enableAccountUserLoading: (state) => state.enableAccountUserLoading,
    disableAccountUserLoading: (state) => state.disableAccountUserLoading,
    resendAccountUserVerifictionLoading: (state) => state.resendAccountUserVerifictionLoading,
    removeAccountUserLoading: (state) => state.removeAccountUserLoading,
    createAccountUserLoading: (state) => state.createAccountUserLoading,
}

export const mutations = {
    'GET_ACCOUNT_USERS_REQUEST' (state) {
        state.accountUsersLoading = true
    },

    'GET_ACCOUNT_USERS_SUCCESS' (state, payload) {
        state.accountUsers = [...payload]
        state.accountUsersLoading = false
    },

    'GET_ACCOUNT_USERS_FAILURE' (state) {
        state.accountUsersLoading = false
    },

    'UPDATE_ACCOUNT_USERS_TOTAL_COUNT' (state, payload) {
        state.accountUsersTotalCount = payload
    },

    'UPDATE_ACCOUNT_USERS_PER_PAGE' (state, payload) {
        state.accountUsersPerPage = payload
    },

    'UPDATE_ACCOUNT_USERS_CURRENT_PAGE' (state, payload) {
        state.accountUsersCurrentPage = payload
    },

    'UPDATE_ACCOUNT_USERS_FILTER' (state, payload) {
        state.accountUsersFilter = payload
    },

    'UPDATE_ACCOUNT_USERS_SEARCH' (state, payload) {
        state.accountUsersSearch = payload
    },

    'UPDATE_ACCOUNT_USER_REQUEST' (state) {
        state.updateAccountUserLoading = true
    },

    'UPDATE_ACCOUNT_USER_SUCCESS' (state) {
        state.updateAccountUserLoading = false
    },

    'UPDATE_ACCOUNT_USER_FAILURE' (state) {
        state.updateAccountUserLoading = false
    },

    'ENABLE_ACCOUNT_USER_REQUEST' (state) {
        state.enableAccountUserLoading = true
    },

    'ENABLE_ACCOUNT_USER_SUCCESS' (state, payload) {
        const accountUsers = [...state.accountUsers]

        accountUsers.forEach((user) => {
            if (user._id === payload) {
                user.enabled = true
            }
        })

        state.accountUsers = [...accountUsers]

        state.enableAccountUserLoading = false
    },

    'ENABLE_ACCOUNT_USER_FAILURE' (state) {
        state.enableAccountUserLoading = false
    },

    'DISABLE_ACCOUNT_USER_REQUEST' (state) {
        state.disableAccountUserLoading = true
    },

    'DISABLE_ACCOUNT_USER_SUCCESS' (state, payload) {
        const accountUsers = [...state.accountUsers]

        accountUsers.forEach((user) => {
            if (user._id === payload) {
                user.enabled = false
            }
        })

        state.accountUsers = [...accountUsers]

        state.disableAccountUserLoading = false
    },

    'DISABLE_ACCOUNT_USER_FAILURE' (state) {
        state.disableAccountUserLoading = false
    },

    'RESEND_ACCOUNT_USER_VERIFICATION_REQUEST' (state) {
        state.resendAccountUserVerifictionLoading = true
    },

    'RESEND_ACCOUNT_USER_VERIFICATION_SUCCESS' (state) {
        state.resendAccountUserVerifictionLoading = false
    },

    'RESEND_ACCOUNT_USER_VERIFICATION_FAILURE' (state) {
        state.resendAccountUserVerifictionLoading = false
    },

    'REMOVE_ACCOUNT_USER_REQUEST' (state) {
        state.removeAccountUserLoading = true
    },

    'REMOVE_ACCOUNT_USER_SUCCESS' (state, payload) {
        let accountUsers = [...state.accountUsers]

        accountUsers.forEach((user) => {
            if (user._id === payload) {
                accountUsers = accountUsers.filter((user) => user._id !== payload)
            }
        })

        state.accountUsers = [...accountUsers]
        state.removeAccountUserLoading = false
    },

    'REMOVE_ACCOUNT_USER_FAILURE' (state) {
        state.removeAccountUserLoading = false
    },

    'CREATE_ACCOUNT_USER_REQUEST' (state) {
        state.createAccountUserLoading = true
    },

    'CREATE_ACCOUNT_USER_SUCCESS' (state) {
        state.createAccountUserLoading = false
    },

    'CREATE_ACCOUNT_USER_FAILURE' (state) {
        state.createAccountUserLoading = false
    },
}

export const actions = {
    async getAccountUsers ({ commit }, params) {
        commit('GET_ACCOUNT_USERS_REQUEST')

        const queryParams = {}

        if (params.page) queryParams.page = params.page
        if (params.perPage) queryParams.per_page = params.perPage
        if (params.filter) queryParams.filter = { roles: params.filter }

        if (params.search) queryParams.q = params.search

        try {
            const dataCount = await this.$axios.$get('/api/users/count', { params: queryParams })
            const data = await this.$axios.$get('/api/users', { params: queryParams })

            commit('UPDATE_ACCOUNT_USERS_TOTAL_COUNT', dataCount.count)
            commit('GET_ACCOUNT_USERS_SUCCESS', data)

            return Promise.resolve()
        } catch(err) {
            commit('GET_ACCOUNT_USERS_FAILURE')

            return Promise.reject()
        }
    },

    updateAccountUsersCurrentPage ({ commit }, data) {
        commit('UPDATE_ACCOUNT_USERS_CURRENT_PAGE', data)
    },

    updateAccountUsersPerPage ({ commit }, data) {
        commit('UPDATE_ACCOUNT_USERS_PER_PAGE', data)
    },

    updateAccountUsersFilter ({ commit }, data) {
        commit('UPDATE_ACCOUNT_USERS_FILTER', data)
    },

    updateAccountUsersSearch ({ commit }, data) {
        commit('UPDATE_ACCOUNT_USERS_SEARCH', data)
    },

    async updateAccountUser ({ commit }, data) {
        commit('UPDATE_ACCOUNT_USER_REQUEST')

        try {
            const params = {
                username: data.email,
                firstName: data.firstName,
                lastName: data.lastName,
                phoneNumber: data.phone,
                staffId: data.staffId,
                roles: [data.role],
            }

            await this.$axios.$patch(`/api/users/${data.id}`, params)

            commit('UPDATE_ACCOUNT_USER_SUCCESS', params)

            return Promise.resolve()
        } catch (err) {
            commit('UPDATE_ACCOUNT_USER_FAILURE')

            return Promise.reject()
        }
    },

    async enableAccountUser ({ commit }, data) {
        commit('ENABLE_ACCOUNT_USER_REQUEST')

        try {
            await this.$axios.$post(`/api/users/${data.id}/enable`)

            commit('ENABLE_ACCOUNT_USER_SUCCESS', data.id)

            return Promise.resolve()
        } catch (err) {
            commit('ENABLE_ACCOUNT_USER_FAILURE')

            return Promise.reject()
        }
    },

    async disableAccountUser ({ commit }, data) {
        commit('DISABLE_ACCOUNT_USER_REQUEST')

        try {
            await this.$axios.$post(`/api/users/${data.id}/disable`)

            commit('DISABLE_ACCOUNT_USER_SUCCESS', data.id)

            return Promise.resolve()
        } catch (err) {
            commit('DISABLE_ACCOUNT_USER_FAILURE')

            return Promise.reject()
        }
    },

    async changeAccountUserPassword ({ commit }, data) {
        commit('CHANGE_ACCOUNT_USER_PASSWORD_REQUEST')

        try {
            const params = {
                password: data.oldPassword,
                newPassword: data.newPassword,
            }

            await this.$axios.$post(`/api/users/${data.id}/change-password`, params)

            commit('CHANGE_ACCOUNT_USER_PASSWORD_SUCCESS')

            return Promise.resolve()
        } catch (err) {
            commit('CHANGE_ACCOUNT_USER_PASSWORD_FAILURE')

            return Promise.reject()
        }
    },

    async resendAccountUserVerification ({ commit }, data) {
        commit('RESEND_ACCOUNT_USER_VERIFICATION_REQUEST')

        try {
            await this.$axios.$post(`/api/users/${data.id}/resend-verification`)

            commit('RESEND_ACCOUNT_USER_VERIFICATION_SUCCESS')

            return Promise.resolve()
        } catch(err) {
            commit('RESEND_ACCOUNT_USER_VERIFICATION_FAILURE')

            return Promise.reject()
        }
    },

    async removeAccountUser ({ commit }, data) {
        commit('REMOVE_ACCOUNT_USER_REQUEST')

        try {
            await this.$axios.$delete(`/api/users/${data.id}`)

            commit('REMOVE_ACCOUNT_USER_SUCCESS', data.id)

            return Promise.resolve()
        } catch (err) {
            commit('REMOVE_ACCOUNT_USER_FAILURE')

            return Promise.reject()
        }
    },

    async createAccountUser ({ commit }, data) {
        commit('CREATE_ACCOUNT_USER_REQUEST')

        try {
            const params = {
                username: data.username,
                firstName: data.firstName,
                lastName: data.lastName,
                phoneNumber: data.phoneNumber,
                staffId: data.staffId,
                roles: data.roles,
            }

            const user = await this.$axios.$post('/api/users', params)

            commit('CREATE_ACCOUNT_USER_SUCCESS', user)

            return Promise.resolve()
        } catch(err) {
            commit('CREATE_ACCOUNT_USER_FAILURE')

            return Promise.reject()
        }
    },
}