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

Merge remote-tracking branch 'origin/master'

Browse Source
This commit is contained in:
zhangzhiqiang
2023-05-21 17:24:08 +08:00
parent 6ab3264a4d 089a45b978
commit dbf6773d47
60 changed files with 7193 additions and 1238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
mes/hd/nladmin-system/src/main/java/org/nl/common/utils/AcsUtil.java
View File

@@ -86,4 +86,40 @@ public class AcsUtil {
}
return result;
}
public static JSONObject notifyAcs(String api, JSONObject list) {
log.info("下发ACS参数----------------------------------------+"+api+",---"+list.toString());
//判断是否连接ACS系统
String isConnect = SpringContextHolder.getBean(SysParamServiceImpl.class).findByCode("IS_CONNECT_ACS").getValue();
JSONObject result = new JSONObject();
if (StrUtil.equals(StatusEnum.STATUS_FLASE.getCode(), isConnect)) {
result.put("status", HttpStatus.OK.value());
result.put("message", "下发成功，但未连接ACS!");
result.put("data", new JSONObject());
return result;
}
//ACS地址：127.0.0.1:8010
String acsUrl = SpringContextHolder.getBean(SysParamServiceImpl.class).findByCode("acs_url").getValue();
String url = acsUrl + api;
try {
String resultMsg = HttpRequest.post(url)
.body(String.valueOf(list))
.execute().body();
result = JSONObject.parseObject(resultMsg);
log.info("ACS相应参数----------------------------------------+"+api+",---"+result.toString());
} catch (Exception e) {
log.info("ACS反馈异常----------------------------------------+"+api+",---"+e.getMessage());
String msg = e.getMessage();
//ConnectException: Connection refused: connect
//网络不通
result.put("status", HttpStatus.BAD_REQUEST);
result.put("message", "网络不通,操作失败!");
result.put("data", new JSONObject());
result.put("error", msg);
}
return result;
}
}

2
mes/hd/nladmin-system/src/main/java/org/nl/wms/ext/acs/service/impl/AcsToWmsServiceImpl.java
View File

@@ -283,7 +283,7 @@ public class AcsToWmsServiceImpl implements AcsToWmsService{
String vehicleCode = collect[i];
cachePosition.put("vehicle_code",vehicleCode.equals("0")?"": vehicleCode);
if (vehicleCode.equals("99999")){
cachePosition.put("err_type", StatusEnum.CACHE_POINT_SCAN_ERROR.getCode());
cachePosition.put("err_type", StatusEnum.CACHE_POINT_ERROR.getCode());
}
positionTab.update(cachePosition,"position_code = '"+cachePosition.getString("position_code")+"'");
}

8
mes/hd/nladmin-system/src/main/java/org/nl/wms/masterdata_manage/storage/controller/material/StructrelamaterialController.java
View File

@@ -1,3 +1,4 @@
/*
package org.nl.wms.masterdata_manage.storage.controller.material;
@@ -7,8 +8,6 @@ import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.nl.common.anno.Log;
import org.nl.wms.masterdata_manage.备份st.service.StructrelamaterialService;
import org.nl.wms.masterdata_manage.备份st.service.dto.StructrelamaterialDto;
import org.springframework.data.domain.Pageable;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
@@ -17,10 +16,12 @@ import org.springframework.web.bind.annotation.*;
import java.util.Map;
*/
/**
* @author zhouz
* @date 2021-12-09
**/
**//*
@RestController
@RequiredArgsConstructor
@Api(tags = "物料存放设置管理")
@@ -83,3 +84,4 @@ public class StructrelamaterialController {
return new ResponseEntity<>(HttpStatus.OK);
}
}
*/

519
mes/hd/nladmin-system/src/main/java/org/nl/wms/pda_manage/pda/rest/CacheLineHandController.java
View File

