lyd/liaoninghexing
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat：分拣、冷却窑业务

Browse Source
This commit is contained in:
liyongde
2025-12-31 15:11:59 +08:00
parent 75cd7e6a04
commit 614c4b6c22
28 changed files with 2693 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/ext/acs/service/AcsToWmsService.java
View File

@@ -197,4 +197,11 @@ public interface AcsToWmsService {
BaseResponse applyOneCloth(JSONObject param);
ApplyTaskResponse recordOutCoolKilnTime(ApplyTaskRequest request);
/**
* 分拣清除库存
* @param baseRequest
* @return
*/
ApplyTaskResponse sortClearInventory(ApplyTaskRequest baseRequest);
}

32
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/ext/acs/service/impl/AcsToWmsServiceImpl.java
View File

@@ -665,6 +665,8 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
return this.recordKilnTime(baseRequest);
case GeneralDefinition.LQY:
return this.recordOutCoolKilnTime(baseRequest);
case GeneralDefinition.FJ:
return this.sortClearInventory(baseRequest);
default:
taskResponse.setMessage("参数错误！");
taskResponse.setCode(HttpStatus.HTTP_BAD_REQUEST);
@@ -1098,7 +1100,10 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
// 记录入窑记录
PdmBdKilnRecord record = kilnRecordService.oneByVehicleAndStatus(baseRequest.getVehicle_code(), "2");
if (ObjectUtil.isEmpty(record)) {
throw new BadRequestException("入窑记录不存在！");
record = kilnRecordService.oneByVehicleAndStatus("-", "2");
if (ObjectUtil.isEmpty(record)) {
throw new BadRequestException("入窑记录不存在！");
}
}
kilnRecordService.outCoolEmptyKilnInfo(record);
} else {
@@ -1113,4 +1118,29 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
}
return ApplyTaskResponse.responseOk(baseRequest.getRequestNo(), "扫码成功申请");
}
@Override
public ApplyTaskResponse sortClearInventory(ApplyTaskRequest baseRequest) {
log.info("扫码成功申请 - 分拣送空的参数: {}", baseRequest);
SchBasePoint point = pointService.getById(baseRequest.getDevice_code());
if (ObjectUtil.isEmpty(point)) {
throw new BadRequestException("点位[" + baseRequest.getDevice_code() + "]不存在!");
}
if (ObjectUtil.isEmpty(point.getVehicle_code())) {
throw new BadRequestException("点位没有的托盘号，请检查!");
}
baseRequest.setVehicle_code(point.getVehicle_code());
baseRequest.setVehicle_type(GeneralDefinition.STEEL_TRAY);
SchBaseVehiclematerialgroup groupInfo = vehiclematerialgroupService.getGroupInfo(baseRequest.getVehicle_code(), GeneralDefinition.STEEL_TRAY, GroupBindMaterialStatusEnum.BOUND.getValue());
if (null == groupInfo) {
throw new BadRequestException("组盘信息不存在，请确认是否为空盘！");
}
// 组盘信息解绑
groupInfo.setGroup_bind_material_status(GroupBindMaterialStatusEnum.UNBOUND.getValue());
TaskUtils.setGroupUpdateByAcs(groupInfo);
vehiclematerialgroupService.updateById(groupInfo);
// 点位清空
PointUtils.clearPoint(point);
return ApplyTaskResponse.responseOk(baseRequest.getRequestNo(), "扫码成功申请");
}
}

18
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm/record/service/IPdmBdKilnRecordService.java
View File

@@ -44,8 +44,18 @@ public interface IPdmBdKilnRecordService extends IService<PdmBdKilnRecord> {
*/
void deleteAll(Set<String> ids);
/**
* 入干燥窑插入记录
* @param groupInfo 组盘信息
* @param basePoint 当前点位
*/
void recordKilnInfo(SchBaseVehiclematerialgroup groupInfo, SchBasePoint basePoint);
/**
* 入干燥窑插入空盘记录
* @param vehicleCode
* @param basePoint
*/
void recordEmptyKilnInfo(String vehicleCode, SchBasePoint basePoint);
void outDryKilnInfo(String vehicleCode);
@@ -60,4 +70,12 @@ public interface IPdmBdKilnRecordService extends IService<PdmBdKilnRecord> {
void outCoolEmptyKilnInfo(PdmBdKilnRecord record);
void outCoolKilnInfo(PdmBdKilnRecord record);
void outCoolStatusKilnInfo(PdmBdKilnRecord record);
/**
* 直接入冷却窑插入记录
* @param point
*/
void recordCoolEmptyKilnInfo(SchBasePoint point);
void removeOneCoolEmptyInfo(SchBasePoint point);
}

34
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm/record/service/impl/PdmBdKilnRecordServiceImpl.java
View File

@@ -99,7 +99,6 @@ public class PdmBdKilnRecordServiceImpl extends ServiceImpl<PdmBdKilnRecordMappe
SchBasePoint device = pointService.getById(basePoint.getParent_point_code());
PdmBdKilnRecord record = new PdmBdKilnRecord();
record.setRecord_id(IdUtil.getSnowflake(1,1).nextIdStr());
record.setVehicle_code(basePoint.getVehicle_code());
// 空托
record.setVehicle_code(vehicleCode);
record.setVehicle_type("2");
@@ -148,7 +147,7 @@ public class PdmBdKilnRecordServiceImpl extends ServiceImpl<PdmBdKilnRecordMappe
LambdaQueryWrapper<PdmBdKilnRecord> lam = new LambdaQueryWrapper<>();
lam.eq(PdmBdKilnRecord::getVehicle_code, vehicleCode)
.eq(PdmBdKilnRecord::getStatus, status);
return getOne(lam);
return getOne(lam, false);
}
@Override
@@ -194,4 +193,35 @@ public class PdmBdKilnRecordServiceImpl extends ServiceImpl<PdmBdKilnRecordMappe
updateById(record);
}
@Override
public void recordCoolEmptyKilnInfo(SchBasePoint point) {
SchBasePoint device = pointService.getById(point.getParent_point_code());
PdmBdKilnRecord record = new PdmBdKilnRecord();
record.setRecord_id(IdUtil.getSnowflake(1,1).nextIdStr());
// 空托
record.setVehicle_code("-");
record.setVehicle_type("2");
record.setInto_cooling_kiln_time(DateUtil.now());
record.setCooling_code(device.getPoint_code());
record.setCooling_name(device.getPoint_name());
record.setStatus("2");
record.setCreate_time(DateUtil.now());
pdmBdKilnRecordMapper.insert(record);
}
@Override
public void removeOneCoolEmptyInfo(SchBasePoint point) {
LambdaQueryWrapper<PdmBdKilnRecord> lam = new LambdaQueryWrapper<>();
lam.eq(PdmBdKilnRecord::getVehicle_code, "-")
.eq(PdmBdKilnRecord::getCooling_code, point.getParent_point_code())
.eq(PdmBdKilnRecord::getStatus, "2");
List<PdmBdKilnRecord> pdmBdKilnRecords = pdmBdKilnRecordMapper.selectList(lam);
if (pdmBdKilnRecords.size() == 0) {
throw new BadRequestException("找不到冷却窑空");
}
PdmBdKilnRecord pdmBdKilnRecord = pdmBdKilnRecords.get(0);
pdmBdKilnRecord.setStatus("3");
pdmBdKilnRecordMapper.updateById(pdmBdKilnRecord);
}
}

2
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm/workorder/service/impl/PdmBdWorkorderServiceImpl.java
View File

@@ -129,7 +129,7 @@ public class PdmBdWorkorderServiceImpl extends ServiceImpl<PdmBdWorkorderMapper,
throw new BadRequestException("创建工单失败，物料[" + entity.getMaterial_id() + "]包装规格为空，请维护！");
}
// 计算一个托盘能放多少块砖
BigDecimal multiply = new BigDecimal(TaskUtils.convertMultiply(entity.getPack_method()));
BigDecimal multiply = new BigDecimal(TaskUtils.convertMultiply(material.getPack_method()));
// 1 获取所需数（以库存为主）
BigDecimal totalNum;
// 1.1 工单指定数

7
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task/service/ISchBaseTaskService.java
View File

@@ -143,4 +143,11 @@ public interface ISchBaseTaskService extends IService<SchBaseTask> {
* @return /
*/
BigDecimal getCallMaterialCarryingByDevice(String deviceCode);
/**
* 检测是否有任务
* @param pointCode 点位
* @return true: 有任务， false：没任务
*/
boolean checkTask(String pointCode);
}

2
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task/service/dao/mapper/SchBaseTaskMapper.java
View File

@@ -21,4 +21,6 @@ public interface SchBaseTaskMapper extends BaseMapper<SchBaseTask> {
int getCarryingByDevice(String deviceCode, String taskConfig);
IPage<SchBaseTask> selectPageLeftJoin(IPage<SchBaseTask> pages, SchBaseTaskQuery whereJson, List<String> collect);
Integer checkTask(String pointCode);
}

12
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task/service/dao/mapper/SchBaseTaskMapper.xml
View File

