java_project
/
logisticsplatform-service
4
0
Fork 0
Code Issues Pull Requests Activity
Browse Source

1.优化打托上架逻辑

master
zhenghaoyu 10 months ago
parent
936d637353
commit
b1f63c2caa
6 changed files with 320 additions and 192 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 41
      blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/api/WarehouseUpdownTypeApiController.java
  2. 2
      blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/controller/OldSystemPushController.java
  3. 47
      blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/feign/WarehouseTrayTypeClient.java
  4. 71
      blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/interceptor/ParameterCombinationInterceptor.java
  5. 346
      blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/service/impl/AsyncDataServiceImpl.java
  6. 5
      blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/service/impl/WarehouseUpdownTypeServiceImpl.java

41
blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/api/WarehouseUpdownTypeApiController.java
Unescape View File

@ -1,5 +1,6 @@
package com.logpm.warehouse.api;
import com.alibaba.fastjson.JSONObject;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import com.logpm.basicdata.entity.BasicdataWarehouseEntity;
import com.logpm.basicdata.feign.IBasicdataWarehouseClient;
@ -15,8 +16,10 @@ import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.codec.digest.DigestUtils;
import org.springblade.common.annotations.RepeatSubmit;
import org.springblade.common.exception.CustomerException;
import org.springblade.core.redis.cache.BladeRedis;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.StringUtil;
import org.springframework.web.bind.annotation.*;
@ -34,6 +37,7 @@ public class WarehouseUpdownTypeApiController {
private final IWarehouseUpdownTypeService warehouseUpdownTypeService;
private final IBasicdataWarehouseClient warehouseClient;
private final WarehouseGoodsAllocationClient warehouseGoodsAllocationClient;
private final BladeRedis redis;
//---------------------------------上架--------------------------
@ -195,8 +199,21 @@ public class WarehouseUpdownTypeApiController {
log.info(method + "上架订单维度 updownTypeDTO={}", updownTypeDTO);
List<UpShelfOrderDTO> upShelfOrderList = updownTypeDTO.getUpShelfOrderList();
Long allocationId = updownTypeDTO.getAllocationId();//库位id
String s = JSONObject.toJSONString(updownTypeDTO);
String hasCret = DigestUtils.md5Hex(s);//摘要
Boolean exists = redis.exists("updownType:" + hasCret);
if(Boolean.TRUE.equals(exists)){
log.warn(method+"请勿重复提交 hasCret={}",hasCret);
return R.fail(403,"请勿重复提交");
}
redis.set("updownType:" + hasCret, "1");
try{
//当前登录人选择的仓库
BasicdataWarehouseEntity myCurrentWarehouse = warehouseClient.getMyCurrentWarehouse();
if(Objects.isNull(myCurrentWarehouse)){
@ -215,11 +232,15 @@ public class WarehouseUpdownTypeApiController {
}
//查询该库位的货物信息
return warehouseUpdownTypeService.upShelfOrder(upShelfOrderList,allocationId,myCurrentWarehouse.getId(),"扫码订单上架");
R r = warehouseUpdownTypeService.upShelfOrder(upShelfOrderList, allocationId, myCurrentWarehouse.getId(), "扫码订单上架");
redis.del("updownType:" + hasCret);
return r;
}catch (CustomerException e){
redis.del("updownType:" + hasCret);
log.warn(e.message);
return R.fail(e.code,e.message);
}catch (Exception e){
redis.del("updownType:" + hasCret);
log.error(method+"系统异常，联系管理员",e);
return R.fail(500,"系统异常，联系管理员");
}
@ -236,6 +257,18 @@ public class WarehouseUpdownTypeApiController {
log.info(method + "上架包件维度 updownTypeDTO={}", updownTypeDTO);
List<UpShelfPackageDTO> upShelfPackageList = updownTypeDTO.getUpShelfPackageList();
Long allocationId = updownTypeDTO.getAllocationId();//库位码
String s = JSONObject.toJSONString(updownTypeDTO);
String hasCret = DigestUtils.md5Hex(s);//摘要
Boolean exists = redis.exists("updownType:" + hasCret);
if(Boolean.TRUE.equals(exists)){
log.warn(method+"请勿重复提交 hasCret={}",hasCret);
return R.fail(403,"请勿重复提交");
}
redis.set("updownType:" + hasCret, "1");
try{
BasicdataWarehouseEntity myCurrentWarehouse = warehouseClient.getMyCurrentWarehouse();
if(Objects.isNull(myCurrentWarehouse)){
@ -254,11 +287,15 @@ public class WarehouseUpdownTypeApiController {
}
//查询该库位的货物信息
return warehouseUpdownTypeService.upShelfPackage(upShelfPackageList,allocationId,myCurrentWarehouse.getId(),"包件扫码上架");
R r = warehouseUpdownTypeService.upShelfPackage(upShelfPackageList, allocationId, myCurrentWarehouse.getId(), "包件扫码上架");
redis.del("updownType:" + hasCret);
return r;
}catch (CustomerException e){
redis.del("updownType:" + hasCret);
log.warn(e.message);
return R.fail(e.code,e.message);
}catch (Exception e){
redis.del("updownType:" + hasCret);
log.error(method+"系统异常，联系管理员",e);
return R.fail(500,"系统异常，联系管理员");
}

2
blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/controller/OldSystemPushController.java
Unescape View File

@ -17,6 +17,7 @@ import org.springblade.common.constant.OldSystemDataPushConfig;
import org.springblade.common.constant.RabbitConstant;
import org.springblade.common.exception.CustomerException;
import org.springblade.common.utils.CommonUtil;
import org.springblade.core.redis.cache.BladeRedis;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.StringUtil;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
@ -44,6 +45,7 @@ public class OldSystemPushController {
private final RabbitTemplate rabbitTemplate;
private final IAsyncDataService asyncDataService;
private final ISyncOldTrayTypeLogService syncOldTrayTypeLogService;
private final BladeRedis bladeRedis;
// private final IWarehouseWaybillService warehouseWaybillService;
//

47
blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/feign/WarehouseTrayTypeClient.java
Unescape View File

@ -6,6 +6,7 @@ import com.logpm.warehouse.service.IWarehouseTrayTypeService;
import com.logpm.warehouse.vo.TrayTypeDataVO;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.redis.cache.BladeRedis;
import org.springblade.core.tool.api.R;
import org.springframework.web.bind.annotation.RestController;
import springfox.documentation.annotations.ApiIgnore;
@ -21,7 +22,7 @@ import java.util.Map;
public class WarehouseTrayTypeClient implements IWarehouseTrayTypeClient {
private final IWarehouseTrayTypeService warehouseTrayTypeService;
private final BladeRedis redis;
@Override
@ -41,14 +42,31 @@ public class WarehouseTrayTypeClient implements IWarehouseTrayTypeClient {
Long warehouseId = (Long) map.get("warehouseId");
String orderPackageCode = (String) map.get("orderPackageCode");
R r = warehouseTrayTypeService.orderScanOrderPackageCodeSync(trayType, trayCode, orderPackageCode, warehouseId);
if(r.getCode() == 200){
return true;
Boolean exists = redis.exists("trayType:" + trayCode + ":" + orderPackageCode);
if(Boolean.FALSE.equals(exists)){
try{
redis.set("trayType:" + trayCode + ":" + orderPackageCode, "1");
R r = warehouseTrayTypeService.orderScanOrderPackageCodeSync(trayType, trayCode, orderPackageCode, warehouseId);
redis.del("trayType:" + trayCode + ":" + orderPackageCode);
if(r.getCode() == 200){
return true;
}else{
log.error("############orderScanOrderPackageCode: orderPackageCode={} code={} msg={}",orderPackageCode,r.getCode(),r.getMsg());
return false;
}
}catch (Exception e){
redis.del("trayType:" + trayCode + ":" + orderPackageCode);
log.warn("############orderScanOrderPackageCode: orderPackageCode={} 打托异常",orderPackageCode);
return false;
}
}else{
log.error("############orderScanOrderPackageCode: orderPackageCode={} code={} msg={}",orderPackageCode,r.getCode(),r.getMsg());
log.warn("############orderScanOrderPackageCode: orderPackageCode={} 正在打托",orderPackageCode);
return false;
}
}
@ -59,7 +77,24 @@ public class WarehouseTrayTypeClient implements IWarehouseTrayTypeClient {
Long warehouseId = (Long) map.get("warehouseId");
String orderPackageCode = (String) map.get("orderPackageCode");
return warehouseTrayTypeService.orderScanOrderPackageCodeSync(trayType, trayCode, orderPackageCode, warehouseId);
Boolean exists = redis.exists("trayType:" + trayCode + ":" + orderPackageCode);
if(Boolean.FALSE.equals(exists)){
try{
redis.set("trayType:" + trayCode + ":" + orderPackageCode, "1");
return warehouseTrayTypeService.orderScanOrderPackageCodeSync(trayType, trayCode, orderPackageCode, warehouseId);
}catch (Exception e){
redis.del("trayType:" + trayCode + ":" + orderPackageCode);
log.warn("############orderScanOrderPackageCodeReturnR: orderPackageCode={} 打托异常",orderPackageCode);
return R.fail(405,"打托异常 orderPackageCode="+orderPackageCode);
}finally {
redis.del("trayType:" + trayCode + ":" + orderPackageCode);
}
}else{
log.warn("############orderScanOrderPackageCodeReturnR: orderPackageCode={} 正在打托",orderPackageCode);
return R.fail(405,orderPackageCode+"正在打托");
}
}
@Override

71
blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/interceptor/ParameterCombinationInterceptor.java
Unescape View File

@ -1,5 +1,8 @@
package com.logpm.warehouse.interceptor;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.apache.commons.codec.digest.DigestUtils;
import org.springblade.common.annotations.RepeatSubmit;
import org.springframework.stereotype.Component;
@ -9,12 +12,16 @@ import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.stream.Collectors;
@Component
public class ParameterCombinationInterceptor implements HandlerInterceptor {
private static final ObjectMapper objectMapper = new ObjectMapper();
private static final ThreadLocal<String> PROCESSED_REQUEST_HASH = new ThreadLocal<>();
@Override
@ -23,16 +30,19 @@ public class ParameterCombinationInterceptor implements HandlerInterceptor {
HandlerMethod hm = (HandlerMethod) handler;
RepeatSubmit annotation = hm.getMethodAnnotation(RepeatSubmit.class);
if (annotation != null) {
// 计算当前请求参数的MD5哈希值
String currentRequestHash = calculateRequestHash(request.getParameterMap());
// 读取请求体并解析为Map
Map<String, Object> requestBodyMap = parseRequestBody(request);
requestBodyMap.remove("version");
// 构建请求唯一标识，这里使用请求URI+参数MD5作为示例
String requestKey = getRequestKey(request, requestBodyMap);
// 检查是否已处理过相同参数组合的请求
if (PROCESSED_REQUEST_HASH.get() != null && PROCESSED_REQUEST_HASH.get().equals(currentRequestHash)) {
if (PROCESSED_REQUEST_HASH.get() != null && PROCESSED_REQUEST_HASH.get().equals(requestKey)) {
// 阻止重复提交
response.sendError(HttpServletResponse.SC_CONFLICT, "Duplicate submit detected");
return false;
}
// 保存当前请求的哈希值
PROCESSED_REQUEST_HASH.set(currentRequestHash);
PROCESSED_REQUEST_HASH.set(requestKey);
}
}
return true;
@ -49,18 +59,47 @@ public class ParameterCombinationInterceptor implements HandlerInterceptor {
// 可选清理操作，postHandle中已处理
}
// ...其他方法保持不变
/**
* 计算请求参数的MD5哈希值。
* @param parameters 请求参数Map
* @return 参数哈希值字符串
* 解析请求体为Map对象
* @param request 请求对象
* @return 请求体内容的Map对象
* @throws IOException 如果解析失败
*/
private String calculateRequestHash(Map<String, String[]> parameters) {
// 将参数按key排序并拼接为字符串
String sortedParams = parameters.entrySet().stream()
.sorted(Map.Entry.comparingByKey())
.map(entry -> entry.getKey() + "=" + String.join(",", entry.getValue()))
.collect(Collectors.joining("&"));
// 计算并返回MD5摘要
return DigestUtils.md5Hex(sortedParams);
private Map<String, Object> parseRequestBody(HttpServletRequest request) throws IOException {
BufferedReader reader = request.getReader();
String line;
StringBuilder requestBodyBuilder = new StringBuilder();
while ((line = reader.readLine()) != null) {
requestBodyBuilder.append(line);
}
return objectMapper.readValue(requestBodyBuilder.toString(), TypeFactory.defaultInstance().constructMapType(Map.class, String.class, Object.class));
}
/**
* 构建请求的唯一标识
* @param request 请求对象
* @param requestBodyMap 请求体内容的Map对象
* @return 唯一标识字符串
*/
private String getRequestKey(HttpServletRequest request, Map<String, Object> requestBodyMap) throws JsonProcessingException {
StringBuilder sb = new StringBuilder(request.getRequestURI());
String queryString = request.getQueryString();
if (queryString != null) {
sb.append('?').append(queryString);
}
// 将请求体的Map转换为JSON字符串，然后计算MD5
String requestBodyJson = objectMapper.writeValueAsString(requestBodyMap);
byte[] uriAndQueryBytes = sb.toString().getBytes(StandardCharsets.UTF_8);
byte[] requestBodyJsonBytes = requestBodyJson.getBytes(StandardCharsets.UTF_8);
// 合并两个字节数组
byte[] combinedBytes = new byte[uriAndQueryBytes.length + requestBodyJsonBytes.length];
System.arraycopy(uriAndQueryBytes, 0, combinedBytes, 0, uriAndQueryBytes.length);
System.arraycopy(requestBodyJsonBytes, 0, combinedBytes, uriAndQueryBytes.length, requestBodyJsonBytes.length);
return DigestUtils.md5Hex(combinedBytes);
}
}

346
blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/service/impl/AsyncDataServiceImpl.java
Unescape View File

@ -15,7 +15,9 @@ import com.logpm.oldproject.entity.TrayEntity;
import com.logpm.oldproject.feign.ITrayClient;
import com.logpm.oldproject.feign.ITrayScanClient;
import com.logpm.oldproject.feign.ITrayScanDesClient;
import com.logpm.warehouse.dto.*;
import com.logpm.warehouse.dto.TrayInfoDTO;
import com.logpm.warehouse.dto.UpShelfPackageDTO;
import com.logpm.warehouse.dto.ZeroOrderVO;
import com.logpm.warehouse.entity.*;
import com.logpm.warehouse.service.*;
import com.logpm.warehouse.vo.QuestDetailVO;
@ -24,11 +26,11 @@ import lombok.extern.log4j.Log4j2;
import org.springblade.common.annotations.LogpmAsync;
import org.springblade.common.constant.TenantNum;
import org.springblade.common.exception.CustomerException;
import org.springblade.core.redis.cache.BladeRedis;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
@ -78,6 +80,8 @@ public class AsyncDataServiceImpl implements IAsyncDataService {
private ISyncOldTrayTypeLogService syncOldTrayTypeLogService;
@Autowired
private ISyncTaskErrorLogService syncTaskErrorLogService;
@Autowired
private BladeRedis bladeRedis;
@Override
@LogpmAsync("asyncExecutor")
@ -694,93 +698,127 @@ public class AsyncDataServiceImpl implements IAsyncDataService {
Integer oldWarehouseId = trayInfoDTO.getWarehouseId();
Integer type = trayInfoDTO.getType();
BasicdataWarehouseEntity basicdataWarehouseEntity = basicdataWarehouseClient.getWarehouseByOldId(oldWarehouseId);
if(Objects.isNull(basicdataWarehouseEntity)){
log.warn("####################sendTrayInfoByOrderPackageCode: 仓库信息为空 basicdataWarehouseEntity={}",basicdataWarehouseEntity);
throw new CustomerException(405,"仓库信息为空");
Boolean exists = bladeRedis.exists("trayType:T" + trayId + ":" + orderPackageCode);
if(Boolean.TRUE.equals(exists)){
log.warn("#############sendTrayInfoByOrderPackageCode: orderPackageCode={} 正在打托",orderPackageCode);
throw new CustomerException(405,"正在打托");
}
Long newWarehouseId = basicdataWarehouseEntity.getId();
BasicdataTrayEntity basicdataTrayEntity = basicdataTrayClient.getTrayByTrayCode("T" + trayId);
if(Objects.isNull(basicdataTrayEntity)){
log.info("############sendTrayInfoByOrderPackageCode: 托盘信息不存在 同步");
//如果托盘不存在就去同步该托盘
TrayEntity trayEntity = trayClient.getTrayById(trayId);
basicdataTrayEntity = new BasicdataTrayEntity();
basicdataTrayEntity.setTenantId("627683");
basicdataTrayEntity.setCreateUser(1714696768639311873L);
basicdataTrayEntity.setUpdateUser(1714696768639311873L);
basicdataTrayEntity.setCreateDept(1649331096241836033L);
basicdataTrayEntity.setPalletName(trayEntity.getTrayNo());
basicdataTrayEntity.setPalletCode("T"+trayEntity.getId());
basicdataTrayEntity.setWarehouseId(newWarehouseId);
basicdataTrayEntity.setTrayStatus(trayEntity.getStatus()+"");
basicdataTrayEntity.setType(1);
basicdataTrayEntity.setOldId(trayId);
// basicdataTrayEntity.setNowWarehouseId(nowNewWarehouseId);
Long aLong = basicdataTrayClient.addTray(basicdataTrayEntity);
basicdataTrayEntity.setId(aLong);
}
// TrayScanDesEntity trayScanDesEntity = trayScanDesClient.findScanTypeId(trayId, orderPackageCode, oldWarehouseId);
// if(Objects.isNull(trayScanDesEntity)){
// log.warn("####################sendTrayInfoByOrderPackageCode: 没有打托数据 trayId={}",trayId);
// throw new CustomerException(405,"没有打托数据");
// }
// Integer trayScanId = trayScanDesEntity.getTrayScanId();
// TrayScanEntity trayScanEntity = trayScanClient.getEntityByTrayScanId(trayScanId);
// if(Objects.isNull(trayScanEntity)){
// log.warn("####################sendTrayInfoByOrderPackageCode: 没有打托方式数据 trayScanId={}",trayScanId);
// throw new CustomerException(405,"没有打托方式数据");
// }
// Integer trayType = trayScanEntity.getType();
String newTrayType = "100";
if(1==type){
newTrayType = "60";
}else if(2==type){
newTrayType = "30";
}else if(3==type){
newTrayType = "50";
}else if(4==type){
newTrayType = "100";
}else if(5==type){
newTrayType = "10";
}else if(6==type){
newTrayType = "20";
}
//判断托盘是否有上架
Long allocationId = taryAllocationService.getAllocationIdByTrayId(basicdataTrayEntity.getId());
if(Objects.isNull(allocationId)){
//没有上架就直接打托
R response = trayTypeService.orderScanOrderPackageCodeSync(newTrayType,"T"+trayId,orderPackageCode,newWarehouseId);
int code = response.getCode();
String msg = response.getMsg();
if(code == 4001){
log.info("####################sendTrayInfoByOrderPackageCode: 包件已在当前托盘打托 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}else if(code == 4002){
log.info("####################sendTrayInfoByOrderPackageCode: 包件已在其他托盘打托 orderPackageCode={} ",orderPackageCode);
QueryWrapper<WarehouseTrayGoodsEntity> trayGoodsEntityQueryWrapper = new QueryWrapper<>();
trayGoodsEntityQueryWrapper.eq("association_value",orderPackageCode);
WarehouseTrayGoodsEntity trayGoodsEntity = trayGoodsService.getOne(trayGoodsEntityQueryWrapper);
if(Objects.isNull(trayGoodsEntity)){
log.warn("####################sendTrayInfoByOrderPackageCode: 包件未打托 orderPackageCode={}",orderPackageCode);
}else{
String oldTrayCode = trayGoodsEntity.getTrayCode();
Long trayGoodsId = trayGoodsEntity.getId();
Long wid = trayGoodsEntity.getWarehouseId();
BasicdataTrayEntity oldTrayEntity = basicdataTrayClient.getTrayByTrayCode(oldTrayCode);
Long oldTrayId = oldTrayEntity.getId();
//判断托盘是否有上架
Long oldAllocationId = taryAllocationService.getAllocationIdByTrayId(oldTrayId);
if (Objects.isNull(oldAllocationId)){
//没有上架
//直接解绑托盘
trayGoodsService.deleteByTrayGoodsId(trayGoodsId,wid);
try{
bladeRedis.set("trayType:T" + trayId + ":" + orderPackageCode, "1");
BasicdataWarehouseEntity basicdataWarehouseEntity = basicdataWarehouseClient.getWarehouseByOldId(oldWarehouseId);
if(Objects.isNull(basicdataWarehouseEntity)){
log.warn("####################sendTrayInfoByOrderPackageCode: 仓库信息为空 basicdataWarehouseEntity={}",basicdataWarehouseEntity);
throw new CustomerException(405,"仓库信息为空");
}
Long newWarehouseId = basicdataWarehouseEntity.getId();
BasicdataTrayEntity basicdataTrayEntity = basicdataTrayClient.getTrayByTrayCode("T" + trayId);
if(Objects.isNull(basicdataTrayEntity)){
log.info("############sendTrayInfoByOrderPackageCode: 托盘信息不存在 同步");
//如果托盘不存在就去同步该托盘
TrayEntity trayEntity = trayClient.getTrayById(trayId);
basicdataTrayEntity = new BasicdataTrayEntity();
basicdataTrayEntity.setTenantId("627683");
basicdataTrayEntity.setCreateUser(1714696768639311873L);
basicdataTrayEntity.setUpdateUser(1714696768639311873L);
basicdataTrayEntity.setCreateDept(1649331096241836033L);
basicdataTrayEntity.setPalletName(trayEntity.getTrayNo());
basicdataTrayEntity.setPalletCode("T"+trayEntity.getId());
basicdataTrayEntity.setWarehouseId(newWarehouseId);
basicdataTrayEntity.setTrayStatus(trayEntity.getStatus()+"");
basicdataTrayEntity.setType(1);
basicdataTrayEntity.setOldId(trayId);
Long aLong = basicdataTrayClient.addTray(basicdataTrayEntity);
basicdataTrayEntity.setId(aLong);
}
String newTrayType = "100";
if(1==type){
newTrayType = "60";
}else if(2==type){
newTrayType = "30";
}else if(3==type){
newTrayType = "50";
}else if(4==type){
newTrayType = "100";
}else if(5==type){
newTrayType = "10";
}else if(6==type){
newTrayType = "20";
}
//判断托盘是否有上架
Long allocationId = taryAllocationService.getAllocationIdByTrayId(basicdataTrayEntity.getId());
if(Objects.isNull(allocationId)){
//没有上架就直接打托
R response = trayTypeService.orderScanOrderPackageCodeSync(newTrayType,"T"+trayId,orderPackageCode,newWarehouseId);
int code = response.getCode();
String msg = response.getMsg();
if(code == 4001){
log.info("####################sendTrayInfoByOrderPackageCode: 包件已在当前托盘打托 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}else if(code == 4002){
log.info("####################sendTrayInfoByOrderPackageCode: 包件已在其他托盘打托 orderPackageCode={} ",orderPackageCode);
QueryWrapper<WarehouseTrayGoodsEntity> trayGoodsEntityQueryWrapper = new QueryWrapper<>();
trayGoodsEntityQueryWrapper.eq("association_value",orderPackageCode);
WarehouseTrayGoodsEntity trayGoodsEntity = trayGoodsService.getOne(trayGoodsEntityQueryWrapper);
if(Objects.isNull(trayGoodsEntity)){
log.warn("####################sendTrayInfoByOrderPackageCode: 包件未打托 orderPackageCode={}",orderPackageCode);
}else{
//有上架
//下架
String oldTrayCode = trayGoodsEntity.getTrayCode();
Long trayGoodsId = trayGoodsEntity.getId();
Long wid = trayGoodsEntity.getWarehouseId();
BasicdataTrayEntity oldTrayEntity = basicdataTrayClient.getTrayByTrayCode(oldTrayCode);
Long oldTrayId = oldTrayEntity.getId();
//判断托盘是否有上架
Long oldAllocationId = taryAllocationService.getAllocationIdByTrayId(oldTrayId);
if (Objects.isNull(oldAllocationId)){
//没有上架
//直接解绑托盘
trayGoodsService.deleteByTrayGoodsId(trayGoodsId,wid);
}else{
//有上架
//下架
List<UpShelfPackageDTO> upShelfPackageList = new ArrayList<>();
UpShelfPackageDTO upShelfPackageDTO = new UpShelfPackageDTO();
upShelfPackageDTO.setOrderPackageCode(orderPackageCode);
upShelfPackageList.add(upShelfPackageDTO);
updownTypeService.downPackage(upShelfPackageList,wid,"系统包件下架");
}
}
R r = trayTypeService.orderScanOrderPackageCodeSync(newTrayType,"T"+trayId,orderPackageCode,newWarehouseId);
int code1 = r.getCode();
if(code1 != 200){
//存入打托信息
SyncOldTrayTypeLogEntity syncOldTrayTypeLogEntity = new SyncOldTrayTypeLogEntity();
syncOldTrayTypeLogEntity.setCreateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setUpdateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setCreateDept(1649331096241836033L);
syncOldTrayTypeLogEntity.setTenantId(TenantNum.HUITONGCODE);
syncOldTrayTypeLogEntity.setCreateTime(new Date());
syncOldTrayTypeLogEntity.setUpdateTime(new Date());
syncOldTrayTypeLogEntity.setArgs(JSONObject.toJSONString(trayInfoDTO));
syncOldTrayTypeLogEntity.setSyncStatus(0);
syncOldTrayTypeLogEntity.setSyncNum(0);
syncOldTrayTypeLogService.save(syncOldTrayTypeLogEntity);
log.warn("####################orderStatusHandler: 二次打托失败 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}else{
log.info("####################orderStatusHandler: 二次打托成功 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}
}else if(code == 4003){
log.info("####################orderStatusHandler: 包件未打托已上架 orderPackageCode={} ",orderPackageCode);
QueryWrapper<WarehouseUpdownGoodsEntity> updownGoodsEntityQueryWrapper = new QueryWrapper<>();
updownGoodsEntityQueryWrapper.eq("association_value", orderPackageCode);
WarehouseUpdownGoodsEntity updownGoodsEntity = updownGoodsService.getOne(updownGoodsEntityQueryWrapper);
if(Objects.isNull(updownGoodsEntity)){
log.warn("####################orderStatusHandler: 包件未上架 orderPackageCode={}",orderPackageCode);
}else{
Long wid = updownGoodsEntity.getWarehouseId();
List<UpShelfPackageDTO> upShelfPackageList = new ArrayList<>();
UpShelfPackageDTO upShelfPackageDTO = new UpShelfPackageDTO();
upShelfPackageDTO.setOrderPackageCode(orderPackageCode);
@ -788,109 +826,81 @@ public class AsyncDataServiceImpl implements IAsyncDataService {
updownTypeService.downPackage(upShelfPackageList,wid,"系统包件下架");
}
}
R r = trayTypeService.orderScanOrderPackageCodeSync(newTrayType, "T" + trayId, orderPackageCode, newWarehouseId);
int code1 = r.getCode();
if(code1 != 200){
//存入打托信息
SyncOldTrayTypeLogEntity syncOldTrayTypeLogEntity = new SyncOldTrayTypeLogEntity();
syncOldTrayTypeLogEntity.setCreateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setUpdateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setCreateDept(1649331096241836033L);
syncOldTrayTypeLogEntity.setTenantId(TenantNum.HUITONGCODE);
syncOldTrayTypeLogEntity.setCreateTime(new Date());
syncOldTrayTypeLogEntity.setUpdateTime(new Date());
syncOldTrayTypeLogEntity.setArgs(JSONObject.toJSONString(trayInfoDTO));
syncOldTrayTypeLogEntity.setSyncStatus(0);
syncOldTrayTypeLogEntity.setSyncNum(0);
syncOldTrayTypeLogService.save(syncOldTrayTypeLogEntity);
log.warn("####################orderStatusHandler: 二次打托失败 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}else{
log.info("####################orderStatusHandler: 二次打托成功 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}
}else if(code == 4004){
log.info("####################orderStatusHandler: 包件打托方式不正确 orderPackageCode={} ",orderPackageCode);
//先去空置托盘再打托
trayTypeService.trayToNull("T"+trayId,"系统空置托盘");
R r = trayTypeService.orderScanOrderPackageCodeSync(newTrayType,"T"+trayId,orderPackageCode,newWarehouseId);
int code1 = r.getCode();
if(code1 != 200){
//存入打托信息
SyncOldTrayTypeLogEntity syncOldTrayTypeLogEntity = new SyncOldTrayTypeLogEntity();
syncOldTrayTypeLogEntity.setCreateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setUpdateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setCreateDept(1649331096241836033L);
syncOldTrayTypeLogEntity.setTenantId(TenantNum.HUITONGCODE);
syncOldTrayTypeLogEntity.setCreateTime(new Date());
syncOldTrayTypeLogEntity.setUpdateTime(new Date());
syncOldTrayTypeLogEntity.setArgs(JSONObject.toJSONString(trayInfoDTO));
syncOldTrayTypeLogEntity.setSyncStatus(0);
syncOldTrayTypeLogEntity.setSyncNum(0);
syncOldTrayTypeLogService.save(syncOldTrayTypeLogEntity);
log.warn("####################orderStatusHandler: 二次打托失败 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}else{
log.info("####################orderStatusHandler: 二次打托成功 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}
}else if(code == 4003){
log.info("####################orderStatusHandler: 包件未打托已上架 orderPackageCode={} ",orderPackageCode);
QueryWrapper<WarehouseUpdownGoodsEntity> updownGoodsEntityQueryWrapper = new QueryWrapper<>();
updownGoodsEntityQueryWrapper.eq("association_value", orderPackageCode);
WarehouseUpdownGoodsEntity updownGoodsEntity = updownGoodsService.getOne(updownGoodsEntityQueryWrapper);
if(Objects.isNull(updownGoodsEntity)){
log.warn("####################orderStatusHandler: 包件未上架 orderPackageCode={}",orderPackageCode);
R r = trayTypeService.orderScanOrderPackageCodeSync(newTrayType, "T" + trayId, orderPackageCode, newWarehouseId);
int code1 = r.getCode();
if(code1 != 200){
//存入打托信息
SyncOldTrayTypeLogEntity syncOldTrayTypeLogEntity = new SyncOldTrayTypeLogEntity();
syncOldTrayTypeLogEntity.setCreateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setUpdateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setCreateDept(1649331096241836033L);
syncOldTrayTypeLogEntity.setTenantId(TenantNum.HUITONGCODE);
syncOldTrayTypeLogEntity.setCreateTime(new Date());
syncOldTrayTypeLogEntity.setUpdateTime(new Date());
syncOldTrayTypeLogEntity.setArgs(JSONObject.toJSONString(trayInfoDTO));
syncOldTrayTypeLogEntity.setSyncStatus(0);
syncOldTrayTypeLogEntity.setSyncNum(0);
syncOldTrayTypeLogService.save(syncOldTrayTypeLogEntity);
log.warn("####################orderStatusHandler: 二次打托失败 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}
}else{
Long wid = updownGoodsEntity.getWarehouseId();
List<UpShelfPackageDTO> upShelfPackageList = new ArrayList<>();
UpShelfPackageDTO upShelfPackageDTO = new UpShelfPackageDTO();
upShelfPackageDTO.setOrderPackageCode(orderPackageCode);
upShelfPackageList.add(upShelfPackageDTO);
updownTypeService.downPackage(upShelfPackageList,wid,"系统包件下架");
}
R r = trayTypeService.orderScanOrderPackageCodeSync(newTrayType, "T" + trayId, orderPackageCode, newWarehouseId);
int code1 = r.getCode();
if(code1 != 200){
//存入打托信息
SyncOldTrayTypeLogEntity syncOldTrayTypeLogEntity = new SyncOldTrayTypeLogEntity();
syncOldTrayTypeLogEntity.setCreateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setUpdateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setCreateDept(1649331096241836033L);
syncOldTrayTypeLogEntity.setTenantId(TenantNum.HUITONGCODE);
syncOldTrayTypeLogEntity.setCreateTime(new Date());
syncOldTrayTypeLogEntity.setUpdateTime(new Date());
syncOldTrayTypeLogEntity.setArgs(JSONObject.toJSONString(trayInfoDTO));
syncOldTrayTypeLogEntity.setSyncStatus(0);
syncOldTrayTypeLogEntity.setSyncNum(0);
syncOldTrayTypeLogService.save(syncOldTrayTypeLogEntity);
log.warn("####################orderStatusHandler: 二次打托失败 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}else{
log.info("####################orderStatusHandler: 二次打托成功 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}
}else if(code == 4004){
log.info("####################orderStatusHandler: 包件打托方式不正确 orderPackageCode={} ",orderPackageCode);
//先去空置托盘再打托
trayTypeService.trayToNull("T"+trayId,"系统空置托盘");
R r = trayTypeService.orderScanOrderPackageCodeSync(newTrayType, "T" + trayId, orderPackageCode, newWarehouseId);
int code1 = r.getCode();
if(code1 != 200){
//存入打托信息
SyncOldTrayTypeLogEntity syncOldTrayTypeLogEntity = new SyncOldTrayTypeLogEntity();
syncOldTrayTypeLogEntity.setCreateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setUpdateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setCreateDept(1649331096241836033L);
syncOldTrayTypeLogEntity.setTenantId(TenantNum.HUITONGCODE);
syncOldTrayTypeLogEntity.setCreateTime(new Date());
syncOldTrayTypeLogEntity.setUpdateTime(new Date());
syncOldTrayTypeLogEntity.setArgs(JSONObject.toJSONString(trayInfoDTO));
syncOldTrayTypeLogEntity.setSyncStatus(0);
syncOldTrayTypeLogEntity.setSyncNum(0);
syncOldTrayTypeLogService.save(syncOldTrayTypeLogEntity);
log.warn("####################orderStatusHandler: 二次打托失败 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
log.warn("######################orderStatusHandler: 打托失败 msg={} code={}",msg,code);
log.warn("######################orderStatusHandler: 打托失败 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
}
}else{
//存入打托信息
SyncOldTrayTypeLogEntity syncOldTrayTypeLogEntity = new SyncOldTrayTypeLogEntity();
syncOldTrayTypeLogEntity.setCreateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setUpdateUser(1714696768639311873L);
syncOldTrayTypeLogEntity.setCreateDept(1649331096241836033L);
syncOldTrayTypeLogEntity.setCreateTime(new Date());
syncOldTrayTypeLogEntity.setUpdateTime(new Date());
syncOldTrayTypeLogEntity.setTenantId(TenantNum.HUITONGCODE);
syncOldTrayTypeLogEntity.setArgs(JSONObject.toJSONString(trayInfoDTO));
syncOldTrayTypeLogEntity.setSyncStatus(0);
syncOldTrayTypeLogEntity.setSyncNum(0);
syncOldTrayTypeLogService.save(syncOldTrayTypeLogEntity);
log.warn("######################orderStatusHandler: 打托失败 msg={} code={}",msg,code);
log.warn("######################orderStatusHandler: 打托失败 orderPackageCode={} trayCode={}",orderPackageCode,"T"+trayId);
//有上架就上架
List<UpShelfPackageDTO> upShelfPackageList = new ArrayList<>();
UpShelfPackageDTO upShelfPackageDTO = new UpShelfPackageDTO();
upShelfPackageDTO.setOrderPackageCode(orderPackageCode);
upShelfPackageList.add(upShelfPackageDTO);
updownTypeService.upShelfPackage(upShelfPackageList,allocationId,newWarehouseId,"");
}
}else{
//有上架就上架
List<UpShelfPackageDTO> upShelfPackageList = new ArrayList<>();
UpShelfPackageDTO upShelfPackageDTO = new UpShelfPackageDTO();
upShelfPackageDTO.setOrderPackageCode(orderPackageCode);
upShelfPackageList.add(upShelfPackageDTO);
updownTypeService.upShelfPackage(upShelfPackageList,allocationId,newWarehouseId,"");
bladeRedis.del("trayType:T" + trayId + ":" + orderPackageCode);
}catch (Exception e){
log.warn("###############sendTrayInfoByOrderPackageCode: 打托失败");
bladeRedis.del("trayType:T" + trayId + ":" + orderPackageCode);
}
}
@Override

5
blade-service/logpm-warehouse/src/main/java/com/logpm/warehouse/service/impl/WarehouseUpdownTypeServiceImpl.java
Unescape View File

@ -886,6 +886,11 @@ public class WarehouseUpdownTypeServiceImpl extends BaseServiceImpl<WarehouseUpd
findParamterDTO.setWarehouseId(warehouseId);
List<DistributionParcelListEntity> parcelListList = distributionParcelListClient.findALLNoUpShelfPackageByOrderCodeList(findParamterDTO);
if(parcelListList.isEmpty()){
log.warn("############upShelfOrder: 没有可上架的包件");
return R.fail(405,"没有可上架的包件");
}
List<UpShelfPackageDTO> upShelfPackageList = new ArrayList<>();
parcelListList.forEach(parcelListEntity -> {

Write Preview
Loading…
Cancel
Save