root/yiBinGaoCe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

基础task修改

Browse Source
This commit is contained in:
psh
2024-01-24 17:58:22 +08:00
parent df510cdc39
commit e0d6436e38
13 changed files with 272 additions and 1224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/AbstractTask.java
View File

@@ -99,7 +99,7 @@ public abstract class AbstractTask {
SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
.eq(SchBaseTaskconfig::getConfig_code, config_code));
taskDto.setPriority(taskConfig.getPriority());
// taskDto.setTask_type(taskConfig.getTask_type());
taskDto.setTask_type(taskConfig.getTask_type());
taskDto.setRoute_plan_code(taskConfig.getRoute_plan_code());
return taskDto;
}

232
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/KGHJRKTask.java
View File

@@ -1,232 +0,0 @@
package org.nl.wms.sch.task_manage.task.tasks;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.exception.BadRequestException;
import org.nl.config.MapOf;
import org.nl.wms.ext.service.WmsToAcsService;
import org.nl.wms.ext.service.dto.to.BaseResponse;
import org.nl.wms.pdm.service.IPdmBdWorkorderService;
import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
import org.nl.wms.sch.point.service.ISchBasePointService;
import org.nl.wms.sch.point.service.dao.SchBasePoint;
import org.nl.wms.sch.task.service.ISchBaseTaskService;
import org.nl.wms.sch.task.service.ISchBaseTaskconfigService;
import org.nl.wms.sch.task.service.dao.SchBaseTask;
import org.nl.wms.sch.task.service.dao.SchBaseTaskconfig;
import org.nl.wms.sch.task_manage.AbstractTask;
import org.nl.wms.sch.task_manage.enums.GroupBindMaterialStatusEnum;
import org.nl.wms.sch.task_manage.enums.GroupStatusEnum;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.mapper.PointMapper;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: psh
* @Description: 空固化架入库
* @Date: 2023/9/28
*/
@Slf4j
@Component
@TaskType("KGHJRKTask")
@Lazy
public class KGHJRKTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "KGHJRKTask";
/**
* 入口
*/
private static String ENTRANCE = "1";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private PointMapper pointMapper;
@Autowired
private WmsToAcsService wmsToAcsService;
@Override
// @Transactional(rollbackFor = Exception.class)
protected void create() throws BadRequestException {
// 获取任务
List<SchBaseTask> tasks = taskService.findTasksByTaskStatus(TASK_CONFIG_CODE, TaskStatus.APPLY);
for (SchBaseTask task : tasks) {
// 找终点
SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getPoint_code, task.getPoint_code1()));
SchBasePoint point = findNextPoint(startPoint,task.getVehicle_type());
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
log.info("空固化架入库未找到当前符合条件的点位");
continue;
}
// 设置终点并修改创建成功状态
if("1".equals(task.getVehicle_type())){
task.setTask_type("11");
}else{
task.setTask_type("12");
}
task.setPoint_code2(point.getNext_wait_point());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
taskService.update(task);
// //发起任务时先把点位占用，防止发起重复任务
// point.setIng_task_code(task.getTask_code());
// pointService.update(point);
//下发
this.renotifyAcs(task);
}
}
/**
* 判断目标点位
* 1.A区的去A区缓存点,B区的去B区
* 2.倒叙查找，找到满足当前位置数量不足3的即可
*/
private SchBasePoint findNextPoint(SchBasePoint startPoint,String vehicleType) {
String regionCode = null;
if ("A1".equals(startPoint.getWorkshop_code())) {
//A1空架到HCQ1
regionCode = "HCQ1";
if("1".equals(vehicleType)){
regionCode="ZJBKGHJDJW";
}
} else if ("A2".equals(startPoint.getWorkshop_code())) {
//A1空架到KGHJ2
regionCode = "KGHJ2";
}
List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion(regionCode,"1");
//从前往后判断，直到发现点位有货，取前一个
SchBasePoint schBasePoint=null;
if(!"ZJBKGHJDJW".equals(regionCode)) {
for (int i = schBasePointList.size() - 1; i >= 0; i--) {
SchBasePoint temp = schBasePointList.get(i);
if (temp.getVehicle_qty() == 1 &&
ObjectUtil.isEmpty(temp.getIng_task_code())) {
if (schBasePoint != null) {
log.info("空固化架放货找到当前点位有货：{}，取上一个空位：{}", temp.getPoint_code(), schBasePoint.getPoint_code());
} else {
log.info("当前区域："+regionCode+"所有点位均已放满，暂时跳过");
}
break;
}
schBasePoint = temp;
}
}else{
for (int i = schBasePointList.size() - 1; i >= 0; i--) {
SchBasePoint temp = schBasePointList.get(i);
if (temp.getVehicle_qty() <3 &&
ObjectUtil.isEmpty(temp.getIng_task_code())) {
schBasePoint = temp;
}
}
if (schBasePoint==null){
log.info("当前区域："+regionCode+"所有点位均已放满，暂时跳过");
}
}
return schBasePoint;
}
@Override
// @Transactional(rollbackFor = Exception.class)
protected void updateStatus(String task_code, TaskStatus status) {
// 校验任务
SchBaseTask taskObj = taskService.getById(task_code);
if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
throw new BadRequestException("该任务已完成!");
}
if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
throw new BadRequestException("该任务已取消!");
}
String startPoint = taskObj.getPoint_code1(); // 获取起点
String endPoint = taskObj.getPoint_code2(); // 获取终点
SchBasePoint startPointObj = pointService.getById(startPoint);
SchBasePoint endPointObj = pointService.getById(endPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
// 终点解锁,库存增加
startPointObj.setIng_task_code("");
//正极板对接位通过plc信号同步，任务完成不增加
if(!"ZJBKGHJDJW".equals(startPointObj.getRegion_code())) {
startPointObj.setVehicle_qty(startPointObj.getVehicle_qty() + 1);
}
pointService.update(endPointObj);
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 终点解锁
if (ObjectUtil.isNotEmpty(endPointObj)) {
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
}
taskObj.setRemark("任务取消");
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
}
taskService.update(taskObj);
}
@Override
public void forceFinish(String task_code) {
this.updateStatus(task_code, TaskStatus.FINISHED);
}
@Override
public void cancel(String task_code) {
this.updateStatus(task_code, TaskStatus.CANCELED);
}
@Override
protected void feedbackTaskState(JSONObject param,SchBaseTask schBaseTask, BaseResponse result) {
//重新计算固化室放货点位
JSONObject extGroupData = JSONObject.parseObject(schBaseTask.getExt_group_data());
SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getPoint_code, schBaseTask.getPoint_code1()));
SchBasePoint point = findNextPoint(startPoint, schBaseTask.getVehicle_type());
if("ZJBKGHJDJW".equals(point.getRegion_code())) {
schBaseTask.setPoint_code2(point.getPoint_code() + "0" + (point.getVehicle_qty() + 1));
}else{
schBaseTask.setPoint_code2(point.getPoint_code().replace("HCQ","QHQ"));
if(ObjectUtil.isNotEmpty(point.getIng_task_code())&&!schBaseTask.getTask_code().equals(point.getIng_task_code())){
throw new BadRequestException("当前空架点位有任务，暂不反馈！");
}
//重算点位时把点位占用
point.setIng_task_code(schBaseTask.getTask_code());
pointService.update(point);
}
}
}

