no message

skyouc

8 小时以前 45b95bf88ab48e4b4db7ff9205e9afa2b83e8737

 src/main/java/com/zy/asrs/service/impl/MobileServiceImpl.java

@@ -6,6 +6,7 @@
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.*;
import com.core.exception.CoolException;
import com.zy.api.enums.MatLocType;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.*;
@@ -21,25 +22,27 @@
import com.zy.common.constant.HIKApiConstant;
import com.zy.common.constant.MesConstant;
import com.zy.common.entity.Parameter;
import com.zy.common.model.DetlDto;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.MesCombParam;
import com.zy.common.model.StartupDto;
import com.zy.common.model.*;
import com.zy.common.model.enums.WorkNoType;
import com.zy.common.properties.SlaveProperties;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
@@ -131,6 +134,10 @@
    private StationRelaService stationRelaService;
    @Autowired
    private BasStationDetlService basStationDetlService;
    @Autowired
    private WorkService workService;
    @Autowired
    private ConfigService configService;

    @Override
    @Transactional
@@ -171,7 +178,9 @@
        wrkMastService.insert(wrkMast);

        for (OrderDetl orderDetl : param.getCombMats()) {
            Mat mat = matService.selectOne(new EntityWrapper<Mat>().eq("matnr", orderDetl.getMatnr()));
            Mat mat = matService.selectOne(new EntityWrapper<Mat>()
                    .eq("supp_code", orderDetl.getStandby1())
                    .eq("matnr", orderDetl.getMatnr()));
            if (mat == null) {
                throw new CoolException("保存工作档失败，物料信息不存在：" + orderDetl.getMatnr());
            }
@@ -370,6 +379,7 @@
        for (CombParam.CombMat combMat : combParam.getCombMats()) {
            List<LocDetl> locDetlList = locDetlService.selectList(new EntityWrapper<LocDetl>()
                    .eq("loc_no", combParam.getLocNo())
                    .eq(!Cools.isEmpty(combMat.getStandby1()), "supp_code", combMat.getStandby1())
                    .eq("matnr", combMat.getMatnr()));
            if (locDetlList.isEmpty()) {
                return R.error("未查询到库存数据");
@@ -444,7 +454,9 @@
                wrkMast.setModiUser(userId);
                wrkMastService.insert(wrkMast);

                Mat mat = matService.selectOne(new EntityWrapper<Mat>().eq("matnr", combMat.getMatnr()));
                Mat mat = matService.selectOne(new EntityWrapper<Mat>()
                        .eq(!Cools.isEmpty(combMat.getStandby1()), "supp_code", combMat.getStandby1())
                        .eq("matnr", combMat.getMatnr()));
                if (mat == null) {
                    throw new CoolException("保存工作档失败，物料信息不存在：" + combMat.getMatnr());
                }
@@ -589,12 +601,10 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void comb(CombParam param, Long userId) {
        if (Cools.isEmpty(param.getBarcode(), param.getCombMats())) {
        if (Objects.isNull(param.getBarcode())) {
            throw new CoolException(BaseRes.PARAM);
        }
        if (param.getCombMats().size() < 1) {
            throw new CoolException("请提取一个商品，或者刷新重新组托！");
        }

        // 判断是否有相同条码的数据
        if (waitPakinService.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet", param.getBarcode())
                .eq("io_status", "N")) > 0) {
@@ -626,51 +636,69 @@
        Date now = new Date();
        // 无单组托
        if (Cools.isEmpty(param.getOrderNo())) {
            // 生成入库通知档
            List<DetlDto> detlDtos = new ArrayList<>();
            param.getCombMats().forEach(elem -> {
                DetlDto detlDto = new DetlDto(elem.getMatnr(), elem.getBatch(), elem.getBrand(), elem.getStandby1(),
                        elem.getStandby2(), elem.getStandby3(),
                        elem.getBoxType1(), elem.getBoxType2(), elem.getBoxType3(), elem.getAnfme(),
                        elem.getThreeCode());
                if (DetlDto.has(detlDtos, detlDto)) {
                    DetlDto one = DetlDto.findDto(detlDtos, detlDto);
                    assert one != null;
                    one.setAnfme(one.getAnfme() + detlDto.getAnfme());
                } else {
                    detlDtos.add(detlDto);
                }
            });

            for (DetlDto detlDto : detlDtos) {
                Mat mat = matService.selectByMatnr(detlDto.getMatnr());
                if (Cools.isEmpty(mat)) {
                    throw new CoolException(detlDto.getMatnr() + "商品档案不存在");
                }
                if (mat.getUpQty().compareTo(detlDto.getAnfme()) < 0) {
                    throw new CoolException("物料：" + detlDto.getMatnr() + "单次最大组托上限为：" + mat.getUpQty());
                }
            //空板组托
            if (!Cools.isEmpty(param.getPakinType()) && param.getPakinType().equals("3")) {
                WaitPakin waitPakin = new WaitPakin();
                BeanUtils.copyProperties(mat, waitPakin);
                waitPakin.setBatch(detlDto.getBatch());
                waitPakin.setZpallet(param.getBarcode());
                waitPakin.setIoStatus("N");
                waitPakin.setAnfme(detlDto.getAnfme());
                waitPakin.setThreeCode(detlDto.getThreeCode());
                waitPakin.setStatus("Y");
                waitPakin.setSuppCode(detlDto.getStandby1());
                waitPakin.setStandby1(detlDto.getStandby1());
                waitPakin.setStandby2(detlDto.getStandby2());
                waitPakin.setStandby3(detlDto.getStandby3());
                waitPakin.setBoxType1(detlDto.getBoxType1());
                waitPakin.setBoxType2(detlDto.getBoxType2());
                waitPakin.setBoxType3(detlDto.getBoxType3());
                waitPakin.setAppeUser(userId);
                waitPakin.setAppeTime(now);
                waitPakin.setModiUser(userId);
                waitPakin.setModiTime(now);
                if (!waitPakinService.insert(waitPakin)) {
                    throw new CoolException("保存入库通知档失败");
                }
            } else {
                if (param.getCombMats().size() < 1) {
                    throw new CoolException("请提取一个商品，或者刷新重新组托！");
                }
                // 生成入库通知档
                List<DetlDto> detlDtos = new ArrayList<>();
                param.getCombMats().forEach(elem -> {
                    DetlDto detlDto = new DetlDto(elem.getMatnr(), elem.getBatch(), elem.getBrand(), elem.getStandby1(),
                            elem.getStandby2(), elem.getStandby3(),
                            elem.getBoxType1(), elem.getBoxType2(), elem.getBoxType3(), elem.getAnfme(),
                            elem.getThreeCode());
                    if (DetlDto.has(detlDtos, detlDto)) {
                        DetlDto one = DetlDto.findDto(detlDtos, detlDto);
                        assert one != null;
                        one.setAnfme(one.getAnfme() + detlDto.getAnfme());
                    } else {
                        detlDtos.add(detlDto);
                    }
                });

                for (DetlDto detlDto : detlDtos) {
                    Mat mat = matService.selectByMatnr(detlDto.getMatnr());
                    if (Cools.isEmpty(mat)) {
                        throw new CoolException(detlDto.getMatnr() + "商品档案不存在");
                    }
                    if (mat.getUpQty().compareTo(detlDto.getAnfme()) < 0) {
                        throw new CoolException("物料：" + detlDto.getMatnr() + "单次最大组托上限为：" + mat.getUpQty());
                    }
                    WaitPakin waitPakin = new WaitPakin();
                    BeanUtils.copyProperties(mat, waitPakin);
                    waitPakin.setBatch(detlDto.getBatch());
                    waitPakin.setZpallet(param.getBarcode());
                    waitPakin.setIoStatus("N");
                    waitPakin.setAnfme(detlDto.getAnfme());
                    waitPakin.setThreeCode(detlDto.getThreeCode());
                    waitPakin.setStatus("Y");
                    waitPakin.setSuppCode(detlDto.getStandby1());
                    waitPakin.setStandby1(detlDto.getStandby1());
                    waitPakin.setStandby2(detlDto.getStandby2());
                    waitPakin.setStandby3(detlDto.getStandby3());
                    waitPakin.setBoxType1(detlDto.getBoxType1());
                    waitPakin.setBoxType2(detlDto.getBoxType2());
                    waitPakin.setBoxType3(detlDto.getBoxType3());
                    waitPakin.setAppeUser(userId);
                    waitPakin.setAppeTime(now);
                    waitPakin.setModiUser(userId);
                    waitPakin.setModiTime(now);
                    if (!waitPakinService.insert(waitPakin)) {
                        throw new CoolException("保存入库通知档失败");
                    }
                }
            }
            // 关联组托
@@ -690,6 +718,7 @@
                // elem.getBoxType1(), elem.getBoxType2(), elem.getBoxType3());
                OrderDetlPakin detls = orderDetlPakinService.selectOne(new EntityWrapper<OrderDetlPakin>()
                        .eq("order_id", order.getId())
                        .eq("supp_code", elem.getStandby1())
                        .eq("matnr", elem.getMatnr()));
                if (Objects.isNull(elem.getBoxType1())) {
                    throw new CoolException("格层编码不能为空！！");
@@ -720,9 +749,16 @@
                }
            });

            Set<String> matnrs = detlDtos.stream().map(DetlDto::getMatnr).collect(Collectors.toSet());
            List<Mat> mats = matService.selectList(new EntityWrapper<Mat>().in("matnr", matnrs));
            Set<Long> tagIds = mats.stream().map(Mat::getTagId).collect(Collectors.toSet());
            List<Mat> tempMats = new ArrayList<>();
            for (DetlDto detlDto : detlDtos) {
                Mat mat = matService.selectOne(new EntityWrapper<Mat>()
                        .eq("matnr", detlDto.getMatnr())
                        .eq("supp_code", detlDto.getStandby1()));
                tempMats.add(mat);
            }

//            Set<String> matnrs = tempMats.stream().map(Mat::getMatnr).collect(Collectors.toSet());
            Set<Long> tagIds = tempMats.stream().map(Mat::getTagId).collect(Collectors.toSet());
            if (tagIds.size() > 1) {
                throw new CoolException("组托物料类型不一致，只有相同的物料分类才可以组托！！");
            }
@@ -880,9 +916,9 @@
                        // todo 盘点记录、保存调整记录
                        // 修改明细
                        if (!wrkDetlService.updateAnfme(wrkDetl1.getAnfme(), wrkMast.getWrkNo(), wrkDetl.getMatnr(),
                                wrkDetl.getBatch())) {
                                wrkDetl.getSuppCode())) {
                            throw new CoolException(wrkMast.getWrkNo() + "盘点任务，" + wrkDetl.getMatnr() + "商品，"
                                    + wrkDetl.getBatch() + "批号修改数量失败");
                                    + wrkDetl.getSuppCode() + "批号修改数量失败");
                        }
                    }
                    iterator.remove();
@@ -894,7 +930,7 @@
        // 删除明细
        for (WrkDetl wrkDetl : wrkDetls) {
            // todo 盘点记录、保存调整记录
            if (!wrkDetlService.updateAnfme(-1.0D, wrkMast.getWrkNo(), wrkDetl.getMatnr(), wrkDetl.getBatch())) {
            if (!wrkDetlService.updateAnfme(-1.0D, wrkMast.getWrkNo(), wrkDetl.getMatnr(), wrkDetl.getSuppCode())) {
                throw new CoolException("删除" + wrkMast.getWrkNo() + "盘点任务，" + wrkDetl.getMatnr() + "商品，"
                        + wrkDetl.getBatch() + "批号任务明细失败");
            }
@@ -1168,6 +1204,7 @@
                orderDetl.setUpdateBy(userId);
                orderDetl.setUpdateTime(now);
                Wrapper wrapper = new EntityWrapper<OrderDetl>().eq("order_no", orderNo)
                        .eq(!Cools.isEmpty(orderDetl.getStandby1()), "supp_code", orderDetl.getStandby1())
                        .eq("matnr", orderDetl.getMatnr());
                if (!Cools.isEmpty(orderDetl.getBatch())) {
                    wrapper.eq("batch", orderDetl.getBatch());
@@ -1189,15 +1226,15 @@
        // 获取库位
        LocMast locMast = locMastService.selectById(locDetl.getLocNo());
        // 获取路径
        Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                .eq("type_no", ioType)
                .eq("stn_no", staNo.getDevNo())
                .eq("crn_no", locMast.getCrnNo());

        StaDesc staDesc = staDescService.selectOne(wrapper);
        if (Cools.isEmpty(staDesc)) {
            throw new CoolException("出库路径不存在");
        }
//        Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
//                .eq("type_no", ioType)
//                .eq("stn_no", staNo.getDevNo())
//                .eq("crn_no", locMast.getCrnNo());
//
//        StaDesc staDesc = staDescService.selectOne(wrapper);
//        if (Cools.isEmpty(staDesc)) {
//            throw new CoolException("出库路径不存在");
//        }
        // 生成工作号
        int workNo = commonService.getWorkNo(2);
        // 生成工作档
@@ -1208,8 +1245,8 @@
        wrkMast.setIoType(ioType); // 入出库状态
        wrkMast.setIoPri(13D); // 优先级：13
        wrkMast.setCrnNo(locMast.getCrnNo());
        wrkMast.setSourceStaNo(staDesc.getCrnStn() + ""); // 源站
        wrkMast.setStaNo(staDesc.getStnNo() + ""); // 目标站
//        wrkMast.setSourceStaNo(staDesc.getCrnStn() + ""); // 源站
//        wrkMast.setStaNo(staDesc.getStnNo() + ""); // 目标站
        wrkMast.setSourceLocNo(locDetl.getLocNo()); // 源库位
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
@@ -1279,26 +1316,66 @@
        if (Objects.isNull(params.getOrgSite())) {
            throw new CoolException("源站点不能为空！！");
        }
        BasAreas basAreas = basAreasService
                .selectOne(new EntityWrapper<BasAreas>().eq("whs_type_id", LocAreaType.LOC_AREA_TYPE_IN_CACHE.type));
        LocCache locCache = locCacheService.selectOne(new EntityWrapper<LocCache>()
                .eq("area_id", basAreas.getId())
                .eq("frozen", 0)
                .eq("loc_sts", LocStsType.LOC_STS_TYPE_O.type)
                // .eq("loc_no", params.getTarSite())
                .orderAsc(Arrays.asList("loc_no"))
                .last("OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY"));
        if (Objects.isNull(locCache)) {
            throw new CoolException("请检查目标库位是否闲置中！！");
        }
        if (!Objects.isNull(params.getTaskType()) && params.getTaskType().equals("XM1")) {
            String taskType = params.getTaskType();
            generateXAgvTask(params.getOrgSite(), params.getTarSite(), userId, taskType);
        } else {
            String taskType = "M2";
            if (!params.getIsNewIn().isEmpty()) {
                taskType = "M1";
                int cacheCount = locCacheService.selectCount(new EntityWrapper<LocCache>().eq("barcode", params.getBarcode()));
                if (cacheCount > 0) {
                    throw new CoolException("台车已入库，不能勾选新台车！！");
                }
            }

        try {
            generateAgvTask("agv", locCache, params.getOrgSite(), params.getBarcode(), userId);
        } catch (Exception e) {
            throw new CoolException(e.getMessage());
        }
            BasAreas basAreas = basAreasService
                    .selectOne(new EntityWrapper<BasAreas>().eq("whs_type_id", LocAreaType.LOC_AREA_TYPE_IN_CACHE.type));
            LocCache locCache = locCacheService.selectOne(new EntityWrapper<LocCache>()
                    .eq("area_id", basAreas.getId())
                    .eq("frozen", 0)
                    .eq("loc_sts", LocStsType.LOC_STS_TYPE_O.type)
                    .orderAsc(Arrays.asList("loc_no"))
                    .last("OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY"));
            if (Objects.isNull(locCache)) {
                throw new CoolException("请检查目标库位是否闲置中！！");
            }

            try {
                generateAgvTask("agv", locCache, params.getOrgSite(), params.getBarcode(), userId, taskType);
            } catch (Exception e) {
                throw new CoolException(e.getMessage());
            }
        }
        return R.ok();
    }

    @Transactional(rollbackFor = Exception.class)
    public void generateXAgvTask(String orgSite, String tarSite, Long userId, String taskType) {
        // 获取工作号
        int workNo = commonService.getWorkNo(4);
        // 保存工作档
        Task task = new Task();
        task.setWrkNo(workNo)
                .setIoTime(new Date())
                .setWrkSts(201L) // 工作状态：11.生成出库ID
                .setIoType(1) // 入出库状态： 11.库格移载
                .setTaskType("agv")
                .setIoPri(10D)
                .setIsNewIn(taskType)
                .setFullPlt("Y") // 满板：Y
                .setPicking("N") // 拣料
                .setExitMk("N")// 退出
                .setSourceStaNo(orgSite)
                .setStaNo(tarSite)
                .setLinkMis("N")
                .setAppeUser(userId)
                .setAppeTime(new Date())
                .setModiUser(userId)
                .setModiTime(new Date());
        if (!taskService.insert(task)) {
            throw new CoolException("保存工作档失败");
        }
    }

    /**
@@ -1312,18 +1389,12 @@
        if (Objects.isNull(params)) {
            throw new CoolException("参数不能为空！！");
        }
        if (Objects.isNull(params.getOrderNo())) {
            throw new CoolException("单号不能为空！！");
        }
        OrderPakin orderPakin = orderPakinService
                .selectOne(new EntityWrapper<OrderPakin>().eq("order_no", params.getOrderNo()));
        if (Objects.isNull(orderPakin)) {
            throw new CoolException("数据错误：单据不存在！！");
        }

        List<OrderDetlPakin> detlPakins = orderDetlPakinService.selectList(new EntityWrapper<OrderDetlPakin>()
                .eq(!Cools.isEmpty(params.getThreeCode()), "three_code", params.getThreeCode())
                .eq(!Cools.isEmpty(params.getMatnr()), "matnr", params.getMatnr())
                .eq("order_id", orderPakin.getId()));
                        .eq(!Cools.isEmpty(params.getThreeCode()), "three_code", params.getThreeCode())
//                .eq(!Cools.isEmpty(params.getMatnr()), "matnr", params.getMatnr())
//                .eq(!Cools.isEmpty(params.getOrderNo()), "order_no", params.getOrderNo())
        );
        if (Objects.isNull(detlPakins) || detlPakins.isEmpty()) {
            throw new CoolException("数据错误： 单据明细不存在！！");
        }
@@ -1362,7 +1433,8 @@
                    .eq("area_id", basAreas.getId())
                    .eq("loc_no", locCache.getLocNo()));
            if (Objects.isNull(locDetls) || locDetls.isEmpty()) {
                throw new CoolException("库存明细不存在！！");
                continue;
//                throw new CoolException("库存明细不存在！！");
            }

            Set<String> set = locDetls.stream().map(LocDetl::getMatnr).collect(Collectors.toSet());
@@ -1397,9 +1469,19 @@
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R callEmptyCar(AgvCallParams params, Long userId) {

        BasAreas basAreas = basAreasService.selectOne(new EntityWrapper<BasAreas>().eq("name", params.getOrgSite()));

        BasStation station1 = basStationService.selectOne(new EntityWrapper<BasStation>().eq("dev_no", params.getTarSite()));
        if (Objects.isNull(station1) || Objects.isNull(basAreas)) {
            return R.error("目标站点或库区不存在，请联系管理！！");
        }

        List<String> list = Arrays.asList("SSX01", "SSX02", "SSX03", "SSX04", "SSX05", "SSX06", "SSX07", "SSX08", "SSX09", "SSX10");
        if (Long.parseLong(station1.getAreaId()) != basAreas.getId() && !list.contains(params.getTarSite())) {
            return R.error("起始区和目标站点不在同一个库区，请重新操作！！");
        }

        List<LocCache> locCaches = locCacheService.selectList(new EntityWrapper<LocCache>()
                .eq("loc_sts", LocStsType.LOC_STS_TYPE_D.type)
@@ -1416,20 +1498,6 @@
        }
        generateCacheOutTask(station, locCaches.get(0), userId);

        // HIKApiDTO hikApiDTO =new HIKApiDTO()
        // .setOrg(locCaches.get(0).getLocNo())
        // .setOrgType("05")
        // .setTar(params.getTarSite())
        // .setTarType("05")
        // .setTaskType("GT5")
        // .setPriority("1")
        // .setCtnrType("2")
        // ;
        // HIKResultDTO hikResultDTO = sendAgvTask(hikApiDTO,
        // HIKApiConstant.AGV_CALL_IN_PATH);
        // if (!hikResultDTO.isSuccess()){
        // return R.error(hikResultDTO.getMessage());
        // }

        return R.ok();
    }
@@ -1442,6 +1510,9 @@
        }

        BasAreas basAreas = basAreasService.selectOne(new EntityWrapper<BasAreas>().eq("name", params.getTarSite()));
        if (Objects.isNull(basAreas)) {
            return R.error("站点不存在，请检查站点是否输入正确！！");
        }

        List<LocCache> locCaches = locCacheService.selectList(new EntityWrapper<LocCache>()
                .in("loc_sts", LocStsType.LOC_STS_TYPE_O.type)
@@ -1463,23 +1534,17 @@

    @Transactional(rollbackFor = Exception.class)
    public void generateSOEOInTask(String type, LocCache loc, String orgSite, String barcode, Long userId) {
        List<BasStationDetl> basStationDetls = basStationDetlService
                .selectList(new EntityWrapper<BasStationDetl>().eq("dev_no", orgSite));
        if (Objects.isNull(basStationDetls) || basStationDetls.isEmpty()) {
            throw new CoolException("站点信息不存在！！");
        }

        List<Task> tasks = taskService.selectList(new EntityWrapper<Task>().eq("barcode", barcode));
        if (!tasks.isEmpty()) {
            throw new CoolException("托盘已在任务执行中..");
        }
        // 获取工作号
        int workNo = commonService.getWorkNo(WorkNoType.PICK.type);
        int workNo = commonService.getWorkNo(4);
        // 保存工作档
        Task task = new Task();
        task.setWrkNo(workNo)
                .setIoTime(new Date())
                .setWrkSts(1L) // 工作状态：11.生成出库ID
                .setWrkSts(201L) // 工作状态：11.生成入库库ID
                .setIoType(1) // 入出库状态： 11.库格移载
                .setTaskType("agv")
                .setIoPri(10D)
@@ -1499,7 +1564,9 @@
            throw new CoolException("保存工作档失败");
        }

        for (BasStationDetl basStationDetl : basStationDetls) {
        List<BasStationDetl> basStationDetls = basStationDetlService
                .selectList(new EntityWrapper<BasStationDetl>().eq("dev_no", orgSite));
        basStationDetls.forEach(basStationDetl -> {
            TaskDetl wrkDetl = new TaskDetl();
            BeanUtils.copyProperties(basStationDetl, wrkDetl);
            wrkDetl.setWrkNo(workNo)
@@ -1521,36 +1588,32 @@
            if (!taskDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作档明细失败");
            }
        }
        });

        // 修改目标库位状态
        if (loc.getLocSts().equals(LocStsType.LOC_STS_TYPE_O.type)) {
            loc.setLocSts(LocStsType.LOC_STS_TYPE_S.type); // S.入库预约
            loc.setModiTime(new Date());
            loc.setModiUser(userId);
            if (!locCacheService.updateById(loc)) {
            if (!locCacheService.update(loc, new EntityWrapper<LocCache>().eq("loc_no", loc.getLocNo()))) {
                throw new CoolException("更新目标库位状态失败");
            }
        } else {
            throw new CoolException("移转失败，目标库位状态：" + loc.getLocSts$());
        }

        // 修改目标站点信息
        // 修改原站点信息
        BasStation station = basStationService.selectOne(new EntityWrapper<BasStation>().eq("dev_no", orgSite));
        if (Objects.isNull(station)) {
            throw new CoolException("站点不存在!!");
        }

        if (station.getLocSts().equals(LocStsType.LOC_STS_TYPE_F.type)) {
            station.setLocSts("R"); // S.入库预约
            station.setBarcode(barcode);
            station.setModiTime(new Date());
            station.setModiUser(userId);
            if (!basStationService.updateById(station)) {
                throw new CoolException("更新目标站点状态失败");
            }
        } else {
            throw new CoolException("移转失败，目标库位状态：" + station.getLocSts());
        station.setLocSts("R"); // S.入库预约
        station.setBarcode(barcode);
        station.setModiTime(new Date());
        station.setModiUser(userId);
        if (!basStationService.updateById(station)) {
            throw new CoolException("更新目标站点状态失败");
        }
    }

@@ -1604,7 +1667,7 @@
    }

    /**
     * 缓存区上架组托
     * 缓存区并板上架组托
     *
     * @param param
     * @param userId
@@ -1617,140 +1680,98 @@
        if (Objects.isNull(param.getBarcode())) {
            throw new CoolException("托盘码不能为空！！");
        }

        if (Objects.isNull(param.getCombMats()) || param.getCombMats().isEmpty()) {
            throw new CoolException("组托明细不能为空！！");
        }
        // 判断是否有相同条码的数据
        if (waitPakinService.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet", param.getBarcode())
                .eq("io_status", "N")) > 0) {
            throw new CoolException(param.getBarcode() + "数据正在进行入库");

        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                .eq("wrk_sts", 14)
                .eq("io_type", 104)
                .eq("barcode", param.getBarcode()));
        if (Objects.isNull(wrkMast)) {
            throw new CoolException("任务档信息不存在,请检查托盘：" + param.getBarcode() + "任务档是否已完成出库 ！！");
        }

        int countLoc = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet", param.getBarcode()));
        int countWrk = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("zpallet", param.getBarcode()));
        if (countWrk > 0 || countLoc > 0) {
            WrkMast wrkDetl = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode", param.getBarcode()));
            if (!wrkDetl.getIoType().equals(TaskIOType.MERGE_OUT.type)) {
                throw new CoolException("组托档/工作档/库存条码数据已存在===>>" + param.getBarcode());
            }
        }
        int countwait = waitPakinService.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet", param.getBarcode()));
        if (countwait > 0) {
            throw new CoolException("组托档/工作档/库存条码数据已存在===>>" + param.getBarcode());
        }

        // 生成入库通知档
        List<DetlDto> detlDtos = new ArrayList<>();
        param.getCombMats().forEach(elem -> {
            DetlDto detlDto = new DetlDto(elem.getMatnr(), elem.getBatch(), elem.getBrand(), elem.getStandby1(),
                    elem.getStandby2(), elem.getStandby3(),
                    elem.getBoxType1(), elem.getBoxType2(), elem.getBoxType3(), elem.getAnfme(), elem.getThreeCode());
            if (DetlDto.has(detlDtos, detlDto)) {
                DetlDto one = DetlDto.findDto(detlDtos, detlDto);
                assert one != null;
                one.setAnfme(one.getAnfme() + detlDto.getAnfme());
            } else {
                detlDtos.add(detlDto);
            }
        });
        BasContainer container = basContainerService
                .selectOne(new EntityWrapper<BasContainer>().eq("barcode", param.getBarcode()));
        if (Objects.isNull(container)) {
            throw new CoolException("数据错误：容器码不存在！！");
        }
        if (container.getMixMax() < detlDtos.size()) {
            throw new CoolException("超出容器最大混装数量，当前容器最大数量为：" + container.getMixMax() + "!!");
        }
        Set<String> matnrs = detlDtos.stream().map(DetlDto::getMatnr).collect(Collectors.toSet());
        List<Mat> mats = matService.selectList(new EntityWrapper<Mat>().in("matnr", matnrs));
        Set<Long> tagIds = mats.stream().map(Mat::getTagId).collect(Collectors.toSet());
        if (tagIds.size() > 1) {
            throw new CoolException("组托物料类型不一致，只有相同的物料分类才可以组托！！");
        }
        // 还可以放入多少种物料
        Double suplus = container.getMixMax();
        Date now = new Date();
        for (DetlDto detlDto : detlDtos) {
            Mat mat = matService.selectByMatnr(detlDto.getMatnr());
            if (Cools.isEmpty(mat)) {
                throw new CoolException(detlDto.getMatnr() + "商品档案不存在");
            }
            // 最多可放数量
            Double singleMax = mat.getUpQty() * suplus;
            if (singleMax.compareTo(detlDto.getAnfme()) < 0) {
                throw new CoolException("物料：" + detlDto.getMatnr() + "单次组托上限为：" + mat.getUpQty() + ",当前总量超出托盘装载上限!!");
            }
            BigDecimal decimal = new BigDecimal(detlDto.getAnfme() / mat.getUpQty());
            // 当前物料需要占用料箱格数
            Integer curr = decimal.setScale(0, RoundingMode.CEILING).intValue();
            suplus = suplus - curr;
            if (suplus < 0) {
                throw new CoolException("物料：" + detlDto.getMatnr() + ", 超出当前托盘装载上限！！");
            }

        for (CombParam.CombMat combMat : param.getCombMats()) {
            BasStationDetl stationDetl = basStationDetlService.selectOne(new EntityWrapper<BasStationDetl>()
                    .eq("zpallet", param.getCarBarcode())
                    .eq("three_code", detlDto.getThreeCode()));
                    .eq(!Objects.isNull(combMat.getMatnr()), "matnr", combMat.getMatnr())
                    .eq(!Objects.isNull(combMat.getThreeCode()), "three_code", combMat.getThreeCode()));
            if (Objects.isNull(stationDetl)) {
                throw new CoolException("明细内容不存在！！");
            }
            WrkDetl wrkDetl = wrkDetlService.selectOne(new EntityWrapper<WrkDetl>()
                    .eq("matnr", stationDetl.getMatnr())
                    .eq("wrk_no", wrkMast.getWrkNo())
                    .eq("supp_code", stationDetl.getSuppCode()));

            Double v = Math.round((stationDetl.getAnfme() - stationDetl.getWorkQty()) * 10000) / 10000.0;
            if (detlDto.getAnfme().compareTo(v) > 0) {
                throw new CoolException("组托上限为：" + stationDetl.getAnfme() + ", 已组托：" + stationDetl.getWorkQty() + ", 还可组托：" + v);
            }
            if (Objects.isNull(wrkDetl)) {
                //TODO 新插入
                Mat mat = matService.selectOne(new EntityWrapper<Mat>()
                        .eq("matnr", stationDetl.getMatnr())
                        .eq("supp_code", combMat.getSuppCode()));
                if (Objects.isNull(mat)) {
                    throw new CoolException("物料基础信息已不存在！！");
                }
                WrkDetl detl = new WrkDetl();
                BeanUtils.copyProperties(stationDetl, detl);
                detl.setAnfme(combMat.getAnfme());
                detl.setBarcode(wrkMast.getBarcode());
                detl.setZpallet(param.getBarcode());
                detl.setBoxType1(param.getBoxType1());
                detl.setStandby1(combMat.getSuppCode());
                detl.setThreeCode(combMat.getThreeCode());
                detl.setAdjustQty(combMat.getAdjustQty());
                detl.setSplusQty(combMat.getSplusQty());
                detl.setWrkNo(wrkMast.getWrkNo());

            WaitPakin waitPakin = new WaitPakin();
            BeanUtils.copyProperties(mat, waitPakin);
            waitPakin.setBatch(detlDto.getBatch());
            waitPakin.setType(param.getType());
            waitPakin.setZpallet(param.getBarcode());
            // 设置组托类型
            waitPakin.setType(param.getType());
            waitPakin.setIoStatus("N");
            waitPakin.setAnfme(detlDto.getAnfme());
            waitPakin.setThreeCode(detlDto.getThreeCode());
            waitPakin.setStatus("Y");
            waitPakin.setSuppCode(detlDto.getStandby1());
            waitPakin.setStandby1(detlDto.getStandby1());
            waitPakin.setStandby2(detlDto.getStandby2());
            waitPakin.setStandby3(detlDto.getStandby3());
            waitPakin.setBoxType1(detlDto.getBoxType1());
            waitPakin.setBoxType2(detlDto.getBoxType2());
            waitPakin.setBoxType3(detlDto.getBoxType3());
            waitPakin.setAppeUser(userId);
            waitPakin.setAppeTime(now);
            waitPakin.setModiUser(userId);
            waitPakin.setModiTime(now);
            if (!waitPakinService.insert(waitPakin)) {
                throw new CoolException("保存入库通知档失败");
            }

            Double v1 = Math.round((stationDetl.getWorkQty() + detlDto.getAnfme()) * 10000) / 10000.0;
            stationDetl.setWorkQty(v1);

            if (!basStationDetlService.updateById(stationDetl)) {
                throw new CoolException("站点明细修改失败");
            }

            if (v1.compareTo(stationDetl.getAnfme()) >= 0) {
                if (!basStationDetlService.deleteById(stationDetl)) {
                    throw new CoolException("原始数据移除失败！");
                if (!wrkDetlService.insert(detl)) {
                    throw new CoolException("任务明细保存失败！！");
                }
            } else {
                if (Objects.isNull(combMat.getAnfme())) {
                    throw new CoolException("数量不能为空！！");
                }
                double val = Math.round((combMat.getAnfme() + wrkDetl.getAnfme()) * 10000) / 10000.0;
                WrkDetl detl = new WrkDetl();
                detl.setOrderNo(stationDetl.getOrderNo());
                detl.setBoxType1(param.getBoxType1());
                detl.setZpallet(param.getBarcode());
                detl.setBarcode(param.getBarcode());
                detl.setThreeCode(combMat.getThreeCode());
                detl.setStandby1(combMat.getSuppCode());
                detl.setAdjustQty(combMat.getAdjustQty());
                detl.setSplusQty(combMat.getSplusQty());
                detl.setAnfme(val);
                detl.setModiTime(new Date());
                if (!wrkDetlService.update(detl, new EntityWrapper<WrkDetl>()
                        .eq("wrk_no", wrkMast.getWrkNo())
                        .eq("supp_code", stationDetl.getSuppCode())
                        .eq("matnr", stationDetl.getMatnr()))) {
                    throw new CoolException(wrkMast.getWrkNo() + "盘点任务，" + wrkDetl.getMatnr() + "商品，"
                            + wrkDetl.getBatch() + "批号修改数量失败");
                }
            }

            List<BasStationDetl> stas = basStationDetlService.selectList(new EntityWrapper<BasStationDetl>()
                    .eq("dev_no", stationDetl.getDevNo()));
            if (Objects.isNull(stas) || stas.isEmpty()) {
                BasStation station = basStationService.selectOne(new EntityWrapper<BasStation>().eq("dev_no", stationDetl.getDevNo()));
                if (Objects.isNull(station)) {
                    throw new CoolException("数据错误，站点不存在！！");
                }
                station.setLocSts(LocStsType.LOC_STS_TYPE_O.type);
                station.setBarcode("");
                if (!basStationService.updateById(station)) {
                    throw new CoolException("站点状态更新失败！！");
            BasStationDetl stationDetl1 = basStationDetlService.selectOne(new EntityWrapper<BasStationDetl>()
                    .eq("zpallet", param.getCarBarcode())
                    .eq("three_code", combMat.getThreeCode()));

            if (!Objects.isNull(stationDetl1)) {
                Double v = Math.round((stationDetl1.getAnfme() - combMat.getAnfme()) * 10000) / 10000.0;
                if (v.compareTo(0.0) == 0) {
                    if (!basStationDetlService.delete(new EntityWrapper<BasStationDetl>()
                            .eq("zpallet", param.getCarBarcode())
                            .eq("three_code", combMat.getThreeCode()))) {
                        throw new CoolException("站点信息更新失败！！");
                    }
                } else {
                    stationDetl1.setAnfme(v);
                    if (!basStationDetlService.update(stationDetl1, new EntityWrapper<BasStationDetl>()
                            .eq("zpallet", param.getCarBarcode())
                            .eq("three_code", combMat.getThreeCode()))) {
                        throw new CoolException("站点信息更新失败！！");
                    }
                }
            }
        }
@@ -1777,33 +1798,64 @@
            param.setLocType1((short) 1);
        }


        log.info("WCS任务生成请求参数：", JSONObject.toJSONString(param));


        BasDevp station = basDevpService.selectOne(new EntityWrapper<BasDevp>()
                .eq("dev_no", param.getSourceStaNo()));
        if (Objects.isNull(station)) {
            throw new CoolException("站点不存在!!");
        BasContainer container = basContainerService.selectOne(new EntityWrapper<BasContainer>().eq("barcode", param.getBarcode()));
        if (Objects.isNull(container)) {
            throw new CoolException("容器编码未维护，请维护后再操作！！");
        }

        List<WaitPakin> waitPakins = waitPakinService
                .selectList(new EntityWrapper<WaitPakin>()
                        .eq("io_status", "N")
                        .eq("zpallet", param.getBarcode()));
        if (Objects.isNull(waitPakins) || waitPakins.isEmpty()) {
            throw new CoolException("数据错误,组拖档已不存在!!");
        Integer whsType = 1;
        Short lcoType = 1;
        //用于判断料箱托盘，料箱，笼框
        if (!container.getType().equals(ContainerType.CONTAINER_TYPE_BOX.type)) {
            whsType = 2;
            if (container.getType().equals(ContainerType.CONTAINER_TYPE_SALVER.type)) {
                lcoType = 2;
            }
        }

        WrkMast wrkMast = generateCrnInTask(waitPakins, station, param.getLocType1(), userId);
        WrkMast barcode = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode", param.getBarcode()));
        if (!Objects.isNull(barcode) && (barcode.getIoType() == 104 || barcode.getIoType() == 103 || barcode.getIoType() == 107) && barcode.getWrkSts() == 14L) {
            //
            workService.pickWrkMast(barcode.getWrkNo() + "", userId);

        Map<String, Object> response = new HashMap<>();
        response.put("taskNo", wrkMast.getWrkNo());
        response.put("locNo", wrkMast.getLocNo());
        response.put("taskPri", wrkMast.getIoPri());
            Map<String, Object> response = new HashMap<>();
            response.put("taskNo", barcode.getWrkNo());
            response.put("locNo", barcode.getLocNo());
            response.put("taskPri", barcode.getIoPri());

        return R.ok("任务生成成功").add(response);
            return R.ok("任务生成成功").add(response);
        } else {
            log.info("WCS任务生成请求参数：{}", JSONObject.toJSONString(param));

            BasDevp station = basDevpService.selectOne(new EntityWrapper<BasDevp>()
                    .eq("dev_no", param.getSourceStaNo()));
            if (Objects.isNull(station)) {
                throw new CoolException("站点不存在!!");
            }
            Map<String, Object> response = new HashMap<>();

            if (Objects.isNull(barcode)) {
                List<WaitPakin> waitPakins = waitPakinService
                        .selectList(new EntityWrapper<WaitPakin>()
                                .eq("io_status", "N")
                                .eq("zpallet", param.getBarcode()));
                if (Objects.isNull(waitPakins) || waitPakins.isEmpty()) {
                    throw new CoolException("数据错误,组拖档已不存在!!");
                }

                WrkMast wrkMast = generateCrnInTask(waitPakins, whsType, station, lcoType, userId);

                response.put("taskNo", wrkMast.getWrkNo());
                response.put("locNo", wrkMast.getLocNo());
                response.put("taskPri", wrkMast.getIoPri());
            } else {
                response.put("taskNo", barcode.getWrkNo());
                response.put("locNo", barcode.getLocNo());
                response.put("taskPri", barcode.getIoPri());
            }

            return R.ok("任务生成成功").add(response);
        }
    }

    /**
@@ -1831,6 +1883,12 @@
        if (Cools.isEmpty(basStation)) {
            throw new CoolException("请输入正确的站点号");
        }

        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode", params.getOrgBarcode()));
        if (Objects.isNull(wrkMast)) {
            throw new CoolException("出库任务档信息不存在！！");
        }

        for (CollectionPakinParams.CombMat combMat : params.getCombMats()) {
            if (combMat.getWorkQty().compareTo(BigDecimal.ZERO) == 0) {
                continue;
@@ -1846,8 +1904,23 @@
            BasStationDetl basStationDetl = basStationDetlService.selectOne(new EntityWrapper<BasStationDetl>()
                    .eq("dev_no", basStation.getDevNo())
                    .eq("matnr", combMat.getMatnr())
                    .eq("batch", combMat.getBatch())
                    .eq("standby1", combMat.getStandby1()));
                    .eq("order_no", combMat.getOrderNo())
                    .eq(!Cools.isEmpty(combMat.getBatch()), "batch", combMat.getBatch())
                    .eq(!Cools.isEmpty(combMat.getStandby1()), "standby1", combMat.getStandby1()));


            Wrapper<WrkDetl> wrapper = new EntityWrapper<WrkDetl>()
                    .eq("wrk_no", wrkMast.getWrkNo())
                    .eq("matnr", combMat.getMatnr())
                    .eq("supp_coode", combMat.getStandby1());
////                    .eq(!Objects.isNull(params.getBoxType1()), "boxType1", params.getBoxType1())
//
//            if (!Objects.isNull(params.getBoxType1())) {
//                wrapper.eq("box_type1", params.getBoxType1());
//            }

//            WrkDetl wrkDetl = wrkDetlService.selectOne(wrapper);

            if (Cools.isEmpty(basStationDetl)) {
                basStationDetl = new BasStationDetl();
                Mat mat = matService.selectByMatnr(combMat.getMatnr());
@@ -1859,12 +1932,18 @@
                        .setBarcode(params.getTarBarcode())
                        .setZpallet(params.getTarBarcode())
                        .setBatch(combMat.getBatch())
                        .setBoxType1(params.getBoxType1())
                        .setSuppCode(combMat.getStandby1())
                        .setStandby1(combMat.getStandby1())
                        .setAnfme(combMat.getWorkQty().doubleValue());

//                if (!Objects.isNull(wrkDetl) && !wrkDetl.getMatnr().equals(combMat.getMatnr())) {
//                    throw new CoolException("请检查隔层是否绑定正确！！");
//                }
                if (!basStationDetlService.insert(basStationDetl)) {
                    throw new CoolException("插入明细失败");
                }

            } else {
                BigDecimal anfme = new BigDecimal(basStationDetl.getAnfme().toString()).add(combMat.getWorkQty());
                basStationDetl.setAnfme(anfme.doubleValue());
@@ -1888,8 +1967,8 @@
        OrderDetlPakin orderDetlPakin = orderDetlPakinService.selectOne(new EntityWrapper<OrderDetlPakin>()
                .eq("order_id", orderPakin.getId())
                .eq("matnr", combMat.getMatnr())
                .eq("batch", combMat.getBatch())
                .eq("standby1", combMat.getStandby1()));
                .eq(!Cools.isEmpty(combMat.getBatch()), "batch", combMat.getBatch())
                .eq(!Cools.isEmpty(combMat.getStandby1()), "supp_code", combMat.getStandby1()));
        if (Cools.isEmpty(orderDetlPakin)) {
            throw new CoolException("检索单据明细数据失败");
        }
@@ -1912,7 +1991,6 @@

    @Override
    public R collectionPakinView(CollectionPakinParams params) {

        WrkMast wrkMast = wrkMastService.selectByBarcode(params.getOrgBarcode());
        if (Cools.isEmpty(wrkMast)) {
            throw new CoolException("未找到任务");
@@ -1920,14 +1998,15 @@

        if (wrkMast.getIoType().equals(TaskIOType.ALL_OUT.type)
                && wrkMast.getIoType().equals(TaskIOType.PICK_OUT.type)) {
            throw new CoolException("人物类型错误");
            throw new CoolException("任务类型错误");
        }

        wrkDetlService.selectList(new EntityWrapper<WrkDetl>()
                .eq(!Objects.isNull(params.getMatnr()), "matnr", params.getMatnr())
        List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>()
                .like(!Objects.isNull(params.getMatnr()), "matnr", params.getMatnr())
                .eq(!Objects.isNull(params.getBoxType1()), "box_type1", params.getBoxType1())
                .eq("wrk_no", wrkMast.getWrkNo()));

        List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
//        List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
        if (Cools.isEmpty(wrkDetls)) {
            throw new CoolException("未找到任务明细");
        }
@@ -1938,12 +2017,13 @@
    /**
     * 生成堆垛机入库任务
     *
     * @param whsType
     * @param station
     * @author Ryan
     * @date 2025/12/9 13:54
     */
    @Transactional(rollbackFor = Exception.class)
    public WrkMast generateCrnInTask(List<WaitPakin> waitPakins, BasDevp station, Short locType, Long userId) {
    public WrkMast generateCrnInTask(List<WaitPakin> waitPakins, Integer whsType, BasDevp station, Short locType, Long userId) {
        Date now = new Date();
//        StationRela rela = stationRelaService.selectOne(new EntityWrapper<StationRela>()
//                .eq("agv_sta", station.getDevNo())
@@ -1966,6 +2046,20 @@
        if (!Objects.isNull(mast)) {
            if (mast.getIoType().equals(TaskIOType.MERGE_OUT.type) || mast.getIoType().equals(TaskIOType.PICK_OUT.type) || mast.getIoType().equals(TaskIOType.CHECK_OUT.type)) {
                int ioType = mast.getIoType() - 50;

                List<WrkDetl> wrkDetls103 = wrkDetlService
                        .selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                if (wrkDetls103.isEmpty()) {
                    ioType = 10;
                }
                List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getSourceLocNo()));
                if (!Objects.isNull(locDetls) && !locDetls.isEmpty()) {
                    Double sum = wrkDetls103.stream().mapToDouble(WrkDetl::getAnfme).sum();
                    Double summed = locDetls.stream().mapToDouble(LocDetl::getAnfme).sum();
                    if (summed.compareTo(sum) <= 0) {
                        ioType = 10;
                    }
                }
                mast.setIoType(ioType);
                mast.setWrkSts(2L);
                mast.setSourceStaNo(mast.getSourceStaNo());
@@ -1999,7 +2093,7 @@
            }

        } else {
            StartupDto dto = commonService.getLocNo(1, sourceStaNo.getDevNo(), findLocNoAttributeVo, locTypeDto);
            StartupDto dto = commonService.getLocNo(1, sourceStaNo.getDevNo(), whsType, findLocNoAttributeVo, locTypeDto);

            int workNo = dto.getWorkNo();
            // 生成工作档
@@ -2050,21 +2144,27 @@

        // 生成工作档明细
        waitPakins.forEach(waitPakin -> {
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(waitPakin);
            wrkDetl.setWrkNo(wrkMast.getWrkNo());
            wrkDetl.setIoTime(wrkMast.getIoTime());
            wrkDetl.setAppeTime(now);
            wrkDetl.setModiTime(now);
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作明细失败");
            if (!Objects.isNull(waitPakin.getMatnr())) {
                WrkDetl wrkDetl = new WrkDetl();
                wrkDetl.sync(waitPakin);
                wrkDetl.setWrkNo(wrkMast.getWrkNo());
                wrkDetl.setIoTime(wrkMast.getIoTime());
                wrkDetl.setAppeTime(now);
                wrkDetl.setModiTime(now);
                if (!wrkDetlService.insert(wrkDetl)) {
                    throw new CoolException("保存工作明细失败");
                }
            } else {
                wrkMast.setWrkSts(2L);
                wrkMast.setIoType(10);
                wrkMastService.updateById(wrkMast);
            }
        });


        // 更新入库通知档 ioStatus ===>> Y
        Wrapper<WaitPakin> wrapper = new EntityWrapper<WaitPakin>()
                .eq("zpallet", pakin.getZpallet());

        WaitPakin setParam = new WaitPakin();
        setParam.setLocNo(locNo);
        setParam.setIoStatus("Y");
@@ -2145,7 +2245,16 @@
        AtomicReference<Double> totalOut = new AtomicReference<>(0.0);
        listMap.forEach((matnr, detls) -> {
            Map<String, List<LocDetl>> supIds = detls.stream().collect(Collectors.groupingBy(LocDetl::getStandby1));
            supIds.forEach((supId, sups) -> {
            for (String supId : supIds.keySet()) {
                List<LocDetl> sups = supIds.get(supId);
//            }
//            supIds.forEach((supId, sups) -> {
                Mat mats = matService.selectOne(new EntityWrapper<Mat>()
                        .eq("supp_code", supId)
                        .eq("matnr", matnr));
                if (Objects.isNull(mats)) {
                    throw new CoolException("物料不存在！！");
                }
                // 根据supId(供应商)分类，得到需要存放的总空库存数量
                Double sum = sups.stream().mapToDouble(LocDetl::getAnfme).sum();
                AtomicReference<Double> itemed = new AtomicReference<>(0.0);
@@ -2173,10 +2282,6 @@
                        if (container.getMixMax() > sets.size()) {
                            //余下可混放种类
                            long suplus = Math.round((container.getMixMax() - sets.size()) * 10000) / 10000;
                            Mat mats = matService.selectOne(new EntityWrapper<Mat>().eq("matnr", matnr));
                            if (Objects.isNull(mats)) {
                                throw new CoolException("物料不存在！！");
                            }
                            //余下最大可放数量
                            Double v = Math.round((mats.getUpQty() * suplus) * 10000) / 10000.0;
                            // 入库数量小于零且入库数量减去已计划出数量大于零（）
@@ -2189,15 +2294,51 @@
                            }
                        }
                    });
                } else {
                    // 获取当前供应商+ 物料在库
                    LocMast notFullList = locMastService.selectNotFull(mats.getLocType(), one.getId());
                    if (Objects.isNull(notFullList)) {
                        continue;
                    }
                    BasContainer container = basContainerService
                            .selectOne(new EntityWrapper<BasContainer>().eq("barcode", notFullList.getBarcode()));
                    if (Objects.isNull(container)) {
                        throw new CoolException("数据错误，容器不存在！！");
                    }
                    List<LocDetl> adetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", notFullList.getLocNo()));
                    Set<String> sets = adetls.stream().map(LocDetl::getMatnr).collect(Collectors.toSet());
                    List<LocDetl> locDtls = new ArrayList<>();
                    // 判断容器是否还可混放,及当前物料可放多少
                    if (container.getMixMax() > sets.size()) {
                        //余下可混放种类
                        long suplus = Math.round((container.getMixMax() - sets.size()) * 10000) / 10000;
                        //余下最大可放数量
                        Double v = Math.round((mats.getUpQty() * suplus) * 10000) / 10000.0;
                        // 入库数量小于零且入库数量减去已计划出数量大于零（）
                        if (sum.compareTo(v) <= 0 && sum.compareTo(itemed.get()) > 0) {
                            itemed.set(Math.round((itemed.get() + v) * 10000) / 10000.0);
                            // 可放下
                            LocDetl locDetl = new LocDetl();
                            BeanUtils.copyProperties(mats, locDetl);
                            locDetl.setLocNo(notFullList.getLocNo());
                            locDetl.setAnfme(0.0);
                            locDetl.setMatnr(mats.getMatnr());
                            locDetl.setZpallet(notFullList.getBarcode());
                            locDetl.setSuppCode(mats.getSuppCode());
                            locDetl.setMaktx(mats.getMaktx());
                            locDtls.add(locDetl);
                            CrnTaskDetlDTO crnTaskDetlDTO = new CrnTaskDetlDTO().setLocNo(notFullList.getLocNo()).setLocDetlList(locDtls);
                            locMasts.add(crnTaskDetlDTO);
                            totalOut.set(Math.round((totalOut.get() + itemed.get()) * 10000) / 10000.0);
                        }
                    }
                }
            });
            }
        });

        // 判断根据分拣出库后,还需要出多少托盘或料箱;如果余料大于0, 出新托盘或料箱
        if (totalOut.get().compareTo(0.0) > 0) {
            generateTask(locMasts, TaskIOType.MERGE_OUT.type, basDevp, userId, station);
            //TODO 细化区分，当前出库托盘是满足拣货数量
        } else {
        /**是否优先空板出库*/
        Config config = configService.selectOne(new EntityWrapper<Config>().eq("code", "OutStockOrderByEmpty"));
        if (!Objects.isNull(config) && Boolean.parseBoolean(config.getValue())) {
            LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                    // todo 根据物料种类,区分库区类型
                    .eq("loc_sts", LocStsType.LOC_STS_TYPE_D.type)
@@ -2207,12 +2348,31 @@
            if (Objects.isNull(locMast)) {
                throw new CoolException("未查询到可用的空板信息！！");
            }

            CrnTaskDetlDTO crnTaskDetlDTO = new CrnTaskDetlDTO().setLocNo(locMast.getLocNo()).setLocDetlList(locDetls);
            CrnTaskDetlDTO crnTaskDetlDTO = new CrnTaskDetlDTO().setLocNo(locMast.getLocNo()).setLocDetlList(new ArrayList<>());
            locMasts.add(crnTaskDetlDTO);

            // 空板出库
            generateTask(locMasts, TaskIOType.MERGE_OUT.type, basDevp, userId, station);
        } else {
            // 判断根据分拣出库后,还需要出多少托盘或料箱;如果余料大于0, 出新托盘或料箱
            if (totalOut.get().compareTo(0.0) > 0) {
                generateTask(locMasts, TaskIOType.MERGE_OUT.type, basDevp, userId, station);
                //TODO 细化区分，当前出库托盘是满足拣货数量
            } else {
                LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                        // todo 根据物料种类,区分库区类型
                        .eq("loc_sts", LocStsType.LOC_STS_TYPE_D.type)
                        .orderAsc(Arrays.asList("row1", "bay1", "lev1"))
                        .last("OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY"));

                if (Objects.isNull(locMast)) {
                    throw new CoolException("未查询到可用的空板信息！！");
                }
                CrnTaskDetlDTO crnTaskDetlDTO = new CrnTaskDetlDTO().setLocNo(locMast.getLocNo()).setLocDetlList(new ArrayList<>());
                locMasts.add(crnTaskDetlDTO);

                // 空板出库
                generateTask(locMasts, TaskIOType.MERGE_OUT.type, basDevp, userId, station);
            }
        }
    }

