flaschengeist-frontend/src/plugins/schedule/store.ts

import { api } from 'src/boot/axios';
import { AxiosError } from 'axios';
import { defineStore } from 'pinia';

interface UserService {
  user: FG.Service;
}

function fixEvent(event: FG.Event) {
  event.start = new Date(event.start);
  if (event.end) event.end = new Date(event.end);

  event.jobs.forEach((job) => {
    job.start = new Date(job.start);
    if (job.end) job.end = new Date(job.end);
  });
}

export const useScheduleStore = defineStore({
  id: 'schedule',

  state: () => ({
    jobTypes: [] as FG.JobType[],
    eventTypes: [] as FG.EventType[],
  }),

  getters: {},

  actions: {
    async getJobTypes() {
      try {
        const { data } = await api.get<FG.JobType[]>('/schedule/job-types');
        this.jobTypes = data;
        return this.jobTypes;
      } catch (error) {
        throw error;
      }
    },

    async addJobType(name: string) {
      await api.post<FG.JobType>('/schedule/job-types', { name: name });
      //TODO: HAndle new JT
    },

    async removeJobType(id: number) {
      await api.delete(`/schedule/job-types/${id}`);
      //Todo Handle delete JT
    },

    async renameJobType(id: number, newName: string) {
      await api.put(`/schedule/job-types/${id}`, { name: newName });
      // TODO handle rename
    },

    async getEventTypes() {
      try {
        const { data } = await api.get<FG.EventType[]>('/schedule/event-types');
        this.eventTypes = data;
      } catch (error) {
        throw error;
      }
    },

    /** Add new EventType
     *
     * @param name Name of new EventType
     * @returns EventType object or null if name already exists
     * @throws Exception if requests fails because of an other reason
     */
    async addEventType(name: string) {
      try {
        const { data } = await api.post<FG.EventType>('/schedule/event-types', { name: name });
        return data;
      } catch (error) {
        if ('response' in error) {
          const ae = <AxiosError>error;
          if (ae.response && ae.response.status == 409 /* CONFLICT */) return null;
        }
        throw error;
      }
    },

    async removeEventType(id: number) {
      await api.delete(`/schedule/event-types/${id}`);
      // TODO handle delete
    },

    async renameEventType(id: number, newName: string) {
      try {
        await api.put(`/schedule/event-types/${id}`, { name: newName });
        // TODO handle rename
        return true;
      } catch (error) {
        if ('response' in error) {
          const ae = <AxiosError>error;
          if (ae.response && ae.response.status == 409 /* CONFLICT */) return false;
        }
        throw error;
      }
    },

    async getEvents(filter: { from?: Date; to?: Date } | undefined = undefined) {
      try {
        const { data } = await api.get<FG.Event[]>('/schedule/events', { params: filter });
        data.forEach((element) => fixEvent(element));
        return data;
      } catch (error) {
        throw error;
      }
    },
    async updateEvent(eventId: number, jobId: number, service: FG.Service | UserService) {
      try {
        const { data } = await api.put<FG.Event>(
          `/schedule/events/${eventId}/jobs/${jobId}`,
          service
        );
        fixEvent(data);
        return data;
      } catch (error) {
        throw error;
      }
    },

    async addEvent(event: FG.Event) {
      const { data } = await api.post<FG.Event>('/schedule/events', event);
      return data;
      //TODO: Handle add event}
    },
  },
});