产品供销存-后端
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
buhuazhen
11 小时以前 2f3cd0975b753d535054a9ffb19e61c4031032a4 
 src/main/java/com/ruoyi/sales/service/impl/SalesLedgerServiceImpl.java


@@ -1,7 +1,12 @@


package com.ruoyi.sales.service.impl;




import cn.hutool.core.bean.BeanUtil;


import cn.hutool.core.convert.Convert;


import cn.hutool.core.date.LocalDateTimeUtil;


import cn.hutool.core.io.FileUtil;


import cn.hutool.core.lang.Assert;


import cn.hutool.core.util.StrUtil;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;


import com.baomidou.mybatisplus.core.mapper.BaseMapper;


import com.baomidou.mybatisplus.core.metadata.IPage;


import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;


@@ -9,31 +14,37 @@


import com.baomidou.mybatisplus.core.toolkit.Wrappers;


import com.baomidou.mybatisplus.extension.plugins.pagination.Page;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


import com.ruoyi.account.pojo.AccountIncome;


import com.deepoove.poi.XWPFTemplate;


import com.deepoove.poi.config.Configure;


import com.deepoove.poi.plugin.table.LoopRowTableRenderPolicy;


import com.ruoyi.account.service.AccountIncomeService;


import com.ruoyi.basic.mapper.CustomerMapper;


import com.ruoyi.basic.mapper.ProductMapper;


import com.ruoyi.basic.mapper.ProductModelMapper;


import com.ruoyi.basic.pojo.Customer;


import com.ruoyi.basic.pojo.ProductModel;


import com.ruoyi.common.enums.FileNameType;


import com.ruoyi.common.enums.SaleEnum;


import com.ruoyi.common.exception.base.BaseException;


import com.ruoyi.common.utils.SecurityUtils;


import com.ruoyi.common.utils.StringUtils;


import com.ruoyi.common.utils.*;


import com.ruoyi.common.utils.poi.ExcelUtil;


import com.ruoyi.framework.security.LoginUser;


import com.ruoyi.framework.web.domain.AjaxResult;


import com.ruoyi.other.mapper.TempFileMapper;


import com.ruoyi.other.pojo.TempFile;


import com.ruoyi.production.dto.ProductStructureDto;


import com.ruoyi.production.mapper.*;


import com.ruoyi.production.pojo.*;


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;


import com.ruoyi.quality.mapper.QualityInspectMapper;


import com.ruoyi.quality.pojo.QualityInspect;


import com.ruoyi.sales.dto.MonthlyAmountDto;


import com.ruoyi.sales.dto.SalesLedgerDto;


import com.ruoyi.sales.dto.*;


import com.ruoyi.sales.mapper.*;


import com.ruoyi.sales.pojo.*;


import com.ruoyi.sales.service.ISalesLedgerService;


import com.ruoyi.sales.vo.ExportProcessContractVo;


import lombok.RequiredArgsConstructor;


import lombok.SneakyThrows;


import lombok.extern.slf4j.Slf4j;


import org.apache.commons.io.FilenameUtils;


import org.springframework.beans.BeanUtils;


@@ -43,10 +54,17 @@


import org.springframework.data.redis.core.script.DefaultRedisScript;


import org.springframework.stereotype.Service;


import org.springframework.transaction.annotation.Transactional;


import org.springframework.web.context.request.RequestContextHolder;


import org.springframework.web.context.request.ServletRequestAttributes;


import org.springframework.web.multipart.MultipartFile;




import javax.servlet.http.HttpServletResponse;


import javax.validation.constraints.NotNull;


import java.io.IOException;


import java.io.InputStream;


import java.lang.reflect.Field;


import java.math.BigDecimal;


import java.math.RoundingMode;


import java.nio.file.Files;


import java.nio.file.Path;


import java.nio.file.Paths;


@@ -70,70 +88,64 @@


@RequiredArgsConstructor


@Slf4j


public class SalesLedgerServiceImpl extends ServiceImpl<SalesLedgerMapper, SalesLedger> implements ISalesLedgerService {


    private final AccountIncomeService accountIncomeService;




    private final SalesLedgerMapper salesLedgerMapper;




    private final CustomerMapper customerMapper;




    private final SalesLedgerProductMapper salesLedgerProductMapper;




    private final CommonFileMapper commonFileMapper;




    private final TempFileMapper tempFileMapper;




    private final ReceiptPaymentMapper receiptPaymentMapper;




    private final InvoiceLedgerMapper invoiceLedgerMapper;




    private final SalesLedgerSchedulingMapper salesLedgerSchedulingMapper;




    private final SalesLedgerWorkMapper salesLedgerWorkMapper;




    private final SalesLedgerProductionAccountingMapper  salesLedgerProductionAccountingMapper;




    private final InvoiceRegistrationProductMapper invoiceRegistrationProductMapper;




    private final InvoiceRegistrationMapper invoiceRegistrationMapper;




    private final ProductOrderMapper productOrderMapper;




    private final ProcessRouteMapper processRouteMapper;


    private final ProductProcessRouteMapper productProcessRouteMapper;




    private final ProcessRouteItemMapper processRouteItemMapper;




    private final ProductProcessRouteItemMapper productProcessRouteItemMapper;




    private final ProductWorkOrderMapper productWorkOrderMapper;




    private final ProductionProductMainMapper productionProductMainMapper;




    private final ProductionProductOutputMapper productionProductOutputMapper;




    private final ProductionProductInputMapper productionProductInputMapper;




    private final QualityInspectMapper qualityInspectMapper;




    @Autowired


    private SysDeptMapper sysDeptMapper;