@@ -2249,7 +2409,7 @@
                wrkMast.setIoType(ioType); // 入出库类型
                wrkMast.setIoPri(13D); // 优先级：13
                wrkMast.setCrnNo(locMast.getCrnNo());
                wrkMast.setSourceStaNo(staDesc.getCrnStn() + ""); // 源站
//                wrkMast.setSourceStaNo(staDesc.getCrnStn() + ""); // 源站
                wrkMast.setStaNo(staDesc.getStnNo() + ""); // 目标站
                wrkMast.setSourceLocNo(locMast.getLocNo()); // 源库位
                //小松项目，缓存出库AGV站点，用于清空缓存区库存
@@ -2312,7 +2472,7 @@
    @Transactional(rollbackFor = Exception.class)
    public void generateCacheOutTask(BasStation station, LocCache loc, Long userId) {
        // 获取工作号
        int workNo = commonService.getWorkNo(WorkNoType.PICK.type);
        int workNo = commonService.getWorkNo(4);
        // 保存工作档
        Task task = new Task();
        task.setWrkNo(workNo)
@@ -2369,9 +2529,10 @@
        loc.setModiUser(userId);
        loc.setModiTime(new Date());

        if (!locCacheService.updateById(loc)) {
            throw new CoolException("更新库位状态信息！！");
        }
//        if (!) {
//            throw new CoolException("更新库位状态信息！！");
//        }
        locCacheService.update(loc, new EntityWrapper<LocCache>().eq("loc_no", loc.getLocNo()));

        // 修改目标站点信息
        if (station.getLocSts().equals(LocStsType.LOC_STS_TYPE_O.type)) {
@@ -2382,7 +2543,8 @@
                throw new CoolException("更新目标库位状态失败");
            }
        } else {
            throw new CoolException("移转失败，目标库位状态：" + station.getLocSts());
            log.error("移转失败，目标库位状态：" + station.getLocSts());
//            throw new CoolException("移转失败，目标库位状态：" + station.getLocSts());
        }
    }

