package com.zy.asrs.service.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.baomidou.mybatisplus.mapper.Wrapper;
|
import com.core.common.Cools;
|
import com.core.common.DateUtils;
|
import com.core.common.R;
|
import com.core.common.SnowflakeIdWorker;
|
import com.core.exception.CoolException;
|
import com.zy.asrs.entity.*;
|
import com.zy.asrs.entity.param.*;
|
import com.zy.asrs.entity.result.OpenOrderCompeteResult;
|
import com.zy.asrs.entity.result.StockVo;
|
import com.zy.asrs.entity.result.ZphjcdgzVo;
|
import com.zy.asrs.entity.result.ZphjcdwcVo;
|
import com.zy.asrs.mapper.*;
|
import com.zy.asrs.service.*;
|
import com.zy.asrs.utils.MatUtils;
|
import com.zy.common.constant.MesConstant;
|
import com.zy.common.model.DetlDto;
|
import com.zy.common.model.LocTypeDto;
|
import com.zy.common.model.StartupDto;
|
import com.zy.common.model.enums.WorkNoType;
|
import com.zy.common.service.CommonService;
|
import com.zy.common.utils.HttpHandler;
|
import com.zy.common.utils.NodeUtils;
|
import com.zy.system.entity.Config;
|
import com.zy.system.mapper.ConfigMapper;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
/**
|
* Created by vincent on 2022/4/9
|
*/
|
@Slf4j
|
@Service
|
public class OpenServiceImpl implements OpenService {
|
|
// 二楼堆垛机对应入库站点
|
private static final int[] secondFloorIn = new int[]{0, 2061, 2064, 2067, 2070, 2073, 2076};
|
// 堆垛机对应一楼出库站点
|
private static final int[] secondFloorOut = new int[]{0, 3002, 3003, 3006, 3008, 3009, 3012};
|
// 堆垛机对应一楼入库站点
|
private static final int[] oneFloorIn = new int[]{0, 3001, 3004, 3005, 3007, 3010, 3011};
|
|
|
@Autowired
|
private OrderService orderService;
|
@Autowired
|
private OrderDetlService orderDetlService;
|
@Autowired
|
private SnowflakeIdWorker snowflakeIdWorker;
|
@Autowired
|
private DocTypeService docTypeService;
|
@Autowired
|
private MatService matService;
|
@Autowired
|
private LocDetlService locDetlService;
|
@Autowired
|
private PackService packService;
|
@Autowired
|
private TagService tagService;
|
@Autowired
|
private TagMapper tagMapper;
|
@Autowired
|
private WrkMastService wrkMastService;
|
@Autowired
|
private BasDevpService basDevpService;
|
@Autowired
|
private WrkDetlService wrkDetlService;
|
@Autowired
|
private WaitPakinService waitPakinService;
|
@Autowired
|
private CommonService commonService;
|
@Autowired
|
private LocDetlRullUpDetailService locDetlRullUpDetailService;
|
@Autowired
|
private WrkDetlSingleService wrkDetlSingleService;
|
@Autowired
|
private WrkMastLogService wrkMastLogService;
|
@Autowired
|
private WrkMastStaService wrkMastStaService;
|
@Autowired
|
private WrkMastStaLogService wrkMastStaLogService;
|
@Autowired
|
private StaDescService staDescService;
|
@Autowired
|
private LocMastService locMastService;
|
@Autowired
|
private ApiLogService apiLogService;
|
|
@Resource
|
private MatMapper matMapper;
|
|
@Resource
|
private LocDetlMapper locDetlMapper;
|
|
@Resource
|
private ConfigMapper configMapper;
|
|
@Resource
|
private OrderMapper orderMapper;
|
|
@Resource
|
private OrderDetlMapper orderDetlMapper;
|
|
@Resource
|
private BasCrnpMapper basCrnpMapper;
|
|
@Override
|
@Transactional
|
public void pakinOrderCreate(OpenOrderPakinParam param) {
|
Order order = orderService.selectByNo(param.getOrderNo());
|
if (!Cools.isEmpty(order)) {
|
throw new CoolException(param.getOrderNo() + "单据已存在，请勿重复提交");
|
}
|
DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.TRUE);
|
Date now = new Date();
|
// 单据主档
|
order = new Order(
|
String.valueOf(snowflakeIdWorker.nextId()), // 编号[非空]
|
param.getOrderNo(), // 订单编号
|
DateUtils.convert(now), // 单据日期
|
docType.getDocId(), // 单据类型
|
null, // 项目编号
|
null, //
|
null, // 调拨项目编号
|
null, // 初始票据号
|
null, // 票据号
|
null, // 客户编号
|
null, // 客户
|
null, // 联系方式
|
null, // 操作人员
|
null, // 合计金额
|
null, // 优惠率
|
null, // 优惠金额
|
null, // 销售或采购费用合计
|
null, // 实付金额
|
null, // 付款类型
|
null, // 业务员
|
null, // 结算天数
|
null, // 邮费支付类型
|
null, // 邮费
|
null, // 付款时间
|
null, // 发货时间
|
null, // 物流名称
|
null, // 物流单号
|
1L, // 订单状态
|
1, // 状态
|
9527L, // 添加人员
|
now, // 添加时间
|
9527L, // 修改人员
|
now, // 修改时间
|
null // 备注
|
);
|
if (!orderService.insert(order)) {
|
throw new CoolException("生成单据主档失败，请联系管理员");
|
}
|
// 单据明细档
|
List<DetlDto> list = new ArrayList<>();
|
List<DetlDto> orderDetails = param.getOrderDetails();
|
for (DetlDto detail : orderDetails) {
|
DetlDto dto = new DetlDto(detail.getMatnr(), detail.getBatch(), detail.getAnfme());
|
if (DetlDto.has(list, dto)) {
|
DetlDto detlDto = DetlDto.find(list, dto.getMatnr(), dto.getBatch());
|
assert detlDto != null;
|
detlDto.setAnfme(detlDto.getAnfme() + detail.getAnfme());
|
} else {
|
list.add(dto);
|
}
|
}
|
for (DetlDto detlDto : list) {
|
Mat mat = matService.selectByMatnr(detlDto.getMatnr());
|
if (Cools.isEmpty(mat)) {
|
throw new CoolException(detlDto.getMatnr() + "编号商品检索失败，请先添加商品");
|
}
|
OrderDetl orderDetl = new OrderDetl();
|
orderDetl.sync(mat);
|
orderDetl.setBatch(detlDto.getBatch());
|
orderDetl.setAnfme(detlDto.getAnfme());
|
orderDetl.setOrderId(order.getId());
|
orderDetl.setOrderNo(order.getOrderNo());
|
orderDetl.setCreateBy(9527L);
|
orderDetl.setCreateTime(now);
|
orderDetl.setUpdateBy(9527L);
|
orderDetl.setUpdateTime(now);
|
orderDetl.setStatus(1);
|
orderDetl.setQty(0.0D);
|
if (!orderDetlService.insert(orderDetl)) {
|
throw new CoolException("生成单据明细失败，请联系管理员");
|
}
|
}
|
}
|
|
@Override
|
@Transactional
|
public List<OpenOrderCompeteResult> pakinOrderComplete(OpenOrderCompleteParam param) {
|
List<OpenOrderCompeteResult> results = new ArrayList<>();
|
if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
|
// 指定订单
|
Order order = orderService.selectByNo(param.getOrderNo());
|
if (null != order) {
|
OpenOrderCompeteResult result = new OpenOrderCompeteResult();
|
results.add(result);
|
result.setOrderNo(order.getOrderNo());
|
result.setOrderTime(order.getOrderTime());
|
result.setOrderType(order.getDocType$());
|
List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
|
for (OrderDetl orderDetl : orderDetls) {
|
result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
|
}
|
if (order.getSettle() == 4L) {
|
// 修改订单状态 4.完成 ===>> 6.已上报
|
if (!orderService.updateSettle(order.getId(), 6L, null)) {
|
throw new CoolException("服务器内部错误，请联系管理员");
|
}
|
}
|
}
|
} else {
|
// 所有订单
|
List<Order> orders = orderService.selectList(new EntityWrapper<Order>().eq("settle", 4L));
|
for (Order order : orders) {
|
OpenOrderCompeteResult result = new OpenOrderCompeteResult();
|
results.add(result);
|
result.setOrderNo(order.getOrderNo());
|
result.setOrderTime(order.getOrderTime());
|
result.setOrderType(order.getDocType$());
|
List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
|
for (OrderDetl orderDetl : orderDetls) {
|
result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
|
}
|
// 修改订单状态 4.完成 ===>> 6.已上报
|
if (!orderService.updateSettle(order.getId(), 6L, null)) {
|
throw new CoolException("服务器内部错误，请联系管理员");
|
}
|
}
|
}
|
return results;
|
}
|
|
@Override
|
@Transactional
|
public void pakoutOrderCreate(OpenOrderPakoutParam param) {
|
Order order = orderService.selectByNo(param.getOrderNo());
|
// 如果单据不存在则添加；如果单据存在，作业中无法修改，反之则修改单据
|
if (!Cools.isEmpty(order)) {
|
if (order.getSettle() > 1L) {
|
throw new CoolException(param.getOrderNo() + "正在出库，无法修改单据");
|
}
|
orderService.remove(order.getId());
|
}
|
DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.FALSE);
|
Date now = new Date();
|
// 单据主档
|
order = new Order(
|
String.valueOf(snowflakeIdWorker.nextId()), // 编号[非空]
|
param.getOrderNo(), // 订单编号
|
DateUtils.convert(now), // 单据日期
|
docType.getDocId(), // 单据类型
|
null, // 项目编号
|
null, //
|
null, // 调拨项目编号
|
null, // 初始票据号
|
null, // 票据号
|
null, // 客户编号
|
null, // 客户
|
null, // 联系方式
|
null, // 操作人员
|
null, // 合计金额
|
null, // 优惠率
|
null, // 优惠金额
|
null, // 销售或采购费用合计
|
null, // 实付金额
|
null, // 付款类型
|
null, // 业务员
|
null, // 结算天数
|
null, // 邮费支付类型
|
null, // 邮费
|
null, // 付款时间
|
null, // 发货时间
|
null, // 物流名称
|
null, // 物流单号
|
1L, // 订单状态
|
1, // 状态
|
9527L, // 添加人员
|
now, // 添加时间
|
9527L, // 修改人员
|
now, // 修改时间
|
null // 备注
|
);
|
if (!orderService.insert(order)) {
|
throw new CoolException("生成单据主档失败，请联系管理员");
|
}
|
// 单据明细档
|
List<DetlDto> list = new ArrayList<>();
|
List<DetlDto> orderDetails = param.getOrderDetails();
|
for (DetlDto detail : orderDetails) {
|
DetlDto dto = new DetlDto(detail.getMatnr(), detail.getBatch(), detail.getAnfme());
|
if (DetlDto.has(list, dto)) {
|
DetlDto detlDto = DetlDto.find(list, dto.getMatnr(), dto.getBatch());
|
assert detlDto != null;
|
detlDto.setAnfme(detlDto.getAnfme() + detail.getAnfme());
|
} else {
|
list.add(dto);
|
}
|
}
|
for (DetlDto detlDto : list) {
|
Mat mat = matService.selectByMatnr(detlDto.getMatnr());
|
if (Cools.isEmpty(mat)) {
|
throw new CoolException(detlDto.getMatnr() + "编号商品检索失败，请先添加商品");
|
}
|
OrderDetl orderDetl = new OrderDetl();
|
orderDetl.sync(mat);
|
orderDetl.setBatch(detlDto.getBatch());
|
orderDetl.setAnfme(detlDto.getAnfme());
|
orderDetl.setOrderId(order.getId());
|
orderDetl.setOrderNo(order.getOrderNo());
|
orderDetl.setCreateBy(9527L);
|
orderDetl.setCreateTime(now);
|
orderDetl.setUpdateBy(9527L);
|
orderDetl.setUpdateTime(now);
|
orderDetl.setStatus(1);
|
orderDetl.setQty(0.0D);
|
if (!orderDetlService.insert(orderDetl)) {
|
throw new CoolException("生成单据明细失败，请联系管理员");
|
}
|
}
|
}
|
|
@Override
|
public List<OpenOrderCompeteResult> pakoutOrderComplete(OpenOrderCompleteParam param) {
|
List<OpenOrderCompeteResult> results = new ArrayList<>();
|
if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
|
// 指定订单
|
Order order = orderService.selectByNo(param.getOrderNo());
|
if (null != order) {
|
OpenOrderCompeteResult result = new OpenOrderCompeteResult();
|
results.add(result);
|
result.setOrderNo(order.getOrderNo());
|
result.setOrderTime(order.getOrderTime());
|
result.setOrderType(order.getDocType$());
|
List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
|
for (OrderDetl orderDetl : orderDetls) {
|
result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
|
}
|
if (order.getSettle() == 4L) {
|
// 修改订单状态 4.完成 ===>> 6.已上报
|
if (!orderService.updateSettle(order.getId(), 6L, null)) {
|
throw new CoolException("服务器内部错误，请联系管理员");
|
}
|
}
|
}
|
} else {
|
// 所有订单
|
List<Order> orders = orderService.selectList(new EntityWrapper<Order>().eq("settle", 4L));
|
for (Order order : orders) {
|
OpenOrderCompeteResult result = new OpenOrderCompeteResult();
|
results.add(result);
|
result.setOrderNo(order.getOrderNo());
|
result.setOrderTime(order.getOrderTime());
|
result.setOrderType(order.getDocType$());
|
List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
|
for (OrderDetl orderDetl : orderDetls) {
|
result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
|
}
|
// 修改订单状态 4.完成 ===>> 6.已上报
|
if (!orderService.updateSettle(order.getId(), 6L, null)) {
|
throw new CoolException("服务器内部错误，请联系管理员");
|
}
|
}
|
}
|
return results;
|
}
|
|
@Override
|
@Transactional
|
public List<StockVo> queryStock() {
|
return locDetlService.queryStockTotal();
|
}
|
|
@Override
|
@Transactional
|
public void packageUp(PackParam param) {
|
if (Cools.isEmpty(param.getBarcode())) {
|
throw new CoolException("barcode不能为空");
|
}
|
Mat analyse = MatUtils.analyseMat(param.getBarcode());
|
Pack pack = packService.selectByBarcode(param.getBarcode());
|
if (null != pack) {
|
throw new CoolException(param.getBarcode() + "重复提交");
|
}
|
Date now = new Date();
|
pack = new Pack(
|
param.getBarcode(), // 条码[非空]
|
analyse.getMatnr(), // 商品编号
|
analyse.getBarcode(), // 序列码
|
1L, // 订单状态
|
1, // 状态
|
now, // 添加时间
|
null, // 添加人员
|
now, // 修改时间
|
null, // 修改人员
|
null // 备注
|
);
|
if (!packService.insert(pack)) {
|
throw new CoolException("服务器内部错误，请联系管理员");
|
}
|
|
Mat mat = matService.selectByMatnr(analyse.getMatnr());
|
if (mat == null) {
|
mat = new Mat();
|
// 分类
|
Long tagId;
|
// 一级分类
|
if (!Cools.isEmpty(param.getGroupCode()) && !Cools.isEmpty(param.getGroupName())) {
|
Tag priTag = tagService.selectByName(param.getGroupCode(), 2);
|
if (priTag == null) {
|
Tag top = tagService.getTop();
|
NodeUtils nodeUtils = new NodeUtils();
|
nodeUtils.executePath(top.getId());
|
priTag = new Tag(
|
null, // 编号
|
param.getGroupCode(), // 名称
|
top.getId(), // 父级
|
top.getName(), // 父级名称
|
nodeUtils.path.toString(), // 关联路径
|
nodeUtils.pathName.toString(), // 关联路径名
|
0, // 类型
|
null, // 负责人
|
null, // 图片
|
null, // 简要描述
|
null, // 数量
|
2, // 等级
|
null, // 排序
|
1, // 状态
|
now, // 添加时间
|
null, // 添加人员
|
now, // 修改时间
|
null, // 修改人员
|
null // 备注
|
);
|
if (tagMapper.insert(priTag) == 0) {
|
throw new CoolException("服务器内部错误，请联系管理员");
|
}
|
}
|
// 二级分类
|
Tag secTag = tagService.selectByName(param.getGroupName(), 3);
|
if (secTag == null) {
|
NodeUtils nodeUtils = new NodeUtils();
|
nodeUtils.executePath(priTag.getId());
|
secTag = new Tag(
|
null, // 编号
|
param.getGroupName(), // 名称
|
priTag.getId(), // 父级
|
priTag.getName(), // 父级名称
|
nodeUtils.path.toString(), // 关联路径
|
nodeUtils.pathName.toString(), // 关联路径名
|
0, // 类型
|
null, // 负责人
|
null, // 图片
|
null, // 简要描述
|
null, // 数量
|
3, // 等级
|
null, // 排序
|
1, // 状态
|
now, // 添加时间
|
null, // 添加人员
|
now, // 修改时间
|
null, // 修改人员
|
null // 备注
|
);
|
if (tagMapper.insert(secTag) == 0) {
|
throw new CoolException("服务器内部错误，请联系管理员");
|
}
|
}
|
tagId = secTag.getId();
|
} else {
|
tagId = tagService.getTop().getId();
|
}
|
mat.setTagId(tagId);
|
mat.setMatnr(analyse.getMatnr());
|
mat.setMaktx(param.getMaterialName());
|
mat.setSpecs(param.getConfigureDesc());
|
mat.setModel(analyse.getModel());
|
mat.setStatus(1);
|
mat.setCreateTime(now);
|
mat.setUpdateTime(now);
|
if (!matService.insert(mat)) {
|
throw new CoolException("服务器内部错误，请联系管理员");
|
} else {
|
log.info("打包上线添加新物料[商品编号：{}]", mat.getMatnr());
|
}
|
}
|
}
|
|
@Override
|
@Transactional
|
public void syncMat(MatSyncParam param) {
|
if (Cools.isEmpty(param.getMatDetails()) || param.getMatDetails().size() <= 0) {
|
throw new CoolException("商品数据为空");
|
}
|
|
for (MatSyncParam.MatParam matParam : param.getMatDetails()) {
|
if (Cools.isEmpty(matParam.getMatnr())) {
|
throw new CoolException("商品编码不能为空");
|
}
|
|
Date now = new Date();
|
Mat mat = matService.selectByMatnr(matParam.getMatnr());
|
if (mat == null) {
|
mat = new Mat();
|
// 分类
|
Long tagId;
|
// 一级分类
|
if (!Cools.isEmpty(matParam.getGroupCode()) && !Cools.isEmpty(matParam.getGroupName())) {
|
Tag priTag = tagService.selectByName(matParam.getGroupCode(), 2);
|
if (priTag == null) {
|
Tag top = tagService.getTop();
|
NodeUtils nodeUtils = new NodeUtils();
|
nodeUtils.executePath(top.getId());
|
priTag = new Tag(
|
null, // 编号
|
matParam.getGroupCode(), // 名称
|
top.getId(), // 父级
|
top.getName(), // 父级名称
|
nodeUtils.path.toString(), // 关联路径
|
nodeUtils.pathName.toString(), // 关联路径名
|
0, // 类型
|
null, // 负责人
|
null, // 图片
|
null, // 简要描述
|
null, // 数量
|
2, // 等级
|
null, // 排序
|
1, // 状态
|
now, // 添加时间
|
null, // 添加人员
|
now, // 修改时间
|
null, // 修改人员
|
null // 备注
|
);
|
if (tagMapper.insert(priTag) == 0) {
|
throw new CoolException("服务器内部错误，请联系管理员");
|
}
|
}
|
// 二级分类
|
Tag secTag = tagService.selectByName(matParam.getGroupName(), 3);
|
if (secTag == null) {
|
NodeUtils nodeUtils = new NodeUtils();
|
nodeUtils.executePath(priTag.getId());
|
secTag = new Tag(
|
null, // 编号
|
matParam.getGroupName(), // 名称
|
priTag.getId(), // 父级
|
priTag.getName(), // 父级名称
|
nodeUtils.path.toString(), // 关联路径
|
nodeUtils.pathName.toString(), // 关联路径名
|
0, // 类型
|
null, // 负责人
|
null, // 图片
|
null, // 简要描述
|
null, // 数量
|
3, // 等级
|
null, // 排序
|
1, // 状态
|
now, // 添加时间
|
null, // 添加人员
|
now, // 修改时间
|
null, // 修改人员
|
null // 备注
|
);
|
if (tagMapper.insert(secTag) == 0) {
|
throw new CoolException("服务器内部错误，请联系管理员");
|
}
|
}
|
tagId = secTag.getId();
|
} else {
|
tagId = tagService.getTop().getId();
|
}
|
mat.sync(param);
|
// mat.setMatnr(param.getMatnr());
|
// mat.setMaktx(param.getMaktx());
|
// mat.setSpecs(param.getSpecs());
|
// mat.setModel(param.getModel());
|
|
mat.setTagId(tagId);
|
mat.setStatus(1);
|
mat.setCreateTime(now);
|
mat.setUpdateTime(now);
|
if (!matService.insert(mat)) {
|
throw new CoolException("服务器内部错误，请联系管理员");
|
} else {
|
log.info("同步新物料[商品编号：{}]", mat.getMatnr());
|
}
|
} else {
|
mat.sync(param);
|
if (!matService.update(mat, new EntityWrapper<Mat>().eq("matnr", matParam.getMatnr()))) {
|
throw new CoolException("更新已存在商品信息失败，请联系管理员");
|
}
|
}
|
}
|
|
}
|
|
/*...........................徐工汉云..............以下.............上饶江铜...........................*/
|
/*............................Created by Monkey D. Luffy on 2023.07.19.............................*/
|
|
/*
|
* 贴标机申请获取货物信息
|
* */
|
@Override
|
@Transactional
|
public LabellerMatParam labellerMat(LabellerMatParam param) {
|
if (Cools.isEmpty(param.getDevNo())) {
|
throw new CoolException("参数：站点号 devNo为空");
|
} else if (Cools.isEmpty(param.getLabNo())) {
|
throw new CoolException("参数：贴标机号 labNo为空");
|
}
|
BasDevp basDevp = basDevpService.selectById(param.getDevNo());
|
if (Cools.isEmpty(basDevp)) {
|
throw new CoolException("参数：站点号 devNo不存在");
|
} else if (Cools.isEmpty(basDevp.getWrkNo()) || basDevp.getWrkNo() == 0) {
|
throw new CoolException("站点:" + param.getDevNo() + " 不存在工作中任务");
|
}
|
|
WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", basDevp.getWrkNo()));
|
if (Cools.isEmpty(wrkMast)) {
|
throw new CoolException("站点:" + param.getDevNo() + " 工作中任务不存在,任务号：" + basDevp.getWrkNo());
|
} else if (!wrkMast.getWrkSts().equals(52L)) {
|
throw new CoolException("站点:" + param.getDevNo() + " 工作中任务状态已变更，请勿重复申请,任务号：" + basDevp.getWrkNo() + ",任务状态:" + wrkMast.getWrkSts$());
|
}
|
|
List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", basDevp.getWrkNo()));
|
if (Cools.isEmpty(wrkDetls) || wrkDetls.size() == 0) {
|
throw new CoolException("站点:" + param.getDevNo() + " 工作中任务不存在任务明细,任务号：" + basDevp.getWrkNo());
|
}
|
|
LabellerMatParam labellerMatParam = new LabellerMatParam();
|
labellerMatParam.setDevNo(param.getDevNo());
|
labellerMatParam.setLabNo(param.getLabNo());
|
labellerMatParam.setWrkNo(basDevp.getWrkNo().toString());
|
// ArrayList<LabellerMatParam.CombMat> combMats = new ArrayList<>();
|
ArrayList<LabellerMatParam.BoxNo> boxNos = new ArrayList<>();
|
// String orderNo = "";
|
|
for (WrkDetl wrkDetl : wrkDetls) {
|
LabellerMatParam.BoxNo boxNo = new LabellerMatParam.BoxNo();
|
boxNo.setBoxNo(wrkDetl.getBatch());
|
boxNos.add(boxNo);
|
}
|
labellerMatParam.setBoxNos(boxNos);
|
// for (WrkDetl wrkDetl:wrkDetls){
|
// LabellerMatParam.CombMat combMat = new LabellerMatParam.CombMat(wrkDetl);
|
// orderNo=wrkDetl.getOrderNo();
|
// combMat.setTemp1("1");
|
// combMats.add(combMat);
|
// }
|
|
// labellerMatParam.setCombMats(combMats);
|
// labellerMatParam.setLabellingTime(DateUtils.convert(new Date()));
|
// labellerMatParam.setLabTemplate("1");
|
// labellerMatParam.setOrderNo(orderNo);
|
wrkMast.setWrkSts(53L);
|
if (!wrkMastService.updateById(wrkMast)) {
|
throw new CoolException("异常，请重新申请");
|
}
|
return labellerMatParam;
|
}
|
|
/*
|
* 贴标机贴标完成
|
* */
|
@Override
|
@Transactional
|
public void labellerComplete(LabellerCompleteParam param) {
|
if (Cools.isEmpty(param.getDevNo())) {
|
throw new CoolException("参数：站点号 devNo为空");
|
} else if (Cools.isEmpty(param.getLabNo())) {
|
throw new CoolException("参数：贴标机号 labNo为空");
|
} else if (Cools.isEmpty(param.getLabResult())) {
|
throw new CoolException("参数：贴标结果 labResult为空");
|
} else if (Cools.isEmpty(param.getWrkNo())) {
|
throw new CoolException("参数：贴标任务号 wrkNo为空");
|
}
|
BasDevp basDevp = basDevpService.selectById(param.getDevNo());
|
if (Cools.isEmpty(basDevp)) {
|
throw new CoolException("参数：站点号 devNo=" + param.getDevNo() + "不存在");
|
} else if (Cools.isEmpty(basDevp.getWrkNo()) || basDevp.getWrkNo() == 0) {
|
throw new CoolException("站点:" + param.getDevNo() + " 不存在工作中任务");
|
} else if (!basDevp.getWrkNo().toString().equals(param.getWrkNo())) {
|
throw new CoolException("站点:" + param.getDevNo() + " 进行中任务号=" + basDevp.getWrkNo() + " 与贴标结果返回任务号=" + param.getWrkNo() + " 不一致");
|
}
|
|
WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", basDevp.getWrkNo()));
|
if (Cools.isEmpty(wrkMast)) {
|
throw new CoolException("站点:" + param.getDevNo() + " 工作中任务不存在,任务号：" + basDevp.getWrkNo());
|
} else if (!wrkMast.getWrkSts().equals(53L)) {
|
throw new CoolException("站点:" + param.getDevNo() + " 工作中任务状态已变更，请勿重复申请,任务号：" + basDevp.getWrkNo() + ",任务状态:" + wrkMast.getWrkSts$());
|
}
|
|
if (param.getLabResult().equals("OK")) {
|
wrkMast.setWrkSts(54L);
|
wrkMast.setStaNo(144);
|
if (!wrkMastService.updateById(wrkMast)) {
|
throw new CoolException("异常，请重新申请");
|
}
|
} else if (param.getLabResult().equals("NG")) {
|
wrkMast.setWrkSts(52L);//重新贴标
|
if (!wrkMastService.updateById(wrkMast)) {
|
throw new CoolException("异常，请重新申请");
|
}
|
} else {
|
throw new CoolException("参数：贴标结果:labResult" + param.getLabResult() + ";请按规则发送：成功：OK 、失败:NG");
|
}
|
|
}
|
|
/*
|
* 中控：码垛完成下发入库信息
|
* */
|
@Override
|
@Transactional
|
public void PalletizingCompleteTwoFloorParam(PalletizingCompleteTwoFloorParam param) {
|
Long userId = 7777L;//中控
|
//判断param参数
|
if (Cools.isEmpty(param.getBarcode())) {
|
throw new CoolException("参数：托盘码 barcode为空");
|
} else if (Cools.isEmpty(param.getPalletizingNo())) {
|
throw new CoolException("参数：码垛位编号 palletizingNo为空");
|
} else if (Cools.isEmpty(param.getBoxType())) {
|
throw new CoolException("参数：木箱类型 boxType为空");
|
} else if (Cools.isEmpty(param.getMatList()) || param.getMatList().size() == 0) {
|
throw new CoolException("参数：物料明细 matLists为空");
|
}
|
|
String matnrOne = "";//木箱相同位置 规格 matnr校验 1、左
|
String matnrTwo = "";//木箱相同位置 规格 matnr校验 2、右
|
ArrayList<String> boxNos = new ArrayList<>(); //木箱唯一编码查重 （batch）
|
//判断matLists参数
|
for (PalletizingCompleteTwoFloorParam.MatList matList : param.getMatList()) {
|
if (Cools.isEmpty(matList.getMatnr())) {
|
throw new CoolException("参数：规格 matnr为空");
|
} else if (Cools.isEmpty(matList.getPosition())) {
|
throw new CoolException("规格：" + matList.getMatnr() + "、参数：码垛位置 position为空");
|
} else if (Cools.isEmpty(matList.getBatch())) {
|
throw new CoolException("规格：" + matList.getMatnr() + "、参数：木箱编号 batch为空");
|
} else if (Cools.isEmpty(matList.getModel())) {
|
throw new CoolException("规格：" + matList.getMatnr() + "、参数：卷号 model为空");
|
} else if (Cools.isEmpty(matList.getBatch())) {
|
throw new CoolException("规格：" + matList.getMatnr() + "、参数：木箱编号 boxNo为空");
|
} else if (Cools.isEmpty(matList.getWeight()) || matList.getWeight().equals(0D)) {
|
throw new CoolException("规格：" + matList.getMatnr() + "、参数：净重 weight为空");
|
} else if (Cools.isEmpty(matList.getRoughWeight()) || matList.getRoughWeight().equals(0D)) {
|
throw new CoolException("规格：" + matList.getMatnr() + "、参数：毛重 roughWeight");
|
} else if (Cools.isEmpty(matList.getRollExtent()) || matList.getRollExtent().equals(0D)) {
|
throw new CoolException("规格：" + matList.getMatnr() + "、参数：卷长度 rollExtent");
|
}
|
// else if (Cools.isEmpty(matList.getJoint()) || matList.getJoint()==0){
|
// throw new CoolException("规格："+matList.getMatnr()+"、参数：接头数 joint");
|
// }
|
|
if (matList.getPosition().equals("1")) {//1、左 2、右
|
if (!matnrOne.equals("")) {
|
if (!matnrOne.equals(matList.getMatnr())) {
|
throw new CoolException("木箱位置：" + matList.getPosition() + "存在不同规格卷信息");
|
}
|
} else {
|
matnrOne = matList.getMatnr();
|
}
|
} else if (matList.getPosition().equals("2")) {
|
if (!matnrTwo.equals("")) {
|
if (!matnrTwo.equals(matList.getMatnr())) {
|
throw new CoolException("木箱位置：" + matList.getPosition() + "存在不同规格卷信息");
|
}
|
} else {
|
matnrTwo = matList.getMatnr();
|
}
|
} else {
|
throw new CoolException("参数：木箱编号 boxNo:" + matList.getBatch() + ",木箱位置错误：" + matList.getPosition());
|
}
|
|
if (!boxNos.contains(matList.getBatch())) {
|
boxNos.add(matList.getBatch());
|
} else {
|
throw new CoolException("参数：木箱编号 boxNo:" + matList.getBatch() + ",木箱编码存在重复");
|
}
|
}
|
|
// BasDevp basDevp = basDevpService.selectById(Integer.parseInt(param.getDevNo$()));
|
// if (Cools.isEmpty(basDevp)){
|
// throw new CoolException("参数：码垛位编号 palletizingNo="+param.getPalletizingNo()+"不存在");
|
// }
|
// if (Cools.isEmpty(basDevp.getAutoing()) || !basDevp.getAutoing().equals("Y")){
|
// throw new CoolException("码垛位编号 palletizingNo="+param.getPalletizingNo()+" 所处站点不是自动状态");
|
// }
|
// if (Cools.isEmpty(basDevp.getLoading()) || !basDevp.getLoading().equals("Y")){
|
// throw new CoolException("码垛位编号 palletizingNo="+param.getPalletizingNo()+" 所处站点不是有物状态");
|
// }
|
// if (Cools.isEmpty(basDevp.getCanining()) || !basDevp.getCanining().equals("Y")){
|
// throw new CoolException("码垛位编号 palletizingNo="+param.getPalletizingNo()+" 所处站点不是能入状态");
|
// }
|
|
|
if (locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet", param.getBarcode())) != 0
|
|| wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("zpallet", param.getBarcode())) != 0
|
|| waitPakinService.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet", param.getBarcode())) != 0) {
|
throw new CoolException("托盘条码：" + param.getBarcode() + "已存在，请勿重复组托");
|
}
|
|
|
Date now = new Date();
|
for (PalletizingCompleteTwoFloorParam.MatList matList : param.getMatList()) {
|
Mat mat = matService.selectByMatnr(matList.getMatnr());
|
if (Cools.isEmpty(mat)) {
|
mat = new Mat();
|
mat.setMatnr(matList.getMatnr());
|
mat.setMaktx(matList.getMatnr());
|
mat.setTagId(tagService.getTop().getId());
|
mat.setCreateBy(userId);
|
mat.setCreateTime(now);
|
mat.setUpdateBy(userId);
|
mat.setUpdateTime(now);
|
mat.setStatus(1);
|
if (!matService.insert(mat)) {
|
throw new CoolException("规格添加失败，请联系管理员");
|
}
|
}
|
WaitPakin waitPakin = new WaitPakin();
|
waitPakin.sync(mat);
|
waitPakin.setBatch(matList.getBatch()); //木箱编码 //批次 唯一值 箱号
|
waitPakin.setModel(matList.getModel()); //卷号 唯一值
|
waitPakin.setBrand(param.getBoxType()); //木箱类型
|
waitPakin.setZpallet(param.getBarcode()); //托盘码
|
waitPakin.setOrigin(matList.getPosition()); //木箱在托盘上的位置
|
waitPakin.setWeight(matList.getWeight()); //净重
|
waitPakin.setVolume(matList.getRoughWeight()); //毛重
|
waitPakin.setPrice(matList.getRollExtent()); //长度
|
waitPakin.setSpecs(String.valueOf(matList.getJoint())); //接头
|
waitPakin.setIoStatus("N"); // 入出状态
|
waitPakin.setAnfme(matList.getAnfme()); // 数量
|
waitPakin.setStatus("Y"); // 状态
|
waitPakin.setAppeUser(userId);
|
waitPakin.setAppeTime(now);
|
waitPakin.setModiUser(userId);
|
waitPakin.setModiTime(now);
|
if (!waitPakinService.insert(waitPakin)) {
|
throw new CoolException("保存入库通知档失败");
|
}
|
}
|
|
}
|
|
/*
|
* 松盛(1楼)：码垛完成下发入库信息
|
* */
|
@Override
|
@Transactional
|
public void palletizingCompleteS(PalletizingCompleteParam param) {
|
//判断param参数
|
if (Cools.isEmpty(param.getBarcode())) {
|
throw new CoolException("参数：托盘码 barcode为空");
|
}
|
|
WrkMast wrkMast = wrkMastService.selectByBarcode(param.getBarcode());
|
if (Cools.isEmpty(wrkMast) || wrkMast.getWrkSts() != 2) {
|
log.error("退库码垛完成，返回托盘码未查询到工作档案！");
|
throw new CoolException("参数：托盘码 barcode未查询到工作档案");
|
}
|
wrkMast.setSheetNo("4");
|
wrkMastService.updateById(wrkMast);
|
}
|
|
|
/*
|
*中控：出库完成月台相关
|
* */
|
@Override
|
@Transactional
|
public void balconyComplete(LabellerMatParam param) {
|
if (Cools.isEmpty(param.getWrkNo())) {
|
throw new CoolException("工作号为空！");
|
}
|
WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", param.getWrkNo()));
|
if (Cools.isEmpty(wrkMast)) {
|
throw new CoolException("工作号为空！");
|
}
|
wrkMast.setWrkSts(57L);
|
wrkMastService.updateById(wrkMast);
|
}
|
|
/*
|
* 桁架上位软件：单次拆垛完成通知
|
* */
|
@Override
|
@Transactional
|
public void singleUnstackingComplete(SingleUnstackingCompleteParam param) {
|
Long userId = 8888L;//桁架上位软件
|
//判断param参数
|
if (Cools.isEmpty(param.getPalletizingNo())) {
|
throw new CoolException("参数：码垛位编号 palletizingNo为空");
|
} else if (Cools.isEmpty(param.getMatList()) || param.getMatList().size() == 0) {
|
throw new CoolException("参数：物料明细 matLists为空");
|
}
|
|
ArrayList<WrkDetl> wrkDetlsNew = new ArrayList<>();
|
ArrayList<WrkDetlSingle> wrkDetlsOld = new ArrayList<>();
|
//判断matLists参数
|
for (SingleUnstackingCompleteParam.MatList matList : param.getMatList()) {
|
if (Cools.isEmpty(matList.getPosition())) {
|
throw new CoolException("参数：码垛位置 position为空");
|
} else if (Cools.isEmpty(matList.getBoxNo())) {
|
throw new CoolException("参数：木箱编号 boxNo为空");
|
}
|
WrkDetlSingle wrkDetlSingleOne = wrkDetlSingleService.selectOne(new EntityWrapper<WrkDetlSingle>().eq("batch", matList.getBoxNo()));
|
List<WrkDetlSingle> wrkDetlSingles = wrkDetlSingleService.selectList(new EntityWrapper<WrkDetlSingle>()
|
.eq("wrk_no", wrkDetlSingleOne.getWrkNo()).eq("io_time", wrkDetlSingleOne.getIoTime()));
|
boolean sign = true;
|
for (WrkDetlSingle wrkDetlSingle : wrkDetlSingles) {
|
WrkDetl wrkDetl = new WrkDetl();
|
wrkDetl.sync(wrkDetlSingle);
|
wrkDetlsNew.add(wrkDetl);
|
wrkDetlsOld.add(wrkDetlSingle);
|
sign = false;
|
break;
|
}
|
if (sign) {
|
throw new CoolException("参数：木箱编号 boxNo未查询到对应的工作明细！");
|
}
|
}
|
|
// 生成工作号
|
int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(202));
|
Date now = new Date();
|
|
// 生成工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(now);
|
wrkMast.setWrkSts(51L); // 工作状态：生成入库ID
|
wrkMast.setIoType(202); // 入出库状态：202.拆垛后出库
|
wrkMast.setIoPri(99D); // 优先级
|
wrkMast.setSourceStaNo(param.getDevNo$());
|
wrkMast.setStaNo(144); //贴标站点 直接到尾端
|
// 操作人员数据
|
wrkMast.setAppeUser(userId);
|
wrkMast.setAppeTime(now);
|
wrkMast.setModiUser(userId);
|
wrkMast.setModiTime(now);
|
if (!wrkMastService.insert(wrkMast)) {
|
throw new CoolException("生成工作档失败==》桁架上位软件：单次拆垛完成通知");
|
}
|
|
for (WrkDetl wrkDetl : wrkDetlsNew) {
|
wrkDetl.setWrkNo(wrkMast.getWrkNo());
|
wrkDetl.setIoTime(wrkMast.getIoTime());
|
wrkDetl.setAppeTime(now);
|
wrkDetl.setModiTime(now);
|
if (!wrkDetlService.insert(wrkDetl)) {
|
throw new CoolException("保存工作明细失败==》桁架上位软件：单次拆垛完成通知");
|
}
|
}
|
|
for (WrkDetlSingle wrkDetlSingle : wrkDetlsOld) {
|
wrkDetlSingleService.delete(new EntityWrapper<WrkDetlSingle>()
|
.eq("batch", wrkDetlSingle.getBatch())
|
.eq("wrk_no", wrkDetlSingle.getWrkNo())
|
.eq("io_time", wrkDetlSingle.getIoTime()));
|
}
|
|
}
|
|
/*
|
* 桁架上位软件：单托拆垛完成通知
|
* */
|
@Override
|
@Transactional
|
public void singleMountUnstackingComplete(SingleMountUnstackingCompleteParam param) {
|
// Long userId = 8888L;//桁架上位软件
|
//判断param参数
|
if (Cools.isEmpty(param.getBarcode())) {
|
throw new CoolException("参数：托盘码 barcode为空");
|
}
|
WrkMast wrkMastMatrix = wrkMastService.selectByBarcode(param.getBarcode());
|
if (Cools.isEmpty(wrkMastMatrix)) {
|
throw new CoolException("参数：托盘码查询工作档失败：" + param.getBarcode());
|
}
|
|
wrkMastMatrix.setSheetNo("2");
|
if (!wrkMastService.updateById(wrkMastMatrix)) {
|
throw new CoolException("更新工作档失败==》桁架上位软件：单托拆垛完成通知");
|
}
|
}
|
|
/*
|
*
|
* */
|
@Override
|
@Transactional
|
public void cs2() {
|
// int[] staNos =new int[]{122};
|
// for (Integer staNo:staNos){
|
// int[] crnNos =new int[]{6};
|
// for (Integer crnNo:crnNos){
|
// descSta(staNo,crnNo);
|
// }
|
// }
|
|
}
|
|
@Override
|
public void updateBarcode() {
|
List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts", "D"));
|
for (int i = 0; i < locMasts.size(); i++) {
|
LocMast locMast = locMasts.get(i);
|
locMast.setBarcode("a" + i);
|
locMastService.updateById(locMast);
|
}
|
System.out.println("更新完了" + locMasts.size());
|
}
|
|
@Override
|
@Transactional
|
public R prodCheck(List<ProdCheckParam> param) {
|
if (param.isEmpty()) {
|
return R.parse("请求参数不能为空");
|
}
|
for (ProdCheckParam checkParam : param) {
|
// 更新库存明细是否合格
|
LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("model", checkParam.getRollNo()));
|
// 更新商品表是否合格
|
// Mat mat = matService.selectOne(new EntityWrapper<Mat>().eq("model", checkParam.getRollNo()));
|
if (locDetl == null) { // || mat == null
|
throw new CoolException("更新是否合格物料不存在：" + checkParam);
|
}
|
|
locDetl.setThreeCode(checkParam.getQualified());
|
// mat.setThreeCode(checkParam.getQualified());
|
|
locDetlService.update(locDetl, new EntityWrapper<LocDetl>().eq("model", checkParam.getRollNo()));
|
// matService.update(mat, (new EntityWrapper<Mat>().eq("model", checkParam.getRollNo())));
|
}
|
|
return R.ok("更新成功");
|
}
|
|
@Override
|
@Transactional
|
public String fxprk(FxprkParam param) {
|
|
// 根据包装组号获取到木箱卷信息
|
List<Mat> list = matService.selectList(new EntityWrapper<Mat>().in("brand", param.getBoxList().stream().map(FxprkParam.Box::getPackageGroupNo).collect(Collectors.toList())));
|
if (list.isEmpty()) {
|
throw new CoolException("没有查询到该包装组号信息：" + param.getBoxList().toString());
|
}
|
|
LocTypeDto locTypeDto = new LocTypeDto();
|
locTypeDto.setLocType1((short) 1);
|
StartupDto dto = commonService.getLocNo(1, param.getPalletizingNo(), locTypeDto, 0);
|
|
// 返回GWCS目标信息
|
pushStaNoToGwcs(param.getPalletizingNo(), dto.getStaNo(), dto.getWorkNo(), param.getBarcode(), "一楼反修品入库推送gwcs");
|
// if (!result) {
|
// throw new CoolException("入库回推入库码头给GWCS失败");
|
// }
|
|
int workNo = dto.getWorkNo();
|
Date now = new Date();
|
// 生成工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(new Date());
|
wrkMast.setWrkSts(1L); // 工作状态：设备上走
|
wrkMast.setIoType(1); // 入出库状态：1.入库
|
wrkMast.setIoPri(13D); // 优先级
|
wrkMast.setCrnNo(dto.getCrnNo());
|
wrkMast.setSourceStaNo(param.getPalletizingNo());
|
wrkMast.setStaNo(dto.getStaNo());
|
wrkMast.setLocNo(dto.getLocNo());
|
wrkMast.setBarcode(param.getBarcode()); // 托盘码
|
wrkMast.setFullPlt("Y"); // 满板：Y
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk("N"); // 空板
|
wrkMast.setLinkMis("Y");
|
wrkMast.setCtnType(1); // 容器类型
|
// 操作人员数据
|
wrkMast.setAppeTime(now);
|
wrkMast.setModiTime(now);
|
boolean res = wrkMastService.insert(wrkMast);
|
if (!res) {
|
throw new CoolException("保存工作档失败");
|
}
|
|
for (Mat obj : list) {
|
WrkDetl wrkDetl = new WrkDetl();
|
wrkDetl.sync(obj);
|
wrkDetl.setWrkNo(wrkMast.getWrkNo());
|
wrkDetl.setAnfme(1.0);
|
// 重新定位木箱位置
|
for (FxprkParam.Box box : param.getBoxList()) {
|
if (box.getPackageGroupNo().equals(obj.getBrand())) {
|
if (!box.getBoxPos().equals(obj.getOrigin())) {
|
wrkDetl.setOrigin(box.getBoxPos());
|
wrkDetl.setZpallet(param.getBarcode());
|
wrkDetl.setBarcode(param.getBarcode());
|
matMapper.updateBoxPos(box.getPackageGroupNo(), box.getBoxPos(), param.getBarcode());
|
}
|
break;
|
}
|
}
|
wrkDetl.setIoTime(now);
|
wrkDetl.setAppeTime(now);
|
wrkDetl.setModiTime(now);
|
if (!wrkDetlService.insert(wrkDetl)) {
|
throw new CoolException("保存工作明细失败");
|
}
|
}
|
|
// 更新目标库位状态
|
LocMast locMast = locMastService.selectById(dto.getLocNo());
|
if (locMast.getLocSts().equals("O")) {
|
locMast.setLocSts("S"); // S.入库预约
|
locMast.setModiTime(now);
|
if (!locMastService.updateById(locMast)) {
|
throw new CoolException("改变库位状态失败");
|
}
|
} else {
|
throw new CoolException(dto.getLocNo() + "目标库位已被占用");
|
}
|
return "入库成功";
|
}
|
|
@Override
|
@Transactional
|
public R kthl(KthlParam param) {
|
|
// 获取模式为电脑模式，无任务的堆垛机列表:防止分配到堆垛机不可用
|
List<BasCrnp> basCrnps = basCrnpService.selectList(new EntityWrapper<BasCrnp>().eq("crn_sts", 3)
|
.eq("wrk_no", 0).eq("in_enable", "Y").eq("out_enable", "Y"));
|
if (basCrnps.isEmpty()) {
|
// 都有任务则获取电脑模式的堆垛机列表
|
basCrnps = basCrnpService.selectList(new EntityWrapper<BasCrnp>().eq("crn_sts", 3).eq("in_enable", "Y")
|
.eq("out_enable", "Y"));
|
}
|
WrkMast exist = wrkMastService.selectOne(
|
new EntityWrapper<WrkMast>()
|
.eq("barcode", param.getBarcode())
|
.eq("io_type", 3));
|
if (exist != null) {
|
return R.error("任务已存在，不可重复提交");
|
}
|
if (basCrnps.isEmpty()) {
|
throw new CoolException("没有可用堆垛机,堆垛机停止或异常或禁用");
|
}
|
// 可用堆垛机列表
|
List<Integer> crnNoList = basCrnps.stream().map(BasCrnp::getCrnNo).collect(Collectors.toList());
|
Integer crnNo = crnNoList.get(0);
|
|
int workNo = commonService.getWorkNo(5);
|
Date now = new Date();
|
// 生成工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(new Date());
|
wrkMast.setWrkSts(1L); //
|
wrkMast.setIoType(3); // 站到站
|
wrkMast.setIoPri(14D); // 优先级
|
wrkMast.setCrnNo(crnNo);
|
wrkMast.setSourceStaNo(secondFloorIn[crnNo]);
|
wrkMast.setStaNo(secondFloorOut[crnNo]);
|
wrkMast.setLocNo("");
|
wrkMast.setBarcode(param.getBarcode()); // 托盘码
|
wrkMast.setFullPlt("N"); // 满板：Y
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk("Y"); // 空板
|
wrkMast.setLinkMis("Y");
|
wrkMast.setCtnType(1); // 容器类型
|
// 操作人员数据
|
wrkMast.setAppeTime(now);
|
wrkMast.setModiTime(now);
|
boolean res = wrkMastService.insert(wrkMast);
|
if (!res) {
|
throw new CoolException("保存工作档失败");
|
}
|
// 返回GWCS目标信息
|
pushStaNoToGwcs(param.getPalletizingNo(), wrkMast.getSourceStaNo(), workNo, param.getBarcode(), "二楼空托回流推送gwcs");
|
|
return R.ok("空托回流请求成功");
|
}
|
|
@Override
|
public R tb(TbParam param) {
|
List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("barcode", param.getBarcode()));
|
if (wrkDetls.isEmpty()) {
|
return R.parse("无物料明细信息");
|
}
|
List<String> collect = wrkDetls.stream().map(WrkDetl::getUnit).distinct().collect(Collectors.toList());
|
return R.ok(collect);
|
}
|
|
@Override
|
public R dd(TbParam param) {
|
List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("barcode", param.getBarcode()));
|
if (wrkDetls.isEmpty()) {
|
return R.parse("无物料明细信息");
|
}
|
List<DdParam> collect = wrkDetls.stream().map(wrkDetl -> {
|
DdParam ddParam = new DdParam();
|
ddParam.setBoxPos(wrkDetl.getOrigin());
|
ddParam.setBoxType(wrkDetl.getColor());
|
return ddParam;
|
}).distinct().collect(Collectors.toList());
|
|
return R.ok(collect);
|
}
|
|
@Override
|
@Transactional
|
public synchronized R gwmsGenerateInventory(GwmsGenerateInventoryDto param) {
|
|
if (Cools.isEmpty(param)) {
|
throw new CoolException("请求参数有误：" + param);
|
}
|
if (!Cools.isEmpty(param.getBarcode())) {
|
int zpalletCount = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet", param.getBarcode()));
|
if (zpalletCount > 0) {
|
throw new CoolException("库存托盘码已存在：" + param.getBarcode());
|
}
|
|
int barcodeCount = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("barcode", param.getBarcode()));
|
if (barcodeCount > 0) {
|
throw new CoolException("工作档已存在该托盘码：" + param.getBarcode());
|
}
|
if (!Cools.isEmpty(param.getMatList())) {
|
HashMap<String, Object> xx = new HashMap<>();
|
List<GwmsGenerateInventoryDto.MatList> matList = param.getMatList();
|
for (GwmsGenerateInventoryDto.MatList obj : matList) {
|
int barcodeCount2 = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("brand", obj.getPackageGroupNo()));
|
if (barcodeCount2 > 0) {
|
throw new CoolException("包装组号已存在工作档（输送线）：" + obj.getPackageGroupNo());
|
}
|
int zpalletCount2 = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("brand", obj.getPackageGroupNo()));
|
if (zpalletCount2 > 0) {
|
throw new CoolException("包装组号已存在：" + obj.getPackageGroupNo());
|
}
|
|
// 卷号
|
HashMap<String, Object> yy = new HashMap<>();
|
// 箱号
|
HashMap<String, Object> zz = new HashMap<>();
|
List<GwmsGenerateInventoryDto.Rolls> rolls = obj.getRolls();
|
for(GwmsGenerateInventoryDto.Rolls roll :rolls) {
|
barcodeCount2 = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("model", roll.getRollNo()));
|
if (barcodeCount2 > 0) {
|
throw new CoolException("卷号已存在工作档（输送线）：" + roll.getRollNo());
|
}
|
zpalletCount2 = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("model", roll.getRollNo()));
|
if (zpalletCount2 > 0) {
|
throw new CoolException("卷号已存在库存：" + roll.getRollNo());
|
}
|
|
barcodeCount2 = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("unit", roll.getBoxNo()));
|
if (barcodeCount2 > 0) {
|
throw new CoolException("箱号已存在工作档（输送线）：" + roll.getBoxNo());
|
}
|
zpalletCount2 = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("unit", roll.getBoxNo()));
|
if (zpalletCount2 > 0) {
|
throw new CoolException("箱号已存在库存：" + roll.getBoxNo());
|
}
|
|
if (yy.get(roll.getRollNo()) != null) {
|
throw new CoolException("明细中存在2条相同的卷号：" + roll.getRollNo());
|
} else {
|
yy.put(roll.getRollNo(), roll.getRollNo());
|
}
|
|
if (zz.get(roll.getBoxNo()) != null) {
|
throw new CoolException("明细中存在2条相同的箱号：" + roll.getBoxNo());
|
} else {
|
zz.put(roll.getBoxNo(), roll.getBoxNo());
|
}
|
}
|
if (xx.get(obj.getPackageGroupNo()) != null) {
|
throw new CoolException("明细中存在2条相同的包装组号：" + obj.getPackageGroupNo());
|
} else {
|
xx.put(obj.getPackageGroupNo(), obj);
|
}
|
}
|
}
|
}
|
LocTypeDto locTypeDto = new LocTypeDto();
|
locTypeDto.setLocType1((short) 1);
|
int iotype = 1;
|
if (Cools.isEmpty(param.getMatList())) {
|
iotype = 10;
|
}
|
// 根据源站点寻找库位
|
// StartupDto dto = commonService.getLocNo(1, 1, param.getPalletizingNo(), null,null,null, locTypeDto);
|
StartupDto dto = commonService.getLocNo(iotype, param.getPalletizingNo(), locTypeDto, 0);
|
|
int workNo = dto.getWorkNo();
|
Date now = new Date();
|
// 生成工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setWhsType(iotype == 1 && param.getPalletizingNo() == 2051 ? 1 : 0); // 返修入库标记
|
wrkMast.setIoTime(new Date());
|
wrkMast.setWrkSts(1L); // 工作状态：设备上走
|
wrkMast.setIoType(iotype); // 入出库状态：1.入库
|
wrkMast.setIoPri(13D); // 优先级
|
wrkMast.setCrnNo(dto.getCrnNo());
|
wrkMast.setSourceStaNo(param.getPalletizingNo());
|
wrkMast.setStaNo(dto.getStaNo());
|
wrkMast.setLocNo(dto.getLocNo());
|
wrkMast.setBarcode(param.getBarcode()); // 托盘码
|
wrkMast.setFullPlt("Y"); // 满板：Y
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk("N"); // 空板
|
wrkMast.setLinkMis("Y");
|
wrkMast.setCtnType(1); // 容器类型
|
// 操作人员数据
|
wrkMast.setAppeTime(now);
|
wrkMast.setModiTime(now);
|
boolean res = wrkMastService.insert(wrkMast);
|
if (!res) {
|
throw new CoolException("保存工作档失败");
|
}
|
|
if (!Cools.isEmpty(param.getMatList())) {
|
List<GwmsGenerateInventoryDto.MatList> matList = param.getMatList();
|
for (GwmsGenerateInventoryDto.MatList obj : matList) {
|
WrkDetl wrkDetl = new WrkDetl();
|
wrkDetl.setWrkNo(wrkMast.getWrkNo());
|
obj.getRolls().forEach(roll -> {
|
wrkDetl.setWrkNo(wrkMast.getWrkNo());
|
wrkDetl.setMatnr(roll.getSpecs()); // 规格
|
wrkDetl.setMaktx(roll.getSpecs()); //规格
|
wrkDetl.setUnit(roll.getBoxNo()); // 箱号
|
wrkDetl.setModel(roll.getRollNo()); // 卷号
|
wrkDetl.setBrand(obj.getPackageGroupNo()); // 包装组号
|
wrkDetl.setZpallet(param.getBarcode()); // 托盘码
|
wrkDetl.setBarcode(param.getBarcode());
|
wrkDetl.setOrigin(obj.getBoxPos()); // 木箱在托盘位置
|
wrkDetl.setColor(obj.getBoxType()); // 木箱类型
|
wrkDetl.setManu(obj.getRollType()); // 管芯类型
|
wrkDetl.setSku(obj.getWideInWidth()); // 实测宽幅
|
wrkDetl.setItemNum(obj.getThickness()); // 生箔厚度
|
wrkDetl.setManuDate(roll.getFqTime()); // 分切下料时间
|
wrkDetl.setWeight(roll.getNetWeight()); // 净重
|
wrkDetl.setVolume(roll.getGrossWeight()); // 毛重
|
wrkDetl.setLength(roll.getLength()); // 长度
|
wrkDetl.setSpecs(String.valueOf(roll.getSplices())); // 接头
|
wrkDetl.setAnfme(1.0);
|
// wrkDetl.setThreeCode(null); // 通过mes或excel导入检测是否合格 0不合格，1 合格
|
// wrkDetl.setDeadWarn(); // 理货标识 0默认，1理货中，2理货完成w
|
// wrkDetl.setInspect(); // 订单明细中用，标识备货的状态 0未备货，1备货中，2备货完成
|
// wrkDetl.setDanger(); // 订单明细中用，标识跨巷道移库 0未移库，1移库中，2移库完成
|
wrkDetl.setIoTime(now);
|
wrkDetl.setAppeTime(now);
|
wrkDetl.setAppeUser(21L); // root
|
wrkDetl.setModiUser(21L); // root
|
wrkDetl.setModiTime(now);
|
if (!wrkDetlService.insert(wrkDetl)) {
|
throw new CoolException("保存工作明细失败");
|
}
|
|
// 物料表备份一份
|
// Mat mat = new Mat();
|
// mat.sync(wrkDetl);
|
// mat.setTagId(6L);
|
// mat.setCreateTime(now);
|
// mat.setUpdateTime(now);
|
// if (!matService.insert(mat)) {
|
// throw new CoolException("备份物料表失败");
|
// }
|
|
});
|
}
|
}
|
|
|
// 更新目标库位状态
|
LocMast locMast = locMastService.selectById(dto.getLocNo());
|
if (locMast.getLocSts().equals("O")) {
|
locMast.setLocSts("S"); // S.入库预约
|
locMast.setModiTime(now);
|
if (!locMastService.updateById(locMast)) {
|
throw new CoolException("改变库位状态失败");
|
}
|
} else {
|
throw new CoolException(dto.getLocNo() + "目标库位已被占用");
|
}
|
|
// 返回GWCS目标信息
|
pushStaNoToGwcs(param.getPalletizingNo(), dto.getStaNo(), dto.getWorkNo(), param.getBarcode(), "gwms申请入库后推送gwcs");
|
|
return null;
|
}
|
|
@Override
|
@Transactional
|
public String crnExecute(CrnExecuteParam param) {
|
if (Cools.isEmpty(param.getStaNo(), param.getWorkNo())) {
|
throw new CoolException("参数不能为空：" + param);
|
}
|
|
WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", param.getWorkNo()));
|
if (wrkMast == null) {
|
throw new CoolException("不存在该工作号：" + param.getWorkNo());
|
}
|
if (wrkMast.getWrkSts() == 3 || wrkMast.getWrkSts() == 4) {
|
throw new CoolException("工作档状态不对：" + param.getWorkNo());
|
}
|
wrkMast.setWrkSts(2L);
|
if (wrkMast.getIoType() == 10) {
|
wrkMast.setBarcode(param.getBarcode());
|
} else if (wrkMast.getIoType() == 12) { // 跨巷道转移入库
|
|
} else if (wrkMast.getSourceStaNo() == 3046 || wrkMast.getSourceStaNo() == 3042) {
|
wrkMast.setBarcode(param.getBarcode());
|
}
|
wrkMastService.updateById(wrkMast);
|
|
return "请求成功";
|
}
|
|
@Override
|
@Transactional
|
public R zwmsOutLocWork(ZwmsOutLocWorkDto param) {
|
|
Order order = orderService.selectByNo(param.getOrderNo());
|
if (!Cools.isEmpty(order)) {
|
throw new CoolException(param.getOrderNo() + "单据已存在，请勿重复提交");
|
}
|
|
DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.FALSE);
|
if (docType == null) {
|
return R.parse("单据类型不存在，请检查：" + param.getOrderType());
|
}
|
Date now = new Date();
|
|
// 单据主档
|
order = new Order(
|
String.valueOf(snowflakeIdWorker.nextId()), // 编号[非空]
|
param.getOrderNo(), // 订单编号
|
DateUtils.convert(now), // 单据日期
|
docType.getDocId(), // 单据类型
|
null, // 项目编号
|
null, //
|
null, // 调拨项目编号
|
null, // 初始票据号
|
null, // 票据号
|
null, // 客户编号
|
param.getCustomerName(), // 客户
|
null, // 联系方式
|
null, // 操作人员
|
null, // 合计金额
|
null, // 优惠率
|
null, // 优惠金额
|
null, // 销售或采购费用合计
|
null, // 实付金额
|
null, // 付款类型
|
null, // 业务员
|
null, // 结算天数
|
null, // 邮费支付类型
|
null, // 邮费
|
null, // 付款时间
|
null, // 发货时间
|
null, // 物流名称
|
null, // 物流单号
|
1L, // 订单状态
|
1, // 状态
|
9527L, // 添加人员
|
now, // 添加时间
|
9527L, // 修改人员
|
now, // 修改时间
|
param.getMemo() // 备注
|
);
|
|
if (!orderService.insert(order)) {
|
throw new CoolException("生成单据主档失败，请联系管理员");
|
}
|
|
// 单据明细档
|
for (String groupNo : param.getGroups()) {
|
OrderDetl orderDetl = new OrderDetl();
|
orderDetl.setBrand(groupNo);
|
orderDetl.setBatch("");
|
orderDetl.setOrderId(order.getId());
|
orderDetl.setOrderNo(order.getOrderNo());
|
orderDetl.setCreateBy(9527L);
|
orderDetl.setCreateTime(now);
|
orderDetl.setUpdateBy(9527L);
|
orderDetl.setUpdateTime(now);
|
orderDetl.setStatus(1);
|
orderDetl.setQty(0.0D);
|
orderDetl.setAnfme(1.0);
|
if (!orderDetlService.insert(orderDetl)) {
|
throw new CoolException("生成单据明细失败，请联系管理员");
|
}
|
}
|
|
return R.ok("单据生成成功");
|
|
}
|
|
@Override
|
public R queryInLocTime(List<String> param) {
|
if (Cools.isEmpty(param)) {
|
return R.parse("参数不能为空");
|
}
|
|
List<InLocTimeDto> inLocTimeDtos = locDetlMapper.queryInLocTime(param);
|
|
return R.ok(inLocTimeDtos);
|
}
|
|
@Override
|
@Transactional
|
public String outLocResultReport(GhjtApiParam param) {
|
|
if (Cools.isEmpty(param.getOutLocResult(), param.getWorkNo())) {
|
throw new CoolException("入参不能为空：" + param);
|
}
|
|
WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", param.getWorkNo()));
|
if (wrkMast == null) {
|
throw new CoolException("该工作档不存在，任务号：" + param.getWorkNo());
|
} else if (wrkMast.getWrkSts() != 2) {
|
throw new CoolException("工作档当前状态不符合，任务号：" + param.getWorkNo() + "，工作档状态：" + wrkMast.getWrkSts());
|
}
|
|
List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", param.getWorkNo()));
|
|
// 是否需要复核(出库单需复核)
|
boolean flag = false;
|
if (!wrkDetls.isEmpty()) {
|
flag = wrkDetls.stream().anyMatch(wrkDetl -> wrkDetl.getOrderNo() != null);
|
}
|
|
// 到达出库口确认为1，更新工作档状态为57.出库完成
|
if (param.getOutLocResult() == 1) {
|
// wrkMast.setWrkSts(20L);
|
// // 空托盘到位直接更新工作档状态为14.已出库未确认，空托无需复核确认
|
// if (!flag || wrkMast.getIoType() == 110) {
|
wrkMast.setWrkSts(14L);
|
// }
|
wrkMastService.updateById(wrkMast);
|
}
|
|
if (!wrkDetls.get(0).getMatnr().equals("空箱")) {
|
// 出库上报推送mes记录
|
ckjgsbPushMes(wrkMast, wrkDetls);
|
} else {
|
wrkMast.setWrkSts(14L);
|
wrkMastService.updateById(wrkMast);
|
}
|
|
|
return "出库结果上报成功";
|
}
|
|
public void ckjgsbPushMes(WrkMast wrkMast, List<WrkDetl> wrkDetls) {
|
GwmsGenerateInventoryDto gwmsGenerateInventoryDto = new GwmsGenerateInventoryDto();
|
gwmsGenerateInventoryDto.setWarehouseType(4);
|
gwmsGenerateInventoryDto.setBarcode(wrkMast.getBarcode());
|
gwmsGenerateInventoryDto.setPalletizingNo(wrkMast.getStaNo());
|
gwmsGenerateInventoryDto.setGroupOrderNumber(wrkMast.getMemo());
|
List<GwmsGenerateInventoryDto.MatList> matLists = new ArrayList<>();
|
for (WrkDetl wrkDetl : wrkDetls) {
|
boolean flag = true;
|
for (GwmsGenerateInventoryDto.MatList matList : matLists) {
|
if (matList.getPackageGroupNo().equals(wrkDetl.getBrand())) {
|
matList.getRolls().add(new GwmsGenerateInventoryDto.Rolls(wrkDetl.getModel(),
|
wrkDetl.getUnit(), wrkDetl.getMaktx(), wrkDetl.getLength(),
|
Integer.parseInt(wrkDetl.getSpecs()), wrkDetl.getWeight(), wrkDetl.getVolume(),
|
wrkDetl.getManuDate()));
|
flag = false;
|
break;
|
}
|
}
|
if (flag) {
|
GwmsGenerateInventoryDto.MatList matList = new GwmsGenerateInventoryDto.MatList();
|
matList.setBoxPos(wrkDetl.getOrigin());
|
matList.setPackageGroupNo(wrkDetl.getBrand());
|
matList.setOutOrIn("out");
|
matList.setStockType(wrkMast.getStaNo() == 2041 ? "返修出库" : "成品出库");
|
matList.setBoxType(wrkDetl.getColor());
|
matList.setRollType(wrkDetl.getManu());
|
matList.setWideInWidth(wrkDetl.getSku());
|
matList.setThickness(wrkDetl.getItemNum());
|
List<GwmsGenerateInventoryDto.Rolls> rollsList = new ArrayList<>();
|
GwmsGenerateInventoryDto.Rolls roll = new GwmsGenerateInventoryDto.Rolls(wrkDetl.getModel(),
|
wrkDetl.getUnit(), wrkDetl.getMaktx(), wrkDetl.getLength(),
|
Integer.parseInt(wrkDetl.getSpecs()), wrkDetl.getWeight(), wrkDetl.getVolume(),
|
wrkDetl.getManuDate());
|
rollsList.add(roll);
|
matList.setRolls(rollsList);
|
matLists.add(matList);
|
}
|
}
|
gwmsGenerateInventoryDto.setMatList(matLists);
|
|
|
boolean success = false;
|
// 获取请求头
|
Map<String, Object> headers = new HashMap<>();
|
headers.put("Content-Type", "application/json;charset=UTF-8");
|
|
// 构造请求体
|
String body = JSON.toJSONString(gwmsGenerateInventoryDto);
|
String response = "";
|
try {
|
response = new HttpHandler.Builder()
|
.setUri(MesConstant.MES_CC_IP_PORT)
|
.setPath(MesConstant.MES_CC_FXRK_URL)
|
.setHeaders(headers)
|
.setJson(body)
|
.build()
|
.doPost();
|
if (!Cools.isEmpty(response)) {
|
JSONObject jsonObject1 = JSONObject.parseObject(response);
|
int code = (int) jsonObject1.get("code");
|
boolean state = jsonObject1.getBoolean("state");
|
if (code == 200 && state) {
|
success = true;
|
}
|
} else {
|
log.error("出库上报推送mes记录失败！！！url：{}；request：{}；response：{}", MesConstant.MES_CC_IP_PORT + MesConstant.MES_CC_FXRK_URL, body, response);
|
}
|
} catch (Exception e) {
|
log.error("出库上报推送mes记录异常：{}", e.getMessage());
|
} finally {
|
try {
|
// 保存接口日志
|
apiLogService.save(
|
"出库上报推送mes记录",
|
MesConstant.MES_CC_IP_PORT + MesConstant.MES_CC_FXRK_URL,
|
null,
|
"127.0.0.1",
|
body,
|
response,
|
success
|
);
|
} catch (Exception e) {
|
log.error("", e);
|
}
|
}
|
}
|
|
@Autowired
|
private BasCrnpService basCrnpService;
|
|
@Override
|
@Transactional
|
public String emptyOutLoc(GhjtApiParam param) {
|
// 3102/3009/3008/3006/3003/3002→3047/3112
|
// 获取模式为电脑模式，无任务的堆垛机列表:防止分配到堆垛机不可用
|
List<BasCrnp> basCrnps = basCrnpService.selectList(new EntityWrapper<BasCrnp>().eq("crn_sts", 3)
|
.eq("wrk_no", 0));
|
if (basCrnps.isEmpty()) {
|
// 都有任务则获取电脑模式的堆垛机列表
|
basCrnps = basCrnpService.selectList(new EntityWrapper<BasCrnp>().eq("crn_sts", 3));
|
}
|
if (basCrnps.isEmpty()) {
|
throw new CoolException("没有可用堆垛机,堆垛机停止或异常");
|
}
|
// 可用堆垛机列表
|
List<Integer> crnNoList = basCrnps.stream().map(BasCrnp::getCrnNo).collect(Collectors.toList());
|
// 寻找空托盘库位，先找浅库位
|
List<LocMast> locMasts;
|
locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts", "D")
|
.orderAsc(Arrays.asList("row1", "lev1", "bay1")).in("crn_no", crnNoList).in("row1", 3, 4, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23));
|
if (locMasts.isEmpty()) {
|
locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts", "D")
|
.orderAsc(Arrays.asList("row1", "lev1", "bay1")).in("crn_no", crnNoList).in("row1", 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24));
|
}
|
|
if (locMasts.isEmpty()) {
|
throw new CoolException("没有找到空托盘，站点：" + param.getStaNo());
|
}
|
|
// 取第一个空库位
|
LocMast locMast = locMasts.get(0);
|
|
// 获取工作路径
|
StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>().eq("type_no", 110).eq("stn_no",
|
param.getStaNo()).eq("crn_no", locMast.getCrnNo()));
|
|
if (staDesc == null) {
|
throw new CoolException("路径不存在");
|
}
|
|
//2.生成空托盘出库工作档
|
Date now = new Date();
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(commonService.getWorkNo(WorkNoType.PAKOUT.type));
|
wrkMast.setIoTime(now);
|
wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
|
wrkMast.setIoType(110); // 入出库状态： 110.空板出库
|
wrkMast.setIoPri(10D);
|
wrkMast.setSourceStaNo(staDesc.getCrnStn()); // 源站
|
wrkMast.setStaNo(staDesc.getStnNo()); // 目标站
|
wrkMast.setCrnNo(locMast.getCrnNo());
|
wrkMast.setSourceLocNo(locMast.getLocNo()); // 源库位
|
wrkMast.setBarcode(locMast.getBarcode());
|
wrkMast.setFullPlt("N"); // 满板：Y
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk("Y"); // 空板
|
wrkMast.setLinkMis("N");
|
wrkMast.setAppeUser(9999L);
|
wrkMast.setAppeTime(now);
|
wrkMast.setModiUser(9999L);
|
wrkMast.setModiTime(now);
|
if (!wrkMastService.insert(wrkMast)) {
|
throw new CoolException("保存工作档失败");
|
}
|
|
// 3.更新库位状态 D.空板 -> R.出库预约
|
if (locMast.getLocSts().equals("D")) {
|
locMast.setLocSts("R");
|
locMast.setModiUser(9999L);
|
locMast.setModiTime(now);
|
if (!locMastService.updateById(locMast)) {
|
throw new CoolException("更新库位状态失败");
|
}
|
}
|
|
return "出库成功";
|
}
|
|
@Override
|
@Transactional
|
public R zphjDw(ZphjckdwParam param) {
|
// 根据任务号得到工作主档
|
if (Cools.isEmpty(param.getWorkNo())) {
|
throw new CoolException("工作号不能为空！");
|
}
|
WrkMast wrkMast = wrkMastService.selectById(param.getWorkNo());
|
if (wrkMast == null) {
|
throw new CoolException("工作档不存在！");
|
}
|
if (wrkMast.getWrkSts() != 2 || wrkMast.getIoType() != 103 && wrkMast.getIoType() != 109) {
|
throw new CoolException("工作档当前状态不为2/出库类型不为拣料！");
|
}
|
// 更新工作档状态2.设备上走->42.等待码垛
|
wrkMast.setWrkSts(42L);
|
wrkMastService.updateById(wrkMast);
|
|
// 查询要拆的位置，只有一个
|
List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
|
WrkDetl wrkDetl = wrkDetls.get(0);
|
|
// 返回拆垛规则
|
ZphjcdgzVo zphjcdgzVo = new ZphjcdgzVo();
|
zphjcdgzVo.setWorkNo(wrkDetl.getWrkNo());
|
zphjcdgzVo.setBoxType(wrkDetl.getColor());
|
zphjcdgzVo.setPosition(wrkDetl.getOrigin());
|
zphjcdgzVo.setCdType(wrkMast.getIoType() == 103 ? 1 : 2);
|
|
return R.ok(zphjcdgzVo);
|
}
|
|
@Override
|
@Transactional
|
public R zphjCdwc(ZphjcdwcParam param) {
|
|
if (Cools.isEmpty(param.getWorkNo(), param.getSourceStaNo(), param.getSite(), param.getBarcode())) {
|
return R.parse("参数不能为空，请检查入参");
|
}
|
WrkMast wrkMast = wrkMastService.selectById(param.getWorkNo());
|
if (wrkMast == null) {
|
throw new CoolException("工作档不存在！");
|
}
|
if (wrkMast.getWrkSts() != 42 || wrkMast.getIoType() != 103) {
|
throw new CoolException("工作档当前状态不为42/出库类型不为拣料！");
|
}
|
|
// 获取出库物料
|
List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
|
|
// 源库位
|
LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
|
|
// 创建桁架理货出库的工作档
|
int work = create111Work(wrkMast, wrkDetls, param.getSite(), wrkMast.getStaNo(), param.getBarcode());
|
|
int descFlag = getType(wrkDetls);
|
|
// 保存工作主档历史档
|
if (!wrkMastLogService.save(wrkMast.getWrkNo())) {
|
throw new CoolException("保存工作主档历史档失败");
|
}
|
|
// 获取备货区配置
|
Config config = configMapper.selectConfigByCode("auto_stock_up");
|
if (config == null) {
|
throw new CoolException("理货获取备货区配置错误！！！");
|
}
|
// 前几列是备货区
|
int columnNum = Integer.parseInt(config.getValue());
|
|
// get0原托盘回流信息，get1拆垛出来物料出库信息
|
List<ZphjcdwcVo> zphjcdwcVos = new ArrayList<>();
|
|
ZphjcdwcVo zphjcdwcVo2 = new ZphjcdwcVo();
|
zphjcdwcVo2.setWorkNo(work);
|
zphjcdwcVo2.setSourceStaNo(param.getSite());
|
zphjcdwcVo2.setStaNo(wrkMast.getStaNo());
|
zphjcdwcVo2.setBarcode(param.getBarcode());
|
zphjcdwcVo2.setDescFlag(descFlag);
|
zphjcdwcVos.add(zphjcdwcVo2);
|
|
// 如果从备货区来的，则不能回原库位
|
if (locMast.getBay1() <= columnNum) {
|
|
// 寻找一个新库位
|
LocTypeDto locTypeDto = new LocTypeDto();
|
locTypeDto.setLocType1((short) 1);
|
StartupDto dto = commonService.getLocNo(53, param.getSourceStaNo(), locTypeDto, 0);
|
// 新库位
|
LocMast staLocMast = locMastService.selectById(dto.getLocNo());
|
|
// 更新旧库位状态 O
|
locMast.setLocSts("O");
|
locMast.setBarcode("");
|
locMast.setModiTime(new Date());
|
locMastService.updateById(locMast);
|
|
// 把旧库位明细转到新库位
|
locDetlService.updateLocNo(staLocMast.getLocNo(), wrkMast.getSourceLocNo());
|
|
// 更新新库位状态 Q
|
staLocMast.setLocSts("Q");
|
staLocMast.setBarcode(wrkMast.getBarcode());
|
staLocMast.setModiTime(new Date());
|
locMastService.updateById(staLocMast);
|
|
// 更新工作工作主档
|
wrkMast.setIoType(53);
|
wrkMast.setWrkSts(52L); // 工作状态42->52.设备上走（拆垛完成）
|
// 目标站点源站点转换
|
wrkMast.setStaNo(dto.getStaNo());
|
wrkMast.setSourceStaNo(dto.getSourceStaNo());
|
wrkMast.setCrnNo(dto.getCrnNo());
|
// 目标库位=源库位
|
wrkMast.setLocNo(dto.getLocNo());
|
// 源库位清除
|
wrkMast.setSourceLocNo("");
|
wrkMast.setModiTime(new Date());
|
|
} else {
|
// 更新工作工作主档
|
wrkMast.setIoType(53);
|
wrkMast.setWrkSts(52L); // 工作状态42->52.设备上走（拆垛完成）
|
wrkMast.setSourceStaNo(param.getSourceStaNo());
|
wrkMast.setStaNo(oneFloorIn[wrkMast.getCrnNo()]);
|
// 源库位
|
LocMast staLocMast = locMastService.selectById(wrkMast.getSourceLocNo());
|
// 目标库位=源库位
|
wrkMast.setLocNo(wrkMast.getSourceLocNo());
|
// 源库位清除
|
wrkMast.setSourceLocNo("");
|
wrkMast.setModiTime(new Date());
|
|
// 更新新库位状态 Q
|
staLocMast.setLocSts("Q");
|
staLocMast.setModiTime(new Date());
|
locMastService.updateById(staLocMast);
|
}
|
|
// 更新工作主档
|
wrkMastService.updateById(wrkMast);
|
|
// 回库
|
ZphjcdwcVo zphjcdwcVo1 = new ZphjcdwcVo();
|
zphjcdwcVo1.setWorkNo(wrkMast.getWrkNo());
|
zphjcdwcVo1.setStaNo(wrkMast.getStaNo());
|
zphjcdwcVo1.setSourceStaNo(wrkMast.getSourceStaNo());
|
zphjcdwcVo1.setBarcode(wrkMast.getBarcode());
|
zphjcdwcVos.add(0, zphjcdwcVo1);
|
|
// 下发回库的目标站点和拆垛的出库目标站点给gwcs
|
return R.ok(zphjcdwcVos);
|
}
|
|
@Override
|
public R kxlhCdwc(KxlhcdwcParam param) {
|
|
if (Cools.isEmpty(param.getWorkNo(), param.getSourceStaNo(), param.getSite(), param.getBarcode())) {
|
return R.parse("参数不能为空，请检查入参");
|
}
|
WrkMast wrkMast = wrkMastService.selectById(param.getWorkNo());
|
if (wrkMast == null) {
|
throw new CoolException("工作档不存在！");
|
}
|
if (wrkMast.getWrkSts() != 42 || wrkMast.getIoType() != 109) {
|
throw new CoolException("工作档当前状态不为42/出库类型不为空闲理货！");
|
}
|
|
Date now = new Date();
|
|
// 获取出库物料
|
List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
|
|
// 获取库存物料
|
List<LocDetl> locDetls = locDetlMapper.selectList(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getSourceLocNo()));
|
|
// 源库位
|
LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
|
|
List<ZphjcdwcVo> zphjcdwcVos = new ArrayList<>();
|
|
if (wrkDetls.size() == locDetls.size()) { // 不需要回库，拆完后剩空托盘去叠盘机
|
|
// 删除源库位库存明细
|
locDetlMapper.delete(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getSourceLocNo()));
|
|
// 修改源库位状态
|
if (locMast.getLocSts().equals("R")) {
|
locMast.setLocSts("O");
|
locMast.setBarcode("");
|
locMast.setSheetNo("0");
|
locMast.setModiTime(now);
|
locMast.setIoTime(now);
|
locMastService.updateById(locMast);
|
}
|
|
// 修改工作主档状态
|
wrkMast.setWrkSts(15L);
|
wrkMast.setModiTime(now);
|
wrkMastService.updateById(wrkMast);
|
|
// 下发去叠盘位置
|
ZphjcdwcVo zphjcdwcVo = new ZphjcdwcVo();
|
zphjcdwcVo.setWorkNo(wrkMast.getWrkNo());
|
zphjcdwcVo.setStaNo(3013);
|
zphjcdwcVo.setSourceStaNo(param.getSourceStaNo());
|
zphjcdwcVo.setBarcode(wrkMast.getBarcode());
|
zphjcdwcVos.add(zphjcdwcVo);
|
|
} else { // 拆完后还有物料，需要回库
|
|
// 先删除库存明细，避免还未回库但组盘的先入库了
|
for (WrkDetl wrkDetl : wrkDetls) {
|
locDetlMapper.delete(new EntityWrapper<LocDetl>().eq("brand", wrkDetl.getBrand()));
|
}
|
|
// 修改工作主档
|
wrkMast.setWrkSts(52L);
|
wrkMast.setIoType(59);
|
wrkMast.setSourceStaNo(wrkMast.getStaNo());
|
wrkMast.setStaNo(oneFloorIn[wrkMast.getCrnNo()]);
|
wrkMast.setLocNo(wrkMast.getSourceLocNo());
|
wrkMast.setSourceLocNo("");
|
wrkMast.setModiTime(now);
|
wrkMastService.updateById(wrkMast);
|
|
// 修改源库位状态
|
if (locMast.getLocSts().equals("R")) {
|
locMast.setLocSts("S");
|
locMast.setModiTime(now);
|
locMastService.updateById(locMast);
|
}
|
|
// 下发回库命令
|
ZphjcdwcVo zphjcdwcVo = new ZphjcdwcVo();
|
zphjcdwcVo.setWorkNo(wrkMast.getWrkNo());
|
zphjcdwcVo.setStaNo(oneFloorIn[wrkMast.getCrnNo()]);
|
zphjcdwcVo.setSourceStaNo(param.getSourceStaNo());
|
zphjcdwcVo.setBarcode(wrkMast.getBarcode());
|
zphjcdwcVos.add(zphjcdwcVo);
|
}
|
|
// 组盘点
|
Integer site = param.getSite();
|
|
// 判断组盘是否完成：两个到换盘站点的任务是否完成
|
Wrapper<WrkMast> wrapper = new EntityWrapper<WrkMast>().eq("io_type", 109).ne("wrk_sts", 15);
|
if (site == 3046) {
|
wrapper.in("sta_no", 3045, 3044);
|
} else {
|
wrapper.in("sta_no", 3041, 3040);
|
}
|
int count = wrkMastService.selectCount(wrapper);
|
|
// 已经完成则下发组盘点入库命令
|
if (count == 0) {
|
// 获取到组盘点入库任务
|
WrkMast wrkMast1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_sts", 1).eq("io_type", 1).eq("source_sta_no", site));
|
ZphjcdwcVo zphjcdwcVo = new ZphjcdwcVo();
|
zphjcdwcVo.setWorkNo(wrkMast1.getWrkNo());
|
zphjcdwcVo.setStaNo(wrkMast1.getStaNo());
|
zphjcdwcVo.setSourceStaNo(site);
|
zphjcdwcVo.setBarcode(param.getBarcode());
|
zphjcdwcVos.add(zphjcdwcVo);
|
}
|
|
return R.ok(zphjcdwcVos);
|
}
|
|
@Override
|
public R requestXhd(String barcode) {
|
|
// 没有任务或者不是盘点任务的托盘经过则返回-1，忽略
|
WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode", barcode));
|
if (wrkMast == null || wrkMast.getIoType() != 107) {
|
return R.ok(-1);
|
}
|
|
// 库存明细木箱位置集合
|
List<LocDetl> locDetls = locDetlMapper.selectList(new EntityWrapper<LocDetl>().eq("zpallet", barcode));
|
List<String> collect1 = locDetls.stream().map(LocDetl::getOrigin).distinct().collect(Collectors.toList());
|
// 工作明细木箱位置集合
|
List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("zpallet", barcode));
|
List<String> collect2 = wrkDetls.stream().map(WrkDetl::getOrigin).distinct().collect(Collectors.toList());
|
|
// 0明细异常,1亮左，2亮右，3都亮
|
if (collect1.size() == 0 || collect2.size() == 0) {
|
return R.ok(0);
|
} else if ((collect1.size() == 1 && collect2.size() == 1) || (collect1.size() == 2 && collect2.size() == 2)) {
|
return R.ok(3);
|
} else if (collect1.size() == 2 && collect2.size() == 1) {
|
return R.ok(collect2.get(0).equals("左") ? 1 : 2);
|
} else {
|
return R.parse("亮信号灯条码异常：" + barcode);
|
}
|
|
}
|
|
@Override
|
public R getUnfulfilledOrders() {
|
// 获取未完成订单统计信息
|
List<OrderStatisticsDto> unfulfilledOrders = orderMapper.getUnfulfilledOrders("");
|
return R.ok(unfulfilledOrders);
|
}
|
|
@Override
|
public R getCrnLaneWayInfo() {
|
List<CrnLaneWayInfoDto> crnLaneWayInfo = basCrnpMapper.getCrnLaneWayInfo();
|
return R.ok(crnLaneWayInfo);
|
}
|
|
@Override
|
public R getOutLocInfoByBarcode(String barcode) {
|
|
// 根据托盘码获取任务主档
|
WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode", barcode));
|
if (wrkMast == null) {
|
return R.parse("该条码无正在执行任务：" + barcode);
|
}
|
// 根据任务主档获取工作档明细
|
List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
|
// 提取包装组号
|
List<String> brandList = wrkDetls.stream().map(WrkDetl::getBrand).distinct().collect(Collectors.toList());
|
OutLocInfoDto outLocInfoDto = new OutLocInfoDto();
|
outLocInfoDto.setWrkNo(wrkMast.getWrkNo());
|
List<OutLocInfoDto.Material> materialList = new ArrayList<>();
|
for (String brand : brandList) {
|
// 一个木箱
|
OutLocInfoDto.Material material = new OutLocInfoDto.Material();
|
material.setPackageGroupNo(brand); // 包装组号
|
// 按包装组号过滤
|
List<WrkDetl> wrkDetls1 = wrkDetls.stream().filter(wrkDetl -> Objects.equals(wrkDetl.getBrand(), brand)).collect(Collectors.toList());
|
// 卷信息
|
List<OutLocInfoDto.Material.MaterialDetail> materialDetailList = new ArrayList<>();
|
for (WrkDetl wrkDetl : wrkDetls1) {
|
OutLocInfoDto.Material.MaterialDetail materialDetail = new OutLocInfoDto.Material.MaterialDetail();
|
materialDetail.setRollNo(wrkDetl.getModel());
|
materialDetail.setBoxNo(wrkDetl.getUnit());
|
materialDetail.setSpecs(wrkDetl.getMatnr());
|
materialDetail.setBoxType(wrkDetl.getColor());
|
materialDetail.setCoreType(wrkDetl.getManu());
|
materialDetail.setWidth(wrkDetl.getSku());
|
materialDetail.setThickness(wrkDetl.getItemNum());
|
materialDetail.setWeight(wrkDetl.getWeight());
|
materialDetail.setLength(wrkDetl.getLength());
|
materialDetail.setVolume(wrkDetl.getVolume());
|
materialDetail.setCustomerName(wrkDetl.getSupp());
|
materialDetail.setMemo(wrkDetl.getMemo());
|
material.setBoxPos(wrkDetl.getOrigin()); // 托盘上木箱位置
|
materialDetailList.add(materialDetail);
|
}
|
// 订单信息
|
WrkDetl wrkDetl = wrkDetls1.get(0);
|
if (wrkDetl != null && wrkDetl.getOrderNo() != null) {
|
Order order = orderService.selectOne(new EntityWrapper<Order>().eq("order_no", wrkDetl.getOrderNo()));
|
if (order != null) {
|
material.setOrderNo(order.getOrderNo());
|
// material.setMemo(order.getMemo());
|
// material.setCustomerName(order.getCstmrName());
|
List<OrderStatisticsDto> unfulfilledOrders = orderMapper.getUnfulfilledOrders(order.getOrderNo());
|
if (unfulfilledOrders.size() == 1) {
|
OrderStatisticsDto orderStatisticsDto = unfulfilledOrders.get(0);
|
material.setSum(orderStatisticsDto.getSum());
|
material.setToShipQuantity(orderStatisticsDto.getToShipQuantity());
|
material.setWorkQuantity(orderStatisticsDto.getWorkQuantity());
|
material.setCompleteQuantity(orderStatisticsDto.getCompletedQuantity());
|
}
|
}
|
}
|
|
material.setMaterialDetailList(materialDetailList);
|
materialList.add(material);
|
}
|
outLocInfoDto.setMaterialList(materialList);
|
|
return R.ok(outLocInfoDto);
|
}
|
|
/**
|
* 创建桁架理货出库的工作档
|
*/
|
private int create111Work(WrkMast wrk, List<WrkDetl> wrkDetls, Integer site, Integer staNo, String barcode) {
|
int workNo = commonService.getWorkNo(4);
|
Date now = new Date();
|
// 生成工作档
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(workNo);
|
wrkMast.setIoTime(new Date());
|
wrkMast.setWrkSts(2L); // 工作状态：设备上走
|
wrkMast.setIoType(111); // 入出库状态：111.理货贴标出库
|
wrkMast.setIoPri(13D); // 优先级
|
wrkMast.setCrnNo(wrk.getCrnNo());
|
wrkMast.setSourceStaNo(site);
|
wrkMast.setStaNo(staNo);
|
wrkMast.setSourceLocNo(wrk.getSourceLocNo());
|
wrkMast.setBarcode(barcode); // 托盘码
|
wrkMast.setFullPlt("Y"); // 满板：Y
|
wrkMast.setPicking("N"); // 拣料
|
wrkMast.setExitMk("N"); // 退出
|
wrkMast.setEmptyMk("N"); // 空板
|
wrkMast.setLinkMis("Y");
|
wrkMast.setCtnType(1); // 容器类型
|
// 操作人员数据
|
wrkMast.setAppeTime(now);
|
wrkMast.setModiTime(now);
|
|
// 插入工作档
|
wrkMastService.insert(wrkMast);
|
|
// 插入工作档明细
|
for (WrkDetl wrkDetl : wrkDetls) {
|
wrkDetl.setWrkNo(workNo);
|
wrkDetl.setBarcode(barcode);
|
wrkDetl.setZpallet(barcode);
|
wrkDetlService.insert(wrkDetl);
|
}
|
|
return workNo;
|
}
|
|
/**
|
* 根据出库物料明细判断是否去贴标(单卷贴标，多卷不贴标)
|
*
|
* @param wrkDetls 物料明细
|
* @return 1.多卷直接出路径，4.单卷贴标路径
|
*/
|
private int getType(List<WrkDetl> wrkDetls) {
|
return wrkDetls.size() > 1 ? 1 : 4; // 一条记录就是一卷
|
}
|
|
public boolean pushStaNoToGwcs(Integer palletizingNo, Integer staNo, Integer workNo, String barcode, String message) {
|
int maxRetry = 3; // 最多重试 3 次
|
long retryDelay = 10000; // 重试间隔 10 秒
|
boolean finalSuccess = false;
|
|
Map<String, Object> headers = getHeaders();
|
JSONObject jsonObject = new JSONObject();
|
jsonObject.put("workNo", workNo);
|
jsonObject.put("staNo", staNo);
|
jsonObject.put("sourceStaNo", palletizingNo);
|
jsonObject.put("barcode", barcode);
|
String body = jsonObject.toJSONString();
|
|
for (int attempt = 1; attempt <= maxRetry; attempt++) {
|
String response = "";
|
boolean success = false;
|
String attemptMsg = message + "（第 " + attempt + " 次尝试）";
|
|
try {
|
response = new HttpHandler.Builder()
|
.setUri(MesConstant.GWCS_IP_PORT)
|
.setPath(MesConstant.GWCS_FPKW_URL)
|
.setHeaders(headers)
|
.setJson(body)
|
.setTimeout(30, TimeUnit.SECONDS) // 设置连接 + 读取超时为30秒
|
.build()
|
.doPost();
|
|
|
if (!Cools.isEmpty(response)) {
|
try {
|
JSONObject resJson = JSON.parseObject(response);
|
int code = resJson.getIntValue("code"); // 视具体接口而定
|
if (code == 200) {
|
success = true;
|
finalSuccess = true;
|
log.info("{} 成功，响应：{}", attemptMsg, response);
|
} else {
|
log.warn("{} 响应失败，返回code={}，完整响应：{}", attemptMsg, code, response);
|
}
|
} catch (Exception parseEx) {
|
log.warn("{} 响应解析失败，内容：{}", attemptMsg, response);
|
}
|
} else {
|
log.warn("{} 失败，响应为空", attemptMsg);
|
}
|
} catch (Exception e) {
|
log.error("{} 异常：{}", attemptMsg, e.getMessage(), e);
|
}
|
|
// 每次都记录日志，不论成功或失败
|
try {
|
apiLogService.save(
|
attemptMsg,
|
MesConstant.GWCS_IP_PORT + MesConstant.GWCS_FPKW_URL,
|
null,
|
"127.0.0.1",
|
body,
|
response,
|
success
|
);
|
} catch (Exception e) {
|
log.error("保存接口日志异常：{}", e.getMessage(), e);
|
}
|
|
if (success) break; // 成功就不再重试
|
|
// 如果还有下一次重试，则等待
|
if (attempt < maxRetry) {
|
try {
|
Thread.sleep(retryDelay);
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
break;
|
}
|
}
|
}
|
|
return finalSuccess;
|
}
|
|
|
Map<String, Object> getHeaders() {
|
Map<String, Object> headers = new HashMap<>();
|
headers.put("digi-type", "sync ");
|
headers.put("digi-protocol", "raw");
|
headers.put("digi-datakey", " XCommon.ImportData");
|
|
return headers;
|
}
|
|
|
private void descSta(Integer staNo, Integer crnNo) {
|
// int[] typeNos =new int[]{1,10,53,101,103,110};
|
int[] typeNos = new int[]{10, 110};
|
for (Integer typeNo : typeNos) {
|
descSta3(staNo, crnNo, typeNo);
|
}
|
}
|
|
private void descSta3(Integer staNo, Integer crnNo, Integer typeNo) {
|
StaDesc staDesc = new StaDesc();
|
staDesc.setTypeNo(typeNo);
|
staDesc.setStnNo(staNo);
|
staDesc.setCrnNo(crnNo);
|
staDesc.setCrnStn(CrnNoRC(crnNo, staDesc.getTypeNo() > 100));
|
descSta2(staDesc);
|
}
|
|
private void descSta2(StaDesc staDesc) {
|
Date now = new Date();
|
//入库
|
int sameRes = staDescService.selectCount(new EntityWrapper<StaDesc>()
|
.eq("type_no", staDesc.getTypeNo())
|
.eq("stn_no", staDesc.getStnNo())
|
.eq("crn_no", staDesc.getCrnNo())
|
.eq("crn_stn", staDesc.getCrnStn()));
|
if (sameRes == 0) {
|
staDesc.setModiUser(9527L);
|
staDesc.setModiTime(now);
|
staDesc.setAppeUser(9527L);
|
staDesc.setAppeTime(now);
|
staDescService.insert(staDesc);
|
}
|
}
|
|
private Integer CrnNoRC(Integer crnNo, boolean sign) {
|
Integer crnStn = 0;
|
switch (crnNo) {
|
case 1:
|
crnStn = 102;
|
break;
|
case 2:
|
crnStn = 105;
|
break;
|
case 3:
|
crnStn = 108;
|
break;
|
case 4:
|
crnStn = 111;
|
break;
|
case 5:
|
crnStn = 114;
|
break;
|
case 6:
|
crnStn = 117;
|
break;
|
}
|
if (sign) {
|
return crnStn - 2;
|
}
|
return crnStn;
|
}
|
|
@Override
|
@Transactional
|
public R groupOrderConfirm(GroupOrderConfirmParam param) {
|
// 1. 查询单据是否存在
|
Order order = orderMapper.selectOrderByOrderNo(param.getGroupOrderNumber());
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
|
if (order == null) {
|
// 1.1 不存在，新建单据
|
order = new Order();
|
order.setOrderNo(param.getGroupOrderNumber());
|
order.setStatus(Integer.valueOf(param.getGroupStatus()));
|
order.setOrderTime(sdf.format(new Date()));
|
order.setCreateTime(new Date());
|
order.setSettle(1L);
|
order.setDocType(25L);
|
orderMapper.insert(order);
|
} else {
|
// 1.2 存在，更新单据状态
|
order.setStatus(Integer.valueOf(param.getGroupStatus()));
|
orderMapper.updateById(order);
|
}
|
orderDetlMapper.delete(
|
new EntityWrapper<OrderDetl>().eq("order_no", param.getGroupOrderNumber())
|
);
|
|
// 2. 一一对应遍历
|
List<GroupOrderConfirmParam.PackageGroupNo> pkgList = param.getPackageGroupNos();
|
List<GroupOrderConfirmParam.VolumeNumber> volList = param.getVolumeNumbers();
|
|
int size = Math.min(pkgList.size(), volList.size()); // 防止越界
|
for (int i = 0; i < size; i++) {
|
GroupOrderConfirmParam.PackageGroupNo pg = pkgList.get(i);
|
GroupOrderConfirmParam.VolumeNumber vn = volList.get(i);
|
|
// 查询是否已存在该 detl
|
OrderDetl detl = orderDetlMapper.selectByOrderNoAndPkgGroupNoAndVolumeNo(
|
param.getGroupOrderNumber(), pg.getPackageGroupNo(), vn.getVolumeNumber()
|
);
|
|
if (detl == null) {
|
detl = new OrderDetl();
|
detl.setOrderId(order.getId());
|
detl.setOrderNo(param.getGroupOrderNumber());
|
detl.setCreateTime(new Date());
|
detl.setAnfme(1.0);
|
detl.setBrand(pg.getPackageGroupNo()); // 包装组号
|
detl.setModel(vn.getVolumeNumber()); // 卷号
|
orderDetlMapper.insert(detl);
|
}
|
}
|
|
return R.ok("组货确认成功");
|
}
|
|
|
@Override
|
@Transactional
|
public R returnOrder(ReturnOrderConfirmParam param) {
|
if (Cools.isEmpty(param.getOrderNumber())) {
|
param.setOrderNumber("THCK" + DateUtils.convert(new Date(), DateUtils.yyyyMMdd));
|
}
|
// 1. 查询单据是否存在
|
Order order = orderMapper.selectOrderByOrderNo(param.getOrderNumber());
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
|
if (order == null) {
|
// 1.1 不存在，新建单据
|
order = new Order();
|
order.setOrderNo(param.getOrderNumber());
|
order.setStatus(1);
|
order.setOrderTime(sdf.format(new Date()));
|
order.setCreateTime(new Date());
|
order.setSettle(1L);
|
order.setDocType(26L);
|
order.setMemo(param.getMemo());
|
orderMapper.insert(order);
|
} else {
|
// 1.2 存在，更新单据状态
|
if (order.getStatus() == 4) {
|
order.setStatus(2);
|
}
|
orderMapper.updateById(order);
|
}
|
|
|
// 2. 一一对应遍历
|
List<ReturnOrderConfirmParam.VolumeNumber> volList = param.getVolumeNumbers();
|
|
for (int i = 0; i < volList.size(); i++) {
|
ReturnOrderConfirmParam.VolumeNumber vn = volList.get(i);
|
|
// 查询是否已存在该 detl
|
OrderDetl detl = orderDetlMapper.selectByOrderNoAndPkgGroupNoAndVolumeNo(
|
param.getOrderNumber(), param.getPackageGroupNo(), vn.getVolumeNumber()
|
);
|
|
if (detl == null) {
|
detl = new OrderDetl();
|
detl.setOrderId(order.getId());
|
detl.setOrderNo(param.getOrderNumber());
|
detl.setCreateTime(new Date());
|
detl.setAnfme(1.0);
|
detl.setBrand(param.getPackageGroupNo()); // 包装组号
|
detl.setModel(vn.getVolumeNumber()); // 卷号
|
detl.setMemo(param.getMemo());
|
orderDetlMapper.insert(detl);
|
} else {
|
throw new RuntimeException("该单据的卷号已存在," + vn.getVolumeNumber());
|
}
|
}
|
|
return R.ok("组货确认成功");
|
}
|
|
@Override
|
@Transactional
|
public R unQualifiedOrder(UnQualifiedOrderConfirmParam param) {
|
if (Cools.isEmpty(param.getOrderNumber())) {
|
param.setOrderNumber("UQCK" + DateUtils.convert(new Date(), DateUtils.yyyyMMdd));
|
}
|
// 1. 查询单据是否存在
|
Order order = orderMapper.selectOrderByOrderNo(param.getOrderNumber());
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
|
if (order == null) {
|
// 1.1 不存在，新建单据
|
order = new Order();
|
order.setOrderNo(param.getOrderNumber());
|
order.setStatus(1);
|
order.setOrderTime(sdf.format(new Date()));
|
order.setCreateTime(new Date());
|
order.setSettle(1L);
|
order.setDocType(27L);
|
order.setMemo(param.getMemo());
|
orderMapper.insert(order);
|
} else {
|
// 1.2 存在，更新单据状态
|
if (order.getStatus() == 4) {
|
order.setStatus(2);
|
}
|
orderMapper.updateById(order);
|
}
|
|
|
// 2. 一一对应遍历
|
List<UnQualifiedOrderConfirmParam.VolumeNumber> volList = param.getVolumeNumbers();
|
|
for (int i = 0; i < volList.size(); i++) {
|
UnQualifiedOrderConfirmParam.VolumeNumber vn = volList.get(i);
|
|
// 查询是否已存在该 detl
|
OrderDetl detl = orderDetlMapper.selectByOrderNoAndVolumeNo(
|
param.getOrderNumber(), vn.getVolumeNumber()
|
);
|
|
if (detl == null) {
|
detl = new OrderDetl();
|
detl.setOrderId(order.getId());
|
detl.setOrderNo(param.getOrderNumber());
|
detl.setCreateTime(new Date());
|
detl.setAnfme(1.0);
|
detl.setModel(vn.getVolumeNumber()); // 卷号
|
detl.setMemo(param.getMemo());
|
orderDetlMapper.insert(detl);
|
} else {
|
throw new RuntimeException("该单据的卷号已存在," + vn.getVolumeNumber());
|
}
|
}
|
|
return R.ok("组货确认成功");
|
}
|
|
/*...........................上饶江铜..............以上.............徐工汉云...........................*/
|
}
|
