package com.ruoyi.cwgl.service.impl;
|
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import com.ruoyi.common.utils.DateUtils;
|
import javax.annotation.Resource;
|
|
import com.ruoyi.cwgl.domain.DispatchOrderItem;
|
import com.ruoyi.cwgl.domain.vo.DispatchOrderAttachmentVo;
|
import com.ruoyi.cwgl.domain.vo.DispatchOrderItemVo;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.stereotype.Service;
|
import org.springframework.scheduling.annotation.Async;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import com.ruoyi.common.utils.PageUtils;
|
import com.ruoyi.common.constant.Constants;
|
import com.ruoyi.common.annotation.DataSource;
|
import com.ruoyi.common.enums.DataSourceType;
|
import com.ruoyi.common.core.service.BaseService;
|
|
import com.ruoyi.cwgl.mapper.DispatchOrderMapper;
|
import com.ruoyi.cwgl.domain.DispatchOrder;
|
import com.ruoyi.cwgl.service.IDispatchOrderService;
|
import com.ruoyi.common.core.text.Convert;
|
|
/**
|
* 调度单Service业务层处理
|
*
|
* @author ruoyi
|
* @date 2025-07-29
|
*/
|
@Service
|
@Transactional(rollbackFor = Exception.class)
|
public class DispatchOrderServiceImpl extends BaseService<DispatchOrderMapper, DispatchOrder> implements IDispatchOrderService
|
{
|
protected final Logger logger = LoggerFactory.getLogger(getClass());
|
@Resource
|
private DispatchOrderMapper dispatchOrderMapper;
|
|
|
/**
|
* 查询调度单
|
*
|
* @param id 调度单ID
|
* @return 调度单
|
*/
|
@DataSource(DataSourceType.SLAVE)
|
@Override
|
public DispatchOrder selectDispatchOrderById(Integer id)
|
{
|
return dispatchOrderMapper.selectDispatchOrderById(id);
|
}
|
|
/**
|
* 查询调度单 记录数
|
*
|
* @param dispatchOrder 调度单
|
* @return 调度单集合
|
*/
|
@DataSource(DataSourceType.SLAVE)
|
@Override
|
public int selectDispatchOrderCount(DispatchOrder dispatchOrder)
|
{
|
return dispatchOrderMapper.selectDispatchOrderCount(dispatchOrder);
|
}
|
|
/**
|
* 查询调度单列表
|
*
|
* @param dispatchOrder 调度单
|
* @return 调度单
|
*/
|
@DataSource(DataSourceType.SLAVE)
|
@Override
|
public List<DispatchOrder> selectDispatchOrderList(DispatchOrder dispatchOrder)
|
{
|
return dispatchOrderMapper.selectDispatchOrderList(dispatchOrder);
|
}
|
/**
|
* 查询调度单列表
|
*
|
* @param dispatchOrder 调度单
|
* @return 调度单
|
*/
|
@DataSource(DataSourceType.CWSJ)
|
@Override
|
public List<DispatchOrder> selectDispatchOrderList2(DispatchOrder dispatchOrder)
|
{
|
return dispatchOrderMapper.selectDispatchOrderList2(dispatchOrder);
|
}
|
|
/**
|
* 查询调度单列表 异步 导出
|
*
|
* @param dispatchOrder 调度单
|
* @param exportKey 导出功能的唯一标识
|
* @return 调度单集合
|
*/
|
@DataSource(DataSourceType.SLAVE)
|
@Async
|
@Override
|
public void export(DispatchOrder dispatchOrder,String exportKey) {
|
|
super.export(DispatchOrder.class,exportKey,"dispatchOrderData",(pageNum)->{
|
PageUtils.startPage(pageNum, Constants.EXPORT_PATE_SIZE);
|
return selectDispatchOrderList(dispatchOrder);
|
});
|
}
|
|
|
/**
|
* 新增调度单
|
*
|
* @param dispatchOrder 调度单
|
* @return 结果
|
*/
|
@Override
|
public int insertDispatchOrder(DispatchOrder dispatchOrder)
|
{
|
dispatchOrder.setCreateTime(DateUtils.getNowDate());
|
return dispatchOrderMapper.insertDispatchOrder(dispatchOrder);
|
}
|
|
/**
|
* 新增调度单[批量]
|
*
|
* @param dispatchOrders 调度单
|
* @return 结果
|
*/
|
@Override
|
public int insertDispatchOrderBatch(List<DispatchOrder> dispatchOrders)
|
{
|
int rows = dispatchOrderMapper.insertDispatchOrderBatch(dispatchOrders);
|
return rows;
|
}
|
|
/**
|
* 修改调度单
|
*
|
* @param dispatchOrder 调度单
|
* @return 结果
|
*/
|
@Override
|
public int updateDispatchOrder(DispatchOrder dispatchOrder)
|
{
|
dispatchOrder.setUpdateTime(DateUtils.getNowDate());
|
return dispatchOrderMapper.updateDispatchOrder(dispatchOrder);
|
}
|
|
/**
|
* 修改调度单[批量]
|
*
|
* @param dispatchOrders 调度单
|
* @return 结果
|
*/
|
@Override
|
public int updateDispatchOrderBatch(List<DispatchOrder> dispatchOrders){
|
return dispatchOrderMapper.updateDispatchOrderBatch(dispatchOrders);
|
}
|
|
/**
|
* 删除调度单对象
|
*
|
* @param ids 需要删除的数据ID
|
* @return 结果
|
*/
|
@Override
|
public int deleteDispatchOrderByIds(String ids)
|
{
|
return deleteDispatchOrderByIds(Convert.toIntArray(ids));
|
}
|
|
/**
|
* 删除调度单对象
|
*
|
*
|
* @param ids 需要删除的数据ID
|
* @return 结果
|
*/
|
@Override
|
public int deleteDispatchOrderByIds(Integer[] ids)
|
{
|
return dispatchOrderMapper.deleteDispatchOrderByIds(ids);
|
}
|
|
/**
|
* 删除调度单信息
|
*
|
* @param id 调度单ID
|
* @return 结果
|
*/
|
@Override
|
public int deleteDispatchOrderById(Integer id)
|
{
|
return dispatchOrderMapper.deleteDispatchOrderById(id);
|
}
|
|
@DataSource(DataSourceType.CWSJ)
|
@Override
|
public List<DispatchOrderItemVo> selectDispatchOrderItem(String no) {
|
// 使用Map来临时存储分组结果
|
Map<String, DispatchOrderItemVo> summaryMap = new HashMap<>();
|
|
List<DispatchOrderItem> dispatchOrderItems=dispatchOrderMapper.selectDispatchOrderItemByNo(no);
|
Set<String> settableFeeItemSet = null;
|
for (DispatchOrderItem dispatchOrderItem : dispatchOrderItems) {
|
String settableFeeItems = dispatchOrderItem.getSettableFeeItems();
|
if (settableFeeItemSet==null) {
|
settableFeeItemSet = new HashSet<>(
|
Arrays.asList(settableFeeItems.split(",")));
|
}
|
// 判断是否可结算
|
String feeItem = dispatchOrderItem.getFeeItem();
|
int isSettable = isFeeItemSettable(feeItem, settableFeeItemSet);
|
// 如果Map中不存在该费用类型，则创建新条目
|
if (!summaryMap.containsKey(feeItem)) {
|
DispatchOrderItemVo summary = new DispatchOrderItemVo();
|
summary.setFeeItem(feeItem);
|
summary.setReceivableFee(BigDecimal.ZERO);
|
summary.setActualFee(BigDecimal.ZERO);
|
summary.setIsSettlement(isSettable);
|
summaryMap.put(feeItem, summary);
|
}
|
// 根据账单类型累加金额
|
DispatchOrderItemVo summary = summaryMap.get(feeItem);
|
if ("R".equals(dispatchOrderItem.getBillType())) { // 应收
|
summary.setReceivableFee(summary.getReceivableFee().add(dispatchOrderItem.getSettleFee()));
|
summary.setReceivableFeeCurrency(dispatchOrderItem.getCurrencyType());
|
} else if ("P".equals(dispatchOrderItem.getBillType())) { // 应付
|
summary.setActualFee(summary.getActualFee().add(dispatchOrderItem.getSettleFee()));
|
summary.setActualFeeCurrency(dispatchOrderItem.getCurrencyType());
|
|
}
|
}
|
// 转换为List并过滤、排序
|
return summaryMap.values().stream()
|
// 过滤掉应收应付都为0的记录
|
.filter(dto -> dto.getReceivableFee().compareTo(BigDecimal.ZERO) != 0
|
|| dto.getActualFee().compareTo(BigDecimal.ZERO) != 0)
|
// 排序：可结算的在前，不可结算的在后；然后按总金额降序
|
.sorted(Comparator.comparing(DispatchOrderItemVo::getIsSettlement).reversed()
|
.thenComparing(dto -> dto.getReceivableFee().add(dto.getActualFee()),
|
Comparator.reverseOrder()))
|
.collect(Collectors.toList());
|
}
|
|
|
|
/**
|
* 判断费用类型是否可结算
|
*/
|
private static int isFeeItemSettable(String feeItem, Set<String> settableFeeItemSet) {
|
if (feeItem == null || settableFeeItemSet == null) {
|
return 0;
|
}
|
|
|
if (settableFeeItemSet.contains(feeItem)) {
|
return 1;
|
}
|
|
return 0;
|
}
|
|
@DataSource(DataSourceType.CWSJ)
|
@Override
|
public List<DispatchOrderAttachmentVo> selectDispatchOrderAttachment(String no) {
|
return dispatchOrderMapper.selectDispatchOrderAttachment(no);
|
}
|
}
|
