13

zhang

8 天以前 29bd10e6981aa5cfcd087dd9695f3d926925f847

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

@@ -11,17 +11,14 @@
import com.zy.asrs.entity.result.StockVo;
import com.zy.asrs.mapper.TagMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.MatUtils;
import com.zy.common.model.DetlDto;
import com.zy.common.utils.NodeUtils;
import com.zy.erp.kingdee.enums.KingDeeUtilType;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

@@ -33,9 +30,13 @@
public class OpenServiceImpl implements OpenService {

    @Autowired
    private OrderService orderService;
    private OrderPakinService orderPakinService;
    @Autowired
    private OrderDetlService orderDetlService;
    private OrderDetlPakinService orderDetlPakinService;
    @Autowired
    private OrderPakoutService orderPakoutService;
    @Autowired
    private OrderDetlPakoutService orderDetlPakoutService;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
@@ -44,8 +45,6 @@
    private MatService matService;
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private PackService packService;
    @Autowired
    private TagService tagService;
    @Autowired
@@ -71,19 +70,24 @@
    public void pakinOrderCreate(OpenOrderPakinParam param) {
        callApiLogSaveOrder(param, "入库单", true);

        Order order = orderService.selectByNo(param.getOrderNo());
        OrderPakin order = orderPakinService.selectByNo(param.getOrderNo());
        if (!Cools.isEmpty(order) && order.getSettle() != 1) {
            throw new CoolException(param.getOrderNo() + "单据已有工作任务");
        }
        if (!Cools.isEmpty(order)) {
            boolean orderNo = orderService.delete(new EntityWrapper<Order>().eq("order_no", param.getOrderNo()));
            boolean orderNo1 = orderDetlService.delete(new EntityWrapper<OrderDetl>().eq("order_no", param.getOrderNo()));
            boolean orderNo = orderPakinService.delete(new EntityWrapper<OrderPakin>().eq("order_no", param.getOrderNo()));
            boolean orderNo1 = orderDetlPakinService.delete(new EntityWrapper<OrderDetlPakin>().eq("order_no", param.getOrderNo()));

        }
        DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.TRUE);
        DocType docType;
        if (param.getOrderType().equals("调拨单")) {
            docType = docTypeService.selectOrAdd("调拨单(入)", Boolean.TRUE);
        } else {
            docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.TRUE);
        }
        Date now = new Date();
        // 单据主档
        order = new Order(
        order = new OrderPakin(
                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
                param.getOrderNo(),    // 订单编号
                param.getInboundDate(),    // 单据日期
@@ -119,8 +123,7 @@
                now,    // 修改时间
                null    // 备注
        );
        order.setShipCode(param.getQuality());
        if (!orderService.insert(order)) {
        if (!orderPakinService.insert(order)) {
            throw new CoolException("生成单据主档失败，请联系管理员");
        }
        // 单据明细档
@@ -129,6 +132,7 @@
        for (DetlDto detail : orderDetails) {
            DetlDto dto = new DetlDto(detail.getMatnr(), detail.getBatch(), detail.getAnfme(), detail.getFromOrderNo()
                    , detail.getMark(), detail.getCustomer(), detail.getSuppName(), detail.getTemp1(), detail.getTemp2(), detail.getTemp3(), detail.getTemp4());
            dto.setQuality(detail.getQuality());
            if (DetlDto.has(list, dto)) {
                DetlDto detlDto = DetlDto.find(list, dto.getMatnr(), dto.getBatch());
                assert detlDto != null;
@@ -142,29 +146,30 @@
            if (Cools.isEmpty(mat)) {
                throw new CoolException(detlDto.getMatnr() + "编号商品检索失败，请先添加商品");
            }
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.sync(mat);
            orderDetl.setBatch(detlDto.getBatch());
            orderDetl.setAnfme(detlDto.getAnfme());
            orderDetl.setOrderId(order.getId());
            orderDetl.setOrderNo(order.getOrderNo());
            orderDetl.setCreateBy(9527L);
            orderDetl.setCreateTime(now);
            orderDetl.setUpdateBy(9527L);
            orderDetl.setUpdateTime(now);
            orderDetl.setStatus(1);
            orderDetl.setQty(0.0D);
            orderDetl.setThreeCode(detlDto.getOrderNo());
            orderDetl.setSuppCode(detlDto.getFromOrderNo());
            orderDetl.setMemo(detlDto.getMemo());
            orderDetl.setManu(detlDto.getMark());
            orderDetl.setSupp(detlDto.getSuppName()); //供应商
            orderDetl.setSku(detlDto.getCustomer());
            orderDetl.setTemp1(detlDto.getTemp1());
            orderDetl.setTemp2(detlDto.getTemp2());
            orderDetl.setTemp3(detlDto.getTemp3());
            orderDetl.setTemp4(detlDto.getTemp4());
            if (!orderDetlService.insert(orderDetl)) {
            OrderDetlPakin orderDetlPakout = new OrderDetlPakin();
            orderDetlPakout.sync(mat);
            orderDetlPakout.setBatch(detlDto.getBatch());
            orderDetlPakout.setAnfme(detlDto.getAnfme());
            orderDetlPakout.setOrderId(order.getId());
            orderDetlPakout.setOrderNo(order.getOrderNo());
            orderDetlPakout.setCreateBy(9527L);
            orderDetlPakout.setCreateTime(now);
            orderDetlPakout.setUpdateBy(9527L);
            orderDetlPakout.setUpdateTime(now);
            orderDetlPakout.setStatus(1);
            orderDetlPakout.setQty(0.0D);
            orderDetlPakout.setThreeCode(detlDto.getOrderNo());
            orderDetlPakout.setSuppCode(detlDto.getFromOrderNo());
            orderDetlPakout.setMemo(detlDto.getMemo());
            orderDetlPakout.setManu(detlDto.getMark());
            orderDetlPakout.setSupp(detlDto.getSuppName()); //供应商
            orderDetlPakout.setSku(detlDto.getCustomer());
            orderDetlPakout.setTemp1(detlDto.getTemp1());
            orderDetlPakout.setTemp2(detlDto.getTemp2());
            orderDetlPakout.setTemp3(detlDto.getTemp3());
            orderDetlPakout.setTemp4(detlDto.getTemp4());
            orderDetlPakout.setInspect(detlDto.getQuality());
            if (!orderDetlPakinService.insert(orderDetlPakout)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }
@@ -173,43 +178,43 @@
    @Override
    @Transactional
    public List<OpenOrderCompeteResult> pakinOrderComplete(OpenOrderCompleteParam param) {
        callApiLogSaveOrder(param, "出库单", true);
        callApiLogSaveOrder(param, "入库单", true);
        List<OpenOrderCompeteResult> results = new ArrayList<>();
        if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
            // 指定订单
            Order order = orderService.selectByNo(param.getOrderNo());
            OrderPakin order = orderPakinService.selectByNo(param.getOrderNo());
            if (null != order) {
                OpenOrderCompeteResult result = new OpenOrderCompeteResult();
                results.add(result);
                result.setOrderNo(order.getOrderNo());
                result.setOrderTime(order.getOrderTime());
                result.setOrderType(order.getDocType$());
                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
                for (OrderDetl orderDetl : orderDetls) {
                    result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
                List<OrderDetlPakin> orderDetlPakouts = orderDetlPakinService.selectByOrderId(order.getId());
                for (OrderDetlPakin orderDetlPakout : orderDetlPakouts) {
                    result.getOrderDetails().add(new DetlDto(orderDetlPakout.getOrderNo(), orderDetlPakout.getMatnr(), orderDetlPakout.getBatch(), orderDetlPakout.getQty()));
                }
                if (order.getSettle() == 4L) {
                    // 修改订单状态 4.完成 ===>> 6.已上报
                    if (!orderService.updateSettle(order.getId(), 6L, null)) {
                    if (!orderPakinService.updateSettle(order.getId(), 6L, null)) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
            }
        } else {
            // 所有订单
            List<Order> orders = orderService.selectList(new EntityWrapper<Order>().eq("settle", 4L));
            for (Order order : orders) {
            List<OrderPakin> orders = orderPakinService.selectList(new EntityWrapper<OrderPakin>().eq("settle", 4L));
            for (OrderPakin order : orders) {
                OpenOrderCompeteResult result = new OpenOrderCompeteResult();
                results.add(result);
                result.setOrderNo(order.getOrderNo());
                result.setOrderTime(order.getOrderTime());
                result.setOrderType(order.getDocType$());
                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
                for (OrderDetl orderDetl : orderDetls) {
                    result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
                List<OrderDetlPakin> orderDetlPakouts = orderDetlPakinService.selectByOrderId(order.getId());
                for (OrderDetlPakin orderDetlPakout : orderDetlPakouts) {
                    result.getOrderDetails().add(new DetlDto(orderDetlPakout.getOrderNo(), orderDetlPakout.getMatnr(), orderDetlPakout.getBatch(), orderDetlPakout.getQty()));
                }
                // 修改订单状态 4.完成 ===>> 6.已上报
                if (!orderService.updateSettle(order.getId(), 6L, null)) {
                if (!orderPakinService.updateSettle(order.getId(), 6L, null)) {
                    throw new CoolException("服务器内部错误，请联系管理员");
                }
            }
@@ -221,18 +226,23 @@
    @Transactional
    public void pakoutOrderCreate(OpenOrderPakoutParam param) {
        callApiLogSaveOrder(param, "出库单", true);
        Order order = orderService.selectByNo(param.getOrderNo());
        OrderPakout order = orderPakoutService.selectByNo(param.getOrderNo());
        // 如果单据不存在则添加；如果单据存在，作业中无法修改，反之则修改单据
        if (!Cools.isEmpty(order)) {
            if (order.getSettle() > 1L) {
                throw new CoolException(param.getOrderNo() + "正在出库，无法修改单据");
            }
            orderService.remove(order.getId());
            orderPakoutService.remove(order.getId());
        }
        DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.FALSE);
        DocType docType;
        if (param.getOrderType().equals("调拨单")) {
            docType = docTypeService.selectOrAdd("调拨单(出)", Boolean.FALSE);
        } else {
            docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.FALSE);
        }
        Date now = new Date();
        // 单据主档
        order = new Order(
        order = new OrderPakout(
                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
                param.getOrderNo(),    // 订单编号
                param.getInboundDate(),    // 单据日期
@@ -269,14 +279,14 @@
                null    // 备注
        );
        order.setShipCode(param.getQuality());
        if (!orderService.insert(order)) {
        if (!orderPakoutService.insert(order)) {
            throw new CoolException("生成单据主档失败，请联系管理员");
        }
        // 单据明细档
        List<DetlDto> list = new ArrayList<>();
        List<DetlDto> orderDetails = param.getDetails();
        for (DetlDto detail : orderDetails) {
            DetlDto dto = new DetlDto(detail.getMatnr(), detail.getBatch(), detail.getAnfme(), detail.getFromOrderNo()
            DetlDto dto = new DetlDto(detail.getMatnr(), detail.getBatch(), detail.getAnfme(), param.getFromOrderNo()
                    , detail.getMark(), detail.getCustomer(), detail.getSuppName(), detail.getTemp1(), detail.getTemp2(), detail.getTemp3(), detail.getTemp4());
            dto.setTemp1(param.getQuality());
            if (DetlDto.has(list, dto)) {
@@ -292,29 +302,29 @@
            if (Cools.isEmpty(mat)) {
                throw new CoolException(detlDto.getMatnr() + "编号商品检索失败，请先添加商品");
            }
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.sync(mat);
            orderDetl.setBatch(detlDto.getBatch());
            orderDetl.setAnfme(detlDto.getAnfme());
            orderDetl.setOrderId(order.getId());
            orderDetl.setOrderNo(order.getOrderNo());
            orderDetl.setCreateBy(9527L);
            orderDetl.setCreateTime(now);
            orderDetl.setUpdateBy(9527L);
            orderDetl.setUpdateTime(now);
            orderDetl.setStatus(1);
            orderDetl.setQty(0.0D);
            orderDetl.setThreeCode(detlDto.getOrderNo());
            orderDetl.setSuppCode(detlDto.getFromOrderNo());
            orderDetl.setMemo(detlDto.getMemo());
            orderDetl.setManu(detlDto.getMark());
            orderDetl.setSupp(detlDto.getSuppName());
            orderDetl.setSku(detlDto.getCustomer());
            orderDetl.setTemp1(detlDto.getTemp1());
            orderDetl.setTemp2(detlDto.getTemp2());
            orderDetl.setTemp3(detlDto.getTemp3());
            orderDetl.setTemp4(detlDto.getTemp4());
            if (!orderDetlService.insert(orderDetl)) {
            OrderDetlPakout orderDetlPakout = new OrderDetlPakout();
            orderDetlPakout.sync(mat);
            orderDetlPakout.setBatch(detlDto.getBatch());
            orderDetlPakout.setAnfme(detlDto.getAnfme());
            orderDetlPakout.setOrderId(order.getId());
            orderDetlPakout.setOrderNo(order.getOrderNo());
            orderDetlPakout.setCreateBy(9527L);
            orderDetlPakout.setCreateTime(now);
            orderDetlPakout.setUpdateBy(9527L);
            orderDetlPakout.setUpdateTime(now);
            orderDetlPakout.setStatus(1);
            orderDetlPakout.setQty(0.0D);
            orderDetlPakout.setThreeCode(detlDto.getOrderNo());
            orderDetlPakout.setSuppCode(detlDto.getFromOrderNo());
            orderDetlPakout.setMemo(detlDto.getMemo());
            orderDetlPakout.setManu(detlDto.getMark());
            orderDetlPakout.setSupp(detlDto.getSuppName());
            orderDetlPakout.setSku(detlDto.getCustomer());
            orderDetlPakout.setTemp1(detlDto.getTemp1());
            orderDetlPakout.setTemp2(detlDto.getTemp2());
            orderDetlPakout.setTemp3(detlDto.getTemp3());
            orderDetlPakout.setTemp4(detlDto.getTemp4());
            if (!orderDetlPakoutService.insert(orderDetlPakout)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }
@@ -325,39 +335,39 @@
        List<OpenOrderCompeteResult> results = new ArrayList<>();
        if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
            // 指定订单
            Order order = orderService.selectByNo(param.getOrderNo());
            OrderPakout order = orderPakoutService.selectByNo(param.getOrderNo());
            if (null != order) {
                OpenOrderCompeteResult result = new OpenOrderCompeteResult();
                results.add(result);
                result.setOrderNo(order.getOrderNo());
                result.setOrderTime(order.getOrderTime());
                result.setOrderType(order.getDocType$());
                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
                for (OrderDetl orderDetl : orderDetls) {
                    result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
                List<OrderDetlPakout> orderDetlPakouts = orderDetlPakoutService.selectByOrderId(order.getId());
                for (OrderDetlPakout orderDetlPakout : orderDetlPakouts) {
                    result.getOrderDetails().add(new DetlDto(orderDetlPakout.getOrderNo(), orderDetlPakout.getMatnr(), orderDetlPakout.getBatch(), orderDetlPakout.getQty()));
                }
                if (order.getSettle() == 4L) {
                    // 修改订单状态 4.完成 ===>> 6.已上报
                    if (!orderService.updateSettle(order.getId(), 6L, null)) {
                    if (!orderPakoutService.updateSettle(order.getId(), 6L, null)) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
            }
        } else {
            // 所有订单
            List<Order> orders = orderService.selectList(new EntityWrapper<Order>().eq("settle", 4L));
            for (Order order : orders) {
            List<OrderPakout> orders = orderPakoutService.selectList(new EntityWrapper<OrderPakout>().eq("settle", 4L));
            for (OrderPakout order : orders) {
                OpenOrderCompeteResult result = new OpenOrderCompeteResult();
                results.add(result);
                result.setOrderNo(order.getOrderNo());
                result.setOrderTime(order.getOrderTime());
                result.setOrderType(order.getDocType$());
                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
                for (OrderDetl orderDetl : orderDetls) {
                    result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
                List<OrderDetlPakout> orderDetlPakouts = orderDetlPakoutService.selectByOrderId(order.getId());
                for (OrderDetlPakout orderDetlPakout : orderDetlPakouts) {
                    result.getOrderDetails().add(new DetlDto(orderDetlPakout.getOrderNo(), orderDetlPakout.getMatnr(), orderDetlPakout.getBatch(), orderDetlPakout.getQty()));
                }
                // 修改订单状态 4.完成 ===>> 6.已上报
                if (!orderService.updateSettle(order.getId(), 6L, null)) {
                if (!orderPakoutService.updateSettle(order.getId(), 6L, null)) {
                    throw new CoolException("服务器内部错误，请联系管理员");
                }
            }
@@ -371,120 +381,6 @@
        return locDetlService.queryStockTotal();
    }

    @Override
    @Transactional
    public void packageUp(PackParam param) {
        if (Cools.isEmpty(param.getBarcode())) {
            throw new CoolException("barcode不能为空");
        }
        Mat analyse = MatUtils.analyseMat(param.getBarcode());
        Pack pack = packService.selectByBarcode(param.getBarcode());
        if (null != pack) {
            throw new CoolException(param.getBarcode() + "重复提交");
        }
        Date now = new Date();
        pack = new Pack(
                param.getBarcode(),    // 条码[非空]
                analyse.getMatnr(),    // 商品编号
                analyse.getBarcode(),    // 序列码
                1L,    // 订单状态
                1,    // 状态
                now,    // 添加时间
                null,    // 添加人员
                now,    // 修改时间
                null,    // 修改人员
                null    // 备注
        );
        if (!packService.insert(pack)) {
            throw new CoolException("服务器内部错误，请联系管理员");
        }

        Mat mat = matService.selectByMatnr(analyse.getMatnr());
        if (mat == null) {
            mat = new Mat();
            // 分类
            Long tagId;
            // 一级分类
            if (!Cools.isEmpty(param.getGroupCode()) && !Cools.isEmpty(param.getGroupName())) {
                Tag priTag = tagService.selectByName(param.getGroupCode(), 2);
                if (priTag == null) {
                    Tag top = tagService.getTop();
                    NodeUtils nodeUtils = new NodeUtils();
                    nodeUtils.executePath(top.getId());
                    priTag = new Tag(
                            null,    // 编号
                            param.getGroupCode(),    // 名称
                            top.getId(),    // 父级
                            top.getName(),    // 父级名称
                            nodeUtils.path.toString(),    // 关联路径
                            nodeUtils.pathName.toString(),    // 关联路径名
                            0,    // 类型
                            null,    // 负责人
                            null,    // 图片
                            null,    // 简要描述
                            null,    // 数量
                            2,    // 等级
                            null,    // 排序
                            1,    // 状态
                            now,    // 添加时间
                            null,    // 添加人员
                            now,    // 修改时间
                            null,    // 修改人员
                            null    // 备注
                    );
                    if (tagMapper.insert(priTag) == 0) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
                // 二级分类
                Tag secTag = tagService.selectByName(param.getGroupName(), 3);
                if (secTag == null) {
                    NodeUtils nodeUtils = new NodeUtils();
                    nodeUtils.executePath(priTag.getId());
                    secTag = new Tag(
                            null,    // 编号
                            param.getGroupName(),    // 名称
                            priTag.getId(),    // 父级
                            priTag.getName(),    // 父级名称
                            nodeUtils.path.toString(),    // 关联路径
                            nodeUtils.pathName.toString(),    // 关联路径名
                            0,    // 类型
                            null,    // 负责人
                            null,    // 图片
                            null,    // 简要描述
                            null,    // 数量
                            3,    // 等级
                            null,    // 排序
                            1,    // 状态
                            now,    // 添加时间
                            null,    // 添加人员
                            now,    // 修改时间
                            null,    // 修改人员
                            null    // 备注
                    );
                    if (tagMapper.insert(secTag) == 0) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
                tagId = secTag.getId();
            } else {
                tagId = tagService.getTop().getId();
            }
            mat.setTagId(tagId);
            mat.setMatnr(analyse.getMatnr());
            mat.setMaktx(param.getMaterialName());
            mat.setSpecs(param.getConfigureDesc());
            mat.setModel(analyse.getModel());
            mat.setStatus(1);
            mat.setCreateTime(now);
            mat.setUpdateTime(now);
            if (!matService.insert(mat)) {
                throw new CoolException("服务器内部错误，请联系管理员");
            } else {
                log.info("打包上线添加新物料[商品编号：{}]", mat.getMatnr());
            }
        }
    }

    @Override
    @Transactional
@@ -595,35 +491,6 @@
                }
            }


            //Tag tag = tagService.selectOne(new EntityWrapper<Tag>().eq("memo", matParam.getTagId()));
//            if (tag == null) {
//                throw new CoolException("出错，未找到分类");
//            }
//            if (mat == null) {
//                mat = new Mat();
//                mat.sync(matParam);
////            mat.setMatnr(param.getMatnr());
////            mat.setMaktx(param.getMaktx());
////            mat.setSpecs(param.getSpecs());
////            mat.setModel(param.getModel());
//
//                mat.setTagId(tag.getId());
//                mat.setStatus(1);
//                mat.setCreateTime(now);
//                mat.setUpdateTime(now);
//                if (!matService.insert(mat)) {
//                    throw new CoolException("服务器内部错误，请联系管理员");
//                } else {
//                    log.info("同步新物料[商品编号：{}]", mat.getMatnr());
//                }
//            } else {
//                mat.sync(matParam);
//                mat.setTagId(tag.getId());
//                if (!matService.update(mat, new EntityWrapper<Mat>().eq("matnr",matParam.getMatnr()))) {
//                    throw new CoolException("更新已存在商品信息失败，请联系管理员");
//                }
//            }
        }

    }
@@ -644,7 +511,7 @@
                    if (wrkDetlLog.getOrderNo() != null && !wrkDetlLog.getOrderNo().isEmpty()) {
                        LocDetlByTimeDTO locDetlByTimeDTO = new LocDetlByTimeDTO();
                        if (!Cools.isEmpty(wrkDetlLog.getOrderNo())) {
                            Order order = orderService.selectByNo(wrkDetlLog.getOrderNo());
                            OrderPakout order = orderPakoutService.selectByNo(wrkDetlLog.getOrderNo());
                            if (!Cools.isEmpty(order)) {
                                locDetlByTimeDTO.setDate(order.getOrderTime());
                                locDetlByTimeDTO.setWarehouse(order.getItemName());
@@ -665,26 +532,6 @@
            }

        });
//        if (!Cools.isEmpty(locDetls)) {
//            for (LocDetl locDetl : locDetls) {
//
//                if (!Cools.isEmpty(locDetl.getOrderNo())){
//                    Order order = orderService.selectByNo(locDetl.getOrderNo());
//                    if (!Cools.isEmpty(order)) {
//                        locDetlByTimeDTO.setDate(order.getOrderTime());
//                        locDetlByTimeDTO.setWarehouse(order.getItemName());
//                        locDetlByTimeDTO.setOrderType(order.getDocType().toString());
//                    }
//                }
//
//                locDetlByTimeDTO.setMatnr(locDetl.getMatnr());
//                locDetlByTimeDTO.setLocNo(locDetl.getLocNo());
//                locDetlByTimeDTO.setBatch(locDetl.getBatch());
//                locDetlByTimeDTO.setAnfme(locDetl.getAnfme());
//                locDetlByTimeDTO.setOrderNo(locDetl.getOrderNo());
//                locDetlByTimeDTOS.add(locDetlByTimeDTO);
//            }
//        }
        return locDetlByTimeDTOS;
    }

@@ -830,18 +677,38 @@

    @Transactional
    @Override
    public void orderDelete(String orderNo) {
        Order order = orderService.selectByNo(orderNo);
    public void orderPakinDelete(String orderNo) {
        OrderPakin order = orderPakinService.selectByNo(orderNo);
        if (order == null) {
            throw new CoolException("未查询到对应订单信息");
        }
        if (order.getSettle() != 1) {
            throw new CoolException("该订单已有对应任务，禁止删除");
        }
        List<OrderDetl> OrderDetl = orderDetlService.selectList(new EntityWrapper<OrderDetl>().eq("order_no", orderNo));
        if (!Cools.isEmpty(OrderDetl)) {
            orderDetlService.delete(new EntityWrapper<OrderDetl>().eq("order_no", orderNo));
        List<OrderDetlPakout> OrderDetlPakout = orderDetlPakoutService.selectList(new EntityWrapper<OrderDetlPakout>().eq("order_no", orderNo));
        if (!Cools.isEmpty(OrderDetlPakout)) {
            orderDetlPakinService.delete(new EntityWrapper<OrderDetlPakin>().eq("order_no", orderNo));
        }
        orderService.delete(new EntityWrapper<Order>().eq("order_no", orderNo));
        orderPakinService.delete(new EntityWrapper<OrderPakin>().eq("order_no", orderNo));


    }

    @Transactional
    @Override
    public void orderPakoutDelete(String orderNo) {

        OrderPakout orderPakout = orderPakoutService.selectByNo(orderNo);
        if (orderPakout == null) {
            throw new CoolException("未查询到对应订单信息");
        }
        if (orderPakout.getSettle() != 1) {
            throw new CoolException("该订单已有对应任务，禁止删除");
        }
        List<OrderDetlPakout> orderDetlPakins = orderDetlPakoutService.selectList(new EntityWrapper<OrderDetlPakout>().eq("order_no", orderNo));
        if (!Cools.isEmpty(orderDetlPakins)) {
            orderDetlPakoutService.delete(new EntityWrapper<OrderDetlPakout>().eq("order_no", orderNo));
        }
        orderPakoutService.delete(new EntityWrapper<OrderPakout>().eq("order_no", orderNo));
    }
}