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.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.quality.mapper.QualityTestStandardBindingMapper;
|
import com.ruoyi.quality.mapper.QualityTestStandardMapper;
|
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 CustomerMapper customerMapper;
|
private final SupplierManageMapper supplierManageMapper;
|
private final ApprovalTemplateMapper approvalTemplateMapper;
|
private final QualityTestStandardMapper qualityTestStandardMapper;
|
private final QualityTestStandardBindingMapper qualityTestStandardBindingMapper;
|
|
@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);
|
}
|
|
for (String module : modules) {
|
switch (module) {
|
case "sales" -> addSalesChecks(itemMap);
|
case "purchase" -> addPurchaseChecks(itemMap);
|
case "quality" -> addQualityChecks(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 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 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;
|
}
|
}
|