253
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/POINTTask.java Normal file
View File

@@ -0,0 +1,253 @@
package org.nl.wms.sch.task_manage.task.tasks;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.exception.BadRequestException;
import org.nl.wms.ext.service.WmsToAcsService;
import org.nl.wms.ext.service.dto.to.BaseResponse;
import org.nl.wms.pdm.service.IPdmBdWorkorderService;
import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
import org.nl.wms.sch.point.service.ISchBasePointService;
import org.nl.wms.sch.point.service.dao.SchBasePoint;
import org.nl.wms.sch.task.service.ISchBaseTaskService;
import org.nl.wms.sch.task.service.ISchBaseTaskconfigService;
import org.nl.wms.sch.task.service.dao.SchBaseTask;
import org.nl.wms.sch.task.service.dao.SchBaseTaskconfig;
import org.nl.wms.sch.task_manage.AbstractTask;
import org.nl.wms.sch.task_manage.GeneralDefinition;
import org.nl.wms.sch.task_manage.enums.GroupBindMaterialStatusEnum;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.mapper.PointMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: psh
* @Description: 点对点任务
* @Date: 2023/1/24
*/
@Slf4j
@Component
@TaskType("POINTTask")
@Lazy
public class POINTTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "POINTTask";
/**
* 入口
*/
private static String ENTRANCE = "1";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private PointMapper pointMapper;
@Autowired
private WmsToAcsService wmsToAcsService;
@Override
// @Transactional(rollbackFor = Exception.class)
protected void create() throws BadRequestException {
// 获取任务
List<SchBaseTask> tasks = taskService.findTasksByTaskStatus(TASK_CONFIG_CODE, TaskStatus.APPLY);
// 配置信息
SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
.eq(SchBaseTaskconfig::getConfig_code, TASK_CONFIG_CODE));
for (SchBaseTask task : tasks) {
String extGroupData = task.getExt_group_data();
JSONObject jsonObject = JSONObject.parseObject(extGroupData);
String materialType = jsonObject.getString("material_type");
SchBasePoint point = findNextPoint(jsonObject,task);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
log.info("包片上料未找到当前符合条件的点位materialType:{},",materialType);
continue;
}
// 设置起点并修改创建成功状态
// 取料先去等待点
task.setTask_type("3");
task.setPoint_code1(point.getNext_wait_point());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
taskService.update(task);
//发起任务时先把点位占用，防止发起重复任务
// point.setIng_task_code(task.getTask_code());
// point.setVehicle_qty(point.getVehicle_qty() - 1);
// point.setVehicle_type(materialType);
// pointService.update(point);
//下发
this.renotifyAcs(task);
}
}
/**
* 判断目标点位
* 从10-1查找可以物料一致且有货的点位
*
* @param extGroupData
* @return
*/
private SchBasePoint findNextPoint(JSONObject extGroupData,SchBaseTask task) {
String regionCode = "";
String materialType = extGroupData.getString("material_type");
if("1".equals(materialType)){
regionCode="ZJBDJW";
}else if("2".equals(materialType)){
regionCode="HCQ2";
}else if ("3".equals(materialType)){
regionCode="HCQ3";
}
List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion(regionCode,"1");
for(int i=schBasePointList.size()-1;i>=0;i--){
SchBasePoint schBasePoint=schBasePointList.get(i);
//已锁定直接返回
if(task.getTask_code().equals(schBasePoint.getIng_task_code())){
return schBasePoint;
}
if (!"2".equals(schBasePoint.getPoint_type())&&schBasePoint.getVehicle_qty()!=0
&&ObjectUtil.isEmpty(schBasePoint.getIng_task_code())
&&(ObjectUtil.isEmpty(schBasePoint.getVehicle_type())||materialType.equals(schBasePoint.getVehicle_type()))){
log.info("包片上料任务找到当前符合条件的缓存区位置{}",schBasePoint.getPoint_code());
return schBasePoint;
}
}
return null;
}
/**
* 1.取货完毕后起点减少最后一份组盘，并且该组盘视为已结束
* 2.包片机LMS不记录点位信息，由人工对组盘进行操作
*/
@Override
// @Transactional(rollbackFor = Exception.class)
protected void updateStatus(String task_code, TaskStatus status) {
// 校验任务
SchBaseTask taskObj = taskService.getById(task_code);
if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
throw new BadRequestException("该任务已完成!");
}
if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
throw new BadRequestException("该任务已取消!");
}
String startPoint = taskObj.getPoint_code1(); // 获取起点
String endPoint = taskObj.getPoint_code2(); // 获取终点
SchBasePoint startPointObj = pointService.getById(startPoint);
SchBasePoint endPointObj = pointService.getById(endPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
List<String> vehicleCodeList = Arrays.stream(startPointObj.getVehicle_code().split(",")).collect(Collectors.toList());
String vehicleCode=vehicleCodeList.get(vehicleCodeList.size()-1);
SchBaseVehiclematerialgroup one = vehiclematerialgroupService.getOne(new LambdaQueryWrapper<SchBaseVehiclematerialgroup>()
.eq(SchBaseVehiclematerialgroup::getVehicle_code, vehicleCode)
.eq(SchBaseVehiclematerialgroup::getGroup_bind_material_status,
GroupBindMaterialStatusEnum.BOUND.getValue()));
if (ObjectUtil.isNotEmpty(one)) {
// throw new BadRequestException(vehicleCode + " => " + startPointObj.getVehicle_type() + "的组盘信息未找到");
// }
one.setTask_code(taskObj.getTask_code());
one.setPoint_code(endPointObj.getPoint_code()); // 当前位置
one.setPoint_name(endPointObj.getPoint_name());
one.setMove_way(one.getMove_way() == null ? "" : (one.getMove_way() + " -> ") + endPointObj.getPoint_code());
one.setGroup_bind_material_status(GroupBindMaterialStatusEnum.UNBOUND.getValue());
one.setUpdate_id(GeneralDefinition.ACS_ID);
one.setUpdate_name(GeneralDefinition.ACS_NAME);
one.setUpdate_time(DateUtil.now());
vehiclematerialgroupService.updateById(one);
}
// 起点清空
if (vehicleCodeList.size()==1) {
startPointObj.setVehicle_code("");
}else{
StringBuilder vehicle_code=new StringBuilder();
for(int i=0;i<=vehicleCodeList.size()-2;i++){
vehicle_code.append(vehicleCodeList.get(i)).append(',');
}
startPointObj.setVehicle_code(vehicle_code.toString());
}
if (!startPointObj.getPoint_code().startsWith("ZJBDJW")) {
startPointObj.setVehicle_qty(startPointObj.getVehicle_qty() - 1);
}
startPointObj.setIng_task_code("");
startPointObj.setUpdate_time(DateUtil.now());
pointService.updateById(startPointObj);
//包片上料完毕后，整排打上记号只允许包片上料
pointMapper.updatePointType(endPointObj.getPoint_code().substring(0,endPointObj.getPoint_code().length()-2),"1");
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setGroup_id(one.getGroup_id());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 终点解锁
if (ObjectUtil.isNotEmpty(endPointObj)) {
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
}
// 起点解锁
if (ObjectUtil.isNotEmpty(startPointObj)) {
startPointObj.setIng_task_code("");
if (startPointObj.getPoint_code().startsWith("ZJBDJW")) {
startPointObj.setVehicle_qty(startPointObj.getVehicle_qty() + 1);
}
pointService.update(endPointObj);
}
taskObj.setRemark("任务取消");
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
}
taskService.update(taskObj);
}
@Override
public void forceFinish(String task_code) {
this.updateStatus(task_code, TaskStatus.FINISHED);
}
@Override
public void cancel(String task_code) {
this.updateStatus(task_code, TaskStatus.CANCELED);
}
@Override
protected void feedbackTaskState(JSONObject param,SchBaseTask schBaseTask, BaseResponse result) {
//重算最优点
JSONObject jsonObject = JSONObject.parseObject(schBaseTask.getExt_group_data());
SchBasePoint point = this.findNextPoint(jsonObject,schBaseTask);
//正极板现在不堆叠
if( "1".equals(jsonObject.getString("material_type"))) {
schBaseTask.setPoint_code1(point.getPoint_code()+"0"+(point.getVehicle_qty()));
}else{
schBaseTask.setPoint_code1(point.getPoint_code().replace("HCQ","QHQ"));
}
//重算点位时把点位占用
point.setIng_task_code(schBaseTask.getTask_code());
//如果是正极板对接位则直接减库存
if ((point.getPoint_code().startsWith("ZJBDJW"))) {
point.setVehicle_qty(point.getVehicle_qty() - 1);
}
pointService.update(point);
}
}

