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

LMS基线更新马钢版本

Browse Source
This commit is contained in:
psh
2023-09-27 14:06:25 +08:00
parent 8d4e6281b5
commit 66aa354d0e
31 changed files with 2915 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/ext/AcsToWmsController.java Normal file
View File

@@ -0,0 +1,44 @@
package org.nl.wms.ext;
import cn.dev33.satoken.annotation.SaIgnore;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.logging.annotation.Log;
import org.nl.wms.sch.task.service.ISchBaseTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
/**
* @Author: lyd
* @Description: acs请求lms接口
* @Date: 2023/6/16
*/
@RestController
@Api(tags = "acs请求lms")
@RequestMapping("/api/wms/task")
@Slf4j
@SaIgnore
public class AcsToWmsController {
@Autowired
private ISchBaseTaskService schBaseTaskService;
@PostMapping("/apply")
@Log("新增任务管理")
@ApiOperation("新增任务管理")
//@SaCheckPermission("@el.check('schBaseTask:add')")
@SaIgnore
public ResponseEntity<Object> apply(@RequestBody Map param) {
schBaseTaskService.apply(JSONObject.parseObject(JSON.toJSONString(param)));
return new ResponseEntity<>(HttpStatus.CREATED);
}
}

66
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm/controller/PdmBdWorkorderController.java Normal file
View File

@@ -0,0 +1,66 @@
package org.nl.wms.pdm.controller;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.base.TableDataInfo;
import org.nl.common.domain.query.PageQuery;
import org.nl.common.logging.annotation.Log;
import org.nl.wms.pdm.service.IPdmBdWorkorderService;
import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
import org.nl.wms.pdm.service.dto.PdmBdWorkorderQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.Set;
/**
* @author lyd
* @date 2023-05-05
**/
@Slf4j
@RestController
@Api(tags = "工单管理管理")
@RequestMapping("/api/pdmBdWorkorder")
public class PdmBdWorkorderController {
@Autowired
private IPdmBdWorkorderService pdmBdWorkorderService;
@GetMapping
@Log("查询工单管理")
@ApiOperation("查询工单管理")
//@SaCheckPermission("@el.check('pdmBdWorkorder:list')")
public ResponseEntity<Object> query(PdmBdWorkorderQuery query, PageQuery page){
return new ResponseEntity<>(TableDataInfo.build(pdmBdWorkorderService.queryAll(query,page)),HttpStatus.OK);
}
@PostMapping
@Log("新增工单管理")
@ApiOperation("新增工单管理")
//@SaCheckPermission("@el.check('pdmBdWorkorder:add')")
public ResponseEntity<Object> create(@Validated @RequestBody PdmBdWorkorder entity){
pdmBdWorkorderService.create(entity);
return new ResponseEntity<>(HttpStatus.CREATED);
}
@PutMapping
@Log("修改工单管理")
@ApiOperation("修改工单管理")
//@SaCheckPermission("@el.check('pdmBdWorkorder:edit')")
public ResponseEntity<Object> update(@Validated @RequestBody PdmBdWorkorder entity){
pdmBdWorkorderService.update(entity);
return new ResponseEntity<>(HttpStatus.NO_CONTENT);
}
@Log("删除工单管理")
@ApiOperation("删除工单管理")
//@SaCheckPermission("@el.check('pdmBdWorkorder:del')")
@DeleteMapping
public ResponseEntity<Object> delete(@RequestBody Set<String> ids) {
pdmBdWorkorderService.deleteAll(ids);
return new ResponseEntity<>(HttpStatus.OK);
}
}

43
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm/service/IPdmBdWorkorderService.java Normal file
View File

@@ -0,0 +1,43 @@
package org.nl.wms.pdm.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import org.nl.common.domain.query.PageQuery;
import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
import org.nl.wms.pdm.service.dto.PdmBdWorkorderQuery;
import java.util.Set;
/**
* @description 服务接口
* @author lyd
* @date 2023-05-05
**/
public interface IPdmBdWorkorderService extends IService<PdmBdWorkorder> {
/**
* 查询数据分页
* @param whereJson 条件
* @param pageable 分页参数
* @return IPage<PdmBdWorkorder>
*/
IPage<PdmBdWorkorder> queryAll(PdmBdWorkorderQuery whereJson, PageQuery pageable);
/**
* 创建
* @param entity /
*/
void create(PdmBdWorkorder entity);
/**
* 编辑
* @param entity /
*/
void update(PdmBdWorkorder entity);
/**
* 多选删除
* @param ids /
*/
void deleteAll(Set<String> ids);
}

123
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm/service/dao/PdmBdWorkorder.java Normal file
View File

@@ -0,0 +1,123 @@
package org.nl.wms.pdm.service.dao;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.math.BigDecimal;
/**
* @description /
* @author lyd
* @date 2023-05-05
**/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("pdm_bd_workorder")
public class PdmBdWorkorder implements Serializable {
private static final long serialVersionUID = 1L;
@TableId(value = "workorder_id", type = IdType.NONE)
@ApiModelProperty(value = "工单标识")
private String workorder_id;
@ApiModelProperty(value = "工单编号")
private String workorder_code;
@ApiModelProperty(value = "计划数量")
private BigDecimal plan_qty;
@ApiModelProperty(value = "实际数量")
private BigDecimal real_qty;
@ApiModelProperty(value = "物料标识")
private String material_id;
@ApiModelProperty(value = "载具类型")
private String vehicle_type;
@ApiModelProperty(value = "计划开始时间")
private String planproducestart_date;
@ApiModelProperty(value = "计划结束时间")
private String planproduceend_date;
@ApiModelProperty(value = "实际开始时间")
private String realproducestart_date;
@ApiModelProperty(value = "实际结束时间")
private String realproduceend_date;
@ApiModelProperty(value = "静置时间(分钟)")
private Integer standing_time;
@ApiModelProperty(value = "点位编码")
private String point_code;
@ApiModelProperty(value = "点位名称")
private String point_name;
@ApiModelProperty(value = "区域编码")
private String region_code;
@ApiModelProperty(value = "区域名称")
private String region_name;
@ApiModelProperty(value = "工单状态")
private String workorder_status;
@ApiModelProperty(value = "是否需要AGV搬运")
private Boolean is_needmove;
@ApiModelProperty(value = "工单类型")
private String workorder_type;
@ApiModelProperty(value = "回传MES状态")
private String passback_status;
@ApiModelProperty(value = "车间编码")
private String workshop_code;
@ApiModelProperty(value = "外部标识")
private String ext_id;
@ApiModelProperty(value = "是否删除")
private Boolean is_delete;
@ApiModelProperty(value = "创建人")
private String create_id;
@ApiModelProperty(value = "创建人")
private String create_name;
@ApiModelProperty(value = "创建时间")
private String create_time;
@ApiModelProperty(value = "修改人")
private String update_id;
@ApiModelProperty(value = "修改人")
private String update_name;
@ApiModelProperty(value = "修改时间")
private String update_time;
@ApiModelProperty(value = "是否加急")
private Boolean is_urgent;
@TableField(exist = false)
private String material_name;
@TableField(exist = false)
private String material_code;
@TableField(exist = false)
private String material_spec;
}

15
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm/service/dao/mapper/PdmBdWorkorderMapper.java Normal file
View File

@@ -0,0 +1,15 @@
package org.nl.wms.pdm.service.dao.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
import org.nl.wms.pdm.service.dto.PdmBdWorkorderQuery;
/**
* @author lyd
* @date 2023-05-05
**/
public interface PdmBdWorkorderMapper extends BaseMapper<PdmBdWorkorder> {
IPage<PdmBdWorkorder> selectPageLeftJoin(IPage<PdmBdWorkorder> pages, PdmBdWorkorderQuery query);
}

32
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm/service/dao/mapper/PdmBdWorkorderMapper.xml Normal file
View File

