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

add:手持接口增加

Browse Source
This commit is contained in:
songxiaopeng
2024-04-03 17:31:37 +08:00
parent 098c1b2ea6
commit 0f7f57ff82
16 changed files with 969 additions and 342 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -61,6 +61,6 @@ public interface AcsToWmsService {
BaseResponse woodenPalletBinding(JSONObject param);
JSONObject errorDeviceRecord(JSONObject param);
/** 混碾机满料 任务不下发*/
BaseResponse mixFull(JSONObject param);
// /** 混碾机满料 任务不下发*/
// BaseResponse mixFull(JSONObject param);
}

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

@@ -1065,26 +1065,26 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
return result;
}
@Override
public BaseResponse mixFull(JSONObject param) {
String requestNo = param.getString("requestNo");
String workorderCode = param.getString("order_code");
// String deviceCode = param.getString("device_code");
String weight = param.getString("weight");
if (ObjectUtil.isEmpty(workorderCode)) {
return BaseResponse.responseError(requestNo,"工单号不能为空");
}
if (ObjectUtil.isEmpty(weight)) {
return BaseResponse.responseError(requestNo,"生产重量不能为空");
}
PdmBdWorkorder workorder = workorderService.getByCode(workorderCode);
if (ObjectUtil.isEmpty(workorder)){
return BaseResponse.responseError(requestNo,"未查询到相应工单");
}
BigDecimal bigDecimal = BigDecimal.valueOf(Long.parseLong(weight));
workorder.setReal_weight(workorder.getReal_weight().add(bigDecimal));
workorder.setWorkorder_status(WorkOrderStatusEnum.STAGING.getCode());
workorderService.update(workorder);
return BaseResponse.responseOk(requestNo);
}
// @Override
// public BaseResponse mixFull(JSONObject param) {
// String requestNo = param.getString("requestNo");
// String workorderCode = param.getString("order_code");
//// String deviceCode = param.getString("device_code");
// String weight = param.getString("weight");
// if (ObjectUtil.isEmpty(workorderCode)) {
// return BaseResponse.responseError(requestNo,"工单号不能为空");
// }
// if (ObjectUtil.isEmpty(weight)) {
// return BaseResponse.responseError(requestNo,"生产重量不能为空");
// }
// PdmBdWorkorder workorder = workorderService.getByCode(workorderCode);
// if (ObjectUtil.isEmpty(workorder)){
// return BaseResponse.responseError(requestNo,"未查询到相应工单");
// }
// BigDecimal bigDecimal = BigDecimal.valueOf(Long.parseLong(weight));
// workorder.setReal_weight(workorder.getReal_weight().add(bigDecimal));
// workorder.setWorkorder_status(WorkOrderStatusEnum.STAGING.getCode());
// workorderService.update(workorder);
// return BaseResponse.responseOk(requestNo);
// }
}

279
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/controller/PdaController.java
View File