@@ -2393,21 +2555,22 @@
     * @version 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public void generateAgvTask(String type, LocCache loc, String orgSite, String barcode, Long userId) {
    public void generateAgvTask(String type, LocCache loc, String orgSite, String barcode, Long userId, String isNewIn) {
        List<Task> tasks = taskService.selectList(new EntityWrapper<Task>().eq("barcode", barcode));
        if (!tasks.isEmpty()) {
            throw new CoolException("托盘已在任务执行中..");
        }
        // 获取工作号
        int workNo = commonService.getWorkNo(WorkNoType.PICK.type);
        int workNo = commonService.getWorkNo(4);
        // 保存工作档
        Task task = new Task();
        task.setWrkNo(workNo)
                .setIoTime(new Date())
                .setWrkSts(201L) // 工作状态：11.生成出库ID
                .setIoType(1) // 入出库状态： 11.库格移载
                .setTaskType("agv")
                .setTaskType(type)
                .setIoPri(10D)
                .setIsNewIn(isNewIn)
                .setLocNo(loc.getLocNo()) // 目标库位
                .setFullPlt("Y") // 满板：Y
                .setPicking("N") // 拣料
@@ -2449,7 +2612,6 @@
                if (!taskDetlService.insert(wrkDetl)) {
                    throw new CoolException("保存工作档明细失败");
                }

            }

            for (WaitPakin pakin : pakins) {
@@ -2458,28 +2620,27 @@
                    throw new CoolException("更新组托信息失败");
                }
            }
        }

        // 修改目标库位状态
        if (loc.getLocSts().equals(LocStsType.LOC_STS_TYPE_O.type)) {
            loc.setLocSts(LocStsType.LOC_STS_TYPE_S.type); // S.入库预约
            loc.setModiTime(new Date());
            loc.setModiUser(userId);
            if (!locCacheService.updateById(loc)) {
                throw new CoolException("更新目标库位状态失败");
            // 修改目标库位状态
            if (loc.getLocSts().equals(LocStsType.LOC_STS_TYPE_O.type)) {
                loc.setLocSts(LocStsType.LOC_STS_TYPE_S.type); // S.入库预约
                loc.setModiTime(new Date());
                loc.setModiUser(userId);

                if (!locCacheService.update(loc, new EntityWrapper<LocCache>().eq("loc_no", loc.getLocNo()))) {
                    throw new CoolException("更新目标库位状态失败");
                }
            } else {
                throw new CoolException("移转失败，目标库位状态：" + loc.getLocSts$());
            }
        } else {
            throw new CoolException("移转失败，目标库位状态：" + loc.getLocSts$());
        }

        // 修改目标站点信息
        BasStation station = basStationService.selectOne(new EntityWrapper<BasStation>().eq("dev_no", orgSite));
        if (Objects.isNull(station)) {
            throw new CoolException("站点不存在!!");
        }
            // 修改目标站点信息
            BasStation station = basStationService.selectOne(new EntityWrapper<BasStation>().eq("dev_no", orgSite));
            if (Objects.isNull(station)) {
                throw new CoolException("站点不存在!!");
            }

        if (station.getLocSts().equals(LocStsType.LOC_STS_TYPE_O.type) || station.getLocSts().equals(LocStsType.LOC_STS_TYPE_D.type)) {
            station.setLocSts("R"); // S.入库预约
            station.setLocSts("R"); // R.入库预约
            station.setBarcode(barcode);
            station.setModiTime(new Date());
            station.setModiUser(userId);
@@ -2487,7 +2648,27 @@
                throw new CoolException("更新目标库位状态失败");
            }
        } else {
            throw new CoolException("移转失败，目标库位状态：" + station.getLocSts());
            // 修改目标库位状态
            loc.setLocSts(LocStsType.LOC_STS_TYPE_D.type); // S.入库预约
            loc.setModiTime(new Date());
            loc.setModiUser(userId);
            if (!locCacheService.update(loc, new EntityWrapper<LocCache>().eq("loc_no", loc.getLocNo()))) {
                throw new CoolException("更新目标库位状态失败");
            }

            // 修改目标站点信息
            BasStation station = basStationService.selectOne(new EntityWrapper<BasStation>().eq("dev_no", orgSite));
            if (Objects.isNull(station)) {
                throw new CoolException("站点不存在!!");
            }
            station.setLocSts("O");
            station.setBarcode(barcode);
            station.setModiTime(new Date());
            station.setModiUser(userId);
            if (!basStationService.updateById(station)) {
                throw new CoolException("更新目标库位状态失败");
            }
            basStationDetlService.delete(new EntityWrapper<BasStationDetl>().eq("dev_no", station.getDevNo()));
        }
    }