@@ -34,298 +34,287 @@ import java.util.regex.Pattern;
@RequestMapping("/api/cacheLineHand")
@Slf4j
@SaIgnore
public class CacheLineHandController{
private final CacheLineHandService cacheLineHandService;
public class CacheLineHandController {
private final CacheLineHandService cacheLineHandService;
@PostMapping("/queryMaterial")
@Log("物料查询")
@ApiOperation("物料查询")
public ResponseEntity<List<MaterialDto>> queryMaterial(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [查询物料] 接口被请求, 请求参数-{}", form);
String params = form.getString("search_bar");
checkLength(params);
return new ResponseEntity<>(cacheLineHandService.queryMaterial(params), HttpStatus.OK);
}
@PostMapping("/queryMaterial")
@Log("物料查询")
@ApiOperation("物料查询")
public ResponseEntity<List<MaterialDto>> queryMaterial(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [查询物料] 接口被请求, 请求参数-{}", form);
String params = form.getString("search_bar");
checkLength(params);
return new ResponseEntity<>(cacheLineHandService.queryMaterial(params), HttpStatus.OK);
}
@PostMapping("/materialQuery")
@Log("物料模糊查询")
@ApiOperation("物料模糊查询")
public ResponseEntity<JSONArray> materialQuery(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [查询物料] 接口被请求, 请求参数-{}", form);
//String params = form.getString("search_bar");
//checkLength(params);
return new ResponseEntity<>(cacheLineHandService.materialQuery(form.getString("search_bar")), HttpStatus.OK);
}
@PostMapping("/materialQuery")
@Log("物料模糊查询")
@ApiOperation("物料模糊查询")
public ResponseEntity<JSONArray> materialQuery(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [查询物料] 接口被请求, 请求参数-{}", form);
//String params = form.getString("search_bar");
//checkLength(params);
return new ResponseEntity<>(cacheLineHandService.materialQuery(form.getString("search_bar")), HttpStatus.OK);
}
@PostMapping("/appUpdate")
@Log("app更新")
@ApiOperation("app更新")
@SaIgnore
public ResponseEntity<JSONArray> appUpdate() {
log.info("海亮缓存线手持服务 [app更新] 接口被请求");
return new ResponseEntity<>(cacheLineHandService.appUpdate(), HttpStatus.OK);
}
@PostMapping("/appUpdate")
@Log("app更新")
@ApiOperation("app更新")
@SaIgnore
public ResponseEntity<JSONArray> appUpdate() {
log.info("海亮缓存线手持服务 [app更新] 接口被请求");
return new ResponseEntity<>(cacheLineHandService.appUpdate(), HttpStatus.OK);
}
/**
* 输入搜索条件校验，限制查询参数过短，模糊力度大
*/
private void checkLength(String params) {
if(StringUtils.isNotBlank(params)) {
int length = params.getBytes().length;
//限制查询参数过短，模糊力度大
if(Pattern.compile("[0-9a-zA-Z]+").matcher(params).matches() || Pattern.compile("\\d+").matcher(params).matches()) {
if(length < 5) {
throw new BizCoreException("输入条件所查询的内容过多，请输入大于4个字的查询条件。");
}
}
else if(Pattern.compile("[\u4e00-\u9fa5]+").matcher(params).matches()) {
if(length < 9) {
throw new BizCoreException("输入条件所查询的内容过多，请输入大于3个字的查询条件。");
}
}
else if(length < 4) {
/**
* 输入搜索条件校验，限制查询参数过短，模糊力度大
*/
private void checkLength(String params) {
if (StringUtils.isNotBlank(params)) {
int length = params.getBytes().length;
//限制查询参数过短，模糊力度大
if (Pattern.compile("[0-9a-zA-Z]+").matcher(params).matches() || Pattern.compile("\\d+").matcher(params).matches()) {
if (length < 5) {
throw new BizCoreException("输入条件所查询的内容过多，请输入大于4个字的查询条件。");
}
} else if (Pattern.compile("[\u4e00-\u9fa5]+").matcher(params).matches()) {
if (length < 9) {
throw new BizCoreException("输入条件所查询的内容过多，请输入大于3个字的查询条件。");
}
}
}
}
} else if (length < 4) {
throw new BizCoreException("输入条件所查询的内容过多，请输入大于3个字的查询条件。");
}
}
}
@PostMapping("/semiMaterialSpecQuery")
@Log("规格下拉框查询")
@ApiOperation("规格下拉框查询")
public ResponseEntity<JSONArray> semiMaterialSpecQuery(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [规格下拉框查询] 接口被请求, 请求参数-{}", form);
return new ResponseEntity<>(cacheLineHandService.semiMaterialSpecQuery(form.getString("search_bar")), HttpStatus.OK);
}
@PostMapping("/semiMaterialSpecQuery")
@Log("规格下拉框查询")
@ApiOperation("规格下拉框查询")
public ResponseEntity<JSONArray> semiMaterialSpecQuery(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [规格下拉框查询] 接口被请求, 请求参数-{}", form);
return new ResponseEntity<>(cacheLineHandService.semiMaterialSpecQuery(form.getString("search_bar")), HttpStatus.OK);
}
@PostMapping("/workprocedureQuery")
@Log("工序下拉框查询")
@ApiOperation("工序下拉框查询")
public ResponseEntity<JSONArray> workProcedureQuery(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [工序下拉框查询] 接口被请求, 请求参数-{}", form);
return new ResponseEntity<>(cacheLineHandService.workProcedureQuery(form.getString("search_bar")), HttpStatus.OK);
}
@PostMapping("/workprocedureQuery")
@Log("工序下拉框查询")
@ApiOperation("工序下拉框查询")
public ResponseEntity<JSONArray> workProcedureQuery(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [工序下拉框查询] 接口被请求, 请求参数-{}", form);
return new ResponseEntity<>(cacheLineHandService.workProcedureQuery(form.getString("search_bar")), HttpStatus.OK);
}
@PostMapping("/deviceQuery")
@Log("缓存线设备下拉框查询")
@ApiOperation("缓存线设备下拉框查询")
public ResponseEntity<JSONArray> deviceQuery(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [缓存线设备下拉框查询] 接口被请求, 请求参数-{}", form);
return new ResponseEntity<>(cacheLineHandService.deviceQuery(form.getString("search_bar")), HttpStatus.OK);
}
@PostMapping("/deviceQuery")
@Log("缓存线设备下拉框查询")
@ApiOperation("缓存线设备下拉框查询")
public ResponseEntity<JSONArray> deviceQuery(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [缓存线设备下拉框查询] 接口被请求, 请求参数-{}", form);
return new ResponseEntity<>(cacheLineHandService.deviceQuery(form.getString("search_bar")), HttpStatus.OK);
}
@PostMapping("/instStatusQuery")
@Log("指令状态下拉框查询")
@ApiOperation("指令状态下拉框查询")
public ResponseEntity<JSONArray> instStatusQuery(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [指令状态下拉框查询] 接口被请求, 请求参数-{}", form);
return new ResponseEntity<>(cacheLineHandService.instStatusQuery(form.getString("search_bar")), HttpStatus.OK);
}
@PostMapping("/instStatusQuery")
@Log("指令状态下拉框查询")
@ApiOperation("指令状态下拉框查询")
public ResponseEntity<JSONArray> instStatusQuery(@RequestBody JSONObject form) {
log.info("海亮缓存线手持服务 [指令状态下拉框查询] 接口被请求, 请求参数-{}", form);
return new ResponseEntity<>(cacheLineHandService.instStatusQuery(form.getString("search_bar")), HttpStatus.OK);
}
@PostMapping("/instPageQuery")
@Log("任务操作-查询")
@ApiOperation("任务操作-查询")
public ResponseEntity<Object> instPageQuery(@RequestBody Map<String,String> param, Pageable page) {
log.info("海亮缓存线手持服务 [任务操作-查询] 接口被请求, 请求参数-{}", param);
if(null == param) {
throw new BizCoreException(ResultCode.VALIDATE_FAILED);
}
return new ResponseEntity<>(cacheLineHandService.instPageQuery(param, page), HttpStatus.OK);
}
@PostMapping("/instPageQuery")
@Log("任务操作-查询")
@ApiOperation("任务操作-查询")
public ResponseEntity<Object> instPageQuery(@RequestBody Map<String, String> param, Pageable page) {
log.info("海亮缓存线手持服务 [任务操作-查询] 接口被请求, 请求参数-{}", param);
if (null == param) {
throw new BizCoreException(ResultCode.VALIDATE_FAILED);
}
return new ResponseEntity<>(cacheLineHandService.instPageQuery(param, page), HttpStatus.OK);
}
@PostMapping("/instOperation")
@Log("任务操作")
@ApiOperation("任务操作")
public ResponseEntity<Object> instOperation(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [任务操作] 接口被请求, 请求参数-{}", param);
//任务类型和任务ID校验，instruct_uuid为前端参数命名，本来应为task_id
if(StringUtils.isBlank(param.getString("instruct_uuid")) || StringUtils.isBlank(param.getString("opt_type"))) {
throw new BizCoreException("ResultCode.VALIDATE_FAILED");
}
return new ResponseEntity<>(cacheLineHandService.instOperation(param), HttpStatus.OK);
}
@PostMapping("/instOperation")
@Log("任务操作")
@ApiOperation("任务操作")
public ResponseEntity<Object> instOperation(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [任务操作] 接口被请求, 请求参数-{}", param);
//任务类型和任务ID校验，instruct_uuid为前端参数命名，本来应为task_id
if (StringUtils.isBlank(param.getString("instruct_uuid")) || StringUtils.isBlank(param.getString("opt_type"))) {
throw new BizCoreException("ResultCode.VALIDATE_FAILED");
}
return new ResponseEntity<>(cacheLineHandService.instOperation(param), HttpStatus.OK);
}
@PostMapping("/cacheLineOutBoxExceptionQuery")
@Log("缓存线出箱异常-查询")
@ApiOperation("缓存线出箱异常-查询")
public ResponseEntity<JSONArray> cacheLineOutBoxExceptionQuery(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线出箱异常-查询] 接口被请求, 请求参数-{}", param);
//参数校验
if(StringUtils.isBlank(param.getString("wcsdevice_code"))) {
throw new BizCoreException("请选择缓存线并输入缓存线位置编号再查询");
}
if(StringUtils.isBlank(param.getString("position_code"))) {
throw new BizCoreException("请输入缓存线位置编号再查询");
}
return new ResponseEntity<>(cacheLineHandService.cacheLineOutBoxExceptionQuery(param), HttpStatus.OK);
}
@PostMapping("/cacheLineOutBoxExceptionQuery")
@Log("缓存线出箱异常-查询")
@ApiOperation("缓存线出箱异常-查询")
public ResponseEntity<Object> cacheLineOutBoxExceptionQuery(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线出箱异常-查询] 接口被请求, 请求参数-{}", param);
//参数校验
if (StringUtils.isBlank(param.getString("wcsdevice_code"))) {
throw new BizCoreException("请选择缓存线并输入缓存线位置编号再查询");
}
if (StringUtils.isBlank(param.getString("position_code"))) {
throw new BizCoreException("请输入缓存线位置编号再查询");
}
return new ResponseEntity<>(cacheLineHandService.cacheLineOutBoxExceptionQuery(param), HttpStatus.OK);
}
@PostMapping("/cacheLineOutBoxExceptionConfirm")
@Log("缓存线出箱异常-确认")
@ApiOperation("缓存线出箱异常-确认")
public ResponseEntity<Object> cacheLineOutBoxExceptionConfirm(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线出箱异常-确认] 接口被请求, 请求参数-{}", param);
//参数校验
if(StringUtils.isBlank(param.getString("vehicle_code"))) {
throw new BizCoreException("请输入料箱码");
}
if(StringUtils.isBlank(param.getString("wcsdevice_code")) || StringUtils.isBlank(param.getString("position_code"))) {
throw new BizCoreException("请输入缓存线位置编号与缓存线编号");
}
return new ResponseEntity<>(cacheLineHandService.cacheLineOutBoxExceptionConfirm(param), HttpStatus.OK);
}
@PostMapping("/cacheLineOutBoxExceptionConfirm")
@Log("缓存线出箱异常-确认")
@ApiOperation("缓存线出箱异常-确认")
public ResponseEntity<Object> cacheLineOutBoxExceptionConfirm(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线出箱异常-确认] 接口被请求, 请求参数-{}", param);
//参数校验
if (StringUtils.isBlank(param.getString("vehicle_code"))) {
throw new BizCoreException("请输入料箱码");
}
if (StringUtils.isBlank(param.getString("wcsdevice_code")) || StringUtils.isBlank(param.getString("position_code"))) {
throw new BizCoreException("请输入缓存线位置编号与缓存线编号");
}
return new ResponseEntity<>(cacheLineHandService.cacheLineOutBoxExceptionConfirm(param), HttpStatus.OK);
}
@PostMapping("/inOutExceptionInstQuery")
@Log("缓存线扫码异常-查询")
@ApiOperation("缓存线扫码异常-查询")
public ResponseEntity<JSONArray> inOutExceptionInstQuery(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线扫码异常-查询] 接口被·请求, 请求参数-{}", param);
//参数校验
if(StringUtils.isBlank(param.getString("wcsdevice_code"))) {
throw new BizCoreException("请选择缓存线编号!");
}
return new ResponseEntity<>(cacheLineHandService.inOutExceptionInstQuery(param), HttpStatus.OK);
}
@PostMapping("/inOutExceptionInstQuery")
@Log("缓存线扫码异常-查询")
@ApiOperation("缓存线扫码异常-查询")
public ResponseEntity<Object> inOutExceptionInstQuery(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线扫码异常-查询] 接口被·请求, 请求参数-{}", param);
//参数校验
if (StringUtils.isBlank(param.getString("wcsdevice_code"))) {
throw new BizCoreException("请选择缓存线编号!");
}
return new ResponseEntity<>(cacheLineHandService.inOutExceptionInstQuery(param), HttpStatus.OK);
}
@PostMapping("/inOutExceptionInstConfirm")
@Log("扫码异常确认")
@ApiOperation("扫码异常确认")
public ResponseEntity<Object> inOutExceptionInstConfirm(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [扫码异常确认] 接口被请求, 请求参数-{}", param);
//参数校验
if(StringUtils.isBlank(param.getString("type")) || StringUtils.isBlank(param.getString("wcsdevice_code")) || StringUtils.isBlank(param.getString("vehicle_code"))) {
throw new BizCoreException("请确认缓存线，位置，料箱码是否都已选择或填入！");
}
return new ResponseEntity<>(cacheLineHandService.inOutExceptionInstConfirm(param), HttpStatus.OK);
}
@PostMapping("/inOutExceptionInstConfirm")
@Log("扫码异常确认")
@ApiOperation("扫码异常确认")
public ResponseEntity<Object> inOutExceptionInstConfirm(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [扫码异常确认] 接口被请求, 请求参数-{}", param);
//参数校验
if (StringUtils.isBlank(param.getString("type")) || StringUtils.isBlank(param.getString("wcsdevice_code")) || StringUtils.isBlank(param.getString("vehicle_code"))) {
throw new BizCoreException("请确认缓存线，位置，料箱码是否都已选择或填入！");
}
return new ResponseEntity<>(cacheLineHandService.inOutExceptionInstConfirm(param), HttpStatus.OK);
}
@PostMapping("/cacheLineMaterInfoQuery")
@Log("缓存线料箱条码查询料箱信息")
@ApiOperation("缓存线料箱条码查询料箱信息")
public ResponseEntity<JSONArray> cacheLineMaterInfoQuery(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线料箱条码查询料箱信息] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.cacheLineMaterInfoQuery(param), HttpStatus.OK);
}
@PostMapping("/cacheLineMaterInfoQuery")
@Log("缓存线料箱条码查询料箱信息")
@ApiOperation("缓存线料箱条码查询料箱信息")
public ResponseEntity<JSONArray> cacheLineMaterInfoQuery(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线料箱条码查询料箱信息] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.cacheLineMaterInfoQuery(param), HttpStatus.OK);
}
@PostMapping("/inOutEmptyBox")
@Log("空箱初始化--出入空箱")
@ApiOperation("空箱初始化--出入空箱")
public ResponseEntity<Object> inOutEmptyBox(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [空箱初始化--出入空箱] 接口被请求, 请求参数-{}", param);
//参数校验
if(StringUtils.isBlank(param.getString("inOut_type")) || StringUtils.isBlank(param.getString("wcsdevice_code")) || StringUtils.isBlank(param.getString("vehicle_code"))) {
throw new BizCoreException(ResultCode.VALIDATE_FAILED);
}
return new ResponseEntity<>(cacheLineHandService.inOutEmptyBox(param), HttpStatus.OK);
}
@PostMapping("/inOutEmptyBox")
@Log("空箱初始化--出入空箱")
@ApiOperation("空箱初始化--出入空箱")
public ResponseEntity<Object> inOutEmptyBox(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [空箱初始化--出入空箱] 接口被请求, 请求参数-{}", param);
//参数校验
if (StringUtils.isBlank(param.getString("inOut_type")) || StringUtils.isBlank(param.getString("wcsdevice_code")) || StringUtils.isBlank(param.getString("vehicle_code"))) {
throw new BizCoreException(ResultCode.VALIDATE_FAILED);
}
return new ResponseEntity<>(cacheLineHandService.inOutEmptyBox(param), HttpStatus.OK);
}
@PostMapping("/setfullBox")
@Log("设置满框")
@ApiOperation("设置满框")
public ResponseEntity<Object> setfullBox(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [设置满框] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.setfullBox(param), HttpStatus.OK);
}
@PostMapping("/setfullBox")
@Log("设置满框")
@ApiOperation("设置满框")
public ResponseEntity<Object> setfullBox(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [设置满框] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.setfullBox(param), HttpStatus.OK);
}
@PostMapping("/setEmptyBox")
@Log("设置空框")
@ApiOperation("设置空框")
public ResponseEntity<Object> setEmptyBox(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [设置空框] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.setEmptyBox(param), HttpStatus.OK);
}
@PostMapping("/setEmptyBox")
@Log("设置空框")
@ApiOperation("设置空框")
public ResponseEntity<Object> setEmptyBox(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [设置空框] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.setEmptyBox(param), HttpStatus.OK);
}
@PostMapping("/deleteBox")
@Log("删除箱子")
@ApiOperation("删除箱子")
public ResponseEntity<Object> deleteBox(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [设置空框] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.deleteBox(param), HttpStatus.OK);
}
@PostMapping("/deleteBox")
@Log("删除箱子")
@ApiOperation("删除箱子")
public ResponseEntity<Object> deleteBox(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [设置空框] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.deleteBox(param), HttpStatus.OK);
}
@PostMapping("/agvInBoxExceptionQuery")
@Log("AGV入箱异常-查询")
@ApiOperation("AGV入箱异常-查询")
public ResponseEntity<JSONArray> agvInBoxExceptionQuery(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [AGV入箱异常-查询] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.agvInBoxExceptionQuery(param), HttpStatus.OK);
}
@PostMapping("/agvInBoxExceptionQuery")
@Log("AGV入箱异常-查询")
@ApiOperation("AGV入箱异常-查询")
public ResponseEntity<JSONArray> agvInBoxExceptionQuery(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [AGV入箱异常-查询] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.agvInBoxExceptionQuery(param), HttpStatus.OK);
}
@PostMapping("/agvInBoxExceptionConfirm")
@Log("AGV入箱异常-确认")
@ApiOperation("AGV入箱异常-确认")
public ResponseEntity<Object> agvInBoxExceptionConfirm(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [AGV入箱异常-确认] 接口被请求, 请求参数-{}", param);
cacheLineHandService.agvInBoxExceptionConfirm(param);
return new ResponseEntity<>(HttpStatus.OK);
}
@PostMapping("/agvInBoxExceptionConfirm")
@Log("AGV入箱异常-确认")
@ApiOperation("AGV入箱异常-确认")
public ResponseEntity<Object> agvInBoxExceptionConfirm(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [AGV入箱异常-确认] 接口被请求, 请求参数-{}", param);
cacheLineHandService.agvInBoxExceptionConfirm(param);
return new ResponseEntity<>(HttpStatus.OK);
}
@PostMapping("/agvOutBoxExceptionQuery")
@Log("AGV异常-查询")
@ApiOperation("AGV异常-查询")
public ResponseEntity<JSONArray> agvOutBoxExceptionQuery(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [AGV异常-查询] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.agvOutBoxExceptionQuery(param), HttpStatus.OK);
}
@PostMapping("/agvOutBoxExceptionQuery")
@Log("AGV异常-查询")
@ApiOperation("AGV异常-查询")
public ResponseEntity<JSONArray> agvOutBoxExceptionQuery(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [AGV异常-查询] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.agvOutBoxExceptionQuery(param), HttpStatus.OK);
}
@PostMapping("/agvOutBoxExceptionConfirm")
@Log("AGV异常-确认")
@ApiOperation("AGV异常-确认")
public ResponseEntity<Object> agvOutBoxExceptionConfirm(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [AGV异常-确认] 接口被请求, 请求参数-{}", param);
cacheLineHandService.agvOutBoxExceptionConfirm(param);
return new ResponseEntity<>(HttpStatus.OK);
}
@PostMapping("/agvOutBoxExceptionConfirm")
@Log("AGV异常-确认")
@ApiOperation("AGV异常-确认")
public ResponseEntity<Object> agvOutBoxExceptionConfirm(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [AGV异常-确认] 接口被请求, 请求参数-{}", param);
cacheLineHandService.agvOutBoxExceptionConfirm(param);
return new ResponseEntity<>(HttpStatus.OK);
}
@PostMapping("/setBlankPos")
@Log("设置缓存线货位为空位置")
@ApiOperation("设置缓存线货位为空位置")
public ResponseEntity<Object> setBlankPos(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [设置缓存线货位为空位置] 接口被请求, 请求参数-{}", param);
cacheLineHandService.setBlankPos(param);
return new ResponseEntity<>(HttpStatus.OK);
}
@PostMapping("/cacheLineExcepOpt")
@Log("缓存线异常处理")
@ApiOperation("缓存线异常处理")
public ResponseEntity<Object> cacheLineExcepOpt(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线异常处理] 接口被请求, 请求参数-{}", param);
//参数校验
if (StringUtils.isBlank(param.getString("wcsdevice_code")) || StringUtils.isBlank(param.getString("opt_type"))) {
throw new BizCoreException(ResultCode.VALIDATE_FAILED);
}
return new ResponseEntity<>(cacheLineHandService.cacheLineExcepOpt(param), HttpStatus.OK);
}
@PostMapping("/cacheLineExcepOpt")
@Log("缓存线异常处理")
@ApiOperation("缓存线异常处理")
public ResponseEntity<Object> cacheLineExcepOpt(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线异常处理] 接口被请求, 请求参数-{}", param);
//参数校验
if(StringUtils.isBlank(param.getString("wcsdevice_code")) || StringUtils.isBlank(param.getString("opt_type"))) {
throw new BizCoreException(ResultCode.VALIDATE_FAILED);
}
return new ResponseEntity<>(cacheLineHandService.cacheLineExcepOpt(param), HttpStatus.OK);
}
@PostMapping("/pourMaterial")
@Log("倒料操作")
@ApiOperation("倒料操作")
public ResponseEntity<Object> pourMaterial(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [倒料操作] 接口被请求, 请求参数-{}", param);
cacheLineHandService.pourMaterial(param);
return new ResponseEntity<>(HttpStatus.OK);
}
@PostMapping("/pourMaterial")
@Log("倒料操作")
@ApiOperation("倒料操作")
public ResponseEntity<Object> pourMaterial(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [倒料操作] 接口被请求, 请求参数-{}", param);
cacheLineHandService.pourMaterial(param);
return new ResponseEntity<>(HttpStatus.OK);
}
@PostMapping("/getCacheLine")
@Log("缓存线下拉框")
@ApiOperation("缓存线下拉框")
public ResponseEntity<JSONArray> getCacheLine(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线盘点-缓存线下拉框] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.getCacheLine(param), HttpStatus.OK);
}
@PostMapping("/getCacheLine")
@Log("缓存线下拉框")
@ApiOperation("缓存线下拉框")
public ResponseEntity<JSONArray> getCacheLine(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线盘点-缓存线下拉框] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.getCacheLine(param), HttpStatus.OK);
}
@PostMapping("/getProductArea")
@Log("获取生产区域下拉框")
@ApiOperation("获取生产区域下拉框")
public ResponseEntity<JSONArray> getProductArea() {
return new ResponseEntity<>(cacheLineHandService.getProductArea(), HttpStatus.OK);
}
@PostMapping("/getProductArea")
@Log("获取生产区域下拉框")
@ApiOperation("获取生产区域下拉框")
public ResponseEntity<JSONArray> getProductArea() {
return new ResponseEntity<>(cacheLineHandService.getProductArea(), HttpStatus.OK);
}
@PostMapping("/getCacheLineMaterialInfo")
@Log("缓存线物料信息盘点")
@ApiOperation("缓存线物料信息盘点")
public ResponseEntity<JSONArray> getCacheLineMaterialInfo(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线盘点-缓存线物料信息盘点] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.getCacheLineMaterialInfo(param), HttpStatus.OK);
}
@PostMapping("/getCacheLineMaterialInfo")
@Log("缓存线物料信息盘点")
@ApiOperation("缓存线物料信息盘点")
public ResponseEntity<Object> getCacheLineMaterialInfo(@RequestBody JSONObject param) {
log.info("海亮缓存线手持服务 [缓存线盘点-缓存线物料信息盘点] 接口被请求, 请求参数-{}", param);
return new ResponseEntity<>(cacheLineHandService.getCacheLineMaterialInfo(param), HttpStatus.OK);
}
}

