package com.ruoyi.mock.service.impl;
|
|
import com.alibaba.fastjson2.JSON;
|
import com.alibaba.fastjson2.JSONArray;
|
import com.alibaba.fastjson2.JSONObject;
|
import com.ruoyi.ai.assistant.Assistant;
|
import com.ruoyi.approve.mapper.ApprovalInstanceMapper;
|
import com.ruoyi.approve.mapper.ApprovalInstanceNodeMapper;
|
import com.ruoyi.approve.mapper.ApprovalRecordMapper;
|
import com.ruoyi.approve.mapper.ApprovalTaskMapper;
|
import com.ruoyi.approve.pojo.ApprovalInstance;
|
import com.ruoyi.approve.pojo.ApprovalInstanceNode;
|
import com.ruoyi.approve.pojo.ApprovalRecord;
|
import com.ruoyi.approve.pojo.ApprovalTask;
|
import com.ruoyi.approve.service.ApprovalInstanceService;
|
import com.ruoyi.basic.mapper.ProductMapper;
|
import com.ruoyi.basic.mapper.ProductModelMapper;
|
import com.ruoyi.basic.pojo.Customer;
|
import com.ruoyi.basic.pojo.Product;
|
import com.ruoyi.basic.pojo.ProductModel;
|
import com.ruoyi.basic.pojo.SupplierManage;
|
import com.ruoyi.basic.service.ICustomerService;
|
import com.ruoyi.basic.service.ISupplierService;
|
import com.ruoyi.common.enums.ReviewStatusEnum;
|
import com.ruoyi.common.enums.StockInQualifiedRecordTypeEnum;
|
import com.ruoyi.common.enums.StockOutQualifiedRecordTypeEnum;
|
import com.ruoyi.common.utils.OrderUtils;
|
import com.ruoyi.mock.dto.DataGenerateRequest;
|
import com.ruoyi.mock.prompt.MockDataPrompt;
|
import com.ruoyi.mock.service.DataGenerateService;
|
import com.ruoyi.mock.vo.DataGenerateResult;
|
import com.ruoyi.mock.vo.DataGenerateResult.ModuleSummary;
|
import com.ruoyi.procurementrecord.utils.StockUtils;
|
import com.ruoyi.production.bean.dto.ProductionOrderPickDto;
|
import com.ruoyi.production.bean.dto.ProductionPlanDto;
|
import com.ruoyi.production.bean.dto.ProductionProductMainDto;
|
import com.ruoyi.production.bean.vo.ProductionBomStructureVo;
|
import com.ruoyi.production.mapper.*;
|
import com.ruoyi.production.pojo.*;
|
import com.ruoyi.production.service.ProductionOrderPickService;
|
import com.ruoyi.production.service.ProductionOrderService;
|
import com.ruoyi.production.service.ProductionPlanService;
|
import com.ruoyi.production.service.ProductionProductMainService;
|
import com.ruoyi.purchase.dto.PurchaseLedgerDto;
|
import com.ruoyi.purchase.pojo.PurchaseLedger;
|
import com.ruoyi.purchase.service.IPurchaseLedgerService;
|
import com.ruoyi.project.system.domain.SysDept;
|
import com.ruoyi.project.system.domain.SysUser;
|
import com.ruoyi.project.system.mapper.SysDeptMapper;
|
import com.ruoyi.project.system.mapper.SysUserDeptMapper;
|
import com.ruoyi.project.system.mapper.SysUserMapper;
|
import com.ruoyi.quality.mapper.QualityInspectMapper;
|
import com.ruoyi.quality.pojo.QualityInspect;
|
import com.ruoyi.quality.pojo.QualityTestStandard;
|
import com.ruoyi.quality.pojo.QualityTestStandardBinding;
|
import com.ruoyi.quality.service.IQualityInspectService;
|
import com.ruoyi.quality.service.IQualityTestStandardService;
|
import com.ruoyi.quality.service.QualityTestStandardBindingService;
|
import com.ruoyi.sales.dto.SalesLedgerDto;
|
import com.ruoyi.sales.dto.ShippingInfoDto;
|
import com.ruoyi.sales.mapper.SalesLedgerMapper;
|
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
|
import com.ruoyi.sales.mapper.ShippingInfoMapper;
|
import com.ruoyi.sales.mapper.ShippingProductDetailMapper;
|
import com.ruoyi.sales.pojo.SalesLedger;
|
import com.ruoyi.sales.pojo.SalesLedgerProduct;
|
import com.ruoyi.sales.pojo.ShippingInfo;
|
import com.ruoyi.sales.pojo.ShippingProductDetail;
|
import com.ruoyi.sales.service.ISalesLedgerService;
|
import com.ruoyi.sales.service.ShippingInfoService;
|
import com.ruoyi.stock.mapper.StockInRecordMapper;
|
import com.ruoyi.stock.mapper.StockInventoryMapper;
|
import com.ruoyi.stock.mapper.StockOutRecordMapper;
|
import com.ruoyi.stock.pojo.StockInventory;
|
import com.ruoyi.stock.pojo.StockOutRecord;
|
import com.ruoyi.stock.dto.StockInventoryDto;
|
import com.ruoyi.stock.service.StockInRecordService;
|
import com.ruoyi.stock.service.StockOutRecordService;
|
import com.ruoyi.stock.service.StockInventoryService;
|
import com.ruoyi.technology.mapper.TechnologyBomStructureMapper;
|
import com.ruoyi.technology.mapper.TechnologyRoutingMapper;
|
import com.ruoyi.technology.mapper.TechnologyRoutingOperationMapper;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.time.temporal.ChronoUnit;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Optional;
|
import java.util.Set;
|
import java.util.concurrent.ThreadLocalRandom;
|
import java.util.stream.Collectors;
|
|
@Slf4j
|
@Service
|
@RequiredArgsConstructor
|
public class DataGenerateServiceImpl implements DataGenerateService {
|
|
private final Assistant assistant;
|
private final ProductMapper productMapper;
|
private final ProductModelMapper productModelMapper;
|
|
private final ICustomerService customerService;
|
private final ISalesLedgerService salesLedgerService;
|
private final ISupplierService supplierService;
|
private final IPurchaseLedgerService purchaseLedgerService;
|
private final IQualityTestStandardService qualityTestStandardService;
|
private final QualityTestStandardBindingService qualityTestStandardBindingService;
|
private final ProductionPlanService productionPlanService;
|
private final ProductionOrderService productionOrderService;
|
private final StockInventoryService stockInventoryService;
|
|
// 采购完整流程需要的service
|
private final ApprovalInstanceService approvalInstanceService;
|
private final ApprovalInstanceMapper approvalInstanceMapper;
|
private final ApprovalInstanceNodeMapper approvalInstanceNodeMapper;
|
private final ApprovalTaskMapper approvalTaskMapper;
|
private final ApprovalRecordMapper approvalRecordMapper;
|
private final IQualityInspectService qualityInspectService;
|
private final QualityInspectMapper qualityInspectMapper;
|
private final StockInRecordService stockInRecordService;
|
private final StockInRecordMapper stockInRecordMapper;
|
|
// 销售完整流程需要的service/mapper
|
private final SalesLedgerMapper salesLedgerMapper;
|
private final SalesLedgerProductMapper salesLedgerProductMapper;
|
private final ProductionPlanMapper productionPlanMapper;
|
private final ProductionOrderMapper productionOrderMapper;
|
private final ProductionOperationTaskMapper productionOperationTaskMapper;
|
private final ProductionProductMainService productionProductMainService;
|
private final ShippingInfoService shippingInfoService;
|
private final ShippingInfoMapper shippingInfoMapper;
|
private final ShippingProductDetailMapper shippingProductDetailMapper;
|
private final StockUtils stockUtils;
|
private final StockOutRecordMapper stockOutRecordMapper;
|
private final StockOutRecordService stockOutRecordService;
|
private final StockInventoryMapper stockInventoryMapper;
|
|
// 工艺数据检测
|
private final TechnologyRoutingMapper technologyRoutingMapper;
|
private final TechnologyRoutingOperationMapper technologyRoutingOperationMapper;
|
private final TechnologyBomStructureMapper technologyBomStructureMapper;
|
|
// 领料
|
private final ProductionOrderPickService productionOrderPickService;
|
private final ProductionOrderBomMapper productionOrderBomMapper;
|
private final ProductionBomStructureMapper productionBomStructureMapper;
|
|
// 用户/角色查询
|
private final SysUserMapper sysUserMapper;
|
private final SysDeptMapper sysDeptMapper;
|
private final SysUserDeptMapper sysUserDeptMapper;
|
|
@Override
|
public DataGenerateResult generate(DataGenerateRequest request) {
|
DataGenerateResult result = new DataGenerateResult();
|
List<ModuleSummary> summaries = new ArrayList<>();
|
List<String> errors = new ArrayList<>();
|
int totalGenerated = 0;
|
|
try {
|
// 构建产品规格分类：通过Product树根节点判断成品/原材料
|
Map<Long, String> productModelIdToCategory = buildProductModelCategoryMap();
|
List<Long> productModelIds = new ArrayList<>(productModelIdToCategory.keySet());
|
|
// 加载已有客户/供应商（不新增，使用已有数据）
|
Map<String, Long> customerNameToId = loadExistingCustomers();
|
Map<String, Long> supplierNameToId = loadExistingSuppliers();
|
List<String> existingCustomerNames = new ArrayList<>(customerNameToId.keySet());
|
List<String> existingSupplierNames = new ArrayList<>(supplierNameToId.keySet());
|
|
// 加载系统用户信息（昵称、角色、部门）
|
List<SysUser> systemUsers = loadSystemUsersWithDetail();
|
|
String systemPrompt = MockDataPrompt.buildSystemPrompt();
|
String userMessage = MockDataPrompt.buildUserMessage(
|
request.getModules(), request.getIndustries(),
|
request.getCountMin(), request.getCountMax(),
|
request.getDateStart(), request.getDateEnd(),
|
request.getAdditionalInfo(),
|
productModelIdToCategory,
|
systemUsers,
|
existingCustomerNames, existingSupplierNames);
|
|
String fullPrompt = systemPrompt + "\n\n" + userMessage;
|
log.info("调用AI生成模拟数据, modules={}, industries={}", request.getModules(), request.getIndustries());
|
String llmResponse = assistant.chat(fullPrompt);
|
log.info("AI返回数据长度: {}", llmResponse != null ? llmResponse.length() : 0);
|
|
if (llmResponse == null || llmResponse.isBlank()) {
|
result.setStatus("FAILED");
|
errors.add("AI未返回任何数据");
|
result.setErrors(errors);
|
return result;
|
}
|
|
List<JSONObject> entities = parseJsonResponse(llmResponse);
|
if (entities.isEmpty()) {
|
result.setStatus("FAILED");
|
errors.add("无法解析AI返回的数据");
|
result.setErrors(errors);
|
return result;
|
}
|
|
// 修正AI生成的日期到指定时间范围内
|
String dateStart = request.getDateStart();
|
String dateEnd = request.getDateEnd();
|
if (dateStart != null && dateEnd != null) {
|
fixDatesInRange(entities, dateStart, dateEnd);
|
}
|
|
Map<String, List<JSONObject>> grouped = entities.stream()
|
.collect(Collectors.groupingBy(e -> e.getString("entity")));
|
|
// Tier 0: 基础数据（客户和供应商不自动生成，使用已有数据）
|
if (grouped.containsKey("qualityTestStandard")) {
|
ModuleSummary s = createQualityStandards(grouped.get("qualityTestStandard"));
|
summaries.add(s);
|
totalGenerated += s.getSuccessCount();
|
}
|
|
// Tier 1: 业务单据
|
if (grouped.containsKey("salesLedger")) {
|
ModuleSummary s = createSalesLedgers(grouped.get("salesLedger"), customerNameToId, request.getDateStart());
|
summaries.add(s);
|
totalGenerated += s.getSuccessCount();
|
}
|
if (grouped.containsKey("purchaseLedger")) {
|
ModuleSummary s = createPurchaseLedgers(grouped.get("purchaseLedger"), supplierNameToId,
|
request.getAdditionalInfo(), request.getDateStart(), request.getDateEnd());
|
summaries.add(s);
|
totalGenerated += s.getSuccessCount();
|
}
|
if (grouped.containsKey("productionPlan")) {
|
ModuleSummary s = createProductionPlans(grouped.get("productionPlan"));
|
summaries.add(s);
|
totalGenerated += s.getSuccessCount();
|
}
|
|
// Tier 2
|
if (grouped.containsKey("productionOrder")) {
|
ModuleSummary s = createProductionOrders(grouped.get("productionOrder"));
|
summaries.add(s);
|
totalGenerated += s.getSuccessCount();
|
}
|
if (grouped.containsKey("qualityTestStandardBinding")) {
|
ModuleSummary s = createQualityBindings(grouped.get("qualityTestStandardBinding"));
|
summaries.add(s);
|
totalGenerated += s.getSuccessCount();
|
}
|
if (grouped.containsKey("stockInventory")) {
|
ModuleSummary s = createStockInventories(grouped.get("stockInventory"));
|
summaries.add(s);
|
totalGenerated += s.getSuccessCount();
|
}
|
|
result.setStatus(errors.isEmpty() ? "SUCCESS" : "PARTIAL");
|
result.setTotalGenerated(totalGenerated);
|
result.setModuleSummaries(summaries);
|
result.setErrors(errors);
|
|
} catch (Exception e) {
|
log.error("数据生成失败", e);
|
result.setStatus("FAILED");
|
errors.add("数据生成异常: " + e.getMessage());
|
result.setErrors(errors);
|
}
|
|
return result;
|
}
|
|
private List<JSONObject> parseJsonResponse(String response) {
|
try {
|
String trimmed = response.trim();
|
if (trimmed.startsWith("```")) {
|
int start = trimmed.indexOf("\n");
|
int end = trimmed.lastIndexOf("```");
|
if (start > 0 && end > start) {
|
trimmed = trimmed.substring(start + 1, end).trim();
|
}
|
}
|
return JSON.parseArray(trimmed, JSONObject.class);
|
} catch (Exception e) {
|
log.warn("JSON解析失败，尝试提取数组片段: {}", e.getMessage());
|
int start = response.indexOf('[');
|
int end = response.lastIndexOf(']');
|
if (start >= 0 && end > start) {
|
return JSON.parseArray(response.substring(start, end + 1), JSONObject.class);
|
}
|
return List.of();
|
}
|
}
|
|
/**
|
* 修正AI生成的日期到指定时间范围内。
|
* 遍历所有实体的所有字段，如果发现日期字符串（yyyy-MM-dd格式）超出范围，替换为范围内的随机日期。
|
*/
|
private void fixDatesInRange(List<JSONObject> entities, String dateStart, String dateEnd) {
|
LocalDate start;
|
LocalDate end;
|
try {
|
start = LocalDate.parse(dateStart);
|
end = LocalDate.parse(dateEnd);
|
} catch (Exception e) {
|
log.warn("日期范围解析失败: {} ~ {}", dateStart, dateEnd);
|
return;
|
}
|
long daysBetween = ChronoUnit.DAYS.between(start, end);
|
if (daysBetween <= 0) {
|
daysBetween = 1;
|
}
|
|
// 所有已知的日期字段名
|
java.util.Set<String> dateFields = java.util.Set.of(
|
"entryDate", "executionDate", "deliveryDate", "requiredDate",
|
"promisedDeliveryDate", "planCompleteTime", "maintenanceTime",
|
"checkTime", "registerDate"
|
);
|
|
for (JSONObject entity : entities) {
|
for (String key : dateFields) {
|
String val = entity.getString(key);
|
if (val != null && val.matches("\\d{4}-\\d{2}-\\d{2}")) {
|
try {
|
LocalDate d = LocalDate.parse(val);
|
if (d.isBefore(start) || d.isAfter(end)) {
|
LocalDate fixed = start.plusDays(ThreadLocalRandom.current().nextLong(daysBetween + 1));
|
entity.put(key, fixed.toString());
|
log.debug("修正日期 {}: {} -> {}", key, val, fixed);
|
}
|
} catch (Exception ignored) {
|
}
|
} else if (val != null && !val.matches("\\d{4}-\\d{2}-\\d{2}")) {
|
// AI返回了无效日期格式，直接替换为范围内的随机日期
|
LocalDate fixed = start.plusDays(ThreadLocalRandom.current().nextLong(daysBetween + 1));
|
entity.put(key, fixed.toString());
|
log.debug("修正无效日期 {}: {} -> {}", key, val, fixed);
|
}
|
}
|
// 修正合同编号中的日期: CG-20230601-001 -> CG-YYYYMMDD-001
|
for (String key : java.util.Set.of("purchaseContractNumber", "salesContractNo", "standardNo", "batchNo")) {
|
String val = entity.getString(key);
|
if (val != null && val.matches(".*\\d{8}.*")) {
|
String datePart = val.replaceAll(".*?(\\d{8}).*", "$1");
|
try {
|
// 验证提取到的是有效日期
|
String dateStr = datePart.substring(0, 4) + "-" + datePart.substring(4, 6) + "-" + datePart.substring(6, 8);
|
LocalDate d = LocalDate.parse(dateStr);
|
if (d.isBefore(start) || d.isAfter(end)) {
|
LocalDate fixed = start.plusDays(ThreadLocalRandom.current().nextLong(daysBetween + 1));
|
String newDatePart = fixed.format(java.time.format.DateTimeFormatter.BASIC_ISO_DATE);
|
String newVal = val.replace(datePart, newDatePart);
|
entity.put(key, newVal);
|
log.debug("修正编号 {}: {} -> {}", key, val, newVal);
|
}
|
} catch (Exception ignored) {
|
}
|
}
|
}
|
}
|
}
|
|
// ---- Tier 0: 基础数据 ----
|
|
/**
|
* 从数据库加载已有客户名称→ID映射
|
*/
|
private Map<String, Long> loadExistingCustomers() {
|
Map<String, Long> map = new HashMap<>();
|
List<Customer> customers = customerService.list();
|
for (Customer c : customers) {
|
if (c.getCustomerName() != null) {
|
map.put(c.getCustomerName(), c.getId());
|
}
|
}
|
return map;
|
}
|
|
/**
|
* 从数据库加载已有供应商名称→ID映射
|
*/
|
private Map<String, Long> loadExistingSuppliers() {
|
Map<String, Long> map = new HashMap<>();
|
List<SupplierManage> suppliers = supplierService.list();
|
for (SupplierManage s : suppliers) {
|
if (s.getSupplierName() != null) {
|
map.put(s.getSupplierName(), s.getId());
|
}
|
}
|
return map;
|
}
|
|
/**
|
* 加载系统用户信息（含角色和部门名称）
|
*/
|
private List<SysUser> loadSystemUsersWithDetail() {
|
return sysUserMapper.selectUserListWithDetail();
|
}
|
|
/**
|
* 构建产品规格ID→顶级产品分类名称的映射
|
* 通过Product树向上找到根节点，判断"成品"/"原材料"/"半成品"
|
*/
|
private Map<Long, String> buildProductModelCategoryMap() {
|
// 加载所有Product节点
|
List<Product> allProducts = productMapper.selectList(null);
|
Map<Long, Product> productMap = allProducts.stream()
|
.collect(Collectors.toMap(Product::getId, p -> p, (a, b) -> a));
|
|
// 对每个Product，沿parentId向上找到根节点名称
|
Map<Long, String> productIdToRootName = new HashMap<>();
|
for (Product p : allProducts) {
|
if (productIdToRootName.containsKey(p.getId())) continue;
|
// 向上遍历找根
|
List<Long> chain = new ArrayList<>();
|
Long currentId = p.getId();
|
while (currentId != null) {
|
chain.add(currentId);
|
Product current = productMap.get(currentId);
|
if (current == null || current.getParentId() == null) break;
|
currentId = current.getParentId();
|
}
|
// 根节点的productName就是分类名
|
Product root = productMap.get(chain.get(chain.size() - 1));
|
String rootName = root != null ? root.getProductName() : "其他";
|
for (Long id : chain) {
|
productIdToRootName.put(id, rootName);
|
}
|
}
|
|
// 对每个ProductModel，通过productId找到其所属分类
|
List<ProductModel> allModels = productModelMapper.selectList(null);
|
Map<Long, String> result = new HashMap<>();
|
for (ProductModel m : allModels) {
|
String category = m.getProductId() != null
|
? productIdToRootName.getOrDefault(m.getProductId(), "其他")
|
: "其他";
|
result.put(m.getId(), category);
|
}
|
return result;
|
}
|
|
private ModuleSummary createCustomers(List<JSONObject> items, Map<String, Long> nameToId) {
|
int success = 0, fail = 0;
|
for (JSONObject item : items) {
|
try {
|
Customer c = new Customer();
|
c.setCustomerName(item.getString("customerName"));
|
c.setCustomerType(item.getString("customerType"));
|
c.setContactPerson(item.getString("contactPerson"));
|
c.setContactPhone(item.getString("contactPhone"));
|
c.setCompanyAddress(item.getString("companyAddress"));
|
c.setCompanyPhone(item.getString("companyPhone"));
|
c.setTaxpayerIdentificationNumber(item.getString("taxpayerIdentificationNumber"));
|
c.setMaintainer(item.getString("maintainer"));
|
if (item.containsKey("maintenanceTime")) {
|
String mtStr = item.getString("maintenanceTime");
|
if (mtStr != null && mtStr.matches("\\d{4}-\\d{2}-\\d{2}")) {
|
c.setMaintenanceTime(java.sql.Date.valueOf(mtStr));
|
}
|
} else {
|
c.setMaintenanceTime(new java.sql.Date(System.currentTimeMillis()));
|
}
|
if (item.containsKey("bankAccount")) {
|
c.setBankAccount(item.getString("bankAccount"));
|
}
|
if (item.containsKey("basicBankAccount")) {
|
c.setBasicBankAccount(item.getString("basicBankAccount"));
|
}
|
if (item.containsKey("bankCode")) {
|
c.setBankCode(item.getString("bankCode"));
|
}
|
customerService.insertCustomer(c);
|
if (c.getId() != null) {
|
nameToId.put(c.getCustomerName(), c.getId());
|
}
|
success++;
|
} catch (Exception e) {
|
log.warn("创建客户失败: {}", e.getMessage());
|
fail++;
|
}
|
}
|
return summary("sales", "客户", items.size(), success, fail);
|
}
|
|
private ModuleSummary createSuppliers(List<JSONObject> items, Map<String, Long> nameToId) {
|
int success = 0, fail = 0;
|
for (JSONObject item : items) {
|
try {
|
SupplierManage s = new SupplierManage();
|
s.setSupplierName(item.getString("supplierName"));
|
s.setSupplierType(item.getString("supplierType"));
|
s.setContactUserName(item.getString("contactUserName"));
|
s.setContactUserPhone(item.getString("contactUserPhone"));
|
s.setCompanyAddress(item.getString("companyAddress"));
|
s.setCompanyPhone(item.getString("companyPhone"));
|
s.setTaxpayerIdentificationNum(item.getString("taxpayerIdentificationNum"));
|
s.setBankAccountName(item.getString("bankAccountName"));
|
s.setBankAccountNum(item.getString("bankAccountNum"));
|
if (item.containsKey("isWhite")) {
|
s.setIsWhite(item.getInteger("isWhite"));
|
}
|
supplierService.saveSupplier(s);
|
if (s.getId() != null) {
|
nameToId.put(s.getSupplierName(), s.getId());
|
}
|
success++;
|
} catch (Exception e) {
|
log.warn("创建供应商失败: {}", e.getMessage());
|
fail++;
|
}
|
}
|
return summary("purchase", "供应商", items.size(), success, fail);
|
}
|
|
private ModuleSummary createQualityStandards(List<JSONObject> items) {
|
int success = 0, fail = 0;
|
for (JSONObject item : items) {
|
try {
|
QualityTestStandard std = new QualityTestStandard();
|
std.setStandardNo(item.getString("standardNo"));
|
std.setStandardName(item.getString("standardName"));
|
std.setInspectType(item.getInteger("inspectType"));
|
std.setRemark(item.getString("remark"));
|
qualityTestStandardService.save(std);
|
success++;
|
} catch (Exception e) {
|
log.warn("创建检测标准失败: {}", e.getMessage());
|
fail++;
|
}
|
}
|
return summary("quality", "检测标准", items.size(), success, fail);
|
}
|
|
// ---- Tier 1: 业务单据 ----
|
|
private ModuleSummary createSalesLedgers(List<JSONObject> items, Map<String, Long> customerNameToId, String dateStart) {
|
int success = 0, fail = 0;
|
for (JSONObject item : items) {
|
try {
|
String customerName = item.getString("customerName");
|
Long customerId = customerNameToId.get(customerName);
|
|
SalesLedgerDto dto = new SalesLedgerDto();
|
dto.setCustomerId(customerId);
|
dto.setCustomerName(customerName);
|
dto.setProjectName(item.getString("projectName"));
|
dto.setSalesman(item.getString("salesman"));
|
dto.setPaymentMethod(item.getString("paymentMethod"));
|
dto.setType(item.getInteger("type"));
|
|
// 录入人：优先用AI返回的，否则从"销售"角色/部门随机选
|
String entryPerson = item.getString("entryPerson");
|
if (entryPerson == null || entryPerson.isBlank()) {
|
SysUser salesUser = randomUserByKeyword("销售");
|
entryPerson = salesUser != null ? salesUser.getNickName() : "系统";
|
}
|
dto.setEntryPerson(entryPerson);
|
|
// 业务员：优先用AI返回的，否则从"销售"角色/部门随机选
|
String salesman = dto.getSalesman();
|
if (salesman == null || salesman.isBlank()) {
|
SysUser salesUser = randomUserByKeyword("销售");
|
salesman = salesUser != null ? salesUser.getNickName() : "系统";
|
dto.setSalesman(salesman);
|
}
|
// customerId为null会导致"客户不存在"异常，跳过
|
if (customerId == null) {
|
log.warn("跳过销售台账，客户[{}]不存在", customerName);
|
fail++;
|
continue;
|
}
|
LocalDate entryDate = null;
|
if (item.containsKey("entryDate")) {
|
String entryDateStr = item.getString("entryDate");
|
if (entryDateStr != null && entryDateStr.matches("\\d{4}-\\d{2}-\\d{2}")) {
|
entryDate = LocalDate.parse(entryDateStr);
|
dto.setEntryDate(java.sql.Date.valueOf(entryDateStr));
|
} else {
|
dto.setEntryDate(java.sql.Date.valueOf(dateStart));
|
}
|
}
|
if (item.containsKey("executionDate")) {
|
String execDateStr = item.getString("executionDate");
|
if (execDateStr != null && execDateStr.matches("\\d{4}-\\d{2}-\\d{2}")) {
|
dto.setExecutionDate(LocalDate.parse(execDateStr));
|
} else {
|
dto.setExecutionDate(LocalDate.parse(dateStart));
|
}
|
}
|
if (item.containsKey("deliveryDate")) {
|
String delDateStr = item.getString("deliveryDate");
|
if (delDateStr != null && delDateStr.matches("\\d{4}-\\d{2}-\\d{2}")) {
|
dto.setDeliveryDate(LocalDate.parse(delDateStr));
|
} else {
|
dto.setDeliveryDate(LocalDate.parse(dateStart));
|
}
|
}
|
JSONArray productData = item.getJSONArray("productData");
|
boolean hasProduction = false;
|
if (productData != null) {
|
List<SalesLedgerProduct> products = new ArrayList<>();
|
for (int i = 0; i < productData.size(); i++) {
|
JSONObject pd = productData.getJSONObject(i);
|
SalesLedgerProduct slp = new SalesLedgerProduct();
|
slp.setProductId(pd.getLong("productId"));
|
slp.setProductModelId(pd.getLong("productModelId"));
|
slp.setQuantity(pd.getBigDecimal("quantity"));
|
slp.setTaxInclusiveUnitPrice(pd.getBigDecimal("taxInclusiveUnitPrice"));
|
slp.setTaxInclusiveTotalPrice(pd.getBigDecimal("taxInclusiveTotalPrice"));
|
slp.setTaxRate(pd.getBigDecimal("taxRate"));
|
slp.setUnit(pd.getString("unit"));
|
slp.setType(pd.getInteger("type"));
|
if (pd.containsKey("taxExclusiveTotalPrice")) {
|
slp.setTaxExclusiveTotalPrice(pd.getBigDecimal("taxExclusiveTotalPrice"));
|
} else if (pd.getBigDecimal("taxInclusiveTotalPrice") != null && pd.getBigDecimal("taxRate") != null) {
|
slp.setTaxExclusiveTotalPrice(
|
pd.getBigDecimal("taxInclusiveTotalPrice").divide(
|
BigDecimal.ONE.add(pd.getBigDecimal("taxRate").divide(new BigDecimal("100"), 4, RoundingMode.HALF_UP)),
|
2, RoundingMode.HALF_UP));
|
} else {
|
slp.setTaxExclusiveTotalPrice(BigDecimal.ZERO);
|
}
|
slp.setIsProduction(true);
|
products.add(slp);
|
hasProduction = true;
|
}
|
dto.setProductData(products);
|
}
|
salesLedgerService.addOrUpdateSalesLedger(dto);
|
// addOrUpdateSalesLedger内部会自动生成合同号并insert，但dto上没有回写
|
// 直接用dto的entryDate和customerId查最新创建的记录
|
SalesLedger savedLedger = salesLedgerMapper.selectOne(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<SalesLedger>()
|
.eq(SalesLedger::getCustomerId, dto.getCustomerId())
|
.orderByDesc(SalesLedger::getId)
|
.last("limit 1"));
|
if (savedLedger != null && hasProduction) {
|
processSalesFullFlow(savedLedger, entryDate);
|
}
|
success++;
|
} catch (Exception e) {
|
log.warn("创建销售台账失败: {}", e.getMessage(), e);
|
fail++;
|
}
|
}
|
return summary("sales", "销售台账", items.size(), success, fail);
|
}
|
|
// ==================== 销售完整流程 ====================
|
|
/**
|
* 销售完整流程: 生产计划合并下发 → 领料 → 报工 → 质检(可选) → 入库 → 发货 → 出库
|
* 时间以销售录入日期为基准，各环节递推0-3天
|
*/
|
private void processSalesFullFlow(SalesLedger salesLedger, LocalDate entryDate) {
|
try {
|
LocalDate baseDate = entryDate != null ? entryDate : LocalDate.now();
|
|
// 1. 查询销售台账产品（含生产计划）
|
List<SalesLedgerProduct> products = salesLedgerProductMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<SalesLedgerProduct>()
|
.eq(SalesLedgerProduct::getSalesLedgerId, salesLedger.getId())
|
.eq(SalesLedgerProduct::getIsProduction, true));
|
if (products.isEmpty()) {
|
log.info("销售台账[{}]无需生产，跳过生产流程", salesLedger.getSalesContractNo());
|
return;
|
}
|
|
// 检查产品是否具备完整的工艺数据（工艺路线、工序、BOM）
|
List<Long> missingTechProductIds = checkTechnologyDataReadiness(products);
|
if (!missingTechProductIds.isEmpty()) {
|
log.warn("销售台账[{}]以下产品缺少工艺数据（工艺路线/工序/BOM），跳过生产流程: {}",
|
salesLedger.getSalesContractNo(), missingTechProductIds);
|
return;
|
}
|
|
// 2. 生产计划合并下发 → 生产订单
|
LocalDate planDate = baseDate.plusDays(ThreadLocalRandom.current().nextInt(0, 4));
|
processProductionCombine(salesLedger, planDate);
|
|
// 3. 领料（物料不足自动入库后再领）
|
LocalDate pickDate = planDate.plusDays(ThreadLocalRandom.current().nextInt(0, 3));
|
processMaterialPick(salesLedger, pickDate);
|
|
// 4. 生产报工
|
LocalDate reportDate = pickDate.plusDays(ThreadLocalRandom.current().nextInt(1, 4));
|
processProductionReport(salesLedger, reportDate);
|
|
// 5. 质检提交 + 入库审批
|
LocalDate qualityDate = reportDate.plusDays(ThreadLocalRandom.current().nextInt(0, 4));
|
processSalesQualityAndStockIn(salesLedger, qualityDate);
|
|
// 6. 发货 + 发货审批 + 出库审批
|
LocalDate shipDate = qualityDate.plusDays(ThreadLocalRandom.current().nextInt(0, 4));
|
processSalesShipping(salesLedger, shipDate);
|
|
log.info("销售台账[{}]完整流程处理完毕", salesLedger.getSalesContractNo());
|
} catch (Exception e) {
|
log.warn("销售完整流程处理失败[{}]: {}", salesLedger.getSalesContractNo(), e.getMessage());
|
}
|
}
|
|
/**
|
* 查询角色或部门含指定关键字的用户，随机返回一个
|
*/
|
private SysUser randomUserByKeyword(String keyword) {
|
try {
|
List<Long> userIds = new ArrayList<>(sysUserMapper.getUserByRole(keyword));
|
|
List<SysDept> depts = sysDeptMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<SysDept>()
|
.like(SysDept::getDeptName, keyword)
|
.eq(SysDept::getDelFlag, "0")
|
.eq(SysDept::getStatus, "0"));
|
if (!depts.isEmpty()) {
|
List<Long> deptIds = depts.stream().map(SysDept::getDeptId).collect(Collectors.toList());
|
List<Long> deptUserIds = sysUserDeptMapper.selectDistinctUserIdsByDeptIds(deptIds);
|
userIds.addAll(deptUserIds);
|
}
|
|
if (userIds.isEmpty()) {
|
return null;
|
}
|
List<Long> distinctIds = userIds.stream().distinct().collect(Collectors.toList());
|
Long randomId = distinctIds.get(ThreadLocalRandom.current().nextInt(distinctIds.size()));
|
return sysUserMapper.selectUserById(randomId);
|
} catch (Exception e) {
|
log.warn("查询[{}]角色/部门用户失败: {}", keyword, e.getMessage());
|
return null;
|
}
|
}
|
|
/**
|
* 查询角色或部门含"生产"的用户，随机返回一个
|
*/
|
private SysUser randomProductionUser() {
|
return randomUserByKeyword("生产");
|
}
|
|
/**
|
* 检查产品是否具备完整的工艺数据（工艺路线、工序、BOM）
|
* @return 缺少工艺数据的产品规格ID列表（空列表表示全部就绪）
|
*/
|
private List<Long> checkTechnologyDataReadiness(List<SalesLedgerProduct> products) {
|
List<Long> missingIds = new ArrayList<>();
|
for (SalesLedgerProduct slp : products) {
|
Long productModelId = slp.getProductModelId();
|
if (productModelId == null) continue;
|
|
// 1. 检查工艺路线
|
List<com.ruoyi.technology.pojo.TechnologyRouting> routings =
|
technologyRoutingMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<com.ruoyi.technology.pojo.TechnologyRouting>()
|
.eq(com.ruoyi.technology.pojo.TechnologyRouting::getProductModelId, productModelId));
|
if (routings.isEmpty()) {
|
log.warn("产品规格[{}]缺少工艺路线", productModelId);
|
missingIds.add(productModelId);
|
continue;
|
}
|
Long routingId = routings.get(0).getId();
|
|
// 2. 检查工艺路线是否有关联工序
|
List<com.ruoyi.technology.pojo.TechnologyRoutingOperation> routingOps =
|
technologyRoutingOperationMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<com.ruoyi.technology.pojo.TechnologyRoutingOperation>()
|
.eq(com.ruoyi.technology.pojo.TechnologyRoutingOperation::getTechnologyRoutingId, routingId));
|
if (routingOps.isEmpty()) {
|
log.warn("产品规格[{}]工艺路线[{}]缺少工序", productModelId, routingId);
|
missingIds.add(productModelId);
|
continue;
|
}
|
|
// 3. 检查BOM（可选但有更好）
|
com.ruoyi.technology.pojo.TechnologyRouting routing = routings.get(0);
|
if (routing.getBomId() != null) {
|
List<com.ruoyi.technology.pojo.TechnologyBomStructure> bomStructures =
|
technologyBomStructureMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<com.ruoyi.technology.pojo.TechnologyBomStructure>()
|
.eq(com.ruoyi.technology.pojo.TechnologyBomStructure::getBomId, routing.getBomId()));
|
if (bomStructures.isEmpty()) {
|
log.warn("产品规格[{}]BOM[{}]缺少产品结构", productModelId, routing.getBomId());
|
missingIds.add(productModelId);
|
}
|
}
|
}
|
return missingIds;
|
}
|
|
/**
|
* 生产计划合并下发 → 生产订单（按productModelId分组，同型号合并下发）
|
*/
|
private void processProductionCombine(SalesLedger salesLedger, LocalDate planDate) {
|
try {
|
List<ProductionPlan> plans = productionPlanMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ProductionPlan>()
|
.eq(ProductionPlan::getSalesLedgerId, salesLedger.getId())
|
.and(w -> w.eq(ProductionPlan::getStatus, 0).or().isNull(ProductionPlan::getStatus)));
|
if (plans.isEmpty()) {
|
log.info("销售台账[{}]无待下发生产计划", salesLedger.getSalesContractNo());
|
return;
|
}
|
|
// 按productModelId分组，同型号才能合并下发；productModelId为null的单独逐个下发
|
Map<Long, List<ProductionPlan>> grouped = plans.stream()
|
.filter(p -> p.getProductModelId() != null)
|
.collect(Collectors.groupingBy(ProductionPlan::getProductModelId));
|
|
for (Map.Entry<Long, List<ProductionPlan>> entry : grouped.entrySet()) {
|
try {
|
List<ProductionPlan> sameModelPlans = entry.getValue();
|
BigDecimal totalQty = sameModelPlans.stream()
|
.map(p -> Optional.ofNullable(p.getQtyRequired()).orElse(BigDecimal.ZERO))
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
ProductionPlanDto combineDto = new ProductionPlanDto();
|
combineDto.setIds(sameModelPlans.stream().map(ProductionPlan::getId).collect(Collectors.toList()));
|
combineDto.setTotalAssignedQuantity(totalQty);
|
combineDto.setPlanCompleteTime(planDate.plusDays(ThreadLocalRandom.current().nextInt(3, 7)));
|
productionPlanService.combine(combineDto);
|
|
// 修正生产订单的planCompleteTime
|
List<ProductionOrder> orders = productionOrderMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ProductionOrder>()
|
.like(ProductionOrder::getProductionPlanIds, String.valueOf(sameModelPlans.get(0).getId())));
|
for (ProductionOrder order : orders) {
|
order.setPlanCompleteTime(planDate.plusDays(ThreadLocalRandom.current().nextInt(3, 7)));
|
order.setStartTime(planDate.atStartOfDay());
|
productionOrderMapper.updateById(order);
|
}
|
log.info("销售台账[{}]生产计划下发成功, productModelId={}, 计划数: {}",
|
salesLedger.getSalesContractNo(), entry.getKey(), sameModelPlans.size());
|
} catch (Exception e) {
|
log.warn("销售台账[{}]生产计划下发失败, productModelId={}: {}",
|
salesLedger.getSalesContractNo(), entry.getKey(), e.getMessage());
|
}
|
}
|
} catch (Exception e) {
|
log.warn("生产计划下发失败[{}]: {}", salesLedger.getSalesContractNo(), e.getMessage());
|
}
|
}
|
|
/**
|
* 领料: 查询生产订单的BOM领料清单，检查库存，不足则先自动入库审批后再领料
|
*/
|
private void processMaterialPick(SalesLedger salesLedger, LocalDate pickDate) {
|
try {
|
List<ProductionOrder> orders = findOrdersForSalesLedger(salesLedger);
|
if (orders.isEmpty()) {
|
log.info("销售台账[{}]无生产订单，跳过领料", salesLedger.getSalesContractNo());
|
return;
|
}
|
|
for (ProductionOrder order : orders) {
|
try {
|
// 查询订单BOM领料清单
|
List<com.ruoyi.production.bean.vo.ProductionOrderPickVo> pickList = productionOrderService.pick(order.getId());
|
if (pickList == null || pickList.isEmpty()) {
|
log.info("生产订单[{}]无领料清单", order.getId());
|
continue;
|
}
|
|
// 检查库存不足的物料，先自动入库
|
ensureMaterialStock(pickList, pickDate);
|
|
// 重新获取领料清单（入库后批号和库存量已更新）
|
pickList = productionOrderService.pick(order.getId());
|
if (pickList == null || pickList.isEmpty()) {
|
log.info("生产订单[{}]重新获取领料清单为空", order.getId());
|
continue;
|
}
|
|
// 执行领料
|
List<ProductionOrderPickDto> pickDtoList = new ArrayList<>();
|
for (com.ruoyi.production.bean.vo.ProductionOrderPickVo pickVo : pickList) {
|
ProductionOrderPickDto pickDto = new ProductionOrderPickDto();
|
pickDto.setProductionOrderId(order.getId());
|
pickDto.setProductModelId(pickVo.getProductModelId());
|
pickDto.setPickQuantity(pickVo.getDemandedQuantity());
|
pickDto.setPickType((byte) 1);
|
pickDto.setOperationName(pickVo.getOperationName());
|
pickDto.setTechnologyOperationId(pickVo.getTechnologyOperationId());
|
pickDto.setDemandedQuantity(pickVo.getDemandedQuantity());
|
pickDto.setBom(pickVo.getBom());
|
// 设置批号（用更新后的批号列表）
|
if (pickVo.getBatchNoList() != null && !pickVo.getBatchNoList().isEmpty()) {
|
pickDto.setBatchNoList(pickVo.getBatchNoList());
|
pickDto.setBatchNo(pickVo.getBatchNoList().get(0));
|
}
|
pickDtoList.add(pickDto);
|
}
|
|
if (!pickDtoList.isEmpty()) {
|
ProductionOrderPickDto batchDto = new ProductionOrderPickDto();
|
batchDto.setPickList(pickDtoList);
|
productionOrderPickService.savePick(batchDto);
|
log.info("生产订单[{}]领料成功, 领料项数: {}", order.getId(), pickDtoList.size());
|
}
|
} catch (Exception e) {
|
log.warn("生产订单[{}]领料失败: {}", order.getId(), e.getMessage());
|
}
|
}
|
} catch (Exception e) {
|
log.warn("领料流程失败[{}]: {}", salesLedger.getSalesContractNo(), e.getMessage());
|
}
|
}
|
|
/**
|
* 确保物料库存充足，不足则先自动入库审批
|
*/
|
private void ensureMaterialStock(List<com.ruoyi.production.bean.vo.ProductionOrderPickVo> pickList, LocalDate pickDate) {
|
LocalDateTime pickDateTime = pickDate.atTime(9, 0, 0).plusMinutes(ThreadLocalRandom.current().nextInt(0, 480));
|
String pickDateStr = pickDate.format(DateTimeFormatter.BASIC_ISO_DATE);
|
|
for (com.ruoyi.production.bean.vo.ProductionOrderPickVo pickVo : pickList) {
|
BigDecimal demanded = pickVo.getDemandedQuantity() != null ? pickVo.getDemandedQuantity() : BigDecimal.ZERO;
|
BigDecimal stockQty = pickVo.getStockQuantity() != null ? pickVo.getStockQuantity() : BigDecimal.ZERO;
|
BigDecimal shortage = demanded.subtract(stockQty);
|
|
if (shortage.compareTo(BigDecimal.ZERO) <= 0) {
|
continue; // 库存充足
|
}
|
|
// 库存不足，自动入库补充
|
try {
|
StockInventoryDto dto = new StockInventoryDto();
|
dto.setProductModelId(pickVo.getProductModelId());
|
dto.setQualitity(shortage);
|
dto.setRecordType(StockInQualifiedRecordTypeEnum.CUSTOMIZATION_STOCK_IN.getCode());
|
dto.setRecordId(0L);
|
stockInventoryService.addStockInRecordOnly(dto);
|
|
// 查找刚创建的入库记录
|
List<com.ruoyi.stock.pojo.StockInRecord> records = stockInRecordService.list(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<com.ruoyi.stock.pojo.StockInRecord>()
|
.eq(com.ruoyi.stock.pojo.StockInRecord::getProductModelId, pickVo.getProductModelId())
|
.eq(com.ruoyi.stock.pojo.StockInRecord::getApprovalStatus, 0)
|
.orderByDesc(com.ruoyi.stock.pojo.StockInRecord::getId)
|
.last("limit 1"));
|
if (!records.isEmpty()) {
|
com.ruoyi.stock.pojo.StockInRecord record = records.get(0);
|
record.setCreateTime(pickDateTime);
|
record.setBatchNo(fixBatchNoDate(record.getBatchNo(), pickDateStr));
|
record.setInboundBatches(fixBatchNoDate(record.getInboundBatches(), pickDateStr));
|
stockInRecordMapper.updateById(record);
|
// 审批通过
|
stockInRecordService.batchApprove(List.of(record.getId()), ReviewStatusEnum.APPROVED.getCode());
|
log.info("物料[{}]自动入库审批完成, 入库数量: {}", pickVo.getProductModelId(), shortage);
|
}
|
} catch (Exception e) {
|
log.warn("物料[{}]自动入库失败: {}", pickVo.getProductModelId(), e.getMessage());
|
}
|
}
|
}
|
|
/**
|
* 生产报工: 遍历工单逐个报工，从生产角色用户中随机选取报工人
|
*/
|
private void processProductionReport(SalesLedger salesLedger, LocalDate reportDate) {
|
try {
|
List<ProductionOrder> orders = findOrdersForSalesLedger(salesLedger);
|
if (orders.isEmpty()) {
|
log.info("销售台账[{}]无生产订单", salesLedger.getSalesContractNo());
|
return;
|
}
|
|
for (ProductionOrder order : orders) {
|
List<ProductionOperationTask> tasks = productionOperationTaskMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ProductionOperationTask>()
|
.eq(ProductionOperationTask::getProductionOrderId, order.getId())
|
.orderByAsc(ProductionOperationTask::getId));
|
for (ProductionOperationTask task : tasks) {
|
if (task.getStatus() != null && task.getStatus() >= 3) continue;
|
|
// 每次报工随机选一个生产用户
|
SysUser productionUser = randomProductionUser();
|
Long userId = productionUser != null ? productionUser.getUserId() : 1L;
|
String userName = productionUser != null ? productionUser.getNickName() : "系统";
|
|
// 报工
|
ProductionProductMainDto reportDto = new ProductionProductMainDto();
|
reportDto.setProductionOperationTaskId(task.getId());
|
reportDto.setQuantity(task.getPlanQuantity());
|
reportDto.setScrapQty(BigDecimal.ZERO);
|
reportDto.setUserId(userId);
|
reportDto.setUserName(userName);
|
productionProductMainService.addProductMain(reportDto);
|
|
// 修正报工时间（重新从DB读取，避免覆盖addProductMain更新的completeQuantity）
|
fixProductionReportTimes(task.getId(), reportDate);
|
}
|
// 修正生产订单时间（重新从DB读取，避免覆盖addProductMain更新的completeQuantity）
|
fixProductionOrderTimes(order.getId(), reportDate);
|
}
|
log.info("销售台账[{}]生产报工完成, 订单数: {}", salesLedger.getSalesContractNo(), orders.size());
|
} catch (Exception e) {
|
log.warn("生产报工失败[{}]: {}", salesLedger.getSalesContractNo(), e.getMessage());
|
}
|
}
|
|
/**
|
* 查找销售台账关联的生产订单
|
*/
|
private List<ProductionOrder> findOrdersForSalesLedger(SalesLedger salesLedger) {
|
List<ProductionOrder> orders = new ArrayList<>();
|
List<ProductionPlan> plans = productionPlanMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ProductionPlan>()
|
.eq(ProductionPlan::getSalesLedgerId, salesLedger.getId()));
|
for (ProductionPlan plan : plans) {
|
List<ProductionOrder> po = productionOrderMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ProductionOrder>()
|
.like(ProductionOrder::getProductionPlanIds, String.valueOf(plan.getId())));
|
orders.addAll(po);
|
}
|
// 去重
|
return orders.stream()
|
.collect(Collectors.toMap(ProductionOrder::getId, o -> o, (a, b) -> a))
|
.values().stream().collect(Collectors.toList());
|
}
|
|
/**
|
* 修正生产报工相关时间（重新从DB读取task，避免覆盖addProductMain已更新的completeQuantity）
|
*/
|
private void fixProductionReportTimes(Long taskId, LocalDate reportDate) {
|
try {
|
ProductionOperationTask freshTask = productionOperationTaskMapper.selectById(taskId);
|
if (freshTask != null) {
|
freshTask.setActualStartTime(reportDate);
|
freshTask.setActualEndTime(reportDate);
|
freshTask.setStatus(4);
|
productionOperationTaskMapper.updateById(freshTask);
|
}
|
} catch (Exception e) {
|
log.warn("修正生产报工时间失败: {}", e.getMessage());
|
}
|
}
|
|
/**
|
* 修正生产订单时间（重新从DB读取order，避免覆盖addProductMain已更新的completeQuantity）
|
*/
|
private void fixProductionOrderTimes(Long orderId, LocalDate reportDate) {
|
try {
|
ProductionOrder freshOrder = productionOrderMapper.selectById(orderId);
|
if (freshOrder != null) {
|
freshOrder.setStartTime(reportDate.minusDays(1).atStartOfDay());
|
freshOrder.setEndTime(reportDate.plusDays(1).atStartOfDay());
|
freshOrder.setStatus(3);
|
productionOrderMapper.updateById(freshOrder);
|
}
|
} catch (Exception e) {
|
log.warn("修正生产订单时间失败: {}", e.getMessage());
|
}
|
}
|
|
/**
|
* 销售质检提交 + 入库审批
|
*/
|
private void processSalesQualityAndStockIn(SalesLedger salesLedger, LocalDate qualityDate) {
|
try {
|
LocalDateTime qualityDateTime = qualityDate.atTime(9, 0, 0)
|
.plusMinutes(ThreadLocalRandom.current().nextInt(0, 480));
|
|
// 查所有未提交的质检单（inspectType=1过程检验, 2=出厂检验，由生产报工生成）
|
List<QualityInspect> allUnsubmitted = qualityInspectService.list(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<QualityInspect>()
|
.eq(QualityInspect::getInspectState, 0)
|
.in(QualityInspect::getInspectType, java.util.Arrays.asList(1, 2)));
|
for (QualityInspect qi : allUnsubmitted) {
|
qualityInspectService.autoSubmit(qi.getId());
|
qi.setCreateTime(qualityDateTime);
|
qualityInspectMapper.updateById(qi);
|
}
|
log.info("销售台账[{}]质检提交完成, 质检单数: {}", salesLedger.getSalesContractNo(), allUnsubmitted.size());
|
|
// 入库审批：审批所有待审批的入库记录
|
LocalDate stockDate = qualityDate.plusDays(ThreadLocalRandom.current().nextInt(0, 3));
|
LocalDateTime stockDateTime = stockDate.atTime(9, 0, 0)
|
.plusMinutes(ThreadLocalRandom.current().nextInt(0, 480));
|
String stockDateStr = stockDate.format(DateTimeFormatter.BASIC_ISO_DATE);
|
List<com.ruoyi.stock.pojo.StockInRecord> stockRecords = stockInRecordService.list(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<com.ruoyi.stock.pojo.StockInRecord>()
|
.eq(com.ruoyi.stock.pojo.StockInRecord::getApprovalStatus, 0));
|
List<Long> recordIds = stockRecords.stream()
|
.map(com.ruoyi.stock.pojo.StockInRecord::getId)
|
.collect(Collectors.toList());
|
if (!recordIds.isEmpty()) {
|
for (com.ruoyi.stock.pojo.StockInRecord sr : stockRecords) {
|
sr.setCreateTime(stockDateTime);
|
sr.setBatchNo(fixBatchNoDate(sr.getBatchNo(), stockDateStr));
|
sr.setInboundBatches(fixBatchNoDate(sr.getInboundBatches(), stockDateStr));
|
stockInRecordMapper.updateById(sr);
|
}
|
stockInRecordService.batchApprove(recordIds, ReviewStatusEnum.APPROVED.getCode());
|
for (com.ruoyi.stock.pojo.StockInRecord sr : stockRecords) {
|
StockInventory si = stockInventoryMapper.selectOne(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<StockInventory>()
|
.eq(StockInventory::getProductModelId, sr.getProductModelId())
|
.eq(StockInventory::getBatchNo, sr.getBatchNo()));
|
if (si != null) {
|
si.setBatchNo(fixBatchNoDate(si.getBatchNo(), stockDateStr));
|
stockInventoryMapper.updateById(si);
|
}
|
}
|
log.info("销售台账[{}]入库审批完成, 入库记录数: {}", salesLedger.getSalesContractNo(), recordIds.size());
|
}
|
} catch (Exception e) {
|
log.warn("销售质检入库失败[{}]: {}", salesLedger.getSalesContractNo(), e.getMessage());
|
}
|
}
|
|
/**
|
* 发货 + 发货审批通过 + 出库审批
|
*/
|
private void processSalesShipping(SalesLedger salesLedger, LocalDate shipDate) {
|
try {
|
LocalDateTime shipDateTime = shipDate.atTime(9, 0, 0)
|
.plusMinutes(ThreadLocalRandom.current().nextInt(0, 480));
|
String shipDateStr = shipDate.format(DateTimeFormatter.BASIC_ISO_DATE);
|
|
// 查找有库存的产品规格
|
List<SalesLedgerProduct> products = salesLedgerProductMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<SalesLedgerProduct>()
|
.eq(SalesLedgerProduct::getSalesLedgerId, salesLedger.getId()));
|
|
List<ShippingProductDetail> details = new ArrayList<>();
|
for (SalesLedgerProduct slp : products) {
|
StockInventory si = stockInventoryMapper.selectOne(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<StockInventory>()
|
.eq(StockInventory::getProductModelId, slp.getProductModelId())
|
.gt(StockInventory::getQualitity, BigDecimal.ZERO)
|
.orderByDesc(StockInventory::getId)
|
.last("limit 1"));
|
if (si != null) {
|
ShippingProductDetail detail = new ShippingProductDetail();
|
detail.setStockInventoryId(si.getId());
|
detail.setProductModelId(slp.getProductModelId());
|
detail.setBatchNo(si.getBatchNo());
|
detail.setQuantity(slp.getQuantity());
|
details.add(detail);
|
}
|
}
|
if (details.isEmpty()) {
|
log.info("销售台账[{}]无可用库存，跳过发货", salesLedger.getSalesContractNo());
|
return;
|
}
|
|
// 创建发货单
|
ShippingInfoDto shipDto = new ShippingInfoDto();
|
shipDto.setSalesLedgerId(salesLedger.getId());
|
shipDto.setSalesLedgerProductId(products.get(0).getId());
|
shipDto.setCreateTime(shipDateTime);
|
shipDto.setBatchNoDetailList(details);
|
shippingInfoService.addReq(shipDto);
|
|
// 找到发货单和审批实例
|
ShippingInfo shippingInfo = shippingInfoMapper.selectOne(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ShippingInfo>()
|
.eq(ShippingInfo::getShippingNo, shipDto.getShippingNo())
|
.last("limit 1"));
|
if (shippingInfo != null) {
|
shippingInfo.setCreateTime(shipDateTime);
|
shippingInfo.setShippingDate(java.sql.Date.valueOf(shipDate));
|
// 根据客户地址生成发货车牌号
|
shippingInfo.setShippingCarNumber(generateCarNumber(salesLedger.getCustomerName()));
|
shippingInfoMapper.updateById(shippingInfo);
|
|
// 发货审批自动通过
|
ApprovalInstance shipApproval = approvalInstanceMapper.selectOne(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ApprovalInstance>()
|
.eq(ApprovalInstance::getBusinessId, shippingInfo.getId())
|
.eq(ApprovalInstance::getBusinessType, 7L)
|
.eq(ApprovalInstance::getDeleted, 0)
|
.orderByDesc(ApprovalInstance::getId)
|
.last("limit 1"));
|
if (shipApproval != null) {
|
LocalDate shipApproveDate = shipDate.plusDays(ThreadLocalRandom.current().nextInt(0, 3));
|
LocalDateTime shipApproveDateTime = shipApproveDate.atTime(9, 0, 0)
|
.plusMinutes(ThreadLocalRandom.current().nextInt(0, 480));
|
approvalInstanceService.autoApprove(shipApproval.getId());
|
fixApprovalTimes(shipApproval.getId(), shipApproveDateTime);
|
|
shippingInfo.setStatus("已发货");
|
shippingInfo.setShippingDate(java.sql.Date.valueOf(shipApproveDate));
|
shippingInfoMapper.updateById(shippingInfo);
|
}
|
|
// 出库审批
|
LocalDate outDate = shipDate.plusDays(ThreadLocalRandom.current().nextInt(0, 3));
|
LocalDateTime outDateTime = outDate.atTime(9, 0, 0)
|
.plusMinutes(ThreadLocalRandom.current().nextInt(0, 480));
|
String outDateStr = outDate.format(DateTimeFormatter.BASIC_ISO_DATE);
|
List<StockOutRecord> outRecords = stockOutRecordMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<StockOutRecord>()
|
.eq(StockOutRecord::getRecordId, shippingInfo.getId())
|
.eq(StockOutRecord::getRecordType,
|
String.valueOf(StockOutQualifiedRecordTypeEnum.SALE_SHIP_STOCK_OUT.getCode())));
|
List<Long> outIds = new ArrayList<>();
|
for (StockOutRecord sr : outRecords) {
|
if (sr.getApprovalStatus() == null || sr.getApprovalStatus() == 0 || sr.getApprovalStatus() == 3) {
|
sr.setCreateTime(outDateTime);
|
sr.setOutboundBatches(fixBatchNoDate(sr.getOutboundBatches(), outDateStr));
|
sr.setBatchNo(fixBatchNoDate(sr.getBatchNo(), outDateStr));
|
stockOutRecordMapper.updateById(sr);
|
outIds.add(sr.getId());
|
}
|
}
|
if (!outIds.isEmpty()) {
|
// 出库审批通过（走正式审批流程，内部会扣减库存）
|
stockOutRecordService.batchApprove(outIds, ReviewStatusEnum.APPROVED.getCode());
|
log.info("销售台账[{}]出库审批完成, 出库记录数: {}",
|
salesLedger.getSalesContractNo(), outIds.size());
|
}
|
}
|
log.info("销售台账[{}]发货流程完成", salesLedger.getSalesContractNo());
|
} catch (Exception e) {
|
log.warn("销售发货流程失败[{}]: {}", salesLedger.getSalesContractNo(), e.getMessage());
|
}
|
}
|
|
private ModuleSummary createPurchaseLedgers(List<JSONObject> items, Map<String, Long> supplierNameToId,
|
String additionalInfo, String dateStart, String dateEnd) {
|
// 是否需要质检，从补充信息判断，默认不需要
|
boolean needQualityInspect = additionalInfo != null
|
&& (additionalInfo.contains("质检") || additionalInfo.contains("需要检验"));
|
int success = 0, fail = 0;
|
for (JSONObject item : items) {
|
try {
|
String supplierName = item.getString("supplierName");
|
Long supplierId = supplierNameToId.get(supplierName);
|
|
PurchaseLedgerDto dto = new PurchaseLedgerDto();
|
dto.setSupplierId(supplierId);
|
dto.setSupplierName(supplierName);
|
dto.setPurchaseContractNumber(item.getString("purchaseContractNumber"));
|
dto.setProjectName(item.getString("projectName"));
|
dto.setContractAmount(item.getBigDecimal("contractAmount"));
|
dto.setPaymentMethod(item.getString("paymentMethod"));
|
|
String entryDateStr = item.getString("entryDate");
|
LocalDate entryDate = null;
|
if (item.containsKey("entryDate") && entryDateStr != null && entryDateStr.matches("\\d{4}-\\d{2}-\\d{2}")) {
|
entryDate = LocalDate.parse(entryDateStr);
|
dto.setEntryDate(java.sql.Date.valueOf(entryDateStr));
|
} else {
|
dto.setEntryDate(java.sql.Date.valueOf(dateStart));
|
}
|
if (item.containsKey("executionDate")) {
|
String execDateStr = item.getString("executionDate");
|
if (execDateStr != null && execDateStr.matches("\\d{4}-\\d{2}-\\d{2}")) {
|
dto.setExecutionDate(java.sql.Date.valueOf(execDateStr));
|
} else {
|
dto.setExecutionDate(java.sql.Date.valueOf(dateStart));
|
}
|
}
|
JSONArray productData = item.getJSONArray("productData");
|
if (productData != null) {
|
List<SalesLedgerProduct> products = new ArrayList<>();
|
for (int i = 0; i < productData.size(); i++) {
|
JSONObject pd = productData.getJSONObject(i);
|
SalesLedgerProduct slp = new SalesLedgerProduct();
|
slp.setProductId(pd.getLong("productId"));
|
slp.setProductModelId(pd.getLong("productModelId"));
|
slp.setQuantity(pd.getBigDecimal("quantity"));
|
slp.setTaxInclusiveUnitPrice(pd.getBigDecimal("taxInclusiveUnitPrice"));
|
slp.setTaxInclusiveTotalPrice(pd.getBigDecimal("taxInclusiveTotalPrice"));
|
slp.setTaxRate(pd.getBigDecimal("taxRate"));
|
slp.setUnit(pd.getString("unit"));
|
slp.setType(2);
|
// 是否质检：从补充信息判断，默认不需要
|
slp.setIsChecked(needQualityInspect);
|
if (pd.containsKey("taxExclusiveTotalPrice")) {
|
slp.setTaxExclusiveTotalPrice(pd.getBigDecimal("taxExclusiveTotalPrice"));
|
} else if (pd.getBigDecimal("taxInclusiveTotalPrice") != null && pd.getBigDecimal("taxRate") != null) {
|
slp.setTaxExclusiveTotalPrice(
|
pd.getBigDecimal("taxInclusiveTotalPrice").divide(
|
BigDecimal.ONE.add(pd.getBigDecimal("taxRate").divide(new BigDecimal("100"), 4, RoundingMode.HALF_UP)),
|
2, RoundingMode.HALF_UP));
|
} else {
|
slp.setTaxExclusiveTotalPrice(BigDecimal.ZERO);
|
}
|
products.add(slp);
|
}
|
dto.setProductData(products);
|
}
|
purchaseLedgerService.addOrEditPurchase(dto);
|
// 通过合同号找到刚创建的采购台账
|
PurchaseLedger savedLedger = purchaseLedgerService.getOne(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<PurchaseLedger>()
|
.eq(PurchaseLedger::getPurchaseContractNumber, dto.getPurchaseContractNumber())
|
.last("limit 1"));
|
if (savedLedger != null) {
|
// 走完整流程：审核通过 → 质检(可选) → 入库 + 入库审核通过
|
processPurchaseFullFlow(savedLedger, needQualityInspect, entryDate, dateEnd);
|
}
|
success++;
|
} catch (Exception e) {
|
log.warn("创建采购台账失败: {}", e.getMessage(), e);
|
fail++;
|
}
|
}
|
return summary("purchase", "采购台账", items.size(), success, fail);
|
}
|
|
/**
|
* 采购完整流程: 审核通过 → 质检(可选) → 入库审核通过
|
* 各环节时间以采购录入日期为基准，偶尔推迟1-3天
|
*/
|
private void processPurchaseFullFlow(PurchaseLedger purchaseLedger, boolean needQualityInspect,
|
LocalDate entryDate, String dateEnd) {
|
try {
|
// 基准日期：采购录入日期，为空则用当天
|
LocalDate baseDate = entryDate != null ? entryDate : LocalDate.now();
|
// 审批时间：基于录入日期，随机推0-3天
|
LocalDate approveDate = baseDate.plusDays(ThreadLocalRandom.current().nextInt(0, 4));
|
LocalDateTime approveDateTime = approveDate.atTime(9, 0, 0)
|
.plusMinutes(ThreadLocalRandom.current().nextInt(0, 480));
|
|
// 1. 审批自动通过
|
ApprovalInstance approvalInstance = approvalInstanceMapper.selectOne(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ApprovalInstance>()
|
.eq(ApprovalInstance::getBusinessId, purchaseLedger.getId())
|
.eq(ApprovalInstance::getBusinessType, 5L)
|
.eq(ApprovalInstance::getDeleted, 0)
|
.orderByDesc(ApprovalInstance::getId)
|
.last("limit 1"));
|
if (approvalInstance != null) {
|
approvalInstanceService.autoApprove(approvalInstance.getId());
|
// 修正审批相关时间为采购录入日期范围
|
fixApprovalTimes(approvalInstance.getId(), approveDateTime);
|
log.info("采购台账[{}]审批通过, 审批日期: {}", purchaseLedger.getPurchaseContractNumber(), approveDate);
|
}
|
|
// 2. 质检流程（如果需要质检）
|
if (needQualityInspect) {
|
// 质检时间：审批之后再推0-3天
|
LocalDate inspectDate = approveDate.plusDays(ThreadLocalRandom.current().nextInt(0, 4));
|
processQualityInspect(purchaseLedger, inspectDate);
|
}
|
|
// 3. 入库审批通过
|
// 入库时间：质检时间（有质检）或审批时间之后再推0-3天
|
LocalDate stockBaseDate = needQualityInspect
|
? approveDate.plusDays(ThreadLocalRandom.current().nextInt(1, 4))
|
: approveDate.plusDays(ThreadLocalRandom.current().nextInt(0, 4));
|
processStockInApprove(purchaseLedger, stockBaseDate);
|
|
} catch (Exception e) {
|
log.warn("采购完整流程处理失败[{}]: {}", purchaseLedger.getPurchaseContractNumber(), e.getMessage());
|
}
|
}
|
|
/**
|
* 修正审批实例及关联节点、任务、记录的时间
|
*/
|
private void fixApprovalTimes(Long instanceId, LocalDateTime dateTime) {
|
try {
|
// 更新审批实例的finishTime和createTime
|
ApprovalInstance instance = approvalInstanceMapper.selectById(instanceId);
|
if (instance != null) {
|
instance.setFinishTime(dateTime);
|
instance.setCreateTime(dateTime.minusHours(1));
|
approvalInstanceMapper.updateById(instance);
|
}
|
|
// 更新审批实例节点的finishTime
|
List<ApprovalInstanceNode> nodes = approvalInstanceNodeMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ApprovalInstanceNode>()
|
.eq(ApprovalInstanceNode::getInstanceId, instanceId));
|
for (ApprovalInstanceNode node : nodes) {
|
node.setFinishTime(dateTime);
|
node.setCreateTime(dateTime.minusHours(1));
|
approvalInstanceNodeMapper.updateById(node);
|
}
|
|
// 更新审批任务的createTime
|
List<ApprovalTask> tasks = approvalTaskMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getInstanceId, instanceId));
|
for (ApprovalTask task : tasks) {
|
task.setCreateTime(dateTime.minusMinutes(30));
|
approvalTaskMapper.updateById(task);
|
}
|
|
// 更新审批记录的createTime
|
List<ApprovalRecord> records = approvalRecordMapper.selectList(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ApprovalRecord>()
|
.eq(ApprovalRecord::getInstanceId, instanceId));
|
for (ApprovalRecord record : records) {
|
record.setCreateTime(dateTime.minusMinutes(10));
|
approvalRecordMapper.updateById(record);
|
}
|
} catch (Exception e) {
|
log.warn("修正审批时间失败: {}", e.getMessage());
|
}
|
}
|
|
/**
|
* 质检: 找到采购关联的质检单，自动提交为合格
|
*/
|
private void processQualityInspect(PurchaseLedger purchaseLedger, LocalDate inspectDate) {
|
try {
|
LocalDateTime inspectDateTime = inspectDate.atTime(9, 0, 0)
|
.plusMinutes(ThreadLocalRandom.current().nextInt(0, 480));
|
List<QualityInspect> inspectList = qualityInspectService.list(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<QualityInspect>()
|
.eq(QualityInspect::getPurchaseLedgerId, purchaseLedger.getId()));
|
for (QualityInspect qi : inspectList) {
|
if (qi.getInspectState() == null || qi.getInspectState() == 0) {
|
qualityInspectService.autoSubmit(qi.getId());
|
// 修正质检时间
|
qi.setCreateTime(inspectDateTime);
|
qualityInspectMapper.updateById(qi);
|
log.info("采购台账[{}]质检单[{}]自动提交合格, 质检日期: {}",
|
purchaseLedger.getPurchaseContractNumber(), qi.getId(), inspectDate);
|
}
|
}
|
} catch (Exception e) {
|
log.warn("质检流程处理失败[{}]: {}", purchaseLedger.getPurchaseContractNumber(), e.getMessage());
|
}
|
}
|
|
/**
|
* 入库审核: 找到入库记录并审批通过，并修正时间与批号日期
|
*/
|
private void processStockInApprove(PurchaseLedger purchaseLedger, LocalDate stockDate) {
|
try {
|
LocalDateTime stockDateTime = stockDate.atTime(9, 0, 0)
|
.plusMinutes(ThreadLocalRandom.current().nextInt(0, 480));
|
String stockDateStr = stockDate.format(java.time.format.DateTimeFormatter.BASIC_ISO_DATE);
|
|
List<com.ruoyi.stock.pojo.StockInRecord> stockRecords = stockInRecordService.list(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<com.ruoyi.stock.pojo.StockInRecord>()
|
.eq(com.ruoyi.stock.pojo.StockInRecord::getRecordId, purchaseLedger.getId())
|
.eq(com.ruoyi.stock.pojo.StockInRecord::getRecordType,
|
String.valueOf(com.ruoyi.common.enums.StockInQualifiedRecordTypeEnum.PURCHASE_STOCK_IN.getCode())));
|
if (stockRecords.isEmpty()) {
|
stockRecords = stockInRecordService.list(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<com.ruoyi.stock.pojo.StockInRecord>()
|
.eq(com.ruoyi.stock.pojo.StockInRecord::getRecordId, purchaseLedger.getId())
|
.eq(com.ruoyi.stock.pojo.StockInRecord::getRecordType,
|
String.valueOf(com.ruoyi.common.enums.StockInQualifiedRecordTypeEnum.CUSTOMIZATION_UNSTOCK_OUT.getCode())));
|
}
|
for (QualityInspect qi : qualityInspectService.list(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<QualityInspect>()
|
.eq(QualityInspect::getPurchaseLedgerId, purchaseLedger.getId()))) {
|
List<com.ruoyi.stock.pojo.StockInRecord> qiRecords = stockInRecordService.list(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<com.ruoyi.stock.pojo.StockInRecord>()
|
.eq(com.ruoyi.stock.pojo.StockInRecord::getRecordId, qi.getId()));
|
stockRecords.addAll(qiRecords);
|
}
|
stockRecords = stockRecords.stream()
|
.collect(Collectors.toMap(com.ruoyi.stock.pojo.StockInRecord::getId, r -> r, (a, b) -> a))
|
.values().stream().collect(Collectors.toList());
|
|
if (!stockRecords.isEmpty()) {
|
List<Long> recordIds = stockRecords.stream()
|
.filter(r -> r.getApprovalStatus() == null || r.getApprovalStatus() == 0)
|
.map(com.ruoyi.stock.pojo.StockInRecord::getId)
|
.collect(Collectors.toList());
|
if (!recordIds.isEmpty()) {
|
// 先修正入库记录的createTime和批号日期（batchApprove内部会用batchNo创建StockInventory）
|
for (Long recordId : recordIds) {
|
com.ruoyi.stock.pojo.StockInRecord sr = stockInRecordMapper.selectById(recordId);
|
if (sr != null) {
|
sr.setCreateTime(stockDateTime);
|
sr.setBatchNo(fixBatchNoDate(sr.getBatchNo(), stockDateStr));
|
String s = OrderUtils.countTodayByCreateTime(stockInRecordMapper, "RK", "inbound_batches", stockDateTime);
|
sr.setInboundBatches(s);
|
stockInRecordMapper.updateById(sr);
|
}
|
}
|
stockInRecordService.batchApprove(recordIds, ReviewStatusEnum.APPROVED.getCode());
|
log.info("采购台账[{}]入库审批通过, 入库日期: {}, 入库记录数: {}",
|
purchaseLedger.getPurchaseContractNumber(), stockDate, recordIds.size());
|
}
|
}
|
} catch (Exception e) {
|
log.warn("入库审批失败[{}]: {}", purchaseLedger.getPurchaseContractNumber(), e.getMessage());
|
}
|
}
|
|
/**
|
* 替换批号中的日期部分（yyyyMMdd → 指定日期）
|
*/
|
/**
|
* 根据客户名称查地址，推断省份简称生成车牌号
|
* 格式: 省份简称 + 字母 + 5位随机数字字母, 如 苏A12345
|
*/
|
private String generateCarNumber(String customerName) {
|
// 省份简称到城市字母的常见映射
|
Map<String, String[]> provinceCityMap = new HashMap<>();
|
provinceCityMap.put("京", new String[]{"A", "B", "C", "E", "F", "G"});
|
provinceCityMap.put("沪", new String[]{"A", "B", "D", "E", "F"});
|
provinceCityMap.put("粤", new String[]{"A", "B", "E", "F", "G", "H", "J", "K"});
|
provinceCityMap.put("苏", new String[]{"A", "B", "E", "F", "G", "H", "J", "K", "L", "M"});
|
provinceCityMap.put("浙", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L"});
|
provinceCityMap.put("鲁", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "U", "V", "W", "Y"});
|
provinceCityMap.put("豫", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "U"});
|
provinceCityMap.put("川", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"});
|
provinceCityMap.put("渝", new String[]{"A", "B", "C", "D"});
|
provinceCityMap.put("鄂", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S"});
|
provinceCityMap.put("湘", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "S"});
|
provinceCityMap.put("闽", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K"});
|
provinceCityMap.put("赣", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M"});
|
provinceCityMap.put("皖", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "R", "S"});
|
provinceCityMap.put("冀", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "R", "T"});
|
provinceCityMap.put("辽", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P"});
|
provinceCityMap.put("吉", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K"});
|
provinceCityMap.put("黑", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "R"});
|
provinceCityMap.put("晋", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M"});
|
provinceCityMap.put("陕", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "V"});
|
provinceCityMap.put("桂", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "R"});
|
provinceCityMap.put("云", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S"});
|
provinceCityMap.put("贵", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J"});
|
provinceCityMap.put("甘", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P"});
|
provinceCityMap.put("琼", new String[]{"A", "B", "C", "D", "E", "F"});
|
provinceCityMap.put("宁", new String[]{"A", "B", "C", "D", "E"});
|
provinceCityMap.put("青", new String[]{"A", "B", "C", "D", "E", "F", "G", "H"});
|
provinceCityMap.put("藏", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J"});
|
provinceCityMap.put("蒙", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M"});
|
provinceCityMap.put("新", new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R"});
|
provinceCityMap.put("津", new String[]{"A", "B", "C", "E", "F", "G", "H", "J", "K", "L", "M", "N", "Q", "R"});
|
|
// 地址关键词到省份简称的映射
|
Map<String, String> addressToProvince = new HashMap<>();
|
addressToProvince.put("北京", "京"); addressToProvince.put("上海", "沪");
|
addressToProvince.put("广州", "粤"); addressToProvince.put("深圳", "粤");
|
addressToProvince.put("东莞", "粤"); addressToProvince.put("佛山", "粤");
|
addressToProvince.put("南京", "苏"); addressToProvince.put("苏州", "苏");
|
addressToProvince.put("无锡", "苏"); addressToProvince.put("南通", "苏");
|
addressToProvince.put("常州", "苏"); addressToProvince.put("徐州", "苏");
|
addressToProvince.put("杭州", "浙"); addressToProvince.put("宁波", "浙");
|
addressToProvince.put("温州", "浙"); addressToProvince.put("嘉兴", "浙");
|
addressToProvince.put("济南", "鲁"); addressToProvince.put("青岛", "鲁");
|
addressToProvince.put("郑州", "豫"); addressToProvince.put("成都", "川");
|
addressToProvince.put("重庆", "渝"); addressToProvince.put("武汉", "鄂");
|
addressToProvince.put("长沙", "湘"); addressToProvince.put("福州", "闽");
|
addressToProvince.put("厦门", "闽"); addressToProvince.put("南昌", "赣");
|
addressToProvince.put("合肥", "皖"); addressToProvince.put("石家庄", "冀");
|
addressToProvince.put("沈阳", "辽"); addressToProvince.put("大连", "辽");
|
addressToProvince.put("长春", "吉"); addressToProvince.put("哈尔滨", "黑");
|
addressToProvince.put("太原", "晋"); addressToProvince.put("西安", "陕");
|
addressToProvince.put("南宁", "桂"); addressToProvince.put("昆明", "云");
|
addressToProvince.put("贵阳", "贵"); addressToProvince.put("兰州", "甘");
|
addressToProvince.put("海口", "琼"); addressToProvince.put("银川", "宁");
|
addressToProvince.put("西宁", "青"); addressToProvince.put("拉萨", "藏");
|
addressToProvince.put("呼和浩特", "蒙"); addressToProvince.put("乌鲁木齐", "新");
|
addressToProvince.put("天津", "津");
|
// 省名映射
|
addressToProvince.put("江苏", "苏"); addressToProvince.put("浙江", "浙");
|
addressToProvince.put("山东", "鲁"); addressToProvince.put("河南", "豫");
|
addressToProvince.put("四川", "川"); addressToProvince.put("湖北", "鄂");
|
addressToProvince.put("湖南", "湘"); addressToProvince.put("福建", "闽");
|
addressToProvince.put("江西", "赣"); addressToProvince.put("安徽", "皖");
|
addressToProvince.put("河北", "冀"); addressToProvince.put("辽宁", "辽");
|
addressToProvince.put("吉林", "吉"); addressToProvince.put("黑龙江", "黑");
|
addressToProvince.put("山西", "晋"); addressToProvince.put("陕西", "陕");
|
addressToProvince.put("广东", "粤"); addressToProvince.put("广西", "桂");
|
addressToProvince.put("云南", "云"); addressToProvince.put("贵州", "贵");
|
addressToProvince.put("甘肃", "甘"); addressToProvince.put("海南", "琼");
|
addressToProvince.put("宁夏", "宁"); addressToProvince.put("青海", "青");
|
addressToProvince.put("西藏", "藏"); addressToProvince.put("内蒙古", "蒙");
|
addressToProvince.put("新疆", "新");
|
|
String province = "苏"; // 默认江苏
|
// 尝试从客户地址推断省份
|
if (customerName != null) {
|
try {
|
Customer customer = customerService.getOne(
|
new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<Customer>()
|
.eq(Customer::getCustomerName, customerName)
|
.last("limit 1"));
|
if (customer != null && customer.getCompanyAddress() != null) {
|
String addr = customer.getCompanyAddress();
|
for (Map.Entry<String, String> e : addressToProvince.entrySet()) {
|
if (addr.contains(e.getKey())) {
|
province = e.getValue();
|
break;
|
}
|
}
|
}
|
} catch (Exception e) {
|
log.debug("查客户地址失败: {}", e.getMessage());
|
}
|
}
|
|
// 生成车牌号: 省份简称 + 城市字母 + 5位随机字符(数字+大写字母)
|
String[] cities = provinceCityMap.getOrDefault(province, new String[]{"A", "B", "C"});
|
String city = cities[ThreadLocalRandom.current().nextInt(cities.length)];
|
String chars = "ABCDEFGHJKLMNPQRSTUVWXYZ0123456789";
|
StringBuilder suffix = new StringBuilder();
|
for (int i = 0; i < 5; i++) {
|
suffix.append(chars.charAt(ThreadLocalRandom.current().nextInt(chars.length())));
|
}
|
return province + city + suffix;
|
}
|
|
private String fixBatchNoDate(String batchNo, String newDate) {
|
if (batchNo == null || batchNo.length() < 8) {
|
return batchNo;
|
}
|
// 批号格式: yyyyMMdd-产品编码-NNN
|
String prefix = batchNo.substring(0, 8);
|
if (prefix.matches("\\d{8}")) {
|
return newDate + batchNo.substring(8);
|
}
|
return batchNo;
|
}
|
|
private ModuleSummary createProductionPlans(List<JSONObject> items) {
|
int success = 0, fail = 0;
|
List<ProductionPlan> createdPlans = new ArrayList<>();
|
for (JSONObject item : items) {
|
try {
|
ProductionPlan plan = new ProductionPlan();
|
plan.setProductModelId(item.getLong("productModelId"));
|
plan.setQtyRequired(item.getBigDecimal("qtyRequired"));
|
plan.setSource(item.getString("source"));
|
plan.setRemark(item.getString("remark"));
|
if (item.containsKey("requiredDate")) {
|
String dateStr = item.getString("requiredDate");
|
if (dateStr != null && dateStr.matches("\\d{4}-\\d{2}-\\d{2}")) {
|
plan.setRequiredDate(LocalDate.parse(dateStr));
|
}
|
}
|
if (item.containsKey("promisedDeliveryDate")) {
|
String dateStr = item.getString("promisedDeliveryDate");
|
if (dateStr != null && dateStr.matches("\\d{4}-\\d{2}-\\d{2}")) {
|
plan.setPromisedDeliveryDate(LocalDate.parse(dateStr));
|
}
|
}
|
productionPlanService.save(plan);
|
createdPlans.add(plan);
|
success++;
|
} catch (Exception e) {
|
log.warn("创建生产计划失败: {}", e.getMessage());
|
fail++;
|
}
|
}
|
|
// 按productModelId分组，自动合并下发
|
Map<Long, List<ProductionPlan>> grouped = createdPlans.stream()
|
.filter(p -> p.getProductModelId() != null)
|
.collect(Collectors.groupingBy(ProductionPlan::getProductModelId));
|
for (Map.Entry<Long, List<ProductionPlan>> entry : grouped.entrySet()) {
|
try {
|
List<Long> planIds = entry.getValue().stream().map(ProductionPlan::getId).collect(Collectors.toList());
|
BigDecimal totalQty = entry.getValue().stream()
|
.map(ProductionPlan::getQtyRequired)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
ProductionPlanDto combineDto = new ProductionPlanDto();
|
combineDto.setIds(planIds);
|
combineDto.setTotalAssignedQuantity(totalQty);
|
combineDto.setPlanCompleteTime(LocalDate.now().plusDays(ThreadLocalRandom.current().nextInt(3, 10)));
|
productionPlanService.combine(combineDto);
|
log.info("生产计划自动下发成功, productModelId={}, 计划数: {}, 下发数量: {}",
|
entry.getKey(), planIds.size(), totalQty);
|
} catch (Exception e) {
|
log.warn("生产计划自动下发失败, productModelId={}: {}", entry.getKey(), e.getMessage());
|
}
|
}
|
|
return summary("production", "生产计划", items.size(), success, fail);
|
}
|
|
// ---- Tier 2: 后续单据 ----
|
|
private ModuleSummary createProductionOrders(List<JSONObject> items) {
|
int success = 0, fail = 0;
|
for (JSONObject item : items) {
|
try {
|
ProductionOrder order = new ProductionOrder();
|
order.setProductModelId(item.getLong("productModelId"));
|
order.setQuantity(item.getBigDecimal("quantity"));
|
if (item.containsKey("planCompleteTime")) {
|
String dateStr = item.getString("planCompleteTime");
|
if (dateStr != null && dateStr.matches("\\d{4}-\\d{2}-\\d{2}")) {
|
order.setPlanCompleteTime(LocalDate.parse(dateStr));
|
}
|
}
|
productionOrderService.saveProductionOrder(order);
|
success++;
|
} catch (Exception e) {
|
log.warn("创建生产订单失败: {}", e.getMessage());
|
fail++;
|
}
|
}
|
return summary("production", "生产订单", items.size(), success, fail);
|
}
|
|
private ModuleSummary createQualityBindings(List<JSONObject> items) {
|
int success = 0, fail = 0;
|
for (JSONObject item : items) {
|
try {
|
QualityTestStandardBinding binding = new QualityTestStandardBinding();
|
binding.setProductId(item.getLong("productId"));
|
binding.setTestStandardId(item.getInteger("testStandardId"));
|
qualityTestStandardBindingService.add(List.of(binding));
|
success++;
|
} catch (Exception e) {
|
log.warn("创建指标绑定失败: {}", e.getMessage());
|
fail++;
|
}
|
}
|
return summary("quality", "指标绑定", items.size(), success, fail);
|
}
|
|
private ModuleSummary createStockInventories(List<JSONObject> items) {
|
int success = 0, fail = 0;
|
for (JSONObject item : items) {
|
try {
|
StockInventoryDto dto = new StockInventoryDto();
|
dto.setProductModelId(item.getLong("productModelId"));
|
dto.setQualitity(item.getBigDecimal("qualitity"));
|
dto.setBatchNo(item.getString("batchNo"));
|
dto.setWarnNum(item.getBigDecimal("warnNum"));
|
dto.setRemark(item.getString("remark"));
|
stockInventoryService.addstockInventory(dto);
|
success++;
|
} catch (Exception e) {
|
log.warn("创建库存记录失败: {}", e.getMessage());
|
fail++;
|
}
|
}
|
return summary("stock", "库存记录", items.size(), success, fail);
|
}
|
|
private ModuleSummary summary(String module, String entityName, int total, int success, int fail) {
|
ModuleSummary s = new ModuleSummary();
|
s.setModule(module);
|
s.setEntityName(entityName);
|
s.setGeneratedCount(total);
|
s.setSuccessCount(success);
|
s.setFailCount(fail);
|
return s;
|
}
|
}
|