@@ -0,0 +1,32 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.nl.wms.pdm.service.dao.mapper.PdmBdWorkorderMapper">
<select id="selectPageLeftJoin" resultType="org.nl.wms.pdm.service.dao.PdmBdWorkorder">
SELECT wo.*
,ma.material_name
,ma.material_code
,ma.material_spec
FROM pdm_bd_workorder wo
LEFT JOIN md_base_material ma ON ma.material_id = wo.material_id
<where>
<if test="query.more_order_status != null and query.more_order_status != ''">
workorder_status IN
<foreach collection="query.more_order_status" item="code" separator="," open="(" close=")">
#{code}
</foreach>
</if>
<if test="query.workorder_code != null and query.workorder_code != ''">
AND wo.workorder_code LIKE CONCAT('%', #{query.workorder_code}, '%')
</if>
<if test="query.point_code != null and query.point_code != ''">
AND LOWER(wo.point_code) LIKE LOWER(CONCAT('%', #{query.point_code}, '%'))
</if>
<if test="query.begin_time != null and query.begin_time != ''">
AND wo.create_time <![CDATA[ >= ]]> #{query.begin_time}
</if>
<if test="query.end_time != null and query.end_time != ''">
AND wo.create_time <![CDATA[ <= ]]> #{query.end_time}
</if>
</where>
</select>
</mapper>

99
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm/service/dto/PdmBdWorkorderDto.java Normal file
View File

@@ -0,0 +1,99 @@
package org.nl.wms.pdm.service.dto;
import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;
/**
* @description /
* @author lyd
* @date 2023-05-05
**/
@Data
public class PdmBdWorkorderDto implements Serializable {
/** 工单标识 */
private String workorder_id;
/** 工单编号 */
private String workorder_code;
/** 计划数量 */
private BigDecimal plan_qty;
/** 实际数量 */
private BigDecimal real_qty;
/** 物料标识 */
private String material_id;
/** 载具类型 */
private String vehicle_type;
/** 计划开始时间 */
private String planproducestart_date;
/** 计划结束时间 */
private String planproduceend_date;
/** 实际开始时间 */
private String realproducestart_date;
/** 实际结束时间 */
private String realproduceend_date;
/** 静置时间(分钟) */
private BigDecimal standing_time;
/** 点位编码 */
private String point_code;
/** 点位名称 */
private String point_name;
/** 区域编码 */
private String region_code;
/** 区域名称 */
private String region_name;
/** 工单状态 */
private String workorder_status;
/** 是否需要AGV搬运 */
private String is_needmove;
/** 工单类型 */
private String workorder_type;
/** 回传MES状态 */
private String passback_status;
/** 车间编码 */
private String workshop_code;
/** 外部标识 */
private String ext_id;
/** 是否删除 */
private Boolean is_delete;
/** 创建人 */
private String create_id;
/** 创建人 */
private String create_name;
/** 创建时间 */
private String create_time;
/** 修改人 */
private String update_id;
/** 修改人 */
private String update_name;
/** 修改时间 */
private String update_time;
}

20
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm/service/dto/PdmBdWorkorderQuery.java Normal file
View File

@@ -0,0 +1,20 @@
package org.nl.wms.pdm.service.dto;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
/**
* @author lyd
* @date 2023-05-05
**/
@Data
public class PdmBdWorkorderQuery implements Serializable {
private String workorder_code;
private String point_code;
private String begin_time;
private String end_time;
private List<String> more_order_status;
}

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

@@ -0,0 +1,83 @@
package org.nl.wms.pdm.service.impl;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.domain.query.PageQuery;
import org.nl.common.exception.BadRequestException;
import org.nl.common.utils.CodeUtil;
import org.nl.common.utils.SecurityUtils;
import org.nl.wms.pdm.service.IPdmBdWorkorderService;
import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
import org.nl.wms.pdm.service.dao.mapper.PdmBdWorkorderMapper;
import org.nl.wms.pdm.service.dto.PdmBdWorkorderQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Set;
/**
* @description 服务实现
* @author lyd
* @date 2023-05-05
**/
@Slf4j
@Service
public class PdmBdWorkorderServiceImpl extends ServiceImpl<PdmBdWorkorderMapper, PdmBdWorkorder> implements IPdmBdWorkorderService {
@Autowired
private PdmBdWorkorderMapper pdmBdWorkorderMapper;
@Override
public IPage<PdmBdWorkorder> queryAll(PdmBdWorkorderQuery query, PageQuery page){
IPage<PdmBdWorkorder> pages = new Page<>(page.getPage() + 1, page.getSize());
pages = pdmBdWorkorderMapper.selectPageLeftJoin(pages, query);
return pages;
}
@Override
public void create(PdmBdWorkorder entity) {
String currentUserId = SecurityUtils.getCurrentUserId();
String nickName = SecurityUtils.getCurrentNickName();
String now = DateUtil.now();
// 点位编码和点位名称为父点位
entity.setWorkorder_id(IdUtil.getSnowflake(1, 1).nextIdStr());
entity.setWorkorder_code(CodeUtil.getNewCode("PDM_SHIFTORDER"));
entity.setCreate_id(currentUserId);
entity.setCreate_name(nickName);
entity.setCreate_time(now);
entity.setUpdate_id(currentUserId);
entity.setUpdate_name(nickName);
entity.setUpdate_time(now);
pdmBdWorkorderMapper.insert(entity);
}
@Override
public void update(PdmBdWorkorder entity) {
PdmBdWorkorder dto = pdmBdWorkorderMapper.selectById(entity.getWorkorder_id());
if (dto == null) throw new BadRequestException("被删除或无权限，操作失败!");
String currentUserId = SecurityUtils.getCurrentUserId();
String nickName = SecurityUtils.getCurrentNickName();
String now = DateUtil.now();
entity.setUpdate_id(currentUserId);
entity.setUpdate_name(nickName);
entity.setUpdate_time(now);
pdmBdWorkorderMapper.updateById(entity);
}
@Override
public void deleteAll(Set<String> ids) {
// 真删除
pdmBdWorkorderMapper.deleteBatchIds(ids);
}
}

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

@@ -0,0 +1,155 @@
package org.nl.wms.sch.task_manage.task.tasks.auto;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.nl.common.exception.BadRequestException;
import org.nl.wms.pdm.service.IPdmBdWorkorderService;
import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
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.PointStatusEnum;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 入窑口叫料
* @Date: 2023/6/19
*/
@Component
@TaskType("RYKQLTask")
public class RYKQLTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "RYKQLTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Override
protected void create() throws BadRequestException {
}
@Override
@Transactional(rollbackFor = Exception.class)
protected void autoCreate() {
// // 自动创建任务
// // 判断当前点位有没有任务执行
// List<SchBaseTask> unFinishTasksByTaskConfig = taskService.findUnFinishTasksByTaskConfig(TASK_CONFIG_CODE);
// if (unFinishTasksByTaskConfig.size() > 0) {
// // 有任务在执行就不创建
// return;
// }
// // 获取任务配置
// SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
// .eq(SchBaseTaskconfig::getConfig_code, TASK_CONFIG_CODE));
// // 创建任务
// SchBaseTask task = new SchBaseTask(); // 任务实体
// // 2、创建申请任务
// task.setConfig_code(TASK_CONFIG_CODE);
// task.setCreate_mode("1");
// task.setTask_status(TaskStatus.APPLY.getCode());
// task.setWorkshop_code(taskConfig.getWorkshop_code()); // 车间编码
// // 设置起/终点
// this.setTaskPoint(taskConfig, task, "RYK");
// // 找起点
// List<String> startRegionStr = Arrays
// .stream(taskConfig.getStart_region_str().split(","))
// .collect(Collectors.toList());
// SchBasePoint point = findStartPoint(startRegionStr);
// if (ObjectUtil.isEmpty(point)) {
// task.setRemark("未找到所需点位!");
// taskService.create(task);
// // 消息通知
// return;
// }
// // 设置终点并修改创建成功状态
// task.setPoint_code1(point.getPoint_code());
// task.setRemark("");
// task.setTask_status(TaskStatus.CREATED.getCode());
// taskService.create(task);
// point.setIng_task_code(task.getTask_code());
// pointService.update(point);
//下发
// this.renotifyAcs(task);
}
private SchBasePoint findStartPoint(List<String> startRegionStr) {
// 无需工单
// 默认认为缓存线有东西
LambdaQueryWrapper<SchBasePoint> lam = new LambdaQueryWrapper<>();
lam.in(SchBasePoint::getRegion_code, startRegionStr)
.eq(SchBasePoint::getPoint_type, '2') // 点位类型是缓存输送线出口
.and(la -> la.isNull(SchBasePoint::getIng_task_code) // 当前执行的任务为空或者NULL，有数据表示锁住
.or()
.eq(SchBasePoint::getIng_task_code, ""))
.eq(SchBasePoint::getIs_used, true);
List<SchBasePoint> schBasePoints = pointService.list(lam);
return ObjectUtil.isNotEmpty(schBasePoints) ? schBasePoints.get(0) : null;
}
@Override
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(); // 获取起点
SchBasePoint startPointObj = pointService.getById(startPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
// 起点解锁
if (ObjectUtil.isNotEmpty(startPointObj)) {
startPointObj.setIng_task_code("");
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(startPointObj);
}
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);
}
}

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

@@ -0,0 +1,142 @@
package org.nl.wms.sch.task_manage.task.tasks.dtk;
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 org.nl.common.exception.BadRequestException;
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.PointStatusEnum;
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.dtk.mapper.DTKMapper;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 拆盘机呼叫空托
* @Date: 2023/6/21
*/
@Component
@TaskType("CTQKTask")
public class CTQKTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "CTQKTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private DTKMapper dtkMapper;
@Override
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) {
List<String> startRegionStr = Arrays.stream(taskConfig.getStart_region_str().split(",")).collect(Collectors.toList());
// 找起点
String extGroupData = task.getExt_group_data();
JSONObject jsonObject = JSONObject.parseObject(extGroupData);
SchBasePoint point = findStartPoint(startRegionStr);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
continue;
}
// 设置终点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
task.setRemark("");
task.setVehicle_qty(point.getVehicle_qty());
task.setTask_status(TaskStatus.CREATED.getCode());
taskService.update(task);
point.setIng_task_code(task.getTask_code());
pointService.update(point);
//下发
// this.renotifyAcs(task);
}
}
/**
* 从区域中获取一推钢托盘
* @param startRegionStr
* @return
*/
private SchBasePoint findStartPoint(List<String> startRegionStr) {
List<SchBasePoint> points = dtkMapper.findPointForCTQK(startRegionStr);
return ObjectUtil.isNotEmpty(points) ? points.get(0) : null;
}
@Override
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)) { // 完成
// 起点清空
if (ObjectUtil.isNotEmpty(startPointObj)) {
PointUtils.clearPoint(startPointObj);
endPointObj.setPoint_status(PointStatusEnum.EMPTY_VEHICLE.getCode());
endPointObj.setVehicle_type("2");
endPointObj.setVehicle_qty(taskObj.getVehicle_qty());
endPointObj.setUpdate_time(DateUtil.now());
pointService.updateById(endPointObj);
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 起点解锁
if (ObjectUtil.isNotEmpty(startPointObj)) {
startPointObj.setIng_task_code("");
pointService.update(startPointObj);
}
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);
}
}

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