19
mes/hd/nladmin-system/src/main/java/org/nl/wms/pda_manage/pda/service/CacheLineHandService.java
View File

@@ -134,7 +134,7 @@ public interface CacheLineHandService{
* @author gbx
* @date 2023/3/24
*/
JSONArray inOutExceptionInstQuery(JSONObject param);
List<Map> inOutExceptionInstQuery(JSONObject param);
/**
* 扫码异常确认
@@ -164,7 +164,7 @@ public interface CacheLineHandService{
* @author gbx
* @date 2023/3/24
*/
CommonResult<Integer> cacheLineOutBoxExceptionConfirm(JSONObject param);
JSONObject cacheLineOutBoxExceptionConfirm(JSONObject param);
/**
* 空箱初始化--出入空箱
@@ -184,7 +184,7 @@ public interface CacheLineHandService{
* @author gbx
* @date 2023/3/24
*/
CommonResult<Integer> setfullBox(JSONObject param);
JSONObject setfullBox(JSONObject param);
/**
* 设置空框
@@ -233,15 +233,6 @@ public interface CacheLineHandService{
*/
void agvOutBoxExceptionConfirm(JSONObject param);
/**
* 设置缓存线货位为空位置
*
* @param param 查询参数
* @author gbx
* @date 2023/3/24
*/
void setBlankPos(JSONObject param);
/**
* 缓存线出箱异常-查询
*
@@ -250,7 +241,7 @@ public interface CacheLineHandService{
* @author gbx
* @date 2023/3/24
*/
JSONArray cacheLineOutBoxExceptionQuery(JSONObject param);
List<Map> cacheLineOutBoxExceptionQuery(JSONObject param);
/**
* 缓存线异常处理
@@ -286,7 +277,7 @@ public interface CacheLineHandService{
* @param param
* @return
*/
JSONArray getCacheLineMaterialInfo(JSONObject param);
List<Map> getCacheLineMaterialInfo(JSONObject param);
/**
* 获取生产区域下拉框

1609
mes/hd/nladmin-system/src/main/java/org/nl/wms/pda_manage/pda/service/impl/CacheLineHandServiceImpl.java
View File

File diff suppressed because it is too large Load Diff

26
mes/hd/nladmin-system/src/main/java/org/nl/wms/pda_manage/pda/wql/PDA_QUERY.wql
View File

@@ -173,17 +173,17 @@
IF 输入.flag = "7"
QUERY
SELECT
p.point_code as value,
p.point_name as text
device_code AS value,
device_name AS text
FROM
sch_base_point p
pdm_bi_device
WHERE
p.region_code = 'A1_HCX'
OPTION 输入.product_area <> ""
p.product_area = 输入.product_area
ENDOPTION
device_code like '%HCX%'
OPTION 输入.product_area <> ""
product_area = 输入.product_area
ENDOPTION
ORDER BY
p.point_code
device_code
ENDSELECT
ENDQUERY
ENDIF
@@ -210,13 +210,9 @@
LEFT JOIN sch_cacheline_vehilematerial ON sch_cacheline_position.vehicle_code = sch_cacheline_vehilematerial.vehicle_code
LEFT JOIN md_me_materialbase ON md_me_materialbase.material_id = sch_cacheline_vehilematerial.material_id
WHERE
1 = 1
OPTION 输入.product_area <> ""
sch_cacheline_position.product_area = 输入.product_area
ENDOPTION
OPTION 输入.cacheline_code <> ""
sch_cacheline_position.cacheline_code = 输入.cacheline_code
ENDOPTION
sch_cacheline_position.product_area = 输入.product_area
AND
sch_cacheline_position.cacheline_code = 输入.cacheline_code
ORDER BY
sch_cacheline_position.cacheline_code, sch_cacheline_position.layer_num, sch_cacheline_position.positionorder_no, sch_cacheline_position.cache_line_no
ENDSELECT

3
mes/hd/nladmin-system/src/main/java/org/nl/wms/scheduler_manage/service/cacheline/dao/SchCachelinePosition.java
View File

@@ -1,6 +1,8 @@
package org.nl.wms.scheduler_manage.service.cacheline.dao;
import java.math.BigDecimal;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import lombok.Data;
@@ -24,6 +26,7 @@ public class SchCachelinePosition implements Serializable {
/**
* 缓存线位置表-位置编码
*/
@TableId(value = "position_code")
private String position_code;
/**

3
mes/hd/nladmin-system/src/main/java/org/nl/wms/scheduler_manage/service/cacheline/dao/SchCachelineVehicle.java
View File

@@ -1,6 +1,8 @@
package org.nl.wms.scheduler_manage.service.cacheline.dao;
import java.math.BigDecimal;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import lombok.Data;
@@ -24,6 +26,7 @@ public class SchCachelineVehicle implements Serializable {
/**
* 缓存线载具表-编码
*/
@TableId(value = "vehicle_code")
private String vehicle_code;
/**

3
mes/hd/nladmin-system/src/main/java/org/nl/wms/scheduler_manage/service/cacheline/dao/SchCachelineVehilematerial.java
View File

@@ -1,6 +1,8 @@
package org.nl.wms.scheduler_manage.service.cacheline.dao;
import java.math.BigDecimal;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import lombok.Data;
@@ -24,6 +26,7 @@ public class SchCachelineVehilematerial implements Serializable {
/**
* 载具物料表-物料标识
*/
@TableId(value = "vehmaterial_id")
private String vehmaterial_id;
/**

5
mes/hd/nladmin-system/src/main/java/org/nl/wms/scheduler_manage/service/cacheline/dao/mapper/SchCachelinePositionMapper.java
View File

@@ -1,8 +1,12 @@
package org.nl.wms.scheduler_manage.service.cacheline.dao.mapper;
import org.apache.ibatis.annotations.Param;
import org.nl.wms.scheduler_manage.service.cacheline.dao.SchCachelinePosition;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
/**
* <p>
* 缓存线位置表 Mapper 接口
@@ -13,4 +17,5 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
*/
public interface SchCachelinePositionMapper extends BaseMapper<SchCachelinePosition> {
List<Map> getPositionInfo(@Param("map") Map map);
}

5
mes/hd/nladmin-system/src/main/java/org/nl/wms/scheduler_manage/service/cacheline/dao/mapper/SchCachelineVehilematerialMapper.java
View File

@@ -1,8 +1,12 @@
package org.nl.wms.scheduler_manage.service.cacheline.dao.mapper;
import org.apache.ibatis.annotations.Param;
import org.nl.wms.scheduler_manage.service.cacheline.dao.SchCachelineVehilematerial;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
/**
* <p>
* 缓存线载具物料表 Mapper 接口
@@ -13,4 +17,5 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
*/
public interface SchCachelineVehilematerialMapper extends BaseMapper<SchCachelineVehilematerial> {
List<Map> getErrorVeh(@Param("cacheline_code") String cacheline_code);
}

30
mes/hd/nladmin-system/src/main/java/org/nl/wms/scheduler_manage/service/cacheline/dao/mapper/xml/SchCachelinePositionMapper.xml
View File

@@ -2,4 +2,34 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.nl.wms.scheduler_manage.service.cacheline.dao.mapper.SchCachelinePositionMapper">
<select id="getPositionInfo" resultType="java.util.Map">
SELECT
scp.cacheline_code,
scp.position_code,
scp.position_name,
scp.vehicle_code,
scp.layer_num,
scp.positionorder_no as seat_order_num,
sch_cacheline_vehilematerial.workprocedure_code,
sch_cacheline_vehilematerial.workprocedure_name,
sch_cacheline_vehilematerial.material_id as material_uuid,
mb.material_code,
mb.material_name,
mb.material_spec,
sch_cacheline_vehilematerial.quantity,
sch_cacheline_vehilematerial.weight,
IF(length(scp.vehicle_code) > 0, IFNULL(sch_cacheline_vehilematerial.vehicle_status, 4), 1) AS vehicle_status
FROM
sch_cacheline_position scp
LEFT JOIN sch_cacheline_vehilematerial ON scp.vehicle_code = sch_cacheline_vehilematerial.vehicle_code
LEFT JOIN md_me_materialbase mb ON mb.material_id = sch_cacheline_vehilematerial.material_id
<where>
scp.cacheline_code = #{map.cacheline_code}
<if test="map.product_area != null and map.product_area != ''">
and scp.product_area = #{map.product_area}
</if>
</where>
ORDER BY
scp.cacheline_code, scp.layer_num, scp.positionorder_no, scp.cache_line_no
</select>
</mapper>

22
mes/hd/nladmin-system/src/main/java/org/nl/wms/scheduler_manage/service/cacheline/dao/mapper/xml/SchCachelineVehilematerialMapper.xml
View File

@@ -2,4 +2,26 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.nl.wms.scheduler_manage.service.cacheline.dao.mapper.SchCachelineVehilematerialMapper">
<select id="getErrorVeh" resultType="java.util.Map">
SELECT
*
FROM
(
SELECT
v.vehicle_code,
p.position_code,
p.cacheline_code
FROM
sch_cacheline_vehilematerial v
LEFT JOIN sch_cacheline_position p ON v.vehicle_code = p.vehicle_code
WHERE
v.err_type = 2
AND v.is_delete = 0
) a
<where>
<if test="cacheline_code != null and cacheline_code != ''">
a.cacheline_code = #{cacheline_code}
</if>
</where>
</select>
</mapper>

5
mes/hd/nladmin-system/src/main/java/org/nl/wms/scheduler_manage/service/task/dao/mapper/SchBaseTaskMapper.java
View File

@@ -1,8 +1,12 @@
package org.nl.wms.scheduler_manage.service.task.dao.mapper;
import org.apache.ibatis.annotations.Param;
import org.nl.wms.scheduler_manage.service.task.dao.SchBaseTask;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
/**
* <p>
* 任务表 Mapper 接口
@@ -13,4 +17,5 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
*/
public interface SchBaseTaskMapper extends BaseMapper<SchBaseTask> {
List<Map> getTaskInfo (@Param("map") Map map);
}

29
mes/hd/nladmin-system/src/main/java/org/nl/wms/scheduler_manage/service/task/dao/mapper/xml/SchBaseTaskMapper.xml
View File

@@ -2,4 +2,33 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.nl.wms.scheduler_manage.service.task.dao.mapper.SchBaseTaskMapper">
<select id="getTaskInfo" resultType="java.util.Map">
SELECT
task.task_id AS instruct_uuid,
task.task_code AS instructoperate_num,
task.task_name,
task.product_area,
class.class_name task_type,
task.vehicle_code,
task.vehicle_code2 AS outvehicle_code,
task.create_time,
dict.label AS status_name,
mater.material_code AS processmaterial_code,
point1.point_name AS startpoint_code,
point2.point_name AS nextpoint_code
FROM
sch_base_task task
LEFT JOIN sch_base_point point1 ON task.point_code1 = point1.point_code
LEFT JOIN sch_base_point point2 ON task.point_code2 = point2.point_code
LEFT JOIN md_me_materialbase mater ON task.material_id = mater.material_id
LEFT JOIN md_pb_classstandard class ON task.task_type = class.class_id
LEFT JOIN sys_dict dict ON dict.`value` = task.task_status AND dict.`code` = 'task_status'
<where>
task.is_delete = '0'
<if test="map.task_code != null and map.task_code != ''">
task.task_code = #{map.task_code}
</if>
</where>
</select>
</mapper>

4
mes/hd/nladmin-system/src/main/java/org/nl/wms/storage_manage/rawmanage/controller/iostorInv/StIvtIostorinvYlOutController.java
View File

@@ -59,8 +59,8 @@ public class StIvtIostorinvYlOutController {
}
@PostMapping("/getIODtl")
@Log("查询入库分配明细")
@ApiOperation("查询入库分配明细")
@Log("查询出库分配明细")
@ApiOperation("查询出库分配明细")
public ResponseEntity<Object> getIODtl(@RequestBody JSONObject whereJson) {
return new ResponseEntity<>(iostorinvOutYlService.getInvDtl(whereJson), HttpStatus.OK);
}

2
mes/hd/nladmin-system/src/main/java/org/nl/wms/storage_manage/rawmanage/service/iostorInv/IStIvtIostorinvdtlYlService.java
View File

@@ -24,7 +24,7 @@ public interface IStIvtIostorinvdtlYlService extends IService<StIvtIostorinvdtlY
* @param iostorinvCp_id
* @return
*/
double create(JSONArray row, String iostorinvCp_id);
double create(JSONArray row, String iostorinvCp_id,String io_type);
List<Map> getDtlList(JSONObject json);
}

