产品供销存-后端
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
zss
7 天以前 00083c26fde57c0165427ae4cc712d24596fdbc6 
 src/main/java/com/ruoyi/sales/service/impl/SalesLedgerServiceImpl.java


@@ -8,7 +8,6 @@


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.service.AccountIncomeService;


import com.ruoyi.basic.enums.ApplicationTypeEnum;


import com.ruoyi.basic.enums.RecordTypeEnum;


import com.ruoyi.basic.mapper.CustomerMapper;


@@ -27,7 +26,6 @@


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.mapper.*;


import com.ruoyi.production.service.ProductionProductMainService;


import com.ruoyi.project.system.domain.SysDept;


@@ -44,7 +42,6 @@


import com.ruoyi.sales.vo.SalesLedgerVo;


import lombok.RequiredArgsConstructor;


import lombok.extern.slf4j.Slf4j;


import org.apache.commons.io.FilenameUtils;


import org.jetbrains.annotations.Nullable;


import org.springframework.beans.BeanUtils;


import org.springframework.beans.factory.annotation.Autowired;


@@ -55,15 +52,10 @@


import org.springframework.transaction.annotation.Transactional;


import org.springframework.web.multipart.MultipartFile;




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;


import java.nio.file.StandardCopyOption;


import java.time.LocalDate;


import java.time.LocalDateTime;


import java.time.YearMonth;


@@ -86,20 +78,15 @@


    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 InvoiceRegistrationProductMapper invoiceRegistrationProductMapper;


    private final InvoiceRegistrationMapper invoiceRegistrationMapper;


    private final ProductionProductMainMapper productionProductMainMapper;


    private final ProductionProductOutputMapper productionProductOutputMapper;


    private final ProductionProductInputMapper productionProductInputMapper;


@@ -289,38 +276,10 @@


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


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




            //  回款金额


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


            receiptPaymentQuery


                    .ge(ReceiptPayment::getCreateTime, startTime)


                    .le(ReceiptPayment::getCreateTime, endTime);




            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);




            MonthlyAmountDto dto = new MonthlyAmountDto();


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


            dto.setReceiptAmount(receiptAmount);


            dto.setInvoiceAmount(invoiceAmount);


            dto.setReceiptAmount(BigDecimal.ZERO);


            dto.setInvoiceAmount(BigDecimal.ZERO);




            result.add(dto);


        }


@@ -372,14 +331,16 @@


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


                salesLedger.setDeliveryDate(DateUtils.toLocalDate(salesLedgerImportDto.getDeliveryDate()));


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


                Optional<Customer> customerOptional = customers.stream()


                salesLedger.setCustomerId(customers.stream()


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


                        .findFirst();


                if (customerOptional.isEmpty()) {


                    throw new RuntimeException("客户:" + salesLedger.getCustomerName() + "不存在！");


                }


                salesLedger.setCustomerId(customerOptional.get().getId());


                salesLedger.setCustomerContractNo(customerOptional.get().getTaxpayerIdentificationNumber());


                        .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()


@@ -409,16 +370,13 @@


                    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());


                    // 校验产品规格是否存在


                    Optional<Map<String, Object>> productModelOptional = list.stream()


                    list.stream()


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


                            .findFirst();


                    if (productModelOptional.isEmpty()) {


                        throw new RuntimeException("产品大类:" + salesLedgerProduct.getProductCategory() + ",规格型号:" + salesLedgerProduct.getSpecificationModel() + "不存在！");


                    }


                    Map<String, Object> productModelMap = productModelOptional.get();


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


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


                            .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()


@@ -543,29 +501,8 @@


            salesLedgerProductMapper.deleteBatchIds(productIds);


        }




        LambdaQueryWrapper<InvoiceRegistrationProduct> wrapper = new LambdaQueryWrapper<>();


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


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


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


        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)) {


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


            }


            invoiceLedgerMapper.delete(wrapperOne);


        }


        invoiceRegistrationProductMapper.delete(wrapper);


        LambdaQueryWrapper<InvoiceRegistration> wrapperTwo = new LambdaQueryWrapper<>();


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


        invoiceRegistrationMapper.delete(wrapperTwo);




        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));