组拖流程修改

skyouc

2025-04-10 950c7cd4958e759b1eeece3e13028a5562cec0e7

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/MobileServiceImpl.java

@@ -1,33 +1,46 @@
package com.vincent.rsf.server.api.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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.params.OtherReceiptParams;
import com.vincent.rsf.server.api.controller.params.ReceiptParams;
import com.vincent.rsf.server.api.entity.dto.ReceiptDetlsDto;
import com.vincent.rsf.server.api.controller.params.*;
import com.vincent.rsf.server.api.entity.dto.*;
import com.vincent.rsf.server.api.entity.enums.OrderType;
import com.vincent.rsf.server.api.entity.enums.OrderWorkType;
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.CommonUtil;
import com.vincent.rsf.server.common.utils.FieldsUtils;
import com.vincent.rsf.server.common.utils.JSONUtil;
import com.vincent.rsf.server.common.utils.JwtUtil;
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.enums.AsnExceStatus;
import com.vincent.rsf.server.manager.enums.PakinIOStatus;
import com.vincent.rsf.server.manager.mapper.*;
import com.vincent.rsf.server.manager.service.WarehouseAreasItemService;
import com.vincent.rsf.server.manager.service.WarehouseAreasService;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.system.constant.CodeRes;
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.Tenant;
import com.vincent.rsf.server.system.entity.User;
import com.vincent.rsf.server.system.entity.UserLogin;
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.mapper.UserMapper;
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.ExtendFieldsUtils;
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
import org.apache.tika.utils.StringUtils;
import net.sf.jsqlparser.statement.select.Wait;
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;
@@ -35,7 +48,9 @@

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author Ryan
@@ -54,7 +69,7 @@
    @Autowired
    private TenantMapper tenantService;
    @Autowired
    private UserMapper userService;
    private UserService userService;
    @Autowired
    private UserLoginService userLoginService;
    @Autowired
@@ -63,17 +78,53 @@
    private WarehouseAreasService warehouseAreasService;
    @Resource
    private AsnOrderItemMapper asnOrderItemMapper;
    @Resource
    private AsnOrderMapper asnOrderMapper;
    @Autowired
    private AsnOrderService asnOrderMapper;
    @Resource
    private MatnrMapper matnrMapper;
    @Resource
    private QlyInspectMapper qlyInspectMapper;
    @Autowired
    private QlyIsptItemService qlyIsptItemService;
    @Resource
    private StockItemMapper stockItemMapper;
    @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;

    /**
     * @author Ryan
@@ -99,7 +150,7 @@
        if (user.getStatus() != 1) {
            return R.parse(CodeRes.USER_10002);
        }
        if (!user.getPassword().equals(param.getPassword())) {
        if (!userService.comparePassword(user.getPassword(), param.getPassword())) {
            return R.parse(CodeRes.USER_10003);
        }

@@ -119,10 +170,10 @@
     */
    @Override
    public R getOrderByCode(String barcode) {
        if (StringUtils.isEmpty(barcode)) {
        if (StringUtils.isBlank(barcode)) {
            return R.error("标签码不能为空！！");
        }
        AsnOrderItem asnOrderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getBarcode, barcode));
        List<AsnOrderItem> asnOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getTrackCode, barcode));
        if (Objects.isNull(asnOrderItem)) {
            throw new CoolException("单据明细不存在！！");
        }
