Merge branch 'master' into guoqiang.duan/billet_basic_info

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/billetActual/controller/BilletHotsendChangeShiftController.java

@@ -111,6 +111,30 @@ public class BilletHotsendChangeShiftController extends JeecgController<BilletHo
 		return Result.OK(null);
 	}
 
+	@ApiOperation(value="5号机自动化交班测试", notes="5号机自动化交班测试")
+	@GetMapping(value = "/autoByCcmNoFive")
+	public Result<String> autoByCcmNoFive(@RequestParam(name="ccmNo", required = false) String ccmNo,
+										 @RequestParam(name="nextId", required = false) Integer nextId,
+										 @RequestParam(name="shift", required = false) String shift,
+										 @RequestParam(name="shiftGroup", required = false) String shiftGroup) {
+		JSONObject jsonObject = new JSONObject();
+		jsonObject.put("changeShiftTime", "2025-04-25 10:21:52");
+		billetHotsendChangeShiftService.autoChangeShift(jsonObject);
+		return Result.OK(null);
+	}
+
+	@ApiOperation(value="6号机自动化交班测试", notes="6号机自动化交班测试")
+	@GetMapping(value = "/autoByCcmNoSix")
+	public Result<String> autoByCcmNoSix(@RequestParam(name="ccmNo", required = false) String ccmNo,
+									  @RequestParam(name="nextId", required = false) Integer nextId,
+									  @RequestParam(name="shift", required = false) String shift,
+									  @RequestParam(name="shiftGroup", required = false) String shiftGroup) {
+		JSONObject jsonObject = new JSONObject();
+		jsonObject.put("changeShiftTime", "2025-04-25 10:21:52");
+		billetHotsendChangeShiftService.autoChangeShiftSix(jsonObject);
+		return Result.OK(null);
+	}
+
 	@ApiOperation(value="获取当前缓存信息", notes="获取当前缓存信息")
 	@GetMapping(value = "/autoByCcmNo1")
 	public Result<String> autoByCcmNo1(@RequestParam(name="ccmNo", required = true) String ccmNo) {
@@ -131,20 +155,19 @@ public class BilletHotsendChangeShiftController extends JeecgController<BilletHo
 		log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " C端自动化当前班次信息名:" + currentCacheId + "," + currentShiftName+ ","+ currentShiftGroupName);
 
 		String[] data = {
-				"1 丙 夜", "2 甲 白", "3 乙 中", "4 丙 夜", "5 甲 白", "6 乙 中", "7 丙 夜", "8 甲 白", "9 乙 中", "10 丙 夜",
-				"11 甲 白", "12 乙 中", "13 丁 夜", "14 丙 白", "15 甲 中", "16 丁 夜", "17 丙 白", "18 甲 中", "19 丁 夜", "20 丙 白",
-				"21 甲 中", "22 丁 夜", "23 丙 白", "24 甲 中", "25 乙 夜", "26 丁 白", "27 丙 中", "28 乙 夜", "29 丁 白", "30 丙 中",
-				"31 乙 夜", "32 丁 白", "33 丙 中", "34 乙 夜", "35 丁 白", "36 丙 中", "37 甲 夜", "38 乙 白", "39 丁 中", "40 甲 夜",
-				"41 乙 白", "42 丁 中", "43 甲 夜", "44 乙 白", "45 丁 中", "46 甲 夜", "47 乙 白", "48 丁 中"
+				"1 丙", "2 甲", "3 乙", "4 丙", "5 甲", "6 乙", "7 丙", "8 甲", "9 乙", "10 丙",
+				"11 甲", "12 乙", "13 丁", "14 丙", "15 甲", "16 丁", "17 丙", "18 甲", "19 丁", "20 丙",
+				"21 甲", "22 丁", "23 丙", "24 甲", "25 乙", "26 丁", "27 丙", "28 乙", "29 丁", "30 丙",
+				"31 乙", "32 丁", "33 丙", "34 乙", "35 丁", "36 丙", "37 甲", "38 乙", "39 丁", "40 甲",
+				"41 乙", "42 丁", "43 甲", "44 乙", "45 丁", "46 甲", "47 乙", "48 丁"
 		};
 
-		ShiftInfo nextShiftInfo = ScheduleUtils.findNextShift(data, Integer.valueOf(currentCacheId), currentShiftGroupName, currentShiftName);
+		ShiftInfo nextShiftInfo = ScheduleUtils.findNextShift(data, Integer.valueOf(currentCacheId), currentShiftGroupName);
 		if (nextShiftInfo == null){
 			log.info("{}{}", "获取到下个班组信息为空!", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + "C端自动化交班失败！");
 			return Result.OK(null);
 		}
 
-		String nextShiftGroupName = nextShiftInfo.getShiftgroup();
 
 		String nextShiftName = nextShiftInfo.getShift();
 
@@ -152,12 +175,6 @@ public class BilletHotsendChangeShiftController extends JeecgController<BilletHo
 
 		String finalNextShiftGroupVal = ShiftGroupEnum.getCodeByName(nextShiftName);
 
-		String finalNextShiftVal = ShiftEnum.getCodeByName(nextShiftGroupName + "班");;
-
-		log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " C端自动化下一个班次信息值:" + finalNextShiftVal + ","+ finalNextShiftGroupVal);
-		log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " C端自动化下一个班次信息名:" + nextUniqueShiftId + "," + nextShiftGroupName + ","+ nextShiftName);
-
-
 		return Result.OK(null);
 	}
 }

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/billetActual/entity/BilletBasicInfo.java

@@ -225,4 +225,11 @@ public class BilletBasicInfo implements Serializable {
     @Excel(name = "组坯号", width = 15)
     @ApiModelProperty(value = "组坯号", required = true)
     private String assemblyNumber;
+
+    /**
+     * 牌号
+     */
+    @Excel(name = "牌号", width = 15)
+    @ApiModelProperty(value = "牌号")
+    private String brandNum;
 }

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/billetActual/entity/BilletHotsend.java

@@ -130,6 +130,10 @@ public class BilletHotsend implements Serializable {
     @Excel(name = "判废支数", width = 15)
     @ApiModelProperty(value = "判废支数")
     private Integer wasteNum;
+    /**叛废总重*/
+    @Excel(name = "叛废总重", width = 15)
+    @ApiModelProperty(value = "叛废总重")
+    private Double wasteBlankOutput;
     /**C*/
     @Excel(name = "C", width = 15)
     @ApiModelProperty(value = "C")

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/billetActual/entity/BilletHotsendChangeShift.java

@@ -79,6 +79,10 @@ public class BilletHotsendChangeShift implements Serializable {
 	@Excel(name = "当前废品支数", width = 15)
     @ApiModelProperty(value = "当前废品支数")
     private Integer wasteAmount;
+    /**叛废总重*/
+    @Excel(name = "叛废总重", width = 15)
+    @ApiModelProperty(value = "叛废总重")
+    private Double wasteBlankOutput;
 	/**当前热送支数*/
 	@Excel(name = "当前热送支数", width = 15)
     @ApiModelProperty(value = "当前热送支数")

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/billetActual/service/IBilletHotsendChangeShiftService.java

@@ -13,4 +13,6 @@ import org.jeecg.modules.billetActual.entity.BilletHotsendChangeShift;
 public interface IBilletHotsendChangeShiftService extends IService<BilletHotsendChangeShift> {
 
     void autoChangeShift(JSONObject jsonObject);
+
+    void autoChangeShiftSix(JSONObject jsonObject);
 }

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/billetActual/service/impl/BilletBasicInfoServiceImpl.java

@@ -19,6 +19,8 @@ import org.jeecg.modules.heatsActuals.mapper.HeatsActualsMapper;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
 import java.text.SimpleDateFormat;
 import java.util.Date;
 
@@ -48,97 +50,104 @@ public class BilletBasicInfoServiceImpl extends ServiceImpl<BilletBasicInfoMappe
     BilletHotsendChangeShiftMapper billetHotsendChangeShiftMapper;
 
     @Override
+    @Transactional(rollbackFor = Exception.class)
     public void addC(BilletBasicInfo billetBasicInfo) {
-        log.info("{}{}", "start钢坯基础信息接收到mqtt消息，开始处理逻辑:", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()));
-        String classShiftGroup = String.format("class:shift:group:%s", billetBasicInfo.getCcmNo()); // 班组
-        String classShift = String.format("class:shift:%s", billetBasicInfo.getCcmNo()); // 班别
-        String classShiftStr = !oConvertUtils.getString(redisTemplate.opsForValue().get(classShift)).isEmpty() ? oConvertUtils.getString(redisTemplate.opsForValue().get(classShift)) : "";
-        String classShiftGroupStr = !oConvertUtils.getString(redisTemplate.opsForValue().get(classShiftGroup)).isEmpty() ? oConvertUtils.getString(redisTemplate.opsForValue().get(classShiftGroup)) : "";
-        log.info("{}{}", "钢坯实绩接收时缓存中的班组班别：", classShiftGroupStr+ " " + classShiftStr);
-        // 查询钢坯基础是否存在
-        LambdaQueryWrapper<BilletBasicInfo> queryWrapper = new LambdaQueryWrapper<BilletBasicInfo>().eq(BilletBasicInfo::getBilletNo, billetBasicInfo.getBilletNo()).eq(BilletBasicInfo::getCcmNo, billetBasicInfo.getCcmNo()).eq(BilletBasicInfo::getHeatNo, billetBasicInfo.getHeatNo()).orderByDesc(BilletBasicInfo::getCreateTime).last("limit 1");
-        BilletBasicInfo basicInfo = baseMapper.selectOne(queryWrapper);
-        if(oConvertUtils.isNotEmpty(basicInfo) && oConvertUtils.isNotEmpty(basicInfo.getId())){ // 编辑
-            log.info("{}{}", "更新钢坯实绩最新一条中的班组班别：", basicInfo.getShiftGroup()+ " " + basicInfo.getShift());
-            // 编辑钢坯基础信息
-            billetBasicInfo.setId(basicInfo.getId());
-            billetBasicInfo.setBilletWeight(basicInfo.getBilletWeight());
-            billetBasicInfo.setWeight(basicInfo.getWeight());
-            billetBasicInfo.setShift(basicInfo.getShift());
-            billetBasicInfo.setActualLength(basicInfo.getActualLength());
-            billetBasicInfo.setThickness(basicInfo.getThickness());
-            billetBasicInfo.setSpec(basicInfo.getSpec());
-            billetBasicInfo.setGrade(basicInfo.getGrade());
-            billetBasicInfo.setShiftGroup(basicInfo.getShiftGroup());
-            baseMapper.updateById(billetBasicInfo);
-        } else {
-            // 查询定尺规则
-            LambdaQueryWrapper<BilletRulerConfig> queryWrapperbilletRulerConfig = new LambdaQueryWrapper<BilletRulerConfig>().eq(BilletRulerConfig::getLength, billetBasicInfo.getLength());
-            BilletRulerConfig billetRulerConfig = billetRulerConfigMapper.selectOne(queryWrapperbilletRulerConfig);
-            Double weight = 0.0;
-            if(oConvertUtils.isEmpty(billetRulerConfig)){
-                weight = billetBasicInfo.getWeight();
-            } else{
-                weight = billetRulerConfig.getWeight();
-            }
-            // 新增数据
-            billetBasicInfo.setBilletWeight(weight);
-            billetBasicInfo.setShift(classShiftStr);
-            billetBasicInfo.setShiftGroup(classShiftGroupStr);
+        try {
+            log.info("{}{}", "start钢坯基础信息接收到mqtt消息，开始处理逻辑:", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()));
+            String classShiftGroup = String.format("class:shift:group:%s", billetBasicInfo.getCcmNo()); // 班组
+            String classShift = String.format("class:shift:%s", billetBasicInfo.getCcmNo()); // 班别
+            String classShiftStr = !oConvertUtils.getString(redisTemplate.opsForValue().get(classShift)).isEmpty() ? oConvertUtils.getString(redisTemplate.opsForValue().get(classShift)) : "";
+            String classShiftGroupStr = !oConvertUtils.getString(redisTemplate.opsForValue().get(classShiftGroup)).isEmpty() ? oConvertUtils.getString(redisTemplate.opsForValue().get(classShiftGroup)) : "";
+            log.info("{}{}", "钢坯实绩接收时缓存中的班组班别：", classShiftGroupStr + " " + classShiftStr);
+            // 查询钢坯基础是否存在
+            LambdaQueryWrapper<BilletBasicInfo> queryWrapper = new LambdaQueryWrapper<BilletBasicInfo>().eq(BilletBasicInfo::getBilletNo, billetBasicInfo.getBilletNo()).eq(BilletBasicInfo::getCcmNo, billetBasicInfo.getCcmNo()).eq(BilletBasicInfo::getHeatNo, billetBasicInfo.getHeatNo()).orderByDesc(BilletBasicInfo::getCreateTime).last("limit 1");
+            BilletBasicInfo basicInfo = baseMapper.selectOne(queryWrapper);
+            if (oConvertUtils.isNotEmpty(basicInfo) && oConvertUtils.isNotEmpty(basicInfo.getId())) { // 编辑
+                log.info("{}{}", "更新钢坯实绩最新一条中的班组班别：", basicInfo.getShiftGroup() + " " + basicInfo.getShift());
+                // 编辑钢坯基础信息
+                billetBasicInfo.setId(basicInfo.getId());
+                billetBasicInfo.setBilletWeight(basicInfo.getBilletWeight());
+                billetBasicInfo.setWeight(basicInfo.getWeight());
+                billetBasicInfo.setShift(basicInfo.getShift());
+                billetBasicInfo.setActualLength(basicInfo.getActualLength());
+                billetBasicInfo.setThickness(basicInfo.getThickness());
+                billetBasicInfo.setSpec(basicInfo.getSpec());
+                billetBasicInfo.setGrade(basicInfo.getGrade());
+                billetBasicInfo.setShiftGroup(basicInfo.getShiftGroup());
+                baseMapper.updateById(billetBasicInfo);
+            } else {
+                // 查询定尺规则
+                LambdaQueryWrapper<BilletRulerConfig> queryWrapperbilletRulerConfig = new LambdaQueryWrapper<BilletRulerConfig>().eq(BilletRulerConfig::getLength, billetBasicInfo.getLength());
+                BilletRulerConfig billetRulerConfig = billetRulerConfigMapper.selectOne(queryWrapperbilletRulerConfig);
+                Double weight = 0.0;
+                if (oConvertUtils.isEmpty(billetRulerConfig)) {
+                    weight = billetBasicInfo.getWeight();
+                } else {
+                    weight = billetRulerConfig.getWeight();
+                }
+                // 新增数据
+                billetBasicInfo.setBilletWeight(weight);
+                billetBasicInfo.setShift(classShiftStr);
+                billetBasicInfo.setShiftGroup(classShiftGroupStr);
 
-            log.info("{}{}", "新增钢坯实绩时班组班别：", billetBasicInfo.getShiftGroup()+ " " + billetBasicInfo.getShift());
-            baseMapper.insert(billetBasicInfo);
+                log.info("{}{}", "新增钢坯实绩时班组班别：", billetBasicInfo.getShiftGroup() + " " + billetBasicInfo.getShift());
+                baseMapper.insert(billetBasicInfo);
 
-            // 炉次实绩出坯量维护
-            LambdaQueryWrapper<HeatsActuals> queryWrapperHeatsActuals = new LambdaQueryWrapper<HeatsActuals>().eq(HeatsActuals::getHeatsCode, billetBasicInfo.getHeatNo()).eq(HeatsActuals::getCasterCode, billetBasicInfo.getCcmNo()).orderByDesc(HeatsActuals::getCreateTime).last("limit 1");
-            HeatsActuals heatsActuals = heatsActualsMapper.selectOne(queryWrapperHeatsActuals);
-            if(oConvertUtils.isNotEmpty(heatsActuals)) {
-                heatsActuals.setId(heatsActuals.getId());
-                heatsActuals.setBlankOutput(heatsActuals.getBlankOutput() + weight);
-                heatsActualsMapper.updateById(heatsActuals);
-            }
+                // 炉次实绩出坯量维护
+                LambdaQueryWrapper<HeatsActuals> queryWrapperHeatsActuals = new LambdaQueryWrapper<HeatsActuals>().eq(HeatsActuals::getHeatsCode, billetBasicInfo.getHeatNo()).eq(HeatsActuals::getCasterCode, billetBasicInfo.getCcmNo()).orderByDesc(HeatsActuals::getCreateTime).last("limit 1");
+                HeatsActuals heatsActuals = heatsActualsMapper.selectOne(queryWrapperHeatsActuals);
+                if (oConvertUtils.isNotEmpty(heatsActuals)) {
+                    heatsActuals.setId(heatsActuals.getId());
+                    heatsActuals.setBlankOutput(heatsActuals.getBlankOutput() + weight);
+                    heatsActualsMapper.updateById(heatsActuals);
+                }
 
-            // 当班总数 + 当班总重 信息维护
-            LambdaQueryWrapper<BilletHotsendChangeShift> queryWrapperBilletHotsendChangeShift = new LambdaQueryWrapper<BilletHotsendChangeShift>()
-                    .eq(BilletHotsendChangeShift::getCcmNo, billetBasicInfo.getCcmNo())
-                    .eq(BilletHotsendChangeShift::getShift, classShiftStr)
-                    .eq(BilletHotsendChangeShift::getShiftGroup, classShiftGroupStr)
-                    .orderByDesc(BilletHotsendChangeShift::getCreateTime).last("limit 1");
-            BilletHotsendChangeShift billetHotsendChangeShift = billetHotsendChangeShiftMapper.selectOne(queryWrapperBilletHotsendChangeShift);
-            if(oConvertUtils.isNotEmpty(billetHotsendChangeShift)){
-                billetHotsendChangeShift.setId(billetHotsendChangeShift.getId());
-                billetHotsendChangeShift.setShiftProduct(billetHotsendChangeShift.getShiftProduct() + weight);
-                billetHotsendChangeShift.setHeatNo(billetBasicInfo.getHeatNo());
-                billetHotsendChangeShift.setShiftSum(billetHotsendChangeShift.getShiftSum() + 1);
-                billetHotsendChangeShiftMapper.updateById(billetHotsendChangeShift);
-            }
+                // 当班总数 + 当班总重 信息维护
+                LambdaQueryWrapper<BilletHotsendChangeShift> queryWrapperBilletHotsendChangeShift = new LambdaQueryWrapper<BilletHotsendChangeShift>()
+                        .eq(BilletHotsendChangeShift::getCcmNo, billetBasicInfo.getCcmNo())
+                        .eq(BilletHotsendChangeShift::getShift, classShiftStr)
+                        .eq(BilletHotsendChangeShift::getShiftGroup, classShiftGroupStr)
+                        .orderByDesc(BilletHotsendChangeShift::getCreateTime).last("limit 1");
+                BilletHotsendChangeShift billetHotsendChangeShift = billetHotsendChangeShiftMapper.selectOne(queryWrapperBilletHotsendChangeShift);
+                if (oConvertUtils.isNotEmpty(billetHotsendChangeShift)) {
+                    billetHotsendChangeShift.setId(billetHotsendChangeShift.getId());
+                    billetHotsendChangeShift.setShiftProduct(billetHotsendChangeShift.getShiftProduct() + weight);
+                    billetHotsendChangeShift.setHeatNo(billetBasicInfo.getHeatNo());
+                    billetHotsendChangeShift.setShiftSum(billetHotsendChangeShift.getShiftSum() + 1);
+                    billetHotsendChangeShiftMapper.updateById(billetHotsendChangeShift);
+                }
 
-            // 钢坯热送单炉支数传递单信息维护
-            LambdaQueryWrapper<BilletHotsend> queryBilletWrapper = new LambdaQueryWrapper<BilletHotsend>().eq(BilletHotsend::getHeatNo, billetBasicInfo.getHeatNo())
-                    .eq(BilletHotsend::getShift, classShiftStr)
-                    .eq(BilletHotsend::getCcmNo,  billetBasicInfo.getCcmNo())
-                    .eq(BilletHotsend::getShiftGroup, classShiftGroupStr).orderByDesc(BilletHotsend::getCreateTime).last("limit 1");
-            BilletHotsend billetHotsendInfo = billetHotsendMapper.selectOne(queryBilletWrapper);
-            if(oConvertUtils.isNotEmpty(billetHotsendInfo) && oConvertUtils.isNotEmpty(billetHotsendInfo.getId())){ // 编辑钢坯热送单炉支数传递单
-                billetHotsendInfo.setId(billetHotsendInfo.getId());
-                billetHotsendInfo.setAmountTotal(billetHotsendInfo.getAmountTotal() + 1);
-                billetHotsendInfo.setBlankOutput(billetHotsendInfo.getBlankOutput() + weight); // 出坯量
-                billetHotsendInfo.setDecideWeight(billetHotsendInfo.getDecideWeight() + billetBasicInfo.getWeight()); // 定重
-                billetHotsendMapper.updateById(billetHotsendInfo);
-            } else {
-                BilletHotsend billetHotsend = new BilletHotsend();
-                billetHotsend.setCcmNo(String.valueOf(billetBasicInfo.getCcmNo())); // 铸机号
-                billetHotsend.setHeatNo(billetBasicInfo.getHeatNo()); // 炉号
-                billetHotsend.setShiftGroup(classShiftGroupStr); // 班组
-                billetHotsend.setShift(classShiftStr); // 班别
-                billetHotsend.setSteel(billetBasicInfo.getGrade()); // 钢种
-                billetHotsend.setSpec(billetBasicInfo.getSpec()); // 规格
-                billetHotsend.setAmountTotal(1); // 支数
-                billetHotsend.setBlankOutput(weight); // 出批量
-                billetHotsend.setDecideWeight(billetBasicInfo.getWeight()); // 定重
-                billetHotsendMapper.insert(billetHotsend);
+                // 钢坯热送单炉支数传递单信息维护
+                LambdaQueryWrapper<BilletHotsend> queryBilletWrapper = new LambdaQueryWrapper<BilletHotsend>().eq(BilletHotsend::getHeatNo, billetBasicInfo.getHeatNo())
+                        .eq(BilletHotsend::getShift, classShiftStr)
+                        .eq(BilletHotsend::getCcmNo, billetBasicInfo.getCcmNo())
+                        .eq(BilletHotsend::getShiftGroup, classShiftGroupStr).orderByDesc(BilletHotsend::getCreateTime).last("limit 1");
+                BilletHotsend billetHotsendInfo = billetHotsendMapper.selectOne(queryBilletWrapper);
+                if (oConvertUtils.isNotEmpty(billetHotsendInfo) && oConvertUtils.isNotEmpty(billetHotsendInfo.getId())) { // 编辑钢坯热送单炉支数传递单
+                    billetHotsendInfo.setId(billetHotsendInfo.getId());
+                    billetHotsendInfo.setAmountTotal(billetHotsendInfo.getAmountTotal() + 1);
+                    billetHotsendInfo.setBlankOutput(billetHotsendInfo.getBlankOutput() + weight); // 出坯量
+                    billetHotsendInfo.setDecideWeight(billetHotsendInfo.getDecideWeight() + billetBasicInfo.getWeight()); // 定重
+                    billetHotsendMapper.updateById(billetHotsendInfo);
+                } else {
+                    BilletHotsend billetHotsend = new BilletHotsend();
+                    billetHotsend.setCcmNo(String.valueOf(billetBasicInfo.getCcmNo())); // 铸机号
+                    billetHotsend.setHeatNo(billetBasicInfo.getHeatNo()); // 炉号
+                    billetHotsend.setShiftGroup(classShiftGroupStr); // 班组
+                    billetHotsend.setShift(classShiftStr); // 班别
+                    billetHotsend.setSteel(billetBasicInfo.getGrade()); // 钢种
+                    billetHotsend.setSpec(billetBasicInfo.getSpec()); // 规格
+                    billetHotsend.setAmountTotal(1); // 支数
+                    billetHotsend.setBlankOutput(weight); // 出批量
+                    billetHotsend.setDecideWeight(billetBasicInfo.getWeight()); // 定重
+                    billetHotsend.setWasteBlankOutput(0.0);
+                    billetHotsendMapper.insert(billetHotsend);
+                }
             }
+            log.info("{}{}", "end钢坯基础信息逻辑处理结束:", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()));
+        } catch (Exception e) {
+            log.error("自动化处理钢坯基础信息时发生异常", e);
+            throw e;
         }
-        log.info("{}{}", "end钢坯基础信息逻辑处理结束:", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()));
     }
 }

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/billetActual/service/impl/BilletHotsendBaseServiceImpl.java