    @Value("${file.upload-dir}")


    private String uploadDir;




    private static final String LOCK_PREFIX = "contract_no_lock:";


    private static final long LOCK_WAIT_TIMEOUT = 10; // 锁等待超时时间（秒）


    private static final long LOCK_EXPIRE_TIME = 30;  // 锁自动过期时间（秒）




    private final AccountIncomeService accountIncomeService;


    private final SalesLedgerMapper salesLedgerMapper;


    private final CustomerMapper customerMapper;


    private final SalesLedgerProductMapper salesLedgerProductMapper;


    private final SalesLedgerProductServiceImpl salesLedgerProductServiceImpl;


    private final CommonFileMapper commonFileMapper;


    private final TempFileMapper tempFileMapper;


    private final ReceiptPaymentMapper receiptPaymentMapper;


    private final ShippingInfoServiceImpl shippingInfoServiceImpl;


    private final CommonFileServiceImpl commonFileService;


    private final ShippingInfoMapper shippingInfoMapper;


    private final InvoiceLedgerMapper invoiceLedgerMapper;


    private final SalesLedgerSchedulingMapper salesLedgerSchedulingMapper;


    private final SalesLedgerWorkMapper salesLedgerWorkMapper;


    private final SalesLedgerProductionAccountingMapper salesLedgerProductionAccountingMapper;


    private final InvoiceRegistrationProductMapper invoiceRegistrationProductMapper;


    private final InvoiceRegistrationMapper invoiceRegistrationMapper;


    private final ProductOrderMapper productOrderMapper;


    private final ProcessRouteMapper processRouteMapper;


    private final ProductProcessRouteMapper productProcessRouteMapper;


    private final ProcessRouteItemMapper processRouteItemMapper;


    private final ProductProcessRouteItemMapper productProcessRouteItemMapper;


    private final ProductWorkOrderMapper productWorkOrderMapper;


    private final ProductionProductMainMapper productionProductMainMapper;


    private final ProductionProductOutputMapper productionProductOutputMapper;


    private final ProductionProductInputMapper productionProductInputMapper;


    private final QualityInspectMapper qualityInspectMapper;


    private final RedisTemplate<String, String> redisTemplate;


    @Autowired


    private SysDeptMapper sysDeptMapper;


    @Value("${file.upload-dir}")


    private String uploadDir;


    @Autowired


    private ProductModelMapper productModelMapper;




    @Autowired


    private ProductMapper productMapper;


    @Autowired


    private ProductStructureMapper productStructureMapper;


    @Autowired


    private ProductionProductMainService productionProductMainService;


    ;


    @Autowired


    private SysUserMapper sysUserMapper;




    @Override


    public List<SalesLedger> selectSalesLedgerList(SalesLedgerDto salesLedgerDto) {


        return salesLedgerMapper.selectSalesLedgerList(salesLedgerDto);


    }




    public List<SalesLedgerProduct> getSalesLedgerProductListByRelateId(Long relateId, SaleEnum type) {


        LambdaQueryWrapper<SalesLedgerProduct> productWrapper = new LambdaQueryWrapper<>();


        productWrapper.eq(SalesLedgerProduct::getSalesLedgerId, relateId);


        productWrapper.eq(SalesLedgerProduct::getType, type.getCode());


        return salesLedgerProductMapper.selectList(productWrapper);


    }




    @Override


@@ -156,6 +168,14 @@


            product.setTempNoInvoiceNum(product.getNoInvoiceNum());


            product.setRegister(SecurityUtils.getLoginUser().getUser().getNickName());


            product.setRegisterDate(LocalDateTime.now());


            // 发货信息


            ShippingInfo shippingInfo = shippingInfoMapper.selectOne(new LambdaQueryWrapper<ShippingInfo>()


                    .eq(ShippingInfo::getSalesLedgerProductId, product.getId())


                    .orderByDesc(ShippingInfo::getCreateTime)


                    .last("limit 1"));


            if (shippingInfo != null) {


                product.setShippingStatus(shippingInfo.getStatus());


            }


        }




        // 3.查询上传文件


