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

add:手持大料箱

Browse Source
This commit is contained in:
liuxy
2025-09-08 09:09:37 +08:00
committed by gengby
parent 763216bf71
commit 422dabd53c
33 changed files with 1659 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/basedata_manage/service/dao/MdMeMaterialbase.java
View File

@@ -182,5 +182,10 @@ public class MdMeMaterialbase implements Serializable {
*/
private Integer quality_time;
/**
* 执行标准
*/
private String execution_stand;
}

1
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/basedata_manage/service/impl/BsrealStorattrServiceImpl.java
View File

@@ -116,7 +116,6 @@ public class BsrealStorattrServiceImpl extends ServiceImpl<BsrealStorattrMapper,
dto.setUpdate_time(now);
dto.setCreate_time(now);
//TODO
dto.setSyscompanyid(9L);
dto.setSysdeptid(9L);
dto.setSysownerid(9L);

12
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/ext/controller/AcsToWmsController.java
View File

@@ -1,6 +1,7 @@
package org.nl.wms.ext.controller;
import cn.dev33.satoken.annotation.SaIgnore;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.logging.annotation.Log;
import org.nl.wms.ext.service.AcsToWmsService;
@@ -30,8 +31,15 @@ public class AcsToWmsController {
@PostMapping("/status")
@Log(value = "ACS给WMS反馈任务状态")
@SaIgnore
public ResponseEntity<Object> receiveTaskStatusAcs(@RequestBody String string) {
return new ResponseEntity<>(acsToWmsService.receiveTaskStatusAcs(string), HttpStatus.OK);
public ResponseEntity<Object> receiveTaskStatusAcs(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(acsToWmsService.receiveTaskStatusAcs(whereJson), HttpStatus.OK);
}
@PostMapping("/resultCar")
@Log(value = "ACS给WMS反馈车号")
@SaIgnore
public ResponseEntity<Object> resultCar(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(acsToWmsService.resultCar(whereJson), HttpStatus.OK);
}
}

10
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/ext/enums/EXTConstant.java
View File

@@ -21,4 +21,14 @@ public class EXTConstant {
* ACS下发任务接口地址
*/
public final static String SEND_TASK_ACS_API = "api/wms/task";
/**
* ACS下发 取放货确认
*/
public final static String CONFIRM_AGV_ACS_API = "api/wms/confirmAgv";
/**
* ACS下发 获取称重信息
*/
public final static String GET_WEIGH_ACS_API = "api/wms/getWeigh";
}

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

@@ -1,5 +1,8 @@
package org.nl.wms.ext.service;
import com.alibaba.fastjson.JSONObject;
import org.nl.wms.ext.util.BaseResponse;
import java.util.Map;
/**
@@ -16,8 +19,20 @@ public interface AcsToWmsService {
* ACS客户端--->WMS服务端
* ACS向WMS反馈任务状态
*
* @param string ACS反馈的任务数组
* @return Map<String, Object>
* @param whereJson ACS反馈的任务数组
* @return BaseResponse
*/
Map<String, Object> receiveTaskStatusAcs(String string);
BaseResponse receiveTaskStatusAcs(JSONObject whereJson);
/**
* ACS客户端--->WMS服务端
* ACS给WMS反馈车号
* @param whereJson {
* task_id: 任务标识
* task_code: 任务编码
* car_no: 车号
* }
* @return BaseResponse
*/
BaseResponse resultCar(JSONObject whereJson);
}

10
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/ext/service/WmsToAcsService.java
View File

@@ -30,4 +30,14 @@ public interface WmsToAcsService {
* @return AcsResponse
*/
AcsResponse getWeighAcs(JSONObject whereJson);
/**
* 确认取放货
* @param whereJson {
* task_type: 1-取货确认 2- 放货确认
* task_code: 任务号
* }
* @return AcsResponse
*/
AcsResponse confirmAgv(JSONObject whereJson);
}

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

