FPSMS-frontend/src/app/api/po/actions.ts

"use server";
// import { BASE_API_URL } from "@/config/api";
import { BASE_API_URL } from "../../../config/api";
// import { ServerFetchError, serverFetchJson, serverFetchWithNoContent } from "@/app/utils/fetchUtil";
import { revalidateTag } from "next/cache";
import { cache } from "react";
import { PoResult, StockInLine } from ".";
//import { serverFetchJson } from "@/app/utils/fetchUtil";
import { serverFetchJson } from "../../utils/fetchUtil";
import { QcItemResult } from "../settings/qcItem";
import { RecordsRes } from "../utils";
import { Uom } from "../settings/uom";
// import { BASE_API_URL } from "@/config/api";

export interface PostStockInLineResponse<T> {
  id: number | null;
  name: string;
  code: string;
  type?: string;
  message: string | null;
  errorPosition: string | keyof T;
  entity: T | T[];
  // entity: StockInLine | StockInLine[]
}

export interface StockInLineEntry {
  id?: number;
  itemId: number;
  purchaseOrderId: number;
  purchaseOrderLineId: number;
  acceptedQty: number;
  status?: string;
  expiryDate?: string;
  productLotNo?: string;
  receiptDate?: string;
  dnDate?: string;
}

export interface PurchaseQcResult{
  qcItemId: number;
  qcPassed: boolean;
  failQty: number;
  remarks?: string;
  
}
export interface StockInInput {
  status: string;
  poCode: string;
  productLotNo?: string;
  dnNo?: string;
  dnDate?: string;
  itemName: string;
  invoiceNo?: string;
  receiptDate: string;
  supplier: string;
  acceptedQty: number;
  qty: number;
  receivedQty: number;
  acceptedWeight?: number;
  productionDate?: string;
  expiryDate: string;
  uom: Uom;
}
export interface PurchaseQCInput {
  status: string;
  acceptQty: number;
  passingQty: number;
  sampleRate: number;
  sampleWeight: number;
  totalWeight: number;
  qcAccept: boolean;
  qcResult: PurchaseQcResult[];
}
export interface EscalationInput {
  status: string;
  remarks?: string;
  handler: string;
  productLotNo: string;
  acceptedQty: number; // this is the qty to be escalated
  // escalationQty: number
}
export interface PutawayLine {
  id?: number
  qty: number
  warehouseId: number;
  warehouse: string;
  printQty: number
}
export interface PutawayInput {
  status: string;
  acceptedQty: number;
  warehouseId: number;
  putawayLine: PutawayLine[]
}

export type ModalFormInput = Partial<
  PurchaseQCInput & StockInInput & EscalationInput & PutawayInput
>;

export const testFetch = cache(async (id: number) => {
  return serverFetchJson<PoResult>(`${BASE_API_URL}/po/detail/${id}`, {
    next: { tags: ["po"] },
  });
});

export const fetchStockInLineInfo = cache(async (stockInLineId: number) => {
  return serverFetchJson<StockInLine>(
    `${BASE_API_URL}/stockInLine/${stockInLineId}`,
    {
      next: { tags: ["stockInLine"] },
    },
  );
});

export const createStockInLine = async (data: StockInLineEntry) => {
  const stockInLine = await serverFetchJson<
    PostStockInLineResponse<StockInLine>
  >(`${BASE_API_URL}/stockInLine/create`, {
    method: "POST",
    body: JSON.stringify(data),
    headers: { "Content-Type": "application/json" },
  });
  // revalidateTag("po");
  return stockInLine;
};

export const updateStockInLine = async (
  data: StockInLineEntry & ModalFormInput,
) => {
  const stockInLine = await serverFetchJson<
    PostStockInLineResponse<StockInLine & ModalFormInput>
  >(`${BASE_API_URL}/stockInLine/update`, {
    method: "POST",
    body: JSON.stringify(data),
    headers: { "Content-Type": "application/json" },
  });
  // revalidateTag("po");
  return stockInLine;
};

export const startPo = async (poId: number) => {
  const po = await serverFetchJson<PostStockInLineResponse<PoResult>>(
    `${BASE_API_URL}/po/start/${poId}`,
    {
      method: "POST",
      body: JSON.stringify({ poId }),
      headers: { "Content-Type": "application/json" },
    },
  );
  revalidateTag("po");
  return po;
};

export const checkPolAndCompletePo = async (poId: number) => {
  const po = await serverFetchJson<PostStockInLineResponse<PoResult>>(
    `${BASE_API_URL}/po/check/${poId}`,
    {
      method: "POST",
      body: JSON.stringify({ poId }),
      headers: { "Content-Type": "application/json" },
    },
  );
  revalidateTag("po");
  return po;
};

export const fetchPoInClient = cache(async (id: number) => {
  return serverFetchJson<PoResult>(`${BASE_API_URL}/po/detail/${id}`, {
    next: { tags: ["po"] },
  });
});

export const fetchPoListClient = cache(
  async (queryParams?: Record<string, any>) => {
    if (queryParams) {
      const queryString = new URLSearchParams(queryParams).toString();
      return serverFetchJson<RecordsRes<PoResult[]>>(
        `${BASE_API_URL}/po/list?${queryString}`,
        {
          method: "GET",
          next: { tags: ["po"] },
        },
      );
    } else {
      return serverFetchJson<RecordsRes<PoResult[]>>(
        `${BASE_API_URL}/po/list`,
        {
          method: "GET",
          next: { tags: ["po"] },
        },
      );
    }
  },
);

export const testing = cache(async (queryParams?: Record<string, any>) => {
  if (queryParams) {
    const queryString = new URLSearchParams(queryParams).toString();
    return serverFetchJson<RecordsRes<PoResult[]>>(
      `${BASE_API_URL}/po/testing?${queryString}`,
      {
        method: "GET",
        next: { tags: ["po"] },
      },
    );
  } else {
    return serverFetchJson<RecordsRes<PoResult[]>>(
      `${BASE_API_URL}/po/testing`,
      {
        method: "GET",
        next: { tags: ["po"] },
      },
    );
  }
});