@@ -0,0 +1,134 @@
package org.nl.wms.sch.task_manage.task.tasks.dtk;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.nl.common.exception.BadRequestException;
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.PointStatusEnum;
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.dtk.mapper.DTKMapper;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 叠托送空盘任务：-> 拆盘机/货架
* @Date: 2023/6/21
*/
@Component
@TaskType("DTSKTask")
public class DTSKTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "DTSKTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private DTKMapper dtkMapper;
@Override
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) {
List<String> nextRegionStr = Arrays.stream(taskConfig.getNext_region_str().split(",")).collect(Collectors.toList());
// 找终点
SchBasePoint point = findNextPoint(nextRegionStr);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
continue;
}
// 设置终点并修改创建成功状态
task.setPoint_code2(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
taskService.update(task);
point.setIng_task_code(task.getTask_code());
pointService.update(point);
//下发
// this.renotifyAcs(task);
}
}
private SchBasePoint findNextPoint(List<String> nextRegionStr) {
List<SchBasePoint> points = dtkMapper.findPointForDTSK(nextRegionStr);
return ObjectUtil.isNotEmpty(points) ? points.get(0) : null;
}
@Override
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(); // 获取终点
String vehicleType = ObjectUtil.isNotEmpty(taskObj.getVehicle_type()) ? taskObj.getVehicle_type() : "";
SchBasePoint endPointObj = pointService.getById(endPoint);
SchBasePoint startPointObj = pointService.getById(startPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
// 设置载具类型、点位状态、释放点位
if (ObjectUtil.isNotEmpty(endPoint)) {
endPointObj.setIng_task_code("");
endPointObj.setVehicle_type(vehicleType);
endPointObj.setVehicle_qty(endPointObj.getVehicle_qty() + taskObj.getVehicle_qty()); // 设置载具数量
endPointObj.setPoint_status(PointStatusEnum.EMPTY_VEHICLE.getCode());
pointService.update(endPointObj);
// 起点清空
PointUtils.clearPoint(startPointObj);
}
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 释放点位
if (ObjectUtil.isNotEmpty(endPoint)) {
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
}
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskObj.setRemark("任务取消");
}
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);
}
}

15
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/dtk/mapper/DTKMapper.java Normal file
View File

@@ -0,0 +1,15 @@
package org.nl.wms.sch.task_manage.task.tasks.dtk.mapper;
import org.nl.wms.sch.point.service.dao.SchBasePoint;
import java.util.List;
/**
* @Author: lyd
* @Description: 叠托库mapper
* @Date: 2023/6/21
*/
public interface DTKMapper {
List<SchBasePoint> findPointForDTSK(List<String> regionCode);
List<SchBasePoint> findPointForCTQK(List<String> regionCode);
}

45
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/dtk/mapper/DTKMapper.xml Normal file
View File

@@ -0,0 +1,45 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.nl.wms.sch.task_manage.task.tasks.dtk.mapper.DTKMapper">
<select id="findPointForDTSK" resultType="org.nl.wms.sch.point.service.dao.SchBasePoint">
SELECT
p.*
FROM
`sch_base_point` p
WHERE (p.point_type = '1' OR p.point_type IS NULL OR p.point_type = '')
AND (p.ing_task_code = '' OR p.ing_task_code IS NULL)
AND p.point_status = '1'
AND p.region_code IN
<foreach collection="regionCode" item="code" separator="," open="(" close=")">
#{code}
</foreach>
ORDER BY
<foreach collection="regionCode" item="region" index="index" separator=",">
CASE
<foreach collection="regionCode" item="innerRegion" index="innerIndex" separator=" ">
WHEN p.region_code = #{innerRegion} THEN #{innerIndex}
</foreach>
END
</foreach>
</select>
<select id="findPointForCTQK" resultType="org.nl.wms.sch.point.service.dao.SchBasePoint">
SELECT p.*
FROM `sch_base_point` p
WHERE (p.point_type = '3' OR p.point_type IS NULL OR p.point_type = '')
AND (p.ing_task_code = '' OR p.ing_task_code IS NULL)
AND p.point_status = '2'
AND p.is_used = 1
AND p.region_code IN
<foreach collection="regionCode" item="code" separator="," open="(" close=")">
#{code}
</foreach>
ORDER BY
<foreach collection="regionCode" item="region" index="index" separator=",">
CASE
<foreach collection="regionCode" item="innerRegion" index="innerIndex" separator=" ">
WHEN p.region_code = #{innerRegion} THEN #{innerIndex}
</foreach>
END
</foreach>
</select>
</mapper>

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