@@ -14,7 +14,6 @@ import org.nl.wms.pda.service.PdaService;
import org.nl.wms.pda.service.dao.dto.*;
import org.nl.wms.pda.service.dao.vo.PdaResponseVo;
import org.nl.wms.pdm.workorder.service.IPdmBdWorkorderService;
import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
@@ -35,233 +34,8 @@ import org.springframework.web.bind.annotation.RestController;
@RequestMapping("/api/pda")
@SaIgnore
public class PdaController {
@Autowired
private IDasDeviceCheckRecordService deviceCheckRecordService;
@Autowired
private IDasDeviceOperationRecordService deviceOperationRecordService;
@Autowired
private PdaService pdaService;
@Autowired
private IPdmBdWorkorderService workorderService;
@PostMapping("/deviceCheck/verify")
@Log("设备点检")
@ApiOperation("设备点检")
public ResponseEntity<Object> deviceCheck(@Validated @RequestBody DasDeviceCheckRecord entity){
return new ResponseEntity<>(deviceCheckRecordService.create(entity), HttpStatus.OK);
}
@PostMapping("/deviceCheck/deviceInfo")
@Log("设备下拉框数据")
@ApiOperation("设备下拉框数据")
public ResponseEntity<Object> deviceInfo(){
return new ResponseEntity<>(pdaService.getDeviceInfo(), HttpStatus.OK);
}
@PostMapping("/deviceCheck/deviceStatus")
@Log("设备状态下拉框数据")
@ApiOperation("设备状态下拉框数据")
public ResponseEntity<Object> deviceStatus(){
return new ResponseEntity<>(pdaService.getDeviceStatus(), HttpStatus.OK);
}
@PostMapping("/deviceSwitchover/deviceAction")
@Log("设备动作下拉框数据")
@ApiOperation("设备动作下拉框数据")
public ResponseEntity<Object> deviceAction(){
return new ResponseEntity<>(pdaService.deviceAction(), HttpStatus.OK);
}
@PostMapping("/deviceSwitchover/verify")
@Log("设备动作切换")
@ApiOperation("设备动作切换")
public ResponseEntity<Object> deviceSwitchover(@Validated @RequestBody DasDeviceOperationRecord entity){
return new ResponseEntity<>(deviceOperationRecordService.create(entity), HttpStatus.OK);
}
@PostMapping("/group/getPressCode")
@Log("获取压机编码")
@ApiOperation("获取压机编码")
public ResponseEntity<Object> getPressCode(){
return new ResponseEntity<>(pdaService.getDeviceInfo(), HttpStatus.OK);
}
@PostMapping("/group/getVehicleType")
@Log("获取载具类型")
@ApiOperation("获取载具类型")
public ResponseEntity<Object> getVehicleType(){
return new ResponseEntity<>(pdaService.getVehicleType(), HttpStatus.OK);
}
@PostMapping("/group/getPressWorkOrder")
@Log("获取工单编码")
@ApiOperation("获取工单编码")
@Deprecated
public ResponseEntity<Object> getPressWorkOrder(@RequestBody JSONObject param){
return new ResponseEntity<>(workorderService.getDeviceProductionTask(param.getString("point_code")), HttpStatus.OK);
}
@PostMapping("/group/manual")
@Log("人工组盘")
@ApiOperation("人工组盘")
public ResponseEntity<PdaResponseVo> manualDiskAssembly(@Validated @RequestBody ManualGroupDto entity){
return new ResponseEntity<>(pdaService.manualCreateByPda(entity), HttpStatus.OK);
}
@PostMapping("/move/getBlendingCode")
@Log("获取混碾机编码")
@ApiOperation("获取混碾机编码")
public ResponseEntity<Object> getBlendingCode(){
return new ResponseEntity<>(pdaService.getBlendingCode(), HttpStatus.OK);
}
@PostMapping("/move/sendTask")
@Log("生成混碾->压机任务")
@ApiOperation("生成混碾->压机任务")
public ResponseEntity<PdaResponseVo> sendTask(@Validated @RequestBody BlendingMoveDto blendingMoveDto){
return new ResponseEntity<>(pdaService.sendTask(blendingMoveDto), HttpStatus.OK);
}
@PostMapping("/forcedResting/show")
@Log("显示静置时长")
@ApiOperation("显示静置时长")
public ResponseEntity<Object> forcedRestingShow(){
return new ResponseEntity<>(pdaService.forcedRestingShow(), HttpStatus.OK);
}
@PostMapping("/forcedResting/submit")
@Log("强制静置")
@ApiOperation("强制静置")
public ResponseEntity<PdaResponseVo> forcedResting(@Validated @RequestBody ForcedRestingDto forcedRestingDto){
return new ResponseEntity<>(pdaService.forcedResting(forcedRestingDto), HttpStatus.OK);
}
@PostMapping("/manualSorting/orders")
@Log("人工分拣-显示工单")
@ApiOperation("人工分拣-显示工单")
public ResponseEntity<Object> manualOrders(){
return new ResponseEntity<>(pdaService.manualOrders(), HttpStatus.OK);
}
@PostMapping("/manualSorting/productionScheduling")
@Log("人工分拣-开工")
@ApiOperation("人工分拣-开工")
public ResponseEntity<PdaResponseVo> productionScheduling(@Validated @RequestBody ManualSortingDto manualSortingDto){
return new ResponseEntity<>(pdaService.productionScheduling(manualSortingDto), HttpStatus.OK);
}
@PostMapping("/manualSorting/productionComplete")
@Log("人工分拣-完工")
@ApiOperation("人工分拣-完工")
public ResponseEntity<PdaResponseVo> productionComplete(@Validated @RequestBody ManualSortingDto manualSortingDto){
return new ResponseEntity<>(pdaService.productionComplete(manualSortingDto), HttpStatus.OK);
}
@PostMapping("/manualSorting/emptyDiskIntoStorageTask")
@Log("人工分拣-空盘入库-动作")
@ApiOperation("人工分拣-空盘入库-动作")
public ResponseEntity<PdaResponseVo> emptyDiskIntoStorageTask(){
return new ResponseEntity<>(pdaService.emptyDiskIntoStorageTask(), HttpStatus.OK);
}
@PostMapping("/manualSorting/emptyDiskIntoStorageShow")
@Log("人工分拣-空盘入库-显示任务信息")
@ApiOperation("人工分拣-空盘入库-显示任务信息")
public ResponseEntity<Object> emptyDiskIntoStorageShow(){
return new ResponseEntity<>(pdaService.emptyDiskIntoStorageShow(), HttpStatus.OK);
}
@PostMapping("/manualSorting/callingWoodenPalletTask")
@Log("人工分拣-呼叫木托盘-动作")
@ApiOperation("人工分拣-呼叫木托盘-动作")
public ResponseEntity<PdaResponseVo> callingWoodenPalletTask(){
return new ResponseEntity<>(pdaService.callingWoodenPalletTask(), HttpStatus.OK);
}
@PostMapping("/manualSorting/callingWoodenPalletTaskShow")
@Log("人工分拣-呼叫木托盘-显示任务信息")
@ApiOperation("人工分拣-呼叫木托盘-显示任务信息")
public ResponseEntity<Object> callingWoodenPalletTaskShow(){
return new ResponseEntity<>(pdaService.callingWoodenPalletTaskShow(), HttpStatus.OK);
}
@PostMapping("/manualSorting/callingMaterialTask")
@Log("人工分拣-呼叫物料-动作")
@ApiOperation("人工分拣-呼叫物料-动作")
public ResponseEntity<PdaResponseVo> callingMaterialTask(){
return new ResponseEntity<>(pdaService.callingMaterialTask(), HttpStatus.OK);
}
@PostMapping("/manualSorting/callingMaterialTaskShow")
@Log("人工分拣-呼叫物料-显示任务信息")
@ApiOperation("人工分拣-呼叫物料-显示任务信息")
public ResponseEntity<Object> callingMaterialTaskShow(){
return new ResponseEntity<>(pdaService.callingMaterialTaskShow(), HttpStatus.OK);
}
@PostMapping("/manualSorting/callingResidueMaterialTask")
@Log("人工分拣-剩料入库-动作")
@ApiOperation("人工分拣-剩料入库-动作")
public ResponseEntity<PdaResponseVo> callingResidueMaterialTask(@Validated @RequestBody ManualResidueInDto manualResidueInDto){
return new ResponseEntity<>(pdaService.callingResidueMaterialTask(manualResidueInDto), HttpStatus.OK);
}
@PostMapping("/manualSorting/callingResidueMaterialTaskShow")
@Log("人工分拣-剩料入库-显示任务信息")
@ApiOperation("人工分拣-剩料入库-显示任务信息")
public ResponseEntity<Object> callingResidueMaterialTaskShow(){
return new ResponseEntity<>(pdaService.callingResidueMaterialTaskShow(), HttpStatus.OK);
}
@PostMapping("/manualSorting/packingTask")
@Log("人工分拣-包装入库-动作")
@ApiOperation("人工分拣-包装入库-动作")
public ResponseEntity<PdaResponseVo> packingTask(@Validated @RequestBody ManualResidueInDto manualResidueInDto){
return new ResponseEntity<>(pdaService.packingTask(manualResidueInDto), HttpStatus.OK);
}
@PostMapping("/manualSorting/packingTaskShow")
@Log("人工分拣-包装入库-显示任务信息")
@ApiOperation("人工分拣-包装入库-显示任务信息")
public ResponseEntity<Object> packingTaskShow(){
return new ResponseEntity<>(pdaService.packingTaskShow(), HttpStatus.OK);
}
@PostMapping("/manualSorting/bindingVehicle")
@Log("人工分拣-载具绑定")
@ApiOperation("人工分拣-载具绑定")
public ResponseEntity<PdaResponseVo> bindingVehicle(@Validated @RequestBody VehicleBindingDto vehicleBindingDto){
return new ResponseEntity<>(pdaService.bindingVehicle(vehicleBindingDto), HttpStatus.OK);
}
@PostMapping("/pressSendMaterial/pressTask")
@Log("压机送料-动作")
@ApiOperation("压机送料-动作")
public ResponseEntity<PdaResponseVo>pressTask(@Validated @RequestBody PressMoveDto pressMoveDto){
return new ResponseEntity<>(pdaService.pressTask(pressMoveDto), HttpStatus.OK);
}
@PostMapping("/pressSendMaterial/pressPointList")
@Log("压机送料-下拉框")
@ApiOperation("压机送料-下拉框")
public ResponseEntity<Object>pressPointList(){
return new ResponseEntity<>(pdaService.pressPointList(), HttpStatus.OK);
}
@PostMapping("/shelf/materialQuery")
@Log("货架盘点-物料查询")
@ApiOperation("货架盘点-物料查询")
public ResponseEntity<Object>materialQuery(@Validated @RequestBody CommonQueryDto commonQueryDto){
return new ResponseEntity<>(pdaService.materialQuery(commonQueryDto), HttpStatus.OK);
}
@PostMapping("/shelf/updateData")
@Log("货架盘点-物料查询")
@ApiOperation("货架盘点-物料查询")
public ResponseEntity<Object>updateData(@Validated @RequestBody ShelfSaveDto shelfSaveDto){
return new ResponseEntity<>(pdaService.updateData(shelfSaveDto), HttpStatus.OK);
}
//华弘手持接口
@PostMapping("/hnWorkOrder")
@Log("查询混碾工单")
@ApiOperation("查询混碾工单")
@@ -269,27 +43,48 @@ public class PdaController {
return new ResponseEntity<>(pdaService.getHnWorkOrder(), HttpStatus.OK);
}
// @PostMapping("/orderFinish")
// @Log("混碾工单完成")
// @ApiOperation("混碾工单完成")
// public ResponseEntity<Object> orderFinish(@RequestBody OrderFinishReq req) {
// return new ResponseEntity<>(pdaService.orderFinish(req), HttpStatus.OK);
// }
@PostMapping("/orderFinish")
@Log("混碾工单完成")
@ApiOperation("混碾工单完成")
public ResponseEntity<Object> orderFinish(@RequestBody OrderFinishReq req) {
return new ResponseEntity<>(pdaService.orderFinish(req), HttpStatus.OK);
@PostMapping("/shelfInfo")
@Log("查询货架上料盅信息")
@ApiOperation("查询货架上料盅信息")
public ResponseEntity<Object> shelfInfo() {
return new ResponseEntity<>(pdaService.shelfInfo(), HttpStatus.OK);
}
@PostMapping("/hnmlTask")
@Log("拆包机料盅入库")
@ApiOperation("拆包机料盅入库")
public ResponseEntity<Object> hnmlTask(@RequestBody OrderFinishReq req) {
return new ResponseEntity<>(pdaService.hnmlTask(req), HttpStatus.OK);
@PostMapping("/cbjqlTask")
@Log("拆包机缺料")
@ApiOperation("拆包机缺料")
public ResponseEntity<Object> cbjqlTask(@RequestBody TaskReq req) {
return new ResponseEntity<>(pdaService.cbjqlTask(req), HttpStatus.OK);
}
@PostMapping("/hnqkTask")
@Log("拆包机叫空蛊")
@ApiOperation("拆包机叫空蛊")
public ResponseEntity<Object> hnqkTask() {
return new ResponseEntity<>(pdaService.hnqkTask(), HttpStatus.OK);
@PostMapping("/cbjmlTask")
@Log("拆包机下料位满料")
@ApiOperation("拆包机下料位满料")
public ResponseEntity<Object> cbjmlTask(@RequestBody TaskReq req) {
return new ResponseEntity<>(pdaService.cbjmlTask(req), HttpStatus.OK);
}
@PostMapping("/cbjqkTask")
@Log("拆包机下料位叫空蛊")
@ApiOperation("拆包机下料位叫空蛊")
public ResponseEntity<Object> cbjqkTask(@RequestBody TaskReq req) {
return new ResponseEntity<>(pdaService.cbjqkTask(req), HttpStatus.OK);
}
@PostMapping("/yzqlTask")
@Log("困料货架点对点到布料机上料位")
@ApiOperation("困料货架点对点到布料机上料位")
public ResponseEntity<Object> yzqlTask(@RequestBody TaskReq req) {
return new ResponseEntity<>(pdaService.yzqlTask(req), HttpStatus.OK);
}
@PostMapping("/yjslwPointList")
@Log("压机上料位下拉框")
@ApiOperation("压机上料位下拉框")
@@ -306,7 +101,7 @@ public class PdaController {
@PostMapping("/materialScrap")
@Log("物料报废")
@ApiOperation("物料报废")
public ResponseEntity<Object> materialScrap(@RequestBody OrderFinishReq req) {
public ResponseEntity<Object> materialScrap(@RequestBody TaskReq req) {
return new ResponseEntity<>(pdaService.materialScrap(req), HttpStatus.OK);
}

13
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/service/PdaService.java
View File

@@ -67,15 +67,20 @@ public interface PdaService {
List<DropdownListVo> pressPointList();
PdaResponseVo orderFinish(OrderFinishReq req);
// PdaResponseVo orderFinish(TaskReq req);
List<ShelfInfoVo> shelfInfo();
PdaResponseVo hnmlTask(OrderFinishReq req);
PdaResponseVo cbjqlTask(TaskReq req);
PdaResponseVo hnqkTask();
PdaResponseVo cbjmlTask(TaskReq req);
PdaResponseVo cbjqkTask(TaskReq req);
PdaResponseVo yzqlTask(TaskReq req);
PdaResponseVo qzhhjTask(ForceBackStorageReq req);
PdaResponseVo materialScrap(OrderFinishReq req);
PdaResponseVo materialScrap(TaskReq req);
PdaResponseVo rgfjqlTask(FjReq req);

8
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/service/dao/dto/OrderFinishReq.java → lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/service/dao/dto/TaskReq.java
View File

@@ -1,16 +1,14 @@
package org.nl.wms.pda.service.dao.dto;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.util.Date;
/**
* @author sxp
*/
@Data
public class OrderFinishReq {
public class TaskReq {
private String orderCode;
private String startPoint;
private String endPoint;
private String barCode;
private String createTime;
}

3
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/service/dao/mapper/PdaMapper.java
View File

@@ -62,7 +62,6 @@ public interface PdaMapper {
/**
* 查询物料
* @param commonQueryDto
* @return
*/
List<MaterialInfoVo> materialQuery(CommonQueryDto commonQueryDto);
@@ -80,4 +79,6 @@ public interface PdaMapper {
List<DropdownListVo> getHchjPoint();
List<DropdownListVo> getYjslwPointList();
List<ShelfInfoVo> selectShelfInfo();
}

11
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/service/dao/mapper/PdaMapper.xml
View File

@@ -183,5 +183,16 @@
p.region_code = 'YZ'
AND p.point_type in ('3','4')
</select>
<select id="selectShelfInfo" resultType="org.nl.wms.pda.service.dao.vo.ShelfInfoVo">
select p.point_code as pointCode, m.material_code as materialCode, g.instorage_time as instorageTime
from sch_base_point p
left join sch_base_vehiclematerialgroup g on p.point_code = g.point_code
left join md_base_material m on g.material_id = m.material_id
where p.region_code = 'KL'
and p.is_used = '1'
and p.point_status = '3'
and p.point_code not like 'CBJ%'
order by g.point_code
</select>
</mapper>

14
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/service/dao/vo/ShelfInfoVo.java Normal file
View File

@@ -0,0 +1,14 @@
package org.nl.wms.pda.service.dao.vo;
import lombok.Data;
/**
* @author sxp
* @Description: 困料货架信息
*/
@Data
public class ShelfInfoVo {
private String pointCode;
private String materialCode;
private String instorageTime;
}

95
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/service/impl/PdaServiceImpl.java
View File

@@ -5,8 +5,6 @@ import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.nl.common.exception.BadRequestException;
@@ -14,7 +12,6 @@ import org.nl.common.utils.SecurityUtils;
import org.nl.wms.database.material.service.IMdBaseMaterialService;
import org.nl.wms.database.material.service.dao.MdBaseMaterial;
import org.nl.wms.ext.acs.service.WmsToAcsService;
import org.nl.wms.ext.acs.service.dto.to.BaseResponse;
import org.nl.wms.ext.acs.service.dto.to.acs.DeviceInfoDto;
import org.nl.wms.ext.acs.service.dto.to.wms.AcsResponse;
import org.nl.wms.pda.service.PdaService;
@@ -41,7 +38,6 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
@@ -395,51 +391,88 @@ public class PdaServiceImpl implements PdaService {
}
@Override
public PdaResponseVo orderFinish(OrderFinishReq req) {
if (StringUtils.isEmpty(req.getOrderCode())) {
throw new BadRequestException("工单不能为空");
public List<ShelfInfoVo> shelfInfo() {
return pdaMapper.selectShelfInfo();
}
// @Override
// public PdaResponseVo orderFinish(TaskReq req) {
// if (StringUtils.isEmpty(req.getOrderCode())) {
// throw new BadRequestException("工单不能为空");
// }
// PdmBdWorkorder bdWorkorder = workorderService.getByCode(req.getOrderCode());
// if (bdWorkorder == null) {
// throw new BadRequestException("未找到对应工单");
// }
// if (!WorkOrderStatusEnum.STAGING.getCode().equals(bdWorkorder.getWorkorder_status())){
// throw new BadRequestException("只能选择暂存中的工单");
// }
// bdWorkorder.setWorkorder_status(WorkOrderStatusEnum.COMPLETE.getCode());
// bdWorkorder.setRealproduceend_date(DateUtil.now());
// TaskUtils.setWorkOrderUpdateByAcs(bdWorkorder);
// // 统计合不合格数量到工单字段中
// workorderService.updateById(bdWorkorder);
// return PdaResponseVo.pdaResultOk("工单完成");
// }
@Override
public PdaResponseVo cbjqlTask(TaskReq req) {
if (StringUtils.isEmpty(req.getStartPoint())) {
throw new BadRequestException("货架点位不能为空");
}
PdmBdWorkorder bdWorkorder = workorderService.getByCode(req.getOrderCode());
if (bdWorkorder == null) {
throw new BadRequestException("未找到对应工单");
if (StringUtils.isEmpty(req.getEndPoint())) {
throw new BadRequestException("拆包机点位不能为空");
}
if (!WorkOrderStatusEnum.STAGING.getCode().equals(bdWorkorder.getWorkorder_status())){
throw new BadRequestException("只能选择暂存中的工单");
}
bdWorkorder.setWorkorder_status(WorkOrderStatusEnum.COMPLETE.getCode());
bdWorkorder.setRealproduceend_date(DateUtil.now());
TaskUtils.setWorkOrderUpdateByAcs(bdWorkorder);
// 统计合不合格数量到工单字段中
workorderService.updateById(bdWorkorder);
return PdaResponseVo.pdaResultOk("工单完成");
JSONObject param = new JSONObject();
param.put("start_point", req.getStartPoint());
param.put("device_code", req.getEndPoint());
param.put("config_code","CBJQLTask");
taskService.apply(param);
return PdaResponseVo.pdaResultOk("拆包机缺料请求成功");
}
@Override
public PdaResponseVo hnmlTask(OrderFinishReq req) {
public PdaResponseVo cbjmlTask(TaskReq req) {
if (StringUtils.isEmpty(req.getOrderCode())) {
throw new BadRequestException("工单不能为空");
}
if (StringUtils.isEmpty(req.getStartPoint())) {
throw new BadRequestException("拆包机点位不能为空");
}
if (StringUtils.isEmpty(req.getBarCode())) {
throw new BadRequestException("条码不能为空");
}
//下发拆包机到货架的任务
JSONObject param = new JSONObject();
param.put("device_code", "CBJ01");
param.put("config_code","HNMLTask");
param.put("vehicle_code", req.getBarCode());
param.put("workorder_code",req.getOrderCode());
param.put("create_time",req.getCreateTime());
param.put("vehicle_code",req.getBarCode());
param.put("device_code", req.getStartPoint());
param.put("config_code","CBJMLTask");
taskService.apply(param);
return PdaResponseVo.pdaResultOk("满料入库请求成功");
return PdaResponseVo.pdaResultOk("拆包机下料位满料请求成功");
}
@Override
public PdaResponseVo hnqkTask() {
public PdaResponseVo cbjqkTask(TaskReq req) {
if (StringUtils.isEmpty(req.getEndPoint())) {
throw new BadRequestException("拆包机点位不能为空");
}
JSONObject param = new JSONObject();
param.put("device_code", "CBJ01");
param.put("config_code","HNQKTask");
param.put("device_code", req.getEndPoint());
param.put("config_code","CBJQKTask");
taskService.apply(param);
return PdaResponseVo.pdaResultOk("空蛊出库请求成功");
return PdaResponseVo.pdaResultOk("拆包机下料位叫空蛊请求成功");
}
@Override
public PdaResponseVo yzqlTask(TaskReq req) {
JSONObject param = new JSONObject();
//作为判断压制缺料点对点任务判断
param.put("task_type","YZQLPTP");
param.put("point_code1", req.getStartPoint());
param.put("device_code", req.getEndPoint());
param.put("config_code","YZQLTask");
taskService.apply(param);
return PdaResponseVo.pdaResultOk("布料机上料位请求成功");
}
@Override
@@ -453,7 +486,7 @@ public class PdaServiceImpl implements PdaService {
@Override
public PdaResponseVo materialScrap(OrderFinishReq req) {
public PdaResponseVo materialScrap(TaskReq req) {
if (StringUtils.isEmpty(req.getBarCode())) {
throw new BadRequestException("条码不能为空");
}

2
lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/point/service/impl/SchBasePointServiceImpl.java
View File

@@ -106,7 +106,7 @@ public class SchBasePointServiceImpl extends ServiceImpl<SchBasePointMapper, Sch
point.setCustomer(point1.getCustomer());
point.setMaterial_code(point1.getMaterial_code());
point.setMaterial_model(point1.getMaterial_model());
point.setMaterial_code(point1.getMaterial_code());
point.setMaterial_spec(point1.getMaterial_spec());
}
});

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

@@ -0,0 +1,306 @@
package org.nl.wms.sch.task_manage.task.tasks.hn;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.nl.common.exception.BadRequestException;
import org.nl.system.service.notice.ISysNoticeService;
import org.nl.wms.database.material.service.IMdBaseMaterialService;
import org.nl.wms.database.material.service.dao.MdBaseMaterial;
import org.nl.wms.pdm.workorder.service.IPdmBdWorkorderService;
import org.nl.wms.pdm.workorder.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.constant.ExceptionConstant;
import org.nl.wms.sch.task_manage.constant.GeneralDefinition;
import org.nl.wms.sch.task_manage.constant.PointTypeConstant;
import org.nl.wms.sch.task_manage.constant.RegionConstant;
import org.nl.wms.sch.task_manage.enums.*;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.hn.mapper.HNMapper;
import org.nl.wms.util.PointUtils;
import org.nl.wms.util.TaskUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @author sxp
* @desc 拆包机下料位满料入库
*/
@Component("CBJMLTask")
public class CBJMLTask extends AbstractTask {
private static final String TASK_CONFIG_CODE = "CBJMLTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Autowired
private ISysNoticeService noticeService;
@Autowired
private IMdBaseMaterialService materialService;
@Autowired
private HNMapper hnMapper;
/**
* 具体业务
* 找点+下发-定时任务
*/
@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) {
TaskUtils.setUpdateByAcs(task);
List<String> nextRegionStr = Arrays.stream(taskConfig.getNext_region_str().split(","))
.collect(Collectors.toList());
String requestParam = task.getRequest_param();
JSONObject jsonObject = JSONObject.parseObject(requestParam);
// 找终点
SchBasePoint point = findNextPoint(nextRegionStr, jsonObject);
if (ObjectUtil.isEmpty(point)) {
task.setRemark(ExceptionConstant.NEED_POINT_NOT_FOUND);
taskService.updateById(task);
// 消息通知
noticeService.createNotice(task.getRemark(), TASK_CONFIG_CODE + task.getTask_code(), NoticeTypeEnum.WARN.getCode());
continue;
}
// 设置终点并修改创建成功状态
task.setPoint_code2(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setRemark("");
task.setVehicle_type(GeneralDefinition.MATERIAL_CUP);
taskService.updateById(task);
// 锁住终点
point.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(point);
pointService.updateById(point);
}
}
/**
* 先判断是否特殊物料 分配货架位置或者布料机
*
* @param nextRegionStr
* @param requestParam
* @return
*/
private SchBasePoint findNextPoint(List<String> nextRegionStr, JSONObject requestParam) {
// 放到困料货架
List<SchBasePoint> points = pointService.list(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getRegion_code, nextRegionStr.get(0))
// 当前执行的任务为空或者NULL，有数据表示锁住
.and(la -> la.isNull(SchBasePoint::getIng_task_code)
.or()
.eq(SchBasePoint::getIng_task_code, ""))
.eq(SchBasePoint::getPoint_status, PointStatusEnum.EMPTY_POINT.getCode())
.eq(SchBasePoint::getIs_used, true)
.orderByAsc(SchBasePoint::getUpdate_time)
.orderByAsc(SchBasePoint::getIn_order_seq)
.orderByAsc(SchBasePoint::getPoint_code));
return ObjectUtil.isNotEmpty(points) ? points.get(0) : null;
}
@Override
@Transactional(rollbackFor = Exception.class)
protected void updateStatus(String task_code, TaskStatus status) {
// 校验任务
SchBaseTask taskObj = taskService.getByCode(task_code);
if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
throw new BadRequestException(ExceptionConstant.THE_TASK_HAS_BEEN_COMPLETED);
}
if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
throw new BadRequestException(ExceptionConstant.THE_TASK_HAS_BEEN_COMPLETED);
}
if (status.equals(TaskStatus.EXECUTING)) {
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
TaskUtils.setUpdateByAcs(taskObj);
taskService.updateById(taskObj);
} else if (status.equals(TaskStatus.FINISHED)) {
this.finishTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
} else if (status.equals(TaskStatus.CANCELED)) {
this.cancelTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
}
}
@Override
public void forceFinish(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
if (ObjectUtil.isEmpty(taskObj)) {
throw new BadRequestException("该任务不存在");
}
this.finishTask(taskObj, TaskFinishedTypeEnum.MANUAL_PC);
}
@Override
public void cancel(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
if (ObjectUtil.isEmpty(taskObj)) {
throw new BadRequestException("该任务不存在");
}
this.cancelTask(taskObj, TaskFinishedTypeEnum.MANUAL_PC);
}
public void finishTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
// 获取参数
String endPoint = taskObj.getPoint_code2();
String startPoint = taskObj.getPoint_code1();
SchBasePoint endPointObj = pointService.getById(endPoint);
SchBasePoint startPointObj = pointService.getById(startPoint);
SchBaseVehiclematerialgroup groupEntity = vehiclematerialgroupService.getOne(
new LambdaQueryWrapper<SchBaseVehiclematerialgroup>()
.eq(SchBaseVehiclematerialgroup::getGroup_id, taskObj.getGroup_id()));
Assert.notNull(groupEntity, ExceptionConstant.GROUP_INFORMATION_NOT_FOUND);
// 终点去除正在执行的任务, 设置载具编码、载具类型、载具数量
if (ObjectUtil.isNotEmpty(endPointObj)) {
endPointObj.setIng_task_code("");
endPointObj.setPoint_status(PointStatusEnum.FULL_POINT.getCode());
endPointObj.setVehicle_qty(1);
endPointObj.setVehicle_code(taskObj.getVehicle_code());
endPointObj.setVehicle_type(GeneralDefinition.MATERIAL_CUP);
PointUtils.setUpdateByType(endPointObj, taskFinishedType);
pointService.updateById(endPointObj);
// 更新组盘数据
groupEntity.setPoint_code(endPointObj.getPoint_code());
groupEntity.setPoint_name(endPointObj.getPoint_name());
groupEntity.setMove_way(groupEntity.getMove_way() + " -> " + endPointObj.getPoint_code());
groupEntity.setTask_code(taskObj.getTask_code());
TaskUtils.setGroupUpdateByType(groupEntity, taskFinishedType);
vehiclematerialgroupService.updateById(groupEntity);
// 更新工单上的实际重量
// 更新混碾工单
PdmBdWorkorder workOrderObj = workorderService.getByCode(groupEntity.getWorkorder_code());
workOrderObj.setReal_weight(workOrderObj.getReal_weight().add(groupEntity.getMaterial_weight()));
TaskUtils.setWorkOrderUpdateByType(workOrderObj, taskFinishedType);
workorderService.updateById(workOrderObj);
// 如果终点是布料机，那就是需要将压机工单对应（新、旧）料的真实值相加
if (RegionConstant.PRESSED_AREA.equals(endPointObj.getRegion_code())) {
PdmBdWorkorder productionTask = workorderService.getDeviceDockingProductionTask(endPoint);
switch (endPointObj.getPoint_type()) {
case PointTypeConstant.NEW_MATERIAL_POINT:
productionTask.setReal_new_weight(productionTask.getReal_new_weight()
.add(groupEntity.getMaterial_weight()));
break;
case PointTypeConstant.OLD_MATERIAL_POINT:
productionTask.setReal_old_weight(productionTask.getReal_old_weight()
.add(groupEntity.getMaterial_weight()));
break;
default:
throw new BadRequestException("点位区域配置错误!");
}
TaskUtils.setWorkOrderUpdateByType(productionTask, taskFinishedType);
workorderService.updateById(productionTask);
}
// 清空起点
PointUtils.setUpdateByType(startPointObj, taskFinishedType);
PointUtils.clearPoint(startPointObj);
}
taskObj.setRemark(GeneralDefinition.TASK_FINISH);
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
public void cancelTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
// 获取参数
String endPoint = taskObj.getPoint_code2();
SchBasePoint one = ObjectUtil.isNotEmpty(endPoint)
? pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getPoint_code, endPoint))
: null;
if (one != null) {
one.setIng_task_code("");
PointUtils.setUpdateByType(one, taskFinishedType);
pointService.updateById(one);
// 删掉组盘信息
vehiclematerialgroupService.removeById(taskObj.getGroup_id());
}
taskObj.setRemark(GeneralDefinition.TASK_CANCEL);
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
/**
* 组盘
*/
@Override
public String setGroupPlate(JSONObject param) {
String vehicleCode = TaskUtils.defaultVehicleCode(param.getString("vehicle_code"));
String vehicleType = GeneralDefinition.MATERIAL_CUP;
String deviceCode = param.getString("device_code");
BigDecimal weight = param.getBigDecimal("weight");
// 获取工单
PdmBdWorkorder productionTask = workorderService.getByCode(param.getString("workorder_code"));
if (ObjectUtil.isEmpty(productionTask)) {
throw new BadRequestException("未查询到工单" + param.getString("workorder_code"));
}
SchBasePoint basePoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getPoint_code, deviceCode)
.eq(SchBasePoint::getIs_used, true));
if (ObjectUtil.isEmpty(basePoint)) {
throw new BadRequestException("点位[" + deviceCode + "]已被禁用");
}
if (vehicleCode == null || vehicleCode.equals(GeneralDefinition.NO)) {
throw new BadRequestException("载具编码不能为空");
}
// 找到相同组盘信息就直接返回id，避免任务取消组盘信息还存在，重复插入
vehiclematerialgroupService.unBindingSameVehicleMaterial(vehicleCode, vehicleType);
SchBaseVehiclematerialgroup groupEntity = new SchBaseVehiclematerialgroup();
groupEntity.setGroup_id(IdUtil.getSnowflake(1, 1).nextIdStr());
// 要把数据存到组盘表
groupEntity.setMaterial_id(productionTask.getMaterial_id());
groupEntity.setRedundance_material_code(productionTask.getRaw_material_code());
groupEntity.setCreate_id(GeneralDefinition.ACS_ID);
groupEntity.setCreate_name(GeneralDefinition.ACS_NAME);
groupEntity.setCreate_time(param.getString("create_time"));
groupEntity.setVehicle_code(vehicleCode);
groupEntity.setVehicle_type(vehicleType);
groupEntity.setSource_vehicle_code(basePoint.getPoint_code());
groupEntity.setPoint_code(basePoint.getPoint_code());
groupEntity.setPoint_name(basePoint.getPoint_name());
groupEntity.setMove_way(basePoint.getPoint_code());
groupEntity.setMix_times("1");
groupEntity.setInstorage_time(DateUtil.now());
groupEntity.setPcsn(DateUtil.format(DateUtil.date(), "yyyyMMdd"));
groupEntity.setStanding_time(productionTask.getStanding_time());
groupEntity.setWorkorder_code(productionTask.getWorkorder_code());
groupEntity.setMaterial_weight(ObjectUtil.isNotEmpty(weight)
? weight
: BigDecimal.valueOf(0));
groupEntity.setGroup_bind_material_status(GroupBindMaterialStatusEnum.BOUND.getValue());
groupEntity.setGroup_status(GroupStatusEnum.IN_STORAGE.getType());
groupEntity.setIs_delete(false);
vehiclematerialgroupService.save(groupEntity);
return groupEntity.getGroup_id();
}
}

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

@@ -0,0 +1,216 @@
package org.nl.wms.sch.task_manage.task.tasks.hn;
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.system.service.notice.ISysNoticeService;
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.constant.ExceptionConstant;
import org.nl.wms.sch.task_manage.constant.GeneralDefinition;
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.enums.TaskFinishedTypeEnum;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.util.PointUtils;
import org.nl.wms.util.TaskUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: sxp
* @Description: 拆包机缺空：呼叫空载具，从困料货架上获取
*/
@Component("CBJQKTask")
public class CBJQKTask extends AbstractTask {
private static final String TASK_CONFIG_CODE = "CBJQKTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private ISysNoticeService noticeService;
/**
* 具体业务
*/
@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) {
TaskUtils.setUpdateByAcs(task); // 修改修改者
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(ExceptionConstant.NEED_POINT_NOT_FOUND);
taskService.update(task);
// 消息通知
continue;
}
// 设置终点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
task.setRemark("");
task.setTask_status(TaskStatus.CREATED.getCode());
taskService.updateById(task);
point.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(point);
pointService.updateById(point);
}
}
/**
* 立即创建任务
* @param task
*/
@Override
protected void createCompletion(SchBaseTask task) {
// 配置信息
SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
.eq(SchBaseTaskconfig::getConfig_code, TASK_CONFIG_CODE));
TaskUtils.setUpdateByAcs(task); // 修改修改者
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)) {
// 消息通知
noticeService.createNotice(ExceptionConstant.NEED_POINT_NOT_FOUND
, TASK_CONFIG_CODE + task.getPoint_code2()
, NoticeTypeEnum.WARN.getCode());
throw new BadRequestException(ExceptionConstant.NEED_POINT_NOT_FOUND);
}
// 设置终点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
task.setRemark("");
task.setTask_status(TaskStatus.CREATED.getCode());
TaskUtils.setUpdateByAcs(task);
taskService.save(task);
point.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(point);
pointService.updateById(point);
}
/**
* 找起点, 通过料盅睏料货架找到空盅
*
* @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_status, PointStatusEnum.EMPTY_VEHICLE.getCode())
.and(la -> la.isNull(SchBasePoint::getIng_task_code) // 当前执行的任务为空或者NULL，有数据表示锁住
.or()
.eq(SchBasePoint::getIng_task_code, ""))
.orderByAsc(SchBasePoint::getUpdate_time)
.orderByAsc(SchBasePoint::getIn_order_seq);
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.getByCode(task_code);
if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
throw new BadRequestException(ExceptionConstant.THE_TASK_HAS_BEEN_COMPLETED);
}
if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
throw new BadRequestException(ExceptionConstant.THE_TASK_HAS_BEEN_CANCELLED);
}
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) {
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
TaskUtils.setUpdateByAcs(taskObj);
taskService.updateById(taskObj);
}
if (status.equals(TaskStatus.FINISHED)) {
this.finishTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
}
if (status.equals(TaskStatus.CANCELED)) {
this.cancelTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
}
}
@Override
public void forceFinish(String task_code) {
this.updateStatus(task_code, TaskStatus.FINISHED);
}
@Override
public void cancel(String task_code) {
this.updateStatus(task_code, TaskStatus.CANCELED);
}
public void finishTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
// 获取参数
String startPoint = taskObj.getPoint_code1(); // 获取起点
String endPoint = taskObj.getPoint_code2(); // 获取起点
SchBasePoint startPointObj = pointService.getById(startPoint);
SchBasePoint endPointObj = pointService.getById(endPoint);
// 起点清空
if (ObjectUtil.isNotEmpty(startPointObj)) {
PointUtils.setUpdateByType(startPointObj, taskFinishedType);
PointUtils.clearPoint(startPointObj);
endPointObj.setPoint_status(PointStatusEnum.EMPTY_VEHICLE.getCode());
endPointObj.setVehicle_type(GeneralDefinition.MATERIAL_CUP);
endPointObj.setVehicle_qty(1);
PointUtils.setUpdateByType(endPointObj, taskFinishedType);
pointService.updateById(endPointObj);
}
// 任务完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark(GeneralDefinition.TASK_FINISH);
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
public void cancelTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
// 获取参数
String startPoint = taskObj.getPoint_code1(); // 获取起点
SchBasePoint startPointObj = pointService.getById(startPoint);
// 起点解锁
if (ObjectUtil.isNotEmpty(startPointObj)) {
startPointObj.setIng_task_code("");
PointUtils.setUpdateByType(startPointObj, taskFinishedType);
pointService.updateById(startPointObj);
}
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
}

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

@@ -0,0 +1,243 @@
package org.nl.wms.sch.task_manage.task.tasks.hn;
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.system.service.notice.ISysNoticeService;
import org.nl.wms.database.material.service.IMdBaseMaterialService;
import org.nl.wms.database.material.service.dao.MdBaseMaterial;
import org.nl.wms.pdm.workorder.service.IPdmBdWorkorderService;
import org.nl.wms.pdm.workorder.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.constant.ExceptionConstant;
import org.nl.wms.sch.task_manage.constant.GeneralDefinition;
import org.nl.wms.sch.task_manage.enums.GroupBindMaterialStatusEnum;
import org.nl.wms.sch.task_manage.enums.NoticeTypeEnum;
import org.nl.wms.sch.task_manage.enums.TaskFinishedTypeEnum;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.yz.mapper.YZMapper;
import org.nl.wms.util.PointUtils;
import org.nl.wms.util.TaskUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Author: sxp
* @Description: 拆包机满料位缺料任务 货架满料位 -> CBJML01
* @Date: 2024/4/2
*/
@Slf4j
@Component("CBJQLTask")
public class CBJQLTask extends AbstractTask {
private static final String TASK_CONFIG_CODE = "CBJQLTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
private ISchBaseTaskService taskService;
@Autowired
private ISchBaseTaskconfigService taskConfigService;
@Autowired
private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
@Autowired
private IPdmBdWorkorderService workorderService;
@Autowired
private YZMapper yzMapper;
@Autowired
private ISysNoticeService noticeService;
@Autowired
IMdBaseMaterialService materialService;
@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) {
TaskUtils.setUpdateByAcs(task);
// List<String> startRegionStr = Arrays.stream(taskConfig.getStart_region_str().split(",")).collect(Collectors.toList());
// 找起点
task.setVehicle_type(GeneralDefinition.MATERIAL_CUP);
String requestParam = task.getRequest_param();
JSONObject extGroupData = JSONObject.parseObject(requestParam);
extGroupData.put("vehicle_type", task.getVehicle_type());
// SchBasePoint point = findStartPoint(startRegionStr, jsonObject);
SchBasePoint point = pointService.selectById(extGroupData.getString("start_point"));
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());
task.setRemark("");
taskService.updateById(task);
point.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(point);
pointService.updateById(point);
}
}
@Override
protected void createCompletion(SchBaseTask task) {
// 配置信息
// SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
// .eq(SchBaseTaskconfig::getConfig_code, TASK_CONFIG_CODE));
TaskUtils.setUpdateByAcs(task);
// 料盅
task.setVehicle_type(GeneralDefinition.MATERIAL_CUP);
// List<String> startRegionStr = Arrays.stream(taskConfig.getStart_region_str().split(","))
// .collect(Collectors.toList());
// 找起点
String requestParam = task.getRequest_param();
JSONObject extGroupData = JSONObject.parseObject(requestParam);
SchBasePoint point = pointService.selectById(extGroupData.getString("start_point"));
if (ObjectUtil.isEmpty(point)) {
// 消息通知
noticeService.createNotice(ExceptionConstant.NEED_POINT_NOT_FOUND,
TASK_CONFIG_CODE + task.getPoint_code2(), NoticeTypeEnum.WARN.getCode());
throw new BadRequestException(ExceptionConstant.NEED_POINT_NOT_FOUND);
}
// 找到了会把组盘标识传过来
// 设置起点并修改创建成功状态
task.setPoint_code1(point.getPoint_code());
task.setTask_status(TaskStatus.CREATED.getCode());
task.setVehicle_code(point.getVehicle_code());
task.setGroup_id(point.getGroup_id());
task.setRemark("");
taskService.save(task);
point.setIng_task_code(task.getTask_code());
PointUtils.setUpdateByAcs(point);
pointService.updateById(point);
}
/**
* 找起点业务：查找困料货架的泥料是和压机工单的泥料相同的位置
* 如果是新料口就选择新料，如果是旧料口就选旧料
* @param startRegionStr : 区域列表
* @param requestParam : 外部参数，包含条件所需的信息
* @return 点位
* @description : JSONObject获取不到就是null
*/
private SchBasePoint findStartPoint(List<String> startRegionStr, JSONObject requestParam) {
// 获取当前工单
String workorderCode = requestParam.getString("workorder_code");
PdmBdWorkorder workOrder = ObjectUtil.isNotEmpty(workorderCode)
? workorderService.getOne(new LambdaQueryWrapper<PdmBdWorkorder>()
.eq(PdmBdWorkorder::getWorkorder_code, workorderCode))
: null;
Assert.notNull(workOrder, "工单不能为空!");
MdBaseMaterial material = materialService.getById(workOrder.getMaterial_id());
// hint: redundance_material_code暂时存在着
List<SchBasePoint> points = yzMapper.findPointByYZQL(startRegionStr, material.getMaterial_code());
return ObjectUtil.isNotEmpty(points) ? points.get(0) : null;
}
@Override
protected void updateStatus(String task_code, TaskStatus status) {
// 校验任务
SchBaseTask taskObj = taskService.getByCode(task_code);
if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
throw new BadRequestException("该任务已完成!");
}
if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
throw new BadRequestException("该任务已取消!");
}
// 根据传来的类型去对任务进行操作
if (status.equals(TaskStatus.EXECUTING)) {
taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
taskObj.setRemark("执行中");
TaskUtils.setUpdateByAcs(taskObj);
taskService.updateById(taskObj);
}
if (status.equals(TaskStatus.FINISHED)) {
this.finishTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
}
if (status.equals(TaskStatus.CANCELED)) {
this.cancelTask(taskObj, TaskFinishedTypeEnum.AUTO_ACS);
}
}
@Override
public void forceFinish(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
if (ObjectUtil.isEmpty(taskObj)) {
throw new BadRequestException("该任务不存在");
}
this.finishTask(taskObj, TaskFinishedTypeEnum.MANUAL_PC);
}
@Override
public void cancel(String task_code) {
SchBaseTask taskObj = taskService.getByCode(task_code);
if (ObjectUtil.isEmpty(taskObj)) {
throw new BadRequestException("该任务不存在");
}
this.cancelTask(taskObj, TaskFinishedTypeEnum.MANUAL_PC);
}
public void finishTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
String startPoint = taskObj.getPoint_code1();
SchBasePoint startPointObj = pointService.getById(startPoint);
// 除了解锁需要将组盘表中的物料绑定载具设置为已解绑
// 起点设置空位
// 任务上有载具编码 -> 获取当前载具编码的组盘信息
SchBaseVehiclematerialgroup groupObj = vehiclematerialgroupService.getById(taskObj.getGroup_id());
// 将载具设置为已解绑
groupObj.setGroup_bind_material_status(GroupBindMaterialStatusEnum.UNBOUND.getValue());
TaskUtils.setGroupUpdateByType(groupObj, taskFinishedType);
vehiclematerialgroupService.update(groupObj);
// 释放点位，将点位设置为空位,清空数据
if (ObjectUtil.isNotEmpty(startPointObj)) {
PointUtils.setUpdateByType(startPointObj, taskFinishedType);
PointUtils.clearPoint(startPointObj);
}
// 任务修改成完成
taskObj.setTask_status(TaskStatus.FINISHED.getCode());
taskObj.setRemark(GeneralDefinition.TASK_FINISH);
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
public void cancelTask(SchBaseTask taskObj, TaskFinishedTypeEnum taskFinishedType) {
String startPoint = taskObj.getPoint_code1();
SchBasePoint startPointObj = pointService.getById(startPoint);
// 起点解锁
if (ObjectUtil.isNotEmpty(startPointObj)) {
startPointObj.setIng_task_code("");
PointUtils.setUpdateByType(startPointObj, taskFinishedType);
pointService.updateById(startPointObj);
}
taskObj.setRemark(GeneralDefinition.TASK_CANCEL);
taskObj.setTask_status(TaskStatus.CANCELED.getCode());
taskObj.setFinished_type(taskFinishedType.getCode());
TaskUtils.setUpdateByType(taskObj, taskFinishedType);
taskService.updateById(taskObj);
}
}

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

