safety-eval-service-frontend/src/api/qualFiling/index.js

/** 资质备案：接口定义与前后端字段适配 */

import { declareRequest } from "@cqsjjb/jjb-dva-runtime";
import { fromPageResponse, fromSingleResponse, toPageQuery } from "../enterpriseInfo/adapter";
import { apiGet, apiPost, apiPostDelete, safeAction, safePageResult } from "../enterpriseInfo/http";
import { asId, normalizeQueryIds } from "../enterpriseInfo/idUtil";
import { formatDate, toApiDate, toDayjs } from "../../utils/dateFormat";
import { parseUploadFileList, resolveUploadFileId } from "../../utils/mockUpload";

// ─── 工具 ───

const APPLY_TYPE_APPLICATION = 1;

// ─── 字段映射：列表行 ───

export function toFilingListRow(data = {}) {
  return {
    id: asId(data.id),
    filingTerritoryCode: data.filingTerritoryCode,
    filingTerritoryName: data.filingTerritoryName,
    filingUnitName: data.filingUnitName,
    filingNo: data.filingNo || (data.id ? String(data.id) : ""),
    businessScope: data.businessScope,
    filingStatusCode: data.filingStatusCode,
    filingStatusName: data.filingStatusName,
    applyTypeCode: data.applyTypeCode,
    applyTypeName: data.applyTypeName,
    changeCount: Number(data.changeCount ?? 0),
    originFilingId: asId(data.originFilingId),
    rejectReason: data.rejectReason,
    submitTime: formatDate(data.submitTime),
    approveTime: formatDate(data.approveTime),
  };
}

// ─── 字段映射：基本表单 ───

export function toFilingBasicForm(data = {}) {
  return {
    id: asId(data.id),
    businessScope: data.businessScope,
    filingTerritoryCode: data.filingTerritoryCode,
    filingTerritoryName: data.filingTerritoryName,
    filingUnitName: data.filingUnitName,
    filingUnitTypeCode: data.filingUnitTypeCode,
    filingUnitTypeName: data.filingUnitTypeName,
    filingNo: data.filingNo,
    registerAddress: data.registerAddress,
    officeAddress: data.officeAddress,
    creditCode: data.creditCode,
    qualCertNo: data.qualCertNo,
    legalPersonPhone: data.legalPersonPhone,
    contactPhone: data.contactPhone,
    infoDisclosureUrl: data.infoDisclosureUrl,
    fixedAssetAmount: data.fixedAssetAmount,
    workplaceArea: data.workplaceArea,
    archiveRoomArea: data.archiveRoomArea,
    fulltimeEvaluatorCount: data.fulltimeEvaluatorCount,
    registeredEngineerCount: data.registeredEngineerCount,
    unitIntro: data.unitIntro,
    attachmentUrl: data.attachmentUrl,
    attachments: parseUploadFileList(data.attachmentUrl, "备案附件.pdf"),
    filingStatusCode: data.filingStatusCode,
    filingStatusName: data.filingStatusName,
    applyTypeCode: data.applyTypeCode,
    originFilingId: asId(data.originFilingId),
  };
}

export function fromFilingBasicForm(values = {}) {
  const territoryName = values.filingTerritoryName || values.filingTerritoryCode;
  const unitTypeName = values.filingUnitTypeName || values.filingUnitTypeCode;
  return normalizeQueryIds({
    id: asId(values.id),
    businessScope: values.businessScope,
    filingTerritoryCode: territoryName,
    filingTerritoryName: territoryName,
    filingUnitName: values.filingUnitName,
    filingUnitTypeCode: unitTypeName,
    filingUnitTypeName: unitTypeName,
    filingNo: values.filingNo,
    registerAddress: values.registerAddress,
    officeAddress: values.officeAddress,
    creditCode: values.creditCode,
    qualCertNo: values.qualCertNo,
    legalPersonPhone: values.legalPersonPhone,
    contactPhone: values.contactPhone,
    infoDisclosureUrl: values.infoDisclosureUrl,
    fixedAssetAmount: values.fixedAssetAmount,
    workplaceArea: values.workplaceArea,
    archiveRoomArea: values.archiveRoomArea,
    fulltimeEvaluatorCount: values.fulltimeEvaluatorCount,
    registeredEngineerCount: values.registeredEngineerCount,
    unitIntro: values.unitIntro,
    attachmentUrl: values.attachmentUrl,
  });
}

// ─── 字段映射：详情 ───

export function toFilingDetail(data = {}) {
  return {
    ...toFilingBasicForm(data),
    materials: (data.materials || []),
    commitment: data.commitment ? toFilingCommitmentForm(data.commitment, data.filingUnitName) : null,
    personnelList: (data.personnelList || []).map(toFilingPersonnelRow),
    equipmentList: (data.equipmentList || []).map(toFilingEquipmentRow),
  };
}



// ─── 字段映射：承诺书 ───

