package cn.iocoder.yudao.module.mes.service.qc.imports;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.iocoder.yudao.framework.common.exception.ServiceException;
|
import cn.iocoder.yudao.framework.dict.core.DictFrameworkUtils;
|
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
|
import cn.iocoder.yudao.module.crm.api.customer.dto.CrmCustomerRespDTO;
|
import cn.iocoder.yudao.module.mdm.api.item.MdmItemApi;
|
import cn.iocoder.yudao.module.mdm.api.item.dto.MdmItemRespDTO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.workstation.MesMdWorkstationDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.template.MesQcTemplateDO;
|
import cn.iocoder.yudao.module.mes.service.md.autocode.MesMdAutoCodeRecordService;
|
import cn.iocoder.yudao.module.mes.service.md.workstation.MesMdWorkstationService;
|
import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderService;
|
import cn.iocoder.yudao.module.mes.service.qc.template.MesQcTemplateService;
|
import cn.iocoder.yudao.module.srm.api.supplier.SrmSupplierApi;
|
import cn.iocoder.yudao.module.srm.api.supplier.dto.SrmSupplierRespDTO;
|
import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
|
import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
|
import jakarta.annotation.Resource;
|
import org.springframework.stereotype.Component;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
|
import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;
|
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.QC_NO_TEMPLATE;
|
|
/**
|
* MES 质检单导入辅助类
|
*
|
* 负责把 Excel 中的人类可读值（物料编码、供应商名称、客户名称、质检方案名称、检测人员姓名、工单号、工位名称等）
|
* 解析为系统编号，并统一处理字典、日期、错误文案。
|
* 各物料/供应商/客户/方案映射在 {@link #startImport()} 后首次使用时一次性加载，避免逐行查询。
|
*/
|
@Component
|
public class MesQcImportHelper {
|
|
@Resource
|
private AdminUserApi adminUserApi;
|
@Resource
|
private MdmItemApi mdmItemApi;
|
@Resource
|
private SrmSupplierApi srmSupplierApi;
|
@Resource
|
private CrmCustomerApi crmCustomerApi;
|
@Resource
|
private MesQcTemplateService templateService;
|
@Resource
|
private MesMdAutoCodeRecordService autoCodeRecordService;
|
@Resource
|
private MesProWorkOrderService workOrderService;
|
@Resource
|
private MesMdWorkstationService workstationService;
|
|
/** 质检方案名称 -> 编号（可能重名，命中多个时取第一个） */
|
private Map<String, Long> templateNameMap;
|
/** 供应商名称 -> 编号 */
|
private Map<String, Long> supplierNameMap;
|
/** 客户名称 -> 编号 */
|
private Map<String, Long> customerNameMap;
|
/** 当前登录用户可见的客户编号；null 表示不限制 */
|
private Set<Long> permittedClientIds;
|
private boolean clientPermissionLoaded;
|
|
/**
|
* 开始一次导入：清空上一次导入的缓存，保证新建的供应商/客户/方案本次即可命中
|
*/
|
public void startImport() {
|
templateNameMap = null;
|
supplierNameMap = null;
|
customerNameMap = null;
|
permittedClientIds = null;
|
clientPermissionLoaded = false;
|
}
|
|
/**
|
* 生成检验单编号，如 IQC20260101000001
|
*/
|
public String generateCode(String ruleCode) {
|
return autoCodeRecordService.generateAutoCode(ruleCode);
|
}
|
|
/**
|
* 解析检测人员：留空取当前登录用户；填写时按姓名（昵称）精确匹配，取不到则用模糊匹配的第一条
|
*/
|
public Long resolveInspectorUserId(String nickname) {
|
if (StrUtil.isBlank(nickname)) {
|
return getLoginUserId();
|
}
|
List<AdminUserRespDTO> users = adminUserApi.getUserListByNickname(nickname.trim());
|
if (CollUtil.isEmpty(users)) {
|
throw new IllegalArgumentException("检测人员不存在：" + nickname.trim()
|
+ "。请在「检测人员」列填写系统内的用户姓名（可在「系统管理-用户管理」中核对），或留空使用当前登录用户");
|
}
|
return users.stream().filter(user -> nickname.trim().equals(user.getNickname()))
|
.map(AdminUserRespDTO::getId).findFirst().orElseGet(() -> users.get(0).getId());
|
}
|
|
/**
|
* 解析产品物料编号，基于物料编码
|
*/
|
public Long resolveItemId(String itemCode) {
|
if (StrUtil.isBlank(itemCode)) {
|
throw new IllegalArgumentException("产品物料编码不能为空：请填写模板中该行的「产品物料编码」列");
|
}
|
MdmItemRespDTO item = mdmItemApi.getItemByCode(itemCode.trim()).getCheckedData();
|
if (item == null) {
|
throw new IllegalArgumentException("物料不存在：" + itemCode.trim()
|
+ "。请先在「物料管理」中维护该物料（编码需与模板完全一致），或修改模板中的产品物料编码后重新导入");
|
}
|
return item.getId();
|
}
|
|
/**
|
* 解析质检方案编号，基于方案名称；留空返回 null（由系统按物料+检验类型自动匹配）
|
*/
|
public Long resolveTemplateId(String templateName) {
|
if (StrUtil.isBlank(templateName)) {
|
return null;
|
}
|
if (templateNameMap == null) {
|
templateNameMap = new HashMap<>();
|
List<MesQcTemplateDO> templates = templateService.getTemplateList();
|
if (CollUtil.isNotEmpty(templates)) {
|
templates.forEach(template -> {
|
if (StrUtil.isNotBlank(template.getName())) {
|
templateNameMap.putIfAbsent(template.getName().trim(), template.getId());
|
}
|
});
|
}
|
}
|
Long templateId = templateNameMap.get(templateName.trim());
|
if (templateId == null) {
|
throw new IllegalArgumentException("质检方案不存在：" + templateName.trim()
|
+ "。请在「质检管理-质检方案」中核对方案名称，或留空该列由系统按物料自动匹配方案后重新导入");
|
}
|
return templateId;
|
}
|
|
/**
|
* 解析供应商编号，基于供应商名称；留空返回 null
|
*/
|
public Long resolveVendorId(String vendorName) {
|
if (StrUtil.isBlank(vendorName)) {
|
return null;
|
}
|
if (supplierNameMap == null) {
|
supplierNameMap = new HashMap<>();
|
List<SrmSupplierRespDTO> suppliers = srmSupplierApi.getSupplierSimpleList().getCheckedData();
|
if (CollUtil.isNotEmpty(suppliers)) {
|
suppliers.forEach(supplier -> {
|
if (StrUtil.isNotBlank(supplier.getName())) {
|
supplierNameMap.putIfAbsent(supplier.getName().trim(), supplier.getId());
|
}
|
});
|
}
|
}
|
Long vendorId = supplierNameMap.get(vendorName.trim());
|
if (vendorId == null) {
|
throw new IllegalArgumentException("供应商不存在或未通过准入审批：" + vendorName.trim()
|
+ "。请在「供应商管理」中核对供应商名称（名称需与模板完全一致），或留空该列后重新导入");
|
}
|
return vendorId;
|
}
|
|
/**
|
* 解析客户编号，基于客户名称
|
*/
|
public Long resolveClientId(String clientName) {
|
if (StrUtil.isBlank(clientName)) {
|
throw new IllegalArgumentException("客户名称不能为空：请填写模板中该行的「客户名称」列");
|
}
|
if (customerNameMap == null) {
|
customerNameMap = new HashMap<>();
|
List<CrmCustomerRespDTO> customers = crmCustomerApi.getCustomerSimpleList();
|
if (CollUtil.isNotEmpty(customers)) {
|
customers.forEach(customer -> {
|
if (StrUtil.isNotBlank(customer.getName())) {
|
customerNameMap.putIfAbsent(customer.getName().trim(), customer.getId());
|
}
|
});
|
}
|
}
|
Long clientId = customerNameMap.get(clientName.trim());
|
if (clientId == null) {
|
throw new IllegalArgumentException("客户不存在：" + clientName.trim()
|
+ "。请先在「CRM 客户管理」中创建该客户（名称需与模板完全一致），或修改模板中的客户名称后重新导入");
|
}
|
return clientId;
|
}
|
|
/**
|
* 校验客户在当前登录用户的可见范围内
|
*
|
* 出货检验单列表按客户数据权限过滤，权限外的客户导入后本人在列表中看不到该单据，因此提前拦截。
|
*/
|
public void validateClientPermission(Long clientId, String clientName) {
|
if (!clientPermissionLoaded) {
|
List<Long> permittedIds = crmCustomerApi.getPermittedCustomerIds();
|
permittedClientIds = permittedIds == null ? null : new HashSet<>(permittedIds);
|
clientPermissionLoaded = true;
|
}
|
if (permittedClientIds == null || permittedClientIds.contains(clientId)) {
|
return;
|
}
|
throw new IllegalArgumentException("客户[" + clientName + "]不在您的数据权限范围内："
|
+ "导入后您将无法在「出货检验」列表中看到该检验单。请改用您负责的客户（可在「CRM 客户管理-我负责的」中查看），"
|
+ "或联系管理员为您开通该客户的权限后重新导入");
|
}
|
|
/**
|
* 解析生产工单编号，基于工单号
|
*/
|
public Long resolveWorkOrderId(String workOrderCode) {
|
if (StrUtil.isBlank(workOrderCode)) {
|
throw new IllegalArgumentException("生产工单号不能为空：请填写模板中该行的「生产工单号」列");
|
}
|
MesProWorkOrderDO workOrder = workOrderService.getWorkOrder(workOrderCode.trim());
|
if (workOrder == null) {
|
throw new IllegalArgumentException("生产工单不存在：" + workOrderCode.trim()
|
+ "。请在「生产管理-生产工单」中核对该工单号（需与模板完全一致），或修改模板后重新导入");
|
}
|
return workOrder.getId();
|
}
|
|
/**
|
* 解析工位编号，基于工位名称
|
*/
|
public Long resolveWorkstationId(String workstationName) {
|
if (StrUtil.isBlank(workstationName)) {
|
throw new IllegalArgumentException("工位名称不能为空：请填写模板中该行的「工位名称」列");
|
}
|
MesMdWorkstationDO workstation = workstationService.getWorkstationByName(workstationName.trim());
|
if (workstation == null) {
|
throw new IllegalArgumentException("工位不存在：" + workstationName.trim()
|
+ "。请在「基础数据-工位管理」中核对该工位名称（需与模板完全一致），或修改模板后重新导入");
|
}
|
return workstation.getId();
|
}
|
|
/**
|
* 解析字典值：支持填写字典名称（如 校验通过）或字典值（如 1）
|
*
|
* @param text Excel 单元格内容
|
* @param dictType 字典类型
|
* @param fieldLabel 列名，用于错误提示
|
* @param required 是否必填
|
*/
|
public Integer resolveDictValue(String text, String dictType, String fieldLabel, boolean required) {
|
List<String> labelList = DictFrameworkUtils.getDictDataLabelList(dictType);
|
if (StrUtil.isBlank(text)) {
|
if (required) {
|
throw new IllegalArgumentException(fieldLabel + "不能为空：请填写模板中该行的「" + fieldLabel
|
+ "」列，可选值：" + String.join("、", labelList));
|
}
|
return null;
|
}
|
String value = text.trim();
|
if (value.matches("\\d+") && DictFrameworkUtils.getDictDataValueList(dictType).contains(value)) {
|
return Integer.valueOf(value);
|
}
|
String parsedValue = DictFrameworkUtils.parseDictDataValue(dictType, value);
|
if (parsedValue == null) {
|
throw new IllegalArgumentException(fieldLabel + "不存在：" + value + "。模板中「" + fieldLabel
|
+ "」请填写以下之一：" + String.join("、", labelList));
|
}
|
return Integer.valueOf(parsedValue);
|
}
|
|
/**
|
* 解析数量：必填时不能为空，且不能小于 0
|
*/
|
public BigDecimal resolveQuantity(BigDecimal value, String fieldLabel, boolean required) {
|
if (value == null) {
|
if (required) {
|
throw new IllegalArgumentException(fieldLabel + "不能为空：请填写模板中该行的「" + fieldLabel + "」列");
|
}
|
return null;
|
}
|
if (value.compareTo(BigDecimal.ZERO) < 0) {
|
throw new IllegalArgumentException(fieldLabel + "不能小于 0，当前为 " + value.stripTrailingZeros().toPlainString()
|
+ "。请修改模板后重新导入");
|
}
|
return value;
|
}
|
|
/**
|
* 校验「合计数量 = 合格品数量 + 不合格品数量」
|
*
|
* @param total 合计数量（合计列留空时传 null，由合格 + 不合格 自动推算）
|
* @param qualified 合格品数量
|
* @param unqualified 不合格品数量
|
* @param totalFieldLabel 合计列的列名，如「本次接收数量」
|
*/
|
public BigDecimal resolveCheckQuantity(BigDecimal total, BigDecimal qualified, BigDecimal unqualified,
|
String totalFieldLabel) {
|
BigDecimal sum = qualified.add(unqualified);
|
if (total == null) {
|
return sum;
|
}
|
if (total.compareTo(sum) != 0) {
|
throw new IllegalArgumentException(totalFieldLabel + "必须等于合格品数量与不合格品数量之和：合格品数量 "
|
+ qualified.stripTrailingZeros().toPlainString() + " + 不合格品数量 "
|
+ unqualified.stripTrailingZeros().toPlainString() + " = " + sum.stripTrailingZeros().toPlainString()
|
+ "，而「" + totalFieldLabel + "」填写的是 " + total.stripTrailingZeros().toPlainString()
|
+ "。请修改模板中的数量列，或将该列留空由系统自动合计后重新导入");
|
}
|
return total;
|
}
|
|
/**
|
* 解析日期时间：支持 2026-01-01 10:00:00 / 2026-01-01 10:00 / 2026-01-01 / 2026/1/1；留空返回 null
|
*/
|
public LocalDateTime parseDateTime(String text, String fieldLabel) {
|
if (StrUtil.isBlank(text)) {
|
return null;
|
}
|
String value = text.trim();
|
for (String pattern : new String[]{"yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy/MM/dd HH:mm:ss"}) {
|
try {
|
return LocalDateTime.parse(value, DateTimeFormatter.ofPattern(pattern));
|
} catch (Exception ignored) {
|
// 继续尝试下一个格式
|
}
|
}
|
for (String pattern : new String[]{"yyyy-MM-dd", "yyyy/M/d"}) {
|
try {
|
return java.time.LocalDate.parse(value, DateTimeFormatter.ofPattern(pattern)).atStartOfDay();
|
} catch (Exception ignored) {
|
// 继续尝试下一个格式
|
}
|
}
|
throw new IllegalArgumentException(fieldLabel + "格式不正确：" + text + "，示例 2026-01-01 10:00:00");
|
}
|
|
/**
|
* 解析必填的日期时间：留空报错
|
*/
|
public LocalDateTime parseRequiredDateTime(String text, String fieldLabel) {
|
LocalDateTime value = parseDateTime(text, fieldLabel);
|
if (value == null) {
|
throw new IllegalArgumentException(fieldLabel + "不能为空：请填写模板中该行的「" + fieldLabel
|
+ "」列，示例 2026-01-01 10:00:00");
|
}
|
return value;
|
}
|
|
/**
|
* 物料未配置质检方案时，补充物料与检验类型上下文再抛出；其余异常原样抛出
|
*/
|
public static void rethrowTemplateError(ServiceException ex, String itemCode, String qcTypeLabel) {
|
if (Objects.equals(ex.getCode(), QC_NO_TEMPLATE.getCode())) {
|
throw new IllegalArgumentException("物料[" + StrUtil.blankToDefault(itemCode, "未知") + "]未配置"
|
+ qcTypeLabel + "的质检方案。请在「质检管理-质检方案」中为该物料配置" + qcTypeLabel
|
+ "方案，或在模板的「质检方案」列填写该物料已配置的方案名称后重新导入");
|
}
|
throw ex;
|
}
|
|
/**
|
* 单行导入失败时的提示文案
|
*/
|
public static String resolveImportErrorMessage(Exception ex) {
|
if (ex instanceof cn.iocoder.yudao.framework.common.exception.ServiceException serviceException) {
|
return serviceException.getMessage();
|
}
|
return StrUtil.blankToDefault(ex.getMessage(), "导入失败");
|
}
|
|
/**
|
* 重复数据提示中的取值展示：留空显示为「未填写」
|
*/
|
public static String describeImportValue(String value) {
|
return StrUtil.isBlank(value) ? "未填写" : value.trim();
|
}
|
|
/**
|
* 同一份模板内出现重复数据时的提示
|
*/
|
public static IllegalArgumentException duplicateRowException(int firstRowNo, String keyDesc) {
|
return new IllegalArgumentException("检测到重复导入：本次导入的第 " + firstRowNo
|
+ " 行与当前行的数据完全相同（" + keyDesc + "）。请删除模板中重复的行后重新导入");
|
}
|
|
/**
|
* 与系统中已有单据重复时的提示
|
*/
|
public static IllegalArgumentException duplicateExistingException(String keyDesc, String docLabel,
|
String existingCode, String menuPath) {
|
return new IllegalArgumentException("检测到重复导入：" + keyDesc + " 与已有" + docLabel + "「" + existingCode
|
+ "」完全相同（可能是本次导入前面的行，也可能是系统中已有单据）。请勿重复导入；如确需重新导入，请先在「"
|
+ menuPath + "」中删除该" + docLabel + "后重试");
|
}
|
|
}
|