@@ -139,47 +190,137 @@
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R receiptToWarehouse(ReceiptParams params) {
        if (params.getReceipts().isEmpty()) {
    public R receiptToWarehouse(Map<String, Object> params) {
        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(params.getWhAreaId())) {
        if (Objects.isNull(receiptParam.getWhAreaId())) {
            throw new CoolException("库区标识不能为空！！");
        }
        WarehouseAreasItem areasItem = warehouseAreasItemService.getOne(new LambdaQueryWrapper<WarehouseAreasItem>().eq(WarehouseAreasItem::getAreaId, params.getWhAreaId()));
        List<ReceiptDetlsDto> receipts = params.getReceipts();
        List<WarehouseAreasItem> allOrders =   new ArrayList<>();
        receipts.forEach(dto -> {

        WarehouseAreas areasItem = warehouseAreasService.getOne(new LambdaQueryWrapper<WarehouseAreas>()
                .eq(WarehouseAreas::getId, receiptParam.getWhAreaId()));
        if (Objects.isNull(areasItem)) {
            throw new CoolException("数据错误：当前库区不存在！！");
        }

        List<ReceiptDetlsDto> receipts = receiptParam.getReceipts();
        List<WarehouseAreasItem> allOrders = new ArrayList<>();

        Double receiptQty = receipts.stream().mapToDouble(ReceiptDetlsDto::getReceiptQty).sum();

        String asnCode = receipts.stream().findFirst().get().getAsnCode();

        AsnOrder asnOrder = asnOrderMapper.getOne(new LambdaQueryWrapper<AsnOrder>()
                .eq(AsnOrder::getCode, asnCode));
        if (Objects.isNull(asnOrder)) {
            throw new CoolException("数据错误：主单不存在！！");
        }
        //TODO /**收货数量累加，1. 会出超收情况 2. 会有收货不足情况*/
        Double rcptedQty = asnOrder.getQty() + receiptQty;
        asnOrder.setQty(rcptedQty).setExceStatus(Short.parseShort(AsnExceStatus.ASN_EXCE_STATUS_EXCE_ING.val));

        if (!asnOrderMapper.updateById(asnOrder)) {
            throw new CoolException("已收货数量修改失败！！");
        }
        List<Map<String, Object>> receipts1 = (List<Map<String, Object>>) params.get("receipts");
        for (Map<String, Object> rcpt : receipts1) {
            if (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("数据错误：当前物料不存在！！");
            }
            WarehouseAreasItem item = new WarehouseAreasItem();
            item.setBarcode(dto.getBarcode())
                    .setAreaName(areasItem.getAreaName())
                    .setAreaId(areasItem.getAreaId())
            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::getMatnrId, dto.getMatnrId()));
            if (Objects.isNull(orderItem)) {
                throw new CoolException("通知单明细不存在！！");
            }
            if (Objects.isNull(dto.getReceiptQty()) || Double.compare(dto.getReceiptQty(), 0.0) == 0) {
                throw new CoolException("物料:" + dto.getMaktx() +  "收货数量不能为零！！");
            }
            Double itemRcptQty = dto.getReceiptQty() + orderItem.getQty();
            orderItem.setQty(itemRcptQty)
                    .setSplrBatch(dto.getSplrBatch())
                    .setStockUnit(dto.getStockUnit())
                    .setBatch(SerialRuleUtils.generateRuleCode("sys_receipt_batch", dto))
                    .setAnfme(dto.getReceiptQty())
                    .setSplrBtch(dto.getSplrBatch())
                    .setProdTime(dto.getProdTime());

            if (!Objects.isNull(rcpt)) {
                try {
                    if (Objects.isNull(rcpt.get("fieldsindex")) || StringUtils.isBlank(rcpt.get("fieldsindex").toString())) {
                        //获取16位uuid
                        String uuid16 = CommonUtil.randomUUID16();
                        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("通知单明细数量修改失败！！");
            }

            WarehouseAreasItem item = new WarehouseAreasItem();
//            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//            String format = null;
//            if (Objects.isNull(dto.getProdTime())) {
//                 format = dateFormat.format(dto.getProdTime());
//            }
            item.setTrackCode(dto.getBarcode())
                    .setAreaName(areasItem.getName())
                    .setAreaId(areasItem.getId())
                    .setAsnItemId(orderItem.getId())
                    .setAsnCode(asnOrder.getCode())
                    .setAsnId(asnOrder.getId())
                    .setProdTime(dto.getProdTime())
                    .setWeight(dto.getWeigth())
                    .setStockUnit(dto.getStockUnit())
                    .setBatch(SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_RECEIPT_BATCH, dto))
                    .setAnfme(itemRcptQty)
                    .setSplrBatch(dto.getSplrBatch())
                    .setMatnrCode(matnr.getCode())
                    .setMatnrId(matnr.getId())
                    .setMatnrName(matnr.getName())
                    .setMaktx(matnr.getName())
                    //库存单位为最小单位
                    .setUnit(dto.getStockUnit())
                    .setStockUnit(dto.getStockUnit())
                    .setWeight(matnr.getWeight())
                    .setFieldsIndex(orderItem.getFieldsIndex())
                    .setShipperId(matnr.getShipperId());
                    //TODO 供应商标识未设置，标识由PO单供应商编码转换
            //TODO 供应商标识未设置，标识由PO单供应商编码转换

            allOrders.add(item);
        });
        }

        if (!warehouseAreasItemService.saveBatch(allOrders)) {
            throw new CoolException("收货失败！！");
        }

        return R.ok("操作成功");
//        //获取采购数量
//        double purQty = receipts.stream().mapToDouble(ReceiptDetlsDto::getPurQty).sum();
//
//        BigDecimal subtract = BigDecimal.valueOf(receiptQty).subtract(BigDecimal.valueOf(purQty));
//        //判断已收货数量是否小于等于采购数量
//        if (subtract.compareTo(new BigDecimal("0.0")) <= 0) {
//            asnOrder.setRleStatus(Short.valueOf("1"));
//            //日志表操作
//            operateOrderLogs(asnOrder);
//        }
        return R.ok(asnOrder);
    }

    /**
@@ -193,13 +334,9 @@
        if (Objects.isNull(params.getAsnCode())) {
            throw new CoolException("通知单不能为空！！");
        }
        if (Objects.isNull(params.getBarcode())) {
            throw new CoolException("物料编码不能为空！！");
        }

        AsnOrderItem asnOrderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<AsnOrderItem>()
        List<AsnOrderItem> asnOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnCode, params.getAsnCode())
                .eq(AsnOrderItem::getBarcode, params.getBarcode()));
                .eq(!Objects.isNull(params.getTrackCode()) ,AsnOrderItem::getTrackCode, params.getTrackCode()));

        if (Objects.isNull(asnOrderItem)) {
            throw new CoolException("单据明细不存在！！");
@@ -216,7 +353,7 @@
     */
    @Override
    public List<AsnOrder> getAllAsnOrders() {
        List<AsnOrder> asnOrders = asnOrderMapper.selectList(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getWkType, OrderWorkType.ORDER_PURCHASE_IN.type));
        List<AsnOrder> asnOrders = asnOrderMapper.list(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getWkType, OrderWorkType.ORDER_PURCHASE_IN.type));
        return asnOrders;
    }

