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

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

const state = {
  jobInvitesFromMe: [],
  jobInvitesToMe: [],
  jobInvitesLoading: false
}

const mutations = {
  setJobInvitesFromMe: (state, jobInvites) => {
    state.jobInvitesFromMe = jobInvites
    state.jobInvitesFromMe.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: []
      }
    })
  },
  setJobInvitesToMe: (state, jobInvites) => {
    state.jobInvitesToMe = jobInvites
    state.jobInvitesToMe.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: []
      }
    })
  },
  setJobInvitesLoading: (state, value) => {
    state.jobInvitesLoading = value
  },
  updateJobInviteToMe: (state, jobInvite) => {
    state.jobInvitesToMe.forEach(item => {
      if (item.id === jobInvite.id) {
        item.watched = jobInvite.watched
      }
    })
  },
  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
    })
  },
  deleteJobInviteFromMe: (state, jobinvite) => {
    var item = state.jobInvitesFromMe.find(item => {
      return item.id === jobinvite.id
    })
    state.jobInvitesFromMe.splice(item, 1)
  }
}

const actions = {
  async getJobInvites({ commit, dispatch, rootState, getters }) {
    try {
      const date = new Date()
      const from_me = await axios.post(
        url.user.getJobInvites,
        {
          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('setJobInvitesFromMe', 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.getJobInvites,
        {
          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('setJobInvitesToMe', 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 })
      })
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async setJobInvites({ commit, dispatch, rootState }, data) {
    try {
      commit('setJobInvitesLoading', true)
      const response = await axios.put(url.user.setJobInvites, data, {
        headers: { Token: rootState.login.user.accessToken }
      })
      commit('setJobInvitesFromMe', response.data)
      commit('setJobInvitesLoading', false)
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async addJob({ commit, rootState, dispatch, getters }, data) {
    var date = new Date(data.year, data.month - 1, data.day)
    commit('setDayLoading', { date, getters, value: true })
    try {
      const response = await axios.post(
        url.user.addJob,
        { ...data },
        {
          headers: { Token: rootState.login.user.accessToken }
        }
      )
      commit('updateMonthWorker', {
        workers: [...response.data],
        date: new Date(data.year, data.month - 1, data.day),
        getters, from_me: false
      })
      commit('setDayLoading', { date, getters, value: false })
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async updateJobInviteToMe({ commit, rootState, dispatch }, data) {
    try {
      const response = await axios.post(url.user.setJobInvites, data, {
        headers: { Token: rootState.login.user.accessToken }
      })
      commit('updateJobInviteToMe', response.data)
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async deleteJobInviteFromMe({ commit, rootState, dispatch}, data) {
    try {
     await axios.post(url.user.deletJobInvite, data, {headers: {Token: rootState.login.user.accessToken}})
      commit('deleteJobInviteFromMe', data)
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  }
}

const getters = {
  jobInvitesFromMe: state => {
    return state.jobInvitesFromMe
  },
  jobInvitesToMe: state => {
    return state.jobInvitesToMe
  },
  jobInvitesLoading: state => {
    return state.jobInvitesLoading
  },
  getDayToMe: state => {
    return date => {
      return state.jobInvitesToMe.filter(item => {
        return item.on_date - date === 0
      })
    }
  },
  getDayFromMe: state => {
    return date => {
      return state.jobInvitesFromMe.filter(item => {
        return item.on_date - date === 0
      })
    }
  },
  getDayWorkerFromMe: state => {
    return date => {
      return state.jobInvitesFromMe.filter(jobInvite => {
        return jobInvite.on_date - date === 0
      })
    }
  },
  news: state => {
    var test = state.jobInvitesToMe.filter(item => {
      return !item.watched
    })
    return test.length
  }
}

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