Merge branch 'dev_New_pro' of http://114.132.189.42:9002/r/product-inventor...

chenhj

8 天以前 76640d343082d1473a482e7ba48461db9b26c035

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

@@ -7,27 +7,31 @@
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.basic.dto.CustomerDto;
import com.ruoyi.basic.mapper.CustomerMapper;
import com.ruoyi.basic.mapper.CustomerPrivatePoolMapper;
import com.ruoyi.basic.pojo.Customer;
import com.ruoyi.basic.pojo.CustomerFollowUp;
import com.ruoyi.basic.pojo.CustomerPrivatePool;
import com.ruoyi.basic.service.CustomerFollowUpService;
import com.ruoyi.basic.service.CustomerReturnVisitService;
import com.ruoyi.basic.service.ICustomerService;
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.AjaxResult;
import com.ruoyi.project.system.domain.SysUser;
import com.ruoyi.sales.mapper.SalesLedgerMapper;
import com.ruoyi.sales.pojo.SalesLedger;
import lombok.AllArgsConstructor;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;


@@ -38,11 +42,15 @@
 * @date 2025-05-07
 */
@Service
@AllArgsConstructor
@RequiredArgsConstructor
@Slf4j
public class CustomerServiceImpl extends ServiceImpl<CustomerMapper, Customer> implements ICustomerService {
    private final SalesLedgerMapper salesLedgerMapper;
    private CustomerMapper customerMapper;
    private final CustomerPrivatePoolMapper customerPrivatePoolMapper;
    private final CustomerMapper customerMapper;

    private final CustomerFollowUpService customerFollowUpService;
    private final CustomerReturnVisitService customerReturnVisitService;

    /**
     * 查询客户档案
@@ -56,50 +64,70 @@
    }

    /**
     * 查询客户详情（含跟进记录和附件）
     *
     * @param id 客户档案主键
     * @return 客户详情DTO
     */
    @Override
    public Customer selectCustomerDetailById(Long id) {
        return this.getById( id);
    }

    /**
     * 查询客户档案列表
     *
     * @param customer 客户档案
     * @return 客户档案
     */
    @Override
    public IPage<Customer> selectCustomerList(Page page, Customer customer) {
        // 1. 处理空值场景（参数校验）
        if (page == null) {
            page = Page.of(1, 10); // 默认第1页，每页10条数据
        }
        if (customer == null) {
            customer = new Customer(); // 避免空对象导致的NPE
    public IPage<CustomerDto> selectCustomerList(Page<CustomerDto> page, CustomerDto customer) {
        IPage<CustomerDto> customerPage = customerMapper.listPage(page, customer);

        List<CustomerDto> records = customerPage.getRecords();
        if (CollectionUtils.isEmpty(records)) {
            return customerPage;
        }

        // 2. 构建查询条件（增强空值安全）
        LambdaQueryWrapper<Customer> queryWrapper = new LambdaQueryWrapper<>();
        String customerName = customer.getCustomerName();
        String customerType = customer.getCustomerType();
        if (StringUtils.isNotBlank(customerName)) {
            queryWrapper.like(Customer::getCustomerName, customerName);
        }
        if (StringUtils.isNotBlank(customerType)) {
            queryWrapper.like(Customer::getCustomerType, customerType);
        }

        // 3. 执行分页查询（保留分页元数据）
        IPage<Customer> customerPage = customerMapper.selectPage(page, queryWrapper);

        // 4. 数据处理（增强空值安全 & 代码可读性）
        List<Customer> processedList = customerPage.getRecords().stream()
                .filter(Objects::nonNull) // 过滤空对象（避免后续操作NPE）
                .peek(c -> {
                    // 安全获取字段，避免null值拼接
                    String address = StringUtils.defaultString(c.getCompanyAddress(), "");
                    String phone = StringUtils.defaultString(c.getCompanyPhone(), "");
                    c.setAddressPhone(address + "(" + phone + ")"); // 优化字符串拼接
                })
        List<Long> customerIds = records.stream()
                .map(CustomerDto::getId)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());

        // 5. 更新分页结果中的数据（保持分页信息完整）
        customerPage.setRecords(processedList);
        if (!CollectionUtils.isEmpty(customerIds)) {
            Map<Long, CustomerFollowUp> latestFollowUpMap = getLatestFollowUpMap(customerIds);

        return customerPage; // 返回包含分页信息的IPage对象
            records.forEach(c -> {
                String address = StringUtils.defaultString(c.getCompanyAddress(), "");
                String phone = StringUtils.defaultString(c.getCompanyPhone(), "");
                c.setAddressPhone(address + "(" + phone + ")");

                CustomerFollowUp followUp = latestFollowUpMap.get(c.getId());
                if (followUp != null) {
                    c.setFollowUpLevel(followUp.getFollowUpLevel());
                    c.setFollowUpTime(Date.from(
                            followUp.getFollowUpTime().atZone(ZoneId.systemDefault()).toInstant()
                    ));
                }
            });
        }

        return customerPage;
    }

    private Map<Long, CustomerFollowUp> getLatestFollowUpMap(List<Long> customerIds) {
        List<CustomerFollowUp> followUps = customerFollowUpService.list(
                new LambdaQueryWrapper<CustomerFollowUp>()
                        .in(CustomerFollowUp::getCustomerPrivatePoolId, customerIds)
                        .orderByDesc(CustomerFollowUp::getFollowUpTime)
        );

        return followUps.stream()
                .collect(Collectors.toMap(
                        CustomerFollowUp::getCustomerPrivatePoolId,
                        followUp -> followUp,
                        (existing, replacement) -> existing
                ));
    }

    /**
@@ -137,12 +165,23 @@
     * @return 结果
     */
    @Override
    @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("客户档案下有销售合同，请先删除销售合同");
        }
        List<CustomerPrivatePool> customerPrivatePools = customerPrivatePoolMapper.selectList(new QueryWrapper<CustomerPrivatePool>().lambda().in(CustomerPrivatePool::getCustomerId, idList));
        if (!customerPrivatePools.isEmpty()) {
            throw new RuntimeException("客户档案下有客户私海，请先收回私海数据");
        }
        //  删除客户的同时也需要删除对应的客户跟随、附件和回访提醒
        for (Long id : ids) {
            customerFollowUpService.deleteByCustomerId(id);
            customerReturnVisitService.deleteByCustomerId(id);
        }

        return customerMapper.deleteBatchIds(idList);
    }

@@ -163,12 +202,12 @@
        try {
            ExcelUtil<Customer> util = new ExcelUtil<Customer>(Customer.class);
            List<Customer> userList = util.importExcel(file.getInputStream());
            if(CollectionUtils.isEmpty(userList)){
            if (CollectionUtils.isEmpty(userList)) {
                return AjaxResult.warn("模板错误或导入数据为空");
            }
            this.saveOrUpdateBatch(userList);
            return AjaxResult.success(true);
        }catch (Exception e){
        } catch (Exception e) {
            e.printStackTrace();
            return AjaxResult.error("导入失败");
        }