2015 lines
86 KiB
Java
2015 lines
86 KiB
Java
package org.dromara.crm.service.impl;
|
||
|
||
import cn.hutool.core.date.DateUtil;
|
||
import cn.hutool.json.JSONArray;
|
||
import cn.hutool.json.JSONObject;
|
||
import cn.hutool.json.JSONUtil;
|
||
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
||
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
||
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
||
import lombok.RequiredArgsConstructor;
|
||
import lombok.extern.slf4j.Slf4j;
|
||
import org.dromara.common.core.exception.ServiceException;
|
||
import org.dromara.common.core.service.UserService;
|
||
import org.dromara.common.core.utils.MapstructUtils;
|
||
import org.dromara.common.core.utils.StringUtils;
|
||
import org.dromara.common.mybatis.core.page.PageQuery;
|
||
import org.dromara.common.mybatis.core.page.TableDataInfo;
|
||
import org.dromara.common.satoken.utils.LoginHelper;
|
||
import org.dromara.crm.domain.*;
|
||
import org.dromara.crm.domain.bo.CrmContractBo;
|
||
import org.dromara.crm.domain.bo.CrmContractProductBo;
|
||
import org.dromara.crm.domain.bo.CrmContractProductPriceTierBo;
|
||
import org.dromara.crm.domain.bo.CrmProductBo;
|
||
import org.dromara.crm.domain.vo.*;
|
||
import org.dromara.crm.mapper.*;
|
||
import org.dromara.crm.service.ICrmContractApprovalService;
|
||
import org.dromara.crm.service.ICrmContractProductService;
|
||
import org.dromara.crm.service.ICrmContractService;
|
||
import org.dromara.crm.service.ICrmPaymentPlanService;
|
||
import org.dromara.crm.service.ICrmProductService;
|
||
import org.dromara.crm.service.ICrmSupplierInfoService;
|
||
import org.springframework.stereotype.Service;
|
||
import org.springframework.transaction.annotation.Transactional;
|
||
|
||
import java.math.BigDecimal;
|
||
import java.math.RoundingMode;
|
||
import java.time.LocalDate;
|
||
import java.time.LocalDateTime;
|
||
import java.time.format.DateTimeFormatter;
|
||
import java.util.*;
|
||
import java.util.stream.Collectors;
|
||
|
||
/**
|
||
* 合同管理Service实现
|
||
*
|
||
* @author AI Assistant
|
||
* @date 2025-10-04
|
||
*/
|
||
@Slf4j
|
||
@RequiredArgsConstructor
|
||
@Service
|
||
public class CrmContractServiceImpl implements ICrmContractService {
|
||
|
||
private final CrmContractMapper baseMapper;
|
||
private final ICrmContractProductService contractProductService;
|
||
private final CrmContractApprovalMapper approvalMapper;
|
||
private final ICrmContractApprovalService contractApprovalService;
|
||
private final ICrmPaymentPlanService paymentPlanService;
|
||
private final CrmPaymentMapper paymentMapper;
|
||
private final CrmOpportunityMapper opportunityMapper;
|
||
private final CrmQuoteMapper quoteMapper;
|
||
private final CrmContractProductMapper contractProductMapper;
|
||
private final CrmContractTemplateMapper contractTemplateMapper;
|
||
private final CrmInvoiceMapper invoiceMapper;
|
||
private final CrmCustomerMapper customerMapper;
|
||
private final CrmContactMapper contactMapper;
|
||
private final UserService userService;
|
||
private final ICrmSupplierInfoService supplierInfoService;
|
||
private final ICrmProductService productService;
|
||
private final CrmProductMapper productMapper;
|
||
private final CrmContractProductPriceTierMapper contractProductPriceTierMapper;
|
||
|
||
/**
|
||
* 构建查询条件
|
||
*/
|
||
private LambdaQueryWrapper<CrmContract> buildQueryWrapper(CrmContractBo bo) {
|
||
LambdaQueryWrapper<CrmContract> lqw = Wrappers.lambdaQuery();
|
||
|
||
// 合同编号、合同名称和客户名称的OR查询
|
||
// 如果三个字段都有值且相同，则认为是联合搜索（OR关系）
|
||
if (StringUtils.isNotBlank(bo.getContractNo()) && StringUtils.isNotBlank(bo.getContractName())
|
||
&& StringUtils.isNotBlank(bo.getCustomerName())
|
||
&& bo.getContractNo().equals(bo.getContractName())
|
||
&& bo.getContractName().equals(bo.getCustomerName())) {
|
||
// 合同编号、合同名称或客户名称包含关键字
|
||
String keyword = bo.getContractNo();
|
||
lqw.and(wrapper -> wrapper
|
||
.like(CrmContract::getContractNo, keyword)
|
||
.or()
|
||
.like(CrmContract::getContractName, keyword)
|
||
.or()
|
||
.like(CrmContract::getCustomerName, keyword));
|
||
} else {
|
||
// 分别查询
|
||
lqw.like(StringUtils.isNotBlank(bo.getContractNo()), CrmContract::getContractNo, bo.getContractNo());
|
||
lqw.like(StringUtils.isNotBlank(bo.getContractName()), CrmContract::getContractName, bo.getContractName());
|
||
lqw.like(StringUtils.isNotBlank(bo.getCustomerName()), CrmContract::getCustomerName, bo.getCustomerName());
|
||
}
|
||
|
||
lqw.eq(bo.getCustomerId() != null, CrmContract::getCustomerId, bo.getCustomerId());
|
||
lqw.eq(bo.getOpportunityId() != null, CrmContract::getOpportunityId, bo.getOpportunityId());
|
||
lqw.eq(bo.getQuoteId() != null, CrmContract::getQuoteId, bo.getQuoteId());
|
||
lqw.eq(StringUtils.isNotBlank(bo.getContractType()), CrmContract::getContractType, bo.getContractType());
|
||
lqw.eq(StringUtils.isNotBlank(bo.getStatus()), CrmContract::getStatus, bo.getStatus());
|
||
// 排除指定状态（如默认排除已作废的记录）
|
||
lqw.ne(StringUtils.isNotBlank(bo.getExcludeStatus()), CrmContract::getStatus, bo.getExcludeStatus());
|
||
lqw.eq(StringUtils.isNotBlank(bo.getApprovalStatus()), CrmContract::getApprovalStatus, bo.getApprovalStatus());
|
||
lqw.eq(bo.getOwnerUserId() != null, CrmContract::getOwnerUserId, bo.getOwnerUserId());
|
||
|
||
// 如果指定了待审批人ID，查询该用户待审批的合同
|
||
if (bo.getPendingApprovalUserId() != null) {
|
||
// 使用SQL子查询：查询审批记录中审批人是当前用户且审批结果是pending且isCurrent=1的合同
|
||
lqw.inSql(CrmContract::getId,
|
||
"SELECT DISTINCT contract_id FROM crm_contract_approval " +
|
||
"WHERE approver_id = " + bo.getPendingApprovalUserId() +
|
||
" AND approval_result = 'pending' " +
|
||
" AND is_current = 1 " +
|
||
" AND del_flag = 0");
|
||
}
|
||
|
||
// 如果指定了审批人ID，查询该用户审批过的合同
|
||
if (bo.getApprovedByUserId() != null) {
|
||
// 查询该审批人已审批过的合同ID列表
|
||
LambdaQueryWrapper<CrmContractApproval> approvalLqw = Wrappers.lambdaQuery();
|
||
approvalLqw.eq(CrmContractApproval::getApproverId, bo.getApprovedByUserId());
|
||
approvalLqw.in(CrmContractApproval::getApprovalResult, "approved", "rejected");
|
||
List<CrmContractApproval> approvalList = approvalMapper.selectList(approvalLqw);
|
||
if (!approvalList.isEmpty()) {
|
||
List<Long> contractIds = approvalList.stream()
|
||
.map(CrmContractApproval::getContractId)
|
||
.distinct()
|
||
.collect(java.util.stream.Collectors.toList());
|
||
lqw.in(CrmContract::getId, contractIds);
|
||
} else {
|
||
// 如果没有审批记录，返回空结果
|
||
lqw.eq(CrmContract::getId, -1L);
|
||
}
|
||
}
|
||
|
||
lqw.ge(bo.getParams().get("minAmount") != null, CrmContract::getAmount, bo.getParams().get("minAmount"));
|
||
lqw.le(bo.getParams().get("maxAmount") != null, CrmContract::getAmount, bo.getParams().get("maxAmount"));
|
||
// 签订日期范围查询
|
||
if (bo.getSignDateBegin() != null && !bo.getSignDateBegin().isEmpty()) {
|
||
lqw.ge(CrmContract::getSignDate, LocalDate.parse(bo.getSignDateBegin()));
|
||
}
|
||
if (bo.getSignDateEnd() != null && !bo.getSignDateEnd().isEmpty()) {
|
||
lqw.le(CrmContract::getSignDate, LocalDate.parse(bo.getSignDateEnd()));
|
||
}
|
||
lqw.between(bo.getParams().get("beginTime") != null && bo.getParams().get("endTime") != null,
|
||
CrmContract::getCreateTime, bo.getParams().get("beginTime"), bo.getParams().get("endTime"));
|
||
lqw.orderByDesc(CrmContract::getCreateTime);
|
||
return lqw;
|
||
}
|
||
|
||
@Override
|
||
public TableDataInfo<CrmContractVo> queryPageList(CrmContractBo bo, PageQuery pageQuery) {
|
||
LambdaQueryWrapper<CrmContract> lqw = buildQueryWrapper(bo);
|
||
Page<CrmContractVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
|
||
|
||
// 设置每个合同的审批权限
|
||
try {
|
||
Long currentUserId = LoginHelper.getUserId();
|
||
for (CrmContractVo vo : result.getRecords()) {
|
||
vo.setCanApprove(contractApprovalService.canUserApprove(vo.getId(), currentUserId));
|
||
}
|
||
} catch (Exception e) {
|
||
log.warn("获取当前用户审批权限失败: {}", e.getMessage());
|
||
}
|
||
|
||
return TableDataInfo.build(result);
|
||
}
|
||
|
||
@Override
|
||
public List<CrmContractVo> queryList(CrmContractBo bo) {
|
||
LambdaQueryWrapper<CrmContract> lqw = buildQueryWrapper(bo);
|
||
return baseMapper.selectVoList(lqw);
|
||
}
|
||
|
||
@Override
|
||
public CrmContractVo queryById(Long id) {
|
||
CrmContractVo vo = baseMapper.selectVoById(id);
|
||
if (vo != null) {
|
||
// 设置当前用户是否可以审批
|
||
try {
|
||
Long currentUserId = LoginHelper.getUserId();
|
||
vo.setCanApprove(contractApprovalService.canUserApprove(id, currentUserId));
|
||
} catch (Exception e) {
|
||
log.warn("获取当前用户审批权限失败: {}", e.getMessage());
|
||
vo.setCanApprove(false);
|
||
}
|
||
|
||
// 关联查询供方主体名称
|
||
if (vo.getSupplierId() != null) {
|
||
try {
|
||
CrmSupplierInfoVo supplierInfo = supplierInfoService.queryById(vo.getSupplierId());
|
||
if (supplierInfo != null) {
|
||
vo.setSupplierName(supplierInfo.getSupplierName());
|
||
}
|
||
} catch (Exception e) {
|
||
log.warn("获取供方主体信息失败: {}", e.getMessage());
|
||
}
|
||
}
|
||
|
||
// 查询并设置产品明细列表
|
||
try {
|
||
List<CrmContractProductVo> products = contractProductService.queryListByContractId(id);
|
||
if (vo.getProducts() == null || vo.getProducts().isEmpty()) {
|
||
vo.setProducts(products);
|
||
}
|
||
if ("framework".equals(vo.getContractType()) && products != null && !products.isEmpty()) {
|
||
List<CrmContractProductPriceTier> tierEntities = contractProductPriceTierMapper.selectList(
|
||
Wrappers.lambdaQuery(CrmContractProductPriceTier.class)
|
||
.eq(CrmContractProductPriceTier::getContractId, id)
|
||
.orderByAsc(CrmContractProductPriceTier::getContractProductId)
|
||
.orderByAsc(CrmContractProductPriceTier::getSort));
|
||
List<CrmContractProductPriceTierVo> allTiers = new ArrayList<>();
|
||
for (CrmContractProductPriceTier en : tierEntities) {
|
||
allTiers.add(convertTierEntityToVo(en));
|
||
}
|
||
Map<Long, List<CrmContractProductPriceTierVo>> tierMap = new HashMap<>();
|
||
for (CrmContractProductPriceTierVo t : allTiers) {
|
||
tierMap.computeIfAbsent(t.getContractProductId(), k -> new ArrayList<>()).add(t);
|
||
}
|
||
for (CrmContractProductVo p : products) {
|
||
p.setPriceTiers(tierMap.getOrDefault(p.getId(), new ArrayList<>()));
|
||
}
|
||
}
|
||
log.info("查询合同详情成功，合同ID: {}, 产品数量: {}", id, products != null ? products.size() : 0);
|
||
} catch (Exception e) {
|
||
log.error("查询合同产品明细失败，合同ID: {}", id, e);
|
||
}
|
||
}
|
||
return vo;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean insertByBo(CrmContractBo bo) {
|
||
validateContractTypeAndProductsPresence(bo);
|
||
normalizeFrameworkContractData(bo);
|
||
validateProductPricesByContractType(bo);
|
||
validateSalePurchaseContractAmount(bo);
|
||
|
||
CrmContract entity = MapstructUtils.convert(bo, CrmContract.class);
|
||
|
||
// 查询供方信息（用于生成合同编号和合同名称）
|
||
String supplierShortName = "山峡"; // 默认简称
|
||
if (entity.getSupplierId() != null) {
|
||
try {
|
||
CrmSupplierInfoVo supplierInfo = supplierInfoService.queryById(entity.getSupplierId());
|
||
if (supplierInfo != null && StringUtils.isNotBlank(supplierInfo.getShortName())) {
|
||
supplierShortName = supplierInfo.getShortName();
|
||
}
|
||
} catch (Exception e) {
|
||
log.warn("查询供方信息失败，使用默认简称，供方ID: {}", entity.getSupplierId(), e);
|
||
}
|
||
}
|
||
|
||
// 生成合同编号
|
||
if (StringUtils.isBlank(entity.getContractNo())) {
|
||
entity.setContractNo(generateContractNo(entity.getSupplierId(), entity.getSignDate()));
|
||
}
|
||
|
||
// 查询客户信息
|
||
CrmCustomer customer = null;
|
||
if (entity.getCustomerId() != null) {
|
||
customer = customerMapper.selectById(entity.getCustomerId());
|
||
if (customer != null) {
|
||
entity.setCustomerName(customer.getCustomerName());
|
||
}
|
||
}
|
||
|
||
String contractType = entity.getContractType();
|
||
|
||
// 自动生成合同名称
|
||
String contractNo = entity.getContractNo();
|
||
String customerShortName = customer != null ? customer.getShortName() : "";
|
||
entity.setContractName(generateContractName(contractNo, contractType, supplierShortName,
|
||
customerShortName, entity.getContractName()));
|
||
|
||
// 查询并设置联系人信息
|
||
if (entity.getContactId() != null) {
|
||
CrmContact contact = contactMapper.selectById(entity.getContactId());
|
||
if (contact != null) {
|
||
entity.setContactName(contact.getContactName());
|
||
entity.setContactMobile(contact.getMobile());
|
||
}
|
||
}
|
||
|
||
// 设置默认值
|
||
if (entity.getStatus() == null) {
|
||
entity.setStatus("draft");
|
||
}
|
||
// 草稿状态下，审批状态应该为空，只有提交审批后才设置为pending
|
||
if ("draft".equals(entity.getStatus())) {
|
||
entity.setApprovalStatus(null);
|
||
}
|
||
if (entity.getOwnerUserId() == null) {
|
||
entity.setOwnerUserId(LoginHelper.getUserId());
|
||
}
|
||
|
||
// 设置负责人姓名
|
||
if (entity.getOwnerUserId() != null) {
|
||
try {
|
||
String ownerUserName = userService.selectNicknameById(entity.getOwnerUserId());
|
||
entity.setOwnerUserName(ownerUserName);
|
||
} catch (Exception e) {
|
||
log.warn("获取负责人姓名失败，用户ID: {}", entity.getOwnerUserId(), e);
|
||
entity.setOwnerUserName(null);
|
||
}
|
||
} else {
|
||
entity.setOwnerUserName(null);
|
||
}
|
||
|
||
if (entity.getReceivedAmount() == null) {
|
||
entity.setReceivedAmount(BigDecimal.ZERO);
|
||
}
|
||
if (entity.getInvoiceAmount() == null) {
|
||
entity.setInvoiceAmount(BigDecimal.ZERO);
|
||
}
|
||
|
||
// 计算未回款金额和未开票金额
|
||
entity.setUnreceivedAmount(entity.getAmount().subtract(entity.getReceivedAmount()));
|
||
entity.setUninvoiceAmount(entity.getAmount().subtract(entity.getInvoiceAmount()));
|
||
|
||
// 保存合同
|
||
resolveContractProductIds(bo.getProducts());
|
||
boolean flag = baseMapper.insert(entity) > 0;
|
||
if (flag) {
|
||
bo.setId(entity.getId());
|
||
|
||
// 保存产品明细
|
||
if (bo.getProducts() != null && !bo.getProducts().isEmpty()) {
|
||
int sort = 1;
|
||
for (CrmContractProductBo product : bo.getProducts()) {
|
||
product.setContractId(entity.getId());
|
||
// 清空ID，让MyBatis-Plus自动生成新ID，避免主键冲突
|
||
product.setId(null);
|
||
// 如果没有设置排序号，则自动设置为循环索引
|
||
if (product.getSort() == null) {
|
||
product.setSort(sort);
|
||
}
|
||
sort++;
|
||
contractProductService.insertByBo(product);
|
||
if ("framework".equals(entity.getContractType())) {
|
||
savePriceTiersForProduct(product.getId(), entity.getId(), product.getPriceTiers());
|
||
}
|
||
}
|
||
}
|
||
|
||
// 生成回款计划
|
||
if (bo.getPaymentPlans() != null && !bo.getPaymentPlans().isEmpty()) {
|
||
try {
|
||
paymentPlanService.batchGenerate(entity.getId(), bo.getPaymentPlans());
|
||
log.info("合同创建成功，已生成回款计划，合同ID: {}, 期数: {}", entity.getId(), bo.getPaymentPlans().size());
|
||
} catch (Exception e) {
|
||
log.error("生成回款计划失败，合同ID: {}", entity.getId(), e);
|
||
// 不影响合同创建，只记录日志
|
||
}
|
||
}
|
||
}
|
||
return flag;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean updateByBo(CrmContractBo bo) {
|
||
// 只有草稿状态的合同才能修改
|
||
CrmContract existContract = baseMapper.selectById(bo.getId());
|
||
if (existContract == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
if (!"draft".equals(existContract.getStatus())) {
|
||
throw new ServiceException("只有草稿状态的合同才能修改");
|
||
}
|
||
|
||
validateContractTypeAndProductsPresence(bo);
|
||
normalizeFrameworkContractData(bo);
|
||
validateProductPricesByContractType(bo);
|
||
validateSalePurchaseContractAmount(bo);
|
||
|
||
CrmContract entity = MapstructUtils.convert(bo, CrmContract.class);
|
||
|
||
// 草稿状态下，审批状态应该为空
|
||
if ("draft".equals(existContract.getStatus())) {
|
||
entity.setApprovalStatus(null);
|
||
}
|
||
|
||
// 查询并设置客户名称（如果客户ID有变化）
|
||
CrmCustomer customer = null;
|
||
if (entity.getCustomerId() != null && !entity.getCustomerId().equals(existContract.getCustomerId())) {
|
||
customer = customerMapper.selectById(entity.getCustomerId());
|
||
if (customer != null) {
|
||
entity.setCustomerName(customer.getCustomerName());
|
||
}
|
||
} else if (entity.getCustomerId() != null) {
|
||
// 客户ID没变化，但可能需要用于生成合同名称
|
||
customer = customerMapper.selectById(entity.getCustomerId());
|
||
}
|
||
|
||
// 查询并设置联系人信息（如果联系人ID有变化）
|
||
if (entity.getContactId() != null && !entity.getContactId().equals(existContract.getContactId())) {
|
||
CrmContact contact = contactMapper.selectById(entity.getContactId());
|
||
if (contact != null) {
|
||
entity.setContactName(contact.getContactName());
|
||
entity.setContactMobile(contact.getMobile());
|
||
}
|
||
}
|
||
|
||
// 检查签订日期是否变化，如果变化则重新生成合同编号和合同名称
|
||
boolean signDateChanged = entity.getSignDate() != null
|
||
&& !entity.getSignDate().equals(existContract.getSignDate());
|
||
boolean supplierIdChanged = entity.getSupplierId() != null
|
||
&& !entity.getSupplierId().equals(existContract.getSupplierId());
|
||
|
||
if (signDateChanged || supplierIdChanged) {
|
||
// 查询供方信息（用于生成合同编号和合同名称）
|
||
String supplierShortName = "山峡"; // 默认简称
|
||
if (entity.getSupplierId() != null) {
|
||
try {
|
||
CrmSupplierInfoVo supplierInfo = supplierInfoService.queryById(entity.getSupplierId());
|
||
if (supplierInfo != null && StringUtils.isNotBlank(supplierInfo.getShortName())) {
|
||
supplierShortName = supplierInfo.getShortName();
|
||
}
|
||
} catch (Exception e) {
|
||
log.warn("查询供方信息失败，使用默认简称，供方ID: {}", entity.getSupplierId(), e);
|
||
}
|
||
}
|
||
|
||
// 重新生成合同编号
|
||
entity.setContractNo(generateContractNo(entity.getSupplierId(), entity.getSignDate()));
|
||
|
||
// 重新生成合同名称
|
||
String contractNo = entity.getContractNo();
|
||
String customerShortName = customer != null ? customer.getShortName() : "";
|
||
// 判断用户是否修改了合同名称
|
||
// 如果用户修改了合同名称，使用用户的新名称；否则使用旧名称并更新编号
|
||
String userContractName = null;
|
||
if (StringUtils.isNotBlank(entity.getContractName())
|
||
&& !entity.getContractName().equals(existContract.getContractName())) {
|
||
// 用户修改了合同名称，使用用户的新名称（移除可能存在的旧编号）
|
||
userContractName = entity.getContractName().replaceAll("（[^）]+）$", "");
|
||
} else {
|
||
// 用户没有修改合同名称，使用旧名称（移除旧的合同编号）
|
||
String oldContractName = existContract.getContractName();
|
||
if (StringUtils.isNotBlank(oldContractName)) {
|
||
userContractName = oldContractName.replaceAll("（[^）]+）$", "");
|
||
}
|
||
}
|
||
entity.setContractName(generateContractName(contractNo, entity.getContractType(), supplierShortName,
|
||
customerShortName, userContractName));
|
||
}
|
||
|
||
// 重新计算未回款金额和未开票金额
|
||
if (entity.getAmount() != null) {
|
||
BigDecimal receivedAmount = existContract.getReceivedAmount() != null
|
||
? existContract.getReceivedAmount()
|
||
: BigDecimal.ZERO;
|
||
BigDecimal invoiceAmount = existContract.getInvoiceAmount() != null
|
||
? existContract.getInvoiceAmount()
|
||
: BigDecimal.ZERO;
|
||
entity.setUnreceivedAmount(entity.getAmount().subtract(receivedAmount));
|
||
entity.setUninvoiceAmount(entity.getAmount().subtract(invoiceAmount));
|
||
}
|
||
|
||
boolean flag = baseMapper.updateById(entity) > 0;
|
||
if (flag && bo.getProducts() != null) {
|
||
resolveContractProductIds(bo.getProducts());
|
||
contractProductPriceTierMapper.delete(Wrappers.lambdaQuery(CrmContractProductPriceTier.class)
|
||
.eq(CrmContractProductPriceTier::getContractId, bo.getId()));
|
||
// 更新产品明细（简化处理：先删除再新增）
|
||
contractProductService.deleteByIds(
|
||
contractProductService.queryListByContractId(bo.getId())
|
||
.stream().map(p -> p.getId()).toList());
|
||
int sort = 1;
|
||
for (CrmContractProductBo product : bo.getProducts()) {
|
||
product.setContractId(bo.getId());
|
||
// 清空ID，让MyBatis-Plus自动生成新ID，避免主键冲突
|
||
product.setId(null);
|
||
// 如果没有设置排序号，则自动设置为循环索引
|
||
if (product.getSort() == null) {
|
||
product.setSort(sort);
|
||
}
|
||
sort++;
|
||
contractProductService.insertByBo(product);
|
||
if ("framework".equals(bo.getContractType())) {
|
||
savePriceTiersForProduct(product.getId(), bo.getId(), product.getPriceTiers());
|
||
}
|
||
}
|
||
}
|
||
return flag;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
|
||
if (isValid) {
|
||
// 校验：只能删除草稿状态的合同
|
||
for (Long id : ids) {
|
||
CrmContract contract = baseMapper.selectById(id);
|
||
if (contract != null && !"draft".equals(contract.getStatus())) {
|
||
throw new ServiceException("只能删除草稿状态的合同");
|
||
}
|
||
}
|
||
}
|
||
return baseMapper.deleteByIds(ids) > 0;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean submitApproval(Long id, List<Long> approverIds, String remark) {
|
||
CrmContract contract = baseMapper.selectById(id);
|
||
if (contract == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
if (!"draft".equals(contract.getStatus())) {
|
||
throw new ServiceException("只有草稿状态的合同才能提交审批");
|
||
}
|
||
|
||
validateFrameworkContractForSubmitApproval(id, contract);
|
||
|
||
// 更新合同状态
|
||
CrmContract update = new CrmContract();
|
||
update.setId(id);
|
||
update.setStatus("approving");
|
||
update.setApprovalStatus("pending");
|
||
baseMapper.updateById(update);
|
||
|
||
// 创建审批记录
|
||
if (approverIds != null && !approverIds.isEmpty()) {
|
||
for (int i = 0; i < approverIds.size(); i++) {
|
||
Long approverId = approverIds.get(i);
|
||
|
||
CrmContractApproval approval = new CrmContractApproval();
|
||
approval.setContractId(id);
|
||
approval.setStep(i + 1);
|
||
approval.setStepName("第" + (i + 1) + "步审批");
|
||
approval.setApproverId(approverId);
|
||
|
||
// TODO: 这里应该查询用户信息填充审批人姓名和部门
|
||
// 由于跨模块调用复杂性，暂时在审批时填充
|
||
// 或者可以通过远程API调用System模块的用户服务
|
||
approval.setApproverName("审批人" + approverId); // 临时占位
|
||
approval.setApproverDept("待审批时填充"); // 临时占位
|
||
|
||
approval.setApprovalResult("pending");
|
||
approval.setIsCurrent(i == 0 ? 1 : 0);
|
||
approval.setSort(i + 1);
|
||
approvalMapper.insert(approval);
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public int batchSubmitApproval(List<Long> ids, List<Long> approverIds, String remark) {
|
||
int successCount = 0;
|
||
for (Long id : ids) {
|
||
try {
|
||
submitApproval(id, approverIds, remark);
|
||
successCount++;
|
||
} catch (Exception e) {
|
||
// 记录错误但继续处理其他合同
|
||
log.error("合同ID {} 提交审批失败: {}", id, e.getMessage());
|
||
}
|
||
}
|
||
return successCount;
|
||
}
|
||
|
||
@Override
|
||
public Boolean saveTemplate(Long id, String templateContent, String settlementClauseDrafts) {
|
||
// 检查合同是否存在
|
||
CrmContract entity = baseMapper.selectById(id);
|
||
if (entity == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
String finalSettlementClauseDrafts = settlementClauseDrafts;
|
||
if (StringUtils.isBlank(finalSettlementClauseDrafts)) {
|
||
String method = StringUtils.isNotBlank(entity.getSettlementMethod()) ? entity.getSettlementMethod() : "arrive_payment";
|
||
String defaultClause = "advance_payment".equals(method)
|
||
? "款到发货。需方付款后安排发货，需方收到货物后，供方开具13%增值税专用发票。"
|
||
: "货到付款，需方收到供方货物后，供方开具13%增值税专用发票，无异议后，以现汇方式月结。";
|
||
JSONObject drafts = new JSONObject();
|
||
drafts.set(method, defaultClause);
|
||
finalSettlementClauseDrafts = drafts.toString();
|
||
}
|
||
|
||
log.info("========== 开始保存合同模板内容 ==========");
|
||
log.info("contractId={}", id);
|
||
log.info("contentLength={}", templateContent != null ? templateContent.length() : 0);
|
||
log.info("content前200字符={}", templateContent != null && templateContent.length() > 200
|
||
? templateContent.substring(0, 200)
|
||
: templateContent);
|
||
log.info("包含HTML标签={}", templateContent != null && templateContent.contains("<"));
|
||
log.info("第五条草稿长度={}", finalSettlementClauseDrafts != null ? finalSettlementClauseDrafts.length() : 0);
|
||
|
||
// 使用 LambdaUpdateWrapper 只更新模板相关字段，避免乐观锁问题
|
||
int result = baseMapper.update(null,
|
||
Wrappers.<CrmContract>lambdaUpdate()
|
||
.eq(CrmContract::getId, id)
|
||
.set(CrmContract::getTemplateContent, templateContent)
|
||
.set(CrmContract::getSettlementClauseDrafts, finalSettlementClauseDrafts));
|
||
|
||
log.info("保存合同模板内容完成: contractId={}, success={}, affectedRows={}",
|
||
id, result > 0, result);
|
||
|
||
// 验证保存结果
|
||
CrmContract savedEntity = baseMapper.selectById(id);
|
||
if (savedEntity != null && savedEntity.getTemplateContent() != null) {
|
||
log.info("验证保存结果: 数据库中的内容长度={}", savedEntity.getTemplateContent().length());
|
||
log.info("验证保存结果: 数据库中的内容前200字符={}",
|
||
savedEntity.getTemplateContent().length() > 200
|
||
? savedEntity.getTemplateContent().substring(0, 200)
|
||
: savedEntity.getTemplateContent());
|
||
} else {
|
||
log.warn("验证保存结果: 数据库中未找到模板内容！");
|
||
}
|
||
|
||
return result > 0;
|
||
}
|
||
|
||
@Override
|
||
public String getTemplate(Long id) {
|
||
log.info("========== 开始获取合同模板内容 ==========");
|
||
log.info("contractId={}", id);
|
||
|
||
// 直接查询，确保获取最新数据
|
||
CrmContract entity = baseMapper.selectById(id);
|
||
if (entity == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
|
||
String templateContent = entity.getTemplateContent();
|
||
log.info("获取合同模板内容完成:");
|
||
log.info("- hasTemplate={}", templateContent != null);
|
||
log.info("- contentLength={}", templateContent != null ? templateContent.length() : 0);
|
||
log.info("- content前200字符={}", templateContent != null && templateContent.length() > 200
|
||
? templateContent.substring(0, 200)
|
||
: templateContent);
|
||
log.info("- 包含HTML标签={}", templateContent != null && templateContent.contains("<"));
|
||
|
||
return templateContent;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean withdrawApproval(Long id, String remark) {
|
||
CrmContract contract = baseMapper.selectById(id);
|
||
if (contract == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
if (!"approving".equals(contract.getStatus())) {
|
||
throw new ServiceException("只有审批中的合同才能撤回");
|
||
}
|
||
|
||
// 使用 UpdateWrapper 来明确更新 null 值
|
||
com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper<CrmContract> updateWrapper = Wrappers
|
||
.lambdaUpdate();
|
||
updateWrapper.eq(CrmContract::getId, id)
|
||
.set(CrmContract::getStatus, "draft")
|
||
.set(CrmContract::getApprovalStatus, null); // 明确设置为 null
|
||
baseMapper.update(null, updateWrapper);
|
||
|
||
// 删除待审批的审批记录
|
||
LambdaQueryWrapper<CrmContractApproval> wrapper = Wrappers.lambdaQuery();
|
||
wrapper.eq(CrmContractApproval::getContractId, id);
|
||
wrapper.eq(CrmContractApproval::getApprovalResult, "pending");
|
||
approvalMapper.delete(wrapper);
|
||
|
||
log.info("撤回审批成功，合同ID: {}, 撤回原因: {}", id, remark);
|
||
return true;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean startExecute(Long id, String remark) {
|
||
CrmContract contract = baseMapper.selectById(id);
|
||
if (contract == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
if (!"approved".equals(contract.getStatus())) {
|
||
throw new ServiceException("只有已审批的合同才能开始执行");
|
||
}
|
||
|
||
CrmContract update = new CrmContract();
|
||
update.setId(id);
|
||
update.setStatus("executing");
|
||
return baseMapper.updateById(update) > 0;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean finishContract(Long id, String remark) {
|
||
CrmContract contract = baseMapper.selectById(id);
|
||
if (contract == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
if (!"executing".equals(contract.getStatus())) {
|
||
throw new ServiceException("只有执行中的合同才能完成");
|
||
}
|
||
|
||
CrmContract update = new CrmContract();
|
||
update.setId(id);
|
||
update.setStatus("finished");
|
||
if (StringUtils.isNotBlank(remark)) {
|
||
update.setRemark(remark);
|
||
}
|
||
return baseMapper.updateById(update) > 0;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean invalidContract(Long id, String invalidReason, String remark) {
|
||
if (StringUtils.isBlank(invalidReason)) {
|
||
throw new ServiceException("作废原因不能为空");
|
||
}
|
||
|
||
CrmContract contract = baseMapper.selectById(id);
|
||
if (contract == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
if ("finished".equals(contract.getStatus())) {
|
||
throw new ServiceException("已完成的合同不能作废");
|
||
}
|
||
|
||
CrmContract update = new CrmContract();
|
||
update.setId(id);
|
||
update.setStatus("invalid");
|
||
update.setInvalidReason(invalidReason);
|
||
update.setInvalidTime(LocalDateTime.now());
|
||
update.setRemark(remark);
|
||
return baseMapper.updateById(update) > 0;
|
||
}
|
||
|
||
@Override
|
||
public Boolean uploadFile(Long id, String fileUrl) {
|
||
CrmContract update = new CrmContract();
|
||
update.setId(id);
|
||
update.setContractFile(fileUrl);
|
||
return baseMapper.updateById(update) > 0;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean uploadAttachments(Long id, String ossIds) {
|
||
if (StringUtils.isBlank(ossIds)) {
|
||
throw new ServiceException("附件ossId不能为空");
|
||
}
|
||
|
||
CrmContract contract = baseMapper.selectById(id);
|
||
if (contract == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
|
||
// 追加附件ossId
|
||
String existingFiles = contract.getAttachmentFiles();
|
||
String newFiles;
|
||
if (StringUtils.isBlank(existingFiles)) {
|
||
newFiles = ossIds;
|
||
} else {
|
||
// 将现有附件和新附件合并（去重）
|
||
String[] existingArr = existingFiles.split(",");
|
||
String[] newArr = ossIds.split(",");
|
||
java.util.Set<String> fileSet = new java.util.HashSet<>(java.util.Arrays.asList(existingArr));
|
||
fileSet.addAll(java.util.Arrays.asList(newArr));
|
||
newFiles = String.join(",", fileSet);
|
||
}
|
||
|
||
CrmContract update = new CrmContract();
|
||
update.setId(id);
|
||
update.setAttachmentFiles(newFiles);
|
||
return baseMapper.updateById(update) > 0;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean uploadAttachmentsWithCategory(Long id, java.util.List<java.util.Map<String, Object>> attachments) {
|
||
if (attachments == null || attachments.isEmpty()) {
|
||
throw new ServiceException("附件列表不能为空");
|
||
}
|
||
|
||
CrmContract contract = baseMapper.selectById(id);
|
||
if (contract == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
|
||
// 解析现有附件（支持JSON格式和逗号分隔格式）
|
||
JSONArray existingAttachments = new JSONArray();
|
||
String existingFiles = contract.getAttachmentFiles();
|
||
if (StringUtils.isNotBlank(existingFiles)) {
|
||
// 尝试解析为JSON格式
|
||
if (existingFiles.trim().startsWith("[")) {
|
||
existingAttachments = JSONUtil.parseArray(existingFiles);
|
||
} else {
|
||
// 兼容旧格式：逗号分隔的ossId，转换为JSON格式
|
||
String[] ossIds = existingFiles.split(",");
|
||
for (String ossId : ossIds) {
|
||
if (StringUtils.isNotBlank(ossId)) {
|
||
JSONObject item = new JSONObject();
|
||
item.set("ossId", ossId.trim());
|
||
item.set("category", "other"); // 旧数据默认分类为"其他附件"
|
||
existingAttachments.add(item);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 添加新附件（去重：基于ossId）
|
||
java.util.Set<String> existingOssIds = new java.util.HashSet<>();
|
||
for (int i = 0; i < existingAttachments.size(); i++) {
|
||
JSONObject item = existingAttachments.getJSONObject(i);
|
||
String ossId = item.getStr("ossId");
|
||
if (StringUtils.isNotBlank(ossId)) {
|
||
existingOssIds.add(ossId);
|
||
}
|
||
}
|
||
|
||
for (java.util.Map<String, Object> attachment : attachments) {
|
||
String ossId = attachment.get("ossId") != null ? attachment.get("ossId").toString() : null;
|
||
String category = attachment.get("category") != null ? attachment.get("category").toString() : "other";
|
||
|
||
if (StringUtils.isBlank(ossId)) {
|
||
continue;
|
||
}
|
||
|
||
// 如果已存在，更新分类；否则添加新附件
|
||
if (existingOssIds.contains(ossId)) {
|
||
// 更新现有附件的分类
|
||
for (int i = 0; i < existingAttachments.size(); i++) {
|
||
JSONObject item = existingAttachments.getJSONObject(i);
|
||
if (ossId.equals(item.getStr("ossId"))) {
|
||
item.set("category", category);
|
||
break;
|
||
}
|
||
}
|
||
} else {
|
||
// 添加新附件
|
||
JSONObject newItem = new JSONObject();
|
||
newItem.set("ossId", ossId);
|
||
newItem.set("category", category);
|
||
existingAttachments.add(newItem);
|
||
existingOssIds.add(ossId);
|
||
}
|
||
}
|
||
|
||
// 保存为JSON格式
|
||
String newFiles = JSONUtil.toJsonStr(existingAttachments);
|
||
|
||
CrmContract update = new CrmContract();
|
||
update.setId(id);
|
||
update.setAttachmentFiles(newFiles);
|
||
return baseMapper.updateById(update) > 0;
|
||
}
|
||
|
||
@Override
|
||
public Map<String, Object> statisticsOverview(Long ownerUserId, String beginTime, String endTime) {
|
||
Map<String, Object> result = new HashMap<>();
|
||
|
||
// 构建查询条件
|
||
LambdaQueryWrapper<CrmContract> lqw = Wrappers.lambdaQuery();
|
||
|
||
// 负责人筛选
|
||
if (ownerUserId != null) {
|
||
lqw.eq(CrmContract::getOwnerUserId, ownerUserId);
|
||
}
|
||
|
||
// 时间范围筛选
|
||
if (StringUtils.isNotBlank(beginTime) && StringUtils.isNotBlank(endTime)) {
|
||
lqw.between(CrmContract::getCreateTime, beginTime, endTime);
|
||
}
|
||
|
||
// 查询所有合同
|
||
List<CrmContract> contracts = baseMapper.selectList(lqw);
|
||
|
||
// 统计各状态数量
|
||
long totalCount = contracts.size();
|
||
long draftCount = contracts.stream().filter(c -> "draft".equals(c.getStatus())).count();
|
||
long approvingCount = contracts.stream().filter(c -> "approving".equals(c.getStatus())).count();
|
||
long executingCount = contracts.stream().filter(c -> "executing".equals(c.getStatus())).count();
|
||
long finishedCount = contracts.stream().filter(c -> "finished".equals(c.getStatus())).count();
|
||
long invalidCount = contracts.stream().filter(c -> "invalid".equals(c.getStatus())).count();
|
||
|
||
// 统计金额
|
||
BigDecimal totalAmount = contracts.stream()
|
||
.map(CrmContract::getAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
BigDecimal receivedAmount = contracts.stream()
|
||
.map(CrmContract::getReceivedAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
BigDecimal unreceivedAmount = contracts.stream()
|
||
.map(CrmContract::getUnreceivedAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
BigDecimal invoiceAmount = contracts.stream()
|
||
.map(CrmContract::getInvoiceAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
BigDecimal uninvoiceAmount = contracts.stream()
|
||
.map(CrmContract::getUninvoiceAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
// 计算回款率和开票率
|
||
BigDecimal receivedRate = totalAmount.compareTo(BigDecimal.ZERO) > 0
|
||
? receivedAmount.divide(totalAmount, 4, RoundingMode.HALF_UP).multiply(new BigDecimal("100"))
|
||
: BigDecimal.ZERO;
|
||
|
||
BigDecimal invoiceRate = totalAmount.compareTo(BigDecimal.ZERO) > 0
|
||
? invoiceAmount.divide(totalAmount, 4, RoundingMode.HALF_UP).multiply(new BigDecimal("100"))
|
||
: BigDecimal.ZERO;
|
||
|
||
// 组装结果
|
||
result.put("totalCount", totalCount);
|
||
result.put("draftCount", draftCount);
|
||
result.put("approvingCount", approvingCount);
|
||
result.put("executingCount", executingCount);
|
||
result.put("finishedCount", finishedCount);
|
||
result.put("invalidCount", invalidCount);
|
||
result.put("totalAmount", totalAmount);
|
||
result.put("receivedAmount", receivedAmount);
|
||
result.put("unreceivedAmount", unreceivedAmount);
|
||
result.put("receivedRate", receivedRate.setScale(2, RoundingMode.HALF_UP));
|
||
result.put("invoiceAmount", invoiceAmount);
|
||
result.put("uninvoiceAmount", uninvoiceAmount);
|
||
result.put("invoiceRate", invoiceRate.setScale(2, RoundingMode.HALF_UP));
|
||
|
||
return result;
|
||
}
|
||
|
||
@Override
|
||
public List<Map<String, Object>> statisticsByStatus() {
|
||
List<Map<String, Object>> result = new ArrayList<>();
|
||
|
||
// 查询所有合同
|
||
List<CrmContract> contracts = baseMapper.selectList(Wrappers.lambdaQuery());
|
||
|
||
// 计算总数和总金额
|
||
long totalCount = contracts.size();
|
||
BigDecimal totalAmount = contracts.stream()
|
||
.map(CrmContract::getAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
// 定义状态映射
|
||
Map<String, String> statusMap = new LinkedHashMap<>();
|
||
statusMap.put("draft", "草稿");
|
||
statusMap.put("approving", "审批中");
|
||
statusMap.put("approved", "已审批");
|
||
statusMap.put("executing", "执行中");
|
||
statusMap.put("finished", "已完成");
|
||
statusMap.put("invalid", "已作废");
|
||
|
||
// 按状态统计
|
||
for (Map.Entry<String, String> entry : statusMap.entrySet()) {
|
||
String status = entry.getKey();
|
||
String statusName = entry.getValue();
|
||
|
||
List<CrmContract> statusContracts = contracts.stream()
|
||
.filter(c -> status.equals(c.getStatus()))
|
||
.toList();
|
||
|
||
long count = statusContracts.size();
|
||
BigDecimal amount = statusContracts.stream()
|
||
.map(CrmContract::getAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
// 计算百分比
|
||
BigDecimal percent = totalCount > 0
|
||
? new BigDecimal(count).divide(new BigDecimal(totalCount), 4, RoundingMode.HALF_UP)
|
||
.multiply(new BigDecimal("100"))
|
||
: BigDecimal.ZERO;
|
||
|
||
Map<String, Object> item = new HashMap<>();
|
||
item.put("status", status);
|
||
item.put("statusName", statusName);
|
||
item.put("count", count);
|
||
item.put("amount", amount);
|
||
item.put("percent", percent.setScale(2, RoundingMode.HALF_UP));
|
||
|
||
result.add(item);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
@Override
|
||
public List<Map<String, Object>> statisticsByType() {
|
||
List<Map<String, Object>> result = new ArrayList<>();
|
||
|
||
// 查询所有合同
|
||
List<CrmContract> contracts = baseMapper.selectList(Wrappers.lambdaQuery());
|
||
|
||
// 计算总数和总金额
|
||
long totalCount = contracts.size();
|
||
BigDecimal totalAmount = contracts.stream()
|
||
.map(CrmContract::getAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
// 定义类型映射
|
||
Map<String, String> typeMap = new LinkedHashMap<>();
|
||
typeMap.put("sale", "销售合同");
|
||
typeMap.put("service", "服务合同");
|
||
typeMap.put("purchase", "采购合同");
|
||
typeMap.put("framework", "框架合同");
|
||
typeMap.put("supplement", "补充协议");
|
||
typeMap.put("lease", "租赁合同");
|
||
typeMap.put("other", "其他");
|
||
|
||
// 按类型统计
|
||
for (Map.Entry<String, String> entry : typeMap.entrySet()) {
|
||
String type = entry.getKey();
|
||
String typeName = entry.getValue();
|
||
|
||
List<CrmContract> typeContracts = contracts.stream()
|
||
.filter(c -> type.equals(c.getContractType()))
|
||
.toList();
|
||
|
||
long count = typeContracts.size();
|
||
|
||
// 如果该类型没有合同，跳过
|
||
if (count == 0) {
|
||
continue;
|
||
}
|
||
|
||
BigDecimal amount = typeContracts.stream()
|
||
.map(CrmContract::getAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
// 计算百分比
|
||
BigDecimal percent = totalCount > 0
|
||
? new BigDecimal(count).divide(new BigDecimal(totalCount), 4, RoundingMode.HALF_UP)
|
||
.multiply(new BigDecimal("100"))
|
||
: BigDecimal.ZERO;
|
||
|
||
Map<String, Object> item = new HashMap<>();
|
||
item.put("contractType", type);
|
||
item.put("typeName", typeName);
|
||
item.put("count", count);
|
||
item.put("amount", amount);
|
||
item.put("percent", percent.setScale(2, RoundingMode.HALF_UP));
|
||
|
||
result.add(item);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
@Override
|
||
public List<Map<String, Object>> statisticsTrend(String type, String beginTime, String endTime) {
|
||
List<Map<String, Object>> result = new ArrayList<>();
|
||
|
||
// 解析开始和结束时间
|
||
LocalDateTime startDateTime;
|
||
LocalDateTime endDateTime;
|
||
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
|
||
|
||
try {
|
||
startDateTime = LocalDateTime.parse(beginTime, formatter);
|
||
endDateTime = LocalDateTime.parse(endTime, formatter);
|
||
} catch (Exception e) {
|
||
log.error("日期格式错误", e);
|
||
return result;
|
||
}
|
||
|
||
// 查询时间范围内的合同
|
||
LambdaQueryWrapper<CrmContract> lqw = Wrappers.lambdaQuery();
|
||
lqw.between(CrmContract::getCreateTime, startDateTime, endDateTime);
|
||
List<CrmContract> contracts = baseMapper.selectList(lqw);
|
||
|
||
// 根据type确定统计粒度
|
||
String period;
|
||
if ("month".equals(type)) {
|
||
period = "month";
|
||
} else if ("quarter".equals(type)) {
|
||
period = "quarter";
|
||
} else if ("year".equals(type)) {
|
||
period = "year";
|
||
} else {
|
||
period = "month"; // 默认按月统计
|
||
}
|
||
|
||
// 按时间分组统计
|
||
Map<String, List<CrmContract>> groupedContracts = new LinkedHashMap<>();
|
||
|
||
for (CrmContract contract : contracts) {
|
||
if (contract.getCreateTime() == null) {
|
||
continue;
|
||
}
|
||
|
||
// 将Date转换为LocalDateTime
|
||
LocalDateTime createTime = DateUtil.toLocalDateTime(contract.getCreateTime());
|
||
|
||
String periodKey;
|
||
if ("month".equals(period)) {
|
||
periodKey = createTime.format(DateTimeFormatter.ofPattern("yyyy-MM"));
|
||
} else if ("quarter".equals(period)) {
|
||
int quarter = (createTime.getMonthValue() - 1) / 3 + 1;
|
||
periodKey = createTime.getYear() + "-Q" + quarter;
|
||
} else { // year
|
||
periodKey = String.valueOf(createTime.getYear());
|
||
}
|
||
|
||
groupedContracts.computeIfAbsent(periodKey, k -> new ArrayList<>()).add(contract);
|
||
}
|
||
|
||
// 生成统计结果
|
||
for (Map.Entry<String, List<CrmContract>> entry : groupedContracts.entrySet()) {
|
||
String periodKey = entry.getKey();
|
||
List<CrmContract> periodContracts = entry.getValue();
|
||
|
||
long totalCount = periodContracts.size();
|
||
BigDecimal totalAmount = periodContracts.stream()
|
||
.map(CrmContract::getAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
BigDecimal receivedAmount = periodContracts.stream()
|
||
.map(CrmContract::getReceivedAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
// 计算回款率
|
||
BigDecimal receivedRate = totalAmount.compareTo(BigDecimal.ZERO) > 0
|
||
? receivedAmount.divide(totalAmount, 4, RoundingMode.HALF_UP).multiply(new BigDecimal("100"))
|
||
: BigDecimal.ZERO;
|
||
|
||
Map<String, Object> item = new HashMap<>();
|
||
item.put("period", periodKey);
|
||
item.put("totalCount", totalCount);
|
||
item.put("totalAmount", totalAmount);
|
||
item.put("receivedAmount", receivedAmount);
|
||
item.put("receivedRate", receivedRate.setScale(2, RoundingMode.HALF_UP));
|
||
|
||
result.add(item);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
@Override
|
||
public List<CrmContractVo> queryExpiring(Integer days) {
|
||
if (days == null || days <= 0) {
|
||
days = 30;
|
||
}
|
||
LocalDate endDate = LocalDate.now().plusDays(days);
|
||
|
||
LambdaQueryWrapper<CrmContract> lqw = Wrappers.lambdaQuery();
|
||
lqw.eq(CrmContract::getStatus, "executing");
|
||
lqw.le(CrmContract::getEndDate, endDate);
|
||
lqw.ge(CrmContract::getEndDate, LocalDate.now());
|
||
lqw.orderByAsc(CrmContract::getEndDate);
|
||
|
||
return baseMapper.selectVoList(lqw);
|
||
}
|
||
|
||
/**
|
||
* 生成合同名称
|
||
* <p>销售合同、框架合同：供方简称-客户简称（合同编号）；采购合同：客户简称-供方简称（合同编号）；其余类型未填名称时为「合同（编号）」。</p>
|
||
*
|
||
* @param contractNo 合同编号
|
||
* @param contractType 合同类型
|
||
* @param supplierShortName 供方简称
|
||
* @param customerShortName 客户简称
|
||
* @param userContractName 用户填写的合同名称（如果为空则自动生成）
|
||
* @return 合同名称
|
||
*/
|
||
private String generateContractName(String contractNo, String contractType,
|
||
String supplierShortName, String customerShortName,
|
||
String userContractName) {
|
||
if (StringUtils.isBlank(userContractName)) {
|
||
// 用户未填写合同名称，根据类型自动生成
|
||
if ("sale".equals(contractType) || "framework".equals(contractType)) {
|
||
// 销售合同、框架合同：供方简称-客户简称（合同编号）
|
||
return supplierShortName + "-" + customerShortName + "（" + contractNo + "）";
|
||
} else if ("purchase".equals(contractType)) {
|
||
// 采购合同：客户简称-供方简称（合同编号）
|
||
return customerShortName + "-" + supplierShortName + "（" + contractNo + "）";
|
||
} else {
|
||
// 其他类型：使用合同编号作为名称
|
||
return "合同（" + contractNo + "）";
|
||
}
|
||
} else {
|
||
// 用户手工填写了合同名称，自动补充合同编号
|
||
// 先移除旧的合同编号（如果存在）
|
||
String cleanedName = userContractName.replaceAll("（[^）]+）$", "");
|
||
// 检查是否已经包含新的合同编号，避免重复添加
|
||
if (!cleanedName.contains("（" + contractNo + "）")) {
|
||
return cleanedName + "（" + contractNo + "）";
|
||
}
|
||
return cleanedName;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 生成合同编号
|
||
* 格式：{供方编码}/X-JT + yyyyMMdd + 3位流水号
|
||
* 示例：SX/X-JT20250926002
|
||
*
|
||
* @param supplierId 供方主体ID，如果为null则使用默认编码"SX"
|
||
* @param signDate 签订日期，如果为null则使用当前日期
|
||
*/
|
||
@Override
|
||
public String generateContractNo(Long supplierId, LocalDate signDate) {
|
||
// 获取供方编码，如果没有则使用默认值"SX"
|
||
String supplierCode = "SX";
|
||
if (supplierId != null) {
|
||
try {
|
||
CrmSupplierInfoVo supplierInfo = supplierInfoService.queryById(supplierId);
|
||
if (supplierInfo != null && StringUtils.isNotBlank(supplierInfo.getSupplierCode())) {
|
||
supplierCode = supplierInfo.getSupplierCode();
|
||
}
|
||
} catch (Exception e) {
|
||
log.warn("查询供方信息失败，使用默认编码，供方ID: {}", supplierId, e);
|
||
}
|
||
}
|
||
|
||
String prefix = supplierCode + "/X-JT";
|
||
// 使用签订日期，如果为null则使用当前日期
|
||
LocalDate dateToUse = signDate != null ? signDate : LocalDate.now();
|
||
String date = dateToUse.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
|
||
|
||
// 查询该签订日期最大流水号（使用动态前缀）
|
||
LambdaQueryWrapper<CrmContract> wrapper = Wrappers.lambdaQuery();
|
||
wrapper.likeRight(CrmContract::getContractNo, prefix + date);
|
||
wrapper.orderByDesc(CrmContract::getContractNo);
|
||
wrapper.last("LIMIT 1");
|
||
CrmContract lastContract = baseMapper.selectOne(wrapper);
|
||
|
||
int serialNum = 1;
|
||
if (lastContract != null && lastContract.getContractNo() != null) {
|
||
String lastNo = lastContract.getContractNo();
|
||
// 完整编号格式：{供方编码}/X-JT20250926002
|
||
// 前缀长度可能不同，需要动态计算
|
||
int prefixLength = prefix.length();
|
||
int dateLength = 8; // yyyyMMdd
|
||
int totalPrefixLength = prefixLength + dateLength;
|
||
|
||
if (lastNo.length() >= totalPrefixLength + 3) {
|
||
try {
|
||
String serialStr = lastNo.substring(totalPrefixLength);
|
||
serialNum = Integer.parseInt(serialStr) + 1;
|
||
} catch (NumberFormatException e) {
|
||
log.warn("解析合同编号流水号失败，使用默认值1，合同编号: {}", lastNo);
|
||
serialNum = 1;
|
||
}
|
||
}
|
||
}
|
||
return String.format("%s%s%03d", prefix, date, serialNum);
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean updateReceivedAmount(Long contractId) {
|
||
// 查询该合同的所有回款记录
|
||
LambdaQueryWrapper<CrmPayment> lqw = Wrappers.lambdaQuery();
|
||
lqw.eq(CrmPayment::getContractId, contractId);
|
||
lqw.eq(CrmPayment::getDelFlag, 0);
|
||
List<CrmPayment> payments = paymentMapper.selectList(lqw);
|
||
|
||
// 计算已回款金额
|
||
BigDecimal receivedAmount = payments.stream()
|
||
.map(CrmPayment::getAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
// 查询合同
|
||
CrmContract contract = baseMapper.selectById(contractId);
|
||
if (contract == null) {
|
||
log.error("合同不存在，无法更新回款金额，合同ID: {}", contractId);
|
||
return false;
|
||
}
|
||
|
||
// 更新合同回款金额
|
||
CrmContract update = new CrmContract();
|
||
update.setId(contractId);
|
||
update.setReceivedAmount(receivedAmount);
|
||
update.setUnreceivedAmount(contract.getAmount().subtract(receivedAmount));
|
||
|
||
boolean flag = baseMapper.updateById(update) > 0;
|
||
if (flag) {
|
||
log.info("更新合同回款金额成功，合同ID: {}, 已回款: {}", contractId, receivedAmount);
|
||
}
|
||
|
||
return flag;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Long renewContract(Long parentContractId, CrmContractBo bo) {
|
||
// 1. 查询原合同
|
||
CrmContract parentContract = baseMapper.selectById(parentContractId);
|
||
if (parentContract == null) {
|
||
throw new ServiceException("原合同不存在");
|
||
}
|
||
|
||
// 2. 创建续签合同
|
||
CrmContract newContract = new CrmContract();
|
||
|
||
// 从原合同复制基础信息
|
||
newContract.setCustomerId(parentContract.getCustomerId());
|
||
newContract.setCustomerName(parentContract.getCustomerName());
|
||
newContract.setContactId(parentContract.getContactId());
|
||
newContract.setContactName(parentContract.getContactName());
|
||
newContract.setContactMobile(parentContract.getContactMobile());
|
||
newContract.setContractType(parentContract.getContractType());
|
||
newContract.setOwnerUserId(parentContract.getOwnerUserId());
|
||
newContract.setOwnerUserName(parentContract.getOwnerUserName());
|
||
// 复制供方主体ID
|
||
newContract.setSupplierId(bo.getSupplierId() != null ? bo.getSupplierId() : parentContract.getSupplierId());
|
||
|
||
// 设置续签相关字段
|
||
newContract.setContractNature("renewal");
|
||
newContract.setParentContractId(parentContractId);
|
||
newContract
|
||
.setRenewalCount((parentContract.getRenewalCount() == null ? 0 : parentContract.getRenewalCount()) + 1);
|
||
|
||
// 使用传入的新信息覆盖
|
||
if (StringUtils.isNotBlank(bo.getContractName())) {
|
||
newContract.setContractName(bo.getContractName());
|
||
} else {
|
||
newContract.setContractName(parentContract.getContractName() + "-续签" + newContract.getRenewalCount());
|
||
}
|
||
|
||
newContract.setAmount(bo.getAmount() != null ? bo.getAmount() : parentContract.getAmount());
|
||
newContract.setCurrency(bo.getCurrency() != null ? bo.getCurrency() : parentContract.getCurrency());
|
||
newContract.setTaxRate(bo.getTaxRate() != null ? bo.getTaxRate() : parentContract.getTaxRate());
|
||
|
||
// 计算含税金额
|
||
if (newContract.getTaxRate() != null && newContract.getAmount() != null) {
|
||
newContract.setAmountWithTax(
|
||
newContract.getAmount().multiply(
|
||
BigDecimal.ONE.add(
|
||
newContract.getTaxRate().divide(new BigDecimal("100"), 4, RoundingMode.HALF_UP))));
|
||
}
|
||
|
||
newContract.setSignDate(bo.getSignDate());
|
||
newContract.setStartDate(bo.getStartDate());
|
||
newContract.setEndDate(bo.getEndDate());
|
||
newContract.setContractPeriod(bo.getContractPeriod());
|
||
|
||
// 复制甲乙方信息
|
||
newContract.setPartyA(parentContract.getPartyA());
|
||
newContract.setPartyAAddress(parentContract.getPartyAAddress());
|
||
newContract.setPartyAContact(parentContract.getPartyAContact());
|
||
newContract.setPartyAMobile(parentContract.getPartyAMobile());
|
||
newContract.setPartyB(parentContract.getPartyB());
|
||
newContract.setPartyBAddress(parentContract.getPartyBAddress());
|
||
newContract.setPartyBContact(parentContract.getPartyBContact());
|
||
newContract.setPartyBMobile(parentContract.getPartyBMobile());
|
||
|
||
// 复制合同条款
|
||
newContract.setPaymentTerms(
|
||
bo.getPaymentTerms() != null ? bo.getPaymentTerms() : parentContract.getPaymentTerms());
|
||
newContract.setDeliveryTerms(
|
||
bo.getDeliveryTerms() != null ? bo.getDeliveryTerms() : parentContract.getDeliveryTerms());
|
||
newContract.setContractTerms(
|
||
bo.getContractTerms() != null ? bo.getContractTerms() : parentContract.getContractTerms());
|
||
|
||
// 生成合同编号（续签合同使用原合同的供方主体）
|
||
newContract.setContractNo(generateContractNo(newContract.getSupplierId(), newContract.getSignDate()));
|
||
|
||
// 设置默认状态
|
||
newContract.setStatus("draft");
|
||
newContract.setApprovalStatus(null); // 草稿状态下，审批状态应该为空
|
||
newContract.setPerformanceStatus("normal");
|
||
newContract.setPerformanceRate(BigDecimal.ZERO);
|
||
newContract.setReceivedAmount(BigDecimal.ZERO);
|
||
newContract.setUnreceivedAmount(newContract.getAmount());
|
||
newContract.setInvoiceAmount(BigDecimal.ZERO);
|
||
newContract.setUninvoiceAmount(newContract.getAmount());
|
||
|
||
// 保存续签合同
|
||
boolean flag = baseMapper.insert(newContract) > 0;
|
||
if (!flag) {
|
||
throw new ServiceException("创建续签合同失败");
|
||
}
|
||
|
||
// 复制产品明细
|
||
if (bo.getProducts() != null && !bo.getProducts().isEmpty()) {
|
||
resolveContractProductIds(bo.getProducts());
|
||
// 使用传入的产品
|
||
for (CrmContractProductBo product : bo.getProducts()) {
|
||
product.setContractId(newContract.getId());
|
||
// 清空ID，让MyBatis-Plus自动生成新ID，避免主键冲突
|
||
product.setId(null);
|
||
contractProductService.insertByBo(product);
|
||
if ("framework".equals(parentContract.getContractType())) {
|
||
savePriceTiersForProduct(product.getId(), newContract.getId(), product.getPriceTiers());
|
||
}
|
||
}
|
||
} else {
|
||
// 复制原合同的产品
|
||
LambdaQueryWrapper<CrmContractProduct> productWrapper = Wrappers.lambdaQuery();
|
||
productWrapper.eq(CrmContractProduct::getContractId, parentContractId);
|
||
List<CrmContractProduct> parentProducts = contractProductMapper.selectList(productWrapper);
|
||
|
||
for (CrmContractProduct parentProduct : parentProducts) {
|
||
CrmContractProduct newProduct = new CrmContractProduct();
|
||
newProduct.setContractId(newContract.getId());
|
||
newProduct.setProductId(parentProduct.getProductId());
|
||
newProduct.setProductName(parentProduct.getProductName());
|
||
newProduct.setProductNo(parentProduct.getProductNo());
|
||
newProduct.setCategoryId(parentProduct.getCategoryId());
|
||
newProduct.setCategoryName(parentProduct.getCategoryName());
|
||
newProduct.setModel(parentProduct.getModel());
|
||
newProduct.setUnit(parentProduct.getUnit());
|
||
newProduct.setQuantity(parentProduct.getQuantity());
|
||
newProduct.setPrice(parentProduct.getPrice());
|
||
newProduct.setDiscount(parentProduct.getDiscount());
|
||
newProduct.setSubtotal(parentProduct.getSubtotal());
|
||
newProduct.setDescription(parentProduct.getDescription());
|
||
newProduct.setSort(parentProduct.getSort());
|
||
contractProductMapper.insert(newProduct);
|
||
if ("framework".equals(parentContract.getContractType())) {
|
||
copyPriceTiersToNewProduct(parentProduct.getId(), newContract.getId(), newProduct.getId());
|
||
}
|
||
}
|
||
}
|
||
|
||
log.info("合同续签成功，原合同ID: {}, 新合同ID: {}, 续签次数: {}", parentContractId, newContract.getId(),
|
||
newContract.getRenewalCount());
|
||
return newContract.getId();
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean createFromOpportunity(Long opportunityId, CrmContractBo bo) {
|
||
// 1. 查询商机
|
||
CrmOpportunity opportunity = opportunityMapper.selectById(opportunityId);
|
||
if (opportunity == null) {
|
||
throw new ServiceException("商机不存在");
|
||
}
|
||
|
||
// 2. 自动填充信息
|
||
bo.setOpportunityId(opportunityId);
|
||
bo.setCustomerId(opportunity.getCustomerId());
|
||
if (bo.getAmount() == null) {
|
||
bo.setAmount(opportunity.getAmount());
|
||
}
|
||
if (bo.getOwnerUserId() == null) {
|
||
bo.setOwnerUserId(opportunity.getOwnerUserId());
|
||
}
|
||
|
||
// 3. 创建合同
|
||
boolean flag = insertByBo(bo);
|
||
|
||
// 4. 更新商机状态为"已转合同"
|
||
if (flag) {
|
||
CrmOpportunity updateOpp = new CrmOpportunity();
|
||
updateOpp.setId(opportunityId);
|
||
updateOpp.setStage("won"); // 赢单
|
||
opportunityMapper.updateById(updateOpp);
|
||
|
||
log.info("从商机创建合同成功，商机ID: {}, 合同ID: {}", opportunityId, bo.getId());
|
||
}
|
||
|
||
return flag;
|
||
}
|
||
|
||
/**
|
||
* 保存合同前解析产品ID（按名称/规格/分类/单位/税率匹配，未命中自动新增）
|
||
*/
|
||
private void resolveContractProductIds(List<CrmContractProductBo> products) {
|
||
if (products == null || products.isEmpty()) {
|
||
return;
|
||
}
|
||
for (CrmContractProductBo product : products) {
|
||
product.setProductId(resolveProductIdForContractItem(product));
|
||
}
|
||
}
|
||
|
||
private Long resolveProductIdForContractItem(CrmContractProductBo contractProductBo) {
|
||
if (contractProductBo == null) {
|
||
throw new ServiceException("产品明细不能为空");
|
||
}
|
||
String productName = normalizeText(contractProductBo.getProductName());
|
||
if (productName == null) {
|
||
throw new ServiceException("产品名称不能为空");
|
||
}
|
||
String model = normalizeText(contractProductBo.getModel());
|
||
String unit = normalizeText(contractProductBo.getUnit());
|
||
BigDecimal taxRateForCompare = normalizeTaxRateForCompare(contractProductBo.getTaxRate());
|
||
BigDecimal taxRateForSave = normalizeTaxRateForSave(contractProductBo.getTaxRate());
|
||
|
||
LambdaQueryWrapper<CrmProduct> lqw = Wrappers.lambdaQuery();
|
||
// 名称/规格/单位：trim + 不区分大小写 + null与空字符串视为相同
|
||
lqw.apply("LOWER(TRIM(COALESCE(product_name, ''))) = {0}", toLower(productName));
|
||
lqw.apply("LOWER(TRIM(COALESCE(model, ''))) = {0}", toLower(model));
|
||
lqw.apply("LOWER(TRIM(COALESCE(unit, ''))) = {0}", toLower(unit));
|
||
// 税率：统一保留2位后比较
|
||
lqw.apply("ROUND(COALESCE(tax_rate, 0), 2) = {0}", taxRateForCompare);
|
||
lqw.orderByDesc(CrmProduct::getId);
|
||
List<CrmProduct> candidates = productMapper.selectList(lqw);
|
||
|
||
if (!candidates.isEmpty()) {
|
||
Long categoryId = contractProductBo.getCategoryId();
|
||
// 分类为空允许匹配；若有分类，优先取分类一致
|
||
if (categoryId != null) {
|
||
for (CrmProduct candidate : candidates) {
|
||
if (categoryId.equals(candidate.getCategoryId())) {
|
||
return candidate.getId();
|
||
}
|
||
}
|
||
}
|
||
// 命中多条取最新一条（id最大）
|
||
return candidates.get(0).getId();
|
||
}
|
||
|
||
// 未命中则自动新增产品
|
||
CrmProductBo newBo = new CrmProductBo();
|
||
newBo.setProductNo(productService.generateAutoProductNo());
|
||
newBo.setProductName(productName);
|
||
newBo.setCategoryId(contractProductBo.getCategoryId());
|
||
newBo.setCategoryName(normalizeText(contractProductBo.getCategoryName()));
|
||
newBo.setModel(model);
|
||
newBo.setUnit(unit);
|
||
newBo.setTaxRate(taxRateForSave);
|
||
// 合同保存自动新增产品时，标准价格默认0
|
||
newBo.setPrice(BigDecimal.ZERO);
|
||
newBo.setStatus("on");
|
||
productService.insertByBo(newBo);
|
||
return newBo.getId();
|
||
}
|
||
|
||
private String normalizeText(String value) {
|
||
if (value == null) {
|
||
return null;
|
||
}
|
||
String trimmed = value.trim();
|
||
return trimmed.isEmpty() ? null : trimmed;
|
||
}
|
||
|
||
private String toLower(String value) {
|
||
return value == null ? "" : value.toLowerCase();
|
||
}
|
||
|
||
private BigDecimal normalizeTaxRateForCompare(BigDecimal value) {
|
||
BigDecimal taxRate = value == null ? BigDecimal.ZERO : value;
|
||
return taxRate.setScale(2, RoundingMode.HALF_UP);
|
||
}
|
||
|
||
/**
|
||
* 保存税率时尽量保留前端传入形态：
|
||
* - 传整数则保存整数
|
||
* - 传小数则保存小数
|
||
*/
|
||
private BigDecimal normalizeTaxRateForSave(BigDecimal value) {
|
||
if (value == null) {
|
||
return BigDecimal.ZERO;
|
||
}
|
||
BigDecimal normalized = value.stripTrailingZeros();
|
||
if (normalized.scale() <= 0) {
|
||
return normalized.setScale(0, RoundingMode.UNNECESSARY);
|
||
}
|
||
return normalized;
|
||
}
|
||
|
||
private void validateContractTypeAndProductsPresence(CrmContractBo bo) {
|
||
if (bo == null || StringUtils.isBlank(bo.getContractType())) {
|
||
return;
|
||
}
|
||
String contractType = bo.getContractType();
|
||
if ("sale".equals(contractType) || "purchase".equals(contractType) || "framework".equals(contractType)) {
|
||
if (bo.getProducts() == null || bo.getProducts().isEmpty()) {
|
||
throw new ServiceException("销售合同、采购合同或框架合同必须至少添加一个产品");
|
||
}
|
||
}
|
||
}
|
||
|
||
private void normalizeFrameworkContractData(CrmContractBo bo) {
|
||
if (bo == null || !"framework".equals(bo.getContractType())) {
|
||
return;
|
||
}
|
||
bo.setAmount(BigDecimal.ZERO);
|
||
bo.setAmountWithTax(BigDecimal.ZERO);
|
||
if (bo.getProducts() == null) {
|
||
return;
|
||
}
|
||
for (CrmContractProductBo p : bo.getProducts()) {
|
||
p.setPrice(BigDecimal.ZERO);
|
||
p.setSubtotal(BigDecimal.ZERO);
|
||
p.setTaxAmount(BigDecimal.ZERO);
|
||
}
|
||
}
|
||
|
||
private void validateProductPricesByContractType(CrmContractBo bo) {
|
||
if (bo == null || StringUtils.isBlank(bo.getContractType())) {
|
||
return;
|
||
}
|
||
String contractType = bo.getContractType();
|
||
if (!"sale".equals(contractType) && !"purchase".equals(contractType)) {
|
||
return;
|
||
}
|
||
List<CrmContractProductBo> products = bo.getProducts();
|
||
if (products == null) {
|
||
return;
|
||
}
|
||
for (CrmContractProductBo p : products) {
|
||
if (p.getPrice() == null || p.getPrice().compareTo(new BigDecimal("0.01")) < 0) {
|
||
throw new ServiceException("销售/采购合同产品的含税单价必须大于0");
|
||
}
|
||
if (p.getSubtotal() == null || p.getSubtotal().compareTo(new BigDecimal("0.01")) < 0) {
|
||
throw new ServiceException("销售/采购合同产品的含税总价必须大于0");
|
||
}
|
||
}
|
||
}
|
||
|
||
private void validateSalePurchaseContractAmount(CrmContractBo bo) {
|
||
if (bo == null || StringUtils.isBlank(bo.getContractType())) {
|
||
return;
|
||
}
|
||
String contractType = bo.getContractType();
|
||
if (!"sale".equals(contractType) && !"purchase".equals(contractType)) {
|
||
return;
|
||
}
|
||
if (bo.getAmount() == null || bo.getAmount().compareTo(new BigDecimal("0.01")) < 0) {
|
||
throw new ServiceException("销售合同或采购合同的合同金额必须大于0");
|
||
}
|
||
}
|
||
|
||
private List<String> parseLetterOssIdsJson(String json) {
|
||
if (StringUtils.isBlank(json)) {
|
||
return Collections.emptyList();
|
||
}
|
||
try {
|
||
List<String> list = JSONUtil.toList(json, String.class);
|
||
return list.stream().filter(StringUtils::isNotBlank).map(String::trim).toList();
|
||
} catch (Exception e) {
|
||
log.warn("解析 letter_oss_ids JSON 失败: {}", json);
|
||
return Collections.emptyList();
|
||
}
|
||
}
|
||
|
||
private List<String> parseLetterOssIdsFromEntity(CrmContractProductPriceTier en) {
|
||
if (StringUtils.isNotBlank(en.getLetterOssIds())) {
|
||
List<String> parsed = parseLetterOssIdsJson(en.getLetterOssIds());
|
||
if (!parsed.isEmpty()) {
|
||
return new ArrayList<>(parsed);
|
||
}
|
||
}
|
||
if (en.getLetterOssId() != null) {
|
||
return new ArrayList<>(List.of(en.getLetterOssId().toString()));
|
||
}
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
private CrmContractProductPriceTierVo convertTierEntityToVo(CrmContractProductPriceTier en) {
|
||
CrmContractProductPriceTierVo vo = new CrmContractProductPriceTierVo();
|
||
vo.setId(en.getId());
|
||
vo.setContractId(en.getContractId());
|
||
vo.setContractProductId(en.getContractProductId());
|
||
vo.setStartDate(en.getStartDate());
|
||
vo.setEndDate(en.getEndDate());
|
||
vo.setPrice(en.getPrice());
|
||
vo.setSort(en.getSort());
|
||
vo.setLetterOssIds(parseLetterOssIdsFromEntity(en));
|
||
return vo;
|
||
}
|
||
|
||
private void savePriceTiersForProduct(Long contractProductId, Long contractId, List<CrmContractProductPriceTierBo> tiers) {
|
||
if (tiers == null || tiers.isEmpty()) {
|
||
return;
|
||
}
|
||
int sort = 1;
|
||
for (CrmContractProductPriceTierBo t : tiers) {
|
||
if (t.getStartDate() == null || t.getEndDate() == null || t.getPrice() == null) {
|
||
continue;
|
||
}
|
||
List<String> ossIds = t.getLetterOssIds();
|
||
if (ossIds == null || ossIds.isEmpty()) {
|
||
continue;
|
||
}
|
||
List<String> normalized = ossIds.stream()
|
||
.filter(StringUtils::isNotBlank)
|
||
.map(String::trim)
|
||
.toList();
|
||
if (normalized.isEmpty()) {
|
||
continue;
|
||
}
|
||
CrmContractProductPriceTier e = new CrmContractProductPriceTier();
|
||
e.setContractId(contractId);
|
||
e.setContractProductId(contractProductId);
|
||
e.setStartDate(t.getStartDate());
|
||
e.setEndDate(t.getEndDate());
|
||
e.setPrice(t.getPrice());
|
||
e.setLetterOssIds(JSONUtil.toJsonStr(normalized));
|
||
e.setLetterOssId(null);
|
||
if (t.getSort() == null) {
|
||
e.setSort(sort);
|
||
} else {
|
||
e.setSort(t.getSort());
|
||
}
|
||
sort++;
|
||
contractProductPriceTierMapper.insert(e);
|
||
}
|
||
}
|
||
|
||
private void copyPriceTiersToNewProduct(Long oldContractProductId, Long newContractId, Long newContractProductId) {
|
||
List<CrmContractProductPriceTier> rows = contractProductPriceTierMapper.selectList(
|
||
Wrappers.lambdaQuery(CrmContractProductPriceTier.class)
|
||
.eq(CrmContractProductPriceTier::getContractProductId, oldContractProductId));
|
||
if (rows == null || rows.isEmpty()) {
|
||
return;
|
||
}
|
||
int s = 1;
|
||
for (CrmContractProductPriceTier row : rows) {
|
||
CrmContractProductPriceTier n = new CrmContractProductPriceTier();
|
||
n.setContractId(newContractId);
|
||
n.setContractProductId(newContractProductId);
|
||
n.setStartDate(row.getStartDate());
|
||
n.setEndDate(row.getEndDate());
|
||
n.setPrice(row.getPrice());
|
||
n.setLetterOssIds(row.getLetterOssIds());
|
||
n.setLetterOssId(row.getLetterOssId());
|
||
n.setSort(row.getSort() != null ? row.getSort() : s);
|
||
contractProductPriceTierMapper.insert(n);
|
||
s++;
|
||
}
|
||
}
|
||
|
||
private void validateFrameworkContractForSubmitApproval(Long contractId, CrmContract contract) {
|
||
if (!"framework".equals(contract.getContractType())) {
|
||
return;
|
||
}
|
||
List<CrmContractProductVo> products = contractProductService.queryListByContractId(contractId);
|
||
if (products == null || products.isEmpty()) {
|
||
throw new ServiceException("框架合同必须维护产品明细");
|
||
}
|
||
List<CrmContractProductPriceTier> tiers = contractProductPriceTierMapper.selectList(
|
||
Wrappers.lambdaQuery(CrmContractProductPriceTier.class)
|
||
.eq(CrmContractProductPriceTier::getContractId, contractId));
|
||
Map<Long, List<CrmContractProductPriceTier>> byProduct = tiers.stream()
|
||
.collect(Collectors.groupingBy(CrmContractProductPriceTier::getContractProductId));
|
||
for (CrmContractProductVo prod : products) {
|
||
List<CrmContractProductPriceTier> list = byProduct.get(prod.getId());
|
||
if (list == null || list.isEmpty()) {
|
||
throw new ServiceException("框架合同产品「" + prod.getProductName() + "」至少维护一条调价区间（含调价函）");
|
||
}
|
||
for (CrmContractProductPriceTier t : list) {
|
||
if (t.getStartDate() == null || t.getEndDate() == null) {
|
||
throw new ServiceException("框架合同产品「" + prod.getProductName() + "」调价区间日期不能为空");
|
||
}
|
||
if (t.getStartDate().isAfter(t.getEndDate())) {
|
||
throw new ServiceException("框架合同产品「" + prod.getProductName() + "」调价开始日期不能晚于结束日期");
|
||
}
|
||
if (t.getPrice() == null || t.getPrice().compareTo(BigDecimal.ZERO) <= 0) {
|
||
throw new ServiceException("框架合同产品「" + prod.getProductName() + "」调价含税单价必须大于0");
|
||
}
|
||
List<String> letterIds = parseLetterOssIdsFromEntity(t);
|
||
if (letterIds.isEmpty()) {
|
||
throw new ServiceException("框架合同产品「" + prod.getProductName() + "」每条调价区间须上传调价函附件");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean createFromQuote(Long quoteId, CrmContractBo bo) {
|
||
// 1. 查询报价单
|
||
CrmQuote quote = quoteMapper.selectById(quoteId);
|
||
if (quote == null) {
|
||
throw new ServiceException("报价单不存在");
|
||
}
|
||
|
||
// 2. 自动填充信息
|
||
bo.setQuoteId(quoteId);
|
||
bo.setCustomerId(quote.getCustomerId());
|
||
bo.setOpportunityId(quote.getOpportunityId());
|
||
|
||
if (bo.getAmount() == null) {
|
||
bo.setAmount(quote.getTotalAmount());
|
||
}
|
||
if (bo.getOwnerUserId() == null) {
|
||
bo.setOwnerUserId(quote.getOwnerUserId());
|
||
}
|
||
|
||
// 从报价单复制产品明细（如果没有传入）
|
||
if ((bo.getProducts() == null || bo.getProducts().isEmpty()) && quote.getId() != null) {
|
||
// TODO: 从报价单产品表复制产品明细
|
||
log.info("从报价单复制产品明细，报价单ID: {}", quoteId);
|
||
}
|
||
|
||
// 3. 创建合同
|
||
boolean flag = insertByBo(bo);
|
||
|
||
// 4. 更新报价单状态为"已转合同"
|
||
if (flag) {
|
||
CrmQuote updateQuote = new CrmQuote();
|
||
updateQuote.setId(quoteId);
|
||
updateQuote.setStatus("converted"); // 已转化
|
||
quoteMapper.updateById(updateQuote);
|
||
|
||
log.info("从报价单创建合同成功，报价单ID: {}, 合同ID: {}", quoteId, bo.getId());
|
||
}
|
||
|
||
return flag;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean createFromTemplate(Long templateId, CrmContractBo bo) {
|
||
// 1. 查询模板
|
||
CrmContractTemplate template = contractTemplateMapper.selectById(templateId);
|
||
if (template == null) {
|
||
throw new ServiceException("合同模板不存在");
|
||
}
|
||
|
||
if (template.getIsActive() == null || template.getIsActive() != 1) {
|
||
throw new ServiceException("该模板已停用，无法使用");
|
||
}
|
||
|
||
// 2. 从模板填充信息
|
||
if (bo.getContractType() == null) {
|
||
bo.setContractType(template.getContractType());
|
||
}
|
||
if (bo.getCurrency() == null) {
|
||
bo.setCurrency(template.getDefaultCurrency());
|
||
}
|
||
if (bo.getTaxRate() == null) {
|
||
bo.setTaxRate(template.getDefaultTaxRate());
|
||
}
|
||
if (bo.getContractPeriod() == null) {
|
||
bo.setContractPeriod(template.getDefaultPeriod());
|
||
}
|
||
|
||
// 填充合同条款
|
||
if (StringUtils.isBlank(bo.getPaymentTerms())) {
|
||
bo.setPaymentTerms(template.getPaymentTerms());
|
||
}
|
||
if (StringUtils.isBlank(bo.getDeliveryTerms())) {
|
||
bo.setDeliveryTerms(template.getDeliveryTerms());
|
||
}
|
||
if (StringUtils.isBlank(bo.getContractTerms())) {
|
||
bo.setContractTerms(template.getContractTerms());
|
||
}
|
||
|
||
// 填充乙方信息
|
||
if (StringUtils.isBlank(bo.getPartyB())) {
|
||
bo.setPartyB(template.getPartyB());
|
||
}
|
||
if (StringUtils.isBlank(bo.getPartyBAddress())) {
|
||
bo.setPartyBAddress(template.getPartyBAddress());
|
||
}
|
||
if (StringUtils.isBlank(bo.getPartyBContact())) {
|
||
bo.setPartyBContact(template.getPartyBContact());
|
||
}
|
||
if (StringUtils.isBlank(bo.getPartyBMobile())) {
|
||
bo.setPartyBMobile(template.getPartyBMobile());
|
||
}
|
||
|
||
// 3. 创建合同
|
||
boolean flag = insertByBo(bo);
|
||
|
||
// 4. 更新模板使用次数
|
||
if (flag) {
|
||
CrmContractTemplate updateTemplate = new CrmContractTemplate();
|
||
updateTemplate.setId(templateId);
|
||
updateTemplate.setUsageCount((template.getUsageCount() == null ? 0 : template.getUsageCount()) + 1);
|
||
contractTemplateMapper.updateById(updateTemplate);
|
||
|
||
log.info("从模板创建合同成功，模板ID: {}, 合同ID: {}", templateId, bo.getId());
|
||
}
|
||
|
||
return flag;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean signContract(Long id, LocalDate actualSignDate, String contractFile, String remark) {
|
||
// 1. 查询合同
|
||
CrmContract contract = baseMapper.selectById(id);
|
||
if (contract == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
|
||
// 2. 校验合同状态
|
||
if (!"approved".equals(contract.getStatus())) {
|
||
throw new ServiceException("只有审批通过的合同才能签订");
|
||
}
|
||
|
||
// 3. 更新合同信息
|
||
CrmContract update = new CrmContract();
|
||
update.setId(id);
|
||
update.setActualSignDate(actualSignDate);
|
||
update.setContractFile(contractFile);
|
||
update.setStatus("executing"); // 签订后进入执行中状态
|
||
update.setPerformanceStatus("normal");
|
||
update.setPerformanceRate(BigDecimal.ZERO);
|
||
if (StringUtils.isNotBlank(remark)) {
|
||
update.setRemark(remark);
|
||
}
|
||
|
||
boolean flag = baseMapper.updateById(update) > 0;
|
||
|
||
if (flag) {
|
||
log.info("合同签订成功，合同ID: {}, 签订日期: {}", id, actualSignDate);
|
||
|
||
// TODO: 发送通知给负责人和财务
|
||
// TODO: 激活回款计划
|
||
}
|
||
|
||
return flag;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean batchAssignOwner(Collection<Long> ids, Long ownerUserId, String remark) {
|
||
if (ids == null || ids.isEmpty()) {
|
||
throw new ServiceException("合同ID列表不能为空");
|
||
}
|
||
if (ownerUserId == null) {
|
||
throw new ServiceException("负责人ID不能为空");
|
||
}
|
||
|
||
// 批量更新
|
||
int successCount = 0;
|
||
for (Long id : ids) {
|
||
CrmContract contract = baseMapper.selectById(id);
|
||
if (contract == null) {
|
||
log.warn("合同不存在，跳过，ID: {}", id);
|
||
continue;
|
||
}
|
||
|
||
CrmContract update = new CrmContract();
|
||
update.setId(id);
|
||
update.setOwnerUserId(ownerUserId);
|
||
|
||
// 设置负责人姓名
|
||
try {
|
||
String ownerUserName = userService.selectNicknameById(ownerUserId);
|
||
update.setOwnerUserName(ownerUserName);
|
||
} catch (Exception e) {
|
||
log.warn("获取负责人姓名失败，用户ID: {}", ownerUserId, e);
|
||
update.setOwnerUserName(null);
|
||
}
|
||
|
||
if (StringUtils.isNotBlank(remark)) {
|
||
update.setRemark(remark);
|
||
}
|
||
|
||
if (baseMapper.updateById(update) > 0) {
|
||
successCount++;
|
||
log.info("合同分配成功，合同ID: {}, 新负责人ID: {}", id, ownerUserId);
|
||
}
|
||
}
|
||
|
||
log.info("批量分配合同负责人完成，成功: {}, 总数: {}", successCount, ids.size());
|
||
return successCount > 0;
|
||
}
|
||
|
||
@Override
|
||
public String downloadContractPdf(Long id) {
|
||
// 查询合同
|
||
CrmContractVo contract = queryById(id);
|
||
if (contract == null) {
|
||
throw new ServiceException("合同不存在");
|
||
}
|
||
|
||
// 返回合同文件路径（如果存在）
|
||
if (StringUtils.isNotBlank(contract.getContractFile())) {
|
||
return contract.getContractFile();
|
||
}
|
||
|
||
throw new ServiceException("合同PDF文件不存在");
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public Boolean updateInvoiceAmount(Long contractId) {
|
||
// 查询该合同的所有发票记录
|
||
LambdaQueryWrapper<CrmInvoice> lqw = Wrappers.lambdaQuery();
|
||
lqw.eq(CrmInvoice::getContractId, contractId);
|
||
lqw.eq(CrmInvoice::getDelFlag, 0);
|
||
List<CrmInvoice> invoices = invoiceMapper.selectList(lqw);
|
||
|
||
// 计算已开票金额
|
||
BigDecimal invoiceAmount = invoices.stream()
|
||
.map(CrmInvoice::getAmount)
|
||
.filter(Objects::nonNull)
|
||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||
|
||
// 查询合同
|
||
CrmContract contract = baseMapper.selectById(contractId);
|
||
if (contract == null) {
|
||
log.error("合同不存在，无法更新开票金额，合同ID: {}", contractId);
|
||
return false;
|
||
}
|
||
|
||
// 更新合同开票金额
|
||
CrmContract update = new CrmContract();
|
||
update.setId(contractId);
|
||
update.setInvoiceAmount(invoiceAmount);
|
||
update.setUninvoiceAmount(contract.getAmount().subtract(invoiceAmount));
|
||
|
||
boolean flag = baseMapper.updateById(update) > 0;
|
||
if (flag) {
|
||
log.info("更新合同开票金额成功，合同ID: {}, 已开票: {}", contractId, invoiceAmount);
|
||
}
|
||
|
||
return flag;
|
||
}
|
||
}
|