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

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

const state = {
  jobRequestsFromMe: [],
  jobRequestsToMe: [],
  jobRequestsLoading: false
}

const mutations = {
  setJobRequestsFromMe: (state, jobRequests) => {
    state.jobRequestsFromMe = jobRequests
    state.jobRequestsFromMe.forEach(item => {
      item.on_date = new Date(
        item.on_date.year,
        item.on_date.month - 1,
        item.on_date.day
      )
      item.day = {
        date: new Date(),
        worker: [],
        loading: false,
        locked: false,
        jobkinddate: []
      }
    })
  },
  setJobRequestsToMe: (state, jobRequests) => {
    state.jobRequestsToMe = jobRequests
    state.jobRequestsToMe.forEach(item => {
      item.on_date = new Date(
        item.on_date.year,
        item.on_date.month - 1,
        item.on_date.day
      )
      item.day = {
        date: new Date(),
        worker: [],
        loading: false,
        locked: false,
        jobkinddate: []
      }
    })
  },
  setJobRequestsLoading: (state, value) => {
    state.jobRequestsLoading = value
  },
  updateJobRequestToMe: (state, jobRequest) => {
    state.jobRequestsToMe.forEach(item => {
      if (item.id === jobRequest.id) {
        item.watched = jobRequest.watched
        item.accepted = jobRequest.accepted
      }
    })
  },
  updateMonthWorker: (state, { workers, date, getters, from_me }) => {
    let mop
    if (from_me) {
      mop = getters.getDayFromMe(date)
    } else {
      mop = getters.getDayToMe(date)
    }
    mop.forEach(a => {
      let day = a.day
      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.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, from_me }) => {
    let mop
    if (from_me) {
      mop = getters.getDayFromMe(date)
    } else {
      mop = getters.getDayToMe(date)
    }
    mop.forEach(a => {
      let day = a.day
      day.locked = !!locked
    })
  },
  updateMonthJobkind: (state, { data, date, getters, from_me }) => {
    let mop
    if (from_me) {
      mop = getters.getDayFromMe(date)
    } else {
      mop = getters.getDayToMe(date)
    }
    mop.forEach(a => {
      let day = a.day
      day.date = 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
          : []
      }
    })
  },
  setDayLoading: (state, { getters, date, value }) => {
    let day = getters.getDayToMe(date)
    day.forEach(a => {
      a.day.loading = value
    })
  },
  deleteJobRequestFromMe: (state, jobrequest) => {
    var item = state.jobRequestsFromMe.find(item => {
      return item.id === jobrequest.id
    })
    state.jobRequestsFromMe.splice(state.jobRequestsFromMe.indexOf(item), 1)
  }
}

const actions = {
  async getJobRequests({ commit, dispatch, rootState, getters }) {
    try {
      commit('setJobRequestsLoading', true)
      const date = new Date()
      const from_me = await axios.post(
        url.user.getJobRequests,
        {
          from_user: rootState.user.user,
          date: {
            year: date.getFullYear(),
            month: date.getMonth() + 1,
            day: date.getDate()
          }
        },
        { headers: { Token: rootState.login.user.accessToken } }
      )
      const workers_from_me = await axios.post(
        url.user.getJobOnDates,
        from_me.data,
        { headers: { Token: rootState.login.user.accessToken } }
      )
      commit('setJobRequestsFromMe', from_me.data)
      workers_from_me.data.forEach(item => {
        var date = new Date(
          item.day.date.year,
          item.day.date.month - 1,
          item.day.date.day
        )
        commit('updateMonthJobkind', {
          data: item.jobkinddate,
          date,
          getters,
          from_me: true
        })
        commit('updateMonthWorker', {
          workers: item.worker,
          date,
          getters,
          from_me: true
        })
        commit('updateMonthLocked', {
          locked: item.day.locked,
          date,
          getters,
          from_me: true
        })
      })
      const to_me = await axios.post(
        url.user.getJobRequests,
        {
          to_user: rootState.user.user,
          date: {
            year: date.getFullYear(),
            month: date.getMonth() + 1,
            day: date.getDate()
          }
        },
        { headers: { Token: rootState.login.user.accessToken } }
      )
      const workers_to_me = await axios.post(
        url.user.getJobOnDates,
        to_me.data,
        { headers: { Token: rootState.login.user.accessToken } }
      )
      commit('setJobRequestsToMe', to_me.data)
      workers_to_me.data.forEach(item => {
        var date = new Date(
          item.day.date.year,
          item.day.date.month - 1,
          item.day.date.day
        )
        commit('updateMonthJobkind', {
          data: item.jobkinddate,
          date,
          getters,
          from_me: false
        })
        commit('updateMonthWorker', {
          workers: item.worker,
          date,
          getters,
          from_me: false
        })
        commit('updateMonthLocked', {
          locked: item.day.locked,
          date,
          getters,
          from_me: false
        })
      })
      commit('setJobRequestsLoading', false)
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async setJobRequests({ commit, dispatch, rootState }, data) {
    try {
      commit('setJobRequestsLoading', true)
      const response = await axios.put(url.user.setJobRequests, data, {
        headers: { Token: rootState.login.user.accessToken }
      })
      commit('setJobRequestsFromMe', response.data)
      commit('setJobRequestsLoading', false)
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async updateJobRequestToMe({ commit, rootState, dispatch }, data) {
    try {
      commit('setJobRequestsLoading', true)
      data.on_date = {
        year: data.on_date.getFullYear(),
        month: data.on_date.getMonth() + 1,
        day: data.on_date.getDate()
      }
      const response = await axios.post(url.user.setJobRequests, data, {
        headers: { Token: rootState.login.user.accessToken }
      })
      response.data.on_date = new Date(
        response.data.on_date.year,
        response.data.on_date.month - 1,
        response.data.on_date.day
      )
      commit('updateJobRequestToMe', response.data)
      commit('setJobRequestsLoading', false)
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async deleteJobRequestFromMe({ commit, rootState, dispatch }, data) {
    try {
      commit('setJobRequestsLoading', true)
      await axios.post(url.user.deletJobRequest, data, {
        headers: { Token: rootState.login.user.accessToken }
      })
      commit('deleteJobRequestFromMe', data)
      commit('setJobRequestsLoading', false)
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  }
}

const getters = {
  jobRequestsFromMe: state => {
    return state.jobRequestsFromMe
  },
  jobRequestsToMe: state => {
    return state.jobRequestsToMe
  },
  jobRequestsLoading: state => {
    return state.jobRequestsLoading
  },
  getDayToMe: state => {
    return date => {
      return state.jobRequestsToMe.filter(item => {
        return item.on_date - date === 0
      })
    }
  },
  getDayFromMe: state => {
    return date => {
      return state.jobRequestsFromMe.filter(item => {
        return item.on_date - date === 0
      })
    }
  },
  getDayWorkerFromMe: state => {
    return date => {
      return state.jobRequestsFromMe.filter(jobRequest => {
        return jobRequest.on_date - date === 0
      })
    }
  },
  news: state => {
    var test = state.jobRequestsToMe.filter(item => {
      return !item.watched
    })
    return test.length
  }
}

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