feat: 打印流程卡与获取销售订单绑定的工艺路线

gongchunyi

5 天以前 4277ab30de3fedfd5bea68bfa0e111e21df73839

 src/main/java/com/ruoyi/sales/service/impl/SalesLedgerServiceImpl.java

@@ -4,7 +4,7 @@
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -15,6 +15,7 @@
import com.ruoyi.basic.pojo.Customer;
import com.ruoyi.common.enums.FileNameType;
import com.ruoyi.common.enums.SaleEnum;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.EnumUtil;
@@ -26,8 +27,10 @@
import com.ruoyi.other.mapper.TempFileMapper;
import com.ruoyi.other.pojo.TempFile;
import com.ruoyi.production.mapper.*;
import com.ruoyi.production.pojo.ProcessRoute;
import com.ruoyi.production.pojo.ProcessRouteItem;
import com.ruoyi.production.service.ProductionProductMainService;
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.SysUserMapper;
@@ -37,6 +40,9 @@
import com.ruoyi.sales.dto.*;
import com.ruoyi.sales.mapper.*;
import com.ruoyi.sales.pojo.*;
import com.ruoyi.sales.service.ISalesLedgerProcessRouteService;
import com.ruoyi.sales.service.ISalesLedgerProductProcessBindService;
import com.ruoyi.sales.service.ISalesLedgerProductProcessService;
import com.ruoyi.sales.service.ISalesLedgerService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -110,6 +116,13 @@
    private final ProductionProductInputMapper productionProductInputMapper;
    private final QualityInspectMapper qualityInspectMapper;
    private final RedisTemplate<String, String> redisTemplate;

    private final ISalesLedgerProductProcessService salesLedgerProductProcessService;

    private final ISalesLedgerProductProcessBindService salesLedgerProductProcessBindService;

    private final ISalesLedgerProcessRouteService salesLedgerProcessRouteService;

    @Autowired
    private SysDeptMapper sysDeptMapper;
    @Value("${file.upload-dir}")
@@ -154,7 +167,7 @@
            // 查询退货信息
            List<Long> productIds = salesLedgerProducts.stream().map(SalesLedgerProduct::getId).collect(Collectors.toList());
            List<SimpleReturnOrderGroupDto> groupListByProductIds = new ArrayList<>();
            if(CollectionUtils.isNotEmpty(productIds)){
            if (CollectionUtils.isNotEmpty(productIds)) {
                groupListByProductIds = purchaseReturnOrderProductsMapper.getReturnOrderGroupListByProductIds(productIds);
            }
            Map<Long, BigDecimal> returnOrderGroupDtoMap = groupListByProductIds.stream().collect(Collectors.toMap(SimpleReturnOrderGroupDto::getSalesLedgerProductId, SimpleReturnOrderGroupDto::getSumReturnQuantity));
@@ -194,6 +207,23 @@
                    .last("limit 1"));
            if (shippingInfo != null) {
                product.setShippingStatus(shippingInfo.getStatus());
            }
            // 加工明细，先查bind表获取该产品关联的工序及数量
            List<SalesLedgerProductProcessBind> bindList = salesLedgerProductProcessBindService.list(
                    new LambdaQueryWrapper<SalesLedgerProductProcessBind>()
                            .eq(SalesLedgerProductProcessBind::getSalesLedgerProductId, product.getId()));
            if (!bindList.isEmpty()) {
                List<Integer> processIds = bindList.stream()
                        .map(SalesLedgerProductProcessBind::getSalesLedgerProductProcessId)
                        .collect(Collectors.toList());
                Map<Integer, Integer> processQuantityMap = bindList.stream()
                        .collect(Collectors.toMap(
                                SalesLedgerProductProcessBind::getSalesLedgerProductProcessId,
                                SalesLedgerProductProcessBind::getQuantity,
                                (a, b) -> a));
                List<SalesLedgerProductProcess> processList = salesLedgerProductProcessService.listByIds(processIds);
                processList.forEach(p -> p.setQuantity(processQuantityMap.get(p.getId())));
                product.setSalesProductProcessList(processList);
            }
        }

