src/api/aftersales/compensation.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,86 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace AfterSaleCompensationApi {
  /** å”®åŽèµ”付/服务补偿单 */
  export interface Compensation {
    id?: number;
    compensationNo?: string; // èµ”付单号
    compensationType?: number; // èµ”付类型：1故障赔付 2服务补偿
    ticketId?: number; // å…³è”售后工单编号
    customerId?: number; // å®¢æˆ·ç¼–号
    customerName?: string; // å®¢æˆ·åç§°
    saleOrderId?: number; // å…³è”销售订单编号
    amount?: number; // èµ”付金额
    payee?: string; // èµ”付对象
    reason?: string; // èµ”付原因
    auditStatus?: number; // å®¡æ‰¹çŠ¶æ€ï¼š0未提交 10审批中 20审核通过 30审核不通过 40已取消
    auditStatusName?: string; // å®¡æ‰¹çŠ¶æ€åç§°
    processInstanceId?: string; // å®¡æ‰¹æµç¨‹å®žä¾‹ç¼–号
    auditUserId?: number; // å®¡æ ¸äºº
    auditTime?: string; // å®¡æ ¸æ—¶é—´
    auditRemark?: string; // å®¡æ ¸å¤‡æ³¨
    payStatus?: number; // æ”¯ä»˜çŠ¶æ€ï¼ˆè´¦åŠ¡è”动预留）
    remark?: string; // å¤‡æ³¨
    createTime?: string;
  }

  /** å®¡æ‰¹å‚æ•° */
  export interface AuditReq {
    id: number;
    auditStatus: number; // 20通过 30驳回
    remark?: string;
  }
}

/** åˆ›å»ºèµ”付/服务补偿单 */
export function createCompensation(data: AfterSaleCompensationApi.Compensation) {
  return requestClient.post<number>('/aftersales/compensation/create', data);
}

/** æ›´æ–°èµ”付/服务补偿单 */
export function updateCompensation(data: AfterSaleCompensationApi.Compensation) {
  return requestClient.put<boolean>('/aftersales/compensation/update', data);
}

/** åˆ é™¤èµ”付/服务补偿单 */
export function deleteCompensation(id: number) {
  return requestClient.delete<boolean>('/aftersales/compensation/delete', {
    params: { id },
  });
}

/** èŽ·å–赔付/服务补偿单 */
export function getCompensation(id: number) {
  return requestClient.get<AfterSaleCompensationApi.Compensation>(
    `/aftersales/compensation/get?id=${id}`,
  );
}

/** èŽ·å–赔付/服务补偿单分页 */
export function getCompensationPage(params: PageParam) {
  return requestClient.get<PageResult<AfterSaleCompensationApi.Compensation>>(
    '/aftersales/compensation/page',
    { params },
  );
}

/** æäº¤èµ”付/服务补偿单审批 */
export function submitCompensation(id: number, processDefinitionKey: string) {
  return requestClient.put<boolean>('/aftersales/compensation/submit', null, {
    params: { id, processDefinitionKey },
  });
}

/** å®¡æ‰¹èµ”付/服务补偿单 */
export function auditCompensation(data: AfterSaleCompensationApi.AuditReq) {
  return requestClient.put<boolean>('/aftersales/compensation/audit', data);
}

/** èŽ·å–赔付/服务补偿单审批流程定义列表 */
export function getApproveProcessList() {
  return requestClient.get<{ id: string; name: string; version: number; key: string }[]>(
    '/aftersales/compensation/approve-process-list',
  );
}

 src/api/bi/decision/alert.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,68 @@
import { requestClient } from '#/api/request';

export namespace DecisionAlertApi {
  export interface AlertRecord {
    id: number;
    ruleId: number;
    kpiCode: string;
    kpiName: string;
    actualValue: number;
    thresholdValue: number;
    severity: number;
    alertMessage: string;
    status: number;
    handlerId?: number;
    handleTime?: string;
    handleRemark?: string;
    triggeredTime: string;
    createTime: string;
  }

  export interface AlertRule {
    id?: number;
    kpiId: number;
    name: string;
    severity: number;
    comparisonOperator: string;
    thresholdValue: number;
    notificationType?: string;
    enabled?: number;
    remark?: string;
  }
}

export function getAlertPage(params: Record<string, unknown>) {
  return requestClient.get('/bi/decision/alert/page', { params });
}

export function getUnprocessedCount() {
  return requestClient.get<number>('/bi/decision/alert/unprocessed-count');
}

export function confirmAlert(id: number) {
  return requestClient.post(`/bi/decision/alert/confirm/${id}`);
}

export function handleAlert(id: number, handleRemark?: string) {
  return requestClient.post('/bi/decision/alert/handle', { id, handleRemark });
}

export function getAlertRulePage(params: Record<string, unknown>) {
  return requestClient.get('/bi/decision/alert-rule/page', { params });
}

export function getAlertRule(id: number) {
  return requestClient.get<DecisionAlertApi.AlertRule>('/bi/decision/alert-rule/get', { params: { id } });
}

export function createAlertRule(data: DecisionAlertApi.AlertRule) {
  return requestClient.post('/bi/decision/alert-rule/create', data);
}

export function updateAlertRule(data: DecisionAlertApi.AlertRule) {
  return requestClient.put('/bi/decision/alert-rule/update', data);
}

export function deleteAlertRule(id: number) {
  return requestClient.delete('/bi/decision/alert-rule/delete', { params: { id } });
}

 src/api/bi/decision/forecast.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,41 @@
import { requestClient } from '#/api/request';

export namespace DecisionForecastApi {
  export interface ForecastItem {
    id: number;
    forecastCode: string;
    forecastName: string;
    pointTime: string;
    forecastValue: number;
    actualValue?: number;
    lowerBound?: number;
    upperBound?: number;
    confidenceLevel?: number;
    modelVersion?: string;
    dimension?: string;
    dimensionValue?: string;
  }
}

export function getForecastList(forecastCode: string, params?: Record<string, unknown>) {
  return requestClient.get<DecisionForecastApi.ForecastItem[]>('/bi/decision/forecast/list', {
    params: { forecastCode, ...params },
  });
}

export function generateForecast(forecastCode: string) {
  return requestClient.post('/bi/decision/forecast/generate', null, {
    params: { forecastCode },
  });
}

export function generateForecastWorkOrder(data: {
  forecastId: number;
  workOrderName?: string;
  workOrderType: number;
  requestDate?: string;
  quantity: number;
  remark?: string;
}) {
  return requestClient.post<number>('/bi/decision/forecast/generate-work-order', data);
}

 src/api/bi/decision/kpi.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,77 @@
import { requestClient } from '#/api/request';

export namespace DecisionKpiApi {
  export interface KpiItem {
    code: string;
    name: string;
    category: string;
    unit: string;
    value: number;
    alertStatus: 'normal' | 'warn' | 'critical';
    chartType: string;
    status: number;
  }

  export interface KpiOverview {
    kpis: KpiItem[];
    total: number;
  }

  export interface KpiDefinition {
    id?: number;
    code: string;
    name: string;
    category: string;
    unit?: string;
    dataSource?: string;
    querySql?: string;
    chartType?: string;
    thresholdWarn?: number;
    thresholdCritical?: number;
    comparisonOperator?: string;
    refreshInterval?: number;
    sort?: number;
    status?: number;
    remark?: string;
  }
}

export function getKpiOverview() {
  return requestClient.get<DecisionKpiApi.KpiOverview>('/bi/decision/kpi/overview');
}

export function getKpiDetail(kpiCode: string) {
  return requestClient.get<Record<string, unknown>>(`/bi/decision/kpi/detail/${kpiCode}`);
}

export function getKpiByCategory(category: string) {
  return requestClient.get<Record<string, unknown>>(`/bi/decision/kpi/category/${category}`);
}

export function refreshKpi(kpiCode: string) {
  return requestClient.post<number>(`/bi/decision/kpi/refresh/${kpiCode}`);
}

export function getKpiDefinitionPage(params: Record<string, unknown>) {
  return requestClient.get('/bi/decision/kpi-definition/page', { params });
}

export function getKpiDefinitionList() {
  return requestClient.get('/bi/decision/kpi-definition/list-all');
}

export function getKpiDefinition(id: number) {
  return requestClient.get<DecisionKpiApi.KpiDefinition>('/bi/decision/kpi-definition/get', { params: { id } });
}

export function createKpiDefinition(data: DecisionKpiApi.KpiDefinition) {
  return requestClient.post('/bi/decision/kpi-definition/create', data);
}

export function updateKpiDefinition(data: DecisionKpiApi.KpiDefinition) {
  return requestClient.put('/bi/decision/kpi-definition/update', data);
}

export function deleteKpiDefinition(id: number) {
  return requestClient.delete('/bi/decision/kpi-definition/delete', { params: { id } });
}

 src/api/crm/cancellation/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,77 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace CrmCancellationApi {
  export interface Cancellation {
    id?: number;
    cancellationNo?: string;
    customerId?: number;
    customerName?: string;
    contractId?: number;
    contractNo?: string;
    cancellationType?: string;
    cancelReason?: string;
    expectedCancelDate?: string;
    actualCancelDate?: string;
    refundAmount?: number;
    applyUserId?: number;
    applyUserName?: string;
    applyTime?: string;
    auditStatus?: number;
    processInstanceId?: string;
    remark?: string;
    createTime?: string;
  }
  export interface PageParams extends PageParam {
    cancellationNo?: string;
    customerId?: number;
    cancellationType?: string;
    auditStatus?: number;
  }
}

/** æŸ¥è¯¢é”€æˆ·ç”³è¯·åˆ†é¡µ */
export function getCancellationPage(
  params: CrmCancellationApi.PageParams,
) {
  return requestClient.get<PageResult<CrmCancellationApi.Cancellation>>(
    '/crm/cancellation/page',
    { params },
  );
}

/** æŸ¥è¯¢é”€æˆ·ç”³è¯·è¯¦æƒ… */
export function getCancellation(id: number) {
  return requestClient.get<CrmCancellationApi.Cancellation>(
    `/crm/cancellation/get?id=${id}`,
  );
}

/** æ–°å¢žé”€æˆ·ç”³è¯· */
export function createCancellation(data: CrmCancellationApi.Cancellation) {
  return requestClient.post('/crm/cancellation/create', data);
}

/** ä¿®æ”¹é”€æˆ·ç”³è¯· */
export function updateCancellation(data: CrmCancellationApi.Cancellation) {
  return requestClient.put('/crm/cancellation/update', data);
}

/** å®¡æ‰¹é”€æˆ·ç”³è¯· */
export function auditCancellation(data: {
  id: number;
  auditStatus: number;
}) {
  return requestClient.put('/crm/cancellation/audit', data);
}

/** åˆ é™¤é”€æˆ·ç”³è¯· */
export function deleteCancellation(id: number) {
  return requestClient.delete(`/crm/cancellation/delete?id=${id}`);
}

/** å¯¼å‡ºé”€æˆ·ç”³è¯· */
export function exportCancellation(params: Record<string, unknown>) {
  return requestClient.download('/crm/cancellation/export-excel', { params });
}

 src/api/crm/contract-command/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,66 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace CrmContractCommandApi {
  export interface ContractCommand {
    id?: number;
    contractId?: number;
    contractNo?: string;
    commandType?: string;
    targetModule?: string;
    targetId?: number;
    bizNo?: string;
    operatorId?: number;
    operatorName?: string;
    operateTime?: string;
    status?: number;
    remark?: string;
    createTime?: string;
  }
  export interface PageParams extends PageParam {
    contractId?: number;
    commandType?: string;
    status?: number;
    bizNo?: string;
  }
}

/** æŸ¥è¯¢åˆåŒæŒ‡ä»¤åˆ†é¡µ */
export function getContractCommandPage(
  params: CrmContractCommandApi.PageParams,
) {
  return requestClient.get<PageResult<CrmContractCommandApi.ContractCommand>>(
    '/crm/contract-command/page',
    { params },
  );
}

/** æ–°å¢žåˆåŒæŒ‡ä»¤ */
export function createContractCommand(
  data: CrmContractCommandApi.ContractCommand,
) {
  return requestClient.post('/crm/contract-command/create', data);
}

/** æ›´æ–°åˆåŒæŒ‡ä»¤ */
export function updateContractCommand(
  data: CrmContractCommandApi.ContractCommand,
) {
  return requestClient.put('/crm/contract-command/update', data);
}

/** æ‰§è¡ŒåˆåŒæŒ‡ä»¤ */
export function executeContractCommand(id: number) {
  return requestClient.put(`/crm/contract-command/execute?id=${id}`);
}

/** å–消合同指令 */
export function cancelContractCommand(id: number) {
  return requestClient.put(`/crm/contract-command/cancel?id=${id}`);
}

/** åˆ é™¤åˆåŒæŒ‡ä»¤ */
export function deleteContractCommand(id: number) {
  return requestClient.delete(`/crm/contract-command/delete?id=${id}`);
}

 src/api/crm/contract/index.ts

@@ -43,6 +43,14 @@
    contactName?: string;
    orderId?: number; // å…³è” ERP é”€å”®è®¢å•ç¼–号
    orderNo?: string; // ERP é”€å”®è®¢å•å•å·
    contractType?: string; // åˆåŒç±»åž‹ï¼ˆä¾›ç”¨ç”µ/能源服务等）
    voltageLevel?: string; // ç”µåŽ‹ç­‰çº§
    electricityType?: string; // ç”¨ç”µç±»åž‹
    contractCapacity?: number; // åˆåŒå®¹é‡ï¼ˆkVA）
    tariffMode?: string; // ç”µä»·æ¨¡å¼
    meterMode?: string; // è®¡é‡æ–¹å¼
    payCycle?: number; // ç¼´è´¹å‘¨æœŸï¼ˆæœˆï¼‰
    commandCount?: number; // æŒ‡ä»¤æ•°é‡
  }

  /** åˆåŒäº§å“ä¿¡æ¯ */

 src/api/crm/credit-rating/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,63 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace CrmCreditRatingApi {
  export interface CreditRating {
    id?: number;
    customerId?: number;
    customerName?: string;
    level?: string;
    score?: number;
    evalType?: string;
    evalReason?: string;
    operatorId?: number;
    operatorName?: string;
    operateTime?: string;
    validUntil?: string;
    remark?: string;
    createTime?: string;
  }
  export interface PageParams extends PageParam {
    customerId?: number;
    level?: string;
    evalType?: string;
  }
}

/** æŸ¥è¯¢ä¿¡ç”¨è¯„级分页 */
export function getCreditRatingPage(
  params: CrmCreditRatingApi.PageParams,
) {
  return requestClient.get<PageResult<CrmCreditRatingApi.CreditRating>>(
    '/crm/credit-rating/page',
    { params },
  );
}

/** æŸ¥è¯¢ä¿¡ç”¨è¯„级详情 */
export function getCreditRating(id: number) {
  return requestClient.get<CrmCreditRatingApi.CreditRating>(
    `/crm/credit-rating/get?id=${id}`,
  );
}

/** æ–°å¢žä¿¡ç”¨è¯„级 */
export function createCreditRating(data: CrmCreditRatingApi.CreditRating) {
  return requestClient.post('/crm/credit-rating/create', data);
}

/** ä¿®æ”¹ä¿¡ç”¨è¯„级 */
export function updateCreditRating(data: CrmCreditRatingApi.CreditRating) {
  return requestClient.put('/crm/credit-rating/update', data);
}

/** åˆ é™¤ä¿¡ç”¨è¯„级 */
export function deleteCreditRating(id: number) {
  return requestClient.delete(`/crm/credit-rating/delete?id=${id}`);
}

/** å¯¼å‡ºä¿¡ç”¨è¯„级 */
export function exportCreditRating(params: Record<string, unknown>) {
  return requestClient.download('/crm/credit-rating/export-excel', { params });
}

 src/api/crm/customer/index.ts

@@ -36,6 +36,11 @@
    createTime: Date; // åˆ›å»ºæ—¶é—´
    updateTime: Date; // æ›´æ–°æ—¶é—´
    poolDay?: number; // è·ç¦»è¿›å…¥å…¬æµ·å¤©æ•°
    customerType?: string; // å®¢æˆ·åˆ†ç±»ï¼ˆæ”¿ä¼/工业/居民等）
    creditLevel?: string; // å½“前信用等级
    creditScore?: number; // å½“前信用分
    overdueAmount?: number; // æ¬ è´¹é‡‘额（未回款+逾期）
    overdueCount?: number; // æ¬ è´¹ç¬”æ•°
  }

  /** å®¢æˆ·å¯¼å…¥è¯·æ±‚ */

 src/api/crm/refund/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,68 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace CrmRefundApi {
  export interface Refund {
    id?: number;
    refundNo?: string;
    customerId?: number;
    customerName?: string;
    contractId?: number;
    contractNo?: string;
    refundType?: string;
    refundAmount?: number;
    refundReason?: string;
    applyUserId?: number;
    applyUserName?: string;
    applyTime?: string;
    auditStatus?: number;
    processInstanceId?: string;
    remark?: string;
    createTime?: string;
  }
  export interface PageParams extends PageParam {
    refundNo?: string;
    customerId?: number;
    refundType?: string;
    auditStatus?: number;
  }
}

/** æŸ¥è¯¢é€€è´¹å•åˆ†é¡µ */
export function getRefundPage(params: CrmRefundApi.PageParams) {
  return requestClient.get<PageResult<CrmRefundApi.Refund>>(
    '/crm/refund/page',
    { params },
  );
}

/** æŸ¥è¯¢é€€è´¹å•è¯¦æƒ… */
export function getRefund(id: number) {
  return requestClient.get<CrmRefundApi.Refund>(`/crm/refund/get?id=${id}`);
}

/** æ–°å¢žé€€è´¹å• */
export function createRefund(data: CrmRefundApi.Refund) {
  return requestClient.post('/crm/refund/create', data);
}

/** ä¿®æ”¹é€€è´¹å• */
export function updateRefund(data: CrmRefundApi.Refund) {
  return requestClient.put('/crm/refund/update', data);
}

/** å®¡æ‰¹é€€è´¹å• */
export function auditRefund(data: { id: number; auditStatus: number }) {
  return requestClient.put('/crm/refund/audit', data);
}

/** åˆ é™¤é€€è´¹å• */
export function deleteRefund(id: number) {
  return requestClient.delete(`/crm/refund/delete?id=${id}`);
}

/** å¯¼å‡ºé€€è´¹å• */
export function exportRefund(params: Record<string, unknown>) {
  return requestClient.download('/crm/refund/export-excel', { params });
}

 src/api/crm/saleQuotation/index.ts

@@ -34,6 +34,13 @@
    createTime?: Date;
    updateTime?: Date;
    items?: SaleQuotationItem[];
    quotationType?: string; // æŠ¥ä»·ç±»åž‹ï¼ˆgeneral/power/energy）
    capacity?: number; // åˆåŒå®¹é‡ï¼ˆkVA）
    maxDemand?: number; // æœ€å¤§éœ€é‡ï¼ˆkW）
    unitPrice?: number; // ç”µåº¦å•ä»·ï¼ˆå…ƒ/kWh）
    tariffMode?: string; // ç”µä»·æ¨¡å¼
    powerFactorFee?: number; // åŠ›è°ƒç”µè´¹ï¼ˆå…ƒï¼‰
    billingCycle?: number; // ç»“算周期（月）
  }

  /** æŠ¥ä»·å•ç‰©æ–™æ˜Žç»† */

 src/api/erp/purchase/plan/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,102 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace ErpPurchasePlanApi {
  /** é‡‡è´­è®¡åˆ’信息 */
  export interface PurchasePlan {
    id?: number; // ç¼–号
    no?: string; // è®¡åˆ’单号
    name?: string; // è®¡åˆ’名称
    status?: number; // çŠ¶æ€ï¼š0未提交 10审批中 20审核通过 30审核不通过 40已取消
    processInstanceId?: string; // å·¥ä½œæµç¼–号
    demandSource?: number; // éœ€æ±‚来源：1库存预警 2运维/生产计划
    demandSourceName?: string; // éœ€æ±‚来源名称
    planDate?: string; // è®¡åˆ’日期
    planUserId?: number; // ç¼–制人编号
    planUserName?: string; // ç¼–制人姓名
    planDeptId?: number; // ç¼–制部门编号
    planDeptName?: string; // ç¼–制部门名称
    supplierId?: number; // ä¾›åº”商编号
    supplierName?: string; // ä¾›åº”商名称
    totalCount?: number; // åˆè®¡æ•°é‡
    generatedFlag?: boolean; // æ˜¯å¦å·²ç”Ÿæˆé‡‡è´­ç”³è¯·
    remark?: string; // å¤‡æ³¨
    productNames?: string; // äº§å“åç§°åˆ—表
    items?: PurchasePlanItem[]; // è®¡åˆ’明细
    createTime?: string; // åˆ›å»ºæ—¶é—´
  }

  /** é‡‡è´­è®¡åˆ’明细 */
  export interface PurchasePlanItem {
    id?: number; // ç¼–号
    productId: number; // äº§å“ç¼–号
    productName?: string; // äº§å“åç§°
    productUnitId?: number; // äº§å“å•ä½ç¼–号
    productUnitName?: string; // äº§å“å•ä½åç§°
    count: number; // è®¡åˆ’采购数量
    demandTime?: string; // éœ€æ±‚日期
    remark?: string; // å¤‡æ³¨
  }
}

/** åˆ›å»ºé‡‡è´­è®¡åˆ’ */
export function createPurchasePlan(data: ErpPurchasePlanApi.PurchasePlan) {
  return requestClient.post('/erp/purchase-plan/create', data);
}

/** æ›´æ–°é‡‡è´­è®¡åˆ’ */
export function updatePurchasePlan(data: ErpPurchasePlanApi.PurchasePlan) {
  return requestClient.put('/erp/purchase-plan/update', data);
}

/** æäº¤é‡‡è´­è®¡åˆ’审批 */
export function submitPurchasePlan(id: number, processDefinitionKey: string) {
  return requestClient.put('/erp/purchase-plan/submit', null, {
    params: { id, processDefinitionKey },
  });
}

/** æ ¹æ®åº“存预警生成采购计划 */
export function generatePlanFromStockAlert(params: { name?: string; supplierId?: number }) {
  return requestClient.post<number>('/erp/purchase-plan/generate-from-stock-alert', null, {
    params,
  });
}

/** ç”Ÿæˆé‡‡è´­ç”³è¯· */
export function generatePurchaseRequests(id: number) {
  return requestClient.post<number[]>('/erp/purchase-plan/generate-requests', null, {
    params: { id },
  });
}

/** åˆ é™¤é‡‡è´­è®¡åˆ’ */
export function deletePurchasePlan(ids: number[]) {
  return requestClient.delete('/erp/purchase-plan/delete', { params: { ids: ids.join(',') } });
}

/** èŽ·å–采购计划详情 */
export function getPurchasePlan(id: number) {
  return requestClient.get<ErpPurchasePlanApi.PurchasePlan>(
    `/erp/purchase-plan/get?id=${id}`,
  );
}

/** èŽ·å–采购计划分页 */
export function getPurchasePlanPage(params: PageParam) {
  return requestClient.get<PageResult<ErpPurchasePlanApi.PurchasePlan>>(
    '/erp/purchase-plan/page',
    { params },
  );
}

/** å¯¼å‡ºé‡‡è´­è®¡åˆ’ Excel */
export function exportPurchasePlan(params: any) {
  return requestClient.download('/erp/purchase-plan/export-excel', { params });
}

/** èŽ·å–审批流程列表 */
export function getApproveProcessList(id: number) {
  return requestClient.get(`/erp/purchase-plan/approve-process-list`, { params: { id } });
}

 src/api/hrm/certificate/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,52 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace HrmCertificateApi {
  /** è¯ä¹¦èµ„è´¨ */
  export interface Certificate {
    id?: number;
    employeeId?: number; // å‘˜å·¥ç¼–号
    employeeName?: string; // å‘˜å·¥å§“名
    certType?: number; // è¯ä¹¦ç±»åž‹ï¼š1特种作业 2从业资质 3技能等级 4安全培训
    certTypeName?: string; // è¯ä¹¦ç±»åž‹åç§°
    certName?: string; // è¯ä¹¦åç§°
    certNo?: string; // è¯ä¹¦ç¼–号
    issueOrg?: string; // å‘证机构
    issueDate?: string; // å‘证日期
    expireDate?: string; // æœ‰æ•ˆæœŸè‡³
    expireStatus?: number; // åˆ°æœŸçŠ¶æ€ï¼š0有效 1即将到期 2已过期
    remark?: string; // å¤‡æ³¨
    createTime?: string;
  }
}

/** åˆ›å»ºè¯ä¹¦èµ„è´¨ */
export function createCertificate(data: HrmCertificateApi.Certificate) {
  return requestClient.post('/hrm/certificate/create', data);
}

/** æ›´æ–°è¯ä¹¦èµ„è´¨ */
export function updateCertificate(data: HrmCertificateApi.Certificate) {
  return requestClient.put('/hrm/certificate/update', data);
}

/** åˆ é™¤è¯ä¹¦èµ„è´¨ */
export function deleteCertificate(ids: number[]) {
  return requestClient.delete('/hrm/certificate/delete', { params: { ids: ids.join(',') } });
}

/** èŽ·å–证书资质详情 */
export function getCertificate(id: number) {
  return requestClient.get<HrmCertificateApi.Certificate>(
    `/hrm/certificate/get?id=${id}`,
  );
}

/** èŽ·å–证书资质分页 */
export function getCertificatePage(params: PageParam) {
  return requestClient.get<PageResult<HrmCertificateApi.Certificate>>(
    '/hrm/certificate/page',
    { params },
  );
}

 src/api/hrm/performance-appraise/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,156 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace HrmPerformanceAppraiseApi {
  /** è€ƒæ ¸æŒ‡æ ‡ */
  export interface AppraiseItem {
    id?: number;
    appraiseId?: number;
    itemName?: string; // æŒ‡æ ‡åç§°
    weight?: number; // æƒé‡
    scoringStandard?: string; // è¯„分标准
    scorerType?: number; // è¯„分人类型：1自评 2上级评
    sort?: number; // æŽ’序
    /** è¯„分时回填用 */
    selfScore?: number;
    superiorScore?: number;
  }

  /** è€ƒæ ¸ç»“果指标明细 */
  export interface ResultItem {
    id?: number;
    resultId?: number;
    itemId?: number;
    itemName?: string;
    weight?: number;
    selfScore?: number;
    superiorScore?: number;
  }

  /** ç»©æ•ˆè€ƒæ ¸æ–¹æ¡ˆ */
  export interface Appraise {
    id?: number;
    name?: string; // æ–¹æ¡ˆåç§°
    periodType?: number; // è€ƒæ ¸å‘¨æœŸç±»åž‹ï¼š1月度 2季度 3年度
    period?: string; // è€ƒæ ¸å‘¨æœŸæè¿°
    scopeType?: number; // è€ƒæ ¸èŒƒå›´ç±»åž‹ï¼š1全部员工 2指定班组
    status?: number; // æ–¹æ¡ˆçŠ¶æ€ï¼š0草稿 10已发布 20进行中 30已完成
    statusName?: string;
    auditStatus?: number; // å®¡æ‰¹çŠ¶æ€ï¼š0未提交 10审批中 20通过 30驳回 40已取消
    auditStatusName?: string;
    processInstanceId?: string;
    auditUserId?: number;
    auditTime?: string;
    auditRemark?: string;
    remark?: string;
    itemCount?: number; // è€ƒæ ¸æŒ‡æ ‡æ•°
    resultCount?: number; // å·²è¯„分人数
    createTime?: string;
  }

  /** è€ƒæ ¸ç»“果（按员工聚合） */
  export interface AppraiseResult {
    id?: number;
    appraiseId?: number;
    employeeId?: number;
    employeeName?: string;
    selfScore?: number; // è‡ªè¯„总分
    superiorScore?: number; // ä¸Šçº§è¯„总分
    finalScore?: number; // ç»¼åˆå¾—分
    grade?: number; // æ¡£çº§ï¼š1优秀 2良好 3合格 4待改进
    comment?: string; // è¯„语
    items?: ResultItem[]; // æŒ‡æ ‡è¯„分明细
  }
}

/** åˆ›å»ºç»©æ•ˆè€ƒæ ¸æ–¹æ¡ˆ */
export function createAppraise(data: HrmPerformanceAppraiseApi.Appraise) {
  return requestClient.post<number>('/hrm/performance-appraise/create', data);
}

/** æ›´æ–°ç»©æ•ˆè€ƒæ ¸æ–¹æ¡ˆ */
export function updateAppraise(data: HrmPerformanceAppraiseApi.Appraise) {
  return requestClient.put<boolean>('/hrm/performance-appraise/update', data);
}

/** åˆ é™¤ç»©æ•ˆè€ƒæ ¸æ–¹æ¡ˆ */
export function deleteAppraise(ids: number[]) {
  return requestClient.delete<boolean>('/hrm/performance-appraise/delete', {
    params: { ids: ids.join(',') },
  });
}

/** èŽ·å–绩效考核方案 */
export function getAppraise(id: number) {
  return requestClient.get<HrmPerformanceAppraiseApi.Appraise>(
    `/hrm/performance-appraise/get?id=${id}`,
  );
}

/** èŽ·å–绩效考核方案分页 */
export function getAppraisePage(params: PageParam) {
  return requestClient.get<PageResult<HrmPerformanceAppraiseApi.Appraise>>(
    '/hrm/performance-appraise/page',
    { params },
  );
}

/** èŽ·å–考核指标列表 */
export function getAppraiseItemList(appraiseId: number) {
  return requestClient.get<HrmPerformanceAppraiseApi.AppraiseItem[]>(
    `/hrm/performance-appraise/item-list?appraiseId=${appraiseId}`,
  );
}

/** ä¿å­˜è€ƒæ ¸æŒ‡æ ‡ï¼ˆæ•´è¡¨æ›¿æ¢ï¼‰ */
export function saveAppraiseItems(data: {
  appraiseId: number;
  items: HrmPerformanceAppraiseApi.AppraiseItem[];
}) {
  return requestClient.post<boolean>('/hrm/performance-appraise/item-save', data);
}

/** æäº¤ç»©æ•ˆè€ƒæ ¸æ–¹æ¡ˆå®¡æ‰¹ */
export function submitAppraise(id: number, processDefinitionKey: string) {
  return requestClient.post<boolean>('/hrm/performance-appraise/submit', null, {
    params: { id, processDefinitionKey },
  });
}

/** å®¡æ‰¹ç»©æ•ˆè€ƒæ ¸æ–¹æ¡ˆ */
export function auditAppraise(data: { id: number; auditStatus: number; remark?: string }) {
  return requestClient.put<boolean>('/hrm/performance-appraise/audit', data);
}

/** èŽ·å–绩效考核方案审批流程定义列表 */
export function getAppraiseProcessList() {
  return requestClient.get<{ id: string; name: string; version: number; key: string }[]>(
    '/hrm/performance-appraise/approve-process-list',
  );
}

/** èŽ·å–考核结果分页 */
export function getAppraiseResultPage(params: PageParam) {
  return requestClient.get<PageResult<HrmPerformanceAppraiseApi.AppraiseResult>>(
    '/hrm/performance-appraise/result-page',
    { params },
  );
}

/** ä¿å­˜å‘˜å·¥è€ƒæ ¸ç»“果（自动计算综合得分与档级） */
export function saveAppraiseResult(data: {
  appraiseId: number;
  employeeId: number;
  comment?: string;
  items: { itemId: number; selfScore?: number; superiorScore?: number }[];
}) {
  return requestClient.post<boolean>('/hrm/performance-appraise/result-save', data);
}

/** èŽ·å–员工考核结果（含指标明细） */
export function getAppraiseResult(appraiseId: number, employeeId: number) {
  return requestClient.get<HrmPerformanceAppraiseApi.AppraiseResult>(
    `/hrm/performance-appraise/result?appraiseId=${appraiseId}&employeeId=${employeeId}`,
  );
}

 src/api/hrm/work-hour-statistics/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,55 @@
import { requestClient } from '#/api/request';

export namespace HrmWorkHourStatisticsApi {
  /** å‘˜å·¥å·¥æ—¶ï¼ˆè€ƒå‹¤å£å¾„） */
  export interface EmployeeWorkHour {
    userId?: number;
    userName?: string;
    deptId?: number;
    deptName?: string;
    workDays?: number; // å‡ºå‹¤å¤©æ•°
    workHours?: number; // æ­£å¸¸å·¥æ—¶ï¼ˆäººæ—¶ï¼‰
    overtimeHours?: number; // åŠ ç­å·¥æ—¶ï¼ˆäººæ—¶ï¼‰
  }

  /** ç­ç»„工时（报工口径） */
  export interface TeamWorkHour {
    teamId?: number;
    teamName?: string;
    taskCount?: number; // ä»»åŠ¡æ•°
    totalDuration?: number; // æ€»ç”Ÿäº§æ—¶é•¿ï¼ˆäººæ—¥ï¼‰
    workHours?: number; // æ€»å·¥æ—¶ï¼ˆäººæ—¶ï¼‰
  }

  export interface EmployeeWorkHourReq {
    userId?: number;
    deptId?: number;
    startDate?: string;
    endDate?: string;
  }

  export interface TeamWorkHourReq {
    startTime?: string;
    endTime?: string;
  }
}

/** å‘˜å·¥å·¥æ—¶ç»Ÿè®¡ï¼ˆè€ƒå‹¤å£å¾„） */
export function getEmployeeWorkHourSummary(
  params: HrmWorkHourStatisticsApi.EmployeeWorkHourReq = {},
) {
  return requestClient.get<HrmWorkHourStatisticsApi.EmployeeWorkHour[]>(
    '/hrm/work-hour-statistics/employee-summary',
    { params },
  );
}

/** ç­ç»„工时统计（报工口径，跨模块聚合 MES） */
export function getTeamWorkHourSummary(
  params: HrmWorkHourStatisticsApi.TeamWorkHourReq = {},
) {
  return requestClient.get<HrmWorkHourStatisticsApi.TeamWorkHour[]>(
    '/hrm/work-hour-statistics/team-summary',
    { params },
  );
}

 src/api/mes/dv/machinery/index.ts

@@ -7,6 +7,7 @@
  export interface Machinery {
    id?: number; // è®¾å¤‡ç¼–号
    code?: string; // è®¾å¤‡ç¼–码
    tbDeviceId?: string; // æ•°é‡‡è®¾å¤‡ID（外部数采 tbDeviceId）
    name?: string; // è®¾å¤‡åç§°
    brand?: string; // å“ç‰Œ
    specification?: string; // è§„格型号

 src/api/mes/dv/statistics/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,32 @@
import { requestClient } from '#/api/request';

export namespace MesDvStatisticsApi {
  /** è®¾å¤‡ç»Ÿè®¡æ±‡æ€» */
  export interface StatisticsSummary {
    totalMachinery?: number; // è®¾å¤‡æ€»æ•°
    producingCount?: number; // ç”Ÿäº§ä¸­
    stoppedCount?: number; // åœæœº
    maintainingCount?: number; // ç»´æŠ¤ä¸­
    faultRate?: number; // æ•…障率%
    totalRepair?: number; // ç»´ä¿®å•æ€»æ•°
    processingRepair?: number; // ç»´ä¿®ä¸­/待验收
    finishedRepair?: number; // å·²ç¡®è®¤ç»´ä¿®
    totalMainten?: number; // ä¿å…»è®°å½•æ€»æ•°
    finishedMainten?: number; // å·²å®Œæˆä¿å…»
    typeDistribution?: TypeItem[]; // æŒ‰è®¾å¤‡ç±»åž‹åˆ†å¸ƒ
  }

  /** è®¾å¤‡ç±»åž‹åˆ†å¸ƒé¡¹ */
  export interface TypeItem {
    machineryTypeId?: number;
    machineryTypeName?: string;
    count?: number;
  }
}

/** è®¾å¤‡ç»Ÿè®¡æ±‡æ€» */
export function getDvStatisticsSummary() {
  return requestClient.get<MesDvStatisticsApi.StatisticsSummary>(
    '/mes/dv/statistics/summary',
  );
}

 src/api/mes/dv/telemetry/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,102 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace MesDvTelemetryApi {
  /** MES è®¾å¤‡æ•°é‡‡é¥æµ‹æ•°æ® */
  export interface Telemetry {
    id?: number; // ç¼–号
    tbDeviceId?: string; // æ•°é‡‡è®¾å¤‡ID
    deviceName?: string; // è®¾å¤‡åç§°
    paramName?: string; // ä¿¡å·åç§°
    paramKeyName?: string; // è®¾å¤‡KEY名称
    standardValue?: string; // æ ‡å‡†å€¼
    timelyValue?: string; // ä¿¡å·å€¼(实时)
    avgValue?: string; // å‡å€¼
    maxValue?: string; // æœ€å¤§å€¼
    minValue?: string; // æœ€å°å€¼
    whetherAnomaly?: boolean; // æ˜¯å¦å¼‚常
    telemetryDataTime?: Date; // é¥æµ‹æ•°æ®æ—¶é—´
    billNo?: string; // å•æ®å·
    shiftName?: string; // ç­æ¬¡
    pullTime?: Date; // æ‹‰å–时间
    createTime?: Date; // åˆ›å»ºæ—¶é—´
  }

  /** æ‹‰å–数采数据结果 */
  export interface PullRespVO {
    recordCount?: number; // æœ¬æ¬¡æ‹‰å–新增数据条数
    deviceCount?: number; // æœ¬æ¬¡æ‹‰å–涉及设备数
    pullTime?: Date; // æ‹‰å–时间
  }

  /** æ•°é‡‡è®¾å¤‡ä¸‹æ‹‰é¡¹ */
  export interface DeviceItem {
    tbDeviceId?: string;
    deviceName?: string;
  }

  /** æœ€æ–°é¥æµ‹æŸ¥è¯¢å‚æ•° */
  export interface LatestReq {
    tbDeviceId?: string;
    deviceName?: string;
  }

  /** ä¾›ç”µå‚数比对校验统计（按设备聚合异常率） */
  export interface CheckSummary {
    tbDeviceId?: string; // æ•°é‡‡è®¾å¤‡ID
    deviceName?: string; // è®¾å¤‡åç§°
    totalCount?: number; // å‚数总数
    normalCount?: number; // æ­£å¸¸æ•°é‡
    anomalyCount?: number; // å¼‚常数量
    anomalyRate?: number; // å¼‚常率(%)
  }
}

/** æ‹‰å–数采数据并入库（近 5 åˆ†é’Ÿè®¾å¤‡æ•°æ®ï¼‰ */
export function pullTelemetry() {
  return requestClient.get<MesDvTelemetryApi.PullRespVO>('/mes/dv/telemetry/pull');
}

/** åˆ†é¡µæŸ¥è¯¢æ•°é‡‡é¥æµ‹æ•°æ®ï¼ˆåŽ†å²è®°å½•ï¼‰ */
export function getTelemetryPage(params: PageParam) {
  return requestClient.get<PageResult<MesDvTelemetryApi.Telemetry>>(
    '/mes/dv/telemetry/page',
    { params },
  );
}

/** æŸ¥è¯¢å„设备最新遥测数据（实时监控） */
export function getLatestTelemetry(params: MesDvTelemetryApi.LatestReq = {}) {
  return requestClient.get<MesDvTelemetryApi.Telemetry[]>(
    '/mes/dv/telemetry/latest',
    { params },
  );
}

/** æŸ¥è¯¢æ•°é‡‡è®¾å¤‡ä¸‹æ‹‰åˆ—表 */
export function getTelemetryDeviceList() {
  return requestClient.get<MesDvTelemetryApi.DeviceItem[]>(
    '/mes/dv/telemetry/device-list',
  );
}

/** ä¾›ç”µå‚数比对校验明细（各设备最新参数 vs æ ‡å‡†å€¼ï¼‰ */
export function getTelemetryCheckList(
  params: MesDvTelemetryApi.LatestReq = {},
) {
  return requestClient.get<MesDvTelemetryApi.Telemetry[]>(
    '/mes/dv/telemetry/check',
    { params },
  );
}

/** ä¾›ç”µå‚数比对校验统计（按设备聚合异常率） */
export function getTelemetryCheckSummary(
  params: MesDvTelemetryApi.LatestReq = {},
) {
  return requestClient.get<MesDvTelemetryApi.CheckSummary[]>(
    '/mes/dv/telemetry/check-summary',
    { params },
  );
}

 src/api/mes/md/item/index.ts

@@ -18,6 +18,7 @@
    safeStockFlag?: boolean; // æ˜¯å¦å¯ç”¨å®‰å…¨åº“å­˜
    minStock?: number; // æœ€ä½Žåº“存量
    maxStock?: number; // æœ€é«˜åº“存量
    materialCategory?: number; // ç”µåŠ›ç‰©èµ„分类
    highValue?: boolean; // æ˜¯å¦é«˜å€¼ç‰©æ–™
    batchFlag?: boolean; // æ˜¯å¦å¯ç”¨æ‰¹æ¬¡ç®¡ç†
    remark?: string; // å¤‡æ³¨

 src/api/mes/pd/basedata/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,330 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace MesPdBaseDataApi {
  /** ç”¨ç”µç±»åž‹ */
  export interface ElectricityType {
    id?: number; // ç¼–号
    code?: string; // ç±»åž‹ç¼–码
    name?: string; // ç±»åž‹åç§°
    description?: string; // ç±»åž‹è¯´æ˜Ž
    sort?: number; // æŽ’序
    status?: number; // å¯ç”¨çŠ¶æ€ï¼ˆ1启用/0禁用）
    createTime?: Date; // åˆ›å»ºæ—¶é—´
  }

  /** ç”µåŽ‹ç­‰çº§ */
  export interface VoltageLevel {
    id?: number; // ç¼–号
    code?: string; // ç­‰çº§ç¼–码
    name?: string; // ç­‰çº§åç§°
    voltageValue?: number; // ç”µåŽ‹æ•°å€¼ï¼ˆkV）
    sort?: number; // æŽ’序
    status?: number; // å¯ç”¨çŠ¶æ€ï¼ˆ1启用/0禁用）
    createTime?: Date; // åˆ›å»ºæ—¶é—´
  }

  /** æœåŠ¡å¥—餐 */
  export interface ServicePackage {
    id?: number; // ç¼–号
    code?: string; // å¥—餐编码
    name?: string; // å¥—餐名称
    description?: string; // å¥—餐说明
    price?: number; // å¥—餐价格
    effectiveDate?: Date; // ç”Ÿæ•ˆæ—¥æœŸ
    expireDate?: Date; // å¤±æ•ˆæ—¥æœŸ
    status?: number; // å¯ç”¨çŠ¶æ€ï¼ˆ1启用/0禁用）
    createTime?: Date; // åˆ›å»ºæ—¶é—´
  }

  /** å®šä»·æ ‡å‡† */
  export interface PriceStandard {
    id?: number; // ç¼–号
    objectType?: number; // å®šä»·å¯¹è±¡ç±»åž‹ï¼ˆ1服务套餐/2电压等级/3用电类型）
    objectTypeName?: string; // å®šä»·å¯¹è±¡ç±»åž‹åç§°
    objectId?: number; // å®šä»·å¯¹è±¡ID
    objectName?: string; // å®šä»·å¯¹è±¡åç§°
    price?: number; // ä»·æ ¼
    unit?: string; // è®¡ä»·å•ä½
    effectiveDate?: Date; // ç”Ÿæ•ˆæ—¥æœŸ
    status?: number; // å¯ç”¨çŠ¶æ€ï¼ˆ1启用/0禁用）
    createTime?: Date; // åˆ›å»ºæ—¶é—´
  }

  /** ä¼˜æƒ ç­–ç•¥ */
  export interface DiscountPolicy {
    id?: number; // ç¼–号
    name?: string; // ç­–略名称
    policyType?: number; // ç­–略类型（1折扣/2立减）
    policyTypeName?: string; // ç­–略类型名称
    policyValue?: number; // ç­–略值（折扣：0-1 æ¯”例；立减：金额）
    targetType?: number; // é€‚用对象类型（1服务套餐/2电压等级/3用电类型，可空=全局）
    targetId?: number; // é€‚用对象ID
    startDate?: Date; // ç”Ÿæ•ˆæ—¥æœŸ
    endDate?: Date; // å¤±æ•ˆæ—¥æœŸ
    status?: number; // å¯ç”¨çŠ¶æ€ï¼ˆ1启用/0禁用）
    createTime?: Date; // åˆ›å»ºæ—¶é—´
  }

  /** é˜¶æ¢¯ç”µä»· */
  export interface TieredPrice {
    id?: number; // ç¼–号
    packageId?: number; // æœåŠ¡å¥—餐ID
    voltageLevelId?: number; // ç”µåŽ‹ç­‰çº§ID
    startValue?: number; // æ¡£ä½ä¸‹é™ï¼ˆå«ï¼ŒkWh）
    endValue?: number; // æ¡£ä½ä¸Šé™ï¼ˆä¸å«ï¼ŒkWh，可空=上不封顶）
    pricePerUnit?: number; // æ¡£ä½å•ä»·
    status?: number; // å¯ç”¨çŠ¶æ€ï¼ˆ1启用/0禁用）
    createTime?: Date; // åˆ›å»ºæ—¶é—´
  }
}

// ==================== ç”¨ç”µç±»åž‹ ====================

/** æŸ¥è¯¢ç”¨ç”µç±»åž‹åˆ†é¡µ */
export function getElectricityTypePage(params: PageParam) {
  return requestClient.get<PageResult<MesPdBaseDataApi.ElectricityType>>(
    '/mes/pd/electricity-type/page',
    { params },
  );
}

/** æŸ¥è¯¢ç”¨ç”µç±»åž‹è¯¦æƒ… */
export function getElectricityType(id: number) {
  return requestClient.get<MesPdBaseDataApi.ElectricityType>(
    `/mes/pd/electricity-type/get?id=${id}`,
  );
}

/** æŸ¥è¯¢ç”¨ç”µç±»åž‹åˆ—表 */
export function getElectricityTypeList() {
  return requestClient.get<MesPdBaseDataApi.ElectricityType[]>(
    '/mes/pd/electricity-type/list',
  );
}

/** æ–°å¢žç”¨ç”µç±»åž‹ */
export function createElectricityType(data: MesPdBaseDataApi.ElectricityType) {
  return requestClient.post('/mes/pd/electricity-type/create', data);
}

/** ä¿®æ”¹ç”¨ç”µç±»åž‹ */
export function updateElectricityType(data: MesPdBaseDataApi.ElectricityType) {
  return requestClient.put('/mes/pd/electricity-type/update', data);
}

/** åˆ é™¤ç”¨ç”µç±»åž‹ */
export function deleteElectricityType(id: number) {
  return requestClient.delete(`/mes/pd/electricity-type/delete?id=${id}`);
}

/** å¯¼å‡ºç”¨ç”µç±»åž‹ Excel */
export function exportElectricityType(params: any) {
  return requestClient.download('/mes/pd/electricity-type/export-excel', {
    params,
  });
}

// ==================== ç”µåŽ‹ç­‰çº§ ====================

/** æŸ¥è¯¢ç”µåŽ‹ç­‰çº§åˆ†é¡µ */
export function getVoltageLevelPage(params: PageParam) {
  return requestClient.get<PageResult<MesPdBaseDataApi.VoltageLevel>>(
    '/mes/pd/voltage-level/page',
    { params },
  );
}

/** æŸ¥è¯¢ç”µåŽ‹ç­‰çº§è¯¦æƒ… */
export function getVoltageLevel(id: number) {
  return requestClient.get<MesPdBaseDataApi.VoltageLevel>(
    `/mes/pd/voltage-level/get?id=${id}`,
  );
}

/** æŸ¥è¯¢ç”µåŽ‹ç­‰çº§åˆ—表 */
export function getVoltageLevelList() {
  return requestClient.get<MesPdBaseDataApi.VoltageLevel[]>(
    '/mes/pd/voltage-level/list',
  );
}

/** æ–°å¢žç”µåŽ‹ç­‰çº§ */
export function createVoltageLevel(data: MesPdBaseDataApi.VoltageLevel) {
  return requestClient.post('/mes/pd/voltage-level/create', data);
}

/** ä¿®æ”¹ç”µåŽ‹ç­‰çº§ */
export function updateVoltageLevel(data: MesPdBaseDataApi.VoltageLevel) {
  return requestClient.put('/mes/pd/voltage-level/update', data);
}

/** åˆ é™¤ç”µåŽ‹ç­‰çº§ */
export function deleteVoltageLevel(id: number) {
  return requestClient.delete(`/mes/pd/voltage-level/delete?id=${id}`);
}

/** å¯¼å‡ºç”µåŽ‹ç­‰çº§ Excel */
export function exportVoltageLevel(params: any) {
  return requestClient.download('/mes/pd/voltage-level/export-excel', { params });
}

// ==================== æœåŠ¡å¥—餐 ====================

/** æŸ¥è¯¢æœåŠ¡å¥—餐分页 */
export function getServicePackagePage(params: PageParam) {
  return requestClient.get<PageResult<MesPdBaseDataApi.ServicePackage>>(
    '/mes/pd/service-package/page',
    { params },
  );
}

/** æŸ¥è¯¢æœåŠ¡å¥—餐详情 */
export function getServicePackage(id: number) {
  return requestClient.get<MesPdBaseDataApi.ServicePackage>(
    `/mes/pd/service-package/get?id=${id}`,
  );
}

/** æŸ¥è¯¢æœåŠ¡å¥—餐列表 */
export function getServicePackageList() {
  return requestClient.get<MesPdBaseDataApi.ServicePackage[]>(
    '/mes/pd/service-package/list',
  );
}

/** æ–°å¢žæœåŠ¡å¥—餐 */
export function createServicePackage(data: MesPdBaseDataApi.ServicePackage) {
  return requestClient.post('/mes/pd/service-package/create', data);
}

/** ä¿®æ”¹æœåŠ¡å¥—餐 */
export function updateServicePackage(data: MesPdBaseDataApi.ServicePackage) {
  return requestClient.put('/mes/pd/service-package/update', data);
}

/** åˆ é™¤æœåŠ¡å¥—餐 */
export function deleteServicePackage(id: number) {
  return requestClient.delete(`/mes/pd/service-package/delete?id=${id}`);
}

/** å¯¼å‡ºæœåŠ¡å¥—餐 Excel */
export function exportServicePackage(params: any) {
  return requestClient.download('/mes/pd/service-package/export-excel', {
    params,
  });
}

// ==================== å®šä»·æ ‡å‡† ====================

/** æŸ¥è¯¢å®šä»·æ ‡å‡†åˆ†é¡µ */
export function getPriceStandardPage(params: PageParam) {
  return requestClient.get<PageResult<MesPdBaseDataApi.PriceStandard>>(
    '/mes/pd/price-standard/page',
    { params },
  );
}

/** æŸ¥è¯¢å®šä»·æ ‡å‡†è¯¦æƒ… */
export function getPriceStandard(id: number) {
  return requestClient.get<MesPdBaseDataApi.PriceStandard>(
    `/mes/pd/price-standard/get?id=${id}`,
  );
}

/** æ–°å¢žå®šä»·æ ‡å‡† */
export function createPriceStandard(data: MesPdBaseDataApi.PriceStandard) {
  return requestClient.post('/mes/pd/price-standard/create', data);
}

/** ä¿®æ”¹å®šä»·æ ‡å‡† */
export function updatePriceStandard(data: MesPdBaseDataApi.PriceStandard) {
  return requestClient.put('/mes/pd/price-standard/update', data);
}

/** åˆ é™¤å®šä»·æ ‡å‡† */
export function deletePriceStandard(id: number) {
  return requestClient.delete(`/mes/pd/price-standard/delete?id=${id}`);
}

/** å¯¼å‡ºå®šä»·æ ‡å‡† Excel */
export function exportPriceStandard(params: any) {
  return requestClient.download('/mes/pd/price-standard/export-excel', { params });
}

// ==================== ä¼˜æƒ ç­–ç•¥ ====================

/** æŸ¥è¯¢ä¼˜æƒ ç­–略分页 */
export function getDiscountPolicyPage(params: PageParam) {
  return requestClient.get<PageResult<MesPdBaseDataApi.DiscountPolicy>>(
    '/mes/pd/discount-policy/page',
    { params },
  );
}

/** æŸ¥è¯¢ä¼˜æƒ ç­–略详情 */
export function getDiscountPolicy(id: number) {
  return requestClient.get<MesPdBaseDataApi.DiscountPolicy>(
    `/mes/pd/discount-policy/get?id=${id}`,
  );
}

/** æ–°å¢žä¼˜æƒ ç­–ç•¥ */
export function createDiscountPolicy(data: MesPdBaseDataApi.DiscountPolicy) {
  return requestClient.post('/mes/pd/discount-policy/create', data);
}

/** ä¿®æ”¹ä¼˜æƒ ç­–ç•¥ */
export function updateDiscountPolicy(data: MesPdBaseDataApi.DiscountPolicy) {
  return requestClient.put('/mes/pd/discount-policy/update', data);
}

/** åˆ é™¤ä¼˜æƒ ç­–ç•¥ */
export function deleteDiscountPolicy(id: number) {
  return requestClient.delete(`/mes/pd/discount-policy/delete?id=${id}`);
}

/** å¯¼å‡ºä¼˜æƒ ç­–ç•¥ Excel */
export function exportDiscountPolicy(params: any) {
  return requestClient.download('/mes/pd/discount-policy/export-excel', {
    params,
  });
}

// ==================== é˜¶æ¢¯ç”µä»· ====================

/** æŸ¥è¯¢é˜¶æ¢¯ç”µä»·åˆ†é¡µ */
export function getTieredPricePage(params: PageParam) {
  return requestClient.get<PageResult<MesPdBaseDataApi.TieredPrice>>(
    '/mes/pd/tiered-price/page',
    { params },
  );
}

/** æŸ¥è¯¢é˜¶æ¢¯ç”µä»·è¯¦æƒ… */
export function getTieredPrice(id: number) {
  return requestClient.get<MesPdBaseDataApi.TieredPrice>(
    `/mes/pd/tiered-price/get?id=${id}`,
  );
}

/** æ–°å¢žé˜¶æ¢¯ç”µä»· */
export function createTieredPrice(data: MesPdBaseDataApi.TieredPrice) {
  return requestClient.post('/mes/pd/tiered-price/create', data);
}

/** ä¿®æ”¹é˜¶æ¢¯ç”µä»· */
export function updateTieredPrice(data: MesPdBaseDataApi.TieredPrice) {
  return requestClient.put('/mes/pd/tiered-price/update', data);
}

/** åˆ é™¤é˜¶æ¢¯ç”µä»· */
export function deleteTieredPrice(id: number) {
  return requestClient.delete(`/mes/pd/tiered-price/delete?id=${id}`);
}

/** å¯¼å‡ºé˜¶æ¢¯ç”µä»· Excel */
export function exportTieredPrice(params: any) {
  return requestClient.download('/mes/pd/tiered-price/export-excel', { params });
}

 src/api/mes/pd/ctc-reel/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,60 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace MesPdCtcReelApi {
  /** æ¢ä½å¯¼çº¿ç›˜å…·è®¡ç®— */
  export interface CtcReel {
    id?: number; // ç¼–号
    ctcId?: number; // æ¢ä½å¯¼çº¿äº§å“ID
    ctcOrderSpec?: string; // æ¢ä½å¯¼çº¿è®¢è´§è§„æ ¼
    reelType?: string; // ç›˜å…·ç±»åž‹
    reelOuterDiameter?: number; // ç›˜å…·å¤–径 mm
    reelInnerDiameter?: number; // ç›˜èŠ¯å†…径 mm
    reelWidth?: number; // ç›˜å®½ mm
    maxCapacity?: number; // æœ€å¤§å®¹é‡ km
    recommendedLength?: number; // æŽ¨èæ¯ç›˜é•¿åº¦ km
    netWeight?: number; // å‡€é‡ kg
    grossWeight?: number; // æ¯›é‡ kg
    calcFormula?: string; // è®¡ç®—公式
    remark?: string; // å¤‡æ³¨
    createTime?: Date; // åˆ›å»ºæ—¶é—´
  }
}

/** æŸ¥è¯¢ç›˜å…·è®¡ç®—分页 */
export function getCtcReelPage(params: PageParam) {
  return requestClient.get<PageResult<MesPdCtcReelApi.CtcReel>>(
    '/mes/pd/ctc-reel/page',
    { params },
  );
}

/** æŸ¥è¯¢ç›˜å…·è®¡ç®—详情 */
export function getCtcReel(id: number) {
  return requestClient.get<MesPdCtcReelApi.CtcReel>(
    `/mes/pd/ctc-reel/get?id=${id}`,
  );
}

/** æŸ¥è¯¢æŒ‡å®šæ¢ä½å¯¼çº¿äº§å“çš„盘具列表 */
export function getCtcReelListByCtcId(ctcId: number) {
  return requestClient.get<MesPdCtcReelApi.CtcReel[]>(
    `/mes/pd/ctc-reel/list-by-ctc?ctcId=${ctcId}`,
  );
}

/** æ–°å¢žç›˜å…·è®¡ç®—记录 */
export function createCtcReel(data: MesPdCtcReelApi.CtcReel) {
  return requestClient.post('/mes/pd/ctc-reel/create', data);
}

/** ä¿®æ”¹ç›˜å…·è®¡ç®—记录 */
export function updateCtcReel(data: MesPdCtcReelApi.CtcReel) {
  return requestClient.put('/mes/pd/ctc-reel/update', data);
}

/** åˆ é™¤ç›˜å…·è®¡ç®—记录 */
export function deleteCtcReel(id: number) {
  return requestClient.delete(`/mes/pd/ctc-reel/delete?id=${id}`);
}

 src/api/mes/pd/ctc/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,128 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace MesPdCtcApi {
  /** æ¢ä½å¯¼çº¿äº§å“æŠ€æœ¯å‚æ•° */
  export interface Ctc {
    id?: number; // ç¼–号
    itemId?: number; // ç‰©æ–™ID
    itemName?: string; // ç‰©æ–™åç§°
    itemCode?: string; // ç‰©æ–™ç¼–码
    orderSpec?: string; // è®¢è´§è§„æ ¼
    bareConductorSpec?: string; // è£¸å¯¼çº¿è§„æ ¼
    enameledSpec?: string; // æ¼†åŒ…线规格
    transpositionSpec?: string; // æ¢ä½è§„æ ¼
    conductorType?: string; // å¯¼ä½“类型
    crossSection?: number; // æˆªé¢ç§¯ mm²
    outerDiameter?: number; // å¤–径 mm
    resistance20c?: number; // 20℃直流电阻 Î©/km
    wrappingAngle?: number; // ç»•åŒ…角度 Â°
    insulationThickness?: number; // ç»ç¼˜åŽšåº¦ mm
    ratedVoltage?: string; // é¢å®šç”µåŽ‹ kV
    testVoltage?: string; // è¯•éªŒç”µåŽ‹ kV
    minBendingRadius?: number; // æœ€å°å¼¯æ›²åŠå¾„ mm
    weightPerKm?: number; // æ¯å…¬é‡Œé‡é‡ kg/km
    standardCode?: string; // æ‰§è¡Œæ ‡å‡†ä»£å·
    remark?: string; // å¤‡æ³¨
    createTime?: Date; // åˆ›å»ºæ—¶é—´
  }

  /** ç»•åŒ…角度计算 */
  export interface AngleCalcReq {
    conductorThickness?: number; // å¯¼ä½“厚度 mm
    conductorWidth?: number; // å¯¼ä½“宽度 mm
    cornerRadius?: number; // åœ†è§’半径 mm
    insulationThickness?: number; // ç»ç¼˜åŽšåº¦ mm
    tapeWidth?: number; // çº¸å¸¦å®½åº¦ mm
    overlapWidth?: number; // é‡å å®½åº¦ mm
  }

  /** ç»•åŒ…角度计算结果 */
  export interface AngleCalcResp {
    circumference?: number; // å¯¼çº¿å‘¨é•¿ mm
    wrappingAngle?: number; // ç»•åŒ…角度 Â°
    wrappingPitch?: number; // ç»•åŒ…节距 mm
  }

  /** ç›´æµç”µé˜»è®¡ç®— */
  export interface ResistanceCalcReq {
    conductorThickness?: number; // å¯¼ä½“厚度 mm
    conductorWidth?: number; // å¯¼ä½“宽度 mm
    temperature?: number; // è®¡ç®—温度 â„ƒ
    material?: string; // å¯¼ä½“材质
  }

  /** ç›´æµç”µé˜»è®¡ç®—结果 */
  export interface ResistanceCalcResp {
    crossSection?: number; // æˆªé¢ç§¯ mm²
    resistance20cKm?: number; // 20℃直流电阻 Î©/km
    resistanceAtTemp?: number; // æŒ‡å®šæ¸©åº¦ç›´æµç”µé˜» Î©/m
    resistanceAtTempKm?: number; // æŒ‡å®šæ¸©åº¦ç›´æµç”µé˜» Î©/km
  }

  /** ç›˜å…·å®¹é‡è®¡ç®— */
  export interface ReelCalcReq {
    reelOuterDiameter?: number; // ç›˜å…·å¤–径 d1 mm
    reelInnerDiameter?: number; // ç›˜èŠ¯å†…径 d2 mm
    reelWidth?: number; // ç›˜å®½ l2 mm
    ctcThickness?: number; // CTC æœ€å¤§é«˜åº¦ mm
    ctcWidth?: number; // CTC æœ€å¤§å®½åº¦ mm
  }

  /** ç›˜å…·å®¹é‡è®¡ç®—结果 */
  export interface ReelCalcResp {
    capacityMeter?: number; // æ¯ç›˜é•¿åº¦ m
    capacityKm?: number; // æ¯ç›˜é•¿åº¦ km
  }
}

/** æŸ¥è¯¢æ¢ä½å¯¼çº¿äº§å“æŠ€æœ¯å‚数分页 */
export function getCtcPage(params: PageParam) {
  return requestClient.get<PageResult<MesPdCtcApi.Ctc>>('/mes/pd/ctc/page', {
    params,
  });
}

/** æŸ¥è¯¢æ¢ä½å¯¼çº¿äº§å“æŠ€æœ¯å‚数详情 */
export function getCtc(id: number) {
  return requestClient.get<MesPdCtcApi.Ctc>(`/mes/pd/ctc/get?id=${id}`);
}

/** æ–°å¢žæ¢ä½å¯¼çº¿äº§å“æŠ€æœ¯å‚æ•° */
export function createCtc(data: MesPdCtcApi.Ctc) {
  return requestClient.post('/mes/pd/ctc/create', data);
}

/** ä¿®æ”¹æ¢ä½å¯¼çº¿äº§å“æŠ€æœ¯å‚æ•° */
export function updateCtc(data: MesPdCtcApi.Ctc) {
  return requestClient.put('/mes/pd/ctc/update', data);
}

/** åˆ é™¤æ¢ä½å¯¼çº¿äº§å“æŠ€æœ¯å‚æ•° */
export function deleteCtc(id: number) {
  return requestClient.delete(`/mes/pd/ctc/delete?id=${id}`);
}

/** å¯¼å‡ºæ¢ä½å¯¼çº¿äº§å“æŠ€æœ¯å‚æ•° */
export function exportCtc(params: any) {
  return requestClient.download('/mes/pd/ctc/export-excel', { params });
}

/** ç»•åŒ…角度计算 */
export function calcCtcAngle(data: MesPdCtcApi.AngleCalcReq) {
  return requestClient.post<MesPdCtcApi.AngleCalcResp>('/mes/pd/ctc/calc-angle', data);
}

/** ç›´æµç”µé˜»è®¡ç®— */
export function calcCtcResistance(data: MesPdCtcApi.ResistanceCalcReq) {
  return requestClient.post<MesPdCtcApi.ResistanceCalcResp>(
    '/mes/pd/ctc/calc-resistance',
    data,
  );
}

/** ç›˜å…·å®¹é‡è®¡ç®— */
export function calcCtcReel(data: MesPdCtcApi.ReelCalcReq) {
  return requestClient.post<MesPdCtcApi.ReelCalcResp>('/mes/pd/ctc/calc-reel', data);
}

 src/api/mes/pd/price/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,38 @@
import { requestClient } from '#/api/request';

export namespace MesPdPriceApi {
  /** é˜¶æ¢¯ç”µä»·æµ‹ç®—请求 */
  export interface PriceCalcReq {
    calcType: number; // æµ‹ç®—类型（1服务套餐/2电压等级）
    packageId?: number; // æœåŠ¡å¥—餐ID（calcType=1 æ—¶å¿…填）
    voltageLevelId?: number; // ç”µåŽ‹ç­‰çº§ID（calcType=2 æ—¶å¿…填）
    quantity: number; // ç”¨ç”µé‡ï¼ˆkWh）
  }

  /** é˜¶æ¢¯ç”µä»·æµ‹ç®—分档明细 */
  export interface PriceCalcDetail {
    startValue?: number; // æ¡£ä½ä¸‹é™ï¼ˆå«ï¼ŒkWh）
    endValue?: number; // æ¡£ä½ä¸Šé™ï¼ˆä¸å«ï¼ŒkWh，可空=上不封顶）
    tierQuantity?: number; // è½å…¥æœ¬æ¡£ç”µé‡ï¼ˆkWh）
    pricePerUnit?: number; // æ¡£ä½å•ä»·
    subtotal?: number; // å°è®¡
  }

  /** é˜¶æ¢¯ç”µä»·æµ‹ç®—响应 */
  export interface PriceCalcResp {
    packageName?: string; // æœåŠ¡å¥—餐名称
    voltageLevelName?: string; // ç”µåŽ‹ç­‰çº§åç§°
    originalPrice?: number; // åŽŸä»·ï¼ˆæœªä¼˜æƒ ï¼‰
    discountAmount?: number; // ä¼˜æƒ é‡‘额
    finalPrice?: number; // ä¼˜æƒ åŽæ€»ä»·
    details?: PriceCalcDetail[]; // åˆ†æ¡£æ˜Žç»†
  }
}

/** é˜¶æ¢¯ç”µä»·æµ‹ç®— */
export function calcPrice(data: MesPdPriceApi.PriceCalcReq) {
  return requestClient.post<MesPdPriceApi.PriceCalcResp>(
    '/mes/pd/price/calc',
    data,
  );
}

 src/api/mes/pd/product/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,76 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace MesPdProductApi {
  /** äº§å“æ¡£æ¡ˆ */
  export interface Product {
    id?: number; // ç¼–号
    archiveType?: number; // æ¡£æ¡ˆç±»åž‹ï¼ˆ1电力服务/2供电产品/3增值能源产品）
    archiveTypeName?: string; // æ¡£æ¡ˆç±»åž‹åç§°
    code?: string; // æ¡£æ¡ˆç¼–码
    name?: string; // æ¡£æ¡ˆåç§°
    spec?: string; // è§„格型号
    unit?: string; // å•ä½
    price?: number; // åŸºå‡†ä»·æ ¼
    auditStatus?: number; // å®¡æ‰¹çŠ¶æ€ï¼ˆ0未提交/10审批中/20审核通过/30审核不通过）
    auditStatusName?: string; // å®¡æ‰¹çŠ¶æ€åç§°
    auditRemark?: string; // å®¡æ‰¹æ„è§
    auditTime?: Date; // å®¡æ‰¹æ—¶é—´
    status?: number; // å¯ç”¨çŠ¶æ€ï¼ˆ1启用/0禁用）
    remark?: string; // å¤‡æ³¨
    createTime?: Date; // åˆ›å»ºæ—¶é—´
  }

  /** äº§å“æ¡£æ¡ˆå®¡æ‰¹å‚æ•° */
  export interface ProductAudit {
    id: number; // ç¼–号
    pass: boolean; // å®¡æ‰¹ç»“果：true=通过 / false=驳回
    auditRemark?: string; // å®¡æ‰¹æ„è§
  }
}

/** æŸ¥è¯¢äº§å“æ¡£æ¡ˆåˆ†é¡µ */
export function getProductPage(params: PageParam) {
  return requestClient.get<PageResult<MesPdProductApi.Product>>(
    '/mes/pd/product/page',
    { params },
  );
}

/** æŸ¥è¯¢äº§å“æ¡£æ¡ˆè¯¦æƒ… */
export function getProduct(id: number) {
  return requestClient.get<MesPdProductApi.Product>(
    `/mes/pd/product/get?id=${id}`,
  );
}

/** æ–°å¢žäº§å“æ¡£æ¡ˆ */
export function createProduct(data: MesPdProductApi.Product) {
  return requestClient.post('/mes/pd/product/create', data);
}

/** ä¿®æ”¹äº§å“æ¡£æ¡ˆ */
export function updateProduct(data: MesPdProductApi.Product) {
  return requestClient.put('/mes/pd/product/update', data);
}

/** åˆ é™¤äº§å“æ¡£æ¡ˆ */
export function deleteProduct(id: number) {
  return requestClient.delete(`/mes/pd/product/delete?id=${id}`);
}

/** å¯¼å‡ºäº§å“æ¡£æ¡ˆ Excel */
export function exportProduct(params: any) {
  return requestClient.download('/mes/pd/product/export-excel', { params });
}

/** æäº¤å®¡æ‰¹ï¼ˆæœªæäº¤/驳回 â†’ å®¡æ‰¹ä¸­ï¼‰ */
export function submitProduct(id: number) {
  return requestClient.put(`/mes/pd/product/submit?id=${id}`);
}

/** å®¡æ‰¹äº§å“æ¡£æ¡ˆï¼ˆå®¡æ‰¹ä¸­ â†’ é€šè¿‡/驳回） */
export function auditProduct(data: MesPdProductApi.ProductAudit) {
  return requestClient.put('/mes/pd/product/audit', data);
}

 src/api/mes/pd/tech-confirm/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,63 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace MesPdTechConfirmApi {
  /** äº§å“æŠ€æœ¯ç¡®è®¤å‡½ */
  export interface TechConfirm {
    id?: number; // ç¼–号
    confirmNo?: string; // ç¡®è®¤å‡½ç¼–号
    customerId?: number; // å®¢æˆ·ID
    customerName?: string; // å®¢æˆ·åç§°
    productName?: string; // äº§å“åç§°
    specification?: string; // è§„格型号
    techParams?: string; // æŠ€æœ¯å‚æ•° JSON
    templateType?: string; // æ¨¡æ¿ç±»åž‹
    drafterId?: number; // ç¼–制人ID
    drafterName?: string; // ç¼–制人姓名
    draftTime?: Date; // ç¼–制时间
    reviewerId?: number; // å®¡æ ¸äººID
    reviewerName?: string; // å®¡æ ¸äººå§“名
    reviewTime?: Date; // å®¡æ ¸æ—¶é—´
    customerConfirmUser?: string; // å®¢æˆ·ç¡®è®¤äºº
    customerConfirmTime?: Date; // å®¢æˆ·ç¡®è®¤æ—¶é—´
    status?: number; // çŠ¶æ€
    remark?: string; // å¤‡æ³¨
    createTime?: Date; // åˆ›å»ºæ—¶é—´
  }
}

/** æŸ¥è¯¢äº§å“æŠ€æœ¯ç¡®è®¤å‡½åˆ†é¡µ */
export function getTechConfirmPage(params: PageParam) {
  return requestClient.get<PageResult<MesPdTechConfirmApi.TechConfirm>>(
    '/mes/pd/tech-confirm/page',
    { params },
  );
}

/** æŸ¥è¯¢äº§å“æŠ€æœ¯ç¡®è®¤å‡½è¯¦æƒ… */
export function getTechConfirm(id: number) {
  return requestClient.get<MesPdTechConfirmApi.TechConfirm>(
    `/mes/pd/tech-confirm/get?id=${id}`,
  );
}

/** æ–°å¢žäº§å“æŠ€æœ¯ç¡®è®¤å‡½ */
export function createTechConfirm(data: MesPdTechConfirmApi.TechConfirm) {
  return requestClient.post('/mes/pd/tech-confirm/create', data);
}

/** ä¿®æ”¹äº§å“æŠ€æœ¯ç¡®è®¤å‡½ */
export function updateTechConfirm(data: MesPdTechConfirmApi.TechConfirm) {
  return requestClient.put('/mes/pd/tech-confirm/update', data);
}

/** åˆ é™¤äº§å“æŠ€æœ¯ç¡®è®¤å‡½ */
export function deleteTechConfirm(id: number) {
  return requestClient.delete(`/mes/pd/tech-confirm/delete?id=${id}`);
}

/** å¯¼å‡ºäº§å“æŠ€æœ¯ç¡®è®¤å‡½ */
export function exportTechConfirm(params: any) {
  return requestClient.download('/mes/pd/tech-confirm/export-excel', { params });
}

 src/api/mes/pro/alternativeplan/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,58 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace MesProAlternativePlanApi {
  /** MES ä½œä¸šæ›¿ä»£æ–¹æ¡ˆ */
  export interface AlternativePlan {
    id?: number;
    code?: string; // æ–¹æ¡ˆç¼–码
    name?: string; // æ–¹æ¡ˆåç§°
    mainProcessId?: number; // ä¸»å·¥åºç¼–号
    mainProcessName?: string; // ä¸»å·¥åºåç§°
    altProcessId?: number; // æ›¿ä»£å·¥åºç¼–号
    altProcessName?: string; // æ›¿ä»£å·¥åºåç§°
    altCondition?: string; // æ›¿ä»£æ¡ä»¶
    scope?: string; // é€‚用范围
    status?: number; // çŠ¶æ€ï¼š0草稿 10已发布
    remark?: string; // å¤‡æ³¨
    createTime?: string;
  }
}

/** åˆ›å»ºä½œä¸šæ›¿ä»£æ–¹æ¡ˆ */
export function createPlan(data: MesProAlternativePlanApi.AlternativePlan) {
  return requestClient.post('/mes/pro/alternative-plan/create', data);
}

/** æ›´æ–°ä½œä¸šæ›¿ä»£æ–¹æ¡ˆ */
export function updatePlan(data: MesProAlternativePlanApi.AlternativePlan) {
  return requestClient.put('/mes/pro/alternative-plan/update', data);
}

/** åˆ é™¤ä½œä¸šæ›¿ä»£æ–¹æ¡ˆ */
export function deletePlan(ids: number[]) {
  return requestClient.delete('/mes/pro/alternative-plan/delete', {
    params: { ids: ids.join(',') },
  });
}

/** èŽ·å–作业替代方案 */
export function getPlan(id: number) {
  return requestClient.get<MesProAlternativePlanApi.AlternativePlan>(
    `/mes/pro/alternative-plan/get?id=${id}`,
  );
}

/** èŽ·å–作业替代方案分页 */
export function getPlanPage(params: PageParam) {
  return requestClient.get<PageResult<MesProAlternativePlanApi.AlternativePlan>>(
    '/mes/pro/alternative-plan/page',
    { params },
  );
}

/** å‘布作业替代方案 */
export function publishPlan(id: number) {
  return requestClient.put(`/mes/pro/alternative-plan/publish?id=${id}`);
}

 src/api/mes/pro/emergencyplan/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,53 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace MesProEmergencyPlanApi {
  /** åº”急处置预案 */
  export interface EmergencyPlan {
    id?: number;
    code?: string; // é¢„案编码
    name?: string; // é¢„案名称
    planType?: number; // é¢„案类型：1停电 2设备故障 3火灾 4自然灾害 5其他
    content?: string; // å¤„置内容
    orgUnit?: string; // è´£ä»»å•ä½
    status?: number; // çŠ¶æ€ï¼š0草稿 10已发布
    remark?: string; // å¤‡æ³¨
    createTime?: string;
  }
}

/** åˆ›å»ºåº”急处置预案 */
export function createPlan(data: MesProEmergencyPlanApi.EmergencyPlan) {
  return requestClient.post('/mes/pro/emergency-plan/create', data);
}

/** æ›´æ–°åº”急处置预案 */
export function updatePlan(data: MesProEmergencyPlanApi.EmergencyPlan) {
  return requestClient.put('/mes/pro/emergency-plan/update', data);
}

/** åˆ é™¤åº”急处置预案 */
export function deletePlan(ids: number[]) {
  return requestClient.delete('/mes/pro/emergency-plan/delete', { params: { ids: ids.join(',') } });
}

/** èŽ·å–应急处置预案 */
export function getPlan(id: number) {
  return requestClient.get<MesProEmergencyPlanApi.EmergencyPlan>(
    `/mes/pro/emergency-plan/get?id=${id}`,
  );
}

/** èŽ·å–应急处置预案分页 */
export function getPlanPage(params: PageParam) {
  return requestClient.get<PageResult<MesProEmergencyPlanApi.EmergencyPlan>>(
    '/mes/pro/emergency-plan/page',
    { params },
  );
}

/** å‘布应急处置预案 */
export function publishPlan(id: number) {
  return requestClient.put(`/mes/pro/emergency-plan/publish?id=${id}`);
}

 src/api/mes/pro/feedback/index.ts

@@ -204,3 +204,40 @@
    `/mes/pro/feedback/list-by-task?taskId=${taskId}`,
  );
}

/** ä½œä¸šæˆæžœæ±‡æ€»é¡¹ï¼ˆæŒ‰å·¥å•ç±»åž‹ï¼‰ */
export interface WorkResultTypeItem {
  workOrderType?: number;
  workOrderTypeName?: string;
  feedbackQuantity?: number;
  qualifiedQuantity?: number;
  feedbackCount?: number;
}

/** ä½œä¸šæˆæžœæ±‡æ€»é¡¹ï¼ˆæŒ‰æ—¥æœŸï¼‰ */
export interface WorkResultDateItem {
  date?: string;
  feedbackQuantity?: number;
  qualifiedQuantity?: number;
  feedbackCount?: number;
}

/** ä½œä¸šæˆæžœæ±‡æ€» */
export interface WorkResultSummary {
  totalFeedbackQuantity?: number;
  totalQualifiedQuantity?: number;
  totalFeedbackCount?: number;
  byType?: WorkResultTypeItem[];
  byDate?: WorkResultDateItem[];
}

/** ä½œä¸šæˆæžœæ±‡æ€»ç»Ÿè®¡ */
export function getFeedbackSummary(params: {
  beginDate?: string;
  endDate?: string;
  workOrderType?: number;
}) {
  return requestClient.get<WorkResultSummary>('/mes/pro/feedback/summary', {
    params,
  });
}

 src/api/mes/pro/maintenance-plan/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace MesProMaintenancePlanApi {
  /** ç”µåŠ›ä½œä¸šè®¡åˆ’ */
  export interface MaintenancePlan {
    id?: number; // ç¼–号
    code?: string; // è®¡åˆ’编码
    name?: string; // è®¡åˆ’名称
    planType?: number; // è®¡åˆ’类型：1电网运行 2发电 3变电运维 4线路检修
    station?: string; // ç«™ç‚¹
    line?: string; // çº¿è·¯
    teamId?: number; // ç­ç»„编号
    teamName?: string; // ç­ç»„名称
    planDate?: string; // è®¡åˆ’日期
    status?: number; // çŠ¶æ€ï¼š0草稿 10已下发 20已完成 30已取消
    workOrderId?: number; // ç”Ÿæˆçš„工单编号
    workOrderCode?: string; // ç”Ÿæˆçš„工单编码
    remark?: string; // å¤‡æ³¨
    items?: PlanItem[]; // å¤‡ä»¶éœ€æ±‚明细
    createTime?: string; // åˆ›å»ºæ—¶é—´
  }

  /** å¤‡ä»¶éœ€æ±‚明细 */
  export interface PlanItem {
    id?: number; // ç¼–号
    itemId: number; // ç‰©æ–™/备件编号
    itemName?: string; // ç‰©æ–™åç§°
    itemCode?: string; // ç‰©æ–™ç¼–码
    unitMeasureName?: string; // è®¡é‡å•ä½åç§°
    quantity: number; // éœ€æ±‚数量
    remark?: string; // å¤‡æ³¨
  }
}

/** åˆ›å»ºç”µåŠ›ä½œä¸šè®¡åˆ’ */
export function createPlan(data: MesProMaintenancePlanApi.MaintenancePlan) {
  return requestClient.post('/mes/pro/maintenance-plan/create', data);
}

/** æ›´æ–°ç”µåŠ›ä½œä¸šè®¡åˆ’ */
export function updatePlan(data: MesProMaintenancePlanApi.MaintenancePlan) {
  return requestClient.put('/mes/pro/maintenance-plan/update', data);
}

/** åˆ é™¤ç”µåŠ›ä½œä¸šè®¡åˆ’ */
export function deletePlan(ids: number[]) {
  return requestClient.delete('/mes/pro/maintenance-plan/delete', { params: { ids: ids.join(',') } });
}

/** èŽ·å–电力作业计划详情 */
export function getPlan(id: number) {
  return requestClient.get<MesProMaintenancePlanApi.MaintenancePlan>(
    `/mes/pro/maintenance-plan/get?id=${id}`,
  );
}

/** èŽ·å–电力作业计划分页 */
export function getPlanPage(params: PageParam) {
  return requestClient.get<PageResult<MesProMaintenancePlanApi.MaintenancePlan>>(
    '/mes/pro/maintenance-plan/page',
    { params },
  );
}

/** å¯¼å‡ºç”µåŠ›ä½œä¸šè®¡åˆ’ */
export function exportPlan(params: any) {
  return requestClient.download('/mes/pro/maintenance-plan/export-excel', { params });
}

/** ä¸‹å‘电力作业计划 */
export function issuePlan(id: number) {
  return requestClient.put(`/mes/pro/maintenance-plan/issue?id=${id}`);
}

/** å®Œæˆç”µåŠ›ä½œä¸šè®¡åˆ’ */
export function finishPlan(id: number) {
  return requestClient.put(`/mes/pro/maintenance-plan/finish?id=${id}`);
}

/** æ ¹æ®å¤‡ä»¶éœ€æ±‚生成采购计划 */
export function generatePurchasePlan(id: number) {
  return requestClient.post<number>(`/mes/pro/maintenance-plan/generate-purchase-plan?id=${id}`);
}

/** ç”Ÿæˆè¿ç»´/发电/检修工单 */
export function generateWorkOrder(id: number) {
  return requestClient.post<number>(`/mes/pro/maintenance-plan/generate-work-order?id=${id}`);
}

 src/api/mes/pro/maintenancecalendar/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,59 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace MesProMaintenanceCalendarApi {
  /** MES ç”µåŠ›è¿ç»´æ—¥åŽ† */
  export interface MaintenanceCalendar {
    id?: number;
    code?: string; // æ—¥åŽ†ç¼–码
    name?: string; // æ—¥åŽ†åç§°
    workDate?: string; // ä½œä¸šæ—¥æœŸ
    shift?: number; // ç­æ¬¡
    workType?: number; // ä½œä¸šç±»åž‹ï¼š1变电运维 2线路巡检 3发电运维 4储能充放电 5电网调度
    region?: string; // ä½œä¸šåŒºåŸŸ/线路
    teamId?: number; // å€¼ç­ç­ç»„编号
    teamName?: string; // å€¼ç­ç­ç»„名称
    personnel?: string; // å€¼ç­äººå‘˜
    status?: number; // çŠ¶æ€ï¼š0草稿 10已发布
    remark?: string; // å¤‡æ³¨
    createTime?: string;
  }
}

/** åˆ›å»ºç”µåŠ›è¿ç»´æ—¥åŽ† */
export function createCalendar(data: MesProMaintenanceCalendarApi.MaintenanceCalendar) {
  return requestClient.post('/mes/pro/maintenance-calendar/create', data);
}

/** æ›´æ–°ç”µåŠ›è¿ç»´æ—¥åŽ† */
export function updateCalendar(data: MesProMaintenanceCalendarApi.MaintenanceCalendar) {
  return requestClient.put('/mes/pro/maintenance-calendar/update', data);
}

/** åˆ é™¤ç”µåŠ›è¿ç»´æ—¥åŽ† */
export function deleteCalendar(ids: number[]) {
  return requestClient.delete('/mes/pro/maintenance-calendar/delete', {
    params: { ids: ids.join(',') },
  });
}

/** èŽ·å–电力运维日历 */
export function getCalendar(id: number) {
  return requestClient.get<MesProMaintenanceCalendarApi.MaintenanceCalendar>(
    `/mes/pro/maintenance-calendar/get?id=${id}`,
  );
}

/** èŽ·å–电力运维日历分页 */
export function getCalendarPage(params: PageParam) {
  return requestClient.get<PageResult<MesProMaintenanceCalendarApi.MaintenanceCalendar>>(
    '/mes/pro/maintenance-calendar/page',
    { params },
  );
}

/** å‘布电力运维日历 */
export function publishCalendar(id: number) {
  return requestClient.put(`/mes/pro/maintenance-calendar/publish?id=${id}`);
}

 src/api/mes/pro/process/index.ts

@@ -8,6 +8,7 @@
    id?: number;
    code?: string;
    name?: string;
    type?: number; // ç”µåŠ›å·¥è‰ºåˆ†ç±»
    attention?: string;
    status?: number;
    remark?: string;

 src/api/mes/pro/task/index.ts

@@ -27,6 +27,8 @@
    workstationId?: number; // å·¥ä½œç«™ç¼–号
    workstationCode?: string; // å·¥ä½œç«™ç¼–码
    workstationName?: string; // å·¥ä½œç«™åç§°
    teamId?: number; // ç­ç»„编号
    teamName?: string; // ç­ç»„名称
    routeId?: number; // å·¥è‰ºè·¯çº¿ç¼–号
    processId?: number; // å·¥åºç¼–号
    processName?: string; // å·¥åºåç§°

 src/api/mes/pro/workorder/index.ts

@@ -24,6 +24,8 @@
    clientId?: number; // å®¢æˆ·ç¼–号
    clientCode?: string; // å®¢æˆ·ç¼–码
    clientName?: string; // å®¢æˆ·åç§°
    saleOrderId?: number; // å…³è”营销订单（ERP销售订单）编号
    saleOrderNo?: string; // å…³è”营销订单（ERP销售订单）单号
    vendorId?: number; // ä¾›åº”商编号
    vendorName?: string; // ä¾›åº”商名称
    vendorCode?: string; // ä¾›åº”商编码

 src/api/mes/qc/outsourcetest/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,64 @@
import type { PageParam, PageResult } from '@vben/request';

import { requestClient } from '#/api/request';

export namespace MesQcOutsourceTestApi {
  /** å§”外检测/试验单 */
  export interface OutsourceTest {
    id?: number;
    code?: string; // å•æ®ç¼–码
    name?: string; // å•æ®åç§°
    testType?: number; // æ£€æµ‹ç±»åž‹ï¼š1第三方检测 2委外试验
    itemId?: number; // æ£€æµ‹å¯¹è±¡ç¼–号
    itemName?: string; // æ£€æµ‹å¯¹è±¡åç§°
    testOrg?: string; // æ£€æµ‹æœºæž„
    testDate?: string; // æ£€æµ‹æ—¥æœŸ
    result?: number; // æ£€æµ‹ç»“果：1合格 2不合格
    reportNo?: string; // æ£€æµ‹æŠ¥å‘Šç¼–号
    status?: number; // çŠ¶æ€ï¼š0草稿 10已提交 20已完成
    remark?: string; // å¤‡æ³¨
    blobIds?: number[]; // é™„件
    attachmentList?: { id: number; name?: string; url?: string }[];
    createTime?: string;
  }
}

/** åˆ›å»ºå§”外检测/试验单 */
export function createTest(data: MesQcOutsourceTestApi.OutsourceTest) {
  return requestClient.post('/mes/qc/outsource-test/create', data);
}

/** æ›´æ–°å§”外检测/试验单 */
export function updateTest(data: MesQcOutsourceTestApi.OutsourceTest) {
  return requestClient.put('/mes/qc/outsource-test/update', data);
}

/** åˆ é™¤å§”外检测/试验单 */
export function deleteTest(ids: number[]) {
  return requestClient.delete('/mes/qc/outsource-test/delete', { params: { ids: ids.join(',') } });
}

/** èŽ·å–委外检测/试验单详情 */
export function getTest(id: number) {
  return requestClient.get<MesQcOutsourceTestApi.OutsourceTest>(
    `/mes/qc/outsource-test/get?id=${id}`,
  );
}

/** èŽ·å–委外检测/试验单分页 */
export function getTestPage(params: PageParam) {
  return requestClient.get<PageResult<MesQcOutsourceTestApi.OutsourceTest>>(
    '/mes/qc/outsource-test/page',
    { params },
  );
}

/** æäº¤å§”外检测/试验单 */
export function submitTest(id: number) {
  return requestClient.put(`/mes/qc/outsource-test/submit?id=${id}`);
}

/** å®Œæˆå§”外检测/试验单 */
export function finishTest(id: number) {
  return requestClient.put(`/mes/qc/outsource-test/finish?id=${id}`);
}

 src/api/wls/productissue/index.ts

@@ -16,6 +16,7 @@
    clientCode?: string; // å®¢æˆ·ç¼–码
    clientName?: string; // å®¢æˆ·åç§°
    requiredTime?: number; // éœ€æ±‚时间
    issueType?: number; // å•æ®ç±»åž‹ï¼ˆ1=正常领料，2=紧急补料）
    status?: number; // å•æ®çŠ¶æ€
    remark?: string; // å¤‡æ³¨
    createTime?: Date; // åˆ›å»ºæ—¶é—´

 src/api/wls/stocktaking/task/line/index.ts

@@ -36,6 +36,20 @@
  >('/mes/wm/stocktaking-task-line/page', { params });
}

/** ä¸‹è½½ç›˜ç‚¹å®žç›˜æ•°å¯¼å…¥æ¨¡æ¿ */
export function importStockTakingQuantityTemplate() {
  return requestClient.download('/mes/wm/stocktaking-task-line/get-import-template');
}

/** å¯¼å…¥ç›˜ç‚¹å®žç›˜æ•°é‡ */
export function importStockTakingQuantity(taskId: number, file: File) {
  return requestClient.upload<{
    successCount?: number;
    failureCount?: number;
    failureMessages?: string[];
  }>(`/mes/wm/stocktaking-task-line/import-excel?taskId=${taskId}`, { file });
}

/** æŸ¥è¯¢ç›˜ç‚¹ä»»åŠ¡è¡Œç²¾ç®€åˆ—表 */
export function getStockTakingTaskLineSimpleList(taskId: number) {
  return requestClient.get<WlsStockTakingTaskLineApi.StockTakingTaskLine[]>(

 src/api/wls/warehouse/area/index.ts

@@ -8,6 +8,7 @@
    id?: number; // åº“位编号
    code?: string; // åº“位编码
    name?: string; // åº“位名称
    type?: number; // åº“区类型
    warehouseId?: number; // ä»“库编号
    warehouseName?: string; // ä»“库名称
    locationId?: number; // åº“区编号

 src/api/wls/warehouse/index.ts

@@ -8,6 +8,7 @@
    id?: number; // ä»“库编号
    code?: string; // ä»“库编码
    name?: string; // ä»“库名称
    type?: number; // ä»“库类型
    address?: string; // åœ°å€
    area?: number; // é¢ç§¯
    chargeUserId?: number; // è´Ÿè´£äºº

 src/components/table-action/icons.ts

@@ -13,4 +13,5 @@
  CLOSE: 'lucide:x',
  BOOK: 'lucide:book',
  AUDIT: 'lucide:file-check',
  CALC: 'lucide:calculator',
};

 src/packages/constants/src/biz-mes-enum.ts

@@ -249,12 +249,16 @@
  SELF: 1, // è‡ªè¡Œç”Ÿäº§
  OUTSOURCE: 2, // ä»£å·¥
  PURCHASE: 3, // é‡‡è´­
  POWER_OPERATION: 4, // ç”µåŠ›è¿ç»´
  POWER_GENERATION: 5, // å‘电
  POWER_MAINTENANCE: 6, // æ£€ä¿®
} as const;

/** MES å·¥å•æ¥æºç±»åž‹æžšä¸¾ */
export const MesProWorkOrderSourceTypeEnum = {
  ORDER: 1, // å®¢æˆ·è®¢å•
  STORE: 2, // åº“存备货
  MAINTENANCE_PLAN: 3, // è¿ç»´è®¡åˆ’
} as const;

/** MES ç”Ÿäº§ä»»åŠ¡çŠ¶æ€æžšä¸¾ */

 src/packages/constants/src/dict-enum.ts

@@ -127,6 +127,18 @@
  CRM_SALES_TARGET_PERIOD_TYPE: 'crm_sales_target_period_type', // CRM é”€å”®ç›®æ ‡å‘¨æœŸç±»åž‹
  CRM_SALES_TARGET_DIMENSION: 'crm_sales_target_dimension', // CRM é”€å”®ç›®æ ‡ç»´åº¦
  CRM_SALES_TARGET_STATUS: 'crm_sales_target_status', // CRM é”€å”®ç›®æ ‡çŠ¶æ€
  CRM_CUSTOMER_TYPE: 'crm_customer_type', // CRM å®¢æˆ·åˆ†ç±»ï¼ˆç”µåŠ›ï¼‰
  CRM_CREDIT_LEVEL: 'crm_credit_level', // CRM å®¢æˆ·ä¿¡ç”¨ç­‰çº§
  CRM_QUOTATION_TYPE: 'crm_quotation_type', // CRM æŠ¥ä»·å•ç±»åž‹
  CRM_TARIFF_MODE: 'crm_tariff_mode', // CRM ç”µä»·æ¨¡å¼
  CRM_CONTRACT_TYPE: 'crm_contract_type', // CRM åˆåŒç±»åž‹
  CRM_VOLTAGE_LEVEL: 'crm_voltage_level', // CRM ç”µåŽ‹ç­‰çº§
  CRM_ELECTRICITY_TYPE: 'crm_electricity_type', // CRM ç”¨ç”µç±»åž‹
  CRM_METER_MODE: 'crm_meter_mode', // CRM è®¡é‡æ–¹å¼
  CRM_COMMAND_TYPE: 'crm_command_type', // CRM åˆåŒæŒ‡ä»¤ç±»åž‹
  CRM_COMMAND_STATUS: 'crm_command_status', // CRM åˆåŒæŒ‡ä»¤çŠ¶æ€
  CRM_REFUND_TYPE: 'crm_refund_type', // CRM é€€è´¹ç±»åž‹
  CRM_CANCELLATION_TYPE: 'crm_cancellation_type', // CRM é”€æˆ·ç±»åž‹
} as const;

/** ========== AFTERSALES - å”®åŽæœåŠ¡æ¨¡å— ========== */
@@ -136,6 +148,7 @@
  AFTERSALE_ISSUE_TYPE: 'aftersale_issue_type', // å”®åŽé—®é¢˜ç±»åž‹
  AFTERSALE_RETURN_TYPE: 'aftersale_return_type', // å”®åŽé€€è´§ç±»åž‹
  AFTERSALE_SEVERITY_LEVEL: 'aftersale_severity_level', // å”®åŽä¸¥é‡ç¨‹åº¦
  AFTER_SALE_COMPENSATION_TYPE: 'after_sale_compensation_type', // å”®åŽèµ”付类型
} as const;

/** ========== ERP - ä¼ä¸šèµ„源计划模块 ========== */
@@ -212,6 +225,14 @@
/** ========== MES - åˆ¶é€ æ‰§è¡Œæ¨¡å— ========== */
const MES_DICT = {
  MES_MD_ITEM_OR_PRODUCT: 'mes_md_item_or_product', // MES ç‰©æ–™/产品标识
  MES_MATERIAL_CATEGORY: 'mes_material_category', // MES ç”µåŠ›ç‰©èµ„分类
  MES_PRO_MAINTENANCE_PLAN_TYPE: 'mes_pro_maintenance_plan_type', // MES ç”µåŠ›ä½œä¸šè®¡åˆ’类型
  MES_PRO_MAINTENANCE_PLAN_STATUS: 'mes_pro_maintenance_plan_status', // MES ç”µåŠ›ä½œä¸šè®¡åˆ’状态
  MES_QC_OUTSOURCE_TEST_TYPE: 'mes_qc_outsource_test_type', // MES å§”外检测类型
  MES_QC_OUTSOURCE_TEST_RESULT: 'mes_qc_outsource_test_result', // MES å§”外检测结果
  MES_PRO_PROCESS_TYPE: 'mes_pro_process_type', // MES ç”µåŠ›å·¥è‰ºåˆ†ç±»
  MES_PRO_EMERGENCY_PLAN_TYPE: 'mes_pro_emergency_plan_type', // MES åº”急处置预案类型
  MES_PRO_CALENDAR_WORK_TYPE: 'mes_pro_calendar_work_type', // MES ç”µåŠ›è¿ç»´ä½œä¸šç±»åž‹
  MES_MD_AUTO_CODE_CYCLE_METHOD: 'mes_md_auto_code_cycle_method', // MES ç¼–码规则循环方式
  MES_MD_AUTO_CODE_PADDED_METHOD: 'mes_md_auto_code_padded_method', // MES ç¼–码规则补齐方式
  MES_MD_AUTO_CODE_PART_TYPE: 'mes_md_auto_code_part_type', // MES ç¼–码规则分段类型
@@ -252,6 +273,10 @@
  MES_PD_VERSION_CHANGE_TYPE: 'mes_pd_version_change_type', // MES ç‰ˆæœ¬å˜æ›´ç±»åž‹
  MES_PD_DOCUMENT_TYPE: 'mes_pd_document_type', // MES è®¾è®¡èµ„料类型
  MES_PD_ARCHIVE_STATUS: 'mes_pd_archive_status', // MES è®¾è®¡å½’档状态
  PRODUCT_CONDUCTOR_TYPE: 'product_conductor_type', // æ¢ä½å¯¼çº¿å¯¼ä½“类型
  PRODUCT_REEL_TYPE: 'product_reel_type', // æ¢ä½å¯¼çº¿ç›˜å…·ç±»åž‹
  PRODUCT_TECH_CONFIRM_TEMPLATE: 'product_tech_confirm_template', // æŠ€æœ¯ç¡®è®¤å‡½æ¨¡æ¿ç±»åž‹
  PRODUCT_TECH_CONFIRM_STATUS: 'product_tech_confirm_status', // æŠ€æœ¯ç¡®è®¤å‡½çŠ¶æ€
  MES_PRO_FEEDBACK_CHANNEL: 'mes_pro_feedback_channel', // MES ç”Ÿäº§æŠ¥å·¥é€”径
  MES_PRO_ANDON_STATUS: 'mes_pro_andon_status', // MES å®‰ç¯å¤„置状态
  MES_PRO_ANDON_LEVEL: 'mes_pro_andon_level', // MES å®‰ç¯çº§åˆ«
@@ -270,6 +295,7 @@
  MES_WM_BARCODE_FORMAT: 'mes_wm_barcode_format', // MES æ¡ç æ ¼å¼
  MES_WM_PACKAGE_STATUS: 'mes_wm_package_status', // MES è£…箱单状态
  MES_WM_PRODUCT_SALES_STATUS: 'mes_wm_product_sales_status', // MES é”€å”®å‡ºåº“单状态
  MES_WM_WAREHOUSE_TYPE: 'mes_wm_warehouse_type', // MES ä»“库/库区类型
  MES_WM_QUALITY_STATUS: 'mes_wm_quality_status', // MES è´¨é‡çŠ¶æ€
  MES_WM_MISC_ISSUE_TYPE: 'mes_wm_misc_issue_type', // MES æ‚项出库类型
  MES_WM_MISC_ISSUE_STATUS: 'mes_wm_misc_issue_status', // MES æ‚项出库单状态
@@ -285,6 +311,7 @@
  MES_WM_RETURN_ISSUE_STATUS: 'mes_wm_return_issue_status', // MES ç”Ÿäº§é€€æ–™å•çŠ¶æ€
  MES_WM_RETURN_ISSUE_TYPE: 'mes_wm_return_issue_type', // MES é€€æ–™ç±»åž‹
  MES_WM_PRODUCT_ISSUE_STATUS: 'mes_wm_product_issue_status', // MES é¢†æ–™å‡ºåº“单状态
  MES_WM_PRODUCT_ISSUE_TYPE: 'mes_wm_product_issue_type', // MES ç”Ÿäº§é¢†æ–™å•æ®ç±»åž‹
  MES_WM_PRODUCT_RECEIPT_STATUS: 'mes_wm_product_receipt_status', // MES äº§å“å…¥åº“单状态
  MES_WM_STOCK_TAKING_TYPE: 'mes_wm_stock_taking_type', // MES ç›˜ç‚¹ç±»åž‹
  MES_WM_STOCK_TAKING_TASK_STATUS: 'mes_wm_stock_taking_task_status', // MES ç›˜ç‚¹ä»»åŠ¡çŠ¶æ€
@@ -296,6 +323,12 @@
  MES_PD_TEMPLATE_TYPE: 'mes_pd_template_type', // MES å·¥è‰ºæ¨¡æ¿ç±»åž‹
  MES_NCR_STATUS: 'mes_ncr_status', // MES ä¸åˆæ ¼å“å¤„理单状态
  MES_NCR_DISPOSITION: 'mes_ncr_disposition', // MES ä¸åˆæ ¼å“å¤„置方式
  MES_PD_PRODUCT_ARCHIVE_TYPE: 'mes_pd_product_archive_type', // MES äº§å“æ¡£æ¡ˆç±»åž‹
  MES_PD_AUDIT_STATUS: 'mes_pd_audit_status', // MES äº§å“è®¾è®¡å®¡æ‰¹çŠ¶æ€
  MES_PD_PRODUCT_STATUS: 'mes_pd_product_status', // MES äº§å“æ¡£æ¡ˆå¯ç”¨çŠ¶æ€
  MES_PD_PRICE_OBJECT_TYPE: 'mes_pd_price_object_type', // MES å®šä»·å¯¹è±¡ç±»åž‹
  MES_PD_DISCOUNT_POLICY_TYPE: 'mes_pd_discount_policy_type', // MES ä¼˜æƒ ç­–略类型
  MES_PD_TIERED_PRICE_STATUS: 'mes_pd_tiered_price_status', // MES é˜¶æ¢¯ç”µä»·å¯ç”¨çŠ¶æ€
} as const;

/** ========== WMS - ä»“储管理模块 ========== */
@@ -317,6 +350,7 @@
const HRM_DICT = {
  HRM_DEGREE: 'hrm_degree', // HRM å­¦åŽ†
  HRM_EMPLOYEE_STATUS: 'hrm_employee_status', // HRM å‘˜å·¥çŠ¶æ€
  HRM_CERTIFICATE_TYPE: 'hrm_certificate_type', // HRM è¯ä¹¦èµ„质类型
  HRM_GENDER: 'hrm_gender', // HRM æ€§åˆ«
  HRM_AUDIT_STATUS: 'hrm_audit_status', // HRM å®¡æ‰¹çŠ¶æ€
  HRM_LEAVE_TYPE: 'hrm_leave_type', // HRM è¯·å‡ç±»åž‹
@@ -332,6 +366,10 @@
  HRM_CONTRACT_TERM_TYPE: 'hrm_contract_term_type', // HRM åˆåŒæœŸé™ç±»åž‹
  HRM_CONTRACT_STATUS: 'hrm_contract_status', // HRM åˆåŒçŠ¶æ€
  HRM_CONTRACT_TERMINATE_STATUS: 'hrm_contract_terminate_status', // HRM åˆåŒè§£é™¤ç»ˆæ­¢çŠ¶æ€
  HRM_PERFORMANCE_PERIOD_TYPE: 'hrm_performance_period_type', // HRM ç»©æ•ˆè€ƒæ ¸å‘¨æœŸç±»åž‹
  HRM_PERFORMANCE_SCOPE_TYPE: 'hrm_performance_scope_type', // HRM ç»©æ•ˆè€ƒæ ¸èŒƒå›´ç±»åž‹
  HRM_PERFORMANCE_SCORER_TYPE: 'hrm_performance_scorer_type', // HRM ç»©æ•ˆè€ƒæ ¸è¯„分人类型
  HRM_PERFORMANCE_GRADE: 'hrm_performance_grade', // HRM ç»©æ•ˆè€ƒæ ¸æ¡£çº§
} as const;

/** å­—典类型枚举 - ç»Ÿä¸€å¯¼å‡º */

 src/views/aftersales/compensation/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,245 @@
import type { VbenFormApi, VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

import { markRaw } from 'vue';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import CrmCustomerSelect from '#/components/crm-customer-select.vue';

import AfterSaleTicketSelect from './modules/ticket-select.vue';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'edit';

/** å®¡æ‰¹çŠ¶æ€å¸¸é‡ */
export const AUDIT_STATUS = {
  DRAFT: 0,
  PROCESS: 10,
  APPROVE: 20,
  REJECT: 30,
  CANCEL: 40,
};

/** è¡¨å•çš„配置项 */
export function useFormSchema(formType: FormType, formApi?: VbenFormApi): VbenFormSchema[] {
  const isReadonly = formType === 'detail';
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'compensationNo',
      label: '赔付单号',
      component: 'Input',
      componentProps: {
        placeholder: '系统自动生成',
        disabled: true,
      },
    },
    {
      fieldName: 'compensationType',
      label: '赔付类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.AFTER_SALE_COMPENSATION_TYPE, 'number'),
        placeholder: '请选择赔付类型',
        disabled: isReadonly,
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'ticketId',
      label: '关联售后工单',
      component: markRaw(AfterSaleTicketSelect),
      componentProps: {
        placeholder: '请选择售后工单',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'customerId',
      label: '客户',
      component: markRaw(CrmCustomerSelect),
      componentProps: {
        placeholder: '请选择客户',
        disabled: isReadonly,
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'saleOrderId',
      label: '关联销售订单',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 0,
        placeholder: '请输入销售订单编号',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'amount',
      label: '赔付金额',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入赔付金额',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'payee',
      label: '赔付对象',
      component: 'Input',
      componentProps: {
        placeholder: '如：张三',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'reason',
      label: '赔付原因',
      component: 'Textarea',
      formItemClass: 'col-span-3',
      componentProps: {
        placeholder: '请输入赔付原因',
        rows: 3,
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入备注',
        autoSize: { minRows: 1, maxRows: 1 },
        disabled: isReadonly,
      },
      formItemClass: 'col-span-3',
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'compensationNo',
      label: '赔付单号',
      component: 'Input',
      componentProps: {
        placeholder: '请输入赔付单号',
      },
    },
    {
      fieldName: 'compensationType',
      label: '赔付类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.AFTER_SALE_COMPENSATION_TYPE, 'number'),
        placeholder: '请选择赔付类型',
      },
    },
    {
      fieldName: 'customerId',
      label: '客户',
      component: markRaw(CrmCustomerSelect),
      componentProps: {
        placeholder: '请选择客户',
      },
    },
    {
      fieldName: 'auditStatus',
      label: '审批状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: [
          { label: '未提交', value: AUDIT_STATUS.DRAFT },
          { label: '审批中', value: AUDIT_STATUS.PROCESS },
          { label: '审核通过', value: AUDIT_STATUS.APPROVE },
          { label: '审核不通过', value: AUDIT_STATUS.REJECT },
          { label: '已取消', value: AUDIT_STATUS.CANCEL },
        ],
        placeholder: '请选择审批状态',
      },
    },
  ];
}

/** åˆ—表的表格列 */
export function useGridColumns(): VxeTableGridOptions['columns'] {
  return [
    { type: 'checkbox', width: 50 },
    { type: 'seq', title: '序号', width: 60 },
    {
      field: 'compensationNo',
      title: '赔付单号',
      minWidth: 160,
      slots: { default: 'compensationNo' },
    },
    {
      field: 'compensationType',
      title: '赔付类型',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.AFTER_SALE_COMPENSATION_TYPE },
      },
    },
    {
      field: 'customerName',
      title: '客户名称',
      minWidth: 150,
    },
    {
      field: 'amount',
      title: '赔付金额',
      width: 110,
    },
    {
      field: 'payee',
      title: '赔付对象',
      minWidth: 110,
    },
    {
      field: 'reason',
      title: '赔付原因',
      minWidth: 200,
      showOverflow: true,
    },
    {
      field: 'auditStatus',
      title: '审批状态',
      width: 110,
      slots: { default: 'auditStatus' },
    },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      field: 'action',
      title: '操作',
      width: 260,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/aftersales/compensation/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,240 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { AfterSaleCompensationApi } from '#/api/aftersales/compensation';

import { ref } from 'vue';
import { useRouter } from 'vue-router';

import { Page, useVbenModal } from '@vben/common-ui';
import { isEmpty } from '@vben/utils';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import {
  deleteCompensation,
  getApproveProcessList,
  getCompensationPage,
} from '#/api/aftersales/compensation';
import { $t } from '#/locales';

import { AUDIT_STATUS, useGridColumns, useGridFormSchema } from './data';
import AuditModal from './modules/audit-modal.vue';
import Form from './modules/form.vue';
import ProcessSelectModal from './modules/process-select-modal.vue';

/** å”®åŽèµ”付/服务补偿单列表 */
defineOptions({ name: 'AfterSaleCompensation' });

const router = useRouter();

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

const [ProcessModal, processModalApi] = useVbenModal({
  connectedComponent: ProcessSelectModal,
  destroyOnClose: true,
});

const [AuditFormModal, auditModalApi] = useVbenModal({
  connectedComponent: AuditModal,
  destroyOnClose: true,
});

function handleRefresh() {
  gridApi.query();
}

function handleCreate() {
  formModalApi.setData({ formType: 'create' }).open();
}

function handleEdit(row: AfterSaleCompensationApi.Compensation) {
  formModalApi.setData({ formType: 'edit', id: row.id }).open();
}

function handleDetail(row: AfterSaleCompensationApi.Compensation) {
  formModalApi.setData({ formType: 'detail', id: row.id }).open();
}

async function handleDelete(id: number) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting'),
    duration: 0,
  });
  try {
    await deleteCompensation(id);
    message.success($t('ui.actionMessage.deleteSuccess'));
    handleRefresh();
  } finally {
    hideLoading();
  }
}

/** æäº¤å®¡æ‰¹ - å…ˆèŽ·å–流程列表 */
async function handleSubmit(row: AfterSaleCompensationApi.Compensation) {
  const hideLoading = message.loading({
    content: '获取审批流程...',
    duration: 0,
  });
  try {
    const processList = await getApproveProcessList();
    hideLoading();
    if (!processList || processList.length === 0) {
      message.warning('暂无可用审批流程，请先配置 BPM æµç¨‹');
      return;
    }
    processModalApi.setData({ id: row.id, processList }).open();
  } catch {
    hideLoading();
  }
}

/** å®¡æ‰¹ï¼ˆé€šè¿‡/驳回） */
function handleAudit(row: AfterSaleCompensationApi.Compensation) {
  auditModalApi.setData({ id: row.id }).open();
}

/** æŸ¥çœ‹å®¡æ‰¹è¯¦æƒ… */
function handleViewProcess(row: AfterSaleCompensationApi.Compensation) {
  if (!row.processInstanceId) {
    message.warning('该单据尚未提交审批');
    return;
  }
  router.push({
    name: 'BpmProcessInstanceDetail',
    query: { id: row.processInstanceId },
  });
}

const checkedIds = ref<number[]>([]);
function handleRowCheckboxChange({
  records,
}: {
  records: AfterSaleCompensationApi.Compensation[];
}) {
  checkedIds.value = records.map((item) => item.id!);
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) => {
          return await getCompensationPage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          });
        },
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<AfterSaleCompensationApi.Compensation>,
  gridEvents: {
    checkboxAll: handleRowCheckboxChange,
    checkboxChange: handleRowCheckboxChange,
  },
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <ProcessModal @success="handleRefresh" />
    <AuditFormModal @success="handleRefresh" />
    <Grid table-title="赔付/服务补偿单列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['赔付/服务补偿单']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['aftersales:compensation:create'],
              onClick: handleCreate,
            },
          ]"
        />
      </template>
      <template #compensationNo="{ row }">
        <a class="link" @click="handleDetail(row)">{{ row.compensationNo }}</a>
      </template>
      <template #auditStatus="{ row }">
        <Tag v-if="row.auditStatus === AUDIT_STATUS.DRAFT" color="default">未提交</Tag>
        <Tag v-else-if="row.auditStatus === AUDIT_STATUS.PROCESS" color="processing">审批中</Tag>
        <Tag v-else-if="row.auditStatus === AUDIT_STATUS.APPROVE" color="success">审核通过</Tag>
        <Tag v-else-if="row.auditStatus === AUDIT_STATUS.REJECT" color="error">审核不通过</Tag>
        <Tag v-else-if="row.auditStatus === AUDIT_STATUS.CANCEL" color="warning">已取消</Tag>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['aftersales:compensation:query'],
              onClick: handleDetail.bind(null, row),
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['aftersales:compensation:update'],
              ifShow: row.auditStatus === AUDIT_STATUS.DRAFT,
              onClick: handleEdit.bind(null, row),
            },
            {
              label: '提交审批',
              type: 'link',
              auth: ['aftersales:compensation:submit'],
              ifShow: row.auditStatus === AUDIT_STATUS.DRAFT || row.auditStatus === AUDIT_STATUS.REJECT,
              onClick: handleSubmit.bind(null, row),
            },
            {
              label: '审批',
              type: 'link',
              auth: ['aftersales:compensation:audit'],
              ifShow: row.auditStatus === AUDIT_STATUS.PROCESS,
              onClick: handleAudit.bind(null, row),
            },
            {
              label: '查看审批',
              type: 'link',
              ifShow: row.auditStatus !== AUDIT_STATUS.DRAFT && !!row.processInstanceId,
              onClick: handleViewProcess.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['aftersales:compensation:delete'],
              ifShow: row.auditStatus === AUDIT_STATUS.DRAFT,
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.compensationNo]),
                confirm: handleDelete.bind(null, row.id!),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/aftersales/compensation/modules/audit-modal.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,91 @@
<script lang="ts" setup>
import { ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import { auditCompensation } from '#/api/aftersales/compensation';

const emit = defineEmits(['success']);

const compensationId = ref<number>();

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 100,
  },
  wrapperClass: 'grid-cols-1',
  layout: 'vertical',
  schema: [
    {
      fieldName: 'auditStatus',
      label: '审批结果',
      component: 'RadioGroup',
      componentProps: {
        options: [
          { label: '通过', value: 20 },
          { label: '驳回', value: 30 },
        ],
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'remark',
      label: '审批备注',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入审批备注',
        rows: 3,
      },
    },
  ],
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    try {
      const values = await formApi.getValues<{
        auditStatus: number;
        remark?: string;
      }>();
      await auditCompensation({
        id: compensationId.value!,
        auditStatus: values.auditStatus,
        remark: values.remark,
      });
      await modalApi.close();
      emit('success');
      message.success('审批完成');
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      compensationId.value = undefined;
      await formApi.resetForm();
      return;
    }
    const data = modalApi.getData<{ id: number }>();
    compensationId.value = data?.id;
    await formApi.setValues({ auditStatus: 20 });
  },
});
</script>

<template>
  <Modal title="审批赔付/服务补偿单" class="w-1/3">
    <Form class="mx-3" />
  </Modal>
</template>

 src/views/aftersales/compensation/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,95 @@
<script lang="ts" setup>
import type { AfterSaleCompensationApi } from '#/api/aftersales/compensation';

import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import {
  createCompensation,
  getCompensation,
  updateCompensation,
} from '#/api/aftersales/compensation';
import { $t } from '#/locales';

import type { FormType } from '../data';
import { useFormSchema } from '../data';

const emit = defineEmits(['success']);
const formData = ref<AfterSaleCompensationApi.Compensation>();
const formType = ref<FormType>('create');

const getTitle = computed(() => {
  if (formType.value === 'create') {
    return $t('ui.actionTitle.create', ['赔付/服务补偿单']);
  } else if (formType.value === 'edit') {
    return $t('ui.actionTitle.edit', ['赔付/服务补偿单']);
  } else {
    return '赔付/服务补偿单详情';
  }
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 120,
  },
  wrapperClass: 'grid-cols-3',
  layout: 'vertical',
  schema: [],
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data =
      (await formApi.getValues()) as AfterSaleCompensationApi.Compensation;
    try {
      await (formType.value === 'create'
        ? createCompensation(data)
        : updateCompensation(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    const data = modalApi.getData<{ formType: FormType; id?: number }>();
    formType.value = data.formType;
    formApi.setDisabled(formType.value === 'detail');
    formApi.updateSchema(useFormSchema(formType.value, formApi));
    if (!data || !data.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getCompensation(data.id);
      await formApi.setValues(formData.value);
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal :title="getTitle" class="w-2/3" :show-confirm-button="formType !== 'detail'">
    <Form class="mx-3" />
  </Modal>
</template>

 src/views/aftersales/compensation/modules/process-select-modal.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,78 @@
<script lang="ts" setup>
import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message, Select } from 'ant-design-vue';

import { submitCompensation } from '#/api/aftersales/compensation';

interface ProcessDefinition {
  id: string;
  name: string;
  version: number;
  key: string;
}

const emit = defineEmits(['success']);

const compensationId = ref<number>();
const processList = ref<ProcessDefinition[]>([]);
const selectedProcessKey = ref<string>('');

const processOptions = computed(() => {
  return processList.value.map((p) => ({
    label: `${p.name} (V${p.version})`,
    value: p.key,
  }));
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    if (!selectedProcessKey.value) {
      message.warning('请选择审批流程');
      return;
    }
    modalApi.lock();
    try {
      await submitCompensation(compensationId.value!, selectedProcessKey.value);
      await modalApi.close();
      emit('success');
      message.success('提交成功');
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      compensationId.value = undefined;
      selectedProcessKey.value = '';
      processList.value = [];
      return;
    }
    const data = modalApi.getData<{ id: number; processList: ProcessDefinition[] }>();
    if (!data) {
      return;
    }
    compensationId.value = data.id;
    processList.value = data.processList || [];
    if (processList.value.length > 0) {
      selectedProcessKey.value = processList.value[0]?.key ?? '';
    }
  },
});
</script>

<template>
  <Modal title="选择审批流程" class="w-1/3">
    <div class="mb-4">
      <span class="mr-2">审批流程：</span>
      <Select
        v-model:value="selectedProcessKey"
        :options="processOptions"
        style="width: 200px"
        placeholder="请选择审批流程"
      />
    </div>
  </Modal>
</template>

 src/views/aftersales/compensation/modules/ticket-select.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,70 @@
<script lang="ts" setup>
import type { AftersalesTicketApi } from '#/api/aftersales/ticket';

import { computed, onMounted, ref } from 'vue';

import { Select } from 'ant-design-vue';

import { getTicketPage } from '#/api/aftersales/ticket';

defineOptions({ name: 'AfterSaleTicketSelect', inheritAttrs: false });

const props = withDefaults(
  defineProps<{
    allowClear?: boolean;
    disabled?: boolean;
    modelValue?: number;
    placeholder?: string;
  }>(),
  {
    allowClear: true,
    disabled: false,
    modelValue: undefined,
    placeholder: '请选择售后工单',
  },
);

const emit = defineEmits<{
  'update:modelValue': [value: number | undefined];
}>();

const ticketList = ref<AftersalesTicketApi.Ticket[]>([]);

const selectValue = computed({
  get: () => props.modelValue,
  set: (value: number | undefined) => {
    emit('update:modelValue', value);
  },
});

async function loadTickets() {
  const { list } = await getTicketPage({ pageNo: 1, pageSize: 200 });
  ticketList.value = list || [];
}

onMounted(loadTickets);
</script>

<template>
  <Select
    v-bind="$attrs"
    v-model:value="selectValue"
    :allow-clear="allowClear"
    :disabled="disabled"
    :field-names="{ label: 'no', value: 'id' }"
    :options="ticketList"
    :placeholder="placeholder"
    class="w-full"
    option-filter-prop="no"
    show-search
  >
    <template #option="{ value: id, label: no }">
      <div class="flex items-center gap-2">
        <span>{{ no }}</span>
        <span class="text-xs text-gray-400">
          {{ ticketList.find((t) => t.id === id)?.name }}
        </span>
      </div>
    </template>
  </Select>
</template>

 src/views/aftersales/ticket/data.ts

@@ -25,6 +25,10 @@
  { label: '一般问题', value: 1 },
  { label: '维修问题', value: 2 },
  { label: '退货问题', value: 3 },
  { label: '停电报修', value: 4 },
  { label: '用电故障', value: 5 },
  { label: '服务投诉', value: 6 },
  { label: '供电质量异议', value: 7 },
];

/** ä¸¥é‡ç¨‹åº¦é€‰é¡¹ */

 src/views/bi/decision/alert-center/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,179 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { DecisionAlertApi } from '#/api/bi/decision/alert';

import { onMounted, reactive, ref } from 'vue';

import { Page } from '@vben/common-ui';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import { confirmAlert, getAlertPage, getUnprocessedCount, handleAlert } from '#/api/bi/decision/alert';

defineOptions({ name: 'DecisionAlertCenter' });

const unprocessedCount = ref(0);
const queryParams = reactive<Record<string, unknown>>({});

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: [
      {
        fieldName: 'status',
        label: '状态',
        component: 'Select',
        componentProps: {
          options: [
            { label: '全部', value: '' },
            { label: '未处理', value: 0 },
            { label: '已确认', value: 1 },
            { label: '已处理', value: 2 },
          ],
          allowClear: true,
        },
      },
      {
        fieldName: 'severity',
        label: '严重级别',
        component: 'Select',
        componentProps: {
          options: [
            { label: '全部', value: '' },
            { label: '警告', value: 1 },
            { label: '严重', value: 2 },
            { label: '紧急', value: 3 },
          ],
          allowClear: true,
        },
      },
    ],
  },
  gridOptions: {
    columns: [
      { field: 'id', title: 'ID', width: 60 },
      { field: 'kpiName', title: 'KPI名称', width: 140 },
      {
        field: 'severity', title: '严重级别', width: 90,
        slots: { default: 'severitySlot' },
      },
      {
        field: 'actualValue', title: '实际值', width: 100,
        formatter: ({ cellValue }: any) => cellValue?.toLocaleString(),
      },
      {
        field: 'thresholdValue', title: '阈值', width: 100,
        formatter: ({ cellValue }: any) => cellValue?.toLocaleString(),
      },
      { field: 'alertMessage', title: '预警消息', minWidth: 200 },
      {
        field: 'status', title: '状态', width: 80,
        slots: { default: 'statusSlot' },
      },
      { field: 'triggeredTime', title: '触发时间', width: 170 },
      { field: 'handleRemark', title: '处理备注', width: 140 },
      {
        title: '操作', width: 160,
        slots: { default: 'actionSlot' },
        fixed: 'right',
      },
    ],
    height: 'auto',
    proxyConfig: {
      ajax: {
        query: async ({ page, form }: any) => {
          const res = await getAlertPage({ ...page, ...form, ...queryParams });
          return res;
        },
      },
    },
  } as VxeTableGridOptions<DecisionAlertApi.AlertRecord>,
});

async function loadUnprocessed() {
  try {
    unprocessedCount.value = await getUnprocessedCount();
  } catch {
    // ignore
  }
}

async function handleConfirm(row: DecisionAlertApi.AlertRecord) {
  const hide = message.loading('确认中...', 0);
  try {
    await confirmAlert(row.id);
    message.success('已确认');
    gridApi.query();
    loadUnprocessed();
  } finally {
    hide();
  }
}

async function handleProcess(row: DecisionAlertApi.AlertRecord) {
  const hide = message.loading('处理中...', 0);
  try {
    await handleAlert(row.id, '已处理');
    message.success('已处理');
    gridApi.query();
    loadUnprocessed();
  } finally {
    hide();
  }
}

function severityColor(severity: number): string {
  if (severity === 3) return 'red';
  if (severity === 2) return 'orange';
  return 'blue';
}

function severityText(severity: number): string {
  if (severity === 3) return '紧急';
  if (severity === 2) return '严重';
  return '警告';
}

function statusColor(status: number): string {
  if (status === 0) return 'red';
  if (status === 1) return 'blue';
  return 'green';
}

function statusText(status: number): string {
  if (status === 0) return '未处理';
  if (status === 1) return '已确认';
  return '已处理';
}

onMounted(() => {
  loadUnprocessed();
});
</script>

<template>
  <Page :auto-content-height="true">
    <div class="mb-3">
      <span class="text-lg font-bold">预警中心</span>
      <Tag v-if="unprocessedCount > 0" color="red" class="ml-2">
        {{ unprocessedCount }} æ¡æœªå¤„理
      </Tag>
    </div>
    <Grid>
      <template #severitySlot="{ row }">
        <Tag :color="severityColor(row.severity)">{{ severityText(row.severity) }}</Tag>
      </template>
      <template #statusSlot="{ row }">
        <Tag :color="statusColor(row.status)">{{ statusText(row.status) }}</Tag>
      </template>
      <template #actionSlot="{ row }">
        <TableAction
          :actions="[
            { label: '确认', type: 'link', icon: ACTION_ICON.AUDIT, ifShow: row.status === 0, onClick: handleConfirm.bind(null, row) },
            { label: '处理', type: 'link', icon: ACTION_ICON.EDIT, ifShow: row.status < 2, onClick: handleProcess.bind(null, row) },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/bi/decision/alert-rule/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,119 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

export function useGridColumns(): VxeTableGridOptions['columns'] {
  return [
    { field: 'id', title: 'ID', width: 60 },
    { field: 'name', title: '规则名称', width: 150 },
    {
      field: 'severity', title: '严重级别', width: 90,
      slots: { default: 'severitySlot' },
    },
    { field: 'comparisonOperator', title: '运算符', width: 70 },
    { field: 'thresholdValue', title: '阈值', width: 100 },
    {
      field: 'enabled', title: '启用', width: 70,
      slots: { default: 'enabledSlot' },
    },
    {
      title: '操作', width: 160,
      slots: { default: 'actionSlot' },
      fixed: 'right',
    },
  ];
}

export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'enabled',
      label: '状态',
      component: 'Select',
      componentProps: {
        options: [
          { label: '全部', value: '' },
          { label: '启用', value: 1 },
          { label: '禁用', value: 0 },
        ],
        allowClear: true,
      },
    },
  ];
}

export function useFormSchema(kpiOptions: { label: string; value: number }[]): VbenFormSchema[] {
  return [
    {
      fieldName: 'kpiId',
      label: '关联KPI',
      component: 'Select',
      componentProps: { options: kpiOptions },
      rules: 'required',
    },
    {
      fieldName: 'name',
      label: '规则名称',
      component: 'Input',
      componentProps: { placeholder: '请输入规则名称' },
      rules: 'required',
    },
    {
      fieldName: 'severity',
      label: '严重级别',
      component: 'Select',
      componentProps: {
        options: [
          { label: '警告', value: 1 },
          { label: '严重', value: 2 },
          { label: '紧急', value: 3 },
        ],
      },
      rules: 'required',
    },
    {
      fieldName: 'comparisonOperator',
      label: '比较运算符',
      component: 'Select',
      componentProps: {
        options: [
          { label: '大于 >', value: '>' },
          { label: '小于 <', value: '<' },
          { label: '大于等于 >=', value: '>=' },
          { label: '小于等于 <=', value: '<=' },
        ],
      },
      rules: 'required',
    },
    {
      fieldName: 'thresholdValue', label: '阈值', component: 'InputNumber',
      componentProps: { placeholder: '阈值', style: 'width:100%' },
      rules: 'required',
    },
    {
      fieldName: 'enabled',
      label: '启用',
      component: 'Switch',
      componentProps: { checkedValue: 1, unCheckedValue: 0 },
    },
    {
      fieldName: 'notificationType', label: '通知方式', component: 'Input',
      componentProps: { placeholder: 'system/message/email' },
    },
    {
      fieldName: 'remark', label: '备注', component: 'InputTextArea',
      componentProps: { placeholder: '备注', rows: 2 },
    },
  ];
}

export function severityColor(severity: number): string {
  if (severity === 3) return 'red';
  if (severity === 2) return 'orange';
  return 'blue';
}

export function severityText(severity: number): string {
  if (severity === 3) return '紧急';
  if (severity === 2) return '严重';
  return '警告';
}

 src/views/bi/decision/alert-rule/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,88 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { DecisionAlertApi } from '#/api/bi/decision/alert';

import { Page, useVbenModal } from '@vben/common-ui';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import { deleteAlertRule, getAlertRulePage } from '#/api/bi/decision/alert';

import { severityColor, severityText, useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';

defineOptions({ name: 'DecisionAlertRule' });

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    proxyConfig: {
      ajax: {
        query: async ({ page, form }: any) => {
          const res = await getAlertRulePage({ ...page, ...form });
          return res;
        },
      },
    },
  } as VxeTableGridOptions<DecisionAlertApi.AlertRule>,
});

function handleRefresh() {
  gridApi.query();
}

function handleCreate() {
  formModalApi.setData(null).open();
}

function handleEdit(row: DecisionAlertApi.AlertRule) {
  formModalApi.setData(row).open();
}

async function handleDelete(row: DecisionAlertApi.AlertRule) {
  const hide = message.loading(`正在删除「${row.name}」...`, 0);
  try {
    await deleteAlertRule(row.id!);
    message.success('删除成功');
    handleRefresh();
  } finally {
    hide();
  }
}
</script>

<template>
  <Page :auto-content-height="true">
    <div class="mb-3 flex items-center justify-between">
      <span class="text-lg font-bold">预警规则配置</span>
      <a-button type="primary" @click="handleCreate">新增</a-button>
    </div>
    <Grid>
      <template #severitySlot="{ row }">
        <Tag :color="severityColor(row.severity)">{{ severityText(row.severity) }}</Tag>
      </template>
      <template #enabledSlot="{ row }">
        <Tag :color="row.enabled === 1 ? 'green' : 'default'">{{ row.enabled === 1 ? '启用' : '禁用' }}</Tag>
      </template>
      <template #actionSlot="{ row }">
        <TableAction
          :actions="[
            { label: '编辑', type: 'link', icon: ACTION_ICON.EDIT, onClick: handleEdit.bind(null, row) },
            { label: '删除', type: 'link', danger: true, icon: ACTION_ICON.DELETE, onClick: handleDelete.bind(null, row) },
          ]"
        />
      </template>
    </Grid>
    <FormModal />
  </Page>
</template>

 src/views/bi/decision/alert-rule/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,95 @@
<script lang="ts" setup>
import type { DecisionAlertApi } from '#/api/bi/decision/alert';

import { computed, onMounted, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import { createAlertRule, getAlertRule, updateAlertRule } from '#/api/bi/decision/alert';
import { getKpiDefinitionList } from '#/api/bi/decision/kpi';

import { useFormSchema } from '../data';

const emit = defineEmits(['success']);
const formData = ref<DecisionAlertApi.AlertRule>();
const kpiOptions = ref<{ label: string; value: number }[]>([]);

const getTitle = computed(() => {
  return formData.value?.id ? '编辑预警规则' : '新增预警规则';
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: { class: 'w-full' },
    formItemClass: 'col-span-2',
    labelWidth: 120,
  },
  layout: 'horizontal',
  schema: useFormSchema([]),
  showDefaultActions: false,
});

async function refreshKpiOptions() {
  try {
    const res: any = await getKpiDefinitionList();
    const list = res?.list || [];
    kpiOptions.value = list.map((k: any) => ({ label: `${k.name}(${k.code})`, value: k.id }));
    formApi.setState((prev) => ({
      ...prev,
      schema: useFormSchema(kpiOptions.value),
    }));
  } catch {
    // ignore
  }
}

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data = (await formApi.getValues()) as DecisionAlertApi.AlertRule;
    try {
      await (formData.value?.id ? updateAlertRule(data) : createAlertRule(data));
      await modalApi.close();
      emit('success');
      message.success('操作成功');
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    await refreshKpiOptions();
    const data = modalApi.getData<DecisionAlertApi.AlertRule>();
    if (!data || !data.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getAlertRule(data.id);
      await formApi.setValues(formData.value);
    } finally {
      modalApi.unlock();
    }
  },
});

onMounted(() => {
  refreshKpiOptions();
});
</script>

<template>
  <Modal :title="getTitle">
    <Form class="mx-4" />
  </Modal>
</template>

 src/views/bi/decision/forecast-analysis/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,227 @@
<script lang="ts" setup>
import { onMounted, ref } from 'vue';

import { Page, useVbenModal } from '@vben/common-ui';

import { DatePicker, message, Select, Spin } from 'ant-design-vue';
import dayjs from 'dayjs';

import { useVbenForm } from '#/adapter/form';
import {
  generateForecastWorkOrder,
  getForecastList,
} from '#/api/bi/decision/forecast';

defineOptions({ name: 'DecisionForecastAnalysis' });

const loading = ref(false);
const forecastData = ref<any[]>([]);
const forecastCode = ref('load_forecast_daily');

const FORECAST_OPTIONS = [
  { label: '日负荷预测', value: 'load_forecast_daily' },
  { label: '周负荷预测', value: 'load_forecast_weekly' },
  { label: '月负荷预测', value: 'load_forecast_monthly' },
];

const WORK_ORDER_TYPE_OPTIONS = [
  { label: '电力运维', value: 4 },
  { label: '发电', value: 5 },
  { label: '检修', value: 6 },
];

async function loadData() {
  loading.value = true;
  try {
    forecastData.value = await getForecastList(forecastCode.value);
  } catch {
    forecastData.value = [];
  } finally {
    loading.value = false;
  }
}

onMounted(loadData);

/** ========== ç”Ÿæˆå·¥å• ========== */
const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 100,
  },
  wrapperClass: 'grid-cols-1',
  layout: 'vertical',
  schema: [
    {
      fieldName: 'forecastId',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'workOrderName',
      label: '工单名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入工单名称',
      },
    },
    {
      fieldName: 'workOrderType',
      label: '工单类型',
      component: 'Select',
      componentProps: {
        options: WORK_ORDER_TYPE_OPTIONS,
        placeholder: '请选择工单类型',
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'requestDate',
      label: '需求日期',
      component: 'DatePicker',
      componentProps: {
        placeholder: '请选择需求日期',
        valueFormat: 'YYYY-MM-DD HH:mm:ss',
      },
    },
    {
      fieldName: 'quantity',
      label: '生产数量',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入生产数量',
      },
      rules: 'required',
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入备注',
        rows: 3,
      },
    },
  ],
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    try {
      const values = await formApi.getValues<{
        forecastId: number;
        workOrderName?: string;
        workOrderType: number;
        requestDate?: string;
        quantity: number;
        remark?: string;
      }>();
      await generateForecastWorkOrder({
        forecastId: Number(values.forecastId),
        workOrderName: values.workOrderName,
        workOrderType: Number(values.workOrderType),
        requestDate: values.requestDate,
        quantity: Number(values.quantity ?? 1),
        remark: values.remark,
      });
      await modalApi.close();
      message.success('工单生成成功');
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      return;
    }
    const data = modalApi.getData<{ item: any }>();
    const item = data?.item;
    await formApi.resetForm();
    await formApi.setValues({
      forecastId: item?.id,
      workOrderType: 4,
      requestDate: item?.pointTime ?? dayjs().format('YYYY-MM-DD HH:mm:ss'),
      quantity: item?.forecastValue ?? 1,
      remark: `由负荷预测（${item?.forecastName ?? forecastCode.value}）自动生成`,
    });
  },
});

function handleGenerate(item: any) {
  modalApi.setData({ item }).open();
}
</script>

<template>
  <Page :auto-content-height="true">
    <Modal title="负荷预测生成生产工单" class="w-1/2">
      <Form class="mx-3" />
    </Modal>
    <div class="p-4">
      <div class="mb-4 flex items-center gap-4">
        <h2 class="text-lg font-bold">负荷预测</h2>
        <Select
          v-model:value="forecastCode"
          :options="FORECAST_OPTIONS"
          style="width: 180px"
          @change="loadData"
        />
      </div>

      <Spin :spinning="loading">
        <div v-if="forecastData.length === 0" class="py-12 text-center text-gray-400">
          æš‚无预测数据，请先配置 KPI æŒ‡æ ‡å’Œé¢„警规则后查看
        </div>
        <div v-else class="grid grid-cols-1 gap-4 lg:grid-cols-2">
          <div
            v-for="item in forecastData"
            :key="item.id"
            class="rounded-lg border p-4"
          >
            <div class="mb-2 flex items-center justify-between">
              <span class="font-medium">{{ item.forecastName }}</span>
              <span class="text-xs text-gray-400">{{ item.pointTime }}</span>
            </div>
            <div class="mb-1 text-2xl font-bold">
              {{ item.forecastValue ?? '-' }}
              <span class="ml-1 text-sm font-normal text-gray-400">(预测)</span>
            </div>
            <div v-if="item.actualValue != null" class="text-sm text-gray-500">
              å®žé™…值: {{ item.actualValue }}
              <span v-if="item.lowerBound != null" class="ml-2">
                ç½®ä¿¡åŒºé—´: [{{ item.lowerBound }} ~ {{ item.upperBound }}]
              </span>
            </div>
            <div v-if="item.dimension" class="mt-1 text-xs text-gray-400">
              {{ item.dimension }}: {{ item.dimensionValue }}
            </div>
            <div class="mt-3">
              <a-button
                type="primary"
                ghost
                size="small"
                @click="handleGenerate(item)"
              >
                ç”Ÿæˆå·¥å•
              </a-button>
            </div>
          </div>
        </div>
      </Spin>
    </div>
  </Page>
</template>

 src/views/bi/decision/kpi-config/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,154 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

export function useGridColumns(): VxeTableGridOptions['columns'] {
  return [
    { field: 'code', title: 'KPI编码', width: 140 },
    { field: 'name', title: 'KPI名称', width: 150 },
    {
      field: 'category', title: '分类', width: 100,
      slots: { default: 'categorySlot' },
    },
    { field: 'unit', title: '单位', width: 70 },
    { field: 'chartType', title: '图表类型', width: 90 },
    {
      field: 'status', title: '状态', width: 70,
      slots: { default: 'statusSlot' },
    },
    { field: 'sort', title: '排序', width: 60 },
    {
      title: '操作', width: 160,
      slots: { default: 'actionSlot' },
      fixed: 'right',
    },
  ];
}

export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'name',
      label: 'KPI名称',
      component: 'Input',
      componentProps: { placeholder: '请输入KPI名称' },
    },
    {
      fieldName: 'category',
      label: '分类',
      component: 'Select',
      componentProps: {
        options: [
          { label: '全部', value: '' },
          { label: '供电量', value: 'power_supply' },
          { label: '设备运行', value: 'device_operation' },
          { label: '生产', value: 'production' },
          { label: '质量', value: 'quality' },
          { label: '采购', value: 'procurement' },
          { label: '安全', value: 'safety' },
        ],
        allowClear: true,
      },
    },
    {
      fieldName: 'status',
      label: '状态',
      component: 'Select',
      componentProps: {
        options: [
          { label: '全部', value: '' },
          { label: '启用', value: 1 },
          { label: '禁用', value: 0 },
        ],
        allowClear: true,
      },
    },
  ];
}

export function useFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'code',
      label: 'KPI编码',
      component: 'Input',
      componentProps: { placeholder: '请输入KPI编码（唯一）' },
      rules: 'required',
    },
    {
      fieldName: 'name',
      label: 'KPI名称',
      component: 'Input',
      componentProps: { placeholder: '请输入KPI名称' },
      rules: 'required',
    },
    {
      fieldName: 'category',
      label: '分类',
      component: 'Select',
      componentProps: {
        options: [
          { label: '供电量', value: 'power_supply' },
          { label: '设备运行', value: 'device_operation' },
          { label: '生产', value: 'production' },
          { label: '质量', value: 'quality' },
          { label: '采购', value: 'procurement' },
          { label: '安全', value: 'safety' },
        ],
      },
      rules: 'required',
    },
    { fieldName: 'unit', label: '单位', component: 'Input', componentProps: { placeholder: '单位' } },
    {
      fieldName: 'chartType',
      label: '图表类型',
      component: 'Select',
      componentProps: {
        options: [
          { label: '数字卡片', value: 'number' },
          { label: '柱状图', value: 'bar' },
          { label: '折线图', value: 'line' },
          { label: '饼图', value: 'pie' },
        ],
      },
    },
    {
      fieldName: 'comparisonOperator',
      label: '比较运算符',
      component: 'Select',
      componentProps: {
        options: [
          { label: '大于 >', value: '>' },
          { label: '小于 <', value: '<' },
          { label: '大于等于 >=', value: '>=' },
          { label: '小于等于 <=', value: '<=' },
        ],
      },
    },
    { fieldName: 'thresholdWarn', label: '警告阈值', component: 'InputNumber', componentProps: { placeholder: '警告阈值', style: 'width:100%' } },
    { fieldName: 'thresholdCritical', label: '严重阈值', component: 'InputNumber', componentProps: { placeholder: '严重阈值', style: 'width:100%' } },
    { fieldName: 'refreshInterval', label: '刷新间隔(秒)', component: 'InputNumber', componentProps: { placeholder: '默认300', style: 'width:100%' } },
    { fieldName: 'sort', label: '排序', component: 'InputNumber', componentProps: { placeholder: '排序号', style: 'width:100%' } },
    {
      fieldName: 'status',
      label: '状态',
      component: 'Select',
      componentProps: {
        options: [
          { label: '启用', value: 1 },
          { label: '禁用', value: 0 },
        ],
      },
    },
    { fieldName: 'querySql', label: '查询SQL', component: 'InputTextArea', componentProps: { placeholder: 'SELECT SUM(...) FROM ...', rows: 3 } },
    { fieldName: 'remark', label: '备注', component: 'InputTextArea', componentProps: { placeholder: '备注', rows: 2 } },
  ];
}

export const CATEGORY_MAP: Record<string, string> = {
  power_supply: '供电量',
  device_operation: '设备运行',
  production: '生产',
  quality: '质量',
  procurement: '采购',
  safety: '安全',
};

 src/views/bi/decision/kpi-config/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,88 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { DecisionKpiApi } from '#/api/bi/decision/kpi';

import { Page, useVbenModal } from '@vben/common-ui';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import { deleteKpiDefinition, getKpiDefinitionPage } from '#/api/bi/decision/kpi';

import { CATEGORY_MAP, useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';

defineOptions({ name: 'DecisionKpiConfig' });

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    proxyConfig: {
      ajax: {
        query: async ({ page, form }: any) => {
          const res = await getKpiDefinitionPage({ ...page, ...form });
          return res;
        },
      },
    },
  } as VxeTableGridOptions<DecisionKpiApi.KpiDefinition>,
});

function handleRefresh() {
  gridApi.query();
}

function handleCreate() {
  formModalApi.setData(null).open();
}

function handleEdit(row: DecisionKpiApi.KpiDefinition) {
  formModalApi.setData(row).open();
}

async function handleDelete(row: DecisionKpiApi.KpiDefinition) {
  const hide = message.loading(`正在删除「${row.name}」...`, 0);
  try {
    await deleteKpiDefinition(row.id!);
    message.success(`删除「${row.name}」成功`);
    handleRefresh();
  } finally {
    hide();
  }
}
</script>

<template>
  <Page :auto-content-height="true">
    <div class="mb-3 flex items-center justify-between">
      <span class="text-lg font-bold">KPI指标定义</span>
      <a-button type="primary" @click="handleCreate">新增</a-button>
    </div>
    <Grid>
      <template #categorySlot="{ row }">
        <Tag color="blue">{{ CATEGORY_MAP[row.category] || row.category }}</Tag>
      </template>
      <template #statusSlot="{ row }">
        <Tag :color="row.status === 1 ? 'green' : 'default'">{{ row.status === 1 ? '启用' : '禁用' }}</Tag>
      </template>
      <template #actionSlot="{ row }">
        <TableAction
          :actions="[
            { label: '编辑', type: 'link', icon: ACTION_ICON.EDIT, onClick: handleEdit.bind(null, row) },
            { label: '删除', type: 'link', danger: true, icon: ACTION_ICON.DELETE, onClick: handleDelete.bind(null, row) },
          ]"
        />
      </template>
    </Grid>
    <FormModal />
  </Page>
</template>

 src/views/bi/decision/kpi-config/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,74 @@
<script lang="ts" setup>
import type { DecisionKpiApi } from '#/api/bi/decision/kpi';

import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import { createKpiDefinition, getKpiDefinition, updateKpiDefinition } from '#/api/bi/decision/kpi';

import { useFormSchema } from '../data';

const emit = defineEmits(['success']);
const formData = ref<DecisionKpiApi.KpiDefinition>();

const getTitle = computed(() => {
  return formData.value?.id ? '编辑KPI指标' : '新增KPI指标';
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: { class: 'w-full' },
    formItemClass: 'col-span-2',
    labelWidth: 120,
  },
  layout: 'horizontal',
  schema: useFormSchema(),
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data = (await formApi.getValues()) as DecisionKpiApi.KpiDefinition;
    try {
      await (formData.value?.id ? updateKpiDefinition(data) : createKpiDefinition(data));
      await modalApi.close();
      emit('success');
      message.success('操作成功');
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    const data = modalApi.getData<DecisionKpiApi.KpiDefinition>();
    if (!data || !data.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getKpiDefinition(data.id);
      await formApi.setValues(formData.value);
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal :title="getTitle">
    <Form class="mx-4" />
  </Modal>
</template>

 src/views/bi/decision/kpi-dashboard/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
<script lang="ts" setup>
import { onMounted, ref } from 'vue';

import { Page } from '@vben/common-ui';

import { Spin, Tag } from 'ant-design-vue';

import { getKpiOverview } from '#/api/bi/decision/kpi';
import type { DecisionKpiApi } from '#/api/bi/decision/kpi';

defineOptions({ name: 'DecisionKpiDashboard' });

const loading = ref(true);
const overview = ref<DecisionKpiApi.KpiOverview>({ kpis: [], total: 0 });

async function loadData() {
  loading.value = true;
  try {
    overview.value = await getKpiOverview();
  } catch {
    // ignore
  } finally {
    loading.value = false;
  }
}

const CATEGORY_MAP: Record<string, string> = {
  power_supply: '供电量',
  device_operation: '设备运行',
  production: '生产',
  quality: '质量',
  procurement: '采购',
  safety: '安全',
};

const CATEGORY_COLORS: Record<string, string> = {
  power_supply: '#1677ff',
  device_operation: '#722ed1',
  production: '#13c2c2',
  quality: '#52c41a',
  procurement: '#fa8c16',
  safety: '#ff4d4f',
};

function alertStatusColor(status: string): string {
  if (status === 'critical') return 'red';
  if (status === 'warn') return 'orange';
  return 'green';
}

function alertStatusText(status: string): string {
  if (status === 'critical') return '严重';
  if (status === 'warn') return '警告';
  return '正常';
}

onMounted(loadData);
</script>

<template>
  <Page :auto-content-height="true">
    <Spin :spinning="loading">
      <div class="p-4">
        <h2 class="mb-4 text-lg font-bold">电力 KPI çœ‹æ¿</h2>
        <div class="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4">
          <div
            v-for="kpi in overview.kpis"
            :key="kpi.code"
            class="rounded-lg border p-4 shadow-sm transition-shadow hover:shadow-md"
            :style="{ borderTop: `3px solid ${CATEGORY_COLORS[kpi.category] || '#1677ff'}` }"
          >
            <div class="mb-1 flex items-center justify-between">
              <span class="text-xs text-gray-500">{{ CATEGORY_MAP[kpi.category] || kpi.category }}</span>
              <Tag :color="alertStatusColor(kpi.alertStatus)">
                {{ alertStatusText(kpi.alertStatus) }}
              </Tag>
            </div>
            <div class="mb-1 text-2xl font-bold">
              {{ kpi.value ?? '-' }}
            </div>
            <div class="flex items-center justify-between">
              <span class="text-sm font-medium">{{ kpi.name }}</span>
              <span class="text-xs text-gray-400">{{ kpi.unit || '' }}</span>
            </div>
          </div>
        </div>
      </div>
    </Spin>
  </Page>
</template>

 src/views/bi/decision/trend-analysis/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,87 @@
<script lang="ts" setup>
import { onMounted, ref } from 'vue';

import { Page } from '@vben/common-ui';

import { Select, Spin, Table } from 'ant-design-vue';

import { getKpiOverview } from '#/api/bi/decision/kpi';

defineOptions({ name: 'DecisionTrendAnalysis' });

const loading = ref(false);
const trendData = ref<any[]>([]);
const selectedCategory = ref<string>('');

const CATEGORY_OPTIONS = [
  { label: '全部', value: '' },
  { label: '供电量', value: 'power_supply' },
  { label: '设备运行', value: 'device_operation' },
  { label: '生产', value: 'production' },
  { label: '质量', value: 'quality' },
  { label: '采购', value: 'procurement' },
  { label: '安全', value: 'safety' },
];

const columns = [
  { title: 'KPI名称', dataIndex: 'name', key: 'name', width: 150 },
  { title: '分类', dataIndex: 'category', key: 'category', width: 100 },
  { title: '当前值', dataIndex: 'value', key: 'value', width: 120 },
  { title: '单位', dataIndex: 'unit', key: 'unit', width: 80 },
  { title: '预警状态', dataIndex: 'alertStatus', key: 'alertStatus', width: 100 },
];

async function loadData() {
  loading.value = true;
  try {
    const overview = await getKpiOverview();
    let list = overview.kpis || [];
    if (selectedCategory.value) {
      list = list.filter((k) => k.category === selectedCategory.value);
    }
    trendData.value = list;
  } catch {
    trendData.value = [];
  } finally {
    loading.value = false;
  }
}

onMounted(loadData);
</script>

<template>
  <Page :auto-content-height="true">
    <div class="p-4">
      <div class="mb-4 flex items-center gap-4">
        <h2 class="text-lg font-bold">趋势分析</h2>
        <Select
          v-model:value="selectedCategory"
          :options="CATEGORY_OPTIONS"
          style="width: 160px"
          allow-clear
          @change="loadData"
        />
      </div>

      <Spin :spinning="loading">
        <Table
          :columns="columns"
          :data-source="trendData"
          :pagination="{ pageSize: 20 }"
          row-key="code"
          bordered
          size="middle"
        >
          <template #bodyCell="{ column, record }">
            <template v-if="column.key === 'alertStatus'">
              <span v-if="record.alertStatus === 'critical'" class="text-red-500">严重</span>
              <span v-else-if="record.alertStatus === 'warn'" class="text-orange-500">警告</span>
              <span v-else class="text-green-500">正常</span>
            </template>
          </template>
        </Table>
      </Spin>
    </div>
  </Page>
</template>

 src/views/crm/cancellation/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,227 @@
import type { VbenFormApi, VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { CrmCancellationApi } from '#/api/crm/cancellation';
import type { CrmCustomerApi } from '#/api/crm/customer';

import { markRaw } from 'vue';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import CrmCustomerSelect from '#/components/crm-customer-select.vue';

/** æ–°å¢ž/修改销户申请 */
export function useFormSchema(
  formApi?: VbenFormApi,
): VbenFormSchema[] {
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'cancellationNo',
      label: '销户编号',
      component: 'Input',
      componentProps: {
        placeholder: '不填则自动生成',
      },
    },
    {
      fieldName: 'customerId',
      label: '客户',
      component: markRaw(CrmCustomerSelect),
      componentProps: {
        placeholder: '请选择客户',
        onChange: (item?: CrmCustomerApi.Customer) => {
          formApi?.setFieldValue('customerName', item?.name);
        },
      },
      rules: 'required',
    },
    {
      fieldName: 'customerName',
      label: '客户名称',
      component: 'Input',
      componentProps: {
        placeholder: '客户名称',
        readonly: true,
      },
    },
    {
      fieldName: 'cancellationType',
      label: '销户类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.CRM_CANCELLATION_TYPE),
        placeholder: '请选择销户类型',
      },
      rules: 'required',
    },
    {
      fieldName: 'contractNo',
      label: '合同编号',
      component: 'Input',
      componentProps: {
        placeholder: '请输入关联合同编号',
      },
    },
    {
      fieldName: 'expectedCancelDate',
      label: '预计销户日期',
      component: 'DatePicker',
      componentProps: {
        class: '!w-full',
        format: 'YYYY-MM-DD',
        valueFormat: 'YYYY-MM-DD',
      },
    },
    {
      fieldName: 'actualCancelDate',
      label: '实际销户日期',
      component: 'DatePicker',
      componentProps: {
        class: '!w-full',
        format: 'YYYY-MM-DD',
        valueFormat: 'YYYY-MM-DD',
      },
    },
    {
      fieldName: 'refundAmount',
      label: '退费金额',
      component: 'InputNumber',
      componentProps: {
        class: 'w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入退费金额（元）',
      },
    },
    {
      fieldName: 'applyUserName',
      label: '申请人',
      component: 'Input',
      componentProps: {
        placeholder: '请输入申请人姓名',
      },
    },
    {
      fieldName: 'applyTime',
      label: '申请时间',
      component: 'DatePicker',
      componentProps: {
        class: '!w-full',
        format: 'YYYY-MM-DD HH:mm:ss',
        showTime: true,
        valueFormat: 'YYYY-MM-DD HH:mm:ss',
      },
    },
    {
      fieldName: 'cancelReason',
      label: '销户原因',
      component: 'Textarea',
      formItemClass: 'col-span-2',
      componentProps: {
        placeholder: '请输入销户原因',
        rows: 2,
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      formItemClass: 'col-span-2',
      componentProps: {
        placeholder: '请输入备注',
        rows: 2,
      },
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'cancellationNo',
      label: '销户编号',
      component: 'Input',
      componentProps: {
        allowClear: true,
        placeholder: '请输入销户编号',
      },
    },
    {
      fieldName: 'cancellationType',
      label: '销户类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.CRM_CANCELLATION_TYPE),
        placeholder: '请选择销户类型',
      },
    },
    {
      fieldName: 'auditStatus',
      label: '审批状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.CRM_AUDIT_STATUS, 'number'),
        placeholder: '请选择审批状态',
      },
    },
  ];
}

/** åˆ—表的字段 */
export function useGridColumns(): VxeTableGridOptions<CrmCancellationApi.Cancellation>['columns'] {
  return [
    { field: 'cancellationNo', title: '销户编号', minWidth: 170 },
    { field: 'customerName', title: '客户名称', minWidth: 180 },
    {
      field: 'cancellationType',
      title: '销户类型',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_CANCELLATION_TYPE },
      },
    },
    { field: 'contractNo', title: '合同编号', minWidth: 140 },
    {
      field: 'expectedCancelDate',
      title: '预计销户日期',
      width: 120,
      formatter: 'formatDate',
    },
    {
      field: 'actualCancelDate',
      title: '实际销户日期',
      width: 120,
      formatter: 'formatDate',
    },
    { field: 'refundAmount', title: '退费金额', width: 120 },
    { field: 'applyUserName', title: '申请人', width: 100 },
    {
      field: 'auditStatus',
      title: '审批状态',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_AUDIT_STATUS },
      },
    },
    {
      title: '操作',
      width: 200,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/crm/cancellation/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,189 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { CrmCancellationApi } from '#/api/crm/cancellation';

import { Page, useVbenModal } from '@vben/common-ui';
import { downloadFileFromBlobPart } from '@vben/utils';

import { message } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import {
  auditCancellation,
  deleteCancellation,
  exportCancellation,
  getCancellationPage,
} from '#/api/crm/cancellation';
import { $t } from '#/locales';

import { useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

/** åˆ·æ–°è¡¨æ ¼ */
function handleRefresh() {
  gridApi.query();
}

/** å¯¼å‡ºè¡¨æ ¼ */
async function handleExport() {
  const formValues = await gridApi.formApi.getValues();
  const data = await exportCancellation(formValues);
  downloadFileFromBlobPart({ fileName: '销户申请.xls', source: data });
}

/** æ–°å¢ž */
function handleCreate() {
  formModalApi.setData(null).open();
}

/** ç¼–辑 */
function handleEdit(row: CrmCancellationApi.Cancellation) {
  formModalApi.setData({ cancellation: row }).open();
}

/** åˆ é™¤ */
async function handleDelete(row: CrmCancellationApi.Cancellation) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting', [row.cancellationNo ?? '']),
    duration: 0,
  });
  try {
    await deleteCancellation(row.id!);
    message.success(
      $t('ui.actionMessage.deleteSuccess', [row.cancellationNo ?? '']),
    );
    handleRefresh();
  } finally {
    hideLoading();
  }
}

/** å®¡æ‰¹ï¼ˆé€šè¿‡/驳回） */
async function handleAudit(
  row: CrmCancellationApi.Cancellation,
  pass: boolean,
) {
  const hideLoading = message.loading({
    content: pass ? '审批通过中...' : '审批驳回中...',
    duration: 0,
  });
  try {
    await auditCancellation({ id: row.id!, auditStatus: pass ? 20 : 30 });
    message.success(pass ? '审批通过' : '审批驳回');
    handleRefresh();
  } finally {
    hideLoading();
  }
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) =>
          await getCancellationPage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          }),
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<CrmCancellationApi.Cancellation>,
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="销户申请列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['销户申请']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['crm:cancellation:create'],
              onClick: handleCreate,
            },
            {
              label: $t('ui.actionTitle.export'),
              type: 'primary',
              icon: ACTION_ICON.DOWNLOAD,
              auth: ['crm:cancellation:export'],
              onClick: handleExport,
            },
          ]"
        />
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: '通过',
              type: 'link',
              icon: ACTION_ICON.AUDIT,
              auth: ['crm:cancellation:update'],
              ifShow: row.auditStatus === 0 || row.auditStatus === 10,
              popConfirm: {
                title: '确认审批通过该销户申请？',
                confirm: handleAudit.bind(null, row, true),
              },
            },
            {
              label: '驳回',
              type: 'link',
              danger: true,
              icon: ACTION_ICON.AUDIT,
              auth: ['crm:cancellation:update'],
              ifShow: row.auditStatus === 0 || row.auditStatus === 10,
              popConfirm: {
                title: '确认驳回该销户申请？',
                confirm: handleAudit.bind(null, row, false),
              },
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['crm:cancellation:update'],
              onClick: handleEdit.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['crm:cancellation:delete'],
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [
                  row.cancellationNo ?? '',
                ]),
                confirm: handleDelete.bind(null, row),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/crm/cancellation/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,95 @@
<script lang="ts" setup>
import type { CrmCancellationApi } from '#/api/crm/cancellation';

import { computed, ref } from 'vue';

import { useVbenForm, useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import {
  createCancellation,
  getCancellation,
  updateCancellation,
} from '#/api/crm/cancellation';
import { $t } from '#/locales';

import { useFormSchema } from '../data';

type CancellationFormModalData = {
  cancellation?: Pick<CrmCancellationApi.Cancellation, 'id'>;
};

const emit = defineEmits(['success']);
const formData = ref<Partial<CrmCancellationApi.Cancellation>>();
const getTitle = computed(() => {
  return formData.value?.id
    ? $t('ui.actionTitle.edit', ['销户申请'])
    : $t('ui.actionTitle.create', ['销户申请']);
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 110,
  },
  wrapperClass: 'grid-cols-2',
  layout: 'horizontal',
  schema: [],
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data =
      (await formApi.getValues()) as CrmCancellationApi.Cancellation;
    if (formData.value?.id) {
      data.id = formData.value.id;
    }
    try {
      await (formData.value?.id
        ? updateCancellation(data)
        : createCancellation(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    formApi.setState({ schema: useFormSchema(formApi) });
    await formApi.resetForm();
    const data = modalApi.getData() as null | CancellationFormModalData;
    if (!data?.cancellation?.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getCancellation(data.cancellation.id);
      if (formData.value) {
        await formApi.setValues(formData.value as any);
      }
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal :title="getTitle" class="w-3/5">
    <Form class="mx-4" />
  </Modal>
</template>

 src/views/crm/contract/components/command-form-data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,105 @@
import type { VbenFormApi, VbenFormSchema } from '#/adapter/form';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

/** æ–°å¢ž/修改合同指令 */
export function useFormSchema(
  formApi?: VbenFormApi,
): VbenFormSchema[] {
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'contractId',
      label: '合同ID',
      component: 'InputNumber',
      componentProps: {
        class: 'w-full',
        precision: 0,
        placeholder: '合同ID',
      },
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'contractNo',
      label: '合同编号',
      component: 'Input',
      componentProps: {
        placeholder: '合同编号',
        readonly: true,
      },
    },
    {
      fieldName: 'commandType',
      label: '指令类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.CRM_COMMAND_TYPE),
        placeholder: '请选择指令类型',
        allowClear: true,
      },
      rules: 'required',
    },
    {
      fieldName: 'targetModule',
      label: '目标模块',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: [
          { label: 'MES å·¥å•', value: 'mes-work-order' },
          { label: 'MES æŠ„表', value: 'mes-metering' },
          { label: 'SRM æœåŠ¡å•', value: 'srm-service' },
        ],
        placeholder: '请选择目标模块',
      },
    },
    {
      fieldName: 'bizNo',
      label: '业务单号',
      component: 'Input',
      componentProps: {
        placeholder: '请输入业务单号',
      },
    },
    {
      fieldName: 'operatorName',
      label: '操作人',
      component: 'Input',
      componentProps: {
        placeholder: '请输入操作人姓名',
      },
    },
    {
      fieldName: 'operateTime',
      label: '操作时间',
      component: 'DatePicker',
      componentProps: {
        class: '!w-full',
        format: 'YYYY-MM-DD HH:mm:ss',
        showTime: true,
        valueFormat: 'YYYY-MM-DD HH:mm:ss',
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      formItemClass: 'col-span-2',
      componentProps: {
        placeholder: '请输入备注',
        rows: 2,
      },
    },
  ];
}

 src/views/crm/contract/components/command-form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,90 @@
<script lang="ts" setup>
import type { CrmContractCommandApi } from '#/api/crm/contract-command';

import { ref } from 'vue';

import { useVbenForm, useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import {
  createContractCommand,
  updateContractCommand,
} from '#/api/crm/contract-command';
import { $t } from '#/locales';

import { useFormSchema } from './command-form-data';

const emit = defineEmits(['success']);

const formData = ref<Partial<CrmContractCommandApi.ContractCommand>>();
const getTitle = () => {
  return formData.value?.id
    ? $t('ui.actionTitle.edit', ['指令'])
    : $t('ui.actionTitle.create', ['指令']);
};

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 110,
  },
  wrapperClass: 'grid-cols-2',
  layout: 'horizontal',
  schema: [],
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data =
      (await formApi.getValues()) as CrmContractCommandApi.ContractCommand;
    if (formData.value?.id) {
      data.id = formData.value.id;
    }
    try {
      await (formData.value?.id
        ? updateContractCommand(data)
        : createContractCommand(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    formApi.setState({ schema: useFormSchema(formApi) });
    await formApi.resetForm();
    const data = modalApi.getData() as null | {
      command?: CrmContractCommandApi.ContractCommand;
      contractNo?: string;
    };
    if (data?.contractNo) {
      await formApi.setFieldValue('contractNo', data.contractNo);
    }
    if (!data?.command?.id) {
      return;
    }
    formData.value = data.command;
    await formApi.setValues(formData.value as any);
  },
});
</script>

<template>
  <Modal :title="getTitle()" class="w-2/3">
    <Form class="mx-4" />
  </Modal>
</template>

 src/views/crm/contract/components/command-list-data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,55 @@
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { CrmContractCommandApi } from '#/api/crm/contract-command';

import { DICT_TYPE } from '@vben/constants';

/** åˆåŒæŒ‡ä»¤è¯¦æƒ…列表字段 */
export function useDetailListColumns(): VxeTableGridOptions<CrmContractCommandApi.ContractCommand>['columns'] {
  return [
    {
      field: 'commandType',
      title: '指令类型',
      width: 120,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_COMMAND_TYPE },
      },
    },
    {
      field: 'targetModule',
      title: '目标模块',
      width: 130,
    },
    {
      field: 'bizNo',
      title: '业务单号',
      minWidth: 140,
    },
    {
      field: 'operatorName',
      title: '操作人',
      width: 100,
    },
    {
      field: 'operateTime',
      title: '操作时间',
      minWidth: 160,
      formatter: 'formatDateTime',
    },
    {
      field: 'status',
      title: '状态',
      width: 100,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_COMMAND_STATUS },
      },
    },
    {
      title: '操作',
      width: 220,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/crm/contract/components/command-list.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,188 @@
<!-- åˆåŒæŒ‡ä»¤ä¸‹å‘列表：用于【合同】详情 Tab，展示并下发/执行/取消合同指令 -->
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { CrmContractCommandApi } from '#/api/crm/contract-command';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import {
  cancelContractCommand,
  deleteContractCommand,
  executeContractCommand,
  getContractCommandPage,
} from '#/api/crm/contract-command';
import { $t } from '#/locales';

import CommandForm from './command-form.vue';
import { useDetailListColumns } from './command-list-data';

const props = defineProps<{
  contractId?: number; // åˆåŒç¼–号
  contractNo?: string; // åˆåŒå•å·
}>();

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: CommandForm,
  destroyOnClose: true,
});

/** åˆ·æ–°è¡¨æ ¼ */
function handleRefresh() {
  gridApi.query();
}

/** åˆ›å»ºæŒ‡ä»¤ */
function handleCreate() {
  formModalApi
    .setData({ contractNo: props.contractNo })
    .open();
}

/** ç¼–辑指令 */
function handleEdit(row: CrmContractCommandApi.ContractCommand) {
  formModalApi.setData({ command: row }).open();
}

/** æ‰§è¡ŒæŒ‡ä»¤ */
async function handleExecute(row: CrmContractCommandApi.ContractCommand) {
  const hideLoading = message.loading({ content: '指令执行中...', duration: 0 });
  try {
    await executeContractCommand(row.id!);
    message.success('指令执行完成');
    handleRefresh();
  } finally {
    hideLoading();
  }
}

/** å–消指令 */
async function handleCancel(row: CrmContractCommandApi.ContractCommand) {
  const hideLoading = message.loading({ content: '指令取消中...', duration: 0 });
  try {
    await cancelContractCommand(row.id!);
    message.success('指令已取消');
    handleRefresh();
  } finally {
    hideLoading();
  }
}

/** åˆ é™¤æŒ‡ä»¤ */
async function handleDelete(row: CrmContractCommandApi.ContractCommand) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting', [row.bizNo ?? '']),
    duration: 0,
  });
  try {
    await deleteContractCommand(row.id!);
    message.success($t('ui.actionMessage.deleteSuccess', [row.bizNo ?? '']));
    handleRefresh();
  } finally {
    hideLoading();
  }
}

const [Grid, gridApi] = useVbenVxeGrid({
  gridOptions: {
    columns: useDetailListColumns(),
    height: 400,
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }) => {
          if (!props.contractId) {
            return { list: [], total: 0 };
          }
          return await getContractCommandPage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            contractId: props.contractId,
          });
        },
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: false,
    },
  } as VxeTableGridOptions<CrmContractCommandApi.ContractCommand>,
});
</script>

<template>
  <div>
    <FormModal @success="handleRefresh" />
    <Grid>
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: '下发指令',
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['crm:contract-command:create'],
              onClick: handleCreate,
            },
          ]"
        />
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: '执行',
              type: 'link',
              icon: ACTION_ICON.AUDIT,
              auth: ['crm:contract-command:update'],
              ifShow: row.status === 0 || row.status === 10,
              popConfirm: {
                title: '确认执行该指令？',
                confirm: handleExecute.bind(null, row),
              },
            },
            {
              label: '取消',
              type: 'link',
              danger: true,
              icon: ACTION_ICON.CLOSE,
              auth: ['crm:contract-command:update'],
              ifShow: row.status === 0 || row.status === 10,
              popConfirm: {
                title: '确认取消该指令？',
                confirm: handleCancel.bind(null, row),
              },
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['crm:contract-command:update'],
              ifShow: row.status === 0,
              onClick: handleEdit.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['crm:contract-command:delete'],
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [
                  row.bizNo ?? '',
                ]),
                confirm: handleDelete.bind(null, row),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </div>
</template>

 src/views/crm/contract/data.ts

@@ -1,6 +1,8 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';
import { useUserStore } from '@vben/stores';
import { erpPriceInputFormatter, erpPriceMultiply } from '@vben/utils';

@@ -199,6 +201,78 @@
      },
    },
    {
      fieldName: 'contractType',
      label: '合同类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.CRM_CONTRACT_TYPE),
        placeholder: '请选择合同类型',
        allowClear: true,
      },
    },
    {
      fieldName: 'voltageLevel',
      label: '电压等级',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.CRM_VOLTAGE_LEVEL),
        placeholder: '请选择电压等级',
        allowClear: true,
      },
    },
    {
      fieldName: 'electricityType',
      label: '用电类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.CRM_ELECTRICITY_TYPE),
        placeholder: '请选择用电类型',
        allowClear: true,
      },
    },
    {
      fieldName: 'contractCapacity',
      label: '合同容量（kVA）',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入合同容量',
      },
    },
    {
      fieldName: 'tariffMode',
      label: '电价模式',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.CRM_TARIFF_MODE),
        placeholder: '请选择电价模式',
        allowClear: true,
      },
    },
    {
      fieldName: 'meterMode',
      label: '计量方式',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.CRM_METER_MODE),
        placeholder: '请选择计量方式',
        allowClear: true,
      },
    },
    {
      fieldName: 'payCycle',
      label: '缴费周期（月）',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 1,
        precision: 0,
        placeholder: '请输入缴费周期',
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
@@ -353,6 +427,34 @@
      slots: { default: 'businessName' },
    },
    {
      title: '合同类型',
      field: 'contractType',
      minWidth: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_CONTRACT_TYPE },
      },
    },
    {
      title: '电压等级',
      field: 'voltageLevel',
      minWidth: 90,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_VOLTAGE_LEVEL },
      },
    },
    {
      title: '合同容量',
      field: 'contractCapacity',
      minWidth: 100,
    },
    {
      title: '指令数',
      field: 'commandCount',
      minWidth: 80,
    },
    {
      title: '合同金额（元）',
      field: 'totalPrice',
      minWidth: 140,

 src/views/crm/contract/detail/index.vue

@@ -26,6 +26,7 @@
import Form from '../modules/form.vue';
import { useDetailSchema } from './data';
import ContractDetailsInfo from './modules/info.vue';
import CommandDetailsList from '../components/command-list.vue';

const props = defineProps<{ id?: number }>();

@@ -171,6 +172,13 @@
        <Tabs.TabPane tab="操作日志" key="6" :force-render="true">
          <OperateLog :log-list="logList" />
        </Tabs.TabPane>
        <Tabs.TabPane tab="指令下发" key="7" :force-render="true">
          <CommandDetailsList
            v-if="contractId"
            :contract-id="contractId"
            :contract-no="contract.no"
          />
        </Tabs.TabPane>
      </Tabs>
    </Card>
  </Page>

 src/views/crm/credit-rating/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,212 @@
import type { VbenFormApi, VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { CrmCustomerApi } from '#/api/crm/customer';
import type { CrmCreditRatingApi } from '#/api/crm/credit-rating';

import { markRaw } from 'vue';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import CrmCustomerSelect from '#/components/crm-customer-select.vue';

/** æ–°å¢ž/修改信用评级 */
export function useFormSchema(
  formApi?: VbenFormApi,
): VbenFormSchema[] {
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'customerId',
      label: '客户',
      component: markRaw(CrmCustomerSelect),
      componentProps: {
        placeholder: '请选择客户',
        onChange: (item?: CrmCustomerApi.Customer) => {
          formApi?.setFieldValue('customerName', item?.name);
        },
      },
    },
    {
      fieldName: 'customerName',
      label: '客户名称',
      component: 'Input',
      componentProps: {
        placeholder: '客户名称',
        readonly: true,
      },
    },
    {
      fieldName: 'level',
      label: '信用等级',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.CRM_CREDIT_LEVEL),
        placeholder: '请选择信用等级',
      },
      rules: 'required',
    },
    {
      fieldName: 'score',
      label: '信用分',
      component: 'InputNumber',
      componentProps: {
        class: 'w-full',
        min: 0,
        max: 100,
        precision: 0,
        placeholder: '0-100',
      },
    },
    {
      fieldName: 'evalType',
      label: '评定类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: [
          { label: '初评', value: 'INITIAL' },
          { label: '复评', value: 'REVIEW' },
          { label: '动态调整', value: 'ADJUST' },
        ],
        placeholder: '请选择评定类型',
      },
    },
    {
      fieldName: 'evalReason',
      label: '评定理由',
      component: 'Textarea',
      formItemClass: 'col-span-2',
      componentProps: {
        placeholder: '请输入评定理由',
        rows: 2,
      },
    },
    {
      fieldName: 'operateTime',
      label: '评定时间',
      component: 'DatePicker',
      componentProps: {
        class: '!w-full',
        format: 'YYYY-MM-DD HH:mm:ss',
        showTime: true,
        valueFormat: 'YYYY-MM-DD HH:mm:ss',
      },
    },
    {
      fieldName: 'validUntil',
      label: '有效期至',
      component: 'DatePicker',
      componentProps: {
        class: '!w-full',
        format: 'YYYY-MM-DD',
        valueFormat: 'YYYY-MM-DD',
      },
    },
    {
      fieldName: 'operatorName',
      label: '评定人',
      component: 'Input',
      componentProps: {
        placeholder: '请输入评定人姓名',
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      formItemClass: 'col-span-2',
      componentProps: {
        placeholder: '请输入备注',
        rows: 2,
      },
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'level',
      label: '信用等级',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.CRM_CREDIT_LEVEL),
        placeholder: '请选择信用等级',
      },
    },
    {
      fieldName: 'evalType',
      label: '评定类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: [
          { label: '初评', value: 'INITIAL' },
          { label: '复评', value: 'REVIEW' },
          { label: '动态调整', value: 'ADJUST' },
        ],
        placeholder: '请选择评定类型',
      },
    },
  ];
}

/** åˆ—表的字段 */
export function useGridColumns(): VxeTableGridOptions<CrmCreditRatingApi.CreditRating>['columns'] {
  return [
    { field: 'customerName', title: '客户名称', minWidth: 180 },
    {
      field: 'level',
      title: '信用等级',
      width: 100,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_CREDIT_LEVEL },
      },
    },
    { field: 'score', title: '信用分', width: 90 },
    {
      field: 'evalType',
      title: '评定类型',
      width: 120,
      slots: { default: 'evalType' },
    },
    { field: 'evalReason', title: '评定理由', minWidth: 200, showOverflow: true },
    { field: 'operatorName', title: '评定人', width: 100 },
    {
      field: 'operateTime',
      title: '评定时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      field: 'validUntil',
      title: '有效期至',
      width: 120,
      formatter: 'formatDate',
    },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      title: '操作',
      width: 160,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/crm/credit-rating/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,156 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { CrmCreditRatingApi } from '#/api/crm/credit-rating';

import { Page, useVbenModal } from '@vben/common-ui';
import { downloadFileFromBlobPart } from '@vben/utils';

import { message } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import {
  deleteCreditRating,
  exportCreditRating,
  getCreditRatingPage,
} from '#/api/crm/credit-rating';
import { $t } from '#/locales';

import { useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

/** åˆ·æ–°è¡¨æ ¼ */
function handleRefresh() {
  gridApi.query();
}

/** å¯¼å‡ºè¡¨æ ¼ */
async function handleExport() {
  const formValues = await gridApi.formApi.getValues();
  const data = await exportCreditRating(formValues);
  downloadFileFromBlobPart({ fileName: '客户信用评级.xls', source: data });
}

/** æ–°å¢ž */
function handleCreate() {
  formModalApi.setData(null).open();
}

/** ç¼–辑 */
function handleEdit(row: CrmCreditRatingApi.CreditRating) {
  formModalApi.setData({ creditRating: row }).open();
}

/** åˆ é™¤ */
async function handleDelete(row: CrmCreditRatingApi.CreditRating) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting', [row.customerName ?? '']),
    duration: 0,
  });
  try {
    await deleteCreditRating(row.id!);
    message.success(
      $t('ui.actionMessage.deleteSuccess', [row.customerName ?? '']),
    );
    handleRefresh();
  } finally {
    hideLoading();
  }
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) =>
          await getCreditRatingPage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          }),
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<CrmCreditRatingApi.CreditRating>,
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="客户信用评级列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['信用评级']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['crm:credit-rating:create'],
              onClick: handleCreate,
            },
            {
              label: $t('ui.actionTitle.export'),
              type: 'primary',
              icon: ACTION_ICON.DOWNLOAD,
              auth: ['crm:credit-rating:export'],
              onClick: handleExport,
            },
          ]"
        />
      </template>
      <template #evalType="{ row }">
        {{
          row.evalType === 'INITIAL'
            ? '初评'
            : row.evalType === 'REVIEW'
              ? '复评'
              : '动态调整'
        }}
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['crm:credit-rating:update'],
              onClick: handleEdit.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['crm:credit-rating:delete'],
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [
                  row.customerName ?? '',
                ]),
                confirm: handleDelete.bind(null, row),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/crm/credit-rating/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,94 @@
<script lang="ts" setup>
import type { CrmCreditRatingApi } from '#/api/crm/credit-rating';

import { computed, ref } from 'vue';

import { useVbenForm, useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import {
  createCreditRating,
  getCreditRating,
  updateCreditRating,
} from '#/api/crm/credit-rating';
import { $t } from '#/locales';

import { useFormSchema } from '../data';

type CreditRatingFormModalData = {
  creditRating?: Pick<CrmCreditRatingApi.CreditRating, 'id'>;
};

const emit = defineEmits(['success']);
const formData = ref<Partial<CrmCreditRatingApi.CreditRating>>();
const getTitle = computed(() => {
  return formData.value?.id
    ? $t('ui.actionTitle.edit', ['信用评级'])
    : $t('ui.actionTitle.create', ['信用评级']);
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 110,
  },
  wrapperClass: 'grid-cols-2',
  layout: 'horizontal',
  schema: [],
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data = (await formApi.getValues()) as CrmCreditRatingApi.CreditRating;
    if (formData.value?.id) {
      data.id = formData.value.id;
    }
    try {
      await (formData.value?.id
        ? updateCreditRating(data)
        : createCreditRating(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    formApi.setState({ schema: useFormSchema(formApi) });
    await formApi.resetForm();
    const data = modalApi.getData() as null | CreditRatingFormModalData;
    if (!data?.creditRating?.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getCreditRating(data.creditRating.id);
      if (formData.value) {
        await formApi.setValues(formData.value as any);
      }
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal :title="getTitle" class="w-3/5">
    <Form class="mx-4" />
  </Modal>
</template>

 src/views/crm/customer/data.ts

@@ -45,6 +45,16 @@
      },
    },
    {
      fieldName: 'customerType',
      label: '客户分类',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.CRM_CUSTOMER_TYPE),
        placeholder: '请选择客户分类',
        allowClear: true,
      },
    },
    {
      fieldName: 'mobile',
      label: '手机',
      component: 'Input',
@@ -202,6 +212,26 @@
      },
    },
    {
      fieldName: 'customerType',
      label: '客户分类',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.CRM_CUSTOMER_TYPE),
        placeholder: '请选择客户分类',
        allowClear: true,
      },
    },
    {
      fieldName: 'creditLevel',
      label: '信用等级',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.CRM_CREDIT_LEVEL),
        placeholder: '请选择信用等级',
        allowClear: true,
      },
    },
    {
      fieldName: 'createTime',
      label: '创建时间',
      component: 'RangePicker',
@@ -276,6 +306,40 @@
      },
    },
    {
      field: 'customerType',
      title: '客户分类',
      minWidth: 100,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_CUSTOMER_TYPE },
      },
    },
    {
      field: 'creditLevel',
      title: '信用等级',
      minWidth: 100,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_CREDIT_LEVEL },
      },
    },
    {
      field: 'creditScore',
      title: '信用分',
      minWidth: 90,
    },
    {
      field: 'overdueAmount',
      title: '欠费金额',
      minWidth: 110,
      formatter: 'formatAmount2',
    },
    {
      field: 'overdueCount',
      title: '欠费笔数',
      minWidth: 90,
    },
    {
      field: 'mobile',
      title: '手机',
      minWidth: 120,

 src/views/crm/refund/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,208 @@
import type { VbenFormApi, VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { CrmCustomerApi } from '#/api/crm/customer';
import type { CrmRefundApi } from '#/api/crm/refund';

import { markRaw } from 'vue';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import CrmCustomerSelect from '#/components/crm-customer-select.vue';

/** æ–°å¢ž/修改退费单 */
export function useFormSchema(
  formApi?: VbenFormApi,
): VbenFormSchema[] {
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'refundNo',
      label: '退费单号',
      component: 'Input',
      componentProps: {
        placeholder: '不填则自动生成',
      },
    },
    {
      fieldName: 'customerId',
      label: '客户',
      component: markRaw(CrmCustomerSelect),
      componentProps: {
        placeholder: '请选择客户',
        onChange: (item?: CrmCustomerApi.Customer) => {
          formApi?.setFieldValue('customerName', item?.name);
        },
      },
      rules: 'required',
    },
    {
      fieldName: 'customerName',
      label: '客户名称',
      component: 'Input',
      componentProps: {
        placeholder: '客户名称',
        readonly: true,
      },
    },
    {
      fieldName: 'refundType',
      label: '退费类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.CRM_REFUND_TYPE),
        placeholder: '请选择退费类型',
      },
      rules: 'required',
    },
    {
      fieldName: 'refundAmount',
      label: '退费金额',
      component: 'InputNumber',
      componentProps: {
        class: 'w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入退费金额（元）',
      },
      rules: 'required',
    },
    {
      fieldName: 'contractNo',
      label: '合同编号',
      component: 'Input',
      componentProps: {
        placeholder: '请输入关联合同编号',
      },
    },
    {
      fieldName: 'applyUserName',
      label: '申请人',
      component: 'Input',
      componentProps: {
        placeholder: '请输入申请人姓名',
      },
    },
    {
      fieldName: 'applyTime',
      label: '申请时间',
      component: 'DatePicker',
      componentProps: {
        class: '!w-full',
        format: 'YYYY-MM-DD HH:mm:ss',
        showTime: true,
        valueFormat: 'YYYY-MM-DD HH:mm:ss',
      },
    },
    {
      fieldName: 'refundReason',
      label: '退费原因',
      component: 'Textarea',
      formItemClass: 'col-span-2',
      componentProps: {
        placeholder: '请输入退费原因',
        rows: 2,
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      formItemClass: 'col-span-2',
      componentProps: {
        placeholder: '请输入备注',
        rows: 2,
      },
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'refundNo',
      label: '退费单号',
      component: 'Input',
      componentProps: {
        allowClear: true,
        placeholder: '请输入退费单号',
      },
    },
    {
      fieldName: 'refundType',
      label: '退费类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.CRM_REFUND_TYPE),
        placeholder: '请选择退费类型',
      },
    },
    {
      fieldName: 'auditStatus',
      label: '审批状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.CRM_AUDIT_STATUS, 'number'),
        placeholder: '请选择审批状态',
      },
    },
  ];
}

/** åˆ—表的字段 */
export function useGridColumns(): VxeTableGridOptions<CrmRefundApi.Refund>['columns'] {
  return [
    { field: 'refundNo', title: '退费单号', minWidth: 170 },
    { field: 'customerName', title: '客户名称', minWidth: 180 },
    {
      field: 'refundType',
      title: '退费类型',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_REFUND_TYPE },
      },
    },
    { field: 'refundAmount', title: '退费金额', width: 120 },
    { field: 'contractNo', title: '合同编号', minWidth: 140 },
    { field: 'applyUserName', title: '申请人', width: 100 },
    {
      field: 'applyTime',
      title: '申请时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      field: 'auditStatus',
      title: '审批状态',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_AUDIT_STATUS },
      },
    },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      title: '操作',
      width: 200,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/crm/refund/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,184 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { CrmRefundApi } from '#/api/crm/refund';

import { Page, useVbenModal } from '@vben/common-ui';
import { downloadFileFromBlobPart } from '@vben/utils';

import { message } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import {
  auditRefund,
  deleteRefund,
  exportRefund,
  getRefundPage,
} from '#/api/crm/refund';
import { $t } from '#/locales';

import { useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

/** åˆ·æ–°è¡¨æ ¼ */
function handleRefresh() {
  gridApi.query();
}

/** å¯¼å‡ºè¡¨æ ¼ */
async function handleExport() {
  const formValues = await gridApi.formApi.getValues();
  const data = await exportRefund(formValues);
  downloadFileFromBlobPart({ fileName: '退费单.xls', source: data });
}

/** æ–°å¢ž */
function handleCreate() {
  formModalApi.setData(null).open();
}

/** ç¼–辑 */
function handleEdit(row: CrmRefundApi.Refund) {
  formModalApi.setData({ refund: row }).open();
}

/** åˆ é™¤ */
async function handleDelete(row: CrmRefundApi.Refund) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting', [row.refundNo ?? '']),
    duration: 0,
  });
  try {
    await deleteRefund(row.id!);
    message.success($t('ui.actionMessage.deleteSuccess', [row.refundNo ?? '']));
    handleRefresh();
  } finally {
    hideLoading();
  }
}

/** å®¡æ‰¹ï¼ˆé€šè¿‡/驳回） */
async function handleAudit(row: CrmRefundApi.Refund, pass: boolean) {
  const hideLoading = message.loading({
    content: pass ? '审批通过中...' : '审批驳回中...',
    duration: 0,
  });
  try {
    await auditRefund({ id: row.id!, auditStatus: pass ? 20 : 30 });
    message.success(pass ? '审批通过' : '审批驳回');
    handleRefresh();
  } finally {
    hideLoading();
  }
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) =>
          await getRefundPage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          }),
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<CrmRefundApi.Refund>,
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="退费单列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['退费单']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['crm:refund:create'],
              onClick: handleCreate,
            },
            {
              label: $t('ui.actionTitle.export'),
              type: 'primary',
              icon: ACTION_ICON.DOWNLOAD,
              auth: ['crm:refund:export'],
              onClick: handleExport,
            },
          ]"
        />
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: '通过',
              type: 'link',
              icon: ACTION_ICON.AUDIT,
              auth: ['crm:refund:update'],
              ifShow: row.auditStatus === 0 || row.auditStatus === 10,
              popConfirm: {
                title: '确认审批通过该退费单？',
                confirm: handleAudit.bind(null, row, true),
              },
            },
            {
              label: '驳回',
              type: 'link',
              danger: true,
              icon: ACTION_ICON.AUDIT,
              auth: ['crm:refund:update'],
              ifShow: row.auditStatus === 0 || row.auditStatus === 10,
              popConfirm: {
                title: '确认驳回该退费单？',
                confirm: handleAudit.bind(null, row, false),
              },
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['crm:refund:update'],
              onClick: handleEdit.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['crm:refund:delete'],
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [
                  row.refundNo ?? '',
                ]),
                confirm: handleDelete.bind(null, row),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/crm/refund/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,92 @@
<script lang="ts" setup>
import type { CrmRefundApi } from '#/api/crm/refund';

import { computed, ref } from 'vue';

import { useVbenForm, useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import {
  createRefund,
  getRefund,
  updateRefund,
} from '#/api/crm/refund';
import { $t } from '#/locales';

import { useFormSchema } from '../data';

type RefundFormModalData = {
  refund?: Pick<CrmRefundApi.Refund, 'id'>;
};

const emit = defineEmits(['success']);
const formData = ref<Partial<CrmRefundApi.Refund>>();
const getTitle = computed(() => {
  return formData.value?.id
    ? $t('ui.actionTitle.edit', ['退费单'])
    : $t('ui.actionTitle.create', ['退费单']);
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 110,
  },
  wrapperClass: 'grid-cols-2',
  layout: 'horizontal',
  schema: [],
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data = (await formApi.getValues()) as CrmRefundApi.Refund;
    if (formData.value?.id) {
      data.id = formData.value.id;
    }
    try {
      await (formData.value?.id ? updateRefund(data) : createRefund(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    formApi.setState({ schema: useFormSchema(formApi) });
    await formApi.resetForm();
    const data = modalApi.getData() as null | RefundFormModalData;
    if (!data?.refund?.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getRefund(data.refund.id);
      if (formData.value) {
        await formApi.setValues(formData.value as any);
      }
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal :title="getTitle" class="w-3/5">
    <Form class="mx-4" />
  </Modal>
</template>

 src/views/crm/saleQuotation/data.ts

@@ -1,6 +1,9 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import { erpPriceMultiply } from '#/packages/utils/src';

import { z } from '#/adapter/form';
@@ -156,6 +159,81 @@
      },
    },
    {
      fieldName: 'quotationType',
      label: '报价类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.CRM_QUOTATION_TYPE),
        placeholder: '请选择报价类型',
        allowClear: true,
      },
    },
    {
      fieldName: 'capacity',
      label: '合同容量（kVA）',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入合同容量',
      },
    },
    {
      fieldName: 'maxDemand',
      label: '最大需量（kW）',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入最大需量',
      },
    },
    {
      fieldName: 'unitPrice',
      label: '电度单价（元/kWh）',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 4,
        placeholder: '请输入电度单价',
      },
    },
    {
      fieldName: 'tariffMode',
      label: '电价模式',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.CRM_TARIFF_MODE),
        placeholder: '请选择电价模式',
        allowClear: true,
      },
    },
    {
      fieldName: 'powerFactorFee',
      label: '力调电费（元）',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入力调电费',
      },
    },
    {
      fieldName: 'billingCycle',
      label: '结算周期（月）',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 1,
        precision: 0,
        placeholder: '请输入结算周期',
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
@@ -283,6 +361,15 @@
      fixed: 'left',
    },
    {
      field: 'quotationType',
      title: '报价类型',
      minWidth: 100,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.CRM_QUOTATION_TYPE },
      },
    },
    {
      field: 'customerName',
      title: '客户名称',
      minWidth: 120,

 src/views/erp/purchase/plan/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,242 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

import { getDictOptions } from '@vben/hooks';

import { getSupplierSimpleList } from '#/api/srm/supplier';
import { getRangePickerDefaultProps } from '#/utils';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'edit';

/** çŠ¶æ€å¸¸é‡ */
export const PURCHASE_PLAN_STATUS = {
  DRAFT: 0, // æœªæäº¤ï¼ˆè‰ç¨¿ï¼‰
  PROCESSING: 10, // å®¡æ‰¹ä¸­
  APPROVED: 20, // å®¡æ ¸é€šè¿‡
  REJECTED: 30, // å®¡æ ¸ä¸é€šè¿‡
  CANCELLED: 40, // å·²å–消
};

/** éœ€æ±‚来源常量 */
export const DEMAND_SOURCE = {
  STOCK_ALERT: 1, // åº“存预警
  PLAN: 2, // è¿ç»´/生产计划
};

/** è¡¨å•çš„配置项 */
export function useFormSchema(formType: FormType): VbenFormSchema[] {
  const isReadonly = formType === 'detail';
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'no',
      label: '计划单号',
      component: 'Input',
      componentProps: {
        placeholder: '系统自动生成',
        disabled: true,
      },
    },
    {
      fieldName: 'name',
      label: '计划名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入计划名称',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'planDate',
      label: '计划日期',
      component: 'DatePicker',
      componentProps: {
        placeholder: '选择计划日期',
        showTime: true,
        format: 'YYYY-MM-DD HH:mm:ss',
        valueFormat: 'YYYY-MM-DD HH:mm:ss',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'demandSource',
      label: '需求来源',
      component: 'Select',
      componentProps: {
        placeholder: '请选择需求来源',
        allowClear: true,
        options: getDictOptions('erp_purchase_plan_demand_source', 'number'),
        disabled: isReadonly,
      },
    },
    {
      label: '供应商',
      fieldName: 'supplierId',
      component: 'ApiSelect',
      componentProps: {
        placeholder: '请选择供应商',
        allowClear: true,
        showSearch: true,
        api: getSupplierSimpleList,
        labelField: 'name',
        valueField: 'id',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入备注',
        autoSize: { minRows: 1, maxRows: 1 },
        disabled: isReadonly,
      },
      formItemClass: 'col-span-2',
    },
    {
      fieldName: 'items',
      label: '计划明细',
      component: 'Input',
      formItemClass: 'col-span-3',
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'no',
      label: '计划单号',
      component: 'Input',
      componentProps: {
        placeholder: '请输入计划单号',
      },
    },
    {
      fieldName: 'name',
      label: '计划名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入计划名称',
      },
    },
    {
      fieldName: 'demandSource',
      label: '需求来源',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions('erp_purchase_plan_demand_source', 'number'),
        placeholder: '请选择需求来源',
      },
    },
    {
      fieldName: 'status',
      label: '状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: [
          { label: '未提交', value: PURCHASE_PLAN_STATUS.DRAFT },
          { label: '审批中', value: PURCHASE_PLAN_STATUS.PROCESSING },
          { label: '审核通过', value: PURCHASE_PLAN_STATUS.APPROVED },
          { label: '审核不通过', value: PURCHASE_PLAN_STATUS.REJECTED },
          { label: '已取消', value: PURCHASE_PLAN_STATUS.CANCELLED },
        ],
        placeholder: '请选择状态',
      },
    },
    {
      fieldName: 'planDate',
      label: '计划日期',
      component: 'RangePicker',
      componentProps: getRangePickerDefaultProps(),
    },
  ];
}

/** åˆ—表的表格列 */
export function useGridColumns(): VxeTableGridOptions['columns'] {
  return [
    { type: 'checkbox', width: 50 },
    { type: 'seq', title: '序号', width: 60 },
    {
      field: 'no',
      title: '计划单号',
      minWidth: 140,
    },
    {
      field: 'name',
      title: '计划名称',
      minWidth: 180,
    },
    {
      field: 'demandSourceName',
      title: '需求来源',
      width: 110,
    },
    {
      field: 'planUserName',
      title: '编制人',
      width: 110,
    },
    {
      field: 'planDeptName',
      title: '编制部门',
      width: 120,
    },
    {
      field: 'supplierName',
      title: '供应商',
      minWidth: 130,
    },
    {
      field: 'productNames',
      title: '产品',
      minWidth: 180,
    },
    {
      field: 'totalCount',
      title: '合计数量',
      width: 100,
      formatter: 'formatAmount3',
    },
    {
      field: 'planDate',
      title: '计划日期',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      field: 'status',
      title: '状态',
      width: 100,
      slots: { default: 'status' },
    },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      field: 'action',
      title: '操作',
      width: 280,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/erp/purchase/plan/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,300 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { ErpPurchasePlanApi } from '#/api/erp/purchase/plan';

import { ref } from 'vue';
import { useRouter } from 'vue-router';

import { confirm, Page, useVbenModal } from '@vben/common-ui';
import { downloadFileFromBlobPart, isEmpty } from '@vben/utils';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import {
  deletePurchasePlan,
  exportPurchasePlan,
  generatePlanFromStockAlert,
  generatePurchaseRequests,
  getApproveProcessList,
  getPurchasePlanPage,
} from '#/api/erp/purchase/plan';
import { $t } from '#/locales';

import { useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';
import ProcessSelectModal from './modules/process-select-modal.vue';

/** ERP é‡‡è´­è®¡åˆ’列表 */
defineOptions({ name: 'ErpPurchasePlan' });

const router = useRouter();

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

const [ProcessModal, processModalApi] = useVbenModal({
  connectedComponent: ProcessSelectModal,
  destroyOnClose: true,
});

/** åˆ·æ–°è¡¨æ ¼ */
function handleRefresh() {
  gridApi.query();
}

/** å¯¼å‡ºè¡¨æ ¼ */
async function handleExport() {
  const data = await exportPurchasePlan(await gridApi.formApi.getValues());
  downloadFileFromBlobPart({ fileName: '采购计划.xls', source: data });
}

/** æ–°å¢žé‡‡è´­è®¡åˆ’ */
function handleCreate() {
  formModalApi.setData({ formType: 'create' }).open();
}

/** ç¼–辑采购计划 */
function handleEdit(row: ErpPurchasePlanApi.PurchasePlan) {
  formModalApi.setData({ formType: 'edit', id: row.id }).open();
}

/** åˆ é™¤é‡‡è´­è®¡åˆ’ */
async function handleDelete(ids: number[]) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting'),
    duration: 0,
  });
  try {
    await deletePurchasePlan(ids);
    message.success($t('ui.actionMessage.deleteSuccess'));
    handleRefresh();
  } finally {
    hideLoading();
  }
}

/** åº“存预警生成采购计划 */
async function handleGenerateFromStockAlert() {
  const hideLoading = message.loading({
    content: '正在根据库存预警生成采购计划...',
    duration: 0,
  });
  try {
    const planId = await generatePlanFromStockAlert({});
    hideLoading();
    message.success(`已生成采购计划（编号 ${planId}），请核对明细后提交审批`);
    handleRefresh();
  } catch {
    hideLoading();
  }
}

/** æäº¤å®¡æ‰¹ - å…ˆèŽ·å–流程列表 */
async function handleSubmit(row: ErpPurchasePlanApi.PurchasePlan) {
  const hideLoading = message.loading({
    content: '获取审批流程...',
    duration: 0,
  });
  try {
    const processList = await getApproveProcessList(row.id!);
    hideLoading();
    if (!processList || processList.length === 0) {
      message.warning('暂无可用审批流程，请先配置 BPM æµç¨‹');
      return;
    }
    processModalApi.setData({ id: row.id, processList }).open();
  } catch {
    hideLoading();
  }
}

/** ç”Ÿæˆé‡‡è´­ç”³è¯· */
function handleGenerateRequests(row: ErpPurchasePlanApi.PurchasePlan) {
  confirm({
    content: `确认根据计划「${row.name}」生成采购申请？`,
  }).then(() => {
    const hideLoading = message.loading({
      content: '正在生成采购申请...',
      duration: 0,
    });
    generatePurchaseRequests(row.id!)
      .then((requestIds) => {
        message.success(`已生成采购申请（编号 ${requestIds.join(', ')}）`);
        handleRefresh();
      })
      .finally(() => {
        hideLoading();
      });
  });
}

const checkedIds = ref<number[]>([]);
function handleRowCheckboxChange({
  records,
}: {
  records: ErpPurchasePlanApi.PurchasePlan[];
}) {
  checkedIds.value = records.map((item) => item.id!);
}

/** æŸ¥çœ‹è¯¦æƒ… */
function handleDetail(row: ErpPurchasePlanApi.PurchasePlan) {
  formModalApi.setData({ formType: 'detail', id: row.id }).open();
}

/** æŸ¥çœ‹å®¡æ‰¹è¯¦æƒ… */
function handleViewProcess(row: ErpPurchasePlanApi.PurchasePlan) {
  if (!row.processInstanceId) {
    message.warning('该计划尚未提交审批');
    return;
  }
  router.push({ name: 'BpmProcessInstanceDetail', query: { id: row.processInstanceId } });
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) => {
          return await getPurchasePlanPage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          });
        },
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<ErpPurchasePlanApi.PurchasePlan>,
  gridEvents: {
    checkboxAll: handleRowCheckboxChange,
    checkboxChange: handleRowCheckboxChange,
  },
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <ProcessModal @success="handleRefresh" />
    <Grid table-title="采购计划列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['采购计划']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['erp:purchase-plan:create'],
              onClick: handleCreate,
            },
            {
              label: '库存预警生成',
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['erp:purchase-plan:create'],
              popConfirm: {
                title: '根据安全库存缺量自动生成草稿采购计划？',
                confirm: handleGenerateFromStockAlert,
              },
            },
            {
              label: $t('ui.actionTitle.export'),
              type: 'primary',
              icon: ACTION_ICON.DOWNLOAD,
              auth: ['erp:purchase-plan:export'],
              onClick: handleExport,
            },
            {
              label: '批量删除',
              type: 'primary',
              danger: true,
              disabled: isEmpty(checkedIds),
              icon: ACTION_ICON.DELETE,
              auth: ['erp:purchase-plan:delete'],
              popConfirm: {
                title: `是否删除所选中数据？`,
                confirm: handleDelete.bind(null, checkedIds),
              },
            },
          ]"
        />
      </template>
      <template #status="{ row }">
        <Tag v-if="row.status === 0" color="default">未提交</Tag>
        <Tag v-else-if="row.status === 10" color="processing">审批中</Tag>
        <Tag v-else-if="row.status === 20" color="success">审核通过</Tag>
        <Tag v-else-if="row.status === 30" color="error">审核不通过</Tag>
        <Tag v-else-if="row.status === 40" color="warning">已取消</Tag>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['erp:purchase-plan:query'],
              onClick: handleDetail.bind(null, row),
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['erp:purchase-plan:update'],
              ifShow: () => row.status === 0,
              onClick: handleEdit.bind(null, row),
            },
            {
              label: '提交',
              type: 'link',
              ifShow: () => row.status === 0 || row.status === 30,
              onClick: handleSubmit.bind(null, row),
            },
            {
              label: '生成申请',
              type: 'link',
              auth: ['erp:purchase-plan:generate-request'],
              ifShow: () => row.status === 20 && !row.generatedFlag,
              onClick: handleGenerateRequests.bind(null, row),
            },
            {
              label: '查看审批',
              type: 'link',
              ifShow: () => row.status !== 0,
              onClick: handleViewProcess.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['erp:purchase-plan:delete'],
              ifShow: () => row.status === 0,
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.no]),
                confirm: handleDelete.bind(null, [row.id!]),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/erp/purchase/plan/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,236 @@
<script lang="ts" setup>
import type { ErpPurchasePlanApi } from '#/api/erp/purchase/plan';

import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { Button, DatePicker, Input, InputNumber, message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import {
  createPurchasePlan,
  getPurchasePlan,
  updatePurchasePlan,
} from '#/api/erp/purchase/plan';
import { MdmItemSelect } from '#/views/basicData/mdm/components';
import { $t } from '#/locales';

import type { FormType } from '../data';
import { useFormSchema } from '../data';

const emit = defineEmits(['success']);
const formData = ref<ErpPurchasePlanApi.PurchasePlan>();
const formType = ref<FormType>('create');
const items = ref<ErpPurchasePlanApi.PurchasePlanItem[]>([]);

const getTitle = computed(() => {
  if (formType.value === 'create') {
    return $t('ui.actionTitle.create', ['采购计划']);
  } else if (formType.value === 'edit') {
    return $t('ui.actionTitle.edit', ['采购计划']);
  } else {
    return '采购计划详情';
  }
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 120,
  },
  wrapperClass: 'grid-cols-3',
  layout: 'vertical',
  schema: useFormSchema(formType.value),
  showDefaultActions: false,
});

function handleAddItem() {
  items.value.push({
    productId: undefined as unknown as number,
    productName: '',
    productUnitId: undefined as unknown as number,
    productUnitName: '',
    count: 1,
    demandTime: undefined,
    remark: '',
  });
}

function handleRemoveItem(index: number) {
  items.value.splice(index, 1);
}

function handleItemSelect(index: number, item: any) {
  const row = items.value[index];
  if (!row) {
    return;
  }
  row.productId = item?.id;
  row.productName = item?.name;
  row.productUnitId = item?.unitMeasureId;
  row.productUnitName = item?.unitMeasureName;
}

/** åˆ›å»ºæˆ–更新采购计划 */
const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    if (!items.value.length) {
      message.error('请至少添加一条计划明细');
      return;
    }
    if (items.value.some((item) => !item.productId || !item.count)) {
      message.error('请完善计划明细的产品与数量');
      return;
    }
    modalApi.lock();
    const data =
      (await formApi.getValues()) as ErpPurchasePlanApi.PurchasePlan;
    data.items = items.value.map((item) => ({
      productId: item.productId,
      productUnitId: item.productUnitId,
      count: item.count,
      demandTime: item.demandTime,
      remark: item.remark,
    }));
    try {
      await (formType.value === 'create'
        ? createPurchasePlan(data)
        : updatePurchasePlan(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      items.value = [];
      return;
    }
    const data = modalApi.getData<{ formType: FormType; id?: number }>();
    formType.value = data.formType;
    formApi.setDisabled(formType.value === 'detail');
    formApi.updateSchema(useFormSchema(formType.value));
    if (!data || !data.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getPurchasePlan(data.id);
      await formApi.setValues(formData.value);
      items.value = (formData.value.items ?? []).map((item) => ({
        ...item,
      }));
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal
    :title="getTitle"
    class="w-3/4"
    :show-confirm-button="formType !== 'detail'"
  >
    <Form class="mx-3">
      <template #items>
        <div class="mt-2">
          <div v-if="formType !== 'detail'" class="mb-2">
            <Button type="dashed" @click="handleAddItem">+ æ·»åŠ æ˜Žç»†</Button>
          </div>
          <table class="w-full border-collapse border border-gray-200 text-sm">
            <thead>
              <tr class="bg-gray-100">
                <th class="border border-gray-200 px-2 py-1 w-12">序号</th>
                <th class="border border-gray-200 px-2 py-1">产品</th>
                <th class="border border-gray-200 px-2 py-1 w-20">单位</th>
                <th class="border border-gray-200 px-2 py-1 w-32">数量</th>
                <th class="border border-gray-200 px-2 py-1 w-40">需求日期</th>
                <th class="border border-gray-200 px-2 py-1">备注</th>
                <th
                  v-if="formType !== 'detail'"
                  class="border border-gray-200 px-2 py-1 w-16"
                >
                  æ“ä½œ
                </th>
              </tr>
            </thead>
            <tbody>
              <tr v-for="(item, index) in items" :key="index">
                <td class="border border-gray-200 px-2 py-1 text-center">
                  {{ index + 1 }}
                </td>
                <td class="border border-gray-200 px-2 py-1">
                  <MdmItemSelect
                    v-if="formType !== 'detail'"
                    :model-value="item.productId"
                    placeholder="请选择产品"
                    @change="handleItemSelect(index, $event)"
                  />
                  <span v-else>{{ item.productName }}</span>
                </td>
                <td class="border border-gray-200 px-2 py-1 text-center">
                  {{ item.productUnitName || '-' }}
                </td>
                <td class="border border-gray-200 px-2 py-1">
                  <InputNumber
                    v-if="formType !== 'detail'"
                    v-model:value="item.count"
                    class="!w-full"
                    :min="0.01"
                    :precision="2"
                  />
                  <span v-else>{{ item.count }}</span>
                </td>
                <td class="border border-gray-200 px-2 py-1">
                  <DatePicker
                    v-if="formType !== 'detail'"
                    v-model:value="item.demandTime"
                    class="!w-full"
                    value-format="YYYY-MM-DD"
                  />
                  <span v-else>{{ item.demandTime || '-' }}</span>
                </td>
                <td class="border border-gray-200 px-2 py-1">
                  <Input
                    v-if="formType !== 'detail'"
                    v-model:value="item.remark"
                    placeholder="备注"
                  />
                  <span v-else>{{ item.remark || '-' }}</span>
                </td>
                <td
                  v-if="formType !== 'detail'"
                  class="border border-gray-200 px-2 py-1 text-center"
                >
                  <Button type="link" danger @click="handleRemoveItem(index)">
                    åˆ é™¤
                  </Button>
                </td>
              </tr>
              <tr v-if="!items.length">
                <td
                  :colspan="formType === 'detail' ? 6 : 7"
                  class="border border-gray-200 px-2 py-4 text-center text-gray-400"
                >
                  æš‚无明细，请添加
                </td>
              </tr>
            </tbody>
          </table>
        </div>
      </template>
    </Form>
  </Modal>
</template>

 src/views/erp/purchase/plan/modules/process-select-modal.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,79 @@
<script lang="ts" setup>
import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message, Select } from 'ant-design-vue';

import { submitPurchasePlan } from '#/api/erp/purchase/plan';

interface ProcessDefinition {
  id: string;
  name: string;
  version: number;
  key: string;
}

const emit = defineEmits(['success']);

const planId = ref<number>();
const processList = ref<ProcessDefinition[]>([]);
const selectedProcessKey = ref<string>('');

const processOptions = computed(() => {
  return processList.value.map((p) => ({
    label: `${p.name} (V${p.version})`,
    value: p.key,
  }));
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    if (!selectedProcessKey.value) {
      message.warning('请选择审批流程');
      return;
    }
    modalApi.lock();
    try {
      await submitPurchasePlan(planId.value!, selectedProcessKey.value);
      await modalApi.close();
      emit('success');
      message.success('提交成功');
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      planId.value = undefined;
      selectedProcessKey.value = '';
      processList.value = [];
      return;
    }
    const data = modalApi.getData<{ id: number; processList: ProcessDefinition[] }>();
    if (!data) {
      return;
    }
    planId.value = data.id;
    processList.value = data.processList || [];
    // é»˜è®¤é€‰æ‹©ç¬¬ä¸€ä¸ªæµç¨‹
    if (processList.value.length > 0) {
      selectedProcessKey.value = processList.value[0]?.key ?? '';
    }
  },
});
</script>

<template>
  <Modal title="选择审批流程" class="w-1/3">
    <div class="mb-4">
      <span class="mr-2">审批流程：</span>
      <Select
        v-model:value="selectedProcessKey"
        :options="processOptions"
        style="width: 200px"
        placeholder="请选择审批流程"
      />
    </div>
  </Modal>
</template>

 src/views/hrm/certificate/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,197 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

import { markRaw } from 'vue';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import { HrmEmployeeSelect } from '#/views/hrm/employee/components';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'edit';

/** è¡¨å•çš„配置项 */
export function useFormSchema(formType: FormType): VbenFormSchema[] {
  const isReadonly = formType === 'detail';
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'employeeId',
      label: '员工',
      component: markRaw(HrmEmployeeSelect),
      componentProps: {
        placeholder: '请选择员工',
        disabled: isReadonly,
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'certType',
      label: '证书类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.HRM_CERTIFICATE_TYPE, 'number'),
        placeholder: '请选择证书类型',
        disabled: isReadonly,
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'certName',
      label: '证书名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入证书名称',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'certNo',
      label: '证书编号',
      component: 'Input',
      componentProps: {
        placeholder: '请输入证书编号',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'issueOrg',
      label: '发证机构',
      component: 'Input',
      componentProps: {
        placeholder: '请输入发证机构',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'issueDate',
      label: '发证日期',
      component: 'DatePicker',
      componentProps: {
        placeholder: '选择发证日期',
        valueFormat: 'YYYY-MM-DD',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'expireDate',
      label: '有效期至',
      component: 'DatePicker',
      componentProps: {
        placeholder: '选择有效期至',
        valueFormat: 'YYYY-MM-DD',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入备注',
        autoSize: { minRows: 1, maxRows: 1 },
        disabled: isReadonly,
      },
      formItemClass: 'col-span-2',
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'employeeId',
      label: '员工',
      component: markRaw(HrmEmployeeSelect),
      componentProps: {
        allowClear: true,
        placeholder: '请选择员工',
      },
    },
    {
      fieldName: 'certType',
      label: '证书类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.HRM_CERTIFICATE_TYPE, 'number'),
        placeholder: '请选择证书类型',
      },
    },
    {
      fieldName: 'certName',
      label: '证书名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入证书名称',
      },
    },
  ];
}

/** åˆ—表的表格列 */
export function useGridColumns(): VxeTableGridOptions['columns'] {
  return [
    { type: 'checkbox', width: 50 },
    { type: 'seq', title: '序号', width: 60 },
    {
      field: 'employeeName',
      title: '员工',
      minWidth: 120,
    },
    {
      field: 'certType',
      title: '证书类型',
      width: 120,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.HRM_CERTIFICATE_TYPE },
      },
    },
    {
      field: 'certName',
      title: '证书名称',
      minWidth: 200,
    },
    {
      field: 'certNo',
      title: '证书编号',
      minWidth: 130,
    },
    {
      field: 'issueOrg',
      title: '发证机构',
      minWidth: 140,
    },
    {
      field: 'expireDate',
      title: '有效期至',
      width: 120,
      formatter: 'formatDate',
    },
    {
      field: 'expireStatus',
      title: '到期状态',
      width: 100,
      slots: { default: 'expireStatus' },
    },
    {
      field: 'action',
      title: '操作',
      width: 200,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/hrm/certificate/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,169 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { HrmCertificateApi } from '#/api/hrm/certificate';

import { ref } from 'vue';

import { Page, useVbenModal } from '@vben/common-ui';
import { isEmpty } from '@vben/utils';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import { deleteCertificate, getCertificatePage } from '#/api/hrm/certificate';
import { $t } from '#/locales';

import { useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';

/** HRM è¯ä¹¦èµ„质列表 */
defineOptions({ name: 'HrmCertificate' });

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

function handleRefresh() {
  gridApi.query();
}

function handleCreate() {
  formModalApi.setData({ formType: 'create' }).open();
}

function handleEdit(row: HrmCertificateApi.Certificate) {
  formModalApi.setData({ formType: 'edit', id: row.id }).open();
}

function handleDetail(row: HrmCertificateApi.Certificate) {
  formModalApi.setData({ formType: 'detail', id: row.id }).open();
}

async function handleDelete(ids: number[]) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting'),
    duration: 0,
  });
  try {
    await deleteCertificate(ids);
    message.success($t('ui.actionMessage.deleteSuccess'));
    handleRefresh();
  } finally {
    hideLoading();
  }
}

const checkedIds = ref<number[]>([]);
function handleRowCheckboxChange({
  records,
}: {
  records: HrmCertificateApi.Certificate[];
}) {
  checkedIds.value = records.map((item) => item.id!);
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) => {
          return await getCertificatePage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          });
        },
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<HrmCertificateApi.Certificate>,
  gridEvents: {
    checkboxAll: handleRowCheckboxChange,
    checkboxChange: handleRowCheckboxChange,
  },
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="证书资质列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['证书资质']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['hrm:certificate:create'],
              onClick: handleCreate,
            },
            {
              label: '批量删除',
              type: 'primary',
              danger: true,
              disabled: isEmpty(checkedIds),
              icon: ACTION_ICON.DELETE,
              auth: ['hrm:certificate:delete'],
              popConfirm: {
                title: `是否删除所选中数据？`,
                confirm: handleDelete.bind(null, checkedIds),
              },
            },
          ]"
        />
      </template>
      <template #expireStatus="{ row }">
        <Tag v-if="row.expireStatus === 0" color="success">有效</Tag>
        <Tag v-else-if="row.expireStatus === 1" color="warning">即将到期</Tag>
        <Tag v-else-if="row.expireStatus === 2" color="error">已过期</Tag>
        <Tag v-else color="default">-</Tag>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['hrm:certificate:query'],
              onClick: handleDetail.bind(null, row),
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['hrm:certificate:update'],
              onClick: handleEdit.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['hrm:certificate:delete'],
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.certName]),
                confirm: handleDelete.bind(null, [row.id!]),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/hrm/certificate/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,91 @@
<script lang="ts" setup>
import type { HrmCertificateApi } from '#/api/hrm/certificate';

import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import { createCertificate, getCertificate, updateCertificate } from '#/api/hrm/certificate';
import { $t } from '#/locales';

import type { FormType } from '../data';
import { useFormSchema } from '../data';

const emit = defineEmits(['success']);
const formData = ref<HrmCertificateApi.Certificate>();
const formType = ref<FormType>('create');

const getTitle = computed(() => {
  if (formType.value === 'create') {
    return $t('ui.actionTitle.create', ['证书资质']);
  } else if (formType.value === 'edit') {
    return $t('ui.actionTitle.edit', ['证书资质']);
  } else {
    return '证书资质详情';
  }
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 120,
  },
  wrapperClass: 'grid-cols-3',
  layout: 'vertical',
  schema: useFormSchema(formType.value),
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data =
      (await formApi.getValues()) as HrmCertificateApi.Certificate;
    try {
      await (formType.value === 'create'
        ? createCertificate(data)
        : updateCertificate(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    const data = modalApi.getData<{ formType: FormType; id?: number }>();
    formType.value = data.formType;
    formApi.setDisabled(formType.value === 'detail');
    formApi.updateSchema(useFormSchema(formType.value));
    if (!data || !data.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getCertificate(data.id);
      await formApi.setValues(formData.value);
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal :title="getTitle" class="w-2/3" :show-confirm-button="formType !== 'detail'">
    <Form class="mx-3" />
  </Modal>
</template>

 src/views/hrm/performance-appraise/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,203 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'edit';

/** æ–¹æ¡ˆçŠ¶æ€å¸¸é‡ */
export const APPRAISE_STATUS = {
  DRAFT: 0,
  PUBLISHED: 10,
  PROCESSING: 20,
  FINISHED: 30,
};

/** å®¡æ‰¹çŠ¶æ€å¸¸é‡ */
export const AUDIT_STATUS = {
  DRAFT: 0,
  PROCESS: 10,
  APPROVE: 20,
  REJECT: 30,
  CANCEL: 40,
};

/** è¡¨å•çš„配置项 */
export function useFormSchema(formType: FormType): VbenFormSchema[] {
  const isReadonly = formType === 'detail';
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'name',
      label: '方案名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入方案名称',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'periodType',
      label: '考核周期类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.HRM_PERFORMANCE_PERIOD_TYPE, 'number'),
        placeholder: '请选择考核周期类型',
        disabled: isReadonly,
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'period',
      label: '考核周期',
      component: 'Input',
      componentProps: {
        placeholder: '如：2026-08',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'scopeType',
      label: '考核范围',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.HRM_PERFORMANCE_SCOPE_TYPE, 'number'),
        placeholder: '请选择考核范围',
        disabled: isReadonly,
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      formItemClass: 'col-span-3',
      componentProps: {
        placeholder: '请输入备注',
        autoSize: { minRows: 1, maxRows: 1 },
        disabled: isReadonly,
      },
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'name',
      label: '方案名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入方案名称',
      },
    },
    {
      fieldName: 'periodType',
      label: '考核周期类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.HRM_PERFORMANCE_PERIOD_TYPE, 'number'),
        placeholder: '请选择考核周期类型',
      },
    },
    {
      fieldName: 'status',
      label: '方案状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: [
          { label: '草稿', value: APPRAISE_STATUS.DRAFT },
          { label: '已发布', value: APPRAISE_STATUS.PUBLISHED },
          { label: '进行中', value: APPRAISE_STATUS.PROCESSING },
          { label: '已完成', value: APPRAISE_STATUS.FINISHED },
        ],
        placeholder: '请选择方案状态',
      },
    },
  ];
}

/** åˆ—表的表格列 */
export function useGridColumns(): VxeTableGridOptions['columns'] {
  return [
    { type: 'checkbox', width: 50 },
    { type: 'seq', title: '序号', width: 60 },
    {
      field: 'name',
      title: '方案名称',
      minWidth: 200,
      slots: { default: 'name' },
    },
    {
      field: 'periodType',
      title: '考核周期类型',
      width: 120,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.HRM_PERFORMANCE_PERIOD_TYPE },
      },
    },
    {
      field: 'period',
      title: '考核周期',
      width: 110,
    },
    {
      field: 'scopeType',
      title: '考核范围',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.HRM_PERFORMANCE_SCOPE_TYPE },
      },
    },
    {
      field: 'status',
      title: '方案状态',
      width: 100,
      slots: { default: 'status' },
    },
    {
      field: 'auditStatus',
      title: '审批状态',
      width: 100,
      slots: { default: 'auditStatus' },
    },
    {
      field: 'itemCount',
      title: '指标数',
      width: 80,
    },
    {
      field: 'resultCount',
      title: '已评分人数',
      width: 100,
    },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      field: 'action',
      title: '操作',
      width: 320,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/hrm/performance-appraise/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,304 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { HrmPerformanceAppraiseApi } from '#/api/hrm/performance-appraise';

import { ref } from 'vue';
import { useRouter } from 'vue-router';

import { Page, useVbenModal } from '@vben/common-ui';
import { isEmpty } from '@vben/utils';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import {
  deleteAppraise,
  getAppraisePage,
  getAppraiseProcessList,
} from '#/api/hrm/performance-appraise';
import { $t } from '#/locales';

import { APPRAISE_STATUS, AUDIT_STATUS, useGridColumns, useGridFormSchema } from './data';
import AuditModal from './modules/audit-modal.vue';
import Form from './modules/form.vue';
import ItemModal from './modules/item.vue';
import ProcessSelectModal from './modules/process-select-modal.vue';
import ResultModal from './modules/result.vue';
import ScoreModal from './modules/score.vue';

/** HRM ç»©æ•ˆè€ƒæ ¸æ–¹æ¡ˆåˆ—表 */
defineOptions({ name: 'HrmPerformanceAppraise' });

const router = useRouter();

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

const [ItemFormModal, itemModalApi] = useVbenModal({
  connectedComponent: ItemModal,
  destroyOnClose: true,
});

const [ScoreFormModal, scoreModalApi] = useVbenModal({
  connectedComponent: ScoreModal,
  destroyOnClose: true,
});

const [ResultFormModal, resultModalApi] = useVbenModal({
  connectedComponent: ResultModal,
  destroyOnClose: true,
});

const [ProcessModal, processModalApi] = useVbenModal({
  connectedComponent: ProcessSelectModal,
  destroyOnClose: true,
});

const [AuditFormModal, auditModalApi] = useVbenModal({
  connectedComponent: AuditModal,
  destroyOnClose: true,
});

function handleRefresh() {
  gridApi.query();
}

function handleCreate() {
  formModalApi.setData({ formType: 'create' }).open();
}

function handleEdit(row: HrmPerformanceAppraiseApi.Appraise) {
  formModalApi.setData({ formType: 'edit', id: row.id }).open();
}

function handleDetail(row: HrmPerformanceAppraiseApi.Appraise) {
  formModalApi.setData({ formType: 'detail', id: row.id }).open();
}

function handleItems(row: HrmPerformanceAppraiseApi.Appraise) {
  itemModalApi.setData({ id: row.id }).open();
}

function handleScore(row: HrmPerformanceAppraiseApi.Appraise) {
  scoreModalApi.setData({ id: row.id }).open();
}

function handleResult(row: HrmPerformanceAppraiseApi.Appraise) {
  resultModalApi.setData({ id: row.id }).open();
}

async function handleDelete(ids: number[]) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting'),
    duration: 0,
  });
  try {
    await deleteAppraise(ids);
    message.success($t('ui.actionMessage.deleteSuccess'));
    handleRefresh();
  } finally {
    hideLoading();
  }
}

/** æäº¤å®¡æ‰¹ - å…ˆèŽ·å–流程列表 */
async function handleSubmit(row: HrmPerformanceAppraiseApi.Appraise) {
  const hideLoading = message.loading({
    content: '获取审批流程...',
    duration: 0,
  });
  try {
    const processList = await getAppraiseProcessList();
    hideLoading();
    if (!processList || processList.length === 0) {
      message.warning('暂无可用审批流程，请先配置 BPM æµç¨‹');
      return;
    }
    processModalApi.setData({ id: row.id, processList }).open();
  } catch {
    hideLoading();
  }
}

/** å®¡æ‰¹ï¼ˆé€šè¿‡/驳回） */
function handleAudit(row: HrmPerformanceAppraiseApi.Appraise) {
  auditModalApi.setData({ id: row.id }).open();
}

/** æŸ¥çœ‹å®¡æ‰¹è¯¦æƒ… */
function handleViewProcess(row: HrmPerformanceAppraiseApi.Appraise) {
  if (!row.processInstanceId) {
    message.warning('该方案尚未提交审批');
    return;
  }
  router.push({
    name: 'BpmProcessInstanceDetail',
    query: { id: row.processInstanceId },
  });
}

const checkedIds = ref<number[]>([]);
function handleRowCheckboxChange({
  records,
}: {
  records: HrmPerformanceAppraiseApi.Appraise[];
}) {
  checkedIds.value = records.map((item) => item.id!);
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) => {
          return await getAppraisePage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          });
        },
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<HrmPerformanceAppraiseApi.Appraise>,
  gridEvents: {
    checkboxAll: handleRowCheckboxChange,
    checkboxChange: handleRowCheckboxChange,
  },
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <ItemFormModal @success="handleRefresh" />
    <ScoreFormModal @success="handleRefresh" />
    <ResultFormModal @success="handleRefresh" />
    <ProcessModal @success="handleRefresh" />
    <AuditFormModal @success="handleRefresh" />
    <Grid table-title="绩效考核方案列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['绩效考核方案']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['hrm:performance-appraise:create'],
              onClick: handleCreate,
            },
            {
              label: '批量删除',
              type: 'primary',
              danger: true,
              disabled: isEmpty(checkedIds),
              icon: ACTION_ICON.DELETE,
              auth: ['hrm:performance-appraise:delete'],
              popConfirm: {
                title: `是否删除所选中数据？`,
                confirm: handleDelete.bind(null, checkedIds),
              },
            },
          ]"
        />
      </template>
      <template #name="{ row }">
        <a class="link" @click="handleDetail(row)">{{ row.name }}</a>
      </template>
      <template #status="{ row }">
        <Tag v-if="row.status === APPRAISE_STATUS.DRAFT" color="default">草稿</Tag>
        <Tag v-else-if="row.status === APPRAISE_STATUS.PUBLISHED" color="processing">已发布</Tag>
        <Tag v-else-if="row.status === APPRAISE_STATUS.PROCESSING" color="warning">进行中</Tag>
        <Tag v-else-if="row.status === APPRAISE_STATUS.FINISHED" color="success">已完成</Tag>
      </template>
      <template #auditStatus="{ row }">
        <Tag v-if="row.auditStatus === AUDIT_STATUS.DRAFT" color="default">未提交</Tag>
        <Tag v-else-if="row.auditStatus === AUDIT_STATUS.PROCESS" color="processing">审批中</Tag>
        <Tag v-else-if="row.auditStatus === AUDIT_STATUS.APPROVE" color="success">通过</Tag>
        <Tag v-else-if="row.auditStatus === AUDIT_STATUS.REJECT" color="error">驳回</Tag>
        <Tag v-else-if="row.auditStatus === AUDIT_STATUS.CANCEL" color="warning">已取消</Tag>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: '指标',
              type: 'link',
              auth: ['hrm:performance-appraise:update'],
              ifShow: row.status === APPRAISE_STATUS.DRAFT,
              onClick: handleItems.bind(null, row),
            },
            {
              label: '评分',
              type: 'link',
              auth: ['hrm:performance-appraise:update'],
              ifShow: row.status === APPRAISE_STATUS.PUBLISHED || row.status === APPRAISE_STATUS.PROCESSING,
              onClick: handleScore.bind(null, row),
            },
            {
              label: '结果',
              type: 'link',
              ifShow: (row.resultCount ?? 0) > 0,
              onClick: handleResult.bind(null, row),
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['hrm:performance-appraise:update'],
              ifShow: row.status === APPRAISE_STATUS.DRAFT,
              onClick: handleEdit.bind(null, row),
            },
            {
              label: '提交审批',
              type: 'link',
              auth: ['hrm:performance-appraise:submit'],
              ifShow: row.auditStatus === AUDIT_STATUS.DRAFT || row.auditStatus === AUDIT_STATUS.REJECT,
              onClick: handleSubmit.bind(null, row),
            },
            {
              label: '审批',
              type: 'link',
              auth: ['hrm:performance-appraise:audit'],
              ifShow: row.auditStatus === AUDIT_STATUS.PROCESS,
              onClick: handleAudit.bind(null, row),
            },
            {
              label: '查看审批',
              type: 'link',
              ifShow: row.auditStatus !== AUDIT_STATUS.DRAFT && !!row.processInstanceId,
              onClick: handleViewProcess.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['hrm:performance-appraise:delete'],
              ifShow: row.status === APPRAISE_STATUS.DRAFT,
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.name]),
                confirm: handleDelete.bind(null, [row.id!]),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/hrm/performance-appraise/modules/audit-modal.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,91 @@
<script lang="ts" setup>
import { ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import { auditAppraise } from '#/api/hrm/performance-appraise';

const emit = defineEmits(['success']);

const appraiseId = ref<number>();

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 100,
  },
  wrapperClass: 'grid-cols-1',
  layout: 'vertical',
  schema: [
    {
      fieldName: 'auditStatus',
      label: '审批结果',
      component: 'RadioGroup',
      componentProps: {
        options: [
          { label: '通过', value: 20 },
          { label: '驳回', value: 30 },
        ],
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'remark',
      label: '审批备注',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入审批备注',
        rows: 3,
      },
    },
  ],
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    try {
      const values = await formApi.getValues<{
        auditStatus: number;
        remark?: string;
      }>();
      await auditAppraise({
        id: appraiseId.value!,
        auditStatus: values.auditStatus,
        remark: values.remark,
      });
      await modalApi.close();
      emit('success');
      message.success('审批完成');
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      appraiseId.value = undefined;
      await formApi.resetForm();
      return;
    }
    const data = modalApi.getData<{ id: number }>();
    appraiseId.value = data?.id;
    await formApi.setValues({ auditStatus: 20 });
  },
});
</script>

<template>
  <Modal title="审批绩效考核方案" class="w-1/3">
    <Form class="mx-3" />
  </Modal>
</template>

 src/views/hrm/performance-appraise/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,95 @@
<script lang="ts" setup>
import type { HrmPerformanceAppraiseApi } from '#/api/hrm/performance-appraise';

import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import {
  createAppraise,
  getAppraise,
  updateAppraise,
} from '#/api/hrm/performance-appraise';
import { $t } from '#/locales';

import type { FormType } from '../data';
import { useFormSchema } from '../data';

const emit = defineEmits(['success']);
const formData = ref<HrmPerformanceAppraiseApi.Appraise>();
const formType = ref<FormType>('create');

const getTitle = computed(() => {
  if (formType.value === 'create') {
    return $t('ui.actionTitle.create', ['绩效考核方案']);
  } else if (formType.value === 'edit') {
    return $t('ui.actionTitle.edit', ['绩效考核方案']);
  } else {
    return '绩效考核方案详情';
  }
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 120,
  },
  wrapperClass: 'grid-cols-3',
  layout: 'vertical',
  schema: useFormSchema(formType.value),
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data =
      (await formApi.getValues()) as HrmPerformanceAppraiseApi.Appraise;
    try {
      await (formType.value === 'create'
        ? createAppraise(data)
        : updateAppraise(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    const data = modalApi.getData<{ formType: FormType; id?: number }>();
    formType.value = data.formType;
    formApi.setDisabled(formType.value === 'detail');
    formApi.updateSchema(useFormSchema(formType.value));
    if (!data || !data.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getAppraise(data.id);
      await formApi.setValues(formData.value);
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal :title="getTitle" class="w-2/3" :show-confirm-button="formType !== 'detail'">
    <Form class="mx-3" />
  </Modal>
</template>

 src/views/hrm/performance-appraise/modules/item.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,147 @@
<script lang="ts" setup>
import type { HrmPerformanceAppraiseApi } from '#/api/hrm/performance-appraise';

import { ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import {
  getAppraiseItemList,
  saveAppraiseItems,
} from '#/api/hrm/performance-appraise';

const emit = defineEmits(['success']);

const appraiseId = ref<number>();
const items = ref<HrmPerformanceAppraiseApi.AppraiseItem[]>([]);

const SCORER_TYPE_OPTIONS = [
  { label: '自评', value: 1 },
  { label: '上级评', value: 2 },
];

function addRow() {
  items.value.push({
    itemName: '',
    weight: undefined,
    scoringStandard: '',
    scorerType: 1,
    sort: items.value.length + 1,
  });
}

function removeRow(index: number) {
  items.value.splice(index, 1);
  items.value.forEach((item, idx) => {
    item.sort = idx + 1;
  });
}

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    // æ ¡éªŒï¼šæŒ‡æ ‡åç§°ä¸Žæƒé‡å¿…å¡«
    const invalid = items.value.some(
      (item) => !item.itemName || item.weight == null,
    );
    if (invalid) {
      message.warning('请填写完整的指标名称与权重');
      return;
    }
    modalApi.lock();
    try {
      await saveAppraiseItems({ appraiseId: appraiseId.value!, items: items.value });
      await modalApi.close();
      emit('success');
      message.success('指标保存成功');
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      appraiseId.value = undefined;
      items.value = [];
      return;
    }
    const data = modalApi.getData<{ id: number }>();
    appraiseId.value = data?.id;
    modalApi.lock();
    try {
      items.value = await getAppraiseItemList(appraiseId.value!);
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal title="配置考核指标" class="w-3/4">
    <div class="mb-3 flex items-center justify-between">
      <span class="text-sm text-gray-500">设置考核指标名称、权重与评分标准，权重合计建议 100</span>
      <a-button type="primary" @click="addRow">添加指标</a-button>
    </div>
    <a-table
      :data-source="items"
      :pagination="false"
      :scroll="{ y: 360 }"
      bordered
      row-key="sort"
      size="small"
    >
      <a-table-column title="指标名称" width="220">
        <template #default="{ record }">
          <a-input
            v-model:value="record.itemName"
            placeholder="请输入指标名称"
          />
        </template>
      </a-table-column>
      <a-table-column title="权重" width="120">
        <template #default="{ record }">
          <a-input-number
            v-model:value="record.weight"
            :min="0"
            :precision="2"
            class="!w-full"
            placeholder="权重"
          />
        </template>
      </a-table-column>
      <a-table-column title="评分标准" min-width="220">
        <template #default="{ record }">
          <a-input
            v-model:value="record.scoringStandard"
            placeholder="请输入评分标准"
          />
        </template>
      </a-table-column>
      <a-table-column title="评分人" width="120">
        <template #default="{ record }">
          <a-select
            v-model:value="record.scorerType"
            :options="SCORER_TYPE_OPTIONS"
            class="!w-full"
          />
        </template>
      </a-table-column>
      <a-table-column title="排序" width="90">
        <template #default="{ record }">
          <a-input-number
            v-model:value="record.sort"
            :min="1"
            :precision="0"
            class="!w-full"
          />
        </template>
      </a-table-column>
      <a-table-column title="操作" width="80" align="center">
        <template #default="{ index }">
          <a-button type="link" danger @click="removeRow(index)">删除</a-button>
        </template>
      </a-table-column>
    </a-table>
  </Modal>
</template>

 src/views/hrm/performance-appraise/modules/process-select-modal.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,78 @@
<script lang="ts" setup>
import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message, Select } from 'ant-design-vue';

import { submitAppraise } from '#/api/hrm/performance-appraise';

interface ProcessDefinition {
  id: string;
  name: string;
  version: number;
  key: string;
}

const emit = defineEmits(['success']);

const appraiseId = ref<number>();
const processList = ref<ProcessDefinition[]>([]);
const selectedProcessKey = ref<string>('');

const processOptions = computed(() => {
  return processList.value.map((p) => ({
    label: `${p.name} (V${p.version})`,
    value: p.key,
  }));
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    if (!selectedProcessKey.value) {
      message.warning('请选择审批流程');
      return;
    }
    modalApi.lock();
    try {
      await submitAppraise(appraiseId.value!, selectedProcessKey.value);
      await modalApi.close();
      emit('success');
      message.success('提交成功');
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      appraiseId.value = undefined;
      selectedProcessKey.value = '';
      processList.value = [];
      return;
    }
    const data = modalApi.getData<{ id: number; processList: ProcessDefinition[] }>();
    if (!data) {
      return;
    }
    appraiseId.value = data.id;
    processList.value = data.processList || [];
    if (processList.value.length > 0) {
      selectedProcessKey.value = processList.value[0]?.key ?? '';
    }
  },
});
</script>

<template>
  <Modal title="选择审批流程" class="w-1/3">
    <div class="mb-4">
      <span class="mr-2">审批流程：</span>
      <Select
        v-model:value="selectedProcessKey"
        :options="processOptions"
        style="width: 200px"
        placeholder="请选择审批流程"
      />
    </div>
  </Modal>
</template>

 src/views/hrm/performance-appraise/modules/result.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,138 @@
<script lang="ts" setup>
import type { HrmPerformanceAppraiseApi } from '#/api/hrm/performance-appraise';

import { ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { Modal } from 'ant-design-vue';

import { DICT_TYPE } from '@vben/constants';
import { getDictLabel } from '@vben/hooks';

import { getAppraiseResultPage } from '#/api/hrm/performance-appraise';

const emit = defineEmits(['success']);

const appraiseId = ref<number>();
const resultList = ref<HrmPerformanceAppraiseApi.AppraiseResult[]>([]);
const total = ref(0);
const pageNo = ref(1);
const pageSize = ref(10);
const loading = ref(false);

const detailOpen = ref(false);
const detailRows = ref<HrmPerformanceAppraiseApi.ResultItem[]>([]);

function getGradeLabel(grade?: number): string {
  return grade == null ? '-' : getDictLabel(DICT_TYPE.HRM_PERFORMANCE_GRADE, grade);
}

async function loadResults() {
  loading.value = true;
  try {
    const data = await getAppraiseResultPage({
      appraiseId: appraiseId.value!,
      pageNo: pageNo.value,
      pageSize: pageSize.value,
    });
    resultList.value = data.list ?? [];
    total.value = data.total ?? 0;
  } finally {
    loading.value = false;
  }
}

function handlePageChange(page: number, size: number) {
  pageNo.value = page;
  pageSize.value = size;
  loadResults();
}

function handleDetail(row: HrmPerformanceAppraiseApi.AppraiseResult) {
  detailRows.value = row.items ?? [];
  detailOpen.value = true;
}

const [ModalRoot, modalApi] = useVbenModal({
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      appraiseId.value = undefined;
      resultList.value = [];
      total.value = 0;
      pageNo.value = 1;
      return;
    }
    const data = modalApi.getData<{ id: number }>();
    appraiseId.value = data?.id;
    await loadResults();
  },
});
</script>

<template>
  <ModalRoot title="考核结果" class="w-3/4">
    <div class="mb-3 text-sm text-gray-500">
      ç»¼åˆå¾—分 = Î£(权重 Ã— å•æŒ‡æ ‡å¾—分) / Î£æƒé‡ï¼›æ¡£çº§ â‰¥90 ä¼˜ç§€ / â‰¥80 è‰¯å¥½ / â‰¥60 åˆæ ¼ / &lt;60 å¾…改进
    </div>
    <a-table
      :data-source="resultList"
      :loading="loading"
      :pagination="{
        current: pageNo,
        pageSize,
        total,
        showSizeChanger: true,
        showTotal: (t: number) => `共 ${t} äºº`,
      }"
      :scroll="{ y: 380 }"
      bordered
      row-key="id"
      size="small"
      @change="(pag: { current?: number; pageSize?: number }) =>
        handlePageChange(pag.current ?? 1, pag.pageSize ?? 10)"
    >
      <a-table-column title="员工" data-index="employeeName" min-width="120" />
      <a-table-column title="自评总分" data-index="selfScore" width="100" />
      <a-table-column title="上级评总分" data-index="superiorScore" width="110" />
      <a-table-column title="综合得分" data-index="finalScore" width="100">
        <template #default="{ record }">
          <span class="font-medium">{{ record.finalScore ?? '-' }}</span>
        </template>
      </a-table-column>
      <a-table-column title="档级" width="90">
        <template #default="{ record }">
          <a-tag :color="record.grade === 1 ? 'success' : record.grade === 2 ? 'processing' : record.grade === 3 ? 'warning' : 'error'">
            {{ getGradeLabel(record.grade) }}
          </a-tag>
        </template>
      </a-table-column>
      <a-table-column title="评语" data-index="comment" min-width="160" ellipsis />
      <a-table-column title="操作" width="90" align="center">
        <template #default="{ record }">
          <a-button type="link" @click="handleDetail(record)">明细</a-button>
        </template>
      </a-table-column>
    </a-table>

    <Modal
      v-model:open="detailOpen"
      title="指标评分明细"
      width="640px"
      :footer="null"
    >
      <a-table
        :data-source="detailRows"
        :pagination="false"
        bordered
        row-key="id"
        size="small"
      >
        <a-table-column title="指标名称" data-index="itemName" min-width="160" />
        <a-table-column title="权重" data-index="weight" width="90" />
        <a-table-column title="自评得分" data-index="selfScore" width="100" />
        <a-table-column title="上级评得分" data-index="superiorScore" width="110" />
      </a-table>
    </Modal>
  </ModalRoot>
</template>

 src/views/hrm/performance-appraise/modules/score.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,180 @@
<script lang="ts" setup>
import type { HrmPerformanceAppraiseApi } from '#/api/hrm/performance-appraise';

import { markRaw, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import {
  getAppraiseItemList,
  getAppraiseResult,
  saveAppraiseResult,
} from '#/api/hrm/performance-appraise';
import { HrmEmployeeSelect } from '#/views/hrm/employee/components';

const emit = defineEmits(['success']);

const appraiseId = ref<number>();
const employeeId = ref<number>();
const items = ref<HrmPerformanceAppraiseApi.AppraiseItem[]>([]);
const comment = ref<string>('');

const SCORER_TYPE_OPTIONS = [
  { label: '自评', value: 1 },
  { label: '上级评', value: 2 },
];

/** åŠ è½½æŒ‡æ ‡åˆ—表（仅在首次打开时） */
async function loadItems() {
  items.value = await getAppraiseItemList(appraiseId.value!);
}

/** åˆ‡æ¢å‘˜å·¥æ—¶å›žå¡«å·²æœ‰è¯„分 */
async function handleEmployeeChange(item: { id?: number } | undefined) {
  employeeId.value = item?.id;
  comment.value = '';
  if (!item?.id) {
    items.value.forEach((it) => {
      it.selfScore = undefined;
      it.superiorScore = undefined;
    });
    return;
  }
  const result = await getAppraiseResult(appraiseId.value!, item.id);
  if (result?.items) {
    items.value.forEach((it) => {
      const detail = result.items!.find((ri) => ri.itemId === it.id);
      it.selfScore = detail?.selfScore;
      it.superiorScore = detail?.superiorScore;
    });
    comment.value = result.comment ?? '';
  } else {
    items.value.forEach((it) => {
      it.selfScore = undefined;
      it.superiorScore = undefined;
    });
  }
}

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    if (!employeeId.value) {
      message.warning('请选择员工');
      return;
    }
    modalApi.lock();
    try {
      await saveAppraiseResult({
        appraiseId: appraiseId.value!,
        employeeId: employeeId.value!,
        comment: comment.value,
        items: items.value.map((item) => ({
          itemId: item.id!,
          selfScore: item.selfScore,
          superiorScore: item.superiorScore,
        })),
      });
      await modalApi.close();
      emit('success');
      message.success('评分保存成功，已自动计算综合得分');
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      appraiseId.value = undefined;
      employeeId.value = undefined;
      items.value = [];
      comment.value = '';
      return;
    }
    const data = modalApi.getData<{ id: number }>();
    appraiseId.value = data?.id;
    modalApi.lock();
    try {
      await loadItems();
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal title="员工考核评分" class="w-3/4">
    <div class="mb-4 flex items-center gap-4">
      <span class="shrink-0">考核员工：</span>
      <HrmEmployeeSelect
        :model-value="employeeId"
        class="!w-72"
        @change="handleEmployeeChange"
        @update:model-value="(value: number | undefined) => (employeeId = value)"
      />
    </div>
    <a-table
      :data-source="items"
      :pagination="false"
      :scroll="{ y: 300 }"
      bordered
      row-key="id"
      size="small"
    >
      <a-table-column title="指标名称" min-width="180">
        <template #default="{ record }">
          <span>{{ record.itemName }}</span>
        </template>
      </a-table-column>
      <a-table-column title="权重" width="90">
        <template #default="{ record }">
          <span>{{ record.weight }}</span>
        </template>
      </a-table-column>
      <a-table-column title="评分人" width="90">
        <template #default="{ record }">
          <span>{{ record.scorerType === 1 ? '自评' : '上级评' }}</span>
        </template>
      </a-table-column>
      <a-table-column title="自评得分" width="130">
        <template #default="{ record }">
          <a-input-number
            v-model:value="record.selfScore"
            :min="0"
            :max="100"
            :precision="1"
            class="!w-full"
            placeholder="自评得分"
          />
        </template>
      </a-table-column>
      <a-table-column title="上级评得分" width="130">
        <template #default="{ record }">
          <a-input-number
            v-model:value="record.superiorScore"
            :min="0"
            :max="100"
            :precision="1"
            class="!w-full"
            placeholder="上级评得分"
          />
        </template>
      </a-table-column>
      <a-table-column title="评分标准" min-width="180">
        <template #default="{ record }">
          <span class="text-xs text-gray-400">{{ record.scoringStandard || '-' }}</span>
        </template>
      </a-table-column>
    </a-table>
    <div class="mt-3">
      <span class="mr-2">评语：</span>
      <a-textarea
        v-model:value="comment"
        :rows="2"
        placeholder="请输入评语"
        class="!w-full"
      />
    </div>
  </Modal>
</template>

 src/views/hrm/workhour/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,142 @@
<script lang="ts" setup>
  import type { VxeTableGridOptions } from '#/adapter/vxe-table';
  import type { HrmWorkHourStatisticsApi } from '#/api/hrm/work-hour-statistics';

  import { onBeforeUnmount, onMounted, ref, useTemplateRef } from 'vue';

  import { Page } from '@vben/common-ui';
  import { useVbenVxeGrid } from '#/adapter/vxe-table';

  import { Tabs } from 'ant-design-vue';

  import {
    getEmployeeWorkHourSummary,
    getTeamWorkHourSummary,
  } from '#/api/hrm/work-hour-statistics';

  /** HRM å·¥æ—¶ç»Ÿè®¡ï¼ˆè€ƒå‹¤å£å¾„ + æŠ¥å·¥å£å¾„） */
  defineOptions({ name: 'HrmWorkHourStatistics' });

  const activeTab = ref<'employee' | 'team'>('employee');

  const contentRef = useTemplateRef('contentRef');
  let resizeObserver: ResizeObserver | undefined;

  /** è®¡ç®—表格高度：内容区可用高度 - Tabs å¯¼èˆªç­‰å›ºå®šå¼€é”€ï¼Œè¡¨æ ¼æ’‘满页面 */
  function calcTableHeight() {
    const el = contentRef.value;
    if (!el) return;
    const height = Math.max(el.clientHeight - 115, 240);
    employeeGridApi.setGridOptions({ height });
    teamGridApi.setGridOptions({ height });
  }

  onMounted(() => {
    calcTableHeight();
    resizeObserver = new ResizeObserver(calcTableHeight);
    if (contentRef.value) resizeObserver.observe(contentRef.value);
  });

  onBeforeUnmount(() => {
    resizeObserver?.disconnect();
  });

  const [EmployeeGrid, employeeGridApi] = useVbenVxeGrid({
    formOptions: {
      schema: [
        {
          fieldName: 'dateRange',
          label: '日期范围',
          component: 'RangePicker',
          componentProps: {
            class: '!w-full',
            valueFormat: 'YYYY-MM-DD',
            placeholder: ['开始日期', '结束日期'],
          },
        },
      ],
    },
    gridOptions: {
      columns: [
        { field: 'userName', title: '员工姓名', minWidth: 140 },
        { field: 'deptName', title: '部门', minWidth: 140 },
        { field: 'workDays', title: '出勤天数', width: 110 },
        { field: 'workHours', title: '正常工时(人时)', width: 150 },
        { field: 'overtimeHours', title: '加班工时(人时)', width: 150 },
      ],
      height: 400,
      keepSource: true,
      // è¿”回裸数组，需关闭分页
      pagerConfig: { enabled: false },
      proxyConfig: {
        ajax: {
          query: async (_params, formValues) => {
            const range = formValues?.dateRange ?? [];
            return await getEmployeeWorkHourSummary({
              startDate: range?.[0],
              endDate: range?.[1],
            });
          },
        },
      },
      rowConfig: { keyField: 'userId', isHover: true },
      toolbarConfig: { refresh: true, search: true },
    } as VxeTableGridOptions<HrmWorkHourStatisticsApi.EmployeeWorkHour>,
  });

  const [TeamGrid, teamGridApi] = useVbenVxeGrid({
    formOptions: {
      schema: [
        {
          fieldName: 'timeRange',
          label: '日期范围',
          component: 'RangePicker',
          componentProps: {
            class: '!w-full',
            valueFormat: 'YYYY-MM-DD HH:mm:ss',
            placeholder: ['开始时间', '结束时间'],
          },
        },
      ],
    },
    gridOptions: {
      columns: [
        { field: 'teamName', title: '班组名称', minWidth: 160 },
        { field: 'taskCount', title: '任务数', width: 100 },
        { field: 'totalDuration', title: '总生产时长(人日)', width: 160 },
        { field: 'workHours', title: '总工时(人时)', width: 150 },
      ],
      height: 400,
      keepSource: true,
      pagerConfig: { enabled: false },
      proxyConfig: {
        ajax: {
          query: async (_params, formValues) => {
            const range = formValues?.timeRange ?? [];
            return await getTeamWorkHourSummary({
              startTime: range?.[0],
              endTime: range?.[1],
            });
          },
        },
      },
      rowConfig: { keyField: 'teamId', isHover: true },
      toolbarConfig: { refresh: true, search: true },
    } as VxeTableGridOptions<HrmWorkHourStatisticsApi.TeamWorkHour>,
  });
</script>

<template>
  <Page auto-content-height>
    <div ref="contentRef" class="flex h-full w-full flex-col">
      <Tabs v-model:active-key="activeTab" class="min-h-0 flex-1">
        <Tabs.TabPane key="employee" tab="员工工时（考勤口径）">
          <EmployeeGrid table-title="员工工时统计" />
        </Tabs.TabPane>
        <Tabs.TabPane key="team" tab="班组工时（报工口径）">
          <TeamGrid table-title="班组工时统计" />
        </Tabs.TabPane>
      </Tabs>
    </div>
  </Page>
</template>

 src/views/mes/dv/machinery/data.ts

@@ -76,6 +76,15 @@
      rules: 'required',
    },
    {
      fieldName: 'tbDeviceId',
      label: '数采设备ID',
      component: 'Input',
      componentProps: {
        placeholder: '请输入数采设备ID（外部数采 tbDeviceId）',
      },
      help: '与数采系统设备ID对应，用于关联设备实时数据',
    },
    {
      fieldName: 'brand',
      label: '品牌',
      component: 'Input',

 src/views/mes/dv/machinery/modules/form.vue

@@ -23,6 +23,7 @@
  import CheckRecordList from "./check-record-list.vue";
  import MaintenRecordList from "./mainten-record-list.vue";
  import RepairList from "./repair-list.vue";
  import TelemetryList from "./telemetry-list.vue";

  const emit = defineEmits(["success"]);
  const formType = ref<FormType>("create"); // è¡¨å•æ¨¡å¼
@@ -133,6 +134,11 @@
                    tab="维修记录">
        <RepairList :machinery-id="formData.id" />
      </Tabs.TabPane>
      <Tabs.TabPane key="telemetry"
                    tab="数采数据"
                    :disabled="!formData.tbDeviceId">
        <TelemetryList :tb-device-id="formData.tbDeviceId" />
      </Tabs.TabPane>
    </Tabs>
    <template #prepend-footer>
      <div class="flex flex-auto items-center">

 src/views/mes/dv/machinery/modules/telemetry-list.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,52 @@
<script lang="ts" setup>
  import type { VxeTableGridOptions } from '#/adapter/vxe-table';
  import type { MesDvTelemetryApi } from '#/api/mes/dv/telemetry';

  import { watch } from 'vue';

  import { Tag } from 'ant-design-vue';

  import { useVbenVxeGrid } from '#/adapter/vxe-table';
  import { getLatestTelemetry } from '#/api/mes/dv/telemetry';

  import { useLatestColumns } from '../../telemetry/data';

  const props = defineProps<{ tbDeviceId?: string }>();

  const [Grid, gridApi] = useVbenVxeGrid({
    gridOptions: {
      columns: useLatestColumns(),
      height: 320,
      keepSource: true,
      // /latest è¿”回裸数组，需关闭分页，否则 vxe ä¼šæŒ‰ {list,total} è§£æžå¯¼è‡´ä¸å±•ç¤º
      pagerConfig: { enabled: false },
      proxyConfig: {
        ajax: {
          query: async () =>
            await getLatestTelemetry({ tbDeviceId: props.tbDeviceId }),
        },
      },
      rowConfig: { keyField: 'id', isHover: true },
      toolbarConfig: { refresh: true },
    } as VxeTableGridOptions<MesDvTelemetryApi.Telemetry>,
  });

  watch(
    () => props.tbDeviceId,
    (value) => {
      if (value) {
        gridApi.query();
      }
    },
  );
</script>

<template>
  <Grid table-title="数采实时数据">
    <template #anomaly="{ row }">
      <Tag :color="row.whetherAnomaly ? 'red' : 'green'">
        {{ row.whetherAnomaly ? '异常' : '正常' }}
      </Tag>
    </template>
  </Grid>
</template>

 src/views/mes/dv/statistics/summary.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,109 @@
<script lang="ts" setup>
import type { MesDvStatisticsApi } from '#/api/mes/dv/statistics';

import { onMounted, ref } from 'vue';

import { Page } from '@vben/common-ui';

import { Card, Col, Row, Table, Tag } from 'ant-design-vue';

import { getDvStatisticsSummary } from '#/api/mes/dv/statistics';

defineOptions({ name: 'MesDvStatistics' });

const loading = ref(false);
const summary = ref<MesDvStatisticsApi.StatisticsSummary>({});

async function loadSummary() {
  loading.value = true;
  try {
    summary.value = await getDvStatisticsSummary();
  } finally {
    loading.value = false;
  }
}

onMounted(loadSummary);
</script>

<template>
  <Page>
    <Row :gutter="16" class="mb-4">
      <Col :span="4">
        <Card :loading="loading">
          <div class="text-sm text-gray-500">设备总数</div>
          <div class="mt-2 text-2xl font-bold">
            {{ summary.totalMachinery ?? 0 }}
          </div>
        </Card>
      </Col>
      <Col :span="5">
        <Card :loading="loading">
          <div class="text-sm text-gray-500">生产中 / åœæœº / ç»´æŠ¤ä¸­</div>
          <div class="mt-2 text-2xl font-bold">
            <span class="text-green-600">{{ summary.producingCount ?? 0 }}</span>
            <span class="mx-1 text-gray-400">/</span>
            <span class="text-red-600">{{ summary.stoppedCount ?? 0 }}</span>
            <span class="mx-1 text-gray-400">/</span>
            <span class="text-orange-600">{{ summary.maintainingCount ?? 0 }}</span>
          </div>
        </Card>
      </Col>
      <Col :span="5">
        <Card :loading="loading">
          <div class="text-sm text-gray-500">设备故障率</div>
          <div class="mt-2 text-2xl font-bold text-red-600">
            {{ (summary.faultRate ?? 0).toFixed(1) }}%
          </div>
        </Card>
      </Col>
      <Col :span="5">
        <Card :loading="loading">
          <div class="text-sm text-gray-500">维修单（总数 / å¾…处理）</div>
          <div class="mt-2 text-2xl font-bold">
            {{ summary.totalRepair ?? 0 }}
            <span class="text-sm text-gray-400">
              / {{ summary.processingRepair ?? 0 }}
            </span>
          </div>
        </Card>
      </Col>
      <Col :span="5">
        <Card :loading="loading">
          <div class="text-sm text-gray-500">保养记录（总数 / å·²å®Œæˆï¼‰</div>
          <div class="mt-2 text-2xl font-bold">
            {{ summary.totalMainten ?? 0 }}
            <span class="text-sm text-gray-400">
              / {{ summary.finishedMainten ?? 0 }}
            </span>
          </div>
        </Card>
      </Col>
    </Row>

    <Card title="按设备类型分布" :loading="loading">
      <Table
        row-key="machineryTypeId"
        :data-source="summary.typeDistribution ?? []"
        :pagination="false"
        size="middle"
      >
        <Table.Column title="设备类型" data-index="machineryTypeName">
          <template #default="{ record }">
            <Tag color="blue">{{ record.machineryTypeName || '未分类' }}</Tag>
          </template>
        </Table.Column>
        <Table.Column title="设备数量" data-index="count" align="right" />
        <Table.Column title="占比" align="right">
          <template #default="{ record }">
            {{
              summary.totalMachinery
                ? ((record.count / summary.totalMachinery) * 100).toFixed(1)
                : 0
            }}%
          </template>
        </Table.Column>
      </Table>
    </Card>
  </Page>
</template>

 src/views/mes/dv/telemetry/check.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,168 @@
<script lang="ts" setup>
  import type { VxeTableGridOptions } from '#/adapter/vxe-table';
  import type { MesDvTelemetryApi } from '#/api/mes/dv/telemetry';

  import { computed, onBeforeUnmount, onMounted, ref, useTemplateRef } from 'vue';

  import { Page } from '@vben/common-ui';
  import { useVbenVxeGrid } from '#/adapter/vxe-table';

  import { Button, Card, Select, Statistic, Tag } from 'ant-design-vue';

  import {
    getTelemetryCheckList,
    getTelemetryCheckSummary,
    getTelemetryDeviceList,
  } from '#/api/mes/dv/telemetry';

  /** MES ä¾›ç”µå‚数比对校验（各设备最新参数 vs æ ‡å‡†å€¼ï¼‰ */
  defineOptions({ name: 'MesDvTelemetryCheck' });

  const devices = ref<MesDvTelemetryApi.DeviceItem[]>([]);
  const selectedDeviceId = ref<string>();
  const summaryList = ref<MesDvTelemetryApi.CheckSummary[]>([]);

  const contentRef = useTemplateRef('contentRef');
  let resizeObserver: ResizeObserver | undefined;

  /** è®¡ç®—表格高度：内容区可用高度 - è®¾å¤‡é€‰æ‹©è¡Œ/统计卡片/工具栏等固定开销 */
  function calcTableHeight() {
    const el = contentRef.value;
    if (!el) return;
    const height = Math.max(el.clientHeight - 230, 240);
    checkGridApi.setGridOptions({ height });
  }

  onMounted(async () => {
    calcTableHeight();
    resizeObserver = new ResizeObserver(calcTableHeight);
    if (contentRef.value) resizeObserver.observe(contentRef.value);
    devices.value = await getTelemetryDeviceList();
    await loadSummary();
  });

  onBeforeUnmount(() => resizeObserver?.disconnect());

  async function loadSummary() {
    summaryList.value = await getTelemetryCheckSummary({
      tbDeviceId: selectedDeviceId.value,
    });
  }

  /** é€‰è®¾å¤‡æˆ–刷新：重载统计卡片 + æ˜Žç»†è¡¨ */
  async function refreshAll() {
    await loadSummary();
    checkGridApi.query();
  }

  /** é€‰ä¸­è®¾å¤‡çš„统计；未选择则汇总全部设备 */
  const currentSummary = computed(() => {
    if (selectedDeviceId.value) {
      return (
        summaryList.value.find((s) => s.tbDeviceId === selectedDeviceId.value) ??
        {}
      );
    }
    return summaryList.value.reduce(
      (acc, s) => {
        acc.totalCount = (acc.totalCount ?? 0) + (s.totalCount ?? 0);
        acc.normalCount = (acc.normalCount ?? 0) + (s.normalCount ?? 0);
        acc.anomalyCount = (acc.anomalyCount ?? 0) + (s.anomalyCount ?? 0);
        return acc;
      },
      { totalCount: 0, normalCount: 0, anomalyCount: 0 } as MesDvTelemetryApi.CheckSummary,
    );
  });

  const anomalyRate = computed(() => {
    const total = currentSummary.value.totalCount ?? 0;
    if (total <= 0) return 0;
    return Number(
      (((currentSummary.value.anomalyCount ?? 0) * 100) / total).toFixed(1),
    );
  });

  const [CheckGrid, checkGridApi] = useVbenVxeGrid({
    gridOptions: {
      columns: [
        { field: 'deviceName', title: '设备名称', minWidth: 150 },
        { field: 'paramName', title: '信号名称', minWidth: 140 },
        { field: 'paramKeyName', title: '设备KEY名称', minWidth: 130 },
        { field: 'standardValue', title: '标准值', width: 110 },
        { field: 'timelyValue', title: '实时值', width: 110 },
        { field: 'avgValue', title: '均值', width: 110 },
        { field: 'maxValue', title: '最大值', width: 110 },
        { field: 'minValue', title: '最小值', width: 110 },
        {
          field: 'whetherAnomaly',
          title: '是否异常',
          width: 100,
          slots: { default: 'anomaly' },
        },
      ],
      height: 400,
      keepSource: true,
      // /check è¿”回裸数组，需关闭分页
      pagerConfig: { enabled: false },
      proxyConfig: {
        ajax: {
          query: async () =>
            await getTelemetryCheckList({
              tbDeviceId: selectedDeviceId.value,
            }),
        },
      },
      rowConfig: { keyField: 'id', isHover: true },
      toolbarConfig: { refresh: true },
    } as VxeTableGridOptions<MesDvTelemetryApi.Telemetry>,
  });
</script>

<template>
  <Page auto-content-height>
    <div ref="contentRef" class="flex h-full w-full flex-col p-4">
      <div class="mb-4 flex flex-wrap items-center gap-4">
        <Select
          v-model:value="selectedDeviceId"
          class="w-72"
          allow-clear
          placeholder="请选择设备（不选则展示全部设备）"
          :options="
            devices.map((d) => ({ label: d.deviceName, value: d.tbDeviceId }))
          "
          @change="refreshAll"
        />
        <Button @click="refreshAll">刷新</Button>
      </div>
      <div class="mb-4 grid grid-cols-2 gap-4 lg:grid-cols-4">
        <Card>
          <Statistic title="参数总数" :value="currentSummary.totalCount ?? 0" />
        </Card>
        <Card>
          <Statistic
            title="正常"
            :value="currentSummary.normalCount ?? 0"
            :value-style="{ color: '#52c41a' }"
          />
        </Card>
        <Card>
          <Statistic
            title="异常"
            :value="currentSummary.anomalyCount ?? 0"
            :value-style="{ color: '#ff4d4f' }"
          />
        </Card>
        <Card>
          <Statistic title="异常率" :value="anomalyRate" suffix="%" />
        </Card>
      </div>
      <CheckGrid table-title="供电参数比对明细" class="min-h-0 flex-1">
        <template #anomaly="{ row }">
          <Tag :color="row.whetherAnomaly ? 'red' : 'green'">
            {{ row.whetherAnomaly ? '异常' : '正常' }}
          </Tag>
        </template>
      </CheckGrid>
    </div>
  </Page>
</template>

 src/views/mes/dv/telemetry/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,98 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { MesDvTelemetryApi } from '#/api/mes/dv/telemetry';

/** æ˜¯å¦å¼‚常选项（布尔值，后端直接接收） */
export const ANOMALY_OPTIONS = [
  { label: '正常', value: false },
  { label: '异常', value: true },
];

/** åŽ†å²è®°å½•æœç´¢è¡¨å• */
export function useHistoryGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'deviceName',
      label: '设备名称',
      component: 'Input',
      componentProps: { allowClear: true, placeholder: '请输入设备名称' },
    },
    {
      fieldName: 'paramName',
      label: '信号名称',
      component: 'Input',
      componentProps: { allowClear: true, placeholder: '请输入信号名称' },
    },
    {
      fieldName: 'whetherAnomaly',
      label: '是否异常',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: ANOMALY_OPTIONS,
        placeholder: '请选择是否异常',
      },
    },
    {
      fieldName: 'telemetryDataTime',
      label: '遥测时间',
      component: 'RangePicker',
      componentProps: { class: '!w-full', valueFormat: 'YYYY-MM-DD HH:mm:ss' },
    },
  ];
}

/** å®žæ—¶æ•°æ®å­—段 */
export function useLatestColumns(): VxeTableGridOptions<MesDvTelemetryApi.Telemetry>['columns'] {
  return [
    { field: 'deviceName', title: '设备名称', minWidth: 140 },
    { field: 'paramName', title: '信号名称', minWidth: 140 },
    { field: 'timelyValue', title: '信号值(实时)', width: 120 },
    {
      field: 'whetherAnomaly',
      title: '是否异常',
      width: 100,
      slots: { default: 'anomaly' },
    },
    { field: 'shiftName', title: '班次', width: 100 },
    {
      field: 'telemetryDataTime',
      title: '遥测时间',
      width: 180,
      formatter: 'formatDateTime',
    },
    { field: 'standardValue', title: '标准值', width: 110 },
    { field: 'avgValue', title: '均值', width: 110 },
    { field: 'maxValue', title: '最大值', width: 110 },
    { field: 'minValue', title: '最小值', width: 110 },
  ];
}

/** åŽ†å²è®°å½•å­—段 */
export function useHistoryColumns(): VxeTableGridOptions<MesDvTelemetryApi.Telemetry>['columns'] {
  return [
    { field: 'deviceName', title: '设备名称', minWidth: 140 },
    { field: 'paramName', title: '信号名称', minWidth: 140 },
    { field: 'timelyValue', title: '信号值', width: 110 },
    {
      field: 'whetherAnomaly',
      title: '是否异常',
      width: 100,
      slots: { default: 'anomaly' },
    },
    { field: 'shiftName', title: '班次', width: 100 },
    { field: 'billNo', title: '单据号', minWidth: 120 },
    {
      field: 'telemetryDataTime',
      title: '遥测时间',
      width: 180,
      formatter: 'formatDateTime',
    },
    {
      field: 'pullTime',
      title: '拉取时间',
      width: 180,
      formatter: 'formatDateTime',
    },
  ];
}

 src/views/mes/dv/telemetry/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,168 @@
<script lang="ts" setup>
  import type { VxeTableGridOptions } from '#/adapter/vxe-table';
  import type { MesDvTelemetryApi } from '#/api/mes/dv/telemetry';

  import { onBeforeUnmount, onMounted, ref, useTemplateRef } from 'vue';

  import { Page } from '@vben/common-ui';
  import { useVbenVxeGrid } from '#/adapter/vxe-table';

  import { Button, message, Switch, Tabs, Tag } from 'ant-design-vue';
  import dayjs from 'dayjs';

  import {
    getLatestTelemetry,
    getTelemetryPage,
    pullTelemetry,
  } from '#/api/mes/dv/telemetry';

  import { useHistoryColumns, useHistoryGridFormSchema, useLatestColumns } from './data';

  const activeTab = ref<'latest' | 'history'>('latest');
  const autoRefresh = ref(false);
  const pulling = ref(false);
  const lastUpdateTime = ref<Date>();
  let refreshTimer: ReturnType<typeof setInterval> | undefined;

  const contentRef = useTemplateRef('contentRef');
  let resizeObserver: ResizeObserver | undefined;

  /** è®¡ç®—表格高度：内容区可用高度 - å·¥å…·æ è¡Œ/Tabs导航等固定开销，保证表格撑满页面（对齐设备台账页） */
  function calcTableHeight() {
    const el = contentRef.value;
    if (!el) return;
    const height = Math.max(el.clientHeight - 115, 240);
    latestGridApi.setGridOptions({ height });
    historyGridApi.setGridOptions({ height });
  }

  onMounted(() => {
    calcTableHeight();
    resizeObserver = new ResizeObserver(calcTableHeight);
    if (contentRef.value) resizeObserver.observe(contentRef.value);
  });

  const [LatestGrid, latestGridApi] = useVbenVxeGrid({
    gridOptions: {
      columns: useLatestColumns(),
      height: 400,
      keepSource: true,
      // /latest è¿”回裸数组，需关闭分页，否则 vxe ä¼šæŒ‰ {list,total} è§£æžå¯¼è‡´ä¸å±•ç¤º
      pagerConfig: { enabled: false },
      proxyConfig: {
        ajax: {
          query: async () => await getLatestTelemetry(),
        },
      },
      rowConfig: { keyField: 'id', isHover: true },
      toolbarConfig: { refresh: true },
    } as VxeTableGridOptions<MesDvTelemetryApi.Telemetry>,
  });

  const [HistoryGrid, historyGridApi] = useVbenVxeGrid({
    formOptions: { schema: useHistoryGridFormSchema() },
    gridOptions: {
      columns: useHistoryColumns(),
      height: 400,
      keepSource: true,
      proxyConfig: {
        ajax: {
          query: async ({ page }, formValues) =>
            await getTelemetryPage({
              pageNo: page.currentPage,
              pageSize: page.pageSize,
              ...formValues,
            }),
        },
      },
      rowConfig: { keyField: 'id', isHover: true },
      toolbarConfig: { refresh: true, search: true },
    } as VxeTableGridOptions<MesDvTelemetryApi.Telemetry>,
  });

  /** æ‹‰å–最新数采数据并刷新当前 Tab */
  async function handlePull() {
    pulling.value = true;
    try {
      const result = await pullTelemetry();
      lastUpdateTime.value = result.pullTime;
      message.success(
        `拉取成功，新增 ${result.recordCount} æ¡ï¼Œæ¶‰åŠè®¾å¤‡ ${result.deviceCount} å°`,
      );
      refreshActive();
    } finally {
      pulling.value = false;
    }
  }

  /** åˆ·æ–°å½“前 Tab æ•°æ® */
  function refreshActive() {
    if (activeTab.value === 'latest') {
      latestGridApi.query();
    } else {
      historyGridApi.query();
    }
  }

  /** åˆ‡æ¢å®žæ—¶è‡ªåŠ¨åˆ·æ–°ï¼ˆæ¯ 30 ç§’） */
  function toggleAutoRefresh(checked: boolean | string | number) {
    if (checked) {
      refreshTimer = setInterval(() => {
        if (activeTab.value === 'latest') {
          latestGridApi.query();
        }
      }, 30_000);
    } else if (refreshTimer) {
      clearInterval(refreshTimer);
      refreshTimer = undefined;
    }
  }

  onBeforeUnmount(() => {
    resizeObserver?.disconnect();
    if (refreshTimer) {
      clearInterval(refreshTimer);
    }
  });
</script>

<template>
  <Page auto-content-height>
    <div ref="contentRef" class="flex h-full w-full flex-col">
      <div class="mb-4 flex items-center gap-4">
        <Button type="primary" :loading="pulling" @click="handlePull">
          æ‹‰å–最新数据
        </Button>
        <Switch
          v-model:checked="autoRefresh"
          checked-children="实时自动刷新"
          un-checked-children="实时自动刷新"
          @change="toggleAutoRefresh"
        />
        <span v-if="lastUpdateTime" class="text-sm text-gray-500">
          æœ€è¿‘拉取：{{ dayjs(lastUpdateTime).format('YYYY-MM-DD HH:mm:ss') }}
        </span>
      </div>
      <Tabs v-model:active-key="activeTab" class="min-h-0 flex-1">
        <Tabs.TabPane key="latest" tab="实时数据">
          <LatestGrid table-title="实时数据">
            <template #anomaly="{ row }">
              <Tag :color="row.whetherAnomaly ? 'red' : 'green'">
                {{ row.whetherAnomaly ? '异常' : '正常' }}
              </Tag>
            </template>
          </LatestGrid>
        </Tabs.TabPane>
        <Tabs.TabPane key="history" tab="历史记录">
          <HistoryGrid table-title="历史记录">
            <template #anomaly="{ row }">
              <Tag :color="row.whetherAnomaly ? 'red' : 'green'">
                {{ row.whetherAnomaly ? '异常' : '正常' }}
              </Tag>
            </template>
          </HistoryGrid>
        </Tabs.TabPane>
      </Tabs>
    </div>
  </Page>
</template>

 src/views/mes/md/item/data.ts

@@ -178,6 +178,15 @@
      rules: z.number().default(0),
    },
    {
      fieldName: 'materialCategory',
      label: '物资分类',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.MES_MATERIAL_CATEGORY, 'number'),
        placeholder: '请选择物资分类',
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
@@ -298,6 +307,16 @@
      },
    },
    {
      field: 'materialCategory',
      title: '物资分类',
      width: 120,
      align: 'center',
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_MATERIAL_CATEGORY },
      },
    },
    {
      field: 'safeStockFlag',
      title: '安全库存',
      width: 120,

 src/views/mes/pd/basedata/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,808 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { MesPdBaseDataApi } from '#/api/mes/pd/basedata';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import {
  createDiscountPolicy,
  createElectricityType,
  createPriceStandard,
  createServicePackage,
  createTieredPrice,
  createVoltageLevel,
  deleteDiscountPolicy,
  deleteElectricityType,
  deletePriceStandard,
  deleteServicePackage,
  deleteTieredPrice,
  deleteVoltageLevel,
  exportDiscountPolicy,
  exportElectricityType,
  exportPriceStandard,
  exportServicePackage,
  exportTieredPrice,
  exportVoltageLevel,
  getDiscountPolicy,
  getDiscountPolicyPage,
  getElectricityType,
  getElectricityTypeList,
  getElectricityTypePage,
  getPriceStandard,
  getPriceStandardPage,
  getServicePackage,
  getServicePackageList,
  getServicePackagePage,
  getTieredPrice,
  getTieredPricePage,
  getVoltageLevel,
  getVoltageLevelList,
  getVoltageLevelPage,
  updateDiscountPolicy,
  updateElectricityType,
  updatePriceStandard,
  updateServicePackage,
  updateTieredPrice,
  updateVoltageLevel,
} from '#/api/mes/pd/basedata';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'update';

/** å®žä½“ API æ˜ å°„（泛型 CRUD） */
export interface EntityApi {
  page: (params: any) => Promise<any>;
  get: (id: number) => Promise<any>;
  create: (data: any) => Promise<any>;
  update: (data: any) => Promise<any>;
  remove: (id: number) => Promise<any>;
  exportExcel: (params: any) => Promise<any>;
}

/** åŸºç¡€æ•°æ® Tab é…ç½® */
export interface BaseDataEntity {
  key: string;
  title: string;
  api: EntityApi;
  columns: VxeTableGridOptions<any>['columns'];
  gridFormSchema: VbenFormSchema[];
  formSchema: VbenFormSchema[];
}

/** åŠ è½½å®šä»·å¯¹è±¡ä¸‹æ‹‰ï¼ˆ1服务套餐/2电压等级/3用电类型） */
export async function loadObjectOptions(
  type?: number | null,
): Promise<{ label: string; value: number }[]> {
  if (type === 1) {
    const list = await getServicePackageList();
    return list.map((i) => ({ label: i.name ?? '', value: i.id ?? 0 }));
  }
  if (type === 2) {
    const list = await getVoltageLevelList();
    return list.map((i) => ({ label: i.name ?? '', value: i.id ?? 0 }));
  }
  if (type === 3) {
    const list = await getElectricityTypeList();
    return list.map((i) => ({ label: i.name ?? '', value: i.id ?? 0 }));
  }
  return [];
}

/** å¯¹è±¡ç±»åž‹ä¸‹æ‹‰ï¼ˆ1服务套餐/2电压等级/3用电类型） */
function useObjectTypeOptions() {
  return getDictOptions(DICT_TYPE.MES_PD_PRICE_OBJECT_TYPE, 'number');
}

/** é€šç”¨å¯ç”¨çŠ¶æ€åˆ— */
function useStatusColumn(title = '启用状态') {
  return {
    field: 'status',
    title,
    width: 90,
    cellRender: {
      name: 'CellDict',
      props: { type: DICT_TYPE.MES_PD_PRODUCT_STATUS },
    },
  } as const;
}

/** ç”¨ç”µç±»åž‹ */
export const ElectricityTypeConfig: BaseDataEntity = {
  key: 'electricityType',
  title: '用电类型',
  api: {
    page: getElectricityTypePage,
    get: getElectricityType,
    create: createElectricityType,
    update: updateElectricityType,
    remove: deleteElectricityType,
    exportExcel: exportElectricityType,
  },
  columns: [
    { field: 'code', title: '类型编码', width: 140 },
    { field: 'name', title: '类型名称', minWidth: 160 },
    { field: 'description', title: '类型说明', minWidth: 200 },
    { field: 'sort', title: '排序', width: 80 },
    useStatusColumn(),
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    { title: '操作', width: 200, fixed: 'right', slots: { default: 'actions' } },
  ],
  gridFormSchema: [
    {
      fieldName: 'name',
      label: '类型名称',
      component: 'Input',
      componentProps: { placeholder: '请输入类型名称' },
    },
  ],
  formSchema: [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: { triggerFields: [''], show: () => false },
    },
    {
      fieldName: 'code',
      label: '类型编码',
      component: 'Input',
      componentProps: { placeholder: '请输入类型编码' },
      rules: 'required',
    },
    {
      fieldName: 'name',
      label: '类型名称',
      component: 'Input',
      componentProps: { placeholder: '请输入类型名称' },
      rules: 'required',
    },
    {
      fieldName: 'description',
      label: '类型说明',
      component: 'Textarea',
      formItemClass: 'col-span-3',
      componentProps: { placeholder: '请输入类型说明', rows: 2 },
    },
    {
      fieldName: 'sort',
      label: '排序',
      component: 'InputNumber',
      componentProps: { class: '!w-full', min: 0, precision: 0 },
    },
    {
      fieldName: 'status',
      label: '启用状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_PRODUCT_STATUS, 'number'),
        placeholder: '请选择启用状态',
      },
    },
  ],
};

/** ç”µåŽ‹ç­‰çº§ */
export const VoltageLevelConfig: BaseDataEntity = {
  key: 'voltageLevel',
  title: '电压等级',
  api: {
    page: getVoltageLevelPage,
    get: getVoltageLevel,
    create: createVoltageLevel,
    update: updateVoltageLevel,
    remove: deleteVoltageLevel,
    exportExcel: exportVoltageLevel,
  },
  columns: [
    { field: 'code', title: '等级编码', width: 140 },
    { field: 'name', title: '等级名称', minWidth: 160 },
    { field: 'voltageValue', title: '电压数值(kV)', width: 120 },
    { field: 'sort', title: '排序', width: 80 },
    useStatusColumn(),
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    { title: '操作', width: 200, fixed: 'right', slots: { default: 'actions' } },
  ],
  gridFormSchema: [
    {
      fieldName: 'name',
      label: '等级名称',
      component: 'Input',
      componentProps: { placeholder: '请输入等级名称' },
    },
  ],
  formSchema: [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: { triggerFields: [''], show: () => false },
    },
    {
      fieldName: 'code',
      label: '等级编码',
      component: 'Input',
      componentProps: { placeholder: '请输入等级编码' },
      rules: 'required',
    },
    {
      fieldName: 'name',
      label: '等级名称',
      component: 'Input',
      componentProps: { placeholder: '请输入等级名称' },
      rules: 'required',
    },
    {
      fieldName: 'voltageValue',
      label: '电压数值(kV)',
      component: 'InputNumber',
      componentProps: { class: '!w-full', min: 0, precision: 2 },
    },
    {
      fieldName: 'sort',
      label: '排序',
      component: 'InputNumber',
      componentProps: { class: '!w-full', min: 0, precision: 0 },
    },
    {
      fieldName: 'status',
      label: '启用状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_PRODUCT_STATUS, 'number'),
        placeholder: '请选择启用状态',
      },
    },
  ],
};

/** æœåŠ¡å¥—餐 */
export const ServicePackageConfig: BaseDataEntity = {
  key: 'servicePackage',
  title: '服务套餐',
  api: {
    page: getServicePackagePage,
    get: getServicePackage,
    create: createServicePackage,
    update: updateServicePackage,
    remove: deleteServicePackage,
    exportExcel: exportServicePackage,
  },
  columns: [
    { field: 'code', title: '套餐编码', width: 150 },
    { field: 'name', title: '套餐名称', minWidth: 160 },
    {
      field: 'price',
      title: '套餐价格',
      width: 110,
      formatter: 'formatNumber',
    },
    {
      field: 'effectiveDate',
      title: '生效日期',
      width: 160,
      formatter: 'formatDateTime',
    },
    {
      field: 'expireDate',
      title: '失效日期',
      width: 160,
      formatter: 'formatDateTime',
    },
    useStatusColumn(),
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    { title: '操作', width: 200, fixed: 'right', slots: { default: 'actions' } },
  ],
  gridFormSchema: [
    {
      fieldName: 'name',
      label: '套餐名称',
      component: 'Input',
      componentProps: { placeholder: '请输入套餐名称' },
    },
  ],
  formSchema: [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: { triggerFields: [''], show: () => false },
    },
    {
      fieldName: 'code',
      label: '套餐编码',
      component: 'Input',
      componentProps: { placeholder: '保存时自动生成', disabled: true },
    },
    {
      fieldName: 'name',
      label: '套餐名称',
      component: 'Input',
      componentProps: { placeholder: '请输入套餐名称' },
      rules: 'required',
    },
    {
      fieldName: 'description',
      label: '套餐说明',
      component: 'Textarea',
      formItemClass: 'col-span-3',
      componentProps: { placeholder: '请输入套餐说明', rows: 2 },
    },
    {
      fieldName: 'price',
      label: '套餐价格',
      component: 'InputNumber',
      componentProps: { class: '!w-full', min: 0, precision: 2 },
    },
    {
      fieldName: 'effectiveDate',
      label: '生效日期',
      component: 'DatePicker',
      componentProps: { class: '!w-full', valueFormat: 'YYYY-MM-DD HH:mm:ss' },
    },
    {
      fieldName: 'expireDate',
      label: '失效日期',
      component: 'DatePicker',
      componentProps: { class: '!w-full', valueFormat: 'YYYY-MM-DD HH:mm:ss' },
    },
    {
      fieldName: 'status',
      label: '启用状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_PRODUCT_STATUS, 'number'),
        placeholder: '请选择启用状态',
      },
    },
  ],
};

/** å®šä»·æ ‡å‡† */
export const PriceStandardConfig: BaseDataEntity = {
  key: 'priceStandard',
  title: '定价标准',
  api: {
    page: getPriceStandardPage,
    get: getPriceStandard,
    create: createPriceStandard,
    update: updatePriceStandard,
    remove: deletePriceStandard,
    exportExcel: exportPriceStandard,
  },
  columns: [
    {
      field: 'objectType',
      title: '定价对象类型',
      width: 120,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_PD_PRICE_OBJECT_TYPE },
      },
    },
    { field: 'objectName', title: '定价对象', minWidth: 180 },
    {
      field: 'price',
      title: 'ä»·æ ¼',
      width: 110,
      formatter: 'formatNumber',
    },
    { field: 'unit', title: '计价单位', width: 100 },
    {
      field: 'effectiveDate',
      title: '生效日期',
      width: 160,
      formatter: 'formatDateTime',
    },
    useStatusColumn(),
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    { title: '操作', width: 200, fixed: 'right', slots: { default: 'actions' } },
  ],
  gridFormSchema: [
    {
      fieldName: 'objectType',
      label: '定价对象类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: useObjectTypeOptions(),
        placeholder: '请选择定价对象类型',
      },
    },
  ],
  formSchema: [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: { triggerFields: [''], show: () => false },
    },
    {
      fieldName: 'objectType',
      label: '定价对象类型',
      component: 'Select',
      rules: 'selectRequired',
      componentProps: {
        allowClear: true,
        options: useObjectTypeOptions(),
        placeholder: '请选择定价对象类型',
      },
    },
    {
      fieldName: 'objectId',
      label: '定价对象',
      component: 'Select',
      rules: 'selectRequired',
      dependencies: {
        triggerFields: ['objectType'],
        async componentProps(values, form) {
          const options = await loadObjectOptions(values.objectType);
          return {
            allowClear: true,
            placeholder: '请选择定价对象',
            options,
            onChange: (value: number) => {
              const opt = options.find((o) => o.value === value);
              form.setFieldValue('objectName', opt?.label ?? '');
            },
          };
        },
      },
    },
    {
      fieldName: 'objectName',
      component: 'Input',
      dependencies: { triggerFields: [''], show: () => false },
    },
    {
      fieldName: 'price',
      label: 'ä»·æ ¼',
      component: 'InputNumber',
      componentProps: { class: '!w-full', min: 0, precision: 2 },
      rules: 'required',
    },
    {
      fieldName: 'unit',
      label: '计价单位',
      component: 'Input',
      componentProps: { placeholder: '请输入计价单位' },
    },
    {
      fieldName: 'effectiveDate',
      label: '生效日期',
      component: 'DatePicker',
      componentProps: { class: '!w-full', valueFormat: 'YYYY-MM-DD HH:mm:ss' },
    },
    {
      fieldName: 'status',
      label: '启用状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_PRODUCT_STATUS, 'number'),
        placeholder: '请选择启用状态',
      },
    },
  ],
};

/** ä¼˜æƒ ç­–ç•¥ */
export const DiscountPolicyConfig: BaseDataEntity = {
  key: 'discountPolicy',
  title: '优惠策略',
  api: {
    page: getDiscountPolicyPage,
    get: getDiscountPolicy,
    create: createDiscountPolicy,
    update: updateDiscountPolicy,
    remove: deleteDiscountPolicy,
    exportExcel: exportDiscountPolicy,
  },
  columns: [
    { field: 'name', title: '策略名称', minWidth: 160 },
    {
      field: 'policyType',
      title: '策略类型',
      width: 100,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_PD_DISCOUNT_POLICY_TYPE },
      },
    },
    {
      field: 'policyValue',
      title: '策略值',
      width: 110,
      formatter: 'formatNumber',
    },
    {
      field: 'targetType',
      title: '适用对象类型',
      width: 120,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_PD_PRICE_OBJECT_TYPE },
      },
    },
    {
      field: 'startDate',
      title: '生效日期',
      width: 160,
      formatter: 'formatDateTime',
    },
    {
      field: 'endDate',
      title: '失效日期',
      width: 160,
      formatter: 'formatDateTime',
    },
    useStatusColumn(),
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    { title: '操作', width: 200, fixed: 'right', slots: { default: 'actions' } },
  ],
  gridFormSchema: [
    {
      fieldName: 'name',
      label: '策略名称',
      component: 'Input',
      componentProps: { placeholder: '请输入策略名称' },
    },
    {
      fieldName: 'policyType',
      label: '策略类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_DISCOUNT_POLICY_TYPE, 'number'),
        placeholder: '请选择策略类型',
      },
    },
  ],
  formSchema: [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: { triggerFields: [''], show: () => false },
    },
    {
      fieldName: 'name',
      label: '策略名称',
      component: 'Input',
      componentProps: { placeholder: '请输入策略名称' },
      rules: 'required',
    },
    {
      fieldName: 'policyType',
      label: '策略类型',
      component: 'Select',
      rules: 'selectRequired',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_DISCOUNT_POLICY_TYPE, 'number'),
        placeholder: '请选择策略类型',
      },
    },
    {
      fieldName: 'policyValue',
      label: '策略值',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '折扣填0-1比例，立减填金额',
      },
      help: '折扣：0-1 ä¹‹é—´çš„比例；立减：按金额减免',
      rules: 'required',
    },
    {
      fieldName: 'targetType',
      label: '适用对象类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: useObjectTypeOptions(),
        placeholder: '不选则全局适用',
      },
    },
    {
      fieldName: 'targetId',
      label: '适用对象',
      component: 'Select',
      dependencies: {
        triggerFields: ['targetType'],
        disabled: (values) => !values.targetType,
        async componentProps(values) {
          const options = await loadObjectOptions(values.targetType);
          return {
            allowClear: true,
            placeholder: values.targetType ? '请选择适用对象' : '全局适用',
            options,
          };
        },
      },
    },
    {
      fieldName: 'startDate',
      label: '生效日期',
      component: 'DatePicker',
      componentProps: { class: '!w-full', valueFormat: 'YYYY-MM-DD HH:mm:ss' },
    },
    {
      fieldName: 'endDate',
      label: '失效日期',
      component: 'DatePicker',
      componentProps: { class: '!w-full', valueFormat: 'YYYY-MM-DD HH:mm:ss' },
    },
    {
      fieldName: 'status',
      label: '启用状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_PRODUCT_STATUS, 'number'),
        placeholder: '请选择启用状态',
      },
    },
  ],
};

/** é˜¶æ¢¯ç”µä»· */
export const TieredPriceConfig: BaseDataEntity = {
  key: 'tieredPrice',
  title: '阶梯电价',
  api: {
    page: getTieredPricePage,
    get: getTieredPrice,
    create: createTieredPrice,
    update: updateTieredPrice,
    remove: deleteTieredPrice,
    exportExcel: exportTieredPrice,
  },
  columns: [
    { field: 'packageId', title: '服务套餐ID', width: 110 },
    { field: 'voltageLevelId', title: '电压等级ID', width: 110 },
    { field: 'startValue', title: '下限(含,kWh)', width: 120 },
    { field: 'endValue', title: '上限(不含,kWh)', width: 130 },
    {
      field: 'pricePerUnit',
      title: '档位单价',
      width: 110,
      formatter: 'formatNumber',
    },
    useStatusColumn(),
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    { title: '操作', width: 200, fixed: 'right', slots: { default: 'actions' } },
  ],
  gridFormSchema: [
    {
      fieldName: 'packageId',
      label: '服务套餐ID',
      component: 'Input',
      componentProps: { placeholder: '请输入服务套餐ID' },
    },
  ],
  formSchema: [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: { triggerFields: [''], show: () => false },
    },
    {
      fieldName: 'packageId',
      label: '服务套餐',
      component: 'Select',
      componentProps: {
        allowClear: true,
        placeholder: '选择服务套餐（与电压等级二选一）',
      },
      dependencies: {
        triggerFields: ['voltageLevelId'],
        disabled: (values) => !!values.voltageLevelId,
        async componentProps(values) {
          const list = await getServicePackageList();
          return {
            allowClear: true,
            options: list.map((i) => ({ label: i.name, value: i.id })),
            placeholder: '选择服务套餐（与电压等级二选一）',
          };
        },
      },
    },
    {
      fieldName: 'voltageLevelId',
      label: '电压等级',
      component: 'Select',
      componentProps: {
        allowClear: true,
        placeholder: '选择电压等级（与服务套餐二选一）',
      },
      dependencies: {
        triggerFields: ['packageId'],
        disabled: (values) => !!values.packageId,
        async componentProps() {
          const list = await getVoltageLevelList();
          return {
            allowClear: true,
            options: list.map((i) => ({ label: i.name, value: i.id })),
            placeholder: '选择电压等级（与服务套餐二选一）',
          };
        },
      },
    },
    {
      fieldName: 'startValue',
      label: '档位下限(含,kWh)',
      component: 'InputNumber',
      componentProps: { class: '!w-full', min: 0, precision: 2 },
      rules: 'required',
    },
    {
      fieldName: 'endValue',
      label: '档位上限(不含,kWh)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '为空表示上不封顶',
      },
    },
    {
      fieldName: 'pricePerUnit',
      label: '档位单价',
      component: 'InputNumber',
      componentProps: { class: '!w-full', min: 0, precision: 4 },
      rules: 'required',
    },
    {
      fieldName: 'status',
      label: '启用状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_TIERED_PRICE_STATUS, 'number'),
        placeholder: '请选择启用状态',
      },
    },
  ],
};

/** å…¨éƒ¨ Tab é…ç½® */
export const BaseDataConfigs: BaseDataEntity[] = [
  ElectricityTypeConfig,
  VoltageLevelConfig,
  ServicePackageConfig,
  PriceStandardConfig,
  DiscountPolicyConfig,
  TieredPriceConfig,
];

 src/views/mes/pd/basedata/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,28 @@
<script lang="ts" setup>
  import { ref } from 'vue';

  import { Page } from '@vben/common-ui';

  import { Tabs } from 'ant-design-vue';

  import { BaseDataConfigs } from './data';
  import BaseTable from './modules/base-table.vue';

  const activeKey = ref('electricityType');
</script>

<template>
  <Page auto-content-height>
    <div class="p-4">
      <Tabs v-model:activeKey="activeKey">
        <Tabs.TabPane
          v-for="cfg in BaseDataConfigs"
          :key="cfg.key"
          :tab="cfg.title"
        >
          <BaseTable :key="cfg.key" :config="cfg" />
        </Tabs.TabPane>
      </Tabs>
    </div>
  </Page>
</template>

 src/views/mes/pd/basedata/modules/base-table.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,175 @@
<script lang="ts" setup>
  import type { VxeTableGridOptions } from '#/adapter/vxe-table';
  import type { BaseDataEntity } from '../data';

  import { useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';
  import { downloadFileFromBlobPart } from '@vben/utils';

  import { message } from 'ant-design-vue';

  import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';

  import Form from './form.vue';
  import PriceCalc from './price-calc.vue';

  const props = defineProps<{ config: BaseDataEntity }>();

  const [FormModal, formModalApi] = useVbenModal({
    connectedComponent: Form,
    destroyOnClose: true,
  });
  const [PriceCalcModal, priceCalcModalApi] = useVbenModal({
    connectedComponent: PriceCalc,
    destroyOnClose: true,
  });

  /** åˆ·æ–°è¡¨æ ¼ */
  function handleRefresh() {
    gridApi.query();
  }

  /** æ–°å¢ž */
  function handleCreate() {
    formModalApi.setData({ config: props.config, formType: 'create' }).open();
  }

  /** æŸ¥çœ‹ */
  function handleDetail(row: any) {
    formModalApi
      .setData({ config: props.config, formType: 'detail', id: row.id })
      .open();
  }

  /** ç¼–辑 */
  function handleEdit(row: any) {
    formModalApi
      .setData({ config: props.config, formType: 'update', id: row.id })
      .open();
  }

  /** åˆ é™¤ */
  async function handleDelete(row: any) {
    const hideLoading = message.loading({
      content: $t('ui.actionMessage.deleting', [row.name ?? row.code ?? '']),
      duration: 0,
    });
    try {
      await props.config.api.remove(row.id);
      message.success($t('ui.actionMessage.deleteSuccess', [row.name ?? row.code ?? '']));
      handleRefresh();
    } finally {
      hideLoading();
    }
  }

  /** å¯¼å‡º */
  async function handleExport() {
    const data = await props.config.api.exportExcel(
      await gridApi.formApi.getValues(),
    );
    downloadFileFromBlobPart({ fileName: `${props.config.title}.xls`, source: data });
  }

  /** é˜¶æ¢¯ç”µä»·æµ‹ç®— */
  function handleCalc() {
    priceCalcModalApi.open();
  }

  const [Grid, gridApi] = useVbenVxeGrid({
    formOptions: {
      schema: props.config.gridFormSchema,
    },
    gridOptions: {
      columns: props.config.columns,
      height: 'auto',
      keepSource: true,
      proxyConfig: {
        ajax: {
          query: async ({ page }, formValues) =>
            await props.config.api.page({
              pageNo: page.currentPage,
              pageSize: page.pageSize,
              ...formValues,
            }),
        },
      },
      rowConfig: {
        keyField: 'id',
        isHover: true,
      },
      toolbarConfig: {
        refresh: true,
        search: true,
      },
    } as VxeTableGridOptions<any>,
  });
</script>

<template>
  <FormModal @success="handleRefresh" />
  <PriceCalcModal v-if="config.key === 'tieredPrice'" />
  <Grid :table-title="`${config.title}列表`">
    <template #toolbar-tools>
      <TableAction
        :actions="[
          {
            label: $t('ui.actionTitle.create', [config.title]),
            type: 'primary',
            icon: ACTION_ICON.ADD,
            auth: ['mes:pd-basedata:create'],
            onClick: handleCreate,
          },
          {
            label: '阶梯电价测算',
            type: 'primary',
            icon: ACTION_ICON.CALC,
            auth: ['mes:pd-basedata:query'],
            ifShow: config.key === 'tieredPrice',
            onClick: handleCalc,
          },
          {
            label: $t('ui.actionTitle.export'),
            type: 'primary',
            icon: ACTION_ICON.DOWNLOAD,
            auth: ['mes:pd-basedata:export'],
            onClick: handleExport,
          },
        ]"
      />
    </template>
    <template #actions="{ row }">
      <TableAction
        :actions="[
          {
            label: $t('common.edit'),
            type: 'link',
            icon: ACTION_ICON.EDIT,
            auth: ['mes:pd-basedata:update'],
            onClick: handleEdit.bind(null, row),
          },
          {
            label: $t('common.delete'),
            type: 'link',
            danger: true,
            icon: ACTION_ICON.DELETE,
            auth: ['mes:pd-basedata:delete'],
            popConfirm: {
              title: $t('ui.actionMessage.deleteConfirm', [
                row.name ?? row.code ?? '',
              ]),
              confirm: handleDelete.bind(null, row),
            },
          },
          {
            label: $t('common.detail'),
            type: 'link',
            icon: ACTION_ICON.VIEW,
            auth: ['mes:pd-basedata:query'],
            onClick: handleDetail.bind(null, row),
          },
        ]"
      />
    </template>
  </Grid>
</template>

 src/views/mes/pd/basedata/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,102 @@
<script lang="ts" setup>
  import type { BaseDataEntity, FormType } from '../data';

  import { computed, ref } from 'vue';

  import { useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';

  import { message } from 'ant-design-vue';

  import { useVbenForm } from '#/adapter/form';

  const emit = defineEmits(['success']);
  const config = ref<BaseDataEntity>();
  const formType = ref<FormType>('create'); // è¡¨å•æ¨¡å¼
  const formData = ref<any>();
  const isDetail = computed(() => formType.value === 'detail'); // æ˜¯å¦æŸ¥çœ‹æ¨¡å¼
  const getTitle = computed(() => {
    const title = config.value?.title ?? '';
    if (formType.value === 'detail') {
      return `查看${title}`;
    }
    return formType.value === 'update' ? `修改${title}` : `新增${title}`;
  });

  const [Form, formApi] = useVbenForm({
    commonConfig: {
      componentProps: {
        class: 'w-full',
      },
      formItemClass: 'col-span-1',
      labelWidth: 130,
    },
    wrapperClass: 'grid-cols-3',
    layout: 'horizontal',
    schema: [],
    showDefaultActions: false,
  });

  const [Modal, modalApi] = useVbenModal({
    async onConfirm() {
      if (isDetail.value) {
        await modalApi.close();
        return;
      }
      const { valid } = await formApi.validate();
      if (!valid) {
        return;
      }
      modalApi.lock();
      // æäº¤è¡¨å•
      const data = await formApi.getValues();
      try {
        if (data.id) {
          await config.value!.api.update(data);
        } else {
          await config.value!.api.create(data);
        }
        // å…³é—­å¹¶æç¤º
        await modalApi.close();
        emit('success');
        message.success($t('ui.actionMessage.operationSuccess'));
      } finally {
        modalApi.unlock();
      }
    },
    async onOpenChange(isOpen: boolean) {
      if (!isOpen) {
        formData.value = undefined;
        return;
      }
      // åŠ è½½æ•°æ®
      const data = modalApi.getData<{
        config: BaseDataEntity;
        formType: FormType;
        id?: number;
      }>();
      config.value = data.config;
      formType.value = data.formType;
      formApi.setState({ schema: data.config.formSchema });
      formApi.setDisabled(formType.value === 'detail');
      modalApi.setState({ showConfirmButton: formType.value !== 'detail' });
      if (!data.id) {
        return;
      }
      modalApi.lock();
      try {
        formData.value = await data.config.api.get(data.id);
        // è®¾ç½®åˆ° values
        await formApi.setValues(formData.value);
      } finally {
        modalApi.unlock();
      }
    },
  });
</script>

<template>
  <Modal :title="getTitle" class="w-3/5">
    <Form class="mx-4" />
  </Modal>
</template>

 src/views/mes/pd/basedata/modules/price-calc.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,171 @@
<script lang="ts" setup>
  import type { VbenFormSchema } from '#/adapter/form';
  import type { MesPdPriceApi } from '#/api/mes/pd/price';

  import { ref } from 'vue';

  import { useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';

  import { Descriptions, Empty, Table } from 'ant-design-vue';

  import { useVbenForm } from '#/adapter/form';
  import { calcPrice } from '#/api/mes/pd/price';
  import { getServicePackageList, getVoltageLevelList } from '#/api/mes/pd/basedata';

  const result = ref<MesPdPriceApi.PriceCalcResp>();
  const hasResult = ref(false);

  const [Form, formApi] = useVbenForm({
    commonConfig: {
      componentProps: {
        class: 'w-full',
      },
      formItemClass: 'col-span-1',
      labelWidth: 130,
    },
    wrapperClass: 'grid-cols-3',
    layout: 'horizontal',
    schema: [],
    showDefaultActions: false,
  });

  /** æµ‹ç®—表单字段 */
  function useCalcSchema(): VbenFormSchema[] {
    return [
      {
        fieldName: 'calcType',
        label: '测算类型',
        component: 'Select',
        rules: 'selectRequired',
        componentProps: {
          options: [
            { label: '服务套餐', value: 1 },
            { label: '电压等级', value: 2 },
          ],
          placeholder: '请选择测算类型',
        },
      },
      {
        fieldName: 'packageId',
        label: '服务套餐',
        component: 'Select',
        rules: 'selectRequired',
        dependencies: {
          triggerFields: ['calcType'],
          show: (values) => values.calcType === 1,
          async componentProps(values, form) {
            if (values.calcType !== 1) {
              form.setFieldValue('packageId', undefined);
              return { allowClear: true, options: [], placeholder: '请选择服务套餐' };
            }
            const list = await getServicePackageList();
            return {
              allowClear: true,
              options: list.map((i) => ({ label: i.name, value: i.id })),
              placeholder: '请选择服务套餐',
            };
          },
        },
      },
      {
        fieldName: 'voltageLevelId',
        label: '电压等级',
        component: 'Select',
        rules: 'selectRequired',
        dependencies: {
          triggerFields: ['calcType'],
          show: (values) => values.calcType === 2,
          async componentProps(values, form) {
            if (values.calcType !== 2) {
              form.setFieldValue('voltageLevelId', undefined);
              return { allowClear: true, options: [], placeholder: '请选择电压等级' };
            }
            const list = await getVoltageLevelList();
            return {
              allowClear: true,
              options: list.map((i) => ({ label: i.name, value: i.id })),
              placeholder: '请选择电压等级',
            };
          },
        },
      },
      {
        fieldName: 'quantity',
        label: '用电量(kWh)',
        component: 'InputNumber',
        componentProps: { class: '!w-full', min: 0, precision: 2 },
        rules: 'required',
      },
    ];
  }

  const [Modal, modalApi] = useVbenModal({
    async onConfirm() {
      const { valid } = await formApi.validate();
      if (!valid) {
        return;
      }
      modalApi.lock();
      try {
        const data = (await formApi.getValues()) as MesPdPriceApi.PriceCalcReq;
        result.value = await calcPrice(data);
        hasResult.value = true;
      } finally {
        modalApi.unlock();
      }
    },
    async onOpenChange(isOpen: boolean) {
      if (!isOpen) {
        return;
      }
      result.value = undefined;
      hasResult.value = false;
      formApi.setState({ schema: useCalcSchema() });
      formApi.resetForm();
      modalApi.setState({ confirmText: '测算', showConfirmButton: true });
    },
  });
</script>

<template>
  <Modal :title="'阶梯电价测算'" class="w-4/5">
    <Form class="mx-4 mb-4" />
    <div v-if="hasResult && result" class="mx-4">
      <Descriptions
        :column="3"
        bordered
        size="small"
        class="mb-4"
      >
        <Descriptions.Item label="原价">
          {{ result.originalPrice ?? 0 }}
        </Descriptions.Item>
        <Descriptions.Item label="优惠金额">
          {{ result.discountAmount ?? 0 }}
        </Descriptions.Item>
        <Descriptions.Item label="优惠后总价">
          <span class="text-lg font-bold text-primary">
            {{ result.finalPrice ?? 0 }}
          </span>
        </Descriptions.Item>
      </Descriptions>
      <Table
        :columns="[
          { title: '档位下限(含,kWh)', dataIndex: 'startValue', key: 'startValue' },
          { title: '档位上限(不含,kWh)', dataIndex: 'endValue', key: 'endValue' },
          { title: '本档电量(kWh)', dataIndex: 'tierQuantity', key: 'tierQuantity' },
          { title: '档位单价', dataIndex: 'pricePerUnit', key: 'pricePerUnit' },
          { title: '小计', dataIndex: 'subtotal', key: 'subtotal' },
        ]"
        :data-source="result.details ?? []"
        :pagination="false"
        size="small"
        class="mb-4"
      />
    </div>
    <div v-else class="mx-4">
      <Empty description="请选择测算类型并输入用电量后点击「测算」" />
    </div>
  </Modal>
</template>

 src/views/mes/pd/ctc-reel/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,206 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { MesPdCtcReelApi } from '#/api/mes/pd/ctc-reel';

import { markRaw } from 'vue';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import { PdCtcSelect } from '#/views/mes/pd/ctc/components';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'update';

/** æ–°å¢ž/修改盘具计算记录 */
export function useFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'ctcId',
      label: '换位导线产品',
      component: markRaw(PdCtcSelect),
      componentProps: {
        placeholder: '请选择换位导线产品',
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'reelType',
      label: '盘具类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.PRODUCT_REEL_TYPE, 'string'),
        placeholder: '请选择盘具类型',
      },
    },
    {
      fieldName: 'reelOuterDiameter',
      label: '盘具外径(mm)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 0,
        placeholder: '请输入盘具外径 d1',
      },
    },
    {
      fieldName: 'reelInnerDiameter',
      label: '盘芯内径(mm)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 0,
        placeholder: '请输入盘芯内径 d2',
      },
    },
    {
      fieldName: 'reelWidth',
      label: '盘宽(mm)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 0,
        placeholder: '请输入盘宽 l2',
      },
    },
    {
      fieldName: 'maxCapacity',
      label: '最大容量(km)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 4,
        placeholder: '请输入最大容量',
      },
    },
    {
      fieldName: 'recommendedLength',
      label: '推荐每盘长度(km)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入推荐每盘长度',
      },
    },
    {
      fieldName: 'netWeight',
      label: '净重(kg)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入净重',
      },
    },
    {
      fieldName: 'grossWeight',
      label: '毛重(kg)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入毛重',
      },
    },
    {
      fieldName: 'calcFormula',
      label: '计算公式',
      component: 'Textarea',
      formItemClass: 'col-span-3',
      componentProps: {
        placeholder: '((d1-60)+(d2+10))×INT(l2/(宽+1))×(d1-d2-70)/(高+0.2)/1274',
        rows: 2,
      },
      help: '容量计算：((d1-60)+(d2+10))×INT(l2/(CTC宽+1))×(d1-d2-70)/(CTC高+0.2)/1274',
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      formItemClass: 'col-span-3',
      componentProps: {
        placeholder: '请输入备注',
        rows: 2,
      },
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'ctcId',
      label: '换位导线产品',
      component: markRaw(PdCtcSelect),
      componentProps: {
        allowClear: true,
        placeholder: '请选择换位导线产品',
      },
    },
    {
      fieldName: 'reelType',
      label: '盘具类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.PRODUCT_REEL_TYPE, 'string'),
        placeholder: '请选择盘具类型',
      },
    },
  ];
}

/** åˆ—表的字段 */
export function useGridColumns(): VxeTableGridOptions<MesPdCtcReelApi.CtcReel>['columns'] {
  return [
    { field: 'ctcOrderSpec', title: '换位导线规格', minWidth: 160 },
    {
      field: 'reelType',
      title: '盘具类型',
      width: 100,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.PRODUCT_REEL_TYPE },
      },
    },
    { field: 'reelOuterDiameter', title: '盘具外径(mm)', width: 110 },
    { field: 'reelInnerDiameter', title: '盘芯内径(mm)', width: 110 },
    { field: 'reelWidth', title: '盘宽(mm)', width: 100 },
    { field: 'maxCapacity', title: '最大容量(km)', width: 120 },
    { field: 'recommendedLength', title: '推荐长度(km)', width: 120 },
    { field: 'netWeight', title: '净重(kg)', width: 100 },
    { field: 'grossWeight', title: '毛重(kg)', width: 100 },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      title: '操作',
      width: 220,
      fixed: 'right',
      slots: {
        default: 'actions',
      },
    },
  ];
}

 src/views/mes/pd/ctc-reel/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,150 @@
<script lang="ts" setup>
  import type { VxeTableGridOptions } from '#/adapter/vxe-table';
  import type { MesPdCtcReelApi } from '#/api/mes/pd/ctc-reel';

  import { ref } from 'vue';

  import { Page, useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';

  import { Button, message } from 'ant-design-vue';

  import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
  import {
    deleteCtcReel,
    getCtcReelPage,
  } from '#/api/mes/pd/ctc-reel';

  import { useGridColumns, useGridFormSchema } from './data';
  import Form from './modules/form.vue';

  const [FormModal, formModalApi] = useVbenModal({
    connectedComponent: Form,
    destroyOnClose: true,
  });

  /** åˆ·æ–°è¡¨æ ¼ */
  function handleRefresh() {
    gridApi.query();
  }

  /** æ–°å¢ž */
  function handleCreate() {
    formModalApi.setData({ formType: 'create' }).open();
  }

  /** æŸ¥çœ‹ */
  function handleDetail(row: MesPdCtcReelApi.CtcReel) {
    formModalApi.setData({ id: row.id, formType: 'detail' }).open();
  }

  /** ç¼–辑 */
  function handleEdit(row: MesPdCtcReelApi.CtcReel) {
    formModalApi.setData({ id: row.id, formType: 'update' }).open();
  }

  /** åˆ é™¤ */
  async function handleDelete(row: MesPdCtcReelApi.CtcReel) {
    const hideLoading = message.loading({
      content: $t('ui.actionMessage.deleting', [row.ctcOrderSpec ?? '']),
      duration: 0,
    });
    try {
      await deleteCtcReel(row.id!);
      message.success(
        $t('ui.actionMessage.deleteSuccess', [row.ctcOrderSpec ?? '']),
      );
      handleRefresh();
    } finally {
      hideLoading();
    }
  }

  const [Grid, gridApi] = useVbenVxeGrid({
    formOptions: {
      schema: useGridFormSchema(),
    },
    gridOptions: {
      columns: useGridColumns(),
      height: 'auto',
      keepSource: true,
      proxyConfig: {
        ajax: {
          query: async ({ page }, formValues) =>
            await getCtcReelPage({
              pageNo: page.currentPage,
              pageSize: page.pageSize,
              ...formValues,
            }),
        },
      },
      rowConfig: {
        keyField: 'id',
        isHover: true,
      },
      toolbarConfig: {
        refresh: true,
        search: true,
      },
    } as VxeTableGridOptions<MesPdCtcReelApi.CtcReel>,
  });
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="换位导线盘具计算列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['盘具计算']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['mes:pd-ctc-reel:create'],
              onClick: handleCreate,
            },
          ]"
        />
      </template>
      <template #ctcOrderSpec="{ row }">
        <Button type="link" @click="handleDetail(row)">
          {{ row.ctcOrderSpec }}
        </Button>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['mes:pd-ctc-reel:update'],
              onClick: handleEdit.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pd-ctc-reel:delete'],
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [
                  row.ctcOrderSpec ?? '',
                ]),
                confirm: handleDelete.bind(null, row),
              },
            },
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['mes:pd-ctc-reel:query'],
              onClick: handleDetail.bind(null, row),
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/mes/pd/ctc-reel/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,126 @@
<script lang="ts" setup>
  import type { FormType } from '../data';

  import type { MesPdCtcReelApi } from '#/api/mes/pd/ctc-reel';

  import { computed, ref } from 'vue';

  import { useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';

  import { Button, message } from 'ant-design-vue';

  import { useVbenForm } from '#/adapter/form';
  import {
    createCtcReel,
    getCtcReel,
    updateCtcReel,
  } from '#/api/mes/pd/ctc-reel';
  import { CalcModal } from '#/views/mes/pd/ctc/modules';

  import { useFormSchema } from '../data';

  const emit = defineEmits(['success']);
  const formType = ref<FormType>('create'); // è¡¨å•æ¨¡å¼
  const formData = ref<MesPdCtcReelApi.CtcReel>();
  const isDetail = computed(() => formType.value === 'detail'); // æ˜¯å¦æŸ¥çœ‹æ¨¡å¼
  const getTitle = computed(() => {
    if (formType.value === 'detail') {
      return '查看盘具计算';
    }
    return formType.value === 'update' ? '修改盘具计算' : '新增盘具计算';
  });

  const [Form, formApi] = useVbenForm({
    commonConfig: {
      componentProps: {
        class: 'w-full',
      },
      formItemClass: 'col-span-1',
      labelWidth: 130,
    },
    wrapperClass: 'grid-cols-3',
    layout: 'horizontal',
    schema: [],
    showDefaultActions: false,
  });

  const [CalcModal, calcModalApi] = useVbenModal({
    connectedComponent: CalcModal,
    destroyOnClose: true,
  });

  /** æ‰“开容量计算工具 */
  function handleOpenCalc() {
    calcModalApi.open();
  }

  /** å›žå¡«æœ€å¤§å®¹é‡ï¼ˆkm） */
  function handleFillReel(value: { capacityKm: number }) {
    formApi.setFieldValue('maxCapacity', value.capacityKm);
  }

  const [Modal, modalApi] = useVbenModal({
    async onConfirm() {
      if (isDetail.value) {
        await modalApi.close();
        return;
      }
      const { valid } = await formApi.validate();
      if (!valid) {
        return;
      }
      modalApi.lock();
      // æäº¤è¡¨å•
      const data = (await formApi.getValues()) as MesPdCtcReelApi.CtcReel;
      try {
        await (data.id ? updateCtcReel(data) : createCtcReel(data));
        // å…³é—­å¹¶æç¤º
        await modalApi.close();
        emit('success');
        message.success($t('ui.actionMessage.operationSuccess'));
      } finally {
        modalApi.unlock();
      }
    },
    async onOpenChange(isOpen: boolean) {
      if (!isOpen) {
        formData.value = undefined;
        return;
      }
      // åŠ è½½æ•°æ®
      const data = modalApi.getData<{ formType: FormType; id?: number }>();
      formType.value = data.formType;
      formApi.setState({ schema: useFormSchema() });
      formApi.setDisabled(formType.value === 'detail');
      modalApi.setState({ showConfirmButton: formType.value !== 'detail' });
      if (!data?.id) {
        return;
      }
      modalApi.lock();
      try {
        formData.value = await getCtcReel(data.id);
        // è®¾ç½®åˆ° values
        await formApi.setValues(formData.value);
      } finally {
        modalApi.unlock();
      }
    },
  });
</script>

<template>
  <Modal :title="getTitle" class="w-4/5">
    <Form class="mx-4" />
    <template #prepend-footer>
      <Button
        v-if="!isDetail"
        type="default"
        @click="handleOpenCalc"
      >
        å®¹é‡è®¡ç®—
      </Button>
    </template>
    <CalcModal @reel="handleFillReel" />
  </Modal>
</template>

 src/views/mes/pd/ctc/components/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1 @@
export { default as PdCtcSelect } from './select.vue';

 src/views/mes/pd/ctc/components/select.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,64 @@
<script lang="ts" setup>
  import { onMounted, ref } from 'vue';

  import { Select } from 'ant-design-vue';

  import { getCtcPage } from '#/api/mes/pd/ctc';

  defineOptions({ name: 'PdCtcSelect', inheritAttrs: false });

  const props = withDefaults(
    defineProps<{
      allowClear?: boolean;
      disabled?: boolean;
      modelValue?: number;
      placeholder?: string;
    }>(),
    {
      allowClear: true,
      disabled: false,
      modelValue: undefined,
      placeholder: '请选择换位导线产品',
    },
  );

  const emit = defineEmits<{
    'update:modelValue': [value: number | undefined];
  }>();

  const options = ref<{ label: string; value: number }[]>([]);
  const searchText = ref('');

  async function load() {
    const data = await getCtcPage({
      pageNo: 1,
      pageSize: 100,
      orderSpec: searchText.value || undefined,
    });
    options.value = (data.list ?? []).map((item) => ({
      label: `${item.orderSpec ?? ''}${item.itemName ? `（${item.itemName}）` : ''}`,
      value: item.id!,
    }));
  }

  onMounted(load);

  function handleSearch(val: string) {
    searchText.value = val;
    load();
  }
</script>

<template>
  <Select
    :model-value="modelValue"
    :options="options"
    :disabled="disabled"
    :placeholder="placeholder"
    :allow-clear="allowClear"
    show-search
    :filter-option="false"
    @update:value="(v: number | undefined) => emit('update:modelValue', v)"
    @search="handleSearch"
  />
</template>

 src/views/mes/pd/ctc/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,262 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { MesPdCtcApi } from '#/api/mes/pd/ctc';

import { markRaw } from 'vue';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import { MdItemSelect } from '#/views/mes/md/item/components';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'update';

/** æ–°å¢ž/修改换位导线产品技术参数 */
export function useFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'itemId',
      label: '物料',
      component: markRaw(MdItemSelect),
      componentProps: {
        placeholder: '请选择换位导线物料',
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'orderSpec',
      label: '订货规格',
      component: 'Input',
      componentProps: {
        placeholder: '请输入订货规格',
      },
    },
    {
      fieldName: 'bareConductorSpec',
      label: '裸导线规格',
      component: 'Input',
      componentProps: {
        placeholder: '请输入裸导线规格',
      },
    },
    {
      fieldName: 'enameledSpec',
      label: '漆包线规格',
      component: 'Input',
      componentProps: {
        placeholder: '请输入漆包线规格',
      },
    },
    {
      fieldName: 'transpositionSpec',
      label: '换位规格',
      component: 'Input',
      componentProps: {
        placeholder: '请输入换位规格',
      },
    },
    {
      fieldName: 'conductorType',
      label: '导体类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.PRODUCT_CONDUCTOR_TYPE, 'string'),
        placeholder: '请选择导体类型',
      },
    },
    {
      fieldName: 'crossSection',
      label: '截面积(mm²)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入截面积',
      },
    },
    {
      fieldName: 'outerDiameter',
      label: '外径(mm)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入外径',
      },
    },
    {
      fieldName: 'resistance20c',
      label: '20℃直流电阻(Ω/km)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 6,
        placeholder: '请输入20℃直流电阻',
      },
    },
    {
      fieldName: 'wrappingAngle',
      label: '绕包角度(°)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入绕包角度',
      },
    },
    {
      fieldName: 'insulationThickness',
      label: '绝缘厚度(mm)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入绝缘厚度',
      },
    },
    {
      fieldName: 'ratedVoltage',
      label: '额定电压(kV)',
      component: 'Input',
      componentProps: {
        placeholder: '请输入额定电压',
      },
    },
    {
      fieldName: 'testVoltage',
      label: '试验电压(kV)',
      component: 'Input',
      componentProps: {
        placeholder: '请输入试验电压',
      },
    },
    {
      fieldName: 'minBendingRadius',
      label: '最小弯曲半径(mm)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入最小弯曲半径',
      },
    },
    {
      fieldName: 'weightPerKm',
      label: '每公里重量(kg/km)',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入每公里重量',
      },
    },
    {
      fieldName: 'standardCode',
      label: '执行标准',
      component: 'Input',
      componentProps: {
        placeholder: '请输入执行标准代号',
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      formItemClass: 'col-span-3',
      componentProps: {
        placeholder: '请输入备注',
        rows: 2,
      },
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'itemId',
      label: '物料',
      component: markRaw(MdItemSelect),
      componentProps: {
        allowClear: true,
        placeholder: '请选择换位导线物料',
      },
    },
    {
      fieldName: 'orderSpec',
      label: '订货规格',
      component: 'Input',
      componentProps: {
        allowClear: true,
        placeholder: '请输入订货规格',
      },
    },
    {
      fieldName: 'conductorType',
      label: '导体类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.PRODUCT_CONDUCTOR_TYPE, 'string'),
        placeholder: '请选择导体类型',
      },
    },
  ];
}

/** åˆ—表的字段 */
export function useGridColumns(): VxeTableGridOptions<MesPdCtcApi.Ctc>['columns'] {
  return [
    { field: 'itemName', title: '物料名称', minWidth: 140 },
    { field: 'itemCode', title: '物料编码', minWidth: 120 },
    { field: 'orderSpec', title: '订货规格', minWidth: 140 },
    { field: 'transpositionSpec', title: '换位规格', minWidth: 120 },
    {
      field: 'conductorType',
      title: '导体类型',
      width: 100,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.PRODUCT_CONDUCTOR_TYPE },
      },
    },
    { field: 'crossSection', title: '截面积(mm²)', width: 110 },
    { field: 'outerDiameter', title: '外径(mm)', width: 100 },
    { field: 'resistance20c', title: '20℃电阻(Ω/km)', width: 140 },
    { field: 'wrappingAngle', title: '绕包角度(°)', width: 110 },
    { field: 'ratedVoltage', title: '额定电压(kV)', width: 110 },
    { field: 'standardCode', title: '执行标准', minWidth: 140 },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      title: '操作',
      width: 220,
      fixed: 'right',
      slots: {
        default: 'actions',
      },
    },
  ];
}

 src/views/mes/pd/ctc/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,161 @@
<script lang="ts" setup>
  import type { VxeTableGridOptions } from '#/adapter/vxe-table';
  import type { MesPdCtcApi } from '#/api/mes/pd/ctc';

  import { ref } from 'vue';

  import { Page, useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';
  import { downloadFileFromBlobPart } from '@vben/utils';

  import { Button, message } from 'ant-design-vue';

  import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
  import {
    deleteCtc,
    exportCtc,
    getCtcPage,
  } from '#/api/mes/pd/ctc';

  import { useGridColumns, useGridFormSchema } from './data';
  import Form from './modules/form.vue';

  const [FormModal, formModalApi] = useVbenModal({
    connectedComponent: Form,
    destroyOnClose: true,
  });

  /** åˆ·æ–°è¡¨æ ¼ */
  function handleRefresh() {
    gridApi.query();
  }

  /** æ–°å¢ž */
  function handleCreate() {
    formModalApi.setData({ formType: 'create' }).open();
  }

  /** æŸ¥çœ‹ */
  function handleDetail(row: MesPdCtcApi.Ctc) {
    formModalApi.setData({ id: row.id, formType: 'detail' }).open();
  }

  /** ç¼–辑 */
  function handleEdit(row: MesPdCtcApi.Ctc) {
    formModalApi.setData({ id: row.id, formType: 'update' }).open();
  }

  /** åˆ é™¤ */
  async function handleDelete(row: MesPdCtcApi.Ctc) {
    const hideLoading = message.loading({
      content: $t('ui.actionMessage.deleting', [row.orderSpec ?? '']),
      duration: 0,
    });
    try {
      await deleteCtc(row.id!);
      message.success($t('ui.actionMessage.deleteSuccess', [row.orderSpec ?? '']));
      handleRefresh();
    } finally {
      hideLoading();
    }
  }

  /** å¯¼å‡º */
  async function handleExport() {
    const data = await exportCtc(await gridApi.formApi.getValues());
    downloadFileFromBlobPart({ fileName: '换位导线技术参数.xls', source: data });
  }

  const [Grid, gridApi] = useVbenVxeGrid({
    formOptions: {
      schema: useGridFormSchema(),
    },
    gridOptions: {
      columns: useGridColumns(),
      height: 'auto',
      keepSource: true,
      proxyConfig: {
        ajax: {
          query: async ({ page }, formValues) =>
            await getCtcPage({
              pageNo: page.currentPage,
              pageSize: page.pageSize,
              ...formValues,
            }),
        },
      },
      rowConfig: {
        keyField: 'id',
        isHover: true,
      },
      toolbarConfig: {
        refresh: true,
        search: true,
      },
    } as VxeTableGridOptions<MesPdCtcApi.Ctc>,
  });
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="换位导线技术参数列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['换位导线技术参数']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['mes:pd-ctc:create'],
              onClick: handleCreate,
            },
            {
              label: $t('ui.actionTitle.export'),
              type: 'primary',
              icon: ACTION_ICON.DOWNLOAD,
              auth: ['mes:pd-ctc:export'],
              onClick: handleExport,
            },
          ]"
        />
      </template>
      <template #orderSpec="{ row }">
        <Button type="link" @click="handleDetail(row)">
          {{ row.orderSpec || row.itemName }}
        </Button>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['mes:pd-ctc:update'],
              onClick: handleEdit.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pd-ctc:delete'],
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.orderSpec ?? '']),
                confirm: handleDelete.bind(null, row),
              },
            },
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['mes:pd-ctc:query'],
              onClick: handleDetail.bind(null, row),
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/mes/pd/ctc/modules/calc-modal.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,344 @@
<script lang="ts" setup>
  import { reactive, ref } from 'vue';

  import { useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';

  import {
    Button,
    Descriptions,
    DescriptionsItem,
    InputNumber,
    message,
    Select,
    Tabs,
  } from 'ant-design-vue';

  import {
    calcCtcAngle,
    calcCtcResistance,
    calcCtcReel,
  } from '#/api/mes/pd/ctc';

  const emit = defineEmits<{
    angle: [value: { wrappingAngle: number }];
    resistance: [value: { resistance20c: number }];
    reel: [value: { capacityKm: number }];
  }>();

  /** ç»•åŒ…角度计算表单 */
  const angleForm = reactive<{
    conductorThickness?: number;
    conductorWidth?: number;
    cornerRadius?: number;
    insulationThickness?: number;
    tapeWidth?: number;
    overlapWidth?: number;
  }>({});
  const angleResult = ref<{
    circumference?: number;
    wrappingAngle?: number;
    wrappingPitch?: number;
  }>();

  /** ç›´æµç”µé˜»è®¡ç®—表单 */
  const resistanceForm = reactive<{
    conductorThickness?: number;
    conductorWidth?: number;
    temperature?: number;
    material?: string;
  }>({ temperature: 75, material: 'copper' });
  const resistanceResult = ref<{
    crossSection?: number;
    resistance20cKm?: number;
    resistanceAtTemp?: number;
    resistanceAtTempKm?: number;
  }>();

  /** ç›˜å…·å®¹é‡è®¡ç®—表单 */
  const reelForm = reactive<{
    reelOuterDiameter?: number;
    reelInnerDiameter?: number;
    reelWidth?: number;
    ctcThickness?: number;
    ctcWidth?: number;
  }>({});
  const reelResult = ref<{
    capacityMeter?: number;
    capacityKm?: number;
  }>();

  /** ç»•åŒ…角度计算 */
  async function handleCalcAngle() {
    const data = await calcCtcAngle(angleForm);
    angleResult.value = data;
  }

  /** ç›´æµç”µé˜»è®¡ç®— */
  async function handleCalcResistance() {
    const data = await calcCtcResistance(resistanceForm);
    resistanceResult.value = data;
  }

  /** ç›˜å…·å®¹é‡è®¡ç®— */
  async function handleCalcReel() {
    const data = await calcCtcReel(reelForm);
    reelResult.value = data;
  }

  /** å›žå¡«ç»•åŒ…角度 */
  function handleFillAngle() {
    if (angleResult.value?.wrappingAngle == null) {
      message.warning('请先执行绕包角度计算');
      return;
    }
    emit('angle', { wrappingAngle: angleResult.value.wrappingAngle });
    message.success($t('ui.actionMessage.operationSuccess'));
  }

  /** å›žå¡«ç›´æµç”µé˜» */
  function handleFillResistance() {
    if (resistanceResult.value?.resistance20cKm == null) {
      message.warning('请先执行直流电阻计算');
      return;
    }
    emit('resistance', { resistance20c: resistanceResult.value.resistance20cKm });
    message.success($t('ui.actionMessage.operationSuccess'));
  }

  /** å›žå¡«ç›˜å…·å®¹é‡ */
  function handleFillReel() {
    if (reelResult.value?.capacityKm == null) {
      message.warning('请先执行盘具容量计算');
      return;
    }
    emit('reel', { capacityKm: reelResult.value.capacityKm });
    message.success($t('ui.actionMessage.operationSuccess'));
  }

  const [Modal, modalApi] = useVbenModal({
    onOpenChange(isOpen: boolean) {
      if (!isOpen) {
        angleResult.value = undefined;
        resistanceResult.value = undefined;
        reelResult.value = undefined;
      }
    },
  });
</script>

<template>
  <Modal title="换位导线计算工具" class="w-2/3">
    <Tabs>
      <Tabs.TabPane key="angle" tab="绕包角度">
        <div class="grid grid-cols-3 gap-4">
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">导体厚度(mm)</span>
            <InputNumber
              v-model:value="angleForm.conductorThickness"
              class="!flex-1"
              :min="0"
              :precision="2"
              placeholder="如 19.08"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">导体宽度(mm)</span>
            <InputNumber
              v-model:value="angleForm.conductorWidth"
              class="!flex-1"
              :min="0"
              :precision="2"
              placeholder="如 12.6"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">圆角半径(mm)</span>
            <InputNumber
              v-model:value="angleForm.cornerRadius"
              class="!flex-1"
              :min="0"
              :precision="2"
              placeholder="如 1"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">绝缘厚度(mm)</span>
            <InputNumber
              v-model:value="angleForm.insulationThickness"
              class="!flex-1"
              :min="0"
              :precision="2"
              placeholder="如 0.75"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">纸带宽度(mm)</span>
            <InputNumber
              v-model:value="angleForm.tapeWidth"
              class="!flex-1"
              :min="0"
              :precision="2"
              placeholder="如 22"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">重叠宽度(mm)</span>
            <InputNumber
              v-model:value="angleForm.overlapWidth"
              class="!flex-1"
              :min="0"
              :precision="2"
              placeholder="如 2"
            />
          </div>
        </div>
        <div class="mt-4 flex gap-2">
          <Button type="primary" @click="handleCalcAngle">计算</Button>
          <Button @click="handleFillAngle">回填绕包角度</Button>
        </div>
        <Descriptions v-if="angleResult" class="mt-4" :column="3" bordered>
          <DescriptionsItem label="导线周长(mm)">
            {{ angleResult.circumference }}
          </DescriptionsItem>
          <DescriptionsItem label="绕包角度(°)">
            {{ angleResult.wrappingAngle }}
          </DescriptionsItem>
          <DescriptionsItem label="绕包节距(mm)">
            {{ angleResult.wrappingPitch }}
          </DescriptionsItem>
        </Descriptions>
      </Tabs.TabPane>

      <Tabs.TabPane key="resistance" tab="直流电阻">
        <div class="grid grid-cols-3 gap-4">
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">导体厚度(mm)</span>
            <InputNumber
              v-model:value="resistanceForm.conductorThickness"
              class="!flex-1"
              :min="0"
              :precision="2"
              placeholder="如 1.27"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">导体宽度(mm)</span>
            <InputNumber
              v-model:value="resistanceForm.conductorWidth"
              class="!flex-1"
              :min="0"
              :precision="2"
              placeholder="如 5.7"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">计算温度(℃)</span>
            <InputNumber
              v-model:value="resistanceForm.temperature"
              class="!flex-1"
              :min="0"
              :precision="0"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">导体材质</span>
            <Select
              v-model:value="resistanceForm.material"
              class="!flex-1"
              :options="[
                { label: '铜', value: 'copper' },
                { label: '铝', value: 'aluminum' },
              ]"
            />
          </div>
        </div>
        <div class="mt-4 flex gap-2">
          <Button type="primary" @click="handleCalcResistance">计算</Button>
          <Button @click="handleFillResistance">回填20℃电阻</Button>
        </div>
        <Descriptions v-if="resistanceResult" class="mt-4" :column="2" bordered>
          <DescriptionsItem label="截面积(mm²)">
            {{ resistanceResult.crossSection }}
          </DescriptionsItem>
          <DescriptionsItem label="20℃电阻(Ω/km)">
            {{ resistanceResult.resistance20cKm }}
          </DescriptionsItem>
          <DescriptionsItem label="计算温度电阻(Ω/m)">
            {{ resistanceResult.resistanceAtTemp }}
          </DescriptionsItem>
          <DescriptionsItem label="计算温度电阻(Ω/km)">
            {{ resistanceResult.resistanceAtTempKm }}
          </DescriptionsItem>
        </Descriptions>
      </Tabs.TabPane>

      <Tabs.TabPane key="reel" tab="盘具容量">
        <div class="grid grid-cols-3 gap-4">
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">盘具外径 d1(mm)</span>
            <InputNumber
              v-model:value="reelForm.reelOuterDiameter"
              class="!flex-1"
              :min="0"
              :precision="0"
              placeholder="如 1600"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">盘芯内径 d2(mm)</span>
            <InputNumber
              v-model:value="reelForm.reelInnerDiameter"
              class="!flex-1"
              :min="0"
              :precision="0"
              placeholder="如 1100"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">盘宽 l2(mm)</span>
            <InputNumber
              v-model:value="reelForm.reelWidth"
              class="!flex-1"
              :min="0"
              :precision="0"
              placeholder="如 500"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">CTC高度(mm)</span>
            <InputNumber
              v-model:value="reelForm.ctcThickness"
              class="!flex-1"
              :min="0"
              :precision="2"
              placeholder="如 19.08"
            />
          </div>
          <div class="flex items-center gap-2">
            <span class="w-28 text-right">CTC宽度(mm)</span>
            <InputNumber
              v-model:value="reelForm.ctcWidth"
              class="!flex-1"
              :min="0"
              :precision="2"
              placeholder="如 12.6"
            />
          </div>
        </div>
        <div class="mt-4 flex gap-2">
          <Button type="primary" @click="handleCalcReel">计算</Button>
          <Button @click="handleFillReel">回填最大容量</Button>
        </div>
        <Descriptions v-if="reelResult" class="mt-4" :column="2" bordered>
          <DescriptionsItem label="每盘长度(m)">
            {{ reelResult.capacityMeter }}
          </DescriptionsItem>
          <DescriptionsItem label="每盘长度(km)">
            {{ reelResult.capacityKm }}
          </DescriptionsItem>
        </Descriptions>
      </Tabs.TabPane>
    </Tabs>
  </Modal>
</template>

 src/views/mes/pd/ctc/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,134 @@
<script lang="ts" setup>
  import type { FormType } from '../data';

  import type { MesPdCtcApi } from '#/api/mes/pd/ctc';

  import { computed, ref } from 'vue';

  import { useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';

  import { Button, message } from 'ant-design-vue';

  import { useVbenForm } from '#/adapter/form';
  import {
    createCtc,
    getCtc,
    updateCtc,
  } from '#/api/mes/pd/ctc';

  import { useFormSchema } from '../data';
  import CalcModal from './calc-modal.vue';

  const emit = defineEmits(['success']);
  const formType = ref<FormType>('create'); // è¡¨å•æ¨¡å¼
  const formData = ref<MesPdCtcApi.Ctc>();
  const isDetail = computed(() => formType.value === 'detail'); // æ˜¯å¦æŸ¥çœ‹æ¨¡å¼
  const getTitle = computed(() => {
    if (formType.value === 'detail') {
      return '查看换位导线技术参数';
    }
    return formType.value === 'update' ? '修改换位导线技术参数' : '新增换位导线技术参数';
  });

  const [Form, formApi] = useVbenForm({
    commonConfig: {
      componentProps: {
        class: 'w-full',
      },
      formItemClass: 'col-span-1',
      labelWidth: 130,
    },
    wrapperClass: 'grid-cols-3',
    layout: 'horizontal',
    schema: [],
    showDefaultActions: false,
  });

  const [CalcModal, calcModalApi] = useVbenModal({
    connectedComponent: CalcModal,
    destroyOnClose: true,
  });

  /** æ‰“开计算工具 */
  function handleOpenCalc() {
    calcModalApi.open();
  }

  /** å›žå¡«ç»•åŒ…角度 */
  function handleFillAngle(value: { wrappingAngle: number }) {
    formApi.setFieldValue('wrappingAngle', value.wrappingAngle);
  }

  /** å›žå¡«ç›´æµç”µé˜» */
  function handleFillResistance(value: { resistance20c: number }) {
    formApi.setFieldValue('resistance20c', value.resistance20c);
  }

  const [Modal, modalApi] = useVbenModal({
    async onConfirm() {
      if (isDetail.value) {
        await modalApi.close();
        return;
      }
      const { valid } = await formApi.validate();
      if (!valid) {
        return;
      }
      modalApi.lock();
      // æäº¤è¡¨å•
      const data = (await formApi.getValues()) as MesPdCtcApi.Ctc;
      try {
        await (data.id ? updateCtc(data) : createCtc(data));
        // å…³é—­å¹¶æç¤º
        await modalApi.close();
        emit('success');
        message.success($t('ui.actionMessage.operationSuccess'));
      } finally {
        modalApi.unlock();
      }
    },
    async onOpenChange(isOpen: boolean) {
      if (!isOpen) {
        formData.value = undefined;
        return;
      }
      // åŠ è½½æ•°æ®
      const data = modalApi.getData<{ formType: FormType; id?: number }>();
      formType.value = data.formType;
      formApi.setState({ schema: useFormSchema() });
      formApi.setDisabled(formType.value === 'detail');
      modalApi.setState({ showConfirmButton: formType.value !== 'detail' });
      if (!data?.id) {
        return;
      }
      modalApi.lock();
      try {
        formData.value = await getCtc(data.id);
        // è®¾ç½®åˆ° values
        await formApi.setValues(formData.value);
      } finally {
        modalApi.unlock();
      }
    },
  });
</script>

<template>
  <Modal :title="getTitle" class="w-4/5">
    <Form class="mx-4" />
    <template #prepend-footer>
      <Button
        v-if="!isDetail"
        type="default"
        @click="handleOpenCalc"
      >
        è®¡ç®—工具
      </Button>
    </template>
    <CalcModal
      @angle="handleFillAngle"
      @resistance="handleFillResistance"
    />
  </Modal>
</template>

 src/views/mes/pd/ctc/modules/index.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1 @@
export { default as CalcModal } from './calc-modal.vue';

 src/views/mes/pd/product/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,181 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { MesPdProductApi } from '#/api/mes/pd/product';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'update';

/** å®¡æ‰¹çŠ¶æ€å¸¸é‡ */
export const AuditStatus = {
  DRAFT: 0, // æœªæäº¤
  PROCESS: 10, // å®¡æ‰¹ä¸­
  APPROVE: 20, // å®¡æ ¸é€šè¿‡
  REJECT: 30, // å®¡æ ¸ä¸é€šè¿‡
} as const;

/** æ–°å¢ž/修改产品档案 */
export function useFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'archiveType',
      label: '档案类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_PRODUCT_ARCHIVE_TYPE, 'number'),
        placeholder: '请选择档案类型',
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'name',
      label: '档案名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入档案名称',
      },
      rules: 'required',
    },
    {
      fieldName: 'spec',
      label: '规格型号',
      component: 'Input',
      componentProps: {
        placeholder: '请输入规格型号',
      },
    },
    {
      fieldName: 'unit',
      label: '单位',
      component: 'Input',
      componentProps: {
        placeholder: '请输入单位',
      },
    },
    {
      fieldName: 'price',
      label: '基准价格',
      component: 'InputNumber',
      componentProps: {
        class: '!w-full',
        min: 0,
        precision: 2,
        placeholder: '请输入基准价格',
      },
    },
    {
      fieldName: 'status',
      label: '启用状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_PRODUCT_STATUS, 'number'),
        placeholder: '请选择启用状态',
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      formItemClass: 'col-span-3',
      componentProps: {
        placeholder: '请输入备注',
        rows: 2,
      },
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'archiveType',
      label: '档案类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_PRODUCT_ARCHIVE_TYPE, 'number'),
        placeholder: '请选择档案类型',
      },
    },
    {
      fieldName: 'name',
      label: '档案名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入档案名称',
      },
    },
    {
      fieldName: 'auditStatus',
      label: '审批状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PD_AUDIT_STATUS, 'number'),
        placeholder: '请选择审批状态',
      },
    },
  ];
}

/** åˆ—表的字段 */
export function useGridColumns(): VxeTableGridOptions<MesPdProductApi.Product>['columns'] {
  return [
    { field: 'code', title: '档案编码', width: 150 },
    { field: 'name', title: '档案名称', minWidth: 160 },
    {
      field: 'archiveType',
      title: '档案类型',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_PD_PRODUCT_ARCHIVE_TYPE },
      },
    },
    { field: 'spec', title: '规格型号', width: 140 },
    { field: 'unit', title: '单位', width: 80 },
    {
      field: 'price',
      title: '基准价格',
      width: 100,
      formatter: 'formatNumber',
    },
    {
      field: 'auditStatus',
      title: '审批状态',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_PD_AUDIT_STATUS },
      },
    },
    { field: 'auditRemark', title: '审批意见', width: 150 },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      title: '操作',
      width: 260,
      fixed: 'right',
      slots: {
        default: 'actions',
      },
    },
  ];
}

 src/views/mes/pd/product/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,214 @@
<script lang="ts" setup>
  import type { VxeTableGridOptions } from '#/adapter/vxe-table';
  import type { MesPdProductApi } from '#/api/mes/pd/product';

  import { useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';
  import { downloadFileFromBlobPart } from '@vben/utils';

  import { message } from 'ant-design-vue';

  import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
  import {
    deleteProduct,
    exportProduct,
    getProductPage,
    submitProduct,
  } from '#/api/mes/pd/product';

  import { AuditStatus, useGridColumns, useGridFormSchema } from './data';
  import Audit from './modules/audit.vue';
  import Form from './modules/form.vue';

  const [FormModal, formModalApi] = useVbenModal({
    connectedComponent: Form,
    destroyOnClose: true,
  });
  const [AuditModal, auditModalApi] = useVbenModal({
    connectedComponent: Audit,
    destroyOnClose: true,
  });

  /** åˆ·æ–°è¡¨æ ¼ */
  function handleRefresh() {
    gridApi.query();
  }

  /** æ–°å¢ž */
  function handleCreate() {
    formModalApi.setData({ formType: 'create' }).open();
  }

  /** æŸ¥çœ‹ */
  function handleDetail(row: MesPdProductApi.Product) {
    formModalApi.setData({ id: row.id, formType: 'detail' }).open();
  }

  /** ç¼–辑 */
  function handleEdit(row: MesPdProductApi.Product) {
    formModalApi.setData({ id: row.id, formType: 'update' }).open();
  }

  /** åˆ é™¤ */
  async function handleDelete(row: MesPdProductApi.Product) {
    const hideLoading = message.loading({
      content: $t('ui.actionMessage.deleting', [row.code ?? '']),
      duration: 0,
    });
    try {
      await deleteProduct(row.id!);
      message.success($t('ui.actionMessage.deleteSuccess', [row.code ?? '']));
      handleRefresh();
    } finally {
      hideLoading();
    }
  }

  /** æäº¤å®¡æ‰¹ï¼ˆæœªæäº¤/驳回 â†’ å®¡æ‰¹ä¸­ï¼‰ */
  async function handleSubmit(row: MesPdProductApi.Product) {
    const hideLoading = message.loading({ content: '提交审批中...', duration: 0 });
    try {
      await submitProduct(row.id!);
      message.success('提交成功');
      handleRefresh();
    } finally {
      hideLoading();
    }
  }

  /** æ‰“开审批弹窗（通过/驳回） */
  function handleAudit(row: MesPdProductApi.Product, pass: boolean) {
    auditModalApi.setData({ row, pass }).open();
  }

  /** å¯¼å‡º */
  async function handleExport() {
    const data = await exportProduct(await gridApi.formApi.getValues());
    downloadFileFromBlobPart({ fileName: '产品档案.xls', source: data });
  }

  const [Grid, gridApi] = useVbenVxeGrid({
    formOptions: {
      schema: useGridFormSchema(),
    },
    gridOptions: {
      columns: useGridColumns(),
      height: 'auto',
      keepSource: true,
      proxyConfig: {
        ajax: {
          query: async ({ page }, formValues) =>
            await getProductPage({
              pageNo: page.currentPage,
              pageSize: page.pageSize,
              ...formValues,
            }),
        },
      },
      rowConfig: {
        keyField: 'id',
        isHover: true,
      },
      toolbarConfig: {
        refresh: true,
        search: true,
      },
    } as VxeTableGridOptions<MesPdProductApi.Product>,
  });
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <AuditModal @success="handleRefresh" />
    <Grid table-title="产品档案列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['产品档案']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['mes:pd-product:create'],
              onClick: handleCreate,
            },
            {
              label: $t('ui.actionTitle.export'),
              type: 'primary',
              icon: ACTION_ICON.DOWNLOAD,
              auth: ['mes:pd-product:export'],
              onClick: handleExport,
            },
          ]"
        />
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: '提交审批',
              type: 'link',
              icon: ACTION_ICON.AUDIT,
              auth: ['mes:pd-product:submit'],
              ifShow:
                row.auditStatus === AuditStatus.DRAFT ||
                row.auditStatus === AuditStatus.REJECT,
              popConfirm: {
                title: '确认提交审批？',
                confirm: handleSubmit.bind(null, row),
              },
            },
            {
              label: '审核通过',
              type: 'link',
              icon: ACTION_ICON.AUDIT,
              auth: ['mes:pd-product:audit'],
              ifShow: row.auditStatus === AuditStatus.PROCESS,
              onClick: handleAudit.bind(null, row, true),
            },
            {
              label: '审核驳回',
              type: 'link',
              danger: true,
              icon: ACTION_ICON.AUDIT,
              auth: ['mes:pd-product:audit'],
              ifShow: row.auditStatus === AuditStatus.PROCESS,
              onClick: handleAudit.bind(null, row, false),
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['mes:pd-product:update'],
              ifShow:
                row.auditStatus === AuditStatus.DRAFT ||
                row.auditStatus === AuditStatus.REJECT,
              onClick: handleEdit.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pd-product:delete'],
              ifShow:
                row.auditStatus === AuditStatus.DRAFT ||
                row.auditStatus === AuditStatus.REJECT,
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.code ?? '']),
                confirm: handleDelete.bind(null, row),
              },
            },
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['mes:pd-product:query'],
              onClick: handleDetail.bind(null, row),
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/mes/pd/product/modules/audit.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,94 @@
<script lang="ts" setup>
  import type { VbenFormSchema } from '#/adapter/form';
  import type { MesPdProductApi } from '#/api/mes/pd/product';

  import { computed, ref } from 'vue';

  import { useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';

  import { message } from 'ant-design-vue';

  import { useVbenForm } from '#/adapter/form';
  import { auditProduct } from '#/api/mes/pd/product';

  const emit = defineEmits(['success']);
  const pass = ref(true); // true=通过 / false=驳回
  const rowData = ref<MesPdProductApi.Product>();
  const getTitle = computed(() => (pass.value ? '审核通过' : '审核驳回'));

  const [Form, formApi] = useVbenForm({
    commonConfig: {
      componentProps: {
        class: 'w-full',
      },
      formItemClass: 'col-span-1',
      labelWidth: 130,
    },
    wrapperClass: 'grid-cols-1',
    layout: 'horizontal',
    schema: [],
    showDefaultActions: false,
  });

  /** å®¡æ ¸è¡¨å•å­—段 */
  function useAuditSchema(): VbenFormSchema[] {
    return [
      {
        fieldName: 'auditRemark',
        label: '审批意见',
        component: 'Textarea',
        formItemClass: 'col-span-1',
        componentProps: {
          rows: 3,
          placeholder: pass.value
            ? '请输入审批意见（可选）'
            : '请输入驳回原因（必填）',
        },
        rules: pass.value ? '' : 'required',
      },
    ];
  }

  const [Modal, modalApi] = useVbenModal({
    async onConfirm() {
      const { valid } = await formApi.validate();
      if (!valid) {
        return;
      }
      modalApi.lock();
      const values = await formApi.getValues();
      try {
        await auditProduct({
          id: rowData.value!.id!,
          pass: pass.value,
          auditRemark: values.auditRemark,
        });
        await modalApi.close();
        emit('success');
        message.success(pass.value ? '审批通过' : '审批驳回');
      } finally {
        modalApi.unlock();
      }
    },
    async onOpenChange(isOpen: boolean) {
      if (!isOpen) {
        return;
      }
      const data = modalApi.getData<{
        row: MesPdProductApi.Product;
        pass: boolean;
      }>();
      rowData.value = data.row;
      pass.value = data.pass;
      formApi.setState({ schema: useAuditSchema() });
      formApi.resetForm();
    },
  });
</script>

<template>
  <Modal :title="getTitle" class="w-2/5">
    <Form class="mx-4" />
  </Modal>
</template>

 src/views/mes/pd/product/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,100 @@
<script lang="ts" setup>
  import type { FormType } from '../data';

  import type { MesPdProductApi } from '#/api/mes/pd/product';

  import { computed, ref } from 'vue';

  import { useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';

  import { message } from 'ant-design-vue';

  import { useVbenForm } from '#/adapter/form';
  import {
    createProduct,
    getProduct,
    updateProduct,
  } from '#/api/mes/pd/product';

  import { useFormSchema } from '../data';

  const emit = defineEmits(['success']);
  const formType = ref<FormType>('create'); // è¡¨å•æ¨¡å¼
  const formData = ref<MesPdProductApi.Product>();
  const isDetail = computed(() => formType.value === 'detail'); // æ˜¯å¦æŸ¥çœ‹æ¨¡å¼
  const getTitle = computed(() => {
    if (formType.value === 'detail') {
      return '查看产品档案';
    }
    return formType.value === 'update' ? '修改产品档案' : '新增产品档案';
  });

  const [Form, formApi] = useVbenForm({
    commonConfig: {
      componentProps: {
        class: 'w-full',
      },
      formItemClass: 'col-span-1',
      labelWidth: 130,
    },
    wrapperClass: 'grid-cols-3',
    layout: 'horizontal',
    schema: [],
    showDefaultActions: false,
  });

  const [Modal, modalApi] = useVbenModal({
    async onConfirm() {
      if (isDetail.value) {
        await modalApi.close();
        return;
      }
      const { valid } = await formApi.validate();
      if (!valid) {
        return;
      }
      modalApi.lock();
      // æäº¤è¡¨å•
      const data = (await formApi.getValues()) as MesPdProductApi.Product;
      try {
        await (data.id ? updateProduct(data) : createProduct(data));
        // å…³é—­å¹¶æç¤º
        await modalApi.close();
        emit('success');
        message.success($t('ui.actionMessage.operationSuccess'));
      } finally {
        modalApi.unlock();
      }
    },
    async onOpenChange(isOpen: boolean) {
      if (!isOpen) {
        formData.value = undefined;
        return;
      }
      // åŠ è½½æ•°æ®
      const data = modalApi.getData<{ formType: FormType; id?: number }>();
      formType.value = data.formType;
      formApi.setState({ schema: useFormSchema() });
      formApi.setDisabled(formType.value === 'detail');
      modalApi.setState({ showConfirmButton: formType.value !== 'detail' });
      if (!data?.id) {
        return;
      }
      modalApi.lock();
      try {
        formData.value = await getProduct(data.id);
        // è®¾ç½®åˆ° values
        await formApi.setValues(formData.value);
      } finally {
        modalApi.unlock();
      }
    },
  });
</script>

<template>
  <Modal :title="getTitle" class="w-3/5">
    <Form class="mx-4" />
  </Modal>
</template>

 src/views/mes/pd/tech-confirm/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,260 @@
import type { VbenFormApi, VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { CrmCustomerApi } from '#/api/crm/customer';
import type { MesPdTechConfirmApi } from '#/api/mes/pd/tech-confirm';

import { markRaw } from 'vue';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import CrmCustomerSelect from '#/components/crm-customer-select.vue';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'update';

/** æ–°å¢ž/修改产品技术确认函 */
export function useFormSchema(
  formApi?: VbenFormApi,
): VbenFormSchema[] {
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'confirmNo',
      label: '确认函编号',
      component: 'Input',
      componentProps: {
        placeholder: '请输入确认函编号',
      },
      rules: 'required',
    },
    {
      fieldName: 'customerId',
      label: '客户',
      component: markRaw(CrmCustomerSelect),
      componentProps: {
        placeholder: '请选择客户',
        onChange: (item?: CrmCustomerApi.Customer) => {
          formApi?.setFieldValue('customerName', item?.name);
        },
      },
    },
    {
      fieldName: 'customerName',
      label: '客户名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入客户名称',
      },
      rules: 'required',
    },
    {
      fieldName: 'productName',
      label: '产品名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入产品名称',
      },
      rules: 'required',
    },
    {
      fieldName: 'specification',
      label: '规格型号',
      component: 'Input',
      componentProps: {
        placeholder: '请输入规格型号',
      },
    },
    {
      fieldName: 'techParams',
      label: '技术参数(JSON)',
      component: 'Textarea',
      formItemClass: 'col-span-3',
      componentProps: {
        placeholder: '请输入技术参数 JSON，如 {"thickness":"1.27","width":"5.7"}',
        rows: 4,
      },
    },
    {
      fieldName: 'templateType',
      label: '模板类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.PRODUCT_TECH_CONFIRM_TEMPLATE, 'string'),
        placeholder: '请选择模板类型',
      },
    },
    {
      fieldName: 'status',
      label: '状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.PRODUCT_TECH_CONFIRM_STATUS, 'number'),
        placeholder: '请选择状态',
      },
    },
    {
      fieldName: 'drafterName',
      label: '编制人',
      component: 'Input',
      componentProps: {
        placeholder: '请输入编制人姓名',
      },
    },
    {
      fieldName: 'draftTime',
      label: '编制时间',
      component: 'DatePicker',
      componentProps: {
        class: '!w-full',
        format: 'YYYY-MM-DD HH:mm:ss',
        showTime: true,
        valueFormat: 'YYYY-MM-DD HH:mm:ss',
      },
    },
    {
      fieldName: 'reviewerName',
      label: '审核人',
      component: 'Input',
      componentProps: {
        placeholder: '请输入审核人姓名',
      },
    },
    {
      fieldName: 'reviewTime',
      label: '审核时间',
      component: 'DatePicker',
      componentProps: {
        class: '!w-full',
        format: 'YYYY-MM-DD HH:mm:ss',
        showTime: true,
        valueFormat: 'YYYY-MM-DD HH:mm:ss',
      },
    },
    {
      fieldName: 'customerConfirmUser',
      label: '客户确认人',
      component: 'Input',
      componentProps: {
        placeholder: '请输入客户确认人',
      },
    },
    {
      fieldName: 'customerConfirmTime',
      label: '客户确认时间',
      component: 'DatePicker',
      componentProps: {
        class: '!w-full',
        format: 'YYYY-MM-DD HH:mm:ss',
        showTime: true,
        valueFormat: 'YYYY-MM-DD HH:mm:ss',
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      formItemClass: 'col-span-3',
      componentProps: {
        placeholder: '请输入备注',
        rows: 2,
      },
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'confirmNo',
      label: '确认函编号',
      component: 'Input',
      componentProps: {
        allowClear: true,
        placeholder: '请输入确认函编号',
      },
    },
    {
      fieldName: 'productName',
      label: '产品名称',
      component: 'Input',
      componentProps: {
        allowClear: true,
        placeholder: '请输入产品名称',
      },
    },
    {
      fieldName: 'templateType',
      label: '模板类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.PRODUCT_TECH_CONFIRM_TEMPLATE, 'string'),
        placeholder: '请选择模板类型',
      },
    },
    {
      fieldName: 'status',
      label: '状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.PRODUCT_TECH_CONFIRM_STATUS, 'number'),
        placeholder: '请选择状态',
      },
    },
  ];
}

/** åˆ—表的字段 */
export function useGridColumns(): VxeTableGridOptions<MesPdTechConfirmApi.TechConfirm>['columns'] {
  return [
    { field: 'confirmNo', title: '确认函编号', minWidth: 160 },
    { field: 'customerName', title: '客户名称', minWidth: 180 },
    { field: 'productName', title: '产品名称', minWidth: 140 },
    { field: 'specification', title: '规格型号', minWidth: 140 },
    {
      field: 'templateType',
      title: '模板类型',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.PRODUCT_TECH_CONFIRM_TEMPLATE },
      },
    },
    { field: 'drafterName', title: '编制人', width: 90 },
    {
      field: 'status',
      title: '状态',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.PRODUCT_TECH_CONFIRM_STATUS },
      },
    },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      title: '操作',
      width: 260,
      fixed: 'right',
      slots: {
        default: 'actions',
      },
    },
  ];
}

 src/views/mes/pd/tech-confirm/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,198 @@
<script lang="ts" setup>
  import type { VxeTableGridOptions } from '#/adapter/vxe-table';
  import type { MesPdTechConfirmApi } from '#/api/mes/pd/tech-confirm';

  import { ref } from 'vue';

  import { Page, useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';
  import { downloadFileFromBlobPart } from '@vben/utils';

  import { Button, message } from 'ant-design-vue';

  import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
  import {
    deleteTechConfirm,
    exportTechConfirm,
    getTechConfirmPage,
    updateTechConfirm,
  } from '#/api/mes/pd/tech-confirm';

  import { useGridColumns, useGridFormSchema } from './data';
  import Form from './modules/form.vue';

  const [FormModal, formModalApi] = useVbenModal({
    connectedComponent: Form,
    destroyOnClose: true,
  });

  /** åˆ·æ–°è¡¨æ ¼ */
  function handleRefresh() {
    gridApi.query();
  }

  /** æ–°å¢ž */
  function handleCreate() {
    formModalApi.setData({ formType: 'create' }).open();
  }

  /** æŸ¥çœ‹ */
  function handleDetail(row: MesPdTechConfirmApi.TechConfirm) {
    formModalApi.setData({ id: row.id, formType: 'detail' }).open();
  }

  /** ç¼–辑 */
  function handleEdit(row: MesPdTechConfirmApi.TechConfirm) {
    formModalApi.setData({ id: row.id, formType: 'update' }).open();
  }

  /** åˆ é™¤ */
  async function handleDelete(row: MesPdTechConfirmApi.TechConfirm) {
    const hideLoading = message.loading({
      content: $t('ui.actionMessage.deleting', [row.confirmNo ?? '']),
      duration: 0,
    });
    try {
      await deleteTechConfirm(row.id!);
      message.success($t('ui.actionMessage.deleteSuccess', [row.confirmNo ?? '']));
      handleRefresh();
    } finally {
      hideLoading();
    }
  }

  /** çŠ¶æ€æµè½¬ */
  async function handleStatus(row: MesPdTechConfirmApi.TechConfirm, next: number) {
    const hideLoading = message.loading({ content: '状态更新中...', duration: 0 });
    try {
      await updateTechConfirm({ ...row, status: next });
      message.success($t('ui.actionMessage.operationSuccess'));
      handleRefresh();
    } finally {
      hideLoading();
    }
  }

  /** å¯¼å‡º */
  async function handleExport() {
    const data = await exportTechConfirm(await gridApi.formApi.getValues());
    downloadFileFromBlobPart({ fileName: '产品技术确认函.xls', source: data });
  }

  const [Grid, gridApi] = useVbenVxeGrid({
    formOptions: {
      schema: useGridFormSchema(),
    },
    gridOptions: {
      columns: useGridColumns(),
      height: 'auto',
      keepSource: true,
      proxyConfig: {
        ajax: {
          query: async ({ page }, formValues) =>
            await getTechConfirmPage({
              pageNo: page.currentPage,
              pageSize: page.pageSize,
              ...formValues,
            }),
        },
      },
      rowConfig: {
        keyField: 'id',
        isHover: true,
      },
      toolbarConfig: {
        refresh: true,
        search: true,
      },
    } as VxeTableGridOptions<MesPdTechConfirmApi.TechConfirm>,
  });
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="产品技术确认函列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['技术确认函']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['mes:pd-tech-confirm:create'],
              onClick: handleCreate,
            },
            {
              label: $t('ui.actionTitle.export'),
              type: 'primary',
              icon: ACTION_ICON.DOWNLOAD,
              auth: ['mes:pd-tech-confirm:export'],
              onClick: handleExport,
            },
          ]"
        />
      </template>
      <template #confirmNo="{ row }">
        <Button type="link" @click="handleDetail(row)">
          {{ row.confirmNo }}
        </Button>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: '提交审核',
              type: 'link',
              icon: ACTION_ICON.AUDIT,
              auth: ['mes:pd-tech-confirm:update'],
              ifShow: row.status === 0,
              onClick: handleStatus.bind(null, row, 1),
            },
            {
              label: '审核通过',
              type: 'link',
              icon: ACTION_ICON.AUDIT,
              auth: ['mes:pd-tech-confirm:update'],
              ifShow: row.status === 1,
              onClick: handleStatus.bind(null, row, 2),
            },
            {
              label: '客户确认',
              type: 'link',
              icon: ACTION_ICON.AUDIT,
              auth: ['mes:pd-tech-confirm:update'],
              ifShow: row.status === 2,
              onClick: handleStatus.bind(null, row, 3),
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['mes:pd-tech-confirm:update'],
              onClick: handleEdit.bind(null, row),
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pd-tech-confirm:delete'],
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.confirmNo ?? '']),
                confirm: handleDelete.bind(null, row),
              },
            },
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['mes:pd-tech-confirm:query'],
              onClick: handleDetail.bind(null, row),
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/mes/pd/tech-confirm/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,100 @@
<script lang="ts" setup>
  import type { FormType } from '../data';

  import type { MesPdTechConfirmApi } from '#/api/mes/pd/tech-confirm';

  import { computed, ref } from 'vue';

  import { useVbenModal } from '@vben/common-ui';
  import { $t } from '@vben/locales';

  import { message } from 'ant-design-vue';

  import { useVbenForm } from '#/adapter/form';
  import {
    createTechConfirm,
    getTechConfirm,
    updateTechConfirm,
  } from '#/api/mes/pd/tech-confirm';

  import { useFormSchema } from '../data';

  const emit = defineEmits(['success']);
  const formType = ref<FormType>('create'); // è¡¨å•æ¨¡å¼
  const formData = ref<MesPdTechConfirmApi.TechConfirm>();
  const isDetail = computed(() => formType.value === 'detail'); // æ˜¯å¦æŸ¥çœ‹æ¨¡å¼
  const getTitle = computed(() => {
    if (formType.value === 'detail') {
      return '查看技术确认函';
    }
    return formType.value === 'update' ? '修改技术确认函' : '新增技术确认函';
  });

  const [Form, formApi] = useVbenForm({
    commonConfig: {
      componentProps: {
        class: 'w-full',
      },
      formItemClass: 'col-span-1',
      labelWidth: 130,
    },
    wrapperClass: 'grid-cols-3',
    layout: 'horizontal',
    schema: [],
    showDefaultActions: false,
  });

  const [Modal, modalApi] = useVbenModal({
    async onConfirm() {
      if (isDetail.value) {
        await modalApi.close();
        return;
      }
      const { valid } = await formApi.validate();
      if (!valid) {
        return;
      }
      modalApi.lock();
      // æäº¤è¡¨å•
      const data = (await formApi.getValues()) as MesPdTechConfirmApi.TechConfirm;
      try {
        await (data.id ? updateTechConfirm(data) : createTechConfirm(data));
        // å…³é—­å¹¶æç¤º
        await modalApi.close();
        emit('success');
        message.success($t('ui.actionMessage.operationSuccess'));
      } finally {
        modalApi.unlock();
      }
    },
    async onOpenChange(isOpen: boolean) {
      if (!isOpen) {
        formData.value = undefined;
        return;
      }
      // åŠ è½½æ•°æ®
      const data = modalApi.getData<{ formType: FormType; id?: number }>();
      formType.value = data.formType;
      formApi.setState({ schema: useFormSchema(formApi) });
      formApi.setDisabled(formType.value === 'detail');
      modalApi.setState({ showConfirmButton: formType.value !== 'detail' });
      if (!data?.id) {
        return;
      }
      modalApi.lock();
      try {
        formData.value = await getTechConfirm(data.id);
        // è®¾ç½®åˆ° values
        await formApi.setValues(formData.value);
      } finally {
        modalApi.unlock();
      }
    },
  });
</script>

<template>
  <Modal :title="getTitle" class="w-4/5">
    <Form class="mx-4" />
  </Modal>
</template>

 src/views/mes/pro/alternativeplan/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,196 @@
import type { VbenFormApi, VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

import { markRaw } from 'vue';

import { ProProcessSelect } from '#/views/mes/pro/process/components';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'edit';

/** çŠ¶æ€å¸¸é‡ */
export const PLAN_STATUS = {
  DRAFT: 0,
  PUBLISHED: 10,
};

/** è¡¨å•çš„配置项 */
export function useFormSchema(formType: FormType, formApi?: VbenFormApi): VbenFormSchema[] {
  const isReadonly = formType === 'detail';
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'code',
      label: '方案编码',
      component: 'Input',
      componentProps: {
        placeholder: '系统自动生成',
        disabled: true,
      },
    },
    {
      fieldName: 'name',
      label: '方案名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入方案名称',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'mainProcessId',
      label: '主工序',
      component: markRaw(ProProcessSelect),
      componentProps: {
        placeholder: '请选择主工序',
        disabled: isReadonly,
        onChange: (item: { name?: string } | undefined) => {
          formApi?.setFieldValue('mainProcessName', item?.name ?? '');
        },
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'altProcessId',
      label: '替代工序',
      component: markRaw(ProProcessSelect),
      componentProps: {
        placeholder: '请选择替代工序',
        disabled: isReadonly,
        onChange: (item: { name?: string } | undefined) => {
          formApi?.setFieldValue('altProcessName', item?.name ?? '');
        },
      },
    },
    {
      fieldName: 'altCondition',
      label: '替代条件',
      component: 'Input',
      componentProps: {
        placeholder: '如：设备故障/负荷受限/人员不足',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'scope',
      label: '适用范围',
      component: 'Input',
      componentProps: {
        placeholder: '如：110kV çº¿è·¯',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入备注',
        autoSize: { minRows: 1, maxRows: 1 },
        disabled: isReadonly,
      },
      formItemClass: 'col-span-3',
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'code',
      label: '方案编码',
      component: 'Input',
      componentProps: {
        placeholder: '请输入方案编码',
      },
    },
    {
      fieldName: 'name',
      label: '方案名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入方案名称',
      },
    },
    {
      fieldName: 'status',
      label: '状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: [
          { label: '草稿', value: PLAN_STATUS.DRAFT },
          { label: '已发布', value: PLAN_STATUS.PUBLISHED },
        ],
        placeholder: '请选择状态',
      },
    },
  ];
}

/** åˆ—表的表格列 */
export function useGridColumns(): VxeTableGridOptions['columns'] {
  return [
    { type: 'checkbox', width: 50 },
    { type: 'seq', title: '序号', width: 60 },
    {
      field: 'code',
      title: '方案编码',
      minWidth: 150,
      slots: { default: 'code' },
    },
    {
      field: 'name',
      title: '方案名称',
      minWidth: 200,
    },
    {
      field: 'mainProcessName',
      title: '主工序',
      minWidth: 130,
    },
    {
      field: 'altProcessName',
      title: '替代工序',
      minWidth: 130,
    },
    {
      field: 'altCondition',
      title: '替代条件',
      minWidth: 200,
    },
    {
      field: 'scope',
      title: '适用范围',
      minWidth: 140,
    },
    {
      field: 'status',
      title: '状态',
      width: 100,
      slots: { default: 'status' },
    },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      field: 'action',
      title: '操作',
      width: 260,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/mes/pro/alternativeplan/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,188 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { MesProAlternativePlanApi } from '#/api/mes/pro/alternativeplan';

import { ref } from 'vue';

import { Page, useVbenModal } from '@vben/common-ui';
import { isEmpty } from '@vben/utils';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import { deletePlan, getPlanPage, publishPlan } from '#/api/mes/pro/alternativeplan';
import { $t } from '#/locales';

import { PLAN_STATUS, useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';

/** MES ä½œä¸šæ›¿ä»£æ–¹æ¡ˆåˆ—表 */
defineOptions({ name: 'MesProAlternativePlan' });

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

function handleRefresh() {
  gridApi.query();
}

function handleCreate() {
  formModalApi.setData({ formType: 'create' }).open();
}

function handleEdit(row: MesProAlternativePlanApi.AlternativePlan) {
  formModalApi.setData({ formType: 'edit', id: row.id }).open();
}

function handleDetail(row: MesProAlternativePlanApi.AlternativePlan) {
  formModalApi.setData({ formType: 'detail', id: row.id }).open();
}

async function handleDelete(ids: number[]) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting'),
    duration: 0,
  });
  try {
    await deletePlan(ids);
    message.success($t('ui.actionMessage.deleteSuccess'));
    handleRefresh();
  } finally {
    hideLoading();
  }
}

async function handlePublish(row: MesProAlternativePlanApi.AlternativePlan) {
  await publishPlan(row.id!);
  message.success('已发布');
  handleRefresh();
}

const checkedIds = ref<number[]>([]);
function handleRowCheckboxChange({
  records,
}: {
  records: MesProAlternativePlanApi.AlternativePlan[];
}) {
  checkedIds.value = records.map((item) => item.id!);
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) => {
          return await getPlanPage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          });
        },
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<MesProAlternativePlanApi.AlternativePlan>,
  gridEvents: {
    checkboxAll: handleRowCheckboxChange,
    checkboxChange: handleRowCheckboxChange,
  },
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="作业替代方案列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['作业替代方案']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['mes:pro-alternative-plan:create'],
              onClick: handleCreate,
            },
            {
              label: '批量删除',
              type: 'primary',
              danger: true,
              disabled: isEmpty(checkedIds),
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pro-alternative-plan:delete'],
              popConfirm: {
                title: `是否删除所选中数据？`,
                confirm: handleDelete.bind(null, checkedIds),
              },
            },
          ]"
        />
      </template>
      <template #code="{ row }">
        <a class="link" @click="handleDetail(row)">{{ row.code }}</a>
      </template>
      <template #status="{ row }">
        <Tag v-if="row.status === PLAN_STATUS.DRAFT" color="default">草稿</Tag>
        <Tag v-else-if="row.status === PLAN_STATUS.PUBLISHED" color="success">已发布</Tag>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['mes:pro-alternative-plan:query'],
              onClick: handleDetail.bind(null, row),
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['mes:pro-alternative-plan:update'],
              ifShow: row.status === PLAN_STATUS.DRAFT,
              onClick: handleEdit.bind(null, row),
            },
            {
              label: '发布',
              type: 'link',
              auth: ['mes:pro-alternative-plan:update'],
              ifShow: row.status === PLAN_STATUS.DRAFT,
              popConfirm: {
                title: '确认发布该方案？',
                confirm: handlePublish.bind(null, row),
              },
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pro-alternative-plan:delete'],
              ifShow: row.status === PLAN_STATUS.DRAFT,
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.code]),
                confirm: handleDelete.bind(null, [row.id!]),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/mes/pro/alternativeplan/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,91 @@
<script lang="ts" setup>
import type { MesProAlternativePlanApi } from '#/api/mes/pro/alternativeplan';

import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import { createPlan, getPlan, updatePlan } from '#/api/mes/pro/alternativeplan';
import { $t } from '#/locales';

import type { FormType } from '../data';
import { useFormSchema } from '../data';

const emit = defineEmits(['success']);
const formData = ref<MesProAlternativePlanApi.AlternativePlan>();
const formType = ref<FormType>('create');

const getTitle = computed(() => {
  if (formType.value === 'create') {
    return $t('ui.actionTitle.create', ['作业替代方案']);
  } else if (formType.value === 'edit') {
    return $t('ui.actionTitle.edit', ['作业替代方案']);
  } else {
    return '作业替代方案详情';
  }
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 120,
  },
  wrapperClass: 'grid-cols-3',
  layout: 'vertical',
  schema: [],
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data =
      (await formApi.getValues()) as MesProAlternativePlanApi.AlternativePlan;
    try {
      await (formType.value === 'create'
        ? createPlan(data)
        : updatePlan(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    const data = modalApi.getData<{ formType: FormType; id?: number }>();
    formType.value = data.formType;
    formApi.setDisabled(formType.value === 'detail');
    formApi.updateSchema(useFormSchema(formType.value, formApi));
    if (!data || !data.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getPlan(data.id);
      await formApi.setValues(formData.value);
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal :title="getTitle" class="w-2/3" :show-confirm-button="formType !== 'detail'">
    <Form class="mx-3" />
  </Modal>
</template>

 src/views/mes/pro/emergencyplan/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,187 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'edit';

/** çŠ¶æ€å¸¸é‡ */
export const PLAN_STATUS = {
  DRAFT: 0,
  PUBLISHED: 10,
};

/** è¡¨å•çš„配置项 */
export function useFormSchema(formType: FormType): VbenFormSchema[] {
  const isReadonly = formType === 'detail';
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'code',
      label: '预案编码',
      component: 'Input',
      componentProps: {
        placeholder: '系统自动生成',
        disabled: true,
      },
    },
    {
      fieldName: 'name',
      label: '预案名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入预案名称',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'planType',
      label: '预案类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.MES_PRO_EMERGENCY_PLAN_TYPE, 'number'),
        placeholder: '请选择预案类型',
        disabled: isReadonly,
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'orgUnit',
      label: '责任单位',
      component: 'Input',
      componentProps: {
        placeholder: '请输入责任单位/部门',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'content',
      label: '处置内容',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入应急处置内容',
        rows: 4,
        disabled: isReadonly,
      },
      formItemClass: 'col-span-3',
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入备注',
        autoSize: { minRows: 1, maxRows: 1 },
        disabled: isReadonly,
      },
      formItemClass: 'col-span-3',
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'code',
      label: '预案编码',
      component: 'Input',
      componentProps: {
        placeholder: '请输入预案编码',
      },
    },
    {
      fieldName: 'name',
      label: '预案名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入预案名称',
      },
    },
    {
      fieldName: 'planType',
      label: '预案类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PRO_EMERGENCY_PLAN_TYPE, 'number'),
        placeholder: '请选择预案类型',
      },
    },
    {
      fieldName: 'status',
      label: '状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: [
          { label: '草稿', value: PLAN_STATUS.DRAFT },
          { label: '已发布', value: PLAN_STATUS.PUBLISHED },
        ],
        placeholder: '请选择状态',
      },
    },
  ];
}

/** åˆ—表的表格列 */
export function useGridColumns(): VxeTableGridOptions['columns'] {
  return [
    { type: 'checkbox', width: 50 },
    { type: 'seq', title: '序号', width: 60 },
    {
      field: 'code',
      title: '预案编码',
      minWidth: 150,
      slots: { default: 'code' },
    },
    {
      field: 'name',
      title: '预案名称',
      minWidth: 200,
    },
    {
      field: 'planType',
      title: '预案类型',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_PRO_EMERGENCY_PLAN_TYPE },
      },
    },
    {
      field: 'orgUnit',
      title: '责任单位',
      minWidth: 140,
    },
    {
      field: 'status',
      title: '状态',
      width: 100,
      slots: { default: 'status' },
    },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      field: 'action',
      title: '操作',
      width: 260,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/mes/pro/emergencyplan/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,188 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { MesProEmergencyPlanApi } from '#/api/mes/pro/emergencyplan';

import { ref } from 'vue';

import { Page, useVbenModal } from '@vben/common-ui';
import { isEmpty } from '@vben/utils';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import { deletePlan, getPlanPage, publishPlan } from '#/api/mes/pro/emergencyplan';
import { $t } from '#/locales';

import { PLAN_STATUS, useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';

/** MES åº”急处置预案列表 */
defineOptions({ name: 'MesProEmergencyPlan' });

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

function handleRefresh() {
  gridApi.query();
}

function handleCreate() {
  formModalApi.setData({ formType: 'create' }).open();
}

function handleEdit(row: MesProEmergencyPlanApi.EmergencyPlan) {
  formModalApi.setData({ formType: 'edit', id: row.id }).open();
}

function handleDetail(row: MesProEmergencyPlanApi.EmergencyPlan) {
  formModalApi.setData({ formType: 'detail', id: row.id }).open();
}

async function handleDelete(ids: number[]) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting'),
    duration: 0,
  });
  try {
    await deletePlan(ids);
    message.success($t('ui.actionMessage.deleteSuccess'));
    handleRefresh();
  } finally {
    hideLoading();
  }
}

async function handlePublish(row: MesProEmergencyPlanApi.EmergencyPlan) {
  await publishPlan(row.id!);
  message.success('已发布');
  handleRefresh();
}

const checkedIds = ref<number[]>([]);
function handleRowCheckboxChange({
  records,
}: {
  records: MesProEmergencyPlanApi.EmergencyPlan[];
}) {
  checkedIds.value = records.map((item) => item.id!);
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) => {
          return await getPlanPage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          });
        },
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<MesProEmergencyPlanApi.EmergencyPlan>,
  gridEvents: {
    checkboxAll: handleRowCheckboxChange,
    checkboxChange: handleRowCheckboxChange,
  },
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="应急处置预案列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['应急处置预案']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['mes:pro-emergency-plan:create'],
              onClick: handleCreate,
            },
            {
              label: '批量删除',
              type: 'primary',
              danger: true,
              disabled: isEmpty(checkedIds),
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pro-emergency-plan:delete'],
              popConfirm: {
                title: `是否删除所选中数据？`,
                confirm: handleDelete.bind(null, checkedIds),
              },
            },
          ]"
        />
      </template>
      <template #code="{ row }">
        <a class="link" @click="handleDetail(row)">{{ row.code }}</a>
      </template>
      <template #status="{ row }">
        <Tag v-if="row.status === PLAN_STATUS.DRAFT" color="default">草稿</Tag>
        <Tag v-else-if="row.status === PLAN_STATUS.PUBLISHED" color="success">已发布</Tag>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['mes:pro-emergency-plan:query'],
              onClick: handleDetail.bind(null, row),
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['mes:pro-emergency-plan:update'],
              ifShow: row.status === PLAN_STATUS.DRAFT,
              onClick: handleEdit.bind(null, row),
            },
            {
              label: '发布',
              type: 'link',
              auth: ['mes:pro-emergency-plan:update'],
              ifShow: row.status === PLAN_STATUS.DRAFT,
              popConfirm: {
                title: '确认发布该预案？',
                confirm: handlePublish.bind(null, row),
              },
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pro-emergency-plan:delete'],
              ifShow: row.status === PLAN_STATUS.DRAFT,
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.code]),
                confirm: handleDelete.bind(null, [row.id!]),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/mes/pro/emergencyplan/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,91 @@
<script lang="ts" setup>
import type { MesProEmergencyPlanApi } from '#/api/mes/pro/emergencyplan';

import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import { createPlan, getPlan, updatePlan } from '#/api/mes/pro/emergencyplan';
import { $t } from '#/locales';

import type { FormType } from '../data';
import { useFormSchema } from '../data';

const emit = defineEmits(['success']);
const formData = ref<MesProEmergencyPlanApi.EmergencyPlan>();
const formType = ref<FormType>('create');

const getTitle = computed(() => {
  if (formType.value === 'create') {
    return $t('ui.actionTitle.create', ['应急处置预案']);
  } else if (formType.value === 'edit') {
    return $t('ui.actionTitle.edit', ['应急处置预案']);
  } else {
    return '应急处置预案详情';
  }
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 120,
  },
  wrapperClass: 'grid-cols-3',
  layout: 'vertical',
  schema: useFormSchema(formType.value),
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data =
      (await formApi.getValues()) as MesProEmergencyPlanApi.EmergencyPlan;
    try {
      await (formType.value === 'create'
        ? createPlan(data)
        : updatePlan(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    const data = modalApi.getData<{ formType: FormType; id?: number }>();
    formType.value = data.formType;
    formApi.setDisabled(formType.value === 'detail');
    formApi.updateSchema(useFormSchema(formType.value));
    if (!data || !data.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getPlan(data.id);
      await formApi.setValues(formData.value);
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal :title="getTitle" class="w-2/3" :show-confirm-button="formType !== 'detail'">
    <Form class="mx-3" />
  </Modal>
</template>

 src/views/mes/pro/maintenance-plan/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,244 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import { getRangePickerDefaultProps } from '#/utils';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'edit';

/** è®¡åˆ’状态常量 */
export const PLAN_STATUS = {
  DRAFT: 0,
  ISSUED: 10,
  FINISHED: 20,
  CANCELLED: 30,
};

/** è¡¨å•çš„配置项 */
export function useFormSchema(formType: FormType): VbenFormSchema[] {
  const isReadonly = formType === 'detail';
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'code',
      label: '计划编码',
      component: 'Input',
      componentProps: {
        placeholder: '系统自动生成',
        disabled: true,
      },
    },
    {
      fieldName: 'name',
      label: '计划名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入计划名称',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'planType',
      label: '计划类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.MES_PRO_MAINTENANCE_PLAN_TYPE, 'number'),
        placeholder: '请选择计划类型',
        disabled: isReadonly,
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'station',
      label: '站点',
      component: 'Input',
      componentProps: {
        placeholder: '请输入站点',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'line',
      label: '线路',
      component: 'Input',
      componentProps: {
        placeholder: '请输入线路',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'planDate',
      label: '计划日期',
      component: 'DatePicker',
      componentProps: {
        placeholder: '选择计划日期',
        showTime: true,
        format: 'YYYY-MM-DD HH:mm:ss',
        valueFormat: 'YYYY-MM-DD HH:mm:ss',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'teamId',
      label: '班组',
      component: 'Input',
      componentProps: {
        disabled: true,
        placeholder: '由计划执行分配',
      },
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入备注',
        autoSize: { minRows: 1, maxRows: 1 },
        disabled: isReadonly,
      },
      formItemClass: 'col-span-2',
    },
    {
      fieldName: 'items',
      label: '备件/物资需求',
      component: 'Input',
      formItemClass: 'col-span-3',
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'code',
      label: '计划编码',
      component: 'Input',
      componentProps: {
        placeholder: '请输入计划编码',
      },
    },
    {
      fieldName: 'name',
      label: '计划名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入计划名称',
      },
    },
    {
      fieldName: 'planType',
      label: '计划类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PRO_MAINTENANCE_PLAN_TYPE, 'number'),
        placeholder: '请选择计划类型',
      },
    },
    {
      fieldName: 'status',
      label: '状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: [
          { label: '草稿', value: PLAN_STATUS.DRAFT },
          { label: '已下发', value: PLAN_STATUS.ISSUED },
          { label: '已完成', value: PLAN_STATUS.FINISHED },
          { label: '已取消', value: PLAN_STATUS.CANCELLED },
        ],
        placeholder: '请选择状态',
      },
    },
    {
      fieldName: 'planDate',
      label: '计划日期',
      component: 'RangePicker',
      componentProps: getRangePickerDefaultProps(),
    },
  ];
}

/** åˆ—表的表格列 */
export function useGridColumns(): VxeTableGridOptions['columns'] {
  return [
    { type: 'checkbox', width: 50 },
    { type: 'seq', title: '序号', width: 60 },
    {
      field: 'code',
      title: '计划编码',
      minWidth: 150,
      slots: { default: 'code' },
    },
    {
      field: 'name',
      title: '计划名称',
      minWidth: 180,
    },
    {
      field: 'planType',
      title: '计划类型',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_PRO_MAINTENANCE_PLAN_TYPE },
      },
    },
    {
      field: 'station',
      title: '站点',
      minWidth: 140,
    },
    {
      field: 'line',
      title: '线路',
      minWidth: 140,
    },
    {
      field: 'teamName',
      title: '班组',
      width: 110,
    },
    {
      field: 'planDate',
      title: '计划日期',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      field: 'status',
      title: '状态',
      width: 100,
      slots: { default: 'status' },
    },
    {
      field: 'workOrderCode',
      title: '生成的工单',
      minWidth: 150,
    },
    {
      field: 'action',
      title: '操作',
      width: 300,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/mes/pro/maintenance-plan/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,271 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { MesProMaintenancePlanApi } from '#/api/mes/pro/maintenance-plan';

import { ref } from 'vue';

import { Page, useVbenModal } from '@vben/common-ui';
import { downloadFileFromBlobPart, isEmpty } from '@vben/utils';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import {
  deletePlan,
  exportPlan,
  finishPlan,
  generatePurchasePlan,
  generateWorkOrder,
  getPlanPage,
  issuePlan,
} from '#/api/mes/pro/maintenance-plan';
import { $t } from '#/locales';

import { PLAN_STATUS, useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';

/** MES ç”µåŠ›ä½œä¸šè®¡åˆ’列表 */
defineOptions({ name: 'MesProMaintenancePlan' });

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

function handleRefresh() {
  gridApi.query();
}

async function handleExport() {
  const data = await exportPlan(await gridApi.formApi.getValues());
  downloadFileFromBlobPart({ fileName: '电力作业计划.xls', source: data });
}

function handleCreate() {
  formModalApi.setData({ formType: 'create' }).open();
}

function handleEdit(row: MesProMaintenancePlanApi.MaintenancePlan) {
  formModalApi.setData({ formType: 'edit', id: row.id }).open();
}

function handleDetail(row: MesProMaintenancePlanApi.MaintenancePlan) {
  formModalApi.setData({ formType: 'detail', id: row.id }).open();
}

async function handleDelete(ids: number[]) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting'),
    duration: 0,
  });
  try {
    await deletePlan(ids);
    message.success($t('ui.actionMessage.deleteSuccess'));
    handleRefresh();
  } finally {
    hideLoading();
  }
}

async function handleIssue(row: MesProMaintenancePlanApi.MaintenancePlan) {
  await issuePlan(row.id!);
  message.success('已下发');
  handleRefresh();
}

async function handleFinish(row: MesProMaintenancePlanApi.MaintenancePlan) {
  await finishPlan(row.id!);
  message.success('已完成');
  handleRefresh();
}

async function handleGeneratePurchasePlan(
  row: MesProMaintenancePlanApi.MaintenancePlan,
) {
  const hideLoading = message.loading({
    content: '正在根据备件需求生成采购计划...',
    duration: 0,
  });
  try {
    const planId = await generatePurchasePlan(row.id!);
    message.success(`已生成采购计划（编号 ${planId}），请在采购管理中核对提交审批`);
  } finally {
    hideLoading();
  }
}

async function handleGenerateWorkOrder(
  row: MesProMaintenancePlanApi.MaintenancePlan,
) {
  const hideLoading = message.loading({
    content: '正在生成工单...',
    duration: 0,
  });
  try {
    const workOrderId = await generateWorkOrder(row.id!);
    message.success(`已生成工单（编号 ${workOrderId}），可在生产订单中查看`);
    handleRefresh();
  } finally {
    hideLoading();
  }
}

const checkedIds = ref<number[]>([]);
function handleRowCheckboxChange({
  records,
}: {
  records: MesProMaintenancePlanApi.MaintenancePlan[];
}) {
  checkedIds.value = records.map((item) => item.id!);
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) => {
          return await getPlanPage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          });
        },
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<MesProMaintenancePlanApi.MaintenancePlan>,
  gridEvents: {
    checkboxAll: handleRowCheckboxChange,
    checkboxChange: handleRowCheckboxChange,
  },
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="电力作业计划列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['电力作业计划']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['mes:pro-maintenance-plan:create'],
              onClick: handleCreate,
            },
            {
              label: $t('ui.actionTitle.export'),
              type: 'primary',
              icon: ACTION_ICON.DOWNLOAD,
              auth: ['mes:pro-maintenance-plan:export'],
              onClick: handleExport,
            },
            {
              label: '批量删除',
              type: 'primary',
              danger: true,
              disabled: isEmpty(checkedIds),
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pro-maintenance-plan:delete'],
              popConfirm: {
                title: `是否删除所选中数据？`,
                confirm: handleDelete.bind(null, checkedIds),
              },
            },
          ]"
        />
      </template>
      <template #code="{ row }">
        <a class="link" @click="handleDetail(row)">{{ row.code }}</a>
      </template>
      <template #status="{ row }">
        <Tag v-if="row.status === PLAN_STATUS.DRAFT" color="default">草稿</Tag>
        <Tag v-else-if="row.status === PLAN_STATUS.ISSUED" color="processing">已下发</Tag>
        <Tag v-else-if="row.status === PLAN_STATUS.FINISHED" color="success">已完成</Tag>
        <Tag v-else-if="row.status === PLAN_STATUS.CANCELLED" color="warning">已取消</Tag>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['mes:pro-maintenance-plan:query'],
              onClick: handleDetail.bind(null, row),
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['mes:pro-maintenance-plan:update'],
              ifShow: row.status === PLAN_STATUS.DRAFT,
              onClick: handleEdit.bind(null, row),
            },
            {
              label: '下发',
              type: 'link',
              auth: ['mes:pro-maintenance-plan:update'],
              ifShow: row.status === PLAN_STATUS.DRAFT,
              popConfirm: {
                title: '确认下发该计划？',
                confirm: handleIssue.bind(null, row),
              },
            },
            {
              label: '生成采购计划',
              type: 'link',
              auth: ['mes:pro-maintenance-plan:generate-purchase-plan'],
              ifShow: row.status === PLAN_STATUS.ISSUED,
              onClick: handleGeneratePurchasePlan.bind(null, row),
            },
            {
              label: '生成工单',
              type: 'link',
              auth: ['mes:pro-maintenance-plan:generate-work-order'],
              ifShow: row.status === PLAN_STATUS.ISSUED && !row.workOrderId,
              onClick: handleGenerateWorkOrder.bind(null, row),
            },
            {
              label: '完成',
              type: 'link',
              auth: ['mes:pro-maintenance-plan:update'],
              ifShow: row.status === PLAN_STATUS.ISSUED,
              popConfirm: {
                title: '确认完成该计划？',
                confirm: handleFinish.bind(null, row),
              },
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pro-maintenance-plan:delete'],
              ifShow: row.status === PLAN_STATUS.DRAFT,
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.code]),
                confirm: handleDelete.bind(null, [row.id!]),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/mes/pro/maintenance-plan/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,220 @@
<script lang="ts" setup>
import type { MesProMaintenancePlanApi } from '#/api/mes/pro/maintenance-plan';

import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { Button, DatePicker, Input, InputNumber, message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import {
  createPlan,
  getPlan,
  updatePlan,
} from '#/api/mes/pro/maintenance-plan';
import { MdItemSelect } from '#/views/mes/md/item/components';
import { $t } from '#/locales';

import type { FormType } from '../data';
import { useFormSchema } from '../data';

const emit = defineEmits(['success']);
const formData = ref<MesProMaintenancePlanApi.MaintenancePlan>();
const formType = ref<FormType>('create');
const items = ref<MesProMaintenancePlanApi.PlanItem[]>([]);

const getTitle = computed(() => {
  if (formType.value === 'create') {
    return $t('ui.actionTitle.create', ['电力作业计划']);
  } else if (formType.value === 'edit') {
    return $t('ui.actionTitle.edit', ['电力作业计划']);
  } else {
    return '电力作业计划详情';
  }
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 120,
  },
  wrapperClass: 'grid-cols-3',
  layout: 'vertical',
  schema: useFormSchema(formType.value),
  showDefaultActions: false,
});

function handleAddItem() {
  items.value.push({
    itemId: undefined as unknown as number,
    itemName: '',
    itemCode: '',
    unitMeasureName: '',
    quantity: 1,
    remark: '',
  });
}

function handleRemoveItem(index: number) {
  items.value.splice(index, 1);
}

function handleItemSelect(index: number, item: any) {
  const row = items.value[index];
  if (!row) {
    return;
  }
  row.itemId = item?.id;
  row.itemName = item?.name;
  row.itemCode = item?.code;
  row.unitMeasureName = item?.unitMeasureName;
}

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    if (!items.value.length) {
      message.error('请至少添加一条备件/物资需求');
      return;
    }
    if (items.value.some((item) => !item.itemId || !item.quantity)) {
      message.error('请完善备件需求的产品与数量');
      return;
    }
    modalApi.lock();
    const data =
      (await formApi.getValues()) as MesProMaintenancePlanApi.MaintenancePlan;
    data.items = items.value.map((item) => ({
      itemId: item.itemId,
      quantity: item.quantity,
      remark: item.remark,
    }));
    try {
      await (formType.value === 'create'
        ? createPlan(data)
        : updatePlan(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      items.value = [];
      return;
    }
    const data = modalApi.getData<{ formType: FormType; id?: number }>();
    formType.value = data.formType;
    formApi.setDisabled(formType.value === 'detail');
    formApi.updateSchema(useFormSchema(formType.value));
    if (!data || !data.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getPlan(data.id);
      await formApi.setValues(formData.value);
      items.value = (formData.value.items ?? []).map((item) => ({ ...item }));
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal
    :title="getTitle"
    class="w-3/4"
    :show-confirm-button="formType !== 'detail'"
  >
    <Form class="mx-3">
      <template #items>
        <div class="mt-2">
          <div v-if="formType !== 'detail'" class="mb-2">
            <Button type="dashed" @click="handleAddItem">+ æ·»åŠ å¤‡ä»¶éœ€æ±‚</Button>
          </div>
          <table class="w-full border-collapse border border-gray-200 text-sm">
            <thead>
              <tr class="bg-gray-100">
                <th class="border border-gray-200 px-2 py-1 w-12">序号</th>
                <th class="border border-gray-200 px-2 py-1">物料/备件</th>
                <th class="border border-gray-200 px-2 py-1 w-20">单位</th>
                <th class="border border-gray-200 px-2 py-1 w-32">需求数量</th>
                <th class="border border-gray-200 px-2 py-1">备注</th>
                <th
                  v-if="formType !== 'detail'"
                  class="border border-gray-200 px-2 py-1 w-16"
                >
                  æ“ä½œ
                </th>
              </tr>
            </thead>
            <tbody>
              <tr v-for="(item, index) in items" :key="index">
                <td class="border border-gray-200 px-2 py-1 text-center">
                  {{ index + 1 }}
                </td>
                <td class="border border-gray-200 px-2 py-1">
                  <MdItemSelect
                    v-if="formType !== 'detail'"
                    :model-value="item.itemId"
                    placeholder="请选择物料/备件"
                    @change="handleItemSelect(index, $event)"
                  />
                  <span v-else>{{ item.itemName }}</span>
                </td>
                <td class="border border-gray-200 px-2 py-1 text-center">
                  {{ item.unitMeasureName || '-' }}
                </td>
                <td class="border border-gray-200 px-2 py-1">
                  <InputNumber
                    v-if="formType !== 'detail'"
                    v-model:value="item.quantity"
                    class="!w-full"
                    :min="0.01"
                    :precision="2"
                  />
                  <span v-else>{{ item.quantity }}</span>
                </td>
                <td class="border border-gray-200 px-2 py-1">
                  <Input
                    v-if="formType !== 'detail'"
                    v-model:value="item.remark"
                    placeholder="备注"
                  />
                  <span v-else>{{ item.remark || '-' }}</span>
                </td>
                <td
                  v-if="formType !== 'detail'"
                  class="border border-gray-200 px-2 py-1 text-center"
                >
                  <Button type="link" danger @click="handleRemoveItem(index)">
                    åˆ é™¤
                  </Button>
                </td>
              </tr>
              <tr v-if="!items.length">
                <td
                  :colspan="formType === 'detail' ? 5 : 6"
                  class="border border-gray-200 px-2 py-4 text-center text-gray-400"
                >
                  æš‚无备件需求，请添加
                </td>
              </tr>
            </tbody>
          </table>
        </div>
      </template>
    </Form>
  </Modal>
</template>

 src/views/mes/pro/maintenancecalendar/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,246 @@
import type { VbenFormApi, VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

import { markRaw } from 'vue';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import { CalTeamSelect } from '#/views/mes/cal/team/components';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'edit';

/** çŠ¶æ€å¸¸é‡ */
export const CAL_STATUS = {
  DRAFT: 0,
  PUBLISHED: 10,
};

/** è¡¨å•çš„配置项 */
export function useFormSchema(formType: FormType, formApi?: VbenFormApi): VbenFormSchema[] {
  const isReadonly = formType === 'detail';
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'code',
      label: '日历编码',
      component: 'Input',
      componentProps: {
        placeholder: '系统自动生成',
        disabled: true,
      },
    },
    {
      fieldName: 'name',
      label: '日历名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入日历名称',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'workDate',
      label: '作业日期',
      component: 'DatePicker',
      componentProps: {
        placeholder: '请选择作业日期',
        valueFormat: 'YYYY-MM-DD',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'shift',
      label: '班次',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.MES_CAL_SHIFT_TYPE, 'number'),
        placeholder: '请选择班次',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'workType',
      label: '作业类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.MES_PRO_CALENDAR_WORK_TYPE, 'number'),
        placeholder: '请选择作业类型',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'region',
      label: '作业区域/线路',
      component: 'Input',
      componentProps: {
        placeholder: '如：110kV åŸŽåŒºçº¿',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'teamId',
      label: '值班班组',
      component: markRaw(CalTeamSelect),
      componentProps: {
        placeholder: '请选择值班班组',
        disabled: isReadonly,
        onChange: (item: { name?: string } | undefined) => {
          formApi?.setFieldValue('teamName', item?.name ?? '');
        },
      },
    },
    {
      fieldName: 'personnel',
      label: '值班人员',
      component: 'Input',
      componentProps: {
        placeholder: '如：张三,李四',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入备注',
        autoSize: { minRows: 1, maxRows: 1 },
        disabled: isReadonly,
      },
      formItemClass: 'col-span-3',
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'code',
      label: '日历编码',
      component: 'Input',
      componentProps: {
        placeholder: '请输入日历编码',
      },
    },
    {
      fieldName: 'name',
      label: '日历名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入日历名称',
      },
    },
    {
      fieldName: 'workType',
      label: '作业类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PRO_CALENDAR_WORK_TYPE, 'number'),
        placeholder: '请选择作业类型',
      },
    },
    {
      fieldName: 'status',
      label: '状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: [
          { label: '草稿', value: CAL_STATUS.DRAFT },
          { label: '已发布', value: CAL_STATUS.PUBLISHED },
        ],
        placeholder: '请选择状态',
      },
    },
  ];
}

/** åˆ—表的表格列 */
export function useGridColumns(): VxeTableGridOptions['columns'] {
  return [
    { type: 'checkbox', width: 50 },
    { type: 'seq', title: '序号', width: 60 },
    {
      field: 'code',
      title: '日历编码',
      minWidth: 150,
      slots: { default: 'code' },
    },
    {
      field: 'name',
      title: '日历名称',
      minWidth: 180,
    },
    {
      field: 'workDate',
      title: '作业日期',
      width: 120,
      formatter: 'formatDate',
    },
    {
      field: 'shift',
      title: '班次',
      width: 100,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_CAL_SHIFT_TYPE },
      },
    },
    {
      field: 'workType',
      title: '作业类型',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_PRO_CALENDAR_WORK_TYPE },
      },
    },
    {
      field: 'region',
      title: '作业区域/线路',
      minWidth: 140,
    },
    {
      field: 'teamName',
      title: '值班班组',
      minWidth: 130,
    },
    {
      field: 'personnel',
      title: '值班人员',
      minWidth: 140,
    },
    {
      field: 'status',
      title: '状态',
      width: 100,
      slots: { default: 'status' },
    },
    {
      field: 'createTime',
      title: '创建时间',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      field: 'action',
      title: '操作',
      width: 260,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/mes/pro/maintenancecalendar/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,192 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { MesProMaintenanceCalendarApi } from '#/api/mes/pro/maintenancecalendar';

import { ref } from 'vue';

import { Page, useVbenModal } from '@vben/common-ui';
import { isEmpty } from '@vben/utils';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import {
  deleteCalendar,
  getCalendarPage,
  publishCalendar,
} from '#/api/mes/pro/maintenancecalendar';
import { $t } from '#/locales';

import { CAL_STATUS, useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';

/** MES ç”µåŠ›è¿ç»´æ—¥åŽ†åˆ—表 */
defineOptions({ name: 'MesProMaintenanceCalendar' });

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

function handleRefresh() {
  gridApi.query();
}

function handleCreate() {
  formModalApi.setData({ formType: 'create' }).open();
}

function handleEdit(row: MesProMaintenanceCalendarApi.MaintenanceCalendar) {
  formModalApi.setData({ formType: 'edit', id: row.id }).open();
}

function handleDetail(row: MesProMaintenanceCalendarApi.MaintenanceCalendar) {
  formModalApi.setData({ formType: 'detail', id: row.id }).open();
}

async function handleDelete(ids: number[]) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting'),
    duration: 0,
  });
  try {
    await deleteCalendar(ids);
    message.success($t('ui.actionMessage.deleteSuccess'));
    handleRefresh();
  } finally {
    hideLoading();
  }
}

async function handlePublish(row: MesProMaintenanceCalendarApi.MaintenanceCalendar) {
  await publishCalendar(row.id!);
  message.success('已发布');
  handleRefresh();
}

const checkedIds = ref<number[]>([]);
function handleRowCheckboxChange({
  records,
}: {
  records: MesProMaintenanceCalendarApi.MaintenanceCalendar[];
}) {
  checkedIds.value = records.map((item) => item.id!);
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) => {
          return await getCalendarPage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          });
        },
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<MesProMaintenanceCalendarApi.MaintenanceCalendar>,
  gridEvents: {
    checkboxAll: handleRowCheckboxChange,
    checkboxChange: handleRowCheckboxChange,
  },
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="电力运维日历列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['电力运维日历']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['mes:pro-maintenance-calendar:create'],
              onClick: handleCreate,
            },
            {
              label: '批量删除',
              type: 'primary',
              danger: true,
              disabled: isEmpty(checkedIds),
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pro-maintenance-calendar:delete'],
              popConfirm: {
                title: `是否删除所选中数据？`,
                confirm: handleDelete.bind(null, checkedIds),
              },
            },
          ]"
        />
      </template>
      <template #code="{ row }">
        <a class="link" @click="handleDetail(row)">{{ row.code }}</a>
      </template>
      <template #status="{ row }">
        <Tag v-if="row.status === CAL_STATUS.DRAFT" color="default">草稿</Tag>
        <Tag v-else-if="row.status === CAL_STATUS.PUBLISHED" color="success">已发布</Tag>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['mes:pro-maintenance-calendar:query'],
              onClick: handleDetail.bind(null, row),
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['mes:pro-maintenance-calendar:update'],
              ifShow: row.status === CAL_STATUS.DRAFT,
              onClick: handleEdit.bind(null, row),
            },
            {
              label: '发布',
              type: 'link',
              auth: ['mes:pro-maintenance-calendar:update'],
              ifShow: row.status === CAL_STATUS.DRAFT,
              popConfirm: {
                title: '确认发布该日历？',
                confirm: handlePublish.bind(null, row),
              },
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['mes:pro-maintenance-calendar:delete'],
              ifShow: row.status === CAL_STATUS.DRAFT,
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.code]),
                confirm: handleDelete.bind(null, [row.id!]),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/mes/pro/maintenancecalendar/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,95 @@
<script lang="ts" setup>
import type { MesProMaintenanceCalendarApi } from '#/api/mes/pro/maintenancecalendar';

import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import {
  createCalendar,
  getCalendar,
  updateCalendar,
} from '#/api/mes/pro/maintenancecalendar';
import { $t } from '#/locales';

import type { FormType } from '../data';
import { useFormSchema } from '../data';

const emit = defineEmits(['success']);
const formData = ref<MesProMaintenanceCalendarApi.MaintenanceCalendar>();
const formType = ref<FormType>('create');

const getTitle = computed(() => {
  if (formType.value === 'create') {
    return $t('ui.actionTitle.create', ['电力运维日历']);
  } else if (formType.value === 'edit') {
    return $t('ui.actionTitle.edit', ['电力运维日历']);
  } else {
    return '电力运维日历详情';
  }
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 120,
  },
  wrapperClass: 'grid-cols-3',
  layout: 'vertical',
  schema: [],
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data =
      (await formApi.getValues()) as MesProMaintenanceCalendarApi.MaintenanceCalendar;
    try {
      await (formType.value === 'create'
        ? createCalendar(data)
        : updateCalendar(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    const data = modalApi.getData<{ formType: FormType; id?: number }>();
    formType.value = data.formType;
    formApi.setDisabled(formType.value === 'detail');
    formApi.updateSchema(useFormSchema(formType.value, formApi));
    if (!data || !data.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getCalendar(data.id);
      await formApi.setValues(formData.value);
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal :title="getTitle" class="w-2/3" :show-confirm-button="formType !== 'detail'">
    <Form class="mx-3" />
  </Modal>
</template>

 src/views/mes/pro/task/data.ts

@@ -19,6 +19,7 @@
import { getRangePickerDefaultProps } from '#/utils';
import { MdItemSelect } from '#/views/mes/md/item/components';
import { MdWorkstationSelect } from '#/views/mes/md/workstation/components';
import { CalTeamSelect } from '#/views/mes/cal/team/components';
import { ProProcessSelect } from '#/views/mes/process-design/process/components';
import { RouteColorPicker } from '#/views/mes/process-design/route/components';
import { ProWorkOrderSelect } from '#/views/mes/pro/workorder/components';
@@ -347,6 +348,11 @@
      width: 120,
    },
    {
      field: 'teamName',
      title: '班组',
      width: 120,
    },
    {
      field: 'quantity',
      title: '排产数量',
      width: 100,
@@ -406,6 +412,14 @@
      rules: 'selectRequired',
    },
    {
      fieldName: 'teamId',
      label: '班组',
      component: markRaw(CalTeamSelect),
      componentProps: {
        placeholder: '请选择班组',
      },
    },
    {
      fieldName: 'quantity',
      label: '排产数量',
      component: 'InputNumber',

 src/views/mes/pro/workorder/data.ts

@@ -3,6 +3,7 @@
import type { MesProWorkOrderApi } from '#/api/mes/pro/workorder';
import type { MesProWorkOrderBomApi } from '#/api/mes/pro/workorder/bom';
import type { MesProWorkOrderProcessApi } from '#/api/mes/pro/workorder/process';
import type { ErpSaleOrderApi } from '#/api/erp/sale/order';

import { h, markRaw } from 'vue';

@@ -23,6 +24,7 @@
  MdItemSelect,
} from '#/views/mes/md/item/components';
import { MdVendorSelect } from '#/views/mes/md/vendor/components';
import { ErpSaleOrderSelect } from '#/views/erp/sale/order/components';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'confirm' | 'create' | 'detail' | 'finish' | 'update';
@@ -192,6 +194,30 @@
      componentProps: {
        disabled: headerReadonly,
        placeholder: '请选择客户',
      },
      dependencies: {
        triggerFields: ['orderSourceType'],
        show: (values) =>
          values.orderSourceType === MesProWorkOrderSourceTypeEnum.ORDER,
      },
    },
    {
      fieldName: 'saleOrderId',
      label: '营销订单',
      component: markRaw(ErpSaleOrderSelect),
      componentProps: {
        disabled: headerReadonly,
        placeholder: '请选择营销订单（ERP销售订单）',
        // é€‰ä¸­è¥é”€è®¢å•åŽè‡ªåŠ¨å¸¦å…¥å®¢æˆ·
        onChange: async (item?: ErpSaleOrderApi.SaleOrder) => {
          if (!item) {
            return;
          }
          const values = (await formApi?.getValues()) ?? {};
          if (values.clientId == null && item.customerId) {
            await formApi?.setFieldValue('clientId', item.customerId);
          }
        },
      },
      dependencies: {
        triggerFields: ['orderSourceType'],
@@ -398,6 +424,11 @@
      width: 120,
    },
    {
      field: 'saleOrderNo',
      title: '营销订单号',
      width: 140,
    },
    {
      field: 'requestDate',
      title: '需求日期',
      width: 180,

 src/views/mes/pro/workresult/summary.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,168 @@
<script lang="ts" setup>
import type { WorkResultSummary } from '#/api/mes/pro/feedback';

import { onMounted, reactive, ref } from 'vue';

import { Page } from '@vben/common-ui';
import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import {
  Button,
  Card,
  Col,
  DatePicker,
  Row,
  Select,
  Space,
  Table,
  Tag,
} from 'ant-design-vue';

import { getFeedbackSummary } from '#/api/mes/pro/feedback';

defineOptions({ name: 'MesWorkResultSummary' });

const loading = ref(false);
const summary = ref<WorkResultSummary>({});

const queryForm = reactive<{
  beginDate?: string;
  endDate?: string;
  workOrderType?: number;
}>({});

const workOrderTypeOptions = getDictOptions(
  DICT_TYPE.MES_PRO_WORK_ORDER_TYPE,
  'number',
).map((option) => ({ label: option.label, value: option.value as number }));

async function loadSummary() {
  loading.value = true;
  try {
    summary.value = await getFeedbackSummary({
      beginDate: queryForm.beginDate,
      endDate: queryForm.endDate,
      workOrderType: queryForm.workOrderType,
    });
  } finally {
    loading.value = false;
  }
}

function handleRangeChange(_: unknown, dateStrings: string[]) {
  queryForm.beginDate = dateStrings[0] || undefined;
  queryForm.endDate = dateStrings[1] || undefined;
}

function resetQuery() {
  queryForm.beginDate = undefined;
  queryForm.endDate = undefined;
  queryForm.workOrderType = undefined;
  loadSummary();
}

onMounted(loadSummary);
</script>

<template>
  <Page>
    <Card class="mb-4">
      <Space wrap>
        <DatePicker.RangePicker
          :placeholder="['开始日期', '结束日期']"
          value-format="YYYY-MM-DD"
          @change="handleRangeChange"
        />
        <Select
          v-model:value="queryForm.workOrderType"
          allow-clear
          :options="workOrderTypeOptions"
          placeholder="工单类型"
          style="width: 160px"
        />
        <Button type="primary" :loading="loading" @click="loadSummary">
          æŸ¥è¯¢
        </Button>
        <Button @click="resetQuery">重置</Button>
      </Space>
    </Card>

    <Row :gutter="16" class="mb-4">
      <Col :span="8">
        <Card>
          <div class="text-sm text-gray-500">累计报工数量</div>
          <div class="mt-2 text-2xl font-bold">
            {{ summary.totalFeedbackQuantity ?? 0 }}
          </div>
        </Card>
      </Col>
      <Col :span="8">
        <Card>
          <div class="text-sm text-gray-500">累计合格数量</div>
          <div class="mt-2 text-2xl font-bold text-green-600">
            {{ summary.totalQualifiedQuantity ?? 0 }}
          </div>
        </Card>
      </Col>
      <Col :span="8">
        <Card>
          <div class="text-sm text-gray-500">累计报工单数</div>
          <div class="mt-2 text-2xl font-bold text-blue-600">
            {{ summary.totalFeedbackCount ?? 0 }}
          </div>
        </Card>
      </Col>
    </Row>

    <Card class="mb-4" title="按工单类型汇总">
      <Table
        row-key="workOrderType"
        :data-source="summary.byType ?? []"
        :loading="loading"
        :pagination="false"
        size="middle"
      >
        <Table.Column title="工单类型" data-index="workOrderTypeName">
          <template #default="{ record }">
            <Tag color="blue">{{ record.workOrderTypeName }}</Tag>
          </template>
        </Table.Column>
        <Table.Column
          title="报工数量"
          data-index="feedbackQuantity"
          align="right"
        />
        <Table.Column
          title="合格数量"
          data-index="qualifiedQuantity"
          align="right"
        />
        <Table.Column title="报工单数" data-index="feedbackCount" align="right" />
      </Table>
    </Card>

    <Card title="按日期汇总">
      <Table
        row-key="date"
        :data-source="summary.byDate ?? []"
        :loading="loading"
        :pagination="false"
        size="middle"
      >
        <Table.Column title="日期" data-index="date" />
        <Table.Column
          title="报工数量"
          data-index="feedbackQuantity"
          align="right"
        />
        <Table.Column
          title="合格数量"
          data-index="qualifiedQuantity"
          align="right"
        />
        <Table.Column title="报工单数" data-index="feedbackCount" align="right" />
      </Table>
    </Card>
  </Page>
</template>

 src/views/mes/process-design/process/data.ts

@@ -66,6 +66,16 @@
      rules: z.string().min(1, '工序名称不能为空').max(100),
    },
    {
      fieldName: 'type',
      label: '电力工艺分类',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_PRO_PROCESS_TYPE, 'number'),
        placeholder: '请选择电力工艺分类',
      },
    },
    {
      fieldName: 'status',
      label: '状态',
      component: 'RadioGroup',
@@ -148,6 +158,15 @@
    },
    { field: 'name', title: '工序名称', minWidth: 180 },
    {
      field: 'type',
      title: '电力工艺分类',
      width: 120,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_PRO_PROCESS_TYPE },
      },
    },
    {
      field: 'status',
      title: '状态',
      width: 100,

 src/views/mes/qc/outsourcetest/data.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,263 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';

import { DICT_TYPE } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import { getRangePickerDefaultProps } from '#/utils';

/** è¡¨å•ç±»åž‹ */
export type FormType = 'create' | 'detail' | 'edit';

/** çŠ¶æ€å¸¸é‡ */
export const TEST_STATUS = {
  DRAFT: 0,
  SUBMITTED: 10,
  FINISHED: 20,
};

/** è¡¨å•çš„配置项 */
export function useFormSchema(formType: FormType): VbenFormSchema[] {
  const isReadonly = formType === 'detail';
  return [
    {
      fieldName: 'id',
      component: 'Input',
      dependencies: {
        triggerFields: [''],
        show: () => false,
      },
    },
    {
      fieldName: 'code',
      label: '单据编码',
      component: 'Input',
      componentProps: {
        placeholder: '系统自动生成',
        disabled: true,
      },
    },
    {
      fieldName: 'name',
      label: '单据名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入单据名称',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'testType',
      label: '检测类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.MES_QC_OUTSOURCE_TEST_TYPE, 'number'),
        placeholder: '请选择检测类型',
        disabled: isReadonly,
      },
      rules: 'selectRequired',
    },
    {
      fieldName: 'itemId',
      label: '检测对象',
      component: 'Input',
      componentProps: {
        placeholder: '检测对象（物料/设备）',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'testOrg',
      label: '检测机构',
      component: 'Input',
      componentProps: {
        placeholder: '请输入检测机构',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'testDate',
      label: '检测日期',
      component: 'DatePicker',
      componentProps: {
        placeholder: '选择检测日期',
        showTime: true,
        format: 'YYYY-MM-DD HH:mm:ss',
        valueFormat: 'YYYY-MM-DD HH:mm:ss',
        disabled: isReadonly,
      },
      rules: 'required',
    },
    {
      fieldName: 'result',
      label: '检测结果',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.MES_QC_OUTSOURCE_TEST_RESULT, 'number'),
        placeholder: '请选择检测结果',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'reportNo',
      label: '报告编号',
      component: 'Input',
      componentProps: {
        placeholder: '请输入检测报告编号',
        disabled: isReadonly,
      },
    },
    {
      fieldName: 'remark',
      label: '备注',
      component: 'Textarea',
      componentProps: {
        placeholder: '请输入备注',
        autoSize: { minRows: 1, maxRows: 1 },
        disabled: isReadonly,
      },
      formItemClass: 'col-span-2',
    },
    {
      fieldName: 'blobIds',
      label: '检测报告/资质文件',
      component: 'FileUpload',
      componentProps: {
        valueKey: 'id',
        maxNumber: 10,
        multiple: true,
        disabled: isReadonly,
      },
      formItemClass: 'col-span-3',
    },
  ];
}

/** åˆ—表的搜索表单 */
export function useGridFormSchema(): VbenFormSchema[] {
  return [
    {
      fieldName: 'code',
      label: '单据编码',
      component: 'Input',
      componentProps: {
        placeholder: '请输入单据编码',
      },
    },
    {
      fieldName: 'name',
      label: '单据名称',
      component: 'Input',
      componentProps: {
        placeholder: '请输入单据名称',
      },
    },
    {
      fieldName: 'testType',
      label: '检测类型',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_QC_OUTSOURCE_TEST_TYPE, 'number'),
        placeholder: '请选择检测类型',
      },
    },
    {
      fieldName: 'result',
      label: '检测结果',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: getDictOptions(DICT_TYPE.MES_QC_OUTSOURCE_TEST_RESULT, 'number'),
        placeholder: '请选择检测结果',
      },
    },
    {
      fieldName: 'status',
      label: '状态',
      component: 'Select',
      componentProps: {
        allowClear: true,
        options: [
          { label: '草稿', value: TEST_STATUS.DRAFT },
          { label: '已提交', value: TEST_STATUS.SUBMITTED },
          { label: '已完成', value: TEST_STATUS.FINISHED },
        ],
        placeholder: '请选择状态',
      },
    },
    {
      fieldName: 'testDate',
      label: '检测日期',
      component: 'RangePicker',
      componentProps: getRangePickerDefaultProps(),
    },
  ];
}

/** åˆ—表的表格列 */
export function useGridColumns(): VxeTableGridOptions['columns'] {
  return [
    { type: 'checkbox', width: 50 },
    { type: 'seq', title: '序号', width: 60 },
    {
      field: 'code',
      title: '单据编码',
      minWidth: 150,
      slots: { default: 'code' },
    },
    {
      field: 'name',
      title: '单据名称',
      minWidth: 180,
    },
    {
      field: 'testType',
      title: '检测类型',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_QC_OUTSOURCE_TEST_TYPE },
      },
    },
    {
      field: 'itemName',
      title: '检测对象',
      minWidth: 140,
    },
    {
      field: 'testOrg',
      title: '检测机构',
      minWidth: 160,
    },
    {
      field: 'testDate',
      title: '检测日期',
      width: 170,
      formatter: 'formatDateTime',
    },
    {
      field: 'result',
      title: '检测结果',
      width: 100,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_QC_OUTSOURCE_TEST_RESULT },
      },
    },
    {
      field: 'status',
      title: '状态',
      width: 100,
      slots: { default: 'status' },
    },
    {
      field: 'action',
      title: '操作',
      width: 260,
      fixed: 'right',
      slots: { default: 'actions' },
    },
  ];
}

 src/views/mes/qc/outsourcetest/index.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,210 @@
<script lang="ts" setup>
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { MesQcOutsourceTestApi } from '#/api/mes/qc/outsourcetest';

import { ref } from 'vue';

import { Page, useVbenModal } from '@vben/common-ui';
import { isEmpty } from '@vben/utils';

import { message, Tag } from 'ant-design-vue';

import { ACTION_ICON, TableAction, useVbenVxeGrid } from '#/adapter/vxe-table';
import {
  deleteTest,
  finishTest,
  getTestPage,
  submitTest,
} from '#/api/mes/qc/outsourcetest';
import { $t } from '#/locales';

import { TEST_STATUS, useGridColumns, useGridFormSchema } from './data';
import Form from './modules/form.vue';

/** MES å§”外检测/试验单列表 */
defineOptions({ name: 'MesQcOutsourceTest' });

const [FormModal, formModalApi] = useVbenModal({
  connectedComponent: Form,
  destroyOnClose: true,
});

function handleRefresh() {
  gridApi.query();
}

function handleCreate() {
  formModalApi.setData({ formType: 'create' }).open();
}

function handleEdit(row: MesQcOutsourceTestApi.OutsourceTest) {
  formModalApi.setData({ formType: 'edit', id: row.id }).open();
}

function handleDetail(row: MesQcOutsourceTestApi.OutsourceTest) {
  formModalApi.setData({ formType: 'detail', id: row.id }).open();
}

async function handleDelete(ids: number[]) {
  const hideLoading = message.loading({
    content: $t('ui.actionMessage.deleting'),
    duration: 0,
  });
  try {
    await deleteTest(ids);
    message.success($t('ui.actionMessage.deleteSuccess'));
    handleRefresh();
  } finally {
    hideLoading();
  }
}

async function handleSubmit(row: MesQcOutsourceTestApi.OutsourceTest) {
  await submitTest(row.id!);
  message.success('已提交');
  handleRefresh();
}

async function handleFinish(row: MesQcOutsourceTestApi.OutsourceTest) {
  await finishTest(row.id!);
  message.success('已完成');
  handleRefresh();
}

const checkedIds = ref<number[]>([]);
function handleRowCheckboxChange({
  records,
}: {
  records: MesQcOutsourceTestApi.OutsourceTest[];
}) {
  checkedIds.value = records.map((item) => item.id!);
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
  },
  gridOptions: {
    columns: useGridColumns(),
    height: 'auto',
    keepSource: true,
    proxyConfig: {
      ajax: {
        query: async ({ page }, formValues) => {
          return await getTestPage({
            pageNo: page.currentPage,
            pageSize: page.pageSize,
            ...formValues,
          });
        },
      },
    },
    rowConfig: {
      keyField: 'id',
      isHover: true,
    },
    toolbarConfig: {
      refresh: true,
      search: true,
    },
  } as VxeTableGridOptions<MesQcOutsourceTestApi.OutsourceTest>,
  gridEvents: {
    checkboxAll: handleRowCheckboxChange,
    checkboxChange: handleRowCheckboxChange,
  },
});
</script>

<template>
  <Page auto-content-height>
    <FormModal @success="handleRefresh" />
    <Grid table-title="委外检测/试验单列表">
      <template #toolbar-tools>
        <TableAction
          :actions="[
            {
              label: $t('ui.actionTitle.create', ['委外检测/试验单']),
              type: 'primary',
              icon: ACTION_ICON.ADD,
              auth: ['mes:qc-outsource-test:create'],
              onClick: handleCreate,
            },
            {
              label: '批量删除',
              type: 'primary',
              danger: true,
              disabled: isEmpty(checkedIds),
              icon: ACTION_ICON.DELETE,
              auth: ['mes:qc-outsource-test:delete'],
              popConfirm: {
                title: `是否删除所选中数据？`,
                confirm: handleDelete.bind(null, checkedIds),
              },
            },
          ]"
        />
      </template>
      <template #code="{ row }">
        <a class="link" @click="handleDetail(row)">{{ row.code }}</a>
      </template>
      <template #status="{ row }">
        <Tag v-if="row.status === TEST_STATUS.DRAFT" color="default">草稿</Tag>
        <Tag v-else-if="row.status === TEST_STATUS.SUBMITTED" color="processing">已提交</Tag>
        <Tag v-else-if="row.status === TEST_STATUS.FINISHED" color="success">已完成</Tag>
      </template>
      <template #actions="{ row }">
        <TableAction
          :actions="[
            {
              label: $t('common.detail'),
              type: 'link',
              icon: ACTION_ICON.VIEW,
              auth: ['mes:qc-outsource-test:query'],
              onClick: handleDetail.bind(null, row),
            },
            {
              label: $t('common.edit'),
              type: 'link',
              icon: ACTION_ICON.EDIT,
              auth: ['mes:qc-outsource-test:update'],
              ifShow: row.status === TEST_STATUS.DRAFT,
              onClick: handleEdit.bind(null, row),
            },
            {
              label: '提交',
              type: 'link',
              auth: ['mes:qc-outsource-test:update'],
              ifShow: row.status === TEST_STATUS.DRAFT,
              popConfirm: {
                title: '确认提交该单据？',
                confirm: handleSubmit.bind(null, row),
              },
            },
            {
              label: '完成',
              type: 'link',
              auth: ['mes:qc-outsource-test:update'],
              ifShow: row.status === TEST_STATUS.SUBMITTED,
              popConfirm: {
                title: '确认完成该单据？',
                confirm: handleFinish.bind(null, row),
              },
            },
            {
              label: $t('common.delete'),
              type: 'link',
              danger: true,
              icon: ACTION_ICON.DELETE,
              auth: ['mes:qc-outsource-test:delete'],
              ifShow: row.status === TEST_STATUS.DRAFT,
              popConfirm: {
                title: $t('ui.actionMessage.deleteConfirm', [row.code]),
                confirm: handleDelete.bind(null, [row.id!]),
              },
            },
          ]"
        />
      </template>
    </Grid>
  </Page>
</template>

 src/views/mes/qc/outsourcetest/modules/form.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,101 @@
<script lang="ts" setup>
import type { MesQcOutsourceTestApi } from '#/api/mes/qc/outsourcetest';

import { computed, ref } from 'vue';

import { useVbenModal } from '@vben/common-ui';

import { message } from 'ant-design-vue';

import { useVbenForm } from '#/adapter/form';
import { createTest, getTest, updateTest } from '#/api/mes/qc/outsourcetest';
import { $t } from '#/locales';

import type { FormType } from '../data';
import { useFormSchema } from '../data';

const emit = defineEmits(['success']);
const formData = ref<MesQcOutsourceTestApi.OutsourceTest>();
const formType = ref<FormType>('create');

const getTitle = computed(() => {
  if (formType.value === 'create') {
    return $t('ui.actionTitle.create', ['委外检测/试验单']);
  } else if (formType.value === 'edit') {
    return $t('ui.actionTitle.edit', ['委外检测/试验单']);
  } else {
    return '委外检测/试验单详情';
  }
});

const [Form, formApi] = useVbenForm({
  commonConfig: {
    componentProps: {
      class: 'w-full',
    },
    labelWidth: 140,
  },
  wrapperClass: 'grid-cols-3',
  layout: 'vertical',
  schema: useFormSchema(formType.value),
  showDefaultActions: false,
});

const [Modal, modalApi] = useVbenModal({
  async onConfirm() {
    const { valid } = await formApi.validate();
    if (!valid) {
      return;
    }
    modalApi.lock();
    const data =
      (await formApi.getValues()) as MesQcOutsourceTestApi.OutsourceTest;
    try {
      await (formType.value === 'create'
        ? createTest(data)
        : updateTest(data));
      await modalApi.close();
      emit('success');
      message.success($t('ui.actionMessage.operationSuccess'));
    } finally {
      modalApi.unlock();
    }
  },
  async onOpenChange(isOpen: boolean) {
    if (!isOpen) {
      formData.value = undefined;
      return;
    }
    const data = modalApi.getData<{ formType: FormType; id?: number }>();
    formType.value = data.formType;
    formApi.setDisabled(formType.value === 'detail');
    formApi.updateSchema(useFormSchema(formType.value));
    if (!data || !data.id) {
      return;
    }
    modalApi.lock();
    try {
      formData.value = await getTest(data.id);
      await formApi.setValues(formData.value);
      if (formData.value?.attachmentList?.length) {
        const blobIds = formData.value.attachmentList.map((item) => ({
          uid: String(item.id),
          name: item.name || '',
          url: item.url || '',
          status: 'done',
          id: item.id,
        }));
        await formApi.setFieldValue('blobIds', blobIds);
      }
    } finally {
      modalApi.unlock();
    }
  },
});
</script>

<template>
  <Modal :title="getTitle" class="w-2/3" :show-confirm-button="formType !== 'detail'">
    <Form class="mx-3" />
  </Modal>
</template>

 src/views/wls/productissue/data.ts

@@ -93,6 +93,19 @@
      rules: 'required',
    },
    {
      fieldName: 'issueType',
      label: '单据类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.MES_WM_PRODUCT_ISSUE_TYPE, 'number'),
        placeholder: '请选择单据类型',
      },
      dependencies: {
        triggerFields: ['status'],
        show: (values) => values.status === undefined || values.status === 0,
      },
    },
    {
      fieldName: 'requiredTime',
      label: '需求时间',
      component: 'DatePicker',
@@ -196,6 +209,15 @@
      minWidth: 150,
    },
    {
      field: 'issueType',
      title: '单据类型',
      width: 100,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_WM_PRODUCT_ISSUE_TYPE },
      },
    },
    {
      field: 'workOrderCode',
      title: '生产订单',
      minWidth: 140,

 src/views/wls/stocktaking/task/index.vue

@@ -2,6 +2,8 @@
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { MesWmStockTakingTaskApi } from '#/api/mes/wm/stocktaking/task';

import { ref } from 'vue';

import { Page, useVbenModal } from '@vben/common-ui';
import { MesWmStockTakingTaskStatusEnum } from '@vben/constants';
import { downloadFileFromBlobPart } from '@vben/utils';
@@ -15,6 +17,10 @@
  exportStockTaking,
  getStockTakingPage,
} from '#/api/mes/wm/stocktaking/task';
import {
  importStockTakingQuantity,
  importStockTakingQuantityTemplate,
} from '#/api/wls/stocktaking/task/line';
import { $t } from '#/locales';

import { useGridColumns, useGridFormSchema } from './data';
@@ -83,6 +89,41 @@
  downloadFileFromBlobPart({ fileName: '盘点任务.xls', source: data });
}

/** ä¸‹è½½ç›˜ç‚¹å¯¼å…¥æ¨¡æ¿ */
async function handleImportTemplate() {
  const data = await importStockTakingQuantityTemplate();
  downloadFileFromBlobPart({ fileName: '盘点实盘数导入模板.xls', source: data });
}

const importFileRef = ref<HTMLInputElement>();
const importTaskId = ref<number>();

/** è§¦å‘导入文件选择 */
function handleImport(row: MesWmStockTakingTaskApi.StockTakingTask) {
  importTaskId.value = row.id!;
  importFileRef.value?.click();
}

/** å¯¼å…¥å®žç›˜æ•°æ–‡ä»¶é€‰æ‹©åŽä¸Šä¼  */
async function handleImportFileChange(event: Event) {
  const file = (event.target as HTMLInputElement).files?.[0];
  if (!file || !importTaskId.value) {
    return;
  }
  const hideLoading = message.loading({ content: '正在导入实盘数...', duration: 0 });
  try {
    const result = await importStockTakingQuantity(importTaskId.value, file);
    message.success(`导入完成：成功 ${result.successCount ?? 0} æ¡ï¼Œå¤±è´¥ ${result.failureCount ?? 0} æ¡`);
    if (result.failureMessages?.length) {
      message.warning(result.failureMessages.slice(0, 5).join('；'));
    }
    handleRefresh();
  } finally {
    (event.target as HTMLInputElement).value = '';
    hideLoading();
  }
}

const [Grid, gridApi] = useVbenVxeGrid({
  formOptions: {
    schema: useGridFormSchema(),
@@ -137,6 +178,13 @@
              auth: ['mes:wm-stock-taking-task:export'],
              onClick: handleExport,
            },
            {
              label: '导入模板',
              type: 'primary',
              icon: ACTION_ICON.DOWNLOAD,
              auth: ['mes:wm-stock-taking-task:query'],
              onClick: handleImportTemplate,
            },
          ]"
        />
      </template>
@@ -183,6 +231,14 @@
              onClick: handleExecute.bind(null, row),
            },
            {
              label: '导入实盘数',
              type: 'link',
              icon: ACTION_ICON.UPLOAD,
              auth: ['mes:wm-stock-taking-task:update'],
              ifShow: row.status === StatusEnum.APPROVING,
              onClick: handleImport.bind(null, row),
            },
            {
              label: '取消',
              type: 'link',
              danger: true,
@@ -197,5 +253,12 @@
        />
      </template>
    </Grid>
    <input
      ref="importFileRef"
      class="hidden"
      type="file"
      accept=".xls,.xlsx"
      @change="handleImportFileChange"
    />
  </Page>
</template>

 src/views/wls/warehouse/area/data.ts

@@ -102,6 +102,15 @@
      rules: 'required',
    },
    {
      fieldName: 'type',
      label: '库区类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.MES_WM_WAREHOUSE_TYPE, 'number'),
        placeholder: '请选择库区类型',
      },
    },
    {
      fieldName: 'area',
      label: '面积（㎡）',
      component: 'InputNumber',
@@ -275,6 +284,15 @@
      minWidth: 160,
    },
    {
      field: 'type',
      title: '库区类型',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_WM_WAREHOUSE_TYPE },
      },
    },
    {
      field: 'area',
      title: '面积（㎡）',
      width: 100,

 src/views/wls/warehouse/data.ts

@@ -6,6 +6,7 @@
import { h } from 'vue';

import { DICT_TYPE, MesAutoCodeRuleCode } from '@vben/constants';
import { getDictOptions } from '@vben/hooks';

import { Button } from 'ant-design-vue';

@@ -68,6 +69,15 @@
        placeholder: '请输入仓库名称',
      },
      rules: 'required',
    },
    {
      fieldName: 'type',
      label: '仓库类型',
      component: 'Select',
      componentProps: {
        options: getDictOptions(DICT_TYPE.MES_WM_WAREHOUSE_TYPE, 'number'),
        placeholder: '请选择仓库类型',
      },
    },
    {
      fieldName: 'chargeUserId',
@@ -175,6 +185,15 @@
      minWidth: 160,
    },
    {
      field: 'type',
      title: '仓库类型',
      width: 110,
      cellRender: {
        name: 'CellDict',
        props: { type: DICT_TYPE.MES_WM_WAREHOUSE_TYPE },
      },
    },
    {
      field: 'address',
      title: '仓库地址',
      minWidth: 180,

 vite.config.ts

@@ -76,7 +76,7 @@
        proxy: {
          "/admin-api": {
            changeOrigin: true,
            target: "http://192.168.0.10:48080",
            target: "http://127.0.0.1:48080",
            ws: true,
          },
        },