package com.ruoyi.sales.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
|
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.mapper.sales.AccountInvoiceApplicationMapper;
|
import com.ruoyi.account.mapper.sales.AccountSalesCollectionMapper;
|
import com.ruoyi.account.pojo.sales.AccountInvoiceApplication;
|
import com.ruoyi.account.pojo.sales.AccountSalesCollection;
|
import com.ruoyi.approve.bean.dto.ApprovalInstanceDto;
|
import com.ruoyi.approve.pojo.ApprovalTemplate;
|
import com.ruoyi.approve.service.ApprovalInstanceService;
|
import com.ruoyi.approve.service.ApprovalTemplateService;
|
import com.ruoyi.basic.enums.ApplicationTypeEnum;
|
import com.ruoyi.basic.enums.RecordTypeEnum;
|
import com.ruoyi.basic.mapper.CustomerMapper;
|
import com.ruoyi.basic.mapper.CustomerUserMapper;
|
import com.ruoyi.basic.mapper.ProductMapper;
|
import com.ruoyi.basic.mapper.ProductModelMapper;
|
import com.ruoyi.basic.pojo.Customer;
|
import com.ruoyi.basic.pojo.CustomerUser;
|
import com.ruoyi.basic.pojo.Product;
|
import com.ruoyi.basic.pojo.ProductModel;
|
import com.ruoyi.basic.utils.FileUtil;
|
import com.ruoyi.common.enums.FileNameType;
|
import com.ruoyi.common.enums.SaleEnum;
|
import com.ruoyi.common.enums.TypeEnums;
|
import com.ruoyi.common.exception.base.BaseException;
|
import com.ruoyi.common.utils.DateUtils;
|
import com.ruoyi.common.utils.EnumUtil;
|
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.other.mapper.TempFileMapper;
|
import com.ruoyi.production.mapper.ProductionProductInputMapper;
|
import com.ruoyi.production.mapper.ProductionProductMainMapper;
|
import com.ruoyi.production.mapper.ProductionProductOutputMapper;
|
import com.ruoyi.production.service.ProductionProductMainService;
|
import com.ruoyi.project.system.domain.SysDept;
|
import com.ruoyi.project.system.domain.SysUser;
|
import com.ruoyi.project.system.mapper.SysDeptMapper;
|
import com.ruoyi.project.system.mapper.SysUserMapper;
|
import com.ruoyi.purchase.dto.SimpleReturnOrderGroupDto;
|
import com.ruoyi.purchase.mapper.PurchaseReturnOrderProductsMapper;
|
import com.ruoyi.quality.mapper.QualityInspectMapper;
|
import com.ruoyi.sales.dto.*;
|
import com.ruoyi.sales.mapper.CommonFileMapper;
|
import com.ruoyi.sales.mapper.SalesLedgerMapper;
|
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
|
import com.ruoyi.sales.mapper.ShippingInfoMapper;
|
import com.ruoyi.sales.pojo.CommonFile;
|
import com.ruoyi.sales.pojo.SalesLedger;
|
import com.ruoyi.sales.pojo.SalesLedgerProduct;
|
import com.ruoyi.sales.pojo.ShippingInfo;
|
import com.ruoyi.sales.service.ISalesLedgerService;
|
import com.ruoyi.sales.vo.SalesLedgerVo;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.jetbrains.annotations.Nullable;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.data.redis.core.script.DefaultRedisScript;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.interceptor.TransactionAspectSupport;
|
import org.springframework.transaction.support.TransactionSynchronizationManager;
|
import org.springframework.web.multipart.MultipartFile;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
|
import java.io.InputStream;
|
import java.lang.reflect.Field;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.YearMonth;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
|
/**
|
* 销售台账Service业务层处理
|
*
|
* @author ruoyi
|
* @date 2025-05-08
|
*/
|
@Service
|
@RequiredArgsConstructor
|
@Slf4j
|
public class SalesLedgerServiceImpl extends ServiceImpl<SalesLedgerMapper, SalesLedger> implements ISalesLedgerService {
|
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 static final String IMPORT_DEFAULT_VALUE = "/";
|
/** 导入自动新增产品大类时挂载的顶级产品节点名称 */
|
private static final String FINISHED_PRODUCT_NAME = "成品";
|
private final SalesLedgerMapper salesLedgerMapper;
|
private final CustomerMapper customerMapper;
|
private final CustomerUserMapper customerUserMapper;
|
private final SalesLedgerProductMapper salesLedgerProductMapper;
|
private final SalesLedgerProductServiceImpl salesLedgerProductServiceImpl;
|
private final CommonFileMapper commonFileMapper;
|
private final TempFileMapper tempFileMapper;
|
private final ShippingInfoServiceImpl shippingInfoServiceImpl;
|
private final CommonFileServiceImpl commonFileService;
|
private final ShippingInfoMapper shippingInfoMapper;
|
private final ProductionProductMainMapper productionProductMainMapper;
|
private final ProductionProductOutputMapper productionProductOutputMapper;
|
private final ProductionProductInputMapper productionProductInputMapper;
|
private final QualityInspectMapper qualityInspectMapper;
|
private final RedisTemplate<String, String> redisTemplate;
|
private final FileUtil fileUtil;
|
private final AccountInvoiceApplicationMapper accountInvoiceApplicationMapper;
|
private final AccountSalesCollectionMapper accountSalesCollectionMapper;
|
|
@Autowired
|
private SysDeptMapper sysDeptMapper;
|
@Value("${file.upload-dir}")
|
private String uploadDir;
|
@Autowired
|
private ProductModelMapper productModelMapper;
|
|
@Autowired
|
private ProductMapper productMapper;
|
@Autowired
|
private ProductionProductMainService productionProductMainService;
|
@Autowired
|
private PurchaseReturnOrderProductsMapper purchaseReturnOrderProductsMapper;
|
;
|
@Autowired
|
private SysUserMapper sysUserMapper;
|
|
@Autowired
|
private ApprovalInstanceService approvalInstanceService;
|
@Autowired
|
private ApprovalTemplateService approvalTemplateService;
|
|
@Override
|
public List<SalesLedger> selectSalesLedgerList(SalesLedgerDto salesLedgerDto) {
|
return salesLedgerMapper.selectSalesLedgerList(salesLedgerDto);
|
}
|
|
public List<SalesLedgerProduct> getSalesLedgerProductListByRelateId(Long relateId, SaleEnum type) {
|
LambdaQueryWrapper<SalesLedgerProduct> productWrapper = new LambdaQueryWrapper<>();
|
productWrapper.eq(SalesLedgerProduct::getSalesLedgerId, relateId);
|
productWrapper.eq(SalesLedgerProduct::getType, type.getCode());
|
return salesLedgerProductMapper.selectList(productWrapper);
|
}
|
|
@Override
|
public List<SalesLedgerProduct> getSalesLedgerProductListByIds(@Nullable List<Long> relateIds, SaleEnum type) {
|
if (CollectionUtils.isEmpty(relateIds)) {
|
return Collections.emptyList();
|
}
|
LambdaQueryWrapper<SalesLedgerProduct> productWrapper = new LambdaQueryWrapper<>();
|
productWrapper.in(SalesLedgerProduct::getId, relateIds);
|
productWrapper.eq(SalesLedgerProduct::getType, type.getCode());
|
List<SalesLedgerProduct> salesLedgerProducts = salesLedgerProductMapper.selectList(productWrapper);
|
if (type.equals(SaleEnum.PURCHASE)) {
|
// 查询退货信息
|
List<Long> productIds = salesLedgerProducts.stream().map(SalesLedgerProduct::getProductModelId).collect(Collectors.toList());
|
List<SimpleReturnOrderGroupDto> groupListByProductIds = new ArrayList<>();
|
if(CollectionUtils.isNotEmpty(productIds)){
|
groupListByProductIds = purchaseReturnOrderProductsMapper.getReturnOrderGroupListByProductIds(productIds);
|
}
|
Map<Long, BigDecimal> returnOrderGroupDtoMap = groupListByProductIds.stream().collect(Collectors.toMap(SimpleReturnOrderGroupDto::getProductModelId, SimpleReturnOrderGroupDto::getSumReturnQuantity));
|
salesLedgerProducts.forEach(item -> {
|
BigDecimal returnQuality = returnOrderGroupDtoMap.getOrDefault(item.getProductModelId(), BigDecimal.ZERO);
|
item.setReturnQuality(returnQuality);
|
item.setAvailableQuality(item.getQuantity().subtract(returnQuality));
|
});
|
}
|
return salesLedgerProducts;
|
}
|
|
@Override
|
public SalesLedgerDto getSalesLedgerWithProducts(SalesLedgerDto salesLedgerDto) {
|
// 1. 查询主表
|
SalesLedger salesLedger = salesLedgerMapper.selectById(salesLedgerDto.getId());
|
if (salesLedger == null) {
|
throw new BaseException("台账不存在");
|
}
|
|
// 2. 查询子表
|
LambdaQueryWrapper<SalesLedgerProduct> productWrapper = new LambdaQueryWrapper<>();
|
productWrapper.eq(SalesLedgerProduct::getSalesLedgerId, salesLedger.getId());
|
productWrapper.eq(SalesLedgerProduct::getType, 1);
|
List<SalesLedgerProduct> products = salesLedgerProductMapper.selectList(productWrapper);
|
for (SalesLedgerProduct product : products) {
|
product.setRegister(SecurityUtils.getLoginUser().getUser().getNickName());
|
product.setRegisterDate(LocalDateTime.now());
|
// 发货信息
|
ShippingInfo shippingInfo = shippingInfoMapper.selectOne(new LambdaQueryWrapper<ShippingInfo>()
|
.eq(ShippingInfo::getSalesLedgerProductId, product.getId())
|
.orderByDesc(ShippingInfo::getCreateTime)
|
.last("limit 1"));
|
if (shippingInfo != null) {
|
product.setShippingStatus(shippingInfo.getStatus());
|
}
|
}
|
|
// 3.查询上传文件
|
LambdaQueryWrapper<CommonFile> salesLedgerFileWrapper = new LambdaQueryWrapper<>();
|
salesLedgerFileWrapper.eq(CommonFile::getCommonId, salesLedger.getId())
|
.eq(CommonFile::getType, FileNameType.SALE.getValue());
|
List<CommonFile> salesLedgerFiles = commonFileMapper.selectList(salesLedgerFileWrapper);
|
|
// 4. 转换 DTO
|
SalesLedgerDto resultDto = new SalesLedgerDto();
|
BeanUtils.copyProperties(salesLedger, resultDto);
|
if (!products.isEmpty()) {
|
resultDto.setHasChildren(true);
|
resultDto.setProductData(products);
|
resultDto.setSalesLedgerFiles(salesLedgerFiles);
|
}
|
return resultDto;
|
}
|
|
@Override
|
public List<Map<String, Object>> getSalesNo() {
|
LambdaQueryWrapper<SalesLedger> queryWrapper = Wrappers.lambdaQuery();
|
queryWrapper.select(SalesLedger::getId, SalesLedger::getSalesContractNo, SalesLedger::getProjectName);
|
|
// 获取原始查询结果
|
List<Map<String, Object>> result = salesLedgerMapper.selectMaps(queryWrapper);
|
|
// 将下划线命名转换为驼峰命名
|
return result.stream().map(map -> map.entrySet().stream()
|
.collect(Collectors.toMap(
|
entry -> underlineToCamel(entry.getKey()),
|
Map.Entry::getValue))
|
).collect(Collectors.toList());
|
}
|
|
@Override
|
public BigDecimal getContractAmount() {
|
LocalDate now = LocalDate.now();
|
YearMonth currentMonth = YearMonth.from(now);
|
|
// 创建LambdaQueryWrapper
|
LambdaQueryWrapper<SalesLedger> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.ge(SalesLedger::getEntryDate, currentMonth.atDay(1).atStartOfDay()) // 大于等于本月第一天
|
.lt(SalesLedger::getEntryDate, currentMonth.plusMonths(1).atDay(1).atStartOfDay()); // 小于下月第一天
|
|
// 执行查询并计算总和
|
List<SalesLedger> salesLedgers = salesLedgerMapper.selectList(queryWrapper);
|
|
BigDecimal totalContractAmount = salesLedgers.stream()
|
.map(SalesLedger::getContractAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
|
return totalContractAmount;
|
}
|
|
@Override
|
public List getTopFiveList() {
|
// 查询原始数据
|
LambdaQueryWrapper<SalesLedger> queryWrapper = Wrappers.lambdaQuery();
|
queryWrapper.select(SalesLedger::getCustomerId,
|
SalesLedger::getCustomerName,
|
SalesLedger::getContractAmount)
|
.orderByDesc(SalesLedger::getContractAmount);
|
List<SalesLedger> records = salesLedgerMapper.selectList(queryWrapper);
|
|
// 按客户ID分组并聚合金额
|
Map<Long, GroupedCustomer> groupedMap = new LinkedHashMap<>(); // 使用LinkedHashMap保持排序
|
for (SalesLedger record : records) {
|
groupedMap.computeIfAbsent(record.getCustomerId(),
|
k -> new GroupedCustomer(record.getCustomerId(), record.getCustomerName()))
|
.addAmount(record.getContractAmount());
|
}
|
|
// 转换为结果列表并取前5
|
return groupedMap.values().stream()
|
.sorted(Comparator.comparing(GroupedCustomer::getTotalAmount).reversed())
|
.limit(5)
|
.map(customer -> {
|
Map<String, Object> result = new HashMap<>();
|
result.put("customerId", customer.getCustomerId());
|
result.put("customerName", customer.getCustomerName());
|
result.put("totalAmount", customer.getTotalAmount());
|
return result;
|
})
|
.collect(Collectors.toList());
|
}
|
|
@Override
|
public List<MonthlyAmountDto> getAmountHalfYear(Integer type) {
|
LocalDate now = LocalDate.now();
|
List<MonthlyAmountDto> result = new ArrayList<>();
|
for (int i = 5; i >= 0; i--) {
|
YearMonth yearMonth = YearMonth.from(now.minusMonths(i));
|
LocalDate startTime = yearMonth.atDay(1);
|
LocalDate endTime = yearMonth.atEndOfMonth();
|
MonthlyAmountDto dto = new MonthlyAmountDto();
|
dto.setMonth(yearMonth.format(DateTimeFormatter.ofPattern("yyyy-MM")));
|
//回款金额
|
List<AccountSalesCollection> accountSalesCollections = accountSalesCollectionMapper.selectList(new LambdaQueryWrapper<AccountSalesCollection>()
|
.between(AccountSalesCollection::getCollectionDate, startTime, endTime));
|
BigDecimal totalIncome = Optional.of(
|
accountSalesCollections.stream()
|
.map(AccountSalesCollection::getCollectionAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add)
|
).orElse(BigDecimal.ZERO);
|
dto.setReceiptAmount(totalIncome);
|
//开票金额
|
List<AccountInvoiceApplication> accountInvoiceApplications = accountInvoiceApplicationMapper.selectList(new LambdaQueryWrapper<AccountInvoiceApplication>()
|
.eq(AccountInvoiceApplication::getStatus,1)
|
.between(AccountInvoiceApplication::getApplyDate, startTime, endTime));
|
BigDecimal totalInvoiceAmount = Optional.of(
|
accountInvoiceApplications.stream()
|
.map(AccountInvoiceApplication::getInvoiceAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add)
|
).orElse(BigDecimal.ZERO);
|
dto.setInvoiceAmount(totalInvoiceAmount);
|
result.add(dto);
|
}
|
return result;
|
}
|
|
@Override
|
public IPage<SalesLedgerVo> selectSalesLedgerListPage(Page page, SalesLedgerDto salesLedgerDto) {
|
return salesLedgerMapper.selectSalesLedgerListPage(page, salesLedgerDto);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public AjaxResult importData(MultipartFile file) {
|
LoginUser loginUser = SecurityUtils.getLoginUser();
|
try {
|
InputStream inputStream = file.getInputStream();
|
ExcelUtil<SalesLedgerImportDto> salesLedgerImportDtoExcelUtil = new ExcelUtil<>(SalesLedgerImportDto.class);
|
Map<String, List<SalesLedgerImportDto>> stringListMap = salesLedgerImportDtoExcelUtil.importExcelMultiSheet(Arrays.asList("销售台账数据", "销售产品数据"), inputStream, 0);
|
if (CollectionUtils.isEmpty(stringListMap)) return AjaxResult.error("销售表格为空！");
|
// 业务层合并
|
List<SalesLedgerImportDto> salesLedgerImportDtoList = stringListMap.get("销售台账数据");
|
if (CollectionUtils.isEmpty(salesLedgerImportDtoList)) return AjaxResult.error("销售台账数据为空！");
|
List<SalesLedgerImportDto> salesLedgerProductImportDtoList = stringListMap.get("销售产品数据");
|
if (CollectionUtils.isEmpty(salesLedgerProductImportDtoList)) return AjaxResult.error("销售产品数据为空！");
|
// 客户数据 - 参考 listPage 查询私海客户（type = 0）
|
// type = 0（私海客户）或者 type = 1（公海客户）且已被分配，并且是自己领用、自己创建或者共享给自己的客户
|
// 客户不存在时自动新增并挂到自己名下，公海客户自动领用/共享给自己
|
Long loginUserId = loginUser.getUser().getUserId();
|
Map<String, Customer> customerCache = new HashMap<>();
|
// 产品大类、规格型号缓存，key = 产品大类 + | + 规格型号，不存在时自动新增
|
Map<String, ProductModel> productModelCache = new HashMap<>();
|
// 录入人数据
|
List<SysUser> sysUsers = sysUserMapper.selectList(new LambdaQueryWrapper<SysUser>().in(SysUser::getNickName,
|
salesLedgerImportDtoList.stream().map(SalesLedgerImportDto::getEntryPerson).collect(Collectors.toList())));
|
for (SalesLedgerImportDto salesLedgerImportDto : salesLedgerImportDtoList) {
|
SalesLedger salesLedger1 = salesLedgerMapper.selectOne(new LambdaQueryWrapper<SalesLedger>()
|
.eq(SalesLedger::getSalesContractNo, salesLedgerImportDto.getSalesContractNo())
|
.last("LIMIT 1"));
|
if (salesLedger1 != null) {
|
continue;
|
}
|
|
// 判断业务员是否存在
|
SysUser salesman = sysUserMapper.selectOne(new LambdaQueryWrapper<SysUser>()
|
.eq(SysUser::getNickName, salesLedgerImportDto.getSalesman()));
|
if (salesman == null) {
|
throw new RuntimeException("业务员:" + salesLedgerImportDto.getSalesman() + "不存在！");
|
}
|
SalesLedger salesLedger = new SalesLedger();
|
BeanUtils.copyProperties(salesLedgerImportDto, salesLedger);
|
salesLedger.setExecutionDate(DateUtils.toLocalDate(salesLedgerImportDto.getExecutionDate()));
|
salesLedger.setDeliveryDate(DateUtils.toLocalDate(salesLedgerImportDto.getDeliveryDate()));
|
// 通过客户名称查询客户ID，客户合同号，客户不存在时自动新增
|
Customer customer = resolveImportCustomer(salesLedger.getCustomerName(), loginUserId,
|
loginUser.getNickName(), customerCache);
|
salesLedger.setCustomerId(customer.getId());
|
salesLedger.setCustomerContractNo(customer.getTaxpayerIdentificationNumber());
|
Long aLong = sysUsers.stream()
|
.filter(sysUser -> sysUser.getNickName().equals(salesLedger.getEntryPerson()))
|
.findFirst()
|
.map(SysUser::getUserId)
|
.orElse(null);
|
if (aLong == null)
|
throw new RuntimeException("录入人:" + salesLedger.getEntryPerson() + ",无对应用户！");
|
salesLedger.setEntryPerson(aLong.toString());
|
// 销售产品数据绑定，通过销售单号获取对应销售产品数据
|
List<SalesLedgerProductImportDto> salesLedgerProductImportDtos = salesLedgerProductImportDtoList.stream()
|
.filter(salesLedgerProductImportDto -> salesLedgerProductImportDto.getSalesContractNo().equals(salesLedger.getSalesContractNo()))
|
.collect(Collectors.toList());
|
if (CollectionUtils.isEmpty(salesLedgerProductImportDtos))
|
throw new RuntimeException("销售单号:" + salesLedgerImportDto.getSalesContractNo() + ",无对应产品数据！");
|
salesLedger.setContractAmount(salesLedgerProductImportDtos.stream()
|
.map(SalesLedgerProductImportDto::getTaxInclusiveTotalPrice)
|
.reduce(BigDecimal.ZERO, BigDecimal::add));
|
salesLedgerMapper.insert(salesLedger);
|
|
|
for (SalesLedgerProductImportDto salesLedgerProductImportDto : salesLedgerProductImportDtos) {
|
SalesLedgerProduct salesLedgerProduct = new SalesLedgerProduct();
|
BeanUtils.copyProperties(salesLedgerProductImportDto, salesLedgerProduct);
|
salesLedgerProduct.setSalesLedgerId(salesLedger.getId());
|
salesLedgerProduct.setType(1);
|
// 计算不含税总价
|
salesLedgerProduct.setTaxExclusiveTotalPrice(salesLedgerProduct.getTaxInclusiveTotalPrice().divide(new BigDecimal(1).add(salesLedgerProduct.getTaxRate().divide(new BigDecimal(100))), 6, RoundingMode.HALF_UP));
|
// 校验产品规格是否存在，产品大类、规格型号不存在时自动新增
|
ProductModel productModel = resolveImportProductModel(salesLedgerProduct.getProductCategory(),
|
salesLedgerProduct.getSpecificationModel(), salesLedgerProduct.getUnit(), productModelCache);
|
salesLedgerProduct.setProductModelId(productModel.getId());
|
salesLedgerProduct.setProductId(productModel.getProductId());
|
// 规格型号为空时取产品大类，单位为空时取规格型号上的单位
|
salesLedgerProduct.setSpecificationModel(productModel.getModel());
|
if (StringUtils.isEmpty(salesLedgerProduct.getUnit())) {
|
salesLedgerProduct.setUnit(productModel.getUnit());
|
}
|
salesLedgerProduct.setRegister(loginUser.getNickName());
|
salesLedgerProduct.setRegisterDate(LocalDateTime.now());
|
salesLedgerProduct.setApproveStatus(0);
|
salesLedgerProduct.setIsProduction(salesLedgerProductImportDto.getIsProduction() == 1);
|
salesLedgerProductMapper.insert(salesLedgerProduct);
|
// 添加生产数据
|
salesLedgerProductServiceImpl.addProductionData(salesLedgerProduct);
|
}
|
}
|
|
return AjaxResult.success("导入成功");
|
} catch (Exception e) {
|
e.printStackTrace();
|
// 导入过程中会自动新增客户、产品大类、规格型号，失败时需要回滚，避免残留脏数据
|
if (TransactionSynchronizationManager.isActualTransactionActive()) {
|
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
|
}
|
return AjaxResult.error("导入失败：" + e.getMessage());
|
}
|
}
|
|
/**
|
* 导入时获取客户，客户不存在则自动新增并挂到当前登录人名下
|
* <p>
|
* 1、当前登录人可用的客户（私海，或公海已分配且自己领用/创建/共享）：直接使用；
|
* 2、同名公海客户未分配：领用到自己名下；
|
* 3、同名公海客户已分配给别人：共享给自己；
|
* 4、同名客户在别人私海：报错，不新建；
|
* 5、客户不存在：新增私海客户挂到自己名下，纳税人识别号、电话等信息填 "/"。
|
*/
|
private Customer resolveImportCustomer(String customerName, Long loginUserId, String nickName,
|
Map<String, Customer> customerCache) {
|
String name = StringUtils.trim(customerName);
|
if (StringUtils.isEmpty(name)) {
|
throw new RuntimeException("客户名称不能为空！");
|
}
|
Customer cachedCustomer = customerCache.get(name);
|
if (cachedCustomer != null) {
|
return cachedCustomer;
|
}
|
// 当前登录人可用的客户
|
Customer customer = customerMapper.selectOne(new QueryWrapper<Customer>()
|
.eq("customer_name", name)
|
.and(wrapper -> wrapper.eq("type", 0)
|
.or(wrapper2 -> wrapper2.eq("type", 1).eq("is_assigned", 1)))
|
.and(wrapper -> wrapper.eq("usage_user", loginUserId)
|
.or(wrapper2 -> wrapper2.eq("create_user", loginUserId)
|
.or(wrapper3 -> wrapper3.exists("select 1 from customer_user cu where cu.customer_id = customer.id and cu.user_id = " + loginUserId))))
|
.last("limit 1"));
|
if (customer == null) {
|
customer = claimOrCreateImportCustomer(name, loginUserId, nickName);
|
}
|
customerCache.put(name, customer);
|
return customer;
|
}
|
|
/**
|
* 同名客户不属于当前登录人时的处理：公海未分配的领用到自己名下，公海已分配的共享给自己，
|
* 在别人私海的直接报错，都不存在则新增客户
|
*/
|
private Customer claimOrCreateImportCustomer(String customerName, Long loginUserId, String nickName) {
|
List<Customer> sameNameCustomers = customerMapper.selectList(new QueryWrapper<Customer>()
|
.eq("customer_name", customerName)
|
.orderByAsc("id"));
|
// 公海未分配客户，领用到自己名下
|
Optional<Customer> publicUnassigned = sameNameCustomers.stream()
|
.filter(item -> Objects.equals(item.getType(), 1)
|
&& (item.getIsAssigned() == null || item.getIsAssigned() == 0))
|
.findFirst();
|
if (publicUnassigned.isPresent()) {
|
Customer customer = publicUnassigned.get();
|
customer.setIsAssigned(1);
|
customer.setUsageStatus(1L);
|
customer.setUsageUser(loginUserId);
|
customerMapper.updateById(customer);
|
return customer;
|
}
|
// 公海已分配给别人的客户，共享给自己
|
Optional<Customer> publicAssigned = sameNameCustomers.stream()
|
.filter(item -> Objects.equals(item.getType(), 1) && Objects.equals(item.getIsAssigned(), 1))
|
.findFirst();
|
if (publicAssigned.isPresent()) {
|
Customer customer = publicAssigned.get();
|
CustomerUser customerUser = new CustomerUser();
|
customerUser.setCustomerId(customer.getId());
|
customerUser.setUserId(loginUserId);
|
customerUserMapper.insert(customerUser);
|
return customer;
|
}
|
// 剩下的都是别人的私海客户
|
if (!sameNameCustomers.isEmpty()) {
|
throw new RuntimeException("客户:" + customerName + "已在其他人私海中，无法导入！");
|
}
|
// 客户不存在，新增私海客户并挂到自己名下
|
Customer customer = new Customer();
|
customer.setCustomerName(customerName);
|
customer.setCustomerType(IMPORT_DEFAULT_VALUE);
|
customer.setTaxpayerIdentificationNumber(IMPORT_DEFAULT_VALUE);
|
customer.setCompanyAddress(IMPORT_DEFAULT_VALUE);
|
customer.setCompanyPhone(IMPORT_DEFAULT_VALUE);
|
customer.setContactPerson(IMPORT_DEFAULT_VALUE);
|
customer.setContactPhone(IMPORT_DEFAULT_VALUE);
|
customer.setBasicBankAccount(IMPORT_DEFAULT_VALUE);
|
customer.setBankAccount(IMPORT_DEFAULT_VALUE);
|
customer.setBankCode(IMPORT_DEFAULT_VALUE);
|
customer.setMaintainer(nickName);
|
customer.setMaintenanceTime(new Date());
|
// 私海客户，领用人为当前登录人
|
customer.setType(0);
|
customer.setIsAssigned(0);
|
customer.setUsageStatus(1L);
|
customer.setUsageUser(loginUserId);
|
customerMapper.insert(customer);
|
return customer;
|
}
|
|
/**
|
* 导入时获取规格型号，产品大类、规格型号不存在则自动新增
|
* <p>
|
* 规格型号为空时取产品大类作为规格型号；产品大类不存在时挂到顶级"成品"节点下；
|
* 新增规格型号时按"规格型号 + 规格ID + _ + 三位流水号"生成产品编码
|
*/
|
private ProductModel resolveImportProductModel(String productCategory, String specificationModel, String unit,
|
Map<String, ProductModel> productModelCache) {
|
String category = StringUtils.trim(productCategory);
|
if (StringUtils.isEmpty(category)) {
|
throw new RuntimeException("产品大类不能为空！");
|
}
|
// 规格型号为空时取产品大类当产品规格
|
String model = StringUtils.trim(specificationModel);
|
if (StringUtils.isEmpty(model)) {
|
model = category;
|
}
|
String cacheKey = category + "|" + model;
|
ProductModel cachedProductModel = productModelCache.get(cacheKey);
|
if (cachedProductModel != null) {
|
return cachedProductModel;
|
}
|
// 产品大类不存在则新增到顶级"成品"节点下
|
Product product = productMapper.selectOne(new LambdaQueryWrapper<Product>()
|
.eq(Product::getProductName, category)
|
.orderByAsc(Product::getId)
|
.last("limit 1"));
|
if (product == null) {
|
product = new Product();
|
product.setParentId(getFinishedProductId());
|
product.setProductName(category);
|
productMapper.insert(product);
|
}
|
// 规格型号不存在则新增
|
ProductModel productModel = productModelMapper.selectOne(new LambdaQueryWrapper<ProductModel>()
|
.eq(ProductModel::getProductId, product.getId())
|
.eq(ProductModel::getModel, model)
|
.orderByAsc(ProductModel::getId)
|
.last("limit 1"));
|
if (productModel == null) {
|
productModel = new ProductModel();
|
productModel.setProductId(product.getId());
|
productModel.setModel(model);
|
productModel.setUnit(StringUtils.isEmpty(unit) ? IMPORT_DEFAULT_VALUE : StringUtils.trim(unit));
|
productModelMapper.insert(productModel);
|
// 产品编码依赖自增的规格ID，插入后再回填
|
productModel.setProductCode(generateProductCode(productModel.getModel(), productModel.getId()));
|
productModelMapper.updateById(productModel);
|
}
|
productModelCache.put(cacheKey, productModel);
|
return productModel;
|
}
|
|
/**
|
* 查询顶级"成品"产品节点（产品名称为成品且父ID为空）
|
*/
|
private Long getFinishedProductId() {
|
Product finishedProduct = productMapper.selectOne(new LambdaQueryWrapper<Product>()
|
.eq(Product::getProductName, FINISHED_PRODUCT_NAME)
|
.isNull(Product::getParentId)
|
.orderByAsc(Product::getId)
|
.last("limit 1"));
|
if (finishedProduct == null) {
|
throw new RuntimeException("产品档案中不存在顶级节点:" + FINISHED_PRODUCT_NAME + "，无法自动新增产品大类！");
|
}
|
return finishedProduct.getId();
|
}
|
|
/**
|
* 生成产品编码，规则：规格型号 + 规格ID + _ + 三位流水号，编码已存在时流水号递增
|
*/
|
private String generateProductCode(String model, Long productModelId) {
|
String prefix = model + productModelId + "_";
|
for (int sequence = 1; sequence < 1000; sequence++) {
|
String productCode = prefix + String.format("%03d", sequence);
|
Long count = productModelMapper.selectCount(new LambdaQueryWrapper<ProductModel>()
|
.eq(ProductModel::getProductCode, productCode));
|
if (count == null || count == 0) {
|
return productCode;
|
}
|
}
|
throw new RuntimeException("规格型号:" + model + "的产品编码流水号已超出范围！");
|
}
|
|
@Override
|
public List<LossProductModelDto> getSalesLedgerWithProductsLoss(Long salesLedgerId) {
|
|
|
List<LossProductModelDto> lossProductModelDtos = salesLedgerProductMapper.selectProductBomStructure(salesLedgerId);
|
|
|
return lossProductModelDtos;
|
}
|
|
@Override
|
public IPage<SalesLedgerDto> listSalesLedger(SalesLedgerDto salesLedgerDto, Page page) {
|
IPage<SalesLedgerDto> salesLedgerDtoIPage = salesLedgerMapper.listSalesLedgerAndShipped(page, salesLedgerDto);
|
for (SalesLedgerDto salesLedger : salesLedgerDtoIPage.getRecords()) {
|
LambdaQueryWrapper<SalesLedgerProduct> productWrapper = new LambdaQueryWrapper<>();
|
productWrapper.eq(SalesLedgerProduct::getSalesLedgerId, salesLedger.getId());
|
productWrapper.eq(SalesLedgerProduct::getType, 1);
|
List<SalesLedgerProduct> products = salesLedgerProductMapper.selectList(productWrapper);
|
for (SalesLedgerProduct product : products) {
|
product.setRegister(SecurityUtils.getLoginUser().getUser().getNickName());
|
product.setRegisterDate(LocalDateTime.now());
|
// 发货信息
|
ShippingInfo shippingInfo = shippingInfoMapper.selectOne(new LambdaQueryWrapper<ShippingInfo>()
|
.eq(ShippingInfo::getSalesLedgerProductId, product.getId())
|
.orderByDesc(ShippingInfo::getCreateTime)
|
.last("limit 1"));
|
product.setShippingCarNumber(shippingInfo.getShippingCarNumber());
|
product.setShippingDate(shippingInfo.getShippingDate());
|
if (shippingInfo != null) {
|
product.setShippingStatus(shippingInfo.getStatus());
|
}
|
}
|
// 过滤只保留发货记录
|
products = products.stream().filter(product -> "已发货".equals(product.getShippingStatus())).collect(Collectors.toList());
|
if (!products.isEmpty()) {
|
salesLedger.setHasChildren(true);
|
salesLedger.setProductData(products);
|
}
|
}
|
|
|
return salesLedgerDtoIPage;
|
}
|
|
/**
|
* 下划线命名转驼峰命名
|
*/
|
private String underlineToCamel(String param) {
|
if (param == null || "".equals(param.trim())) {
|
return "";
|
}
|
int len = param.length();
|
StringBuilder sb = new StringBuilder(len);
|
for (int i = 0; i < len; i++) {
|
char c = param.charAt(i);
|
if (c == '_') {
|
if (++i < len) {
|
sb.append(Character.toUpperCase(param.charAt(i)));
|
}
|
} else {
|
sb.append(Character.toLowerCase(c));
|
}
|
}
|
return sb.toString();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int deleteSalesLedgerByIds(Long[] ids) {
|
List<Long> idList = Arrays.stream(ids)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toList());
|
if (CollectionUtils.isEmpty(idList)) {
|
return 0;
|
}
|
// 删除销售管理数据
|
LambdaQueryWrapper<SalesLedgerProduct> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.in(SalesLedgerProduct::getSalesLedgerId, idList)
|
.select(SalesLedgerProduct::getId);
|
|
List<SalesLedgerProduct> products = salesLedgerProductMapper.selectList(queryWrapper);
|
List<Long> productIds = products.stream()
|
.map(SalesLedgerProduct::getId)
|
.collect(Collectors.toList());
|
//删除生产数据
|
salesLedgerProductServiceImpl.deleteProductionData(productIds);
|
|
// 批量删除产品子表
|
if (!productIds.isEmpty()) {
|
salesLedgerProductMapper.deleteBatchIds(productIds);
|
}
|
|
List<Integer> invoiceLedgerIds = new ArrayList<>();
|
|
// 删除发货台账记录
|
List<ShippingInfo> shippingInfos = shippingInfoMapper.selectList(new LambdaQueryWrapper<ShippingInfo>()
|
.in(ShippingInfo::getSalesLedgerId, idList));
|
if (CollectionUtils.isNotEmpty(shippingInfos)) {
|
shippingInfoServiceImpl.delete(shippingInfos.stream().map(ShippingInfo::getId).collect(Collectors.toList()));
|
}
|
// 删除附件表
|
commonFileService.deleteByBusinessIds(idList, FileNameType.SALE.getValue());
|
|
// 删除生产管控数据
|
//查询生产报工id
|
ArrayList<Long> mainIdList = productionProductMainService.listMain(idList);
|
if (CollectionUtils.isNotEmpty(mainIdList)) {
|
mainIdList.stream().forEach(mainId -> {
|
productionProductMainService.removeProductMain(mainId);
|
});
|
}
|
// 2. 再删除主表数据
|
return salesLedgerMapper.deleteBatchIds(idList);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int addOrUpdateSalesLedger(SalesLedgerDto salesLedgerDto) {
|
// 1. 校验客户信息
|
Customer customer = customerMapper.selectById(salesLedgerDto.getCustomerId());
|
if (customer == null) {
|
throw new BaseException("客户不存在");
|
}
|
|
// 2. DTO转Entity
|
SalesLedger salesLedger = convertToEntity(salesLedgerDto);
|
salesLedger.setCustomerName(customer.getCustomerName());
|
salesLedger.setTenantId(customer.getTenantId());
|
// 3. 新增或更新主表
|
if (salesLedger.getId() == null) {
|
String contractNo = salesLedger.getSalesContractNo();
|
if (StringUtils.isEmpty(contractNo)) {
|
contractNo = generateSalesContractNo(salesLedgerDto.getEntryDate());
|
}
|
salesLedger.setSalesContractNo(contractNo);
|
salesLedger.setApprovalStatus(0);
|
salesLedgerMapper.insert(salesLedger);
|
|
// 新增时发起协同审批
|
submitApproval(salesLedger);
|
} else {
|
salesLedgerMapper.updateById(salesLedger);
|
}
|
|
|
// 4. 处理子表数据
|
List<SalesLedgerProduct> productList = salesLedgerDto.getProductData();
|
if (productList != null && !productList.isEmpty()) {
|
handleSalesLedgerProducts(salesLedger.getId(), productList, EnumUtil.fromCode(SaleEnum.class, salesLedgerDto.getType()));
|
updateMainContractAmount(
|
salesLedger.getId(),
|
productList,
|
SalesLedgerProduct::getTaxInclusiveTotalPrice,
|
salesLedgerMapper,
|
SalesLedger.class
|
);
|
}
|
|
// 5. 保存销售台账附件
|
fileUtil.saveStorageAttachment(ApplicationTypeEnum.FILE, RecordTypeEnum.SALES_LEDGER, salesLedger.getId(), salesLedgerDto.getStorageBlobDTOs());
|
|
return 1;
|
}
|
|
@Override
|
public void handleSalesLedgerProducts(Long salesLedgerId, List<SalesLedgerProduct> products, SaleEnum type) {
|
// 按ID分组，区分新增和更新的记录
|
Map<Boolean, List<SalesLedgerProduct>> partitionedProducts = products.stream()
|
.peek(p -> p.setSalesLedgerId(salesLedgerId))
|
.collect(Collectors.partitioningBy(p -> p.getId() != null));
|
|
List<SalesLedgerProduct> updateList = partitionedProducts.get(true);
|
List<SalesLedgerProduct> insertList = partitionedProducts.get(false);
|
|
// 执行更新操作
|
if (!updateList.isEmpty()) {
|
for (SalesLedgerProduct product : updateList) {
|
product.setType(type.getCode());
|
salesLedgerProductMapper.updateById(product);
|
}
|
}
|
// 执行插入操作
|
if (!insertList.isEmpty()) {
|
for (SalesLedgerProduct salesLedgerProduct : insertList) {
|
salesLedgerProduct.setType(type.getCode());
|
salesLedgerProductMapper.insert(salesLedgerProduct);
|
}
|
}
|
}
|
|
private SalesLedger convertToEntity(SalesLedgerDto dto) {
|
SalesLedger entity = new SalesLedger();
|
BeanUtils.copyProperties(dto, entity);
|
return entity;
|
}
|
|
@Transactional(readOnly = true)
|
public String generateSalesContractNo(Date entryDate) {
|
LocalDate currentDate = entryDate != null ? DateUtils.toLocalDate(entryDate) : LocalDate.now();
|
String datePart = currentDate.format(DateTimeFormatter.BASIC_ISO_DATE);
|
String lockKey = LOCK_PREFIX + datePart;
|
String lockValue = Thread.currentThread().getId() + "-" + System.nanoTime(); // 唯一标识锁持有者
|
|
try {
|
// 1. 尝试获取分布式锁（循环直到超时）
|
long startWaitTime = System.currentTimeMillis();
|
while (System.currentTimeMillis() - startWaitTime < LOCK_WAIT_TIMEOUT * 1000) {
|
// SET key value NX PX 30000：仅当锁不存在时获取，设置30秒过期
|
Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, LOCK_EXPIRE_TIME, TimeUnit.SECONDS);
|
if (Boolean.TRUE.equals(locked)) {
|
break; // 成功获取锁
|
}
|
// 短暂休眠避免忙等待
|
try {
|
Thread.sleep(100);
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
throw new RuntimeException("获取锁时被中断", e);
|
}
|
}
|
|
if (!redisTemplate.hasKey(lockKey)) {
|
throw new RuntimeException("获取合同编号生成锁失败：超时");
|
}
|
|
// 2. 查询当天/公司已存在的序列号（与原逻辑一致）
|
Long tenantId = SecurityUtils.getLoginUser().getTenantId();
|
if (null != tenantId) {
|
//获取公司编号
|
SysDept sysDept = sysDeptMapper.selectDeptById(tenantId.longValue());
|
if (!ObjectUtils.isEmpty(sysDept)) {
|
datePart = (StringUtils.isEmpty(sysDept.getDeptNick()) ? "" : sysDept.getDeptNick()) + datePart;
|
}
|
}
|
List<Integer> existingSequences = salesLedgerMapper.selectSequencesByDate(datePart);
|
int nextSequence = findFirstMissingSequence(existingSequences);
|
|
return datePart + String.format("%03d", nextSequence);
|
} finally {
|
// 3. 释放锁
|
String luaScript = "if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end";
|
redisTemplate.execute(
|
new DefaultRedisScript<>(luaScript, Long.class),
|
Collections.singletonList(lockKey),
|
lockValue
|
);
|
}
|
}
|
|
private int findFirstMissingSequence(List<Integer> sequences) {
|
if (sequences.isEmpty()) {
|
return 1;
|
}
|
// 排序后查找第一个缺失的正整数
|
sequences.sort(Integer::compareTo);
|
int next = 1;
|
for (int seq : sequences) {
|
if (seq == next) {
|
next++;
|
} else if (seq > next) {
|
break;
|
}
|
}
|
return next;
|
}
|
|
public <T, S> void updateMainContractAmount(
|
Long mainId,
|
List<T> subList,
|
Function<T, BigDecimal> amountGetter,
|
BaseMapper<S> mainMapper,
|
Class<S> mainEntityClass) {
|
|
if (mainId == null || subList == null || subList.isEmpty()) {
|
return;
|
}
|
|
// 计算子表金额总和
|
BigDecimal totalAmount = subList.stream()
|
.map(amountGetter)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
|
// 构造主表更新对象
|
try {
|
S entity = mainEntityClass.getDeclaredConstructor().newInstance();
|
Field idField = mainEntityClass.getDeclaredField("id");
|
idField.setAccessible(true);
|
idField.set(entity, mainId);
|
|
Field amountField = mainEntityClass.getDeclaredField("contractAmount");
|
amountField.setAccessible(true);
|
amountField.set(entity, totalAmount);
|
|
mainMapper.updateById(entity);
|
} catch (Exception e) {
|
throw new RuntimeException("动态更新主表金额失败", e);
|
}
|
}
|
|
// 内部类用于存储聚合结果
|
private static class GroupedCustomer {
|
private final Long customerId;
|
private final String customerName;
|
private BigDecimal totalAmount = BigDecimal.ZERO;
|
|
public GroupedCustomer(Long customerId, String customerName) {
|
this.customerId = customerId;
|
this.customerName = customerName;
|
}
|
|
public void addAmount(BigDecimal amount) {
|
if (amount != null) {
|
this.totalAmount = this.totalAmount.add(amount);
|
}
|
}
|
|
public Long getCustomerId() {
|
return customerId;
|
}
|
|
public String getCustomerName() {
|
return customerName;
|
}
|
|
public BigDecimal getTotalAmount() {
|
return totalAmount;
|
}
|
}
|
|
/**
|
* 新增销售台账时发起协同审批
|
*/
|
private void submitApproval(SalesLedger salesLedger) {
|
LoginUser loginUser = SecurityUtils.getLoginUser();
|
ApprovalTemplate template = approvalTemplateService.getOne(
|
new LambdaQueryWrapper<ApprovalTemplate>()
|
.eq(ApprovalTemplate::getBusinessType, TypeEnums.SALES_LEDGER_APPROVAL.getCode())
|
.eq(ApprovalTemplate::getDeleted, 0)
|
.orderByDesc(ApprovalTemplate::getId)
|
.last("limit 1")
|
);
|
if (template == null) {
|
log.warn("销售审批模板不存在，跳过发起审批");
|
return;
|
}
|
ApprovalInstanceDto instanceDto = new ApprovalInstanceDto();
|
instanceDto.setTemplateId(template.getId());
|
instanceDto.setTemplateName(template.getTemplateName());
|
instanceDto.setBusinessId(salesLedger.getId());
|
instanceDto.setBusinessType(TypeEnums.SALES_LEDGER_APPROVAL.getCode());
|
instanceDto.setCurrentLevel(1);
|
instanceDto.setTitle(salesLedger.getSalesContractNo() + "销售审批");
|
instanceDto.setApplicantId(loginUser.getUserId());
|
instanceDto.setApplicantName(loginUser.getNickName());
|
instanceDto.setApplyTime(LocalDateTime.now());
|
approvalInstanceService.add(instanceDto);
|
}
|
}
|
