Merge remote-tracking branch 'origin/nbncasrs' into nbncasrs

cp

2024-10-21 33590e66e814b1c2e025e038410ef0006f4f38f7

Merge remote-tracking branch 'origin/nbncasrs' into nbncasrs

 zy-asrs-common/src/main/java/com/zy/asrs/common/openapi/entity/dto/MergeBoardManyDto.java

New file
@@ -0,0 +1,17 @@
package com.zy.asrs.common.openapi.entity.dto;

import com.zy.asrs.common.wms.entity.WrkDetl;
import lombok.Data;

import java.util.List;

@Data
public class MergeBoardManyDto {

    private Double originAnfme;

    private WrkDetl wrkDetl;

    private List<PickMergeOrderDto> orders;

}

 zy-asrs-common/src/main/java/com/zy/asrs/common/openapi/entity/dto/PickMergeDto.java

New file
@@ -0,0 +1,17 @@
package com.zy.asrs.common.openapi.entity.dto;

import com.zy.asrs.common.wms.entity.LocDetl;
import lombok.Data;

import java.util.List;

@Data
public class PickMergeDto {

    private Double originAnfme;

    private LocDetl locDetl;

    private List<PickMergeOrderDto> orders;

}

 zy-asrs-common/src/main/java/com/zy/asrs/common/openapi/entity/dto/PickMergeOrderDto.java

New file
@@ -0,0 +1,16 @@
package com.zy.asrs.common.openapi.entity.dto;

import lombok.Data;

@Data
public class PickMergeOrderDto {

    private String orderNo;

    private Double anfme;

    public PickMergeOrderDto(String orderNo, Double anfme) {
        this.orderNo = orderNo;
        this.anfme = anfme;
    }
}

 zy-asrs-common/src/main/java/com/zy/asrs/common/openapi/entity/param/WarehouseOutMergeBoardManyParam.java

New file
@@ -0,0 +1,17 @@
package com.zy.asrs.common.openapi.entity.param;

import com.zy.asrs.common.wms.entity.OrderDetl;
import lombok.Data;

import java.util.List;

@Data
public class WarehouseOutMergeBoardManyParam {

    // 托盘码
    private String barcode;

    //组托物料
    private List<OrderDetl> combMats;

}

 zy-asrs-common/src/main/java/com/zy/asrs/common/openapi/entity/param/WarehouseOutPickMergeParam.java

New file
@@ -0,0 +1,20 @@
package com.zy.asrs.common.openapi.entity.param;

import com.zy.asrs.common.wms.entity.OrderDetl;
import lombok.Data;

import java.util.List;

@Data
public class WarehouseOutPickMergeParam {

    // 单据编号
    private String orderNo;

    // 库位编号
    private String locNo;

    //组托物料
    private List<OrderDetl> combMats;

}

 zy-asrs-common/src/main/java/com/zy/asrs/common/wms/service/MobileService.java

@@ -2,6 +2,8 @@

import com.zy.asrs.common.domain.param.MobileAdjustParam;
import com.zy.asrs.common.openapi.entity.param.CombParam;
import com.zy.asrs.common.openapi.entity.param.WarehouseOutMergeBoardManyParam;
import com.zy.asrs.common.openapi.entity.param.WarehouseOutPickMergeParam;
import com.zy.asrs.framework.common.R;

public interface MobileService {
@@ -20,4 +22,6 @@

    R WarehouseOut(CombParam combParam, Long hostId);
    R WarehouseOutV1(CombParam combParam, Long hostId);
    R WarehouseOutPickMergeV1(WarehouseOutPickMergeParam param, Long hostId);
    R WarehouseOutMergeBoardMany(WarehouseOutMergeBoardManyParam param, Long hostId);
}

 zy-asrs-common/src/main/java/com/zy/asrs/common/wms/service/OrderService.java

@@ -24,6 +24,7 @@
    void checkComplete(String orderNo, Long hostId);


    List<OrderNameListDto> selectAllCombOrderNo(Long hostId);
    List<OrderNameListDto> selectAllorderNo(Long hostId);
    List<String> selectAllOutOrderNo(String orderNo,Long hostId);


 zy-asrs-common/src/main/java/com/zy/asrs/common/wms/service/impl/MobileServiceImpl.java

