|
package com.by4cloud.platform.processing.service.impl;
|
|
import cn.hutool.json.JSONObject;
|
import com.alibaba.excel.util.CollectionUtils;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.by4cloud.platform.common.core.util.R;
|
import com.by4cloud.platform.processing.entity.*;
|
import com.by4cloud.platform.processing.mapper.PlanMapper;
|
import com.by4cloud.platform.processing.service.PlanService;
|
import com.by4cloud.platform.yunxiao.api.feign.RemoteMaxSize;
|
import com.by4cloud.platform.yunxiao.api.feign.RemotePonderation;
|
import com.by4cloud.platform.yunxiao.constant.MaxSizeContant;
|
import com.by4cloud.platform.yunxiao.entity.ContractOrder;
|
import com.by4cloud.platform.yunxiao.entity.Ponderation;
|
import com.by4cloud.platform.yunxiao.utils.NumUtils;
|
import lombok.AllArgsConstructor;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.text.DateFormat;
|
import java.text.ParseException;
|
import java.time.*;
|
import java.time.format.DateTimeFormatter;
|
import java.time.format.DateTimeParseException;
|
import java.time.temporal.ChronoUnit;
|
import java.time.temporal.TemporalAdjusters;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import static com.by4cloud.platform.yunxiao.utils.AvgTimeUtils.isValidDateTimeWithDateTimeFormatter;
|
|
/**
|
* 计划表
|
*
|
* @author zzl
|
* @date 2025-10-17 09:47:25
|
*/
|
@Service
|
@AllArgsConstructor
|
public class PlanServiceImpl extends ServiceImpl<PlanMapper, Plan> implements PlanService {
|
|
RemotePonderation remotePonderation;
|
|
RemoteMaxSize remoteMaxSize;
|
|
@Override
|
public void insertPonderation(Plan plan) {
|
|
//可用车辆
|
Map<String,CarAvgTare> usableCar = new HashMap<>();
|
CustomerUseCar customerUseCar = new CustomerUseCar();
|
|
//车辆平均重量
|
List<CarAvgTare> carAvgTares = new ArrayList<>();
|
|
//历史服务过的包含车辆的才可用
|
carAvgTares.forEach(e -> {
|
if (customerUseCar.getUseCars().contains(e.getVehicleNo())){
|
usableCar.put(e.getVehicleNo(),e);
|
}
|
});
|
|
|
}
|
|
/**
|
* 按每日目标湿煤量循环生成磅单
|
* @param plan 调整计划（含总干煤量）
|
* @param contractShui 合同水分（%，如8d）
|
* @param customerUseCars 客户历史车辆
|
* @param carAvgTares 车辆皮重数据
|
* @param loadTimes 装载时间数据
|
* @param transitTimes 运输时间数据
|
* @param
|
* @return 生成的磅单列表
|
*/
|
public List<Ponderation> generateByDailyTarget(Plan plan,
|
Double contractShui,
|
List<String> customerUseCars,
|
List<CarAvgTare> carAvgTares,
|
List<LoadUnloadAvgTime> loadTimes,
|
List<TransitAvgSch> transitTimes,
|
List<LocalDate> validDates) {
|
|
// 基础参数初始化
|
LocalDate planMonth = convertToLocalDate(plan.getMonth());
|
// List<LocalDate> validDates = getAllDatesOfMonth(planMonth);
|
// if (holidays != null) validDates.removeAll(holidays);
|
int validDays = validDates.size();
|
double totalDryTarget = plan.getQuantity(); // 总干煤目标
|
double dailyDryTarget = NumUtils.divideDouble(totalDryTarget,(double)validDays,3); // 每日干煤目标
|
|
// 筛选可用车辆和基础时间数据
|
Map<String, CarAvgTare> usableCars = filterUsableCars(carAvgTares, customerUseCars);
|
TransitAvgSch transitTime = getTransitTime(plan, transitTimes);
|
LoadUnloadAvgTime loadTime = getLoadTime(plan, loadTimes);
|
|
// 按日循环生成
|
List<Ponderation> allPonderations = new ArrayList<>();
|
Random random = new Random();
|
double totalWetAccumulated = 0.0; // 总湿煤累计
|
Map<String,List<Ponderation>> ponderations = new HashMap<>();
|
for (LocalDate date : validDates) {
|
System.out.println("===== 处理日期：" + date + " =====");
|
ZonedDateTime utcZonedDateTime = date.atStartOfDay(ZoneId.of("UTC"));
|
Date utcDate = Date.from(utcZonedDateTime.toInstant());
|
// 计算当日湿煤目标
|
R<JSONObject> r = remotePonderation.getDayCheck(plan.getFyCompId(),plan.getCoalId(),plan.getCustomerId(),utcDate);
|
JSONObject object = r.getData();
|
Double realShui = 0d;
|
if(object == null) continue;
|
realShui = (Double) object.get("mt");
|
Integer checkId = (Integer) object.get("checkId");
|
if (realShui == null) continue;
|
double dailyWetTarget = calculateDailyWetTarget(dailyDryTarget, realShui, contractShui); // 当日湿煤目标
|
System.out.println("当日干煤目标：" + dailyDryTarget + "吨，实际水分：" + realShui + "%，湿煤目标：" + dailyWetTarget + "吨");
|
|
|
// 当日磅单生成
|
List<Ponderation> dailyPds = new ArrayList<>();
|
double dailyWetAccumulated = 0.0; // 当日湿煤累计
|
Map<String, LocalDateTime> vehicleLastOutTime = new HashMap<>(); // 车辆当日最后出场时间
|
|
while (dailyWetAccumulated < dailyWetTarget) {
|
// 随机选择车辆
|
String vehicleNo = selectRandomVehicle(usableCars, random);
|
List<Ponderation> dayPonderations = ponderations.get(vehicleNo);
|
if (dayPonderations == null){
|
R<List<Ponderation>> p = remotePonderation.getPonderationByDay(utcDate,plan.getFyCompId(),plan.getFiledId(),vehicleNo);
|
if (p.getCode() == 0){
|
ponderations.put(vehicleNo,p.getData());
|
}else {
|
ponderations.put(vehicleNo,new ArrayList<>());
|
}
|
}
|
CarAvgTare car = usableCars.get(vehicleNo);
|
String dateKey = vehicleNo + date;
|
|
// 3.2.2 计算入场/出场时间
|
LocalDateTime[] times = getTimes(ponderations.get(vehicleNo),date,vehicleNo,loadTime.getAvgTime(), transitTime.getAvgTime(),random);
|
if (times == null) continue;
|
LocalDateTime inTime = times[0].withSecond(random.nextInt(60));
|
LocalDateTime outTime = times[1].withSecond(random.nextInt(60));
|
R<JSONObject> times1 = remotePonderation.verifyTimes(inTime,outTime,plan.getFiledId(),plan.getFyCompId());
|
String firstMan = null;
|
String secondMan = null;
|
if (times1.getCode()==0){
|
JSONObject object1 = times1.getData();
|
if (object1 == null)continue;
|
String time1 = object1.get("inTime").toString();
|
String time2 = object1.get("outTime").toString();
|
inTime = stringToLocalDateTime(time1);
|
outTime = stringToLocalDateTime(time2);
|
firstMan = object1.get("firstMan").toString();
|
secondMan = object1.get("secondMan").toString();
|
}
|
// 生成单车载湿煤量
|
double tare = generateTare(car, random); // 皮重
|
double wetNet = generateWetNet(tare, random); // 湿煤净重
|
double gross = NumUtils.addDouble(tare,wetNet); // 毛重
|
|
// 3.2.4 构建磅单
|
Ponderation pd = buildPonderation(plan, vehicleNo, inTime, outTime, tare, gross, wetNet,firstMan,secondMan,checkId);
|
ponderations.get(vehicleNo).add(pd);
|
dailyPds.add(pd);
|
|
// 3.2.5 更新累计
|
dailyWetAccumulated = NumUtils.addDouble(dailyWetAccumulated,wetNet,2);
|
vehicleLastOutTime.put(dateKey, outTime);
|
|
//检查是否接近目标
|
if (dailyWetAccumulated >= dailyWetTarget - 2) {
|
break;
|
}
|
}
|
|
// 调整当日最后一车
|
// adjustLastPonderation(dailyPds, dailyWetAccumulated, dailyWetTarget, realShui);
|
|
// 汇总当日数据
|
allPonderations.addAll(dailyPds);
|
totalWetAccumulated = NumUtils.addDouble(totalWetAccumulated,dailyWetTarget,2); // 按目标值累计
|
System.out.println("当日生成磅单：" + dailyPds.size() + "条，实际湿煤量：" + dailyWetTarget + "吨\n");
|
}
|
|
// 校验总湿煤量
|
double totalDryActual = NumUtils.accurateDouble(totalWetAccumulated * (100 - contractShui) / 100,2); // 按合同水分反算总干煤
|
// System.out.println("总干煤目标：" + totalDryTarget + "吨，实际总干煤：" + totalDryActual + "吨");
|
|
return allPonderations;
|
}
|
|
|
// 核心工具方法：计算当日湿煤目标
|
private double calculateDailyWetTarget(double dailyDryTarget, double realShui, double contractShui) {
|
// 湿煤目标 = 干煤目标 × (100 - 合同水分) / (100 - 实际水分)
|
if (realShui <= contractShui) return dailyDryTarget;
|
return NumUtils.accurateDouble(dailyDryTarget * (100 - contractShui) / (100 - realShui), 2);
|
}
|
|
|
// 工具方法：调整当日最后一车重量，确保累计达标
|
private void adjustLastPonderation(List<Ponderation> dailyPds, double currentTotal, double target, double realShui) {
|
if (dailyPds.isEmpty()) return;
|
|
double diff = target - currentTotal;
|
if (Math.abs(diff) <= 0.001) return; // 已达标
|
|
// 调整最后一车的湿净重和毛重
|
Ponderation last = dailyPds.get(dailyPds.size() - 1);
|
double newWetNet = last.getExecutive() + diff;
|
last.setExecutive(NumUtils.accurateDouble(newWetNet, 3)); // 湿净重
|
last.setSecWeight(NumUtils.accurateDouble(last.getFirWeight() + newWetNet, 3)); // 毛重
|
// 更新备注（记录调整信息）
|
last.setRemark(last.getRemark() + "，调整量：" + NumUtils.accurateDouble(diff, 3) + "吨（确保当日达标）");
|
}
|
|
|
// 以下为辅助方法（与之前逻辑一致，确保完整性）
|
private LocalDate convertToLocalDate(Date date) {
|
return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
}
|
|
// private List<LocalDate> getAllDatesOfMonth(LocalDate month) {
|
//
|
// return dates;
|
// }
|
|
private Map<String, CarAvgTare> filterUsableCars(List<CarAvgTare> carAvgTares, List<String> customerUseCars) {
|
List<String> cars = carAvgTares.stream().map(e -> e.getVehicleNo()).collect(Collectors.toList());
|
return carAvgTares.stream()
|
.filter(car -> customerUseCars.contains(car.getVehicleNo()))
|
.collect(Collectors.toMap(CarAvgTare::getVehicleNo, car -> car));
|
}
|
|
private TransitAvgSch getTransitTime(Plan plan, List<TransitAvgSch> transitTimes) {
|
return transitTimes.stream()
|
.filter(t -> t.getFyCompId().equals(plan.getFyCompId())
|
&& t.getCustomerAddressId().equals(plan.getCustomerAddressId())
|
&& t.getTransitType().equals(1))
|
.findFirst()
|
.orElseThrow(() -> new RuntimeException("未找到匹配的运输时间数据"));
|
}
|
|
private LoadUnloadAvgTime getLoadTime(Plan plan, List<LoadUnloadAvgTime> loadTimes) {
|
return loadTimes.stream()
|
.filter(l -> l.getCoalId().equals(plan.getCoalId()))
|
.findFirst()
|
.orElseThrow(() -> new RuntimeException("未找到匹配的装载时间数据"));
|
}
|
|
private String selectRandomVehicle(Map<String, CarAvgTare> usableCars, Random random) {
|
List<String> vehicleNos = new ArrayList<>(usableCars.keySet());
|
return vehicleNos.get(random.nextInt(vehicleNos.size()));
|
}
|
|
//入场时间计算
|
private LocalDateTime calculateInTime(String vehicleNo, LocalDate date, int avgTransitTime,
|
LocalDateTime lastOutTime, Random random) {
|
//如果今天这一车没有发运记录
|
if (lastOutTime == null) {
|
int hour = 8;
|
int minute = (hour == 17) ? random.nextInt(31) : random.nextInt(60);
|
return LocalDateTime.of(date, LocalTime.of(hour, minute));
|
} else {
|
//有的话这个时间 + 平均时间
|
int transitTime = avgTransitTime + (random.nextInt(10) - 5);
|
LocalDateTime inTime = lastOutTime.plusMinutes(transitTime);
|
return inTime;
|
}
|
}
|
|
/**
|
*
|
* @param inTime 入场时间
|
* @param avgLoadTime 平均装卸时间
|
* @return
|
*/
|
private LocalDateTime calculateOutTime(LocalDateTime inTime, int avgLoadTime,Random random) {
|
//装卸时间 + 随机生成 +- 3分钟
|
int loadTime = avgLoadTime + (random.nextInt(7) - 3);
|
LocalDateTime outTime = inTime.plusMinutes(loadTime);
|
|
//若大于 下班时间
|
// if (outTime.toLocalTime().isAfter(LocalTime.of(18, 0))) {
|
// outTime = outTime.with(LocalTime.of(18, 0));
|
// }
|
return outTime;
|
}
|
|
private LocalDateTime[] getTimes(List<Ponderation> ponderations,LocalDate day,String vehicleNo, int avgLoadTime,int transitAvgTime,Random random) {
|
//出场和下一次入场所需要平均多少分钟
|
ponderations.sort(Comparator.comparing(Ponderation::getCreateTime));
|
int zuiduanM = avgLoadTime + transitAvgTime;
|
if (ponderations.size() == 0){
|
LocalDateTime inTime = this.calculateInTime(vehicleNo,day,transitAvgTime,null,random);
|
LocalDateTime ouTime = this.calculateOutTime(inTime,avgLoadTime,random);
|
return new LocalDateTime[]{inTime,ouTime};
|
}
|
for (int i = 0; i < ponderations.size(); i++) {
|
Ponderation ponderation = ponderations.get(i);
|
if (i == ponderations.size()-1){
|
//和当天上班时间对比
|
long c = getMinutesDifference(day.atTime(8,0,0),ponderation.getCreateTime());
|
//可以插入数据
|
if (c>zuiduanM){
|
LocalDateTime inTime = this.calculateInTime(vehicleNo,day,transitAvgTime,day.atTime(8,0,0),random);
|
LocalDateTime ouTime = this.calculateOutTime(inTime,avgLoadTime,random);
|
return new LocalDateTime[]{inTime,ouTime};
|
}else{
|
//和下班时间对比
|
long o = getMinutesDifference(ponderation.getOutTime(),day.atTime(18,0,0));
|
//可以插入数据
|
if (o>zuiduanM){
|
//
|
LocalDateTime inTime = this.calculateInTime(vehicleNo,day,transitAvgTime,LocalDateTime.ofInstant(ponderation.getOutTime().toInstant(), ZoneId.systemDefault()),random);
|
LocalDateTime ouTime = this.calculateOutTime(inTime,avgLoadTime,random);
|
return new LocalDateTime[]{inTime,ouTime};
|
}
|
}
|
return null;
|
|
}else{
|
Ponderation ponderation1 = ponderations.get(i+1);
|
long c = getMinutesDifference(ponderation.getOutTime(),ponderation1.getCreateTime());
|
LocalDateTime inTime = this.calculateInTime(vehicleNo,day,transitAvgTime,day.atTime(8,0,0),random);
|
LocalDateTime ouTime = this.calculateOutTime(inTime,avgLoadTime,random);
|
return new LocalDateTime[]{inTime,ouTime};
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 随机皮重
|
* @param car 车辆级皮重
|
* @param random
|
* @return
|
*/
|
private double generateTare(CarAvgTare car, Random random) {
|
// +- 0.02
|
double base = 0.02 + random.nextDouble() * 0.02; // 生成 0.02~0.04 之间的随机数
|
int sign = random.nextBoolean() ? 1 : -1; // 随机确定正负
|
double d = base * sign; //随机结果
|
double tare = NumUtils.addDouble(car.getAvgTare(),d,2);
|
return tare;
|
}
|
|
/**
|
* 随机毛重
|
* @param tare 皮重
|
* @param random
|
* @return
|
*/
|
private double generateWetNet(double tare, Random random) {
|
double base = 49 - tare - 0.5;
|
return NumUtils.accurateDouble(base + (random.nextDouble() * 0.4 - 0.2), 2);
|
}
|
|
private boolean isInServiceTime(LocalDateTime time) {
|
LocalTime t = time.toLocalTime();
|
return t.isAfter(LocalTime.of(7, 59)) && t.isBefore(LocalTime.of(18, 1));
|
}
|
|
private Ponderation buildPonderation(Plan plan, String vehicleNo, LocalDateTime inTime,
|
LocalDateTime outTime, double tare, double gross,
|
double wetNet,String firstMan,String secondMan,Integer checkId) {
|
Ponderation pd = new Ponderation();
|
pd.setCompId(plan.getFyCompId());//矿
|
pd.setVehicleNo(vehicleNo);//车牌号
|
pd.setFirWeight(tare);//皮重
|
pd.setSecWeight(gross);//毛重
|
pd.setExecutive(wetNet);//净重
|
pd.setCreateTime(inTime);//入场时间
|
R<String> r = remoteMaxSize.nextNo(MaxSizeContant.WX_BD_NUM,plan.getFyCompId());
|
pd.setNumber(r.getData());
|
pd.setRefId(checkId);//检查id
|
// pd.setInTime(localDateTimeToDate());//入场时间
|
pd.setFirstMan(firstMan);//一次称重司磅员
|
pd.setSecondMan(secondMan);//二次称重司磅员
|
pd.setOutTime(Date.from(outTime.atZone(ZoneId.systemDefault()).toInstant()));//出厂时间
|
pd.setFiledId(plan.getFiledId());//煤场
|
pd.setCustomerId(plan.getCustomerId());//客户
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm");
|
pd.setPrintTime(outTime.format(formatter));
|
pd.setCoalId(plan.getCoalId());//产品
|
pd.setFromCompId(plan.getFyCompId());
|
pd.setPonderationType("外销");
|
return pd;
|
}
|
|
private double getDailyRealShui(Integer coalId, LocalDate date) {
|
return 0d;
|
}
|
|
|
/**
|
* 根据折干量计算湿煤量
|
* @param dryQuantity 折干量（已知）
|
* @param realShui 实际水分（%，如10d）
|
* @param contractShui 合同水分（%，如8d）
|
* @return 湿煤量（保留3位小数）
|
*/
|
public static Double getWetQuantityByDry(Double dryQuantity, Double realShui, Double contractShui) {
|
// 校验异常值
|
if (realShui >= 100) {
|
throw new IllegalArgumentException("实际水分不能大于等于100%");
|
}
|
// 校验折干量不为空
|
if (dryQuantity == null || dryQuantity <= 0) {
|
throw new IllegalArgumentException("折干量必须为正数");
|
}
|
|
// 计算分母：100 - 实际水分
|
double denominator = 100 - realShui;
|
// 计算分子：100 - 合同水分
|
double numerator = 100 - contractShui;
|
|
// 湿煤量 = 折干量 × (分子 / 分母)，保留3位小数
|
return NumUtils.accurateDouble(dryQuantity * (numerator / denominator), 3);
|
}
|
|
/**
|
* 两个时间相差多少分钟
|
* @param
|
* @param
|
* @return
|
* @throws ParseException
|
*/
|
public static long getMinutesDifference(String datetime1, String datetime2){
|
if (!isValidDateTimeWithDateTimeFormatter(datetime1) || !isValidDateTimeWithDateTimeFormatter(datetime2)) {
|
return 0;
|
}
|
// 定义匹配"yyyy-MM-dd HH:mm:ss"格式的解析器
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
|
|
// 解析字符串为LocalDateTime对象
|
LocalDateTime time1 = LocalDateTime.parse(datetime1, formatter);
|
LocalDateTime time2 = LocalDateTime.parse(datetime2, formatter);
|
|
// 计算分钟差并返回绝对值
|
return Math.abs(ChronoUnit.MINUTES.between(time1, time2));
|
}
|
|
/**
|
* 计算 Date 和 LocalDateTime 的分钟差
|
* @param date 日期对象（含时区信息）
|
* @param localDateTime 本地日期时间（需结合默认时区转换）
|
* @return 分钟差的绝对值
|
*/
|
public static long getMinutesDifference(Date date, LocalDateTime localDateTime) {
|
if (date == null || localDateTime == null) {
|
return 0; // 空值直接返回0
|
}
|
// Date 转 LocalDateTime（使用系统默认时区，可根据需求修改）
|
LocalDateTime dateTime1 = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
|
// 计算分钟差
|
return Math.abs(ChronoUnit.MINUTES.between(dateTime1, localDateTime));
|
}
|
|
/**
|
* 计算两个 Date 的分钟差
|
* @param date1 第一个日期
|
* @param date2 第二个日期
|
* @return 分钟差的绝对值
|
*/
|
public static long getMinutesDifference(Date date1, Date date2) {
|
if (date1 == null || date2 == null) {
|
return 0; // 空值直接返回0
|
}
|
// 转换为毫秒差后计算分钟（1分钟=60000毫秒）
|
long diffMs = Math.abs(date1.getTime() - date2.getTime());
|
return diffMs / 60000;
|
}
|
|
/**
|
* 计算 Date 和 LocalDateTime 的分钟差
|
* @param date 日期对象（含时区信息）
|
* @param localDateTime 本地日期时间（需结合默认时区转换）
|
* @return 分钟差的绝对值
|
*/
|
public static long getMinutesDifference(LocalDateTime date, LocalDateTime localDateTime) {
|
// 计算分钟差
|
return Math.abs(ChronoUnit.MINUTES.between(date, localDateTime));
|
}
|
|
/**
|
* localDate转换成Date
|
* @param localDateTime
|
* @return
|
*/
|
public static Date localDateTimeToDate(LocalDateTime localDateTime) {
|
if (localDateTime == null) {
|
return null;
|
}
|
// 使用系统默认时区（ZoneId.systemDefault()）
|
return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
|
}
|
|
/**
|
* 将字符串转换为LocalDateTime
|
* @param dateTimeStr 待转换的日期时间字符串
|
* @param
|
* @return 转换后的LocalDateTime
|
*/
|
public static LocalDateTime stringToLocalDateTime(String dateTimeStr) {
|
String pattern = "yyyy-MM-dd HH:mm:ss";
|
if (dateTimeStr == null) {
|
return null;
|
}
|
try {
|
// 创建指定格式的DateTimeFormatter
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
|
// 解析字符串为LocalDateTime
|
return LocalDateTime.parse(dateTimeStr, formatter);
|
} catch (DateTimeParseException e) {
|
// 格式不匹配时抛出异常，这里捕获并返回null
|
System.err.println("字符串格式与指定模式不匹配：" + e.getMessage());
|
return null;
|
}
|
}
|
|
// public static void genOrderByPonList(Integer orderId,Plan plan){
|
// ContractOrder order = new ContractOrder();
|
// order.setCreateCompId();
|
// order.setCompId(plan.getFyCompId());
|
// order.setCustomerId(plan.getCustomerId());
|
// order.setCustomerAddressId(plan.getCustomerAddressId());
|
// order.setNumber(remoteMaxSize.nextNo(MaxSizeContant.WX_ORDER_NUM,plan.getFyCompId()).getData());
|
// };
|
}
|
