shoc-frontend-new/src/domain/work-orders/api/work-orders-api.ts

import { API_PATHS } from "@/api/api-paths";
import { apiDelete, apiGet, apiPost } from "@/api/api";
import { handleApiResponse, handlePaginatedResponse } from "@/api/handle-api-response";
import {
  mapDispatchComment,
  mapDispatchDetail,
  mapDispatchSignoff,
  mapDispatchToVendorPayload,
  mapEmployeeOptions,
  mapLocationOptions,
  mapTaskListTemplates,
  mapUpdateDispatchPayload,
  mapVendorDropdownItems,
  mapWorkOrderComment,
  mapWorkOrderDetail,
  mapWorkOrderFormToCreatePayload,
  mapWorkOrderFormToUpdatePayload,
  mapWorkOrderListItems,
} from "@/domain/work-orders/mappers/work-order-mapper";
import type { WorkOrderFormSchemaValues } from "@/domain/work-orders/schemas/work-order-schema";
import type {
  DispatchDetail,
  DispatchToVendorPayload,
  EmployeeOption,
  LocationOption,
  TaskListTemplate,
  UpdateDispatchPayload,
  VendorDropdownItem,
  WorkOrderComment,
  WorkOrderDetail,
  WorkOrderFormValues,
  WorkOrderUser,
  WorkOrdersListParams,
  WorkOrdersListResult,
} from "@/domain/work-orders/types/work-order";

function buildSearchParams(params: WorkOrdersListParams): Record<string, string | number> {
  const searchParams: Record<string, string | number> = {
    search: params.search ?? "",
    page: params.page ?? 1,
    pageSize: params.pageSize ?? 12,
  };

  if (params.sortBy) {
    searchParams.sortBy = params.sortBy;
  }
  if (params.sortDir) {
    searchParams.sortDir = params.sortDir;
  }
  if (params.status) {
    searchParams.status = params.status;
  }
  if (params.assignee) {
    searchParams.assignee = params.assignee;
  }
  if (params.locationId) {
    searchParams.locationId = params.locationId;
  }

  return searchParams;
}

function mapUser(raw: unknown): WorkOrderUser {
  const item = (typeof raw === "object" && raw !== null ? raw : {}) as Record<string, unknown>;
  const id = item.id ?? item.Id;
  const name =
    (typeof item.name === "string" ? item.name : undefined) ??
    (typeof item.Name === "string" ? item.Name : undefined) ??
    (typeof item.userName === "string" ? item.userName : "") ??
    "";

  return {
    id: typeof id === "string" || typeof id === "number" ? id : "",
    name,
  };
}

