package cn.iocoder.yudao.module.mes.service.pd.knowledge;
|
|
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
|
import cn.iocoder.yudao.framework.common.pojo.PageParam;
|
import cn.iocoder.yudao.framework.common.pojo.PageResult;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.knowledge.KnowledgeDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.knowledge.KnowledgeStandardDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.knowledge.KnowledgeResourceDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.knowledge.KnowledgeReferenceDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pd.knowledge.KnowledgeMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pd.knowledge.KnowledgeStandardMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pd.knowledge.KnowledgeResourceMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pd.knowledge.KnowledgeReferenceMapper;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdProductBomDO;
|
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService;
|
import cn.iocoder.yudao.module.mes.service.md.item.MesMdProductBomService;
|
import jakarta.annotation.Resource;
|
import org.springframework.stereotype.Service;
|
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.Objects;
|
import java.util.stream.Collectors;
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.invalidParamException;
|
|
/** 已发布知识的条件匹配；草稿和停用版本不参与推荐。 */
|
@Service
|
public class KnowledgeSearchService {
|
@Resource private KnowledgeMapper knowledgeMapper;
|
@Resource private KnowledgeStandardMapper standardMapper;
|
@Resource private KnowledgeResourceMapper resourceMapper;
|
@Resource private KnowledgeReferenceMapper referenceMapper;
|
@Resource private MesMdItemService itemService;
|
@Resource private MesMdProductBomService bomService;
|
|
public PageResult<KnowledgeDO> page(PageParam page, String name) {
|
return knowledgeMapper.selectPage(page, new LambdaQueryWrapperX<KnowledgeDO>()
|
.likeIfPresent(KnowledgeDO::getName, name).orderByDesc(KnowledgeDO::getId));
|
}
|
|
public Detail get(Long id) {
|
KnowledgeDO record = knowledgeMapper.selectById(id);
|
if (record == null) return null;
|
List<String> standards = standardMapper.selectList(new LambdaQueryWrapperX<KnowledgeStandardDO>()
|
.eq(KnowledgeStandardDO::getKnowledgeId, id)).stream()
|
.map(KnowledgeStandardDO::getStandardCode).toList();
|
List<KnowledgeResourceDO> resources = resourceMapper.selectList(new LambdaQueryWrapperX<KnowledgeResourceDO>()
|
.eq(KnowledgeResourceDO::getKnowledgeId, id));
|
List<KnowledgeReferenceDO> references = referenceMapper.selectList(new LambdaQueryWrapperX<KnowledgeReferenceDO>()
|
.eq(KnowledgeReferenceDO::getKnowledgeId, id));
|
return new Detail(record, standards, resources, references);
|
}
|
|
public record Detail(KnowledgeDO knowledge, List<String> standards, List<KnowledgeResourceDO> resources, List<KnowledgeReferenceDO> references) {}
|
|
public List<KnowledgeDO> match(KnowledgeMatch.Request request) {
|
if (request.bomId() != null && request.productId() == null) throw invalidParamException("请选择 BOM 明细所属的物料");
|
if (request.productId() != null) itemService.validateItemExists(request.productId());
|
Set<Long> productBomItems;
|
if (request.productId() != null) {
|
productBomItems = bomService.getProductBomListByItemId(request.productId()).stream()
|
.filter(bom -> Objects.equals(bom.getItemId(), request.productId()) && Objects.equals(bom.getStatus(), 0)).map(MesMdProductBomDO::getBomItemId)
|
.filter(Objects::nonNull).collect(Collectors.toSet());
|
} else productBomItems = Set.of();
|
if (request.bomId() != null && !productBomItems.contains(request.bomId()))
|
throw invalidParamException("所选 BOM 子物料不存在、未启用或不属于该物料");
|
Set<Long> candidateBomItems = request.bomId() == null ? productBomItems : Set.of(request.bomId());
|
List<KnowledgeDO> records = knowledgeMapper.selectList(new LambdaQueryWrapperX<KnowledgeDO>()
|
.eq(KnowledgeDO::getStatus, 1).orderByDesc(KnowledgeDO::getId));
|
if (records.isEmpty()) return List.of();
|
List<Long> ids = records.stream().map(KnowledgeDO::getId).toList();
|
Map<Long, Set<String>> standards = standardMapper.selectList(new LambdaQueryWrapperX<KnowledgeStandardDO>()
|
.in(KnowledgeStandardDO::getKnowledgeId, ids)).stream()
|
.collect(Collectors.groupingBy(KnowledgeStandardDO::getKnowledgeId,
|
Collectors.mapping(KnowledgeStandardDO::getStandardCode, Collectors.toSet())));
|
return records.stream().filter(record -> {
|
if (record.getBomId() != null && !candidateBomItems.contains(record.getBomId())) return false;
|
// 已按 BOM 子物料比对，向纯规则传递当前知识对应的约束。
|
var resolvedRequest = new KnowledgeMatch.Request(request.productId(), record.getBomId(), request.voltage(), request.market(), request.standards());
|
return KnowledgeMatch.matches(new KnowledgeMatch.Criteria(record.getProductItemId(), record.getBomId(),
|
record.getVoltageMin(), record.getVoltageMax(), record.getMarket(),
|
standards.getOrDefault(record.getId(), Set.of())), resolvedRequest);
|
}).toList();
|
}
|
}
|