2
mes/hd/nladmin-system/src/main/java/org/nl/wms/storage_manage/rawmanage/service/iostorInv/dao/StIvtIostorinvYl.java
View File

@@ -202,7 +202,7 @@ public class StIvtIostorinvYl implements Serializable {
/**
* 车间标识
*/
private String product_area;
private String workshop_id;
}

6
mes/hd/nladmin-system/src/main/java/org/nl/wms/storage_manage/rawmanage/service/iostorInv/dao/mapper/xml/StIvtIostorinvOutYlMapper.xml
View File

@@ -19,6 +19,7 @@
mst.total_qty,
mst.detail_count,
mst.bill_status,
mst.workshop_id,
mst.remark,
mst.create_id,
mst.create_name,
@@ -28,12 +29,9 @@
DATE_FORMAT( mst.update_time,'%Y-%m-%d %H:%i:%s') AS update_time,
mst.confirm_id,
mst.confirm_name,
DATE_FORMAT( mst.confirm_time,'%Y-%m-%d %H:%i:%s') AS confirm_time,
dis.struct_id,
dis.sect_id
DATE_FORMAT( mst.confirm_time,'%Y-%m-%d %H:%i:%s') AS confirm_time
FROM
st_ivt_iostorinv_yl mst
LEFT JOIN st_ivt_iostorinvdis_yl dis ON dis.iostorinv_id = mst.iostorinv_id
<where>
mst.is_delete = '0'
AND

