322 lines
9.0 KiB
JavaScript
322 lines
9.0 KiB
JavaScript
import axios from 'axios'
|
|
import url from '@/plugins/routes'
|
|
|
|
const state = {
|
|
month: [],
|
|
allUsers: [],
|
|
disabled: 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
|
|
}
|
|
},
|
|
createMonth: (state, date) => {
|
|
let month = []
|
|
let id = 0
|
|
const year = date.getFullYear()
|
|
const mon = date.getMonth()
|
|
let a = new Date(year, mon + 1, 0)
|
|
let days = a.getDate()
|
|
let startDate = 1
|
|
for (let intDay = 1; intDay <= days; intDay++) {
|
|
if (new Date(year, mon, intDay).getDay() === 3) {
|
|
startDate = intDay
|
|
break
|
|
}
|
|
}
|
|
let end = false
|
|
let week = { id: id, days: {} }
|
|
for (let intDay = startDate; intDay <= days + 7; intDay++) {
|
|
if (end) break
|
|
let currentDate = new Date(year, mon, intDay)
|
|
|
|
switch (currentDate.getDay()) {
|
|
case 1:
|
|
mutations.setStartEndDate(week)
|
|
month.push(week)
|
|
id++
|
|
week = { id: id, days: {} }
|
|
week.days.monday = {
|
|
id: currentDate.getDay(),
|
|
date: currentDate,
|
|
name: 'Montag',
|
|
worker: [],
|
|
loading: false,
|
|
locked: false
|
|
}
|
|
break
|
|
case 2:
|
|
week.days.tuesday = {
|
|
id: currentDate.getDay(),
|
|
date: currentDate,
|
|
name: 'Dienstag',
|
|
worker: [],
|
|
loading: false,
|
|
locked: false
|
|
}
|
|
break
|
|
case 3:
|
|
if (currentDate.getMonth() === mon + 1) {
|
|
end = true
|
|
mutations.setStartEndDate(week)
|
|
month.push(week)
|
|
} else {
|
|
week.days.wednesday = {
|
|
id: currentDate.getDay(),
|
|
date: currentDate,
|
|
name: 'Mittwoch',
|
|
worker: [],
|
|
loading: false,
|
|
locked: false
|
|
}
|
|
}
|
|
break
|
|
case 4:
|
|
week.days.thursday = {
|
|
id: currentDate.getDay(),
|
|
date: currentDate,
|
|
name: 'Donnerstag',
|
|
worker: [],
|
|
loading: false,
|
|
locked: false
|
|
}
|
|
break
|
|
case 5:
|
|
week.days.friday = {
|
|
id: currentDate.getDay(),
|
|
date: currentDate,
|
|
name: 'Freitag',
|
|
worker: [],
|
|
loading: false,
|
|
locked: false
|
|
}
|
|
break
|
|
case 6:
|
|
week.days.satturday = {
|
|
id: currentDate.getDay(),
|
|
date: currentDate,
|
|
name: 'Samstag',
|
|
worker: [],
|
|
loading: false,
|
|
locked: false
|
|
}
|
|
break
|
|
case 0:
|
|
week.days.sunday = {
|
|
id: currentDate.getDay(),
|
|
date: currentDate,
|
|
name: 'Sontag',
|
|
worker: [],
|
|
loading: false,
|
|
locked: false
|
|
}
|
|
break
|
|
}
|
|
}
|
|
state.month = month
|
|
},
|
|
setStartEndDate: week => {
|
|
if (week.days.monday) {
|
|
week.startDate = week.days.monday.date
|
|
} else if (week.days.tuesday) {
|
|
week.startDate = week.days.tuesday.date
|
|
} else if (week.days.wednesday) {
|
|
week.startDate = week.days.wednesday.date
|
|
} else if (week.days.thursday) {
|
|
week.startDate = week.days.thursday.date
|
|
} else if (week.days.friday) {
|
|
week.startDate = week.days.friday.date
|
|
} else if (week.days.satturday) {
|
|
week.startDate = week.days.satturday.date
|
|
} else if (week.days.sunday) {
|
|
week.startDate = week.days.sunday.date
|
|
}
|
|
|
|
if (week.days.sunday) {
|
|
week.endDate = week.days.sunday.date
|
|
} else if (week.days.satturday) {
|
|
week.endDate = week.days.satturday.date
|
|
} else if (week.days.friday) {
|
|
week.endDate = week.days.friday.date
|
|
} else if (week.days.thursday) {
|
|
week.endDate = week.days.thursday.date
|
|
} else if (week.days.wednesday) {
|
|
week.endDate = week.days.wednesday.date
|
|
} else if (week.days.tuesday) {
|
|
week.endDate = week.days.tuesday.date
|
|
} else if (week.days.monday) {
|
|
week.endDate = week.days.monday.date
|
|
}
|
|
},
|
|
updateMonth: (state, data) => {
|
|
const date = new Date(data.start.year, data.start.month - 1, data.start.day)
|
|
const user = data.user
|
|
for (let week = 0; week < state.month.length; week++) {
|
|
for (let day in state.month[week].days) {
|
|
if (state.month[week].days[day].date - date === 0) {
|
|
if (user) {
|
|
let worker = state.month[week].days[day].worker.find(a => {
|
|
return a.username === user.username
|
|
})
|
|
if (!worker && data.com === 'add') {
|
|
state.month[week].days[day].worker.push({
|
|
firstname: user.firstname,
|
|
lastname: user.lastname,
|
|
username: user.username,
|
|
fullName: user.firstname + ' ' + user.lastname
|
|
})
|
|
}
|
|
}
|
|
if (data.day) {
|
|
state.month[week].days[day].locked = data.day.locked
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
setDayLoading: (state, { date, getters }) => {
|
|
let day = getters.getDay(date)
|
|
day.loading = true
|
|
},
|
|
setDayNotLoading: (state, { date, getters }) => {
|
|
let day = getters.getDay(date)
|
|
day.loading = false
|
|
},
|
|
setDisabled: (state, data) => {
|
|
state.disabled = data
|
|
}
|
|
}
|
|
const actions = {
|
|
createMonth({ commit }, date) {
|
|
commit('setDisabled', true)
|
|
commit('createMonth', date)
|
|
commit('setDisabled', false)
|
|
},
|
|
async getAllUsers({ commit, rootState, dispatch }) {
|
|
try {
|
|
const response = await axios.post(
|
|
url.searchUser,
|
|
{ searchString: '' },
|
|
{ headers: { Token: rootState.login.user.accessToken } }
|
|
)
|
|
commit('setAllUsers', response.data)
|
|
} catch (e) {
|
|
if (e.response)
|
|
if (e.response.data === 401) dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
// eslint-disable-next-line no-unused-vars
|
|
async addUser({ commit, rootState, dispatch }, data) {
|
|
try {
|
|
const response = await axios.post(
|
|
url.vorstand.sm.addUser,
|
|
{ ...data },
|
|
{
|
|
headers: { Token: rootState.login.user.accessToken }
|
|
}
|
|
)
|
|
commit('updateMonth', { ...response.data[0], com: 'add' })
|
|
} catch (e) {
|
|
if (e.response)
|
|
if (e.response.status === 401) dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
async getUser({ commit, rootState, dispatch, getters }, data) {
|
|
commit('setDayLoading', { date: data.startdatetime, getters })
|
|
try {
|
|
const response = await axios.post(
|
|
url.vorstand.sm.getUser,
|
|
{ ...data },
|
|
{ headers: { Token: rootState.login.user.accessToken } }
|
|
)
|
|
for (let item = 0; item < response.data.worker.length; item++) {
|
|
commit('updateMonth', {
|
|
...response.data.worker[item],
|
|
com: 'add',
|
|
day: response.data.day
|
|
})
|
|
}
|
|
commit('updateMonth', {
|
|
start: response.data.day.date,
|
|
day: response.data.day
|
|
})
|
|
commit('setDayNotLoading', { date: data.startdatetime, getters })
|
|
} catch (e) {
|
|
if (e.response)
|
|
if (e.response.status === 401) dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
// eslint-disable-next-line no-unused-vars
|
|
async deleteUser({ commit, rootState, dispatch }, data) {
|
|
try {
|
|
// eslint-disable-next-line no-unused-vars
|
|
const response = await axios.post(
|
|
url.vorstand.sm.deleteUser,
|
|
{ ...data },
|
|
{ headers: { Token: rootState.login.user.accessToken } }
|
|
)
|
|
commit('updateMonth', { ...data, com: 'delete' })
|
|
} catch (e) {
|
|
if (e.response)
|
|
if (e.response.status === 401) dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
async lockDay({ commit, rootState, dispatch }, data) {
|
|
try {
|
|
const response = await axios.post(
|
|
url.vorstand.sm.lockDay,
|
|
{ ...data },
|
|
{ headers: { Token: rootState.login.user.accessToken } }
|
|
)
|
|
commit('updateMonth', { start: response.data.date, day: response.data })
|
|
} catch (e) {
|
|
if (e.response)
|
|
if (e.response.status === 401) dispatch('logout', null, { root: true })
|
|
}
|
|
},
|
|
setDayLoading({ commit, getters }, date) {
|
|
commit('setDayLoading', { date, getters })
|
|
},
|
|
setDayNotLoading({ commit, getters }, date) {
|
|
commit('setDayNotLoading', { date, getters })
|
|
}
|
|
}
|
|
const getters = {
|
|
month: state => {
|
|
return state.month
|
|
},
|
|
allUsers: state => {
|
|
return state.allUsers
|
|
},
|
|
getDayLoading: (state, getters) => date => {
|
|
let day = getters.getDay(date)
|
|
return day.loading
|
|
},
|
|
getDay: state => date => {
|
|
for (let week = 0; week < state.month.length; week++) {
|
|
for (let day in state.month[week].days) {
|
|
if (state.month[week].days[day].date - date === 0) {
|
|
return state.month[week].days[day]
|
|
}
|
|
}
|
|
}
|
|
},
|
|
disabled: state => {
|
|
return state.disabled
|
|
}
|
|
}
|
|
|
|
export default {
|
|
namespaced: true,
|
|
state,
|
|
mutations,
|
|
actions,
|
|
getters
|
|
}
|