blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
skyouc
2025-01-15 cc6dae7468506691bfb23ca81be5e14045771bce 
 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/service/impl/MobileServiceImpl.java


@@ -1,21 +1,22 @@


package com.zy.asrs.wms.asrs.service.impl;







import com.baomidou.mybatisplus.core.conditions.Wrapper;



import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;



import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;



import com.baomidou.mybatisplus.core.metadata.IPage;



import com.zy.asrs.framework.common.R;



import com.zy.asrs.framework.exception.CoolException;



import com.zy.asrs.wms.asrs.entity.*;



import com.zy.asrs.wms.asrs.entity.dto.PickSheetDetlDto;



import com.zy.asrs.wms.asrs.entity.dto.ShippingOrderDetlDto;



import com.zy.asrs.wms.asrs.entity.enums.*;



import com.zy.asrs.wms.asrs.entity.enums.OrderType;



import com.zy.asrs.wms.asrs.entity.param.BatchMergeOrdersParam;



import com.zy.asrs.wms.asrs.entity.param.GeneratePakInParam;



import com.zy.asrs.wms.asrs.entity.param.PageRequest;



import com.zy.asrs.wms.asrs.entity.param.PakinOnShelvesParams;



import com.zy.asrs.wms.asrs.mapper.*;



import com.zy.asrs.wms.asrs.service.*;



import com.zy.asrs.wms.system.entity.Host;



import com.zy.asrs.wms.system.service.HostService;



import io.netty.util.internal.StringUtil;



import org.springframework.beans.BeanUtils;



import org.springframework.beans.factory.annotation.Autowired;



import org.springframework.stereotype.Service;



@@ -39,6 +40,8 @@


    @Autowired



    private OrderService orderService;



    @Autowired



    private OrderDetlService orderDetlService;



    @Autowired



    private OrderLogService orderLogService;



    @Autowired



    private LocService locService;



@@ -52,6 +55,26 @@


    private PickSheetService pickSheetService;



    @Autowired



    private PickSheetDetlService pickSheetDetlService;



    @Autowired



    private MatService matService;



    @Autowired



    private WaveService waveService;



    @Autowired



    private WaveDetlService waveDetlService;



    @Autowired



    private CacheSiteMapper cacheSiteMapper;







    @Autowired



    private SeedSitesMapper seedSitesMapper;



    @Autowired



    private OrderDetlMapper orderDetlMapper;



    @Autowired



    private WaveSeedMapper waveSeedMapper;



    @Autowired



    private WaveSeedLogService waveSeedLogService;



    @Autowired



    private OrderDetlLogService orderDetlLogService;











    @Override



    @Transactional(rollbackFor = Exception.class)



@@ -91,8 +114,6 @@


            if (workService.generatePakIn(generatePakInParam)) {



                return true;



            }



        } else {



            //fixme 平库是否需要预约入库



        }



        return false;



    }



