114 lines
3.6 KiB
TypeScript
114 lines
3.6 KiB
TypeScript
/* eslint-disable canonical/id-match */
|
|
import { getClientWithToken } from '../apollo/client';
|
|
import * as GQL from '../types';
|
|
import { Enum_Customer_Role, Enum_Slot_State } from '../types';
|
|
import { BaseService } from './base';
|
|
import { CustomersService } from './customers';
|
|
import { ServicesService } from './services';
|
|
import { SlotsService } from './slots';
|
|
import { type VariablesOf } from '@graphql-typed-document-node/core';
|
|
import { formatTime, sumTime } from '@repo/utils/datetime-format';
|
|
|
|
const ERRORS = {
|
|
INVALID_CLIENT: 'Invalid client',
|
|
INVALID_MASTER: 'Invalid master',
|
|
INVALID_SERVICE_DURATION: 'Invalid service duration',
|
|
MISSING_CLIENT: 'Missing client id',
|
|
MISSING_SERVICE_ID: 'Missing service id',
|
|
MISSING_SERVICES: 'Missing services',
|
|
MISSING_SLOT: 'Missing slot id',
|
|
MISSING_START_TIME: 'Missing time start',
|
|
SLOT_CLOSED: 'Slot is closed',
|
|
};
|
|
|
|
export class OrdersService extends BaseService {
|
|
async createOrder(variables: {
|
|
input: Omit<VariablesOf<typeof GQL.CreateOrderDocument>['input'], 'time_end'>;
|
|
}) {
|
|
if (!variables.input.slot) throw new Error(ERRORS.MISSING_SLOT);
|
|
if (!variables.input.client) throw new Error(ERRORS.MISSING_CLIENT);
|
|
if (!variables.input.services?.length) throw new Error(ERRORS.MISSING_SERVICES);
|
|
if (!variables.input.services[0]) throw new Error(ERRORS.MISSING_SERVICE_ID);
|
|
if (!variables.input.time_start) throw new Error(ERRORS.MISSING_START_TIME);
|
|
|
|
const customersService = new CustomersService(this.customer);
|
|
const slotsService = new SlotsService(this.customer);
|
|
const servicesService = new ServicesService(this.customer);
|
|
|
|
const { customer } = await customersService.getCustomer(this.customer);
|
|
const { slot } = await slotsService.getSlot({ documentId: variables.input.slot });
|
|
|
|
if (slot?.state === Enum_Slot_State.Closed) {
|
|
throw new Error(ERRORS.SLOT_CLOSED);
|
|
}
|
|
|
|
if (customer?.role === Enum_Customer_Role.Client) {
|
|
if (customer.documentId !== variables.input.client) {
|
|
throw new Error(ERRORS.INVALID_CLIENT);
|
|
}
|
|
|
|
const masters = await customersService.getMasters(this.customer);
|
|
|
|
const masterId = slot?.master?.documentId;
|
|
if (!masters.customers.some((master) => master?.documentId === masterId)) {
|
|
throw new Error(ERRORS.INVALID_MASTER);
|
|
}
|
|
}
|
|
|
|
if (
|
|
customer?.role === Enum_Customer_Role.Master &&
|
|
slot?.master?.documentId !== customer.documentId
|
|
) {
|
|
throw new Error(ERRORS.INVALID_MASTER);
|
|
}
|
|
|
|
const { service } = await servicesService.getService({
|
|
documentId: variables.input.services[0],
|
|
});
|
|
|
|
if (!service?.duration) throw new Error(ERRORS.INVALID_SERVICE_DURATION);
|
|
|
|
const endTime = sumTime(variables.input.time_start, service?.duration);
|
|
|
|
const { mutate } = await getClientWithToken();
|
|
|
|
const mutationResult = await mutate({
|
|
mutation: GQL.CreateOrderDocument,
|
|
variables: {
|
|
...variables,
|
|
input: {
|
|
...variables.input,
|
|
time_end: formatTime(endTime).db(),
|
|
},
|
|
},
|
|
});
|
|
|
|
const error = mutationResult.errors?.at(0);
|
|
if (error) throw new Error(error.message);
|
|
|
|
return mutationResult.data;
|
|
}
|
|
|
|
async getOrder(variables: VariablesOf<typeof GQL.GetOrderDocument>) {
|
|
const { query } = await getClientWithToken();
|
|
|
|
const result = await query({
|
|
query: GQL.GetOrderDocument,
|
|
variables,
|
|
});
|
|
|
|
return result.data;
|
|
}
|
|
|
|
async getOrders(variables: VariablesOf<typeof GQL.GetOrdersDocument>) {
|
|
const { query } = await getClientWithToken();
|
|
|
|
const result = await query({
|
|
query: GQL.GetOrdersDocument,
|
|
variables,
|
|
});
|
|
|
|
return result.data;
|
|
}
|
|
}
|