@@ -5,11 +5,12 @@
<select id="getEmptyVehicleCarryingByDevice" resultType="java.lang.Integer">
SELECT COUNT(*)
FROM `sch_base_task` t
LEFT JOIN sch_base_point p1 ON p1.point_code = t.point_code4
LEFT JOIN sch_base_point p1 ON p1.point_code = t.point_code2
LEFT JOIN sch_base_point p2 ON p2.point_code = #{deviceCode}
WHERE t.config_code = 'FJMLTask'
AND t.point_code4 IS NOT NULL
WHERE t.is_delete = FALSE
AND t.task_status IN ('1', '2', '3', '4')
AND ((t.config_code = 'FJQKTask')
OR (t.config_code = 'MDOutMoveTask' AND t.request_param LIKE CONCAT('%', t.point_code2, '%')))
AND p1.parent_point_code = p2.parent_point_code
</select>
<select id="getCarryingByDevice" resultType="java.lang.Integer">
@@ -73,4 +74,9 @@
</where>
ORDER BY t.create_time DESC
</select>
<select id="checkTask" resultType="java.lang.Integer">
select count(*) from sch_base_task t
where '5' > t.task_status and t.is_delete = false
and (t.point_code1 = #{pointCode} or t.point_code2 = #{pointCode} or t.point_code3 = #{pointCode} or t.point_code4 = #{pointCode})
</select>
</mapper>

6
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task/service/impl/SchBaseTaskServiceImpl.java
View File

@@ -251,4 +251,10 @@ public class SchBaseTaskServiceImpl extends ServiceImpl<SchBaseTaskMapper, SchBa
return schBaseTaskMapper.getCallMaterialCarryingByDevice(deviceCode);
}
@Override
public boolean checkTask(String pointCode) {
Integer num = schBaseTaskMapper.checkTask(pointCode);
return num > 0;
}
}

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

@@ -239,6 +239,10 @@ public abstract class AbstractTask {
*/
public abstract void cancel(String task_code);
public boolean checkTask(JSONObject param) {
return false;
}
/**
* 申请任务
*
@@ -251,9 +255,13 @@ public abstract class AbstractTask {
// 请求点
String apply_point_code = param.getString("device_code");
String config_code = param.getString("config_code");
if (ObjectUtil.isEmpty(config_code)) {
throw new BadRequestException("请配置任务编码！！！");
}
String requestNo = param.getString("requestNo");
String vehicleType = param.getString("vehicle_type");
String vehicleCode = TaskUtils.defaultVehicleCode(param.getString("vehicle_code"));
param.put("vehicle_code", vehicleCode);
AbstractTask bean = SpringContextHolder.getBean(this.getClass());
// 1、校验数据
SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
@@ -264,7 +272,9 @@ public abstract class AbstractTask {
// 获取执行中的任务
List<SchBaseTask> unFinishTasksByTaskConfig = taskService.findUnFinishTasksByTaskConfig(
taskConfig.getConfig_code(), apply_point_code, taskConfig.getTask_direction());
if (bean.checkTask(param)) {
throw new BadRequestException("已经创建过任务了！");
}
Assert.isFalse(unFinishTasksByTaskConfig.size() >= tcmn,
apply_point_code + "该点位申请的任务未完成数已超过上限，无法申请任务");
// 获取对接位点位对象

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

@@ -83,6 +83,10 @@ public class GeneralDefinition {
* 对接位
*/
public static final String DOCKING_POINT = "2";
/**
* 中转位
*/
public static final String TRANSIT_POSITION = "1";
/**
* 物料位
*/
@@ -136,6 +140,7 @@ public class GeneralDefinition {
*/
public static final String GZY = "GZY";
public static final String LQY = "LQY";
public static final String FJ = "FJ";
// 特殊: 1-缓存输送线入口，2-缓存输送线出口，3-上输送线，4-下输送线
/**
* 上输送线

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

@@ -0,0 +1,187 @@
package org.nl.wms.sch.task_manage.task.tasks.common;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.nl.common.exception.BadRequestException;
import org.nl.wms.pdm.track.service.IPdmBdProductionProcessTrackingService;
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_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.PointStatusEnum;
import org.nl.wms.sch.task_manage.enums.TaskFinishedTypeEnum;
import org.nl.wms.sch.task_manage.task.TaskFactory;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.fj.FJQKTask;
import org.nl.wms.util.PointUtils;
import org.nl.wms.util.TaskUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
/**
* 码垛移回库（中转移到半托货位）
* @Author: lyd
* @Date: 2025/12/22
*/
@Component(value = "MDInMoveTask")
public class MDInMoveTask extends AbstractTask {
private static final String TASK_CONFIG_CODE = "MDInMoveTask";
@Resource
private ISchBaseTaskService taskService;
@Resource
private ISchBaseTaskconfigService taskConfigService;
@Resource
private ISchBasePointService pointService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private IPdmBdProductionProcessTrackingService processTrackingService;
@Resource
private FJQKTask fjqkTask;
@Override
public void create() throws BadRequestException {
}
@Override
public void createCompletion(SchBaseTask task) {
JSONObject req = JSONObject.parseObject(task.getRequest_param());
task.setPoint_code2(req.getString("target"));
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
TaskUtils.setUpdateByAcs(task);
taskService.save(task);
}
@Override
public String setGroupPlate(JSONObject param) {
return param.getString("group_id");
}
@Override
protected void updateStatus(String task_code, TaskStatus status) {
// 校验任务
SchBaseTask taskObj = taskService.getByCode(task_code);
if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
throw new BadRequestException("该任务已完成!");
}
if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
throw new BadRequestException("该任务已取消!");
}
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) {
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
TaskUtils.setUpdateByAcs(taskObj);
taskService.updateById(taskObj);
}
if (status.equals(TaskStatus.FINISHED)) {
this.finishTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
}
if (status.equals(TaskStatus.CANCELED)) {
this.cancelTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
}
}
@Override
public void forceFinish(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
if (ObjectUtil.isEmpty(taskObj)) {
throw new BadRequestException("该任务不存在");
}
this.finishTask(taskObj, TaskFinishedTypeEnum.MANUAL_PC);
}
@Override
public void cancel(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
if (ObjectUtil.isEmpty(taskObj)) {
throw new BadRequestException("该任务不存在");
}
this.cancelTask(taskObj, TaskFinishedTypeEnum.MANUAL_PC);
}
@Transactional(rollbackFor = Exception.class)
public void finishTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
// 载具编码：前面需要根据任务判断，没有载具不能生成任务
String vehicle_code = taskObj.getVehicle_code();
String vehicleType = taskObj.getVehicle_type();
if (vehicleType == null || vehicleType.equals(GeneralDefinition.NO)) {
vehicleType = GeneralDefinition.STEEL_TRAY;
}
String startPoint = taskObj.getPoint_code1();
String endPoint = taskObj.getPoint_code2();
SchBasePoint startPointObj = pointService.getById(startPoint);
SchBasePoint endPointObj = pointService.getById(endPoint);
// 终点解锁
if (ObjectUtil.isNotEmpty(endPointObj)) {
// 修改组盘信息
SchBaseVehiclematerialgroup one = vehiclematerialgroupService.getOne(new LambdaQueryWrapper<SchBaseVehiclematerialgroup>()
.eq(SchBaseVehiclematerialgroup::getVehicle_code, vehicle_code)
.eq(SchBaseVehiclematerialgroup::getVehicle_type, vehicleType)
.eq(SchBaseVehiclematerialgroup::getGroup_bind_material_status,
GroupBindMaterialStatusEnum.BOUND.getValue()));
if (ObjectUtil.isEmpty(one)) {
throw new BadRequestException(vehicle_code + " => " + vehicleType + "的组盘信息未找到");
}
one.setTask_code(taskObj.getTask_code());
one.setPoint_code(endPointObj.getPoint_code());
one.setPoint_name(endPointObj.getPoint_name());
one.setMove_way(one.getMove_way() + " -> " + endPointObj.getPoint_code());
TaskUtils.setGroupUpdateByType(one, taskFinishedType);
vehiclematerialgroupService.updateById(one);
// 记录库存并解锁
endPointObj.setIng_task_code("");
endPointObj.setVehicle_code(vehicle_code);
endPointObj.setVehicle_type(vehicleType);
endPointObj.setVehicle_qty(1);
endPointObj.setPoint_status(PointStatusEnum.EMPTY_VEHICLE.getCode());
PointUtils.setUpdateByType(endPointObj, taskFinishedType);
pointService.updateById(endPointObj);
PointUtils.clearPoint(startPointObj);
// 是否需要释放
JSONObject req = JSONObject.parseObject(taskObj.getRequest_param());
String needReleased = req.getString("need_released");
if (ObjectUtil.isNotEmpty(needReleased)) {
pointService.update(new LambdaUpdateWrapper<SchBasePoint>()
.set(SchBasePoint::getIng_task_code, "")
.eq(SchBasePoint::getPoint_code, needReleased));
}
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark(GeneralDefinition.TASK_FINISH);
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
@Transactional(rollbackFor = Exception.class)
public void cancelTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
String endPoint = taskObj.getPoint_code2();
SchBasePoint endPointObj = pointService.getById(endPoint);
// 终点解锁
if (ObjectUtil.isNotEmpty(endPointObj)) {
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
}
taskObj.setRemark(GeneralDefinition.TASK_CANCEL);
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
}

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