3
mes/hd/nladmin-system/src/main/java/org/nl/wms/storage_manage/rawmanage/service/iostorInv/dao/mapper/xml/StIvtIostorinvYlMapper.xml
View File

@@ -30,7 +30,8 @@
mst.confirm_name,
DATE_FORMAT( mst.confirm_time,'%Y-%m-%d %H:%i:%s') AS confirm_time,
dis.struct_id,
dis.sect_id
dis.sect_id,
mst.workshop_id
FROM
st_ivt_iostorinv_yl mst
LEFT JOIN st_ivt_iostorinvdis_yl dis ON dis.iostorinv_id = mst.iostorinv_id

55
mes/hd/nladmin-system/src/main/java/org/nl/wms/storage_manage/rawmanage/service/iostorInv/impl/StIvtIostorinvOutYlServiceImpl.java
View File

@@ -30,6 +30,7 @@ import org.nl.wms.storage_manage.rawmanage.service.iostorInv.IStIvtIostorinvdtlY
import org.nl.wms.storage_manage.rawmanage.service.iostorInv.dao.StIvtIostorinvYl;
import org.nl.wms.storage_manage.rawmanage.service.iostorInv.dao.StIvtIostorinvdisYl;
import org.nl.wms.storage_manage.rawmanage.service.iostorInv.dao.StIvtIostorinvdtlYl;
import org.nl.wms.storage_manage.rawmanage.service.iostorInv.dao.mapper.StIvtIostorinvOutYlMapper;
import org.nl.wms.storage_manage.rawmanage.service.iostorInv.dao.mapper.StIvtIostorinvYlMapper;
import org.nl.wms.storage_manage.rawmanage.service.iostorInv.dto.YlIostorInvQuery;
import org.nl.wms.storage_manage.rawmanage.service.structIvt.IStIvtStructivtYlService;
@@ -59,7 +60,7 @@ public class StIvtIostorinvOutYlServiceImpl extends ServiceImpl<StIvtIostorinvYl
private IStIvtIostorinvdtlYlService iostorinvdtlYlService;
@Autowired
private StIvtIostorinvYlMapper iostorinvYlMapper;
private StIvtIostorinvOutYlMapper ivtIostorinvOutYlMapper;
@Autowired
private IStIvtIostorinvdisYlService iostorinvdisYlService;
@@ -77,7 +78,7 @@ public class StIvtIostorinvOutYlServiceImpl extends ServiceImpl<StIvtIostorinvYl
@Override
public Object pageQuery(YlIostorInvQuery query, PageQuery pageQuery) {
Page<Object> page = PageHelper.startPage(pageQuery.getPage() + 1, pageQuery.getSize());
List<Map> mst_detail = iostorinvYlMapper.getMstDetail(query, pageQuery);
List<Map> mst_detail = ivtIostorinvOutYlMapper.getMstDetail(query, pageQuery);
TableDataInfo<Map> build = TableDataInfo.build(mst_detail);
build.setTotalElements(page.getTotal());
return build;
@@ -94,7 +95,7 @@ public class StIvtIostorinvOutYlServiceImpl extends ServiceImpl<StIvtIostorinvYl
this.save(stIvtIostorinvYl);
// 调用明细表 插入/更新方法
iostorinvdtlYlService.create(rows, stIvtIostorinvYl.getIostorinv_id());
iostorinvdtlYlService.create(rows, stIvtIostorinvYl.getIostorinv_id(), stIvtIostorinvYl.getIo_type());
}
@Override
@@ -109,7 +110,7 @@ public class StIvtIostorinvOutYlServiceImpl extends ServiceImpl<StIvtIostorinvYl
JSONArray rows = form.getJSONArray("tableData");
if (ObjectUtil.isEmpty(rows)) throw new BadRequestException("请求参数不能为空");
// 调用明细表 插入/更新方法
iostorinvdtlYlService.create(rows, form.getString("iostorinv_id"));
iostorinvdtlYlService.create(rows, form.getString("iostorinv_id"), mst.getIo_type());
return mst.getIostorinv_id();
}
@@ -138,56 +139,17 @@ public class StIvtIostorinvOutYlServiceImpl extends ServiceImpl<StIvtIostorinvYl
StIvtIostorinvYl mst = this.getById(iostorinv_id);
List<StIvtIostorinvdisYl> dis_list = iostorinvdisYlService.list(new QueryWrapper<StIvtIostorinvdisYl>().eq("iostorinv_id", iostorinv_id));
List<StIvtIostorinvdtlYl> dtl_list = iostorinvdtlYlService.list(new QueryWrapper<StIvtIostorinvdtlYl>().eq("iostorinv_id", iostorinv_id));
if (ObjectUtil.isEmpty(dis_list)) {
throw new BadRequestException("该入库单不存在分配明细！");
if (ObjectUtil.isEmpty(dtl_list)) {
throw new BadRequestException("该入库单不存在明细！");
}
if (mst == null || mst.getIs_delete() == true) {
throw new BadRequestException("单据不存在");
}
//修改分配状态
dis_list.forEach(dis -> {
dis.setReal_qty(dis.getPlan_qty());
dis.setWork_status(IOSEnum.WORK_STATUS.code("完成"));
iostorinvdisYlService.updateById(dis);
//修改库存和插入库存变动记录表
structivtflowService.recordStructivtFlow(
StIvtStructivtflowDto.builder()
.bill_code(mst.getBill_code()).change_type_scode(CHANGE_BILL_TYPE_ENUM.IOSTORINV_IN_CONFIRM).bill_table("st_ivt_iostorinv_bcp")
.material_id(dis.getMaterial_id()).pcsn(dis.getPcsn())
.struct_code(dis.getStruct_code()).result_qty(structivtYlService.getOne(new QueryWrapper<StIvtStructivtYl>().eq("struct_code", dis.getStruct_code())).getCanuse_qty()).change_qty(dis.getReal_qty())
.task_id(dis.getTask_id())
.storagevehicle_code(dis.getStoragevehicle_code())
.build()
);
});
//修改明细状态
dtl_list.forEach(dtl -> {
dtl.setReal_qty(dtl.getPlan_qty());
dtl.setBill_status(IOSEnum.BILL_STATUS.code("完成"));
iostorinvdtlYlService.updateById(dtl);
//如果单据类型为原料入库
if (mst.getBill_type().equals(IOSEnum.BILL_TYPE.code("原料入库"))) {
JSONObject pur_jo = new JSONObject();
pur_jo.put("po_code", dtl.getSource_bill_code());
pur_jo.put("instor_qty", dtl.getReal_qty());
purchaseorderService.updatePurchaseNum(pur_jo);
}
});
//修改主表
mst.setConfirm_id(SecurityUtils.getCurrentUserId());
mst.setConfirm_name(SecurityUtils.getCurrentNickName());
mst.setConfirm_time(DateUtil.now());
mst.setBill_status(IOSEnum.BILL_STATUS.code("完成"));
this.updateById(mst);
}
@@ -198,7 +160,7 @@ public class StIvtIostorinvOutYlServiceImpl extends ServiceImpl<StIvtIostorinvYl
// 新增
stIvtIostorinvYl.setIostorinv_id(IdUtil.getStringId());
stIvtIostorinvYl.setBill_code(CodeUtil.getNewCode("IO_CODE"));
stIvtIostorinvYl.setIo_type(IOSEnum.IO_TYPE.code("入库"));
stIvtIostorinvYl.setIo_type(IOSEnum.IO_TYPE.code("出库"));
stIvtIostorinvYl.setBuss_type(whereJson.getString("bill_type"));
stIvtIostorinvYl.setBill_type(stIvtIostorinvYl.getBuss_type());
stIvtIostorinvYl.setBill_status(IOSEnum.BILL_STATUS.code("生成"));
@@ -234,6 +196,7 @@ public class StIvtIostorinvOutYlServiceImpl extends ServiceImpl<StIvtIostorinvYl
stIvtIostorinvYl.setTotal_qty(whereJson.getBigDecimal("total_qty"));
stIvtIostorinvYl.setDetail_count(rows.size());
stIvtIostorinvYl.setRemark(whereJson.getString("remark"));
stIvtIostorinvYl.setWorkshop_id(whereJson.getString("workshop_id"));
return stIvtIostorinvYl;
}