@@ -497,6 +527,39 @@
        return salesLedgerDtoIPage;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saleProcessBind(SalesLedgerProcessRoute salesLedgerProcessRoute) {
        if (salesLedgerProcessRoute == null) {
            throw new ServiceException("绑定失败,数据不能为空");
        }

        SalesLedger salesLedger = baseMapper.selectById(salesLedgerProcessRoute.getSalesLedgerId());
        if (salesLedger == null) {
            throw new ServiceException("绑定失败,销售订单不存在");
        }
        ProcessRoute processRoute = processRouteMapper.selectById(salesLedgerProcessRoute.getProcessRouteId());
        if (processRoute == null) {
            throw new ServiceException("绑定失败,工艺路线不存在");
        }
        //  清除已绑定的数据
        salesLedgerProcessRouteService.remove(new LambdaQueryWrapper<SalesLedgerProcessRoute>().eq(SalesLedgerProcessRoute::getSalesLedgerId, salesLedger.getId()));

        //  将数据迁移到sales_ledger_process_route
        List<ProcessRouteItem> routeItems = processRouteItemMapper.selectList(new LambdaQueryWrapper<ProcessRouteItem>().eq(ProcessRouteItem::getRouteId, processRoute.getId()));
        SalesLedgerProcessRoute ledgerProcessRoute;
        List<SalesLedgerProcessRoute> salesLedgerProcessRouteList = new ArrayList<>();
        for (ProcessRouteItem routeItem : routeItems) {
            ledgerProcessRoute = new SalesLedgerProcessRoute();
            ledgerProcessRoute.setProcessRouteId(processRoute.getId());
            ledgerProcessRoute.setSalesLedgerId(salesLedger.getId());
            ledgerProcessRoute.setProcessRouteItemId(routeItem.getId());
            ledgerProcessRoute.setDragSort(routeItem.getDragSort());
            salesLedgerProcessRouteList.add(ledgerProcessRoute);
        }
        salesLedgerProcessRouteService.saveBatch(salesLedgerProcessRouteList);
    }

    /**
     * 下划线命名转驼峰命名
     */
@@ -544,6 +607,9 @@
        if (!productIds.isEmpty()) {
            salesLedgerProductMapper.deleteBatchIds(productIds);
        }

        //  清除产品的加工
        salesLedgerProductProcessBindService.remove(new LambdaQueryWrapper<SalesLedgerProductProcessBind>().in(SalesLedgerProductProcessBind::getSalesLedgerProductId, productIds));

        LambdaQueryWrapper<InvoiceRegistrationProduct> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(InvoiceRegistrationProduct::getSalesLedgerId, idList);
@@ -727,6 +793,8 @@
            for (SalesLedgerProduct product : updateList) {
                product.setType(type.getCode());
                salesLedgerProductMapper.updateById(product);
                //  清空销售产品绑定的加工
                salesLedgerProductProcessBindService.updateProductProcessBind(product.getSalesProductProcessList(), product.getId());
            }
        }
        // 执行插入操作
@@ -737,6 +805,9 @@
                salesLedgerProduct.setNoInvoiceAmount(salesLedgerProduct.getTaxInclusiveTotalPrice());
                salesLedgerProduct.setPendingInvoiceTotal(salesLedgerProduct.getTaxInclusiveTotalPrice());
                salesLedgerProductMapper.insert(salesLedgerProduct);
                //  绑定产品额外加工
                //  清空销售产品绑定的加工
                salesLedgerProductProcessBindService.updateProductProcessBind(salesLedgerProduct.getSalesProductProcessList(), salesLedgerProduct.getId());
                // 添加生产数据
                salesLedgerProductServiceImpl.addProductionData(salesLedgerProduct);
            }
