package com.ruoyi.production.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.ruoyi.basic.mapper.ProductMapper;
|
import com.ruoyi.basic.mapper.ProductModelMapper;
|
import com.ruoyi.basic.mapper.SupplierManageMapper;
|
import com.ruoyi.basic.pojo.Product;
|
import com.ruoyi.basic.pojo.ProductModel;
|
import com.ruoyi.basic.pojo.SupplierManage;
|
import com.ruoyi.home.dto.processDataProductionStatisticsDto;
|
import com.ruoyi.production.dto.ProductionStatisticDto;
|
import com.ruoyi.production.mapper.ProductProcessMapper;
|
import com.ruoyi.production.mapper.ProductWorkOrderMapper;
|
import com.ruoyi.production.mapper.ProductionProductInputMapper;
|
import com.ruoyi.production.mapper.ProductionProductOutputMapper;
|
import com.ruoyi.production.pojo.ProductProcess;
|
import com.ruoyi.production.pojo.ProductWorkOrder;
|
import com.ruoyi.production.pojo.ProductionProductInput;
|
import com.ruoyi.production.pojo.ProductionProductOutput;
|
import com.ruoyi.production.service.ProductionStatisticService;
|
import com.ruoyi.quality.mapper.QualityInspectMapper;
|
import com.ruoyi.quality.pojo.QualityInspect;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.LocalTime;
|
import java.time.YearMonth;
|
import java.time.ZoneId;
|
import java.util.Date;
|
import java.util.Set;
|
import java.util.TreeSet;
|
import java.time.temporal.TemporalAdjusters;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* 生产统计服务实现类
|
*/
|
@Service
|
public class ProductionStatisticServiceImpl implements ProductionStatisticService {
|
|
@Autowired
|
private ProductProcessMapper productProcessMapper;
|
|
@Autowired
|
private ProductWorkOrderMapper productWorkOrderMapper;
|
|
@Autowired
|
private ProductionProductOutputMapper productionProductOutputMapper;
|
|
@Autowired
|
private ProductionProductInputMapper productionProductInputMapper;
|
|
@Autowired
|
private QualityInspectMapper qualityInspectMapper;
|
|
@Autowired
|
private SupplierManageMapper supplierManageMapper;
|
|
@Autowired
|
private ProductModelMapper productModelMapper;
|
|
@Autowired
|
private ProductMapper productMapper;
|
|
@Override
|
public ProductionStatisticDto getWorkOrderCount() {
|
ProductionStatisticDto dto = new ProductionStatisticDto();
|
|
// 查询工单总数
|
Long totalCount = productWorkOrderMapper.selectCount(null);
|
dto.setTotalCount(totalCount);
|
|
// 查询进行中工单（完成数量小于需求数量）
|
Long inProgressCount = productWorkOrderMapper.selectCount(
|
new LambdaQueryWrapper<ProductWorkOrder>()
|
.apply("complete_quantity < plan_quantity and complete_quantity > 0")
|
);
|
dto.setInProgressCount(inProgressCount);
|
|
// 查询已完成工单（完成数量大于等于需求数量）
|
Long completedCount = productWorkOrderMapper.selectCount(
|
new LambdaQueryWrapper<ProductWorkOrder>()
|
.apply("complete_quantity >= plan_quantity and complete_quantity > 0")
|
);
|
dto.setCompletedCount(completedCount);
|
|
// 查询待完成工单（完成数量为0）
|
Long pendingCount = productWorkOrderMapper.selectCount(
|
new LambdaQueryWrapper<ProductWorkOrder>()
|
.eq(ProductWorkOrder::getCompleteQuantity, 0)
|
);
|
dto.setPendingCount(pendingCount);
|
|
return dto;
|
}
|
|
@Override
|
public Map<String, Object> getQualityStatistics() {
|
Map<String, Object> result = new HashMap<>();
|
|
// 查询所有报工记录
|
List<ProductionProductOutput> outputList = productionProductOutputMapper.selectList(null);
|
|
// 计算报工总数、报废总数和不良总数
|
BigDecimal totalOutput = BigDecimal.ZERO;
|
BigDecimal totalScrap = BigDecimal.ZERO;
|
BigDecimal totalDefect = BigDecimal.ZERO;
|
|
for (ProductionProductOutput output : outputList) {
|
// 报工总数
|
if (output.getQuantity() != null) {
|
totalOutput = totalOutput.add(output.getQuantity());
|
}
|
// 报废数量
|
if (output.getScrapQty() != null) {
|
totalScrap = totalScrap.add(output.getScrapQty());
|
}
|
// 不良数量（从QualityInspect表查询）
|
List<QualityInspect> qualityInspects = qualityInspectMapper.selectList(
|
new LambdaQueryWrapper<QualityInspect>()
|
.eq(QualityInspect::getProductMainId, output.getProductMainId())
|
);
|
for (QualityInspect inspect : qualityInspects) {
|
if (inspect.getDefectiveQuantity() != null) {
|
totalDefect = totalDefect.add(inspect.getDefectiveQuantity());
|
}
|
}
|
}
|
|
// 计算合格数量
|
BigDecimal qualifiedQuantity = totalOutput.subtract(totalScrap).subtract(totalDefect);
|
|
// 计算合格率和不良率
|
double qualifiedRate = 0.0;
|
double defectRate = 0.0;
|
if (totalOutput.compareTo(BigDecimal.ZERO) > 0) {
|
// 使用BigDecimal确保精度
|
BigDecimal qualifiedRateBD = qualifiedQuantity.divide(totalOutput, 4, BigDecimal.ROUND_HALF_UP).multiply(new BigDecimal(100));
|
BigDecimal defectRateBD = totalDefect.divide(totalOutput, 4, BigDecimal.ROUND_HALF_UP).multiply(new BigDecimal(100));
|
// 保留两位小数
|
qualifiedRate = qualifiedRateBD.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
|
defectRate = defectRateBD.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
|
}
|
|
result.put("qualifiedRate", qualifiedRate); // 合格率
|
result.put("defectRate", defectRate); // 不良率
|
result.put("scrapCount", totalScrap.intValue()); // 报废总数
|
|
return result;
|
}
|
|
@Override
|
public Map<String, Object> getProductionStatistics() {
|
Map<String, Object> result = new HashMap<>();
|
|
// 获取当前月份和上一个月份的开始和结束时间
|
LocalDateTime now = LocalDateTime.now();
|
YearMonth currentMonth = YearMonth.from(now);
|
LocalDateTime currentMonthStart = now.with(TemporalAdjusters.firstDayOfMonth()).with(LocalTime.MIN);
|
LocalDateTime currentMonthEnd = currentMonth.atEndOfMonth().atTime(23, 59, 59);
|
LocalDateTime lastMonth = now.minusMonths(1);
|
LocalDateTime lastMonthStart = lastMonth.with(TemporalAdjusters.firstDayOfMonth()).with(LocalTime.MIN);
|
LocalDateTime lastMonthEnd = currentMonthStart.minusDays(1).withHour(23).withMinute(59).withSecond(59);
|
|
// 计算生产总产出（当前月）
|
List<ProductionProductOutput> currentOutputList = productionProductOutputMapper.selectList(
|
new LambdaQueryWrapper<ProductionProductOutput>()
|
.ge(ProductionProductOutput::getCreateTime, currentMonthStart)
|
.le(ProductionProductOutput::getCreateTime, currentMonthEnd)
|
);
|
BigDecimal currentProductionOutput = BigDecimal.ZERO;
|
for (ProductionProductOutput output : currentOutputList) {
|
if (output.getQuantity() != null) {
|
currentProductionOutput = currentProductionOutput.add(output.getQuantity());
|
}
|
}
|
|
// 计算生产总产出（上月）
|
List<ProductionProductOutput> lastOutputList = productionProductOutputMapper.selectList(
|
new LambdaQueryWrapper<ProductionProductOutput>()
|
.ge(ProductionProductOutput::getCreateTime, lastMonthStart)
|
.le(ProductionProductOutput::getCreateTime, lastMonthEnd)
|
);
|
BigDecimal lastProductionOutput = BigDecimal.ZERO;
|
for (ProductionProductOutput output : lastOutputList) {
|
if (output.getQuantity() != null) {
|
lastProductionOutput = lastProductionOutput.add(output.getQuantity());
|
}
|
}
|
|
// 计算生产总消耗（当前月）
|
List<ProductionProductInput> currentInputList = productionProductInputMapper.selectList(
|
new LambdaQueryWrapper<ProductionProductInput>()
|
.ge(ProductionProductInput::getCreateTime, currentMonthStart)
|
.le(ProductionProductInput::getCreateTime, currentMonthEnd)
|
);
|
BigDecimal currentProductionConsumption = BigDecimal.ZERO;
|
for (ProductionProductInput input : currentInputList) {
|
if (input.getQuantity() != null) {
|
currentProductionConsumption = currentProductionConsumption.add(input.getQuantity());
|
}
|
}
|
|
// 计算生产总消耗（上月）
|
List<ProductionProductInput> lastInputList = productionProductInputMapper.selectList(
|
new LambdaQueryWrapper<ProductionProductInput>()
|
.ge(ProductionProductInput::getCreateTime, lastMonthStart)
|
.le(ProductionProductInput::getCreateTime, lastMonthEnd)
|
);
|
BigDecimal lastProductionConsumption = BigDecimal.ZERO;
|
for (ProductionProductInput input : lastInputList) {
|
if (input.getQuantity() != null) {
|
lastProductionConsumption = lastProductionConsumption.add(input.getQuantity());
|
}
|
}
|
|
// 计算供应商数量（当前月）
|
List<SupplierManage> currentSuppliers = supplierManageMapper.selectList(
|
new LambdaQueryWrapper<SupplierManage>()
|
.ge(SupplierManage::getCreateTime, currentMonthStart)
|
.le(SupplierManage::getCreateTime, currentMonthEnd)
|
);
|
int currentSupplierCount = currentSuppliers != null ? currentSuppliers.size() : 0;
|
|
// 计算供应商数量（上月）
|
List<SupplierManage> lastSuppliers = supplierManageMapper.selectList(
|
new LambdaQueryWrapper<SupplierManage>()
|
.ge(SupplierManage::getCreateTime, lastMonthStart)
|
.le(SupplierManage::getCreateTime, lastMonthEnd)
|
);
|
int lastSupplierCount = lastSuppliers != null ? lastSuppliers.size() : 0;
|
|
// 计算趋势
|
double productionOutputMonthlyChange = 0.0;
|
if (lastProductionOutput.compareTo(BigDecimal.ZERO) > 0) {
|
productionOutputMonthlyChange = (currentProductionOutput.subtract(lastProductionOutput)
|
.divide(lastProductionOutput, 4, BigDecimal.ROUND_HALF_UP).doubleValue()) * 100;
|
}
|
|
double productionConsumptionMonthlyChange = 0.0;
|
if (lastProductionConsumption.compareTo(BigDecimal.ZERO) > 0) {
|
productionConsumptionMonthlyChange = (currentProductionConsumption.subtract(lastProductionConsumption)
|
.divide(lastProductionConsumption, 4, BigDecimal.ROUND_HALF_UP).doubleValue()) * 100;
|
}
|
|
double supplierCountMonthlyChange = 0.0;
|
if (lastSupplierCount > 0) {
|
supplierCountMonthlyChange = ((currentSupplierCount - lastSupplierCount) * 100.0) / lastSupplierCount;
|
}
|
|
result.put("productionOutput", currentProductionOutput.doubleValue()); // 生产总产
|
result.put("productionConsumption", currentProductionConsumption.doubleValue()); // 生产总消耗
|
result.put("productionOutputMonthlyChange", productionOutputMonthlyChange); // 生产总产月度变化
|
result.put("productionConsumptionMonthlyChange", productionConsumptionMonthlyChange); // 生产总消耗月度变化
|
result.put("supplierCount", currentSupplierCount); // 产品总供应公司
|
result.put("supplierCountMonthlyChange", supplierCountMonthlyChange); // 供应商数量月度变化
|
|
return result;
|
}
|
|
@Override
|
public List<Map<String, Object>> getProductOutputCategoryPieData() {
|
List<Map<String, Object>> result = new ArrayList<>();
|
// 按产品大类
|
// 查询所有报工记录
|
List<ProductionProductOutput> outputList = productionProductOutputMapper.selectList(null);
|
|
// 按产品分组计算产出数量
|
Map<Long, BigDecimal> productOutputMap = new HashMap<>();
|
|
for (ProductionProductOutput output : outputList) {
|
if (output.getProductModelId() != null && output.getQuantity() != null) {
|
// 根据productModelId查询ProductModel
|
ProductModel productModel = productModelMapper.selectById(output.getProductModelId());
|
if (productModel != null && productModel.getProductId() != null) {
|
// 根据productId查询Product
|
Product product = productMapper.selectById(productModel.getProductId());
|
if (product != null) {
|
// 按产品ID分组计算产出数量
|
productOutputMap.put(product.getId(),
|
productOutputMap.getOrDefault(product.getId(), BigDecimal.ZERO).add(output.getQuantity()));
|
}
|
}
|
}
|
}
|
|
// 转换为结果格式
|
for (Map.Entry<Long, BigDecimal> entry : productOutputMap.entrySet()) {
|
Product product = productMapper.selectById(entry.getKey());
|
if (product != null) {
|
Map<String, Object> item = new HashMap<>();
|
item.put("name", product.getProductName());
|
item.put("value", entry.getValue().intValue());
|
result.add(item);
|
}
|
}
|
|
return result;
|
}
|
|
@Override
|
public List<Map<String, Object>> getDefectReasonAnalysis() {
|
List<Map<String, Object>> result = new ArrayList<>();
|
|
// 查询所有质量检验记录
|
List<QualityInspect> qualityInspectList = qualityInspectMapper.selectList(null);
|
|
// 按不良原因分组统计数量
|
Map<String, Integer> reasonCountMap = new HashMap<>();
|
|
for (QualityInspect inspect : qualityInspectList) {
|
if (inspect.getDefectiveReason() != null && !inspect.getDefectiveReason().isEmpty()) {
|
String reason = inspect.getDefectiveReason();
|
reasonCountMap.put(reason, reasonCountMap.getOrDefault(reason, 0) + 1);
|
}
|
}
|
|
// 转换为结果格式
|
for (Map.Entry<String, Integer> entry : reasonCountMap.entrySet()) {
|
Map<String, Object> item = new HashMap<>();
|
item.put("name", entry.getKey());
|
item.put("value", entry.getValue());
|
result.add(item);
|
}
|
|
return result;
|
}
|
|
@Override
|
public List<Map<String, Object>> getProcessDefectRateAnalysis(String startDate, String endDate) {
|
List<Map<String, Object>> result = new ArrayList<>();
|
|
// 默认查询近一个月数据
|
if (startDate == null || endDate == null) {
|
LocalDate now = LocalDate.now();
|
startDate = now.minusMonths(1).toString();
|
endDate = now.toString();
|
}
|
|
// 解析日期
|
LocalDate startLocalDate = LocalDate.parse(startDate);
|
LocalDate endLocalDate = LocalDate.parse(endDate);
|
Date start = Date.from(startLocalDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
|
Date end = Date.from(endLocalDate.plusDays(1).atStartOfDay(ZoneId.systemDefault()).toInstant());
|
|
// 查询所有工序
|
List<ProductProcess> processList = productProcessMapper.selectList(null);
|
|
// 收集所有日期
|
Set<LocalDate> dateSet = new TreeSet<>();
|
LocalDate currentDate = startLocalDate;
|
while (!currentDate.isAfter(endLocalDate)) {
|
dateSet.add(currentDate);
|
currentDate = currentDate.plusDays(1);
|
}
|
|
// 一次性查询所有日期范围内的质量检验记录
|
List<QualityInspect> allQualityInspects = qualityInspectMapper.selectList(
|
new LambdaQueryWrapper<QualityInspect>()
|
.ge(QualityInspect::getCheckTime, start)
|
.lt(QualityInspect::getCheckTime, end)
|
);
|
|
// 按日期和工序分组处理数据
|
Map<LocalDate, Map<String, BigDecimal[]>> dateProcessMap = new HashMap<>();
|
|
for (QualityInspect inspect : allQualityInspects) {
|
if (inspect.getCheckTime() != null && inspect.getProcess() != null) {
|
// 转换检查时间为LocalDate
|
LocalDate inspectDate = inspect.getCheckTime().toInstant()
|
.atZone(ZoneId.systemDefault()).toLocalDate();
|
|
// 确保日期在查询范围内
|
if (dateSet.contains(inspectDate)) {
|
String processName = inspect.getProcess();
|
|
// 初始化日期和工序数据
|
dateProcessMap.computeIfAbsent(inspectDate, k -> new HashMap<>());
|
BigDecimal[] quantities = dateProcessMap.get(inspectDate)
|
.computeIfAbsent(processName, k -> new BigDecimal[]{BigDecimal.ZERO, BigDecimal.ZERO});
|
|
// 累加数量
|
if (inspect.getQuantity() != null) {
|
quantities[0] = quantities[0].add(inspect.getQuantity());
|
}
|
if (inspect.getDefectiveQuantity() != null) {
|
quantities[1] = quantities[1].add(inspect.getDefectiveQuantity());
|
}
|
}
|
}
|
}
|
|
// 构建结果数据
|
for (LocalDate date : dateSet) {
|
Map<String, Object> item = new HashMap<>();
|
item.put("date", date.toString());
|
|
// 初始化每日总数量和不良数量
|
BigDecimal dailyTotalQuantity = BigDecimal.ZERO;
|
BigDecimal dailyDefectiveQuantity = BigDecimal.ZERO;
|
|
// 初始化工序数据列表
|
List<Map<String, Object>> processesList = new ArrayList<>();
|
|
// 获取该日期的工序数据
|
Map<String, BigDecimal[]> processData = dateProcessMap.getOrDefault(date, new HashMap<>());
|
|
for (ProductProcess process : processList) {
|
if (process.getName() != null) {
|
String processName = process.getName();
|
BigDecimal[] quantities = processData.getOrDefault(processName, new BigDecimal[]{BigDecimal.ZERO, BigDecimal.ZERO});
|
|
BigDecimal processTotalQuantity = quantities[0];
|
BigDecimal processDefectiveQuantity = quantities[1];
|
|
// 累加每日总数量
|
dailyTotalQuantity = dailyTotalQuantity.add(processTotalQuantity);
|
dailyDefectiveQuantity = dailyDefectiveQuantity.add(processDefectiveQuantity);
|
|
// 计算该工序的不良率
|
double processDefectRate = 0.0;
|
if (processTotalQuantity.compareTo(BigDecimal.ZERO) > 0) {
|
// 计算不良率，保留两位小数
|
BigDecimal defectRateDecimal = processDefectiveQuantity.divide(processTotalQuantity, 4, BigDecimal.ROUND_HALF_UP).multiply(new BigDecimal(100));
|
processDefectRate = defectRateDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
|
}
|
|
// 构建工序数据对象
|
Map<String, Object> processMap = new HashMap<>();
|
processMap.put(process.getName(), processDefectRate);
|
processesList.add(processMap);
|
}
|
}
|
|
// 计算每日平均不良率
|
double dailyAverageDefectRate = 0.0;
|
if (dailyTotalQuantity.compareTo(BigDecimal.ZERO) > 0) {
|
// 计算不良率，保留两位小数
|
BigDecimal defectRateDecimal = dailyDefectiveQuantity.divide(dailyTotalQuantity, 4, BigDecimal.ROUND_HALF_UP).multiply(new BigDecimal(100));
|
dailyAverageDefectRate = defectRateDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
|
}
|
|
// 添加平均不良率和工序数据到结果项
|
item.put("averageDefectRate", dailyAverageDefectRate);
|
item.put("processes", processesList);
|
|
result.add(item);
|
}
|
|
return result;
|
}
|
}
|