5
mes/hd/nladmin-system/src/main/java/org/nl/wms/storage_manage/rawmanage/service/iostorInv/impl/StIvtIostorinvYlServiceImpl.java
View File

@@ -95,7 +95,7 @@ public class StIvtIostorinvYlServiceImpl extends ServiceImpl<StIvtIostorinvYlMap
this.save(stIvtIostorinvYl);
// 调用明细表 插入/更新方法
iostorinvdtlYlService.create(rows, stIvtIostorinvYl.getIostorinv_id());
iostorinvdtlYlService.create(rows, stIvtIostorinvYl.getIostorinv_id(), stIvtIostorinvYl.getIo_type());
}
@Override
@@ -110,7 +110,7 @@ public class StIvtIostorinvYlServiceImpl extends ServiceImpl<StIvtIostorinvYlMap
JSONArray rows = form.getJSONArray("tableData");
if (ObjectUtil.isEmpty(rows)) throw new BadRequestException("请求参数不能为空");
// 调用明细表 插入/更新方法
iostorinvdtlYlService.create(rows, form.getString("iostorinv_id"));
iostorinvdtlYlService.create(rows, form.getString("iostorinv_id"), mst.getIo_type());
return mst.getIostorinv_id();
}
@@ -235,6 +235,7 @@ public class StIvtIostorinvYlServiceImpl extends ServiceImpl<StIvtIostorinvYlMap
stIvtIostorinvYl.setTotal_qty(whereJson.getBigDecimal("total_qty"));
stIvtIostorinvYl.setDetail_count(rows.size());
stIvtIostorinvYl.setRemark(whereJson.getString("remark"));
stIvtIostorinvYl.setWorkshop_id(whereJson.getString("workshop_id"));
return stIvtIostorinvYl;
}