export function parseCommitmentNames(content = "", filingUnitName = "") {
  const withComma = String(content).match(/本人是(.+?)，是(.+?)法定代表人/);
  if (withComma) {
    return {
      legalRepName: withComma[1]?.trim() || "",
      filingUnitName: withComma[2]?.trim() || filingUnitName || "",
    };
  }
  const legacy = String(content).match(/本人是(.+?)是(.+?)法定代表人/);
  return {
    legalRepName: legacy?.[1]?.trim() || "",
    filingUnitName: legacy?.[2]?.trim() || filingUnitName || "",
  };
}

export function toFilingCommitmentForm(data = {}, filingUnitName = "") {
  const parsed = parseCommitmentNames(data.commitmentContent, filingUnitName);
  const legalRepPersonnelId = data.legalRepPersonnelId ? String(asId(data.legalRepPersonnelId)) : "";
  return {
    id: asId(data.id),
    filingId: asId(data.filingId),
    commitmentContent: data.commitmentContent,
    legalRepPersonnelId,
    legalRepName: data.legalRepName || parsed.legalRepName,
    filingUnitName: parsed.filingUnitName || filingUnitName,
    legalRepSignatureUrl: data.legalRepSignatureUrl,
    signDate: toDayjs(data.signDate),
    signatureFiles: parseUploadFileList(data.legalRepSignatureUrl, "电子签名.jpg"),
  };
}

export function fromFilingCommitmentForm(values = {}, filingId) {
  const personnelId = asId(values.legalRepPersonnelId);
  return {
    id: asId(values.id),
    filingId: asId(filingId),
    commitmentContent: values.commitmentContent,
    legalRepSignatureUrl: values.legalRepSignatureUrl,
    signDate: toApiDate(values.signDate),
    legalRepPersonnelId: personnelId || null,
    legalRepName: values.legalRepName || "",
  };
}

// ─── 字段映射：人员 / 装备 ───

export function toFilingPersonnelRow(data = {}) {
  return {
    id: asId(data.id),
    filingId: asId(data.filingId),
    sourcePersonnelId: asId(data.sourcePersonnelId),
    personName: data.personName,
    personTypeName: data.personTypeName,
    positionName: data.positionName,
    titleName: data.titleName,
  };
}

export function toFilingEquipmentRow(data = {}) {
  return {
    id: asId(data.id),
    filingId: asId(data.filingId),
    sourceEquipmentId: asId(data.sourceEquipmentId),
    deviceName: data.deviceName,
    deviceModel: data.deviceModel,
    manufacturer: data.manufacturer,
    calibrationReportUrl: data.calibrationReportUrl,
  };
}

// ─── 字段映射：变更历史 ───

export function toChangeHistory(data = {}) {
  return {
    changeCount: Number(data.changeCount ?? 0),
    records: (data.records || []).map((item, index) => ({
      id: asId(item.id),
      index: index + 1,
      changeItemName: item.changeItemName,
      changeTime: formatDate(item.changeTime),
      operatorName: item.operatorName,
    })),
  };
}

// ─── 查询参数映射 ───

export function toFilingPageQuery(params = {}, extra = {}) {
  const query = toPageQuery(params, {
    filingUnitName: "filingUnitName",
    filingTerritoryName: "filingTerritoryCode",
    filingNo: "filingNo",
    filingStatus: "filingStatusCode",
  });
  if (query.filingTerritoryCode) {
    query.filingTerritoryName = query.filingTerritoryCode;
  }
  delete query.orgId;
  return { ...query, ...extra };
}

// ═══════════════════════════════════════════════════
// 接口 Action
// ═══════════════════════════════════════════════════

export async function fetchQualFilingDetail(id) {
  const res = await apiGet("/safetyEval/qual-filing/detail", { id: asId(id) });
  return fromSingleResponse(res, toFilingDetail);
}

export async function fetchQualFilingChangeHistory(originFilingId) {
  const res = await apiGet("/safetyEval/qual-filing-change/history", {
    originFilingId: asId(originFilingId),
  });
  return fromSingleResponse(res, toChangeHistory);
}

export const qualFilingPage = declareRequest("qualFilingLoading", safePageResult(async (params) => {
  const query = toFilingPageQuery(params, { applyTypeCode: APPLY_TYPE_APPLICATION });
  const res = await apiGet("/safetyEval/qual-filing/page", query);
  return fromPageResponse(res, toFilingListRow);
}));

export const qualFilingFiledPage = declareRequest("qualFilingLoading", safePageResult(async (params) => {
  const query = toFilingPageQuery(params);
  const res = await apiGet("/safetyEval/qual-filing/filed/page", query);
  return fromPageResponse(res, toFilingListRow);
}));

export const qualFilingChangePage = declareRequest("qualFilingLoading", safePageResult(async (params) => {
  const query = toFilingPageQuery(params);
  const res = await apiGet("/safetyEval/qual-filing/change/page", query);
  return fromPageResponse(res, toFilingListRow);
}));

export const qualFilingDraft = declareRequest("qualFilingLoading", safeAction(async () => {
  const res = await apiPost("/safetyEval/qual-filing/draft?applyTypeCode=1", {});
  return fromSingleResponse(res, toFilingListRow);
}));