@@ -7,6 +7,7 @@ import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.toolkit.IdWorker;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang.StringUtils;
 import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.util.DateUtils;
 import org.jeecg.common.util.oConvertUtils;
@@ -236,7 +237,20 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 		saveBilletRodLineCommom(billetHotsendDetailsVo);
 		log.info("C端自动化操作结果，{}新增成功:{}", operationMsg, billetNos);
 	}
-
+	public static void main(String[] args) {
+		String billetNos = "255061616805,255061615705,255061615606,255061575804";
+
+		String ninthCharStr = Optional.ofNullable(billetNos)
+				.filter(s -> !s.isEmpty())
+				.map(s -> s.split(","))
+				.filter(arr -> arr.length > 0)
+				.map(arr -> arr[0])
+				.filter(num -> num.length() >= 9)
+				.map(num -> String.valueOf(num.charAt(8)))
+				.orElse(""); // 默认返回空字符串或其他默认值
+
+		System.out.println("第一个坯号的第9位字符是：" + ninthCharStr);
+	}
 	/**
 	 * 5、6号机  轧钢外运
 	 * 去上若  车牌为陕E开头
@@ -247,13 +261,11 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 	@Override
 	@Transactional(rollbackFor = {Exception.class})
 	public void autoAddRodLine(JSONObject jsonObject) {
-		log.info("{}{}", "C端自动化轧钢外运<保存>参数:", jsonObject);
-
+		log.info("{}{}", "C端自动化热装<保存>mqtt参数:", jsonObject);
 		BilletHotsendDetailsVo billetHotsendDetailsVo = new BilletHotsendDetailsVo();
 
 		String ccmNo = jsonObject.getString("ccmNo");
 		String billetNos = jsonObject.getString("billetNos");
-//		String billetHotsendTypeConfigId = jsonObject.getString("billetHotsendTypeConfigId");
 		String licensePlate = jsonObject.getString("licensePlate");
 		String destination = jsonObject.getString("destination");
 		String positionNum = jsonObject.getString("positionNum");
@@ -264,15 +276,41 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 		String location = jsonObject.getString("location");
 
 		if (oConvertUtils.isEmpty(billetNos) || oConvertUtils.isEmpty(positionNum)){
-			log.info("{}{}", "参数为空，自动化轧钢外运<保存>失败！", jsonObject);
+			log.info("{}{}", "参数为空，C端自动化热装<保存>失败！", jsonObject);
 			return;
 		}
 
+		// 首先查询钢坯装运单
+		LambdaQueryWrapper<StorageBill> queryWrapper2 = new LambdaQueryWrapper<>();
+		queryWrapper2.eq(StorageBill::getPositionNum, Integer.valueOf(positionNum))
+				.isNull(StorageBill::getOutTime);
+		// 2号车位不验证铸机号
+		if (!positionNum.equals("2")) {
+			queryWrapper2.eq(StorageBill::getCcmNo, ccmNo);
+		}
+		StorageBill isStorageBill = storageBillService.getOne(queryWrapper2);
+		// 更具装运单确认铸机号
+		if (oConvertUtils.isNotEmpty(isStorageBill) && oConvertUtils.isNotEmpty(isStorageBill.getCcmNo())) {
+			ccmNo = isStorageBill.getCcmNo();
+		}else {
+			ccmNo = Optional.ofNullable(billetNos)
+					.filter(s -> !s.isEmpty())
+					.map(s -> s.split(","))
+					.filter(arr -> arr.length > 0)
+					.map(arr -> arr[0])
+					.filter(num -> num.length() >= 9)
+					.map(num -> String.valueOf(num.charAt(8)))
+					.orElse("");
+			// 更新铸机号，到装运单
+			isStorageBill.setCcmNo(ccmNo);
+			storageBillService.updateById(isStorageBill);
+		}
+
 		String shiftGroup = shiftGroupHandle(ccmNo);
 		String shift = shiftHandle(ccmNo);
 
 		if (oConvertUtils.isEmpty(shiftGroup) || oConvertUtils.isEmpty(shift)){
-			log.info("{}{}", "班组班别获取为空，自动化轧钢外运<保存>失败！", jsonObject);
+			log.info("{}{}", "班组班别获取为空，C端自动化热装<保存>失败！", jsonObject);
 			return;
 		}
 
@@ -302,9 +340,9 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 		if (oConvertUtils.isNotEmpty(liftingTime)){
 			billetLiftingBill.setLiftingTime(DateUtils.str2Date(liftingTime, DateUtils.datetimeFormat.get()));
 		}
-		billetLiftingBill.setRemark("轧钢外运吊运单");
+		billetLiftingBill.setRemark("热装吊运单");
 		billetLiftingBill.setBilletWeight(0.00);
-		log.info("C端自动化轧钢外运热装吊运单，吊运单信息: {}", JSON.toJSON(billetLiftingBill));
+		log.info("C端自动化热装——吊运单信息: {}", JSON.toJSON(billetLiftingBill));
 		saveBilletLiftingBillsHotCharge(billetLiftingBill);
 
 		// 根据坯号查询 对应的钢坯基础信息
@@ -316,9 +354,24 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 				.isNull(BilletBasicInfo::getBhtcId);
 		List<BilletBasicInfo> billetBasicInfoLists = billetBasicInfoService.list(queryWrapper1);
 		if (oConvertUtils.listIsEmpty(billetBasicInfoLists)){
-			log.info("{}{}", "钢坯基础信息不存在，C端自动化轧钢外运<保存>失败!", jsonObject);
+			// 循环三次处理
+			for (int i = 0; i < 10; i++) {
+				// 延迟10秒
+				try {
+					Thread.sleep(10000);
+				} catch (InterruptedException e) {
+					e.printStackTrace();
+				}
+				billetBasicInfoLists = billetBasicInfoService.list(queryWrapper1);
+				if (!oConvertUtils.listIsEmpty(billetBasicInfoLists)){
+					break;
+				}
+			}
+		}
+		if (oConvertUtils.listIsEmpty(billetBasicInfoLists)){
+			log.info("{}{}", "钢坯基础信息不存在，C端自动化热装<保存>失败!", jsonObject);
 			BilletAutoException billetAutoException = createBilletAutoException(ccmNo, billetNos, shiftGroupHandle(ccmNo), shiftHandle(ccmNo), null);
-			billetAutoException.setMassage("钢坯基础信息不存在，自动化轧钢外运<保存>失败!");
+			billetAutoException.setMassage("钢坯基础信息不存在，自动化热装<保存>失败!");
 			billetAutoExceptionService.save(billetAutoException);
 			return;
 		}
@@ -333,16 +386,26 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 			billetLiftingBillUpdate.setAssemblyNumber(getAssemblyNumber(billetBasicInfoLists));
 			billetLiftingBillService.updateById(billetLiftingBillUpdate);
 		}
-
-		LambdaQueryWrapper<StorageBill> queryWrapper2 = new LambdaQueryWrapper<>();
-		queryWrapper2.eq(StorageBill::getCcmNo, ccmNo)
-				.eq(StorageBill::getPositionNum, Integer.valueOf(positionNum))
-//				.eq(StorageBill::getShiftGroup, shiftGroup)
-//				.eq(StorageBill::getShift, shift)
-				.isNull(StorageBill::getOutTime);
-		StorageBill isStorageBill = storageBillService.getOne(queryWrapper2);
-		if (oConvertUtils.isEmpty(isStorageBill)) {
-			log.info("未查询钢坯装运单信息，车位号为：{}，C端自动化轧钢外运<保存>失败！", positionNum);
+		// 查询更新后的装运单信息
+		StorageBill storageBill = storageBillService.getById(isStorageBill.getId());
+		if (oConvertUtils.isEmpty(storageBill)) {
+			//  验证空的装运单 循环三次处理
+			for (int i = 0; i < 6; i++) {
+				// 延迟10秒
+				try {
+					Thread.sleep(10000);
+				} catch (InterruptedException e) {
+					e.printStackTrace();
+				}
+				storageBill = storageBillService.getById(isStorageBill.getId());
+				if (!oConvertUtils.isEmpty(storageBill)){
+					break;
+				}
+			}
+		}
+		// 钢坯装运单
+		if (oConvertUtils.isEmpty(storageBill)) {
+			log.info("未查询钢坯装运单信息，车位号为：{}，C端自动化热装<保存>失败！", positionNum);
 			BilletAutoException billetAutoException = new BilletAutoException();
 			billetAutoException.setId(String.valueOf(IdWorker.getId()));
 			billetAutoException.setCcmNo(ccmNo);
@@ -351,14 +414,14 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 			billetAutoException.setShift(shift);
 			billetAutoException.setCreateTime(new Date());
 			billetAutoException.setRemark(licensePlate);
-			billetAutoException.setMassage("未查询钢坯装运单信息，自动化轧钢外运<保存>失败!");
+			billetAutoException.setMassage("未查询钢坯装运单信息，C端自动化热装<保存>失败!");
 			billetAutoExceptionService.save(billetAutoException);
 			return;
 		}
-		billetHotsendDetailsVo.setStorageBill(isStorageBill);
+		billetHotsendDetailsVo.setStorageBill(storageBill);
 		// 轧钢外运保存时，先判断装运单中的目的地ID是否为1024，如果为1024、明细暂存临时表billet_auto_tmp
-		if ("1024".equals(isStorageBill.getTypeConfigId())){
-			log.info("{}{}", "C端自动化轧钢外运未知目的地信息:", JSON.toJSON(billetNosparts));
+		if ("1024".equals(storageBill.getTypeConfigId())){
+			log.info("{}{}", "C端自动化热装未知目的地，坯号集:", JSON.toJSON(billetNosparts));
 			billetHotsendDetailsVo.setBelongTable("billet_auto_tmp");
 			billetHotsendDetailsVo.setBilletHotsendTypeConfigId("1024");
 		}else {
@@ -367,7 +430,10 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 			queryWrapper3.eq(BilletHotsendTypeConfig::getCastMachine, ccmNo)
 					.eq(BilletHotsendTypeConfig::getTypeName, isStorageBill.getDestination());
 			BilletHotsendTypeConfig billetHotsendTypeConfig = billetHotsendTypeConfigService.getOne(queryWrapper3);
-			log.info("{}{}", "C端自动化轧钢外运查询到钢坯配置信息:", JSON.toJSON(billetHotsendTypeConfig));
+			if (oConvertUtils.isEmpty(billetHotsendTypeConfig)){
+				log.info("{}{}", "C端自动化热装钢坯配置信息查询为空:", JSON.toJSON(isStorageBill));
+				return;
+			}
 			billetHotsendDetailsVo.setBelongTable(billetHotsendTypeConfig.getBelongTable());
 			billetHotsendDetailsVo.setBelongTypeName(billetHotsendTypeConfig.getTypeName());
 			billetHotsendDetailsVo.setBilletHotsendTypeConfigId(billetHotsendTypeConfig.getId());
@@ -375,10 +441,11 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 
 		List<RollClubCommon> rollClubCommonLists= new ArrayList<>();
 		AtomicInteger startNum = new AtomicInteger(0);
+		String finalCcmNo = ccmNo;
 		billetBasicInfoLists.forEach(x ->{
 			RollClubCommon rollClubCommon = new RollClubCommon();
 			BeanUtils.copyProperties(x, rollClubCommon);
-			rollClubCommon.setCcmNo(ccmNo);
+			rollClubCommon.setCcmNo(finalCcmNo);
 			rollClubCommon.setSize(x.getLength().toString());
 			rollClubCommon.setDecideWeight(x.getWeight());
 			rollClubCommon.setStartNum(startNum.get());
@@ -388,24 +455,24 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 		});
 		billetHotsendDetailsVo.setRollClubCommonList(rollClubCommonLists);
 
-		log.info("{}{}", "C端自动化轧钢外运数据转换<保存>参数:", JSON.toJSONString(billetHotsendDetailsVo));
+		log.info("{}{}", "C端自动化热装数据转换<保存>参数:", JSON.toJSONString(billetHotsendDetailsVo));
 
 		saveBilletCommomTrucking(billetHotsendDetailsVo);
 
-		log.info("{}{}", "C端自动化轧钢外运<保存>操作成功:", jsonObject);
+		log.info("{}{}", "C端自动化热装<保存>操作成功:", jsonObject);
 
 	}
 
 	@Override
 	public void autoDepartTrucking(JSONObject jsonObject) {
 
-		log.info("{}{}", "C端自动化轧钢外运<直接发车>参数:", jsonObject);
+		log.info("{}{}", "C端自动化离站发车接收mqtt参数:", jsonObject);
 
 		String ccmNo = jsonObject.getString("ccmNo");
 		String licensePlate = jsonObject.getString("licensePlate");
 		String positionNum = jsonObject.getString("positionNum");
 		if (oConvertUtils.isEmpty(ccmNo) || oConvertUtils.isEmpty(positionNum)){
-			log.info("{}{}", "参数为空，C端自动化轧钢外运<直接发车>失败！", jsonObject);
+			log.info("{}{}", "参数为空，C端自动化离站发车失败！", jsonObject);
 			return;
 		}
 
@@ -413,16 +480,15 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 		 * 根据车牌号和铸机号 查询当天未发车的车辆信息
 		 */
 		LambdaQueryWrapper<StorageBill> queryWrapper = new LambdaQueryWrapper<>();
-		queryWrapper.eq(StorageBill::getCcmNo, ccmNo)
-				.eq(StorageBill::getPositionNum, positionNum)
+		queryWrapper.eq(StorageBill::getPositionNum, positionNum)
 				.isNull(StorageBill::getOutTime)
-				.orderByDesc(StorageBill::getCreateTime).last("limit 1");;
+				.orderByDesc(StorageBill::getCreateTime).last("limit 1");
 		StorageBill storageBill = storageBillService.getOne(queryWrapper);
 		if (oConvertUtils.isEmpty(storageBill)){
-			log.info("{}{}", "该车装运单信息不存在，自动化轧钢外运<直接发车>失败！", jsonObject);
+			log.info("{}{}", "装运单信息不存在，C端自动化离站发车失败！", jsonObject);
 			BilletAutoException billetAutoException = createBilletAutoException(ccmNo, null, shiftGroupHandle(ccmNo), shiftHandle(ccmNo), null);
 			billetAutoException.setRemark(licensePlate);
-			billetAutoException.setMassage("C端该车装运单信息不存在，自动化轧钢外运<直接发车>失败!");
+			billetAutoException.setMassage("装运单信息不存在，C端自动化离站发车失败!");
 			billetAutoExceptionService.save(billetAutoException);
 			return;
 		}
@@ -433,7 +499,7 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 
 		// 判断装运单，是否有装运信息，装运总支数为0时，手动发车失败
 		if (storageBill.getAmountTotal() == null || storageBill.getAmountTotal() == 0) {
-			log.info("C端自动化离站发车，钢坯装运信息为空，发车成功！{}", JSON.toJSON(storageBill));
+			log.info("钢坯装运信息为空，C端自动化离站发车成功！{}", JSON.toJSON(storageBill));
 			storageBillService.updateById(storageBill);
 			return;
 		}
@@ -479,7 +545,7 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 		storageCarLog.setDataTime(new Date());
 		storageCarLog.setAmount(storageBill.getAmountTotal());// 支数
 		storageCarLogService.save(storageCarLog);
-		log.info("{}{}", "C端自动化轧钢外运直接发车操作成功!:", licensePlate);
+		log.info("{}{}", "C端自动化离站发车成功!:", licensePlate + "<——>" + storageBill.getId());
 
 	}
 
@@ -527,14 +593,14 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 				.eq(BilletHotsendChangeShift::getShiftGroup, cacheShintGroup)
 				.orderByDesc(BilletHotsendChangeShift::getCreateTime).last("limit 1");
 		BilletHotsendChangeShift billetHotsendChangeShift = billetHotsendChangeShiftService.getOne(queryWrapperCS, false);