215
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/TBXBKJTask.java
View File

@@ -1,215 +0,0 @@
package org.nl.wms.sch.task_manage.task.tasks;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.exception.BadRequestException;
import org.nl.config.MapOf;
import org.nl.wms.ext.service.WmsToAcsService;
import org.nl.wms.ext.service.dto.to.BaseResponse;
import org.nl.wms.pdm.service.IPdmBdWorkorderService;
import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
import org.nl.wms.sch.point.service.ISchBasePointService;
import org.nl.wms.sch.point.service.dao.SchBasePoint;
import org.nl.wms.sch.task.service.ISchBaseTaskService;
import org.nl.wms.sch.task.service.ISchBaseTaskconfigService;
import org.nl.wms.sch.task.service.dao.SchBaseTask;
import org.nl.wms.sch.task.service.dao.SchBaseTaskconfig;
import org.nl.wms.sch.task_manage.AbstractTask;
import org.nl.wms.sch.task_manage.enums.GroupBindMaterialStatusEnum;
import org.nl.wms.sch.task_manage.enums.GroupStatusEnum;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.mapper.PointMapper;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: psh
* @Description: 涂板线补空架
* @Date: 2023/9/28
*/
@Slf4j
@Component
@TaskType("TBXBKJTask")
@Lazy
public class TBXBKJTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "TBXBKJTask";
/**
* 入口
*/
private static String ENTRANCE = "1";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private PointMapper pointMapper;
@Autowired
private WmsToAcsService wmsToAcsService;
/**
* 涂版线工位发起叫料请求
* 从对应AB区的空固化架缓存位生成搬运任务
* 不记录组盘，不考虑点位状态
*/
@Override
// @Transactional(rollbackFor = Exception.class)
protected void create() throws BadRequestException {
// 获取任务
List<SchBaseTask> tasks = taskService.findTasksByTaskStatus(TASK_CONFIG_CODE, TaskStatus.APPLY);
// 配置信息
SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
.eq(SchBaseTaskconfig::getConfig_code, TASK_CONFIG_CODE));
for (SchBaseTask task : tasks) {
// 找起点
SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getPoint_code, task.getPoint_code2()));
SchBasePoint point = findNextPoint(startPoint,task);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
log.info("涂板线补空架未找到空架缓存点存在空架！");
continue;
}
// 设置终点并修改创建成功状态
if("TBX1".equals(startPoint.getRegion_code())) {
task.setTask_type("4");
}else{
task.setTask_type("7");
}
task.setPoint_code1(point.getStart_wait_point());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
taskService.update(task);
//下发
this.renotifyAcs(task);
}
}
/**
* 从01到10顺序判断最先有货的工位
*/
private SchBasePoint findNextPoint(SchBasePoint startPoint,SchBaseTask task) {
String regionCode = null;
if ("TBX1".equals(startPoint.getRegion_code())) {
//TBX1找A区
regionCode = "HCQ1";
} else if ("TBX2".equals(startPoint.getRegion_code())) {
//TBX2找B区
regionCode = "HCQ5";
}
SchBasePoint temp = null;
List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion(regionCode, "1");
for (SchBasePoint schBasePoint : schBasePointList) {
//如果当前任务已锁定则直接返回
if(task.getTask_code().equals(schBasePoint.getIng_task_code())){
return schBasePoint;
}
if (schBasePoint.getVehicle_qty() > 0 &&
(ObjectUtil.isEmpty(schBasePoint.getIng_task_code()))) {
if (temp == null ||
schBasePoint.getPoint_code().startsWith(temp.getPoint_code().substring(0, temp.getPoint_code().length() - 2))
&&schBasePoint.getPoint_code().compareTo(temp.getPoint_code())>0){
temp=schBasePoint;
log.info("涂板线补空架找到当前符合条件的点位{}", schBasePoint.getPoint_code());
}
}
}
return temp;
}
@Override
// @Transactional(rollbackFor = Exception.class)
protected void updateStatus(String task_code, TaskStatus status) {
// 校验任务
SchBaseTask taskObj = taskService.getById(task_code);
if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
throw new BadRequestException("该任务已完成!");
}
if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
throw new BadRequestException("该任务已取消!");
}
String startPoint = taskObj.getPoint_code1(); // 获取起点
String endPoint = taskObj.getPoint_code2(); // 获取终点
SchBasePoint startPointObj = pointService.getById(startPoint);
SchBasePoint endPointObj = pointService.getById(endPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
// 起点解锁,库存减少
startPointObj.setIng_task_code("");
startPointObj.setVehicle_qty(startPointObj.getVehicle_qty() - 1);
pointService.update(startPointObj);
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 起点解锁
if (ObjectUtil.isNotEmpty(startPointObj)) {
startPointObj.setIng_task_code("");
pointService.update(endPointObj);
}
// 终点解锁
if (ObjectUtil.isNotEmpty(endPointObj)) {
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
}
taskObj.setRemark("任务取消");
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
}
taskService.update(taskObj);
}
@Override
public void forceFinish(String task_code) {
this.updateStatus(task_code, TaskStatus.FINISHED);
}
@Override
public void cancel(String task_code) {
this.updateStatus(task_code, TaskStatus.CANCELED);
}
@Override
protected void feedbackTaskState(JSONObject param, SchBaseTask schBaseTask, BaseResponse result) {
//todo 重算最优点
SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getPoint_code, schBaseTask.getPoint_code2()));
SchBasePoint point = this.findNextPoint(startPoint,schBaseTask);
schBaseTask.setPoint_code1(point.getPoint_code());
//重算点位时把点位占用，防止发起重复任务
point.setIng_task_code(schBaseTask.getTask_code());
// //空固化架区别于组盘，任务完成后再扣除库存
//// point.setVehicle_qty(point.getVehicle_qty() - 1);
pointService.update(point);
}
}

