# 并板出库

whycq

2024-07-04 09a482e8fb4d4dac63aed1503fd91e738ddb070d

 src/main/java/com/zy/asrs/controller/MobileController.java

@@ -1,22 +1,25 @@
package com.zy.asrs.controller;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.annotations.ManagerAuth;
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.CombParam;
import com.zy.asrs.entity.param.MobileAdjustParam;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.MobileAdjustResult;
import com.zy.asrs.mapper.ManLocDetlMapper;
import com.zy.asrs.service.*;
import com.zy.common.model.WrkDto;
import com.zy.common.model.enums.WorkNoType;
import com.zy.common.service.CommonService;
import com.zy.common.web.BaseController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;

import java.util.*;

@@ -37,6 +40,8 @@
    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private DocTypeService docTypeService;
    @Autowired
    private WrkMastService wrkMastService;
@@ -46,6 +51,33 @@
    private BasDevpService basDevpService;
    @Autowired
    private PackService packService;
    @Autowired
    private ManLocDetlMapper manLocDetlMapper;
    @Autowired
    private StaDescService staDescService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private MatService matService;
    @Autowired
    private BomMatService bomMatService;

    // 商品上架
    @RequestMapping("/mat/onSale/auth")
    @ManagerAuth
    public R matOnSale(@RequestBody CombParam combParam){
        mobileService.onSale(combParam);
        return R.ok("上架成功");
    }
    // 商品下架
    @RequestMapping("/mat/offSale/auth")
    //@ManagerAuth
    public R matOffSale(@RequestBody OffSaleParam offSaleParam){
        mobileService.offSale(offSaleParam);
        return R.ok("下架成功");
    }



    // 组托 ----------------------------------------------------------------------------------------------------