@@ -21,11 +21,13 @@ 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.constant.GeneralDefinition;
import org.nl.wms.sch.task_manage.constant.ExceptionConstant;
import org.nl.wms.sch.task_manage.constant.GeneralDefinition;
import org.nl.wms.sch.task_manage.constant.PointTypeConstant;
import org.nl.wms.sch.task_manage.constant.RegionConstant;
import org.nl.wms.sch.task_manage.enums.*;
import org.nl.wms.sch.task_manage.task.TaskType;
import org.nl.wms.sch.task_manage.task.core.TaskStatus;
import org.nl.wms.sch.task_manage.task.tasks.hn.mapper.HNMapper;
import org.nl.wms.util.PointUtils;
@@ -47,7 +49,7 @@ import java.util.stream.Collectors;
*/
@Component("HNMLTask")
public class HNMLTask extends AbstractTask {
private static final String TASK_CONFIG_CODE = "HNMLTask";
private static String TASK_CONFIG_CODE = "HNMLTask";
@Autowired
private ISchBasePointService pointService;
@Autowired
@@ -274,11 +276,9 @@ public class HNMLTask extends AbstractTask {
String deviceCode = param.getString("device_code");
BigDecimal weight = param.getBigDecimal("weight");
// 泥料号
// String materialCode = param.getString("material_code");
PdmBdWorkorder productionTask = workorderService.getByCode(param.getString("workorder_code"));
String materialCode = param.getString("material_code");
// 获取工单
// PdmBdWorkorder productionTask = workorderService.getDeviceDockingProductionTask(deviceCode);
PdmBdWorkorder productionTask = workorderService.getDeviceDockingProductionTask(deviceCode);
SchBasePoint basePoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
.eq(SchBasePoint::getPoint_code, deviceCode)
.eq(SchBasePoint::getIs_used, true));
@@ -294,10 +294,10 @@ public class HNMLTask extends AbstractTask {
groupEntity.setGroup_id(IdUtil.getSnowflake(1, 1).nextIdStr());
// 要把数据存到组盘表
groupEntity.setMaterial_id(productionTask.getMaterial_id());
groupEntity.setRedundance_material_code(productionTask.getRaw_material_code());
groupEntity.setRedundance_material_code(materialCode);
groupEntity.setCreate_id(GeneralDefinition.ACS_ID);
groupEntity.setCreate_name(GeneralDefinition.ACS_NAME);
groupEntity.setCreate_time(param.getString("create_time"));
groupEntity.setCreate_time(DateUtil.now());
groupEntity.setVehicle_code(vehicleCode);
groupEntity.setVehicle_type(vehicleType);
groupEntity.setSource_vehicle_code(basePoint.getPoint_code());
@@ -319,3 +319,4 @@ public class HNMLTask extends AbstractTask {
return groupEntity.getGroup_id();
}
}

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

@@ -173,6 +173,10 @@ public class YZQLTask extends AbstractTask {
* @description : JSONObject获取不到就是null
*/
private SchBasePoint findStartPoint(List<String> startRegionStr, JSONObject requestParam) {
String taskType = requestParam.getString("task_type");
if (!StringUtils.isEmpty(taskType) && "YZQLPTP".equals(taskType)) {
return pointService.selectById(requestParam.getString("point_code1"));
}
// 获取当前工单
String workorderCode = requestParam.getString("workorder_code");
PdmBdWorkorder workOrder = ObjectUtil.isNotEmpty(workorderCode)