10
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/BPSLTask.java → lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/YCLCKTask.java
View File

@@ -39,15 +39,15 @@ import java.util.stream.Collectors;
/**
* @Author: psh
* @Description: 包片上料
* @Date: 2023/9/28
* @Description: 原材料出库
* @Date: 2023/1/24
*/
@Slf4j
@Component
@TaskType("BPSLTask")
@TaskType("YCLCKTask")
@Lazy
public class BPSLTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "BPSLTask";
public class YCLCKTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "YCLCKTask";
/**
* 入口
*/

40
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/MJXLTask.java → lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/YCLRKTask.java
View File

@@ -40,15 +40,15 @@ import java.util.Set;
/**
* @Author: psh
* @Description: 满架下料
* @Date: 2023/9/28
* @Description: 原材料入库
* @Date: 2024/1/24
*/
@Slf4j
@Component
@TaskType("MJXLTask")
@TaskType("YCLRKTask")
@Lazy
public class MJXLTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "MJXLTask";
public class YCLRKTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "YCLRKTask";
/**
* 入口
*/
@@ -82,28 +82,24 @@ public class MJXLTask extends AbstractTask {
.eq(SchBasePoint::getPoint_code, task.getPoint_code1()));
String extGroupData = task.getExt_group_data();
JSONObject jsonObject = JSONObject.parseObject(extGroupData);
String materialType = jsonObject.getString("material_type");
// String materialType = jsonObject.getString("material_type");
SchBasePoint point = findNextPoint(startPoint, jsonObject);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
log.info("满架下料未找到当前符合条件的点位materialType:{},", materialType);
log.info("原材料入库未找到当前符合条件的点位！");
continue;
}
task.setTask_type("5");
if("TBX2".equals(startPoint.getRegion_code())){
task.setTask_type("9");
}
// 设置终点并修改创建成功状态
task.setPoint_code2(point.getNext_wait_point());
task.setPoint_code2(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
taskService.update(task);
//发起任务时先把点位占用，防止发起重复任务
// point.setIng_task_code(task.getTask_code());
point.setVehicle_type(materialType);
point.setIng_task_code(task.getTask_code());
// point.setVehicle_type(materialType);
pointService.update(point);
//下发
@@ -263,9 +259,6 @@ public class MJXLTask extends AbstractTask {
if (ObjectUtil.isNotEmpty(endPointObj)) {
endPointObj.setIng_task_code("");
//任务取消把原先占用的位置释放
if (endPointObj.getVehicle_qty() <= 0) {
endPointObj.setVehicle_type(null);
}
pointService.update(endPointObj);
}
taskObj.setRemark("任务取消");
@@ -286,17 +279,6 @@ public class MJXLTask extends AbstractTask {
@Override
protected void feedbackTaskState(JSONObject param, SchBaseTask schBaseTask, BaseResponse result) {
//重新计算固化室放货点位
JSONObject extGroupData = JSONObject.parseObject(schBaseTask.getExt_group_data());
SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getPoint_code, schBaseTask.getPoint_code1()));
SchBasePoint point = findNextPoint(startPoint, extGroupData);
schBaseTask.setPoint_code2(point.getPoint_code()+"0"+(point.getVehicle_qty()+1));
if(ObjectUtil.isNotEmpty(point.getIng_task_code())&&!schBaseTask.getTask_code().equals(point.getIng_task_code())){
throw new BadRequestException("当前固化室点位有任务，暂不反馈！");
}
//重算点位时把点位占用
point.setIng_task_code(schBaseTask.getTask_code());
pointService.update(point);
//该场景无需重算等待点
}
}

99
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/ZJBZKDDTask.java
View File