@@ -0,0 +1,188 @@
package org.nl.wms.sch.task_manage.task.tasks.fj;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.nl.common.exception.BadRequestException;
import org.nl.wms.pdm.service.IPdmBdWorkorderService;
import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
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.NoticeTypeEnum;
import org.nl.wms.sch.task_manage.enums.PointStatusEnum;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 分拣满空任务 - 4点
* @Date: 2023/6/21
*/
@Component
@TaskType("FJMKTask")
public class FJMKTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "FJMKTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Override
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) {
List<String> nextRegionStr = Arrays.stream(taskConfig.getNext_region_str().split(",")).collect(Collectors.toList());
List<String> startRegionStr = Arrays.stream(taskConfig.getStart_region_str().split(",")).collect(Collectors.toList());
String extGroupData = task.getExt_group_data();// 任务的其他数据
JSONObject jsonObject = JSONObject.parseObject(extGroupData);
// 找终点
SchBasePoint packagePoint = findNextPoint(nextRegionStr, jsonObject);
if (ObjectUtil.isEmpty(packagePoint)) {
task.setRemark("包装线不可用!");
taskService.update(task);
// 消息通知
continue;
}
SchBasePoint LaminatePoint = findStartPoint(startRegionStr, jsonObject);
if (ObjectUtil.isEmpty(LaminatePoint)) {
task.setRemark("覆膜区不可用!");
taskService.update(task);
// 消息通知
continue;
}
// 设置终点并修改创建成功状态
task.setPoint_code2(packagePoint.getPoint_code());
task.setPoint_code3(LaminatePoint.getPoint_code());
task.setPoint_code4(task.getPoint_code1());
task.setTask_status(TaskStatus.CREATED.getCode());
taskService.update(task);
packagePoint.setIng_task_code(task.getTask_code());
pointService.update(packagePoint);
LaminatePoint.setIng_task_code(task.getTask_code());
pointService.update(LaminatePoint);
//下发
// this.renotifyAcs(task);
}
}
/**
* 从覆膜区找个空木托盘
* @param startRegionStr
* @param extData
* @return
*/
private SchBasePoint findStartPoint(List<String> startRegionStr, JSONObject extData) {
// 当前设备的工单
String workorderCode = extData.getString("workorder_code");
PdmBdWorkorder one = ObjectUtil.isNotEmpty(workorderCode)
? workorderService.getOne(new LambdaQueryWrapper<PdmBdWorkorder>()
.eq(PdmBdWorkorder::getWorkorder_code, workorderCode))
: null;
if (one == null) {
throw new BadRequestException("工单不能为空!");
}
String vehicleType = one.getVehicle_type();
// todo: 向ACS请求所需木托盘在那个栈拆盘机？
// todo: 请求ACS释放一个木托盘
// 这个点的父点位为起点
SchBasePoint point = pointService.getById("FMADJW");
return point;
}
/**
* 从包装线找个位置放货
* @param nextRegionStr
* @param extData
* @return
*/
private SchBasePoint findNextPoint(List<String> nextRegionStr, JSONObject extData) {
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) // 当前执行的任务为空或者NULL，有数据表示锁住
.or()
.eq(SchBasePoint::getIng_task_code, ""))
.orderByAsc(SchBasePoint::getIn_order_seq)
.orderByAsc(SchBasePoint::getPoint_code);
List<SchBasePoint> schBasePoints = pointService.list(lam);
return ObjectUtil.isNotEmpty(schBasePoints) ? schBasePoints.get(0) : null;
}
@Override
@Transactional
protected void updateStatus(String task_code, TaskStatus status) {
// todo: 任务完成需要组盘,包装线解锁,覆膜对接位清空,分拣拆垛对接位设置空盘
// 校验任务
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 bzxPoint = taskObj.getPoint_code2(); // 获取终点1
String fmPoint = taskObj.getPoint_code3(); // 获取起点2
String fjcPoint = taskObj.getPoint_code4(); // 获取终点2
SchBasePoint bzxPointObj = pointService.getById(bzxPoint);
SchBasePoint fmPointObj = pointService.getById(fmPoint);
SchBasePoint fjcPointObj = pointService.getById(fjcPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
PointUtils.clearPoint(bzxPointObj);
PointUtils.clearPoint(fmPointObj);
fjcPointObj.setPoint_status(PointStatusEnum.EMPTY_VEHICLE.getCode());
fjcPointObj.setVehicle_qty(1);
fjcPointObj.setVehicle_type(taskObj.getVehicle_type());
pointService.update(fjcPointObj);
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 释放点位
fmPointObj.setIng_task_code("");
bzxPointObj.setIng_task_code("");
pointService.update(fmPointObj);
pointService.update(bzxPointObj);
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskObj.setRemark("任务取消");
}
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);
}
}

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

@@ -0,0 +1,146 @@
package org.nl.wms.sch.task_manage.task.tasks.fj;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.nl.common.exception.BadRequestException;
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.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.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 分拣呼叫空托盘任务
* @Date: 2023/6/21
*/
@Component
@TaskType("FJQKTask")
public class FJQKTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "FJQKTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Override
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) {
List<String> startRegionStr = Arrays.stream(taskConfig.getStart_region_str().split(",")).collect(Collectors.toList());
// 找起点
String extGroupDataStr = task.getExt_group_data();
JSONObject extGroupData = JSONObject.parseObject(extGroupDataStr);
SchBasePoint point = findStartPoint(startRegionStr, extGroupData);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
continue;
}
// 设置起点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setVehicle_code(point.getVehicle_code());
task.setGroup_id(point.getGroup_id());
taskService.update(task);
point.setIng_task_code(task.getTask_code());
pointService.update(point);
//下发
// this.renotifyAcs(task);
}
}
private SchBasePoint findStartPoint(List<String> startRegionStr, JSONObject extGroupData) {
// 当前设备的工单
String workorderCode = extGroupData.getString("workorder_code");
PdmBdWorkorder one = ObjectUtil.isNotEmpty(workorderCode)
? workorderService.getOne(new LambdaQueryWrapper<PdmBdWorkorder>()
.eq(PdmBdWorkorder::getWorkorder_code, workorderCode))
: null;
if (one == null) {
throw new BadRequestException("工单不能为空!");
}
String vehicleType = one.getVehicle_type();
// todo: 向ACS请求所需木托盘在那个栈拆盘机？
// todo: 请求ACS释放一个木托盘
// 这个点的父点位为起点
SchBasePoint point = pointService.getById("FMADJW");
return point;
}
@Override
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 vehicle_code = taskObj.getVehicle_code();
String startPoint = taskObj.getPoint_code2(); // 获取终点
SchBasePoint startPointObj = pointService.getById(startPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
if (ObjectUtil.isNotEmpty(startPointObj)) {
PointUtils.clearPoint(startPointObj);
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 终点解锁
if (ObjectUtil.isNotEmpty(startPointObj)) {
startPointObj.setIng_task_code("");
pointService.update(startPointObj);
}
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);
}
}

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

@@ -0,0 +1,161 @@
package org.nl.wms.sch.task_manage.task.tasks.fj;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.nl.common.exception.BadRequestException;
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.PointStatusEnum;
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.fj.mapper.FJMapper;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 分拣缺料任务
* @Date: 2023/6/20
*/
@Component
@TaskType("FJQLTask")
public class FJQLTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "FJQLTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Autowired
private FJMapper fjMapper;
@Override
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) {
List<String> startRegionStr = Arrays.stream(taskConfig.getStart_region_str().split(",")).collect(Collectors.toList());
// 找起点
String extGroupDataStr = task.getExt_group_data();
JSONObject extGroupData = JSONObject.parseObject(extGroupDataStr);
extGroupData.put("vehicle_type", task.getVehicle_type());
SchBasePoint point = findStartPoint(startRegionStr, extGroupData);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
continue;
}
// 设置起点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setVehicle_code(point.getVehicle_code());
task.setGroup_id(point.getGroup_id());
taskService.update(task);
point.setIng_task_code(task.getTask_code());
pointService.update(point);
//下发
// this.renotifyAcs(task);
}
}
/**
* 找起点：到钢托盘缓存找一个物料与分拣工单的物料相同的物料
* @param startRegionStr
* @param extGroupData
* @return
*/
private SchBasePoint findStartPoint(List<String> startRegionStr, JSONObject extGroupData) {
// 获取当前工单
String workorderCode = extGroupData.getString("workorder_code");
PdmBdWorkorder workOrder = ObjectUtil.isNotEmpty(workorderCode)
? workorderService.getOne(new LambdaQueryWrapper<PdmBdWorkorder>()
.eq(PdmBdWorkorder::getWorkorder_code, workorderCode))
: null;
Assert.notNull(workOrder, "工单不能为空!");
List<SchBasePoint> points = fjMapper.findPointForFJQL(startRegionStr, workOrder.getMaterial_id());
return ObjectUtil.isNotEmpty(points) ? points.get(0) : null;
}
@Override
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 vehicle_code = taskObj.getVehicle_code();
String startPoint = taskObj.getPoint_code2(); // 获取终点
SchBasePoint startPointObj = pointService.getById(startPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
// 除了解锁需要将组盘表中的物料绑定载具设置为已解绑
// 起点设置空位
if (ObjectUtil.isNotEmpty(startPointObj)) {
PointUtils.clearPoint(startPointObj); // 执行失败
SchBaseVehiclematerialgroup vehiclematerialgroup =
vehiclematerialgroupService.getById(taskObj.getGroup_id());
vehiclematerialgroup.setGroup_bind_material_status("3");
vehiclematerialgroup.setUpdate_time(DateUtil.now());
vehiclematerialgroupService.updateById(vehiclematerialgroup);
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 终点解锁
if (ObjectUtil.isNotEmpty(startPointObj)) {
startPointObj.setIng_task_code("");
pointService.update(startPointObj);
}
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);
}
}

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