@@ -74,11 +106,75 @@
        return R.ok().add(orderDetls);
    }

    @RequestMapping("/check/mergeStore/barcode")
    @ManagerAuth
    public R mergeStoreBarcode(@RequestParam String barcode){
        WrkMast wrkMast = wrkMastService.selectByBarcode(barcode);
        if (Cools.isEmpty(wrkMast)) {
            throw new CoolException("当前托盘码" + barcode + "没有任务，请检查！");
        }
        if (wrkMast.getIoType() != 104) {
            throw new CoolException("当前托盘码" + barcode + "非并板出库");
        }
        if (wrkMast.getWrkSts() != 14L) {
            throw new CoolException("当前托盘码" + barcode + "出库未完成");
        }
        WrkDetl wrkDetl = wrkDetlService.selectOne(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
        return R.ok().add(wrkDetl.getBomCode());
    }

    @RequestMapping("/comb/auth")
    @ManagerAuth(memo = "组托")
    public R comb(@RequestBody CombParam combParam){
        mobileService.comb(combParam, getUserId());
        return R.ok("组托成功");
    }

    @RequestMapping("/comb/auth2")
    @ManagerAuth(memo = "组托")
    public R comb2(@RequestBody CombParam combParam){
        mobileService.comb2(combParam, getUserId());
        return R.ok("组托成功");
    }

    @RequestMapping("/merge/comb/auth")
    @ManagerAuth(memo = "组托")
    public R mergeComb(@RequestBody CombParam combParam){
        mobileService.mergeComb(combParam, getUserId());
        return R.ok("组托成功");
    }

    @RequestMapping("/comb/checkBom")
    @ManagerAuth(memo = "校验Bom")
    public R checkBom(@RequestBody CheckBom checkBom){
        BomMat bomMat = new BomMat();
        // 没有输入bom号正常组托
        if (Cools.isEmpty(checkBom.getBomCode())) {
            return R.ok();
        }

        if (Cools.isEmpty(checkBom.getMatnr())) {
            return R.ok().add(bomMat);
        } else {
            // 检查是否在bom清单内
            bomMat = bomMatService.selectOne(new EntityWrapper<BomMat>().eq("bom_num", checkBom.getBomCode()).eq("element_num", checkBom.getMatnr()));
            if (Cools.isEmpty(bomMat)) {
                throw new CoolException("当前物料" + checkBom.getMatnr() + "不在Bom清单内");
            } else {
                // 检查库存中是否有当前bom的物料
                Double bomQyt = locDetlService.getBomQyt(checkBom.getBomCode(), checkBom.getMatnr());
                if (!Cools.isEmpty(bomQyt)) {
                    bomMat.setZpalletAnfme(bomMat.getZpalletAnfme() - bomQyt);
                }
                Double bomQty = wrkDetlService.getBomQty(checkBom.getBomCode(), checkBom.getMatnr());
                if (!Cools.isEmpty(bomQty)) {
                    bomMat.setZpalletAnfme(bomMat.getZpalletAnfme() - bomQty);
                }
                // 检查工作档中是否有当前bom的物料

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

    @RequestMapping("/pack/get/auth")
@@ -97,7 +193,7 @@
    @RequestMapping("/pack/comb/auth")
    @ManagerAuth(memo = "下线组托")
    public R packComb(@RequestBody CombParam combParam){
        mobileService.packComb(combParam, getUserId());
//        mobileService.packComb(combParam, getUserId());
        return R.ok("组托成功");
    }

@@ -141,10 +237,20 @@
        if (wrkMast != null) {
            List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
            // 去除已出库确认的明细
            wrkDetls.removeIf(wrkDetl -> wrkDetl.getInspect() == 1);
            wrkDetls.removeIf(wrkDetl -> wrkDetl.getInspect() != null && wrkDetl.getInspect() != 0);
            return R.ok().add(Cools.add("wrkNo", wrkMast.getWrkNo()).add("ioType", wrkMast.getIoType()).add("list", wrkDetls));
        }
        return R.ok();
    }

    // 根据库位码和商品码搜索商品
    @RequestMapping("/mat/find/auth")
    public R find(@RequestParam(required = false) String locNo
            , @RequestParam(required = false) String matnr){
        //List<ManLocDetl> manLocDetls = manLocDetlMapper.selectItem0(locNo, matnr);
        ManLocDetl manLocDetl = manLocDetlMapper.selectLocNo0(locNo, matnr);
        return R.ok(manLocDetl);
        //return R.ok(manLocDetlMapper.selectItem0(locNo, matnr));
    }

    /**
@@ -197,12 +303,46 @@
        if (Cools.isEmpty(list)) {
            return R.ok();
        }
        // todo:luxiaotao 拣料出库可修改工作档明细
        Set<Integer> wrkNos = new HashSet<>();
        List<WrkDto> dtos = new ArrayList<>();
        for (WrkDetl wrkDetl : list) {
            wrkNos.add(wrkDetl.getWrkNo());
            wrkDetlService.updateInspect(wrkDetl.getWrkNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
            if (wrkNos.contains(wrkDetl.getWrkNo())) {
                for (WrkDto dto : dtos) {
                    if (dto.getWrkNo().equals(wrkDetl.getWrkNo())) {
                        dto.getWrkDetls().add(wrkDetl);
                        break;
                    }
                }
            } else {
                wrkNos.add(wrkDetl.getWrkNo());
                dtos.add(new WrkDto(wrkDetl.getWrkNo(), wrkDetl));
            }
        }

        for (WrkDto dto : dtos) {
            WrkMast wrkMast = wrkMastService.selectById(dto.getWrkNo());
            if (wrkMast != null) {
                // 101
                if (wrkMast.getIoType() == 101) {
                    for (WrkDetl wrkDetl : dto.getWrkDetls()) {
                        wrkDetlService.updateInspect(wrkDetl.getWrkNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
                    }
                }
                // 103
                if (wrkMast.getIoType() == 103) {
                    if (!wrkDetlService.delete(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()))) {
                        throw new CoolException("拣料出库确认失败");
                    }
                    for (WrkDetl wrkDetl : dto.getWrkDetls()) {
                        wrkDetl.setInspect(1);
                        if (!wrkDetlService.insert(wrkDetl)) {
                            throw new CoolException("拣料出库确认失败");
                        }
                    }
                }
            }
        }

        for (Integer wrkNo : wrkNos) {
            WrkMast wrkMast = wrkMastService.selectById(wrkNo);
            if (wrkMast.getWrkSts() == 14 && (Cools.isEmpty(wrkMast.getInvWh()) || wrkMast.getInvWh().equals("N"))) {
@@ -259,5 +399,210 @@
        return R.ok("盘点成功");
    }

    @PostMapping("/order/out/pakout/auth")
    @ManagerAuth(memo = "订单出库")
    public synchronized R pakoutByOrder(@RequestBody JSONObject param) {
        if(!param.containsKey("staNo") || !param.containsKey("orderNo")){
            return R.parse(BaseRes.PARAM);
        }
        mobileService.pakoutByOrder(param,getUserId());
        return R.ok("出库成功");
    }

    //平库pda上架
    @RequestMapping("/manDetl/in")
    public R manDetlAdd(@RequestBody JSONObject json){
        if (json == null){
            return R.error("传入数据为空");
        }
        return mobileService.manDetlIn(json);
    }

    //平库pda下架
    @RequestMapping("/manDetl/out")
    public R manDetlDelete(@RequestBody JSONObject json){
        if (json == null){
            return R.error("传入数据为空");
        }
        return mobileService.manDetlOut(json);
    }

    @RequestMapping("/loc/f/list")
    @ManagerAuth(memo = "获取在库库位")
    public R locNoF(@RequestParam(required = false) String locNo){
        Wrapper<LocMast> wrapper = new EntityWrapper<LocMast>().eq("loc_sts", "F");
        if (!Cools.isEmpty(locNo)) {
            wrapper.like("loc_no", locNo);
        }
        List<LocMast> list = locMastService.selectList(wrapper);
        return R.ok().add(list);
    }

    @RequestMapping("/pick/sta/list")
    @ManagerAuth(memo = "获取并板站")
    public R pickSta(){
        List<StaDesc> list = staDescService.selectList(new EntityWrapper<StaDesc>().eq("type_no",104));
        return R.ok().add(list);
    }

    @RequestMapping("/pick/mat/list")
    @ManagerAuth(memo = "获取并板物料")
    public R pickMats(@RequestParam(required = false) String matnr){
        List<DocType> docTypes = docTypeService.selectList(new EntityWrapper<DocType>().like("doc_name", "入库"));
        ArrayList<Long> typeList = new ArrayList<>();
        for (DocType docType : docTypes) {
            typeList.add(docType.getDocId());
        }

        EntityWrapper<Order> wrapper = new EntityWrapper<>();
        wrapper.eq("status", 1);
        wrapper.in("doc_type", typeList);
        List<Order> orders = orderService.selectList(wrapper);

        ArrayList<Long> orderIds = new ArrayList<>();
        for (Order order : orders) {
            orderIds.add(order.getId());
        }

        //搜索明细
        Wrapper<OrderDetl> wrapper1 = new EntityWrapper<OrderDetl>();
        wrapper1.eq("status", 1);
        wrapper1.in("order_id", orderIds);
        if (!Cools.isEmpty(matnr)) {
            wrapper1.like("matnr", matnr);
        }

        List<OrderDetl> list = orderDetlService.selectList(wrapper1);

        ArrayList<PickMatParam> maps = new ArrayList<>();
        for (OrderDetl orderDetl : list) {
            //剩余可用数量
            double count = orderDetl.getAnfme() - orderDetl.getWorkQty();
            if (count <= 0) {
                continue;
            }

            PickMatParam matParam = new PickMatParam();
            matParam.setMatnr(orderDetl.getMatnr());
            matParam.setBatch(orderDetl.getBatch());
            matParam.setOrderNo(orderDetl.getOrderNo());
            matParam.setOrderId(orderDetl.getOrderId());
            matParam.setCount(count);
            matParam.setUseCount(0D);
            maps.add(matParam);
        }
        return R.ok().add(maps);
    }

    @RequestMapping("/pick/in")
    @ManagerAuth(memo = "并板入库")
    @Transactional
    public R pickConfirm(@RequestBody PickConfirmParam param){
        LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", param.getLocNo()));
        if (!locMast.getLocSts().equals("F")) {
            return R.error("库位状态不是在库");
        }

        StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                .eq("type_no", 104)
                .eq("stn_no", param.getStaNo()));
        if (staDesc == null) {
            return R.error("站点不存在");
        }

        //检验传参是否和订单明细匹配
        for (PickMatParam matParam : param.getList()) {
            Wrapper<OrderDetl> wrapper = new EntityWrapper<OrderDetl>()
                    .eq("order_no", matParam.getOrderNo())
                    .eq("status", 1)
                    .eq("matnr", matParam.getMatnr());
            if (!Cools.isEmpty(matParam.getBatch())) {
                wrapper.eq("batch", matParam.getBatch());
            }
            OrderDetl orderDetl = orderDetlService.selectOne(wrapper);
            if (orderDetl == null) {
                return R.error("物料数据不存在");
            }

            //剩余可用数量
            double count = orderDetl.getAnfme() - orderDetl.getWorkQty();
            if (matParam.getCount() != count) {
                return R.error("物料数据已过期");
            }

            if (matParam.getUseCount() > count) {
                return R.error("可用数量不足");
            }
        }

        Date now = new Date();
        // 生成工作号
        int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(104));
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(101L); // 工作状态：101.生成出库
        wrkMast.setIoType(104); // 入出库状态
        wrkMast.setIoPri(13D); // 优先级：13
        wrkMast.setSourceStaNo(staDesc.getCrnStn()); // 源站
        wrkMast.setStaNo(staDesc.getStnNo()); // 目标站
        wrkMast.setSourceLocNo(param.getLocNo()); // 源库位
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("Y"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setBarcode(locMast.getBarcode());
        wrkMast.setAppeUser(getUserId()); // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(getUserId());
        wrkMast.setModiTime(now);
        wrkMast.setCrnNo(staDesc.getCrnNo());
        if (!wrkMastService.insert(wrkMast)) {
            throw new CoolException("保存工作档失败，出库库位号：" + param.getLocNo());
        }
        // 生成工作档明细
        for (PickMatParam matParam : param.getList()) {
            EntityWrapper<Mat> wrapper = new EntityWrapper<>();
            wrapper.eq("status", 1);
            wrapper.eq("matnr", matParam.getMatnr());
            Mat mat = matService.selectOne(wrapper);
            if (mat == null) {
                throw new CoolException("保存工作档失败，物料信息不存在：" + matParam.getMatnr());
            }

            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(mat);
            wrkDetl.setOrderNo(matParam.getOrderNo());
            wrkDetl.setWrkNo(workNo);
            wrkDetl.setZpallet(wrkMast.getBarcode());
            wrkDetl.setIoTime(now);
            wrkDetl.setAnfme(matParam.getUseCount()); // 数量
            wrkDetl.setAppeTime(now);
            wrkDetl.setAppeUser(getUserId());
            wrkDetl.setModiTime(now);
            wrkDetl.setModiUser(getUserId());
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作档明细失败");
            }

            //更新订单工作数量
            orderDetlService.increaseWorkQtyByOrderNo(matParam.getOrderNo(), matParam.getMatnr(), matParam.getBatch(), matParam.getUseCount());
        }
        // 修改库位状态:   F.在库 ====>>> R.出库预约/P.拣料/盘点/并板出库中
        locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", param.getLocNo()));
        if (locMast.getLocSts().equals("F")) {
            locMast.setLocSts("P");
            locMast.setModiUser(getUserId());
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)) {
                throw new CoolException("预约库位状态失败，库位号：" + param.getLocNo());
            }
        } else {
            throw new CoolException(param.getLocNo() + "库位不是在库状态");
        }

        return R.ok();
    }

}