-		log.info("{}{}", "自动化轧钢外运，当班信息:", JSON.toJSON(billetHotsendChangeShift));
+		log.info("{}{}", "自动化BilletHotsendChangeShift当班信息:", JSON.toJSON(billetHotsendChangeShift));
 		if (oConvertUtils.isNotEmpty(billetHotsendChangeShift)) {
 			if ("hotSend".equals(type)){
 				billetHotsendChangeShift.setHotsendAmount(billetHotsendChangeShift.getHotsendAmount() + sum);
-				log.info(">>>>>自动化轧钢外运，统计当前班次《热送》总支数:{} 班组：{} 班次：{}", billetHotsendChangeShift.getHotsendAmount(), cacheShintGroup, cacheShint);
+				log.info(">>>>>自动化统计当前班次《热送》总支数:{} 班组：{} 班次：{}", billetHotsendChangeShift.getHotsendAmount(), cacheShintGroup, cacheShint);
 			}else if ("hotCharge".equals(type)){
 				billetHotsendChangeShift.setHotfeignAmount(billetHotsendChangeShift.getHotfeignAmount() + sum);
-				log.info(">>>>>自动化轧钢外运，统计当前班次《热装》总支数:{} 班组：{} 班次：{}", billetHotsendChangeShift.getHotfeignAmount(), cacheShintGroup, cacheShint);
+				log.info(">>>>>自动化统计当前班次《热装》总支数:{} 班组：{} 班次：{}", billetHotsendChangeShift.getHotfeignAmount(), cacheShintGroup, cacheShint);
 			}
 			billetHotsendChangeShiftService.updateById(billetHotsendChangeShift);
 		}
@@ -563,7 +629,8 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 			BilletAutoException billetAutoException = createBilletAutoException(billetHotsend.getCcmNo(), String.join(",", billetNos), billetHotsend.getShiftGroup(), billetHotsend.getShift(), billetHotsendTypeConfig);
 			billetAutoException.setMassage("钢坯热送信息不存在，自动化棒线操作失败!");
 			billetAutoExceptionService.save(billetAutoException);
-			result.put("fail", "钢坯热送信息不存在，自动化棒线操作失败！");
+			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+			result.put("fail", "钢坯热送传递单不存在，自动化棒线操作失败！");
 			return result;
 		}
 		if ("roll_club_one".equals(billetHotsendDetailsVo.getBelongTable()) && "0".equals(billetHotsendTypeConfig.getBelongType().toString())){
@@ -644,6 +711,7 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 				rollClubOneDetails.setLicensePlate("辊道");
 				rollClubOneDetails.setSize(String.valueOf(x.getLength()));
 				rollClubOneDetails.setSteel(x.getGrade());
+				rollClubOneDetails.setUpdateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				rollClubOneDetails.setCreateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				rollClubOneDetails.setBlankOutput(x.getBilletWeight());//出坯量
 				rollClubOneDetailsList.add(rollClubOneDetails);
@@ -692,6 +760,7 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 				rollClubTwoDetails.setLicensePlate(storageBill.getLicensePlate());
 				rollClubTwoDetails.setSize(String.valueOf(x.getLength()));
 				rollClubTwoDetails.setSteel(x.getGrade());
+				rollClubTwoDetails.setUpdateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				rollClubTwoDetails.setCreateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				rollClubTwoDetails.setBlankOutput(x.getBilletWeight());//出坯量
 				rollClubTwoDetailsList.add(rollClubTwoDetails);
@@ -740,6 +809,7 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 				rollClubThreeDetails.setLicensePlate(storageBill.getLicensePlate());
 				rollClubThreeDetails.setSize(String.valueOf(x.getLength()));
 				rollClubThreeDetails.setSteel(x.getGrade());
+				rollClubThreeDetails.setUpdateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				rollClubThreeDetails.setCreateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				rollClubThreeDetails.setBlankOutput(x.getBilletWeight());//出坯量
 				rollClubThreeDetailsList.add(rollClubThreeDetails);
@@ -816,6 +886,7 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 				rollHeightDetails.setLicensePlate("辊道");
 				rollHeightDetails.setSize(String.valueOf(x.getLength()));
 				rollHeightDetails.setSteel(x.getGrade());
+				rollHeightDetails.setUpdateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				rollHeightDetails.setCreateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				rollHeightDetails.setBlankOutput(x.getBilletWeight());//出坯量
 				rollHeightDetailsList.add(rollHeightDetails);
@@ -867,6 +938,7 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 				rollOutShippDetails.setLicensePlate(storageBill.getLicensePlate());
 				rollOutShippDetails.setSize(String.valueOf(x.getLength()));
 				rollOutShippDetails.setSteel(x.getGrade());
+				rollOutShippDetails.setUpdateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				rollOutShippDetails.setCreateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				rollOutShippDetails.setBlankOutput(x.getBilletWeight());//出坯量
 				rollOutShippDetailsList.add(rollOutShippDetails);
@@ -889,6 +961,7 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 				billetAutoTmp.setLicensePlate(storageBill.getLicensePlate());
 				billetAutoTmp.setSize(String.valueOf(x.getLength()));
 				billetAutoTmp.setSteel(x.getGrade());
+				billetAutoTmp.setUpdateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				billetAutoTmp.setCreateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
 				billetAutoTmp.setBlankOutput(x.getBilletWeight());//出坯量
 				billetAutoTmpList.add(billetAutoTmp);
@@ -977,7 +1050,7 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 			JSONObject jsonObject = commonBilletHotsenAndDetailsHandle(billetHotsend, billetHotsendDetailsVo, billetHotsendTypeConfig, storageBill, groupRollClubCommonList);
 			if (jsonObject.containsKey("fail")){
 				TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-				log.info("{}{}", "自动化棒线轧钢外运钢坯热送信息查询、明细 新增、更新失败！事务回滚", jsonObject);
+				log.info("{}{}", "C端自动化轧钢外运，钢坯热送信息查询、明细 新增、更新失败！事务回滚:", jsonObject);
 				return jsonObject;
 			}
 		}
@@ -989,7 +1062,8 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 				.in(BilletBasicInfo::getBilletNo, billetNos);
 		List<BilletBasicInfo> billetBasicInfoList = billetBasicInfoService.list(queryWrapperls);
 		if (oConvertUtils.listIsEmpty(billetBasicInfoList)) {
-			log.info("{}{}", "钢坯基础信息为空，C端自动化钢坯轧钢外运保存失败！", billetNos);
+			log.info("{}{}", ">>>>>>钢坯实绩查询为空，C端自动化轧钢外运保存失败，事务回滚:", billetNos);
+			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
 			result.put("fail", "钢坯基础信息为空，C端自动化钢坯轧钢外运保存失败！");
 			return result;
 		}
@@ -1033,30 +1107,55 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 			result.put("fail", "钢坯装运单不存在，C端自动化轧钢外运保存操作失败！");
 			return result;
 		}
-		storageBillInfo.setAmountTotal(storageBillInfo.getAmountTotal() + rollClubCommonList.size());
+
 		// 取最新的第一条钢坯信息
-		RollClubCommon rollClubCommon = rollClubCommonList.stream().findFirst().orElse(null);
-		if (rollClubCommon != null) {
-			storageBillInfo.setSteel(rollClubCommon.getGrade());//钢种
-			storageBillInfo.setSpec(rollClubCommon.getSpec());//规格
-			storageBillInfo.setHeatNo(rollClubCommon.getHeatNo());// 炉号
+		BilletBasicInfo billetBasicInfo = billetBasicInfoList.stream().findFirst().orElse(null);
+		if (billetBasicInfo != null) {
+			storageBillInfo.setSteel(billetBasicInfo.getGrade());//钢种
+			storageBillInfo.setSpec(billetBasicInfo.getSpec());//规格
+			storageBillInfo.setHeatNo(billetBasicInfo.getHeatNo());// 炉号
+		}
+		// 装运单编辑确认目的地，同步时，维护定尺
+		List<Integer> sizeIntList = billetBasicInfoList.stream().map(BilletBasicInfo::getLength).distinct().collect(Collectors.toList());
+		List<String> sizeStrList = sizeIntList.stream().map(String::valueOf).collect(Collectors.toList());
+		if(oConvertUtils.listIsNotEmpty(sizeStrList)) {
+			String distinctSizeStr = sizeIntList.stream()
+					.distinct()
+					.map(String::valueOf)
+					.collect(Collectors.joining(","));
+			String finalSizeStr = Optional.ofNullable(storageBillInfo.getSize())
+					.filter(oConvertUtils::isNotEmpty)
+					.map(s -> s + "," + distinctSizeStr)
+					.orElse(distinctSizeStr);
+			// 对 finalSizeStr 再次去重
+			String[] sizeArray = finalSizeStr.split(",");
+			Set<String> uniqueSizes = Arrays.stream(sizeArray)
+					.filter(s -> s != null && !s.isEmpty())
+					.collect(Collectors.toCollection(HashSet::new));
+			finalSizeStr = String.join(",", uniqueSizes);
+			storageBillInfo.setSize(finalSizeStr);
 		}
-		List<Integer> sizeList = rollClubCommonList.stream().map(RollClubCommon::getLength).distinct().collect(Collectors.toList());
-		List<String> sizeLists = sizeList.stream().map(String::valueOf).collect(Collectors.toList());
-		String sizeString = String.join(",", sizeLists);
-		storageBillInfo.setSize(sizeString);// 定尺
-		List<String> stringList = billetBasicInfoList.stream().map(BilletBasicInfo::getAssemblyNumber).filter(assemblyNumber -> oConvertUtils.isNotEmpty(assemblyNumber)).collect(Collectors.toList());
-		if(oConvertUtils.listIsNotEmpty(stringList)) {
-			String distinctAssemblyNumber = billetBasicInfoList.stream()
-					.map(BilletBasicInfo::getAssemblyNumber)
-					.filter(assemblyNumber -> oConvertUtils.isNotEmpty(assemblyNumber))
-					.distinct().collect(Collectors.joining(","));
+
+		// 装运单编辑确认目的地，同步时，维护组批号
+		List<String> assemblyNumberList = billetBasicInfoList.stream().map(BilletBasicInfo::getAssemblyNumber)
+				.filter(assemblyNumber -> oConvertUtils.isNotEmpty(assemblyNumber)).collect(Collectors.toList());
+		if(oConvertUtils.listIsNotEmpty(assemblyNumberList)) {
+			String distinctAssemblyNumber = assemblyNumberList.stream().distinct().collect(Collectors.joining(","));
 			String finalAssemblyNumber = Optional.ofNullable(storageBillInfo.getAssemblyNumber())
 					.filter(oConvertUtils::isNotEmpty)
 					.map(s -> s + "," + distinctAssemblyNumber)
 					.orElse(distinctAssemblyNumber);
+
+			// 对 finalAssemblyNumber 再次去重
+			String[] assemblyNumberArray = finalAssemblyNumber.split(",");
+			Set<String> uniqueAssemblyNumbers = Arrays.stream(assemblyNumberArray)
+					.filter(s -> s != null && !s.isEmpty())
+					.collect(Collectors.toCollection(HashSet::new));
+			finalAssemblyNumber = String.join(",", uniqueAssemblyNumbers);
 			storageBillInfo.setAssemblyNumber(finalAssemblyNumber);
 		}
+
+		storageBillInfo.setAmountTotal(storageBillInfo.getAmountTotal() + rollClubCommonList.size());
 		storageBillInfo.setBtype("0");
 		storageBillService.updateById(storageBillInfo);
 
@@ -1095,11 +1194,11 @@ public class BilletHotsendBaseServiceImpl extends ServiceImpl<BilletHotsendBaseM
 			billetHotsend.setShiftGroup(parts[1]);// 班组
 			billetHotsend.setShift(parts[2]);// 班别
 			List<RollClubCommon> groupRollClubCommonList = entry.getValue();
-			log.info("{}{}", "自动化5号机棒一、6号机高线热送单信息:", JSON.toJSON(billetHotsend));
+			log.info("{}{}", billetHotsend.getCcmNo() + "#自动化热送高线或直轧棒一传递单信息:", JSON.toJSON(billetHotsend));
 			JSONObject jsonObject = commonBilletHotsenAndDetailsHandle(billetHotsend, billetHotsendDetailsVo, billetHotsendTypeConfig, null, groupRollClubCommonList);
 			if (jsonObject.containsKey("fail")){
 				TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-				log.info("{}{}", "自动化直轧和高线钢坯操作失败，事务回滚！", jsonObject);
+				log.info("{}{}", billetHotsend.getCcmNo() + "自动化热送高线或直轧棒一钢坯操作失败事务回滚！", jsonObject);
 				return jsonObject;
 			}
 			List<String> billetNos = groupRollClubCommonList.stream().map(RollClubCommon::getBilletNo).collect(Collectors.toList());

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/billetActual/service/impl/BilletHotsendChangeShiftServiceImpl.java

@@ -60,7 +60,7 @@ public class BilletHotsendChangeShiftServiceImpl extends ServiceImpl<BilletHotse
     @Transactional(rollbackFor = Exception.class)
     public void autoChangeShift(JSONObject jsonObj) {
 
-        log.info("{}{}", "C端自动化交班请求参数：", jsonObj);
+        log.info("{}{}", "5号机C端自动化交班请求参数：", jsonObj);
 
         String autoChangeShiftLimitKey = String.format("autoChangeShift:execution:%s", "5");
 
@@ -83,37 +83,48 @@ public class BilletHotsendChangeShiftServiceImpl extends ServiceImpl<BilletHotse
         String nextshiftIdKey = String.format("class:nextshift:Id:%s", "5");
         String currentCacheId = oConvertUtils.getString(redisTemplate.opsForValue().get(nextshiftIdKey));
 
-        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " C端自动化当前班次信息值:" + sixShift+ ","+ sixShiftGroup);
-        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " C端自动化当前班次信息名:" + currentCacheId + "," + currentShiftName+ ","+ currentShiftGroupName);
+        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " 5号机C端自动化当前班次信息值:" + sixShift+ ","+ sixShiftGroup);
+        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " 5号机C端自动化当前班次信息名:" + currentCacheId + "," + currentShiftName+ ","+ currentShiftGroupName);
 
         String[] data = {
-                "1 丙 夜", "2 甲 白", "3 乙 中", "4 丙 夜", "5 甲 白", "6 乙 中", "7 丙 夜", "8 甲 白", "9 乙 中", "10 丙 夜",
-                "11 甲 白", "12 乙 中", "13 丁 夜", "14 丙 白", "15 甲 中", "16 丁 夜", "17 丙 白", "18 甲 中", "19 丁 夜", "20 丙 白",
-                "21 甲 中", "22 丁 夜", "23 丙 白", "24 甲 中", "25 乙 夜", "26 丁 白", "27 丙 中", "28 乙 夜", "29 丁 白", "30 丙 中",
-                "31 乙 夜", "32 丁 白", "33 丙 中", "34 乙 夜", "35 丁 白", "36 丙 中", "37 甲 夜", "38 乙 白", "39 丁 中", "40 甲 夜",
-                "41 乙 白", "42 丁 中", "43 甲 夜", "44 乙 白", "45 丁 中", "46 甲 夜", "47 乙 白", "48 丁 中"
+                "1 丙", "2 甲", "3 乙", "4 丙", "5 甲", "6 乙", "7 丙", "8 甲", "9 乙", "10 丙",
+                "11 甲", "12 乙", "13 丁", "14 丙", "15 甲", "16 丁", "17 丙", "18 甲", "19 丁", "20 丙",
+                "21 甲", "22 丁", "23 丙", "24 甲", "25 乙", "26 丁", "27 丙", "28 乙", "29 丁", "30 丙",
+                "31 乙", "32 丁", "33 丙", "34 乙", "35 丁", "36 丙", "37 甲", "38 乙", "39 丁", "40 甲",
+                "41 乙", "42 丁", "43 甲", "44 乙", "45 丁", "46 甲", "47 乙", "48 丁"
         };
 
-        ShiftInfo nextShiftInfo = ScheduleUtils.findNextShift(data, Integer.valueOf(currentCacheId), currentShiftGroupName, currentShiftName);
-        if (nextShiftInfo == null){
-            log.info("{}{}", "获取到下个班组信息为空!", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + "C端自动化交班失败！");
+        ShiftInfo nextShiftGroupInfo = ScheduleUtils.findNextShift(data, Integer.valueOf(currentCacheId), currentShiftGroupName);
+        if (nextShiftGroupInfo == null){
+            log.info("{}{}", "5号机获取到下个班组信息为空!", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + "C端自动化交班失败！");
             return;
         }
+        // 班别名（白中夜）
+        String nextShiftName  = "";
+        // 验证23:00 到01:00 之间
+        if (ScheduleUtils.isBetweenTime(new Date(), "07:40", "08:30")) {
+            nextShiftName = "白";
+        } else if (ScheduleUtils.isBetweenTime(new Date(), "15:40", "16:30")) {
+            nextShiftName = "中";
+        } else if (ScheduleUtils.isBetweenTime(new Date(), "23:40", "00:30")) {
+            nextShiftName = "夜";
+        }else {
+            log.info("{}{}", "未在交班范围内，", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + "5号机C端自动化交班失败！");
+            return;
+        }
+        // 班组名（甲乙丙丁）
+        String nextShiftGroupName =  nextShiftGroupInfo.getShift();
+        // 班组值
+        String finalNextShiftGroupVal = ShiftGroupEnum.getCodeByName(nextShiftGroupName);
+        // 班别值
+        String finalNextShiftVal = ShiftEnum.getCodeByName(nextShiftName + "班");
 
-        String nextShiftGroupName = nextShiftInfo.getShiftgroup();
-
-        String nextShiftName = nextShiftInfo.getShift();
-
-        int nextUniqueShiftId = nextShiftInfo.getId();
-
-        String finalNextShiftGroupVal = ShiftGroupEnum.getCodeByName(nextShiftName);
-
-        String finalNextShiftVal = ShiftEnum.getCodeByName(nextShiftGroupName + "班");;
+        int nextUniqueShiftId = nextShiftGroupInfo.getId();
 
         redisTemplate.opsForValue().set(nextshiftIdKey, nextUniqueShiftId);
 
-        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " C端自动化下一个班次信息值:" + finalNextShiftVal + ","+ finalNextShiftGroupVal);
-        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " C端自动化下一个班次信息名:" + nextUniqueShiftId + "," + nextShiftGroupName + ","+ nextShiftName);
+        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " 5号机C端自动化下一个班次信息值:" + finalNextShiftVal + ","+ finalNextShiftGroupVal);
+        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " 5号机C端自动化下一个班次信息名:" + nextUniqueShiftId + "," + nextShiftGroupName + ","+ nextShiftName);
 
         // 设置键并设置过期时间
         redisTemplate.opsForValue().set(autoChangeShiftLimitKey,"executed", EXPIRE_TIME, EXPIRE_TIME_UNIT);
@@ -138,124 +149,326 @@ public class BilletHotsendChangeShiftServiceImpl extends ServiceImpl<BilletHotse
 //            }
 //        }
         BilletHotsendChangeShift billetHotsendChangeShiftVo = new BilletHotsendChangeShift();
+        billetHotsendChangeShiftVo.setCcmNo("5");
         billetHotsendChangeShiftVo.setShiftGroup(finalNextShiftGroupVal);
         billetHotsendChangeShiftVo.setShift(finalNextShiftVal);
         JSONObject jsonObject = autoChangeShiftHandle(billetHotsendChangeShiftVo, sixShiftGroup, sixShift);