@@ -0,0 +1,140 @@
package org.nl.wms.sch.task_manage.task.tasks.fj;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.nl.common.exception.BadRequestException;
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.NoticeTypeEnum;
import org.nl.wms.sch.task_manage.enums.PointStatusEnum;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 分拣入库任务 - 2点
* @Date: 2023/6/21
*/
@Component
@TaskType("FJRKTask")
public class FJRKTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "FJRKTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Override
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) {
List<String> nextRegionStr = Arrays.stream(taskConfig.getNext_region_str().split(",")).collect(Collectors.toList());
// 找终点
SchBasePoint point = findNextPoint(nextRegionStr);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
continue;
}
// 设置终点并修改创建成功状态
task.setPoint_code2(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
taskService.update(task);
point.setIng_task_code(task.getTask_code());
pointService.update(point);
//下发
// this.renotifyAcs(task);
}
}
/**
* 到对应的区域中获取放置点
* @param nextRegionStr
* @return
*/
private SchBasePoint findNextPoint(List<String> nextRegionStr) {
LambdaQueryWrapper<SchBasePoint> lam = new LambdaQueryWrapper<>();
lam.in(SchBasePoint::getRegion_code, nextRegionStr)
.and(la -> la.isNull(SchBasePoint::getIng_task_code) // 当前执行的任务为空或者NULL，有数据表示锁住
.or()
.eq(SchBasePoint::getIng_task_code, ""))
.eq(SchBasePoint::getIs_used, true);
List<SchBasePoint> schBasePoints = pointService.list(lam);
return ObjectUtil.isNotEmpty(schBasePoints) ? schBasePoints.get(0) : null;
}
@Override
protected void updateStatus(String task_code, TaskStatus status) {
// todo: 组盘
// 校验任务
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 endPoint = taskObj.getPoint_code2(); // 获取终点
String vehicleType = ObjectUtil.isNotEmpty(taskObj.getVehicle_type()) ? taskObj.getVehicle_type() : "";
// 获取外部参数
JSONObject extGroupData = ObjectUtil.isNotEmpty(taskObj.getExt_group_data())
? JSONObject.parseObject(taskObj.getExt_group_data())
: null;
SchBasePoint endPointObj = pointService.getById(endPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
// 设置载具类型、点位状态、释放点位
if (ObjectUtil.isNotEmpty(endPoint)) {
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
}
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 释放点位
if (ObjectUtil.isNotEmpty(endPoint)) {
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
}
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskObj.setRemark("任务取消");
}
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);
}
}

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

@@ -0,0 +1,141 @@
package org.nl.wms.sch.task_manage.task.tasks.fj;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.nl.common.exception.BadRequestException;
import org.nl.wms.pdm.service.IPdmBdWorkorderService;
import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
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.PointStatusEnum;
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.fj.mapper.FJMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 分拣送空托 -> 叠托位
* @Date: 2023/6/20
*/
@Component
@TaskType("FJSKTask")
public class FJSKTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "FJSKTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Autowired
private FJMapper fjMapper;
@Override
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) {
List<String> nextRegionStr = Arrays.stream(taskConfig.getNext_region_str().split(",")).collect(Collectors.toList());
// 找终点
SchBasePoint point = findNextPoint(nextRegionStr);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
continue;
}
// 设置终点并修改创建成功状态
task.setPoint_code2(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
taskService.update(task);
point.setIng_task_code(task.getTask_code());
pointService.update(point);
//下发
// this.renotifyAcs(task);
}
}
/**
* 找叠托位，无锁的位置即可
* @param nextRegionStr
* @return
*/
private SchBasePoint findNextPoint(List<String> nextRegionStr) {
List<SchBasePoint> points = fjMapper.findPointForFJSK(nextRegionStr);
return ObjectUtil.isNotEmpty(points) ? points.get(0) : null;
}
@Override
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 endPoint = taskObj.getPoint_code2(); // 获取终点
String vehicleType = ObjectUtil.isNotEmpty(taskObj.getVehicle_type()) ? taskObj.getVehicle_type() : "";
SchBasePoint endPointObj = pointService.getById(endPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
// 设置载具类型、点位状态、释放点位
if (ObjectUtil.isNotEmpty(endPoint)) {
endPointObj.setIng_task_code("");
endPointObj.setVehicle_type(vehicleType);
endPointObj.setVehicle_qty(endPointObj.getVehicle_qty() + 1); // 设置载具数量
endPointObj.setPoint_status(PointStatusEnum.EMPTY_VEHICLE.getCode());
pointService.update(endPointObj);
}
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 释放点位
if (ObjectUtil.isNotEmpty(endPoint)) {
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
}
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskObj.setRemark("任务取消");
}
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);
}
}

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

@@ -0,0 +1,15 @@
package org.nl.wms.sch.task_manage.task.tasks.fj.mapper;
import org.nl.wms.sch.point.service.dao.SchBasePoint;
import java.util.List;
/**
* @Author: lyd
* @Description: 分拣
* @Date: 2023/6/20
*/
public interface FJMapper {
List<SchBasePoint> findPointForFJQL(List<String> regionCode, String materialId);
List<SchBasePoint> findPointForFJSK(List<String> regionCode);
}

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

@@ -0,0 +1,32 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.nl.wms.sch.task_manage.task.tasks.fj.mapper.FJMapper">
<select id="findPointForFJQL" resultType="org.nl.wms.sch.point.service.dao.SchBasePoint">
SELECT
p.*,
vg.group_id
FROM
`sch_base_point` p
LEFT JOIN sch_base_vehiclematerialgroup vg ON p.vehicle_code = vg.vehicle_code AND p.vehicle_type = vg.vehicle_type AND vg.group_bind_material_status = '2'
WHERE (p.ing_task_code = '' OR p.ing_task_code IS NULL)
AND p.is_used = 1
AND p.point_status = '3'
AND vg.material_id = #{materialId}
AND p.region_code IN
<foreach collection="regionCode" item="code" separator="," open="(" close=")">
#{code}
</foreach>
</select>
<select id="findPointForFJSK" resultType="org.nl.wms.sch.point.service.dao.SchBasePoint">
SELECT
p.*
FROM
`sch_base_point` p
WHERE (p.ing_task_code = '' OR p.ing_task_code IS NULL)
AND p.point_type = '3'
AND p.region_code IN
<foreach collection="regionCode" item="code" separator="," open="(" close=")">
#{code}
</foreach>
</select>
</mapper>

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

@@ -0,0 +1,148 @@
package org.nl.wms.sch.task_manage.task.tasks.yao;
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.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.PointStatusEnum;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 出窑暂存
* @Date: 2023/6/20
*/
@Slf4j
@Component
@TaskType("CYZCTask")
public class CYZCTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "CYZCTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Override
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) {
List<String> nextRegionStr = Arrays.stream(taskConfig.getNext_region_str().split(",")).collect(Collectors.toList());
// 找终点
String extGroupData = task.getExt_group_data();
JSONObject jsonObject = JSONObject.parseObject(extGroupData);
SchBasePoint point = findNextPoint(nextRegionStr, jsonObject);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
continue;
}
// 设置终点并修改创建成功状态
task.setVehicle_type("2"); // 钢托盘
task.setPoint_code2(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
taskService.update(task);
point.setIng_task_code(task.getTask_code());
pointService.update(point);
//下发
// this.renotifyAcs(task);
}
}
/**
* 找终点：到钢托盘缓存区中获取一个空位
* @param nextRegionStr
* @param extData
* @return
*/
private SchBasePoint findNextPoint(List<String> nextRegionStr, JSONObject extData) {
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) // 当前执行的任务为空或者NULL，有数据表示锁住
.or()
.eq(SchBasePoint::getIng_task_code, ""))
.eq(SchBasePoint::getIs_used, true);
List<SchBasePoint> schBasePoints = pointService.list(lam);
return ObjectUtil.isNotEmpty(schBasePoints) ? schBasePoints.get(0) : null;
}
@Override
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 vehicle_code = taskObj.getVehicle_code();
String endPoint = taskObj.getPoint_code2(); // 获取终点
SchBasePoint endPointObj = pointService.getById(endPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
// 终点解锁
if (ObjectUtil.isNotEmpty(endPointObj)) {
endPointObj.setIng_task_code("");
endPointObj.setVehicle_code(vehicle_code);
endPointObj.setVehicle_qty(1);
endPointObj.setVehicle_type("2");
endPointObj.setPoint_status(PointStatusEnum.FULL_POINT.getCode());
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);
}
}

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

