王明 / Food-Labeling-Management-Platform

  import { ApiError, createApiClient } from "../lib/apiClient";

  import { authorizedPostBlobDownload } from "../lib/batchFileHttp";

  import type {
    LabelReportData,
    LabelReportQueryInput,
    ReportsPrintLogListItem,
    ReportsPrintLogListResult,
    ReportsPrintLogQueryInput,

    TemplatePrintStatListItem,
    TemplatePrintStatListResult,
    TemplatePrintStatQueryInput,

  } from "../types/reports";
  
  const api = createApiClient({
    getToken: () => {
      try {
        return localStorage.getItem("access_token") ?? localStorage.getItem("token") ?? null;
      } catch {
        return null;
      }
    },
  });
  
  const REPORTS_PREFIX = "/reports";
  
  function str(raw: unknown, c: string, p: string, fallback = ""): string {
    if (!raw || typeof raw !== "object") return fallback;
    const o = raw as Record<string, unknown>;
    const v = o[c] ?? o[p];
    if (v === null || v === undefined) return fallback;
    return String(v);
  }
  
  function num(raw: unknown, c: string, p: string, fallback = 0): number {
    if (!raw || typeof raw !== "object") return fallback;
    const o = raw as Record<string, unknown>;
    const v = o[c] ?? o[p];
    const n = typeof v === "number" ? v : Number(v);
    return Number.isFinite(n) ? n : fallback;
  }
  
  function normPrintItem(raw: unknown): ReportsPrintLogListItem {
    if (!raw || typeof raw !== "object") {
      return {
        taskId: "",
        labelCode: "",
        productName: "None",

        productCategoryName: "None",
        labelCategoryName: "None",

        categoryName: "None",
        templateText: "",
        printedAt: "",
        printedByName: "None",
        locationText: "None",
        locationId: "",
        expiryDateText: "None",
      };
    }
    const o = raw as Record<string, unknown>;
    return {
      taskId: str(o, "taskId", "TaskId"),
      labelCode: str(o, "labelCode", "LabelCode") || "None",
      productName: str(o, "productName", "ProductName", "None") || "None",

      productCategoryName:
        str(o, "productCategoryName", "ProductCategoryName", "") ||
        str(o, "categoryName", "CategoryName", "None") ||
        "None",
      labelCategoryName: str(o, "labelCategoryName", "LabelCategoryName", "None") || "None",

      categoryName: str(o, "categoryName", "CategoryName", "None") || "None",
      templateText: str(o, "templateText", "TemplateText", ""),
      printedAt: str(o, "printedAt", "PrintedAt", ""),
      printedByName: str(o, "printedByName", "PrintedByName", "None") || "None",
      locationText: str(o, "locationText", "LocationText", "None") || "None",
      locationId: str(o, "locationId", "LocationId", ""),
      expiryDateText: str(o, "expiryDateText", "ExpiryDateText", "None") || "None",
    };
  }
  
  function buildPrintLogQuery(
    input: ReportsPrintLogQueryInput,
    opts: { includePaging: boolean } = { includePaging: true }
  ) {
    const q: Record<string, unknown> = {
      Sorting: input.sorting,
      PartnerId: input.partnerId,
      GroupId: input.groupId,
      LocationId: input.locationId,
      StartDate: input.startDate,
      EndDate: input.endDate,
      Keyword: input.keyword,
    };
    if (opts.includePaging) {
      q.SkipCount = input.skipCount;
      q.MaxResultCount = input.maxResultCount;
    }
    return q;
  }
  
  export async function getReportsPrintLogList(
    input: ReportsPrintLogQueryInput,
    signal?: AbortSignal
  ): Promise<ReportsPrintLogListResult> {
    const raw = await api.requestJson<unknown>({
      path: `${REPORTS_PREFIX}/print-log-list`,
      method: "GET",
      query: buildPrintLogQuery(input, { includePaging: true }),
      signal,
    });
  
    const o = (raw && typeof raw === "object" ? raw : {}) as Record<string, unknown>;
    const itemsRaw = o.items ?? o.Items;
    const list = Array.isArray(itemsRaw) ? itemsRaw.map(normPrintItem) : [];
    const total = num(o, "totalCount", "TotalCount", list.length);
    return { items: list, totalCount: total };
  }
  
  function normLabelSlice(x: unknown): { name: string; count: number } | null {
    if (!x || typeof x !== "object") return null;
    const o = x as Record<string, unknown>;
    const name = str(
      o,
      "categoryName",
      "CategoryName",
      str(o, "name", "Name", str(o, "labelCategoryName", "LabelCategoryName", "Category"))
    );
    if (!name.trim()) return null;
    const count = num(
      o,
      "count",
      "Count",
      num(o, "printCount", "PrintCount", num(o, "totalPrinted", "TotalPrinted", 0))
    );
    return { name: name.trim(), count };
  }
  
  function normTrendPoint(x: unknown): { date: string; count: number } | null {
    if (!x || typeof x !== "object") return null;
    const o = x as Record<string, unknown>;
    const date = str(
      o,
      "date",
      "Date",
      str(o, "day", "Day", str(o, "printDate", "PrintDate", ""))
    );
    if (!date.trim()) return null;
    const count = num(o, "count", "Count", num(o, "volume", "Volume", 0));
    return { date: date.trim(), count };
  }
  
  function normTopProduct(x: unknown) {
    if (!x || typeof x !== "object") return null;
    const o = x as Record<string, unknown>;
    const productName = str(o, "productName", "ProductName", "");
    if (!productName.trim()) return null;
    return {
      productName: productName.trim(),
      categoryName: str(o, "categoryName", "CategoryName", "None") || "None",
      totalPrinted: num(
        o,
        "totalPrinted",
        "TotalPrinted",
        num(o, "printCount", "PrintCount", 0)
      ),
      usagePercent: num(o, "usagePercent", "UsagePercent", 0),
    };
  }
  
  function normLabelReport(raw: unknown): LabelReportData {
    if (!raw || typeof raw !== "object") {
      return {
        summary: {
          totalLabelsPrinted: 0,
          totalLabelsPrintedPrevPeriod: 0,
          totalLabelsPrintedChangeRate: 0,
          hottestCategoryName: "None",
          hottestCategoryCount: 0,
          topProductName: "None",
          topProductCount: 0,
          avgDailyPrints: 0,
          avgDailyPrintsChangeRate: 0,
        },
        labelsByCategory: [],
        printVolumeTrend: [],
        mostUsedProducts: [],
      };
    }
    const root = raw as Record<string, unknown>;
    const sumRaw = root.summary ?? root.Summary;
    const s = (sumRaw && typeof sumRaw === "object" ? sumRaw : {}) as Record<string, unknown>;
  
    const labelsRaw = root.labelsByCategory ?? root.LabelsByCategory;
    const trendRaw = root.printVolumeTrend ?? root.PrintVolumeTrend;
    const productsRaw = root.mostUsedProducts ?? root.MostUsedProducts;
  
    const labelsByCategory: { name: string; count: number }[] = [];
    if (Array.isArray(labelsRaw)) {
      for (const x of labelsRaw) {
        const n = normLabelSlice(x);
        if (n) labelsByCategory.push(n);
      }
    }
  
    const printVolumeTrend: { date: string; count: number }[] = [];
    if (Array.isArray(trendRaw)) {
      for (const x of trendRaw) {
        const p = normTrendPoint(x);
        if (p) printVolumeTrend.push(p);
      }
    }
  
    const mostUsedProducts: {
      productName: string;
      categoryName: string;
      totalPrinted: number;
      usagePercent: number;
    }[] = [];
    if (Array.isArray(productsRaw)) {
      for (const x of productsRaw) {
        const p = normTopProduct(x);
        if (p) mostUsedProducts.push(p);
      }
    }
  
    return {
      summary: {
        totalLabelsPrinted: num(s, "totalLabelsPrinted", "TotalLabelsPrinted", 0),
        totalLabelsPrintedPrevPeriod: num(
          s,
          "totalLabelsPrintedPrevPeriod",
          "TotalLabelsPrintedPrevPeriod",
          0
        ),
        totalLabelsPrintedChangeRate: num(
          s,
          "totalLabelsPrintedChangeRate",
          "TotalLabelsPrintedChangeRate",
          0
        ),
        hottestCategoryName:
          str(
            s,
            "hottestLabelCategoryName",
            "HottestLabelCategoryName",
            str(
              s,
              "mostPopularLabelCategoryName",
              "MostPopularLabelCategoryName",
              str(s, "hottestCategoryName", "HottestCategoryName", "None")
            )
          ) || "None",
        hottestCategoryCount: num(
          s,
          "hottestLabelCategoryCount",
          "HottestLabelCategoryCount",
          num(s, "hottestCategoryCount", "HottestCategoryCount", 0)
        ),
        topProductName: str(
          s,
          "topProductName",
          "TopProductName",
          str(s, "mostUsedProductName", "MostUsedProductName", "None")
        ) || "None",
        topProductCount: num(s, "topProductCount", "TopProductCount", 0),
        avgDailyPrints: num(s, "avgDailyPrints", "AvgDailyPrints", 0),
        avgDailyPrintsChangeRate: num(
          s,
          "avgDailyPrintsChangeRate",
          "AvgDailyPrintsChangeRate",
          0
        ),
      },
      labelsByCategory: labelsByCategory,
      printVolumeTrend: printVolumeTrend,
      mostUsedProducts: mostUsedProducts,
    };
  }
  
  function buildLabelReportQuery(input: LabelReportQueryInput) {
    return {
      PartnerId: input.partnerId,
      GroupId: input.groupId,
      LocationId: input.locationId,
      StartDate: input.startDate,
      EndDate: input.endDate,
      Keyword: input.keyword,
    };
  }
  
  export async function getLabelReport(
    input: LabelReportQueryInput,
    signal?: AbortSignal
  ): Promise<LabelReportData> {
    const raw = await api.requestJson<unknown>({
      path: `${REPORTS_PREFIX}/label-report`,
      method: "GET",
      query: buildLabelReportQuery(input),
      signal,
    });
    return normLabelReport(raw);
  }
  

  function normTemplatePrintStatItem(raw: unknown): TemplatePrintStatListItem {
    if (!raw || typeof raw !== "object") {
      return { templateId: null, templateName: "None", printedCount: 0 };
    }
    const o = raw as Record<string, unknown>;
    const tid = str(o, "templateId", "TemplateId", "");
    return {
      templateId: tid.trim() ? tid : null,
      templateName: str(o, "templateName", "TemplateName", "None") || "None",
      printedCount: num(o, "printedCount", "PrintedCount", 0),
    };
  }
  
  function buildTemplatePrintStatQuery(input: TemplatePrintStatQueryInput) {
    return {
      SkipCount: input.skipCount,
      MaxResultCount: input.maxResultCount,
      Sorting: input.sorting ?? "PrintedCount desc",
      PartnerId: input.partnerId,
      GroupId: input.groupId,
      LocationId: input.locationId,
      StartDate: input.startDate,
      EndDate: input.endDate,
      Keyword: input.keyword,
    };
  }
  
  /** 按模板汇总打印数量（`GET /api/app/reports/template-print-stat-list`） */
  export async function getTemplatePrintStatList(
    input: TemplatePrintStatQueryInput,
    signal?: AbortSignal,
  ): Promise<TemplatePrintStatListResult> {
    const raw = await api.requestJson<unknown>({
      path: `${REPORTS_PREFIX}/template-print-stat-list`,
      method: "GET",
      query: buildTemplatePrintStatQuery(input),
      signal,
    });
    const o = (raw && typeof raw === "object" ? raw : {}) as Record<string, unknown>;
    const itemsRaw = o.items ?? o.Items;
    const list = Array.isArray(itemsRaw) ? itemsRaw.map(normTemplatePrintStatItem) : [];
    const total = num(o, "totalCount", "TotalCount", list.length);
    return {
      items: list,
      totalCount: total,
      pageIndex: num(o, "pageIndex", "PageIndex", input.skipCount),
      pageSize: num(o, "pageSize", "PageSize", input.maxResultCount),
      totalPages: num(o, "totalPages", "TotalPages", 0),
    };
  }
  

  // --- 下载、重打：不走 JSON 解包，单独 fetch ---
  
  function joinUrl(baseUrl: string, path: string): string {
    if (!baseUrl) return path;
    const b = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
    const p = path.startsWith("/") ? path : `/${path}`;
    return `${b}${p}`;
  }
  
  function toQueryString(params: Record<string, unknown>): string {
    const qs = new URLSearchParams();
    for (const [k, v] of Object.entries(params)) {
      if (v === undefined || v === null || v === "") continue;
      if (typeof v === "boolean") {
        qs.set(k, v ? "true" : "false");
        continue;
      }
      qs.set(k, String(v));
    }
    const s = qs.toString();
    return s ? `?${s}` : "";
  }
  
  function getTokenForFetch(): string | null {
    try {
      return localStorage.getItem("access_token") ?? localStorage.getItem("token") ?? null;
    } catch {
      return null;
    }
  }
  
  function parseFileNameFromContentDisposition(h: string | null): string | null {
    if (!h) return null;
    const m = /filename\*?=(?:UTF-8''|)([^;]+)/i.exec(h);
    if (m?.[1]) return decodeURIComponent(m[1].trim().replace(/^["']|["']$/g, ""));
    return null;
  }
  
  function buildLabelReportExportQuery(input: LabelReportQueryInput) {
    return toQueryString({
      PartnerId: input.partnerId,
      GroupId: input.groupId,
      LocationId: input.locationId,
      StartDate: input.startDate,
      EndDate: input.endDate,
      Keyword: input.keyword,
    } as Record<string, unknown>);
  }
  
  function buildPrintLogExportQuery(input: ReportsPrintLogQueryInput) {
    return toQueryString({
      Sorting: input.sorting ?? "PrintedAt desc",
      PartnerId: input.partnerId,
      GroupId: input.groupId,
      LocationId: input.locationId,
      StartDate: input.startDate,
      EndDate: input.endDate,
      Keyword: input.keyword,
    } as Record<string, unknown>);
  }
  
  export async function exportPrintLogPdf(input: ReportsPrintLogQueryInput): Promise<void> {
    const baseUrl = import.meta.env.VITE_API_BASE_URL ?? "http://localhost:19001";
    const path = joinUrl(
      baseUrl,
      `/api/app${REPORTS_PREFIX}/export-print-log-pdf${buildPrintLogExportQuery(input)}`
    );
    const token = getTokenForFetch();

    const res = await fetch(path, { method: "POST", headers: token ? { Authorization: `Bearer ${token}` } : {} });

    const ct = res.headers.get("content-type") ?? "";
    if (!res.ok) {
      if (ct.includes("application/json")) {
        const payload = await res.json().catch(() => null);
        const p = payload as { error?: { message?: string } };
        const msg = p?.error?.message?.trim() || "Export failed.";
        throw new ApiError(msg, res.status, payload);
      }
      const t = await res.text().catch(() => "");
      throw new ApiError(t || "Export failed.", res.status, t);
    }
    if (ct.includes("application/json")) {
      const payload = await res.json().catch(() => null);
      const p = payload as { error?: { message?: string } };
      const msg = p?.error?.message?.trim() || "Export failed.";
      throw new ApiError(msg, res.status, payload);
    }
    const blob = await res.blob();
    const name =
      parseFileNameFromContentDisposition(res.headers.get("content-disposition")) || "print-log-export.pdf";
    const url = URL.createObjectURL(blob);
    const a = document.createElement("a");
    a.href = url;
    a.download = name;
    a.click();
    URL.revokeObjectURL(url);
  }
  

  export async function exportPrintLogExcel(input: ReportsPrintLogQueryInput, signal?: AbortSignal): Promise<void> {

    await authorizedPostBlobDownload({

      path: `${REPORTS_PREFIX}/export-print-log-excel`,
      query: {
        Sorting: input.sorting ?? "PrintedAt desc",
        PartnerId: input.partnerId,
        GroupId: input.groupId,
        LocationId: input.locationId,
        StartDate: input.startDate,
        EndDate: input.endDate,
        Keyword: input.keyword,
      },
      defaultFileName: "print-log-export.xlsx",
      signal,
    });
  }
  

  export async function exportLabelReportPdf(input: LabelReportQueryInput): Promise<void> {
    const baseUrl = import.meta.env.VITE_API_BASE_URL ?? "http://localhost:19001";
    const path = joinUrl(
      baseUrl,
      `/api/app${REPORTS_PREFIX}/export-label-report-pdf${buildLabelReportExportQuery(input)}`
    );
    const token = getTokenForFetch();

    const res = await fetch(path, { method: "POST", headers: token ? { Authorization: `Bearer ${token}` } : {} });

    const ct = res.headers.get("content-type") ?? "";
    if (!res.ok) {
      if (ct.includes("application/json")) {
        const payload = await res.json().catch(() => null);
        const p = payload as { error?: { message?: string } };
        const msg = p?.error?.message?.trim() || "Export failed.";
        throw new ApiError(msg, res.status, payload);
      }
      const t = await res.text().catch(() => "");
      throw new ApiError(t || "Export failed.", res.status, t);
    }
    if (ct.includes("application/json")) {
      const payload = await res.json().catch(() => null);
      const p = payload as { error?: { message?: string } };
      const msg = p?.error?.message?.trim() || "Export failed.";
      throw new ApiError(msg, res.status, payload);
    }
    const blob = await res.blob();
    const name =
      parseFileNameFromContentDisposition(res.headers.get("content-disposition")) || "label-report-export.pdf";
    const url = URL.createObjectURL(blob);
    const a = document.createElement("a");
    a.href = url;
    a.download = name;
    a.click();
    URL.revokeObjectURL(url);
  }
  
  export type ReprintPrintLogInput = {
    locationId: string;
    taskId: string;
    printQuantity?: number;
    clientRequestId?: string;
    printerId?: string;
    printerMac?: string;
    printerAddress?: string;
  };
  
  export async function reprintPrintLog(input: ReprintPrintLogInput, signal?: AbortSignal): Promise<unknown> {
    return api.requestJson<unknown>({
      path: `${REPORTS_PREFIX}/reprint-print-log`,
      method: "POST",
      body: {
        locationId: input.locationId,
        taskId: input.taskId,
        printQuantity: input.printQuantity ?? 1,
        clientRequestId: input.clientRequestId,
        printerId: input.printerId,
        printerMac: input.printerMac,
        printerAddress: input.printerAddress,
      },
      signal,
    });
  }