@@ -2572,13 +2753,12 @@
        if (Objects.isNull(station)) {
            throw new CoolException("站点不存在!!");
        }

        try {
            //空台车回库
            generateAgvTask("agv_back", locCache, callAgvBackParam.getOrgSite(), station.getBarcode(), userId);
            generateAgvTask("agv_back", locCache, callAgvBackParam.getOrgSite(), station.getBarcode(), userId, "M2");
        } catch (Exception e) {
            e.printStackTrace();
            return R.error(e.getMessage());
            log.error(e.getMessage());
            throw new CoolException(e.getMessage());
        }

        return R.ok(locCache);
@@ -2594,7 +2774,7 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R taskMove(CompleteParam combParam, long userId) {
        if (Objects.isNull(combParam.getWorkNo())) {
        if (Objects.isNull(combParam.getTaskNo())) {
            return R.error("任务号不能为空");
        }
        if (Objects.isNull(combParam.getSourceLocNo())) {
@@ -2603,25 +2783,32 @@
        if (Objects.isNull(combParam.getLocNo())) {
            return R.error("目标库位不能为空！");
        }
        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", combParam.getWorkNo()));
        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", combParam.getTaskNo()));
        if (Objects.isNull(wrkMast)) {
            return R.error("任务档不存在！！");
        }


        String body = JSON.toJSONString(combParam);
        boolean success = false;
        String response = "";
        try {
            response = new HttpHandler.Builder()
                    .setUri(HIKApiConstant.AGV_IP)
                    .setUri(MesConstant.WCS_URL)
                    .setPath(MesConstant.MOVE_LOC_TASK)
                    .setJson(body)
                    .build()
                    .doPost();
            JSONObject jsonObject = JSON.parseObject(response);
            if (jsonObject.getInteger("code").equals(200)) {
                wrkMast.setWrkSts(12L);
                wrkMast.setWrkSts(2L);
                if (!wrkMastService.updateById(wrkMast)) {
                    throw new CoolException("任务状态更新失败！！");
                }
                LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", wrkMast.getSourceLocNo()));
                if (!Objects.isNull(locMast)) {
                    locMast.setMoveStatus(1);
                    locMastService.updateById(locMast);
                }
                success = true;
            } else {
@@ -2650,6 +2837,7 @@

    /**
     * 6.15WCS申请在库库位更换库位
     *
     * @param combParam
     * @param l
     * @return
@@ -2702,6 +2890,489 @@
    }

    /**
     * 获取缓存站点信息
     *
     * @param type
     * @return
     */
    @Override
    public R getCacheSites(String type) {
        BasAreas areas = basAreasService.selectOne(new EntityWrapper<BasAreas>().eq("whs_type_id", type));
        if (Objects.isNull(areas)) {
            return R.error("库区不存在！");
        }
        List<BasStation> stations = basStationService.selectList(new EntityWrapper<BasStation>().eq("area_id", areas.getId()));
        if (Objects.isNull(stations) || stations.isEmpty()) {
            return R.error("站点不存在！");
        }
        return R.ok("查询成功").add(stations);
    }

    /**
     * 获取捆包明细信息
     *
     * @param params
     * @return
     */
    @Override
    public R getAllBindInfo(AgvCallParams params) {
        if (Objects.isNull(params.getCarBarcode())) {
            return R.error("台车编码不能为空！");
        }
        List<TaskDetl> taskDetls = taskDetlService.selectList(new EntityWrapper<TaskDetl>()
                .eq("zpallet", params.getCarBarcode()));

        taskDetls.forEach(taskDetl -> {
            OrderPakout orderDetlPakout = orderPakoutService.selectOne(new EntityWrapper<OrderPakout>()
                    .eq("order_no", taskDetl.getOrderNo()));
            taskDetl.setMemo(orderDetlPakout.getShipCode());
        });

        return R.ok("查询成功").add(taskDetls);
    }

    /**
     * 按台车出库
     *
     * @param params
     * @return com.core.common.R
     * @author Ryan
     * @date 2026/3/28 8:41
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R outStockByTc(AgvCallParams params) {
        if (Objects.isNull(params.getCarBarcode())) {
            return R.error("台车码不能为空！！");
        }
        LocCache locCache = locCacheService.selectOne(new EntityWrapper<LocCache>().eq("barcode", params.getCarBarcode()));
        if (Objects.isNull(locCache)) {
            return R.error("当前台车不在缓冲库区！！");
        }
        if (Objects.isNull(params.getTarSite())) {
            return R.error("目标站点不能为空！！");
        }
        BasStation devNo = basStationService.selectOne(new EntityWrapper<BasStation>().eq("dev_no", params.getTarSite()));
        if (Objects.isNull(devNo) || !devNo.getLocSts().equals(LocStsType.LOC_STS_TYPE_O.type)) {
            return R.error("目标站点忙碌中！！");
        }

        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", locCache.getLocNo()));
        if (Objects.isNull(locDetls) || locDetls.isEmpty()) {
            return R.error("台车上没有对应明细信息！！");
        }
        List<LocDto> locDtos = new ArrayList<>();
        locDetls.forEach(locDetl -> {
            List<OrderPakout> orderPakouts = orderPakoutService.selectList(new EntityWrapper<OrderPakout>()
                    .eq("doc_type", 5)
                    .eq("number", locDetl.getOrderNo()));
            if (Objects.isNull(orderPakouts) || orderPakouts.isEmpty()) {
                throw new CoolException("单据信息不存在或已上报完成！！");
            }
            for (OrderPakout orderPakout : orderPakouts) {
                OrderDetlPakout orderDetl = orderDetlPakoutService.selectOne(new EntityWrapper<OrderDetlPakout>()
                        .eq("matnr", locDetl.getMatnr())
                        .eq("supp_code", locDetl.getSuppCode())
                        .eq("order_no", orderPakout.getOrderNo()));
                if (Objects.isNull(orderDetl)) {
                    continue;
                }
                locDetl.setMemo(orderPakout.getShipCode());
                locDetl.setOrderNo(orderPakout.getOrderNo());

                LocDto locDto = new LocDto(locDetl.getLocNo(), locDetl.getMatnr(), locDetl.getMaktx(), locDetl.getBatch(), orderDetl.getOrderNo(), locDetl.getAnfme());
                locDto.setFrozen(locDetl.getFrozen());
                locDto.setFrozenLoc(locCache.getFrozen());
                locDto.setAgvStaNo(params.getTarSite());
                locDto.setBrand(orderDetl.getBrand());
                locDto.setSuppCode(orderDetl.getSuppCode());
                locDto.setStandby1(orderDetl.getStandby1());
                locDto.setStandby2(orderDetl.getStandby2());
                locDto.setStandby3(orderDetl.getStandby3());
                locDto.setBoxType1(orderDetl.getBoxType1());
                locDto.setBoxType2(orderDetl.getBoxType2());
                locDto.setBoxType3(orderDetl.getBoxType3());
                locDtos.add(locDto);

            }
//            exist.add(locDetl.getLocNo());
        });

        generateAgvTaskByTc(locDtos);

        return R.ok();
    }

    /**
     * 获取站点明细信息
     *
     * @param params
     * @return
     */
    @Override
    public R getStationInfos(AgvCallParams params) {
        if (Objects.isNull(params.getOrgSite())) {
            return R.error("站点不能为空！！");
        }
        if (Objects.isNull(params.getCarBarcode())) {
            return R.error("站点台车不能为空！！");
        }
//        if (!Cools.isEmpty(params.getMatnr())) {
//            return R.error("物料信息不能为空！！");
//        }
        BasStation station = basStationService.selectOne(new EntityWrapper<BasStation>()
                .eq("dev_no", params.getOrgSite())
                .eq("barcode", params.getCarBarcode()));
        if (Objects.isNull(station)) {
            throw new CoolException("台车与站点绑定关系不存在，请联系管理员！");
        }
        List<BasStationDetl> stationDetls = basStationDetlService.selectList(new EntityWrapper<BasStationDetl>()
                .like(!Cools.isEmpty(params.getMatnr()), "matnr", params.getMatnr())
                .eq("dev_no", station.getDevNo()));
        if (!stationDetls.isEmpty()) {
            return R.ok().add(stationDetls);
        }
        return R.ok();
    }

    /**
     * 站点物料解绑
     *
     * @param params
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R unbindMatnr(CombParam params) {
        if (Objects.isNull(params.getCombMats()) || params.getCombMats().isEmpty()) {
            return R.error("明细不能为空！！");
        }
        for (CombParam.CombMat combMat : params.getCombMats()) {
            if (Objects.isNull(combMat)) {
                continue;
            }
            OrderPakin order = orderPakinService.selectOne(new EntityWrapper<OrderPakin>()
                    .lt("settle", 4)
                    .eq("order_no", combMat.getOrderNo()));
            if (Objects.isNull(order)) {
                return R.error("未查询到订单，请确认是否为库口组托信息！！");
            }
            //入库
            OrderDetlPakin detlPakin = orderDetlPakinService.selectOne(new EntityWrapper<OrderDetlPakin>()
                    .eq("order_no", combMat.getOrderNo())
                    .eq("matnr", combMat.getMatnr())
                    .eq("supp_code", combMat.getStandby1())
                    .last("AND anfme != qty"));

            if (!Objects.isNull(detlPakin)) {
                Double v = Math.round((detlPakin.getWorkQty() - combMat.getAnfme()) * 10000) / 10000.0;
                detlPakin.setWorkQty(v);
                if (!orderDetlPakinService.update(detlPakin, new EntityWrapper<OrderDetlPakin>()
                        .eq("order_no", combMat.getOrderNo())
                        .eq("matnr", combMat.getMatnr())
                        .eq("supp_code", combMat.getStandby1()))) {
                    throw new CoolException("订单明细更新失败！！");
                }

                BasStationDetl stationDetl = basStationDetlService.selectOne(new EntityWrapper<BasStationDetl>()
                        .eq("order_no", combMat.getOrderNo())
                        .eq("matnr", combMat.getMatnr())
                        .eq("supp_code", combMat.getStandby1()));
                if (!Objects.isNull(stationDetl)) {
                    if (!basStationDetlService.delete(new EntityWrapper<BasStationDetl>()
                            .eq("order_no", combMat.getOrderNo())
                            .eq("matnr", combMat.getMatnr())
                            .eq("supp_code", combMat.getStandby1()))) {
                        throw new CoolException("解绑失败，站点库存删除失败！");
                    }
                }

                BasAreas basAreas = basAreasService.selectOne(new EntityWrapper<BasAreas>().eq("whs_type_id", LocAreaType.LOC_AREA_TYPE_IN_CACHE.type));
                if (Objects.isNull(basAreas)) {
                    throw new CoolException("站点查询失败，请联系管理员！！");
                }

                LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>()
                        .eq("area_id", basAreas.getId())
                        .eq("order_no", combMat.getOrderNo())
                        .eq("matnr", combMat.getMatnr())
                        .eq("supp_code", combMat.getStandby1()));
                if (!Objects.isNull(locDetl)) {
                    if (!locDetlService.delete(new EntityWrapper<LocDetl>()
                            .eq("area_id", basAreas.getId())
                            .eq("order_no", combMat.getOrderNo())
                            .eq("matnr", combMat.getMatnr())
                            .eq("supp_code", combMat.getStandby1()))) {
                        throw new CoolException("解绑失败，缓冲库区库存删除失败！");
                    }
                }

                WaitPakin waitPakin = waitPakinService.selectOne(new EntityWrapper<WaitPakin>()
                        .eq("order_no", combMat.getOrderNo())
                        .eq("matnr", combMat.getMatnr())
                        .eq("supp_code", combMat.getStandby1()));
                if (!Objects.isNull(waitPakin)) {
                    if (!waitPakinService.delete(new EntityWrapper<WaitPakin>().eq("order_no", combMat.getOrderNo())
                            .eq("matnr", combMat.getMatnr())
                            .eq("supp_code", combMat.getStandby1()))) {
                        throw new CoolException("原组托档删除失败！！");
                    }
                }
            } else {
                throw new CoolException("订单明细绑定关系不存在或已完成入库！！");
            }
        }
        return R.ok();
    }


    @Transactional(rollbackFor = Exception.class)
    public void generateAgvTaskByTc(List<LocDto> locDtos) {
        List<LocDto> locDtoArrayList = new ArrayList<>();
        for (LocDto locDto : locDtos) {
            if (locDto.getFrozen() != 1 && locDto.getFrozenLoc() != 1) {
                locDtoArrayList.add(locDto);
            }
        }
        locDtos = locDtoArrayList;
        if (Cools.isEmpty(locDtos)) {
            throw new CoolException("库存/库位被冻结，请处理后出库！！！");
        }
        boolean lack = true;
        for (LocDto locDto : locDtos) {
            if (!locDto.isLack()) {
                lack = false;
                break;
            }
        }
        if (lack) {
            throw new CoolException("库存不足");
        }

        try {
            Thread.sleep(300L);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        List<TaskDto> taskDtos = new ArrayList<>();
        // 根据 （库位 & 出库站） 分组； 理想状态：一组为一次出库任务
        for (LocDto locDto : locDtos) {
            if (locDto.isLack()) {
                continue;
            }
            TaskDto taskDto = new TaskDto(locDto.getLocNo(), locDto.getAgvStaNo(), locDto);
            if (TaskDto.hasAgv(taskDtos, taskDto)) {
                TaskDto dto = TaskDto.findAgv(taskDtos, taskDto);
                assert dto != null;
                dto.getLocDtos().addAll(taskDto.getLocDtos());
            } else {
                taskDtos.add(taskDto);
            }
        }
        // -----------------------------------------------------------------------------------------------
        Map<String, List<TaskDto>> listMap = taskDtos.stream().collect(Collectors.groupingBy(TaskDto::getLocNo));
        listMap.keySet().forEach(locNo -> {
            listMap.get(locNo).forEach(taskDto -> {
                BasStation station = basStationService.selectOne(new EntityWrapper<BasStation>()
                        .in("loc_sts", Arrays.asList(LocStsType.LOC_STS_TYPE_O.type, LocStsType.LOC_STS_TYPE_O.type))
                        .eq("dev_no", taskDto.getAgvStaNo()));
                if (Objects.isNull(station)) {
                    throw new CoolException("数据错误，站点不存在或已使用！！");
                }
                workService.agvStockOut(station, taskDto, 9527L);
            });
        });
    }

    /**
     * 确认捆包出库
     *
     * @param combParam
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R confirmOutstock(CombParam combParam) {
        if (Objects.isNull(combParam.getCombMats()) || combParam.getCombMats().isEmpty()) {
            return R.error("捆包信息不能为空！！");
        }
        Task task = taskService.selectOne(new EntityWrapper<Task>()
                .eq("wrk_sts", 304)
                .eq("barcode", combParam.getBarcode()));
        if (Objects.isNull(task)) {
            throw new CoolException("任务信息不存在！！");
        }
        if (task.getIoType().equals(103)) {
            List<TaskDetl> taskDetls = taskDetlService.selectList(new EntityWrapper<TaskDetl>()
                    .eq("wrk_no", task.getWrkNo()));

            int workNo = commonService.getWorkNo(4);
            Task task1 = new Task();
            BeanUtils.copyProperties(task, task1);
            task1.setIoType(53);
            task1.setLocNo(task.getSourceLocNo());
            task1.setSourceStaNo(task.getStaNo());
            task1.setWrkNo(workNo);
            task1.setWrkSts(TaskStatusType.AGV_IN_START.type);

            if (!taskService.insert(task1)) {
                throw new CoolException("入库任务生成失败！！");
            }
            if (!Objects.isNull(taskDetls) && !taskDetls.isEmpty()) {
                for (CombParam.CombMat combMat : combParam.getCombMats()) {
                    taskDetls.forEach(taskDetl -> {
                        if (taskDetl.getMatnr().equals(combMat.getMatnr()) && taskDetl.getSuppCode().equals(combMat.getSuppCode())) {
                            //TODO
                            if (!taskDetl.getAnfme().equals(combMat.getAnfme())) {
                                throw new CoolException("物料--->" + combMat.getMatnr() + "未拣料完成，请确认完成后再尝试！！");
                            }
                            List<TaskDetl> taskDetls1 = taskDetlService.selectList(new EntityWrapper<TaskDetl>().eq("wrk_no", task.getWrkNo()));
                            if (!Objects.isNull(taskDetls1) && !taskDetls1.isEmpty()) {
                                taskDetls1.forEach(detl -> {
                                    detl.setWrkNo(workNo);
                                    detl.setBoxType1(combMat.getBoxType1());
                                    detl.setSupp(combMat.getSuppCode());
                                    if (!taskDetlService.update(detl, new EntityWrapper<TaskDetl>()
                                            .eq("matnr", detl.getMatnr())
                                            .eq("order_no", detl.getOrderNo())
                                            .eq("supp_code", detl.getSuppCode())
                                            .eq("wrk_no", task.getWrkNo()))) {
                                        throw new CoolException("任务号信息更新失败！！");
                                    }
                                });
                            }
                        }
                    });
                }
            }
            task.setWrkSts(TaskStatusType.AGV_INVENTORY_UPDATED_OUT.type);
            if (!taskService.update(task, new EntityWrapper<Task>().eq("wrk_no", task.getWrkNo()))) {
                throw new CoolException("任务信息更新失败！！");
            }
        }
        return R.ok("呼叫成功！！");
    }


    /**
     * 空板出库任务
     *
     * @param params
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R getEmptyOutStock(AgvCallParams params) {
        if (Objects.isNull(params.getOrgSite())) {
            return R.error("托盘类型不能为空！！");
        }
        if (Objects.isNull(params.getTarSite())) {
            return R.error("目标站点不能为空！！");
        }
        Wrapper<LocMast> wrapper = new EntityWrapper<LocMast>().eq("loc_sts", LocStsType.LOC_STS_TYPE_D.type);
        if (params.getOrgSite().equals(MatLocType.AUTOMATED.type)) {
            wrapper.like("barcode", "LX80");
        } else if (params.getOrgSite().equals(MatLocType.SO_HOLDING.type)) {
            wrapper.like("barcode", "TP80");
        } else {
            wrapper.like("barcode", "TP88");
        }
        wrapper.orderAsc(Arrays.asList("row1", "lev1"));
        LocMast locMast = locMastService.selectOne(wrapper);
        if (Objects.isNull(locMast)) {
            return R.error("没有可用空板！！");
        }

        locMast.setLocSts(LocStsType.LOC_STS_TYPE_R.type);

        if (!locMastService.update(locMast, new EntityWrapper<LocMast>().eq("loc_no", locMast.getLocNo()))) {
            throw new CoolException(locMast.getLocNo() + "出库预约失败！！");
        }

        WrkMast wrkMast1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("source_loc_no", locMast.getLocNo()));
        if (!Objects.isNull(wrkMast1)) {
            throw new CoolException("任务档已生成，请不要重复操作！！");
        }
        int workNo = commonService.getWorkNo(0);
        //TODO 生成并板出库任务
        WrkMast wrkMast = new WrkMast();
        wrkMast.setIoType(104);
        wrkMast.setWrkSts(11L);
        wrkMast.setStaNo(params.getTarSite());
        wrkMast.setSourceLocNo(locMast.getLocNo());
        wrkMast.setBarcode(locMast.getBarcode());
        wrkMast.setIoPri(14.0);
        wrkMast.setAppeTime(new Date());
        wrkMast.setModiTime(new Date());
        wrkMast.setCrnNo(locMast.getCrnNo());
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkDate(new Date());
        wrkMast.setWrkNo(workNo);
        wrkMast.setTaskType("crn");

        if (!wrkMastService.insert(wrkMast)) {
            throw new CoolException("新建任务失败！！");
        }

        return R.ok().add(wrkMast);
    }

    /**
     * 获取出库台车所有信息
     *
     * @param params
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R getTcAllInfos(AgvCallParams params) {
        if (Objects.isNull(params.getCarBarcode())) {
            return R.error("台车码不能为空！！");
        }
//        Task task = taskService.selectOne(new EntityWrapper<Task>().eq("barcode", params.getCarBarcode()));
//        if (Objects.isNull(task)) {
//            throw new CoolException("任务档不存在！！");
//        }
//        if (Objects.isNull(task.getSourceLocNo())) {
//            throw new CoolException("请检查任务类型是否属于出库捆绑！！");
//        }
        LocCache locCache = locCacheService.selectOne(new EntityWrapper<LocCache>().eq("barcode", params.getCarBarcode()));
        if (Objects.isNull(locCache)) {
            return R.error("当前台车不在缓冲库区！！");
        }
        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", locCache.getLocNo()));
        if (!Objects.isNull(locDetls) && !locDetls.isEmpty()) {
            locDetls.forEach(locDetl -> {
                OrderPakout orderPakout = orderPakoutService.selectOne(new EntityWrapper<OrderPakout>()
                        .eq("number", locDetl.getOrderNo()));
                if (!Objects.isNull(orderPakout)) {
                    locDetl.setMemo(orderPakout.getShipCode());
                }
            });
        }

        try {
            Map<String, List<LocDetl>> listMap = locDetls.stream().collect(Collectors.groupingBy(LocDetl::getMemo));
            if (!Cools.isEmpty(params.getShipCode())) {
                List<LocDetl> detlList = listMap.get(params.getShipCode());
                return R.ok().add(detlList);
            }
        } catch (Exception e) {
            log.error(e.getMessage());
        }

        return R.ok().add(locDetls);
//        Map<String, List<LocDetl>> listMap = locDetls.stream().collect(Collectors.groupingBy(LocDetl::getMemo));
//        if (!Objects.isNull(params.getShipCode())) {
//            List<LocDetl> detlList = listMap.get(params.getShipCode());
//            return R.ok().add(detlList);
//        } else {
//            return R.ok().add(locDetls);
//        }
    }

    /**
     * 生成移库任务
     *
     * @param result
@@ -2748,12 +3419,12 @@
        LocCache loc = findAvailableLocByAreaType(LocAreaType.LOC_AREA_TYPE_IN_CACHE);
        if (loc != null) return loc;

        // 2. Try SO Area
        loc = findAvailableLocByAreaType(LocAreaType.LOC_AREA_TYPE_SO);
        if (loc != null) return loc;

        // 3. Try EO Area
        loc = findAvailableLocByAreaType(LocAreaType.LOC_AREA_TYPE_EO);
//        // 2. Try SO Area
//        loc = findAvailableLocByAreaType(LocAreaType.LOC_AREA_TYPE_SO);
//        if (loc != null) return loc;
//
//        // 3. Try EO Area
//        loc = findAvailableLocByAreaType(LocAreaType.LOC_AREA_TYPE_EO);
        return loc;
    }

@@ -2767,9 +3438,7 @@
        }
        return locCacheService.selectOne(new EntityWrapper<LocCache>()
                .eq("area_id", area.getId())
                .eq("frozen", 0)
                .eq("loc_sts", LocStsType.LOC_STS_TYPE_O.type)
                .orderAsc(Arrays.asList("loc_no"))
                .last("OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY"));
                .orderAsc(Arrays.asList("loc_no")));
    }
}