@@ -1,99 +0,0 @@
package org.nl.wms.sch.task_manage.task.tasks;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.exception.BadRequestException;
import org.nl.config.MapOf;
import org.nl.wms.ext.service.WmsToAcsService;
import org.nl.wms.ext.service.dto.to.BaseResponse;
import org.nl.wms.pdm.service.IPdmBdWorkorderService;
import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
import org.nl.wms.sch.point.service.ISchBasePointService;
import org.nl.wms.sch.point.service.dao.SchBasePoint;
import org.nl.wms.sch.task.service.ISchBaseTaskService;
import org.nl.wms.sch.task.service.ISchBaseTaskconfigService;
import org.nl.wms.sch.task.service.dao.SchBaseTask;
import org.nl.wms.sch.task.service.dao.SchBaseTaskconfig;
import org.nl.wms.sch.task_manage.AbstractTask;
import org.nl.wms.sch.task_manage.enums.GroupBindMaterialStatusEnum;
import org.nl.wms.sch.task_manage.enums.GroupStatusEnum;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.mapper.PointMapper;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: psh
* @Description: 正极板转库堆叠
* @Date: 2023/9/28
*/
@Slf4j
@Component
@TaskType("ZJBZKDDTask")
@Lazy
public class ZJBZKDDTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "ZJBZKDDTask";
/**
* 入口
*/
private static String ENTRANCE = "1";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private PointMapper pointMapper;
@Autowired
private WmsToAcsService wmsToAcsService;
@Override
// @Transactional(rollbackFor = Exception.class)
protected void create() throws BadRequestException {
}
private SchBasePoint findNextPoint(SchBasePoint startPoint) {
return null;
}
@Override
// @Transactional(rollbackFor = Exception.class)
protected void updateStatus(String task_code, TaskStatus status) {
}
@Override
public void forceFinish(String task_code) {
this.updateStatus(task_code, TaskStatus.FINISHED);
}
@Override
public void cancel(String task_code) {
this.updateStatus(task_code, TaskStatus.CANCELED);
}
@Override
protected void feedbackTaskState(JSONObject param,SchBaseTask schBaseTask, BaseResponse result) {
//todo 重算最优点
}
}

294
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/ghs/GHSFMTask.java
View File