@@ -3,7 +3,12 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.common.domain.dto.DetlDto;
import com.zy.asrs.common.domain.param.MobileAdjustParam;
import com.zy.asrs.common.openapi.entity.dto.MergeBoardManyDto;
import com.zy.asrs.common.openapi.entity.dto.PickMergeDto;
import com.zy.asrs.common.openapi.entity.dto.PickMergeOrderDto;
import com.zy.asrs.common.openapi.entity.param.CombParam;
import com.zy.asrs.common.openapi.entity.param.WarehouseOutMergeBoardManyParam;
import com.zy.asrs.common.openapi.entity.param.WarehouseOutPickMergeParam;
import com.zy.asrs.common.wms.entity.*;
import com.zy.asrs.common.wms.mapper.LocDetlMapper;
import com.zy.asrs.common.wms.service.*;
@@ -20,10 +25,7 @@
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.*;

/**
 * 移动端服务核心类
@@ -52,6 +54,8 @@
    private LocDetlService locDetlService;
    @Autowired
    private WaitPakinLogService waitPakinLogService;
    @Autowired
    private AdjDetlService adjDetlService;

    @Override
    @Transactional
@@ -157,7 +161,7 @@
                waitPakin.setAppeTime(now);
                waitPakin.setModiUser(userId);
                waitPakin.setModiTime(now);
                waitPakin.setOwner(param.getOwner());
                waitPakin.setOwner(Optional.ofNullable(param.getOwner()).orElse(""));
                if (!waitPakinService.save(waitPakin)) {
                    throw new CoolException("保存入库通知档失败");
                }
@@ -451,7 +455,16 @@
            }
            try {
                //处理库存信息
                AdjDetl adjDetl = new AdjDetl();
                adjDetl.setLocNo(locDetl.getLocNo());
                adjDetl.setMatnr(locDetl.getMatnr());
                adjDetl.setBatch(locDetl.getBatch());
                adjDetl.setOriQty(locDetl.getAnfme());
                adjDetl.setMemo("WarehouseOutV1-pick");
                adjDetl.setModiTime(new Date());

                if (combMat.getAnfme().equals(locDetl.getAnfme())){
                    adjDetl.setAdjQty(0D);
                    //库存相等删除数据
                    locDetlService.removeById(locDetl);
                    int count = locDetlService.count(new LambdaQueryWrapper<LocDetl>().eq(LocDetl::getLocNo,combParam.getLocno()).eq(LocDetl::getHostId, hostId));
@@ -464,6 +477,11 @@
                    BigDecimal subtract = BigDecimal.valueOf(locDetl.getAnfme()).subtract(BigDecimal.valueOf(combMat.getAnfme()));
                    locDetl.setAnfme(subtract.doubleValue());
                    locDetlService.updateById(locDetl);
                    adjDetl.setAdjQty(subtract.doubleValue());
                }

                if (!adjDetlService.save(adjDetl)) {
                    throw new CoolException("保存库存调整记录失败");
                }
            }catch (Exception e){
                throw new CoolException("更新库存数据出错"+e.getMessage());
@@ -471,4 +489,271 @@
        }
        return R.ok();
    }

    @Override
    @Transactional
    public R WarehouseOutPickMergeV1(WarehouseOutPickMergeParam param, Long hostId) {
        //判断库位状态
        LocMast locMast = locMastService.getOne(new LambdaQueryWrapper<LocMast>().eq(LocMast::getLocNo, param.getLocNo()).eq(LocMast::getHostId,hostId).eq(LocMast::getWhsType,0L));
        if (Cools.isEmpty(locMast)){
            return R.error("该库位不存在");
        }
        if (!locMast.getLocSts().equals("P")){
            return R.error("该库位状态为："+locMast.getLocSts()+",不满足拣料途中并板条件！！！");
        }

        HashMap<String, OrderDetl> mapData = new HashMap<>();
        for (OrderDetl orderDetl : param.getCombMats()) {
            String key = orderDetl.getMatnr();
            if (!Cools.isEmpty(orderDetl.getBatch())) {
                key += "_" + orderDetl.getBatch();
            }

            OrderDetl value = mapData.get(key);
            if(value == null){
                mapData.put(key, orderDetl);
            }else {
                value.setAnfme(value.getAnfme() + orderDetl.getAnfme());
                mapData.put(key, value);
            }
        }

        List<LocDetl> locDetls = locDetlService.list(new LambdaQueryWrapper<LocDetl>().eq(LocDetl::getLocNo, locMast.getLocNo()));

        HashMap<String, PickMergeDto> locData = new HashMap<>();
        for (LocDetl locDetl : locDetls) {
            String matKey = locDetl.getMatnr();
            if (!Cools.isEmpty(locDetl.getBatch())) {
                matKey += "_" + locDetl.getBatch();
            }

            PickMergeDto dto = new PickMergeDto();
            dto.setOriginAnfme(locDetl.getAnfme());
            dto.setLocDetl(locDetl);
            dto.setOrders(new ArrayList<>());
            locData.put(matKey, dto);
        }

        for (Map.Entry<String, OrderDetl> entry : mapData.entrySet()) {
            OrderDetl orderDetl = entry.getValue();
            LocDetl locDetl = new LocDetl();
            locDetl.sync(orderDetl);
            locDetl.setId(null);
            locDetl.setLocNo(param.getLocNo());
            locDetl.setBarcode(locMast.getBarcode());

            String matKey = locDetl.getMatnr();
            if (!Cools.isEmpty(locDetl.getBatch())) {
                matKey += "_" + locDetl.getBatch();
            }

            PickMergeDto dto = locData.get(matKey);
            if (dto == null) {
                ArrayList<PickMergeOrderDto> orders = new ArrayList<>();
                orders.add(new PickMergeOrderDto(locDetl.getOrderNo(), locDetl.getAnfme()));

                dto = new PickMergeDto();
                dto.setOriginAnfme(locDetl.getAnfme());
                dto.setLocDetl(locDetl);
                dto.setOrders(orders);

                locData.put(matKey, dto);
            }else {
                LocDetl detl = dto.getLocDetl();
                List<PickMergeOrderDto> orders = dto.getOrders();

                detl.setAnfme(detl.getAnfme() + locDetl.getAnfme());
                orders.add(new PickMergeOrderDto(locDetl.getOrderNo(), locDetl.getAnfme()));

                dto.setLocDetl(detl);
                dto.setOrders(orders);

                locData.put(matKey, dto);
            }
        }


        for (Map.Entry<String, PickMergeDto> entry : locData.entrySet()) {
            PickMergeDto dto = entry.getValue();

            Double originAnfme = dto.getOriginAnfme();
            LocDetl locDetl = dto.getLocDetl();
            List<PickMergeOrderDto> orders = dto.getOrders();

            if (locDetl.getId() == null) {
                if (!locDetlService.save(locDetl)) {
                    throw new CoolException("并板库存插入失败");
                }
            }else {
                if (!locDetlService.updateById(locDetl)) {
                    throw new CoolException("并板库存更新失败");
                }
            }

            if (!orders.isEmpty()){
                for (PickMergeOrderDto orderDto : orders) {
                    Order order = orderService.selectByNo(orderDto.getOrderNo(), hostId);
                    if (Cools.isEmpty(order)){
                        continue;
                    }
                    if (order.getSettle() == 1){
                        orderService.updateSettle(order.getId(), 2L, 9527L, hostId);
                    }
                    OrderDetl orderDetl = orderDetlService.selectItem(order.getId(), locDetl.getMatnr(), locDetl.getBatch(),hostId);
                    if (Cools.isEmpty(orderDetl)){
                        continue;
                    }
                    if (orderDetl.getAnfme() < (orderDetl.getWorkQty() + orderDto.getAnfme())) {
                        throw new CoolException("拣选数量出错,订单剩余出库数量小于已出库数量与将拣选数量之和！！！");
                    }
                    // 修改订单明细作业数量
                    if (!orderDetlService.increaseWorkQtyByOrderNo(orderDto.getOrderNo(), locDetl.getMatnr(), locDetl.getBatch(), orderDto.getAnfme(), hostId)) {
                        throw new CoolException("修改单据明细工作数量失败");
                    }
                    // 修改订单明细完成数量
                    if (!orderDetlService.increase(order.getId(), hostId, locDetl.getMatnr(), locDetl.getBatch(), orderDto.getAnfme())) {
                        throw new CoolException("修改单据明细完成数量失败");
                    }
                    // 修改订单状态 作业中 ===>> 已完成
                    orderService.checkComplete(orderDto.getOrderNo(), hostId);
                }
            }

            try {
                //处理库存信息
                AdjDetl adjDetl = new AdjDetl();
                adjDetl.setLocNo(locDetl.getLocNo());
                adjDetl.setMatnr(locDetl.getMatnr());
                adjDetl.setBatch(locDetl.getBatch());
                adjDetl.setOriQty(originAnfme);
                adjDetl.setAdjQty(locDetl.getAnfme());
                adjDetl.setMemo("WarehouseOutV1-pick");
                adjDetl.setModiTime(new Date());

                if (!adjDetlService.save(adjDetl)) {
                    throw new CoolException("保存库存调整记录失败");
                }
            }catch (Exception e){
                e.printStackTrace();
                throw new CoolException("更新库存数据出错" + e.getMessage());
            }
        }
        return R.ok();
    }

    @Override
    @Transactional
    public R WarehouseOutMergeBoardMany(WarehouseOutMergeBoardManyParam param, Long hostId) {
        WrkMast wrkMast = wrkMastService.selectByBarcode(param.getBarcode(), hostId);
        if (wrkMast == null) {
            throw new CoolException("工作档不存在");
        }

        if (wrkMast.getIoType() != 104) {
            throw new CoolException("工作类型不属于并板出库");
        }

        if (wrkMast.getWrkSts() != 199) {
            throw new CoolException("工作状态不满足多次并板入库状态");
        }

        List<WrkDetl> wrkDetls = wrkDetlService.list(new LambdaQueryWrapper<WrkDetl>().eq(WrkDetl::getWrkNo, wrkMast.getWrkNo()));

        HashMap<String, MergeBoardManyDto> wrkData = new HashMap<>();
        for (WrkDetl wrkDetl : wrkDetls) {
            String matKey = wrkDetl.getMatnr();
            if (!Cools.isEmpty(wrkDetl.getBatch())) {
                matKey += "_" + wrkDetl.getBatch();
            }

            MergeBoardManyDto dto = new MergeBoardManyDto();
            dto.setOriginAnfme(wrkDetl.getAnfme());
            dto.setWrkDetl(wrkDetl);
            dto.setOrders(new ArrayList<>());
            wrkData.put(matKey, dto);
        }

        for (OrderDetl orderDetl : param.getCombMats()) {
            String matKey = orderDetl.getMatnr();
            if (!Cools.isEmpty(orderDetl.getBatch())) {
                matKey += "_" + orderDetl.getBatch();
            }

            MergeBoardManyDto dto = wrkData.get(matKey);
            if(dto == null){
                WrkDetl wrkDetl = new WrkDetl();
                wrkDetl.sync(orderDetl);
                wrkDetl.setId(null);
                wrkDetl.setWrkNo(wrkMast.getWrkNo());
                wrkDetl.setWrkMastId(wrkMast.getId());
                wrkDetl.setIoTime(new Date());

                ArrayList<PickMergeOrderDto> orderDtos = new ArrayList<>();
                orderDtos.add(new PickMergeOrderDto(orderDetl.getOrderNo(), orderDetl.getAnfme()));

                dto = new MergeBoardManyDto();
                dto.setOriginAnfme(orderDetl.getAnfme());
                dto.setWrkDetl(wrkDetl);
                dto.setOrders(orderDtos);
            }else {
                WrkDetl wrkDetl = dto.getWrkDetl();
                List<PickMergeOrderDto> orders = dto.getOrders();

                wrkDetl.setAnfme(wrkDetl.getAnfme() + orderDetl.getAnfme());
                orders.add(new PickMergeOrderDto(orderDetl.getOrderNo(), orderDetl.getAnfme()));

                dto.setWrkDetl(wrkDetl);
                dto.setOrders(orders);
            }

            wrkData.put(matKey, dto);
        }

        for (Map.Entry<String, MergeBoardManyDto> entry : wrkData.entrySet()) {
            MergeBoardManyDto dto = entry.getValue();
            List<PickMergeOrderDto> orders = dto.getOrders();
            WrkDetl wrkDetl = dto.getWrkDetl();

            if (wrkDetl.getId() == null) {
                if (!wrkDetlService.save(wrkDetl)) {
                    throw new CoolException("多次并板插入工作明细失败");
                }
            }else {
                if (!wrkDetlService.updateById(wrkDetl)) {
                    throw new CoolException("多次并板更新工作明细失败");
                }
            }

            if (!orders.isEmpty()){
                for (PickMergeOrderDto orderDto : orders) {
                    Order order = orderService.selectByNo(orderDto.getOrderNo(), hostId);
                    if (Cools.isEmpty(order)){
                        continue;
                    }
                    if (order.getSettle() == 1){
                        orderService.updateSettle(order.getId(), 2L, 9527L, hostId);
                    }
                    OrderDetl orderDetl = orderDetlService.selectItem(order.getId(), wrkDetl.getMatnr(), wrkDetl.getBatch(),hostId);
                    if (Cools.isEmpty(orderDetl)){
                        continue;
                    }
                    if (orderDetl.getAnfme() < (orderDetl.getWorkQty() + orderDto.getAnfme())) {
                        throw new CoolException("拣选数量出错,订单剩余出库数量小于已出库数量与将拣选数量之和！！！");
                    }
                    // 修改订单明细作业数量
                    if (!orderDetlService.increaseWorkQtyByOrderNo(orderDto.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch(), orderDto.getAnfme(), hostId)) {
                        throw new CoolException("修改单据明细工作数量失败");
                    }
                    // 修改订单明细完成数量
                    if (!orderDetlService.increase(order.getId(), hostId, wrkDetl.getMatnr(), wrkDetl.getBatch(), orderDto.getAnfme())) {
                        throw new CoolException("修改单据明细完成数量失败");
                    }
                    // 修改订单状态 作业中 ===>> 已完成
                    orderService.checkComplete(orderDto.getOrderNo(), hostId);
                }
            }
        }

        return R.ok();
    }
}

 zy-asrs-common/src/main/java/com/zy/asrs/common/wms/service/impl/OrderServiceImpl.java

@@ -166,8 +166,33 @@
    }

    @Override
    public List<OrderNameListDto> selectAllCombOrderNo(Long hostId) {
        List<Order> list = list(new LambdaQueryWrapper<Order>().eq(Order::getHostId, hostId).orderByDesc(Order::getCreateTime));
        if (Cools.isEmpty(list)){
            return null;
        }
        ArrayList<OrderNameListDto> orderNameListDtos = new ArrayList<>();
        for (Order order :list){
            DocType docType = docTypeService.getOne(new LambdaQueryWrapper<DocType>().eq(DocType::getDocId, order.getDocType()));

            if (order.getSettle() >= 4) {
                continue;
            }

            if (docType.getPakin() == 1){
                OrderNameListDto orderNameListDto = new OrderNameListDto();
                orderNameListDto.setOrder_no(order.getOrderNo());
                orderNameListDtos.add(orderNameListDto);
            }
        }

        return orderNameListDtos;

    }

    @Override
    public List<OrderNameListDto> selectAllorderNo(Long hostId) {
        List<Order> list = list(new LambdaQueryWrapper<Order>().eq(Order::getHostId, hostId));
        List<Order> list = list(new LambdaQueryWrapper<Order>().eq(Order::getHostId, hostId).orderByDesc(Order::getCreateTime));
        if (Cools.isEmpty(list)){
            return null;
        }
@@ -191,10 +216,12 @@
        List<Order> list = list(new LambdaQueryWrapper<Order>()
                .eq(Order::getHostId, hostId)
                .like(Order::getOrderNo, orderNo)
                .orderByDesc(Order::getCreateTime)
        );
        if (Cools.isEmpty(orderNo) || orderNo.isEmpty()){
            list = list(new LambdaQueryWrapper<Order>()
                    .eq(Order::getHostId, hostId)
                    .orderByDesc(Order::getCreateTime)
            );
        }
        if (Cools.isEmpty(list)){
@@ -204,6 +231,10 @@
        for (Order order :list){
            DocType docType = docTypeService.getOne(new LambdaQueryWrapper<DocType>().eq(DocType::getDocId, order.getDocType()));

            if (order.getSettle() >= 4) {
                continue;
            }

            if (docType.getPakout() == 1){
                orderNameListDtos.add(order.getOrderNo());
            }

 zy-asrs-wms/src/main/java/com/zy/asrs/wms/controller/MatController.java

@@ -5,8 +5,12 @@
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zy.asrs.common.utils.TreeUtils;
import com.zy.asrs.common.wms.entity.LocDetl;
import com.zy.asrs.common.wms.entity.LocMast;
import com.zy.asrs.common.wms.entity.Mat;
import com.zy.asrs.common.wms.entity.OrderDetl;
import com.zy.asrs.common.wms.service.LocDetlService;
import com.zy.asrs.common.wms.service.LocMastService;
import com.zy.asrs.common.wms.service.MatService;
import com.zy.asrs.framework.annotations.ManagerAuth;
import com.zy.asrs.framework.common.Cools;
@@ -27,6 +31,10 @@
    private MatService matService;
    @Autowired
    private TreeUtils treeUtils;
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private LocMastService locMastService;

    @RequestMapping(value = "/mat/{id}/auth")
    @ManagerAuth
@@ -201,4 +209,37 @@
        return R.ok().add(matService.page(new Page<>(curr, limit), wrapper));
    }

    @RequestMapping(value = "/mat/pad/search")
    @ManagerAuth
    public R padSearch(@RequestParam("matnr") String matnr) {
        List<Mat> list = matService.list(new LambdaQueryWrapper<Mat>()
                .like(Mat::getMatnr, matnr)
                .eq(Mat::getHostId, getHostId()));
        if (list.isEmpty()){
            return R.error("未查询到相关物料");
        }
        return R.ok(list);
    }

    @RequestMapping(value = "/mat/pad/searchLoc")
    @ManagerAuth
    public R padSearchLoc(@RequestParam("matnr") String matnr) {
        List<LocDetl> list = locDetlService.list(new LambdaQueryWrapper<LocDetl>().eq(LocDetl::getMatnr, matnr).eq(LocDetl::getHostId, getHostId()));

        ArrayList<LocDetl> locDetls = new ArrayList<>();
        for (LocDetl locDetl : list) {
            LocMast one = locMastService.getOne(new LambdaQueryWrapper<LocMast>().eq(LocMast::getLocNo, locDetl.getLocNo()).eq(LocMast::getHostId, locDetl.getHostId()));
            if (one == null) {
                continue;
            }

            if (!one.getLocSts().equals("F")) {
                continue;
            }

            locDetls.add(locDetl);
        }
        return R.ok(locDetls);
    }

}

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

@@ -10,6 +10,8 @@
import com.zy.asrs.common.domain.param.PickConfirmParam;
import com.zy.asrs.common.domain.param.PickMatParam;
import com.zy.asrs.common.openapi.entity.param.CombParam;
import com.zy.asrs.common.openapi.entity.param.WarehouseOutMergeBoardManyParam;
import com.zy.asrs.common.openapi.entity.param.WarehouseOutPickMergeParam;
import com.zy.asrs.common.sys.service.StaDescService;
import com.zy.asrs.common.web.BaseController;
import com.zy.asrs.common.wms.entity.*;
@@ -80,6 +82,18 @@
    @ManagerAuth
    public R WarehouseOutV1(@RequestBody CombParam combParam){
        return mobileService.WarehouseOutV1(combParam,getHostId());
    }

    @RequestMapping("/pda/WarehouseOutPickMerge/v1")
    @ManagerAuth
    public R WarehouseOutPickMergeV1(@RequestBody WarehouseOutPickMergeParam param){
        return mobileService.WarehouseOutPickMergeV1(param, getHostId());
    }

    @RequestMapping("/pda/WarehouseOutMergeBoardMany/v1")
    @ManagerAuth
    public R WarehouseOutMergeBoardManyV1(@RequestBody WarehouseOutMergeBoardManyParam param){
        return mobileService.WarehouseOutMergeBoardMany(param, getHostId());
    }

    @RequestMapping("/menu/pda/auth")
@@ -574,4 +588,28 @@
        return R.ok().add(wrkMastArrayList);
    }

    @RequestMapping("/barcode/list/pick")
    @ManagerAuth(memo = "拣料入库途中并板")
    @Transactional
    public R orderOutListOrderPick(@RequestBody String barcode) {
        ArrayList<WrkMast> wrkMastArrayList = new ArrayList<>();
        if (Cools.isEmpty(barcode) || barcode.isEmpty()){
            List<WrkMast> wrkMasts = wrkMastService.list(new LambdaQueryWrapper<WrkMast>()
                    .eq(WrkMast::getHostId, getHostId())
                    .eq(WrkMast::getWrkSts, 199L)
                    .eq(WrkMast::getIoType, 103));
            wrkMastArrayList.addAll(wrkMasts);
        } else {
            List<WrkMast> wrkMasts = wrkMastService.list(new LambdaQueryWrapper<WrkMast>()
                    .like(WrkMast::getBarcode, barcode)
                    .eq(WrkMast::getHostId, getHostId())
                    .eq(WrkMast::getWrkSts, 199L)
                    .eq(WrkMast::getIoType, 103)
            );
            wrkMastArrayList.addAll(wrkMasts);
        }

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

}

 zy-asrs-wms/src/main/java/com/zy/asrs/wms/controller/OrderController.java

@@ -57,7 +57,7 @@
    @RequestMapping(value = "/order/list/orderNo")
    public R orderListorderNo(@RequestParam String orderNo) {
        //数量修改成为完成数量
        List<OrderDetl> orderDetl1=orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().eq(OrderDetl::getOrderNo,orderNo));
        List<OrderDetl> orderDetl1 = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().eq(OrderDetl::getOrderNo, orderNo));
        List<OrderDetl> orderDetls= new ArrayList<OrderDetl>();
        for (OrderDetl o: orderDetl1) {
            BigDecimal c1 = new BigDecimal(o.getEnableQty()).setScale(2,BigDecimal.ROUND_HALF_UP);
@@ -76,6 +76,12 @@
        return R.ok(orderService.selectAllorderNo(getHostId()));
    }

    @RequestMapping(value = "/order/comb/list/all")
    @ManagerAuth
    public R orderListComb() {
        return R.ok(orderService.selectAllCombOrderNo(getHostId()));
    }

//    @RequestMapping(value = "/outOrder/list/all")
//    @ManagerAuth
//    public R orderOutList() {

 zy-asrs-wms/src/main/java/com/zy/asrs/wms/controller/OrderDetlController.java

@@ -99,11 +99,60 @@
        if (orderDetlList.size()>1){
            return R.error("此订单此物料数据数据大于1条，为保证数据准确性，请用正常流程出库！！！");
        }
        ArrayList<OrderDetl> orderDetls = new ArrayList<>();
        for(OrderDetl orderDetl:orderDetlList){
            double count = orderDetl.getAnfme() - orderDetl.getWorkQty();
            if (count <= 0D) {
                continue;
            }
            orderDetl.setAnfme(count);
            orderDetls.add(orderDetl);
        }
        return R.ok(orderDetlList);
        return R.ok(orderDetls);
    }

    @RequestMapping(value = "/orderDetl/forOrderNo/mergePakin/v1")
    @ManagerAuth
    public R forOrderNoMergePakinV1(@RequestParam String orderNo) {
        List<DocType> docTypes = docTypeService.list(new LambdaQueryWrapper<DocType>().eq(DocType::getPakin, 1));
        ArrayList<Long> docTypeIds = new ArrayList<>();
        for (DocType docType : docTypes) {
            docTypeIds.add(docType.getDocId());
        }

        if (docTypeIds.isEmpty()) {
            return R.error("单据类型不存在");
        }

        List<Order> orders = orderService.list(new LambdaQueryWrapper<Order>().in(Order::getDocType, docTypeIds).in(Order::getSettle, 0, 1, 2));
        if (orders.isEmpty()) {
            return R.error("未查询到订单");
        }

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

        List<OrderDetl> orderDetlList = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>()
                .eq(OrderDetl::getHostId, getHostId())
                .in(OrderDetl::getOrderId, orderIds)
                .like(OrderDetl::getOrderNo, orderNo)
        );
        if (Cools.isEmpty(orderDetlList)){
            return R.error("未查询到此订单此物料数据");
        }

        ArrayList<OrderDetl> orderDetls = new ArrayList<>();
        for(OrderDetl orderDetl:orderDetlList){
            double count = orderDetl.getAnfme() - orderDetl.getWorkQty();
            if (count <= 0D) {
                continue;
            }
            orderDetl.setAnfme(count);
            orderDetls.add(orderDetl);
        }
        return R.ok(orderDetls);
    }