package com.ruoyi.common.utils;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.ruoyi.basic.dto.ProductModelExcelDto;
|
import com.ruoyi.basic.dto.ProductModelExcelItemDto;
|
import com.ruoyi.common.utils.uuid.UUID;
|
import org.apache.poi.ss.formula.functions.T;
|
import org.springframework.stereotype.Component;
|
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.LocalTime;
|
import java.time.ZoneId;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author :yys
|
* @date : 2025/9/15 15:31
|
*/
|
public class OrderUtils {
|
|
|
/**
|
* 查询当天（基于createTime字段）的记录数量
|
* @param mapper 实体类对应的BaseMapper
|
* @param <T> 实体类泛型
|
* @return 当天记录数量
|
*/
|
public static <T> String countTodayByCreateTime(BaseMapper<T> mapper,String preFix) {
|
// 获取当天开始时间（00:00:00）
|
LocalDateTime todayStart = LocalDateTime.of(
|
LocalDateTime.now().toLocalDate(),
|
LocalTime.MIN
|
);
|
// 获取当天结束时间（23:59:59.999）
|
LocalDateTime todayEnd = LocalDateTime.of(
|
LocalDateTime.now().toLocalDate(),
|
LocalTime.MAX
|
);
|
|
// 转换为Date类型（如果实体类中createTime是LocalDateTime可直接使用）
|
Date startDate = Date.from(todayStart.atZone(ZoneId.systemDefault()).toInstant());
|
Date endDate = Date.from(todayEnd.atZone(ZoneId.systemDefault()).toInstant());
|
|
// 构建查询条件
|
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
|
queryWrapper.ge("create_time", startDate) // 大于等于当天开始
|
.lt("create_time", endDate); // 小于当天结束（避免毫秒精度问题）
|
|
// 执行查询
|
Long aLong = mapper.selectCount(queryWrapper);
|
// 拼接订单编号 preFix + 时间（yyyyMMdd） + 订单数量(001)
|
return preFix + LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE).replaceAll("-", "") + String.format("%03d", (aLong + 1)) + "-" + new Date().getTime();
|
}
|
|
/**
|
* 将平面列表转换为树形结构（含规格型号拆分功能）
|
* @param flatList 导入的平面数据列表
|
* @return 树形结构的根节点列表
|
*/
|
public static List<ProductModelExcelDto> buildTree(List<ProductModelExcelDto> flatList) {
|
// 1. 参数校验
|
if (CollectionUtils.isEmpty(flatList)) {
|
return new ArrayList<>();
|
}
|
|
// 2. 预处理：过滤无效数据 + 规格型号拆分 + 初始化子节点列表
|
List<ProductModelExcelDto> validList = preprocessData(flatList);
|
if (CollectionUtils.isEmpty(validList)) {
|
return new ArrayList<>();
|
}
|
|
// 3. 按层级分组，便于逐层处理
|
Map<Integer, List<ProductModelExcelDto>> levelGroupMap = groupByLevel(validList);
|
|
// 4. 构建节点映射（序号 -> 节点），提高查询效率
|
Map<String, ProductModelExcelDto> nodeMap = buildNodeMap(validList);
|
|
// 5. 逐层构建父子关系
|
buildParentChildRelation(levelGroupMap, nodeMap);
|
|
// 6. 获取根节点（层级1）并排序
|
List<ProductModelExcelDto> rootNodes = getRootNodes(levelGroupMap);
|
sortTreeNodes(rootNodes);
|
|
return rootNodes;
|
}
|
|
/**
|
* 数据预处理：
|
* 1. 过滤无效数据
|
* 2. 规格型号拆分并填充到items集合
|
* 3. 初始化子节点列表
|
*/
|
private static List<ProductModelExcelDto> preprocessData(List<ProductModelExcelDto> flatList) {
|
return flatList.stream()
|
// 过滤核心字段无效的节点
|
.filter(node -> isValidNode(node))
|
// 处理规格型号拆分和items填充
|
.peek(node -> {
|
// 拆分规格型号并填充到items
|
splitModelAndFillItems(node);
|
// 初始化子节点列表（避免空指针）
|
if (node.getChildren() == null) {
|
node.setChildren(new ArrayList<>());
|
}
|
})
|
.collect(Collectors.toList());
|
}
|
|
/**
|
* 验证节点是否有效（核心字段校验）
|
*/
|
private static boolean isValidNode(ProductModelExcelDto node) {
|
if (node == null) {
|
return false;
|
}
|
// 序号必须有效（基础校验）
|
if (!isValidSequence(node.getNumber())) {
|
return false;
|
}
|
// 产品名称非空（业务校验，可根据实际需求调整）
|
return StringUtils.isNotBlank(node.getProductName());
|
}
|
|
/**
|
* 规格型号拆分并填充到items集合
|
* @param node 待处理的节点
|
*/
|
private static void splitModelAndFillItems(ProductModelExcelDto node) {
|
// 1. 获取原始规格型号
|
String originalModel = node.getModel();
|
List<ProductModelExcelItemDto> items = new ArrayList<>();
|
|
if (StringUtils.isNotBlank(originalModel)) {
|
// 2. 按"+"拆分规格型号（如果有多个），处理每个片段
|
List<String> splitModels = Arrays.stream(originalModel.split("\\+"))
|
.map(String::trim)
|
.filter(StringUtils::isNotBlank)
|
.distinct()
|
.collect(Collectors.toList());
|
|
// 3. 为每个规格创建Item（即使只有一个，也生成一个Item）
|
items = splitModels.stream()
|
.map(model -> createExcelItem(node, model))
|
.collect(Collectors.toList());
|
}
|
|
// 4. 填充到节点的items集合（覆盖原有数据）
|
node.setItems(items);
|
}
|
|
/**
|
* 创建ProductModelExcelItemDto对象（继承原节点的公共属性）
|
* @param node 原节点
|
* @param model 拆分后的规格型号
|
* @return 构建好的Item对象
|
*/
|
private static ProductModelExcelItemDto createExcelItem(ProductModelExcelDto node, String model) {
|
ProductModelExcelItemDto item = new ProductModelExcelItemDto();
|
// 1. 拆分后的规格型号
|
item.setModel(model);
|
// 2. 继承原节点的单位（空值处理）
|
item.setUnit(StringUtils.defaultIfBlank(node.getUnit(), ""));
|
// 3. 继承原节点的产品类型（空值处理，默认0表示未知）
|
item.setProductType(Optional.ofNullable(node.getProductType()).orElse(0));
|
// 4. 继承原节点的图纸编号（空值处理）
|
item.setDrawingNumber(StringUtils.defaultIfBlank(node.getDrawingNumber(), ""));
|
return item;
|
}
|
|
/**
|
* 验证序号格式是否有效（支持1、1.1、1.1.1等格式）
|
*/
|
private static boolean isValidSequence(String sequence) {
|
if (StringUtils.isBlank(sequence)) {
|
return false;
|
}
|
// 正则表达式：匹配数字开头，后续可跟.和数字
|
return sequence.trim().matches("^\\d+(\\.\\d+)*$");
|
}
|
|
/**
|
* 按节点层级分组
|
*/
|
private static Map<Integer, List<ProductModelExcelDto>> groupByLevel(List<ProductModelExcelDto> validList) {
|
return validList.stream()
|
.collect(Collectors.groupingBy(
|
node -> getNodeLevel(node.getNumber()), // 计算层级
|
TreeMap::new, // 按层级升序排序
|
Collectors.toList()
|
));
|
}
|
|
/**
|
* 计算节点层级（序号中.的数量 + 1）
|
* 例：1 -> 1级，1.1 -> 2级，1.1.1 -> 3级
|
*/
|
private static int getNodeLevel(String sequence) {
|
if (StringUtils.isBlank(sequence)) {
|
return 0;
|
}
|
String trimmedSeq = sequence.trim();
|
return trimmedSeq.split("\\.").length;
|
}
|
|
/**
|
* 构建节点映射表（序号 -> 节点）
|
*/
|
private static Map<String, ProductModelExcelDto> buildNodeMap(List<ProductModelExcelDto> validList) {
|
return validList.stream()
|
.collect(Collectors.toMap(
|
node -> node.getNumber().trim(), // 键：序号（去空格）
|
node -> node, // 值：节点对象
|
(oldVal, newVal) -> oldVal // 处理重复序号：保留第一个
|
));
|
}
|
|
/**
|
* 构建父子节点关系
|
*/
|
private static void buildParentChildRelation(Map<Integer, List<ProductModelExcelDto>> levelGroupMap,
|
Map<String, ProductModelExcelDto> nodeMap) {
|
// 从层级2开始处理（层级1是根节点，无父节点）
|
for (Map.Entry<Integer, List<ProductModelExcelDto>> entry : levelGroupMap.entrySet()) {
|
int currentLevel = entry.getKey();
|
if (currentLevel <= 1) {
|
continue; // 跳过根节点层级
|
}
|
|
List<ProductModelExcelDto> currentLevelNodes = entry.getValue();
|
for (ProductModelExcelDto currentNode : currentLevelNodes) {
|
// 计算父节点序号
|
String parentSequence = getParentSequence(currentNode.getNumber());
|
if (StringUtils.isBlank(parentSequence)) {
|
continue;
|
}
|
|
// 查找父节点
|
ProductModelExcelDto parentNode = nodeMap.get(parentSequence);
|
if (parentNode != null && parentNode.getChildren() != null) {
|
// 添加到父节点的子节点列表
|
parentNode.getChildren().add(currentNode);
|
}
|
}
|
}
|
}
|
|
/**
|
* 根据当前节点序号获取父节点序号
|
* 例：1.1.2 -> 1.1，1.2 -> 1，1 -> null
|
*/
|
private static String getParentSequence(String currentSequence) {
|
if (StringUtils.isBlank(currentSequence)) {
|
return null;
|
}
|
|
String trimmedSeq = currentSequence.trim();
|
String[] seqParts = trimmedSeq.split("\\.");
|
if (seqParts.length <= 1) {
|
return null; // 根节点无父节点
|
}
|
|
// 去掉最后一部分，拼接父节点序号
|
String[] parentParts = Arrays.copyOfRange(seqParts, 0, seqParts.length - 1);
|
return String.join(".", parentParts);
|
}
|
|
/**
|
* 获取根节点列表（层级1的节点）
|
*/
|
private static List<ProductModelExcelDto> getRootNodes(Map<Integer, List<ProductModelExcelDto>> levelGroupMap) {
|
return levelGroupMap.getOrDefault(1, new ArrayList<>());
|
}
|
|
/**
|
* 递归排序所有节点（按序号数字顺序）
|
*/
|
private static void sortTreeNodes(List<ProductModelExcelDto> nodeList) {
|
if (CollectionUtils.isEmpty(nodeList)) {
|
return;
|
}
|
|
// 排序当前层级节点
|
nodeList.sort(Comparator.comparing(
|
ProductModelExcelDto::getNumber,
|
new SequenceComparator() // 自定义序号比较器
|
));
|
|
// 递归排序子节点
|
for (ProductModelExcelDto node : nodeList) {
|
sortTreeNodes(node.getChildren());
|
}
|
}
|
|
/**
|
* 序号比较器：按数字顺序排序（支持1.10在1.2之后）
|
*/
|
private static class SequenceComparator implements Comparator<String> {
|
@Override
|
public int compare(String seq1, String seq2) {
|
if (StringUtils.isBlank(seq1) && StringUtils.isBlank(seq2)) {
|
return 0;
|
}
|
if (StringUtils.isBlank(seq1)) {
|
return -1;
|
}
|
if (StringUtils.isBlank(seq2)) {
|
return 1;
|
}
|
|
// 分割序号为数字数组
|
String[] parts1 = seq1.trim().split("\\.");
|
String[] parts2 = seq2.trim().split("\\.");
|
|
// 逐段比较数字
|
int minLength = Math.min(parts1.length, parts2.length);
|
for (int i = 0; i < minLength; i++) {
|
int num1 = parseSequencePart(parts1[i]);
|
int num2 = parseSequencePart(parts2[i]);
|
if (num1 != num2) {
|
return num1 - num2;
|
}
|
}
|
|
// 长度不同时，短的在前（如1.1在1.1.1之前）
|
return parts1.length - parts2.length;
|
}
|
|
/**
|
* 解析序号片段为数字（处理异常情况）
|
*/
|
private int parseSequencePart(String part) {
|
try {
|
return Integer.parseInt(part.trim());
|
} catch (NumberFormatException e) {
|
return 0; // 异常情况按0处理
|
}
|
}
|
}
|
|
|
/**
|
* 产品类型映射（1=物料，2=产品，0=未知）
|
*/
|
private static String mapProductType(Integer productType) {
|
return Optional.ofNullable(productType)
|
.map(type -> type == 1 ? "物料" : (type == 2 ? "产品" : "未知"))
|
.orElse("未知");
|
}
|
|
|
|
|
}
|