@@ -1,12 +1,13 @@
package org.nl.wms.ext.service.impl;
import com.alibaba.fastjson.JSONArray;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.exception.BadRequestException;
import org.nl.wms.ext.enums.ResultAcsStatus;
import org.nl.wms.ext.service.AcsToWmsService;
import org.nl.wms.ext.util.BaseResponse;
import org.nl.wms.sch_manage.enums.TaskStatus;
import org.nl.wms.sch_manage.service.ISchBaseTaskService;
import org.nl.wms.sch_manage.service.dao.SchBaseTask;
@@ -15,11 +16,9 @@ import org.nl.wms.sch_manage.service.util.TaskFactory;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
@@ -55,52 +54,77 @@ public class AcsToWmsServiceImpl implements AcsToWmsService {
@Override
@Transactional(rollbackFor = Exception.class)
@SneakyThrows
public Map<String, Object> receiveTaskStatusAcs(String string) {
log.info("acs向lms反馈任务状态，请求参数：--------------------------------------" + string);
JSONArray array = JSONArray.parseArray(string);
//返回处理失败的任务
JSONArray errArr = new JSONArray();
for (int i = 0; i < array.size(); i++) {
JSONObject row = array.getJSONObject(i);
String task_id = row.getString("task_id");
RLock lock = redissonClient.getLock(task_id);
boolean tryLock = lock.tryLock(0, TimeUnit.SECONDS);
try {
if (tryLock) {
SchBaseTask taskObj = iSchBaseTaskService.getById(task_id);
// acs反馈的任务类型
String acs_task_status = row.getString("task_status");
TaskStatus status;
if (ResultAcsStatus.EXECUTING.getCode().equals(acs_task_status)) {
// 执行中
status = TaskStatus.EXECUTING;
} else if (ResultAcsStatus.FINISHED.getCode().equals(acs_task_status)) {
// 完成
status = TaskStatus.FINISHED;
iSchBaseTaskService.updateById(taskObj);
} else {
// 取消
status = TaskStatus.CANCELED;
}
// 根据配置编码执行相关配置内的方法
AbstractTask task = taskFactory.getTask(taskObj.getConfig_code());
task.updateTaskStatus(taskObj.getTask_code(),status);
public BaseResponse receiveTaskStatusAcs(JSONObject whereJson) {
log.info("acs向lms反馈任务状态，请求参数：--------------------------------------" + whereJson.toString());
// 任务标识
String task_id = whereJson.getString("task_id");
// acs反馈的任务类型
String acs_task_status = whereJson.getString("task_status");
RLock lock = redissonClient.getLock(task_id);
boolean tryLock = lock.tryLock(0, TimeUnit.SECONDS);
try {
if (tryLock) {
SchBaseTask taskObj = iSchBaseTaskService.getById(task_id);
TaskStatus status;
if (ResultAcsStatus.EXECUTING.getCode().equals(acs_task_status)) {
// 执行中
status = TaskStatus.EXECUTING;
// 更新车号
} else if (ResultAcsStatus.FINISHED.getCode().equals(acs_task_status)) {
// 完成
status = TaskStatus.FINISHED;
} else {
throw new BadRequestException("任务标识为：" + task_id + "的任务正在操作中！");
}
} finally {
if (tryLock) {
lock.unlock();
// 取消
status = TaskStatus.CANCELED;
}
// 根据配置编码执行相关配置内的方法
AbstractTask task = taskFactory.getTask(taskObj.getConfig_code());
task.updateTaskStatus(taskObj.getTask_code(), status);
} else {
throw new BadRequestException("任务标识为：" + task_id + "的任务正在操作中！");
}
} finally {
if (tryLock) {
lock.unlock();
}
}
JSONObject result = new JSONObject();
result.put("status", HttpStatus.OK.value());
result.put("message", "任务状态反馈成功!");
result.put("data", new JSONObject());
result.put("errArr", errArr);
log.info("acs向lms反馈任务状态，返回参数：--------------------------------------" + result.toString());
return result;
log.info("acs向lms反馈任务状态，返回参数：--------------------------------------" + BaseResponse.responseOk().toString());
return BaseResponse.responseOk();
}
@Override
@Transactional(rollbackFor = Exception.class)
@SneakyThrows
public BaseResponse resultCar(JSONObject whereJson) {
log.info("acs向lms反馈任务车号，请求参数：--------------------------------------" + whereJson.toString());
// 任务标识
String task_id = whereJson.getString("task_id");
// 车号
String car_no = whereJson.getString("car_no");
if (ObjectUtil.isEmpty(car_no)) {
throw new BadRequestException("车号不能为空！");
}
RLock lock = redissonClient.getLock(task_id);
boolean tryLock = lock.tryLock(0, TimeUnit.SECONDS);
try {
if (tryLock) {
SchBaseTask taskObj = iSchBaseTaskService.getById(task_id);
taskObj.setCar_no(car_no);
iSchBaseTaskService.updateById(taskObj);
} else {
throw new BadRequestException("任务标识为：" + task_id + "的任务正在操作中！");
}
} finally {
if (tryLock) {
lock.unlock();
}
}
return BaseResponse.responseOk();
}
}

8
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/ext/service/impl/WmsToAcsServiceImpl.java
View File

@@ -30,6 +30,12 @@ public class WmsToAcsServiceImpl implements WmsToAcsService {
@Override
public AcsResponse getWeighAcs(JSONObject whereJson) {
return null;
return AcsUtil.notifyAcs(EXTConstant.GET_WEIGH_ACS_API, whereJson);
}
@Override
public AcsResponse confirmAgv(JSONObject whereJson) {
return AcsUtil.notifyAcs(EXTConstant.CONFIRM_AGV_ACS_API, whereJson);
}
}

47
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/ext/util/AcsUtil.java
View File

@@ -80,4 +80,51 @@ public class AcsUtil {
return resultAcs;
}
/**
* 调用acs
* @param api acs地址
* @param param 下发参数
* @return AcsResponse
*/
public static AcsResponse notifyAcs(String api, JSONObject param) {
log.info("下发acs接口"+api+"的输入参数为：-------------------" + param.toString());
// 返回参数
AcsResponse resultAcs;
// 系统参数类
SysParamServiceImpl sysParamService = SpringContextHolder.getBean(SysParamServiceImpl.class);
//判断是否连接ACS系统
Param isConnectAcs = sysParamService.findByCode(SysParamConstant.IS_CONNECT_ACS);
if (ObjectUtil.isEmpty(isConnectAcs)) {
return AcsResponse.requestError("系统参数表中：" + SysParamConstant.IS_CONNECT_ACS + "不存在");
}
if (isConnectAcs.getValue().equals(IOSConstant.IS_DELETE_NO)) {
return AcsResponse.requestOkMessage("下发成功，未连接ACS系统!");
}
//ACS地址
Param acsUrlParam = sysParamService.findByCode(SysParamConstant.ACS_URL);
if (ObjectUtil.isEmpty(acsUrlParam)) {
return AcsResponse.requestError("系统参数表中：" + SysParamConstant.ACS_URL + "不存在");
}
String url = acsUrlParam.getValue() + api;
try {
String resultMsg = HttpRequest.post(url)
.body(String.valueOf(param))
.execute().body();
// 格式转换
JSONObject result = JSONObject.parseObject(resultMsg);
resultAcs = JSONObject.toJavaObject(result, AcsResponse.class);
log.info("下发ACS任务的输出参数为：-------------------" + resultMsg);
} catch (Exception e) {
//网络不通
String msg = e.getMessage();
log.error("连接失败：{}", msg);
return AcsResponse.requestError("网络不通,操作失败!");
}
return resultAcs;
}
}

6
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/ext/util/BaseResponse.java
View File

@@ -56,9 +56,8 @@ public class BaseResponse implements Serializable {
return response;
}
public static BaseResponse responseOk(String requestNo) {
public static BaseResponse responseOk() {
BaseResponse response = new BaseResponse();
response.setRequestNo(requestNo);
response.setStatus(HttpStatus.HTTP_OK);
response.setMessage("请求成功");
response.setResponseDate(DateUtil.now());
@@ -84,9 +83,8 @@ public class BaseResponse implements Serializable {
return response;
}
public static BaseResponse responseError(String requestNo, String message) {
public static BaseResponse responseError(String message) {
BaseResponse response = new BaseResponse();
response.setRequestNo(requestNo);
response.setStatus(HttpStatus.HTTP_BAD_REQUEST);
response.setMessage(message);
response.setResponseDate(DateUtil.now());

2
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/general_management/service/impl/PdaInGroupBoxServiceImpl.java
View File

@@ -78,7 +78,7 @@ public class PdaInGroupBoxServiceImpl implements PdaInGroupBoxService {
// 物料编码
String mater_code = split[0];
// 烘干次数
String bake_num = split[10];
String bake_num = split[7];
// 校验物料
MdMeMaterialbase materDao = iMdMeMaterialbaseService.getById(groupDao.getMaterial_id());
if (!materDao.getMaterial_code().equals(mater_code)) {

144
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/large_material_box/controller/PdaLargeMaterialBoxController.java Normal file
View File

@@ -0,0 +1,144 @@
package org.nl.wms.pda.large_material_box.controller;
import cn.dev33.satoken.annotation.SaIgnore;
import com.alibaba.fastjson.JSONObject;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.logging.annotation.Log;
import org.nl.wms.pda.large_material_box.service.PdaLargeMaterialBoxService;
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;
/**
* @Description TODO
* @Author Gengby
* @Date 2025/9/2
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/pda/largeMaterialBox")
@Slf4j
public class PdaLargeMaterialBoxController {
@Autowired
private PdaLargeMaterialBoxService pdaLargeMaterialBoxService;
@PostMapping("/bindEmptyVehicle")
@Log("大料箱-绑定空载具")
@SaIgnore
public ResponseEntity<Object> bindEmptyVehicle(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.bindEmptyVehicle(reqParam), HttpStatus.OK);
}
@PostMapping("/unBindEmptyVehicle")
@Log("大料箱-解绑空载具")
@SaIgnore
public ResponseEntity<Object> unBindEmptyVehicle(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.unBindEmptyVehicle(reqParam), HttpStatus.OK);
}
@PostMapping("/materialBoxInConfirm")
@Log("大料箱-料箱入库-确认入库")
@SaIgnore
public ResponseEntity<Object> materialBoxInConfirm(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.materialBoxInConfirm(reqParam), HttpStatus.OK);
}
@PostMapping("/materialInConfirm")
@Log("大料箱-物料入库-确认入库")
@SaIgnore
public ResponseEntity<Object> materialInConfirm(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.materialInConfirm(reqParam), HttpStatus.OK);
}
@PostMapping("/materialBoxOutConfirm")
@Log("大料箱-大料箱出库-确认出库")
@SaIgnore
public ResponseEntity<Object> materialBoxOutConfirm(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.materialBoxOutConfirm(reqParam), HttpStatus.OK);
}
@PostMapping("/returnConfirm")
@Log("大料箱-退库确认-确认退回")
@SaIgnore
public ResponseEntity<Object> returnConfirm(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.returnConfirm(reqParam), HttpStatus.OK);
}
@PostMapping("/materialBoxMoveConfirm")
@Log("大料箱-大料箱移库-确认移库")
@SaIgnore
public ResponseEntity<Object> materialBoxMoveConfirm(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.materialBoxMoveConfirm(reqParam), HttpStatus.OK);
}
@PostMapping("/materialBoxInventoryConfirm")
@Log("大料箱-大料箱盘库-确认盘点")
@SaIgnore
public ResponseEntity<Object> materialBoxInventoryConfirm(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.materialBoxInventoryConfirm(reqParam), HttpStatus.OK);
}
@PostMapping("/getGroupInfo")
@Log("获取组盘状态的组盘信息信息")
@SaIgnore
public ResponseEntity<Object> getGroupInfo(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.getGroupInfo(reqParam), HttpStatus.OK);
}
@PostMapping("/getInGroupInfo")
@Log("获取入库状态的组盘信息信息")
@SaIgnore
public ResponseEntity<Object> getInGroupInfo(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.getInGroupInfotGroupInfo(reqParam), HttpStatus.OK);
}
@PostMapping("/getOutGroupInfo")
@Log("获取出库状态的组盘信息信息")
@SaIgnore
public ResponseEntity<Object> getOutGroupInfo(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.getOutGroupInfo(reqParam), HttpStatus.OK);
}
@PostMapping("/getMaterialInfo")
@Log("获取物料信息")
@SaIgnore
public ResponseEntity<Object> getMaterialInfo(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.getMaterialInfo(reqParam), HttpStatus.OK);
}
@PostMapping("/getIoDisDocumentInfo")
@Log("获取出入库单据分配信息")
@SaIgnore
public ResponseEntity<Object> getIoDisDocumentInfo(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.getIoDisDocumentInfo(reqParam), HttpStatus.OK);
}
@PostMapping("/getMoveDocumentInfo")
@Log("获取移库单据信息")
@SaIgnore
public ResponseEntity<Object> getMoveDocumentInfo(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.getMoveDocumentInfo(reqParam), HttpStatus.OK);
}
@PostMapping("/getCheckDocumentInfo")
@Log("获取盘点单据信息")
@SaIgnore
public ResponseEntity<Object> getCheckDocumentInfo(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.getCheckDocumentInfo(reqParam), HttpStatus.OK);
}
@PostMapping("/getInvInfoQty")
@Log("获取库存数量")
@SaIgnore
public ResponseEntity<Object> getInvInfoQty(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaLargeMaterialBoxService.getInvInfoQty(reqParam), HttpStatus.OK);
}
}

124
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/large_material_box/service/PdaLargeMaterialBoxService.java Normal file
View File

@@ -0,0 +1,124 @@
package org.nl.wms.pda.large_material_box.service;
import com.alibaba.fastjson.JSONObject;
import org.nl.wms.pda.util.PdaResponse;
/**
* @Description TODO
* @Author Gengby
* @Date 2025/9/2
*/
public interface PdaLargeMaterialBoxService {
/**
* 绑定空载具
* @param reqParam
* @return
*/
PdaResponse bindEmptyVehicle(JSONObject reqParam);
/**
* 解绑空载具
* @param reqParam
* @return
*/
PdaResponse unBindEmptyVehicle(JSONObject reqParam);
/**
* 大料箱入库-确认入库
* @param reqParam
* @return
*/
PdaResponse materialBoxInConfirm(JSONObject reqParam);
/**
* 物料入库-确认入库
* @param reqParam
* @return
*/
PdaResponse materialInConfirm(JSONObject reqParam);
/**
* 大料箱出库
* @param reqParam
* @return
*/
PdaResponse materialBoxOutConfirm(JSONObject reqParam);
/**
* 退库确认-确认退回
* @param reqParam
* @return
*/
PdaResponse returnConfirm(JSONObject reqParam);
/**
* 大料箱-大料箱移库-确认移库
* @param reqParam
* @return
*/
PdaResponse materialBoxMoveConfirm(JSONObject reqParam);
/**
* 大料箱-大料箱盘库-确认盘点
* @param reqParam
* @return
*/
PdaResponse materialBoxInventoryConfirm(JSONObject reqParam);
/**
* 获取组盘状态的组盘信息
* @param reqParam
* @return
*/
PdaResponse getGroupInfo(JSONObject reqParam);
/**
* 获取入库状态的组盘信息
* @param reqParam
* @return
*/
PdaResponse getInGroupInfotGroupInfo(JSONObject reqParam);
/**
* 获取出库状态的组盘信息
* @param reqParam
* @return
*/
PdaResponse getOutGroupInfo(JSONObject reqParam);
/**
* 获取物料信息
* @param reqParam
* @return
*/
PdaResponse getMaterialInfo(JSONObject reqParam);
/**
* 获取出入库单据信息
* @param reqParam
* @return
*/
PdaResponse getIoDisDocumentInfo(JSONObject reqParam);
/**
* 获取移库单据信息
* @param reqParam
* @return
*/
PdaResponse getMoveDocumentInfo(JSONObject reqParam);
/**
* 获取盘点单据信息
* @param reqParam
* @return
*/
PdaResponse getCheckDocumentInfo(JSONObject reqParam);
/**
* 获取库存信息
* @param reqParam
* @return
*/
PdaResponse getInvInfoQty(JSONObject reqParam);
}

639
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/large_material_box/service/impl/PadLargeMaterialBoxServiceImpl.java Normal file
View File

@@ -0,0 +1,639 @@
package org.nl.wms.pda.large_material_box.service.impl;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.nl.common.exception.BadRequestException;
import org.nl.common.utils.IdUtil;
import org.nl.common.utils.SecurityUtils;
import org.nl.wms.basedata_manage.service.*;
import org.nl.wms.basedata_manage.service.dao.*;
import org.nl.wms.pda.large_material_box.service.PdaLargeMaterialBoxService;
import org.nl.wms.pda.util.PdaResponse;
import org.nl.wms.pdm_manage.enums.BomEnum;
import org.nl.wms.pdm_manage.service.IPdmBomCallMaterialDtlService;
import org.nl.wms.pdm_manage.service.IPdmBomCallMaterialService;
import org.nl.wms.pdm_manage.service.dao.PdmBomCallMaterial;
import org.nl.wms.pdm_manage.service.dao.PdmBomCallMaterialDtl;
import org.nl.wms.warehouse_management.enums.IOSEnum;
import org.nl.wms.warehouse_management.service.IMdPbGroupplateService;
import org.nl.wms.warehouse_management.service.IOutBillService;
import org.nl.wms.warehouse_management.service.IRawAssistIStorService;
import org.nl.wms.warehouse_management.service.dao.GroupPlate;
import org.nl.wms.warehouse_management.service.dao.IOStorInv;
import org.nl.wms.warehouse_management.service.dao.IOStorInvDis;
import org.nl.wms.warehouse_management.service.dao.IOStorInvDtl;
import org.nl.wms.warehouse_management.service.dao.mapper.IOStorInvDisMapper;
import org.nl.wms.warehouse_management.service.dao.mapper.IOStorInvDtlMapper;
import org.nl.wms.warehouse_management.service.dao.mapper.StIvtCheckdtlMapper;
import org.nl.wms.warehouse_management.service.dao.mapper.StIvtMoveinvdtlMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @Description TODO
* @Author Gengby
* @Date 2025/9/2
*/
@Service
public class PadLargeMaterialBoxServiceImpl implements PdaLargeMaterialBoxService {
@Autowired
private IMdPbGroupplateService mdPbGroupplateService;
@Autowired
private IMdMeMaterialbaseService mdMeMaterialbaseService;
@Autowired
private IMdCsSupplierbaseService mdCsSupplierbaseService;
@Autowired
private IOutBillService iOutBillService;
@Autowired
private IOStorInvDisMapper ioStorInvDisMapper;
@Autowired
private IOStorInvDtlMapper ioStorInvDtlMapper;
@Autowired
private IMdPbStoragevehicleextService mdPbStoragevehicleextService;
@Autowired
private IStructattrService structattrService;
@Autowired
private IPdmBomCallMaterialService pdmBomCallMaterialService;
@Autowired
private StIvtMoveinvdtlMapper stIvtMoveinvdtlMapper;
@Autowired
private StIvtCheckdtlMapper stIvtCheckdtlMapper;
@Autowired
private IMdPbStoragevehicleinfoService mdPbStoragevehicleinfoService;
@Autowired
private IRawAssistIStorService rawAssistIStorService;
@Autowired
private IPdmBomCallMaterialDtlService pdmBomCallMaterialDtlService;
@Override
@Transactional(rollbackFor = Exception.class)
public PdaResponse bindEmptyVehicle(JSONObject reqParam) {
Assert.notEmpty(reqParam, "请求参数不能为空!");
String struct_code = reqParam.getString("struct_code");
Assert.notEmpty(struct_code, "仓位编码不能为空！");
String storagevehicle_code = reqParam.getString("storagevehicle_code");
Assert.notEmpty(storagevehicle_code, "载具编码不能为空！");
Structattr structattr = structattrService.getOne(new LambdaQueryWrapper<Structattr>()
.eq(Structattr::getStruct_code, struct_code)
.eq(Structattr::getIs_delete, "0")
.eq(Structattr::getIs_used, "1"));
if (ObjectUtil.isEmpty(structattr)) {
throw new BadRequestException("仓位信息不存在或未启用!");
}
MdPbStoragevehicleinfo storagevehicleinfo = mdPbStoragevehicleinfoService.getOne(new LambdaQueryWrapper<MdPbStoragevehicleinfo>()
.eq(MdPbStoragevehicleinfo::getStoragevehicle_code, storagevehicle_code)
.eq(MdPbStoragevehicleinfo::getIs_delete, "0")
.eq(MdPbStoragevehicleinfo::getIs_used, "1"));
if (ObjectUtil.isEmpty(storagevehicleinfo)) {
throw new BadRequestException("载具信息不存在或未启用!");
}
structattr.setStoragevehicle_code(storagevehicle_code);
structattr.setStoragevehicle_type(storagevehicleinfo.getStoragevehicle_type());
structattr.setIs_emptyvehicle("1");
structattr.setUpdate_optid(SecurityUtils.getCurrentUserId());
structattr.setUpdate_optname(SecurityUtils.getCurrentNickName());
structattr.setUpdate_time(DateUtil.now());
structattrService.updateById(structattr);
return PdaResponse.requestOk();
}
@Override
@Transactional(rollbackFor = Exception.class)
public PdaResponse unBindEmptyVehicle(JSONObject reqParam) {
Assert.notEmpty(reqParam, "请求参数不能为空!");
String struct_code = reqParam.getString("struct_code");
String storagevehicle_code = reqParam.getString("storagevehicle_code");
Assert.notEmpty(storagevehicle_code, "载具编码不能为空！");
Structattr structattr = structattrService.getOne(new LambdaQueryWrapper<Structattr>()
.eq(Structattr::getStruct_code, struct_code)
.or()
.eq(Structattr::getStoragevehicle_code, storagevehicle_code)
.eq(Structattr::getIs_delete, "0")
.eq(Structattr::getIs_used, "1"));
if (ObjectUtil.isEmpty(structattr)) {
throw new BadRequestException("仓位信息不存在或未启用!");
}
if (!StrUtil.equals(structattr.getIs_emptyvehicle(), "0")) {
throw new BadRequestException("当前点位或载具不是空载具，无法解绑!");
}
structattr.setStoragevehicle_code("");
structattr.setIs_emptyvehicle("0");
structattr.setUpdate_optid(SecurityUtils.getCurrentUserId());
structattr.setUpdate_optname(SecurityUtils.getCurrentNickName());
structattr.setUpdate_time(DateUtil.now());
structattrService.updateById(structattr);
return PdaResponse.requestOk();
}
@Override
@Transactional(rollbackFor = Exception.class)
public PdaResponse materialBoxInConfirm(JSONObject reqParam) {
//生成出入库单主表明细表分配明细表
Assert.notEmpty(reqParam, "请求参数不能为空!");
String bill_type = reqParam.getString("bill_type");
Assert.notEmpty(bill_type, "单据类型不能为空！");
String struct_code = reqParam.getString("struct_code");
Assert.notEmpty(struct_code, "仓位编码不能为空！");
Structattr structattr = structattrService.getOne(new LambdaQueryWrapper<Structattr>()
.eq(Structattr::getStruct_code, struct_code));
Assert.notNull(structattr, "仓位信息不存在！");
JSONArray tableData = reqParam.getJSONArray("tableData");
Assert.notEmpty(tableData, "组盘信息数据不能为空！");
JSONObject param = new JSONObject();
param.put("bill_type", bill_type);
param.put("biz_date", DateUtil.today());
param.put("struct_id", structattr.getStruct_id());
param.put("struct_code", structattr.getStruct_code());
param.put("struct_name", structattr.getStruct_name());
param.put("stor_id", structattr.getStor_id());
param.put("stor_code", structattr.getStor_code());
param.put("stor_name", structattr.getStor_name());
param.put("tableData", tableData);
rawAssistIStorService.insertPdaDtl(param);
//更新组盘表组盘状态为入库状态
JSONObject row = tableData.getJSONObject(0);
String group_id = row.getString("group_id");
GroupPlate groupPlate = mdPbGroupplateService.getById(group_id);
groupPlate.setStatus(IOSEnum.GROUP_PLATE_STATUS.code("入库"));
mdPbGroupplateService.updateById(groupPlate);
MdPbStoragevehicleinfo storagevehicleinfo = mdPbStoragevehicleinfoService.getByCode(groupPlate.getStoragevehicle_code());
Assert.notNull(storagevehicleinfo, "载具信息不存在！");
//更新仓位表载具信息
structattr.setStoragevehicle_code(storagevehicleinfo.getStoragevehicle_code());
structattr.setStoragevehicle_type(storagevehicleinfo.getStoragevehicle_type());
structattr.setIs_emptyvehicle("0");
structattr.setUpdate_optid(SecurityUtils.getCurrentUserId());
structattr.setUpdate_optname(SecurityUtils.getCurrentNickName());
structattr.setUpdate_time(DateUtil.now());
structattrService.updateById(structattr);
//生成库存信息
MdPbStoragevehicleext mdPbStoragevehicleext = new MdPbStoragevehicleext();
mdPbStoragevehicleext.setStoragevehicleext_id(IdUtil.getStringId());
mdPbStoragevehicleext.setStoragevehicle_code(storagevehicleinfo.getStoragevehicle_code());
mdPbStoragevehicleext.setMaterial_id(groupPlate.getMaterial_id());
mdPbStoragevehicleext.setPcsn(groupPlate.getPcsn());
mdPbStoragevehicleext.setQty_unit_id(groupPlate.getQty_unit_id());
mdPbStoragevehicleext.setQty_unit_name(groupPlate.getQty_unit_name());
mdPbStoragevehicleext.setCanuse_qty(groupPlate.getQty());
mdPbStoragevehicleext.setFrozen_qty(BigDecimal.ZERO);
mdPbStoragevehicleext.setUpdate_optid(SecurityUtils.getCurrentUserId());
mdPbStoragevehicleext.setUpdate_optname(SecurityUtils.getCurrentNickName());
mdPbStoragevehicleext.setInsert_time(DateUtil.now());
mdPbStoragevehicleext.setUpdate_time(DateUtil.now());
mdPbStoragevehicleextService.save(mdPbStoragevehicleext);
return PdaResponse.requestOk();
}
@Override
public PdaResponse materialInConfirm(JSONObject reqParam) {
Assert.notEmpty(reqParam, "请求参数不能为空!");
String bill_type = reqParam.getString("bill_type");
Assert.notEmpty(bill_type, "单据类型不能为空！");
String struct_code = reqParam.getString("struct_code");
Assert.notEmpty(struct_code, "仓位编码不能为空！");
Structattr structattr = structattrService.getOne(new LambdaQueryWrapper<Structattr>()
.eq(Structattr::getStruct_code, struct_code));
Assert.notNull(structattr, "仓位信息不存在！");
JSONArray tableData = reqParam.getJSONArray("tableData");
Assert.notEmpty(tableData, "组盘信息数据不能为空！");
JSONObject material_info = reqParam.getJSONObject("material_info");
Assert.notNull(material_info, "新加物料信息不能为空！");
String material_code = material_info.getString("material_code");
Assert.notEmpty(material_code, "物料编码不能为空！");
String material_qty = material_info.getString("material_qty");
Assert.notEmpty(material_qty, "新增物料数量不能为空！");
//物料数量必须大于0
try {
BigDecimal qty = new BigDecimal(material_qty);
if (qty.compareTo(BigDecimal.ZERO) <= 0) {
throw new BadRequestException("物料数量必须大于0！");
}
} catch (NumberFormatException e) {
throw new BadRequestException("物料数量格式不正确！");
}
//校验加物料是否一致
JSONObject groupJson = tableData.getJSONObject(0);
if (!StrUtil.equals(groupJson.getString("material_code"), material_code)) {
throw new BadRequestException("新加物料信息与原物料信息不一致！");
}
//新增入库单及入库单明细
JSONObject param = new JSONObject();
param.put("bill_type", bill_type);
param.put("biz_date", DateUtil.today());
param.put("struct_id", structattr.getStruct_id());
param.put("struct_code", structattr.getStruct_code());
param.put("struct_name", structattr.getStruct_name());
param.put("stor_id", structattr.getStor_id());
param.put("stor_code", structattr.getStor_code());
param.put("stor_name", structattr.getStor_name());
param.put("tableData", tableData);
param.put("material_qty", material_qty);
rawAssistIStorService.insertPdaDtl(param);
//更新组盘表组盘数量
JSONObject row = tableData.getJSONObject(0);
String group_id = row.getString("group_id");
GroupPlate groupPlate = mdPbGroupplateService.getById(group_id);
groupPlate.setQty(groupPlate.getQty().add(new BigDecimal(material_qty)));
mdPbGroupplateService.updateById(groupPlate);
//更新库存数量
MdPbStoragevehicleext storagevehicleext = mdPbStoragevehicleextService.getOne(new LambdaQueryWrapper<MdPbStoragevehicleext>()
.eq(MdPbStoragevehicleext::getStoragevehicle_code, groupPlate.getStoragevehicle_code()));
storagevehicleext.setCanuse_qty(storagevehicleext.getCanuse_qty().add(new BigDecimal(material_qty)));
mdPbStoragevehicleextService.updateById(storagevehicleext);
return PdaResponse.requestOk();
}
@Override
@Transactional(rollbackFor = Exception.class)
public PdaResponse materialBoxOutConfirm(JSONObject reqParam) {
Assert.notEmpty(reqParam, "请求参数不能为空!");
String iostorinvdis_id = reqParam.getString("iostorinvdis_id");
Assert.notEmpty(iostorinvdis_id, "分配明细ID不能为空！");
String storagevehicle_code = reqParam.getString("storagevehicle_code");
Assert.notEmpty(storagevehicle_code, "载具编码不能为空！");
String struct_code = reqParam.getString("struct_code");
Assert.notEmpty(struct_code, "仓位编码不能为空！");
String ts_storagevehicle_code = reqParam.getString("ts_storagevehicle_code");
String plan_qty = reqParam.getString("plan_qty");
Assert.notEmpty(plan_qty, "计划数量不能为空！");
if (StrUtil.isBlank(ts_storagevehicle_code)) {
//如果配送载具为空，则直接清除库存，将仓位表中的载具号清除，并标记为空载具，组盘信息更新为出库
MdPbStoragevehicleext storagevehicleext = mdPbStoragevehicleextService.getOne(new LambdaQueryWrapper<MdPbStoragevehicleext>()
.eq(MdPbStoragevehicleext::getStoragevehicle_code, storagevehicle_code));
if (storagevehicleext != null) {
mdPbStoragevehicleextService.removeById(storagevehicleext.getStoragevehicleext_id());
}
Structattr structattr = structattrService.findByCode(struct_code);
if (structattr != null) {
structattr.setIs_emptyvehicle("1");
structattr.setUpdate_optid(SecurityUtils.getCurrentUserId());
structattr.setUpdate_optname(SecurityUtils.getCurrentNickName());
structattr.setUpdate_time(DateUtil.now());
structattrService.updateById(structattr);
}
GroupPlate groupPlate = mdPbGroupplateService.getOne(new LambdaQueryWrapper<GroupPlate>()
.eq(GroupPlate::getStoragevehicle_code, storagevehicle_code));
if (groupPlate != null) {
groupPlate.setStatus(IOSEnum.GROUP_PLATE_STATUS.code("出库"));
mdPbGroupplateService.updateById(groupPlate);
}
} else {
//如果配送载具不为空，则更新库存，更新组盘信息中的数量
GroupPlate groupPlate = mdPbGroupplateService.getOne(new LambdaQueryWrapper<GroupPlate>()
.eq(GroupPlate::getStoragevehicle_code, storagevehicle_code));
if (groupPlate != null) {
groupPlate.setStatus(IOSEnum.GROUP_PLATE_STATUS.code("出库"));
groupPlate.setQty(groupPlate.getQty().subtract(new BigDecimal(plan_qty)));
mdPbGroupplateService.updateById(groupPlate);
}
MdPbStoragevehicleext storagevehicleext = mdPbStoragevehicleextService.getOne(new LambdaQueryWrapper<MdPbStoragevehicleext>()
.eq(MdPbStoragevehicleext::getStoragevehicle_code, ts_storagevehicle_code));
if (storagevehicleext != null) {
storagevehicleext.setCanuse_qty(storagevehicleext.getCanuse_qty().subtract(new BigDecimal(plan_qty)));
mdPbStoragevehicleextService.updateById(storagevehicleext);
}
}
IOStorInvDis ioStorInvDis = ioStorInvDisMapper.selectById(iostorinvdis_id);
if (ioStorInvDis != null) {
ioStorInvDis.setWork_status(IOSEnum.INBILL_DIS_STATUS.code("完成"));
ioStorInvDisMapper.updateById(ioStorInvDis);
List<IOStorInvDis> ioStorInvDisList = ioStorInvDisMapper.selectList(new LambdaQueryWrapper<IOStorInvDis>()
.eq(IOStorInvDis::getIostorinvdtl_id, ioStorInvDis.getIostorinvdtl_id())
.lt(IOStorInvDis::getWork_status, IOSEnum.INBILL_DIS_STATUS.code("完成")));
if (ioStorInvDisList.size() == 0) {
//更新单据状态为完成
IOStorInvDtl ioStorInvDtl = ioStorInvDtlMapper.selectById(ioStorInvDis.getIostorinvdtl_id());
if (ioStorInvDtl != null) {
ioStorInvDtl.setBill_status(IOSEnum.BILL_STATUS.code("完成"));
ioStorInvDtlMapper.updateById(ioStorInvDtl);
List<IOStorInvDtl> storInvDtlList = ioStorInvDtlMapper.selectList(new LambdaQueryWrapper<IOStorInvDtl>()
.eq(IOStorInvDtl::getIostorinv_id, ioStorInvDtl.getIostorinv_id())
.lt(IOStorInvDtl::getBill_status, IOSEnum.BILL_STATUS.code("完成")));
if (storInvDtlList.size() == 0) {
IOStorInv ioStorInv = iOutBillService.getById(ioStorInvDtl.getIostorinv_id());
if (ioStorInv != null) {
ioStorInv.setBill_status(IOSEnum.BILL_STATUS.code("完成"));
iOutBillService.updateById(ioStorInv);
}
}
}
}
}
return PdaResponse.requestOk();
}
@Override
@Transactional(rollbackFor = Exception.class)
public PdaResponse returnConfirm(JSONObject reqParam) {
Assert.notEmpty(reqParam, "请求参数不能为空!");
String storagevehicle_code = reqParam.getString("storagevehicle_code");
Assert.notEmpty(storagevehicle_code, "载具编码不能为空！");
String bom_code = reqParam.getString("bom_code");
Assert.notEmpty(bom_code, "BOM编码不能为空！");
String residue_qty = reqParam.getString("residue_qty");
if (StrUtil.isBlank(residue_qty) || BigDecimal.ZERO.compareTo(new BigDecimal(residue_qty)) == 0) {
//如果剩余物料为0或空，就删除组盘信息
GroupPlate groupPlate = mdPbGroupplateService.getOne(new LambdaQueryWrapper<GroupPlate>()
.eq(GroupPlate::getStoragevehicle_code, storagevehicle_code)
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("出库")));
if (groupPlate != null) {
mdPbGroupplateService.removeById(groupPlate);
}
//更新工单实际重量 为组盘数量
PdmBomCallMaterial bomCallMaterial = pdmBomCallMaterialService.findByCode(bom_code);
if (bomCallMaterial != null) {
//根据载具号和工单ID 查询叫料明细
PdmBomCallMaterialDtl pdmBomCallMaterialDtl = pdmBomCallMaterialDtlService.getOne(new LambdaQueryWrapper<PdmBomCallMaterialDtl>()
.eq(PdmBomCallMaterialDtl::getBom_id, bomCallMaterial.getBom_id())
.eq(PdmBomCallMaterialDtl::getVehicle_code, storagevehicle_code)
.lt(PdmBomCallMaterialDtl::getBom_status, BomEnum.CALL_BOM_DTL_STATUS.code("完成")));
if (pdmBomCallMaterialDtl != null) {
pdmBomCallMaterialDtl.setBom_status(BomEnum.CALL_BOM_DTL_STATUS.code("完成"));
pdmBomCallMaterialDtlService.updateById(pdmBomCallMaterialDtl);
bomCallMaterial.setReal_weigh_qty(bomCallMaterial.getReal_weigh_qty().add(groupPlate.getQty()));
List<PdmBomCallMaterialDtl> pdmBomCallMaterialDtlList = pdmBomCallMaterialDtlService.list(new LambdaQueryWrapper<PdmBomCallMaterialDtl>()
.eq(PdmBomCallMaterialDtl::getBom_id, pdmBomCallMaterialDtl.getBom_id())
.lt(PdmBomCallMaterialDtl::getBom_status, BomEnum.CALL_BOM_DTL_STATUS.code("完成")));
if (pdmBomCallMaterialDtlList.size() == 0) {
bomCallMaterial.setBom_status(BomEnum.CALL_BOM_STATUS.code("完成"));
}
pdmBomCallMaterialService.updateById(bomCallMaterial);
}
}
} else {
//有重量，更新剩余物料到组盘信息的重量
GroupPlate groupPlate = mdPbGroupplateService.getOne(new LambdaQueryWrapper<GroupPlate>()
.eq(GroupPlate::getStoragevehicle_code, storagevehicle_code)
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("出库")));
//原组盘数量
BigDecimal qty = groupPlate.getQty();
if (groupPlate != null) {
groupPlate.setQty(new BigDecimal(residue_qty));
mdPbGroupplateService.updateById(groupPlate);
}
// ，更新工单的实际重量=组盘重量-剩余物料重量
PdmBomCallMaterial bomCallMaterial = pdmBomCallMaterialService.findByCode(bom_code);
if (bomCallMaterial != null) {
//根据载具号和工单ID 查询叫料明细
PdmBomCallMaterialDtl pdmBomCallMaterialDtl = pdmBomCallMaterialDtlService.getOne(new LambdaQueryWrapper<PdmBomCallMaterialDtl>()
.eq(PdmBomCallMaterialDtl::getBom_id, bomCallMaterial.getBom_id())
.eq(PdmBomCallMaterialDtl::getVehicle_code, storagevehicle_code)
.lt(PdmBomCallMaterialDtl::getBom_status, BomEnum.CALL_BOM_DTL_STATUS.code("完成")));
if (pdmBomCallMaterialDtl != null) {
pdmBomCallMaterialDtl.setBom_status(BomEnum.CALL_BOM_DTL_STATUS.code("完成"));
pdmBomCallMaterialDtlService.updateById(pdmBomCallMaterialDtl);
bomCallMaterial.setReal_weigh_qty(bomCallMaterial.getReal_weigh_qty().add(qty.subtract(new BigDecimal(residue_qty))));
List<PdmBomCallMaterialDtl> pdmBomCallMaterialDtlList = pdmBomCallMaterialDtlService.list(new LambdaQueryWrapper<PdmBomCallMaterialDtl>()
.eq(PdmBomCallMaterialDtl::getBom_id, pdmBomCallMaterialDtl.getBom_id())
.lt(PdmBomCallMaterialDtl::getBom_status, BomEnum.CALL_BOM_DTL_STATUS.code("完成")));
if (pdmBomCallMaterialDtlList.size() == 0) {
bomCallMaterial.setBom_status(BomEnum.CALL_BOM_STATUS.code("完成"));
}
pdmBomCallMaterialService.updateById(bomCallMaterial);
}
}
}
return PdaResponse.requestOk();
}
@Override
public PdaResponse materialBoxMoveConfirm(JSONObject reqParam) {
return PdaResponse.requestOk();
}
@Override
public PdaResponse materialBoxInventoryConfirm(JSONObject reqParam) {
return PdaResponse.requestOk();
}
@Override
public PdaResponse getGroupInfo(JSONObject reqParam) {
Assert.notNull(reqParam, "请求参数不能为空!");
String storagevehicle_code = reqParam.getString("storagevehicle_code");
Assert.notBlank(storagevehicle_code, "载具号不能为空！");
List<GroupPlate> groupPlateList = mdPbGroupplateService.list(new LambdaQueryWrapper<GroupPlate>()
.eq(GroupPlate::getStoragevehicle_code, storagevehicle_code)
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("组盘")));
//将GroupPlate对象转换为Map
List<Map<String, Object>> groupPlateListMap = groupPlateList.stream()
.map(groupPlate -> {
Map<String, Object> groupPlateMap = new HashMap<>();
groupPlateMap.put("group_id", groupPlate.getGroup_id());
groupPlateMap.put("storagevehicle_code", groupPlate.getStoragevehicle_code());
MdMeMaterialbase materialbase = mdMeMaterialbaseService.getById(groupPlate.getMaterial_id());
groupPlateMap.put("material_id", groupPlate.getMaterial_id());
if (ObjectUtil.isNotEmpty(materialbase)) {
groupPlateMap.put("material_code", materialbase.getMaterial_code());
groupPlateMap.put("material_name", materialbase.getMaterial_name());
groupPlateMap.put("material_spec", materialbase.getMaterial_spec());
groupPlateMap.put("material_mode", materialbase.getMaterial_model());
}
groupPlateMap.put("qty_unit_name", groupPlate.getQty_unit_name());
groupPlateMap.put("pcsn", groupPlate.getPcsn());
groupPlateMap.put("qty", groupPlate.getQty());
MdCsSupplierbase mdCsSupplierbase = mdCsSupplierbaseService.getOne(new LambdaQueryWrapper<MdCsSupplierbase>().eq(MdCsSupplierbase::getSupp_code, groupPlate.getSupp_code()));
groupPlateMap.put("supp_code", groupPlate.getSupp_code());
if (ObjectUtil.isNotEmpty(mdCsSupplierbase)) {
groupPlateMap.put("supp_name", mdCsSupplierbase.getSupp_name());
}
groupPlateMap.put("quality_time", groupPlate.getQuality_time());
groupPlateMap.put("produce_time", groupPlate.getProduce_time());
groupPlateMap.put("execution_stand", groupPlate.getExecution_stand());
groupPlateMap.put("bake_num", groupPlate.getBake_num());
groupPlateMap.put("quality_type", groupPlate.getQuality_type());
return groupPlateMap;
}).collect(Collectors.toList());
return PdaResponse.requestParamOk(groupPlateListMap);
}
@Override
public PdaResponse getInGroupInfotGroupInfo(JSONObject reqParam) {
Assert.notNull(reqParam, "请求参数不能为空!");
String storagevehicle_code = reqParam.getString("storagevehicle_code");
Assert.notBlank(storagevehicle_code, "载具号不能为空！");
List<GroupPlate> groupPlateList = mdPbGroupplateService.list(new LambdaQueryWrapper<GroupPlate>()
.eq(GroupPlate::getStoragevehicle_code, storagevehicle_code)
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("入库")));
//将GroupPlate对象转换为Map
List<Map<String, Object>> groupPlateListMap = groupPlateList.stream()
.map(groupPlate -> {
Map<String, Object> groupPlateMap = new HashMap<>();
groupPlateMap.put("group_id", groupPlate.getGroup_id());
groupPlateMap.put("storagevehicle_code", groupPlate.getStoragevehicle_code());
MdMeMaterialbase materialbase = mdMeMaterialbaseService.getById(groupPlate.getMaterial_id());
groupPlateMap.put("material_id", groupPlate.getMaterial_id());
if (ObjectUtil.isNotEmpty(materialbase)) {
groupPlateMap.put("material_code", materialbase.getMaterial_code());
groupPlateMap.put("material_name", materialbase.getMaterial_name());
groupPlateMap.put("material_spec", materialbase.getMaterial_spec());
groupPlateMap.put("material_mode", materialbase.getMaterial_model());
}
groupPlateMap.put("qty_unit_name", groupPlate.getQty_unit_name());
groupPlateMap.put("qty", groupPlate.getQty());
MdCsSupplierbase mdCsSupplierbase = mdCsSupplierbaseService.getOne(new LambdaQueryWrapper<MdCsSupplierbase>().eq(MdCsSupplierbase::getSupp_code, groupPlate.getSupp_code()));
groupPlateMap.put("supp_code", groupPlate.getSupp_code());
if (ObjectUtil.isNotEmpty(mdCsSupplierbase)) {
groupPlateMap.put("supp_name", mdCsSupplierbase.getSupp_name());
}
groupPlateMap.put("quality_time", groupPlate.getQuality_time());
groupPlateMap.put("produce_time", groupPlate.getProduce_time());
groupPlateMap.put("execution_stand", groupPlate.getExecution_stand());
groupPlateMap.put("bake_num", groupPlate.getBake_num());
groupPlateMap.put("quality_type", groupPlate.getQuality_type());
groupPlateMap.put("box_type", groupPlate.getBox_type());
return groupPlateMap;
}).collect(Collectors.toList());
return PdaResponse.requestParamOk(groupPlateListMap);
}
@Override
public PdaResponse getOutGroupInfo(JSONObject reqParam) {
Assert.notNull(reqParam, "请求参数不能为空!");
String storagevehicle_code = reqParam.getString("storagevehicle_code");
Assert.notBlank(storagevehicle_code, "载具号不能为空！");
List<GroupPlate> groupPlateList = mdPbGroupplateService.list(new LambdaQueryWrapper<GroupPlate>()
.eq(GroupPlate::getStoragevehicle_code, storagevehicle_code)
.eq(GroupPlate::getStatus, IOSEnum.GROUP_PLATE_STATUS.code("出库")));
Assert.notEmpty(groupPlateList, "没有找到对应的组盘信息！");
GroupPlate groupPlateOne = groupPlateList.get(0);
PdmBomCallMaterial pdmBomCallMaterial = pdmBomCallMaterialService.getById(groupPlateOne.getBom_id());
Assert.notNull(pdmBomCallMaterial, "没有找到对应的工单信息信息！");
JSONObject resp = new JSONObject();
//将GroupPlate对象转换为Map
List<Map<String, Object>> groupPlateListMap = groupPlateList.stream()
.map(groupPlate -> {
Map<String, Object> groupPlateMap = new HashMap<>();
groupPlateMap.put("group_id", groupPlate.getGroup_id());
groupPlateMap.put("storagevehicle_code", groupPlate.getStoragevehicle_code());
MdMeMaterialbase materialbase = mdMeMaterialbaseService.getById(groupPlate.getMaterial_id());
groupPlateMap.put("material_id", groupPlate.getMaterial_id());
if (ObjectUtil.isNotEmpty(materialbase)) {
groupPlateMap.put("material_code", materialbase.getMaterial_code());
groupPlateMap.put("material_name", materialbase.getMaterial_name());
groupPlateMap.put("material_spec", materialbase.getMaterial_spec());
groupPlateMap.put("material_mode", materialbase.getMaterial_model());
}
groupPlateMap.put("qty_unit_name", groupPlate.getQty_unit_name());
groupPlateMap.put("qty", groupPlate.getQty());
MdCsSupplierbase mdCsSupplierbase = mdCsSupplierbaseService.getOne(new LambdaQueryWrapper<MdCsSupplierbase>().eq(MdCsSupplierbase::getSupp_code, groupPlate.getSupp_code()));
groupPlateMap.put("supp_code", groupPlate.getSupp_code());
if (ObjectUtil.isNotEmpty(mdCsSupplierbase)) {
groupPlateMap.put("supp_name", mdCsSupplierbase.getSupp_name());
}
groupPlateMap.put("quality_time", groupPlate.getQuality_time());
groupPlateMap.put("produce_time", groupPlate.getProduce_time());
groupPlateMap.put("execution_stand", groupPlate.getExecution_stand());
groupPlateMap.put("bake_num", groupPlate.getBake_num());
groupPlateMap.put("quality_type", groupPlate.getQuality_type());
groupPlateMap.put("box_type", groupPlate.getBox_type());
return groupPlateMap;
}).collect(Collectors.toList());
resp.put("bom_code", pdmBomCallMaterial.getBom_code());
resp.put("device_code", pdmBomCallMaterial.getDevice_code());
resp.put("data", groupPlateListMap);
return PdaResponse.requestParamOk(resp);
}
@Override
public PdaResponse getMaterialInfo(JSONObject reqParam) {
Assert.notNull(reqParam, "请求参数不能为空!");
String material = reqParam.getString("material");
LambdaQueryWrapper<MdMeMaterialbase> queryWrapper = new LambdaQueryWrapper<>();
if (ObjectUtil.isNotEmpty(material)) {
queryWrapper.and(wrapper -> wrapper
.like(MdMeMaterialbase::getMaterial_code, material)
.or()
.like(MdMeMaterialbase::getMaterial_name, material)
.or()
.like(MdMeMaterialbase::getMaterial_spec, material)
.or()
.like(MdMeMaterialbase::getMaterial_model, material));
}
List<MdMeMaterialbase> materialList = mdMeMaterialbaseService.list(queryWrapper);
List<Map<String, Object>> materialMapList = materialList.stream()
.map(materialbase -> {
Map<String, Object> map = new HashMap<>();
map.put("material_id", materialbase.getMaterial_id());
map.put("material_code", materialbase.getMaterial_code());
map.put("material_name", materialbase.getMaterial_name());
map.put("material_spec", materialbase.getMaterial_spec());
map.put("material_model", materialbase.getMaterial_model());
map.put("quality_time", materialbase.getQuality_time());
map.put("execution_stand", materialbase.getExecution_stand());
return map;
})
.collect(Collectors.toList());
return PdaResponse.requestParamOk(materialMapList);
}
@Override
public PdaResponse getIoDisDocumentInfo(JSONObject reqParam) {
Assert.notNull(reqParam, "请求参数不能为空!");
String type = reqParam.getString("type");
Assert.notBlank(type, "出入库单据类型不能为空！");
JSONObject param = new JSONObject();
param.put("query", reqParam.getString("query"));
param.put("biz_date", reqParam.getString("biz_date"));
param.put("bill_type", type);
param.put("bill_status", IOSEnum.BILL_STATUS.code("分配完"));
List<Map<String, Object>> ioDisDtl = iOutBillService.getIoDisDtl(param);
return PdaResponse.requestParamOk(ioDisDtl);
}
@Override
public PdaResponse getMoveDocumentInfo(JSONObject reqParam) {
String type = reqParam.getString("type");
Assert.notBlank(type, "移库类型不能为空！");
String vehicleStructCode = reqParam.getString("vehicleStructCode");
Assert.notBlank(vehicleStructCode, "载具编码或点位编码不能为空！");
JSONObject param = new JSONObject();
param.put("vehicleStructCode", vehicleStructCode);
List<Map<String, Object>> mapList = new ArrayList<>();
if (StrUtil.equals("1", type)) {
mapList = stIvtMoveinvdtlMapper.getOutMoveDtlByVehicleStructCode(param);
} else if (StrUtil.equals("2", type)) {
mapList = stIvtMoveinvdtlMapper.getInMoveDtlByVehicleStructCode(param);
} else {
throw new BadRequestException("移库类型错误");
}
return PdaResponse.requestParamOk(mapList);
}
@Override
public PdaResponse getCheckDocumentInfo(JSONObject reqParam) {
Assert.notEmpty(reqParam, "请求参数不能为空!");
List<Map<String, Object>> checkDtl = stIvtCheckdtlMapper.getCheckDtl(reqParam);
return PdaResponse.requestParamOk(checkDtl);
}
@Override
public PdaResponse getInvInfoQty(JSONObject reqParam) {
String vehicleStructCode = reqParam.getString("vehicleStructCode");
Assert.notBlank(vehicleStructCode, "载具编码或点位编码不能为空！");
Structattr structattr = structattrService.getOne(new LambdaQueryWrapper<Structattr>()
.eq(Structattr::getStoragevehicle_code, vehicleStructCode)
.or()
.eq(Structattr::getStruct_code, vehicleStructCode));
Assert.notNull(structattr, "载具编码或点位编码不存在！");
MdPbStoragevehicleext storagevehicleext = mdPbStoragevehicleextService.getOne(new LambdaQueryWrapper<MdPbStoragevehicleext>()
.eq(MdPbStoragevehicleext::getStoragevehicle_code, structattr.getStoragevehicle_code()));
JSONObject data = new JSONObject();
data.put("ivt_qty", storagevehicleext == null ? 0 : storagevehicleext.getCanuse_qty());
return PdaResponse.requestParamOk(data);
}
}

42
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/pda_common_interface/controller/PdaCommonInterfaceController.java Normal file
View File

@@ -0,0 +1,42 @@
package org.nl.wms.pda.pda_common_interface.controller;
import cn.dev33.satoken.annotation.SaIgnore;
import com.alibaba.fastjson.JSONObject;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.logging.annotation.Log;
import org.nl.wms.pda.pda_common_interface.service.PdaCommonInterfaceService;
import org.nl.wms.warehouse_management.enums.IOSEnum;
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;
/**
* @Description TODO
* @Author Gengby
* @Date 2025/9/2
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/pda/common")
@Slf4j
public class PdaCommonInterfaceController {
@Autowired
private PdaCommonInterfaceService pdaCommonInterfaceService;
@PostMapping("/getDictType")
@Log("获取字典类型")
@SaIgnore
public ResponseEntity<Object> getDictType(@RequestBody JSONObject reqParam) {
return new ResponseEntity<>(pdaCommonInterfaceService.getDictType(reqParam), HttpStatus.OK);
}
}

23
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/pda_common_interface/service/PdaCommonInterfaceService.java Normal file
View File

@@ -0,0 +1,23 @@
package org.nl.wms.pda.pda_common_interface.service;
import com.alibaba.fastjson.JSONObject;
import org.nl.wms.pda.util.PdaResponse;
/**
* @Description TODO
* @Author Gengby
* @Date 2025/9/2
*/
public interface PdaCommonInterfaceService {
/**
* 获取字典类型
* @param reqParam
* @return
*/
PdaResponse getDictType(JSONObject reqParam);
}

64
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pda/pda_common_interface/service/impl/PdaCommonInterfaceServiceImpl.java Normal file
View File

@@ -0,0 +1,64 @@
package org.nl.wms.pda.pda_common_interface.service.impl;
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.system.service.dict.ISysDictService;
import org.nl.system.service.dict.dao.Dict;
import org.nl.wms.basedata_manage.service.IMdCsSupplierbaseService;
import org.nl.wms.basedata_manage.service.IMdMeMaterialbaseService;
import org.nl.wms.basedata_manage.service.IMdPbStoragevehicleextService;
import org.nl.wms.basedata_manage.service.IStructattrService;
import org.nl.wms.basedata_manage.service.dao.MdCsSupplierbase;
import org.nl.wms.basedata_manage.service.dao.MdMeMaterialbase;
import org.nl.wms.basedata_manage.service.dao.MdPbStoragevehicleext;
import org.nl.wms.basedata_manage.service.dao.Structattr;
import org.nl.wms.pda.pda_common_interface.service.PdaCommonInterfaceService;
import org.nl.wms.pda.util.PdaResponse;
import org.nl.wms.pdm_manage.service.IPdmBomCallMaterialService;
import org.nl.wms.pdm_manage.service.dao.PdmBomCallMaterial;
import org.nl.wms.warehouse_management.enums.IOSEnum;
import org.nl.wms.warehouse_management.service.IMdPbGroupplateService;
import org.nl.wms.warehouse_management.service.IOutBillService;
import org.nl.wms.warehouse_management.service.IStIvtMoveinvdtlService;
import org.nl.wms.warehouse_management.service.dao.GroupPlate;
import org.nl.wms.warehouse_management.service.dao.mapper.StIvtMoveinvdtlMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @Description TODO
* @Author Gengby
* @Date 2025/9/2
*/
@Service
public class PdaCommonInterfaceServiceImpl implements PdaCommonInterfaceService {
@Autowired
private ISysDictService sysDictService;
@Override
public PdaResponse getDictType(JSONObject reqParam) {
String type = reqParam.getString("type");
Assert.notBlank(type, "字典类型不能为空！");
List<Dict> dictTypeList = sysDictService.getDictByName(type);
List<Map<String, String>> dictTypeListMap = dictTypeList.stream()
.map(dict -> {
Map<String, String> map = new HashMap<>();
map.put("text", dict.getLabel());
map.put("value", dict.getValue());
return map;
})
.collect(Collectors.toList());
return PdaResponse.requestParamOk(dictTypeListMap);
}
}

11
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/pdm_manage/service/impl/PdmBomCallMaterialDtlServiceImpl.java
View File

@@ -101,10 +101,15 @@ public class PdmBomCallMaterialDtlServiceImpl extends ServiceImpl<PdmBomCallMate
throw new BadRequestException("请维护当前载具重量【" + pointDao.getVehicle_code() + "】");
}
// TODO 调用ACS接口获取称重信息
AcsResponse weighAcs = wmsToAcsService.getWeighAcs(new JSONObject());
JSONObject jsonResult = weighAcs.getResultData();
// 调用ACS接口获取称重信息
JSONObject jsonParam = new JSONObject();
jsonParam.put("device_code", pointDao.getPoint_code());
AcsResponse weighAcs = wmsToAcsService.getWeighAcs(jsonParam);
if (weighAcs.getStatus() != 200) {
throw new BadRequestException(weighAcs.getMessage());
}
JSONObject jsonResult = weighAcs.getResultData();
// 称重重量
double weigh_qty = NumberUtil.round(jsonResult.getDoubleValue("weigh_qty"), 2).doubleValue();
// 扣除载具重量

32
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch_manage/service/impl/SchBasePointServiceImpl.java
View File

@@ -14,6 +14,8 @@ import lombok.extern.slf4j.Slf4j;
import org.nl.common.domain.query.PageQuery;
import org.nl.common.exception.BadRequestException;
import org.nl.common.utils.SecurityUtils;
import org.nl.wms.ext.service.WmsToAcsService;
import org.nl.wms.ext.service.util.AcsResponse;
import org.nl.wms.sch_manage.enums.PointStatusEnum;
import org.nl.wms.sch_manage.service.ISchBasePointService;
import org.nl.wms.sch_manage.service.dao.SchBasePoint;
@@ -48,6 +50,9 @@ public class SchBasePointServiceImpl extends ServiceImpl<SchBasePointMapper, Sch
@Autowired
private SchBaseRegionMapper regionMapper;
@Autowired
private WmsToAcsService wmsToAcsService;
@Override
public IPage<SchBasePoint> queryAll(SchBasePointQuery whereJson, PageQuery page) {
IPage<SchBasePoint> pages = new Page<>(page.getPage() + 1, page.getSize());
@@ -204,19 +209,42 @@ public class SchBasePointServiceImpl extends ServiceImpl<SchBasePointMapper, Sch
@Transactional
public void getConfirm(JSONObject whereJson) {
SchBasePoint pointDao = this.getById(whereJson.getString("point_code"));
if (ObjectUtil.isEmpty(pointDao.getIng_task_code())) {
throw new BadRequestException("当前站点没有任务【"+pointDao.getPoint_code()+"】");
}
// 通知ACS可以离开
JSONObject jsonParam = new JSONObject();
jsonParam.put("task_type", IOSConstant.ONE);
jsonParam.put("task_code", pointDao.getIng_task_code());
AcsResponse acsResponse = wmsToAcsService.confirmAgv(jsonParam);
if (acsResponse.getStatus() != 200) {
throw new BadRequestException(acsResponse.getMessage());
}
// 清空点位信息
pointDao.setVehicle_code("");
pointDao.setPoint_status(IOSEnum.POINT_STATUS.code("空位"));
pointDao.setIng_task_code("");
this.updateById(pointDao);
// TODO 通知ACS可以离开
}
@Override
@Transactional
public void putConfirm(JSONObject whereJson) {
SchBasePoint pointDao = this.getById(whereJson.getString("point_code"));
// TODO 通知ACS可以离开
if (ObjectUtil.isEmpty(pointDao.getIng_task_code())) {
throw new BadRequestException("当前站点没有任务【"+pointDao.getPoint_code()+"】");
}
// 通知ACS可以离开
JSONObject jsonParam = new JSONObject();
jsonParam.put("task_type", IOSConstant.TWO);
jsonParam.put("task_code", pointDao.getIng_task_code());
AcsResponse acsResponse = wmsToAcsService.confirmAgv(jsonParam);
if (acsResponse.getStatus() != 200) {
throw new BadRequestException(acsResponse.getMessage());
}
}
@Override

19
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/IOutBillService.java
View File

@@ -37,6 +37,7 @@ public interface IOutBillService extends IService<IOStorInv> {
/**
* 获取可用库存物料
*
* @param whereJson : {
* 分页参数：page，size
* stor_id: 仓库id
@@ -44,8 +45,8 @@ public interface IOutBillService extends IService<IOStorInv> {
* struct_code: 货位编码
* material_code: 物料编码
* pcsn: 批次
* }
* @param page : 分页对象
* }
* @param page : 分页对象
* @return 返回结果
*/
IPage<JSONObject> getCanuseIvt(Map whereJson, PageQuery page);
@@ -84,6 +85,7 @@ public interface IOutBillService extends IService<IOStorInv> {
/**
* 查询未出库分配
*
* @param whereJson
* @return
*/
@@ -104,20 +106,22 @@ public interface IOutBillService extends IService<IOStorInv> {
void allCancel(JSONObject whereJson);
/**
*
* 自动分配 单条出库单明细
*
* @param whereJson
*/
void autoDiv(JSONObject whereJson);
/**
* 自动取消分配 单条出库单明细
*
* @param whereJson
*/
void autoCancel(JSONObject whereJson);
/**
* 查询可用库存
*
* @param whereJson
* @return
*/
@@ -153,6 +157,7 @@ public interface IOutBillService extends IService<IOStorInv> {
/**
* 出库单作业明细查询
*
* @param whereJson
* @return
*/
@@ -160,7 +165,15 @@ public interface IOutBillService extends IService<IOStorInv> {
/**
* 出库任务完成
*
* @param task
*/
void taskFinish(SchBaseTask task);
/**
* 获取出入库单据分配明细
*
* @return
*/
List<Map<String, Object>> getIoDisDtl(JSONObject param);
}

2
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/IRawAssistIStorService.java
View File

@@ -149,4 +149,6 @@ public interface IRawAssistIStorService extends IService<IOStorInv> {
* @return List<IOStorInvDisDto>
*/
List<IOStorInvDisDto> getInBillTaskDtl(Map whereJson);
String insertPdaDtl(JSONObject whereJson);
}

3
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/dao/mapper/IOStorInvDisMapper.java
View File

@@ -1,5 +1,6 @@
package org.nl.wms.warehouse_management.service.dao.mapper;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@@ -22,4 +23,6 @@ public interface IOStorInvDisMapper extends BaseMapper<IOStorInvDis> {
//查询未出库单分配
List<IOStorInvDisDto> queryOutBillDisDtl(@Param("params") Map whereJson);
List<Map<String, Object>> getIoDisDtl(@Param("param") JSONObject param);
}

68
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/dao/mapper/IOStorInvDisMapper.xml
View File

@@ -19,18 +19,15 @@
</select>
<select id="getBillTaskDtl" resultType="org.nl.wms.warehouse_management.service.dto.IOStorInvDisDto">
SELECT
dis.*,
mb.material_code,
mb.material_name,
task.task_code,
task.task_status
FROM
st_ivt_iostorinvdis dis
LEFT JOIN md_me_materialbase mb ON mb.material_id = dis.material_id
LEFT JOIN sch_base_task task ON task.task_id = dis.task_id
where
dis.iostorinvdtl_id = #{iostorinvdtl_id}
SELECT dis.*,
mb.material_code,
mb.material_name,
task.task_code,
task.task_status
FROM st_ivt_iostorinvdis dis
LEFT JOIN md_me_materialbase mb ON mb.material_id = dis.material_id
LEFT JOIN sch_base_task task ON task.task_id = dis.task_id
where dis.iostorinvdtl_id = #{iostorinvdtl_id}
</select>
<select id="queryOutBillDisDtl" resultType="org.nl.wms.warehouse_management.service.dto.IOStorInvDisDto">
@@ -57,4 +54,51 @@
</if>
</select>
<select id="getIoDisDtl" resultType="java.util.Map">
SELECT ios.iostorinv_id,
ios.bill_code,
ios.bill_type,
ios.total_qty,
dis.material_id,
mb.material_code,
mb.material_name,
dis.iostorinvdis_id,
dis.iostorinvdtl_id,
dis.struct_code,
dis.struct_name,
dis.storagevehicle_code,
dis.pcsn,
dis.plan_qty,
gp.produce_time,
gp.bake_num,
sb.supp_code,
sb.supp_name
FROM st_ivt_iostorinv ios
LEFT JOIN st_ivt_iostorinvdis dis ON ios.iostorinv_id = dis.iostorinv_id
LEFT JOIN md_me_materialbase mb ON mb.material_id = dis.material_id
LEFT JOIN md_pb_groupplate gp ON gp.storagevehicle_code = dis.storagevehicle_code
LEFT JOIN md_cs_supplierbase sb ON sb.supplier_code = gp.supplier_code
<where>
is_delete = '0'
<if test="param.query != null and param.query != ''">
AND (ios.bill_code LIKE CONCAT('%', #{param.query}, '%')
OR mb.material_code LIKE CONCAT('%', #{param.query}, '%')
OR mb.material_name LIKE CONCAT('%', #{param.query}, '%')
OR dis.pcsn LIKE CONCAT('%', #{param.query}, '%')
OR sb.supp_code LIKE CONCAT('%', #{param.query}, '%')
OR sb.supp_name LIKE CONCAT('%', #{param.query}, '%'))
</if>
<if test="param.bill_type != null and param.bill_type != ''">
AND ios.bill_type = #{param.bill_type}
</if>
<if test="param.bill_status != null and param.bill_status != ''">
AND ios.bill_status = #{param.bill_status}
</if>
<if test="param.biz_date != null and param.biz_date != ''">
AND ios.biz_date = #{param.biz_date}
</if>
</where>
ORDER BY ios.bill_code, dis.seq_no ASC
</select>
</mapper>

6
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/dao/mapper/MdPbGroupplateMapper.xml
View File

@@ -25,10 +25,14 @@
late.*,
mater.material_code,
mater.material_name,
mater.material_spec
mater.material_spec,
mater.material_model,
mater.quality_time AS quality_time_day,
supp.supp_name
FROM
md_pb_groupplate late
INNER JOIN md_me_materialbase mater ON mater.material_id = late.material_id
INNER JOIN md_cs_supplierbase supp ON supp.supp_code = late.supp_code
<where>
1 = 1
<if test="param.material_code != null and param.material_code != ''">

15
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/dao/mapper/StIvtCheckdtlMapper.java
View File

@@ -20,20 +20,31 @@ public interface StIvtCheckdtlMapper extends BaseMapper<StIvtCheckdtl> {
/**
* 获取明细
*
* @param whereJson {
* check_id 主表标识
* }
* }
* @return List<JSONObject>
*/
List<JSONObject> getDtl(@Param("param") Map whereJson);
/**
* 手持获取盘点明细
*
* @param whereJson {
* storagevehicle_code：载具编码
* struct_code： 仓位
* }
* }
* @return List<JSONObject>
*/
List<JSONObject> getPdaDtl(@Param("param") JSONObject whereJson);
/**
* 手持大料箱获取盘点明细
*
* @param reqParam
* @return
*/
List<Map<String, Object>> getCheckDtl(JSONObject reqParam);
}

91
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/dao/mapper/StIvtCheckdtlMapper.xml
View File

@@ -4,25 +4,25 @@
<select id="getDtl" resultType="com.alibaba.fastjson.JSONObject">
SELECT
dtl.*,
material.material_code,
material.material_name,
sect.sect_name,
attr.struct_name,
task.task_code,
(
CASE
WHEN dtl.status > '20' THEN true
ELSE false
END
) AS edit
dtl.*,
material.material_code,
material.material_name,
sect.sect_name,
attr.struct_name,
task.task_code,
(
CASE
WHEN dtl.status > '20' THEN true
ELSE false
END
) AS edit
FROM
st_ivt_checkdtl dtl
LEFT JOIN st_ivt_checkmst ios ON ios.check_id = dtl.check_id
LEFT JOIN md_me_materialbase material ON material.material_id = dtl.material_id
LEFT JOIN st_ivt_sectattr sect ON sect.sect_code = dtl.sect_code
LEFT JOIN st_ivt_structattr attr ON attr.struct_code = dtl.struct_code
LEFT JOIN sch_base_task task ON task.task_id = dtl.task_id
st_ivt_checkdtl dtl
LEFT JOIN st_ivt_checkmst ios ON ios.check_id = dtl.check_id
LEFT JOIN md_me_materialbase material ON material.material_id = dtl.material_id
LEFT JOIN st_ivt_sectattr sect ON sect.sect_code = dtl.sect_code
LEFT JOIN st_ivt_structattr attr ON attr.struct_code = dtl.struct_code
LEFT JOIN sch_base_task task ON task.task_id = dtl.task_id
<where>
ios.is_delete = '0'
<if test="param.check_id != null and param.check_id != ''">
@@ -34,18 +34,18 @@
<select id="getPdaDtl" resultType="com.alibaba.fastjson.JSONObject">
SELECT
dtl.checkdtl_id,
ios.check_code AS bill_code,
material.material_code,
material.material_name,
dtl.pcsn,
dtl.base_qty,
dtl.fac_qty,
dtl.qty_unit_name
dtl.checkdtl_id,
ios.check_code AS bill_code,
material.material_code,
material.material_name,
dtl.pcsn,
dtl.base_qty,
dtl.fac_qty,
dtl.qty_unit_name
FROM
st_ivt_checkdtl dtl
LEFT JOIN st_ivt_checkmst ios ON ios.check_id = dtl.check_id
LEFT JOIN md_me_materialbase material ON material.material_id = dtl.material_id
st_ivt_checkdtl dtl
LEFT JOIN st_ivt_checkmst ios ON ios.check_id = dtl.check_id
LEFT JOIN md_me_materialbase material ON material.material_id = dtl.material_id
<where>
dtl.status IN ('10','20')
AND ios.status IN ('10','20')
@@ -60,5 +60,38 @@
</if>
</where>
</select>
<select id="getCheckDtl" resultType="java.util.Map">
SELECT
mst.check_id,
mst.check_code,
dtl.checkdtl_id,
dtl.status,
dtl.check_result,
dtl.material_id,
mb.material_code,
mb.material_name,
dtl.struct_code,
dtl.storagevehicle_code,
dtl.pcsn,
dtl.base_qty,
dtl.fac_qty,
gp.produce_time,
gp.bake_num,
sb.supp_code,
sb.supp_name
FROM st_ivt_checkmst mst
LEFT JOIN st_ivt_checkdtl dtl ON dtl.check_id = mst.check_id
LEFT JOIN md_pb_groupplate gp ON dtl.storagevehicle_code = gp.storagevehicle_code
LEFT JOIN md_me_materialbase mb ON dtl.material_id = mb.material_id
LEFT JOIN md_cs_supplierbase sb ON sb.supp_code = gp.supp_code
<where>
mst.is_delete = '0'AND mst.status != '99'
<if test="reqParam.bill_code != null and reqParam.bill_code != ''">
AND
mst.check_code = #{reqParam.bill_code}
</if>
</where>
ORDER BY mst.input_time,dtl.seq_no ASC
</select>
</mapper>

20
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/dao/mapper/StIvtMoveinvdtlMapper.java
View File

@@ -20,10 +20,28 @@ public interface StIvtMoveinvdtlMapper extends BaseMapper<StIvtMoveinvdtl> {
/**
* 查询移库单明细
*
* @param whereJson {
* moveinv_id 移库单标识
* }
* }
* @return List<JSONObject>
*/
List<JSONObject> getMoveDtl(@Param("param") Map whereJson);
/**
* 根据载具或仓位查询移库单移出明细
* @param param
* @return
*/
List<Map<String, Object>> getOutMoveDtlByVehicleStructCode(@Param("param") JSONObject param);
/**
* 根据载具或仓位查询移库单移入明细
* @param param
* @return
*/
List<Map<String, Object>> getInMoveDtlByVehicleStructCode(@Param("param") JSONObject param);
}

106
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/dao/mapper/StIvtMoveinvdtlMapper.xml
View File

@@ -5,31 +5,31 @@
<select id="getMoveDtl" resultType="com.alibaba.fastjson.JSONObject">
SELECT
dtl.moveinvdtl_id,
dtl.work_status,
material.material_id,
material.material_code,
material.material_name,
dtl.pcsn,
dtl.qty,
dtl.qty_unit_id,
dtl.qty_unit_name,
dtl.storagevehicle_code,
dtl.storagevehicle_code2,
attrout.sect_name AS turnout_sect_name,
attrout.sect_code AS turnout_sect_code,
attrout.struct_code AS turnout_struct_code,
attrin.sect_name AS turnin_sect_name,
attrin.sect_code AS turnin_sect_code,
attrin.struct_code AS turnin_struct_code,
task.task_code
dtl.moveinvdtl_id,
dtl.work_status,
material.material_id,
material.material_code,
material.material_name,
dtl.pcsn,
dtl.qty,
dtl.qty_unit_id,
dtl.qty_unit_name,
dtl.storagevehicle_code,
dtl.storagevehicle_code2,
attrout.sect_name AS turnout_sect_name,
attrout.sect_code AS turnout_sect_code,
attrout.struct_code AS turnout_struct_code,
attrin.sect_name AS turnin_sect_name,
attrin.sect_code AS turnin_sect_code,
attrin.struct_code AS turnin_struct_code,
task.task_code
FROM
st_ivt_moveinvdtl dtl
LEFT JOIN st_ivt_moveinv ios ON ios.moveinv_id = dtl.moveinv_id
LEFT JOIN md_me_materialbase material ON material.material_code = dtl.material_code
LEFT JOIN st_ivt_structattr attrout ON attrout.struct_code = dtl.turnout_struct_code
LEFT JOIN st_ivt_structattr attrin ON attrin.struct_code = dtl.turnin_struct_code
LEFT JOIN sch_base_task task ON task.task_id = dtl.task_id
st_ivt_moveinvdtl dtl
LEFT JOIN st_ivt_moveinv ios ON ios.moveinv_id = dtl.moveinv_id
LEFT JOIN md_me_materialbase material ON material.material_code = dtl.material_code
LEFT JOIN st_ivt_structattr attrout ON attrout.struct_code = dtl.turnout_struct_code
LEFT JOIN st_ivt_structattr attrin ON attrin.struct_code = dtl.turnin_struct_code
LEFT JOIN sch_base_task task ON task.task_id = dtl.task_id
<where>
ios.is_delete = '0'
<if test="param.moveinv_id != null and param.moveinv_id != ''">
@@ -38,4 +38,62 @@
</if>
</where>
</select>
<select id="getOutMoveDtlByVehicleStructCode" resultType="java.util.Map">
SELECT
dtl.moveinvdtl_id,
dtl.moveinv_id,
dtl.turnout_struct_code as struct_code,
dtl.storagevehicle_code as storagevehicle_code,
dtl.pcsn,
dtl.qty,
mb.material_id,
mb.material_code,
mb.material_name,
gp.group_id,
gp.produce_time,
gp.bake_num,
sb.supp_code,
sb.supp_name
FROM st_ivt_moveinvdtl dtl
LEFT JOIN md_pb_groupplate gp ON dtl.storagevehicle_code = gp.storagevehicle_code
LEFT JOIN md_me_materialbase mb ON mb.material_code = dtl.material_code
LEFT JOIN md_cs_supplierbase sb ON sb.supp_code = gp.supp_code
<where>
dtl.work_status = '10' AND gp.is_delete = '0' AND gp.status = '2'
<if test="param.vehicleStructCode != null and param.vehicleStructCode != ''">
AND (
dtl.storagevehicle_code = #{param.vehicleStructCode}
OR dtl.turnout_struct_code = #{param.vehicleStructCode}
)
</if>
</where>
</select>
<select id="getInMoveDtlByVehicleStructCode" resultType="java.util.Map">
SELECT
dtl.turnin_struct_code as struct_code,
dtl.storagevehicle_code2 as storagevehicle_code,
dtl.pcsn,
dtl.qty,
mb.material_code,
mb.material_name,
gp.produce_time,
gp.bake_num,
sb.supp_code,
sb.supp_name
FROM st_ivt_moveinvdtl dtl
LEFT JOIN md_pb_groupplate gp ON dtl.storagevehicle_code2 = gp.storagevehicle_code
LEFT JOIN md_me_materialbase mb ON mb.material_code = dtl.material_code
LEFT JOIN md_cs_supplierbase sb ON sb.supp_code = gp.supp_code
<where>
dtl.work_status = '10' AND gp.is_delete = '0' AND gp.status = '2'
<if test="param.vehicleStructCode != null and param.vehicleStructCode != ''">
AND (
dtl.storagevehicle_code2 = #{param.vehicleStructCode}
OR dtl.turnin_struct_code = #{param.vehicleStructCode}
)
</if>
</where>
</select>
</mapper>

35
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/impl/OutBillServiceImpl.java
View File

@@ -427,7 +427,7 @@ public class OutBillServiceImpl extends ServiceImpl<IOStorInvMapper, IOStorInv>
*/
//出库分配查询货位信息
List<MdPbStoragevehicleextDto> outAllocationList = mdPbStoragevehicleextMapper.queryOutAllocation(pcsn, material_id,sect_code);
List<MdPbStoragevehicleextDto> outAllocationList = mdPbStoragevehicleextMapper.queryOutAllocation(pcsn, material_id, sect_code);
int seq_no = 1;
double allocation_canuse_qty = 0;
@@ -651,7 +651,7 @@ public class OutBillServiceImpl extends ServiceImpl<IOStorInvMapper, IOStorInv>
*/
//出库分配查询货位信息
List<MdPbStoragevehicleextDto> outAllocationList = mdPbStoragevehicleextMapper.queryOutAllocation(pcsn, material_id,sect_code);
List<MdPbStoragevehicleextDto> outAllocationList = mdPbStoragevehicleextMapper.queryOutAllocation(pcsn, material_id, sect_code);
int seq_no = 1;
double allocation_canuse_qty = 0;
@@ -1144,12 +1144,12 @@ public class OutBillServiceImpl extends ServiceImpl<IOStorInvMapper, IOStorInv>
// 判断此单据下的所有任务有没有完成的
boolean is_finish = iSchBaseTaskService.list(
new QueryWrapper<SchBaseTask>().lambda()
.in(SchBaseTask::getTask_id, storInvDisList.stream()
.map(IOStorInvDis::getTask_id)
.collect(Collectors.toList())
)
).stream()
new QueryWrapper<SchBaseTask>().lambda()
.in(SchBaseTask::getTask_id, storInvDisList.stream()
.map(IOStorInvDis::getTask_id)
.collect(Collectors.toList())
)
).stream()
.allMatch(row -> row.getTask_status().equals(TaskStatus.FINISHED.getCode()));
if (!is_finish) {
throw new BadRequestException("当前有未完成的任务不能强制确认!");
@@ -1336,6 +1336,11 @@ public class OutBillServiceImpl extends ServiceImpl<IOStorInvMapper, IOStorInv>
}
}
@Override
public List<Map<String, Object>> getIoDisDtl(JSONObject param) {
return ioStorInvDisMapper.getIoDisDtl(param);
}
/**
* 更新叫料单状态
*
@@ -1344,13 +1349,13 @@ public class OutBillServiceImpl extends ServiceImpl<IOStorInvMapper, IOStorInv>
*/
private void updateBomStatus(IOStorInv ios, String bom_status) {
List<String> sourceList = ioStorInvDtlMapper.selectList(
new QueryWrapper<IOStorInvDtl>().lambda()
.eq(IOStorInvDtl::getIostorinv_id, ios.getIostorinv_id())
.in(bom_status.equals(IOSConstant.TWO), IOStorInvDtl::getBill_status, IOSEnum.BILL_STATUS.code("分配中")
, IOSEnum.BILL_STATUS.code("分配完")
)
.in(bom_status.equals(IOSConstant.IS_DELETE_YES), IOStorInvDtl::getBill_status, IOSEnum.BILL_STATUS.code("生成"))
).stream().map(IOStorInvDtl::getSource_bill_code)
new QueryWrapper<IOStorInvDtl>().lambda()
.eq(IOStorInvDtl::getIostorinv_id, ios.getIostorinv_id())
.in(bom_status.equals(IOSConstant.TWO), IOStorInvDtl::getBill_status, IOSEnum.BILL_STATUS.code("分配中")
, IOSEnum.BILL_STATUS.code("分配完")
)
.in(bom_status.equals(IOSConstant.IS_DELETE_YES), IOStorInvDtl::getBill_status, IOSEnum.BILL_STATUS.code("生成"))
).stream().map(IOStorInvDtl::getSource_bill_code)
.collect(Collectors.toList());
if (ObjectUtil.isEmpty(sourceList)) {

94
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/impl/RawAssistIStorServiceImpl.java
View File

@@ -629,8 +629,8 @@ public class RawAssistIStorServiceImpl extends ServiceImpl<IOStorInvMapper, IOSt
// 更新任务完成
iSchBaseTaskService.update(
new UpdateWrapper<SchBaseTask>().lambda()
.eq(SchBaseTask::getTask_id, ioStorInvDis.getTask_id())
.set(SchBaseTask::getTask_status, TaskStatus.FINISHED.getCode())
.eq(SchBaseTask::getTask_id, ioStorInvDis.getTask_id())
.set(SchBaseTask::getTask_status, TaskStatus.FINISHED.getCode())
);
}
@@ -786,4 +786,94 @@ public class RawAssistIStorServiceImpl extends ServiceImpl<IOStorInvMapper, IOSt
String iostorinvdtl_id = (String) whereJson.get("iostorinvdtl_id");
return ioStorInvDisMapper.getBillTaskDtl(iostorinvdtl_id);
}
@Override
@Transactional(rollbackFor = Exception.class)
public String insertPdaDtl(JSONObject whereJson) {
ArrayList<HashMap> rows = (ArrayList<HashMap>) whereJson.get("tableData");
String currentUserId = SecurityUtils.getCurrentUserId();
String nickName = SecurityUtils.getCurrentNickName();
String now = DateUtil.now();
double total_qty = 0;
JSONObject io_mst = new JSONObject();
String iostorinv_id = IdUtil.getStringId();
String bill_code = CodeUtil.getNewCode("IN_STORE_CODE");
io_mst.put("iostorinv_id", iostorinv_id);
io_mst.put("bill_code", bill_code);
io_mst.put("buss_type", ((String) whereJson.get("bill_type")).substring(0, 4));
io_mst.put("io_type", IOSEnum.IO_TYPE.code("入库"));
io_mst.put("bill_type", whereJson.get("bill_type"));
io_mst.put("biz_date", whereJson.get("biz_date").toString().substring(0, 10));
io_mst.put("stor_id", whereJson.get("stor_id"));
io_mst.put("stor_code", whereJson.get("stor_code"));
io_mst.put("stor_name", whereJson.get("stor_name"));
io_mst.put("detail_count", rows.size());
io_mst.put("remark", whereJson.get("remark"));
io_mst.put("source_id", whereJson.get("source_id"));
io_mst.put("source_type", whereJson.get("source_type"));
io_mst.put("bill_status", IOSEnum.BILL_STATUS.code("完成"));
io_mst.put("create_mode", IOSEnum.CREATE_MODE.code("终端产生"));
io_mst.put("input_optid", currentUserId + "");
io_mst.put("input_optname", nickName);
io_mst.put("input_time", now);
io_mst.put("update_optid", currentUserId + "");
io_mst.put("update_optname", nickName);
io_mst.put("update_time", now);
io_mst.put("is_delete", BaseDataEnum.IS_YES_NOT.code("否"));
io_mst.put("is_upload", BaseDataEnum.IS_YES_NOT.code("否"));
Long deptId = SecurityUtils.getDeptId();
io_mst.put("sysdeptid", deptId + "");
io_mst.put("syscompanyid", deptId + "");
for (int i = 0; i < rows.size(); i++) {
HashMap<String, Object> row = rows.get(i);
Object qty = ObjectUtil.isEmpty(whereJson.getBigDecimal("material_qty")) ? row.get("qty") :whereJson.getBigDecimal("material_qty");
JSONObject ioStorInvDtl = new JSONObject();
ioStorInvDtl.putAll(row);
ioStorInvDtl.put("iostorinvdtl_id", IdUtil.getStringId());
ioStorInvDtl.put("iostorinv_id", iostorinv_id);
ioStorInvDtl.put("seq_no", (i + 1) + "");
ioStorInvDtl.put("material_id", row.get("material_id"));
ioStorInvDtl.put("pcsn", row.get("pcsn"));
ioStorInvDtl.put("bill_status", IOSEnum.BILL_STATUS.code("完成"));
ioStorInvDtl.put("qty_unit_id", row.get("qty_unit_id"));
ioStorInvDtl.put("qty_unit_name", row.get("qty_unit_name"));
ioStorInvDtl.put("source_bill_type", row.get("ext_type"));
ioStorInvDtl.put("source_bill_code", row.get("ext_code"));
ioStorInvDtl.put("assign_qty", qty);
ioStorInvDtl.put("unassign_qty", "0");
ioStorInvDtl.put("plan_qty", qty);
total_qty += Double.parseDouble(qty.toString());
//判断该载具编号是否已经存在库内
Structattr structattr = iStructattrService.getOne(new LambdaQueryWrapper<>(Structattr.class).eq(Structattr::getStoragevehicle_code, row.get("storagevehicle_code")));
if (ObjectUtil.isNotEmpty(structattr)) {
throw new BadRequestException("载具编码：" + row.get("storagevehicle_code") + "已存在库内，请对数据进行核实！");
}
ioStorInvDtlMapper.insert(ioStorInvDtl.toJavaObject(IOStorInvDtl.class));
JSONObject dis = new JSONObject();
dis.put("iostorinvdis_id", IdUtil.getStringId());
dis.put("iostorinv_id", iostorinv_id);
dis.put("iostorinvdtl_id", ioStorInvDtl.getString("iostorinvdtl_id"));
dis.put("seq_no", 1);
dis.put("material_id", row.get("material_id"));
dis.put("struct_id", whereJson.getString("struct_id"));
dis.put("struct_code", whereJson.getString("struct_code"));
dis.put("struct_name", whereJson.getString("struct_name"));
dis.put("pcsn", row.get("pcsn"));
dis.put("storagevehicle_code", row.get("storagevehicle_code"));
dis.put("work_status", IOSEnum.INBILL_DIS_STATUS.code("完成"));
dis.put("is_issued", BaseDataEnum.IS_YES_NOT.code("是"));
dis.put("qty_unit_id", row.get("qty_unit_id"));
dis.put("qty_unit_name", row.get("qty_unit_name"));
dis.put("plan_qty", qty);
ioStorInvDisMapper.insert(dis.toJavaObject(IOStorInvDis.class));
}
io_mst.put("total_qty", total_qty);
ioStorInvMapper.insert(io_mst.toJavaObject(IOStorInv.class));
return iostorinv_id;
}
}

11
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/impl/SelectOutServiceImpl.java
View File

@@ -138,10 +138,15 @@ public class SelectOutServiceImpl extends ServiceImpl<IOStorInvDtlMapper, IOStor
throw new BadRequestException("请维护当前载具重量【" + pointDao.getVehicle_code() + "】");
}
// TODO 调用ACS接口获取称重信息
AcsResponse weighAcs = wmsToAcsService.getWeighAcs(new JSONObject());
JSONObject jsonResult = weighAcs.getResultData();
// 调用ACS接口获取称重信息
JSONObject jsonParam = new JSONObject();
jsonParam.put("device_code", pointDao.getPoint_code());
AcsResponse weighAcs = wmsToAcsService.getWeighAcs(jsonParam);
if (weighAcs.getStatus() != 200) {
throw new BadRequestException(weighAcs.getMessage());
}
JSONObject jsonResult = weighAcs.getResultData();
// 称重重量
double weigh_qty = NumberUtil.round(jsonResult.getDoubleValue("weigh_qty"), 2).doubleValue();
// 扣除载具重量

11
wms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/warehouse_management/service/impl/StIvtCombinedBoxServiceImpl.java
View File

@@ -185,10 +185,15 @@ public class StIvtCombinedBoxServiceImpl extends ServiceImpl<StIvtCombinedBoxMap
throw new BadRequestException("请维护当前载具重量【" + pointDao.getVehicle_code() + "】");
}
// TODO 调用ACS接口获取称重信息
AcsResponse weighAcs = wmsToAcsService.getWeighAcs(new JSONObject());
JSONObject jsonResult = weighAcs.getResultData();
// 调用ACS接口获取称重信息
JSONObject jsonParam = new JSONObject();
jsonParam.put("device_code", pointDao.getPoint_code());
AcsResponse weighAcs = wmsToAcsService.getWeighAcs(jsonParam);
if (weighAcs.getStatus() != 200) {
throw new BadRequestException(weighAcs.getMessage());
}
JSONObject jsonResult = weighAcs.getResultData();
// 称重重量
double weigh_qty = NumberUtil.round(jsonResult.getDoubleValue("weigh_qty"), 2).doubleValue();
// 扣除载具重量

26
wms/nladmin-ui/src/views/wms/basedata/group/index.vue
View File

@@ -403,13 +403,27 @@ export default {
LODOP.SET_SHOW_MODE('HIDE_DISBUTTIN_SETUP', 1)// 隐藏那些无效按钮
// 打印纸张大小设置https://www.it610.com/article/2094844.html
LODOP.PRINT_INIT('')
LODOP.SET_PRINT_PAGESIZE(1, '80mm', '60mm', '')
LODOP.ADD_PRINT_RECT('1mm', '3mm', '74mm', '54mm', 0, 1)
LODOP.SET_PRINT_STYLE('FontSize', 9)
LODOP.SET_PRINT_PAGESIZE(1, '100mm', '80mm', '')
LODOP.ADD_PRINT_RECT('1mm', '3mm', '94mm', '74mm', 0, 1)
LODOP.SET_PRINT_STYLE('FontSize', 11)
LODOP.SET_PRINT_STYLE('Bold', 1)
LODOP.ADD_PRINT_BARCODE('10mm', '15mm', '60mm', '20mm', 'QRCode', row.material_name)
LODOP.ADD_PRINT_TEXT('35mm', '15mm', '80mm', '15mm', '备件名称：' + row.material_name + '')
LODOP.ADD_PRINT_TEXT('45mm', '15mm', '80mm', '15mm', '型号：' + row.material_spec + '')
LODOP.ADD_PRINT_BARCODE('5mm', '5mm', '40mm', '40mm', 'QRCode', row.material_code + '##' + row.material_name + '##' +
row.material_spec + '##' + row.material_model + '##' + row.quality_time_day + '##' + row.produce_time + '##' +
row.supp_name + '##' + row.bake_num + '##' + row.supp_code + '##' + row.pcsn + '##' + row.execution_stand
)
LODOP.ADD_PRINT_TEXT('7mm', '48mm', '80mm', '15mm', '物料编码：' + row.material_code + '')
LODOP.ADD_PRINT_TEXT('16mm', '48mm', '80mm', '15mm', '物料名称：' + row.material_name + '')
LODOP.ADD_PRINT_TEXT('25mm', '48mm', '80mm', '15mm', '规格：' + row.material_spec + '')
LODOP.ADD_PRINT_TEXT('34mm', '48mm', '80mm', '15mm', '型号：' + row.material_model + '')
LODOP.ADD_PRINT_TEXT('43mm', '48mm', '80mm', '15mm', '有效期(天)：' + row.quality_time_day + '')
LODOP.ADD_PRINT_TEXT('52mm', '48mm', '80mm', '15mm', '生产日期：' + row.produce_time + '')
LODOP.ADD_PRINT_TEXT('61mm', '48mm', '80mm', '15mm', '供应商名称：' + row.supp_name + '')
LODOP.ADD_PRINT_TEXT('43mm', '5mm', '80mm', '15mm', '烘干次数：' + row.bake_num + '')
LODOP.ADD_PRINT_TEXT('52mm', '5mm', '80mm', '15mm', '供应商编码：' + row.supp_code + '')
LODOP.ADD_PRINT_TEXT('61mm', '5mm', '80mm', '15mm', '批号：' + row.pcsn + '')
LODOP.ADD_PRINT_TEXT('69mm', '5mm', '80mm', '15mm', '执行标准：' + row.execution_stand + '')
// LODOP.PRINT()// 打印
LODOP.PREVIEW()// 预览
}