@@ -1,294 +0,0 @@
package org.nl.wms.sch.task_manage.task.tasks.ghs;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.exception.BadRequestException;
import org.nl.config.MapOf;
import org.nl.wms.database.material.service.dao.MdBaseMaterial;
import org.nl.wms.ext.service.WmsToAcsService;
import org.nl.wms.ext.service.dto.to.BaseResponse;
import org.nl.wms.pdm.service.IPdmBdWorkorderService;
import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
import org.nl.wms.sch.point.service.ISchBasePointService;
import org.nl.wms.sch.point.service.dao.SchBasePoint;
import org.nl.wms.sch.task.service.ISchBaseTaskService;
import org.nl.wms.sch.task.service.ISchBaseTaskconfigService;
import org.nl.wms.sch.task.service.dao.SchBaseTask;
import org.nl.wms.sch.task.service.dao.SchBaseTaskconfig;
import org.nl.wms.sch.task_manage.AbstractTask;
import org.nl.wms.sch.task_manage.GeneralDefinition;
import org.nl.wms.sch.task_manage.enums.GroupBindMaterialStatusEnum;
import org.nl.wms.sch.task_manage.enums.GroupStatusEnum;
import org.nl.wms.sch.task_manage.enums.PointStatusEnum;
import org.nl.wms.sch.task_manage.enums.WorkOrderStatusEnum;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.mapper.PointMapper;
import org.nl.wms.util.PointUtils;
import org.nl.wms.util.TaskUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: psh
* @Description: 固化室起始站点放满后自动生成搬运到内部的任务，优先级为8
* @Date: 2023/9/28
*/
@Slf4j
@Component
@TaskType("GHSFMTask")
@Lazy
public class GHSFMTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "GHSFMTask";
/**
* 入口
*/
private static String ENTRANCE = "1";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private PointMapper pointMapper;
@Autowired
private WmsToAcsService wmsToAcsService;
/**
* 1.扫描每个允许放货的固化室01和06位置是否满足三列均已放满，开始下一层判断
* 2.如果当列1-5或6-10总15个位置已经放满，则进行下一层判断
* 3.如果该固化室30个位置全部放满，则通知acs告知固化室开始固化
* 4.如果内部2-5或7-10仍有空列，则生成1-（2-5），6-（7-10）的任务，优先级为8最高
*/
@Override
// @Transactional(rollbackFor = Exception.class)
protected void create() throws BadRequestException {
List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion("GHS", "2");
for (SchBasePoint schBasePoint : schBasePointList) {
if (!schBasePoint.getPoint_code().endsWith("01") &&
!schBasePoint.getPoint_code().endsWith("06")) {
continue;
}
if (schBasePoint.getVehicle_qty() == 3 && ObjectUtil.isEmpty(schBasePoint.getIng_task_code())) {
log.info("固化室对接位{}已经放满,开始进行后续判断", schBasePoint.getPoint_code());
String first = schBasePoint.getPoint_code().substring(0, schBasePoint.getPoint_code().length() - 2);
String last = schBasePoint.getPoint_code().substring(schBasePoint.getPoint_code().length() - 1);
String middle = schBasePoint.getPoint_code().substring(schBasePoint.getPoint_code().length() - 4, schBasePoint.getPoint_code().length() - 2);
boolean flag = false;
String pointCode = null;
//倒叙检查是否有符合要求的终点
for (int i = 4; i > 0; i--) {
pointCode = first + String.format("%02d", Integer.valueOf(last) + i);
for (SchBasePoint schBasePoint1 : schBasePointList) {
if (schBasePoint1.getPoint_code().equals(pointCode)
&& schBasePoint1.getVehicle_qty() == 0 && ObjectUtil.isEmpty(schBasePoint1.getIng_task_code())) {
log.info("找到当前列内部存在空位{}", pointCode);
flag = true;
break;
}
}
if (flag) {
break;
}
}
if (flag) {
//生成任务并下发
this.createTask(schBasePoint, pointCode);
} else {
//如果当列均已放满，检查隔壁列是否已全部放满
if ("1".equals(last)) {
last = "6";
}
for (int i = 0; i <= 4; i++) {
pointCode = first + String.format("%02d", Integer.valueOf(last) + i);
for (SchBasePoint schBasePoint1 : schBasePointList) {
if (schBasePoint1.getPoint_code().equals(pointCode)
&& (schBasePoint1.getVehicle_qty() != 3 || ObjectUtil.isNotEmpty(schBasePoint1.getIng_task_code()))) {
log.info("检查当前固化室{}隔壁列，找到当前列内部存在空位{}，不发送固化请求", schBasePoint.getPoint_code(), pointCode);
flag = true;
break;
}
}
}
}
if (!flag) {
//通知acs已经放满，固化室可以进行固化
String device_code = "ZDM" + middle;
log.info("当前固化室已经全部放满，通知固化室的自动门{}开始固化", device_code);
JSONObject map = new JSONObject();
map.put("device_code", device_code);
map.put("type", "1");
wmsToAcsService.notifyAcs(map);
}
}
}
}
/**
* 创建任务并下发
*
* @param schBasePoint
* @param endPoint
* @return
*/
private void createTask(SchBasePoint schBasePoint, String endPoint) {
// 申请任务
SchBaseTask task = new SchBaseTask(); // 任务实体
String apply_point_code = schBasePoint.getPoint_code(); // 请求点
String config_code = "GHSFMTask";
// 1、校验数据
SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
.eq(SchBaseTaskconfig::getConfig_code, config_code));
Assert.notNull(taskConfig, "找不到配置文件，请确认[" + config_code + "]配置是否存在！");
// 最大任务数
Integer tcmn = taskConfig.getTask_create_max_num();
// 获取执行中的任务
List<SchBaseTask> unFinishTasksByTaskConfig = taskService.findUnFinishTasksByTaskConfig(
taskConfig.getConfig_code(), apply_point_code + "01", taskConfig.getTask_direction());
Assert.isFalse(unFinishTasksByTaskConfig.size() >= tcmn,
"该点位申请的任务未完成数已超过上限，无法申请任务");
// 获取对接位点位对象
SchBasePoint pointObj = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getPoint_code, apply_point_code));
// 校验是否需要自动agv
if (!pointObj.getIs_auto()) {
// 如果不需要自动，则不创建任务
return;
}
// 2、创建申请任务
task.setConfig_code(config_code);
task.setCreate_mode(GeneralDefinition.ACS_CREATION);
task.setVehicle_code(schBasePoint.getVehicle_code());
task.setVehicle_qty(schBasePoint.getVehicle_qty());
task.setTask_status(TaskStatus.APPLY.getCode());
task.setWorkshop_code(taskConfig.getWorkshop_code()); // 车间编码
//acs固化室首位不存在01和06整体概念，需要补充01生成第一个点位的任务
task.setPoint_code1(apply_point_code + "01");
task.setTask_type("2");
task.setPoint_code2(endPoint);
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
// 设置起/终点
// this.setTaskPoint(taskConfig, task, apply_point_code);
taskService.create(task);
//下发
this.renotifyAcs(task);
}
/**
* 修改任务状态
* 1.任务完成时，无需再次组盘，将点位表起点货位三个组盘信息移动到终点
* 2.组盘表中三个点位增加移动动作，并且修改当前点位到目标地点
* 3.
*
* @param task_code
* @param status
* @return
*/
@Override
// @Transactional(rollbackFor = Exception.class)
protected void updateStatus(String task_code, TaskStatus status) {
// 校验任务
SchBaseTask taskObj = taskService.getById(task_code);
if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
throw new BadRequestException("该任务已完成!");
}
if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
throw new BadRequestException("该任务已取消!");
}
String startPoint = taskObj.getPoint_code1().substring(0, taskObj.getPoint_code1().length() - 2); // 获取起点
String endPoint = taskObj.getPoint_code2(); // 获取终点
SchBasePoint startPointObj = pointService.getById(startPoint);
SchBasePoint endPointObj = pointService.getById(endPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
StringBuilder group_id = new StringBuilder();
// 终点解锁
endPointObj.setIng_task_code("");
endPointObj.setVehicle_type(startPointObj.getVehicle_type());
endPointObj.setVehicle_code(startPointObj.getVehicle_code());
endPointObj.setVehicle_qty(startPointObj.getVehicle_qty());
endPointObj.setUpdate_time(DateUtil.now());
pointService.update(endPointObj);
List<String> vehicleCodeList = Arrays.stream(startPointObj.getVehicle_code().split(",")).collect(Collectors.toList());
for (String vehicleCode : vehicleCodeList) {
SchBaseVehiclematerialgroup one = vehiclematerialgroupService.getOne(new LambdaQueryWrapper<SchBaseVehiclematerialgroup>()
.eq(SchBaseVehiclematerialgroup::getVehicle_code, vehicleCode)
.eq(SchBaseVehiclematerialgroup::getGroup_bind_material_status,
GroupBindMaterialStatusEnum.BOUND.getValue()));
if (ObjectUtil.isNotEmpty(one)) {
// throw new BadRequestException(vehicleCode + " => " + startPointObj.getVehicle_type() + "的组盘信息未找到");
// }
one.setTask_code(taskObj.getTask_code());
one.setPoint_code(endPointObj.getPoint_code()); // 当前位置
one.setPoint_name(endPointObj.getPoint_name());
one.setMove_way(one.getMove_way() == null ? "" : (one.getMove_way() + " -> ") + endPointObj.getPoint_code());
one.setUpdate_id(GeneralDefinition.ACS_ID);
one.setUpdate_name(GeneralDefinition.ACS_NAME);
one.setUpdate_time(DateUtil.now());
vehiclematerialgroupService.updateById(one);
group_id.append(one.getGroup_id()).append(',');
}
}
// 起点清空
if (ObjectUtil.isNotEmpty(startPointObj)) {
PointUtils.clearPoint(startPointObj);
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setGroup_id(group_id.toString());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 终点解锁
if (ObjectUtil.isNotEmpty(endPointObj)) {
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
}
taskObj.setRemark("任务取消");
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
}
taskService.update(taskObj);
}
@Override
public void forceFinish(String task_code) {
this.updateStatus(task_code, TaskStatus.FINISHED);
}
@Override
public void cancel(String task_code) {
this.updateStatus(task_code, TaskStatus.CANCELED);
}
@Override
protected void feedbackTaskState(JSONObject param, SchBaseTask schBaseTask, BaseResponse result) {
//todo 重算最优点
}
}

347
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/ghs/GHSQHTask.java
View File

