流程更改

pang.jiabao

4 天以前 b6e0bec71de45cad64e9de14977770053be7e010

 src/main/java/com/zy/common/web/WcsController.java

@@ -2,26 +2,30 @@

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.BaseRes;
import com.core.common.Cools;
import com.core.common.R;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.EmptyPlateOutParam;
import com.zy.asrs.entity.result.FindLocNoAttributeVo;
import com.zy.asrs.mapper.LocMastMapper;
import com.zy.asrs.service.*;
import com.zy.common.CodeRes;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.StartupDto;
import com.zy.common.service.CommonService;
import com.zy.common.web.param.CanningLineInLocParam;
import com.zy.common.web.param.SearchLocParam;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import java.util.*;

/**
 * Created by vincent on 2020/10/30
@@ -50,8 +54,18 @@
    @Autowired
    private WorkService workService;

    @Resource
    private LocMastMapper locMastMapper;

    @Resource
    private MatService matService;

    @Resource
    private ConfigService configService;

    @PostMapping("/pakin/loc/v1")
    @ResponseBody
    @Transactional
    public synchronized R getLocNo(@RequestBody SearchLocParam param) {
        log.info("收到WCS入库接口请求====>>入参:{}", param);
        if (Cools.isEmpty(param.getIoType())) {
@@ -60,24 +74,10 @@
        if (Cools.isEmpty(param.getSourceStaNo())) {
            return R.error("源站编号不能为空");
        }
        List<WaitPakin> waitPakins = null;
        WaitPakin waitPakin = null;
        if (param.getIoType() == 1) {
            if (Cools.isEmpty(param.getBarcode())) {
                return R.error("条码不能为空");
            }
            waitPakins = waitPakinService.selectList(new EntityWrapper<WaitPakin>().eq("zpallet", param.getBarcode()));
            if (Cools.isEmpty(waitPakins)) {
                WrkMast wrkMast = wrkMastService.selectByBarcode(param.getBarcode());
                if (wrkMast != null && wrkMast.getIoType() == 103) {
                    return R.parse(CodeRes.PICK_600);
                }
                return R.parse(CodeRes.NO_COMB_700);
            }
            int countLoc = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet",param.getBarcode()));
            int countWrk = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("zpallet",param.getBarcode()));
            if (countLoc > 0 || countWrk > 0) {
                return R.error(CodeRes.EXIST_500);
            }
            // 先创建入库通知档
            waitPakin = comb(param.getBarcode(),param.getBucketType(),param.getBucketCount());
        }
        if (Cools.isEmpty(param.getLocType1())){
            return R.error("高低检测信号不能为空");
@@ -89,19 +89,473 @@
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);

        StartupDto dto = null;

        if(param.getIoType() == 1) {
            List<SearchLocParam.WantBucket> wantBucketFlag = param.getWantBucketFlag();
            for(SearchLocParam.WantBucket wantBucket: wantBucketFlag) {
                if(wantBucket.getBucketType() != 0 && wantBucket.getBucketType() == param.getBucketType()) { // 罐装线有要桶信号并且当前桶是罐装线要的桶
                    if(waitPakin == null) {
                        return R.error("入库通知档为空");
                    } else {
                        int count = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("wrk_sts", 2).eq("sta_no", wantBucket.getSite()));
                        if(wantBucket.getSite() == 1071 && count < 12 || wantBucket.getSite() == 1064 && count < 10 || wantBucket.getSite() == 1078 && count < 12) {
                            dto = startupFullPutStore(param,waitPakin,wantBucket); // 直供罐装线任务
                            if (dto != null) {
                                log.info("WCS入库直供罐装线接口返参:{},托盘码:{}", dto, param.getBarcode());
                                return R.ok().add(dto);
                            }
                        } else {
                            log.warn("直供灌装线任务已满，入成品库,入库目标站点{}，任务数：{}",wantBucket.getSite(),count);
                        }
                    }
                }
            }
        }
        // 1.母托盘，2子托盘
        int flag = 0;
        if(param.getIoType() == 10) {
            flag = param.getBucketType() == 21 ? 1 : 2 ;
        }

        switch (param.getIoType()) {
            case 1://满托盘入库
                assert waitPakins != null;
                dto = startupFullPutStore(param.getSourceStaNo(), param.getBarcode(), locTypeDto, waitPakins);
                assert waitPakin != null;
                dto = startupFullPutStore(param.getSourceStaNo(), param.getBarcode(), locTypeDto, waitPakin, param.isTailSupportFlag());
                break;
            case 10://空托盘入库
                dto = emptyPlateIn(param.getSourceStaNo(), locTypeDto, param.getBarcode());
                dto = emptyPlateIn(param.getSourceStaNo(), locTypeDto, param.getBarcode(), 1, flag);
                break;
            default:
                break;
        }
        log.info("WCS入库接口返参:{},托盘码:{}", dto, param.getBarcode());
        return R.ok().add(dto);
    }

    // 罐装完成入库
    @PostMapping("/pakin/CanningLine/loc/v1")
    @ResponseBody
    @Transactional
    public synchronized R inCanningLine(@RequestBody CanningLineInLocParam param) {
        log.info("收到WCS罐装入库接口请求====>>入参:{}", param);
        if (Cools.isEmpty(param.getWrkNo())) {
            return R.error("工作号不能为空");
        }
        if (Cools.isEmpty(param.getSourceStaNo())) {
            return R.error("源站编号不能为空");
        }

        // 根据任务号查询任务
        WrkMast wrkMast1 = wrkMastService.selectById(param.getWrkNo());
        // 根据任务号查询任务明细
        WrkDetl wrkDetl1 = wrkDetlService.selectOne(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast1.getWrkNo()));

        Mat mat = matService.selectByMatnr(param.getMatnr());
        if (mat == null) {
            log.error("罐装完成入库，反馈给wcs成品标识不存在：{}",param.getMatnr());
            return R.error("罐装完成入库，反馈给wcs成品标识不存在：" + param.getMatnr());
        }

        // 获取系统配置，看成品罐装完成是否直接出到发货口
        Config config = configService.selectConfigByCode("gzwcfh");
        boolean fhFlag = false;
        if (config != null && config.getStatus() == 1 && !Cools.isEmpty(config.getValue())) {
            String[] split = config.getValue().split("=");
            for(String item : split) {
                if(param.getMatnr().equals(item)) {
                    fhFlag = true;
                    break;
                }
            }
        }

        Date now = new Date();
        StartupDto dto;

        // 判断贴标异常，复检重量异常的，不分配库位，去往异常口1090
//        if ( !param.isTbFlag() || param.getGrossWeight() < param.getWeight()) {
//
//            // 生成工作档 ------------------------------------------------------
//            WrkMast wrkMast = new WrkMast();
//            wrkMast.setWrkNo(commonService.getWorkNo(0));
//            wrkMast.setIoTime(now);
//            wrkMast.setIoType(3); // 入出库类型3.站到站
//            wrkMast.setWrkSts(2L);
//            wrkMast.setIoPri(13D); // 优先级
////            wrkMast.setCrnNo(dto.getCrnNo());
//            wrkMast.setSourceStaNo(param.getSourceStaNo());
//            wrkMast.setStaNo(1090);
////            wrkMast.setLocNo(dto.getLocNo());
//            wrkMast.setBarcode(wrkMast1.getBarcode()); // 托盘码
//            wrkMast.setFullPlt("Y"); // 满板：Y
////            wrkMast.setPicking("N"); // 拣料
////            wrkMast.setExitMk("N"); // 退出
////            wrkMast.setEmptyMk("N"); // 空板
////            wrkMast.setLinkMis("Y");
////            wrkMast.setCtnType(wrkMast1.getCtnType()); // 尾托标识
//            wrkMast.setPdcType(wrkMast1.getPdcType()); // 空桶类型
//            wrkMast.setAppeTime(now);
//            wrkMastService.insert(wrkMast);
//
//            // 生成工作档明细----------------------------------------------------
//            WrkDetl wrkDetl = new WrkDetl();
//            wrkDetl.sync(mat);
//            wrkDetl.setWrkNo(wrkMast.getWrkNo());
//            wrkDetl.setAnfme(wrkDetl1.getAnfme());
//            wrkDetl.setZpallet(wrkMast1.getBarcode());
//            wrkDetl.setBatch(param.getBatch());
//            wrkDetl.setManuDate(param.getManuDate());
//            wrkDetl.setWeight(param.getWeight());
//            wrkDetl.setManLength(param.getGrossWeight());
//            wrkDetl.setInspect(1); // 贴标成功
//            wrkDetl.setIoTime(now);
//            wrkDetl.setAppeTime(now);
//            wrkDetlService.insert(wrkDetl);
//
//            dto = new StartupDto();
//            dto.setWorkNo(wrkMast.getWrkNo());
//            dto.setSourceStaNo(wrkMast.getSourceStaNo());
//            dto.setStaNo(wrkMast.getStaNo());
//        } else
        if(fhFlag) { // 直接发货
            // 生成工作档 ------------------------------------------------------
            WrkMast wrkMast = new WrkMast();
            wrkMast.setWrkNo(commonService.getWorkNo(0));
            wrkMast.setIoTime(now);
            wrkMast.setIoType(3); // 入出库类型3.站到站
            wrkMast.setWrkSts(2L);
            wrkMast.setIoPri(13D); // 优先级
//            wrkMast.setCrnNo(dto.getCrnNo());
            wrkMast.setSourceStaNo(param.getSourceStaNo());
            wrkMast.setStaNo(1016);
//            wrkMast.setLocNo(dto.getLocNo());
            wrkMast.setBarcode(wrkMast1.getBarcode()); // 托盘码
            wrkMast.setFullPlt("Y"); // 满板：Y
//            wrkMast.setPicking("N"); // 拣料
//            wrkMast.setExitMk("N"); // 退出
//            wrkMast.setEmptyMk("N"); // 空板
//            wrkMast.setLinkMis("Y");
//            wrkMast.setCtnType(wrkMast1.getCtnType()); // 尾托标识
            wrkMast.setPdcType(wrkMast1.getPdcType()); // 空桶类型
            wrkMast.setAppeTime(now);
            wrkMastService.insert(wrkMast);

            // 生成工作档明细----------------------------------------------------
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(mat);
            wrkDetl.setWrkNo(wrkMast.getWrkNo());
            wrkDetl.setAnfme(wrkDetl1.getAnfme());
            wrkDetl.setZpallet(wrkMast1.getBarcode());
            wrkDetl.setBatch(param.getBatch());
            wrkDetl.setManuDate(param.getManuDate());
            wrkDetl.setWeight(param.getWeight());
            wrkDetl.setManLength(param.getGrossWeight());
            wrkDetl.setInspect(1);
            wrkDetl.setIoTime(now);
            wrkDetl.setAppeTime(now);
            wrkDetlService.insert(wrkDetl);

            dto = new StartupDto();
            dto.setWorkNo(wrkMast.getWrkNo());
            dto.setSourceStaNo(wrkMast.getSourceStaNo());
            dto.setStaNo(wrkMast.getStaNo());
        } else  { // 检测成功，入成品库
                // 检索库位条件
                FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();
                findLocNoAttributeVo.setMatnr(wrkDetl1.getMatnr());
                findLocNoAttributeVo.setModel(wrkDetl1.getModel());

                // 分配库位
                dto = commonService.getLocNoNew(1, param.getSourceStaNo(), findLocNoAttributeVo, 1);

                // 创建新任务
                int workNo = dto.getWorkNo();
                // 生成工作档
                WrkMast wrkMast = new WrkMast();
                wrkMast.setWrkNo(workNo);
                wrkMast.setIoTime(now);
                wrkMast.setWrkSts(2L); // 工作状态：生成入库ID
                wrkMast.setIoType(1); // 入出库状态：1.入库
                wrkMast.setIoPri(13D); // 优先级
                wrkMast.setCrnNo(dto.getCrnNo());
                wrkMast.setSourceStaNo(dto.getSourceStaNo());
                wrkMast.setStaNo(dto.getStaNo());
                wrkMast.setLocNo(dto.getLocNo());
                wrkMast.setBarcode(wrkMast1.getBarcode()); // 托盘码
                wrkMast.setFullPlt("Y"); // 满板：Y
                wrkMast.setPicking("N"); // 拣料
                wrkMast.setExitMk("N"); // 退出
                wrkMast.setEmptyMk("N"); // 空板
                wrkMast.setLinkMis("Y");
//            wrkMast.setCtnType(wrkMast1.getCtnType()); // 尾托标识
                wrkMast.setPdcType(wrkMast1.getPdcType()); // 空桶类型
                wrkMast.setAppeTime(now);
                wrkMastService.insert(wrkMast);

                // 生成工作档明细
                WrkDetl wrkDetl = new WrkDetl();
                wrkDetl.sync(mat);
                wrkDetl.setWrkNo(workNo);
                wrkDetl.setAnfme(wrkDetl1.getAnfme());
                wrkDetl.setZpallet(wrkMast1.getBarcode());
                wrkDetl.setBatch(param.getBatch());
                wrkDetl.setManuDate(param.getManuDate());
                wrkDetl.setWeight(param.getWeight());
                wrkDetl.setManLength(param.getGrossWeight());
                wrkDetl.setInspect(1); // 贴标成功
                wrkDetl.setIoTime(now);
                wrkDetl.setAppeTime(now);
                wrkDetlService.insert(wrkDetl);

                // 更新目标库位状态
                LocMast locMast = locMastService.selectById(dto.getLocNo());
                if (locMast.getLocSts().equals("O")) {
                    locMast.setLocSts("S"); // S.入库预约
                    locMast.setModiTime(now);
                    if (!locMastService.updateById(locMast)) {
                        throw new CoolException("改变库位状态失败");
                    }
                } else {
                    log.error(dto.getLocNo() + "目标库位已被占用");
                    throw new CoolException(dto.getLocNo() + "目标库位已被占用");
                }
            }

        // 完成旧任务(直供罐装线任务手动完成)
        if (wrkMast1.getIoType() == 3 && wrkMast1.getWrkSts() == 2) {
            wrkMast1.setWrkSts(5L);
            wrkMast1.setModiTime(now);
            wrkMastService.updateById(wrkMast1);
        } else if(wrkMast1.getIoType() == 101 && wrkMast1.getWrkSts() == 2) {
            wrkMast1.setWrkSts(15L);
            wrkMast1.setModiTime(now);
            wrkMastService.updateById(wrkMast1);
        } else {
            log.error("罐装完成，完成旧任务失败：{}",wrkMast1.getWrkNo());
            return R.parse("罐装完成，完成旧任务失败:"+wrkMast1.getWrkNo());
        }

        // 更新源站点信息
        BasDevp basDevp = basDevpService.selectById(param.getSourceStaNo());
        basDevp.setWrkNo(dto.getWorkNo());
        basDevp.setModiTime(now);
        if (!basDevpService.updateById(basDevp)) {
            throw new CoolException("更新源站失败");
        }

        log.info("WCS罐装入库接口返参:{},托盘码:{}", dto, wrkMast1.getBarcode());
        return R.ok(dto);
    }

    // 异常口入库，获取库位
    @PostMapping("/pakin/abnormalMouthWarehousing/loc/v1")
    @ResponseBody
    @Transactional
    public synchronized R abnormalMouthWarehousing(@RequestBody CanningLineInLocParam param) {
        log.info("收到WCS异常口入库接口请求====>>入参:{}", param);
        int wrkNo = param.getWrkNo();
        Integer sourceStaNo = param.getSourceStaNo();
        if (Cools.isEmpty(wrkNo)) {
            return R.error("工作号不能为空");
        }
        if (Cools.isEmpty(sourceStaNo)) {
            return R.error("源站编号不能为空");
        }

        Date now = new Date();
        StartupDto dto;

        WrkMast wrkMast = wrkMastService.selectById(wrkNo);
        if (wrkMast == null) {
            throw new CoolException("异常口入库任务号无任务：" + wrkNo);
        } else if (wrkMast.getLocNo() != null) {
            throw new CoolException("异常口入库库位已分配：" + wrkMast.getLocNo());
        }

        if(!param.isTbFlag()) { //下线出库
            wrkMast.setSourceStaNo(1090);
            wrkMast.setStaNo(1016); // 异常下线默认入库站点为1016
            wrkMastService.updateById(wrkMast);
            return R.ok();
        }


        WrkDetl wrkDetl = wrkDetlService.selectOne(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkNo));

        // 检索库位条件
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();
        findLocNoAttributeVo.setMatnr(wrkDetl.getMatnr());
        findLocNoAttributeVo.setModel(wrkDetl.getModel());

        // 分配库位
        dto = commonService.getLocNoNew(1, param.getSourceStaNo(), findLocNoAttributeVo, 1);

        dto.setWorkNo(wrkMast.getWrkNo()); // 使用原工作号
        wrkMast.setIoType(1); // 入出库类型 1.入库
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setLocNo(dto.getLocNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
        wrkMastService.updateById(wrkMast);

        // 更新目标库位状态
        LocMast locMast = locMastService.selectById(dto.getLocNo());
        if (locMast.getLocSts().equals("O")) {
            locMast.setLocSts("S"); // S.入库预约
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)) {
                throw new CoolException("改变库位状态失败");
            }
        } else {
            log.error(dto.getLocNo() + "目标库位已被占用");
            throw new CoolException(dto.getLocNo() + "目标库位已被占用");
        }

        // 更新源站点信息
        BasDevp basDevp = basDevpService.selectById(sourceStaNo);
        basDevp.setWrkNo(dto.getWorkNo());
        basDevp.setModiTime(now);
        if (!basDevpService.updateById(basDevp)) {
            throw new CoolException("更新源站失败");
        }

        log.info("WCS异常口入库接口返参:{},托盘码:{}", dto, wrkMast.getBarcode());
        return R.ok(dto);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public WaitPakin comb(String barcode, int matnr,int bucketCount) {
        if (Cools.isEmpty(barcode, matnr,bucketCount)) {
            throw new CoolException(BaseRes.PARAM);
        }

        // 判断是否有相同条码的数据
        if (waitPakinService.selectCount(new EntityWrapper<WaitPakin>().
                eq("zpallet", barcode).eq("io_status", "N")) > 0) {
            throw new CoolException(barcode + "数据正在进行入库");
        }

        if(barcode.length()!=8){
            throw new CoolException("条码长度不是8位===>>" + barcode);
        }

        int countLoc = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet",barcode));
        int countWrk = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("zpallet",barcode));
        int countwait = waitPakinService.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet",barcode));
        if (countLoc > 0 || countWrk > 0 || countwait > 0) {
            throw new CoolException("组托档/工作档/库存条码数据已存在===>>" + barcode);
        }

        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());
//                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(String.valueOf(matnr));
                if (Cools.isEmpty(mat)) {
                    throw new CoolException(matnr + "商品档案不存在");
                }
//                // 判断空桶类型
//                Config config = configService.selectConfigByCode("EmptyBucketType");
//                if (config == null) {
//                    log.info("配置入库空桶类型为空");
//                    throw new CoolException("配置入库空桶类型为空");
//                }
//                String[] split = config.getValue().split("=");
//                String bucketType = split[0];
//                Integer sum = Integer.valueOf(split[1]);
//                int count = bucketType.equals("IBC") ? 1 : 4;
                WaitPakin waitPakin = new WaitPakin();
                waitPakin.sync(mat);
//                waitPakin.setBatch(detlDto.getBatch());
                waitPakin.setZpallet(barcode);   // 托盘码
                waitPakin.setIoStatus("N");     // 入出状态
                waitPakin.setAnfme((double) bucketCount);  // 数量
                waitPakin.setStatus("Y");    // 状态
                waitPakin.setAppeUser(29L);
                waitPakin.setAppeTime(now);
                waitPakin.setModiUser(29L);
                waitPakin.setModiTime(now);
                if (!waitPakinService.insert(waitPakin)) {
                    throw new CoolException("保存入库通知档失败");
                }
                return waitPakin;
//            }
            // 关联组托
//        } else {
////            Order order = orderService.selectByNo(param.getOrderNo());
//            Order order = OrderInAndOutUtil.selectByNo(Boolean.TRUE, param.getOrderNo());
//            if (Cools.isEmpty(order) || order.getSettle() > 2) {
//                throw new CoolException("单据编号已过期");
//            }
//            // 生成入库通知档
//            List<DetlDto> detlDtos = new ArrayList<>();
//            param.getCombMats().forEach(elem -> {
//
//                // 订单明细数量校验
////                OrderDetl orderDetl = orderDetlService.selectItem(order.getId(), elem.getMatnr(), elem.getBatch());
//                OrderDetl orderDetl = OrderInAndOutUtil.selectItem(Boolean.TRUE, order.getId(), elem.getMatnr(), elem.getBatch(),elem.getBrand(),elem.getStandby1(),elem.getStandby2(),elem.getStandby3(),
//                        elem.getBoxType1(),elem.getBoxType2(),elem.getBoxType3());
//                if (elem.getAnfme() > orderDetl.getEnableQty()) {
//                    throw new CoolException(orderDetl.getMatnr() + "入库数量不合法");
//                }
//                // 修改订单作业数量
////                if (!orderDetlService.increaseWorkQty(order.getId(), elem.getMatnr(), elem.getBatch(), elem.getAnfme())) {
////                    throw new CoolException("修改单据作业数量失败");
////                }
//                OrderInAndOutUtil.increaseWorkQty(Boolean.TRUE,order.getId(), elem.getMatnr(), elem.getBatch(),elem.getBrand(),elem.getStandby1(),elem.getStandby2(),elem.getStandby3(),
//                        elem.getBoxType1(),elem.getBoxType2(),elem.getBoxType3(), elem.getAnfme());
//                DetlDto detlDto = new DetlDto(elem.getMatnr(), elem.getBatch(),elem.getBrand(),elem.getStandby1(),elem.getStandby2(),elem.getStandby3(),
//                        elem.getBoxType1(),elem.getBoxType2(),elem.getBoxType3(),  elem.getAnfme());
//                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() + "商品档案不存在");
//                }
//                WaitPakin waitPakin = new WaitPakin();
//                waitPakin.sync(mat);
//                waitPakin.setOrderNo(order.getOrderNo());   // 单据编号
//                waitPakin.setBatch(detlDto.getBatch());     // 序列码
//                waitPakin.setZpallet(param.getBarcode());   // 托盘码
//                waitPakin.setIoStatus("N");     // 入出状态
//                waitPakin.setAnfme(detlDto.getAnfme());  // 数量
//                waitPakin.setStatus("Y");    // 状态
//                waitPakin.setAppeUser(userId);
//                waitPakin.setAppeTime(now);
//                waitPakin.setModiUser(userId);
//                waitPakin.setModiTime(now);
//                if (!waitPakinService.insert(waitPakin)) {
//                    throw new CoolException("保存入库通知档失败");
//                }
//            }
////            orderService.updateSettle(order.getId(), 2L, userId);
//            OrderInAndOutUtil.updateOrder(Boolean.TRUE,order.getId(), 2L, userId);
//        }

    }

    @PostMapping("/auto/emptyIn/v1")
@@ -111,7 +565,9 @@
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(12, true);

        // 检索库位
        StartupDto dto = commonService.getLocNo(rowLastnoService.selectNextWhsType(), 10, 12, null,null,null, locTypeDto,0);
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();

        StartupDto dto = commonService.getLocNo( 10, 12, findLocNoAttributeVo, locTypeDto);
        Date now = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
@@ -139,15 +595,31 @@

    @PostMapping("auto/emptyOut/v1")
    @ResponseBody
    public R autoEmptyOut(){
        LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                .eq("loc_sts", "D"));
        if (Cools.isEmpty(locMast)) {
            return R.error("库存没有空板");
    public R autoEmptyOut(@RequestBody Map<String,String> emptyPalletSite){
        // 空托盘类型
        String type = emptyPalletSite.get("flag");
        // 出库站点
        Integer site = Integer.valueOf(emptyPalletSite.get("site"));

        LocMast locMast;

        // 先找浅库位
        locMast = locMastMapper.queryLocMasterByLocStsAndRow(Arrays.asList(2, 3), type);

        // 浅库位没有则查询所有
        if (locMast == null) {
            locMast = locMastMapper.queryLocMasterByLocStsAndRow(null, type);
        }

        if (locMast == null) {
            return R.error("库存没有"+type+"类型空托盘");
        }

        String locNo = locMast.getLocNo();

        EmptyPlateOutParam emptyPlateOutParam = new EmptyPlateOutParam();
        emptyPlateOutParam.setOutSite(12);
        emptyPlateOutParam.setLocNos(new ArrayList<String>(){{add(locMast.getLocNo()+"");}});
        emptyPlateOutParam.setOutSite(site);
        emptyPlateOutParam.setLocNos(new ArrayList<String>(){{add(locNo);}});
        WrkMast wrkMast = workService.emptyPlateOut(emptyPlateOutParam);
        return R.ok(!Cools.isEmpty(wrkMast)? R.ok("自动空托出库成功,工作号:" + wrkMast.getWrkNo()) : R.error("生成自动空托出库失败"));
    }
@@ -155,13 +627,13 @@
    /**
     * 全板入库
     */
    @Transactional
    public StartupDto startupFullPutStore(Integer devpNo, String barcode, LocTypeDto locTypeDto, List<WaitPakin> waitPakins) {
    @Transactional(propagation = Propagation.REQUIRED)
    public StartupDto startupFullPutStore(Integer devpNo, String barcode, LocTypeDto locTypeDto, WaitPakin waitPakins,boolean tailSupportFlag) {
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        List<String> matNos = waitPakins.stream().map(WaitPakin::getMatnr).distinct().collect(Collectors.toList());
        StartupDto dto = commonService.getLocNo(1, 1, devpNo, matNos.get(0),null,null, locTypeDto,0);
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo(waitPakins);
        StartupDto dto = commonService.getLocNoNew( 1, devpNo,findLocNoAttributeVo,waitPakins.getModel().equals("空托盘") ? 1 : 2);
        int workNo = dto.getWorkNo();
        Date now = new Date();
        // 生成工作档
@@ -181,7 +653,8 @@
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("Y");
        wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
        wrkMast.setCtnType(tailSupportFlag ? 1 : 0); // 尾托标识
        wrkMast.setPdcType(waitPakins.getMatnr()); // 空桶类型
        // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
@@ -190,9 +663,8 @@
            throw new CoolException("保存工作档失败");
        }
        // 生成工作档明细
        waitPakins.forEach(waitPakin -> {
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(waitPakin);
            wrkDetl.sync(waitPakins);
            wrkDetl.setWrkNo(wrkMast.getWrkNo());
            wrkDetl.setIoTime(wrkMast.getIoTime());
            wrkDetl.setAppeTime(now);
@@ -200,7 +672,6 @@
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作明细失败");
            }
        });
        // 更新入库通知档 ioStatus ===>> Y
        Wrapper<WaitPakin> wrapper = new EntityWrapper<WaitPakin>()
                .eq("zpallet", barcode);