@@ -0,0 +1,152 @@
package org.nl.wms.sch.task_manage.task.tasks.yz;
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.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.PointStatusEnum;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 压制呼叫空盘
* @Date: 2023/6/16
*/
@Slf4j
@Component
@TaskType("YZQKTask")
public class YZQKTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "YZQKTask";
private static String EMPTY_ZHONG = "1";
/**碟盘机出口**/
private static String DISCONNECTING_EXIT = "2";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Override
@Transactional(rollbackFor = Exception.class)
protected void create() {
// 获取任务
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) {
List<String> startRegionStr = Arrays.stream(taskConfig.getStart_region_str().split(",")).collect(Collectors.toList());
// 找起点
String extGroupData = task.getExt_group_data();
JSONObject jsonObject = JSONObject.parseObject(extGroupData);
SchBasePoint point = findStartPoint(startRegionStr, jsonObject);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
continue;
}
// 设置终点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
task.setRemark("");
task.setTask_status(TaskStatus.CREATED.getCode());
taskService.update(task);
point.setIng_task_code(task.getTask_code());
pointService.update(point);
//下发
// this.renotifyAcs(task);
}
}
/**
* 业务过程：到指定的区域获取空托盘
* @param startRegionStr
* @param extGroupData
* @return
*/
private SchBasePoint findStartPoint(List<String> startRegionStr, JSONObject extGroupData) {
LambdaQueryWrapper<SchBasePoint> lam = new LambdaQueryWrapper<>();
lam.in(SchBasePoint::getRegion_code, startRegionStr)
.eq(SchBasePoint::getPoint_type, DISCONNECTING_EXIT) // 点位类型是拆盘机出口
.and(la -> la.isNull(SchBasePoint::getIng_task_code) // 当前执行的任务为空或者NULL，有数据表示锁住
.or()
.eq(SchBasePoint::getIng_task_code, ""))
.eq(SchBasePoint::getIs_used, true);
List<SchBasePoint> schBasePoints = pointService.list(lam);
return ObjectUtil.isNotEmpty(schBasePoints) ? schBasePoints.get(0) : null;
}
@Override
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)) { // 完成
// 起点清空
if (ObjectUtil.isNotEmpty(startPointObj)) {
PointUtils.clearPoint(startPointObj);
endPointObj.setPoint_status(PointStatusEnum.EMPTY_VEHICLE.getCode());
endPointObj.setVehicle_type("2");
endPointObj.setVehicle_qty(1);
pointService.update(endPointObj);
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark("任务完成");
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
// 起点解锁
if (ObjectUtil.isNotEmpty(startPointObj)) {
startPointObj.setIng_task_code("");
pointService.update(startPointObj);
}
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);
}
}

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

@@ -0,0 +1,171 @@
package org.nl.wms.sch.task_manage.task.tasks.yz;
import cn.hutool.core.lang.Assert;
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.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.PointStatusEnum;
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.yz.mapper.YZMapper;
import org.nl.wms.util.PointUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: lyd
* @Description: 压制缺料任务
* @Date: 2023/5/25
*/
@Slf4j
@Component
@TaskType("YZQLTask")
public class YZQLTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "YZQLTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Autowired
private YZMapper yzMapper;
@Override
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) {
List<String> startRegionStr = Arrays.stream(taskConfig.getStart_region_str().split(",")).collect(Collectors.toList());
// 找起点
String extGroupData = task.getExt_group_data();
JSONObject jsonObject = JSONObject.parseObject(extGroupData);
jsonObject.put("vehicle_type", task.getVehicle_type());
SchBasePoint point = findStartPoint(startRegionStr, jsonObject);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
continue;
}
// 设置起点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setVehicle_code(point.getVehicle_code());
taskService.update(task);
point.setIng_task_code(task.getTask_code());
pointService.update(point);
//下发
// this.renotifyAcs(task);
}
}
/**
* 找起点业务：混碾机工单的物料标识相同的位置
*
* @param startRegionStr : 区域列表
* @param extGroupData : 外部参数，包含条件所需的信息
* @return
* @description : JSONObject获取不到就是null
*/
private SchBasePoint findStartPoint(List<String> startRegionStr, JSONObject extGroupData) {
// 获取当前工单 todo: 半托优先
String workorderCode = extGroupData.getString("workorder_code");
PdmBdWorkorder workOrder = ObjectUtil.isNotEmpty(workorderCode)
? workorderService.getOne(new LambdaQueryWrapper<PdmBdWorkorder>()
.eq(PdmBdWorkorder::getWorkorder_code, workorderCode))
: null;
Assert.notNull(workOrder, "工单不能为空!");
// 查找混碾机工单的物料相同的位置
List<SchBasePoint> points = yzMapper.findPointForYZQL(startRegionStr, workOrder.getMaterial_id());
return ObjectUtil.isNotEmpty(points) ? points.get(0) : null;
}
@Override
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(); // 起点
JSONObject extGroupData = ObjectUtil.isNotEmpty(taskObj.getExt_group_data())
? JSONObject.parseObject(taskObj.getExt_group_data())
: null;
SchBasePoint startPointObj = pointService.getById(startPoint);
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) { // 执行中
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
}
if (status.equals(TaskStatus.FINISHED)) { // 完成
// 任务上有载具编码 -> 获取当前载具编码的组盘信息
SchBaseVehiclematerialgroup one = vehiclematerialgroupService.getOne(new LambdaQueryWrapper<SchBaseVehiclematerialgroup>()
.eq(SchBaseVehiclematerialgroup::getVehicle_code, taskObj.getVehicle_code())
.eq(SchBaseVehiclematerialgroup::getVehicle_type, taskObj.getVehicle_type())
.eq(SchBaseVehiclematerialgroup::getGroup_bind_material_status, GroupBindMaterialStatusEnum.BOUND.getValue()));
// 将载具设置为已解绑
one.setGroup_bind_material_status(GroupBindMaterialStatusEnum.UNBOUND.getValue());
vehiclematerialgroupService.update(one);
// 释放点位，将点位设置为空位,清空数据
if (ObjectUtil.isNotEmpty(startPointObj)) {
PointUtils.clearPoint(startPointObj);
// todo: 终点暂时无设置
}
// 任务修改成完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
}
if (status.equals(TaskStatus.CANCELED)) { // 取消
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
// 释放点位，起点正在执行的任务清空
if (ObjectUtil.isNotEmpty(startPointObj)) {
startPointObj.setIng_task_code("");
pointService.update(startPointObj);
}
}
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);
}
}

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