@@ -774,19 +845,20 @@
                }
            }

            if (!redisTemplate.hasKey(lockKey)) {
            if (Boolean.FALSE.equals(redisTemplate.hasKey(lockKey))) {
                throw new RuntimeException("获取合同编号生成锁失败：超时");
            }

            // 2. 查询当天/公司已存在的序列号（与原逻辑一致）
            Long tenantId = SecurityUtils.getLoginUser().getTenantId();
            if (null != tenantId) {
                //获取公司编号
                SysDept sysDept = sysDeptMapper.selectDeptById(tenantId.longValue());
                if (!ObjectUtils.isEmpty(sysDept)) {
                    datePart = (StringUtils.isEmpty(sysDept.getDeptNick()) ? "" : sysDept.getDeptNick()) + datePart;
                }
            }
//            Long tenantId = SecurityUtils.getLoginUser().getTenantId();
//            if (null != tenantId) {
//                //获取公司编号
//                SysDept sysDept = sysDeptMapper.selectDeptById(tenantId);
//                if (!ObjectUtils.isEmpty(sysDept)) {
//                    datePart = (StringUtils.isEmpty(sysDept.getDeptNick()) ? "" : sysDept.getDeptNick()) + datePart;
//                }
//            }
            datePart = "D" + datePart;
            List<Integer> existingSequences = salesLedgerMapper.selectSequencesByDate(datePart);
            int nextSequence = findFirstMissingSequence(existingSequences);

@@ -802,6 +874,163 @@
        }
    }

    @Override
    public SalesLedgerProcessRouteDto salesProcess(Long salesLedgerId) {
        SalesLedgerProcessRouteDto dto = new SalesLedgerProcessRouteDto();
        List<SalesLedgerProcessRoute> list = baseMapper.selectSalesProcess(salesLedgerId);
        if (CollectionUtils.isNotEmpty(list)) {
            Long processRouteId = list.get(0).getProcessRouteId();
            ProcessRoute processRoute = processRouteMapper.selectById(processRouteId);
            if (processRoute != null) {
                dto.setRouteId(processRoute.getId());
                dto.setRouteName(processRoute.getProcessRouteName());
            }
        } else {
            //  要是list查询为空的话，就查询默认的工艺路线返回
            ProcessRoute defaultRoute = processRouteMapper.selectOne(new LambdaQueryWrapper<ProcessRoute>().eq(ProcessRoute::getIsDefault, 1).last("limit 1"));
            if (defaultRoute != null) {
                dto.setRouteId(defaultRoute.getId());
                dto.setRouteName(defaultRoute.getProcessRouteName());
                List<ProcessRouteItem> routeItems = processRouteItemMapper.selectList(new LambdaQueryWrapper<ProcessRouteItem>().eq(ProcessRouteItem::getRouteId, defaultRoute.getId()).orderByAsc(ProcessRouteItem::getDragSort));
                list = routeItems.stream().map(item -> {
                    SalesLedgerProcessRoute salesLedgerProcessRoute = new SalesLedgerProcessRoute();
                    salesLedgerProcessRoute.setProcessRouteId(defaultRoute.getId());
                    salesLedgerProcessRoute.setSalesLedgerId(salesLedgerId);
                    salesLedgerProcessRoute.setProcessRouteItemId(item.getId());
                    salesLedgerProcessRoute.setProcessName(item.getProcessName());
                    salesLedgerProcessRoute.setDragSort(item.getDragSort());
                    return salesLedgerProcessRoute;
                }).collect(Collectors.toList());
            }
        }
        dto.setList(list);
        return dto;
    }

    @Override
    public SalesProcessCardDto processCard(Long salesLedgerId) {
        if (salesLedgerId == null) {
            throw new ServiceException("流程卡打印失败,打印销售订单不能为空");
        }
        //  查询销售订单
        SalesLedger salesLedger = baseMapper.selectById(salesLedgerId);
        if (salesLedger == null) {
            throw new ServiceException("流程卡打印失败,销售订单不存在");
        }

        SalesProcessCardDto dto = new SalesProcessCardDto();
        dto.setSalesContractNo(salesLedger.getSalesContractNo());
        dto.setCustomerName(salesLedger.getCustomerName());
        dto.setDeliveryDate(salesLedger.getDeliveryDate());
        dto.setRegister(SecurityUtils.getLoginUser().getUser().getNickName());
        dto.setRegisterDate(LocalDateTime.now());
        dto.setOrderProcessRequirement(salesLedger.getRemarks());

        //  查询产品列表
        List<SalesLedgerProduct> products = salesLedgerProductMapper.selectList(
                new LambdaQueryWrapper<SalesLedgerProduct>().eq(SalesLedgerProduct::getSalesLedgerId, salesLedgerId));

        BigDecimal totalQuantity = BigDecimal.ZERO;
        BigDecimal totalArea = BigDecimal.ZERO;
        List<SalesProcessCardDto.ProcessCardItemDto> itemDtos = new ArrayList<>();

        for (SalesLedgerProduct p : products) {
            SalesProcessCardDto.ProcessCardItemDto itemDto = new SalesProcessCardDto.ProcessCardItemDto();
            itemDto.setFloorCode(p.getFloorCode());
            // 组装产品描述：大类 + (规格)
            String desc = (p.getProductCategory() != null ? p.getProductCategory() : "") +
                    (StringUtils.isNotBlank(p.getSpecificationModel()) ? " " + p.getSpecificationModel() : "");
            itemDto.setProductDescription(desc.trim());
            itemDto.setWidth(p.getWidth());
            itemDto.setHeight(p.getHeight());
            itemDto.setQuantity(p.getQuantity());

            // 面积计算(平米)
            BigDecimal area = p.getActualPieceArea() != null ? p.getActualPieceArea() : p.getSettlePieceArea();
            if (area == null && p.getWidth() != null && p.getHeight() != null) {
                area = p.getWidth().multiply(p.getHeight()).divide(new BigDecimal(1000000), 2, RoundingMode.HALF_UP);
            }
            itemDto.setArea(area);
            itemDto.setProcessRequirement(p.getProcessRequirement());

            BigDecimal qty = p.getQuantity() != null ? p.getQuantity() : BigDecimal.ZERO;
            totalQuantity = totalQuantity.add(qty);
            if (area != null) {
                totalArea = totalArea.add(area.multiply(qty));
            }

            itemDtos.add(itemDto);
        }
        dto.setItems(itemDtos);
        dto.setTotalQuantity(totalQuantity);
        dto.setTotalArea(totalArea.setScale(2, RoundingMode.HALF_UP));

        //  工艺路线
        List<SalesLedgerProcessRoute> salesLedgerProcessRoutes = salesLedgerProcessRouteService.list(
                new LambdaQueryWrapper<SalesLedgerProcessRoute>()
                        .eq(SalesLedgerProcessRoute::getSalesLedgerId, salesLedgerId)
                        .orderByAsc(SalesLedgerProcessRoute::getDragSort));

        List<SalesProcessCardDto.ProcessNodeDto> nodeDtos = new ArrayList<>();

        if (CollectionUtils.isEmpty(salesLedgerProcessRoutes)) {
            // 无自定义路线，取默认路线
            ProcessRoute defaultRoute = processRouteMapper.selectOne(
                    new LambdaQueryWrapper<ProcessRoute>().eq(ProcessRoute::getIsDefault, 1).last("LIMIT 1"));
            if (defaultRoute != null) {
                List<ProcessRouteItem> routeItems = processRouteItemMapper.selectList(
                        new LambdaQueryWrapper<ProcessRouteItem>()
                                .eq(ProcessRouteItem::getRouteId, defaultRoute.getId())
                                .orderByAsc(ProcessRouteItem::getDragSort));
                for (ProcessRouteItem i : routeItems) {
                    SalesProcessCardDto.ProcessNodeDto node = new SalesProcessCardDto.ProcessNodeDto();
                    node.setProcessRouteItemId(i.getId());
                    node.setProcessRouteItemName(i.getProcessName());
                    node.setDragSort(i.getDragSort());
                    nodeDtos.add(node);
                }
            }
        } else {
            // 使用自定义路线绑定的节点
            List<Long> itemIds = salesLedgerProcessRoutes.stream()
                    .map(SalesLedgerProcessRoute::getProcessRouteItemId)
                    .collect(Collectors.toList());
            List<ProcessRouteItem> rawItems = processRouteItemMapper.selectBatchIds(itemIds);
            Map<Long, ProcessRouteItem> itemMap = rawItems.stream()
                    .collect(Collectors.toMap(ProcessRouteItem::getId, i -> i, (a, b) -> a));

            for (SalesLedgerProcessRoute r : salesLedgerProcessRoutes) {
                ProcessRouteItem pi = itemMap.get(r.getProcessRouteItemId());
                if (pi != null) {
                    SalesProcessCardDto.ProcessNodeDto node = new SalesProcessCardDto.ProcessNodeDto();
                    node.setProcessRouteItemId(pi.getId());
                    node.setProcessRouteItemName(pi.getProcessName());
                    node.setDragSort(r.getDragSort() != null ? r.getDragSort() : pi.getDragSort());
                    node.setRemark(r.getRemark());
                    nodeDtos.add(node);
                }
            }
        }

        if (!nodeDtos.isEmpty()) {
            //  dragSort 进行升序排序
            nodeDtos.sort(Comparator.comparing(
                    SalesProcessCardDto.ProcessNodeDto::getDragSort,
                    Comparator.nullsLast(Comparator.naturalOrder())
            ));
            //  重新生成排序后的路径名称列表
            List<String> sortedPathNames = nodeDtos.stream()
                    .map(SalesProcessCardDto.ProcessNodeDto::getProcessRouteItemName)
                    .collect(Collectors.toList());
            //  拼接字符串
            dto.setProcessPathDisplay(String.join(" -> ", sortedPathNames));
            // 设置顶层节点的工艺路线
            dto.setRouteNodes(nodeDtos);
        }

        return dto;
    }

    private int findFirstMissingSequence(List<Integer> sequences) {
        if (sequences.isEmpty()) {
            return 1;