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

import axios from 'axios'
import url from '@/plugins/routes'
const timeout = 20000
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,
            jobkinddate: []
          }
          break
        case 2:
          week.days.tuesday = {
            id: currentDate.getDay(),
            date: currentDate,
            name: 'Dienstag',
            worker: [],
            loading: false,
            locked: false,
            jobkinddate: []
          }
          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,
              jobkinddate: []
            }
          }
          break
        case 4:
          week.days.thursday = {
            id: currentDate.getDay(),
            date: currentDate,
            name: 'Donnerstag',
            worker: [],
            loading: false,
            locked: false,
            jobkinddate: []
          }
          break
        case 5:
          week.days.friday = {
            id: currentDate.getDay(),
            date: currentDate,
            name: 'Freitag',
            worker: [],
            loading: false,
            locked: false,
            jobkinddate: []
          }
          break
        case 6:
          week.days.satturday = {
            id: currentDate.getDay(),
            date: currentDate,
            name: 'Samstag',
            worker: [],
            loading: false,
            locked: false,
            jobkinddate: []
          }
          break
        case 0:
          week.days.sunday = {
            id: currentDate.getDay(),
            date: currentDate,
            name: 'Sonntag',
            worker: [],
            loading: false,
            locked: false,
            jobkinddate: []
          }
          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
    }
  },
  // eslint-disable-next-line no-unused-vars
  updateMonthWorker: (state, { workers, date, getters }) => {
    var day = getters.getDay(date)
    day.jobkinddate.forEach(item => {
      var filtered = workers.filter(worker => {
        return item.job_kind.id === (worker.job_kind ? worker.job_kind.id : 1)
      })
      var filteredWorkers = []
      filtered.forEach(item => {
        filteredWorkers.push(item.user)
      })
      filteredWorkers.forEach(worker => {
        if (
          !item.worker.find(a => {
            return a.id === worker.id
          })
        ) {
          item.worker.push(worker)
          item.backupWorker.push(worker)
        }
      })
      item.worker.forEach(worker => {
        if (
          !filteredWorkers.find(a => {
            return a.id === worker.id
          })
        ) {
          item.worker.splice(item.worker.indexOf(worker), 1)
        }
      })
    })
  },
  updateMonthLocked: (state, { locked, date, getters }) => {
    var day = getters.getDay(date)
    day.locked = !!locked
  },
  updateMonthJobkind: (state, { data, date, getters }) => {
    let day = getters.getDay(date)
    var backup = []

    for (let jobkind in day.jobkinddate) {
      if (day.jobkinddate[jobkind].worker !== undefined) {
        backup.push({
          id: day.jobkinddate[jobkind].job_kind.id,
          worker: day.jobkinddate[jobkind].worker,
          backupWorker: day.jobkinddate[jobkind].backupWorker
        })
      } else {
        backup.push({
          id: day.jobkinddate[jobkind].job_kind.id,
          worker: [],
          backupWorker: []
        })
      }
    }
    day.jobkinddate = [...data]
    var test = day.jobkinddate.find(jobkind => {
      return jobkind.job_kind.id === 1
    })
    if (!test) {
      day.jobkinddate.push({
        id: -1,
        job_kind: { id: 1, name: 'Bardienst' },
        maxpersons: 2,
        daydate: {
          year: date.getFullYear(),
          month: date.getMonth() + 1,
          day: date.getDate()
        },
        worker: [],
        backupWorker: []
      })
    }
    for (var jobkind in day.jobkinddate) {
      var worker = backup.find(item => {
        return item.id === day.jobkinddate[jobkind].job_kind.id
      })
      day.jobkinddate[jobkind].worker = worker ? worker.worker : []
      day.jobkinddate[jobkind].backupWorker = worker ? worker.backupWorker : []
    }
  },
  setAllDayLoading: state => {
    for (let week = 0; week < state.month.length; week++) {
      for (let day in state.month[week].days) {
        state.month[week].days[day].loading = true
      }
    }
  },
  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.get(url.vorstand.sm.searchUser, {
        headers: { Token: rootState.login.user.accessToken },
        timeout
      })
      commit('setAllUsers', response.data)
      dispatch('getLifetime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      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 {
      // eslint-disable-next-line no-unused-vars
      const response = await axios.post(
        url.vorstand.sm.addUser,
        { ...data },
        {
          headers: { Token: rootState.login.user.accessToken },
          timeout
        }
      )
      //commit('updateMonth', { ...response.data[0], com: 'add' })
      dispatch('getLifetime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  // eslint-disable-next-line no-unused-vars
  async getUsers({ commit, rootState, dispatch, getters }, data) {
    commit('setAllDayLoading')
    try {
      const response = await axios.post(
        url.vorstand.sm.getUsers,
        { ...data },
        { headers: { Token: rootState.login.user.accessToken }, timeout }
      )
      for (var day in response.data) {
        var date = new Date(
          response.data[day].day.date.year,
          response.data[day].day.date.month - 1,
          response.data[day].day.date.day
        )
        commit('updateMonthJobkind', {
          data: [...response.data[day].jobkinddate],
          date,
          getters
        })
        commit('updateMonthWorker', {
          workers: [...response.data[day].worker],
          date,
          getters
        })
        commit('updateMonthLocked', {
          locked: response.data[day].day.locked,
          date,
          getters
        })
        commit('setDayNotLoading', { date, getters })
      }
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      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 }, timeout }
      )
      //commit('updateMonth', { ...data, com: 'delete' })
      dispatch('getLifetime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async lockDay({ commit, rootState, dispatch, getters }, data) {
    try {
      const response = await axios.post(
        url.vorstand.sm.lockDay,
        { ...data },
        { headers: { Token: rootState.login.user.accessToken }, timeout }
      )
      console.log(response.data)
      let date = new Date(
        response.data.date.year,
        response.data.date.month - 1,
        response.data.date.day
      )
      commit('updateMonthLocked', {
        locked: response.data.locked,
        date,
        getters
      })
      dispatch('getLifetime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async updateJobKindDate(
    { commit, rootState, dispatch, getters },
    { data, date }
  ) {
    try {
      commit('setDayLoading', { date, getters })
      const response = await axios.post(
        url.vorstand.sm.updateJobKindDates,
        [...data],
        { headers: { Token: rootState.login.user.accessToken }, timeout }
      )
      commit('updateMonthJobkind', { data: response.data, date, getters })
      commit('setDayNotLoading', { date, getters })
      dispatch('getLifetime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      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
  },
  getStartDate: state => {
    return state.month[0].startDate
  },
  getEndDate: state => {
    return state.month[state.month.length - 1].endDate
  }
}

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