package com.ruoyi.mock.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.ruoyi.approve.pojo.ApprovalTemplate;
|
import com.ruoyi.approve.mapper.ApprovalTemplateMapper;
|
import com.ruoyi.basic.mapper.CustomerMapper;
|
import com.ruoyi.basic.mapper.ProductMapper;
|
import com.ruoyi.basic.mapper.ProductModelMapper;
|
import com.ruoyi.basic.mapper.SupplierManageMapper;
|
import com.ruoyi.common.enums.TypeEnums;
|
import com.ruoyi.mock.dto.DataCheckRequest;
|
import com.ruoyi.mock.service.DataCheckService;
|
import com.ruoyi.mock.vo.DataCheckResult;
|
import com.ruoyi.mock.vo.DataCheckResult.CheckItem;
|
import com.ruoyi.project.system.domain.SysUser;
|
import com.ruoyi.project.system.mapper.SysUserMapper;
|
import com.ruoyi.quality.mapper.QualityTestStandardBindingMapper;
|
import com.ruoyi.quality.mapper.QualityTestStandardMapper;
|
import com.ruoyi.technology.mapper.TechnologyBomMapper;
|
import com.ruoyi.technology.mapper.TechnologyBomStructureMapper;
|
import com.ruoyi.technology.mapper.TechnologyOperationMapper;
|
import com.ruoyi.technology.mapper.TechnologyRoutingMapper;
|
import com.ruoyi.technology.mapper.TechnologyRoutingOperationMapper;
|
import com.ruoyi.technology.pojo.TechnologyBom;
|
import com.ruoyi.technology.pojo.TechnologyBomStructure;
|
import com.ruoyi.technology.pojo.TechnologyRouting;
|
import com.ruoyi.technology.pojo.TechnologyRoutingOperation;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
|
import java.util.ArrayList;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
@Service
|
@RequiredArgsConstructor
|
public class DataCheckServiceImpl implements DataCheckService {
|
|
private final ProductMapper productMapper;
|
private final ProductModelMapper productModelMapper;
|
private final CustomerMapper customerMapper;
|
private final SupplierManageMapper supplierManageMapper;
|
private final ApprovalTemplateMapper approvalTemplateMapper;
|
private final QualityTestStandardMapper qualityTestStandardMapper;
|
private final QualityTestStandardBindingMapper qualityTestStandardBindingMapper;
|
private final TechnologyRoutingMapper technologyRoutingMapper;
|
private final TechnologyRoutingOperationMapper technologyRoutingOperationMapper;
|
private final TechnologyOperationMapper technologyOperationMapper;
|
private final TechnologyBomMapper technologyBomMapper;
|
private final TechnologyBomStructureMapper technologyBomStructureMapper;
|
private final SysUserMapper sysUserMapper;
|
|
@Override
|
public DataCheckResult check(DataCheckRequest request) {
|
List<String> modules = request.getModules();
|
if (modules == null) {
|
modules = List.of();
|
}
|
|
Map<String, CheckItem> itemMap = new LinkedHashMap<>();
|
|
if (!modules.isEmpty()) {
|
addProductCheck(itemMap);
|
addUserChecks(itemMap);
|
}
|
|
for (String module : modules) {
|
switch (module) {
|
case "sales" -> addSalesChecks(itemMap);
|
case "purchase" -> addPurchaseChecks(itemMap);
|
case "quality" -> addQualityChecks(itemMap);
|
case "production" -> addProductionChecks(itemMap);
|
}
|
}
|
|
List<CheckItem> items = new ArrayList<>(itemMap.values());
|
|
DataCheckResult result = new DataCheckResult();
|
result.setItems(items);
|
result.setTotalItems(items.size());
|
result.setPassedItems((int) items.stream().filter(CheckItem::isPassed).count());
|
return result;
|
}
|
|
private void addProductCheck(Map<String, CheckItem> itemMap) {
|
String key = "common:产品数据";
|
if (itemMap.containsKey(key)) {
|
return;
|
}
|
long count = productMapper.selectCount(null);
|
itemMap.put(key, buildItem("common", "产品数据", 1, (int) count,
|
"缺少产品数据，请先在【基础数据-产品管理】中添加至少1条产品"));
|
}
|
|
private void addUserChecks(Map<String, CheckItem> itemMap) {
|
// 1. 系统用户
|
String userKey = "common:系统用户";
|
if (!itemMap.containsKey(userKey)) {
|
List<SysUser> users = sysUserMapper.selectUserListWithDetail();
|
itemMap.put(userKey, buildItem("common", "系统用户", 1, (int) users.size(),
|
"缺少系统用户，请先在【系统管理-用户管理】中添加用户"));
|
}
|
|
// 2. 有角色的用户
|
String userWithRoleKey = "common:用户角色配置";
|
if (!itemMap.containsKey(userWithRoleKey)) {
|
List<SysUser> users = sysUserMapper.selectUserListWithDetail();
|
long withRole = users.stream().filter(u -> u.getRoleNames() != null && !u.getRoleNames().isBlank()).count();
|
itemMap.put(userWithRoleKey, buildItem("common", "用户角色配置", 1, (int) withRole,
|
"没有用户分配角色，请先在【系统管理-用户管理】中为用户分配角色"));
|
}
|
|
// 3. 有部门的用户
|
String userWithDeptKey = "common:用户部门配置";
|
if (!itemMap.containsKey(userWithDeptKey)) {
|
List<SysUser> users = sysUserMapper.selectUserListWithDetail();
|
long withDept = users.stream().filter(u -> u.getDeptNames() != null && !u.getDeptNames().isBlank()).count();
|
itemMap.put(userWithDeptKey, buildItem("common", "用户部门配置", 1, (int) withDept,
|
"没有用户分配部门，请先在【系统管理-用户管理】中为用户分配部门"));
|
}
|
}
|
|
private void addSalesChecks(Map<String, CheckItem> itemMap) {
|
String customerKey = "sales:客户数据";
|
if (!itemMap.containsKey(customerKey)) {
|
long count = customerMapper.selectCount(null);
|
itemMap.put(customerKey, buildItem("sales", "客户数据", 1, (int) count,
|
"缺少客户数据，请先在【基础数据-客户管理】中添加至少1条客户"));
|
}
|
|
String quotationKey = "sales:报价审批模板";
|
if (!itemMap.containsKey(quotationKey)) {
|
long count = approvalTemplateMapper.selectCount(
|
new LambdaQueryWrapper<ApprovalTemplate>()
|
.eq(ApprovalTemplate::getBusinessType, TypeEnums.QUOTATION_APPROVAL.getCode()));
|
itemMap.put(quotationKey, buildItem("sales", "报价审批模板", 1, (int) count,
|
"缺少报价审批模板，请先在【系统管理-审批模板】中创建报价审批模板"));
|
}
|
|
String shippingKey = "sales:发货审批模板";
|
if (!itemMap.containsKey(shippingKey)) {
|
long count = approvalTemplateMapper.selectCount(
|
new LambdaQueryWrapper<ApprovalTemplate>()
|
.eq(ApprovalTemplate::getBusinessType, TypeEnums.SHIPPING_APPROVAL.getCode()));
|
itemMap.put(shippingKey, buildItem("sales", "发货审批模板", 1, (int) count,
|
"缺少发货审批模板，请先在【系统管理-审批模板】中创建发货审批模板"));
|
}
|
}
|
|
private void addPurchaseChecks(Map<String, CheckItem> itemMap) {
|
String supplierKey = "purchase:供应商数据";
|
if (!itemMap.containsKey(supplierKey)) {
|
long count = supplierManageMapper.selectCount(null);
|
itemMap.put(supplierKey, buildItem("purchase", "供应商数据", 1, (int) count,
|
"缺少供应商数据，请先在【基础数据-供应商管理】中添加至少1条供应商"));
|
}
|
|
String tplKey = "purchase:采购审批模板";
|
if (!itemMap.containsKey(tplKey)) {
|
long count = approvalTemplateMapper.selectCount(
|
new LambdaQueryWrapper<ApprovalTemplate>()
|
.eq(ApprovalTemplate::getBusinessType, TypeEnums.PURCHASE_APPROVAL.getCode()));
|
itemMap.put(tplKey, buildItem("purchase", "采购审批模板", 1, (int) count,
|
"缺少采购审批模板，请先在【系统管理-审批模板】中创建采购审批模板"));
|
}
|
}
|
|
private void addQualityChecks(Map<String, CheckItem> itemMap) {
|
String standardKey = "quality:检测标准";
|
if (!itemMap.containsKey(standardKey)) {
|
long count = qualityTestStandardMapper.selectCount(null);
|
itemMap.put(standardKey, buildItem("quality", "检测标准", 1, (int) count,
|
"缺少检测标准，请先在【质量管理-检测标准】中创建检测标准"));
|
}
|
|
String bindingKey = "quality:指标绑定";
|
if (!itemMap.containsKey(bindingKey)) {
|
long count = qualityTestStandardBindingMapper.selectCount(null);
|
itemMap.put(bindingKey, buildItem("quality", "指标绑定", 1, (int) count,
|
"缺少指标绑定，请先在【质量管理-检测标准绑定】中将检测标准与产品绑定"));
|
}
|
}
|
|
private void addProductionChecks(Map<String, CheckItem> itemMap) {
|
// 1. 产品规格
|
String modelKey = "production:产品规格";
|
if (!itemMap.containsKey(modelKey)) {
|
long count = productModelMapper.selectCount(null);
|
itemMap.put(modelKey, buildItem("production", "产品规格", 1, (int) count,
|
"缺少产品规格，请先在【基础数据-产品管理】中为产品添加规格型号"));
|
}
|
|
// 2. 工序
|
String operationKey = "production:工序";
|
if (!itemMap.containsKey(operationKey)) {
|
long count = technologyOperationMapper.selectCount(null);
|
itemMap.put(operationKey, buildItem("production", "工序", 1, (int) count,
|
"缺少工序，请先在【工艺设计-工序管理】中创建工序"));
|
}
|
|
// 3. BOM
|
String bomKey = "production:BOM";
|
if (!itemMap.containsKey(bomKey)) {
|
long count = technologyBomMapper.selectCount(null);
|
itemMap.put(bomKey, buildItem("production", "BOM", 1, (int) count,
|
"缺少BOM，请先在【工艺设计-BOM管理】中创建BOM"));
|
}
|
|
// 4. BOM产品结构
|
String bomStructureKey = "production:BOM产品结构";
|
if (!itemMap.containsKey(bomStructureKey)) {
|
long count = technologyBomStructureMapper.selectCount(null);
|
itemMap.put(bomStructureKey, buildItem("production", "BOM产品结构", 1, (int) count,
|
"缺少BOM产品结构，请先在【工艺设计-BOM管理】中为BOM添加产品结构节点"));
|
}
|
|
// 5. 工艺路线
|
String routingKey = "production:工艺路线";
|
if (!itemMap.containsKey(routingKey)) {
|
long count = technologyRoutingMapper.selectCount(null);
|
itemMap.put(routingKey, buildItem("production", "工艺路线", 1, (int) count,
|
"缺少工艺路线，请先在【工艺设计-工艺路线】中创建工艺路线"));
|
}
|
|
// 6. 工艺路线工序
|
String routingOpKey = "production:工艺路线工序";
|
if (!itemMap.containsKey(routingOpKey)) {
|
long count = technologyRoutingOperationMapper.selectCount(null);
|
itemMap.put(routingOpKey, buildItem("production", "工艺路线工序", 1, (int) count,
|
"缺少工艺路线工序，请先在【工艺设计-工艺路线】中为工艺路线添加工序"));
|
}
|
|
// 7. 关联性检测：有产品规格但无工艺路线的
|
String linkageKey = "production:产品-工艺路线关联";
|
if (!itemMap.containsKey(linkageKey)) {
|
long modelCount = productModelMapper.selectCount(null);
|
long routedCount = technologyRoutingMapper.selectCount(
|
new LambdaQueryWrapper<TechnologyRouting>()
|
.isNotNull(TechnologyRouting::getProductModelId)
|
.gt(TechnologyRouting::getProductModelId, 0));
|
itemMap.put(linkageKey, buildItem("production", "产品-工艺路线关联",
|
(int) Math.min(modelCount, 1), (int) routedCount,
|
"部分产品规格未关联工艺路线，请先在【工艺设计-工艺路线】中为产品规格创建工艺路线"));
|
}
|
|
// 8. 关联性检测：有工艺路线但无工序的
|
String routingOpLinkKey = "production:工艺路线-工序关联";
|
if (!itemMap.containsKey(routingOpLinkKey)) {
|
long routingCount = technologyRoutingMapper.selectCount(null);
|
long routedOpCount = technologyRoutingOperationMapper.selectCount(
|
new LambdaQueryWrapper<TechnologyRoutingOperation>()
|
.gt(TechnologyRoutingOperation::getTechnologyRoutingId, 0));
|
itemMap.put(routingOpLinkKey, buildItem("production", "工艺路线-工序关联",
|
(int) Math.min(routingCount, 1), (int) routedOpCount,
|
"部分工艺路线未添加工序，请先在【工艺设计-工艺路线】中为工艺路线添加工序"));
|
}
|
|
// 9. 关联性检测：有BOM但无产品结构的
|
String bomStructureLinkKey = "production:BOM-产品结构关联";
|
if (!itemMap.containsKey(bomStructureLinkKey)) {
|
long bomCount = technologyBomMapper.selectCount(null);
|
long structureCount = technologyBomStructureMapper.selectCount(
|
new LambdaQueryWrapper<TechnologyBomStructure>()
|
.gt(TechnologyBomStructure::getBomId, 0));
|
itemMap.put(bomStructureLinkKey, buildItem("production", "BOM-产品结构关联",
|
(int) Math.min(bomCount, 1), (int) structureCount,
|
"部分BOM未添加产品结构，请先在【工艺设计-BOM管理】中为BOM添加产品结构节点"));
|
}
|
}
|
|
private CheckItem buildItem(String module, String itemName, int minRequired, int currentCount, String failMessage) {
|
CheckItem item = new CheckItem();
|
item.setModule(module);
|
item.setItemName(itemName);
|
item.setMinRequired(minRequired);
|
item.setCurrentCount(currentCount);
|
item.setPassed(currentCount >= minRequired);
|
item.setMessage(item.isPassed() ? "通过" : failMessage);
|
return item;
|
}
|
}
|