@@ -246,75 +266,51 @@




    @Override


    public List<MonthlyAmountDto> getAmountHalfYear(Integer type) {




        LocalDate now = LocalDate.now();


        LocalDateTime currentDateTime = LocalDateTime.now();




        // 根据 type 确定查询的时间间隔（天数）和总查询天数


        int daysPerPeriod;


        int totalDays;


        switch (type) {


            case 1:


                daysPerPeriod = 5;   // 每5天查一次


                totalDays = 30;       // 6次 × 5天 = 30天


                break;


            case 2:


                daysPerPeriod = 15;    // 每15天查一次


                totalDays = 90;       // 6次 × 15天 = 90天


                break;


            case 3:


                daysPerPeriod = 30;   // 每30天查一次


                totalDays = 180;      // 6次 × 30天 = 180天


                break;


            default:


                throw new IllegalArgumentException("Invalid type value: " + type);


        }




        List<MonthlyAmountDto> result = new ArrayList<>();




        // 循环6次，每次查询一个时间段的数据


        for (int i = 0; i < 6; i++) {


            // 计算当前时间段的起始和结束时间


            LocalDateTime endTime = currentDateTime.minusDays(i * daysPerPeriod);


            LocalDateTime startTime = endTime.minusDays(daysPerPeriod);


        for (int i = 5; i >= 0; i--) {


            YearMonth yearMonth = YearMonth.from(now.minusMonths(i));


            LocalDateTime startTime = yearMonth.atDay(1).atStartOfDay();


            LocalDateTime endTime = yearMonth.atEndOfMonth().atTime(23, 59, 59);




            // 查询回款金额


            //  回款金额


            LambdaQueryWrapper<ReceiptPayment> receiptPaymentQuery = new LambdaQueryWrapper<>();


            receiptPaymentQuery


                    .ge(ReceiptPayment::getCreateTime, startTime)


                    .lt(ReceiptPayment::getCreateTime, endTime);


            List<ReceiptPayment> receiptPayments = receiptPaymentMapper.selectList(receiptPaymentQuery);


                    .le(ReceiptPayment::getCreateTime, endTime);




            // 查询开票金额


            LambdaQueryWrapper<InvoiceLedger> invoiceLedgerQuery = new LambdaQueryWrapper<>();


            invoiceLedgerQuery


                    .ge(InvoiceLedger::getCreateTime, startTime)


                    .lt(InvoiceLedger::getCreateTime, endTime);


            List<InvoiceLedger> invoiceLedgers = invoiceLedgerMapper.selectList(invoiceLedgerQuery);


            List<ReceiptPayment> receiptPayments =


                    receiptPaymentMapper.selectList(receiptPaymentQuery);




            // 计算回款总额


            BigDecimal receiptAmount = receiptPayments.stream()


                    .map(ReceiptPayment::getReceiptPaymentAmount)


                    .filter(Objects::nonNull)


                    .reduce(BigDecimal.ZERO, BigDecimal::add);




            // 计算开票总额


            //  开票金额


            LambdaQueryWrapper<InvoiceLedger> invoiceLedgerQuery = new LambdaQueryWrapper<>();


            invoiceLedgerQuery


                    .ge(InvoiceLedger::getCreateTime, startTime)


                    .le(InvoiceLedger::getCreateTime, endTime);




            List<InvoiceLedger> invoiceLedgers =


                    invoiceLedgerMapper.selectList(invoiceLedgerQuery);




            BigDecimal invoiceAmount = invoiceLedgers.stream()


                    .map(InvoiceLedger::getInvoiceTotal)


                    .filter(Objects::nonNull)


                    .reduce(BigDecimal.ZERO, BigDecimal::add);




            // 构造返回的 DTO


            MonthlyAmountDto dto = new MonthlyAmountDto();


            dto.setMonth(startTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")) + " ~ " +


                    endTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));


            dto.setMonth(yearMonth.format(DateTimeFormatter.ofPattern("yyyy-MM")));


            dto.setReceiptAmount(receiptAmount);


            dto.setInvoiceAmount(invoiceAmount);




            result.add(dto);


        }




        // 反转列表，使时间顺序从早到晚


        Collections.reverse(result);


        return result;


    }