@@ -231,12 +702,90 @@
        return dto;
    }

    /**
     * 直供罐装线
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public StartupDto startupFullPutStore(SearchLocParam param,WaitPakin waitPakin,SearchLocParam.WantBucket wantBucket) {

        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(param.getSourceStaNo(), true);

//        // 判断空桶库有多少这种桶型
//        int count = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("matnr", param.getBucketType()).where("CAST(SUBSTRING(loc_no, 1, 2) as int) >= 9"));
//
//        // 小于10个则直供罐装线，避免入空桶库后在出库
//        if (count > 10) {
//             return null;
//        }

        StartupDto dto = commonService.getLocNo(param,wantBucket.getSite());
        int workNo = dto.getWorkNo();
        Date now = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(2L);
        wrkMast.setIoType(3); // 入出库状态：3.站到站
        wrkMast.setIoPri(13D); // 优先级
//        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
//        wrkMast.setLocNo(dto.getLocNo());
        wrkMast.setBarcode(param.getBarcode()); // 托盘码
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("Y");
        wrkMast.setCtnType(param.isTailSupportFlag() ? 1 : 0); // 尾托标识
        wrkMast.setPdcType(waitPakin.getMatnr()); // 空桶类型
        // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
        }
        // 生成工作档明细
        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("保存工作明细失败");
        }
        // 更新入库通知档 ioStatus ===>> Y
        Wrapper<WaitPakin> wrapper = new EntityWrapper<WaitPakin>()
                .eq("zpallet", param.getBarcode());
        WaitPakin setParam = new WaitPakin();
        setParam.setLocNo(dto.getLocNo());
        setParam.setIoStatus("Y");
        setParam.setModiTime(now);
        if (!waitPakinService.update(setParam, wrapper)) {
            throw new CoolException("更新通知档失败");
        }
        // 更新源站点信息
        sourceStaNo.setWrkNo(workNo);
        sourceStaNo.setModiTime(now);
        if (!basDevpService.updateById(sourceStaNo)){
            throw new CoolException("更新源站失败");
        }

        return dto;
    }

    @Transactional
    public StartupDto emptyPlateIn(Integer devpNo, LocTypeDto locTypeDto, String barcode) {
    public StartupDto emptyPlateIn(Integer devpNo, LocTypeDto locTypeDto, String barcode, int locArea, int flag) {
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        StartupDto dto = commonService.getLocNo(1, 10, devpNo, null,null,null, locTypeDto,0);
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();

        StartupDto dto = commonService.getLocNoNew( 10, devpNo, findLocNoAttributeVo, locArea);
        int workNo = dto.getWorkNo();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
@@ -254,8 +803,9 @@
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("Y"); // 空板
        wrkMast.setLinkMis("Y");
        wrkMast.setBarcode(barcode);
        wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
        wrkMast.setPltType(flag); // 空拖类型
//        wrkMast.setBarcode(barcode);
//        wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
        // 操作人员数据
        wrkMast.setAppeTime(new Date());
        wrkMast.setModiTime(new Date());