@@ -10,13 +10,17 @@ 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.PointStatusEnum;
import org.nl.wms.sch.task_manage.enums.TaskFinishedTypeEnum;
import org.nl.wms.sch.task_manage.task.TaskFactory;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.fj.FJQKTask;
import org.nl.wms.util.PointUtils;
import org.nl.wms.util.TaskUtils;
import org.springframework.beans.factory.annotation.Autowired;
@@ -24,9 +28,12 @@ import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* 码垛移库
* 码垛移库（移到中转）
* @Author: lyd
* @Date: 2025/12/22
*/
@@ -36,11 +43,15 @@ public class MDOutMoveTask extends AbstractTask {
@Resource
private ISchBaseTaskService taskService;
@Resource
private ISchBaseTaskconfigService taskConfigService;
@Resource
private ISchBasePointService pointService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private IPdmBdProductionProcessTrackingService processTrackingService;
@Resource
private TaskFactory taskFactory;
@Override
public void create() throws BadRequestException {
@@ -48,14 +59,38 @@ public class MDOutMoveTask extends AbstractTask {
@Override
public void createCompletion(SchBaseTask task) {
JSONObject req = JSONObject.parseObject(task.getRequest_param());
task.setPoint_code2(req.getString("target"));
SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
.eq(SchBaseTaskconfig::getConfig_code, TASK_CONFIG_CODE));
List<String> nextRegionStr = Arrays.stream(taskConfig.getNext_region_str().split(","))
.collect(Collectors.toList());
// 找终点
SchBasePoint movePoint = findNextPoint(nextRegionStr);
if (ObjectUtil.isEmpty(movePoint)) {
throw new BadRequestException("找不到可用的中转点位！");
}
task.setPoint_code2(movePoint.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
TaskUtils.setUpdateByAcs(task);
taskService.save(task);
}
public SchBasePoint findNextPoint(List<String> nextRegionStr) {
// 查找移库点
LambdaQueryWrapper<SchBasePoint> lam = new LambdaQueryWrapper<>();
lam.in(SchBasePoint::getRegion_code, nextRegionStr)
// 当前执行的任务为空或者NULL，有数据表示锁住
.and(la -> la.isNull(SchBasePoint::getIng_task_code)
.or()
.eq(SchBasePoint::getIng_task_code, ""))
.eq(SchBasePoint::getIs_used, true)
.eq(SchBasePoint::getPoint_type, "2")
.eq(SchBasePoint::getPoint_status, "1")
.orderByAsc(SchBasePoint::getPoint_type)
.orderByAsc(SchBasePoint::getPoint_code);
return pointService.getOne(lam, false);
}
@Override
public String setGroupPlate(JSONObject param) {
return param.getString("group_id");
@@ -114,6 +149,8 @@ public class MDOutMoveTask extends AbstractTask {
if (vehicleType == null || vehicleType.equals(GeneralDefinition.NO)) {
vehicleType = GeneralDefinition.STEEL_TRAY;
}
String startPoint = taskObj.getPoint_code1();
SchBasePoint startPointObj = pointService.getById(startPoint);
String endPoint = taskObj.getPoint_code2();
SchBasePoint endPointObj = pointService.getById(endPoint);
// 终点解锁
@@ -138,10 +175,32 @@ public class MDOutMoveTask extends AbstractTask {
endPointObj.setVehicle_code(vehicle_code);
endPointObj.setVehicle_type(vehicleType);
endPointObj.setVehicle_qty(1);
endPointObj.setPoint_status(PointStatusEnum.FULL_POINT.getCode());
endPointObj.setPoint_status(PointStatusEnum.EMPTY_VEHICLE.getCode());
PointUtils.setUpdateByType(endPointObj, taskFinishedType);
pointService.updateById(endPointObj);
// 起点解锁，创建四点任务
JSONObject req = JSONObject.parseObject(taskObj.getRequest_param());
SchBasePoint point = pointService.getById(req.getString("point_code1"));
// 创建呼叫任务
AbstractTask task = taskFactory.getTask(req.getString("next"));
JSONObject param = new JSONObject();
if ("FJMLTask".equals(req.getString("next"))) {
SchBaseVehiclematerialgroup group = vehiclematerialgroupService.getById(req.getString("group_id"));
param.put("vehicle_code", group.getVehicle_code());
param.put("vehicle_type", group.getVehicle_type());
param.put("group_id", req.getString("group_id"));
} else {
param.put("vehicle_code", point.getVehicle_code());
param.put("vehicle_type", point.getVehicle_type());
param.put("need_released", startPoint);
PointUtils.clearPointNoLock(startPointObj);
}
param.put("device_code", req.getString("point_code2"));
param.put("target", req.getString("point_code1"));
param.put("point_code1", taskObj.getPoint_code2());
param.put("point_code2", req.getString("point_code1"));
param.put("config_code", req.getString("next"));
param.put("is_confirm", "1");
task.apply(param);
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
@@ -153,12 +212,17 @@ public class MDOutMoveTask extends AbstractTask {
@Transactional(rollbackFor = Exception.class)
public void cancelTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
String startPoint = taskObj.getPoint_code1();
SchBasePoint startPointObj = pointService.getById(startPoint);
String endPoint = taskObj.getPoint_code2();
SchBasePoint endPointObj = pointService.getById(endPoint);
// 终点解锁
if (ObjectUtil.isNotEmpty(endPointObj)) {
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
startPointObj.setIng_task_code("");
PointUtils.setUpdateByType(startPointObj, taskFinishedType);
PointUtils.setUpdateByType(endPointObj, taskFinishedType);
pointService.updateBatchById(Arrays.asList(startPointObj, endPointObj));
}
taskObj.setRemark(GeneralDefinition.TASK_CANCEL);
taskObj.setTask_status(TaskStatus.CANCELED.getCode());

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

@@ -20,6 +20,7 @@ import org.nl.wms.sch.task_manage.enums.GroupBindMaterialStatusEnum;
import org.nl.wms.sch.task_manage.enums.PointStatusEnum;
import org.nl.wms.sch.task_manage.enums.TaskFinishedTypeEnum;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.fj.FJQLTask;
import org.nl.wms.util.PointUtils;
import org.nl.wms.util.TaskUtils;
import org.springframework.beans.factory.annotation.Autowired;
@@ -29,7 +30,7 @@ import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
/**
* 转运任务
* 转运任务（AGV）
* @Author: lyd
* @Date: 2025/12/22
*/
@@ -44,6 +45,8 @@ public class MoveTask extends AbstractTask {
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private IPdmBdProductionProcessTrackingService processTrackingService;
@Resource(name = "FJQLTask")
private FJQLTask fjqlTask;
@Override
public void create() throws BadRequestException {
@@ -53,8 +56,15 @@ public class MoveTask extends AbstractTask {
public void createCompletion(SchBaseTask task) {
JSONObject req = JSONObject.parseObject(task.getRequest_param());
task.setPoint_code2(req.getString("target"));
task.setPoint_code3(req.getString("target2"));
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
task.setGroup_id(setGroupPlate(req));
// 提前分配的货位需要锁住
SchBasePoint flagPoint = pointService.getById(req.getString("target"));
flagPoint.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(flagPoint);
pointService.updateById(flagPoint);
TaskUtils.setUpdateByAcs(task);
taskService.save(task);
}
@@ -117,10 +127,12 @@ public class MoveTask extends AbstractTask {
if (vehicleType == null || vehicleType.equals(GeneralDefinition.NO)) {
vehicleType = GeneralDefinition.STEEL_TRAY;
}
String startPoint = taskObj.getPoint_code1();
String endPoint = taskObj.getPoint_code2();
SchBasePoint startPointObj = pointService.getById(startPoint);
SchBasePoint endPointObj = pointService.getById(endPoint);
// 终点解锁
if (ObjectUtil.isNotEmpty(endPointObj)) {
if (ObjectUtil.isNotEmpty(startPointObj)) {
// 修改组盘信息
SchBaseVehiclematerialgroup one = vehiclematerialgroupService.getOne(new LambdaQueryWrapper<SchBaseVehiclematerialgroup>()
.eq(SchBaseVehiclematerialgroup::getVehicle_code, vehicle_code)
@@ -139,18 +151,21 @@ public class MoveTask extends AbstractTask {
// 插入生产过程跟踪表
PdmBdProductionProcessTracking processTracking = new PdmBdProductionProcessTracking();
processTracking.setBuss_move_id(one.getBuss_move_id());
processTracking.setProcess_action("出中转进入缓存");
processTracking.setProcess_action("出钢托缓存到中转位");
processTracking.setProcess_location(endPoint);
processTracking.setRecord_time(DateUtil.now());
processTrackingService.create(processTracking);
// 记录库存并解锁
endPointObj.setIng_task_code("");
endPointObj.setVehicle_code(vehicle_code);
endPointObj.setVehicle_type(vehicleType);
endPointObj.setVehicle_qty(1);
endPointObj.setPoint_status(PointStatusEnum.FULL_POINT.getCode());
PointUtils.setUpdateByType(endPointObj, taskFinishedType);
pointService.updateById(endPointObj);
PointUtils.clearPoint(startPointObj);
// 创建RGV任务
JSONObject param = new JSONObject();
param.put("device_code", taskObj.getPoint_code3());
param.put("is_confirm", 1);
param.put("target", taskObj.getPoint_code2());
param.put("vehicle_code", taskObj.getVehicle_code());
param.put("vehicle_type", taskObj.getVehicle_type());
param.put("config_code", "FJQLTask");
param.put("group_id", one.getGroup_id());
fjqlTask.apply(param);
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());

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

@@ -26,6 +26,8 @@ import org.nl.wms.sch.task_manage.GeneralDefinition;
import org.nl.wms.sch.task_manage.enums.*;
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.common.MDInMoveTask;
import org.nl.wms.sch.task_manage.task.tasks.common.MDOutMoveTask;
import org.nl.wms.sch.task_manage.task.tasks.fj.mapper.FJMapper;
import org.nl.wms.util.PointUtils;
import org.nl.wms.util.TaskUtils;
@@ -33,14 +35,16 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 分拣满料任务，半满才有流程，全满没有业务
* @Description: 分拣满料任务
* @Date: 2023/6/21
*/
@Slf4j
@@ -64,6 +68,10 @@ public class FJMLTask extends AbstractTask {
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private WmsToMesService wmsToMesService;
@Resource(name = "MDOutMoveTask")
private MDOutMoveTask mdOutMoveTask;
@Resource(name = "MDInMoveTask")
private MDInMoveTask mdInMoveTask;
@Override
public void create() throws BadRequestException {
@@ -120,20 +128,62 @@ public class FJMLTask extends AbstractTask {
List<String> nextRegionStr = Arrays.stream(taskConfig.getNext_region_str().split(","))
.collect(Collectors.toList());
JSONObject jsonObject = JSONObject.parseObject(task.getRequest_param());
task.setGroup_id(setGroupPlate(jsonObject));
// 找终点
/** 包装位/半托缓存 */
SchBasePoint packagePoint = findNextPoint(nextRegionStr, jsonObject);
if (ObjectUtil.isEmpty(packagePoint)) {
// 消息通知
noticeService.createNotice("包装线不可用!", task.getPoint_code1() + "分拣满料找不到点位",
NoticeTypeEnum.WARN.getCode());
throw new BadRequestException("包装线不可用!");
String isConfirm = jsonObject.getString("is_confirm");
if (ObjectUtil.isNotEmpty(isConfirm) && GeneralDefinition.YES.equals(isConfirm)) {
task.setPoint_code2(jsonObject.getString("target"));
task.setTask_status(TaskStatus.CREATED.getCode());
task.setVehicle_code(jsonObject.getString("vehicle_code"));
task.setVehicle_type(jsonObject.getString("vehicle_type"));
task.setGroup_id(jsonObject.getString("group_id"));
task.setRemark("中转后的半托任务");
} else {
task.setGroup_id(setGroupPlate(jsonObject));
// 找终点
/** 包装位/半托缓存 */
SchBasePoint packagePoint = findNextPoint(nextRegionStr, jsonObject);
if (ObjectUtil.isEmpty(packagePoint)) {
// 消息通知
noticeService.createNotice("包装线不可用!", task.getPoint_code1() + "分拣满料找不到点位",
NoticeTypeEnum.WARN.getCode());
throw new BadRequestException("包装线不可用!");
}
// 半托任务
if ("1".equals(jsonObject.getString("flag"))) {
SchBasePoint movePoint = packagePoint.getFlagPoint();
// 需要移库
JSONObject param = new JSONObject();
// 移动的货位
param.put("device_code", movePoint.getPoint_code());
// 所需要的半托位置
param.put("point_code1", packagePoint.getPoint_code());
// 分拣码垛位
param.put("point_code2", task.getPoint_code1());
param.put("vehicle_code", movePoint.getVehicle_code());
param.put("vehicle_type", movePoint.getVehicle_type());
// 满托的组盘id
param.put("group_id", task.getGroup_id());
param.put("config_code", "MDOutMoveTask");
param.put("next", "FJMLTask");
mdOutMoveTask.apply(param);
packagePoint.setIng_task_code("半托移库任务");
PointUtils.setUpdateByAcs(packagePoint);
movePoint.setIng_task_code("半托移库任务");
PointUtils.setUpdateByAcs(movePoint);
pointService.updateBatchById(Arrays.asList(packagePoint, movePoint));
return;
} else {
// 不需要移库
// 设置起点并修改创建成功状态
task.setPoint_code2(packagePoint.getPoint_code());
task.setVehicle_code(jsonObject.getString("vehicle_code"));
task.setVehicle_type(jsonObject.getString("vehicle_type"));
packagePoint.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(packagePoint);
pointService.updateById(packagePoint);
}
task.setRemark("");
}
// 设置组盘 - 需要的话由子类自行实现
task.setPoint_code2(packagePoint.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
taskService.save(task);
}
@@ -198,14 +248,15 @@ public class FJMLTask extends AbstractTask {
groupEntity.setPcsn(DateUtil.format(DateUtil.date(), "yyyyMMdd"));
groupEntity.setInstorage_time(DateUtil.now());
groupEntity.setGroup_bind_material_status(GroupBindMaterialStatusEnum.UNBOUND.getValue());
groupEntity.setGroup_bind_material_status(GroupBindMaterialStatusEnum.BOUND.getValue());
groupEntity.setGroup_status(GroupStatusEnum.IN_STORAGE.getType());
groupEntity.setIs_delete(false);
groupEntity.setIs_full(isFull.equals(GeneralDefinition.YES));
vehiclematerialgroupService.saveOrUpdate(groupEntity);
param.put("vehicle_code", vehicleCode);
// 返回组盘id记录任务中
return isFull.equals(GeneralDefinition.YES) ? null : groupEntity.getGroup_id();
return groupEntity.getGroup_id();
}
/**
@@ -216,16 +267,50 @@ public class FJMLTask extends AbstractTask {
* @return
*/
private SchBasePoint findNextPoint(List<String> nextRegionStr, JSONObject requestParam) {
LambdaQueryWrapper<SchBasePoint> lam = new LambdaQueryWrapper<>();
lam.in(SchBasePoint::getRegion_code, nextRegionStr)
.eq(SchBasePoint::getPoint_status, PointStatusEnum.EMPTY_POINT.getCode())
.and(la -> la.isNull(SchBasePoint::getIng_task_code)
.or()
.eq(SchBasePoint::getIng_task_code, ""))
.eq(SchBasePoint::getPoint_type, GeneralDefinition.DOCKING_POINT)
.orderByAsc(SchBasePoint::getIn_order_seq)
.orderByAsc(SchBasePoint::getPoint_code);
List<SchBasePoint> schBasePoints = pointService.list(lam);
String isFull = requestParam.getString("is_full");
List<SchBasePoint> schBasePoints;
if ("1".equals(isFull)) {
// 满托
LambdaQueryWrapper<SchBasePoint> lam = new LambdaQueryWrapper<>();
lam.eq(SchBasePoint::getRegion_code, "BZ")
.eq(SchBasePoint::getPoint_status, PointStatusEnum.EMPTY_POINT.getCode())
.eq(SchBasePoint::getPoint_type, GeneralDefinition.DOCKING_POINT)
.orderByAsc(SchBasePoint::getIn_order_seq)
.orderByAsc(SchBasePoint::getPoint_code);
schBasePoints = pointService.list(lam);
} else {
// 需要判断是否满托
LambdaQueryWrapper<SchBasePoint> lam = new LambdaQueryWrapper<>();
lam.eq(SchBasePoint::getRegion_code, "BTHC")
.eq(SchBasePoint::getPoint_status, PointStatusEnum.EMPTY_POINT.getCode())
.eq(SchBasePoint::getPoint_type, GeneralDefinition.TRANSIT_POSITION)
.orderByAsc(SchBasePoint::getIn_order_seq)
.orderByAsc(SchBasePoint::getPoint_code);
schBasePoints = pointService.list(lam);
SchBasePoint schBasePoint = schBasePoints.get(0);
if (schBasePoint.getRow_num() == 2) {
// 判断是否阻挡
LambdaQueryWrapper<SchBasePoint> lam2 = new LambdaQueryWrapper<>();
lam2.eq(SchBasePoint::getRegion_code, schBasePoint.getRegion_code())
// 当前执行的任务为空或者NULL，有数据表示锁住
.and(la -> la.isNull(SchBasePoint::getIng_task_code)
.or()
.eq(SchBasePoint::getIng_task_code, ""))
.eq(SchBasePoint::getIs_used, true)
.eq(SchBasePoint::getPoint_status, "2")
.eq(SchBasePoint::getCol_num, schBasePoint.getCol_num())
.ne(SchBasePoint::getRow_num, schBasePoint.getRow_num())
.orderByAsc(SchBasePoint::getPoint_type)
.orderByAsc(SchBasePoint::getPoint_code);
SchBasePoint movePoint = pointService.getOne(lam2);
if (ObjectUtil.isNotEmpty(movePoint)) {
// 创建移库
requestParam.put("flag", "1");
schBasePoint.setFlagPoint(movePoint);
}
return schBasePoint;
}
}
return ObjectUtil.isNotEmpty(schBasePoints) ? schBasePoints.get(0) : null;
}
@@ -276,39 +361,20 @@ public class FJMLTask extends AbstractTask {
@Transactional(rollbackFor = Exception.class)
public void finishTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
String requestParam = taskObj.getRequest_param();
JSONObject jsonObject = JSONObject.parseObject(requestParam);
String workorderCode = jsonObject.getString("workorder_code");
PdmBdWorkorder workorder = workorderService.getByCode(workorderCode);
// 获取参数
String startPoint = taskObj.getPoint_code1();
String bzxPoint = taskObj.getPoint_code2();
String fmPoint = taskObj.getPoint_code3();
String fjcPoint = taskObj.getPoint_code4();
SchBasePoint startPointObj = pointService.getById(startPoint);
SchBasePoint bzxPointObj = pointService.getById(bzxPoint);
SchBasePoint fmPointObj = pointService.getById(fmPoint);
SchBasePoint fjcPointObj = pointService.getById(fjcPoint);
JSONObject parsedObject = JSONObject.parseObject(taskObj.getRequest_param());
if (ObjectUtil.isNotEmpty(bzxPointObj)) {
// 包装位: 解锁
// 包装位/半托: 解锁
bzxPointObj.setVehicle_qty(1);
bzxPointObj.setVehicle_code(taskObj.getVehicle_code());
bzxPointObj.setVehicle_type(taskObj.getVehicle_type());
PointUtils.setUpdateByType(bzxPointObj, taskFinishedType);
PointUtils.clearPoint(bzxPointObj);
if (ObjectUtil.isNotEmpty(fmPoint)) {
// 覆膜位: 解锁 . 清空
PointUtils.setUpdateByType(fmPointObj, taskFinishedType);
PointUtils.clearPoint(fmPointObj);
// 工单的真实数+1
workorder.setReal_qty(workorder.getReal_qty().add(BigDecimal.ONE));
TaskUtils.setWorkOrderUpdateByType(workorder, taskFinishedType);
workorderService.updateById(workorder);
}
// 分拣机械手: 清空
if (ObjectUtil.isNotEmpty(fjcPointObj)) {
// 机械手对接位: 赋值
fjcPointObj.setPoint_status(PointStatusEnum.EMPTY_VEHICLE.getCode());
fjcPointObj.setVehicle_qty(1);
fjcPointObj.setVehicle_type(taskObj.getVehicle_type());
PointUtils.setUpdateByType(fjcPointObj, taskFinishedType);
pointService.updateById(fjcPointObj);
}
pointService.updateById(bzxPointObj);
PointUtils.clearPoint(startPointObj);
SchBaseVehiclematerialgroup vehicleMaterialGroupObj =
vehiclematerialgroupService.getById(taskObj.getGroup_id());
vehicleMaterialGroupObj.setGroup_bind_material_status(GroupBindMaterialStatusEnum.UNBOUND.getValue());
@@ -319,6 +385,20 @@ public class FJMLTask extends AbstractTask {
TaskUtils.setGroupUpdateByType(vehicleMaterialGroupObj, taskFinishedType);
vehiclematerialgroupService.updateById(vehicleMaterialGroupObj);
}
if (ObjectUtil.isNotEmpty(parsedObject.getString("is_confirm"))
&& "1".equals(parsedObject.getString("is_confirm"))) {
if (!taskService.checkTask(parsedObject.getString("point_code1"))) {
// 创建恢复任务
SchBasePoint point = pointService.getById(parsedObject.getString("point_code1"));
JSONObject param = new JSONObject();
param.put("device_code", parsedObject.getString("point_code1"));
param.put("target", parsedObject.getString("point_code2"));
param.put("vehicle_code", point.getVehicle_code());
param.put("vehicle_type", point.getVehicle_type());
param.put("config_code", "MDInMoveTask");
mdInMoveTask.apply(param);
}
}
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark(GeneralDefinition.TASK_FINISH);
taskObj.setFinished_type(taskFinishedType.getCode());
@@ -330,20 +410,15 @@ public class FJMLTask extends AbstractTask {
public void cancelTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
// 获取参数
String bzxPoint = taskObj.getPoint_code2();
String fmPoint = taskObj.getPoint_code3();
SchBasePoint bzxPointObj = pointService.getById(bzxPoint);
SchBasePoint fmPointObj = pointService.getById(fmPoint);
if (ObjectUtil.isNotEmpty(bzxPointObj)) {
// 释放点位
bzxPointObj.setIng_task_code("");
PointUtils.setUpdateByType(bzxPointObj, taskFinishedType);
pointService.updateById(bzxPointObj);
}
if (ObjectUtil.isNotEmpty(fmPointObj)) {
fmPointObj.setIng_task_code("");
PointUtils.setUpdateByType(fmPointObj, taskFinishedType);
pointService.updateById(fmPointObj);
}
// 组盘删除
vehiclematerialgroupService.removeById(taskObj.getGroup_id());
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskObj.setRemark(GeneralDefinition.TASK_CANCEL);
taskObj.setFinished_type(taskFinishedType.getCode());

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

@@ -23,6 +23,7 @@ import org.nl.wms.sch.task_manage.enums.PointStatusEnum;
import org.nl.wms.sch.task_manage.enums.TaskFinishedTypeEnum;
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.common.MDInMoveTask;
import org.nl.wms.sch.task_manage.task.tasks.common.MDOutMoveTask;
import org.nl.wms.sch.task_manage.task.tasks.fj.mapper.FJMapper;
import org.nl.wms.util.PointUtils;
@@ -63,6 +64,8 @@ public class FJQKTask extends AbstractTask {
private FJMapper fjMapper;
@Resource(name = "MDOutMoveTask")
private MDOutMoveTask mdOutMoveTask;
@Resource(name = "MDInMoveTask")
private MDInMoveTask mdInMoveTask;
@Override
@Transactional(rollbackFor = Exception.class)
@@ -128,72 +131,81 @@ public class FJQKTask extends AbstractTask {
// 找起点
String requestParam = task.getRequest_param();
JSONObject extGroupData = JSONObject.parseObject(requestParam);
// 判断工单是否够
boolean enoughCallEmpty = workorderService.isEnoughCallEmpty(task.getPoint_code2());
if (!enoughCallEmpty) {
throw new BadRequestException("所需数量已足够，不呼叫空盘");
}
SchBasePoint point = findStartPoint(startRegionStr, extGroupData);
if (ObjectUtil.isEmpty(point)) {
// 消息通知
noticeService.createNotice("覆膜机不可用!", TASK_CONFIG_CODE + task.getTask_code(),
NoticeTypeEnum.WARN.getCode());
throw new BadRequestException("覆膜机不可用!");
}
// 将覆膜机设备放到任务中
if ("1".equals(extGroupData.getString("isEmpty"))) {
// 把这个设备位放到任务中
extGroupData.put("fmj_device", point.getPoint_code());
// 设置起点并修改创建成功状态
task.setPoint_code1(point.getParent_point_code());
// 父点位锁住
SchBasePoint basePoint = pointService.getById(point.getParent_point_code());
basePoint.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(basePoint);
pointService.updateById(basePoint);
String isConfirm = extGroupData.getString("is_confirm");
if (ObjectUtil.isNotEmpty(isConfirm) && GeneralDefinition.YES.equals(isConfirm)) {
task.setPoint_code1(extGroupData.getString("target"));
task.setTask_status(TaskStatus.CREATED.getCode());
task.setVehicle_code(extGroupData.getString("vehicle_code"));
task.setVehicle_type(extGroupData.getString("vehicle_type"));
task.setGroup_id(extGroupData.getString("group_id"));
task.setRemark("中转后的半托任务");
} else {
// 半托任务
if ("1".equals(extGroupData.getString("flag"))) {
// 查找移库点
LambdaQueryWrapper<SchBasePoint> lam = new LambdaQueryWrapper<>();
lam.eq(SchBasePoint::getRegion_code, point.getRegion_code())
// 当前执行的任务为空或者NULL，有数据表示锁住
.and(la -> la.isNull(SchBasePoint::getIng_task_code)
.or()
.eq(SchBasePoint::getIng_task_code, ""))
.eq(SchBasePoint::getIs_used, true)
.eq(SchBasePoint::getPoint_type, "2")
.eq(SchBasePoint::getPoint_status, "1")
.orderByAsc(SchBasePoint::getPoint_type)
.orderByAsc(SchBasePoint::getPoint_code);
SchBasePoint movePoint = pointService.getOne(lam);
if (ObjectUtil.isEmpty(movePoint)) {
throw new BadRequestException("找不到可用的中转点位！");
}
// 需要移库
JSONObject param = new JSONObject();
// 移动的货位
param.put("device_code", point.getFlagPoint().getPoint_code());
// 中转位
param.put("target", movePoint.getPoint_code());
// 所需要的半托位置
param.put("point_code1", point.getPoint_code());
// 分拣码垛位
param.put("point_code2", task.getPoint_code2());
param.put("vehicle_code", task.getVehicle_code());
param.put("vehicle_type", task.getVehicle_type());
mdOutMoveTask.apply(param);
return;
} else {
// 不需要移库
// 设置起点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
// 判断工单是否够
boolean enoughCallEmpty = workorderService.isEnoughCallEmpty(task.getPoint_code2());
if (!enoughCallEmpty) {
throw new BadRequestException("所需数量已足够，不呼叫空盘");
}
// 找起点
SchBasePoint point = findStartPoint(startRegionStr, extGroupData);
if (ObjectUtil.isEmpty(point)) {
// 消息通知
noticeService.createNotice("覆膜机不可用!", TASK_CONFIG_CODE + task.getTask_code(),
NoticeTypeEnum.WARN.getCode());
throw new BadRequestException("覆膜机不可用!");
}
// 将覆膜机设备放到任务中
if ("1".equals(extGroupData.getString("isEmpty"))) {
// 把这个设备位放到任务中
extGroupData.put("fmj_device", point.getPoint_code());
// 设置起点并修改创建成功状态
task.setPoint_code1(point.getParent_point_code());
// 父点位锁住
SchBasePoint basePoint = pointService.getById(point.getParent_point_code());
basePoint.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(basePoint);
pointService.updateById(basePoint);
} else {
// 半托任务
if ("1".equals(extGroupData.getString("flag"))) {
SchBasePoint movePoint = point.getFlagPoint();
// 需要移库
JSONObject param = new JSONObject();
// 移动的货位
param.put("device_code", movePoint.getPoint_code());
// 所需要的半托位置
param.put("point_code1", point.getPoint_code());
// 分拣码垛位
param.put("point_code2", task.getPoint_code2());
param.put("vehicle_code", movePoint.getVehicle_code());
param.put("vehicle_type", movePoint.getVehicle_type());
param.put("group_id", point.getGroup_id());
param.put("config_code", "MDOutMoveTask");
param.put("next", "FJQKTask");
mdOutMoveTask.apply(param);
point.setIng_task_code("半托移库任务");
PointUtils.setUpdateByAcs(point);
movePoint.setIng_task_code("半托移库任务");
PointUtils.setUpdateByAcs(movePoint);
pointService.updateBatchById(Arrays.asList(point, movePoint));
return;
} else {
// 不需要移库
// 设置起点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
point.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(point);
pointService.updateById(point);
}
}
// 记录了上一个任务的任务号，等这个任务完成之后，才能触发下发该任务
if (ObjectUtil.isNotEmpty(point.getTask_warn())) {
}
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
task.setGroup_id(point.getGroup_id());
}
task.setTask_status(TaskStatus.CREATED.getCode());
task.setResponse_param(extGroupData.toJSONString());
task.setRemark("");
task.setGroup_id(point.getGroup_id());
taskService.save(task);
}
@@ -244,6 +256,20 @@ public class FJQKTask extends AbstractTask {
}
}
return endPointObj;
} else {
// 判断是否正在移库或者被还原移库 且没其他任务
SchBasePoint zzwPoint = fjMapper.findOnePointAndTransit();
if (ObjectUtil.isNotEmpty(zzwPoint)) {
return zzwPoint;
}
// 判断是否存在任务
List<SchBaseTask> tasks = fjMapper.findTaskForRunningMaterial(one.getMaterial_id());
if (!tasks.isEmpty()) {
SchBaseTask schBaseTask = tasks.get(0);
SchBasePoint point = pointService.getById(schBaseTask.getPoint_code2());
point.setTask_warn(schBaseTask.getTask_code());
return point;
}
}
// 向ACS请求所需木托盘在那个栈拆盘机？已经实时更新,故只需要自己查询即可
endPointObj = fjMapper.findPointForFJQK(startRegionStr, new JSONObject()
@@ -326,6 +352,22 @@ public class FJQKTask extends AbstractTask {
TaskUtils.setWorkOrderUpdateByType(workorder, taskFinishedType);
workorderService.updateById(workorder);
}
// 如果是移库，需要还原
if (ObjectUtil.isNotEmpty(jsonObject.getString("is_confirm"))
&& "1".equals(jsonObject.getString("is_confirm"))) {
// 需要再次判断是否有任务
if (!taskService.checkTask(jsonObject.getString("point_code1"))) {
SchBasePoint point = pointService.getById(jsonObject.getString("point_code1"));
JSONObject param = new JSONObject();
param.put("device_code", jsonObject.getString("point_code1"));
param.put("target", jsonObject.getString("point_code2"));
param.put("vehicle_code", point.getVehicle_code());
param.put("vehicle_type", point.getVehicle_type());
param.put("config_code", "MDInMoveTask");
param.put("need_released", jsonObject.getString("need_released"));
mdInMoveTask.apply(param);
}
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark(GeneralDefinition.TASK_FINISH);

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

@@ -111,6 +111,33 @@ public class FJQLTask extends AbstractTask {
}
}
@Override
public boolean checkTask(JSONObject param) {
// 1. 优先检查确认标志
if (isConfirmed(param)) {
return false;
}
// 2. 验证必要参数
String deviceCode = param.getString("device_code");
if (ObjectUtil.isEmpty(deviceCode)) {
return false;
}
// 3. 查询未完成任务数量
long count = taskService.count(buildTaskQuery(deviceCode));
return count > 0;
}
private boolean isConfirmed(JSONObject param) {
String isConfirm = param.getString("is_confirm");
return ObjectUtil.isNotEmpty(isConfirm)
&& GeneralDefinition.YES.equals(isConfirm);
}
private LambdaQueryWrapper<SchBaseTask> buildTaskQuery(String deviceCode) {
return new LambdaQueryWrapper<SchBaseTask>()
.eq(SchBaseTask::getPoint_code3, deviceCode)
.eq(SchBaseTask::getIs_delete, false)
.lt(SchBaseTask::getTask_status, TaskStatus.FINISHED.getCode());
}
@Override
@Transactional(rollbackFor = Exception.class)
public void createCompletion(SchBaseTask task) {
@@ -125,45 +152,59 @@ public class FJQLTask extends AbstractTask {
// 找起点
String requestParam = task.getRequest_param();
JSONObject extGroupData = JSONObject.parseObject(requestParam);
// hint: 需要加上搬运过程中的数量
boolean enoughCallMaterial = workorderService.isEnoughCallMaterial(task.getPoint_code2());
// 对于分拣，用于分拣钢托盘砖块数
if (!enoughCallMaterial) {
// 消息通知
noticeService.createNotice("钢托盘砖块数已达到所需数量!", TASK_CONFIG_CODE + task.getPoint_code2(),
NoticeTypeEnum.WARN.getCode());
throw new BadRequestException("钢托盘砖块数已达到所需数量!");
}
extGroupData.put("vehicle_type", task.getVehicle_type());
extGroupData.put("flag", "0");
SchBasePoint point = findStartPoint(startRegionStr, extGroupData);
if (ObjectUtil.isEmpty(point)) {
// 消息通知
noticeService.createNotice("钢托盘缓存货架没有所需物料!", TASK_CONFIG_CODE + task.getPoint_code2(),
NoticeTypeEnum.WARN.getCode());
throw new BadRequestException("钢托盘缓存货架没有所需物料!");
}
// 设置起点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setVehicle_code(point.getVehicle_code());
task.setGroup_id(point.getGroup_id());
task.setRemark("");
if ("1".equals(point.getTask_warn())) {
// 提前分配的货位需要锁住
SchBasePoint flagPoint = point.getFlagPoint();
flagPoint.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(flagPoint);
pointService.updateById(flagPoint);
task.setPoint_code3(task.getPoint_code2());
task.setPoint_code2(flagPoint.getPoint_code());
task.setRequest_param(JSONObject.toJSONString(extGroupData));
String isConfirm = extGroupData.getString("is_confirm");
if (ObjectUtil.isNotEmpty(isConfirm) && GeneralDefinition.YES.equals(isConfirm)) {
task.setPoint_code1(extGroupData.getString("target"));
task.setTask_status(TaskStatus.CREATED.getCode());
task.setVehicle_code(extGroupData.getString("vehicle_code"));
task.setVehicle_type(extGroupData.getString("vehicle_type"));
task.setGroup_id(extGroupData.getString("group_id"));
task.setRemark("");
} else {
// hint: 需要加上搬运过程中的数量
boolean enoughCallMaterial = workorderService.isEnoughCallMaterial(task.getPoint_code2());
// 对于分拣，用于分拣钢托盘砖块数
if (!enoughCallMaterial) {
// 消息通知
noticeService.createNotice("钢托盘砖块数已达到所需数量!", task.getPoint_code2() + "分拣呼叫物料失败",
NoticeTypeEnum.WARN.getCode());
throw new BadRequestException("钢托盘砖块数已达到所需数量!");
}
extGroupData.put("vehicle_type", task.getVehicle_type());
extGroupData.put("flag", "0");
SchBasePoint point = findStartPoint(startRegionStr, extGroupData);
if (ObjectUtil.isEmpty(point)) {
// 消息通知
noticeService.createNotice("钢托盘缓存货架没有所需物料!", task.getPoint_code2() + "分拣呼叫物料失败",
NoticeTypeEnum.WARN.getCode());
throw new BadRequestException("钢托盘缓存货架没有所需物料!");
}
// 设置起点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setVehicle_code(point.getVehicle_code());
task.setGroup_id(point.getGroup_id());
task.setRemark("");
if ("1".equals(point.getTask_warn())) {
// 提前分配的货位需要锁住
SchBasePoint flagPoint = point.getFlagPoint();
JSONObject param = new JSONObject();
param.put("device_code", point.getPoint_code());
param.put("target", flagPoint.getPoint_code());
param.put("target2", task.getPoint_code2());
param.put("vehicle_code", point.getVehicle_code());
param.put("vehicle_type", point.getVehicle_type());
param.put("config_code", "MoveTask");
param.put("ext_param", extGroupData);
param.put("group_id", point.getGroup_id());
moveTask.apply(param);
return;
}
point.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(point);
pointService.updateById(point);
}
taskService.save(task);
point.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(point);
pointService.updateById(point);
}
/**
@@ -184,7 +225,7 @@ public class FJQLTask extends AbstractTask {
Assert.notNull(workOrder, "工单不能为空!");
// 从所选区域中，选择满料位、无锁、可用的点位
List<SchBasePoint> points = fjMapper.findPointForFJQL(startRegionStr, workOrder.getMaterial_id());
if (points.size() == 0) {
if (points.isEmpty()) {
return null;
}
// 判断点位是否需要先AGV中转
@@ -198,7 +239,8 @@ public class FJQLTask extends AbstractTask {
requestParam.put("flag", "1");
requestParam.put("target", hcssx.getPoint_code());
basePoint.setTask_warn("1");
basePoint.setFlagPoint(basePoint);
// 存放缓存输送线中转点
basePoint.setFlagPoint(hcssx);
}
return basePoint;
}
@@ -279,6 +321,7 @@ public class FJQLTask extends AbstractTask {
endPointObj.setVehicle_code(vehicleMaterialGroupObj.getVehicle_code());
endPointObj.setVehicle_type(vehicleMaterialGroupObj.getVehicle_type());
endPointObj.setPoint_status(PointStatusEnum.EMPTY_VEHICLE.getCode());
endPointObj.setVehicle_qty(1);
PointUtils.setUpdateByType(endPointObj, taskFinishedType);
pointService.updateById(endPointObj);
// 修改工单实际搬运钢托盘上的码垛数量
@@ -287,20 +330,6 @@ public class FJQLTask extends AbstractTask {
vehicleMaterialGroupObj.getMaterial_qty())));
TaskUtils.setWorkOrderUpdateByType(workorderCode, taskFinishedType);
workorderService.updateById(workorderCode);
// 创建中转任务
// 判断是否转运
String flag = extGroupData.getString("flag");
if (ObjectUtil.isNotEmpty(flag) && "1".equals(flag)) {
// 创建AGV任务
JSONObject param = new JSONObject();
param.put("device_code", taskObj.getPoint_code2());
param.put("target", taskObj.getPoint_code3());
param.put("vehicle_code", taskObj.getVehicle_code());
param.put("vehicle_type", taskObj.getVehicle_type());
param.put("config_code", "MoveTask");
param.put("group_id", vehicleMaterialGroupObj.getGroup_id());
moveTask.apply(param);
}
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());

5
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/fj/mapper/FJMapper.java
View File

@@ -3,6 +3,7 @@ package org.nl.wms.sch.task_manage.task.tasks.fj.mapper;
import com.alibaba.fastjson.JSONObject;
import org.apache.ibatis.annotations.Param;
import org.nl.wms.sch.point.service.dao.SchBasePoint;
import org.nl.wms.sch.task.service.dao.SchBaseTask;
import java.util.List;
@@ -41,4 +42,8 @@ public interface FJMapper {
String getNeedFullNumber(String materialId);
SchBasePoint findPointForBt(String materialId);
List<SchBaseTask> findTaskForRunningMaterial(String materialId);
SchBasePoint findOnePointAndTransit();
}

22
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/fj/mapper/FJMapper.xml
View File

@@ -77,7 +77,8 @@
</select>
<select id="findPointForBt" resultType="org.nl.wms.sch.point.service.dao.SchBasePoint">
SELECT
p.*
p.*,
g.group_id
FROM
`sch_base_point` p
LEFT JOIN sch_base_vehiclematerialgroup g ON g.vehicle_code = p.vehicle_code
@@ -95,4 +96,23 @@
p.out_order_seq
LIMIT 1
</select>
<select id="findTaskForRunningMaterial" resultType="org.nl.wms.sch.task.service.dao.SchBaseTask">
select * from sch_base_task t
where t.is_delete = false
and (t.config_code = 'MDOutMoveTask' or t.config_code = 'MDInMoveTask')
and '5' > t.task_status
and #{materialId} = (select v.material_id from sch_base_vehiclematerialgroup v
where v.vehicle_code = t.vehicle_code and v.vehicle_type = t.vehicle_type
and v.group_bind_material_status = '2')
</select>
<select id="findOnePointAndTransit" resultType="org.nl.wms.sch.point.service.dao.SchBasePoint">
SELECT p.*
FROM sch_base_point p
WHERE p.region_code = 'BTHC'
AND (p.ing_task_code IS NULL OR p.ing_task_code = '')
AND p.is_used = true
AND p.point_status = '2'
AND p.point_type = '2'
AND 0 = (select count(*) from sch_base_task t where '5' > t.task_status and (t.point_code1 = p.point_code or t.point_code2 = p.point_code))
</select>
</mapper>

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

@@ -39,6 +39,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
@@ -211,7 +212,7 @@ public class CYZCTask extends AbstractTask {
}
PdmBdWorkorder order = workorderService.getByCode(vehilceCode.getWorkorder_code());
if (order.getIs_urgent()) {
// 加急，直接去3号窑
// 加急，直接去3号窑todo: 判断3号窑满了没
return pointService.getById("LQYRK03");
}
}
@@ -273,8 +274,6 @@ public class CYZCTask extends AbstractTask {
}
if (status.equals(TaskStatus.FINISHED)) {
this.finishTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
// todo 出窑上报出窑记录
// wmsToMesService.reportGdyMaterialInfoOut(taskObj.getGroup_id());
}
if (status.equals(TaskStatus.CANCELED)) {
this.cancelTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
@@ -340,6 +339,15 @@ public class CYZCTask extends AbstractTask {
processTracking.setProcess_location(endPoint);
processTracking.setRecord_time(DateUtil.now());
processTrackingService.create(processTracking);
// 如果是去分拣拆垛位，需要给工单加上数量
if (endPoint.startsWith("FJ")) {
PdmBdWorkorder productionTask = workorderService.getDeviceProductionTask(endPointObj.getParent_point_code());
productionTask.setReal_weight(productionTask.getReal_weight().add(BigDecimal.valueOf(
one.getMaterial_qty())));
TaskUtils.setWorkOrderUpdateByType(productionTask, taskFinishedType);
workorderService.updateById(productionTask);
}
}
kilnRecordService.inCoolKilnInfo(vehicle_code, endPointObj);

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

@@ -222,14 +222,14 @@ public class LQYMLTask extends AbstractTask {
// 判断双层输送线和钢托缓存库有没有相同物料
List<SchBasePoint> list = gzyMapper.getPointTheSameMaterial(vehicleObj.getMaterial_id());
List<SchBasePoint> useList = new ArrayList<>();
if (list.size() == 0) {
// 分配一个到对应分拣工单的空位置。
if (list.isEmpty()) {
// 分配一个到对应分拣工单的空位置。已经判断了工单计划数与实际数
useList = gzyMapper.getSortingEmptyPoint(vehicleObj.getMaterial_id());
}
if (useList.size() == 0) {
if (useList.isEmpty()) {
// 分配一个双层输送线的一层货位
useList = gzyMapper.getOneLayerConveyor(vehicleObj.getMaterial_id());
if (useList.size() == 0) {
if (useList.isEmpty()) {
// 分配钢托盘缓存库
useList = gzyMapper.getSteelLib();
}

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

@@ -0,0 +1,142 @@
package org.nl.wms.sch.task_manage.task.tasks.yao;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import org.nl.common.exception.BadRequestException;
import org.nl.wms.pdm.record.service.IPdmBdKilnRecordService;
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.dao.SchBaseTask;
import org.nl.wms.sch.task_manage.AbstractTask;
import org.nl.wms.sch.task_manage.GeneralDefinition;
import org.nl.wms.sch.task_manage.enums.TaskFinishedTypeEnum;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.util.TaskUtils;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* 冷却窑缺空任务
* <p>
* 会呼叫空的窑口：
* 冷却窑入口01-03
* 冷却窑出口03
* <p>
* 呼叫的统统不知道载具号，故为“-”，空盘出窑的时候，如果有载具号，但是没找到载具号的记录，则筛选一条“-”的出窑
* @Author: lyd
* @Date: 2025/12/30
*/
@Component("LQYQKTask")
public class LQYQKTask extends AbstractTask {
public static final String[] AREA = {"DTW02", "CPJCK"};
@Resource
private ISchBasePointService pointService;
@Resource
private ISchBaseTaskService taskService;
@Resource
private IPdmBdKilnRecordService kilnRecordService;
@Override
public void create() throws BadRequestException {
}
/**
* 入窑口去DTW02
* 出窑口去CPJCK
* @param task
*/
@Override
public void createCompletion(SchBaseTask task) {
int vehicleQty = task.getVehicle_qty();
SchBasePoint startPoint = pointService.getById(task.getPoint_code1());
// CPJCK DTW02
SchBasePoint point = pointService.getById(AREA[Integer.parseInt(startPoint.getPoint_type())]);
if (!"3".equals(point.getPoint_type())) {
SchBasePoint point1 = pointService.getById(point.getParent_point_code());
vehicleQty = Math.min(vehicleQty, point1.getVehicle_qty());
} else {
vehicleQty = Math.min(vehicleQty, point.getVehicle_qty());
}
if (0 == vehicleQty) {
throw new BadRequestException("暂无空托盘！");
}
for (int i = 0; i < vehicleQty; i++) {
task.setTask_id(IdUtil.getSnowflake(1, 1).nextIdStr());
task.setTask_code(IdUtil.getSnowflake(1, 1).nextIdStr());
task.setVehicle_type(GeneralDefinition.STEEL_TRAY);
task.setPoint_code2(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
TaskUtils.setUpdateByAcs(task);
taskService.updateById(task);
}
}
@Override
protected void updateStatus(String task_code, TaskStatus status) {
// 校验任务
SchBaseTask taskObj = taskService.getByCode(task_code);
if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
throw new BadRequestException("该任务已完成!");
}
if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
throw new BadRequestException("该任务已取消!");
}
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) {
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
TaskUtils.setUpdateByAcs(taskObj);
taskService.updateById(taskObj);
}
if (status.equals(TaskStatus.FINISHED)) {
this.finishTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
}
if (status.equals(TaskStatus.CANCELED)) {
this.cancelTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
}
}
@Override
public void forceFinish(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
if (ObjectUtil.isEmpty(taskObj)) {
throw new BadRequestException("该任务不存在");
}
this.finishTask(taskObj, TaskFinishedTypeEnum.MANUAL_PC);
}
@Override
public void cancel(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
if (ObjectUtil.isEmpty(taskObj)) {
throw new BadRequestException("该任务不存在");
}
this.cancelTask(taskObj, TaskFinishedTypeEnum.MANUAL_PC);
}
public void finishTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
SchBasePoint point = pointService.getById(taskObj.getPoint_code2());
// 记录入窑
// 记录入窑记录
kilnRecordService.recordCoolEmptyKilnInfo( point);
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark(GeneralDefinition.TASK_FINISH);
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
public void cancelTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
// 任务完成
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskObj.setRemark(GeneralDefinition.TASK_CANCEL);
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
}

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

@@ -0,0 +1,165 @@
package org.nl.wms.sch.task_manage.task.tasks.yao;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.nl.common.exception.BadRequestException;
import org.nl.system.service.param.ISysParamService;
import org.nl.system.service.param.dao.Param;
import org.nl.wms.pdm.record.service.IPdmBdKilnRecordService;
import org.nl.wms.pdm.record.service.dao.PdmBdKilnRecord;
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.dao.SchBaseTask;
import org.nl.wms.sch.task_manage.AbstractTask;
import org.nl.wms.sch.task_manage.GeneralDefinition;
import org.nl.wms.sch.task_manage.enums.TaskFinishedTypeEnum;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.util.TaskUtils;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
/**
* 冷却窑送空任务
* @Author: lyd
* @Date: 2025/12/30
*/
@Component("LQYSKTask")
public class LQYSKTask extends AbstractTask {
private static final String COOL_KILN_MAX = "COOL_KILN_MAX";
@Resource
private ISchBasePointService pointService;
@Resource
private ISchBaseTaskService taskService;
@Resource
private IPdmBdKilnRecordService kilnRecordService;
@Resource
private ISysParamService paramService;
@Override
public void create() throws BadRequestException {
}
@Override
public void createCompletion(SchBaseTask task) {
// 过滤窑内现有的托盘数不超过设定值
Param param = paramService.findByCode(COOL_KILN_MAX);
if (ObjectUtil.isEmpty(param)) {
throw new BadRequestException("未配置冷却窑最大托盘数!");
}
LambdaQueryWrapper<SchBasePoint> lam = new LambdaQueryWrapper<>();
lam.eq(SchBasePoint::getRegion_code, "LQY")
.eq(SchBasePoint::getPoint_type, GeneralDefinition.ENTRANCE)
.ne(SchBasePoint::getPoint_code, "LQYRK03")
.eq(SchBasePoint::getIs_used, true);
List<SchBasePoint> schBasePoints = pointService.list(lam);
List<SchBasePoint> collect = schBasePoints.stream()
.map(p -> {
int count = kilnRecordService.count(new LambdaQueryWrapper<PdmBdKilnRecord>()
.eq(PdmBdKilnRecord::getCooling_code, p.getPoint_code())
.eq(PdmBdKilnRecord::getStatus, "2"));
int taskNum = taskService.count(new LambdaQueryWrapper<SchBaseTask>()
.eq(SchBaseTask::getPoint_code2, p.getPoint_code())
.eq(SchBaseTask::getIs_delete, false)
.lt(SchBaseTask::getTask_status, "5"));
return new PointWithTotal(p, count + taskNum);
})
.filter(pwt -> pwt.total < Integer.parseInt(param.getValue()))
.sorted(Comparator.comparingInt((PointWithTotal pwt) -> pwt.total).reversed())
.map(pwt -> pwt.point)
.collect(Collectors.toList());
if (collect.size() == 0) {
throw new BadRequestException("冷却窑均满了，请稍后在试！");
}
SchBasePoint basePoint = collect.get(0);
task.setVehicle_type(GeneralDefinition.STEEL_TRAY);
task.setPoint_code2(basePoint.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
TaskUtils.setUpdateByAcs(task);
taskService.updateById(task);
}
@Override
protected void updateStatus(String task_code, TaskStatus status) {
// 校验任务
SchBaseTask taskObj = taskService.getByCode(task_code);
if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
throw new BadRequestException("该任务已完成!");
}
if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
throw new BadRequestException("该任务已取消!");
}
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) {
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
TaskUtils.setUpdateByAcs(taskObj);
taskService.updateById(taskObj);
}
if (status.equals(TaskStatus.FINISHED)) {
this.finishTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
}
if (status.equals(TaskStatus.CANCELED)) {
this.cancelTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
}
}
@Override
public void forceFinish(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
if (ObjectUtil.isEmpty(taskObj)) {
throw new BadRequestException("该任务不存在");
}
this.finishTask(taskObj, TaskFinishedTypeEnum.MANUAL_PC);
}
@Override
public void cancel(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
if (ObjectUtil.isEmpty(taskObj)) {
throw new BadRequestException("该任务不存在");
}
this.cancelTask(taskObj, TaskFinishedTypeEnum.MANUAL_PC);
}
public void finishTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
SchBasePoint point = pointService.getById(taskObj.getPoint_code2());
// 记录入窑
// 记录入窑记录
kilnRecordService.recordCoolEmptyKilnInfo(point);
// 去处当前出窑的空托
kilnRecordService.removeOneCoolEmptyInfo(point);
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark(GeneralDefinition.TASK_FINISH);
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
public void cancelTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
// 任务完成
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskObj.setRemark(GeneralDefinition.TASK_CANCEL);
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
static class PointWithTotal {
SchBasePoint point;
int total;
PointWithTotal(SchBasePoint point, int total) {
this.point = point;
this.total = total;
}
}
}

33
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/yao/mapper/GZYMapper.xml
View File

@@ -45,22 +45,23 @@
AND g.group_bind_material_status = '2'
</select>
<select id="getSortingEmptyPoint" resultType="org.nl.wms.sch.point.service.dao.SchBasePoint">
SELECT
p.*
FROM
sch_base_point p
INNER JOIN pdm_bd_workorder w ON w.point_code = p.parent_point_code
AND w.region_code = 'FJ'
AND w.real_weight <![CDATA[<>]]> w.plan_weight
AND w.workorder_status = '3'
WHERE
p.point_type = '2'
AND p.region_code = 'FJ'
AND p.is_used = TRUE
AND p.point_status = '1'
AND IFNULL( p.ing_task_code, '' ) = ''
AND 0 = (SELECT COUNT(*) FROM sch_base_task t WHERE t.is_delete = FALSE AND t.point_code2 = p.point_code AND t.task_status <![CDATA[<]]> '5')
AND w.material_id = #{materialId}
SELECT p.*
FROM sch_base_point p
INNER JOIN pdm_bd_workorder w ON w.point_code = p.parent_point_code
AND w.region_code = 'FJ'
AND w.real_weight <![CDATA[<>]]> w.plan_weight
AND w.workorder_status = '3'
WHERE p.point_type = '2'
AND p.region_code = 'FJ'
AND p.is_used = TRUE
AND p.point_status = '1'
AND IFNULL(p.ing_task_code, '') = ''
AND 0 = (SELECT COUNT(*)
FROM sch_base_task t
WHERE t.is_delete = FALSE
AND t.point_code2 = p.point_code
AND t.task_status <![CDATA[<]]> '5')
AND w.material_id = #{materialId}
</select>
<select id="getOneLayerConveyor" resultType="org.nl.wms.sch.point.service.dao.SchBasePoint">
SELECT *

17
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/util/PointUtils.java
View File

@@ -54,6 +54,23 @@ public class PointUtils {
point.setUpdate_time(DateUtil.now());
pointService.updateById(point);
}
/**
* 清空点位 - 不解锁
*
* @param point
*/
public static void clearPointNoLock(SchBasePoint point) {
if (ObjectUtil.isEmpty(point)) {
return; // 空直接退出
}
SchBasePointServiceImpl pointService = SpringContextHolder.getBean(SchBasePointServiceImpl.class);
point.setPoint_status(PointStatusEnum.EMPTY_POINT.getCode());
point.setVehicle_type("");
point.setVehicle_code("");
point.setVehicle_qty(0);
point.setUpdate_time(DateUtil.now());
pointService.updateById(point);
}
/**
* 清空点位

3
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/util/TaskUtils.java
View File

@@ -199,6 +199,9 @@ public class TaskUtils {
if (ObjectUtil.isEmpty(acsVehicleCode) || acsVehicleCode.equals(GeneralDefinition.NO)) {
return null;
}
if (acsVehicleCode.startsWith("M")) {
return acsVehicleCode;
}
return String.format("%04d", Integer.parseInt(acsVehicleCode));
}