444 lines
13 KiB
JavaScript
444 lines
13 KiB
JavaScript
import axios from 'axios'
|
|
// eslint-disable-next-line no-unused-vars
|
|
import url from '@/plugins/routes'
|
|
|
|
const state = {
|
|
users: [],
|
|
activeUser: {
|
|
username: null
|
|
},
|
|
allUsers: [],
|
|
user: null,
|
|
errorMails: null,
|
|
errorMail: null,
|
|
year: new Date().getFullYear(),
|
|
years: [],
|
|
months: [
|
|
{ value: 1, text: 'Januar' },
|
|
{ value: 2, text: 'Februar' },
|
|
{ value: 3, text: 'März' },
|
|
{ value: 4, text: 'April' },
|
|
{ value: 5, text: 'Mai' },
|
|
{ value: 6, text: 'Juni' },
|
|
{ value: 7, text: 'Juli' },
|
|
{ value: 8, text: 'August' },
|
|
{ value: 9, text: 'September' },
|
|
{ value: 10, text: 'Oktober' },
|
|
{ value: 11, text: 'November' },
|
|
{ value: 12, text: 'Dezember' }
|
|
]
|
|
}
|
|
|
|
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
|
|
}
|
|
},
|
|
setActiveUser: (state, user) => {
|
|
if (state.activeUser.username === user.username) {
|
|
state.activeUser = { username: null }
|
|
} else {
|
|
state.activeUser = user
|
|
}
|
|
state.errorMail = null
|
|
},
|
|
setUsers: (state, users) => {
|
|
// eslint-disable-next-line no-console
|
|
console.log('users', users)
|
|
for (let user in users) {
|
|
// eslint-disable-next-line no-console
|
|
console.log('user', user)
|
|
let list = {}
|
|
for (let creditList in users[user]['creditList']) {
|
|
let amount = mutations.createAmount(
|
|
users[user]['creditList'][creditList]
|
|
)
|
|
let credit = mutations.createCredit(
|
|
users[user]['creditList'][creditList]
|
|
)
|
|
let sum = mutations.createSum(credit, amount)
|
|
list[creditList] = [{ ...credit }, { ...amount }, { ...sum }]
|
|
}
|
|
|
|
let existUser = state.users.find(a => {
|
|
return a.username === user
|
|
})
|
|
|
|
// eslint-disable-next-line no-console
|
|
console.log(existUser)
|
|
if (existUser) {
|
|
existUser.username = users[user].username
|
|
existUser.firstname = users[user].firstname
|
|
existUser.lastname = users[user].lastname
|
|
existUser.limit = users[user].limit
|
|
existUser.locked = users[user].locked
|
|
existUser.autoLock = users[user].autoLock
|
|
existUser.creditList = list
|
|
} else {
|
|
state.users.push({
|
|
username: users[user].username,
|
|
firstname: users[user].firstname,
|
|
lastname: users[user].lastname,
|
|
limit: users[user].limit,
|
|
locked: users[user].locked,
|
|
autoLock: users[user].autoLock,
|
|
creditList: list,
|
|
expand: false
|
|
})
|
|
}
|
|
}
|
|
mutations.sortUsers(state)
|
|
|
|
// eslint-disable-next-line no-console
|
|
console.log(state.users)
|
|
},
|
|
createAmount(creditList) {
|
|
let amount = {
|
|
type: 'Schulden',
|
|
jan_amount: 0 - creditList.jan.depts,
|
|
feb_amount: 0 - creditList.feb.depts,
|
|
maer_amount: 0 - creditList.maer.depts,
|
|
apr_amount: 0 - creditList.apr.depts,
|
|
mai_amount: 0 - creditList.mai.depts,
|
|
jun_amount: 0 - creditList.jun.depts,
|
|
jul_amount: 0 - creditList.jul.depts,
|
|
aug_amount: 0 - creditList.aug.depts,
|
|
sep_amount: 0 - creditList.sep.depts,
|
|
okt_amount: 0 - creditList.okt.depts,
|
|
nov_amount: 0 - creditList.nov.depts,
|
|
dez_amount: 0 - creditList.dez.depts,
|
|
last: 0 - creditList['last']
|
|
}
|
|
|
|
amount.sum =
|
|
amount.jan_amount +
|
|
amount.feb_amount +
|
|
amount.maer_amount +
|
|
amount.apr_amount +
|
|
amount.mai_amount +
|
|
amount.jun_amount +
|
|
amount.jul_amount +
|
|
amount.aug_amount +
|
|
amount.sep_amount +
|
|
amount.okt_amount +
|
|
amount.nov_amount +
|
|
amount.dez_amount
|
|
return amount
|
|
},
|
|
createCredit(creditList) {
|
|
let credit = {
|
|
type: 'Guthaben',
|
|
jan_amount: creditList.jan.credit,
|
|
feb_amount: creditList.feb.credit,
|
|
maer_amount: creditList.maer.credit,
|
|
apr_amount: creditList.apr.credit,
|
|
mai_amount: creditList.mai.credit,
|
|
jun_amount: creditList.jun.credit,
|
|
jul_amount: creditList.jul.credit,
|
|
aug_amount: creditList.aug.credit,
|
|
sep_amount: creditList.sep.credit,
|
|
okt_amount: creditList.okt.credit,
|
|
nov_amount: creditList.nov.credit,
|
|
dez_amount: creditList.dez.credit
|
|
}
|
|
credit.sum =
|
|
credit.jan_amount +
|
|
credit.feb_amount +
|
|
credit.maer_amount +
|
|
credit.apr_amount +
|
|
credit.mai_amount +
|
|
credit.jun_amount +
|
|
credit.jul_amount +
|
|
credit.aug_amount +
|
|
credit.sep_amount +
|
|
credit.okt_amount +
|
|
credit.nov_amount +
|
|
credit.dez_amount
|
|
return credit
|
|
},
|
|
createSum(credit, amount) {
|
|
let sum = {
|
|
type: 'Summe',
|
|
jan_amount: credit.jan_amount + amount.jan_amount,
|
|
feb_amount: credit.feb_amount + amount.feb_amount,
|
|
maer_amount: credit.maer_amount + amount.maer_amount,
|
|
apr_amount: credit.apr_amount + amount.apr_amount,
|
|
mai_amount: credit.mai_amount + amount.mai_amount,
|
|
jun_amount: credit.jun_amount + amount.jun_amount,
|
|
jul_amount: credit.jul_amount + amount.jul_amount,
|
|
aug_amount: credit.aug_amount + amount.aug_amount,
|
|
sep_amount: credit.sep_amount + amount.sep_amount,
|
|
okt_amount: credit.okt_amount + amount.okt_amount,
|
|
nov_amount: credit.nov_amount + amount.nov_amount,
|
|
dez_amount: credit.dez_amount + amount.dez_amount
|
|
}
|
|
sum.sum =
|
|
sum.jan_amount +
|
|
sum.feb_amount +
|
|
sum.maer_amount +
|
|
sum.apr_amount +
|
|
sum.mai_amount +
|
|
sum.jun_amount +
|
|
sum.jul_amount +
|
|
sum.aug_amount +
|
|
sum.sep_amount +
|
|
sum.okt_amount +
|
|
sum.nov_amount +
|
|
sum.dez_amount
|
|
return sum
|
|
},
|
|
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
|
|
})
|
|
},
|
|
updateUsers: (state, data) => {
|
|
let index = state.users.indexOf(
|
|
state.users.find(a => {
|
|
return a.username === data.username
|
|
})
|
|
)
|
|
if (data.creditLists !== undefined) {
|
|
let list = {}
|
|
for (let creditList in data.creditLists) {
|
|
let amount = mutations.createAmount(data.creditLists[creditList])
|
|
let credit = mutations.createCredit(data.creditLists[creditList])
|
|
let sum = mutations.createSum(credit, amount)
|
|
list[creditList] = [{ ...credit }, { ...amount }, { ...sum }]
|
|
}
|
|
state.users[index].creditList = list
|
|
}
|
|
if (data.locked !== undefined) state.users[index].locked = data.locked
|
|
if (data.limit !== undefined) state.users[index].limit = data.limit
|
|
if (data.autoLock !== undefined) state.users[index].autoLock = data.autoLock
|
|
},
|
|
setMails: (state, data) => {
|
|
state.errorMails = data
|
|
},
|
|
setMail: (state, data) => {
|
|
state.errorMail = data
|
|
},
|
|
setYears: state => {
|
|
for (let year = new Date().getFullYear(); year >= 2000; year--) {
|
|
state.years.push({ value: year, text: year })
|
|
}
|
|
},
|
|
setYear: (state, value) => {
|
|
if (value) state.year++
|
|
else state.year--
|
|
}
|
|
}
|
|
|
|
const actions = {
|
|
// eslint-disable-next-line no-unused-vars
|
|
async getAllUsers({ commit, rootState, dispatch }) {
|
|
// eslint-disable-next-line no-console
|
|
console.log(rootState)
|
|
try {
|
|
const response = await axios.post(
|
|
url.searchUser,
|
|
{ searchString: '' },
|
|
{ headers: { Token: rootState.login.user.accessToken } }
|
|
)
|
|
commit('setAllUsers', response.data)
|
|
} catch (err) {
|
|
// eslint-disable-next-line no-console
|
|
if (err.response)
|
|
if (err.response.status === 401)
|
|
dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
async getUsers({ commit, rootState, dispatch }) {
|
|
try {
|
|
const response = await axios.get(url.getFinanzerMain, {
|
|
headers: { Token: rootState.login.user.accessToken }
|
|
})
|
|
// eslint-disable-next-line no-console
|
|
console.log('response', response.data)
|
|
commit('setUsers', response.data)
|
|
} catch (err) {
|
|
// eslint-disable-next-line no-console
|
|
console.log(err)
|
|
if (err.response)
|
|
if (err.response.status === 401)
|
|
dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
setActiveUser({ commit }, user) {
|
|
commit('setActiveUser', user)
|
|
},
|
|
async addAmount({ commit, rootState, dispatch }, data) {
|
|
try {
|
|
const response = await axios.post(
|
|
url.finanzerAddAmount,
|
|
{
|
|
userId: data.user.username,
|
|
amount: data.amount * 100,
|
|
year: data.year,
|
|
month: data.month
|
|
},
|
|
{ headers: { Token: rootState.login.user.accessToken } }
|
|
)
|
|
const creditLists = { ...response.data }
|
|
delete creditLists.locked
|
|
commit('updateUsers', {
|
|
creditLists: creditLists,
|
|
locked: response.data.locked,
|
|
username: data.user.username
|
|
})
|
|
} catch (err) {
|
|
if (err.response)
|
|
if (err.response.status === 401)
|
|
dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
async addCredit({ commit, rootState, dispatch }, data) {
|
|
try {
|
|
const response = await axios.post(
|
|
url.finanzerAddCredit,
|
|
{
|
|
userId: data.user.username,
|
|
credit: data.credit * 100,
|
|
year: data.year,
|
|
month: data.month
|
|
},
|
|
{ headers: { Token: rootState.login.user.accessToken } }
|
|
)
|
|
const creditLists = { ...response.data }
|
|
delete creditLists.locked
|
|
commit('updateUsers', {
|
|
creditLists: creditLists,
|
|
locked: response.data.locked,
|
|
username: data.user.username
|
|
})
|
|
} catch (err) {
|
|
if (err.response)
|
|
if (err.response.status === 401)
|
|
dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
async doLock({ commit, rootState, dispatch }, data) {
|
|
try {
|
|
const response = await axios.post(
|
|
url.lockUser,
|
|
{ userId: data.user.username, locked: data.locked },
|
|
{ headers: { Token: rootState.login.user.accessToken } }
|
|
)
|
|
commit('updateUsers', response.data)
|
|
} catch (e) {
|
|
if (e.response)
|
|
if (e.response.status === 401) dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
async saveConfig({ commit, rootState, dispatch }, data) {
|
|
try {
|
|
const response = await axios.post(
|
|
url.finanzerSetConfig,
|
|
{
|
|
userId: data.user.username,
|
|
limit: data.limit * 100,
|
|
autoLock: data.autoLock
|
|
},
|
|
{ headers: { Token: rootState.login.user.accessToken } }
|
|
)
|
|
commit('updateUsers', response.data)
|
|
} catch (e) {
|
|
if (e.response)
|
|
if (e.response.status === 401) dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
async addUser({ commit, rootState, dispatch }, data) {
|
|
try {
|
|
const response = await axios.post(
|
|
url.finanzerAddUser,
|
|
{ userId: data.username },
|
|
{ headers: { Token: rootState.login.user.accessToken } }
|
|
)
|
|
commit('setUsers', response.data)
|
|
} catch (e) {
|
|
if (e.response)
|
|
if (e.response.status === 401) dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
async sendMails({ commit, rootState, dispatch }) {
|
|
try {
|
|
const response = await axios.get(url.finanzerSendAllMail, {
|
|
headers: { Token: rootState.login.user.accessToken }
|
|
})
|
|
commit('setMails', response.data)
|
|
} catch (e) {
|
|
if (e.response)
|
|
if (e.response.status === 401) dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
async sendMail({ commit, rootState, dispatch }, data) {
|
|
try {
|
|
const response = await axios.post(
|
|
url.finanzerSendOneMail,
|
|
{ userId: data.username },
|
|
{ headers: { Token: rootState.login.user.accessToken } }
|
|
)
|
|
commit('setMail', response.data)
|
|
} catch (e) {
|
|
if (e.response)
|
|
if (e.response.status === 401) dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
createYears({ commit }) {
|
|
commit('setYears')
|
|
return 'hallo'
|
|
},
|
|
countYear({ commit }, value) {
|
|
commit('setYear', value)
|
|
}
|
|
}
|
|
|
|
const getters = {
|
|
users: state => {
|
|
return state.users
|
|
},
|
|
activeUser: state => {
|
|
return state.activeUser
|
|
},
|
|
allUsers: state => {
|
|
return state.allUsers
|
|
},
|
|
user: state => {
|
|
return state.user
|
|
},
|
|
errorMails: state => {
|
|
return state.errorMails
|
|
},
|
|
errorMail: state => {
|
|
return state.errorMail
|
|
},
|
|
years: state => {
|
|
return state.years
|
|
},
|
|
selectYears: state => {
|
|
return state.years
|
|
},
|
|
year: state => {
|
|
return state.year
|
|
},
|
|
months: state => {
|
|
return state.months
|
|
}
|
|
}
|
|
|
|
export default {
|
|
namespaced: true,
|
|
state,
|
|
mutations,
|
|
actions,
|
|
getters
|
|
}
|