@@ -323,34 +319,245 @@


        return salesLedgerMapper.selectSalesLedgerListPage(page, salesLedgerDto);


    }




    // 内部类用于存储聚合结果


    private static class GroupedCustomer {


        private final Long customerId;


        private final String customerName;


        private BigDecimal totalAmount = BigDecimal.ZERO;


    @Override


    @Transactional(rollbackFor = Exception.class)


    public AjaxResult importData(MultipartFile file) {


        LoginUser loginUser = SecurityUtils.getLoginUser();


        try {


            InputStream inputStream = file.getInputStream();


            ExcelUtil<SalesLedgerImportDto> salesLedgerImportDtoExcelUtil = new ExcelUtil<>(SalesLedgerImportDto.class);


            Map<String, List<SalesLedgerImportDto>> stringListMap = salesLedgerImportDtoExcelUtil.importExcelMultiSheet(Arrays.asList("销售台账数据", "销售产品数据"), inputStream, 0);


            if (CollectionUtils.isEmpty(stringListMap)) return AjaxResult.error("销售表格为空！");


            // 业务层合并


            List<SalesLedgerImportDto> salesLedgerImportDtoList = stringListMap.get("销售台账数据");


            if (CollectionUtils.isEmpty(salesLedgerImportDtoList)) return AjaxResult.error("销售台账数据为空！");


            List<SalesLedgerImportDto> salesLedgerProductImportDtoList = stringListMap.get("销售产品数据");


            if (CollectionUtils.isEmpty(salesLedgerProductImportDtoList)) return AjaxResult.error("销售产品数据为空！");


            // 客户数据


            List<Customer> customers = customerMapper.selectList(new LambdaQueryWrapper<Customer>().in(Customer::getCustomerName,


                    salesLedgerImportDtoList.stream().map(SalesLedgerImportDto::getCustomerName).collect(Collectors.toList())));


//            // 规格型号数据


//            List<ProductModel> productModels = productModelMapper.selectList(new LambdaQueryWrapper<ProductModel>().in(ProductModel::getModel,


//                    salesLedgerProductImportDtoList.stream().map(SalesLedgerImportDto::getSpecificationModel).collect(Collectors.toList())));


//            // 产品大类数据


//            List<Product> productList = productMapper.selectList(new LambdaQueryWrapper<Product>().in(Product::getProductName,


//                    salesLedgerProductImportDtoList.stream().map(SalesLedgerImportDto::getProductCategory).collect(Collectors.toList())));


            List<Map<String, Object>> list = productModelMapper.getProductAndModelList();


            // 录入人数据


            List<SysUser> sysUsers = sysUserMapper.selectList(new LambdaQueryWrapper<SysUser>().in(SysUser::getNickName,


                    salesLedgerImportDtoList.stream().map(SalesLedgerImportDto::getEntryPerson).collect(Collectors.toList())));


            for (SalesLedgerImportDto salesLedgerImportDto : salesLedgerImportDtoList) {


                SalesLedger salesLedger1 = salesLedgerMapper.selectOne(new LambdaQueryWrapper<SalesLedger>()


                        .eq(SalesLedger::getSalesContractNo, salesLedgerImportDto.getSalesContractNo())


                        .last("LIMIT 1"));


                if (salesLedger1 != null) {


                    continue;


                }


                SalesLedger salesLedger = new SalesLedger();


                BeanUtils.copyProperties(salesLedgerImportDto, salesLedger);


                salesLedger.setExecutionDate(DateUtils.toLocalDate(salesLedgerImportDto.getExecutionDate()));


                // 通过客户名称查询客户ID，客户合同号


                salesLedger.setCustomerId(customers.stream()


                        .filter(customer -> customer.getCustomerName().equals(salesLedger.getCustomerName()))


                        .findFirst()


                        .map(Customer::getId)


                        .orElse(null));


                salesLedger.setCustomerContractNo(customers.stream()


                        .filter(customer -> customer.getCustomerName().equals(salesLedger.getCustomerName()))


                        .findFirst()


                        .map(Customer::getTaxpayerIdentificationNumber)


                        .orElse(null));


                Long aLong = sysUsers.stream()


                        .filter(sysUser -> sysUser.getNickName().equals(salesLedger.getEntryPerson()))


                        .findFirst()


                        .map(SysUser::getUserId)


                        .orElse(null);


                if (aLong == null)


                    throw new RuntimeException("录入人:" + salesLedger.getEntryPerson() + ",无对应用户！");


                salesLedger.setEntryPerson(aLong.toString());


                // 销售产品数据绑定，通过销售单号获取对应销售产品数据


                List<SalesLedgerProductImportDto> salesLedgerProductImportDtos = salesLedgerProductImportDtoList.stream()


                        .filter(salesLedgerProductImportDto -> salesLedgerProductImportDto.getSalesContractNo().equals(salesLedger.getSalesContractNo()))


                        .collect(Collectors.toList());


                if (CollectionUtils.isEmpty(salesLedgerProductImportDtos))


                    throw new RuntimeException("销售单号:" + salesLedgerImportDto.getSalesContractNo() + ",无对应产品数据！");


                salesLedger.setContractAmount(salesLedgerProductImportDtos.stream()


                        .map(SalesLedgerProductImportDto::getTaxInclusiveTotalPrice)


                        .reduce(BigDecimal.ZERO, BigDecimal::add));


                salesLedgerMapper.insert(salesLedger);




        public GroupedCustomer(Long customerId, String customerName) {


            this.customerId = customerId;


            this.customerName = customerName;




                for (SalesLedgerProductImportDto salesLedgerProductImportDto : salesLedgerProductImportDtos) {


                    SalesLedgerProduct salesLedgerProduct = new SalesLedgerProduct();


                    BeanUtils.copyProperties(salesLedgerProductImportDto, salesLedgerProduct);


                    salesLedgerProduct.setSalesLedgerId(salesLedger.getId());


                    salesLedgerProduct.setType(1);


                    // 计算不含税总价


                    salesLedgerProduct.setTaxExclusiveTotalPrice(salesLedgerProduct.getTaxInclusiveTotalPrice().divide(new BigDecimal(1).add(salesLedgerProduct.getTaxRate().divide(new BigDecimal(100))), 2, RoundingMode.HALF_UP));


                    salesLedgerProduct.setNoInvoiceNum(salesLedgerProduct.getQuantity());


                    salesLedgerProduct.setNoInvoiceAmount(salesLedgerProduct.getTaxExclusiveTotalPrice());


                    list.stream()


                            .filter(map -> map.get("productName").equals(salesLedgerProduct.getProductCategory()) && map.get("model").equals(salesLedgerProduct.getSpecificationModel()))


                            .findFirst()


                            .ifPresent(map -> {


                                salesLedgerProduct.setProductModelId(Long.parseLong(map.get("modelId").toString()));


                                salesLedgerProduct.setProductId(Long.parseLong(map.get("id").toString()));


                            });


//                    salesLedgerProduct.setProductId(productList.stream()


//                            .filter(product -> product.getProductName().equals(salesLedgerProduct.getProductCategory()))


//                            .findFirst()


//                            .map(Product::getId)


//                            .orElse(null));


//                    salesLedgerProduct.setProductModelId(productModels.stream()


//                            .filter(productModel -> productModel.getModel().equals(salesLedgerProduct.getSpecificationModel()))


//                            .findFirst()


//                            .map(ProductModel::getId)


//                            .orElse(null));


                    salesLedgerProduct.setRegister(loginUser.getNickName());


                    salesLedgerProduct.setRegisterDate(LocalDateTime.now());


                    salesLedgerProduct.setApproveStatus(0);


                    salesLedgerProduct.setPendingInvoiceTotal(salesLedgerProductImportDto.getTaxInclusiveTotalPrice());


                    salesLedgerProductMapper.insert(salesLedgerProduct);


                    // 添加生产数据


                    salesLedgerProductServiceImpl.addProductionData(salesLedgerProduct);


                }


            }




            return AjaxResult.success("导入成功");


        } catch (Exception e) {


            e.printStackTrace();


        }


        return AjaxResult.success("导入失败");


    }




        public void addAmount(BigDecimal amount) {


            if (amount != null) {


                this.totalAmount = this.totalAmount.add(amount);


    @Override


    public List<LossProductModelDto> getSalesLedgerWithProductsLoss(Long salesLedgerId) {






        List<LossProductModelDto> lossProductModelDtos = salesLedgerProductMapper.selectProductBomStructure(salesLedgerId);






        return lossProductModelDtos;


    }




    @Override


    public IPage<SalesLedgerDto> listSalesLedger(SalesLedgerDto salesLedgerDto, Page page) {


        IPage<SalesLedgerDto> salesLedgerDtoIPage = salesLedgerMapper.listSalesLedger(page, salesLedgerDto);


        for (SalesLedgerDto salesLedger : salesLedgerDtoIPage.getRecords()) {


            LambdaQueryWrapper<SalesLedgerProduct> productWrapper = new LambdaQueryWrapper<>();


            productWrapper.eq(SalesLedgerProduct::getSalesLedgerId, salesLedger.getId());


            productWrapper.eq(SalesLedgerProduct::getType, 1);


            List<SalesLedgerProduct> products = salesLedgerProductMapper.selectList(productWrapper);


            for (SalesLedgerProduct product : products) {


                product.setOriginalNoInvoiceNum(product.getNoInvoiceNum());


                // 提供临时未开票数，未开票金额供前段计算


                product.setTempnoInvoiceAmount(product.getNoInvoiceAmount());


                product.setTempNoInvoiceNum(product.getNoInvoiceNum());


                product.setRegister(SecurityUtils.getLoginUser().getUser().getNickName());


                product.setRegisterDate(LocalDateTime.now());


                // 发货信息


                ShippingInfo shippingInfo = shippingInfoMapper.selectOne(new LambdaQueryWrapper<ShippingInfo>()


                        .eq(ShippingInfo::getSalesLedgerProductId, product.getId())


                        .orderByDesc(ShippingInfo::getCreateTime)


                        .last("limit 1"));


                if (shippingInfo != null) {


                    product.setShippingStatus(shippingInfo.getStatus());




                }


            }


            if (!products.isEmpty()) {


                salesLedger.setHasChildren(true);


                salesLedger.setProductData(products);


            }


        }




        public Long getCustomerId() {


            return customerId;


        return salesLedgerDtoIPage;


    }




    @Override


    public void exportProcessContract(Long id) {


        //加工承揽合同


        ExportProcessContractVo exportProcessContract = new ExportProcessContractVo();


        exportProcessContract.setId(id);


        SalesLedger salesLedger = salesLedgerMapper.selectById(id);


        // 查询客户公司信息


        Customer customer = customerMapper.selectById(salesLedger.getCustomerId());


        exportProcessContract.setCreateTime(LocalDateTimeUtil.format(Optional.ofNullable(salesLedger.getExecutionDate()).orElse(LocalDate.now()), "yyyy年MM月dd日"));


        exportProcessContract.setRemark(Optional.ofNullable(salesLedger.getRemarks()).orElse("无")); // 备注


        exportProcessContract.setPlaceOfSinging(Optional.ofNullable(salesLedger.getPlaceOfSinging()).orElse(""));




        // 填写甲方信息


        ExportProcessContractVo.Customer partyA = ExportProcessContractVo.Customer.getCustomer(customer);


        exportProcessContract.setPartyAClientName(customer.getCustomerName());


        exportProcessContract.setPartyA(partyA);




        // 填写乙方信息


        ExportProcessContractVo.Customer partyB = new ExportProcessContractVo.Customer();


        exportProcessContract.setPartyBClientName("");//todo@ 乙方公司名称


        exportProcessContract.setPartyB(partyB);




        // 填写商品信息


        final BigDecimal[] totalAmount = {BigDecimal.ZERO}; // 总金额


        LambdaQueryWrapper<SalesLedgerProduct> productWrapper = new LambdaQueryWrapper<>();


        productWrapper.eq(SalesLedgerProduct::getSalesLedgerId, salesLedger.getId());


        productWrapper.eq(SalesLedgerProduct::getType, 1);


        List<SalesLedgerProduct> products = salesLedgerProductMapper.selectList(productWrapper);


        List<ExportProcessContractVo.SaleProduct> productList = products.stream().map(it -> {


            ExportProcessContractVo.SaleProduct saleProduct = BeanUtil.copyProperties(it, ExportProcessContractVo.SaleProduct.class);


            // 计算总价格


            totalAmount[0] = totalAmount[0].add(Optional.ofNullable(saleProduct.getTaxInclusiveTotalPrice()).orElse(BigDecimal.ZERO));


            return saleProduct;


        }).collect(Collectors.toList());


        // 第一个设置 合同编号


        if (!productList.isEmpty()) {


            productList.get(0).setSalesContractNo(salesLedger.getSalesContractNo());


        }


        // 查看税率 理论上税率单一，如果多税率为空


        Map<BigDecimal, Long> rateMap = productList.stream().map(product -> product.getTaxRate()).filter(Objects::nonNull)


                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));


        String taxRateStr = rateMap.size() == 1 ? rateMap.keySet().iterator().next().toString() + " %" : "";


        exportProcessContract.setTaxRate(taxRateStr);


        exportProcessContract.setSaleProducts(productList);// 商品信息


        // 设置大写的总价格


        exportProcessContract.setTotalAmountZh(Convert.digitToChinese(totalAmount[0].doubleValue()));




        exportProcessContractToWord(exportProcessContract);


    }




    @SneakyThrows


    private void exportProcessContractToWord(@NotNull ExportProcessContractVo exportProcessContract){


        // 确保 saleProducts 不为 null


        if (exportProcessContract.getSaleProducts() == null) {


            exportProcessContract.setSaleProducts(new ArrayList<>());


        }




        public String getCustomerName() {


            return customerName;


        }


        // 模板输入流


        InputStream inputStream = this.getClass().getResourceAsStream("/static/contract_tmp.docx");


        Assert.isTrue(inputStream != null, "模板不存在");




        public BigDecimal getTotalAmount() {


            return totalAmount;


        }


        // 转 Map


        Map<String, Object> dataMap = BeanUtil.beanToMap(exportProcessContract);




        // 绑定循环策略


        Configure configure = Configure.builder()


                .bind("saleProducts", new LoopRowTableRenderPolicy())


                .build();




        // 渲染模板


        XWPFTemplate template = XWPFTemplate.compile(inputStream, configure)


                .render(dataMap);


//        template.write(FileUtil.getOutputStream("/Users/ONEX/Downloads/a.docx"));




        // 输出到浏览器


        HttpServletResponse response =


                ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes()))


                        .getResponse();


        response.setContentType("application/vnd.openxmlformats-officedocument.wordprocessingml.document");


        response.setHeader("Content-Disposition", "attachment;filename="+ StrUtil.format("{}-{}",exportProcessContract.getPartyAClientName(),exportProcessContract.getCreateTime()) +"合同.docx");




        template.write(response.getOutputStream());


        template.close();


        response.flushBuffer();


    }




    /**


@@ -393,86 +600,8 @@


        List<Long> productIds = products.stream()


                .map(SalesLedgerProduct::getId)


                .collect(Collectors.toList());




        //批量查询productOrder


        List<ProductOrder> productOrders = productOrderMapper.selectList(


                new LambdaQueryWrapper<ProductOrder>()


                        .in(ProductOrder::getProductModelId, productIds)


        );




        if (!org.springframework.util.CollectionUtils.isEmpty(productOrders)) {


            List<Long> orderIds = productOrders.stream()


                    .map(ProductOrder::getId)


                    .collect(Collectors.toList());




            // 批量查询processRouteItems


            List<ProductProcessRouteItem> allRouteItems = productProcessRouteItemMapper.selectList(


                    new LambdaQueryWrapper<ProductProcessRouteItem>()


                            .in(ProductProcessRouteItem::getProductOrderId, orderIds)


            );




            if (!CollectionUtils.isEmpty(allRouteItems)) {


                // 获取要删除的工序项ID


                List<Long> routeItemIds = allRouteItems.stream()


                        .map(ProductProcessRouteItem::getId)


                        .collect(Collectors.toList());




                // 查询关联的工单ID


                List<ProductWorkOrder> workOrders = productWorkOrderMapper.selectList(


                        new LambdaQueryWrapper<ProductWorkOrder>()


                                .in(ProductWorkOrder::getProductProcessRouteItemId, routeItemIds)


                );


                if (!CollectionUtils.isEmpty(workOrders)) {


                    List<Long> workOrderIds = workOrders.stream()


                            .map(ProductWorkOrder::getId)


                            .collect(Collectors.toList());




                    // 查询关联的生产主表ID


                    List<ProductionProductMain> productMains = productionProductMainMapper.selectList(


                            new LambdaQueryWrapper<ProductionProductMain>()


                                    .in(ProductionProductMain::getWorkOrderId, workOrderIds)


                    );


                    List<Long> productMainIds = productMains.stream()


                            .map(ProductionProductMain::getId)


                            .collect(Collectors.toList());




                    // 删除产出表、投入表数据


                    if (!CollectionUtils.isEmpty(productMainIds)) {


                        productionProductOutputMapper.deleteByProductMainIds(productMainIds);


                        productionProductInputMapper.deleteByProductMainIds(productMainIds);


                        List<QualityInspect> qualityInspects = qualityInspectMapper.selectList(


                                new LambdaQueryWrapper<QualityInspect>()


                                        .in(QualityInspect::getProductMainId, productMainIds)


                        );


                        qualityInspects.forEach(qualityInspect -> {


                            //inspectState=1 已提交 不能删除


                            if(qualityInspect.getInspectState() == 1){


                                throw new RuntimeException("已提交的检验单不能删除");


                            }


                        });


                        qualityInspectMapper.deleteByProductMainIds(productMainIds);


                    }




                    // 删除生产主表数据


                    productionProductMainMapper.deleteByWorkOrderIds(workOrderIds);




                    // 删除工单数据


                    productWorkOrderMapper.delete(new LambdaQueryWrapper<ProductWorkOrder>()


                            .in(ProductWorkOrder::getProductProcessRouteItemId, routeItemIds));


                }


            }


            // 批量删除processRouteItem


            productProcessRouteItemMapper.delete(new LambdaQueryWrapper<ProductProcessRouteItem>()


                    .in(ProductProcessRouteItem::getProductOrderId, orderIds));




            // 批量删除productProcessRoute


            productProcessRouteMapper.delete(new LambdaQueryWrapper<ProductProcessRoute>()


                    .in(ProductProcessRoute::getProductOrderId, orderIds));




            // 批量删除productOrder


            productOrderMapper.delete(new LambdaQueryWrapper<ProductOrder>()


                    .in(ProductOrder::getProductModelId, productIds));


        }


        //删除生产数据


        salesLedgerProductServiceImpl.deleteProductionData(productIds);




        // 批量删除产品子表


        if (!productIds.isEmpty()) {


@@ -483,11 +612,11 @@


        wrapper.in(InvoiceRegistrationProduct::getSalesLedgerId, idList);


        List<InvoiceRegistrationProduct> invoiceRegistrationProducts = invoiceRegistrationProductMapper.selectList(wrapper);


        List<Integer> invoiceLedgerIds = new ArrayList<>();


        if(CollectionUtils.isNotEmpty(invoiceRegistrationProducts)){


        if (CollectionUtils.isNotEmpty(invoiceRegistrationProducts)) {


            LambdaQueryWrapper<InvoiceLedger> wrapperOne = new LambdaQueryWrapper<>();


            wrapperOne.in(InvoiceLedger::getInvoiceRegistrationProductId, invoiceRegistrationProducts.stream().map(InvoiceRegistrationProduct::getId).collect(Collectors.toList()));


            List<InvoiceLedger> invoiceLedgers = invoiceLedgerMapper.selectList(wrapperOne);


            if(CollectionUtils.isNotEmpty(invoiceLedgers)){


            if (CollectionUtils.isNotEmpty(invoiceLedgers)) {


                invoiceLedgerIds = invoiceLedgers.stream().map(InvoiceLedger::getId).collect(Collectors.toList());


            }


            invoiceLedgerMapper.delete(wrapperOne);


@@ -497,25 +626,28 @@


        wrapperTwo.in(InvoiceRegistration::getSalesLedgerId, idList);


        invoiceRegistrationMapper.delete(wrapperTwo);




        if(CollectionUtils.isNotEmpty(invoiceLedgerIds)){


        if (CollectionUtils.isNotEmpty(invoiceLedgerIds)) {


            LambdaQueryWrapper<ReceiptPayment> wrapperTree = new LambdaQueryWrapper<>();


            wrapperTree.in(ReceiptPayment::getInvoiceLedgerId, invoiceLedgerIds);


            receiptPaymentMapper.delete(wrapperTree);


        }


        // 删除发货台账记录


        List<ShippingInfo> shippingInfos = shippingInfoMapper.selectList(new LambdaQueryWrapper<ShippingInfo>()


                .in(ShippingInfo::getSalesLedgerId, idList));


        if (CollectionUtils.isNotEmpty(shippingInfos)) {


            shippingInfoServiceImpl.delete(shippingInfos.stream().map(ShippingInfo::getId).collect(Collectors.toList()));


        }


        // 删除附件表


        commonFileService.deleteByBusinessIds(idList, FileNameType.SALE.getValue());




        // 删除生产管控数据


        // 删除生产订单数据


        LambdaQueryWrapper<SalesLedgerScheduling> in = new LambdaQueryWrapper<SalesLedgerScheduling>()


                .in(SalesLedgerScheduling::getSalesLedgerId, idList);


        salesLedgerSchedulingMapper.delete(in);


        // 删除生产派工数据


        LambdaQueryWrapper<SalesLedgerWork> workOrderWrapper = new LambdaQueryWrapper<>();


        workOrderWrapper.in(SalesLedgerWork::getSalesLedgerId, idList);


        salesLedgerWorkMapper.delete(workOrderWrapper);


        // 删除生产报工数据


        LambdaQueryWrapper<SalesLedgerProductionAccounting> reportWrapper = new LambdaQueryWrapper<>();


        reportWrapper.in(SalesLedgerProductionAccounting::getSalesLedgerId, idList);


        salesLedgerProductionAccountingMapper.delete(reportWrapper);


        //查询生产报工id


        ArrayList<Long> mainIdList = productionProductMainService.listMain(idList);


        if (CollectionUtils.isNotEmpty(mainIdList)) {


            mainIdList.stream().forEach(mainId -> {


                productionProductMainService.removeProductMain(mainId);


            });


        }


        // 2. 再删除主表数据


        return salesLedgerMapper.deleteBatchIds(idList);


    }


@@ -546,7 +678,7 @@


            // 4. 处理子表数据


            List<SalesLedgerProduct> productList = salesLedgerDto.getProductData();


            if (productList != null && !productList.isEmpty()) {


                handleSalesLedgerProducts(salesLedger.getId(), productList, salesLedgerDto.getType());


                handleSalesLedgerProducts(salesLedger.getId(), productList, EnumUtil.fromCode(SaleEnum.class, salesLedgerDto.getType()));


                updateMainContractAmount(


                        salesLedger.getId(),


                        productList,


@@ -565,8 +697,6 @@


            throw new BaseException("文件迁移失败: " + e.getMessage());


        }


    }




    // 文件迁移方法




    /**


     * 将临时文件迁移到正式目录


@@ -643,8 +773,10 @@


        }


    }




    // 文件迁移方法




    private void handleSalesLedgerProducts(Long salesLedgerId, List<SalesLedgerProduct> products, Integer type) {


    @Override


    public void handleSalesLedgerProducts(Long salesLedgerId, List<SalesLedgerProduct> products, SaleEnum type) {


        // 按ID分组，区分新增和更新的记录


        Map<Boolean, List<SalesLedgerProduct>> partitionedProducts = products.stream()


                .peek(p -> p.setSalesLedgerId(salesLedgerId))


@@ -656,91 +788,20 @@


        // 执行更新操作


        if (!updateList.isEmpty()) {


            for (SalesLedgerProduct product : updateList) {


                product.setType(type);


                product.setType(type.getCode());


                salesLedgerProductMapper.updateById(product);


            }


        }


        // 执行插入操作


        if (!insertList.isEmpty()) {


            for (SalesLedgerProduct salesLedgerProduct : insertList) {


                salesLedgerProduct.setType(type);


                salesLedgerProduct.setType(type.getCode());


                salesLedgerProduct.setNoInvoiceNum(salesLedgerProduct.getQuantity());


                salesLedgerProduct.setNoInvoiceAmount(salesLedgerProduct.getTaxInclusiveTotalPrice());


                salesLedgerProduct.setPendingInvoiceTotal(salesLedgerProduct.getTaxInclusiveTotalPrice());


                salesLedgerProductMapper.insert(salesLedgerProduct);




                ProductOrder productOrder = new ProductOrder();


                productOrder.setSalesLedgerId(salesLedgerProduct.getSalesLedgerId());


                productOrder.setProductModelId(salesLedgerProduct.getId());


                productOrder.setNpsNo("SC" + String.format("%08d", salesLedgerProduct.getId()));


                productOrder.setQuantity(salesLedgerProduct.getQuantity());//需求数量


                productOrder.setCompleteQuantity(BigDecimal.ZERO);//完成数量


                productOrderMapper.insert(productOrder);




                ProcessRoute processRoute = processRouteMapper.selectOne(new QueryWrapper<ProcessRoute>().lambda().eq(ProcessRoute::getProductModelId, salesLedgerProduct.getProductModelId()));


                if (processRoute != null) {


                    List<ProductStructureDto> productStructureDtos = productStructureMapper.listBybomId(processRoute.getBomId());


                    //新增生产订单工艺路线主表


                    ProductProcessRoute productProcessRoute = new ProductProcessRoute();


                    productProcessRoute.setProductModelId(processRoute.getProductModelId());


                    productProcessRoute.setProcessRouteCode(processRoute.getProcessRouteCode());


                    productProcessRoute.setProductOrderId(productOrder.getId());


                    productProcessRoute.setBomId(processRoute.getBomId());


                    productProcessRouteMapper.insert(productProcessRoute);


                    //新增生产订单工艺路线子表


                    List<ProcessRouteItem> processRouteItems = processRouteItemMapper.selectList(new QueryWrapper<ProcessRouteItem>().lambda().eq(ProcessRouteItem::getRouteId, processRoute.getId()));


                    // 生成当前日期的前缀：年月日


                    String datePrefix = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));


                    for (ProcessRouteItem processRouteItem : processRouteItems) {


                        ProductProcessRouteItem productProcessRouteItem = new ProductProcessRouteItem();


                        productProcessRouteItem.setProductModelId(processRouteItem.getProductModelId());


                        productProcessRouteItem.setProcessId(processRouteItem.getProcessId());


                        productProcessRouteItem.setProductOrderId(productOrder.getId());


                        productProcessRouteItem.setProductRouteId(productProcessRoute.getId());


                        productProcessRouteItem.setDragSort(processRouteItem.getDragSort());


                        int insert = productProcessRouteItemMapper.insert(productProcessRouteItem);


                        if (insert > 0) {


                            // 查询今日已存在的最大工单号


                            QueryWrapper<ProductWorkOrder> queryWrapper = new QueryWrapper<>();


                            queryWrapper.likeRight("work_order_no", datePrefix)


                                    .orderByDesc("work_order_no")


                                    .last("LIMIT 1");




                            ProductWorkOrder lastWorkOrder = productWorkOrderMapper.selectOne(queryWrapper);




                            int sequenceNumber = 1; // 默认序号


                            if (lastWorkOrder != null && lastWorkOrder.getWorkOrderNo() != null) {


                                String lastNo = lastWorkOrder.getWorkOrderNo().toString();


                                if (lastNo.startsWith(datePrefix)) {


                                    String seqStr = lastNo.substring(datePrefix.length());


                                    try {


                                        sequenceNumber = Integer.parseInt(seqStr) + 1;


                                    } catch (NumberFormatException e) {


                                        sequenceNumber = 1;


                                    }


                                }


                            }


                            // 生成完整的工单号


                            String workOrderNoStr = String.format("%s%03d", datePrefix, sequenceNumber);


                            ProductWorkOrder productWorkOrder = new ProductWorkOrder();


                            productStructureDtos.stream().forEach(productStructureDto -> {


                                if (productStructureDto.getProductModelId().equals(productProcessRouteItem.getProductModelId())){


                                    productWorkOrder.setPlanQuantity(productWorkOrder.getPlanQuantity());


                                }


                            });


                            if (Objects.equals(productProcessRouteItem.getProductModelId(), salesLedgerProduct.getProductModelId())) {


                                productWorkOrder.setPlanQuantity(salesLedgerProduct.getQuantity());


                            }


                            productWorkOrder.setProductProcessRouteItemId(productProcessRouteItem.getId());


                            productWorkOrder.setProductOrderId(productOrder.getId());


                            productWorkOrder.setWorkOrderNo(workOrderNoStr);


                            productWorkOrder.setStatus(1);


                            productWorkOrderMapper.insert(productWorkOrder);


                        }


                    }


                    productOrder.setRouteId(processRoute.getId());


                    productOrderMapper.updateById(productOrder);


                }


                // 添加生产数据


                salesLedgerProductServiceImpl.addProductionData(salesLedgerProduct);


            }


        }


    }


@@ -854,4 +915,34 @@


            throw new RuntimeException("动态更新主表金额失败", e);


        }


    }




    // 内部类用于存储聚合结果


    private static class GroupedCustomer {


        private final Long customerId;


        private final String customerName;


        private BigDecimal totalAmount = BigDecimal.ZERO;




        public GroupedCustomer(Long customerId, String customerName) {


            this.customerId = customerId;


            this.customerName = customerName;


        }




        public void addAmount(BigDecimal amount) {


            if (amount != null) {


                this.totalAmount = this.totalAmount.add(amount);


            }


        }




        public Long getCustomerId() {


            return customerId;


        }




        public String getCustomerName() {


            return customerName;


        }




        public BigDecimal getTotalAmount() {


            return totalAmount;


        }


    }


}