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

"use server";
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 { serverFetchJson } from "@/app/utils/fetchUtil";
import { QcItemResult } from "../settings/qcItem";
import { RecordsRes } from "../utils";
import { ConsoPickOrderResult, PickOrderLineWithSuggestedLot, PickOrderResult, PreReleasePickOrderSummary, StockOutLine } from ".";
import { PurchaseQcResult } from "../po/actions";
// import { BASE_API_URL } from "@/config/api";
export interface PostStockOutLiineResponse<T> {
  id: number | null;
  name: string;
  code: string;
  type?: string
  message: string | null;
  errorPosition: string | keyof T;
  entity: T | T[]
}

export interface ReleasePickOrderInputs {
    consoCode: string
    assignTo: number,
}

export interface CreateStockOutLine {
  consoCode: string,
  pickOrderLineId: number,
  inventoryLotLineId: number,
  qty: number,
}

export interface UpdateStockOutLine {
  id: number,
  // consoCode: String,
  itemId: number,
  qty: number,
  pickOrderLineId: number,
  inventoryLotLineId?: number,
  status: string,
  pickTime?: string,
  // pickerId: number?
}

export interface PickOrderQcInput {
  qty: number
  status: string
  qcResult: PurchaseQcResult[];
}

export interface PickOrderApprovalInput {
  allowQty: number
  rejectQty: number
  status: string
}

export const consolidatePickOrder = async (ids: number[]) => {
  const pickOrder = await serverFetchJson<any>(`${BASE_API_URL}/pickOrder/conso`, {
    method: "POST",
    body: JSON.stringify({ ids: ids }),
    headers: { "Content-Type": "application/json" },
  });
//   revalidateTag("po");
  return pickOrder
}

export const consolidatePickOrder_revert = async (ids: number[]) => {
  const pickOrder = await serverFetchJson<any>(`${BASE_API_URL}/pickOrder/deconso`, {
    method: "POST",
    body: JSON.stringify({ ids: ids }),
    headers: { "Content-Type": "application/json" },
  });
//   revalidateTag("po");
  return pickOrder
}


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

  export const fetchConsoPickOrderClient = cache(async (queryParams?: Record<string, any>) => {
    if (queryParams) {
      const queryString = new URLSearchParams(queryParams).toString();
      return serverFetchJson<RecordsRes<ConsoPickOrderResult[]>>(`${BASE_API_URL}/pickOrder/getRecordByPage-conso?${queryString}`, {
        method: 'GET',
        next: { tags: ["pickorder"] },
      });
    } else {
      return serverFetchJson<RecordsRes<ConsoPickOrderResult[]>>(`${BASE_API_URL}/pickOrder/getRecordByPage-conso`, {
        method: 'GET',
        next: { tags: ["pickorder"] },
      });
    }
  });

  export const fetchPickOrderLineClient = cache(async (queryParams?: Record<string, any>) => {
    if (queryParams) {
      const queryString = new URLSearchParams(queryParams).toString();
      return serverFetchJson<RecordsRes<PickOrderLineWithSuggestedLot[]>>(`${BASE_API_URL}/pickOrder/get-pickorder-line-byPage?${queryString}`, {
        method: 'GET',
        next: { tags: ["pickorder"] },
      });
    } else {
      return serverFetchJson<RecordsRes<PickOrderLineWithSuggestedLot[]>>(`${BASE_API_URL}/pickOrder/get-pickorder-line-byPage`, {
        method: 'GET',
        next: { tags: ["pickorder"] },
      });
    }
  });

  export const fetchStockOutLineClient = cache(async (pickOrderLineId: number) => {
      return serverFetchJson<StockOutLine[]>(`${BASE_API_URL}/stockOutLine/getByPickOrderLineId/${pickOrderLineId}`, {
        method: 'GET',
        next: { tags: ["pickorder"] },
      });
  });

  export const fetchConsoDetail = cache(async (consoCode: string) => {
      return serverFetchJson<PreReleasePickOrderSummary>(`${BASE_API_URL}/pickOrder/pre-release-info/${consoCode}`, {
        method: 'GET',
        next: { tags: ["pickorder"] },
      });
  });

  
  export const releasePickOrder = async (data: ReleasePickOrderInputs) => {
    console.log(data)
    console.log(JSON.stringify(data))
    const po = await serverFetchJson<{body: any, status: number}>(`${BASE_API_URL}/pickOrder/releaseConso`, {
      method: "POST",
      body: JSON.stringify(data),
      headers: { "Content-Type": "application/json" },
    });
    revalidateTag("pickorder");
    return po
  }

  export const createStockOutLine = async (data: CreateStockOutLine) => {
    console.log("triggering")
    const po = await serverFetchJson<PostStockOutLiineResponse<StockOutLine>>(`${BASE_API_URL}/stockOutLine/create`, {
      method: "POST",
      body: JSON.stringify(data),
      headers: { "Content-Type": "application/json" },
    });
    revalidateTag("pickorder");
    return po
  }

  export const updateStockOutLine = async (data: UpdateStockOutLine) => {
    console.log(data)
    const po = await serverFetchJson<PostStockOutLiineResponse<StockOutLine>>
    (`${BASE_API_URL}/stockOutLine/update`, {
      method: "POST",
      body: JSON.stringify(data),
      headers: { "Content-Type": "application/json" },
    });
    revalidateTag("pickorder");
    return po
  }

  export const completeConsoPickOrder = async (consoCode: string) => {
    const po = await serverFetchJson<PostStockOutLiineResponse<StockOutLine>>
    (`${BASE_API_URL}/pickOrder/consoPickOrder/complete/${consoCode}`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
    });
    revalidateTag("pickorder");
    return po
  }