用河南鹤壁代码覆盖山西长治

yuan

9 小时以前 47806d9e390ee00e1d29ad1da8c1aa908882a758

 src/main/java/com/ruoyi/basic/service/impl/CustomerServiceImpl.java

@@ -16,17 +16,14 @@
import com.ruoyi.basic.pojo.CustomerUser;
import com.ruoyi.basic.service.*;
import com.ruoyi.basic.vo.CustomerVo;
import com.ruoyi.common.utils.AmountUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.security.LoginUser;
import com.ruoyi.framework.web.domain.R;
import com.ruoyi.procurementrecord.mapper.ReturnManagementMapper;
import com.ruoyi.procurementrecord.pojo.ReturnManagement;
import com.ruoyi.sales.mapper.SalesLedgerMapper;
import com.ruoyi.sales.mapper.SalesQuotationMapper;
import com.ruoyi.sales.pojo.SalesLedger;
import com.ruoyi.sales.pojo.SalesQuotation;
import com.ruoyi.sales.vo.CustomerTransactionsDetailsVo;
import com.ruoyi.sales.vo.CustomerTransactionsVo;
import lombok.AllArgsConstructor;
@@ -38,6 +35,7 @@
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;

import java.math.BigDecimal;
import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;
@@ -54,11 +52,7 @@
@Slf4j
public class CustomerServiceImpl extends ServiceImpl<CustomerMapper, Customer> implements ICustomerService {
    @Autowired
    private SalesLedgerMapper salesLedgerMapper;
    @Autowired
    private SalesQuotationMapper salesQuotationMapper;
    @Autowired
    private ReturnManagementMapper returnManagementMapper;
    private  SalesLedgerMapper salesLedgerMapper;
    @Autowired
    private CustomerMapper customerMapper;

@@ -226,26 +220,12 @@
    @Transactional(rollbackFor = Exception.class)
    public int deleteCustomerByIds(Long[] ids) {
        List<Long> idList = Arrays.asList(ids);
        // 检查是否有销售台账关联
        List<SalesLedger> salesLedgers = salesLedgerMapper.selectList(new QueryWrapper<SalesLedger>().lambda().in(SalesLedger::getCustomerId, idList));
        if (!salesLedgers.isEmpty()) {
            throw new RuntimeException("客户档案下有销售台账，请先删除销售台账");
            throw new RuntimeException("客户档案下有销售合同，请先删除销售合同");
        }

        // 检查是否有销售退货关联
        List<ReturnManagement> returnManagements = returnManagementMapper.selectList(new QueryWrapper<ReturnManagement>().lambda().in(ReturnManagement::getCustomerId, idList));
        if (!returnManagements.isEmpty()) {
            throw new RuntimeException("客户档案下有销售退货，请先删除销售退货");
        }

        // 检查是否有销售报价关联
        List<SalesQuotation> salesQuotations = salesQuotationMapper.selectList(new QueryWrapper<SalesQuotation>().lambda().in(SalesQuotation::getCustomerId, idList));
        if (!salesQuotations.isEmpty()) {
            throw new RuntimeException("客户档案下有销售报价，请先删除销售报价");
        }

        // 查询是否有已分配的公海客户
        List<Customer> assignedPools = customerMapper.selectList(
        /*List<Customer> assignedPools = customerMapper.selectList(
                new QueryWrapper<Customer>().lambda()
                        .in(Customer::getId, idList)
                        .eq(Customer::getType, 1).
@@ -253,7 +233,7 @@
        );
        if (!assignedPools.isEmpty()) {
            throw new RuntimeException("客户档案下有已分配的公海客户，请先收回");
        }
        }*/
        // 删除客户的同时也需要删除对应的客户跟随、附件和回访提醒
        for (Long id : ids) {
            customerFollowUpService.deleteByCustomerId(id);
@@ -293,11 +273,11 @@
            }

            // 根据 type 参数设置客户类型（私海/公海）
            if (type != null) {
            /*if (type != null) {
                userList.forEach(customer -> {
                    customer.setType(type);
                });
            }
            }*/
            this.saveOrUpdateBatch(userList);
            return R.ok(true);
        } catch (Exception e) {
@@ -405,12 +385,58 @@

    @Override
    public IPage<CustomerTransactionsVo> customewTransactions(Page page, String customerName) {
        return customerMapper.customewTransactions(page, customerName);
        IPage<CustomerTransactionsVo> p = customerMapper.customewTransactions(page, customerName);
        List<CustomerTransactionsVo> records = p.getRecords();
        if (!CollectionUtils.isEmpty(records)) {
            List<Long> customerIds = records.stream().map(CustomerTransactionsVo::getCustomerId).collect(Collectors.toList());
            List<Map<String, Object>> shippedAmountList = customerMapper.getShippedAmountByCustomerIds(customerIds);
            Map<Long, BigDecimal> shippedAmountMap = new HashMap<>();
            for (Map<String, Object> map : shippedAmountList) {
                if (map.get("outboundAmount") != null) {
                    shippedAmountMap.put(((Number) map.get("customerId")).longValue(), new BigDecimal(String.valueOf(map.get("outboundAmount"))));
                }
            }
            for (CustomerTransactionsVo vo : records) {
                BigDecimal outboundAmount = shippedAmountMap.getOrDefault(vo.getCustomerId(), BigDecimal.ZERO);
                vo.setShippedAmount(outboundAmount);
                BigDecimal contractAmounts = vo.getContractAmounts() == null ? BigDecimal.ZERO : vo.getContractAmounts();
                BigDecimal unshippedAmount = contractAmounts.subtract(outboundAmount);
                if (unshippedAmount.compareTo(BigDecimal.ZERO) < 0) {
                    unshippedAmount = BigDecimal.ZERO;
                }
                vo.setUnshippedAmount(unshippedAmount);
                AmountUtils.normalizeCustomerTransaction(vo);
            }
        }
        return p;
    }

    @Override
    public IPage<CustomerTransactionsDetailsVo> customewTransactionsDetails(Page page, Long customerId) {
        return customerMapper.customewTransactionsDetails(page, customerId);
        IPage<CustomerTransactionsDetailsVo> p = customerMapper.customewTransactionsDetails(page, customerId);
        List<CustomerTransactionsDetailsVo> records = p.getRecords();
        if (!CollectionUtils.isEmpty(records)) {
            List<Long> salesLedgerIds = records.stream().map(CustomerTransactionsDetailsVo::getSalesLedgerId).collect(Collectors.toList());
            List<Map<String, Object>> shippedAmountList = customerMapper.getShippedAmountBySalesLedgerIds(salesLedgerIds);
            Map<Long, BigDecimal> shippedAmountMap = new HashMap<>();
            for (Map<String, Object> map : shippedAmountList) {
                if (map.get("outboundAmount") != null) {
                    shippedAmountMap.put(((Number) map.get("salesLedgerId")).longValue(), new BigDecimal(String.valueOf(map.get("outboundAmount"))));
                }
            }
            for (CustomerTransactionsDetailsVo vo : records) {
                BigDecimal outboundAmount = shippedAmountMap.getOrDefault(vo.getSalesLedgerId(), BigDecimal.ZERO);
                vo.setShippedAmount(outboundAmount);
                BigDecimal contractAmount = vo.getContractAmount() == null ? BigDecimal.ZERO : vo.getContractAmount();
                BigDecimal unshippedAmount = contractAmount.subtract(outboundAmount);
                if (unshippedAmount.compareTo(BigDecimal.ZERO) < 0) {
                    unshippedAmount = BigDecimal.ZERO;
                }
                vo.setUnshippedAmount(unshippedAmount);
                AmountUtils.normalizeCustomerTransactionDetail(vo);
            }
        }
        return p;
    }

    /**