zapishis-client/packages/graphql/api/slots.ts

import { getClientWithToken } from '../apollo/client';
import * as GQL from '../types';
import { BaseService } from './base';
import { CustomersService } from './customers';
import { ServicesService } from './services';
import { type VariablesOf } from '@graphql-typed-document-node/core';
import { getMinutes } from '@repo/utils/datetime-format';
import dayjs from 'dayjs';

export class SlotsService extends BaseService {
  async createSlot(variables: VariablesOf<typeof GQL.CreateSlotDocument>) {
    const customerService = new CustomersService(this.customer);

    const { customer } = await customerService.getCustomer(this.customer);

    const { mutate } = await getClientWithToken();

    const mutationResult = await mutate({
      mutation: GQL.CreateSlotDocument,
      variables: {
        ...variables,
        input: {
          ...variables.input,
          master: customer?.documentId,
        },
      },
    });

    const error = mutationResult.errors?.at(0);
    if (error) throw new Error(error.message);

    return mutationResult.data;
  }

  async deleteSlot(variables: VariablesOf<typeof GQL.DeleteSlotDocument>) {
    const { mutate } = await getClientWithToken();

    const mutationResult = await mutate({
      mutation: GQL.DeleteSlotDocument,
      variables,
    });

    const error = mutationResult.errors?.at(0);
    if (error) throw new Error(error.message);

    return mutationResult.data;
  }

  async getAvailableTimeSlots(
    variables: VariablesOf<typeof GQL.GetSlotsDocument>,
    context: { service: GQL.ServiceFiltersInput },
  ) {
    if (!variables.filters?.datetime_start) throw new Error('Missing date');
    if (!context?.service?.documentId?.eq) throw new Error('Missing service id');

    const { query } = await getClientWithToken();

    const getSlotsResult = await query({
      query: GQL.GetSlotsOrdersDocument,
      variables: {
        filters: {
          ...variables.filters,
          state: { eq: GQL.Enum_Slot_State.Open },
        },
      },
    });

    if (getSlotsResult.error) throw new Error(getSlotsResult.error.message);

    const servicesService = new ServicesService(this.customer);

    const { service } = await servicesService.getService({
      documentId: context.service.documentId.eq,
    });

    if (!service) throw new Error('Service not found');

    const serviceDuration = getMinutes(service.duration);

    const slots = getSlotsResult.data.slots;

    const times: Array<{ slotId: string; time: string }> = [];
    for (const slot of slots) {
      if (!slot?.datetime_start || !slot?.datetime_end) continue;

      let datetimeStart = dayjs(slot.datetime_start);
      const datetimeEnd = dayjs(slot.datetime_end).subtract(serviceDuration, 'minutes');

      while (datetimeStart.valueOf() <= datetimeEnd.valueOf()) {
        const slotStartTime = datetimeStart;
        const potentialDatetimeEnd = datetimeStart.add(serviceDuration, 'minutes');

        const hasConflict = slot.orders.some(
          (order) =>
            order?.state &&
            ![GQL.Enum_Order_State.Cancelled].includes(order.state) &&
            slotStartTime.isBefore(dayjs(order.datetime_end)) &&
            potentialDatetimeEnd.isAfter(dayjs(order.datetime_start)),
        );

        if (!hasConflict) {
          times.push({ slotId: slot.documentId, time: datetimeStart.toISOString() });
        }

        datetimeStart = datetimeStart.add(15, 'minutes');
      }
    }

    return { slots, times };
  }

  async getSlot(variables: VariablesOf<typeof GQL.GetSlotDocument>) {
    const { query } = await getClientWithToken();

    const result = await query({
      query: GQL.GetSlotDocument,
      variables,
    });

    return result.data;
  }

  async getSlots(variables: VariablesOf<typeof GQL.GetSlotsDocument>) {
    const { query } = await getClientWithToken();

    const result = await query({
      query: GQL.GetSlotsDocument,
      variables,
    });

    return result.data;
  }

  async updateSlot(variables: VariablesOf<typeof GQL.UpdateSlotDocument>) {
    const { mutate } = await getClientWithToken();

    const mutationResult = await mutate({
      mutation: GQL.UpdateSlotDocument,
      variables,
    });

    const error = mutationResult.errors?.at(0);
    if (error) throw new Error(error.message);

    return mutationResult.data;
  }
}