package com.vincent.rsf.server.api.service.impl;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.vincent.rsf.framework.common.Cools;
|
import com.vincent.rsf.framework.common.R;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.api.controller.erp.params.*;
|
import com.vincent.rsf.server.api.entity.dto.*;
|
import com.vincent.rsf.server.manager.enums.*;
|
import com.vincent.rsf.server.api.service.MobileService;
|
import com.vincent.rsf.server.common.config.ConfigProperties;
|
import com.vincent.rsf.server.common.enums.WarehouseAreaType;
|
import com.vincent.rsf.server.common.security.JwtSubject;
|
import com.vincent.rsf.server.common.utils.FieldsUtils;
|
import com.vincent.rsf.server.common.utils.JwtUtil;
|
import com.vincent.rsf.server.manager.controller.params.GenerateTaskParams;
|
import com.vincent.rsf.server.manager.controller.params.IsptItemsParams;
|
import com.vincent.rsf.server.manager.controller.params.WaitPakinParam;
|
import com.vincent.rsf.server.manager.entity.*;
|
import com.vincent.rsf.server.manager.mapper.*;
|
import com.vincent.rsf.server.manager.service.*;
|
import com.vincent.rsf.server.system.constant.CodeRes;
|
import com.vincent.rsf.server.system.constant.GlobalConfigCode;
|
import com.vincent.rsf.server.system.constant.SerialRuleCode;
|
import com.vincent.rsf.server.system.controller.param.LoginParam;
|
import com.vincent.rsf.server.system.controller.result.LoginResult;
|
import com.vincent.rsf.server.system.entity.*;
|
import com.vincent.rsf.server.system.mapper.FieldsMapper;
|
import com.vincent.rsf.server.system.mapper.TenantMapper;
|
import com.vincent.rsf.server.system.service.ConfigService;
|
import com.vincent.rsf.server.system.service.FieldsItemService;
|
import com.vincent.rsf.server.system.service.UserLoginService;
|
import com.vincent.rsf.server.system.service.UserService;
|
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import javax.servlet.http.HttpServletRequest;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author Ryan
|
* @version 1.0
|
* @title MobileServiceImpl
|
* @description
|
* @create 2025/3/10 08:07
|
*/
|
@Service
|
public class MobileServiceImpl implements MobileService {
|
|
@Value("${super.pwd}")
|
private String superPwd;
|
@Resource
|
private ConfigProperties configProperties;
|
@Autowired
|
private TenantMapper tenantService;
|
@Autowired
|
private UserService userService;
|
@Autowired
|
private UserLoginService userLoginService;
|
@Autowired
|
private WarehouseAreasItemService warehouseAreasItemService;
|
@Autowired
|
private WarehouseAreasService warehouseAreasService;
|
@Resource
|
private AsnOrderItemMapper asnOrderItemMapper;
|
@Autowired
|
private AsnOrderService asnOrderMapper;
|
@Resource
|
private MatnrMapper matnrMapper;
|
@Resource
|
private QlyInspectMapper qlyInspectMapper;
|
@Autowired
|
private QlyIsptItemService qlyIsptItemService;
|
@Resource
|
private StockItemMapper stockItemMapper;
|
@Autowired
|
private LocItemService locItemService;
|
@Resource
|
private PurchaseItemMapper purchaseItemMapper;
|
@Resource
|
private FieldsMapper fieldsMapper;
|
@Autowired
|
private IsptHistoriesMapper isptHistoriesMapper;
|
@Autowired
|
private AsnOrderLogService asnOrderLogService;
|
@Autowired
|
private WaitPakinService waitPakinService;
|
@Autowired
|
private WaitPakinItemService waitPakinItemService;
|
@Autowired
|
private AsnOrderItemLogService asnOrderItemLogService;
|
@Autowired
|
private FieldsItemService fieldsItemService;
|
@Autowired
|
private LocService locService;
|
@Autowired
|
private PurchaseService purchaseService;
|
@Autowired
|
private StockService stockService;
|
@Autowired
|
private StockItemService stockItemService;
|
@Autowired
|
private TaskService taskService;
|
@Autowired
|
private TaskItemService taskItemService;
|
@Autowired
|
private LocAreaMatRelaMapper locAreaMatRelaMapper;
|
@Autowired
|
private LocAreaRelaMapper locAreaRelaMapper;
|
@Autowired
|
private LocAreaMapper locAreaMapper;
|
@Autowired
|
private DeviceSiteMapper deviceSiteMapper;
|
@Autowired
|
private ConfigService configService;
|
@Autowired
|
private CompanysService companysService;
|
@Autowired
|
private OutStockService outStockService;
|
|
/**
|
* @return
|
* @author Ryan
|
* @description 手持PDA登录接口
|
* @params LoginParam param， HttpServletRequest request
|
* @time 2025/3/10 15:36
|
*/
|
@Override
|
public R login(LoginParam param, HttpServletRequest request) {
|
User user = userService.selectByUsernameWithoutTenant(param.getUsername(), null);
|
if (param.getUsername().equals("super") && param.getPassword().equals(Cools.md5(superPwd))) {
|
Map<String, Object> res = new HashMap<>();
|
res.put("username", param.getUsername());
|
res.put("token", JwtUtil.buildToken(new JwtSubject(param.getUsername(), user.getTenantId()),
|
configProperties.getTokenExpireTime(), configProperties.getTokenKey()));
|
return R.ok(res);
|
}
|
|
if (Cools.isEmpty(user)) {
|
return R.parse(CodeRes.USER_10001);
|
}
|
if (user.getStatus() != 1) {
|
return R.parse(CodeRes.USER_10002);
|
}
|
if (!userService.comparePassword(user.getPassword(), param.getPassword())) {
|
return R.parse(CodeRes.USER_10003);
|
}
|
|
String accessToken = JwtUtil.buildToken(new JwtSubject(param.getUsername(), user.getTenantId()),
|
configProperties.getTokenExpireTime(), configProperties.getTokenKey());
|
userLoginService.saveAsync(user.getId(), accessToken, UserLogin.TYPE_LOGIN, user.getTenantId(), null, request);
|
Tenant tenant = tenantService.selectById(user.getTenantId());
|
return R.ok("Sign In Success").add(new LoginResult(accessToken, user, tenant.getName()));
|
}
|
|
/**
|
* @param barcode
|
* @return
|
* @author Ryan
|
* @description 扫码获取收货明细
|
* @time 2025/3/10 15:37
|
*/
|
@Override
|
public R getOrderByCode(String barcode) {
|
if (StringUtils.isBlank(barcode)) {
|
return R.error("标签码不能为空！！");
|
}
|
List<WkOrderItem> wkOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<WkOrderItem>()
|
.eq(WkOrderItem::getTrackCode, barcode));
|
|
if (Objects.isNull(wkOrderItem)) {
|
throw new CoolException("单据明细不存在！！");
|
}
|
List<WkOrderItem> items = new ArrayList<>();
|
for (WkOrderItem record : wkOrderItem) {
|
if (!Objects.isNull(record.getFieldsIndex())) {
|
Map<String, String> fields = FieldsUtils.getFields(record.getFieldsIndex());
|
record.setExtendFields(fields);
|
}
|
items.add(record);
|
}
|
return getAsnOrderItem(items);
|
}
|
|
/**
|
* @param params
|
* @param loginUserId
|
* @return
|
* @author Ryan
|
* @description 收货至收货区
|
* @time 2025/3/10 15:41
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public synchronized R receiptToWarehouse(Map<String, Object> params, Long loginUserId) {
|
if (Objects.isNull(params)) {
|
throw new CoolException("参数不能为空！！");
|
}
|
ReceiptParams receiptParam = JSONObject.parseObject(JSONObject.toJSONString(params), ReceiptParams.class);
|
if (receiptParam.getReceipts().isEmpty()) {
|
throw new CoolException("收货明细不能为空！！");
|
}
|
if (Objects.isNull(receiptParam.getWhAreaId())) {
|
throw new CoolException("库区标识不能为空！！");
|
}
|
|
WarehouseAreas areasItem = warehouseAreasService.getOne(new LambdaQueryWrapper<WarehouseAreas>()
|
.eq(WarehouseAreas::getId, receiptParam.getWhAreaId()));
|
if (Objects.isNull(areasItem)) {
|
throw new CoolException("数据错误：当前库区不存在！！");
|
}
|
|
List<ReceiptDetlsDto> receipts = receiptParam.getReceipts();
|
|
Double receiptQty = receipts.stream().mapToDouble(ReceiptDetlsDto::getReceiptQty).sum();
|
|
if (Objects.isNull(receiptQty) || receiptQty.compareTo(0.00) <= 0) {
|
throw new CoolException("收货数量不能小于或等于零！！");
|
}
|
|
String asnCode = receipts.stream().findFirst().get().getAsnCode();
|
|
WkOrder wkOrder = asnOrderMapper.getOne(new LambdaQueryWrapper<WkOrder>()
|
.eq(WkOrder::getCode, asnCode));
|
|
//判断调拔单出库是否完成
|
if (wkOrder.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER_TERANSFER.type)) {
|
WkOrder one = outStockService.getOne(new LambdaQueryWrapper<WkOrder>()
|
.eq(WkOrder::getPoId, wkOrder.getPoId())
|
.eq(WkOrder::getWkType, OrderWorkType.ORDER_WORK_TYPE_STOCK_TERANSFER.type)
|
.eq(WkOrder::getType, OrderType.ORDER_OUT.type));
|
if (Objects.isNull(one)) {
|
throw new CoolException("数据错误！！");
|
}
|
if (!one.getExceStatus().equals(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val)) {
|
throw new CoolException("调拔出库单未完成，不可执行收货操作！！");
|
}
|
}
|
|
if (Objects.isNull(wkOrder)) {
|
throw new CoolException("数据错误：主单不存在！！");
|
}
|
//TODO /**收货数量累加，1. 会出超收情况 2. 会有收货不足情况*/
|
Double rcptedQty = Math.round((wkOrder.getQty() + receiptQty) * 10000) / 10000.0;
|
wkOrder.setQty(rcptedQty).setExceStatus(AsnExceStatus.ASN_EXCE_STATUS_EXCE_ING.val);
|
if (!asnOrderMapper.updateById(wkOrder)) {
|
throw new CoolException("已收货数量修改失败！！");
|
}
|
Config config = configService.getOne(new LambdaQueryWrapper<Config>().eq(Config::getFlag, GlobalConfigCode.ALLOW_OVER_CHANGE));
|
|
List<Map<String, Object>> receipts1 = (List<Map<String, Object>>) params.get("receipts");
|
for (Map<String, Object> rcpt : receipts1) {
|
if (null == rcpt || Objects.isNull(rcpt)) {
|
continue;
|
}
|
ReceiptDetlsDto dto = JSONObject.parseObject(JSONObject.toJSONString(rcpt), ReceiptDetlsDto.class);
|
Matnr matnr = matnrMapper.selectById(dto.getMatnrId());
|
if (Objects.isNull(matnr)) {
|
throw new CoolException("数据错误：当前物料不存在！！");
|
}
|
if (Objects.isNull(dto.getReceiptQty())) {
|
throw new CoolException("收货数据不能为空！！");
|
}
|
// if (dto.getReceiptQty().compareTo(dto.getAnfme()) > 0) {
|
// throw new CoolException("收货数量不能大于采购数量！！");
|
// }
|
// AsnOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<AsnOrderItem>()
|
// .eq(AsnOrderItem::getAsnCode, asnCode)
|
// .eq(AsnOrderItem::getId, dto.getId())
|
// .eq(AsnOrderItem::getTrackCode, dto.getBarcode())
|
// .eq(AsnOrderItem::getSplrBatch, dto.getSplrBatch()));
|
|
WkOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getId, dto.getId()));
|
//asnOrderItemMapper.resultById(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getId, dto.getId()));
|
|
if (Objects.isNull(orderItem)) {
|
throw new CoolException("通知单明细不存在！！");
|
}
|
if (Objects.isNull(dto.getReceiptQty()) || Double.compare(dto.getReceiptQty(), 0.0) == 0) {
|
throw new CoolException("物料:" + dto.getMaktx() + "收货数量不能为零！！");
|
}
|
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
try {
|
if (!Objects.isNull(dto.getProdTime())) {
|
sdf.parse(dto.getProdTime());
|
}
|
} catch (ParseException e) {
|
throw new CoolException("请输入正确的时间格式！！");
|
}
|
|
Double itemRcptQty = Math.round((dto.getReceiptQty() + orderItem.getQty()) * 10000) / 10000.0;
|
Boolean allowOver = false;
|
if (!Objects.isNull(config)) {
|
if (Boolean.parseBoolean(config.getVal())) {
|
allowOver = true;
|
}
|
}
|
if (itemRcptQty.compareTo(orderItem.getAnfme()) > 0 && !allowOver) {
|
throw new CoolException("收货数量不能大于计划数量！！");
|
}
|
|
orderItem.setQty(itemRcptQty)
|
// .setSplrBatch(dto.getSplrBatch())
|
.setUpdateBy(loginUserId)
|
.setStockUnit(dto.getStockUnit())
|
.setProdTime(dto.getProdTime());
|
|
// if (!Objects.isNull(rcpt)) {
|
// try {
|
// if (Objects.isNull(rcpt.get("fieldsindex")) || StringUtils.isBlank(rcpt.get("fieldsindex").toString())) {
|
// StringBuffer sb = new StringBuffer();
|
// if (!dto.getExtendFields().isEmpty()) {
|
// dto.getExtendFields().forEach(field -> {
|
// field.keySet().forEach(key -> {
|
// sb.append(field.get(key));
|
// });
|
// });
|
// }
|
// sb.append(dto.getAsnCode() + dto.getMatnr() + dto.getSplrBatch() + orderItem.getIsptResult$());
|
// //获取16位uuid
|
// String uuid16 = Cools.md5Chinese(sb.toString());
|
// rcpt.put("index", uuid16);
|
// orderItem.setFieldsIndex(uuid16);
|
// }
|
// //保存或更新扩展字段
|
// FieldsUtils.updateFieldsValue(rcpt);
|
// } catch (Exception e) {
|
// throw new RuntimeException(e);
|
// }
|
// }
|
|
if (asnOrderItemMapper.updateById(orderItem) < 1) {
|
throw new CoolException("通知单明细数量修改失败！！");
|
}
|
/**保存明细至收货区**/
|
extracted(loginUserId, dto, areasItem, orderItem, wkOrder, matnr);
|
|
}
|
|
WkOrder order = asnOrderMapper.getOne(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getCode, asnCode));
|
if (order.getQty().compareTo(order.getAnfme()) >= 0.00) {
|
order.setExceStatus(AsnExceStatus.ASN_EXCE_STATUS_RECEIPT_DONE.val).setRleStatus(Short.valueOf("1"));
|
if (!asnOrderMapper.updateById(order)) {
|
throw new CoolException("订单状态修改失败！！");
|
}
|
}
|
|
return R.ok("收货成功！！");
|
}
|
|
private void extracted(Long loginUserId, ReceiptDetlsDto dto, WarehouseAreas areasItem, WkOrderItem orderItem, WkOrder wkOrder, Matnr matnr) {
|
|
Companys companys = new Companys();
|
if (StringUtils.isNoneBlank(orderItem.getSplrCode())) {
|
companys = companysService.getOne(new LambdaQueryWrapper<Companys>().eq(Companys::getCode, orderItem.getSplrCode()));
|
}
|
|
WarehouseAreasItem item = new WarehouseAreasItem();
|
item.setTrackCode(dto.getBarcode())
|
.setAreaName(areasItem.getName())
|
.setAreaId(areasItem.getId())
|
.setAsnItemId(orderItem.getId())
|
.setAsnCode(wkOrder.getCode())
|
.setAsnId(wkOrder.getId())
|
.setProdTime(dto.getProdTime())
|
.setSplrId(companys.getId())
|
.setWeight(dto.getWeigth())
|
.setPlatOrderCode(orderItem.getPlatOrderCode())
|
.setPlatWorkCode(orderItem.getPlatWorkCode())
|
.setProjectCode(orderItem.getProjectCode())
|
//库存单位为最小单位
|
.setUnit(orderItem.getStockUnit())
|
.setStockUnit(orderItem.getStockUnit())
|
.setBatch(StringUtils.isBlank(orderItem.getBatch()) ? SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_RECEIPT_BATCH, dto) : orderItem.getBatch())
|
.setAnfme(dto.getReceiptQty())
|
.setSplrBatch(dto.getSplrBatch())
|
.setMatnrCode(matnr.getCode())
|
.setUpdateBy(loginUserId)
|
.setCreateBy(loginUserId)
|
.setMatnrId(matnr.getId())
|
.setIsptResult(orderItem.getIsptResult())
|
.setMaktx(matnr.getName())
|
.setWeight(matnr.getWeight())
|
.setFieldsIndex(orderItem.getFieldsIndex())
|
.setShipperId(matnr.getShipperId());
|
//TODO 供应商标识未设置，标识由PO单供应商编码转换
|
|
LambdaQueryWrapper<WarehouseAreasItem> queryWrapper = new LambdaQueryWrapper<WarehouseAreasItem>()
|
// .eq(WarehouseAreasItem::getAsnItemId, item.getAsnItemId())
|
.eq(WarehouseAreasItem::getMatnrCode, item.getMatnrCode())
|
.eq(!Cools.isEmpty(item.getFieldsIndex()), WarehouseAreasItem::getFieldsIndex, item.getFieldsIndex())
|
.eq(WarehouseAreasItem::getAsnCode, item.getAsnCode())
|
.eq(StringUtils.isNotBlank(item.getSplrBatch()), WarehouseAreasItem::getSplrBatch, item.getSplrBatch());
|
if (Objects.isNull(orderItem.getIsptResult())) {
|
queryWrapper.isNull(WarehouseAreasItem::getIsptResult);
|
} else {
|
queryWrapper.eq(WarehouseAreasItem::getIsptResult, orderItem.getIsptResult());
|
}
|
|
WarehouseAreasItem serviceOne = warehouseAreasItemService.getOne(queryWrapper);
|
|
if (!Objects.isNull(serviceOne)) {
|
item.setId(serviceOne.getId());
|
Double anfme = Math.round((item.getAnfme() + serviceOne.getAnfme()) * 10000) / 10000.0;
|
item.setAnfme(anfme);
|
}
|
|
//未质检
|
if (!warehouseAreasItemService.saveOrUpdate(item)) {
|
throw new CoolException("收货失败！！");
|
}
|
|
// if (null != orderItem.getSafeQty() || null != orderItem.getDisQty() ) {
|
//
|
// }
|
// else {
|
// //不合格数量
|
// if (orderItem.getDisQty().compareTo(0.00) > 0) {
|
// item.setIsptQty(orderItem.getDisQty()).setFlagNorm(QlyIsptResult.QLY_ISPT_RESULT_DEFECT.val);
|
// if (!warehouseAreasItemService.saveOrUpdate(item)) {
|
// throw new CoolException("收货失败！！");
|
// }
|
// }
|
//
|
// item.setIsptQty(orderItem.getSafeQty()).setFlagNorm(QlyIsptResult.QLY_ISPT_RESULT_EXCELLENT.val);
|
// if (!warehouseAreasItemService.saveOrUpdate(item)) {
|
// throw new CoolException("收货失败！！");
|
// }
|
// }
|
|
|
}
|
|
/**
|
* @param params
|
* @return
|
* @author Ryan
|
* @description 其它收货
|
*/
|
@Override
|
public R otherReceipt(OtherReceiptParams params) {
|
if (Objects.isNull(params.getAsnCode())) {
|
throw new CoolException("通知单不能为空！！");
|
}
|
|
List<Short> shorts = Arrays.asList(AsnExceStatus.ASN_EXCE_STATUS_TASK_CANCEL.val, AsnExceStatus.ASN_EXCE_STATUS_TASK_CLOSE
|
.val, AsnExceStatus.ASN_EXCE_STATUS_TASK_DONE.val);
|
WkOrder order = asnOrderMapper.getOne(new LambdaQueryWrapper<WkOrder>()
|
.notIn(WkOrder::getExceStatus, shorts)
|
.eq(WkOrder::getCode, params.getAsnCode()));
|
if (Objects.isNull(order)) {
|
throw new CoolException("请检查订单状态是否已完成或已取消！！");
|
}
|
|
List<WkOrderItem> wkOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<WkOrderItem>()
|
.eq(WkOrderItem::getOrderCode, params.getAsnCode())
|
.eq(!Objects.isNull(params.getTrackCode()), WkOrderItem::getTrackCode, params.getTrackCode())
|
.eq(!Cools.isEmpty(params.getMatnrCode()), WkOrderItem::getMatnrCode, params.getMatnrCode())
|
);
|
|
if (Objects.isNull(wkOrderItem)) {
|
throw new CoolException("单据明细不存在！！");
|
}
|
|
List<WkOrderItem> items = new ArrayList<>();
|
for (WkOrderItem record : wkOrderItem) {
|
if (!Objects.isNull(record.getFieldsIndex())) {
|
Map<String, String> fields = FieldsUtils.getFields(record.getFieldsIndex());
|
record.setExtendFields(fields);
|
}
|
items.add(record);
|
}
|
|
return getAsnOrderItem(items);
|
|
}
|
|
/**
|
* @return
|
* @author Ryan
|
* @description 获取所有通知单
|
*/
|
@Override
|
public List<WkOrder> getAllAsnOrders() {
|
List<WkOrder> wkOrders = asnOrderMapper.list(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getWkType, OrderWorkType.ORDER_WORK_TYPE_PURCHASE.type));
|
return wkOrders;
|
}
|
|
/**
|
* @param
|
* @return
|
* @author Ryan
|
* @description 获取收货区
|
* @time 2025/3/11 10:12
|
*/
|
@Override
|
public R getReceiptAreas() {
|
List<WarehouseAreas> areas = warehouseAreasService.list(new LambdaQueryWrapper<WarehouseAreas>()
|
.eq(WarehouseAreas::getType, WarehouseAreaType.WAREHOUSE_AREA_RECEIPT.type));
|
return R.ok(areas);
|
}
|
|
/**
|
* @param
|
* @return
|
* @author Ryan
|
* @description 获取所有启用动态字段
|
* @time 2025/3/12 09:23
|
*/
|
@Override
|
public List<Fields> getDynamicFields() {
|
return fieldsMapper.selectList(new LambdaQueryWrapper<Fields>()
|
.eq(Fields::getFlagEnable, 1)
|
.eq(Fields::getStatus, 1).orderByAsc(Fields::getId));
|
}
|
|
/**
|
* @param
|
* @return
|
* @author Ryan
|
* @description 获取组盘明细
|
* @time 2025/4/7 16:58
|
*/
|
@Override
|
public R getDeltByCode(Map<String, Object> params) {
|
Object code = params.get("code");
|
Object matnrCode = params.get("matnrCode");
|
Object asnCode = params.get("asnCode");
|
Object batch = params.get("batch");
|
|
//TODO 后续需根据策略配置，获取组拖数据。如：混装，按批次混装等
|
LambdaQueryWrapper<WarehouseAreasItem> queryWrapper = new LambdaQueryWrapper<WarehouseAreasItem>()
|
.or().eq(!Cools.isEmpty(code), WarehouseAreasItem::getTrackCode, code)
|
.or().eq(!Cools.isEmpty(batch), WarehouseAreasItem::getSplrBatch, batch)
|
.or().eq(!Cools.isEmpty(matnrCode), WarehouseAreasItem::getMatnrCode, matnrCode)
|
.or().eq(!Cools.isEmpty(asnCode), WarehouseAreasItem::getAsnCode, asnCode);
|
List<WarehouseAreasItem> list = warehouseAreasItemService.list(queryWrapper);
|
list.removeIf(e -> e.getAnfme() <= e.getWorkQty());
|
return R.ok(list);
|
}
|
|
/**
|
* @param
|
* @param userId
|
* @return
|
* @author Ryan
|
* @description PDA组拖
|
* @time 2025/3/29 14:26
|
*/
|
@Override
|
public WaitPakin mergeItems(WaitPakinParam waitPakin, Long userId) {
|
return waitPakinService.mergeItems(waitPakin, userId);
|
}
|
|
/**
|
* @param param
|
* @return
|
* @author Ryan
|
* @description 解绑
|
*/
|
@Override
|
public WaitPakin unBind(WaitPakinParam param) {
|
return waitPakinService.unBind(param);
|
}
|
|
/**
|
* 报检功能
|
*
|
* @param code
|
* @param loginUserId
|
* @return
|
*/
|
@Override
|
public R inspect(String code, Long loginUserId) {
|
WkOrder wkOrders = asnOrderMapper.getOne(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getCode, code));
|
if (Objects.isNull(wkOrders)) {
|
throw new CoolException("单据不存在！！");
|
}
|
InspectDetlDto detlDto = new InspectDetlDto();
|
detlDto.setCode(wkOrders.getCode()).setId(wkOrders.getId()).setPoCode(wkOrders.getPoCode());
|
List<WkOrderItem> orderItems = asnOrderItemMapper.selectList(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderCode, code));
|
if (orderItems.isEmpty()) {
|
detlDto.setItems(new ArrayList<>());
|
} else {
|
List<InspectItemDto> itemDtos = new ArrayList<>();
|
orderItems.forEach(dto -> {
|
InspectItemDto itemDto = new InspectItemDto();
|
if (!Objects.isNull(dto.getMatnrCode())) {
|
Matnr matnr = matnrMapper.selectOne(new LambdaQueryWrapper<Matnr>().eq(Matnr::getCode, dto.getMatnrCode()));
|
itemDto.setGroup(matnr.getGroupCode());
|
}
|
itemDto.setMaktx(dto.getMaktx())
|
.setMatnrCode(dto.getMatnrCode())
|
.setPurUnit(dto.getPurUnit())
|
.setSuplierCode(dto.getSplrCode())
|
.setSuplierName(dto.getSplrName())
|
.setPurQty(dto.getPurQty());
|
itemDtos.add(itemDto);
|
});
|
detlDto.setItems(itemDtos);
|
}
|
|
List<IsptHistories> histories = isptHistoriesMapper.selectList(new LambdaQueryWrapper<IsptHistories>().eq(IsptHistories::getAsnId, wkOrders.getId()));
|
detlDto.setHistories(histories);
|
return R.ok(detlDto);
|
}
|
|
/**
|
* @param
|
* @return
|
* @author Ryan
|
* @description 提交报检
|
* @time 2025/4/1 16:47
|
*/
|
@Override
|
public R confirmIspt(String id) {
|
if (org.apache.commons.lang3.StringUtils.isBlank(id)) {
|
throw new CoolException("参数不能为空！！");
|
}
|
WkOrder wkOrder = asnOrderMapper.getById(id);
|
if (Objects.isNull(wkOrder)) {
|
throw new CoolException("单据不存在！！");
|
}
|
List<WkOrder> orders = new ArrayList<>();
|
orders.add(wkOrder);
|
if (asnOrderMapper.notifyInspect(orders)) {
|
return R.ok("上报成功！！");
|
} else {
|
return R.error("上报失败！！");
|
}
|
}
|
|
/**
|
* 通过物料，质检单获取需要质检单据
|
*
|
* @param params
|
* @return
|
*/
|
@Override
|
public R checkObjs(CheckObjParams params) {
|
if (Objects.isNull(params.getIsptCode())) {
|
throw new CoolException("质检单不能为空");
|
}
|
List<Short> asList = Arrays.asList(QlyIsptStatus.QLY_ISPT_STAS_DONE.val, QlyIsptStatus.QLY_ISPT_STAS_CLOSE.val);
|
QlyInspect inspect = qlyInspectMapper.selectOne(new LambdaQueryWrapper<QlyInspect>()
|
.notIn(QlyInspect::getIsptStatus, asList)
|
.eq(QlyInspect::getCode, params.getIsptCode()));
|
if (Objects.isNull(inspect)) {
|
throw new CoolException("质检单据不存在！!");
|
}
|
List<QlyIsptItem> isptItems = qlyIsptItemService.list(new LambdaQueryWrapper<QlyIsptItem>()
|
.eq(StringUtils.isNotBlank(params.getMatnrCode()), QlyIsptItem::getMatnrCode, StringUtils.isNotBlank(params.getMatnrCode()) ? params.getMatnrCode() : null)
|
.eq(QlyIsptItem::getIspectId, inspect.getId()));
|
if (Objects.isNull(isptItems)) {
|
throw new CoolException("质检单明细不存在！！");
|
}
|
List<CheckObjDto> dtos = new ArrayList<>();
|
isptItems.forEach(isptItem -> {
|
CheckObjDto objDto = new CheckObjDto();
|
objDto.setIsptCode(inspect.getCode())
|
.setAsnCode(inspect.getAsnCode())
|
.setId(isptItem.getId())
|
.setMatnrCode(isptItem.getMatnrCode())
|
.setMaktx(isptItem.getMaktx())
|
// .setDisQty(isptItem.getDisQty())
|
.setDlyQty(isptItem.getDlyQty())
|
.setRcptQty(isptItem.getRcptQty())
|
.setIsptResult(isptItem.getIsptResult())
|
.setSplrBatch(isptItem.getSplrBatch())
|
.setSplrName(isptItem.getSplrName())
|
.setPicPath(isptItem.getPicPath())
|
.setMemo(isptItem.getMemo());
|
// .setSafeQty(isptItem.getSafeQty());
|
dtos.add(objDto);
|
});
|
return R.ok(dtos);
|
}
|
|
/**
|
* 快速质检
|
*
|
* @param params
|
* @param loginUserId
|
* @return
|
*/
|
@Override
|
public R checkUpdate(List<QlyIsptItem> params, Long loginUserId) {
|
if (Objects.isNull(params) || params.isEmpty()) {
|
throw new CoolException("参数不能为空！！");
|
}
|
IsptItemsParams itemsParams = new IsptItemsParams();
|
itemsParams.setIsptItem(params).setType("0");
|
if (qlyIsptItemService.batchUpdate(itemsParams, loginUserId)) {
|
return R.ok();
|
} else {
|
return R.error("保存失败！！");
|
}
|
}
|
|
/**
|
* @param
|
* @return
|
* @author Ryan
|
* @description 人工上架
|
* @time 2025/4/2 16:33
|
*/
|
@Override
|
public R operateToStock(OpStockParams params) {
|
if (org.apache.commons.lang3.StringUtils.isBlank(params.getBarcode())) {
|
throw new CoolException("托盘码不能为空！！");
|
}
|
WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, params.getBarcode())
|
.eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val)
|
);
|
if (Cools.isEmpty(waitPakin)) {
|
throw new CoolException("未找到组托数据,请检查状态");
|
}
|
List<WaitPakinItem> waitPakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin.getId()));
|
if (Cools.isEmpty(waitPakinItems)) {
|
throw new CoolException("数据错误，未找到组托明细");
|
}
|
|
|
return R.ok(waitPakinItems);
|
}
|
|
/**
|
* 人工上架入库
|
*
|
* @param params
|
* @param loginUserId
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public synchronized R publicToStock(PublicToStockParams params, Long loginUserId) {
|
if (Objects.isNull(params.getLocCode()) || StringUtils.isBlank(params.getLocCode())) {
|
throw new CoolException("库位不能为空！！");
|
}
|
if (Objects.isNull(params.getItemList()) || params.getItemList().isEmpty()) {
|
throw new CoolException("单据明细不能为空！！");
|
}
|
Long OrderId = params.getItemList().stream().findFirst().get().getOrderId();
|
/**获取平库订单*/
|
WkOrder order = asnOrderMapper.getOne(new LambdaQueryWrapper<WkOrder>()
|
.eq(WkOrder::getId, OrderId)
|
.eq(WkOrder::getWkType, OrderWorkType.ORDER_WORK_TYPE_OTHER_IN.type)
|
.eq(WkOrder::getType, OrderType.ORDER_IN.type));
|
if (Objects.isNull(order)) {
|
throw new CoolException("非平库单据不可执行人工上架！！");
|
}
|
Stock stock = new Stock();
|
// if (!Objects.isNull(order.getPoCode()) && StringUtils.isNotBlank(order.getPoCode())) {
|
// Purchase purchase = purchaseService.getOne(new LambdaQueryWrapper<Purchase>().eq(Purchase::getCode, order.getPoCode()));
|
// if (!Objects.isNull(purchase)) {
|
// stock.setPlatOrderNo(purchase.getPlatCode()).setPlatToken(purchase.getPlatId());
|
// }
|
// }
|
String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_STOCK_CODE, null);
|
if (StringUtils.isBlank(ruleCode)) {
|
throw new CoolException("当前业务：" + SerialRuleCode.SYS_STOCK_CODE + "，编码规则不存在！！");
|
}
|
List<WkOrderItem> itemList = params.getItemList();
|
double sum = itemList.stream().mapToDouble(WkOrderItem::getAnfme).sum();
|
stock.setAnfme(sum)
|
.setSourceId(order.getId())
|
.setType(order.getType())
|
.setUpdateBy(loginUserId)
|
.setCreateBy(loginUserId)
|
.setWkType(Short.parseShort(order.getWkType()));
|
if (!stockService.save(stock)) {
|
throw new CoolException("库存保存失败！！");
|
}
|
//TODO 平库上架策略问题： 1 平库库位是单独设计，还是与产库一起用类型区分
|
Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, params.getLocCode()));
|
if (Objects.isNull(loc)) {
|
throw new CoolException("库位不存在！！");
|
}
|
//locItemSerivce
|
List<LocItem> locItems = new ArrayList<>();
|
itemList.forEach(asnOrderItem -> {
|
LocItem item = new LocItem();
|
BeanUtils.copyProperties(asnOrderItem, item);
|
item.setLocId(loc.getId())
|
.setId(null)
|
.setLocCode(loc.getCode())
|
.setOrderId(order.getId())
|
.setUpdateBy(loginUserId)
|
.setUpdateBy(loginUserId)
|
.setOrderItemId(asnOrderItem.getId())
|
.setWkType(Short.parseShort(order.getWkType()))
|
.setType(order.getType());
|
locItems.add(item);
|
});
|
if (!locItemService.saveBatch(locItems)) {
|
throw new CoolException("库位明细更新失败！！");
|
}
|
|
List<StockItem> stockItems = new ArrayList<>();
|
itemList.forEach(orderItem -> {
|
StockItem stockItem = new StockItem();
|
BeanUtils.copyProperties(orderItem, stockItem);
|
stockItem.setSourceItemId(orderItem.getId())
|
.setBarcode(orderItem.getBarcode())
|
.setStockCode(stock.getCode())
|
.setUpdateBy(loginUserId)
|
.setCreateBy(loginUserId)
|
.setId(null)
|
.setStockId(stock.getId());
|
stockItems.add(stockItem);
|
});
|
|
if (!stockItemService.saveBatch(stockItems)) {
|
throw new CoolException("任务上架失败！！");
|
}
|
return R.ok(stock);
|
}
|
|
/**
|
* 获取任务信息
|
*
|
* @param code
|
* @return
|
*/
|
@Override
|
public R taskToStock(String code) {
|
if (StringUtils.isBlank(code)) {
|
throw new CoolException("拖盘码不能为空！！");
|
}
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, code));
|
if (Objects.isNull(task)) {
|
throw new CoolException("拖盘任务不存在！！");
|
}
|
List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
|
if (taskItems.isEmpty()) {
|
throw new CoolException("拖盘任务明细不存在！！");
|
}
|
TaskQueueDto queueDto = new TaskQueueDto();
|
queueDto.setTask(task).setTaskItems(taskItems);
|
List<Long> list = taskItems.stream().map(TaskItem::getMatnrId).collect(Collectors.toList());
|
List<LocAreaMatRela> matRelas = locAreaMatRelaMapper.selectList(new LambdaQueryWrapper<LocAreaMatRela>().in(LocAreaMatRela::getMatnrId,
|
list));
|
TaskLocAreaDto locAreaDto = new TaskLocAreaDto();
|
/**判断是否为空*/
|
if (matRelas.isEmpty()) {
|
locAreaDto.setLocs(new ArrayList<>());
|
} else {
|
Long ids = matRelas.stream().map(LocAreaMatRela::getLocId).collect(Collectors.toList()).stream().findFirst().get();
|
List<Loc> locs = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getId, ids));
|
if (locs.isEmpty()) {
|
locAreaDto.setLocs(new ArrayList<>());
|
} else {
|
LocArea locArea = locAreaMapper.selectById(new LambdaQueryWrapper<Loc>().in(Loc::getId, ids));
|
if (!Objects.isNull(locArea)) {
|
locAreaDto.setAreaName(locArea.getName()).setAreaCode(locArea.getCode()).setAreaId(locArea.getId());
|
}
|
locAreaDto.setLocs(locs);
|
}
|
}
|
queueDto.setLocArea(locAreaDto);
|
|
return R.ok(queueDto);
|
}
|
|
/**
|
* @param code
|
* @return
|
* @Author Ryan
|
* @desc 任务上架
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public synchronized R taskGetLocs(String code) throws Exception {
|
if (StringUtils.isBlank(code)) {
|
throw new CoolException("拖盘码不能为空！！");
|
}
|
Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, code));
|
if (Objects.isNull(task)) {
|
throw new CoolException("拖盘任务不存在！！");
|
}
|
List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
|
if (!taskItems.isEmpty()) {
|
throw new CoolException("拖盘任务明细不存在！！");
|
}
|
List<Task> tasks = new ArrayList<>();
|
tasks.add(task);
|
|
taskService.completeTask(tasks);
|
|
return R.ok();
|
}
|
|
@Override
|
public R completeOrder(Long id, Long loginUserId) {
|
return asnOrderMapper.completeOrder(id, loginUserId);
|
}
|
|
/**
|
* @param
|
* @return
|
* @author Ryan
|
* @description 通过容器获取组拖物料
|
* @time 2025/4/9 16:57
|
*/
|
@Override
|
public R getItemByContainer(Map<String, Object> params) {
|
// if (Objects.isNull(params.get("code"))) {
|
// throw new CoolException("参数不能为空！！");
|
// }
|
//获取组拖未生成任务的组拖档
|
List<Short> asList = Arrays.asList(Short.valueOf(PakinIOStatus.PAKIN_IO_STATUS_DONE.val));
|
Short flagDefect = 0;
|
if (!Objects.isNull(params.get("type")) && params.get("type").equals("defective")) {
|
flagDefect = 1;
|
}
|
List<WaitPakin> waitPakin = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>()
|
.eq(WaitPakin::getBarcode, params.get("barcode").toString())
|
// .eq(WaitPakin::getFlagDefect, flagDefect)
|
.in(WaitPakin::getIoStatus, asList));
|
if (!Cools.isEmpty(waitPakin)) {
|
throw new CoolException("托盘不可用,在组托中已存在");
|
}
|
List<Loc> locs = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getBarcode, params.get("barcode").toString()));
|
if (!Cools.isEmpty(locs)) {
|
throw new CoolException("托盘不可用，在库位中已存在");
|
}
|
return R.ok("托盘可用");
|
}
|
|
/**
|
* @param
|
* @return
|
* @author Ryan
|
* @description 通过容器获取组拖物料
|
* @time 2025/4/9 16:57
|
*/
|
@Override
|
public R getUnItemByContainer(Map<String, Object> params) {
|
if (Cools.isEmpty(params.get("barcode")) && Cools.isEmpty(params.get("code"))) {
|
throw new CoolException("容器号与组托档编码不能全为空");
|
}
|
//获取组拖未生成任务的组拖档
|
// List<Short> asList = Arrays.asList(Short.valueOf(PakinIOStatus.PAKIN_IO_STATUS_DONE.val), Short.valueOf(PakinIOStatus.PAKIN_IO_STATUS_DONE.val));
|
|
WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
|
.eq(!Cools.isEmpty(params.get("barcode")), WaitPakin::getBarcode, params.get("barcode"))
|
.eq(!Cools.isEmpty(params.get("code")), WaitPakin::getCode, params.get("code"))
|
.eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val));
|
if (Objects.isNull(waitPakin)) {
|
return R.error("未找到该容器码的组托明细，请检查组托状态");
|
}
|
List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>()
|
.eq(WaitPakinItem::getPakinId, waitPakin.getId()));
|
// if (pakinItems.isEmpty()) {
|
// return R.ok(new ArrayList<>());
|
// }
|
// List<Long> list = pakinItems.stream().map(WaitPakinItem::getSource).collect(Collectors.toList());
|
// LambdaQueryWrapper<WarehouseAreasItem> queryWrapper = new LambdaQueryWrapper<WarehouseAreasItem>().in(WarehouseAreasItem::getId, list);
|
// List<WarehouseAreasItem> warehouseAreasItems = warehouseAreasItemService.list(queryWrapper);
|
// for (int i = 0; i < warehouseAreasItems.size(); i++) {
|
// for (WaitPakinItem pakinItem : pakinItems) {
|
// if (warehouseAreasItems.get(i).getId().equals(pakinItem.getSource())) {
|
// warehouseAreasItems.get(i).setAnfme(pakinItem.getAnfme());
|
// }
|
// }
|
// }
|
return R.ok(pakinItems);
|
}
|
|
|
/**
|
* @param
|
* @return
|
* @author Ryan
|
* @description 不良标签
|
* @time 2025/4/12 08:12
|
*/
|
@Override
|
public R defectProducts(String trackCode) {
|
WkOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getTrackCode, trackCode));
|
return R.ok(orderItem);
|
}
|
|
/**
|
* @param barcode
|
* @return
|
* @author Ryan
|
* @description 获取入库组拖信息
|
*/
|
@Override
|
public R getPakinInStock(String barcode) {
|
WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, barcode));
|
if (Objects.isNull(waitPakin)) {
|
throw new CoolException("组拖单据不存在！！");
|
}
|
List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, waitPakin.getId()));
|
if (pakinItems.isEmpty()) {
|
return R.ok(new ArrayList<>());
|
}
|
return R.ok(pakinItems);
|
}
|
|
/**
|
* @return
|
* @author Ryan
|
* @description 获取库口站点信息
|
*/
|
@Override
|
public R getDeviceSites() {
|
List<DeviceSite> sites = deviceSiteMapper.selectList(new LambdaQueryWrapper<DeviceSite>()
|
.select(DeviceSite::getId, DeviceSite::getSite, DeviceSite::getName)
|
.eq(DeviceSite::getStatus, 1)
|
.groupBy(DeviceSite::getSite, DeviceSite::getId, DeviceSite::getName));
|
return R.ok(sites);
|
}
|
|
/**
|
* @return
|
* @author Ryan
|
* @description 获取推荐库位
|
*/
|
@Override
|
public R getRecommondLocs() {
|
return R.ok(locService.list(new LambdaQueryWrapper<Loc>().last("limit 10")));
|
}
|
|
/**
|
* @param map
|
* @param loginUserId
|
* @return
|
* @author Ryan
|
* @description 生成任务列表
|
*/
|
@Override
|
public synchronized R generateTask(Map<String, Object> map, Long loginUserId) {
|
String barcode = map.get("barcode").toString();
|
List<WaitPakin> waitPakins = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, barcode));
|
if (waitPakins.isEmpty()) {
|
throw new CoolException("单据不存在 ！！");
|
}
|
GenerateTaskParams taskParams = new GenerateTaskParams();
|
taskParams.setWaitPakins(waitPakins)
|
.setSiteId(Long.parseLong(map.get("site").toString()))
|
.setLocCode(map.get("locCode").toString());
|
return R.ok(taskService.generateTasks(taskParams, loginUserId));
|
|
}
|
|
/**
|
* 获取ReceiptDetlsDtos
|
*/
|
private R getAsnOrderItem(List<WkOrderItem> items) {
|
List<ReceiptDetlsDto> detlsDtos = new ArrayList<>();
|
items.forEach(asnOrderItem -> {
|
ReceiptDetlsDto detlsDto = new ReceiptDetlsDto();
|
|
detlsDto.setAsnCode(asnOrderItem.getOrderCode())
|
.setId(asnOrderItem.getId())
|
.setMaktx(asnOrderItem.getMaktx())
|
.setFieldsIndex(asnOrderItem.getFieldsIndex())
|
.setBarcode(asnOrderItem.getTrackCode())
|
.setQty(asnOrderItem.getQty())
|
.setStockUnit(asnOrderItem.getStockUnit())
|
.setPurUnit(asnOrderItem.getPurUnit())
|
.setPoCode(asnOrderItem.getPoCode())
|
.setAnfme(asnOrderItem.getAnfme())
|
.setPurQty(asnOrderItem.getPurQty())
|
.setSplrBatch(asnOrderItem.getSplrBatch())
|
.setExtendFields(asnOrderItem.getExtendFields())
|
.setMatnr(asnOrderItem.getMatnrCode())
|
.setInspect(asnOrderItem.getIsptResult$()) //质检结果
|
.setPlatItemId(asnOrderItem.getPlatItemId());
|
|
Matnr matnr = matnrMapper.selectById(asnOrderItem.getMatnrId());
|
if (Objects.isNull(matnr)) {
|
throw new CoolException("数据错误：当前物料不存在！！");
|
}
|
//SET 物料最大存放数量
|
detlsDto.setMaxQty(matnr.getMaxQty())
|
.setMatnrId(matnr.getId());
|
// QlyInspect inspect = qlyInspectMapper.selectOne(new LambdaQueryWrapper<QlyInspect>()
|
// .eq(QlyInspect::getAsnId, asnOrderItem.getAsnId()));
|
// if (!Objects.isNull(inspect)) {
|
// //set 质检结果
|
// detlsDto.setInspect(inspect.getStatus$());
|
// }
|
//获取当前库存信息
|
LocItem stockItem = locItemService.getOne(new LambdaQueryWrapper<LocItem>()
|
// .eq(LocItem::getOrderItemId, asnOrderItem.getId())
|
.eq(LocItem::getFieldsIndex, asnOrderItem.getFieldsIndex())
|
.eq(LocItem::getBatch, asnOrderItem.getSplrBatch())
|
.eq(LocItem::getMatnrId, asnOrderItem.getMatnrId()));
|
//SET 当前库存数量
|
if (Objects.isNull(stockItem)) {
|
detlsDto.setStockQty(0.0);
|
} else {
|
Double anfme = Math.round((stockItem.getAnfme() + stockItem.getWorkQty()) * 10000) / 10000.0;
|
detlsDto.setStockQty(anfme);
|
}
|
|
if (!Objects.isNull(asnOrderItem.getPoDetlId())) {
|
//获取采购单明细信息
|
PurchaseItem purchaseItem = purchaseItemMapper.selectOne(new LambdaQueryWrapper<PurchaseItem>().eq(PurchaseItem::getId, asnOrderItem.getPoDetlId()));
|
if (Objects.isNull(purchaseItem)) {
|
//SET 平台行号
|
detlsDto.setPlatformId(purchaseItem.getPlatItemId());
|
}
|
}
|
detlsDtos.add(detlsDto);
|
});
|
|
return R.ok(detlsDtos);
|
}
|
|
|
}
|