export const qualFilingFiledDraft = declareRequest("qualFilingLoading", safeAction(async () => {
  const res = await apiPost("/safetyEval/qual-filing/filed/draft", {});
  return fromSingleResponse(res, toFilingListRow);
}));

export const qualFilingSaveDraft = declareRequest("qualFilingLoading", safeAction(async (values) => {
  const res = await apiPost("/safetyEval/qual-filing/save-draft", fromFilingBasicForm(values));
  return fromSingleResponse(res, toFilingListRow);
}));

export const qualFilingSubmit = declareRequest("qualFilingLoading", safeAction(async ({ id }) => {
  const res = await apiPost(`/safetyEval/qual-filing/submit?id=${encodeURIComponent(asId(id))}`, {});
  return fromSingleResponse(res, toFilingListRow);
}));

export const qualFilingDelete = declareRequest("qualFilingLoading", safeAction(async ({ id }) => {
  return apiPostDelete("/safetyEval/qual-filing/delete", id);
}));

export const qualFilingMaterialInitTemplate = declareRequest("qualFilingLoading", safeAction(async ({ filingId }) => {
  return apiPost(`/safetyEval/qual-filing-material/init-template?filingId=${encodeURIComponent(asId(filingId))}`, {});
}));

export const qualFilingMaterialUpload = declareRequest("qualFilingLoading", safeAction(async ({ id, attachmentUrl, files }) => {
  const url = attachmentUrl || resolveUploadFileId(files);
  const res = await apiPost("/safetyEval/qual-filing-material/upload", { id: asId(id), attachmentUrl: url });
  return fromSingleResponse(res);
}));

export const qualFilingUploadAttachment = declareRequest("qualFilingLoading", safeAction(async ({ id, attachmentUrl, files }) => {
  const url = attachmentUrl || resolveUploadFileId(files);
  const res = await apiPost("/safetyEval/qual-filing/upload-attachment", { id: asId(id), attachmentUrl: url });
  return fromSingleResponse(res, toFilingListRow);
}));

export const qualFilingCommitmentSaveOrUpdate = declareRequest("qualFilingLoading", safeAction(async (values) => {
  const payload = fromFilingCommitmentForm(values, values.filingId);
  const res = await apiPost("/safetyEval/qual-filing-commitment/save-or-update", payload);
  return fromSingleResponse(res);
}));

export const qualFilingCommitmentUploadSignature = declareRequest("qualFilingLoading", safeAction(async ({ id, attachmentUrl, files }) => {
  const url = attachmentUrl || resolveUploadFileId(files);
  const res = await apiPost("/safetyEval/qual-filing-commitment/upload-signature", { id: asId(id), attachmentUrl: url });
  return fromSingleResponse(res);
}));

export const qualFilingPersonnelBatchAdd = declareRequest("qualFilingLoading", safeAction(async ({ filingId, sourcePersonnelIds }) => {
  const res = await apiPost("/safetyEval/qual-filing-personnel/batch-add-from-org", {
    filingId: asId(filingId),
    sourcePersonnelIds: (sourcePersonnelIds || []).map(asId),
  });
  return res;
}));

export const qualFilingPersonnelDelete = declareRequest("qualFilingLoading", safeAction(async ({ id }) => {
  return apiPostDelete("/safetyEval/qual-filing-personnel/delete", id);
}));

export const qualFilingEquipmentBatchAdd = declareRequest("qualFilingLoading", safeAction(async ({ filingId, sourceEquipmentIds }) => {
  const res = await apiPost("/safetyEval/qual-filing-equipment/batch-add-from-org", {
    filingId: asId(filingId),
    sourceEquipmentIds: (sourceEquipmentIds || []).map(asId),
  });
  return res;
}));

export const qualFilingEquipmentUploadCalibration = declareRequest("qualFilingLoading", safeAction(async ({ id, attachmentUrl, files }) => {
  const url = attachmentUrl || resolveUploadFileId(files);
  const res = await apiPost("/safetyEval/qual-filing-equipment/upload-calibration", { id: asId(id), attachmentUrl: url });
  return fromSingleResponse(res);
}));

export const qualFilingEquipmentDelete = declareRequest("qualFilingLoading", safeAction(async ({ id }) => {
  return apiPostDelete("/safetyEval/qual-filing-equipment/delete", id);
}));

export const qualFilingChangeStart = declareRequest("qualFilingLoading", safeAction(async ({ originFilingId }) => {
  const res = await apiPost(
    `/safetyEval/qual-filing-change/start?originFilingId=${encodeURIComponent(asId(originFilingId))}`,
    {},
  );
  return fromSingleResponse(res, (data) => ({ draftFilingId: asId(data) }));
}));

export const qualFilingChangeSubmit = declareRequest("qualFilingLoading", safeAction(async ({ draftFilingId }) => {
  return apiPost("/safetyEval/qual-filing-change/submit", { draftFilingId: asId(draftFilingId) });
}));

export const submitQualFiling = declareRequest(
  "qualFilingSubmitLoading",
  "Post > @/safetyEval/qual-filing/aggregationSaveOrEdit",
);