-        log.info("C端5号机自动化交班结果:{}{}", jsonObject, DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()));
+        log.info("5号机C端自动化交班结果:{}{}", jsonObject, DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()));
+    }
+
+    @Override
+    public void autoChangeShiftSix(JSONObject jsonObj) {
+
+        log.info("{}{}", "C端6号机自动化交班请求参数：", jsonObj);
+
+        String autoChangeShiftLimitKey = String.format("autoChangeShift:execution:%s", "6");
+
+        // 检查键是否存在
+        Boolean isExecutedRecently = redisTemplate.hasKey(autoChangeShiftLimitKey);
+        if (isExecutedRecently == null || isExecutedRecently) {
+            log.info("{}{}", "6号机自动化交班10分钟内已有交班记录，执行失败！", jsonObj);
+            return;
+        }
+
+        String keyShiftGroupsix = String.format("class:shift:group:%s", "6");
+        String keyShiftsix = String.format("class:shift:%s", "6");
+
+        String sixShiftGroup = oConvertUtils.getString(redisTemplate.opsForValue().get(keyShiftGroupsix));
+        String sixShift = oConvertUtils.getString(redisTemplate.opsForValue().get(keyShiftsix));
+
+        String currentShiftGroupName = ShiftGroupEnum.fromCode(sixShiftGroup).name();
+        String currentShiftName = ShiftEnum.fromCode(sixShift).name().replace("班", "");
+
+        String nextshiftIdKey = String.format("class:nextshift:Id:%s", "6");
+        String currentCacheId = oConvertUtils.getString(redisTemplate.opsForValue().get(nextshiftIdKey));
+
+        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " 6号机C端自动化当前班次信息值:" + sixShift+ ","+ sixShiftGroup);
+        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " 6号机C端自动化当前班次信息名:" + currentCacheId + "," + currentShiftName+ ","+ currentShiftGroupName);
+
+        String[] data = {
+                "1 丙", "2 甲", "3 乙", "4 丙", "5 甲", "6 乙", "7 丙", "8 甲", "9 乙", "10 丙",
+                "11 甲", "12 乙", "13 丁", "14 丙", "15 甲", "16 丁", "17 丙", "18 甲", "19 丁", "20 丙",
+                "21 甲", "22 丁", "23 丙", "24 甲", "25 乙", "26 丁", "27 丙", "28 乙", "29 丁", "30 丙",
+                "31 乙", "32 丁", "33 丙", "34 乙", "35 丁", "36 丙", "37 甲", "38 乙", "39 丁", "40 甲",
+                "41 乙", "42 丁", "43 甲", "44 乙", "45 丁", "46 甲", "47 乙", "48 丁"
+        };
+
+        ShiftInfo nextShiftGroupInfo = ScheduleUtils.findNextShift(data, Integer.valueOf(currentCacheId), currentShiftGroupName);
+        if (nextShiftGroupInfo == null){
+            log.info("{}{}", "6号机获取到下个班组信息为空!", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + "6号机C端自动化交班失败！");
+            return;
+        }
+
+        // 班别名
+        String nextShiftName  = "";
+        // 验证23:00 到01:00 之间
+        if (ScheduleUtils.isBetweenTime(new Date(), "07:40", "08:30")) {
+            nextShiftName = "白";
+        } else if (ScheduleUtils.isBetweenTime(new Date(), "15:40", "16:30")) {
+            nextShiftName = "中";
+        } else if (ScheduleUtils.isBetweenTime(new Date(), "23:40", "00:30")) {
+            nextShiftName = "夜";
+        }else {
+            log.info("{}{}", "未在交班范围内，", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + "6号机C端自动化交班失败！");
+            return;
+        }
+        // 班组名
+        String nextShiftGroupName =  nextShiftGroupInfo.getShift();
+        // 班组值
+        String finalNextShiftGroupVal = ShiftGroupEnum.getCodeByName(nextShiftGroupName);
+        // 班别值
+        String finalNextShiftVal = ShiftEnum.getCodeByName(nextShiftName + "班");
+
+        int nextUniqueShiftId = nextShiftGroupInfo.getId();
+
+        redisTemplate.opsForValue().set(nextshiftIdKey, nextUniqueShiftId);
+
+        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " 6号机C端自动化下一个班次信息值:" + finalNextShiftVal + ","+ finalNextShiftGroupVal);
+        log.info(DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()) + " 6号机C端自动化下一个班次信息名:" + nextUniqueShiftId + "," + nextShiftGroupName + ","+ nextShiftName);
+
+        // 设置键并设置过期时间
+        redisTemplate.opsForValue().set(autoChangeShiftLimitKey,"executed", EXPIRE_TIME, EXPIRE_TIME_UNIT);
+        BilletHotsendChangeShift billetHotsendChangeShiftVo = new BilletHotsendChangeShift();
+        billetHotsendChangeShiftVo.setCcmNo("6");
+        billetHotsendChangeShiftVo.setShiftGroup(finalNextShiftGroupVal);
+        billetHotsendChangeShiftVo.setShift(finalNextShiftVal);
+        JSONObject jsonObject = autoSixChangeShiftHandle(billetHotsendChangeShiftVo, sixShiftGroup, sixShift);
+        log.info("6号机C端自动化交班结果:{}{}", jsonObject, DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()));
+    }
+
+    private JSONObject autoSixChangeShiftHandle(BilletHotsendChangeShift billetHotsendChangeShiftVo, String currentShiftGroup, String currentShift) {
+        JSONObject result = new JSONObject();
+        // 缓存交班索引ID
+        String ccmNo = billetHotsendChangeShiftVo.getCcmNo();
+        String nextshiftIdKey = String.format("class:nextshift:Id:%s", ccmNo);
+        String keyShiftGroup = String.format("class:shift:group:%s", ccmNo);
+        String keyShift = String.format("class:shift:%s", ccmNo);
+        // 保存旧的缓存值，用于异常回滚
+        String oldShiftGroup = Optional.ofNullable(redisTemplate.opsForValue().get(keyShiftGroup))
+                .map(Object::toString)
+                .orElse(null);
+        String oldShift = Optional.ofNullable(redisTemplate.opsForValue().get(keyShift))
+                .map(Object::toString)
+                .orElse(null);
+        try {
+            // 先更新班组班别缓存
+            redisTemplate.opsForValue().set(keyShiftGroup, billetHotsendChangeShiftVo.getShiftGroup());
+            redisTemplate.opsForValue().set(keyShift, billetHotsendChangeShiftVo.getShift());
+
+            // 获取当前班组班别
+            BilletHotsendChangeShift billetHotsendChangeShift = baseMapper.selectOne(new LambdaQueryWrapper<BilletHotsendChangeShift>()
+                    .eq(BilletHotsendChangeShift::getCcmNo, ccmNo)
+                    .orderByDesc(BilletHotsendChangeShift::getCreateTime)
+                    .last("limit 1"));
+            if (oConvertUtils.isEmpty(billetHotsendChangeShift)) {
+                result.put("fail", "当班信息查询为空，6号机自动化交班操作失败！");
+                // 自动交班失败，交班ID索引值回滚，保证交班顺序
+                String nextCacheIdRollBack = oConvertUtils.getString(redisTemplate.opsForValue().get(nextshiftIdKey));
+                int nextCacheIdRollBacks = Integer.parseInt(nextCacheIdRollBack);
+                redisTemplate.opsForValue().set(nextshiftIdKey, nextCacheIdRollBacks - 1);
+                // 班组班别回滚
+                redisTemplate.opsForValue().set(keyShiftGroup, oldShiftGroup);
+                redisTemplate.opsForValue().set(keyShift, oldShift);
+                return result;
+            }
+            // 更新当前班次的交班时间，相当于上一个班交班的结束时间
+            billetHotsendChangeShift.setChangeShiftTime(new Date());
+            billetHotsendChangeShift.setUpdateTime(new Date());
+            baseMapper.updateById(billetHotsendChangeShift);
+
+            // 生成新的交班记录 初始化并保存入库
+            BilletHotsendChangeShift billetHotsendChangeShift1 = new BilletHotsendChangeShift();
+            billetHotsendChangeShift1.setId(String.valueOf(IdWorker.getId()));
+            billetHotsendChangeShift1.setCcmNo(ccmNo);
+            billetHotsendChangeShift1.setShift(billetHotsendChangeShiftVo.getShift());
+            billetHotsendChangeShift1.setShiftGroup(billetHotsendChangeShiftVo.getShiftGroup());
+            billetHotsendChangeShift1.setHotfeignAmount(0); // 当前热装支数
+            billetHotsendChangeShift1.setProductAmount(0); // 当前生产支数
+            billetHotsendChangeShift1.setHotsendAmount(0); // 当前热送支数
+            billetHotsendChangeShift1.setStackAmount(0); // 当前起垛支数
+            billetHotsendChangeShift1.setOutCarNum(0); // 车次
+            billetHotsendChangeShift1.setShiftSum(0); // 当班总数
+            billetHotsendChangeShift1.setShiftProduct(0d); // 当班总重
+            billetHotsendChangeShift1.setWasteAmount(0); // 当前废品支数
+            billetHotsendChangeShift1.setWasteBlankOutput(0d);
+            billetHotsendChangeShift1.setCreateTime(new Date());
+            // 3.19 新增班次实绩
+            billetHotsendChangeShift1.setShiftHotsendAmount(0);
+            billetHotsendChangeShift1.setShiftHotsendWeight(0d);
+
+            billetHotsendChangeShift1.setShiftHotfeignAmount(0);
+            billetHotsendChangeShift1.setShiftHotfeignWeight(0d);
+
+            billetHotsendChangeShift1.setShiftStackAmount(0);
+            billetHotsendChangeShift1.setShiftStackWeight(0d);
+
+            billetHotsendChangeShift1.setAllCarNum(0);
+            billetHotsendChangeShift1.setCounts(0);
+            billetHotsendChangeShift1.setBlankOutputs(0d);
+            baseMapper.insert(billetHotsendChangeShift1);
+
+            /**
+             * 6号机根据 铸机号、当班班组、当班班别 查询储运配置信息，倒序取最新的一条，把查询到的牌号、定尺、目的地、新/旧站台
+             * 带到下一个班组中，生成一个新的储运配置信息，并保存到数据库中
+             */
+            LambdaQueryWrapper<ShiftConfiguration> queryWrapper = new LambdaQueryWrapper<ShiftConfiguration>();
+            queryWrapper.eq(ShiftConfiguration::getCcmNo, "6")
+                    .eq(ShiftConfiguration::getShiftGroup, currentShiftGroup)
+                    .eq(ShiftConfiguration::getShift, currentShift)
+                    .orderByDesc(ShiftConfiguration::getCreateTime)
+                    .last("limit 1");
+            ShiftConfiguration shiftConfiguration = shiftConfigurationService.getOne(queryWrapper);
+            if (shiftConfiguration != null){
+                // 生出储运配置信息
+                ShiftConfiguration newShiftConfiguration = new ShiftConfiguration();
+                newShiftConfiguration.setId(String.valueOf(IdWorker.getId()));
+                newShiftConfiguration.setCcmNo(ccmNo);
+                newShiftConfiguration.setShiftGroup(billetHotsendChangeShiftVo.getShiftGroup());
+                newShiftConfiguration.setShift(billetHotsendChangeShiftVo.getShift());
+                newShiftConfiguration.setSteelGrade(shiftConfiguration.getSteelGrade());
+                newShiftConfiguration.setSpec(shiftConfiguration.getSpec());
+                newShiftConfiguration.setDestination(shiftConfiguration.getDestination());
+                newShiftConfiguration.setNewOldPlatform(shiftConfiguration.getNewOldPlatform());
+                newShiftConfiguration.setCreateTime(new Date());
+                newShiftConfiguration.setDate(DateUtils.getDateWithOnlyYearMonthDay(new Date()));
+                shiftConfigurationService.save(newShiftConfiguration);
+                log.info("{}{}", "6号机自动化交班时生成储运配置：", JSON.toJSON(newShiftConfiguration));
+            }
+            result.put("success", "6号机自动化交班操作成功！");
+        } catch (Exception e) {
+            log.error("6号机自动化交班操作出现异常", e);
+            // 回滚缓存
+            if (oldShiftGroup != null && oldShift != null) {
+                redisTemplate.opsForValue().set(keyShiftGroup, oldShiftGroup);
+                redisTemplate.opsForValue().set(keyShift, oldShift);
+            }
+            // 自动交班失败，交班ID索引值回滚，保证交班顺序
+            String nextCacheIdRollBack = oConvertUtils.getString(redisTemplate.opsForValue().get(nextshiftIdKey));
+            int nextCacheIdRollBacks = Integer.parseInt(nextCacheIdRollBack);
+            redisTemplate.opsForValue().set(nextshiftIdKey, nextCacheIdRollBacks - 1);
+            result.put("fail", "6号机自动化交班操作失败，出现异常！");
+        }
+        return result;
     }
 
