package com.ruoyi.home.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.ruoyi.approve.mapper.ApproveProcessMapper;
|
import com.ruoyi.approve.pojo.ApproveProcess;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.dto.MapDto;
|
import com.ruoyi.framework.security.LoginUser;
|
import com.ruoyi.home.dto.*;
|
import com.ruoyi.home.service.HomeService;
|
import com.ruoyi.lavorissue.mapper.LavorIssueMapper;
|
import com.ruoyi.lavorissue.pojo.LaborIssue;
|
import com.ruoyi.procurementrecord.mapper.ProcurementRecordMapper;
|
import com.ruoyi.procurementrecord.mapper.ProcurementRecordOutMapper;
|
import com.ruoyi.procurementrecord.pojo.ProcurementRecordOut;
|
import com.ruoyi.procurementrecord.pojo.ProcurementRecordStorage;
|
import com.ruoyi.project.system.domain.SysDept;
|
import com.ruoyi.project.system.mapper.SysDeptMapper;
|
import com.ruoyi.purchase.mapper.PaymentRegistrationMapper;
|
import com.ruoyi.purchase.mapper.PurchaseLedgerMapper;
|
import com.ruoyi.purchase.pojo.PaymentRegistration;
|
import com.ruoyi.purchase.pojo.PurchaseLedger;
|
import com.ruoyi.quality.mapper.QualityInspectMapper;
|
import com.ruoyi.quality.pojo.QualityInspect;
|
import com.ruoyi.sales.mapper.ReceiptPaymentMapper;
|
import com.ruoyi.sales.mapper.SalesLedgerMapper;
|
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
|
import com.ruoyi.sales.pojo.ReceiptPayment;
|
import com.ruoyi.sales.pojo.SalesLedger;
|
import com.ruoyi.sales.pojo.SalesLedgerProduct;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.time.*;
|
import java.time.temporal.TemporalAdjusters;
|
import java.util.*;
|
import java.util.concurrent.atomic.AtomicInteger;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author :yys
|
* @date : 2025/7/25 9:23
|
*/
|
@Service
|
@Slf4j
|
public class HomeServiceImpl implements HomeService {
|
|
@Autowired
|
private SalesLedgerMapper salesLedgerMapper;
|
|
@Autowired
|
private PurchaseLedgerMapper purchaseLedgerMapper;
|
|
@Autowired
|
private SalesLedgerProductMapper salesLedgerProductMapper;
|
|
@Autowired
|
private ProcurementRecordOutMapper procurementRecordOutMapper;
|
|
@Autowired
|
private ProcurementRecordMapper procurementRecordStorageMapper;
|
|
@Autowired
|
private QualityInspectMapper qualityStatisticsMapper;
|
|
@Autowired
|
private ApproveProcessMapper approveProcessMapper;
|
|
@Autowired
|
private ReceiptPaymentMapper receiptPaymentMapper;
|
|
@Autowired
|
private PaymentRegistrationMapper paymentRegistrationMapper;
|
|
@Autowired
|
private LavorIssueMapper lavorIssueMapper;
|
|
@Autowired
|
private SysDeptMapper sysDeptMapper;
|
|
@Override
|
public HomeBusinessDto business() {
|
// 构建结果
|
HomeBusinessDto homeBusinessDto = new HomeBusinessDto();
|
LocalDate now = LocalDate.now();
|
YearMonth currentMonth = YearMonth.from(now);
|
// 创建LambdaQueryWrapper
|
LambdaQueryWrapper<SalesLedger> salesLedgerLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
salesLedgerLambdaQueryWrapper.ge(SalesLedger::getEntryDate, currentMonth.atDay(1).atStartOfDay()) // 大于等于本月第一天
|
.lt(SalesLedger::getEntryDate, currentMonth.plusMonths(1).atDay(1).atStartOfDay()); // 小于下月第一天
|
List<SalesLedger> salesLedgers = salesLedgerMapper.selectList(salesLedgerLambdaQueryWrapper);
|
if(CollectionUtils.isEmpty(salesLedgers)){
|
return homeBusinessDto;
|
}
|
// 合计合同金额
|
BigDecimal contractAmount = salesLedgers.stream().map(SalesLedger::getContractAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
LambdaQueryWrapper<SalesLedgerProduct> salesLedgerProductMapperLambdaQueryWrapper = new LambdaQueryWrapper<SalesLedgerProduct>();
|
salesLedgerProductMapperLambdaQueryWrapper.eq(SalesLedgerProduct::getType, 1)
|
.in(SalesLedgerProduct::getSalesLedgerId, salesLedgers.stream().map(SalesLedger::getId).collect(Collectors.toList()));
|
List<SalesLedgerProduct> salesLedgerProducts = salesLedgerProductMapper.selectList(salesLedgerProductMapperLambdaQueryWrapper);
|
// 未开票金额
|
BigDecimal noInvoiceAmountTotal = salesLedgerProducts.stream().map(SalesLedgerProduct::getNoInvoiceAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
homeBusinessDto.setMonthSaleMoney(contractAmount.setScale(2, RoundingMode.HALF_UP).toString());
|
homeBusinessDto.setMonthSaleHaveMoney(noInvoiceAmountTotal.setScale(2, RoundingMode.HALF_UP).toString());
|
// 创建LambdaQueryWrapper
|
LambdaQueryWrapper<PurchaseLedger> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.ge(PurchaseLedger::getEntryDate, currentMonth.atDay(1).atStartOfDay()) // 大于等于本月第一天
|
.lt(PurchaseLedger::getEntryDate, currentMonth.plusMonths(1).atDay(1).atStartOfDay()); // 小于下月第一天
|
|
// 执行查询并计算总和
|
List<PurchaseLedger> purchaseLedgers = purchaseLedgerMapper.selectList(queryWrapper);
|
if(CollectionUtils.isEmpty(purchaseLedgers)){
|
return homeBusinessDto;
|
}
|
|
LambdaQueryWrapper<SalesLedgerProduct> salesLedgerProductMapperLambdaQueryWrapperCopy = new LambdaQueryWrapper<SalesLedgerProduct>();
|
salesLedgerProductMapperLambdaQueryWrapper.eq(SalesLedgerProduct::getType, 2)
|
.in(SalesLedgerProduct::getSalesLedgerId, purchaseLedgers.stream().map(PurchaseLedger::getId).collect(Collectors.toList()));
|
List<SalesLedgerProduct> salesLedgerProductsCopy = salesLedgerProductMapper.selectList(salesLedgerProductMapperLambdaQueryWrapperCopy);
|
// 合计合同金额
|
BigDecimal receiveAmount = purchaseLedgers.stream()
|
.map(PurchaseLedger::getContractAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
// 未开票金额
|
BigDecimal unReceiptPaymentAmount = salesLedgerProductsCopy.stream()
|
.map(SalesLedgerProduct::getNoInvoiceAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
|
// 统计库存
|
List<ProcurementRecordStorage> procurementRecordStorages = procurementRecordStorageMapper.selectList(null);
|
BigDecimal stockAmount = procurementRecordStorages.stream()
|
.map(ProcurementRecordStorage::getInboundNum)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
List<ProcurementRecordOut> procurementRecordOuts = procurementRecordOutMapper.selectList(null);
|
BigDecimal outboundAmount = procurementRecordOuts.stream()
|
.map(ProcurementRecordOut::getInboundNum)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
BigDecimal stock = stockAmount.subtract(outboundAmount);
|
// 获取当天入库数量
|
LambdaQueryWrapper<ProcurementRecordStorage> procurementRecordStorageLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
procurementRecordStorageLambdaQueryWrapper.ge(ProcurementRecordStorage::getCreateTime, now) // 大于等于当天
|
.lt(ProcurementRecordStorage::getCreateTime, now.plusDays(1)); // 小于明天
|
List<ProcurementRecordStorage> procurementRecordStorages1 = procurementRecordStorageMapper.selectList(procurementRecordStorageLambdaQueryWrapper);
|
BigDecimal stockAmount1 = procurementRecordStorages1.stream()
|
.map(ProcurementRecordStorage::getInboundNum)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
|
homeBusinessDto.setMonthPurchaseMoney(receiveAmount.setScale(2, RoundingMode.HALF_UP).toString());
|
homeBusinessDto.setMonthPurchaseHaveMoney(unReceiptPaymentAmount.setScale(2, RoundingMode.HALF_UP).toString());
|
homeBusinessDto.setInventoryNum(stock.setScale(2, RoundingMode.HALF_UP).toString());
|
homeBusinessDto.setTodayInventoryNum(stockAmount1.setScale(2, RoundingMode.HALF_UP).toString());
|
return homeBusinessDto;
|
}
|
|
@Override
|
public AnalysisCustomerContractAmountsDto analysisCustomerContractAmounts() {
|
List<SalesLedger> salesLedgers = salesLedgerMapper.selectList(null);
|
// 合计合同金额
|
BigDecimal contractAmount = salesLedgers.stream().map(SalesLedger::getContractAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
// 计算周同比
|
// 获取当前时间
|
LocalDate today = LocalDate.now();
|
|
// 获取本周周一
|
LocalDate startOfWeek = today.with(DayOfWeek.MONDAY);
|
|
// 获取本周周日
|
LocalDate endOfWeek = today.with(DayOfWeek.SUNDAY);
|
List<SalesLedger> salesLedgers1 = salesLedgerMapper.selectList(new LambdaQueryWrapper<SalesLedger>()
|
.ge(SalesLedger::getEntryDate, startOfWeek) // 大于等于本周周一
|
.lt(SalesLedger::getEntryDate, endOfWeek.plusDays(1))); // 修改：使用 lt 并加上一天来包含周日
|
BigDecimal weekContractAmount = salesLedgers1.stream().map(SalesLedger::getContractAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
// 获取去年本周时间
|
LocalDate lastYearStartOfWeek = today.minusYears(1).with(DayOfWeek.MONDAY);
|
LocalDate lastYearEndOfWeek = today.minusYears(1).with(DayOfWeek.SUNDAY);
|
List<SalesLedger> salesLedgers2 = salesLedgerMapper.selectList(new LambdaQueryWrapper<SalesLedger>()
|
.ge(SalesLedger::getEntryDate, lastYearStartOfWeek) // 大于等于去年本周周一
|
.lt(SalesLedger::getEntryDate, lastYearEndOfWeek.plusDays(1))); // 修改：使用 lt 并加上一天来包含周日
|
BigDecimal lastYearWeekContractAmount = salesLedgers2.stream().map(SalesLedger::getContractAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
BigDecimal subtract = weekContractAmount.subtract(lastYearWeekContractAmount);
|
String weekYny = "";
|
// 周同比
|
if(subtract.compareTo(BigDecimal.ZERO) == 0 || lastYearWeekContractAmount.compareTo(BigDecimal.ZERO) == 0){
|
weekYny = "0.00";
|
}else{
|
weekYny = String.format("%.2f", subtract.divide(lastYearWeekContractAmount, 2, RoundingMode.HALF_UP).multiply(new BigDecimal("100")));
|
|
}
|
|
// 计算日环比
|
LocalDate yesterday = today.minusDays(1);
|
LocalDate plusDays = today.plusDays(1);
|
List<SalesLedger> salesLedgers3 = salesLedgerMapper.selectList(new LambdaQueryWrapper<SalesLedger>()
|
.ge(SalesLedger::getEntryDate, today) // 大于等于今天
|
.lt(SalesLedger::getEntryDate, plusDays)); // 修改：使用 lt 并加上一天来包含当天
|
BigDecimal todayContractAmount = salesLedgers3.stream().map(SalesLedger::getContractAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
List<SalesLedger> salesLedgers4 = salesLedgerMapper.selectList(new LambdaQueryWrapper<SalesLedger>()
|
.ge(SalesLedger::getEntryDate, yesterday) // 大于等于昨天
|
.lt(SalesLedger::getEntryDate, today)); // 修改：使用 lt 而不是 gt
|
BigDecimal lastYearYesterdayContractAmount = salesLedgers4.stream().map(SalesLedger::getContractAmount)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
BigDecimal subtract1 = todayContractAmount.subtract(lastYearYesterdayContractAmount); // 修改：使用 todayContractAmount 而不是 yesterdayContractAmount
|
// 日环比
|
String chain = "";
|
if(subtract1.compareTo(BigDecimal.ZERO) == 0 || lastYearYesterdayContractAmount.compareTo(BigDecimal.ZERO) == 0){
|
chain = "0.00";
|
}else{
|
chain = String.format("%.2f", subtract1.divide(lastYearYesterdayContractAmount, 2, RoundingMode.HALF_UP).multiply(new BigDecimal("100")));
|
}
|
|
|
AnalysisCustomerContractAmountsDto analysisCustomerContractAmountsDto = new AnalysisCustomerContractAmountsDto();
|
// 修改：将合同金额保留两位小数
|
analysisCustomerContractAmountsDto.setSum(contractAmount.setScale(2, RoundingMode.HALF_UP).toString());
|
analysisCustomerContractAmountsDto.setYny(weekYny);
|
analysisCustomerContractAmountsDto.setChain(chain);
|
|
Map<String, BigDecimal> collect = salesLedgers.stream().collect(Collectors.groupingBy(SalesLedger::getCustomerName, Collectors.reducing(BigDecimal.ZERO,
|
SalesLedger::getContractAmount, BigDecimal::add)));
|
List<MapDto> mapDtos = new ArrayList<>();
|
collect.forEach((k,v)->{
|
MapDto mapDto = new MapDto();
|
mapDto.setName(k);
|
// 修改：将金额值保留两位小数
|
mapDto.setValue(v.setScale(2, RoundingMode.HALF_UP).toString());
|
if(contractAmount.compareTo(new BigDecimal(0)) == 0){
|
mapDto.setRate("0");
|
}else{
|
mapDto.setRate(String.format("%.2f", v.divide(contractAmount, 2, RoundingMode.HALF_UP).multiply(new BigDecimal("100"))));
|
}
|
mapDtos.add(mapDto);
|
});
|
analysisCustomerContractAmountsDto.setItem(mapDtos);
|
return analysisCustomerContractAmountsDto;
|
}
|
|
|
@Override
|
public QualityStatisticsDto qualityStatistics() {
|
// 获取一周数据
|
// 获取当前时间
|
LocalDate today = LocalDate.now();
|
// 获取本周周一
|
LocalDate startOfWeek = today.with(DayOfWeek.MONDAY);
|
// 获取本周周日
|
LocalDate endOfWeek = today.with(DayOfWeek.SUNDAY);
|
LambdaQueryWrapper<QualityInspect> qualityInspectLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
qualityInspectLambdaQueryWrapper.ge(QualityInspect::getCheckTime, startOfWeek)
|
.gt(QualityInspect::getCheckTime, endOfWeek);
|
List<QualityInspect> qualityInspects = qualityStatisticsMapper.selectList(qualityInspectLambdaQueryWrapper);
|
QualityStatisticsDto qualityStatisticsDto = new QualityStatisticsDto();
|
qualityStatisticsDto.setSupplierNum(qualityInspects.stream().filter(item -> item.getInspectType().equals(0)).map(QualityInspect::getQuantity).reduce(BigDecimal.ZERO, BigDecimal::add));
|
qualityStatisticsDto.setProcessNum(qualityInspects.stream().filter(item -> item.getInspectType().equals(1)).map(QualityInspect::getQuantity).reduce(BigDecimal.ZERO, BigDecimal::add));
|
qualityStatisticsDto.setFactoryNum(qualityInspects.stream().filter(item -> item.getInspectType().equals(2)).map(QualityInspect::getQuantity).reduce(BigDecimal.ZERO, BigDecimal::add));
|
List<QualityStatisticsItem> qualityStatisticsItems = new ArrayList<>();
|
for (int j = 1; j < 8; j++) {
|
LocalDate endTime = startOfWeek.plusDays(j);
|
LocalDate startTime = endTime.minusDays(1);
|
QualityStatisticsItem qualityStatisticsItem = new QualityStatisticsItem();
|
qualityStatisticsItem.setDate(startTime.toString());
|
qualityStatisticsItem.setSupplierNum(qualityInspects.stream()
|
.filter(item -> item.getInspectType().equals(0) && "不合格".equals(item.getCheckResult())
|
&& (startTime.isEqual(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()) || startTime.isAfter(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))
|
&& endTime.isBefore(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))
|
.map(QualityInspect::getQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add)
|
);
|
qualityStatisticsItem.setFactoryNum(qualityInspects.stream()
|
.filter(item -> item.getInspectType().equals(1) && "不合格".equals(item.getCheckResult())
|
&& (startTime.isEqual(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()) || startTime.isAfter(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))
|
&& endTime.isBefore(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))
|
.map(QualityInspect::getQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add)
|
);
|
qualityStatisticsItem.setProcessNum(qualityInspects.stream()
|
.filter(item -> item.getInspectType().equals(2) && "不合格".equals(item.getCheckResult())
|
&& (startTime.isEqual(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()) || startTime.isAfter(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))
|
&& endTime.isBefore(item.getCheckTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()))
|
.map(QualityInspect::getQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add));
|
qualityStatisticsItems.add(qualityStatisticsItem);
|
}
|
qualityStatisticsDto.setItem(qualityStatisticsItems);
|
return qualityStatisticsDto;
|
}
|
|
@Override
|
public List<ApproveProcess> todos() throws ParseException {
|
LoginUser loginUser = SecurityUtils.getLoginUser();
|
LambdaQueryWrapper<ApproveProcess> approveProcessLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
approveProcessLambdaQueryWrapper.eq(ApproveProcess::getApproveDelete, 0)
|
.eq(ApproveProcess::getApproveUserCurrentId, loginUser.getUserId())
|
.ne(ApproveProcess::getApproveStatus, 2)
|
.eq(ApproveProcess::getTenantId, loginUser.getTenantId());
|
List<ApproveProcess> approveProcesses = approveProcessMapper.selectList(approveProcessLambdaQueryWrapper);
|
if(CollectionUtils.isEmpty(approveProcesses)){
|
approveProcesses = new ArrayList<>();
|
}
|
// 查询未领用劳保记录
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
|
LaborIssue laborIssue1 = new LaborIssue();
|
laborIssue1.setAdoptedDate(new Date());
|
laborIssue1.setIssueDate(sdf.parse(sdf.format(new Date())));
|
List<LaborIssue> laborIssues = lavorIssueMapper.list(laborIssue1);
|
if(!CollectionUtils.isEmpty(laborIssues)){
|
for (LaborIssue laborIssue : laborIssues) {
|
ApproveProcess approveProcess = new ApproveProcess();
|
approveProcess.setApproveId(laborIssue.getOrderNo());
|
approveProcess.setApproveDeptName(sysDeptMapper.selectDeptById(loginUser.getTenantId()).getDeptName());
|
approveProcess.setApproveTime(laborIssue.getIssueDate());
|
approveProcess.setApproveReason(laborIssue.getDictTypeName() + "-" + laborIssue.getDictName() + "超时未领取");
|
approveProcesses.add(approveProcess);
|
}
|
}
|
return approveProcesses;
|
}
|
|
/**
|
*
|
* @param type 1-周 2-月 3-季度
|
* @return
|
*/
|
@Override
|
public StatisticsReceivablePayableDto statisticsReceivablePayable(Integer type) {
|
LocalDate today = LocalDate.now();
|
LocalDate startDate = null;
|
LocalDate endDate = null;
|
switch (type){
|
case 1:
|
// 获取本周周一
|
startDate = today.with(DayOfWeek.MONDAY);
|
// 获取本周周日
|
endDate = today.with(DayOfWeek.SUNDAY);
|
break;
|
case 2:
|
startDate = today.with(TemporalAdjusters.firstDayOfMonth());
|
endDate = today.with(TemporalAdjusters.lastDayOfMonth());
|
break;
|
case 3:
|
Month currentMonth = today.getMonth();
|
Month firstMonthOfQuarter = currentMonth.firstMonthOfQuarter();
|
Month lastMonthOfQuarter = Month.of(firstMonthOfQuarter.getValue() + 2);
|
|
startDate = today.withMonth(firstMonthOfQuarter.getValue())
|
.with(TemporalAdjusters.firstDayOfMonth());
|
endDate = today.withMonth(lastMonthOfQuarter.getValue())
|
.with(TemporalAdjusters.lastDayOfMonth());
|
break;
|
}
|
// 应收
|
List<SalesLedger> salesLedgers = salesLedgerMapper.selectList(new LambdaQueryWrapper<SalesLedger>()
|
// .ge(SalesLedger::getEntryDate, startDate)
|
// .lt(SalesLedger::getEntryDate, endDate)
|
);
|
BigDecimal receivableMoney = salesLedgers.stream().map(SalesLedger::getContractAmount).reduce(BigDecimal.ZERO, BigDecimal::add);
|
// 应付
|
List<PurchaseLedger> procurementRecords = purchaseLedgerMapper.selectList(new LambdaQueryWrapper<PurchaseLedger>()
|
// .ge(PurchaseLedger::getEntryDate, startDate)
|
// .lt(PurchaseLedger::getEntryDate, endDate)
|
);
|
BigDecimal payableMoney = procurementRecords.stream().map(PurchaseLedger::getContractAmount).reduce(BigDecimal.ZERO, BigDecimal::add);
|
// 预收
|
List<ReceiptPayment> receiptPayments = receiptPaymentMapper.selectList(new LambdaQueryWrapper<ReceiptPayment>()
|
// .ge(ReceiptPayment::getReceiptPaymentDate, startDate)
|
// .lt(ReceiptPayment::getReceiptPaymentDate, endDate)
|
);
|
BigDecimal advanceMoney = receiptPayments.stream().map(ReceiptPayment::getReceiptPaymentAmount).reduce(BigDecimal.ZERO, BigDecimal::add);
|
// 预付
|
List<PaymentRegistration> paymentRegistrations = paymentRegistrationMapper.selectList(new LambdaQueryWrapper<PaymentRegistration>()
|
// .ge(PaymentRegistration::getPaymentDate, startDate)
|
// .lt(PaymentRegistration::getPaymentDate, endDate)
|
);
|
BigDecimal prepayMoney = paymentRegistrations.stream().map(PaymentRegistration::getCurrentPaymentAmount).reduce(BigDecimal.ZERO, BigDecimal::add);
|
StatisticsReceivablePayableDto statisticsReceivablePayableDto = new StatisticsReceivablePayableDto();
|
statisticsReceivablePayableDto.setPayableMoney(payableMoney.subtract(prepayMoney));
|
statisticsReceivablePayableDto.setReceivableMoney(receivableMoney.subtract(advanceMoney));
|
statisticsReceivablePayableDto.setAdvanceMoney(advanceMoney);
|
statisticsReceivablePayableDto.setPrepayMoney(prepayMoney);
|
|
return statisticsReceivablePayableDto;
|
}
|
}
|
