From 4c111ddd606974a5e3fef73ed11c860df0bdb963 Mon Sep 17 00:00:00 2001 From: yf001217 <834502597@qq.com> Date: Mon, 8 Jun 2026 16:29:36 +0800 Subject: [PATCH] =?UTF-8?q?qms=E6=8A=A5=E8=A1=A8=E7=AE=A1=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../QmdReportManagementController.java | 77 ++++ .../QmdReportManagementControllerService.java | 349 ++++++++++++++++++ .../common/pojo/qo/QmdReportManagementQO.java | 98 +++++ .../common/pojo/vo/QmdReportManagementVO.java | 111 ++++++ 4 files changed, 635 insertions(+) create mode 100644 nflg-qms-admin/src/main/java/com/nflg/qms/admin/controller/QmdReportManagementController.java create mode 100644 nflg-qms-admin/src/main/java/com/nflg/qms/admin/service/QmdReportManagementControllerService.java create mode 100644 nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/qo/QmdReportManagementQO.java create mode 100644 nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/vo/QmdReportManagementVO.java diff --git a/nflg-qms-admin/src/main/java/com/nflg/qms/admin/controller/QmdReportManagementController.java b/nflg-qms-admin/src/main/java/com/nflg/qms/admin/controller/QmdReportManagementController.java new file mode 100644 index 00000000..52029635 --- /dev/null +++ b/nflg-qms-admin/src/main/java/com/nflg/qms/admin/controller/QmdReportManagementController.java @@ -0,0 +1,77 @@ +package com.nflg.qms.admin.controller; + +import com.nflg.qms.admin.service.QmdReportManagementControllerService; +import com.nflg.wms.common.pojo.ApiResult; +import com.nflg.wms.common.pojo.qo.QmdReportManagementQO; +import com.nflg.wms.common.pojo.vo.QmdReportManagementVO; +import com.nflg.wms.starter.BaseController; +import jakarta.annotation.Resource; +import jakarta.validation.Valid; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +/** + * QMD报表管理 + */ +@RestController +@RequestMapping("/qmd/report-management") +public class QmdReportManagementController extends BaseController { + + @Resource + private QmdReportManagementControllerService reportManagementControllerService; + + /** + * IQC报表查询 + */ + @PostMapping("/iqc") + public ApiResult> searchIqc( + @Valid @RequestBody QmdReportManagementQO.IqcReportQO request) { + return ApiResult.success(reportManagementControllerService.searchIqc(request)); + } + + /** + * IQC版本号查询 + */ + @PostMapping("/iqc/versions") + public ApiResult> searchIqcVersions( + @Valid @RequestBody QmdReportManagementQO.IqcVersionQO request) { + return ApiResult.success(reportManagementControllerService.searchIqcVersions(request)); + } + + /** + * PDI报表查询 + */ + @PostMapping("/pdi") + public ApiResult> searchPdi( + @Valid @RequestBody QmdReportManagementQO.PdiReportQO request) { + return ApiResult.success(reportManagementControllerService.searchPdi(request)); + } + + /** + * PDI版本号查询 + */ + @PostMapping("/pdi/versions") + public ApiResult> searchPdiVersions( + @Valid @RequestBody QmdReportManagementQO.PdiVersionQO request) { + return ApiResult.success(reportManagementControllerService.searchPdiVersions(request)); + } + + /** + * PQC报表查询 + */ + @PostMapping("/pqc") + public ApiResult> searchPqc( + @Valid @RequestBody QmdReportManagementQO.PqcReportQO request) { + return ApiResult.success(reportManagementControllerService.searchPqc(request)); + } + + /** + * PQC版本号查询 + */ + @PostMapping("/pqc/versions") + public ApiResult> searchPqcVersions( + @Valid @RequestBody QmdReportManagementQO.PqcVersionQO request) { + return ApiResult.success(reportManagementControllerService.searchPqcVersions(request)); + } +} diff --git a/nflg-qms-admin/src/main/java/com/nflg/qms/admin/service/QmdReportManagementControllerService.java b/nflg-qms-admin/src/main/java/com/nflg/qms/admin/service/QmdReportManagementControllerService.java new file mode 100644 index 00000000..06bc8373 --- /dev/null +++ b/nflg-qms-admin/src/main/java/com/nflg/qms/admin/service/QmdReportManagementControllerService.java @@ -0,0 +1,349 @@ +package com.nflg.qms.admin.service; + +import cn.hutool.core.collection.CollectionUtil; +import cn.hutool.core.util.StrUtil; +import com.nflg.wms.common.pojo.qo.QmdReportManagementQO; +import com.nflg.wms.common.pojo.vo.QmdReportManagementVO; +import com.nflg.wms.repository.entity.*; +import com.nflg.wms.repository.service.*; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; + +/** + * QMD报表管理 ControllerService + */ +@Service +@RequiredArgsConstructor +public class QmdReportManagementControllerService { + + private final IQmsInspectionStandardService inspectionStandardService; + private final IQmsInspectionStandardItemService inspectionStandardItemService; + private final IQmsPdiDetectionRulesService pdiDetectionRulesService; + private final IQmsPdiDetectionRulesStatusItemService pdiStatusItemService; + private final IQmsPdiComponentAnagementService pdiComponentService; + private final IQmsPqcInspectionRuleService pqcInspectionRuleService; + private final IQmsPqcInspectionPointService pqcInspectionPointService; + private final IQmsPqcInspectionPointItemsService pqcInspectionPointItemsService; + + /** + * IQC报表查询 + */ + public List searchIqc(QmdReportManagementQO.IqcReportQO request) { + QmsInspectionStandard currentStandard = inspectionStandardService.lambdaQuery() + .eq(QmsInspectionStandard::getMaterialId, request.getMaterialId()) + .eq(QmsInspectionStandard::getVersion, request.getVersion()) + .last("LIMIT 1") + .one(); + if (currentStandard == null) { + return Collections.emptyList(); + } + + List currentItems = inspectionStandardItemService.lambdaQuery() + .eq(QmsInspectionStandardItem::getInspectionStandardId, currentStandard.getId()) + .orderByAsc(QmsInspectionStandardItem::getId) + .list(); + if (CollectionUtil.isEmpty(currentItems)) { + return Collections.emptyList(); + } + + List allStandards = inspectionStandardService.lambdaQuery() + .eq(QmsInspectionStandard::getMaterialId, request.getMaterialId()) + .list(); + Map versionMap = allStandards.stream() + .collect(Collectors.toMap(QmsInspectionStandard::getId, QmsInspectionStandard::getVersion, (a, b) -> a)); + Set standardIds = versionMap.keySet(); + + Map> itemVersionsMap = CollectionUtil.isEmpty(standardIds) + ? Collections.emptyMap() + : inspectionStandardItemService.lambdaQuery() + .in(QmsInspectionStandardItem::getInspectionStandardId, standardIds) + .list() + .stream() + .collect(Collectors.groupingBy( + this::iqcItemKey, + Collectors.mapping(item -> versionMap.get(item.getInspectionStandardId()), Collectors.toCollection(LinkedHashSet::new)) + )); + + return currentItems.stream() + .sorted(Comparator.comparing(QmsInspectionStandardItem::getId, Comparator.nullsLast(Long::compareTo))) + .map(item -> { + QmdReportManagementVO.IqcReportItemVO vo = new QmdReportManagementVO.IqcReportItemVO(); + vo.setInspectionItemId(item.getId()); + vo.setInspectionItemName(item.getName()); + vo.setVersions(joinVersions(itemVersionsMap.get(iqcItemKey(item)))); + return vo; + }) + .toList(); + } + + /** + * IQC版本号查询 + */ + public List searchIqcVersions(QmdReportManagementQO.IqcVersionQO request) { + return inspectionStandardService.lambdaQuery() + .select(QmsInspectionStandard::getVersion) + .eq(QmsInspectionStandard::getMaterialId, request.getMaterialId()) + .list() + .stream() + .map(QmsInspectionStandard::getVersion) + .filter(StrUtil::isNotBlank) + .distinct() + .sorted(this::compareVersion) + .toList(); + } + + /** + * PDI报表查询 + */ + public List searchPdi(QmdReportManagementQO.PdiReportQO request) { + List currentRules = pdiDetectionRulesService.lambdaQuery() + .eq(QmsPdiDetectionRules::getModelNo, request.getModelNo()) + .eq(QmsPdiDetectionRules::getInspectionVersion, request.getInspectionVersion()) + .list(); + if (CollectionUtil.isEmpty(currentRules)) { + return Collections.emptyList(); + } + + List allRules = pdiDetectionRulesService.lambdaQuery() + .eq(QmsPdiDetectionRules::getModelNo, request.getModelNo()) + .list(); + Map ruleVersionMap = allRules.stream() + .collect(Collectors.toMap(QmsPdiDetectionRules::getId, QmsPdiDetectionRules::getInspectionVersion, (a, b) -> a)); + Set allRuleIds = ruleVersionMap.keySet(); + + List allItems = CollectionUtil.isEmpty(allRuleIds) + ? Collections.emptyList() + : pdiStatusItemService.lambdaQuery() + .in(QmsPdiDetectionRulesStatusItem::getDetectionRulesId, allRuleIds) + .list(); + Map componentMap = getPdiComponentMap(allItems); + Map> itemVersionsMap = allItems.stream() + .collect(Collectors.groupingBy( + item -> pdiItemKey(item, componentMap.get(item.getComponentsId())), + Collectors.mapping(item -> ruleVersionMap.get(item.getDetectionRulesId()), Collectors.toCollection(LinkedHashSet::new)) + )); + + Set currentRuleIds = currentRules.stream().map(QmsPdiDetectionRules::getId).collect(Collectors.toSet()); + return allItems.stream() + .filter(item -> currentRuleIds.contains(item.getDetectionRulesId())) + .sorted(Comparator + .comparingInt((QmsPdiDetectionRulesStatusItem item) -> pdiStatusSort(item.getStatus())) + .thenComparing(QmsPdiDetectionRulesStatusItem::getComponentsId, Comparator.nullsLast(Long::compareTo)) + .thenComparing(QmsPdiDetectionRulesStatusItem::getId, Comparator.nullsLast(Long::compareTo))) + .map(item -> { + QmsPdiComponentAnagement component = componentMap.get(item.getComponentsId()); + QmdReportManagementVO.PdiReportItemVO vo = new QmdReportManagementVO.PdiReportItemVO(); + vo.setStatus(item.getStatus()); + vo.setStatusName(pdiStatusName(item.getStatus())); + vo.setPdiComponentId(item.getComponentsId()); + vo.setPdiComponentName(component == null ? null : component.getComponentName()); + vo.setInspectionItemId(item.getId()); + vo.setInspectionItemName(item.getInspectionContent()); + vo.setVersions(joinVersions(itemVersionsMap.get(pdiItemKey(item, component)))); + return vo; + }) + .toList(); + } + + /** + * PDI版本号查询 + */ + public List searchPdiVersions(QmdReportManagementQO.PdiVersionQO request) { + return pdiDetectionRulesService.lambdaQuery() + .select(QmsPdiDetectionRules::getInspectionVersion) + .eq(QmsPdiDetectionRules::getModelNo, request.getModelNo()) + .list() + .stream() + .map(QmsPdiDetectionRules::getInspectionVersion) + .filter(StrUtil::isNotBlank) + .distinct() + .sorted(this::compareVersion) + .toList(); + } + + /** + * PQC报表查询 + */ + public List searchPqc(QmdReportManagementQO.PqcReportQO request) { + List currentRules = pqcInspectionRuleService.lambdaQuery() + .eq(QmsPqcInspectionRule::getModelNo, request.getModelNo()) + .eq(QmsPqcInspectionRule::getRuleVersion, request.getRuleVersion()) + .list(); + if (CollectionUtil.isEmpty(currentRules)) { + return Collections.emptyList(); + } + + List allRules = pqcInspectionRuleService.lambdaQuery() + .eq(QmsPqcInspectionRule::getModelNo, request.getModelNo()) + .list(); + Map ruleVersionMap = allRules.stream() + .collect(Collectors.toMap(QmsPqcInspectionRule::getId, QmsPqcInspectionRule::getRuleVersion, (a, b) -> a)); + Set allRuleIds = ruleVersionMap.keySet(); + + List allPoints = CollectionUtil.isEmpty(allRuleIds) + ? Collections.emptyList() + : pqcInspectionPointService.lambdaQuery() + .in(QmsPqcInspectionPoint::getPqcRuleId, allRuleIds) + .list(); + if (CollectionUtil.isEmpty(allPoints)) { + return Collections.emptyList(); + } + + Map pointMap = allPoints.stream() + .collect(Collectors.toMap(QmsPqcInspectionPoint::getId, Function.identity(), (a, b) -> a)); + List allItems = pqcInspectionPointItemsService.lambdaQuery() + .in(QmsPqcInspectionPointItems::getInspectionCodeId, pointMap.keySet()) + .list(); + Map> itemVersionsMap = allItems.stream() + .collect(Collectors.groupingBy( + item -> pqcItemKey(pointMap.get(item.getInspectionCodeId()), item), + Collectors.mapping(item -> formatPqcVersion(ruleVersionMap.get(pointMap.get(item.getInspectionCodeId()).getPqcRuleId())), + Collectors.toCollection(LinkedHashSet::new)) + )); + + Set currentRuleIds = currentRules.stream().map(QmsPqcInspectionRule::getId).collect(Collectors.toSet()); + Set currentPointIds = allPoints.stream() + .filter(point -> currentRuleIds.contains(point.getPqcRuleId())) + .map(QmsPqcInspectionPoint::getId) + .collect(Collectors.toSet()); + + return allItems.stream() + .filter(item -> currentPointIds.contains(item.getInspectionCodeId())) + .sorted(Comparator + .comparing((QmsPqcInspectionPointItems item) -> pointMap.get(item.getInspectionCodeId()).getStepDicItemId(), + Comparator.nullsLast(Long::compareTo)) + .thenComparing(item -> pointMap.get(item.getInspectionCodeId()).getId(), Comparator.nullsLast(Long::compareTo)) + .thenComparing(QmsPqcInspectionPointItems::getId, Comparator.nullsLast(Long::compareTo))) + .map(item -> { + QmsPqcInspectionPoint point = pointMap.get(item.getInspectionCodeId()); + QmdReportManagementVO.PqcReportItemVO vo = new QmdReportManagementVO.PqcReportItemVO(); + vo.setModelNo(request.getModelNo()); + vo.setStepDicItemId(point.getStepDicItemId()); + vo.setStepName(point.getStepName()); + vo.setInspectionPointId(point.getId()); + vo.setInspectionPointName(point.getInspectionPointName()); + vo.setInspectionItemId(item.getId()); + vo.setInspectionItemName(item.getInspectionContent()); + vo.setVersions(joinVersions(itemVersionsMap.get(pqcItemKey(point, item)))); + return vo; + }) + .toList(); + } + + /** + * PQC版本号查询 + */ + public List searchPqcVersions(QmdReportManagementQO.PqcVersionQO request) { + return pqcInspectionRuleService.lambdaQuery() + .select(QmsPqcInspectionRule::getRuleVersion) + .eq(QmsPqcInspectionRule::getModelNo, request.getModelNo()) + .list() + .stream() + .map(QmsPqcInspectionRule::getRuleVersion) + .filter(Objects::nonNull) + .distinct() + .sorted() + .map(this::formatPqcVersion) + .toList(); + } + + private Map getPdiComponentMap(List items) { + Set componentIds = items.stream() + .map(QmsPdiDetectionRulesStatusItem::getComponentsId) + .filter(Objects::nonNull) + .collect(Collectors.toSet()); + if (CollectionUtil.isEmpty(componentIds)) { + return Collections.emptyMap(); + } + return pdiComponentService.listByIds(componentIds).stream() + .collect(Collectors.toMap(QmsPdiComponentAnagement::getId, Function.identity(), (a, b) -> a)); + } + + private String iqcItemKey(QmsInspectionStandardItem item) { + return normalize(item.getName()) + "|" + item.getItemType() + "|" + item.getDetectionTypeDictItemId(); + } + + private String pdiItemKey(QmsPdiDetectionRulesStatusItem item, QmsPdiComponentAnagement component) { + String componentName = component == null ? "" : component.getComponentName(); + return item.getStatus() + "|" + normalize(componentName) + "|" + normalize(item.getInspectionContent()); + } + + private String pqcItemKey(QmsPqcInspectionPoint point, QmsPqcInspectionPointItems item) { + String pointKey = StrUtil.isNotBlank(point.getInspectionPointCode()) + ? point.getInspectionPointCode() + : point.getInspectionPointName(); + return point.getStepDicItemId() + "|" + normalize(pointKey) + "|" + normalize(item.getInspectionContent()); + } + + private String joinVersions(Collection versions) { + if (CollectionUtil.isEmpty(versions)) { + return ""; + } + return versions.stream() + .filter(StrUtil::isNotBlank) + .sorted(this::compareVersion) + .collect(Collectors.joining(",")); + } + + private String formatPqcVersion(Integer version) { + return version == null ? "" : "v" + version; + } + + private int compareVersion(String a, String b) { + Integer aNum = parseVersionNumber(a); + Integer bNum = parseVersionNumber(b); + if (aNum != null && bNum != null) { + return aNum.compareTo(bNum); + } + return a.compareTo(b); + } + + private Integer parseVersionNumber(String version) { + if (StrUtil.isBlank(version)) { + return null; + } + String text = version.trim(); + if (text.startsWith("v") || text.startsWith("V")) { + text = text.substring(1); + } + try { + return Integer.parseInt(text); + } catch (NumberFormatException e) { + return null; + } + } + + private int pdiStatusSort(Integer status) { + if (Objects.equals(status, 0)) { + return 0; + } + if (Objects.equals(status, 1)) { + return 1; + } + if (Objects.equals(status, 2)) { + return 2; + } + return 3; + } + + private String pdiStatusName(Integer status) { + if (Objects.equals(status, 0)) { + return "静态"; + } + if (Objects.equals(status, 1)) { + return "动态"; + } + if (Objects.equals(status, 2)) { + return "特殊"; + } + return ""; + } + + private String normalize(String value) { + return StrUtil.blankToDefault(value, "").trim(); + } +} diff --git a/nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/qo/QmdReportManagementQO.java b/nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/qo/QmdReportManagementQO.java new file mode 100644 index 00000000..b66539e3 --- /dev/null +++ b/nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/qo/QmdReportManagementQO.java @@ -0,0 +1,98 @@ +package com.nflg.wms.common.pojo.qo; + +import com.fasterxml.jackson.annotation.JsonAlias; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; +import lombok.Data; + +/** + * QMD报表管理查询参数 + */ +public class QmdReportManagementQO { + + @Data + public static class IqcReportQO { + + /** + * 物料ID + */ + @JsonAlias("material_id") + @NotNull(message = "物料ID不能为空") + private Long materialId; + + /** + * 版本号 + */ + @NotBlank(message = "版本号不能为空") + private String version; + } + + @Data + public static class IqcVersionQO { + + /** + * 物料ID + */ + @JsonAlias("material_id") + @NotNull(message = "物料ID不能为空") + private Long materialId; + } + + @Data + public static class PdiReportQO { + + /** + * 机型编号 + */ + @JsonAlias("model_no") + @NotBlank(message = "机型编号不能为空") + private String modelNo; + + /** + * 检测版本 + */ + @JsonAlias("inspection_version") + @NotBlank(message = "检测版本不能为空") + private String inspectionVersion; + } + + @Data + public static class PdiVersionQO { + + /** + * 机型编号 + */ + @JsonAlias("model_no") + @NotBlank(message = "机型编号不能为空") + private String modelNo; + } + + @Data + public static class PqcReportQO { + + /** + * 机型编号 + */ + @JsonAlias("model_no") + @NotBlank(message = "机型编号不能为空") + private String modelNo; + + /** + * 规则版本 + */ + @JsonAlias("rule_version") + @NotNull(message = "规则版本不能为空") + private Integer ruleVersion; + } + + @Data + public static class PqcVersionQO { + + /** + * 机型编号 + */ + @JsonAlias("model_no") + @NotBlank(message = "机型编号不能为空") + private String modelNo; + } +} diff --git a/nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/vo/QmdReportManagementVO.java b/nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/vo/QmdReportManagementVO.java new file mode 100644 index 00000000..1659a428 --- /dev/null +++ b/nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/vo/QmdReportManagementVO.java @@ -0,0 +1,111 @@ +package com.nflg.wms.common.pojo.vo; + +import lombok.Data; + +/** + * QMD报表管理返回值 + */ +public class QmdReportManagementVO { + + @Data + public static class IqcReportItemVO { + + /** + * 检测项ID + */ + private Long inspectionItemId; + + /** + * 检测项名称 + */ + private String inspectionItemName; + + /** + * 有该检测项的版本号 + */ + private String versions; + } + + @Data + public static class PdiReportItemVO { + + /** + * 状态：0为静态，1为动态，2为特殊 + */ + private Integer status; + + /** + * 状态名称 + */ + private String statusName; + + /** + * 部件ID + */ + private Long pdiComponentId; + + /** + * 部件名称 + */ + private String pdiComponentName; + + /** + * 检测项ID + */ + private Long inspectionItemId; + + /** + * 检测项名称 + */ + private String inspectionItemName; + + /** + * 有该检测项的版本号 + */ + private String versions; + } + + @Data + public static class PqcReportItemVO { + + /** + * 机型编号 + */ + private String modelNo; + + /** + * 步装字典ID + */ + private Long stepDicItemId; + + /** + * 步装名称 + */ + private String stepName; + + /** + * 检查点ID + */ + private Long inspectionPointId; + + /** + * 检查点名称 + */ + private String inspectionPointName; + + /** + * 检测项ID + */ + private Long inspectionItemId; + + /** + * 检测项名称 + */ + private String inspectionItemName; + + /** + * 有该检测项的版本号 + */ + private String versions; + } +}