@@ -1,347 +0,0 @@
package org.nl.wms.sch.task_manage.task.tasks.ghs;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.exception.BadRequestException;
import org.nl.config.MapOf;
import org.nl.wms.ext.service.WmsToAcsService;
import org.nl.wms.ext.service.dto.to.BaseResponse;
import org.nl.wms.pdm.service.IPdmBdWorkorderService;
import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
import org.nl.wms.sch.point.service.ISchBasePointService;
import org.nl.wms.sch.point.service.dao.SchBasePoint;
import org.nl.wms.sch.task.service.ISchBaseTaskService;
import org.nl.wms.sch.task.service.ISchBaseTaskconfigService;
import org.nl.wms.sch.task.service.dao.SchBaseTask;
import org.nl.wms.sch.task.service.dao.SchBaseTaskconfig;
import org.nl.wms.sch.task_manage.AbstractTask;
import org.nl.wms.sch.task_manage.GeneralDefinition;
import org.nl.wms.sch.task_manage.enums.GroupBindMaterialStatusEnum;
import org.nl.wms.sch.task_manage.enums.GroupStatusEnum;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.mapper.PointMapper;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: psh
* @Description: 固化室通知取货后将十个点位增加到取货队列，固化室发起自动取货任务，当前固化室十个点位取货完毕后通知固化室取货完毕
* @Date: 2023/9/28
*/
@Slf4j
@Component
@TaskType("GHSQHTask")
@Lazy
public class GHSQHTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "GHSQHTask";
/**
* 入口
*/
private static String ENTRANCE = "1";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private PointMapper pointMapper;
@Autowired
private WmsToAcsService wmsToAcsService;
/**
* 1.扫描每个允许取货的固化室从1-10的顺序开始进行取货
*/
@Override
// @Transactional(rollbackFor = Exception.class)
protected void create() throws BadRequestException {
List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion("GHS", "3");
if (schBasePointList.size() == 0) {
// 消息通知
log.info("未找到当前符合允许取货的固化室点位，暂不生成任务");
return;
}
SchBasePoint schBasePoint = null;
//按顺序查找第一个符合条件的固化室位置，发起任务
for (SchBasePoint schBasePoint1 : schBasePointList) {
if (schBasePoint1.getVehicle_qty() == 3 && ObjectUtil.isEmpty(schBasePoint1.getIng_task_code())) {
schBasePoint = schBasePoint1;
break;
}
}
if (ObjectUtil.isEmpty(schBasePoint)) {
// 消息通知
log.info("未找到当前符合允许取货的固化室点位，暂不生成任务");
return;
}
SchBasePoint nextPoint = this.findNextPoint(schBasePoint);
if (ObjectUtil.isEmpty(nextPoint)) {
// 消息通知
log.info("未找到当前符合允许放货的缓存点，暂不生成任务Vehicle_type:{}", schBasePoint.getVehicle_type());
return;
}
// 放料先去等待点
this.createTask(schBasePoint, nextPoint.getStart_wait_point());
}
/**
* 创建任务并下发
*
* @param schBasePoint
* @param endPoint
* @return
*/
private void createTask(SchBasePoint schBasePoint, String endPoint) {
// 申请任务
SchBaseTask task = new SchBaseTask(); // 任务实体
String apply_point_code = schBasePoint.getPoint_code(); // 请求点
// 获取对接位点位对象
SchBasePoint pointObj = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getPoint_code, apply_point_code));
//首位01或06生成任务需要补01，例如GHS0101下发需要改成GHS010101
if(apply_point_code.endsWith("01")||apply_point_code.endsWith("06")) {
apply_point_code+="01";
}
String config_code = "GHSQHTask";
// 1、校验数据
SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
.eq(SchBaseTaskconfig::getConfig_code, config_code));
Assert.notNull(taskConfig, "找不到配置文件，请确认[" + config_code + "]配置是否存在！");
// 最大任务数
Integer tcmn = taskConfig.getTask_create_max_num();
// 获取执行中的任务
List<SchBaseTask> unFinishTasksByTaskConfig = taskService.findUnFinishTasksByTaskConfig(
taskConfig.getConfig_code(), apply_point_code, taskConfig.getTask_direction());
Assert.isFalse(unFinishTasksByTaskConfig.size() >= tcmn,
"该点位申请的任务未完成数已超过上限，无法申请任务");
// 校验是否需要自动agv
if (!pointObj.getIs_auto()) {
// 如果不需要自动，则不创建任务
return;
}
// 2、创建申请任务
task.setConfig_code(config_code);
task.setCreate_mode(GeneralDefinition.ACS_CREATION);
task.setVehicle_code(schBasePoint.getVehicle_code());
task.setVehicle_qty(schBasePoint.getVehicle_qty());
// task.setTask_status(TaskStatus.APPLY.getCode());
task.setWorkshop_code(taskConfig.getWorkshop_code()); // 车间编码
//首位01或06生成任务需要补01，例如GHS0101下发需要改成GHS010101
task.setPoint_code1(apply_point_code);
task.setPoint_code2(endPoint);
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
if("GHS1".equals(schBasePoint.getRegion_code())) {
task.setTask_type("6");
}else{
task.setTask_type("10");
}
// 设置起/终点
// this.setTaskPoint(taskConfig, task, apply_point_code);
taskService.create(task);
//下发
this.renotifyAcs(task);
}
/**
* 1.根据当前固化室所处区域，判断到哪个区的缓存位
* 正极板到HCQ4,负极板到HCQ2，边负极板到HCQ3
* 2.从1010列到0101列倒叙判断当前列物料类型是否与起点一致且存在空位
* 3.将当前点位设置为目标点
* 4.如果没有符合条件的点位，跳过执行暂时等待
*/
private SchBasePoint findNextPoint(SchBasePoint startPoint) {
String regionCode = null;
String materialType = startPoint.getVehicle_type();
if ("1".equals(startPoint.getVehicle_type())) {
//正极板到缓存区4
regionCode = "HCQ4";
} else if ("2".equals(startPoint.getVehicle_type())) {
//负极板到缓存区2
regionCode = "HCQ2";
} else if ("3".equals(startPoint.getVehicle_type())) {
//边负极板到缓存区3
regionCode = "HCQ3";
}
List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion(regionCode, "1");
for (int i = schBasePointList.size() - 1; i >= 0; i--) {
SchBasePoint schBasePoint = schBasePointList.get(i);
SchBasePoint temp = null;
if (schBasePoint.getVehicle_qty() == 0
&& ObjectUtil.isEmpty(schBasePoint.getIng_task_code())
//放货三拖一起放，只能到01位置
&& schBasePoint.getPoint_code().endsWith("01")
&& (ObjectUtil.isEmpty(schBasePoint.getVehicle_type()) || materialType.equals(schBasePoint.getVehicle_type()))) {
//发现有空位时暂存当前位置，检查当前列前面是否存在已放货位置，找最前面无货的位置
//如果当列其他位置均已放满，则继续找下一列
List<SchBasePoint> tempList = pointMapper.findPointByParentPoint(schBasePoint.getParent_point_code());
for (SchBasePoint tempPoint : tempList) {
if ((tempPoint.getVehicle_qty() != 0 || ObjectUtil.isNotEmpty(schBasePoint.getIng_task_code()))
) {
break; // 如果当前库位非空，则跳出循环
} else {
if(tempPoint.getPoint_code().endsWith("01")) {
temp = tempPoint; // 更新最大空库位
}
}
}
if (temp != null) {
log.info("固化室取货任务找到当前符合条件的缓存区位置{}", schBasePoint.getPoint_code());
}
return temp;
}
}
return null;
}
/**
* 1.如果起点点位为10结尾视为最后该固化室最后一个任务，取完后通知acs取货完毕
*/
@Override
// @Transactional(rollbackFor = Exception.class)
protected void updateStatus(String task_code, TaskStatus status) {
// 校验任务
SchBaseTask taskObj = taskService.getById(task_code);
if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
throw new BadRequestException("该任务已完成!");
}
if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
throw new BadRequestException("该任务已取消!");
}
String startPoint = taskObj.getPoint_code1(); // 获取起点
if(startPoint.endsWith("0101")||startPoint.endsWith("0601")){
startPoint=startPoint.substring(0,startPoint.length()-2);
}
String endPoint = taskObj.getPoint_code2(); // 获取终点
SchBasePoint startPointObj = pointService.getById(startPoint);
SchBasePoint endPointObj = pointService.getById(endPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
StringBuilder group_id = new StringBuilder();
// 终点解锁，缓存区现在由一个点位改为三个点位，所以将物料存在010203三个位置上
for(int i=1;i<=3;i++) {
SchBasePoint point = pointService.getById(endPoint.substring(0,endPoint.length()-1)+i);
point.setIng_task_code("");
List<String> vehicleCodeList = Arrays.stream(startPointObj.getVehicle_code().split(",")).collect(Collectors.toList());
point.setVehicle_code(vehicleCodeList.get(i-1));
point.setVehicle_type(startPointObj.getVehicle_type());
point.setVehicle_qty(1);
point.setUpdate_time(DateUtil.now());
pointService.update(point);
}
//固化室放料完毕后，将当前一整排都标记上物料信息，防止出现混放情况
pointMapper.updateVehicleType(endPointObj.getPoint_code().substring(0, endPointObj.getPoint_code().length() - 2), endPointObj.getVehicle_type());
List<String> vehicleCodeList = Arrays.stream(startPointObj.getVehicle_code().split(",")).collect(Collectors.toList());
for (int i=0;i<vehicleCodeList.size();i++) {
String vehicleCode=vehicleCodeList.get(i);
SchBaseVehiclematerialgroup one = vehiclematerialgroupService.getOne(new LambdaQueryWrapper<SchBaseVehiclematerialgroup>()
.eq(SchBaseVehiclematerialgroup::getVehicle_code, vehicleCode)
.eq(SchBaseVehiclematerialgroup::getGroup_bind_material_status,
GroupBindMaterialStatusEnum.BOUND.getValue()));
if (ObjectUtil.isNotEmpty(one)) {
one.setTask_code(taskObj.getTask_code());
one.setPoint_code(endPointObj.getPoint_code().substring(0, endPointObj.getPoint_code().length() - 1) + (i + 1)); // 当前位置
one.setPoint_name(endPointObj.getPoint_name().substring(0, endPointObj.getPoint_name().length() - 1) + (i + 1));
one.setMove_way(one.getMove_way() == null ? "" : (one.getMove_way() + " -> ") + endPointObj.getPoint_code().substring(0, endPointObj.getPoint_code().length() - 1) + (i + 1));
one.setUpdate_id(GeneralDefinition.ACS_ID);
one.setUpdate_name(GeneralDefinition.ACS_NAME);
one.setUpdate_time(DateUtil.now());
vehiclematerialgroupService.updateById(one);
group_id.append(one.getGroup_id()).append(',');
}
}
// 起点清空
if (ObjectUtil.isNotEmpty(startPointObj)) {
PointUtils.clearPoint(startPointObj);
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setGroup_id(group_id.toString());
taskObj.setRemark("任务完成");
//如果起点点位为10结尾视为最后该固化室最后一个任务，取完后通知acs取货完毕
// (如果不放满的情况可以固化，可能逻辑需要改成任务完成时检测当前固化室所有点位是否已完成)
if (taskObj.getPoint_code1().endsWith("10")) {
String middle = taskObj.getPoint_code1().substring(taskObj.getPoint_code1().length() - 4, taskObj.getPoint_code1().length() - 2);
//通知acs已经放满，固化室可以进行固化
String device_code = "ZDM" + middle;
log.info("当前固化室已经全部取完，通知固化室的自动门{}取货完毕", device_code);
JSONObject map = new JSONObject();
map.put("device_code", device_code);
map.put("type", "2");
wmsToAcsService.notifyAcs(map);
}
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 终点解锁
if (ObjectUtil.isNotEmpty(endPointObj)) {
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
}
taskObj.setRemark("任务取消");
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
}
taskService.update(taskObj);
}
@Override
public void forceFinish(String task_code) {
this.updateStatus(task_code, TaskStatus.FINISHED);
}
@Override
public void cancel(String task_code) {
this.updateStatus(task_code, TaskStatus.CANCELED);
}
@SneakyThrows
@Override
protected void feedbackTaskState(JSONObject param, SchBaseTask schBaseTask, BaseResponse result) {
//todo 重算最优点
String schBasePoint=schBaseTask.getPoint_code1();
if(schBasePoint.endsWith("0101")||schBasePoint.endsWith("0601")){
schBasePoint=schBasePoint.substring(0,schBasePoint.length()-2);
}
SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getPoint_code, schBasePoint));
SchBasePoint nextPoint = this.findNextPoint(startPoint);
if (ObjectUtil.isEmpty(nextPoint)) {
throw new Exception("当前起点" + schBaseTask.getPoint_code1() + "未找到合适的放货点位");
}
//上位记的是整一个缓存区三个点
schBaseTask.setPoint_code2(nextPoint.getPoint_code());
nextPoint.setIng_task_code(schBaseTask.getTask_code());
pointService.update(nextPoint);
}
}

2
lms/nladmin-system/nlsso-server/src/main/resources/config/application-dev.yml
View File

@@ -6,7 +6,7 @@ spring:
druid:
db-type: com.alibaba.druid.pool.DruidDataSource
driverClassName: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
url: jdbc:log4jdbc:mysql://${DB_HOST:127.0.0.1}:${DB_PORT:3306}/${DB_NAME:cw_lms}?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&useOldAliasMetadataBehavior=true
url: jdbc:log4jdbc:mysql://${DB_HOST:127.0.0.1}:${DB_PORT:3306}/${DB_NAME:gc_lms}?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&useOldAliasMetadataBehavior=true
# url: jdbc:log4jdbc:mysql://${DB_HOST:47.111.78.178}:${DB_PORT:3306}/${DB_NAME:stand_lms}?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&useOldAliasMetadataBehavior=true
username: ${DB_USER:root}
password: ${DB_PWD:123456}