@@ -0,0 +1,235 @@
package org.nl.wms.sch.task_manage.task.tasks.yz;
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.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.yz.mapper.YZMapper;
import org.nl.wms.util.PointUtils;
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;
/**
* @Author: lyd
* @Description: 压制送料
* @Date: 2023/6/19
*/
@Slf4j
@Component
@TaskType("YZSLTask")
public class YZSLTask extends AbstractTask {
private static String TASK_CONFIG_CODE = "YZSLTask";
/**
* 入口
*/
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 YZMapper yzMapper;
@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) {
List<String> nextRegionStr = Arrays.stream(taskConfig.getNext_region_str().split(",")).collect(Collectors.toList());
// 找终点
String extGroupData = task.getExt_group_data();
JSONObject jsonObject = JSONObject.parseObject(extGroupData);
SchBasePoint point = findNextPoint(nextRegionStr, jsonObject);
if (ObjectUtil.isEmpty(point)) {
task.setRemark("未找到所需点位!");
taskService.update(task);
// 消息通知
continue;
}
// 设置终点并修改创建成功状态
task.setPoint_code2(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
taskService.update(task);
point.setIng_task_code(task.getTask_code());
pointService.update(point);
//下发
// this.renotifyAcs(task);
}
}
/**
* 判断是否加急：是->入窑口，否->双层缓存线
*
* @param nextRegionStr
* @param extGroupData
* @return
*/
private SchBasePoint findNextPoint(List<String> nextRegionStr, JSONObject extGroupData) {
// 需要获取nextRegionStr
if (nextRegionStr.size() < 2) {
throw new BadRequestException("压制送料任务的配置文件有错!");
}
String regionCode = nextRegionStr.get(0);
// 当前设备的工单
String workorderCode = extGroupData.getString("workorder_code");
PdmBdWorkorder one = ObjectUtil.isNotEmpty(workorderCode)
? workorderService.getOne(new LambdaQueryWrapper<PdmBdWorkorder>()
.eq(PdmBdWorkorder::getWorkorder_code, workorderCode))
: null;
if (one == null) {
throw new BadRequestException("压制机的工单不能为空!");
}
// 判断是否加急，加急则去窑口，不加急就是去双层缓存输送线
if (one.getIs_urgent()) {
regionCode = nextRegionStr.get(1); // 去窑区
}
List<SchBasePoint> pointForYZSL = yzMapper.findPointForYZSL(new JSONObject(
MapOf.of("regionCode", regionCode, "pointType", ENTRANCE)));
return ObjectUtil.isNotEmpty(pointForYZSL) ? pointForYZSL.get(0) : null;
// ??
// LambdaQueryWrapper<SchBasePoint> lam = new LambdaQueryWrapper<>();
// lam.eq(SchBasePoint::getRegion_code, regionCode)
// .eq(SchBasePoint::getPoint_type, ENTRANCE)
// .and(la -> la.isNull(SchBasePoint::getIng_task_code) // 当前执行的任务为空或者NULL，有数据表示锁住
// .or()
// .eq(SchBasePoint::getIng_task_code, ""))
// .eq(SchBasePoint::getIs_used, true);
// List<SchBasePoint> schBasePoints = pointService.list(lam);
// return ObjectUtil.isNotEmpty(schBasePoints) ? schBasePoints.get(0) : null;
}
@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("该任务已取消!");
}
// 获取参数
JSONObject extGroupData = ObjectUtil.isNotEmpty(taskObj.getExt_group_data())
? JSONObject.parseObject(taskObj.getExt_group_data())
: null;
// 载具编码：没有就创建一个
String vehicle_code = ObjectUtil.isNotEmpty(taskObj.getVehicle_code())
? taskObj.getVehicle_code()
: IdUtil.getSnowflake(1, 1).nextIdStr();
PdmBdWorkorder workorderCode = ObjectUtil.isNotEmpty(extGroupData.getString("workorder_code"))
? workorderService.getOne(new LambdaQueryWrapper<PdmBdWorkorder>()
.eq(PdmBdWorkorder::getWorkorder_code, extGroupData.getString("workorder_code")))
: null;
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)) { // 完成
// 起点清空
if (ObjectUtil.isNotEmpty(startPointObj)) {
PointUtils.clearPoint(startPointObj);
}
// 终点解锁
endPointObj.setIng_task_code("");
pointService.update(endPointObj);
// 要把数据存到组盘表 -> 改造公共方法，返回id
SchBaseVehiclematerialgroup groupEntity = new SchBaseVehiclematerialgroup();
groupEntity.setGroup_id(IdUtil.getSnowflake(1,1).nextIdStr());
groupEntity.setCreate_id("2");
groupEntity.setCreate_name("ACS");
groupEntity.setCreate_time(DateUtil.now());
groupEntity.setMaterial_id(ObjectUtil.isNotEmpty(workorderCode)
? workorderCode.getMaterial_id()
: "");
groupEntity.setStanding_time(ObjectUtil.isNotEmpty(workorderCode)
? workorderCode.getStanding_time()
: 0);
groupEntity.setMaterial_weight(ObjectUtil.isNotEmpty(extGroupData)
? extGroupData.getBigDecimal("material_qty")
: BigDecimal.valueOf(0));
groupEntity.setWorkorder_code(ObjectUtil.isNotEmpty(workorderCode)
? workorderCode.getWorkorder_code()
: "");
groupEntity.setVehicle_code(vehicle_code);
groupEntity.setVehicle_type(taskObj.getVehicle_type());
groupEntity.setPoint_code(startPoint);
groupEntity.setPoint_name(startPointObj.getPoint_name());
groupEntity.setPcsn( DateUtil.format(DateUtil.date(), "yyyyMMdd"));
groupEntity.setInstorage_time(DateUtil.now());
groupEntity.setTask_code(taskObj.getTask_code());
groupEntity.setGroup_bind_material_status(GroupBindMaterialStatusEnum.BOUND.getValue()); // 绑定
groupEntity.setGroup_status(GroupStatusEnum.IN_STORAGE.getType()); // 暂时不维护。
groupEntity.setIs_delete(false);
vehiclematerialgroupService.save(groupEntity);
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setGroup_id(groupEntity.getGroup_id());
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);
}
}

32
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/yz/backup.txt Normal file
View File

@@ -0,0 +1,32 @@
private SchBasePoint findStartPoint(List<String> startRegionStr, JSONObject extGroupData) {
// 获取当前工单
String workorderCode = extGroupData.getString("workorder_code");
PdmBdWorkorder workOrder = ObjectUtil.isNotEmpty(workorderCode)
? workorderService.getOne(new LambdaQueryWrapper<PdmBdWorkorder>()
.eq(PdmBdWorkorder::getWorkorder_code, workorderCode))
: null;
Assert.notNull(workOrder, "工单不能为空!");
String vehicleType = workOrder.getVehicle_type();
String materialId = workOrder.getMaterial_id();
int standingTime = workOrder.getStanding_time(); // 静置时间
Assert.notNull(materialId, "物料不能为空!");
Assert.notNull(vehicleType, "载具类型不能为空!");
Assert.notNull(standingTime, "静置时间不能为空!");
// 找到所需要物料的载具编号
List<SchBaseVehiclematerialgroup> list = vehiclematerialgroupService.list(
new LambdaQueryWrapper<SchBaseVehiclematerialgroup>()
.eq(SchBaseVehiclematerialgroup::getMaterial_id, materialId)
.eq(SchBaseVehiclematerialgroup::getVehicle_type, vehicleType)
.eq(SchBaseVehiclematerialgroup::getGroup_bind_material_status, GroupBindMaterialStatusEnum.BOUND.getValue())
.apply("DATE_ADD(instorage_time, INTERVAL " + standingTime + " MINUTE) <= NOW()")
.orderByAsc(SchBaseVehiclematerialgroup::getPoint_code));
// 获取第一个
SchBaseVehiclematerialgroup vehiclematerialgroup = ObjectUtil.isNotEmpty(list) ? list.get(0) : null;
if (ObjectUtil.isEmpty(vehiclematerialgroup)) return null;
SchBasePoint one = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.in(SchBasePoint::getRegion_code, startRegionStr)
.eq(SchBasePoint::getPoint_status, PointStatusEnum.FULL_POINT.getCode())
.eq(SchBasePoint::getVehicle_code, vehiclematerialgroup.getVehicle_code())
.eq(SchBasePoint::getVehicle_type, vehicleType));
return one;
}

16
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/yz/mapper/YZMapper.java Normal file
View File

@@ -0,0 +1,16 @@
package org.nl.wms.sch.task_manage.task.tasks.yz.mapper;
import com.alibaba.fastjson.JSONObject;
import org.nl.wms.sch.point.service.dao.SchBasePoint;
import java.util.List;
/**
* @Author: lyd
* @Description:
* @Date: 2023/6/19
*/
public interface YZMapper {
List<SchBasePoint> findPointForYZQL(List<String> regionCode, String materialId);
List<SchBasePoint> findPointForYZSL(JSONObject param);
}

34
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/yz/mapper/YZMapper.xml Normal file
View File

@@ -0,0 +1,34 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.nl.wms.sch.task_manage.task.tasks.yz.mapper.YZMapper">
<select id="findPointForYZQL" resultType="org.nl.wms.sch.point.service.dao.SchBasePoint">
SELECT
p.*
FROM
`sch_base_point` p
LEFT JOIN pdm_bd_workorder w ON w.material_id = #{materialId} AND w.workorder_status = '3'
AND w.region_code = 'HN'
WHERE p.point_code = w.point_code
AND (p.ing_task_code = '' OR p.ing_task_code IS NULL)
AND p.is_used = 1
AND p.region_code IN
<foreach collection="regionCode" item="code" separator="," open="(" close=")">
#{code}
</foreach>
</select>
<select id="findPointForYZSL" resultType="org.nl.wms.sch.point.service.dao.SchBasePoint">
SELECT
p.*
FROM
`sch_base_point` p
LEFT JOIN sch_base_task t ON ( t.point_code1 = p.point_code OR t.point_code2 = p.point_code )
AND t.task_status != '5'
AND t.task_status != '6'
WHERE
( p.ing_task_code IS NULL OR p.ing_task_code = '' )
AND p.region_code = #{regionCode}
AND p.point_type = #{pointType}
AND p.is_used = TRUE
AND ( t.task_code IS NULL OR t.task_code = '')
</select>
</mapper>