export const workOrdersApi = {
  getList: async (params: WorkOrdersListParams = {}): Promise<WorkOrdersListResult> => {
    const searchParams = buildSearchParams(params);
    const data = await apiGet<unknown>(API_PATHS.workOrder.getList, { searchParams });
    const paginated = handlePaginatedResponse<unknown>(data, {
      page: params.page,
      pageSize: params.pageSize,
    });

    return {
      items: mapWorkOrderListItems(paginated.items),
      totalCount: paginated.totalCount,
      page: paginated.page,
      pageSize: paginated.pageSize,
    };
  },

  fetchUsers: async (): Promise<WorkOrderUser[]> => {
    const data = await apiGet<unknown>(API_PATHS.user.list);
    const users = handleApiResponse<unknown[]>(data);
    return Array.isArray(users) ? users.map(mapUser) : [];
  },

  getById: async (id: string | number): Promise<WorkOrderDetail> => {
    const data = await apiGet<unknown>(API_PATHS.workOrder.getById, {
      searchParams: { id },
    });
    return mapWorkOrderDetail(handleApiResponse(data));
  },

  create: async (
    values: WorkOrderFormSchemaValues | WorkOrderFormValues,
  ): Promise<WorkOrderDetail> => {
    const payload = mapWorkOrderFormToCreatePayload(values);
    const data = await apiPost<unknown>(API_PATHS.workOrder.addWorkorder, payload);
    return mapWorkOrderDetail(handleApiResponse(data));
  },

  update: async (
    id: string | number,
    values: WorkOrderFormSchemaValues | WorkOrderFormValues,
  ): Promise<WorkOrderDetail> => {
    const payload = mapWorkOrderFormToUpdatePayload(id, values);
    const data = await apiPost<unknown>(API_PATHS.workOrder.editWorkorder, payload);
    return mapWorkOrderDetail(handleApiResponse(data));
  },

  delete: async (id: string | number): Promise<void> => {
    await apiDelete(API_PATHS.workOrder.deleteWorkorder, {
      json: { Id: Number(id) },
    });
  },

  addComment: async (
    workOrderId: string | number,
    text: string,
    commentType: string,
  ): Promise<WorkOrderComment> => {
    const data = await apiPost<unknown>(API_PATHS.workOrder.addCommentJson, {
      WorkorderId: workOrderId,
      Text: text,
      CommentType: commentType,
    });
    return mapWorkOrderComment(handleApiResponse(data));
  },

  changeStatus: async (id: string | number, status: string): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.changeStatus, undefined, {
      searchParams: { id, status },
    });
  },

  changeAssignment: async (id: string | number, assignTo: string | number): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.changeAssignment, undefined, {
      searchParams: { id, assignTo: assignTo || "" },
    });
  },

  fetchLocations: async (): Promise<LocationOption[]> => {
    const data = await apiGet<unknown>(API_PATHS.contact.getLocations);
    const items = handleApiResponse<unknown[]>(data);
    return Array.isArray(items) ? mapLocationOptions(items) : [];
  },

  fetchEmployeesDropdown: async (): Promise<EmployeeOption[]> => {
    try {
      const data = await apiGet<unknown>(API_PATHS.employee.dropdown);
      const items = handleApiResponse<unknown[]>(data);
      return Array.isArray(items) ? mapEmployeeOptions(items) : [];
    } catch {
      const data = await apiGet<unknown>(API_PATHS.employee.getList, {
        searchParams: { page: 1, pageSize: 1000 },
      });
      const paginated = handlePaginatedResponse<unknown>(data);
      const items = paginated.items.map((item) => {
        const record = (typeof item === "object" && item !== null ? item : {}) as Record<
          string,
          unknown
        >;
        const firstName = String(record.firstName ?? record.FirstName ?? "");
        const lastName = String(record.lastName ?? record.LastName ?? "");
        return {
          id: record.id ?? record.Id,
          name: `${firstName} ${lastName}`.trim(),
        };
      });
      return mapEmployeeOptions(items);
    }
  },

  fetchVendorsDropdown: async (trade?: string, siteZip?: string): Promise<VendorDropdownItem[]> => {
    const searchParams: Record<string, string> = {};
    if (trade) {
      searchParams.trade = trade;
    }
    if (siteZip) {
      searchParams.siteZip = siteZip;
    }

    const data = await apiGet<unknown>(API_PATHS.vendor.dropdown, {
      searchParams: Object.keys(searchParams).length > 0 ? searchParams : undefined,
    });
    const items = handleApiResponse<unknown[]>(data);
    return Array.isArray(items) ? mapVendorDropdownItems(items) : [];
  },

  fetchTaskTemplates: async (): Promise<TaskListTemplate[]> => {
    const data = await apiGet<unknown>(API_PATHS.taskListTemplate.list);
    const items = handleApiResponse<unknown[]>(data);
    return Array.isArray(items) ? mapTaskListTemplates(items) : [];
  },

  dispatchToVendor: async (payload: DispatchToVendorPayload): Promise<void> => {
    await apiPost<unknown>(
      API_PATHS.workOrder.dispatchToVendor,
      mapDispatchToVendorPayload(payload),
    );
  },

  getDispatchById: async (id: string | number): Promise<DispatchDetail> => {
    const data = await apiGet<unknown>(`${API_PATHS.workOrder.getDispatch}/${id}`);
    return mapDispatchDetail(handleApiResponse(data));
  },

  updateDispatch: async (payload: UpdateDispatchPayload): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.updateDispatch, mapUpdateDispatchPayload(payload));
  },

  addDispatchComment: async (
    dispatchId: string | number,
    text: string,
    sendEmail = true,
  ): Promise<DispatchDetail["comments"][number]> => {
    const data = await apiPost<unknown>(API_PATHS.workOrder.addDispatchComment, {
      DispatchId: dispatchId,
      Text: text,
      SendEmail: sendEmail,
    });
    return mapDispatchComment(handleApiResponse(data));
  },

  updateChecklistItem: async (
    id: string | number,
    isCompleted: boolean,
    completedBy: string,
  ): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.updateChecklistItem, {
      Id: id,
      IsCompleted: isCompleted,
      CompletedBy: completedBy,
    });
  },

  addChecklistItem: async (dispatchId: string | number, itemText: string): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.addChecklistItem, {
      DispatchId: dispatchId,
      ItemText: itemText,
    });
  },

  addDispatchSignoff: async (
    dispatchId: string | number,
    signoffType: string,
    name: string,
    signature: string,
    signatureMethod: string,
  ): Promise<DispatchDetail["signoffs"][number]> => {
    const data = await apiPost<unknown>(API_PATHS.workOrder.addDispatchSignoff, {
      DispatchId: dispatchId,
      SignoffType: signoffType,
      Name: name,
      Signature: signature,
      SignatureMethod: signatureMethod,
    });
    return mapDispatchSignoff(handleApiResponse(data));
  },

  verifyDispatch: async (dispatchId: string | number): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.verifyDispatch, undefined, {
      searchParams: { dispatchId },
    });
  },
};