shoc-frontend-new/src/domain/services/api/services-api.ts

import { apiGet, apiPost, apiPostNoContent, apiPut } from "@/api/api";
import { API_PATHS } from "@/api/api-paths";
import { handleApiResponse } from "@/api/handle-api-response";
import {
  mapCompletionDocTemplates,
  mapService,
  mapServices,
} from "@/domain/services/mappers/service-mapper";
import type {
  CompletionDocTemplateOption,
  Service,
  ServiceInput,
} from "@/domain/services/types/service";
import { WORK_ORDER_TYPE_API } from "@/domain/work-orders/types/work-order-board";
import type { WOType } from "@/domain/work-orders/types/work-order-wizard";

const SERVICE_WORK_ORDER_TYPE_API = {
  PM: 2,
  Emergency: 3,
  Reactive: 6,
} as const;

// The registry is keyed on PM, Reactive and Emergency; Overdue is PM work the
// client never confirmed, so it lists the PM catalog.
const TYPE_TO_API: Record<WOType, number> = {
  PM: WORK_ORDER_TYPE_API.PM,
  Reactive: WORK_ORDER_TYPE_API.Reactive,
  Emergency: WORK_ORDER_TYPE_API.Emergency,
  Overdue: WORK_ORDER_TYPE_API.PM,
};

function toApiInput(input: ServiceInput) {
  return {
    ...input,
    supportedWorkOrderTypes: input.supportedWorkOrderTypes.map(
      (type) => SERVICE_WORK_ORDER_TYPE_API[type],
    ),
  };
}

export const servicesApi = {
  getAll: async (isActive?: boolean): Promise<Service[]> => {
    const data = await apiGet<unknown>(API_PATHS.services.list, {
      searchParams: isActive === undefined ? undefined : { isActive },
    });
    return mapServices(handleApiResponse(data));
  },

  getActive: async (): Promise<Service[]> => {
    const data = await apiGet<unknown>(API_PATHS.services.list, {
      searchParams: { isActive: true },
    });
    return mapServices(handleApiResponse(data));
  },

  getActiveForWorkOrderType: async (workOrderType: WOType): Promise<Service[]> => {
    const data = await apiGet<unknown>(API_PATHS.services.list, {
      searchParams: { isActive: true, workOrderType: TYPE_TO_API[workOrderType] },
    });
    return mapServices(handleApiResponse(data));
  },

  getCompletionTemplates: async (): Promise<CompletionDocTemplateOption[]> => {
    const data = await apiGet<unknown>(API_PATHS.workOrder.completionTemplates);
    return mapCompletionDocTemplates(handleApiResponse(data));
  },

  create: async (input: ServiceInput): Promise<Service> => {
    const data = await apiPost<unknown>(API_PATHS.services.list, toApiInput(input));
    return mapService(handleApiResponse(data));
  },

  update: async (id: string | number, input: ServiceInput): Promise<Service> => {
    const data = await apiPut<unknown>(API_PATHS.services.byId(id), toApiInput(input));
    return mapService(handleApiResponse(data));
  },

  deactivate: async (id: string | number): Promise<void> => {
    await apiPostNoContent(API_PATHS.services.deactivate(id));
  },
};