42
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/util/test/mapper/TestMapper.java Normal file
View File

@@ -0,0 +1,42 @@
package org.nl.wms.util.test.mapper;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import java.util.HashMap;
import java.util.List;
/**
* @Author: lyd
* @Description: mapper接口
* @Date: 2023/5/23
*/
public interface TestMapper extends BaseMapper<JSONObject> {
List<HashMap<String, Object>> getAll();
JSONObject getAll2();
List<JSONObject> getAll3();
JSONArray getAll4();
JSONArray getAll5();
HashMap<String, Object> getAll6();
JSONObject getAll7();
JSONArray getAll8();
JSONArray getAll9();
JSONObject getAll10(HashMap map);
JSONArray getAll11(JSONObject map);
JSONArray getAll12(List<String> list);
void updateByObject(JSONObject object);
}

90
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/util/test/mapper/TestMapper.xml Normal file
View File

@@ -0,0 +1,90 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.nl.wms.util.test.mapper.TestMapper">
<resultMap id="selectPoint" type="java.util.HashMap">
<result property="point_code" column="point_code"/>
<result property="point_name" column="point_name"/>
<result property="region" column="region_name"/>
</resultMap>
<resultMap id="selectPoint2" type="com.alibaba.fastjson.JSONObject">
<result property="point_code" column="point_code"/>
<result property="point_name" column="point_name"/>
<result property="region" column="region_name"/>
</resultMap>
<update id="updateByObject" parameterType="com.alibaba.fastjson.JSONObject">
UPDATE sch_base_point
SET point_name = #{point_name}
WHERE point_code = #{point_code}
</update>
<select id="getAll" resultMap="selectPoint">
SELECT point_code, point_name, region_name
FROM sch_base_point
</select>
<select id="getAll2" resultMap="selectPoint2">
SELECT point_code, point_name, region_name
FROM sch_base_point
WHERE point_code = 'HNJ01'
</select>
<select id="getAll3" resultMap="selectPoint2">
SELECT point_code, point_name, region_name
FROM sch_base_point
</select>
<select id="getAll4" resultMap="selectPoint2">
SELECT point_code, point_name, region_name
FROM sch_base_point
</select>
<select id="getAll5" resultMap="selectPoint">
SELECT point_code, point_name, region_name
FROM sch_base_point
</select>
<select id="getAll6" resultType="java.util.HashMap">
SELECT point_code, point_name, region_name
FROM sch_base_point
WHERE point_code = 'HNJ01'
</select>
<select id="getAll7" resultType="com.alibaba.fastjson.JSONObject">
SELECT point_code, point_name, region_name
FROM sch_base_point
WHERE point_code = 'HNJ01'
</select>
<select id="getAll8" resultType="com.alibaba.fastjson.JSONObject">
SELECT point_code, point_name, region_name
FROM sch_base_point
</select>
<select id="getAll9" resultType="java.util.HashMap">
SELECT point_code, point_name, region_name
FROM sch_base_point
</select>
<select id="getAll10" resultType="com.alibaba.fastjson.JSONObject" parameterType="java.util.HashMap">
SELECT point_code, point_name, region_name
FROM sch_base_point
WHERE 1 = 1
<if test="pointCode != '' and pointCode != null">
AND point_code = #{pointCode}
</if>
</select>
<!-- 查询所有数据 -->
<select id="getAll11" resultType="com.alibaba.fastjson.JSONObject" parameterType="com.alibaba.fastjson.JSONObject">
<!-- 查询所有数据 -->
SELECT point_code, point_name, region_name
FROM sch_base_point
<where>
<if test="pointCode != '' and pointCode != null">
AND point_code = #{pointCode} -- 条件过滤
</if>
</where>
</select>
<select id="getAll12" resultType="com.alibaba.fastjson.JSONObject" parameterType="java.util.List">
SELECT point_code, point_name, region_name
FROM sch_base_point
<where>
point_code IN
<foreach collection="list" item="code" separator="," open="(" close=")">
#{code}
</foreach>
</where>
</select>
</mapper>

156
lms/nladmin-system/nlsso-server/src/test/java/org/nl/point/PointCreate.java Normal file
View File

@@ -0,0 +1,156 @@
package org.nl.point;
import cn.hutool.core.date.DateUtil;
import org.junit.jupiter.api.Test;
import org.nl.wms.sch.point.service.ISchBasePointService;
import org.nl.wms.sch.point.service.dao.SchBasePoint;
import org.nl.wms.sch.region.service.ISchBaseRegionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
/**
* @Author: lyd
* @Description: 创建点位
* @Date: 2023/6/15
*/
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class PointCreate {
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseRegionService regionService;
@Test
void test01() {
// 创建YJ01-08
List<SchBasePoint> pointList = new ArrayList<>();
for (int i = 3; i <= 8; i++) {
String pointName = "压机0";
String pointCode = "YJ0";
pointName = pointName + i;
pointCode = pointCode + i;
SchBasePoint point = new SchBasePoint();
point.setPoint_code(pointCode);
point.setPoint_name(pointName);
point.setRegion_code("YZ");
point.setRegion_name("压制区域");
point.setPoint_type("1");
point.setParent_point_code(pointCode);
point.setIs_has_workder(true);
point.setIs_auto(true);
pointList.add(point);
}
pointService.saveBatch(pointList);
}
@Test
void test02() { // 压机接料位
// 创建YJ01JLW01
List<SchBasePoint> pointList = new ArrayList<>();
for (int i = 3; i <= 8; i++) {
String pointName = "压机0";
String pointCode = "YJ0";
pointName = pointName + i;
pointCode = pointCode + i;
for (int j = 1; j <= 2; j++) {
String jlw = "JLW0";
String jlw2 = "接料位0";
jlw = jlw + j;
jlw2 = jlw2 + j;
SchBasePoint point = new SchBasePoint();
point.setPoint_code(pointCode + jlw);
point.setPoint_name(pointName + jlw2);
point.setRegion_code("YZ");
point.setRegion_name("压制区域");
point.setPoint_type("2");
point.setParent_point_code(pointCode);
point.setIs_has_workder(false);
point.setIs_auto(true);
pointList.add(point);
}
}
pointService.saveBatch(pointList);
}
@Test
void test03() { // 料盅睏料线区域
// 创建LZKL01 - 32
List<SchBasePoint> pointList = new ArrayList<>();
for (int i = 1; i <= 12; i++) {// 3台
String pointName = "睏料位";
String pointCode = "KLW";
if (i < 10) {
pointName = pointName + "0" + i;
pointCode = pointCode + "0" + i;
} else {
pointName = pointName + i;
pointCode = pointCode + i;
}
SchBasePoint point = new SchBasePoint();
point.setPoint_code(pointCode);
point.setPoint_name(pointName);
point.setRegion_code("LZKLX");
point.setRegion_name("料盅睏料线区域");
point.setParent_point_code(pointCode);
point.setIs_has_workder(false);
point.setIs_auto(true);
pointList.add(point);
}
pointService.saveBatch(pointList);
}
@Test
void test04() { // 缓存库位区域
List<SchBasePoint> pointList = new ArrayList<>();
int count = 1;
for (int i = 1; i <= 2; i++) {
for (int j = 1; j <= 29; j++) {
for (int k = 1; k <= 3; k++) {
String code = "HCHJ";
String name = "缓存货架";
if (count < 10) {
code = code + "00" + count;
name = name + "00" + count;
} else if (count >= 10 && count < 100) {
code = code + "0" + count;
name = name + "0" + count;
} else {
code = code + count;
name = name + count;
}
SchBasePoint point = new SchBasePoint();
point.setPoint_code(code);
point.setPoint_name(name);
point.setRegion_code("GTPHC");
point.setRegion_name("钢托盘缓存区域");
point.setPoint_status("1");
point.setCan_vehicle_type("2");
point.setVehicle_max_qty(1);
point.setBlock_num(1);
point.setRow_num(i);
point.setCol_num(j);
point.setLayer_num(k);
point.setIn_order_seq(count);
point.setOut_order_seq(count);
point.setIn_empty_seq(count);
point.setOut_empty_seq(count);
point.setParent_point_code(code);
point.setCreate_id("1");
point.setCreate_name("管理员");
point.setCreate_time(DateUtil.now());
point.setIs_has_workder(false);
point.setIs_auto(true);
point.setIs_used(true);
pointList.add(point);
count++;
}
}
}
pointService.saveBatch(pointList);
}
}