@@ -120,7 +141,7 @@


            throw new CoolException("库位没有分配所属仓库区域！！");



        }



        locAreas.forEach(locArea -> {



            LocAreaType typeServiceOne = locAreaTypeService.getOne(new LambdaQueryWrapper<LocAreaType>().eq(LocAreaType::getId, locArea.getTypeId()), false);



            LocAreaType typeServiceOne = locAreaTypeService.getOne(new LambdaQueryWrapper<LocAreaType>().eq(LocAreaType::getId, locArea.getTypeId()));



            if (typeServiceOne.getParentId() != LocAreaTypeSts.LOC_AREA_TYPE_FLAT.id && typeServiceOne.getId() != LocAreaTypeSts.LOC_AREA_TYPE_FLAT.id) {



                throw new CoolException("请选择平库区库位，再操作！！");



            }



@@ -135,17 +156,25 @@


        }







        List<WaitPakin> waitPakins = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, shelvesParams.getBarcode()));



        if (waitPakins.isEmpty()) {



            throw new CoolException("当前拖盘没有组拖档!!");



        }







        waitPakins.forEach(pakin -> {



            LocDetl locDetl = new LocDetl();



            locDetl.setAnfme(pakin.getAnfme());



            locDetl.setBatch(pakin.getBatch());



            locDetl.setMatId(pakin.getMatnrId$());



            ;



            locDetl.setCreateTime(new Date());



            locDetl.setOrderNo(pakin.getOrderNo());



            locDetl.setLocNo(loc.getLocNo());



            locDetl.setLocId(loc.getId());



            locDetl.setMatnr(pakin.getMatnr());



            Mat one = matService.getOne(new LambdaQueryWrapper<Mat>().eq(Mat::getMatnr, pakin.getMatnr()));



            if (Objects.isNull(one)) {



                throw new CoolException("当前物料不存在！！");



            }



            locDetl.setMatId(one.getId());



            locDetl.setMemo(pakin.getMemo());



            locDetl.setUpdateTime(new Date());



            if (!locDetlService.saveOrUpdate(locDetl)) {



@@ -159,6 +188,7 @@


        waitPakins.forEach(waitPakin -> {



            WaitPakinLog pakinLog = new WaitPakinLog();



            BeanUtils.copyProperties(waitPakin, pakinLog);



            pakinLog.setIoStatus(1);



            if (!waitPakinLogService.saveOrUpdate(pakinLog)) {



                throw new CoolException("组拖历史档更新失败");



            }



@@ -168,9 +198,16 @@


            throw new CoolException("组拖档删除失败！！");



        }



        //通过组拖订单ID获取订单，并删除原单据，加入单据历史档



        List<Long> list = waitPakins.stream().map(WaitPakin::getOrderId).collect(Collectors.toList());



        Set<Long> list = waitPakins.stream().map(WaitPakin::getOrderId).collect(Collectors.toSet());



        List<Order> orders = orderService.list(new LambdaQueryWrapper<Order>().in(Order::getId, list));



        //订单入历史档



        orders.forEach(order -> {



            if (order.getOrderType() != OrderType.PK_IN_ORDER.id) {



                throw new CoolException("当前订单类型:" + order.getOrderType() + ",不可做平库上架操作！！");



            }



            //修改订单状态为已完成



            order.setOrderSettle(OrderSettleType.COMPLETE.val());







            OrderLog orderLog = new OrderLog();



            BeanUtils.copyProperties(order, orderLog);



            if (!orderLogService.save(orderLog)) {



@@ -178,8 +215,27 @@


            }



        });







        //删除订单数据



        if (!orderService.removeBatchByIds(orders)) {



            throw new CoolException("订单删除失败！！");



        }







        List<OrderDetl> detls = orderDetlMapper.selectList(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, list));



        List<OrderDetlLog> detlLogs = new ArrayList<>();



        detls.forEach(delt ->{



            OrderDetlLog detlLog = new OrderDetlLog();



            BeanUtils.copyProperties(delt, detlLog);



            detlLogs.add(detlLog);



        });







        //订单明细转历史档



        if (!orderDetlLogService.saveBatch(detlLogs)) {



            throw new CoolException("订单明细转历史失败！！");



        }







        //删除订单明细数据



        if (!orderDetlService.remove(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, list))) {



            throw new CoolException("订单明细删除失败！！");



        }







        return true;



@@ -210,6 +266,9 @@


    @Transactional(rollbackFor = Exception.class)



    public boolean confirmFlatSheet(String code) {



        PickSheet pickSheet = pickSheetService.getOne(new LambdaQueryWrapper<PickSheet>().eq(PickSheet::getPickNo, code));



        if (Objects.isNull(pickSheet)) {



            throw new CoolException("拣货单不存在！！");



        }



        if (pickSheet.getStatus() == 1) {



            //状态修改为： 已转历史档



            pickSheet.setStatus(3);



@@ -262,7 +321,165 @@


                }



            }



        });







        //删除波次及对应明细信息



        if (!waveService.remove(new LambdaQueryWrapper<Wave>().eq(Wave::getId, pickSheet.getWaveId()))) {



            throw new CoolException("波次列表单据删除失败！！");



        }







        if (!waveDetlService.remove(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getWaveId, pickSheet.getWaveId()))) {



            throw new CoolException("波次明细列表删除失败！！");



        }







        List<Order> orders = orderService.list(new LambdaQueryWrapper<Order>().eq(Order::getWaveId, pickSheet.getWaveId()));



        if (orders.isEmpty()) {



            throw new CoolException("波次订单不存在！！");



        }



        List<Long> list = orders.stream().map(Order::getId).collect(Collectors.toList());



        boolean remove = orderDetlService.remove(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, list));



        if (!remove) {



            throw new CoolException("原始订单明细删除失败！！");



        }



        if (!orderService.remove(new LambdaQueryWrapper<Order>().in(Order::getId, list))) {



            throw new CoolException("原始订单删除失败！！");



        }







        return true;



    }







    /**



     * 获取播种墙站点



     * @return



     */



    @Override



    public List<CacheSite> getSeedLocs() {



        return cacheSiteMapper.selectList(new LambdaQueryWrapper<>());



    }







    /**



     * 订单绑定播种墙站点+



     * @param param



     * @return



     */



    @Override



    @Transactional(rollbackFor = Exception.class)



    public boolean bindOrderBySite(Map<String, Object> param) {



        CacheSite siteNo = cacheSiteMapper.selectOne(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getSiteNo, param.get("siteNo")), false);



        if (Objects.isNull(siteNo)) {



            throw new CoolException("站点异常！！");



        }



        if (param.get("type").equals("bind")) {



            if (!StringUtil.isNullOrEmpty(siteNo.getOrderNo())) {



                throw new CoolException("当前播种站点已绑定订单！！");



            }



            Order order = orderService.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, param.get("orderNo").toString()));



            if (Objects.isNull(order)) {



                throw new CoolException("绑定订单不存在！！");



            }



            siteNo.setOrderNo(order.getOrderNo()).setOrderId(order.getId()).setSiteStatus(CacheSiteStatusType.R.id);



            if (cacheSiteMapper.updateById(siteNo) < 1) {



                throw new CoolException("订单播种位绑定失败！！" );



            }



        } else {



            if (StringUtil.isNullOrEmpty(siteNo.getOrderNo())) {



                throw new CoolException("当前播种站点未绑定订单！！");



            }



           siteNo.setOrderId(null).setOrderNo(null).setSiteNo("0");



            if (cacheSiteMapper.updateById(siteNo) < 1) {



                throw new CoolException("订单与播种位解绑失败！！" );



            }



        }



        return true;



    }







    @Override



    public R selectShippingDetl(Map<String, Object> params) {



        //判断订单是否为空



        if (StringUtil.isNullOrEmpty((String) params.get("orderNo"))) {



            throw new CoolException("订单编码号不能为空！！");



        }



        String orderId = params.get("orderNo").toString();



        List<ShippingOrderDetlDto> waveSeeds = waveSeedMapper.selectShippingOrderDtel(orderId);







        return R.ok(waveSeeds);



    }







    /**



     * 发货单明细确认



     * 1. 出库修改订单完成状态，判断订单是否完成，完成加入历史档，未完成修改订单已完成数量



     * 2. 删除订单已完成播种明细信息



     * 3. 清除集货区绑定数据



     * @param params



     * @return



     */



    @Override



    @Transactional(rollbackFor = Exception.class)



    public R confirmShippingDetl(List<ShippingOrderDetlDto> params) {



        if (params.isEmpty()) {



            throw new CoolException("发货单据明细为空，不可执行发货操作！！");



        }



        params.forEach(order -> {



            //删除出库订单及明细，加入订单历史档



            if (order.getAnfme() == order.getWorkQty()) { //完全拣货



                OrderDetl byId = orderDetlService.getById(order.getId());



                OrderDetlLog orderDetlLog = new OrderDetlLog();



                BeanUtils.copyProperties(orderDetlLog, byId);



                orderDetlLog.setQty(order.getWorkQty());



                orderDetlLog.setWorkQty(0.0);



                if (!orderDetlLogService.save(orderDetlLog)) {



                    throw new CoolException("订单明细转历史档失败！！");



                }







                if (!orderDetlService.removeById(byId)) {



                    throw new CoolException("订单明细不存在！！");



                }







                //查询当前订单下否还有明细存在



                List<OrderDetl> orders = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().eq(OrderDetl::getOrderNo, order.getOrderNo()));







                if (orders.isEmpty()) {



                    Order one = orderService.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, order.getOrderNo()));



                    if (Objects.isNull(one)) {



                        throw new CoolException("订单不存在！！");



                    }



                    OrderLog orderLog = new OrderLog();







                    BeanUtils.copyProperties(one, orderLog);







                    if (!orderLogService.save(orderLog)) {



                        throw new CoolException("原始订单转历史档失败！！");



                    }







                    if (!orderService.remove(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, order.getOrderNo()))) {



                        throw new CoolException("原始订单删除失败！！");



                    }



                }



            } else {



                //todo 删除已完成明细，保留原始主单及未完成明细



            }







            List<WaveSeed> waveSeeds = waveSeedMapper.selectList(new LambdaQueryWrapper<WaveSeed>().eq(WaveSeed::getOrderDetlId, order.getId()));



            //fixme 订单明细未播种，默认可发货



            if (!waveSeeds.isEmpty()) {



                ArrayList<WaveSeedLog> waveSeedLogs = new ArrayList<>();



                waveSeeds.forEach(seed -> {



                   WaveSeedLog waveSeedLog = new WaveSeedLog();



                   BeanUtils.copyProperties(waveSeedLog, seed);



                   waveSeedLog.setId(null);



                    waveSeedLogs.add(waveSeedLog);



               });



                if (waveSeedLogService.saveBatch(waveSeedLogs)) {



                    throw new CoolException("波明历史档保存失败！！");



                }



            }



            //删除播种明细信息



            if (waveSeedMapper.deleteByIds(waveSeeds) < 1) {



                throw new CoolException("播种明细删除携程！！");



            }



        });











        return null;



    }







}