12
mes/hd/nladmin-system/src/main/java/org/nl/wms/storage_manage/rawmanage/service/iostorInv/impl/StIvtIostorinvdtlYlServiceImpl.java
View File

@@ -36,14 +36,16 @@ public class StIvtIostorinvdtlYlServiceImpl extends ServiceImpl<StIvtIostorinvdt
private IStIvtIostorinvdisYlService iostorinvdisYlService;
@Override
public double create(JSONArray rows, String iostorinvYl_id) {
public double create(JSONArray rows, String iostorinvYl_id, String io_type) {
double total_qty = 0;
if (rows.size() > 0 && StringUtils.isNotEmpty(iostorinvYl_id)) {
// 先删除在插入
this.remove(new QueryWrapper<StIvtIostorinvdtlYl>().eq("iostorinv_id", iostorinvYl_id));
//删除分配记录
iostorinvdisYlService.deleteById(iostorinvYl_id);
if (io_type.equals(IOSEnum.IO_TYPE.code("入库"))) {
//删除分配记录
iostorinvdisYlService.deleteById(iostorinvYl_id);
}
for (int i = 0; i < rows.size(); i++) {
String iostorinvdtlYl_id = IdUtil.getStringId();
@@ -60,7 +62,9 @@ public class StIvtIostorinvdtlYlServiceImpl extends ServiceImpl<StIvtIostorinvdt
JSONObject mst_jo = new JSONObject();
mst_jo.put("mst_id", iostorinvYl_id);
mst_jo.put("dtl_id", iostorinvdtlYl_id);
iostorinvdisYlService.create(rows.getJSONObject(i), mst_jo);
if (io_type.equals(IOSEnum.IO_TYPE.code("入库"))) {
iostorinvdisYlService.create(rows.getJSONObject(i), mst_jo);
}
}
}
return total_qty;