+    /**
+     * 5号机自动化交班
+     * @param billetHotsendChangeShiftVo
+     * @param currentShiftGroup
+     * @param currentShift
+     * @return
+     */
     private JSONObject autoChangeShiftHandle(BilletHotsendChangeShift billetHotsendChangeShiftVo, String currentShiftGroup, String currentShift) {
         JSONObject result = new JSONObject();
         // 缓存交班索引ID
-        String nextshiftIdKey = String.format("class:nextshift:Id:%s", "5");
-        List<String> ccmNoList = Arrays.asList("5");
-        for (String ccmNo : ccmNoList){
-            String keyShiftGroup = String.format("class:shift:group:%s", ccmNo);
-            String keyShift = String.format("class:shift:%s", ccmNo);
-            // 保存旧的缓存值，用于异常回滚
-            String oldShiftGroup = Optional.ofNullable(redisTemplate.opsForValue().get(keyShiftGroup))
-                    .map(Object::toString)
-                    .orElse(null);
-            String oldShift = Optional.ofNullable(redisTemplate.opsForValue().get(keyShift))
-                    .map(Object::toString)
-                    .orElse(null);
-            try {
-                // 先更新班组班别缓存
-                redisTemplate.opsForValue().set(keyShiftGroup, billetHotsendChangeShiftVo.getShiftGroup());
-                redisTemplate.opsForValue().set(keyShift, billetHotsendChangeShiftVo.getShift());
-
-                // 获取当前班组班别
-                BilletHotsendChangeShift billetHotsendChangeShift = baseMapper.selectOne(new LambdaQueryWrapper<BilletHotsendChangeShift>()
-                        .eq(BilletHotsendChangeShift::getCcmNo, ccmNo)
-                        .orderByDesc(BilletHotsendChangeShift::getCreateTime)
-                        .last("limit 1"));
-                if (oConvertUtils.isEmpty(billetHotsendChangeShift)) {
-                    result.put("fail", "当班信息查询为空，自动化交班操作失败！");
-                    // 自动交班失败，交班ID索引值回滚，保证交班顺序
-                    String nextCacheIdRollBack = oConvertUtils.getString(redisTemplate.opsForValue().get(nextshiftIdKey));
-                    int nextCacheIdRollBacks = Integer.parseInt(nextCacheIdRollBack);
-                    redisTemplate.opsForValue().set(nextshiftIdKey, nextCacheIdRollBacks - 1);
-                    // 班组班别回滚
-                    redisTemplate.opsForValue().set(keyShiftGroup, oldShiftGroup);
-                    redisTemplate.opsForValue().set(keyShift, oldShift);
-                    return result;
-                }
-                // 更新当前班次的交班时间，相当于上一个班交班的结束时间
-                billetHotsendChangeShift.setChangeShiftTime(new Date());
-                billetHotsendChangeShift.setUpdateTime(new Date());
-                baseMapper.updateById(billetHotsendChangeShift);
-
-                // 生成新的交班记录 初始化并保存入库
-                BilletHotsendChangeShift billetHotsendChangeShift1 = new BilletHotsendChangeShift();
-                billetHotsendChangeShift1.setId(String.valueOf(IdWorker.getId()));
-                billetHotsendChangeShift1.setCcmNo(ccmNo);
-                billetHotsendChangeShift1.setShift(billetHotsendChangeShiftVo.getShift());
-                billetHotsendChangeShift1.setShiftGroup(billetHotsendChangeShiftVo.getShiftGroup());
-                billetHotsendChangeShift1.setHotfeignAmount(0); // 当前热装支数
-                billetHotsendChangeShift1.setProductAmount(0); // 当前生产支数
-                billetHotsendChangeShift1.setHotsendAmount(0); // 当前热送支数
-                billetHotsendChangeShift1.setStackAmount(0); // 当前起垛支数
-                billetHotsendChangeShift1.setOutCarNum(0); // 车次
-                billetHotsendChangeShift1.setShiftSum(0); // 当班总数
-                billetHotsendChangeShift1.setShiftProduct(0d); // 当班总重
-                billetHotsendChangeShift1.setWasteAmount(0); // 当前废品支数
-                billetHotsendChangeShift1.setCreateTime(new Date());
-                // 3.19 新增班次实绩
-                billetHotsendChangeShift1.setShiftHotsendAmount(0);
-                billetHotsendChangeShift1.setShiftHotsendWeight(0d);
-
-                billetHotsendChangeShift1.setShiftHotfeignAmount(0);
-                billetHotsendChangeShift1.setShiftHotfeignWeight(0d);
-
-                billetHotsendChangeShift1.setShiftStackAmount(0);
-                billetHotsendChangeShift1.setShiftStackWeight(0d);
-
-                billetHotsendChangeShift1.setAllCarNum(0);
-                billetHotsendChangeShift1.setCounts(0);
-                billetHotsendChangeShift1.setBlankOutputs(0d);
-                baseMapper.insert(billetHotsendChangeShift1);
-
-                /**
-                 * 5号机根据 铸机号、当班班组、当班班别 查询储运配置信息，倒序取最新的一条，把查询到的牌号、定尺、目的地、新/旧站台
-                 * 带到下一个班组中，生成一个新的储运配置信息，并保存到数据库中
-                 */
-                LambdaQueryWrapper<ShiftConfiguration> queryWrapper = new LambdaQueryWrapper<ShiftConfiguration>();
-                queryWrapper.eq(ShiftConfiguration::getCcmNo, "5")
-                        .eq(ShiftConfiguration::getShiftGroup, currentShiftGroup)
-                        .eq(ShiftConfiguration::getShift, currentShift)
-                        .orderByDesc(ShiftConfiguration::getCreateTime)
-                        .last("limit 1");
-                ShiftConfiguration shiftConfiguration = shiftConfigurationService.getOne(queryWrapper);
-                if (shiftConfiguration != null){
-                    // 生出储运配置信息
-                    ShiftConfiguration newShiftConfiguration = new ShiftConfiguration();
-                    newShiftConfiguration.setId(String.valueOf(IdWorker.getId()));
-                    newShiftConfiguration.setCcmNo(ccmNo);
-                    newShiftConfiguration.setShiftGroup(billetHotsendChangeShiftVo.getShiftGroup());
-                    newShiftConfiguration.setShift(billetHotsendChangeShiftVo.getShift());
-                    newShiftConfiguration.setSteelGrade(shiftConfiguration.getSteelGrade());
-                    newShiftConfiguration.setSpec(shiftConfiguration.getSpec());
-                    newShiftConfiguration.setDestination(shiftConfiguration.getDestination());
-                    newShiftConfiguration.setNewOldPlatform(shiftConfiguration.getNewOldPlatform());
-                    newShiftConfiguration.setCreateTime(new Date());
-                    newShiftConfiguration.setDate(DateUtils.getDateWithOnlyYearMonthDay(new Date()));
-                    shiftConfigurationService.save(newShiftConfiguration);
-                    log.info("{}{}", "5号机生成储运配置：", JSON.toJSON(newShiftConfiguration));
-                }
-                result.put("success", "5号机自动化交班操作成功！");
-            } catch (Exception e) {
-                log.error("自动化交班操作出现异常", e);
-                // 回滚缓存
-                if (oldShiftGroup != null && oldShift != null) {
-                    redisTemplate.opsForValue().set(keyShiftGroup, oldShiftGroup);
-                    redisTemplate.opsForValue().set(keyShift, oldShift);
-                }
+        String ccmNo = billetHotsendChangeShiftVo.getCcmNo();
+        String nextshiftIdKey = String.format("class:nextshift:Id:%s", ccmNo);
+        String keyShiftGroup = String.format("class:shift:group:%s", ccmNo);
+        String keyShift = String.format("class:shift:%s", ccmNo);
+        // 保存旧的缓存值，用于异常回滚
+        String oldShiftGroup = Optional.ofNullable(redisTemplate.opsForValue().get(keyShiftGroup))
+                .map(Object::toString)
+                .orElse(null);
+        String oldShift = Optional.ofNullable(redisTemplate.opsForValue().get(keyShift))
+                .map(Object::toString)
+                .orElse(null);
+        try {
+            // 先更新班组班别缓存
+            redisTemplate.opsForValue().set(keyShiftGroup, billetHotsendChangeShiftVo.getShiftGroup());
+            redisTemplate.opsForValue().set(keyShift, billetHotsendChangeShiftVo.getShift());
+
+            // 获取当前班组班别
+            BilletHotsendChangeShift billetHotsendChangeShift = baseMapper.selectOne(new LambdaQueryWrapper<BilletHotsendChangeShift>()
+                    .eq(BilletHotsendChangeShift::getCcmNo, ccmNo)
+                    .orderByDesc(BilletHotsendChangeShift::getCreateTime)
+                    .last("limit 1"));
+            if (oConvertUtils.isEmpty(billetHotsendChangeShift)) {
+                result.put("fail", "当班信息查询为空，5号机自动化交班操作失败！");
                 // 自动交班失败，交班ID索引值回滚，保证交班顺序
                 String nextCacheIdRollBack = oConvertUtils.getString(redisTemplate.opsForValue().get(nextshiftIdKey));
                 int nextCacheIdRollBacks = Integer.parseInt(nextCacheIdRollBack);
                 redisTemplate.opsForValue().set(nextshiftIdKey, nextCacheIdRollBacks - 1);
-                result.put("fail", "自动化交班操作失败，出现异常！");
+                // 班组班别回滚
+                redisTemplate.opsForValue().set(keyShiftGroup, oldShiftGroup);
+                redisTemplate.opsForValue().set(keyShift, oldShift);
+                return result;
+            }
+            // 更新当前班次的交班时间，相当于上一个班交班的结束时间
+            billetHotsendChangeShift.setChangeShiftTime(new Date());
+            billetHotsendChangeShift.setUpdateTime(new Date());
+            baseMapper.updateById(billetHotsendChangeShift);
+
+            // 生成新的交班记录 初始化并保存入库
+            BilletHotsendChangeShift billetHotsendChangeShift1 = new BilletHotsendChangeShift();
+            billetHotsendChangeShift1.setId(String.valueOf(IdWorker.getId()));
+            billetHotsendChangeShift1.setCcmNo(ccmNo);
+            billetHotsendChangeShift1.setShift(billetHotsendChangeShiftVo.getShift());
+            billetHotsendChangeShift1.setShiftGroup(billetHotsendChangeShiftVo.getShiftGroup());
+            billetHotsendChangeShift1.setHotfeignAmount(0); // 当前热装支数
+            billetHotsendChangeShift1.setProductAmount(0); // 当前生产支数
+            billetHotsendChangeShift1.setHotsendAmount(0); // 当前热送支数
+            billetHotsendChangeShift1.setStackAmount(0); // 当前起垛支数
+            billetHotsendChangeShift1.setOutCarNum(0); // 车次
+            billetHotsendChangeShift1.setShiftSum(0); // 当班总数
+            billetHotsendChangeShift1.setShiftProduct(0d); // 当班总重
+            billetHotsendChangeShift1.setWasteAmount(0); // 当前废品支数
+            billetHotsendChangeShift1.setWasteBlankOutput(0d);// 当前废品总重量
+            billetHotsendChangeShift1.setCreateTime(new Date());
+            // 3.19 新增班次实绩
+            billetHotsendChangeShift1.setShiftHotsendAmount(0);
+            billetHotsendChangeShift1.setShiftHotsendWeight(0d);
+
+            billetHotsendChangeShift1.setShiftHotfeignAmount(0);
+            billetHotsendChangeShift1.setShiftHotfeignWeight(0d);
+
+            billetHotsendChangeShift1.setShiftStackAmount(0);
+            billetHotsendChangeShift1.setShiftStackWeight(0d);
+
+            billetHotsendChangeShift1.setAllCarNum(0);
+            billetHotsendChangeShift1.setCounts(0);
+            billetHotsendChangeShift1.setBlankOutputs(0d);
+            baseMapper.insert(billetHotsendChangeShift1);
+
+            /**
+             * 5号机根据 铸机号、当班班组、当班班别 查询储运配置信息，倒序取最新的一条，把查询到的牌号、定尺、目的地、新/旧站台
+             * 带到下一个班组中，生成一个新的储运配置信息，并保存到数据库中
+             */
+            LambdaQueryWrapper<ShiftConfiguration> queryWrapper = new LambdaQueryWrapper<ShiftConfiguration>();
+            queryWrapper.eq(ShiftConfiguration::getCcmNo, ccmNo)
+                    .eq(ShiftConfiguration::getShiftGroup, currentShiftGroup)
+                    .eq(ShiftConfiguration::getShift, currentShift)
+                    .orderByDesc(ShiftConfiguration::getCreateTime)
+                    .last("limit 1");
+            ShiftConfiguration shiftConfiguration = shiftConfigurationService.getOne(queryWrapper);
+            if (shiftConfiguration != null){
+                // 生出储运配置信息
+                ShiftConfiguration newShiftConfiguration = new ShiftConfiguration();
+                newShiftConfiguration.setId(String.valueOf(IdWorker.getId()));
+                newShiftConfiguration.setCcmNo(ccmNo);
+                newShiftConfiguration.setShiftGroup(billetHotsendChangeShiftVo.getShiftGroup());
+                newShiftConfiguration.setShift(billetHotsendChangeShiftVo.getShift());
+                newShiftConfiguration.setSteelGrade(shiftConfiguration.getSteelGrade());
+                newShiftConfiguration.setSpec(shiftConfiguration.getSpec());
+                newShiftConfiguration.setDestination(shiftConfiguration.getDestination());
+                newShiftConfiguration.setNewOldPlatform(shiftConfiguration.getNewOldPlatform());
+                newShiftConfiguration.setCreateTime(new Date());
+                newShiftConfiguration.setDate(DateUtils.getDateWithOnlyYearMonthDay(new Date()));
+                shiftConfigurationService.save(newShiftConfiguration);
+                log.info("{}{}", "5号机自动化交班生成储运配置：", JSON.toJSON(newShiftConfiguration));
+            }
+            result.put("success", "5号机自动化交班操作成功！");
+        } catch (Exception e) {
+            log.error("5号机自动化交班操作出现异常", e);
+            // 回滚缓存
+            if (oldShiftGroup != null && oldShift != null) {
+                redisTemplate.opsForValue().set(keyShiftGroup, oldShiftGroup);
+                redisTemplate.opsForValue().set(keyShift, oldShift);
             }
+            // 自动交班失败，交班ID索引值回滚，保证交班顺序
+            String nextCacheIdRollBack = oConvertUtils.getString(redisTemplate.opsForValue().get(nextshiftIdKey));
+            int nextCacheIdRollBacks = Integer.parseInt(nextCacheIdRollBack);
+            redisTemplate.opsForValue().set(nextshiftIdKey, nextCacheIdRollBacks - 1);
+            result.put("fail", "5号机自动化交班操作失败，出现异常！");
         }
         return result;
     }

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/billetActual/util/ScheduleUtils.java

@@ -1,16 +1,18 @@
 package org.jeecg.modules.billetActual.util;
 
 import lombok.extern.slf4j.Slf4j;
+import org.jeecg.modules.storageBill.entity.ShiftGroupEnum;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.*;
 
 @Slf4j
 public class ScheduleUtils {
 
-    public static ShiftInfo findNextShift(String[] data, int currentId, String currentShift, String currentShiftGroup) {
+    private static final SimpleDateFormat TIME_FORMAT = new SimpleDateFormat("HH:mm");
+
+    public static ShiftInfo findNextShift(String[] data, int currentId, String currentShift) {
         List<ShiftInfo> shiftList = new ArrayList<>();
         Map<Integer, ShiftInfo> shiftMap = new HashMap<>();
 
@@ -19,8 +21,7 @@ public class ScheduleUtils {
             String[] parts = line.split(" ");
             int id = Integer.parseInt(parts[0]);
             String shift = parts[1];
-            String shiftgroup = parts[2];
-            ShiftInfo shiftInfo = new ShiftInfo(id, shift, shiftgroup);
+            ShiftInfo shiftInfo = new ShiftInfo(id, shift);
             shiftList.add(shiftInfo);
             shiftMap.put(id, shiftInfo);
         }
@@ -28,7 +29,7 @@ public class ScheduleUtils {
         // 找到当前的 ShiftInfo 对象
         ShiftInfo currentShiftInfo = null;
         for (ShiftInfo info : shiftList) {
-            if (info.getId() == currentId && info.getShift().equals(currentShift) && info.getShiftgroup().equals(currentShiftGroup)) {
+            if (info.getId() == currentId && info.getShift().equals(currentShift)) {
                 currentShiftInfo = info;
                 break;
             }
@@ -42,41 +43,58 @@ public class ScheduleUtils {
         return null;
     }
 
+    /**
+     * 验证当前时间是否在指定时间范围内
+     * @param currentDate 当前日期
+     * @param startTime 开始时间，格式为 "HH:mm"
+     * @param endTime 结束时间，格式为 "HH:mm"
+     * @return 如果当前时间在指定时间范围内，返回 true；否则返回 false
+     */
+    public static boolean isBetweenTime(Date currentDate, String startTime, String endTime) {
+        try {
+            // 将开始时间和结束时间转换为 Date 对象
+            Date start = TIME_FORMAT.parse(startTime);
+            Date end = TIME_FORMAT.parse(endTime);
+
+            // 获取当前时间的小时和分钟
+            String currentTimeStr = TIME_FORMAT.format(currentDate);
+            Date currentTime = TIME_FORMAT.parse(currentTimeStr);
+
+            // 处理跨天的情况，例如 23:30 到 01:00
+            if (end.before(start)) {
+                // 如果结束时间早于开始时间，说明跨天了
+                return currentTime.after(start) || currentTime.before(end);
+            }
+
+            // 正常情况，开始时间早于结束时间
+            return currentTime.after(start) && currentTime.before(end);
+        } catch (ParseException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
 //    public static void main(String[] args) {
 //        String[] data = {
-//                "1 丙 夜", "2 甲 白", "3 乙 中", "4 丙 夜", "5 甲 白", "6 乙 中", "7 丙 夜", "8 甲 白", "9 乙 中", "10 丙 夜",
-//                "11 甲 白", "12 乙 中", "13 丁 夜", "14 丙 白", "15 甲 中", "16 丁 夜", "17 丙 白", "18 甲 中", "19 丁 夜", "20 丙 白",
-//                "21 甲 中", "22 丁 夜", "23 丙 白", "24 甲 中", "25 乙 夜", "26 丁 白", "27 丙 中", "28 乙 夜", "29 丁 白", "30 丙 中",
-//                "31 乙 夜", "32 丁 白", "33 丙 中", "34 乙 夜", "35 丁 白", "36 丙 中", "37 甲 夜", "38 乙 白", "39 丁 中", "40 甲 夜",
-//                "41 乙 白", "42 丁 中", "43 甲 夜", "44 乙 白", "45 丁 中", "46 甲 夜", "47 乙 白", "48 丁 中"
+//                "1 丙", "2 甲", "3 乙", "4 丙", "5 甲", "6 乙", "7 丙", "8 甲", "9 乙", "10 丙",
+//                "11 甲", "12 乙", "13 丁", "14 丙", "15 甲", "16 丁", "17 丙", "18 甲", "19 丁", "20 丙",
+//                "21 甲", "22 丁", "23 丙", "24 甲", "25 乙", "26 丁", "27 丙", "28 乙", "29 丁", "30 丙",
+//                "31 乙", "32 丁", "33 丙", "34 乙", "35 丁", "36 丙", "37 甲", "38 乙", "39 丁", "40 甲",
+//                "41 乙", "42 丁", "43 甲", "44 乙", "45 丁", "46 甲", "47 乙", "48 丁"
 //        };
 //
-//        int currentUniqueShiftId = 26;
-//
+//        int currentUniqueShiftId = 16;
 //        String currentShift = "丁";
 //
-//        String currentShiftGroup = "白";
-//
-//        ShiftInfo nextShiftInfo = ScheduleUtils.findNextShift(data, currentUniqueShiftId, currentShift, currentShiftGroup);
-//        if (nextShiftInfo == null){
+//        ShiftInfo nextShiftInfo = ScheduleUtils.findNextShift(data, currentUniqueShiftId, currentShift);
+//        if (nextShiftInfo == null) {
 //            log.info("{}{}", "获取到下个班组信息为空!", new Date() + "自动化交班失败！");
 //            return;
 //        }
-//        String nextShift = nextShiftInfo.shift;
-//
-//        String nextShiftGroup = nextShiftInfo.shiftgroup;
-//
-//        int nextUniqueShiftId= nextShiftInfo.getId();
-//        // redis中更新缓存nextUniqueShiftId
-//
-//        log.info("{}{}", "获取到下个班组信息:", nextShift+" "+nextShiftGroup);
-//        log.info("{}{}", "获取到下个交班索引ID:", nextUniqueShiftId);
-//        // 甲：0，乙：1，丙、2，丁：3     白：0、夜:1, 中:2
-////  0 0 0 * * ?
-////  0 0 8 * * ?
-////  0 0 16 * * ?
-//
-//
 //
+//        // 班组
+//        String nextShiftGroupName = nextShiftInfo.getShift();
+//        int nextUniqueShiftId = nextShiftInfo.getId();
+//        String finalNextShiftGroupVal = ShiftGroupEnum.getCodeByName(nextShiftGroupName);
 //    }
 }

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/billetActual/util/ShiftInfo.java

@@ -7,12 +7,10 @@ import lombok.Data;
 public class ShiftInfo {
     int id;
     String shift;
-    String shiftgroup;
 
-    public ShiftInfo(int id, String shift, String shiftgroup) {
+    public ShiftInfo(int id, String shift) {
         this.id = id;
         this.shift = shift;
-        this.shiftgroup = shiftgroup;
     }
 
     @Override
@@ -20,7 +18,6 @@ public class ShiftInfo {
         return "ShiftInfo{" +
                 "id=" + id +
                 ", shift='" + shift + '\'' +
-                ", shiftgroup='" + shiftgroup + '\'' +
                 '}';
     }
 }

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/push/utils/MqttClientCallback.java

@@ -185,7 +185,7 @@ public class MqttClientCallback implements MqttCallback, MqttCallbackExtended{
                         JSONObject jsonObject = JSON.parseObject(payload);
                         billetHotsendBaseService.autoAddRodLine(jsonObject);
                     } catch (Exception e) {
-                        log.info("{}{}", "mqtt处理5、6号机-轧钢外运-保存消息出错: ", e.getMessage());
+                        log.info("{}{}", "mqtt处理5、6号机-自动化热装保存消息出错: ", e.getMessage());
                     }
                     return;
                 case SYN_BILLET_HOTSEND_BASE_SHIPP_DEPART:
@@ -193,7 +193,7 @@ public class MqttClientCallback implements MqttCallback, MqttCallbackExtended{
                         JSONObject jsonObject = JSON.parseObject(payload);
                         billetHotsendBaseService.autoDepartTrucking(jsonObject);
                     } catch (Exception e) {
-                        log.info("{}{}", "mqtt处理5、6号机-轧钢外运-发车消息出错: ", e.getMessage());
+                        log.info("{}{}", "mqtt处理5、6号机-自动化离站发车消息出错: ", e.getMessage());
                     }
                     return;
                 case SYN_BILLET_ADD_STACKING:
@@ -212,14 +212,6 @@ public class MqttClientCallback implements MqttCallback, MqttCallbackExtended{
                         log.info("{}{}", "mqtt处理堆垛保存消息出错: ", e.getMessage());
                     }
                     return;
-                case SYN_STACKING_AND_LOADING_VEHICLES_STACK_DEPART:
-                    try {
-                        JSONObject jsonObject = JSON.parseObject(payload);
-//                        stackingAndLoadingVehiclesService.autoStackDirectDepart(jsonObject);
-                    } catch (Exception e) {
-                        log.info("{}{}", "mqtt处理堆垛直接发车消息出错: ", e.getMessage());
-                    }
-                    return;
                 case TRACE_BILLETASSEMBLYNUMBER_BILLET_ADD:
                     try {
                         BilletAssemblyNumber billetAssemblyNumber = JSON.parseObject(payload, BilletAssemblyNumber.class);
@@ -242,7 +234,32 @@ public class MqttClientCallback implements MqttCallback, MqttCallbackExtended{
                         log.info("{}{}", "5号机自动化交班接收消息：", jsonObject);
                         billetHotsendChangeShiftService.autoChangeShift(jsonObject);
                     } catch (Exception e) {
-                        log.info("{}{}", "mqtt处理自动化交班消息出错: ", e.getMessage());
+                        log.info("{}{}", "mqtt处理5号机自动化交班消息出错: ", e.getMessage());
+                    }
+                    return;
+                case SYN_BILLET_SIX_CHANGESHIFT:
+                    try {
+                        JSONObject jsonObject = JSON.parseObject(payload);
+                        log.info("{}{}", "6号机自动化交班接收消息：", jsonObject);
+                        billetHotsendChangeShiftService.autoChangeShiftSix(jsonObject);
+                    } catch (Exception e) {
+                        log.info("{}{}", "mqtt处理6号机自动化交班消息出错: ", e.getMessage());
+                    }
+                    return;
+                case SYN_STACKING_CLEARLOCATION:
+                    try {
+                        JSONObject jsonObject = JSON.parseObject(payload);
+                        stackingAndLoadingVehiclesService.stackingClearLocation(jsonObject);
+                    } catch (Exception e) {
+                        log.info("{}{}", "mqtt处理堆垛位置清空异常: ", e.getMessage());
+                    }
+                    return;
+                case SYN_STACK_PLACEHOLDERS:
+                    try {
+                        JSONObject jsonObject = JSON.parseObject(payload);
+                        stackingAndLoadingVehiclesService.stackQueryLocation(jsonObject);
+                    } catch (Exception e) {
+                        log.info("{}{}", "mqtt处理堆垛层数占位总数异常: ", e.getMessage());
                     }
                     return;
                 default:

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/push/utils/MqttClientUtil.java

@@ -14,7 +14,10 @@ import org.springframework.boot.ApplicationArguments;
 import org.springframework.boot.ApplicationRunner;
 import org.springframework.stereotype.Component;
 
+import java.text.SimpleDateFormat;
+import java.util.Date;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 @Slf4j
@@ -217,4 +220,71 @@ public class MqttClientUtil implements ApplicationRunner {
         }
     }
 
+    /**
+     * C端自动化堆垛清理位置，回传坯号，推送消息
+     * @param configMqttMapper
+     * @param map
+     * @param topicInfo
+     */
+    public void pushCData(ConfigMqttMapper configMqttMapper, Map<String, Object> map, String topicInfo){
+        ConfigMqtt configMqtt = configMqttMapper.selectOne(new LambdaQueryWrapper<ConfigMqtt>().like(ConfigMqtt::getTopic,topicInfo).eq(ConfigMqtt::getPushOrSub,"0"));
+        MqttClient mqttClient = null;
+        try {
+            mqttClient = getMqttClient11(configMqtt);
+        } catch (MqttException e) {
+            e.printStackTrace();
+        }
+        MqttTopic topic = mqttClient.getTopic(topicInfo);
+        MqttMessage message = new MqttMessage();
+        message.setPayload(JSON.toJSON(map).toString().getBytes());
+        message.setQos(0);
+        message.setRetained(true);
+        if (null == topic) {
+            log.error("topic is not exist");
+        }else{
+            MqttDeliveryToken token;//Delivery:配送
+            synchronized (topic) {//注意：这里一定要同步，否则，在多线程publish的情况下，线程会发生死锁，分析见文章最后补充
+                try {
+                    token = topic.publish(message);//也是发送到执行队列中，等待执行线程执行，将消息发送到消息中间件
+                    token.waitForCompletion(1000L);
+                } catch (MqttPersistenceException e) {
+                    e.printStackTrace();
+                } catch (MqttException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+
+    public MqttClient getMqttClient11(ConfigMqtt configMqtt) throws MqttException {
+        MqttConnectOptions options = new MqttConnectOptions();
+        // 配置相关选项，如用户名、密码等...
+        options.setUserName(configMqtt.getUsername());
+        options.setPassword(configMqtt.getPassword().toCharArray());
+        // ...其他配置...
+        // 设置超时时间 单位为秒
+        options.setConnectionTimeout(60);
+        // 设置会话心跳时间 单位为秒 服务器会每隔1.5*20秒的时间向客户端发送个消息判断客户端是否在线，但这个方法并没有重连的机制
+        options.setKeepAliveInterval(60);
+        // 设置是否清空session,这里如果设置为false表示服务器会保留客户端的连接记录，这里设置为true表示每次连接到服务器都以新的身份连接
+        options.setCleanSession(false);
+// 由于 MqttConnectOptions 类没有 setSessionExpiryInterval 方法，需要移除这行代码
+// options.setSessionExpiryInterval(604800L); // 会话保留7天(60*60*24*7)
+        // 开启自动重连功能; 方法会判断这个参数
+        options.setAutomaticReconnect(true);
+        // 设置自动重连最大延迟时间 单位是毫秒
+        options.setMaxReconnectDelay(128000);
+        // 允许的最大传输中消息
+        options.setMaxInflight(100);
+        // 设置“遗嘱”消息的话题，若客户端与服务器之间的连接意外中断，服务器将发布客户端的“遗嘱”消息。
+        options.setWill("willTopic", "offline".getBytes(), 0, false);
+
+        StringBuffer url = new StringBuffer();
+        url.append("tcp://").append(configMqtt.getIp()).append(":").append(configMqtt.getHost());
+        MqttClient client = new MqttClient(url.toString(), configMqtt.getId(), new MemoryPersistence());
+        IMqttToken token = client.connectWithResult(options);
+        token.waitForCompletion();
+        return client;
+    }
 }

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/push/utils/TopicType.java

@@ -51,9 +51,30 @@ public enum TopicType {
      */
     SYN_STORAGE_BILL_UPDATE("syn/storageBill/update"),
     /**
-     * 自动化交班
+     * 5号机自动化交班
      */
-    SYN_BILLET_CHANGESHIFT("syn/billet/changeShift");
+    SYN_BILLET_CHANGESHIFT("syn/billet/changeShift"),
+    /**
+     * 6号机自动化交班
+     */
+    SYN_BILLET_SIX_CHANGESHIFT("syn/billet/changeSixShift"),
+
+    /**
+     * 堆垛位置清空
+     */
+    SYN_STACKING_CLEARLOCATION("syn/stacking/clearLocation"),
+    /**
+     * 坯号回传
+     */
+    SYN_STACKING_PASSBACK("syn/stacking/passback"),
+    /**
+     * 堆垛被占位置总数
+     */
+    SYN_STACK_PLACEHOLDERS("syn/stack/placeholders"),
+    /**
+     * 回传堆垛被占位置总数
+     */
+    SYN_PLACEHOLDER_PASSBACK("syn/placeholderSum/passback");
 
     private String topicValue;
 

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/stackingAndLoadingVehicles/controller/StackingAndLoadingVehiclesController.java

@@ -26,7 +26,6 @@ public class StackingAndLoadingVehiclesController extends JeecgController<Stacki
 	 @Autowired
 	 private IStackingAndLoadingVehiclesService stackingAndLoadingVehiclesService;
 
-
 	 @ApiOperation(value="自动化新增堆垛测试", notes="自动化新增堆垛测试")
 	 @PostMapping(value = "/addStacking")
 	 public Result<?> addStacking(@RequestBody JSONObject jsonObject){
@@ -34,7 +33,6 @@ public class StackingAndLoadingVehiclesController extends JeecgController<Stacki
 		 return Result.OK("自动化新增堆垛测试成功！");
 	 }
 
-
 	 @ApiOperation(value="自动化堆垛装车保存测试", notes="自动化堆垛装车保存测试")
 	 @PostMapping(value = "/autoSaveStackLoading")
 	 public Result<?> autoSaveStackLoading(@RequestBody JSONObject jsonObject){
@@ -42,11 +40,10 @@ public class StackingAndLoadingVehiclesController extends JeecgController<Stacki
 		 return Result.OK("自动化堆垛装车保存测试成功！");
 	 }
 
-
-	 @ApiOperation(value="自动化堆垛装车发车测试", notes="自动化堆垛装车发车测试")
-	 @PostMapping(value = "/autoDepartStackLoading")
-	 public Result<?> autoDepartStackLoading(@RequestBody JSONObject jsonObject){
-		 stackingAndLoadingVehiclesService.autoDepartStackLoading(jsonObject);
-		 return Result.OK("自动化堆垛装车发车测试成功！");
+	 @ApiOperation(value="自动化垛位清理位置测试", notes="自动化垛位清理位置测试")
+	 @PostMapping(value = "/stackingClearLocation")
+	 public Result<?> stackingClearLocation(@RequestBody JSONObject jsonObject){
+		 stackingAndLoadingVehiclesService.stackingClearLocation(jsonObject);
+		 return Result.OK("自动化垛位清理位置成功！");
 	 }
 }

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/stackingAndLoadingVehicles/service/IStackingAndLoadingVehiclesService.java

@@ -20,5 +20,7 @@ public interface IStackingAndLoadingVehiclesService extends IService<StackingAnd
 
     void autoSaveStackLoading(JSONObject jsonObject);
 
-    void autoDepartStackLoading(JSONObject jsonObject);
+    void stackingClearLocation(JSONObject jsonObject);
+
+    void stackQueryLocation(JSONObject jsonObject);
 }

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/stackingAndLoadingVehicles/service/impl/StackingAndLoadingVehiclesServiceImpl.java

@@ -26,8 +26,12 @@ import org.jeecg.modules.billetHotsendConfig.entity.BilletHotsendTypeConfig;
 import org.jeecg.modules.billetHotsendConfig.service.IBilletHotsendTypeConfigService;
 import org.jeecg.modules.billetLiftingBill.entity.BilletLiftingBill;
 import org.jeecg.modules.billetLiftingBill.service.IBilletLiftingBillService;
+import org.jeecg.modules.connConfig.configMqtt.mapper.ConfigMqttMapper;
 import org.jeecg.modules.operateLog.entity.OperateLog;
 import org.jeecg.modules.operateLog.service.IOperateLogService;
+import org.jeecg.modules.push.utils.MqttClientCallback;
+import org.jeecg.modules.push.utils.MqttClientUtil;
+import org.jeecg.modules.push.utils.TopicType;
 import org.jeecg.modules.rollClubThree.entity.RollClubThree;
 import org.jeecg.modules.rollClubThree.entity.RollClubThreeDetails;
 import org.jeecg.modules.rollClubThree.service.IRollClubThreeDetailsService;
@@ -62,10 +66,13 @@ import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.interceptor.TransactionAspectSupport;
 
 import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.stream.Collectors;
 
@@ -123,6 +130,9 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
     private IBilletLiftingBillService billetLiftingBillService;
     @Autowired
     private IOperateLogService operateLogService;
+    @Autowired
+    private ConfigMqttMapper configMqttMapper;
+
 
     @Override
     @Transactional(rollbackFor = Exception.class)
@@ -170,7 +180,6 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
         }
         log.info("C端起跺吊运单信息：" + JSON.toJSON(billetLiftingBillList));
         saveBatchBilletLiftingBills(billetLiftingBillList);
-
         // 根据billetHotsendTypeConfigId 查询基础垛位信息
         BilletHotsendTypeConfig billetHotsendTypeConfig = billetHotsendTypeConfigService.getById(billetHotsendTypeConfigId);
         loadingParams.setBelongTable(billetHotsendTypeConfig.getBelongTable());
@@ -187,90 +196,6 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
             stackingAndLoadingVehicles.setAddress(billetNoItem.getString("address"));
             return stackingAndLoadingVehicles;
         }).collect(Collectors.toList());
-
-//
-//        LambdaQueryWrapper<StackingAndLoadingVehicles> queryWrapper3 = new LambdaQueryWrapper<>();
-//        queryWrapper3.eq(StackingAndLoadingVehicles::getCcmNo, ccmNo)
-//                .eq(StackingAndLoadingVehicles::getTypeConfigId, billetHotsendTypeConfigId);
-//        List<StackingAndLoadingVehicles> stackingAndLoadingVehiclesListInfo = stackingAndLoadingVehiclesMapper.selectList(queryWrapper3);
-//        // 检查 layer=20, address=9 的数据是否已被占用
-//        boolean isTopRightOccupied = stackingAndLoadingVehiclesListInfo.stream()
-//                .anyMatch(vehicle -> Integer.parseInt(vehicle.getLayer()) == 20
-//                        && Integer.parseInt(vehicle.getAddress()) == 9
-//                        && vehicle.getBilletNos() != null
-//                        && !vehicle.getBilletNos().isEmpty());
-//
-//        if (isTopRightOccupied) {
-//            log.info("{}{}", "该垛位容器位置已占满，自动化新增堆垛失败!", jsonObject.toJSONString());
-//            return;
-//        }
-//
-//        // 过滤出 billet_nos 不为空的记录，并按优先级排序（layer 降序，address 降序）
-//        List<StackingAndLoadingVehicles> nonEmptyBillets = stackingAndLoadingVehiclesListInfo.stream()
-//                .filter(vehicle -> vehicle.getBilletNos() != null && !vehicle.getBilletNos().isEmpty())
-//                .sorted(Comparator.comparing((StackingAndLoadingVehicles v) -> Integer.parseInt(v.getLayer())).reversed()
-//                        .thenComparing(v -> Integer.parseInt(v.getAddress()), Comparator.reverseOrder()))
-//                .collect(Collectors.toList());
-//
-//        // 获取所有 billet_nos 为空的记录，并按优先级排序（layer 升序，address 升序）
-//        List<StackingAndLoadingVehicles> emptySlots = stackingAndLoadingVehiclesListInfo.stream()
-//                .filter(vehicle -> vehicle.getBilletNos() == null || vehicle.getBilletNos().isEmpty())
-//                .sorted(Comparator.comparing((StackingAndLoadingVehicles v) -> Integer.parseInt(v.getLayer())) // Layer 升序
-//                        .thenComparing(v -> Integer.parseInt(v.getAddress()))) // Address 也升序
-//                .collect(Collectors.toList());
-//
-//
-//        if (oConvertUtils.listIsEmpty(emptySlots)){
-//            // 如果该垛位所有为空的记录为空，则返回
-//            log.info("{}{}", "该垛位容器位置已占满，自动化新增堆垛失败!", jsonObject.toJSONString());
-//            return;
-//        }
-//
-//        // 确定填充起点
-//        int startIndex;
-//        if (!nonEmptyBillets.isEmpty()) {
-//            // 已有数据，从最高优先级位置开始
-//            StackingAndLoadingVehicles highestPriorityVehicle = nonEmptyBillets.get(0);
-//            int startLayer = Integer.parseInt(highestPriorityVehicle.getLayer());
-//            int startAddress = Integer.parseInt(highestPriorityVehicle.getAddress());
-//
-//            // 处理 address 进位
-//            if (startAddress == 9) {
-//                startLayer += 1;
-//                startAddress = 1;
-//            } else {
-//                startAddress += 1;
-//            }
-//
-//            // 找到第一个符合 startLayer & startAddress 以上的空位
-//            int finalStartLayer = startLayer;
-//            int finalStartAddress = startAddress;
-//            Optional<StackingAndLoadingVehicles> startingPoint = emptySlots.stream()
-//                    .filter(vehicle -> Integer.parseInt(vehicle.getLayer()) == finalStartLayer && Integer.parseInt(vehicle.getAddress()) == finalStartAddress)
-//                    .findFirst();
-//
-//            startIndex = emptySlots.indexOf(startingPoint.orElse(null));
-//        } else {
-//            // 没有已有数据，从 layer=1, address=1 开始填充
-//            startIndex = 0;
-//        }
-//
-//        if (startIndex == -1) {
-//            log.info("未找到合适的填充起点");
-//            return;
-//        }
-//
-//        List<StackingAndLoadingVehicles> newList = new ArrayList<>();
-//        // 按顺序填充数据
-//        for (int i = 0; i < stackingAndLoadingVehiclesLists.size() && startIndex + i < emptySlots.size(); i++) {
-//            emptySlots.get(startIndex + i).setBilletNos(stackingAndLoadingVehiclesLists.get(i).getBilletNos());
-//            emptySlots.get(startIndex + i).setCcmNo(stackingAndLoadingVehiclesLists.get(i).getCcmNo());
-//            emptySlots.get(startIndex + i).setTypeConfigId(stackingAndLoadingVehiclesLists.get(i).getTypeConfigId());
-//            emptySlots.get(startIndex + i).setStackAddr(stackingAndLoadingVehiclesLists.get(i).getStackAddr());
-//            emptySlots.get(startIndex + i).setCreateTime(stackingAndLoadingVehiclesLists.get(i).getCreateTime());
-//            newList.add(emptySlots.get(startIndex + i));
-//        }
-//
         loadingParams.setStackingAndLoadingVehiclesList(stackingAndLoadingVehiclesLists);
 
         List<StackingAndLoadingVehicles> stackingAndLoadingVehiclesList = loadingParams.getStackingAndLoadingVehiclesList();
@@ -287,6 +212,21 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
                 .isNull(BilletBasicInfo::getBelongTable)
                 .isNull(BilletBasicInfo::getBhtcId);
         List<BilletBasicInfo> billetBasicInfoLists = billetBasicInfoService.list(queryWrapperBB);
+        if (oConvertUtils.listIsEmpty(billetBasicInfoLists)){
+            // 循环三次处理
+            for (int i = 0; i < 6; i++) {
+                // 延迟10秒
+                try {
+                    Thread.sleep(10000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                billetBasicInfoLists = billetBasicInfoService.list(queryWrapperBB);
+                if (!oConvertUtils.listIsEmpty(billetBasicInfoLists)){
+                    break;
+                }
+            }
+        }
         if (oConvertUtils.listIsEmpty(billetBasicInfoLists)){
             log.info("{}{}", "钢坯基础信息为空，C端自动化新增堆垛失败!", jsonObject);
             BilletAutoException billetAutoException = createBilletAutoException(ccmNo, allBilletNos, shiftGroupHandle(ccmNo), shiftHandle(ccmNo), billetHotsendTypeConfig.getTypeName(), null, null, null, null);
@@ -424,7 +364,7 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
                 .eq(StackingAndLoadingVehicles::getTypeConfigId, billetHotsendTypeConfig.getId())
                 .isNotNull(StackingAndLoadingVehicles::getBilletNos));
         if (oConvertUtils.isEmpty(stackingAndLoadingVehiclesInfo)){
-            log.info("{}{}", "查询垛位公共容器信息为空，C端自动化垛位装车保存失败：", jsonObject);
+            log.info("{}{}", "该垛位位置上钢坯基础信息为空，C端自动化垛位装车保存失败：", jsonObject);
             return;
         }
         stackingAndLoadingVehiclesLists.add(stackingAndLoadingVehiclesInfo);
@@ -477,13 +417,12 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
         }
         loadingParams.setStorageBill(isStorageBill);
 
-        log.info("{}{}", "自动化堆垛装车保存钢坯装运单数据：", JSON.toJSON(isStorageBill));
+        log.info("{}{}", "自动化堆垛装车保存StorageBill数据：", JSON.toJSON(isStorageBill));
 
         StorageBill storageBill = loadingParams.getStorageBill();
 
         // 轧钢外运保存时，先判断装运单中的目的地ID是否为1024，如果为1024、明细暂存临时表billet_auto_tmp
         if ("1024".equals(isStorageBill.getTypeConfigId())){
-            log.info("{}{}", "C端自动化堆垛外运未知目的地坯号集合:", allBilletNos);
             loadingParams.setBelongTable("billet_auto_tmp");
             loadingParams.setBilletHotsendTypeConfigId("1024");
             loadingParams.setDestinationTable("billet_auto_tmp");
@@ -502,7 +441,6 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
             loadingParams.setBelongTable(billetHotsendTypeConfigInfo.getBelongTable());
             loadingParams.setBilletHotsendTypeConfigId(billetHotsendTypeConfigInfo.getId());
         }
-        log.info("{}{}", "自动化堆垛装车保存公共容器数据：", JSON.toJSON(loadingParams.getStackingAndLoadingVehiclesList()));
 
         log.info("{}{}", "自动化堆垛装车保存热送单数据：", JSON.toJSON(billetHotsend));
 
@@ -561,7 +499,7 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
         billetBasicInfoService.saveOrUpdateBatch(billetBasicInfoList);
 
         if ("billet_auto_tmp".equals(loadingParams.getBelongTable())){
-            log.info("{}{}", "C端自动化堆垛保存去未知目的地装运单信息：", JSON.toJSON(storageBill));
+            log.info("{}{}", "C端自动化堆垛保存临时表成功，坯号集合:", allBilletNos);
             return;
         }
         // 取最新的第一条钢坯信息
@@ -571,16 +509,43 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
         storageBill.setAmountTotal((oConvertUtils.isNotEmpty(storageBill.getAmountTotal()) ? storageBill.getAmountTotal() : 0) + loadingParams.getStackingAndLoadingVehiclesList().size() * 4);
         storageBill.setDestination(loadingParams.getDestination());
         storageBill.setTypeConfigId(loadingParams.getDestinationId());
-        List<String> stringList = billetBasicInfoList.stream().map(BilletBasicInfo::getAssemblyNumber).filter(assemblyNumber -> oConvertUtils.isNotEmpty(assemblyNumber)).collect(Collectors.toList());
-        if(oConvertUtils.listIsNotEmpty(stringList)) {
-            String distinctAssemblyNumber = billetBasicInfoList.stream()
-                    .map(BilletBasicInfo::getAssemblyNumber)
-                    .filter(assemblyNumber -> oConvertUtils.isNotEmpty(assemblyNumber))
-                    .distinct().collect(Collectors.joining(","));
+
+        // 下垛时，有目的，定尺维护
+        List<Integer> sizeIntList = billetBasicInfoList.stream().map(BilletBasicInfo::getLength).filter(oConvertUtils::isNotEmpty).collect(Collectors.toList());
+        List<String> sizeStrList = sizeIntList.stream().map(String::valueOf).collect(Collectors.toList());
+        if(oConvertUtils.listIsNotEmpty(sizeStrList)) {
+            String distinctSizeStr = sizeIntList.stream()
+                    .distinct()
+                    .map(String::valueOf)
+                    .collect(Collectors.joining(","));
+            String finalSizeStr = Optional.ofNullable(storageBill.getSize())
+                    .filter(oConvertUtils::isNotEmpty)
+                    .map(s -> s + "," + distinctSizeStr)
+                    .orElse(distinctSizeStr);
+            // 对 finalSizeStr 再次去重
+            String[] sizeArray = finalSizeStr.split(",");
+            Set<String> uniqueSizes = Arrays.stream(sizeArray)
+                    .filter(s -> s != null && !s.isEmpty())
+                    .collect(Collectors.toCollection(HashSet::new));
+            finalSizeStr = String.join(",", uniqueSizes);
+            storageBill.setSize(finalSizeStr);
+        }
+
+        // 下垛时，有目的，组批号维护
+        List<String> assemblyNumberList = billetBasicInfoList.stream().map(BilletBasicInfo::getAssemblyNumber).filter(assemblyNumber -> oConvertUtils.isNotEmpty(assemblyNumber)).collect(Collectors.toList());
+        if(oConvertUtils.listIsNotEmpty(assemblyNumberList)) {
+            String distinctAssemblyNumber = assemblyNumberList.stream().distinct().collect(Collectors.joining(","));
             String finalAssemblyNumber = Optional.ofNullable(storageBill.getAssemblyNumber())
                     .filter(oConvertUtils::isNotEmpty)
                     .map(s -> s + "," + distinctAssemblyNumber)
                     .orElse(distinctAssemblyNumber);
+
+            // 对 finalAssemblyNumber 再次去重
+            String[] assemblyNumberArray = finalAssemblyNumber.split(",");
+            Set<String> uniqueAssemblyNumbers = Arrays.stream(assemblyNumberArray)
+                    .filter(s -> s != null && !s.isEmpty())
+                    .collect(Collectors.toCollection(HashSet::new));
+            finalAssemblyNumber = String.join(",", uniqueAssemblyNumbers);
             storageBill.setAssemblyNumber(finalAssemblyNumber);
         }
         storageBillService.updateById(storageBill);
@@ -594,228 +559,106 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
         log.info("{}{}", "C端自动化堆垛装车保存操作成功！", allBilletNos);
     }
 
-    /**
-     * 自动化堆垛装车发车
-     * @param jsonObject
-     */
     @Override
     @Transactional(rollbackFor = Exception.class)
-    public void autoDepartStackLoading(JSONObject jsonObject) {
-
-        String ccmNo = jsonObject.getString("ccmNo");
+    public void stackingClearLocation(JSONObject jsonObject) {
+        String ccmNo = jsonObject.getString("ccmNo");// 铸机号
         String billetHotsendTypeConfigId = jsonObject.getString("billetHotsendTypeConfigId");
-        String billetNoLists = jsonObject.getString("billetNos");
         String layer = jsonObject.getString("layer");
         String address = jsonObject.getString("address");
-        String licensePlate = jsonObject.getString("licensePlate");
-        String destinationId = jsonObject.getString("destinationId");
-
-        String classShiftGroup = String.format("class:shift:group:%s", ccmNo); // 班组
-        String classShift = String.format("class:shift:%s", ccmNo); // 班别
-        String classShiftStr = !oConvertUtils.getString(redisTemplate.opsForValue().get(classShift)).isEmpty() ? oConvertUtils.getString(redisTemplate.opsForValue().get(classShift)) : "";
-        String classShiftGroupStr = !oConvertUtils.getString(redisTemplate.opsForValue().get(classShiftGroup)).isEmpty() ? oConvertUtils.getString(redisTemplate.opsForValue().get(classShiftGroup)) : "";
-
-        LoadingParams loadingParams = new LoadingParams();
-
-        loadingParams.setBelongTable("stacking_and_loading_vehicles");
-        loadingParams.setBilletHotsendTypeConfigId(billetHotsendTypeConfigId);
-
-        BilletHotsend billetHotsend = new BilletHotsend();
-        billetHotsend.setCcmNo(ccmNo);
-        billetHotsend.setShiftGroup(classShiftGroupStr);
-        billetHotsend.setShift(classShiftStr);
-        loadingParams.setBilletHotsend(billetHotsend);
-
-        // 根据billetHotsendTypeConfigId 查询基础垛位信息
-        BilletHotsendTypeConfig billetHotsendTypeConfig = billetHotsendTypeConfigService.getById(loadingParams.getBilletHotsendTypeConfigId());
-        // 根据destinationId 查询目的地配置信息
-        BilletHotsendTypeConfig destinationInfo = billetHotsendTypeConfigService.getById(destinationId);
-        loadingParams.setDestination(destinationInfo.getTypeName());
-        loadingParams.setDestinationId(destinationId);
-        loadingParams.setDestinationTable(destinationInfo.getBelongTable());
-
-        // 通过铸机号、billetHotsendTypeConfigId、层数、位置查询公共容器
-        StackingAndLoadingVehicles stackingAndLoadingVehiclesInfo = baseMapper.selectOne(new LambdaQueryWrapper<StackingAndLoadingVehicles>()
-                .eq(StackingAndLoadingVehicles::getTypeConfigId, billetHotsendTypeConfigId)
-                .eq(StackingAndLoadingVehicles::getCcmNo, ccmNo)
-                .eq(StackingAndLoadingVehicles::getLayer, layer)
-                .eq(StackingAndLoadingVehicles::getAddress, address));
-        if (stackingAndLoadingVehiclesInfo == null){
-            log.info("{}{}", "堆垛容器信息查询失败，自动化堆垛装车发车操作失败！", jsonObject);
-            BilletAutoException billetAutoException = createBilletAutoException(ccmNo, billetNoLists, classShiftGroupStr, classShiftStr, billetHotsendTypeConfig.getTypeName(), address, layer, destinationInfo.getBelongTable(), destinationId);
-            billetAutoException.setMassage("堆垛容器信息查询为空，自动化堆垛<发车>操作失败！");
-            billetAutoException.setRemark(licensePlate);
-            billetAutoExceptionService.save(billetAutoException);
+        // 判断layer和address为空时直接返回
+        if (oConvertUtils.isEmpty(layer) || oConvertUtils.isEmpty(address)){
+            log.info("{}{}", "layer和address为空，C端自动化堆垛清空位置失败！", jsonObject);
             return;
         }
-        List<StackingAndLoadingVehicles> stackingAndLoadingVehiclesLists = new ArrayList<>();
-        StackingAndLoadingVehicles stackingAndLoadingVehicles = new StackingAndLoadingVehicles();
-        stackingAndLoadingVehicles.setId(stackingAndLoadingVehiclesInfo.getId());
-        stackingAndLoadingVehicles.setCcmNo(ccmNo);
-        stackingAndLoadingVehicles.setBilletNos(billetNoLists);
-        stackingAndLoadingVehicles.setAddress(address);
-        stackingAndLoadingVehicles.setLayer(layer);
-        stackingAndLoadingVehicles.setStackAddr(billetHotsendTypeConfig.getTypeName());
-        stackingAndLoadingVehicles.setTypeConfigId(billetHotsendTypeConfig.getId());
-        stackingAndLoadingVehicles.setCreateDate(new Date());
-        stackingAndLoadingVehiclesLists.add(stackingAndLoadingVehicles);
-        loadingParams.setStackingAndLoadingVehiclesList(stackingAndLoadingVehiclesLists);
-
-        List<StackingAndLoadingVehicles> stackingAndLoadingVehiclesList = loadingParams.getStackingAndLoadingVehiclesList();
-
-        log.info("{}{}", "自动化下垛结果集合：", JSON.toJSON(stackingAndLoadingVehiclesList));
-        // 获取所有的坯号集合
-        List<String> billetNosList = stackingAndLoadingVehiclesList.stream().map(StackingAndLoadingVehicles::getBilletNos)
-                .flatMap(billetNos -> {
-                    if (billetNos!= null) {
-                        return java.util.stream.Stream.of(billetNos.split(","));
-                    } else {
-                        return java.util.stream.Stream.empty();
-                    }
-                }).collect(Collectors.toList());
-
-        LambdaQueryWrapper<BilletBasicInfo> queryWrapperBB = new LambdaQueryWrapper<BilletBasicInfo>()
-                .eq(BilletBasicInfo::getCcmNo, Integer.valueOf(billetHotsend.getCcmNo()))
-                .in(BilletBasicInfo::getBilletNo, billetNosList);
-        List<BilletBasicInfo> billetBasicInfoList = billetBasicInfoService.list(queryWrapperBB);
-        List<RollClubCommon> rollClubCommonList= new ArrayList<>();
-        billetBasicInfoList.forEach(x ->{
-            RollClubCommon rollClubCommon = new RollClubCommon();
-            BeanUtils.copyProperties(x, rollClubCommon);
-            rollClubCommon.setCcmNo(x.getCcmNo().toString());
-            rollClubCommon.setStartNum(Integer.valueOf(address));
-            rollClubCommon.setStackStorey(layer);
-            rollClubCommonList.add(rollClubCommon);
-        });
-
-        LambdaQueryWrapper<StorageBill> queryWrapper2 = new LambdaQueryWrapper<>();
-        queryWrapper2.eq(StorageBill::getCcmNo, ccmNo)
-                .eq(StorageBill::getLicensePlate, licensePlate)
-                .eq(StorageBill::getShiftGroup, classShiftGroupStr)
-                .eq(StorageBill::getShift, classShiftStr)
-                .isNull(StorageBill::getOutTime);
-        StorageBill isStorageBill = storageBillService.getOne(queryWrapper2);
-        if (oConvertUtils.isNotEmpty(isStorageBill)) {
-            log.info("未查询到未发车车辆，车牌号为：{}，自动化堆垛发车失败:", licensePlate);
+        // 根据以上信息查询堆垛容器信息
+        LambdaQueryWrapper<StackingAndLoadingVehicles> queryWrapper = new LambdaQueryWrapper();
+        queryWrapper.eq(StackingAndLoadingVehicles::getCcmNo, ccmNo)
+                .eq(StackingAndLoadingVehicles::getLayer, layer)
+                .eq(StackingAndLoadingVehicles::getAddress, address)
+                .eq(StackingAndLoadingVehicles::getTypeConfigId, billetHotsendTypeConfigId);
+        List<StackingAndLoadingVehicles> stackingAndLoadingVehiclesList = baseMapper.selectList(queryWrapper);
+        if (oConvertUtils.listIsEmpty(stackingAndLoadingVehiclesList)){
+            log.info("{}{}", "C端自动化堆垛清空位置失败！", jsonObject);
             return;
         }
-        loadingParams.setStorageBill(isStorageBill);
+        // 释放容器位置
+        batchUpdateStackingAndLoadingVehicles(stackingAndLoadingVehiclesList);
 
-        StorageBill storageBill = loadingParams.getStorageBill();
-
-        handleStackDepartCommon(billetHotsend, stackingAndLoadingVehiclesList, loadingParams, billetHotsendTypeConfig, storageBill, rollClubCommonList);
-        Map<String, List<RollClubCommon>> rollClubCommonInfoList = groupByShiftAttributes(rollClubCommonList);
-        for (Map.Entry<String, List<RollClubCommon>> entry : rollClubCommonInfoList.entrySet()) {
-            String[] parts = entry.getKey().split(",");
-            billetHotsend.setHeatNo(parts[0]);// 炉号
-            billetHotsend.setShiftGroup(parts[1]);// 班组
-            billetHotsend.setShift(parts[2]);// 班别
-            List<RollClubCommon> groupRollClubCommonList = entry.getValue();
-            LambdaQueryWrapper<BilletHotsend> queryWrapper = new LambdaQueryWrapper<>();
-            queryWrapper.eq(BilletHotsend::getCcmNo, billetHotsend.getCcmNo())
-                    .eq(BilletHotsend::getHeatNo, billetHotsend.getHeatNo())
-                    .eq(BilletHotsend::getShift,  billetHotsend.getShift())
-                    .eq(BilletHotsend::getShiftGroup, billetHotsend.getShiftGroup());
-            BilletHotsend idExistBh = billetHotsendBaseService.getOne(queryWrapper);
-            if (oConvertUtils.isEmpty(idExistBh)){
-                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-                log.info("{}{}", "钢坯热送单为空，自动化垛位发车失败", storageBill.getLicensePlate());
-                return;
-            }
-            billetHotsend.setId(idExistBh.getId());
-            billetHotsend.setStackNum(Math.max(0, idExistBh.getStackNum() - groupRollClubCommonList.size()));
-            // 钢坯热送基础信息存在，但是钢坯信息不存在 直接返回
-            if ("roll_club_two".equals(loadingParams.getDestinationTable())){
-                billetHotsend.setRollclubtwoNum(oConvertUtils.isNotEmpty(idExistBh.getRollclubtwoNum()) ? idExistBh.getRollclubtwoNum() + groupRollClubCommonList.size() : groupRollClubCommonList.size());
-            }else if ("roll_club_three".equals(loadingParams.getDestinationTable())){
-                billetHotsend.setRollclubthreeNum(oConvertUtils.isNotEmpty(idExistBh.getRollclubthreeNum()) ? idExistBh.getRollclubthreeNum() + groupRollClubCommonList.size() : groupRollClubCommonList.size());
-            }else if ("roll_out_shipp".equals(loadingParams.getDestinationTable())){
-                billetHotsend.setRolloutshippNum(oConvertUtils.isNotEmpty(idExistBh.getRolloutshippNum()) ? idExistBh.getRolloutshippNum() + groupRollClubCommonList.size() : groupRollClubCommonList.size());
-            }
-            billetHotsend.setUpdateTime(new Date());
-            billetHotsendBaseService.updateById(billetHotsend);
-        }
-        //5 获取所有的坯号集合 查询并批量更新钢坯基础信息 belongTable
-        billetBasicInfoList.forEach(x ->{
-            x.setBelongTable(loadingParams.getDestinationTable());
-            x.setBhtcId(loadingParams.getDestinationId());
-        });
-        billetBasicInfoService.saveOrUpdateBatch(billetBasicInfoList);
-
-        //根据铸机号、钢坯转运单ID查询定尺信息
-        List<String> sizeList = new ArrayList<>();
-        List<String> heatNoList = new ArrayList<>();
-        long count = 0L;
-        if ("roll_club_two".equals(loadingParams.getDestinationTable())){
-            LambdaQueryWrapper<RollClubTwoDetails> queryWrapperRC = new LambdaQueryWrapper();
-            queryWrapperRC.eq(RollClubTwoDetails::getCcmNo, storageBill.getCcmNo()).eq(RollClubTwoDetails::getStorageBillId, storageBill.getId());
-            List<RollClubTwoDetails> rollClubTwoDetailsList = rollClubTwoDetailsService.list(queryWrapperRC);
-            sizeList = rollClubTwoDetailsList.stream().map(RollClubTwoDetails::getSize).distinct()
-                    .collect(Collectors.toList());
-            heatNoList = rollClubTwoDetailsList.stream().map(RollClubTwoDetails::getHeatNo).distinct()
-                    .collect(Collectors.toList());
-            if (oConvertUtils.listIsNotEmpty(rollClubTwoDetailsList)){
-                count = rollClubTwoDetailsList.stream().count();
-            }
+        StackingAndLoadingVehicles stackingAndLoadingVehicles = stackingAndLoadingVehiclesList.stream().findFirst().orElse(null);
+        if (stackingAndLoadingVehicles == null || oConvertUtils.isEmpty(stackingAndLoadingVehicles.getBilletNos())){
+            log.info("{}{}", "该位置坯号集为空，C端自动化堆垛清空位置失败！", jsonObject);
+            return;
         }
-        if ("roll_club_three".equals(loadingParams.getDestinationTable())){
-            LambdaQueryWrapper<RollClubThreeDetails> queryWrapperCT = new LambdaQueryWrapper();
-            queryWrapperCT.eq(RollClubThreeDetails::getCcmNo, storageBill.getCcmNo()).eq(RollClubThreeDetails::getStorageBillId, storageBill.getId());
-            List<RollClubThreeDetails> rollClubThreeDetailsList = rollClubThreeDetailsService.list(queryWrapperCT);
-            sizeList = rollClubThreeDetailsList.stream().map(RollClubThreeDetails::getSize).distinct()
-                    .collect(Collectors.toList());
-            heatNoList = rollClubThreeDetailsList.stream().map(RollClubThreeDetails::getHeatNo).distinct()
-                    .collect(Collectors.toList());
-            if (oConvertUtils.listIsNotEmpty(rollClubThreeDetailsList)){
-                count = rollClubThreeDetailsList.stream().count();
-            }
+        // 根据逗号隔开的坯号集，查询钢坯基础信息
+        String[] billetNosparts = stackingAndLoadingVehicles.getBilletNos().split(",");
+        LambdaQueryWrapper<BilletBasicInfo> queryWrapper1 = new LambdaQueryWrapper<>();
+            queryWrapper1.eq(BilletBasicInfo::getCcmNo, ccmNo);
+            queryWrapper1.in(BilletBasicInfo::getBilletNo, Arrays.asList(billetNosparts));
+        List<BilletBasicInfo> billetBasicInfoList = billetBasicInfoService.list(queryWrapper1);
+        if (oConvertUtils.listIsEmpty(billetBasicInfoList)){
+            log.info("{}{}", "钢坯基础信息为空，C端自动化堆垛清空位置失败！", jsonObject);
+            return;
         }
-        if ("roll_out_shipp".equals(loadingParams.getDestinationTable())){
-            LambdaQueryWrapper<RollOutShippDetails> queryWrapperROS = new LambdaQueryWrapper();
-            queryWrapperROS.eq(RollOutShippDetails::getCcmNo, storageBill.getCcmNo()).eq(RollOutShippDetails::getStorageBillId, storageBill.getId());
-            List<RollOutShippDetails> rollOutShippDetailsList = rollOutShippDetailsService.list(queryWrapperROS);
-            sizeList = rollOutShippDetailsList.stream().map(RollOutShippDetails::getSize).distinct()
-                    .collect(Collectors.toList());
-            heatNoList = rollOutShippDetailsList.stream().map(RollOutShippDetails::getHeatNo).distinct()
-                    .collect(Collectors.toList());
-            if (oConvertUtils.listIsNotEmpty(rollOutShippDetailsList)){
-                count = rollOutShippDetailsList.stream().count();
-            }
+        // 更新钢坯基础信息 钢坯基础信息所属表、配置ID赋值
+        batchUpdateBilletBasicInfo(billetBasicInfoList);
+
+        BilletBasicInfo billetBasicInfo = billetBasicInfoList.stream().findFirst().orElse(null);
+        // 根据ccmNo、billetBasicInfo中的heatNo、shiftgroup、shift查询热送传递单
+        LambdaQueryWrapper<BilletHotsend> queryWrapper2 = new LambdaQueryWrapper();
+        queryWrapper2.eq(BilletHotsend::getHeatNo, billetBasicInfo.getHeatNo())
+                .eq(BilletHotsend::getShift, billetBasicInfo.getShift())
+                .eq(BilletHotsend::getCcmNo, billetBasicInfo.getCcmNo())
+                .eq(BilletHotsend::getShiftGroup, billetBasicInfo.getShiftGroup());
+        BilletHotsend billetHotsend = billetHotsendBaseService.getOne(queryWrapper2);
+        if (oConvertUtils.isEmpty(billetHotsend)){
+            log.info("{}{}", "钢坯热送传递单为空，C端自动化堆垛清空位置失败", jsonObject);
+            throw new RuntimeException("钢坯热送传递单为空，C端自动化堆垛清空位置事务回滚！");
         }
-        if ("roll_height".equals(loadingParams.getDestinationTable())){
-            log.info("{}{}", "堆垛去高线发车操作成功!", JSON.toJSON(billetNosList));
+        billetHotsend.setStackNum(Math.max(0, billetHotsend.getStackNum() - billetBasicInfoList.size()));
+        billetHotsend.setUpdateTime(new Date());
+        billetHotsendBaseService.updateById(billetHotsend);
+
+        // 发送坯号结果到mqtt，作为独立的事务
+        sendBilletNoToMqtt(ccmNo, billetBasicInfoList);
+    }
+
+    @Override
+    public void stackQueryLocation(JSONObject jsonObject) {
+        String ccmNo = jsonObject.getString("ccmNo");// 铸机号
+        String billetHotsendTypeConfigId = jsonObject.getString("billetHotsendTypeConfigId");//  基础类型堆垛ID
+        String layer = jsonObject.getString("layer");// 层数
+        if (oConvertUtils.isEmpty(layer) || oConvertUtils.isEmpty(billetHotsendTypeConfigId)){
+            log.info("{}{}", "layer和所属堆垛ID为空，C端自动化堆垛层占用获取失败！", jsonObject);
             return;
+        }
+        // 根据以上三个参数，坯号不为空，查询堆垛容器信息
+        LambdaQueryWrapper<StackingAndLoadingVehicles> queryWrapper = new LambdaQueryWrapper();
+        queryWrapper.eq(StackingAndLoadingVehicles::getCcmNo, ccmNo)
+                .eq(StackingAndLoadingVehicles::getLayer, layer)
+                .eq(StackingAndLoadingVehicles::getTypeConfigId, billetHotsendTypeConfigId)
+                .isNotNull(StackingAndLoadingVehicles::getBilletNos);
+        List<StackingAndLoadingVehicles> stackingAndLoadingVehiclesList = baseMapper.selectList(queryWrapper);
+        int locationSum = stackingAndLoadingVehiclesList.size();
+        // 发送mqtt消息
+        sendLocationSumToMqtt(ccmNo, layer, billetHotsendTypeConfigId, locationSum);
+    }
 
+    public void sendLocationSumToMqtt(String ccmNo, String layer, String billetHotsendTypeConfigId, int locationSum) {
+        try {
+            Map<String, Object> mapSendInfo = new HashMap<>();
+            mapSendInfo.put("ccmNo", ccmNo);
+            mapSendInfo.put("layer", layer);
+            mapSendInfo.put("billetHotsendTypeConfigId", billetHotsendTypeConfigId);
+            mapSendInfo.put("locationSum", locationSum);
+            mapSendInfo.put("queryTime", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()));
+            // 执行MQTT推送，设置合理的超时时间
+            MqttClientUtil mqttClientUtilBe = new MqttClientUtil();
+            mqttClientUtilBe.pushCData(configMqttMapper, mapSendInfo, TopicType.SYN_PLACEHOLDER_PASSBACK.getTopicValue());
+            log.info("C端自动化查询堆垛位置被占总数回传，发送MQTT成功: {}", mapSendInfo);
+        } catch (Exception e) {
+            log.error("C端自动化查询堆垛位置被占总数回传，发送MQTT异常!", e);
         }
-        // 6 更新装运单 storage_bill  取最新的第一条钢坯信息更新钢种和规格
-        RollClubCommon rollClubCommon = rollClubCommonList.stream().findFirst().orElse(null);
-        storageBill.setSteel(rollClubCommon.getGrade());//钢种
-        storageBill.setSpec(rollClubCommon.getSpec());//规格
-        storageBill.setSize(String.join(",", sizeList));
-        storageBill.setTypeConfigId(loadingParams.getDestinationId()); // 钢坯配置类型ID
-        storageBill.setDestination(loadingParams.getDestination());// 目的地
-        storageBill.setAmountTotal(storageBill.getAmountTotal() + stackingAndLoadingVehiclesList.size() * 4);
-        storageBill.setOutTime(new Date());
-        storageBillService.updateById(storageBill);
-        // 7 发车后，新增钢坯堆垛储运信息,生成储运单 storage_car_log
-        StorageCarLog storageCarLog = new StorageCarLog();
-        BeanUtils.copyProperties(storageBill, storageCarLog);
-
-        LambdaQueryWrapper<StackingDownLog> queryWrappersd = new LambdaQueryWrapper();
-        queryWrappersd.eq(StackingDownLog::getCcmNo, storageBill.getCcmNo()).eq(StackingDownLog::getStorageBillId, storageBill.getId());
-        List<StackingDownLog> stackingDownLogs = stackingDownLogService.list(queryWrappersd);
-
-        Integer bx =Integer.valueOf((int) count);
-        Integer dd = stackingDownLogs.size() * 4 + bx;
-        storageCarLog.setDestination(loadingParams.getDestination());// 目的地
-        storageCarLog.setCarNm(storageBill.getLicensePlate());// 车牌号
-        storageCarLog.setTypeConfigId(billetHotsendTypeConfig.getId()); // 钢坯配置类型ID
-        storageCarLog.setHeatNo(String.join(",", heatNoList));
-        storageCarLog.setSize(String.join(",", sizeList));// 定尺
-        storageCarLog.setAmount(dd);// 支数
-        storageCarLog.setDataTime(new Date());
-        storageCarLogService.save(storageCarLog);
-        log.info("{}{}", "自动化堆垛发车操作成功", billetNoLists);
     }
 
 
@@ -864,6 +707,7 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
             List<BilletBasicInfo> billetBasicInfoList = billetBasicInfoService.list(queryWrapper);
             if (oConvertUtils.listIsEmpty(billetBasicInfoList)){
                 log.info("{}{}", "自动化堆垛保存失败，钢坯基础信息不存在！", x.getBilletNos());
+                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                 return;
             }
             List<String> heatNos = billetBasicInfoList.stream().map(BilletBasicInfo::getHeatNo).distinct().collect(Collectors.toList());
@@ -934,7 +778,6 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
                 rollClubTwoDetails.setShift(billetBasicInfo.getShift());
 
                 rollClubTwoDetails.setLicensePlate(storageBill.getLicensePlate());
-                rollClubTwoDetails.setCreateTime(new Date());
                 rollClubTwoDetails.setId(String.valueOf(IdWorker.getId()));
                 rollClubTwoDetails.setBlankOutput(billetWeightTotal);//出坯量
                 rollClubTwoDetails.setSpec(billetBasicInfoList.get(0).getSpec());
@@ -946,6 +789,8 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
                         .distinct()
                         .collect(Collectors.joining(","));
                 rollClubTwoDetails.setAssemblyNumber(distinctAssemblyNumber);
+                rollClubTwoDetails.setCreateTime(new Date());
+                rollClubTwoDetails.setUpdateTime(new Date());
                 addRollClubTwoDetailsList.add(rollClubTwoDetails);
             }else if ("roll_club_three".equals(loadingParams.getDestinationTable())){
                 billetBasicInfoList.forEach(y ->{
@@ -995,6 +840,7 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
                 rollClubThreeDetails.setStackNum(x.getAddress());
                 rollClubThreeDetails.setLicensePlate(storageBill.getLicensePlate());
                 rollClubThreeDetails.setCreateTime(new Date());
+                rollClubThreeDetails.setUpdateTime(new Date());
                 rollClubThreeDetails.setId(String.valueOf(IdWorker.getId()));
                 rollClubThreeDetails.setBlankOutput(billetWeightTotal);//出坯量
                 rollClubThreeDetails.setSpec(billetBasicInfoList.get(0).getSpec());
@@ -1056,6 +902,7 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
                 rollOutShippDetails.setLicensePlate(storageBill.getLicensePlate());
                 rollOutShippDetails.setId(String.valueOf(IdWorker.getId()));
                 rollOutShippDetails.setCreateTime(new Date());
+                rollOutShippDetails.setUpdateTime(new Date());
                 rollOutShippDetails.setBlankOutput(billetWeightTotal);//出坯量
                 rollOutShippDetails.setSpec(billetBasicInfoList.get(0).getSpec());
                 rollOutShippDetails.setSize(billetBasicInfoList.get(0).getLength().toString());
@@ -1090,6 +937,7 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
                 billetAutoTmp.setStorageBillId(storageBill.getId());
                 billetAutoTmp.setLicensePlate(storageBill.getLicensePlate());
                 billetAutoTmp.setCreateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
+                billetAutoTmp.setUpdateTime(new Date(System.currentTimeMillis() + timeOffset.get()));
                 billetAutoTmp.setAssemblyNumber(distinctTmpAssemblyNumber);
                 // 通过坯号查询钢坯临时表
                 List<BilletAutoTmp> billetAutoTmpLists = billetAutoTmpService.list(new LambdaQueryWrapper<BilletAutoTmp>()
@@ -1131,6 +979,21 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
     private void handleAddStackInfo(BilletHotsend billetHotsend, List<StackingAndLoadingVehicles> stackingAndLoadingVehiclesList, LoadingParams loadingParams, BilletHotsendTypeConfig billetHotsendTypeConfig){
         // 2 发车后，动态更新容器中的垛位信息 初始化
         stackingAndLoadingVehiclesList.forEach(x ->{
+
+            LambdaQueryWrapper<StackingAndLoadingVehicles> queryWrapperCheck = new LambdaQueryWrapper<>();
+            queryWrapperCheck.eq(StackingAndLoadingVehicles::getCcmNo, x.getCcmNo())
+                    .eq(StackingAndLoadingVehicles::getLayer, x.getLayer())
+                    .eq(StackingAndLoadingVehicles::getAddress, x.getAddress())
+                    .eq(StackingAndLoadingVehicles::getTypeConfigId, loadingParams.getBilletHotsendTypeConfigId())
+                    .isNotNull(StackingAndLoadingVehicles::getBilletNos);
+            // 查询垛位容器信息
+            StackingAndLoadingVehicles stackingAndLoadingVehiclesCheck = stackingAndLoadingVehiclesMapper.selectOne(queryWrapperCheck);
+            if (oConvertUtils.isNotEmpty(stackingAndLoadingVehiclesCheck)) {
+                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                log.info("{}{}", "C端自动化起垛失败，该垛位容器位置已被占用,事务回滚!", x.getBilletNos());
+                return;
+            }
+
             LambdaUpdateWrapper<StackingAndLoadingVehicles> queryWrapperSA = new LambdaUpdateWrapper<>();
             queryWrapperSA.eq(StackingAndLoadingVehicles::getCcmNo, x.getCcmNo())
                     .eq(StackingAndLoadingVehicles::getLayer, x.getLayer())
@@ -1145,7 +1008,8 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
             queryWrapper.in(BilletBasicInfo::getBilletNo, Arrays.asList(parts));
             List<BilletBasicInfo> billetBasicInfoList = billetBasicInfoService.list(queryWrapper);
             if (oConvertUtils.listIsEmpty(billetBasicInfoList)){
-                log.info("{}{}", "自动化堆垛起跺保存失败，钢坯基础信息不存在！", x.getBilletNos());
+                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                log.info("{}{}", "C端自动化起跺失败，钢坯基础信息不存在，事务回滚:", x.getBilletNos());
                 return;
             }
             BilletBasicInfo billetBasicInfo = billetBasicInfoList.stream().findFirst().orElse(null);
@@ -1157,7 +1021,7 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
             stackingAndLoadingVehicles.setSpec(billetBasicInfo.getSpec());
             stackingAndLoadingVehicles.setSteel(billetBasicInfo.getGrade());
             stackingAndLoadingVehicles.setCreateDate(new Date());
-            log.info("{}{}", "》》》》》》》自动化起跺容器中的信息：", JSON.toJSON(stackingAndLoadingVehicles));
+            log.info("{}{}", ">>>>>>自动化起跺容器中的信息：", JSON.toJSON(stackingAndLoadingVehicles));
             baseMapper.update(stackingAndLoadingVehicles, queryWrapperSA);
         });
         // 3 保存 起垛日志    stacking_up_log
@@ -1288,6 +1152,59 @@ public class StackingAndLoadingVehiclesServiceImpl extends ServiceImpl<StackingA
         }
     }
 
+    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
+    public void sendBilletNoToMqtt(String ccmNo, List<BilletBasicInfo> billetBasicInfoList) {
+        try {
+            String billetNoLists = String.join(",", billetBasicInfoList.stream().map(BilletBasicInfo::getBilletNo).collect(Collectors.toList()));
+            Map<String, Object> mapSendInfo = new HashMap<>();
+            mapSendInfo.put("ccmNo", ccmNo);
+            mapSendInfo.put("billetNos", billetNoLists);
+            mapSendInfo.put("clearLocationTime", DateUtils.date2Str(new Date(), DateUtils.datetimeFormat.get()));
+            // 执行MQTT推送，设置合理的超时时间
+            MqttClientUtil mqttClientUtilBe = new MqttClientUtil();
+            mqttClientUtilBe.pushCData(configMqttMapper, mapSendInfo, TopicType.SYN_STACKING_PASSBACK.getTopicValue());
+            log.info("C端自动化位置清空后坯号回传，发送MQTT成功: {}", mapSendInfo);
+        } catch (Exception e) {
+            log.error("C端自动化位置清空后坯号回传，发送MQTT异常!", e);
+        }
+    }
+
+    /**
+     *  初始化堆垛公共容器
+     * @param stackingAndLoadingVehiclesList
+     */
+    private void batchUpdateStackingAndLoadingVehicles(List<StackingAndLoadingVehicles> stackingAndLoadingVehiclesList) {
+        List<String> ids = stackingAndLoadingVehiclesList.stream().map(StackingAndLoadingVehicles::getId).collect(Collectors.toList());
+        // 创建更新包装器
+        LambdaUpdateWrapper<StackingAndLoadingVehicles> updateWrapper = new LambdaUpdateWrapper<>();
+        updateWrapper.in(StackingAndLoadingVehicles::getId, ids)
+                .set(StackingAndLoadingVehicles::getBilletNos, null)
+                .set(StackingAndLoadingVehicles::getSpec, null)
+                .set(StackingAndLoadingVehicles::getSteel, null)
+                .set(StackingAndLoadingVehicles::getSize, null)
+                .set(StackingAndLoadingVehicles::getShift, null)
+                .set(StackingAndLoadingVehicles::getHeatNo, null)
+                .set(StackingAndLoadingVehicles::getCreateDate, null)
+                .set(StackingAndLoadingVehicles::getShiftGroup, null)
+                .set(StackingAndLoadingVehicles::getUpdateTime, new Date());
+        // 执行批量更新
+        stackingAndLoadingVehiclesMapper.update(null, updateWrapper);
+    }
+
+    /**
+     *  钢坯实绩去向置为空
+     * @param billetBasicInfoList
+     */
+    private void batchUpdateBilletBasicInfo(List<BilletBasicInfo> billetBasicInfoList) {
+        List<String> ids = billetBasicInfoList.stream().map(BilletBasicInfo::getId).collect(Collectors.toList());
+        LambdaUpdateWrapper<BilletBasicInfo> updateWrapper = new LambdaUpdateWrapper<>();
+        updateWrapper.in(BilletBasicInfo::getId, ids)
+                .set(BilletBasicInfo::getBelongTable, null)
+                .set(BilletBasicInfo::getBhtcId, null)
+                .set(BilletBasicInfo::getUpdateTime, new Date());
+        billetBasicInfoService.update(updateWrapper);
+    }
+
     /**
      * 封装BilletAutoException对象的方法
      *

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/storageBill/entity/StorageBill.java

@@ -189,4 +189,17 @@ public class StorageBill implements Serializable {
     @ApiModelProperty(value = "新站台or旧站台（0 新站台 1 旧站台）")
     private Integer newOldPlatform;
 
+    /**
+     * 确认支数时间
+     */
+    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "确认支数时间")
+    private Date confirmNumTime;
+
+    /**总支数*/
+    @Excel(name = "看板总支数", width = 15)
+    @ApiModelProperty(value = "看板总支数")
+    private Integer panelAmountTotal;
+
 }

zgzt-sys-java/jeecg-module-conn/src/main/java/org/jeecg/modules/storageBill/service/impl/StorageBillServiceImpl.java

@@ -91,14 +91,22 @@ public class StorageBillServiceImpl extends ServiceImpl<StorageBillMapper, Stora
             /**
              * 判断该车位上是否有未发出的车辆
              * 车位1:   五号机501堆垛旁的车位
-             * 车位2:   六号机冷床和高线辊道中间的车位
+             * 车位2:   六号机冷床和高线辊道中间的车位 （变更逻辑 2号车位创建不固定 5or6铸机号）
              * 车位3:   六号机601堆垛旁的车位
              * 车位4:   六号机步进冷床和602堆垛中间的车位
              */
+            // 车位等于 2铸机号先归为0 变更日期 2025-4-24 默认取6
+            if (positionNum.equals("2")) {
+                shiftGroup = getShiftInfo("6", "class:shift:group:%s");
+                shift = getShiftInfo("6", "class:shift:%s");
+            }
             LambdaQueryWrapper<StorageBill> queryWrapper = new LambdaQueryWrapper<>();
-            queryWrapper.eq(StorageBill::getCcmNo, ccmNo)
-                    .eq(StorageBill::getPositionNum, Integer.valueOf(positionNum))
+            queryWrapper.eq(StorageBill::getPositionNum, Integer.valueOf(positionNum))
                     .isNull(StorageBill::getOutTime);
+            // 2号车位不验证铸机号
+            if (!positionNum.equals("2")) {
+                queryWrapper.eq(StorageBill::getCcmNo, ccmNo);
+            }
             StorageBill isStorageBill = baseMapper.selectOne(queryWrapper);
             if (oConvertUtils.isNotEmpty(isStorageBill)) {
                 log.info("C端自动化查询到该车位存在未发车车辆，需对此车辆进行发车，车牌号为：{}", jsonObject);
@@ -106,8 +114,8 @@ public class StorageBillServiceImpl extends ServiceImpl<StorageBillMapper, Stora
             }
 
             // 更新交班记录 通过铸机号、班组、班别去查询交班记录并初始化 出车号
-            updateBilletHotsendChangeShift(ccmNo, shiftGroup, shift);
-            // 钢坯信息
+//            updateBilletHotsendChangeShift(ccmNo, shiftGroup, shift);
+            // 装运单信息
             StorageBill storageBill = new StorageBill();
             storageBill.setId(String.valueOf(IdWorker.getId()));
             log.info("{}{}", "C端自动化创建装运单主键ID", storageBill.getId());
@@ -120,27 +128,32 @@ public class StorageBillServiceImpl extends ServiceImpl<StorageBillMapper, Stora
                     log.info("{}{}", "C端自动化新增装运单，车牌字典中是否存在：", exists);
                     if (exists){
                         storageBill.setLicensePlateStatus(0);
-                        int carNum = calculateCarNum(ccmNo, licensePlate, shiftGroup, shift);
-                        storageBill.setCarNum(carNum + 1);
+//                        int carNum = calculateCarNum(ccmNo, licensePlate, shiftGroup, shift);
+//                        storageBill.setCarNum(carNum + 1);
                         storageBill.setLicensePlate(licensePlate);
                     }else {
                         storageBill.setLicensePlateStatus(1);
-                        storageBill.setCarNum(0);
                         storageBill.setLicensePlate("");
                     }
                     log.info("{}{}", "C端自动化新增装运单对象信息：", JSON.toJSON(storageBill));
                 }
             }else {
                 storageBill.setLicensePlate("");
-                storageBill.setCarNum(0);
                 storageBill.setLicensePlateStatus(1);
                 log.info("{}{}", "C端自动化新增钢坯装运单，未传车牌号：", JSON.toJSON(storageBill));
             }
+            storageBill.setCarNum(0); // 本车车次
+            storageBill.setCarAllNum(0); // 总车车次
             // 车次总序号
-            int carAllNum = calculateCarAllNum(ccmNo, shiftGroup, shift);
-            storageBill.setCarAllNum(carAllNum + 1);
-            // 保存钢坯基础信息
-            storageBill.setCcmNo(ccmNo);
+//            int carAllNum = calculateCarAllNum(ccmNo, shiftGroup, shift);
+//            storageBill.setCarAllNum(carAllNum + 1);
+            // 保存储运单信息
+            // 2号车位铸机号给0
+            if (!positionNum.equals("2")) {
+                storageBill.setCcmNo(ccmNo);
+            }else{
+                storageBill.setCcmNo("0");
+            }
             // 根据铸机号、班组、班别，创建时间倒序 只返回一条，查询储运配置信息
             LambdaQueryWrapper<ShiftConfiguration> queryWrapper1 = new LambdaQueryWrapper<ShiftConfiguration>();
             queryWrapper1.eq(ShiftConfiguration::getCcmNo, ccmNo)
@@ -158,7 +171,7 @@ public class StorageBillServiceImpl extends ServiceImpl<StorageBillMapper, Stora
 //                storageBill.setTypeConfigId(shiftConfiguration.getDestination());
                 storageBill.setBrandNum(shiftConfiguration.getSteelGrade());//牌号
                 storageBill.setNewOldPlatform(shiftConfiguration.getNewOldPlatform());
-                storageBill.setSize(shiftConfiguration.getSpec());
+//                storageBill.setSize(shiftConfiguration.getSpec());
                 storageBill.setTypeConfigId("1024");
             }else {
                 // C端自动化创建装运单时，默认未知目的地
@@ -166,6 +179,7 @@ public class StorageBillServiceImpl extends ServiceImpl<StorageBillMapper, Stora
             }
 
             storageBill.setAmountTotal(0);
+            storageBill.setPanelAmountTotal(0);
             storageBill.setArrivalTime(new Date());// 到达时间
             storageBill.setPositionNum(Integer.valueOf(positionNum));
             storageBill.setShiftGroup(shiftGroup);
@@ -206,9 +220,12 @@ public class StorageBillServiceImpl extends ServiceImpl<StorageBillMapper, Stora
                 return;
             }
             LambdaQueryWrapper<StorageBill> queryWrapper = new LambdaQueryWrapper<>();
-            queryWrapper.eq(StorageBill::getCcmNo, ccmNo)
-                    .eq(StorageBill::getPositionNum, Integer.valueOf(positionNum))
+            queryWrapper.eq(StorageBill::getPositionNum, Integer.valueOf(positionNum))
                     .isNull(StorageBill::getOutTime);
+            // 2号车位不验证铸机号 变更日期 2025-4-24
+            if (!positionNum.equals("2")) {
+                queryWrapper.eq(StorageBill::getCcmNo, ccmNo);
+            }
             StorageBill isStorageBill = baseMapper.selectOne(queryWrapper);
             if (oConvertUtils.isEmpty(isStorageBill)) {
                 log.info("C端自动化钢坯装运单信息为空，更新车牌号失败：{}", jsonObject);
@@ -231,8 +248,8 @@ public class StorageBillServiceImpl extends ServiceImpl<StorageBillMapper, Stora
                     log.info("{}{}", "C端自动化更新车牌字典中是否存在：", exists);
                     if (exists){
                         isStorageBill.setLicensePlateStatus(0);
-                        int carNum = calculateCarNum(ccmNo, licensePlate, isStorageBill.getShiftGroup(), isStorageBill.getShift());
-                        isStorageBill.setCarNum(carNum + 1);
+//                        int carNum = calculateCarNum(ccmNo, licensePlate, isStorageBill.getShiftGroup(), isStorageBill.getShift());
+//                        isStorageBill.setCarNum(carNum + 1);
                         log.info("{}{}", "C端自动化更新车牌,本车车次序号：", isStorageBill.getCarNum());
                         isStorageBill.setLicensePlate(licensePlate);
                     }else {

zgzt-sys-java/jeecg-module-system/jeecg-system-start/src/main/resources/application-dev.yml

@@ -172,7 +172,7 @@ spring:
           slow-sql-millis: 5000
       datasource:
         master:
-#          url: jdbc:mysql://123.57.213.14/jeecg-boot?characterEncoding=UTF-8&useUnicode=true&useSSL=false&tinyInt1isBit=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
+#          url: jdbc:mysql://192.168.1.53/lg_0416?characterEncoding=UTF-8&useUnicode=true&useSSL=false&tinyInt1isBit=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
           url: jdbc:mysql://127.0.0.1/lg?characterEncoding=UTF-8&useUnicode=true&useSSL=false&tinyInt1isBit=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
           username: lg
           password: 1qaz2wsx@..