@@ -233,47 +370,460 @@
    }

    /**
     * 获取ReceiptDetlsDto
     * @author Ryan
     * @description 获取所有启用动态字段
     * @param
     * @return
     * @time 2025/3/12 09:23
     */
    private R getAsnOrderItem(AsnOrderItem asnOrderItem) {
        ReceiptDetlsDto detlsDto = new ReceiptDetlsDto();
    @Override
    public List<Fields> getDynamicFields() {
        return fieldsMapper.selectList(new LambdaQueryWrapper<Fields>().eq(Fields::getFlagEnable, 1).eq(Fields::getStatus, 1));
    }

        detlsDto.setAsnCode(asnOrderItem.getAsnCode())
                .setMatnk(asnOrderItem.getMatnk())
                .setBarcode(asnOrderItem.getBarcode())
                .setPoCode(asnOrderItem.getPoCode())
                .setPurQty(asnOrderItem.getAnfme())
                .setSplrBatch(asnOrderItem.getSplrBatch());
    /**
     * @author Ryan
     * @description 获取组盘明细
     * @param
     * @return
     * @time 2025/4/7 16:58
     */
    @Override
    public R getDeltByCode(String code) {
        //TODO 后续需根据策略配置，获取组拖数据。如：混装，按批次混装等
        LambdaQueryWrapper<WarehouseAreasItem> queryWrapper = new QueryWrapper<WarehouseAreasItem>()
                .select("SUM(anfme) as anfme, track_code, asn_code, id, splr_batch, ispt_result, plat_item_id, batch, qty, work_qty, matnr_code, matnr_id, maktx").lambda()
                .eq(WarehouseAreasItem::getTrackCode, code)
                .groupBy(WarehouseAreasItem::getSplrBatch, WarehouseAreasItem::getAsnId, WarehouseAreasItem::getAreaId, WarehouseAreasItem::getMatnrId);
        return R.ok(warehouseAreasItemService.getOne(queryWrapper));
    }

        Matnr matnr = matnrMapper.selectById(asnOrderItem.getMatnrId());
        if (Objects.isNull(matnr)) {
            throw new CoolException("数据错误：当前物料不存在！！");
    /**
     * @author Ryan
     * @description PDA组拖
     * @param
     * @return
     * @time 2025/3/29 14:26
     */
    @Override
    public WaitPakin mergeItems(WaitPakinParam waitPakin) {
        return waitPakinService.mergeItems(waitPakin);
    }

    /**
     * @author Ryan
     * @description 解绑
     * @param param
     * @return
     */
    @Override
    public WaitPakin unBind(WaitPakinParam param) {
        return waitPakinService.unBind(param);
    }

    /**
     * 报检功能
     * @param code
     * @param loginUserId
     * @return
     */
    @Override
    public R inspect(String code, Long loginUserId) {
        AsnOrder asnOrders = asnOrderMapper.getOne(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getCode, code));
        if (Objects.isNull(asnOrders)) {
            throw new CoolException("单据不存在！！");
        }
        //SET 物料最大存放数量
        detlsDto.setMaxQty(matnr.getMaxQty())
                .setMatnrId(matnr.getId())
                .setStockUnit(matnr.getStockUnit());
        QlyInspect inspect = qlyInspectMapper.selectOne(new LambdaQueryWrapper<QlyInspect>()
                .eq(QlyInspect::getAsnItemId, asnOrderItem.getId()).eq(QlyInspect::getPoItemId, asnOrderItem.getPoDetlId()));
        //set 质检结果
        detlsDto.setInspect(inspect.getStatus$());
        //获取当前库存信息
        StockItem stockItem = stockItemMapper.selectOne(new LambdaQueryWrapper<StockItem>()
                .eq(StockItem::getAsnItemId, asnOrderItem.getId())
                .eq(StockItem::getMatnrId, asnOrderItem.getMatnrId()));
        //SET 当前库存数量
        if (Objects.isNull(stockItem)) {
            detlsDto.setStockQty(0.0);
        InspectDetlDto detlDto = new InspectDetlDto();
        detlDto.setCode(asnOrders.getCode()).setId(asnOrders.getId()).setPoCode(asnOrders.getPoCode());
        List<AsnOrderItem> orderItems = asnOrderItemMapper.selectList(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnCode, code));
        if (orderItems.isEmpty()) {
            detlDto.setItems(new ArrayList<>());
        } else {
            detlsDto.setStockQty(stockItem.getQty() + stockItem.getWorkQty());
            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);
        }

        //获取采购单明细信息
        PurchaseItem purchaseItem = purchaseItemMapper.selectOne(new LambdaQueryWrapper<PurchaseItem>().eq(PurchaseItem::getId, asnOrderItem.getPoDetlId()));
        //SET 平台行号
        detlsDto.setPlatformId(purchaseItem.getPlatItemId());
        List<IsptHistories> histories = isptHistoriesMapper.selectList(new LambdaQueryWrapper<IsptHistories>().eq(IsptHistories::getAsnId, asnOrders.getId()));
        detlDto.setHistories(histories);
        return R.ok(detlDto);
    }

        return R.ok(detlsDto);
    /**
     * @author Ryan
     * @description 提交报检
     * @param
     * @return
     * @time 2025/4/1 16:47
     */
    @Override
    public R confirmIspt(String id) {
        if (org.apache.commons.lang3.StringUtils.isBlank(id)) {
            throw new CoolException("参数不能为空！！");
        }
        AsnOrder asnOrder = asnOrderMapper.getById(id);
        if (Objects.isNull(asnOrder)) {
            throw new CoolException("单据不存在！！");
        }
        List<AsnOrder> orders = new ArrayList<>();
        orders.add(asnOrder);
        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("质检单不能为空");
        }
        QlyInspect inspect = qlyInspectMapper.selectOne(new LambdaQueryWrapper<QlyInspect>().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
     * @return
     */
    @Override
    public R checkUpdate(List<QlyIsptItem> params) {
        if (Objects.isNull(params) || params.isEmpty()) {
            throw new CoolException("参数不能为空！！");
        }
        IsptItemsParams itemsParams = new IsptItemsParams();
        itemsParams.setIsptItem(params).setType("0");
        if (qlyIsptItemService.batchUpdate(itemsParams)) {
            return R.ok();
        } else {
            return R.error("保存失败！！");
        }
    }

    /**
    * @author Ryan
    * @description 人工上架
    * @param
    * @return
    * @time 2025/4/2 16:33
    */
    @Override
    public R operateToStock(OpStockParams params) {
        if (org.apache.commons.lang3.StringUtils.isBlank(params.getBarcode())) {
            throw new CoolException("拖盘码不能为空！！");
        }
        if (StringUtils.isBlank(params.getAsnCode())) {
            throw new CoolException("单据不能为空！！");
        }
        if (StringUtils.isBlank(params.getMatnrCode())) {
            throw new CoolException("物料编码不能为空！！");
        }
        AsnOrder asnOrders = asnOrderMapper.getOne(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getCode, params.getAsnCode()));
        if (Objects.isNull(asnOrders)) {
            throw new CoolException("单据不存在！！");
        }
        List<Loc> locs = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getBarcode, params.getBarcode()));
        if (!locs.isEmpty()) {
            throw new CoolException("拖盘已使用");
        }
        List<WaitPakin> waitPakins = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, params.getBarcode()));
        if (!waitPakins.isEmpty()) {
            throw new CoolException("拖盘已使用!!");
        }
        AsnOrderItem orderItems = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnId, asnOrders.getId())
                .eq(AsnOrderItem::getMatnrCode, params.getMatnrCode()));
        if (Objects.isNull(orderItems)) {
            return R.ok(null);
        }
        orderItems.setBarcode(params.getBarcode());

        return R.ok(orderItems);
    }

    /**
     * 人工上架入库
     *
     * @param params
     * @param loginUserId
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public 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().getAsnId();
        /**获取平库订单*/
        AsnOrder order = asnOrderMapper.getOne(new LambdaQueryWrapper<AsnOrder>()
                .eq(AsnOrder::getId, OrderId)
                .eq(AsnOrder::getType, OrderType.ORDER_PLAT_IN.type));
        if (Objects.isNull(order)) {
            throw new CoolException("单据不存在！！");
        }
        Stock stock = new Stock();
        stock.setAsnId(OrderId).setAsnCode(order.getCode());
        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 + "，编码规则不存在！！");
        }
        if (!stockService.save(stock)) {
            throw new CoolException("库存保存失败！！");
        }
        Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, params.getLocCode()));
        if (Objects.isNull(loc)) {
            throw new CoolException("库位不存在！！");
        }
        List<StockItem> stockItems = new ArrayList<>();
        params.getItemList().forEach(orderItem -> {
            StockItem stockItem = new StockItem();
            BeanUtils.copyProperties(orderItem, stockItem);
            stockItem.setAsnItemId(orderItem.getId())
                    .setBarcode(orderItem.getBarcode())
                    .setLocId(loc.getId())
                    .setUpdateBy(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);
    }

    /**
     * @Author Ryan
     * @param code
     * @desc  任务上架
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public 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);
    }

    /**
     * @author Ryan
     * @description 通过容器获取组拖物料
     * @param
     * @return
     * @time 2025/4/9 16:57
     */
    @Override
    public R getItemByContainer(Map<String, Object> params) {
        //获取组拖未生成任务的组拖档
        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(WaitPakin::getBarcode, params.get("barcode").toString())
                .in(WaitPakin::getIoStatus, asList));
        if (Objects.isNull(waitPakin)) {
            return R.ok(new ArrayList<>());
        }
        List<WaitPakinItem> pakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>()
                .eq(WaitPakinItem::getPakinId, waitPakin.getId()));
        if (pakinItems.isEmpty()) {
            return R.ok(new ArrayList<>());
        }
        List<String> list = pakinItems.stream().map(WaitPakinItem::getTrackCode).collect(Collectors.toList());
        LambdaQueryWrapper<WarehouseAreasItem> queryWrapper = new QueryWrapper<WarehouseAreasItem>()
                .select("SUM(anfme) as anfme, track_code, asn_code, id, splr_batch, ispt_result, plat_item_id, batch, qty, work_qty, matnr_code, matnr_id, maktx")
                .lambda()
                .in(WarehouseAreasItem::getTrackCode, list)
                .groupBy(WarehouseAreasItem::getSplrBatch,
                        WarehouseAreasItem::getTrackCode);
        List<WarehouseAreasItem> warehouseAreasItems = warehouseAreasItemService.list(queryWrapper);
        for (int i = 0; i < warehouseAreasItems.size(); i++) {
            for (WaitPakinItem pakinItem : pakinItems) {
                if (warehouseAreasItems.get(i).getTrackCode().equals(pakinItem.getTrackCode())) {
                    warehouseAreasItems.get(i).setAnfme(pakinItem.getAnfme());
                }
            }
        }
        return R.ok(warehouseAreasItems);
    }

    /**
     * 获取ReceiptDetlsDtos
     */
    private R getAsnOrderItem(List<AsnOrderItem> items) {
        List<ReceiptDetlsDto> detlsDtos = new ArrayList<>();
        items.forEach(asnOrderItem -> {
            ReceiptDetlsDto detlsDto = new ReceiptDetlsDto();

            detlsDto.setAsnCode(asnOrderItem.getAsnCode())
                    .setMaktx(asnOrderItem.getMaktx())
                    .setFieldsIndex(asnOrderItem.getFieldsIndex())
                    .setBarcode(asnOrderItem.getTrackCode())
                    .setQty(asnOrderItem.getQty())
                    .setPoCode(asnOrderItem.getPoCode())
                    .setAnfme(asnOrderItem.getAnfme())
                    .setPurQty(asnOrderItem.getPurQty())
                    .setSplrBatch(asnOrderItem.getSplrBatch());

            Matnr matnr = matnrMapper.selectById(asnOrderItem.getMatnrId());
            if (Objects.isNull(matnr)) {
                throw new CoolException("数据错误：当前物料不存在！！");
            }
            //SET 物料最大存放数量
            detlsDto.setMaxQty(matnr.getMaxQty())
                    .setMatnrId(matnr.getId())
                    .setStockUnit(matnr.getStockUnit());
            QlyInspect inspect = qlyInspectMapper.selectOne(new LambdaQueryWrapper<QlyInspect>()
                    .eq(QlyInspect::getAsnId, asnOrderItem.getAsnId()));
            if (!Objects.isNull(inspect)) {
                //set 质检结果
                detlsDto.setInspect(inspect.getStatus$());
            }
            //获取当前库存信息
            StockItem stockItem = stockItemMapper.selectOne(new LambdaQueryWrapper<StockItem>()
                    .eq(StockItem::getAsnItemId, asnOrderItem.getId())
                    .eq(StockItem::getMatnrId, asnOrderItem.getMatnrId()));
            //SET 当前库存数量
            if (Objects.isNull(stockItem)) {
                detlsDto.setStockQty(0.0);
            } else {
                detlsDto.setStockQty(stockItem.getQty() + stockItem.getWorkQty());
            }

            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);
    }