package cn.iocoder.yudao.module.mes.api.qc;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
|
import cn.iocoder.yudao.module.crm.api.customer.dto.CrmCustomerRespDTO;
|
import cn.iocoder.yudao.module.mes.api.qc.dto.MesQcReportItemRespDTO;
|
import cn.iocoder.yudao.module.mes.api.qc.dto.MesQcReportRespDTO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.unitmeasure.MesMdUnitMeasureDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.indicator.MesQcIndicatorDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.indicatorresult.MesQcIndicatorResultDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.indicatorresult.MesQcIndicatorResultDetailDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.iqc.MesQcIqcDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.iqc.MesQcIqcLineDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.ipqc.MesQcIpqcDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.ipqc.MesQcIpqcLineDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.oqc.MesQcOqcDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.oqc.MesQcOqcLineDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.rqc.MesQcRqcDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.rqc.MesQcRqcLineDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderDO;
|
import cn.iocoder.yudao.module.mes.enums.qc.MesQcCheckResultEnum;
|
import cn.iocoder.yudao.module.mes.enums.qc.MesQcIndicatorItemTypeEnum;
|
import cn.iocoder.yudao.module.mes.enums.qc.MesQcResultValueTypeEnum;
|
import cn.iocoder.yudao.module.mes.enums.qc.MesQcStatusEnum;
|
import cn.iocoder.yudao.module.mes.enums.qc.MesQcTypeEnum;
|
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService;
|
import cn.iocoder.yudao.module.mes.service.md.unitmeasure.MesMdUnitMeasureService;
|
import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderService;
|
import cn.iocoder.yudao.module.mes.service.qc.indicator.MesQcIndicatorService;
|
import cn.iocoder.yudao.module.mes.service.qc.indicatorresult.MesQcIndicatorResultService;
|
import cn.iocoder.yudao.module.mes.service.qc.iqc.MesQcIqcLineService;
|
import cn.iocoder.yudao.module.mes.service.qc.iqc.MesQcIqcService;
|
import cn.iocoder.yudao.module.mes.service.qc.ipqc.MesQcIpqcLineService;
|
import cn.iocoder.yudao.module.mes.service.qc.ipqc.MesQcIpqcService;
|
import cn.iocoder.yudao.module.mes.service.qc.oqc.MesQcOqcLineService;
|
import cn.iocoder.yudao.module.mes.service.qc.oqc.MesQcOqcService;
|
import cn.iocoder.yudao.module.mes.service.qc.rqc.MesQcRqcLineService;
|
import cn.iocoder.yudao.module.mes.service.qc.rqc.MesQcRqcService;
|
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.Service;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
|
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;
|
|
/**
|
* MES 质检单数据 API 实现类
|
* <p>
|
* 四类质检单的行表结构完全一致（仅父键名不同：iqc_id / ipqc_id / oqc_id / rqc_id），
|
* 所以「取行」只写四个薄适配方法，映射逻辑一份共用。
|
*/
|
@Service
|
@Validated
|
public class MesQcReportApiImpl implements MesQcReportApi {
|
|
/**
|
* 组名合并格里「这一格让位给上面那一行」的标记值。
|
* <p>
|
* 报告侧把它原样写成 HTML 的 {@code hidden} 属性，所以值本身是什么不重要，
|
* 重要的是它非空 —— 空串在两侧渲染器里都表示「不输出这个属性」，也就是这一格照常可见。
|
*/
|
private static final String GROUP_CELL_HIDDEN = "hidden";
|
|
@Resource
|
private MesQcIqcService iqcService;
|
@Resource
|
private MesQcIpqcService ipqcService;
|
@Resource
|
private MesQcOqcService oqcService;
|
@Resource
|
private MesQcRqcService rqcService;
|
|
@Resource
|
private MesQcIqcLineService iqcLineService;
|
@Resource
|
private MesQcIpqcLineService ipqcLineService;
|
@Resource
|
private MesQcOqcLineService oqcLineService;
|
@Resource
|
private MesQcRqcLineService rqcLineService;
|
|
@Resource
|
private MesQcIndicatorResultService indicatorResultService;
|
@Resource
|
private MesQcIndicatorService indicatorService;
|
|
@Resource
|
private MesMdItemService itemService;
|
@Resource
|
private MesMdUnitMeasureService unitMeasureService;
|
@Resource
|
private MesProWorkOrderService workOrderService;
|
@Resource
|
private AdminUserApi adminUserApi;
|
@Resource
|
private SrmSupplierApi srmSupplierApi;
|
@Resource
|
private CrmCustomerApi customerApi;
|
|
@Override
|
public MesQcReportRespDTO getQcReportData(Integer qcType, Long qcId) {
|
if (qcType == null || qcId == null) {
|
return null;
|
}
|
MesQcReportRespDTO resp;
|
List<LineRow> lines;
|
Long inspectorUserId;
|
if (Objects.equals(qcType, MesQcTypeEnum.IQC.getType())) {
|
MesQcIqcDO order = iqcService.getIqc(qcId);
|
if (order == null) {
|
return null;
|
}
|
resp = common(qcType, order.getId(), order.getCode(), order.getName(), order.getTemplateId(),
|
order.getSourceDocType(), order.getSourceDocCode(), order.getItemId(), order.getCheckQuantity(),
|
order.getQualifiedQuantity(), order.getUnqualifiedQuantity(), order.getCheckResult(),
|
order.getInspectDate(), order.getStatus(), order.getRemark());
|
resp.setVendorBatch(defaultStr(order.getVendorBatch()));
|
resp.setVendorName(supplierName(order.getVendorId()));
|
lines = loadIqcLines(qcId);
|
inspectorUserId = order.getInspectorUserId();
|
} else if (Objects.equals(qcType, MesQcTypeEnum.IPQC.getType())) {
|
MesQcIpqcDO order = ipqcService.getIpqc(qcId);
|
if (order == null) {
|
return null;
|
}
|
resp = common(qcType, order.getId(), order.getCode(), order.getName(), order.getTemplateId(),
|
order.getSourceDocType(), order.getSourceDocCode(), order.getItemId(), order.getCheckQuantity(),
|
order.getQualifiedQuantity(), order.getUnqualifiedQuantity(), order.getCheckResult(),
|
order.getInspectDate(), order.getStatus(), order.getRemark());
|
resp.setWorkOrderCode(workOrderCode(order.getWorkOrderId()));
|
lines = loadIpqcLines(qcId);
|
inspectorUserId = order.getInspectorUserId();
|
} else if (Objects.equals(qcType, MesQcTypeEnum.OQC.getType())) {
|
MesQcOqcDO order = oqcService.getOqc(qcId);
|
if (order == null) {
|
return null;
|
}
|
resp = common(qcType, order.getId(), order.getCode(), order.getName(), order.getTemplateId(),
|
order.getSourceDocType(), order.getSourceDocCode(), order.getItemId(), order.getCheckQuantity(),
|
order.getQualifiedQuantity(), order.getUnqualifiedQuantity(), order.getCheckResult(),
|
order.getInspectDate(), order.getStatus(), order.getRemark());
|
resp.setBatchCode(defaultStr(order.getBatchCode()));
|
resp.setClientName(clientName(order.getClientId()));
|
lines = loadOqcLines(qcId);
|
inspectorUserId = order.getInspectorUserId();
|
} else if (Objects.equals(qcType, MesQcTypeEnum.RQC.getType())) {
|
MesQcRqcDO order = rqcService.getRqc(qcId);
|
if (order == null) {
|
return null;
|
}
|
resp = common(qcType, order.getId(), order.getCode(), order.getName(), order.getTemplateId(),
|
order.getSourceDocType(), order.getSourceDocCode(), order.getItemId(), order.getCheckQuantity(),
|
order.getQualifiedQuantity(), order.getUnqualifiedQuantity(), order.getCheckResult(),
|
order.getInspectDate(), order.getStatus(), order.getRemark());
|
resp.setBatchCode(defaultStr(order.getBatchCode()));
|
lines = loadRqcLines(qcId);
|
inspectorUserId = order.getInspectorUserId();
|
} else {
|
throw new IllegalArgumentException("暂不支持 qcType=" + qcType);
|
}
|
|
// 物料与单位：单位优先取行上的（检验时实际用的单位），缺失才回退物料的默认单位
|
MesMdItemDO item = resp.getItemId() == null ? null
|
: itemService.getItemMap(Collections.singletonList(resp.getItemId())).get(resp.getItemId());
|
if (item != null) {
|
resp.setItemCode(defaultStr(item.getCode()));
|
resp.setItemName(defaultStr(item.getName()));
|
resp.setItemSpecification(defaultStr(item.getSpecification()));
|
}
|
Map<Long, MesMdUnitMeasureDO> unitMap = unitMapOf(lines, item);
|
if (item != null) {
|
MesMdUnitMeasureDO itemUnit = unitMap.get(item.getUnitMeasureId());
|
resp.setUnitName(itemUnit == null ? "" : defaultStr(itemUnit.getName()));
|
}
|
resp.setInspectorName(userName(inspectorUserId));
|
BuiltItems built = buildItems(resp.getQcId(), qcType, lines, unitMap, item);
|
resp.setItems(built.items());
|
resp.setChildlessGroupNames(built.childlessGroupNames());
|
resp.setSynthesizedGroupNames(built.synthesizedGroupNames());
|
resp.setMissingIndicatorCount(built.missingIndicatorCount());
|
return resp;
|
}
|
|
/** 四类单据共有的单头字段 */
|
private MesQcReportRespDTO common(Integer qcType, Long qcId, String code, String name, Long templateId,
|
Integer sourceDocType, String sourceDocCode, Long itemId, BigDecimal checkQuantity,
|
BigDecimal qualifiedQuantity, BigDecimal unqualifiedQuantity,
|
Integer checkResult, LocalDateTime inspectDate, Integer status, String remark) {
|
return new MesQcReportRespDTO()
|
.setQcType(qcType)
|
.setQcTypeName(qcTypeName(qcType))
|
.setQcId(qcId)
|
.setQcCode(defaultStr(code))
|
.setQcName(defaultStr(name))
|
.setTemplateId(templateId)
|
.setSourceDocType(sourceDocType)
|
.setSourceDocCode(defaultStr(sourceDocCode))
|
.setItemId(itemId)
|
.setCheckQuantity(checkQuantity)
|
.setQualifiedQuantity(qualifiedQuantity)
|
.setUnqualifiedQuantity(unqualifiedQuantity)
|
.setCheckResult(checkResult)
|
.setCheckResultText(checkResultName(checkResult))
|
.setInspectDate(inspectDate)
|
.setStatus(status)
|
.setStatusName(statusName(status))
|
.setFinished(Objects.equals(status, MesQcStatusEnum.FINISHED.getStatus()))
|
.setRemark(defaultStr(remark));
|
}
|
|
/**
|
* 检验项 = 「样品 × 指标」一行，按分组结构排好序。
|
* <p>
|
* 归属只看指标的 {@code parent_id}：被本单里别的行用 parent_id 指认的分组项就是组头，
|
* 它自己那一行连同所有子项行合成一组，组名在报告里纵向合并。三处刻意不这么做：
|
* 不用 {@code result_type IS NULL} 判分组（方向是反的，丢掉的恰好是带公式的组名、
|
* 留下的恰好是过程参数），不靠行序（行表里组头与它的子项并不相邻），也不把组头丢掉
|
* （组名与公式是分组检验项最不该丢的两样东西）。
|
*/
|
private BuiltItems buildItems(Long qcId, Integer qcType, List<LineRow> lines,
|
Map<Long, MesMdUnitMeasureDO> unitMap, MesMdItemDO item) {
|
if (CollUtil.isEmpty(lines)) {
|
return new BuiltItems(Collections.emptyList(), Collections.emptyList(), Collections.emptyList(), 0);
|
}
|
Map<Long, MesQcIndicatorDO> indicatorMap = indicatorService.getIndicatorMap(
|
convertSet(lines, LineRow::indicatorId));
|
// 样品 → 该样品的实测值明细
|
Map<Long, List<MesQcIndicatorResultDetailDO>> detailMap = Collections.emptyMap();
|
List<MesQcIndicatorResultDO> samples = indicatorResultService.getIndicatorResultListByQcIdAndType(qcId, qcType);
|
if (CollUtil.isNotEmpty(samples)) {
|
List<MesQcIndicatorResultDetailDO> details = indicatorResultService.getIndicatorResultDetailListByResultIds(
|
new ArrayList<>(convertSet(samples, MesQcIndicatorResultDO::getId)));
|
detailMap = new LinkedHashMap<>();
|
for (MesQcIndicatorResultDetailDO detail : details) {
|
detailMap.computeIfAbsent(detail.getResultId(), k -> new ArrayList<>()).add(detail);
|
}
|
}
|
|
// ① 行 → 指标；指标被删掉的行还原不出任何东西，只计数
|
List<LineRow> liveLines = new ArrayList<>(lines.size());
|
List<MesQcIndicatorDO> liveIndicators = new ArrayList<>(lines.size());
|
int missingIndicatorCount = 0;
|
for (LineRow line : lines) {
|
MesQcIndicatorDO indicator = indicatorMap.get(line.indicatorId());
|
if (indicator == null) {
|
missingIndicatorCount++;
|
continue;
|
}
|
liveLines.add(line);
|
liveIndicators.add(indicator);
|
}
|
|
// ② 组头指标可能压根没排进本单（模板只选了子项），补取出来，否则整组的组名与公式会丢
|
Map<Long, MesQcIndicatorDO> allIndicators = new LinkedHashMap<>(indicatorMap);
|
Set<Long> extraIds = new LinkedHashSet<>();
|
for (MesQcIndicatorDO indicator : liveIndicators) {
|
Long parentId = indicator.getParentId();
|
if (parentId != null && parentId != 0 && !allIndicators.containsKey(parentId)) {
|
extraIds.add(parentId);
|
}
|
}
|
if (CollUtil.isNotEmpty(extraIds)) {
|
allIndicators.putAll(indicatorService.getIndicatorMap(extraIds));
|
}
|
|
// ③ 每一行归到「组头自己的行」或「某个组的子项行」
|
Map<Long, List<Integer>> ownLinesOf = new LinkedHashMap<>();
|
Map<Long, List<Integer>> childLinesOf = new LinkedHashMap<>();
|
for (int i = 0; i < liveLines.size(); i++) {
|
Long headId = groupHeadId(liveIndicators.get(i), allIndicators);
|
if (headId == null) {
|
ownLinesOf.computeIfAbsent(liveLines.get(i).indicatorId(), k -> new ArrayList<>()).add(i);
|
} else {
|
childLinesOf.computeIfAbsent(headId, k -> new ArrayList<>()).add(i);
|
}
|
}
|
|
// ④ 顶层条目 = 组 + 独立项；组头那一行从独立项里摘出来当作组的锚点行
|
List<String> childlessGroupNames = new ArrayList<>();
|
List<String> synthesizedGroupNames = new ArrayList<>();
|
List<Entry> entries = new ArrayList<>();
|
for (Map.Entry<Long, List<Integer>> each : childLinesOf.entrySet()) {
|
Long headId = each.getKey();
|
MesQcIndicatorDO head = allIndicators.get(headId);
|
List<Integer> children = sortByIndicatorOrder(each.getValue(), liveIndicators);
|
List<Integer> own = ownLinesOf.remove(headId);
|
if (CollUtil.isEmpty(own)) {
|
synthesizedGroupNames.add(defaultStr(head.getName()));
|
}
|
entries.add(new Entry(head, own == null ? Collections.emptyList() : own, children,
|
children.get(0)));
|
}
|
for (Map.Entry<Long, List<Integer>> each : ownLinesOf.entrySet()) {
|
MesQcIndicatorDO indicator = allIndicators.get(each.getKey());
|
if (MesQcIndicatorItemTypeEnum.isGroup(indicator.getItemType())) {
|
// 指标主数据里是分组项，本单却没有属于它的子项：照常出成独立检验项，只是组不起来
|
childlessGroupNames.add(defaultStr(indicator.getName()));
|
}
|
entries.add(new Entry(indicator, each.getValue(), Collections.emptyList(), each.getValue().get(0)));
|
}
|
// 排序号缺失的排最后；同值保持行序（List.sort 稳定，比较键里再带上首行下标兜底）
|
entries.sort(Comparator.comparingInt((Entry entry) -> sortKey(entry.indicator()))
|
.thenComparingInt(Entry::firstLine));
|
|
// ⑤ 逐条目产出行，并把分组信息下发到每一行
|
List<MesQcReportItemRespDTO> items = new ArrayList<>();
|
int index = 0;
|
for (Entry entry : entries) {
|
List<MesQcReportItemRespDTO> groupRows = new ArrayList<>();
|
for (Integer lineIndex : entry.ownLines()) {
|
groupRows.addAll(expandRows(liveIndicators.get(lineIndex), liveLines.get(lineIndex),
|
samples, detailMap, unitMap, item));
|
}
|
boolean grouped = CollUtil.isNotEmpty(entry.childLines());
|
if (grouped && groupRows.isEmpty()) {
|
// 组头没有自己的行：补一行，否则组名与公式无处可放
|
groupRows.add(toItem(entry.indicator(), emptyLine(entry.indicator()), "", "", "", unitMap, item));
|
}
|
int anchorCount = groupRows.size();
|
List<MesQcReportItemRespDTO> entryRows = new ArrayList<>(groupRows);
|
for (Integer lineIndex : entry.childLines()) {
|
for (MesQcReportItemRespDTO row : expandRows(liveIndicators.get(lineIndex), liveLines.get(lineIndex),
|
samples, detailMap, unitMap, item)) {
|
row.setGroupChildName(defaultStr(liveIndicators.get(lineIndex).getName()));
|
entryRows.add(row);
|
}
|
}
|
int span = grouped ? entryRows.size() : 1;
|
for (int i = 0; i < entryRows.size(); i++) {
|
MesQcReportItemRespDTO row = entryRows.get(i);
|
row.setIndex(++index);
|
// 组名的合并格只挂在组的第一行，组内其余行整格隐藏、让位给它
|
row.setGroupSpan(i == 0 ? span : 1);
|
row.setGroupHidden(i == 0 ? "" : GROUP_CELL_HIDDEN);
|
row.setRequirement(i < anchorCount
|
? anchorRequirement(entry.indicator(), row)
|
: defaultStr(row.getStandardValue()));
|
items.add(row);
|
}
|
}
|
return new BuiltItems(items, childlessGroupNames, synthesizedGroupNames, missingIndicatorCount);
|
}
|
|
/** 装配结果：检验项本身，以及没能成组、被补了行而必须让调用方知道的那些 */
|
private record BuiltItems(List<MesQcReportItemRespDTO> items, List<String> childlessGroupNames,
|
List<String> synthesizedGroupNames, int missingIndicatorCount) {
|
}
|
|
/**
|
* 一个顶层条目：一个分组（组头指标 + 它的子项行），或一个独立检验项。
|
*
|
* @param indicator 组头的指标 / 独立项的指标
|
* @param ownLines 组头自己那些行（独立项时就是它全部的行）在行表里的下标
|
* @param childLines 组内子项行的下标，独立项恒为空
|
* @param firstLine 条目第一行在行表里的下标，排序号相同时靠它保持行序
|
*/
|
private record Entry(MesQcIndicatorDO indicator, List<Integer> ownLines, List<Integer> childLines,
|
int firstLine) {
|
}
|
|
/**
|
* 这一行的组头指标编号：{@code parent_id} 指向一个「分组项」才算数。
|
* <p>
|
* 指向录入项属于指标主数据配置有问题，不能拿它去合并单元格；
|
* 指向的指标已被删除同样不成组。
|
*/
|
private static Long groupHeadId(MesQcIndicatorDO indicator, Map<Long, MesQcIndicatorDO> allIndicators) {
|
Long parentId = indicator.getParentId();
|
if (parentId == null || parentId == 0) {
|
return null;
|
}
|
MesQcIndicatorDO head = allIndicators.get(parentId);
|
return head != null && MesQcIndicatorItemTypeEnum.isGroup(head.getItemType()) ? parentId : null;
|
}
|
|
/** 组头的「检测要求」放公式（分组项只有公式、没有规格），没配公式就照常放标准要求 */
|
private static String anchorRequirement(MesQcIndicatorDO head, MesQcReportItemRespDTO row) {
|
String formula = defaultStr(head.getFormulaText());
|
return formula.isEmpty() ? defaultStr(row.getStandardValue()) : formula;
|
}
|
|
/** 组头没排进本单时补出来的那一行：只有指标本身，没有单据行 */
|
private static LineRow emptyLine(MesQcIndicatorDO head) {
|
return new LineRow(head.getId(), head.getTool(), null, null, null, null, null, null);
|
}
|
|
/**
|
* 一个检验项摊平成若干行：多样品、一个指标被录了多次实测值都会摊平。
|
* 一行都没有（尚未录入实测值）时仍出一行，避免报告漏项。
|
*/
|
private List<MesQcReportItemRespDTO> expandRows(MesQcIndicatorDO indicator, LineRow line,
|
List<MesQcIndicatorResultDO> samples,
|
Map<Long, List<MesQcIndicatorResultDetailDO>> detailMap,
|
Map<Long, MesMdUnitMeasureDO> unitMap, MesMdItemDO item) {
|
List<MesQcReportItemRespDTO> rows = new ArrayList<>();
|
for (MesQcIndicatorResultDO sample : samples) {
|
for (MesQcIndicatorResultDetailDO detail : detailMap.getOrDefault(sample.getId(),
|
Collections.emptyList())) {
|
if (Objects.equals(detail.getIndicatorId(), line.indicatorId())) {
|
rows.add(toItem(indicator, line, sample.getCode(), detail.getValue(), detail.getRemark(),
|
unitMap, item));
|
}
|
}
|
}
|
if (rows.isEmpty()) {
|
rows.add(toItem(indicator, line, "", "", "", unitMap, item));
|
}
|
return rows;
|
}
|
|
/** 排序键：指标没设排序号的一律排最后 */
|
private static int sortKey(MesQcIndicatorDO indicator) {
|
Integer sortOrder = indicator.getSortOrder();
|
return sortOrder == null ? Integer.MAX_VALUE : sortOrder;
|
}
|
|
/** 按各行的指标排序号排，同值保持行序 */
|
private static List<Integer> sortByIndicatorOrder(List<Integer> lineIndexes,
|
List<MesQcIndicatorDO> indicators) {
|
List<Integer> sorted = new ArrayList<>(lineIndexes);
|
sorted.sort(Comparator.comparingInt((Integer i) -> sortKey(indicators.get(i)))
|
.thenComparingInt(Integer::intValue));
|
return sorted;
|
}
|
|
private MesQcReportItemRespDTO toItem(MesQcIndicatorDO indicator, LineRow line, String sampleCode, String value,
|
String detailRemark, Map<Long, MesMdUnitMeasureDO> unitMap,
|
MesMdItemDO item) {
|
MesMdUnitMeasureDO unit = unitMap.get(line.unitMeasureId());
|
if (unit == null && item != null) {
|
unit = unitMap.get(item.getUnitMeasureId());
|
}
|
return new MesQcReportItemRespDTO()
|
.setIndicatorId(indicator.getId())
|
.setIndicatorCode(defaultStr(indicator.getCode()))
|
.setIndicatorName(defaultStr(indicator.getName()))
|
.setCheckMethod(defaultStr(line.checkMethod()))
|
.setTool(defaultStr(line.tool()))
|
.setStandardValue(plain(line.standardValue()))
|
.setActualValue(defaultStr(value))
|
.setUnit(unit == null ? "" : defaultStr(unit.getName()))
|
.setUpperLimit(line.maxThreshold())
|
.setLowerLimit(line.minThreshold())
|
.setValueType(indicator.getResultType())
|
.setValueTypeName(valueTypeName(indicator.getResultType()))
|
.setSampleNo(defaultStr(sampleCode))
|
// 默认「不是子项、不参与合并」；真子项由装配那一步改写
|
.setGroupChildName("")
|
.setGroupSpan(1)
|
.setGroupHidden("")
|
.setRemark(mergeRemark(line.remark(), detailRemark));
|
}
|
|
// ==================== 取行（四类同构） ====================
|
|
private List<LineRow> loadIqcLines(Long qcId) {
|
List<MesQcIqcLineDO> lines = iqcLineService.getIqcLineListByIqcId(qcId);
|
if (CollUtil.isEmpty(lines)) {
|
return Collections.emptyList();
|
}
|
List<LineRow> rows = new ArrayList<>(lines.size());
|
for (MesQcIqcLineDO l : lines) {
|
rows.add(new LineRow(l.getIndicatorId(), l.getTool(), l.getCheckMethod(), l.getStandardValue(),
|
l.getUnitMeasureId(), l.getMaxThreshold(), l.getMinThreshold(), l.getRemark()));
|
}
|
return rows;
|
}
|
|
private List<LineRow> loadIpqcLines(Long qcId) {
|
List<MesQcIpqcLineDO> lines = ipqcLineService.getIpqcLineListByIpqcId(qcId);
|
if (CollUtil.isEmpty(lines)) {
|
return Collections.emptyList();
|
}
|
List<LineRow> rows = new ArrayList<>(lines.size());
|
for (MesQcIpqcLineDO l : lines) {
|
rows.add(new LineRow(l.getIndicatorId(), l.getTool(), l.getCheckMethod(), l.getStandardValue(),
|
l.getUnitMeasureId(), l.getMaxThreshold(), l.getMinThreshold(), l.getRemark()));
|
}
|
return rows;
|
}
|
|
private List<LineRow> loadOqcLines(Long qcId) {
|
List<MesQcOqcLineDO> lines = oqcLineService.getOqcLineListByOqcId(qcId);
|
if (CollUtil.isEmpty(lines)) {
|
return Collections.emptyList();
|
}
|
List<LineRow> rows = new ArrayList<>(lines.size());
|
for (MesQcOqcLineDO l : lines) {
|
rows.add(new LineRow(l.getIndicatorId(), l.getTool(), l.getCheckMethod(), l.getStandardValue(),
|
l.getUnitMeasureId(), l.getMaxThreshold(), l.getMinThreshold(), l.getRemark()));
|
}
|
return rows;
|
}
|
|
private List<LineRow> loadRqcLines(Long qcId) {
|
List<MesQcRqcLineDO> lines = rqcLineService.getRqcLineListByRqcId(qcId);
|
if (CollUtil.isEmpty(lines)) {
|
return Collections.emptyList();
|
}
|
List<LineRow> rows = new ArrayList<>(lines.size());
|
for (MesQcRqcLineDO l : lines) {
|
rows.add(new LineRow(l.getIndicatorId(), l.getTool(), l.getCheckMethod(), l.getStandardValue(),
|
l.getUnitMeasureId(), l.getMaxThreshold(), l.getMinThreshold(), l.getRemark()));
|
}
|
return rows;
|
}
|
|
// ==================== 关联名称 ====================
|
|
private Map<Long, MesMdUnitMeasureDO> unitMapOf(List<LineRow> lines, MesMdItemDO item) {
|
List<Long> unitIds = new ArrayList<>();
|
for (LineRow line : lines) {
|
if (line.unitMeasureId() != null) {
|
unitIds.add(line.unitMeasureId());
|
}
|
}
|
if (item != null && item.getUnitMeasureId() != null) {
|
unitIds.add(item.getUnitMeasureId());
|
}
|
return unitIds.isEmpty() ? Collections.emptyMap() : unitMeasureService.getUnitMeasureMap(unitIds);
|
}
|
|
private String supplierName(Long vendorId) {
|
if (vendorId == null) {
|
return "";
|
}
|
List<SrmSupplierRespDTO> suppliers = srmSupplierApi.getSupplierList(Collections.singleton(vendorId))
|
.getCheckedData();
|
return CollUtil.isEmpty(suppliers) ? "" : defaultStr(suppliers.get(0).getName());
|
}
|
|
private String clientName(Long clientId) {
|
if (clientId == null) {
|
return "";
|
}
|
CrmCustomerRespDTO client = customerApi.getCustomerMap(Collections.singleton(clientId)).get(clientId);
|
return client == null ? "" : defaultStr(client.getName());
|
}
|
|
private String workOrderCode(Long workOrderId) {
|
if (workOrderId == null) {
|
return "";
|
}
|
MesProWorkOrderDO workOrder = workOrderService.getWorkOrder(workOrderId);
|
return workOrder == null ? "" : defaultStr(workOrder.getCode());
|
}
|
|
private String userName(Long userId) {
|
if (userId == null) {
|
return "";
|
}
|
AdminUserRespDTO user = adminUserApi.getUserMap(Collections.singleton(userId)).get(userId);
|
return user == null ? "" : defaultStr(user.getNickname());
|
}
|
|
// ==================== 小工具 ====================
|
|
/** 去掉无意义的小数尾零，避免报告里出现 5.0000 这种由数据库精度带出来的尾巴 */
|
private static String plain(BigDecimal value) {
|
return value == null ? "" : value.stripTrailingZeros().toPlainString();
|
}
|
|
private static String mergeRemark(String lineRemark, String detailRemark) {
|
if (StrUtil.isBlank(lineRemark)) {
|
return defaultStr(detailRemark);
|
}
|
return StrUtil.isBlank(detailRemark) ? lineRemark : lineRemark + "；" + detailRemark;
|
}
|
|
private static String defaultStr(String value) {
|
return value == null ? "" : value;
|
}
|
|
private static String qcTypeName(Integer qcType) {
|
for (MesQcTypeEnum e : MesQcTypeEnum.values()) {
|
if (Objects.equals(e.getType(), qcType)) {
|
return e.getName();
|
}
|
}
|
return "";
|
}
|
|
private static String statusName(Integer status) {
|
for (MesQcStatusEnum e : MesQcStatusEnum.values()) {
|
if (Objects.equals(e.getStatus(), status)) {
|
return e.getName();
|
}
|
}
|
return "";
|
}
|
|
private static String checkResultName(Integer checkResult) {
|
for (MesQcCheckResultEnum e : MesQcCheckResultEnum.values()) {
|
if (Objects.equals(e.getType(), checkResult)) {
|
return e.getName();
|
}
|
}
|
return "";
|
}
|
|
private static String valueTypeName(Integer resultType) {
|
for (MesQcResultValueTypeEnum e : MesQcResultValueTypeEnum.values()) {
|
if (Objects.equals(e.getType(), resultType)) {
|
return e.getName();
|
}
|
}
|
return "";
|
}
|
|
/** 四类行表字段完全一致，抽成统一形态后共用映射 */
|
private record LineRow(Long indicatorId, String tool, String checkMethod, BigDecimal standardValue,
|
Long unitMeasureId, BigDecimal maxThreshold, BigDecimal minThreshold, String remark) {
|
}
|
|
}
|
