package com.ruoyi.business.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.ruoyi.basic.entity.CoalInfo;
|
import com.ruoyi.basic.entity.CoalPlan;
|
import com.ruoyi.basic.entity.CoalValue;
|
import com.ruoyi.basic.entity.Customer;
|
import com.ruoyi.basic.mapper.CoalInfoMapper;
|
import com.ruoyi.basic.mapper.CoalPlanMapper;
|
import com.ruoyi.basic.mapper.CoalValueMapper;
|
import com.ruoyi.basic.mapper.CustomerMapper;
|
import com.ruoyi.business.dto.*;
|
import com.ruoyi.business.entity.*;
|
import com.ruoyi.business.mapper.*;
|
import com.ruoyi.business.service.ProductHomeService;
|
import com.ruoyi.common.core.domain.R;
|
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.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.LocalTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author :yys
|
* @date : 2025/10/13 9:11
|
*/
|
@Service
|
@Slf4j
|
public class ProductHomeServiceImpl implements ProductHomeService {
|
|
@Autowired
|
private ProductionMapper productionMapper;
|
|
@Autowired
|
private ProductionSchedulingMapper productionSchedulingMapper;
|
|
@Autowired
|
private OfficialInventoryMapper officialInventoryMapper;
|
|
@Autowired
|
private SalesRecordMapper salesRecordMapper;
|
|
@Autowired
|
private CoalInfoMapper coalInfoMapper;
|
|
@Autowired
|
private CustomerMapper customerMapper;
|
|
@Autowired
|
private PurchaseRegistrationMapper purchaseRegistrationMapper;
|
|
@Autowired
|
private CoalValueMapper coalValueMapper;
|
|
@Autowired
|
private CoalPlanMapper coalPlanMapper;
|
|
@Override
|
public R<ProductionSchedulingStatisticsDto> productionSchedulingStatistics(DateQueryDto dto) {
|
String start = dto.getEntryDateStart();
|
String end = dto.getEntryDateEnd();
|
|
|
// 使用 LambdaQueryWrapper 构建查询条件
|
LambdaQueryWrapper<ProductionScheduling> wrapper = new LambdaQueryWrapper<>();
|
|
if (start != null && !start.isEmpty() && end != null && !end.isEmpty()) {
|
wrapper.between(ProductionScheduling::getSchedulingDate, LocalDate.parse(start, DateTimeFormatter.ISO_LOCAL_DATE), LocalDate.parse(end, DateTimeFormatter.ISO_LOCAL_DATE));
|
}
|
|
List<ProductionScheduling> schedulingList = productionSchedulingMapper.selectList(wrapper);
|
|
ProductionSchedulingStatisticsDto result = new ProductionSchedulingStatisticsDto();
|
BigDecimal totalScheduling = BigDecimal.ZERO;
|
BigDecimal completedScheduling = BigDecimal.ZERO;
|
BigDecimal pendingScheduling = BigDecimal.ZERO;
|
|
for (ProductionScheduling scheduling : schedulingList) {
|
BigDecimal num = scheduling.getSchedulingNum();
|
if (num != null) {
|
totalScheduling = totalScheduling.add(num);
|
if (scheduling.getStatus() == 3) { // 已报工
|
completedScheduling = completedScheduling.add(num);
|
} else if (scheduling.getStatus() == 1) { // 待生产
|
pendingScheduling = pendingScheduling.add(num);
|
}
|
}
|
}
|
|
result.setTotalOutput(totalScheduling);
|
result.setCompletedScheduling(completedScheduling);
|
result.setPendingScheduling(pendingScheduling);
|
|
return R.ok(result);
|
}
|
|
@Override
|
public R<List<ProductionScheduling>> productionSchedulingStatisticsList(DateQueryDto dto) {
|
String start = dto.getEntryDateStart();
|
String end = dto.getEntryDateEnd();
|
|
// 使用 LambdaQueryWrapper 构建查询条件
|
LambdaQueryWrapper<ProductionScheduling> wrapper = new LambdaQueryWrapper<>();
|
|
if (start != null && !start.isEmpty() && end != null && !end.isEmpty()) {
|
wrapper.between(ProductionScheduling::getSchedulingDate, LocalDate.parse(start, DateTimeFormatter.ISO_LOCAL_DATE), LocalDate.parse(end, DateTimeFormatter.ISO_LOCAL_DATE));
|
}
|
|
List<ProductionScheduling> schedulingList = productionSchedulingMapper.selectList(wrapper);
|
// 通过煤种id获取煤种名称
|
schedulingList.forEach(scheduling -> {
|
CoalInfo coalInfo = coalInfoMapper.selectById(scheduling.getCoalId());
|
scheduling.setCoalName(coalInfo.getCoal());
|
});
|
return R.ok(schedulingList);
|
}
|
|
@Override
|
public R<List<OfficialInventory>> productionSchedulingInventoryList(DateQueryDto dto) {
|
String start = dto.getEntryDateStart();
|
String end = dto.getEntryDateEnd();
|
|
|
// 使用 LambdaQueryWrapper 构建查询条件
|
LambdaQueryWrapper<OfficialInventory> wrapper = new LambdaQueryWrapper<>();
|
|
if (start != null && !start.isEmpty() && end != null && !end.isEmpty()) {
|
wrapper.between(OfficialInventory::getRegistrationDate, LocalDate.parse(start, DateTimeFormatter.ISO_LOCAL_DATE), LocalDate.parse(end, DateTimeFormatter.ISO_LOCAL_DATE));
|
}
|
|
List<OfficialInventory> schedulingList = officialInventoryMapper.selectList(wrapper);
|
schedulingList.forEach(scheduling -> {
|
CoalInfo coalInfo = coalInfoMapper.selectById(scheduling.getCoalId());
|
scheduling.setCoalName(coalInfo.getCoal());
|
});
|
return R.ok(schedulingList);
|
}
|
|
@Override
|
public R<MaterialStatisticsDto> materialStatistics(DateQueryDto dto) {
|
MaterialStatisticsDto result = new MaterialStatisticsDto();
|
// 获取今日开始时间，结束时间
|
LocalDateTime todayStart = LocalDateTime.of(
|
LocalDateTime.now().toLocalDate(),
|
LocalTime.MIN
|
);
|
LocalDateTime todayEnd = LocalDateTime.of(
|
LocalDateTime.now().toLocalDate(),
|
LocalTime.MAX
|
);
|
// 使用 LambdaQueryWrapper 构建查询条件
|
LambdaQueryWrapper<OfficialInventory> wrapper = new LambdaQueryWrapper<>();
|
wrapper.between(OfficialInventory::getRegistrationDate, todayStart, todayEnd);
|
// 获取今日入库总量
|
List<OfficialInventory> officialInventories = officialInventoryMapper.selectList(wrapper);
|
if (!CollectionUtils.isEmpty(officialInventories)) {
|
BigDecimal todayInboundTotal = officialInventories.stream()
|
.map(OfficialInventory::getInventoryQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
result.setTodayInboundTotal(todayInboundTotal);
|
|
}
|
// 获取当前库存总量
|
R<List<OfficialInventory>> listR = productionSchedulingInventoryList(dto);
|
if (R.isSuccess(listR)) {
|
List<OfficialInventory> officialInventoriesList = listR.getData();
|
if (!CollectionUtils.isEmpty(officialInventoriesList)) {
|
BigDecimal todayOutboundTotal = officialInventoriesList.stream()
|
.map(OfficialInventory::getInventoryQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
result.setTodayOutboundTotal(todayOutboundTotal);
|
}
|
}
|
// 获取今日出库总量
|
// 使用 LambdaQueryWrapper 构建查询条件
|
LambdaQueryWrapper<SalesRecord> wrapperSalesRecord = new LambdaQueryWrapper<>();
|
wrapperSalesRecord.between(SalesRecord::getSaleDate, todayStart, todayEnd);
|
// 获取今日入库总量
|
List<SalesRecord> salesRecords = salesRecordMapper.selectList(wrapperSalesRecord);
|
if (!CollectionUtils.isEmpty(salesRecords)) {
|
BigDecimal todayInboundTotal = salesRecords.stream()
|
.map(SalesRecord::getInventoryQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
result.setTodayOutboundTotal(todayInboundTotal);
|
|
}
|
return R.ok(result);
|
}
|
|
@Override
|
public R<List<ItemListDto>> coalTypeDistribution(DateQueryDto dto) {
|
String start = dto.getEntryDateStart();
|
String end = dto.getEntryDateEnd();
|
// 获取煤种列表
|
List<CoalInfo> coalInfoList = coalInfoMapper.selectList(null);
|
|
// 使用 LambdaQueryWrapper 构建查询条件
|
LambdaQueryWrapper<SalesRecord> wrapper = new LambdaQueryWrapper<>();
|
|
if (start != null && !start.isEmpty() && end != null && !end.isEmpty()) {
|
wrapper.between(SalesRecord::getRegistrationDate, LocalDate.parse(start, DateTimeFormatter.ISO_LOCAL_DATE), LocalDate.parse(end, DateTimeFormatter.ISO_LOCAL_DATE));
|
}
|
List<SalesRecord> salesRecords = salesRecordMapper.selectList(wrapper);
|
// 根据煤种进行分组，并计算占比
|
Map<Long, List<SalesRecord>> coalTypeMap = salesRecords.stream()
|
.collect(Collectors.groupingBy(SalesRecord::getCoalId));
|
|
List<ItemListDto> itemListDtos = coalInfoList.stream().map(coalInfo -> {
|
ItemListDto itemListDto = new ItemListDto();
|
itemListDto.setName(coalInfo.getCoal());
|
|
// 计算该煤种的销售记录总数量
|
List<SalesRecord> records = coalTypeMap.getOrDefault(coalInfo.getId(), Collections.emptyList());
|
BigDecimal totalQuantity = records.stream()
|
.map(SalesRecord::getInventoryQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
|
itemListDto.setValue(totalQuantity);
|
return itemListDto;
|
}).collect(Collectors.toList());
|
|
// 计算所有煤种的销售总量
|
BigDecimal totalAll = itemListDtos.stream()
|
.map(ItemListDto::getValue)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
|
// 设置占比
|
for (ItemListDto item : itemListDtos) {
|
if (totalAll.compareTo(BigDecimal.ZERO) > 0) {
|
BigDecimal percentage = item.getValue().multiply(BigDecimal.valueOf(100))
|
.divide(totalAll, 2, RoundingMode.HALF_UP);
|
item.setPercent(percentage);
|
} else {
|
item.setPercent(BigDecimal.ZERO);
|
}
|
}
|
|
return R.ok(itemListDtos);
|
}
|
|
@Override
|
public R<List<ItemListDto>> originDistribution(DateQueryDto dto) {
|
String start = dto.getEntryDateStart();
|
String end = dto.getEntryDateEnd();
|
// 获取客户列表
|
List<Customer> coalInfoList = customerMapper.selectList(null);
|
|
// 使用 LambdaQueryWrapper 构建查询条件
|
LambdaQueryWrapper<SalesRecord> wrapper = new LambdaQueryWrapper<>();
|
|
if (start != null && !start.isEmpty() && end != null && !end.isEmpty()) {
|
wrapper.between(SalesRecord::getRegistrationDate, LocalDate.parse(start, DateTimeFormatter.ISO_LOCAL_DATE), LocalDate.parse(end, DateTimeFormatter.ISO_LOCAL_DATE));
|
}
|
List<SalesRecord> salesRecords = salesRecordMapper.selectList(wrapper);
|
// 根据煤种进行分组，并计算占比
|
Map<Long, List<SalesRecord>> coalTypeMap = salesRecords.stream()
|
.collect(Collectors.groupingBy(SalesRecord::getCustomerId));
|
|
List<ItemListDto> itemListDtos = coalInfoList.stream().map(coalInfo -> {
|
ItemListDto itemListDto = new ItemListDto();
|
itemListDto.setName(coalInfo.getCustomerName());
|
|
// 计算该煤种的销售记录总数量
|
List<SalesRecord> records = coalTypeMap.getOrDefault(coalInfo.getId(), Collections.emptyList());
|
BigDecimal totalQuantity = records.stream()
|
.map(SalesRecord::getInventoryQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
|
itemListDto.setValue(totalQuantity);
|
return itemListDto;
|
}).collect(Collectors.toList());
|
|
// 计算所有煤种的销售总量
|
BigDecimal totalAll = itemListDtos.stream()
|
.map(ItemListDto::getValue)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
|
// 设置占比
|
for (ItemListDto item : itemListDtos) {
|
if (totalAll.compareTo(BigDecimal.ZERO) > 0) {
|
BigDecimal percentage = item.getValue().multiply(BigDecimal.valueOf(100))
|
.divide(totalAll, 2, RoundingMode.HALF_UP);
|
item.setPercent(percentage);
|
} else {
|
item.setPercent(BigDecimal.ZERO);
|
}
|
}
|
|
return R.ok(itemListDtos);
|
}
|
|
@Override
|
public R<List<CarDto>> carCodeDistribution(DateQueryDto dto) {
|
String start = dto.getEntryDateStart();
|
String end = dto.getEntryDateEnd();
|
|
// 使用 LambdaQueryWrapper 构建查询条件
|
LambdaQueryWrapper<PurchaseRegistration> wrapper = new LambdaQueryWrapper<>();
|
|
if (start != null && !start.isEmpty() && end != null && !end.isEmpty()) {
|
wrapper.between(PurchaseRegistration::getRegistrationDate, LocalDate.parse(start, DateTimeFormatter.ISO_LOCAL_DATE), LocalDate.parse(end, DateTimeFormatter.ISO_LOCAL_DATE));
|
}
|
List<PurchaseRegistration> purchaseRegistrations = purchaseRegistrationMapper.selectList(wrapper);
|
// 通过车牌号分组获取次数，计算总量
|
Map<String, List<PurchaseRegistration>> carMap = purchaseRegistrations.stream()
|
.collect(Collectors.groupingBy(PurchaseRegistration::getLicensePlate));
|
List<CarDto> carDtos = carMap.entrySet().stream().map(entry -> {
|
CarDto carDto = new CarDto();
|
carDto.setCode(entry.getKey());
|
carDto.setCount(entry.getValue().size());
|
carDto.setTotal(entry.getValue().stream()
|
.map(PurchaseRegistration::getPurchaseQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add));
|
return carDto;
|
}).collect(Collectors.toList());
|
return R.ok(carDtos);
|
}
|
|
@Override
|
public R<List<PurchaseRegistration>> recentTransaction(DateQueryDto dto) {
|
String start = dto.getEntryDateStart();
|
String end = dto.getEntryDateEnd();
|
|
// 使用 LambdaQueryWrapper 构建查询条件
|
LambdaQueryWrapper<PurchaseRegistration> wrapper = new LambdaQueryWrapper<>();
|
|
if (start != null && !start.isEmpty() && end != null && !end.isEmpty()) {
|
wrapper.between(PurchaseRegistration::getRegistrationDate, LocalDate.parse(start, DateTimeFormatter.ISO_LOCAL_DATE), LocalDate.parse(end, DateTimeFormatter.ISO_LOCAL_DATE));
|
}
|
List<PurchaseRegistration> purchaseRegistrations = purchaseRegistrationMapper.selectList(wrapper);
|
purchaseRegistrations.forEach(purchaseRegistration -> {
|
purchaseRegistration.setCoalName(coalInfoMapper.selectById(purchaseRegistration.getCoalId()).getCoal());
|
});
|
return R.ok(purchaseRegistrations);
|
}
|
|
@Override
|
public R<List<ItemListDto>> heatValueDistribution(DateQueryDto dto) {
|
String start = dto.getEntryDateStart();
|
String end = dto.getEntryDateEnd();
|
LambdaQueryWrapper<OfficialInventory> officialInventoryLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
if (start != null && !start.isEmpty() && end != null && !end.isEmpty()) {
|
officialInventoryLambdaQueryWrapper.between(OfficialInventory::getRegistrationDate, LocalDate.parse(start, DateTimeFormatter.ISO_LOCAL_DATE), LocalDate.parse(end, DateTimeFormatter.ISO_LOCAL_DATE));
|
}
|
List<OfficialInventory> officialInventories = officialInventoryMapper.selectList(officialInventoryLambdaQueryWrapper);
|
Map<String, BigDecimal> heatValueMap = new HashMap<>();
|
BigDecimal totalQuantity = BigDecimal.ZERO;
|
for (OfficialInventory officialInventory : officialInventories) {
|
List<CoalValue> coalValues = coalValueMapper.selectList(new LambdaQueryWrapper<CoalValue>()
|
.eq(CoalValue::getPlanId, officialInventory.getId())
|
.eq(CoalValue::getFieldName, "发热量"));
|
if (coalValues != null && !coalValues.isEmpty()) {
|
// 根据发热量值进行分类统计
|
|
heatValueMap.put("4000以下", BigDecimal.ZERO);
|
heatValueMap.put("4000-4500", BigDecimal.ZERO);
|
heatValueMap.put("4500-5000", BigDecimal.ZERO);
|
heatValueMap.put("5000-5500", BigDecimal.ZERO);
|
heatValueMap.put("5500-6000", BigDecimal.ZERO);
|
heatValueMap.put("6000+", BigDecimal.ZERO);
|
|
for (CoalValue coalValue : coalValues) {
|
BigDecimal heatValue = BigDecimal.valueOf(Long.parseLong(coalValue.getCoalValue()));
|
if (heatValue == null) continue;
|
|
if (heatValue.compareTo(BigDecimal.valueOf(4000)) < 0) {
|
heatValueMap.put("4000以下", heatValueMap.get("4000以下").add(officialInventory.getInventoryQuantity()));
|
} else if (heatValue.compareTo(BigDecimal.valueOf(4000)) >= 0 && heatValue.compareTo(BigDecimal.valueOf(4500)) < 0) {
|
heatValueMap.put("4000-4500", heatValueMap.get("4000-4500").add(officialInventory.getInventoryQuantity()));
|
} else if (heatValue.compareTo(BigDecimal.valueOf(4500)) >= 0 && heatValue.compareTo(BigDecimal.valueOf(5000)) < 0) {
|
heatValueMap.put("4500-5000", heatValueMap.get("4500-5000").add(officialInventory.getInventoryQuantity()));
|
} else if (heatValue.compareTo(BigDecimal.valueOf(5000)) >= 0 && heatValue.compareTo(BigDecimal.valueOf(5500)) < 0) {
|
heatValueMap.put("5000-5500", heatValueMap.get("5000-5500").add(officialInventory.getInventoryQuantity()));
|
} else if (heatValue.compareTo(BigDecimal.valueOf(5500)) >= 0 && heatValue.compareTo(BigDecimal.valueOf(6000)) < 0) {
|
heatValueMap.put("5500-6000", heatValueMap.get("5500-6000").add(officialInventory.getInventoryQuantity()));
|
} else {
|
heatValueMap.put("6000+", heatValueMap.get("6000+").add(officialInventory.getInventoryQuantity()));
|
}
|
}
|
|
|
}
|
}
|
// 计算总量
|
totalQuantity = heatValueMap.values().stream().reduce(BigDecimal.ZERO, BigDecimal::add);
|
// 将结果转换为 ItemListDto 列表
|
BigDecimal finalTotalQuantity = totalQuantity;
|
List<ItemListDto> itemListDtos = heatValueMap.entrySet().stream()
|
.map(entry -> {
|
ItemListDto itemListDto = new ItemListDto();
|
itemListDto.setName(entry.getKey());
|
itemListDto.setValue(entry.getValue());
|
if (finalTotalQuantity.compareTo(BigDecimal.ZERO) > 0) {
|
BigDecimal percentage = entry.getValue().multiply(BigDecimal.valueOf(100))
|
.divide(finalTotalQuantity, 2, RoundingMode.HALF_UP);
|
itemListDto.setPercent(percentage);
|
}
|
return itemListDto;
|
})
|
.collect(Collectors.toList());
|
return R.ok(itemListDtos);
|
}
|
|
@Override
|
public R<ReportStatisticsDto> reportStatistics(DateQueryDto dto) {
|
ReportStatisticsDto reportStatisticsDto = new ReportStatisticsDto();
|
String start = dto.getEntryDateStart();
|
String end = dto.getEntryDateEnd();
|
LambdaQueryWrapper<OfficialInventory> officialInventoryLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
if (start != null && !start.isEmpty() && end != null && !end.isEmpty()) {
|
officialInventoryLambdaQueryWrapper.between(OfficialInventory::getRegistrationDate, LocalDate.parse(start, DateTimeFormatter.ISO_LOCAL_DATE), LocalDate.parse(end, DateTimeFormatter.ISO_LOCAL_DATE));
|
}
|
List<OfficialInventory> officialInventories = officialInventoryMapper.selectList(officialInventoryLambdaQueryWrapper);
|
if(!CollectionUtils.isEmpty(officialInventories)){
|
BigDecimal reduce = officialInventories.stream()
|
.map(OfficialInventory::getInventoryQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
List<CoalValue> coalValues = coalValueMapper.selectList(new LambdaQueryWrapper<CoalValue>()
|
.in(CoalValue::getPlanId, officialInventories.stream().map(OfficialInventory::getId).collect(Collectors.toList()))
|
.eq(CoalValue::getFieldName, "发热量"));
|
BigDecimal totalQuantity = coalValues.stream()
|
.map(coalValue -> BigDecimal.valueOf(Long.parseLong(coalValue.getCoalValue())))
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
|
|
long count = coalValues.stream()
|
.filter(coalValue -> BigDecimal.valueOf(Long.parseLong(coalValue.getCoalValue())).compareTo(BigDecimal.valueOf(5000)) >= 0)
|
.count();
|
|
|
if (!coalValues.isEmpty()){
|
// 单位热值耗煤量 = reduce * 1000 / totalQuantity
|
BigDecimal heatValue = reduce.multiply(BigDecimal.valueOf(1000)).divide(totalQuantity, 2, RoundingMode.HALF_UP);
|
reportStatisticsDto.setUnitHeatValue(heatValue);
|
// 平均发热量
|
reportStatisticsDto.setAverageFuel(totalQuantity.divide(BigDecimal.valueOf(coalValues.size()), 2, RoundingMode.HALF_UP));
|
// 整体达标率(发热量≥5000大卡)
|
BigDecimal wholeStandardRate = BigDecimal.valueOf(count).divide(BigDecimal.valueOf(coalValues.size()), 2, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100));
|
reportStatisticsDto.setWholeStandardRate(wholeStandardRate);
|
}else{
|
reportStatisticsDto.setAverageFuel(BigDecimal.ZERO);
|
reportStatisticsDto.setWholeStandardRate(BigDecimal.ZERO);
|
reportStatisticsDto.setUnitHeatValue(BigDecimal.ZERO);
|
}
|
}
|
return R.ok(reportStatisticsDto);
|
}
|
|
@Override
|
public R<List<ItemListDto>> reportTrend(DateQueryDto dto) {
|
List<LocalDate> lastFiveDaysQuery = getLastFiveDaysQuery();
|
List<ItemListDto> itemListDtos = new ArrayList<>();
|
for (LocalDate s : lastFiveDaysQuery) {
|
ItemListDto itemListDto = new ItemListDto();
|
itemListDto.setName(s.toString());
|
LambdaQueryWrapper<OfficialInventory> officialInventoryLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
// 在s后面拼上00:00:00
|
officialInventoryLambdaQueryWrapper.eq(OfficialInventory::getRegistrationDate, s);
|
List<OfficialInventory> officialInventories = officialInventoryMapper.selectList(officialInventoryLambdaQueryWrapper);
|
if(!CollectionUtils.isEmpty(officialInventories)){
|
List<CoalValue> coalValues = coalValueMapper.selectList(new LambdaQueryWrapper<CoalValue>()
|
.in(CoalValue::getPlanId, officialInventories.stream().map(OfficialInventory::getId).collect(Collectors.toList()))
|
.eq(CoalValue::getFieldName, "发热量"));
|
// 整体达标率(发热量≥5000大卡)
|
long count = coalValues.stream()
|
.filter(coalValue -> BigDecimal.valueOf(Long.parseLong(coalValue.getCoalValue())).compareTo(BigDecimal.valueOf(5000)) >= 0)
|
.count();
|
// 判断除数不能为零的情况
|
if (!coalValues.isEmpty()) {
|
BigDecimal wholeStandardRate = BigDecimal.valueOf(count).divide(BigDecimal.valueOf(coalValues.size()), 2, RoundingMode.HALF_UP);
|
itemListDto.setValue(wholeStandardRate);
|
}else{
|
itemListDto.setValue(BigDecimal.ZERO);
|
}
|
|
}
|
itemListDtos.add(itemListDto);
|
}
|
return R.ok(itemListDtos);
|
}
|
|
@Override
|
public R<List<ItemListDto>> coalTypeHeatValueComparison(DateQueryDto dto) {
|
List<LocalDate> lastFiveDaysQuery = getLastFiveDaysQuery();
|
List<ItemListDto> itemListDtos = new ArrayList<>();
|
for (LocalDate s : lastFiveDaysQuery) {
|
ItemListDto itemListDto = new ItemListDto();
|
itemListDto.setName(s.toString());
|
LambdaQueryWrapper<OfficialInventory> officialInventoryLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
// 在s后面拼上00:00:00
|
officialInventoryLambdaQueryWrapper.eq(OfficialInventory::getRegistrationDate, s);
|
List<OfficialInventory> officialInventories = officialInventoryMapper.selectList(officialInventoryLambdaQueryWrapper);
|
if(!CollectionUtils.isEmpty(officialInventories)){
|
List<CoalValue> coalValues = coalValueMapper.selectList(new LambdaQueryWrapper<CoalValue>()
|
.in(CoalValue::getPlanId, officialInventories.stream().map(OfficialInventory::getId).collect(Collectors.toList()))
|
.eq(CoalValue::getFieldName, "发热量"));
|
// 发热量(求和)
|
long count = coalValues.stream()
|
.mapToLong(coalValue -> Long.parseLong(coalValue.getCoalValue()))
|
.sum();
|
itemListDto.setValue(BigDecimal.valueOf(count));
|
}
|
itemListDtos.add(itemListDto);
|
}
|
return R.ok(itemListDtos);
|
}
|
|
@Override
|
public R<List<ItemListDto>> processingRateAnalysis(DateQueryDto dto) {
|
List<LocalDate> lastFiveDaysQuery = getLastFiveDaysQuery();
|
List<ItemListDto> itemListDtos = new ArrayList<>();
|
for (LocalDate s : lastFiveDaysQuery) {
|
ItemListDto itemListDto = new ItemListDto();
|
itemListDto.setName(s.toString());
|
// 获取采购数量
|
LambdaQueryWrapper<PurchaseRegistration> purchaseRegistrationLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
// 在s后面拼上00:00:00
|
purchaseRegistrationLambdaQueryWrapper.eq(PurchaseRegistration::getRegistrationDate, s);
|
List<PurchaseRegistration> purchaseRegistrations = purchaseRegistrationMapper.selectList(purchaseRegistrationLambdaQueryWrapper);
|
if(!CollectionUtils.isEmpty(purchaseRegistrations)){
|
BigDecimal totalQuantity = purchaseRegistrations.stream()
|
.map(PurchaseRegistration::getPurchaseQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
// 获取正式库存数量
|
LambdaQueryWrapper<OfficialInventory> officialInventoryLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
// 在s后面拼上00:00:00
|
officialInventoryLambdaQueryWrapper.eq(OfficialInventory::getRegistrationDate, s);
|
List<OfficialInventory> officialInventories = officialInventoryMapper.selectList(officialInventoryLambdaQueryWrapper);
|
if(!CollectionUtils.isEmpty(officialInventories)){
|
BigDecimal officialInventoryQuantity = officialInventories.stream()
|
.map(OfficialInventory::getInventoryQuantity)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
// 加工得率 = 正式库存数量/采购数量
|
if(!totalQuantity.equals(BigDecimal.ZERO)){
|
itemListDto.setValue(officialInventoryQuantity.divide(totalQuantity, 2, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100)));
|
}else{
|
itemListDto.setValue(BigDecimal.ZERO);
|
}
|
}
|
}
|
itemListDtos.add(itemListDto);
|
}
|
return R.ok(itemListDtos);
|
}
|
|
@Override
|
public R<List<ItemListDto>> costStructure(DateQueryDto dto) {
|
List<ItemListDto> itemListDtos = new ArrayList<>();
|
LocalDate now = LocalDate.now();
|
LocalDate startDate = now.minusDays(4);
|
LambdaQueryWrapper<Production> productionLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
productionLambdaQueryWrapper.between(Production::getCreateTime, startDate, now);
|
List<Production> productions = productionMapper.selectList(productionLambdaQueryWrapper);
|
ItemListDto itemListDto = new ItemListDto();
|
itemListDto.setName("人工成本");
|
itemListDto.setValue(productions.stream()
|
.map(Production::getLaborCost)
|
.reduce(BigDecimal.ZERO, BigDecimal::add));
|
itemListDtos.add(itemListDto);
|
ItemListDto itemListDtoOne = new ItemListDto();
|
itemListDtoOne.setName("能耗成本");
|
itemListDtoOne.setValue(productions.stream()
|
.map(Production::getEnergyConsumptionCost)
|
.reduce(BigDecimal.ZERO, BigDecimal::add));
|
itemListDtos.add(itemListDtoOne);
|
return R.ok(itemListDtos);
|
}
|
|
/**
|
* 获取最近五天的时间集合
|
*/
|
private List<LocalDate> getLastFiveDaysQuery() {
|
LocalDate now = LocalDate.now();
|
LocalDate startDate = now.minusDays(4);
|
List<LocalDate> dates = new ArrayList<>();
|
for (int i = 0; i < 5; i++) {
|
LocalDate date = startDate.plusDays(i);
|
dates.add(date);
|
}
|
return dates;
|
}
|
}
|
