package com.zy.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.SnowflakeIdWorker;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.OpenOrderCompeteResult;
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 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.Date;
import java.util.List;

/**
 * Created by vincent on 2022/4/9
 */
@Slf4j
@Service
public class OpenServiceImpl implements OpenService {

    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
    private DocTypeService docTypeService;
    @Autowired
    private MatService matService;
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private TagService tagService;
    @Autowired
    private TagMapper tagMapper;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private WrkMastLogServiceImpl wrkMastLogService;
    @Autowired
    private WrkDetlLogServiceImpl wrkDetlLogService;

    @Autowired
    private ApiLogService apiLogService;

    public void callApiLogSaveOrder(Object order, String name, Boolean bool) {
        apiLogService.save(name, "null", null, null,
                JSON.toJSONString(order),
                null, bool);
    }

    @Override
    @Transactional
    public void pakinOrderCreate(OpenOrderPakinParam param) {
        callApiLogSaveOrder(param, "入库单", true);

        OrderPakin order = orderService.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<OrderPakin>().eq("order_no", param.getOrderNo()));
            boolean orderNo1 = orderDetlService.delete(new EntityWrapper<OrderDetlPakout>().eq("order_no", param.getOrderNo()));

        }
        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 OrderPakin(
                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
                param.getOrderNo(),    // 订单编号
                param.getInboundDate(),    // 单据日期
                docType.getDocId(),    // 单据类型
                null,    // 项目编号
                param.getWarehouse(),    //仓库 itemName
                null,    // 调拨项目编号
                param.getOriginWarehouse(),    // 初始票据号 来源仓库
                param.getDepartment(),    // 票据号
                null,    // 客户编号
                param.getSuppliers(),    // 供应商 cstmrName
                null,    // 联系方式
                param.getUser(),    // 制单人
                null,    // 合计金额
                null,    // 优惠率
                null,    // 优惠金额
                null,    // 销售或采购费用合计
                null,    // 实付金额
                null,    // 付款类型
                param.getSalesman(),    // 业务员
                null,    // 结算天数
                null,    // 邮费支付类型
                null,    // 邮费
                null,    // 付款时间
                null,    // 发货时间
                param.getBusinessType(),    // 物流名称
                null,    // 物流单号
                1L,    // 订单状态
                1,    // 状态
                9527L,    // 添加人员
                now,    // 添加时间
                9527L,    // 修改人员
                now,    // 修改时间
                null    // 备注
        );
        //order.setShipCode(String.valueOf(param.getDetails().get(0).getQuality()));
        if (!orderService.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()
                    , 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;
                detlDto.setAnfme(detlDto.getAnfme() + detail.getAnfme());
            } else {
                list.add(dto);
            }
        }
        for (DetlDto detlDto : list) {
            Mat mat = matService.selectByMatnr(detlDto.getMatnr());
            if (Cools.isEmpty(mat)) {
                throw new CoolException(detlDto.getMatnr() + "编号商品检索失败，请先添加商品");
            }
            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());
            orderDetlPakout.setInspect(detlDto.getQuality());
            if (!orderDetlService.insert(orderDetlPakout)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }
    }

    @Override
    @Transactional
    public List<OpenOrderCompeteResult> pakinOrderComplete(OpenOrderCompleteParam param) {
        callApiLogSaveOrder(param, "出库单", true);
        List<OpenOrderCompeteResult> results = new ArrayList<>();
        if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
            // 指定订单
            OrderPakin order = orderService.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<OrderDetlPakout> orderDetlPakouts = orderDetlService.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)) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
            }
        } else {
            // 所有订单
            List<OrderPakin> orders = orderService.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<OrderDetlPakout> orderDetlPakouts = orderDetlService.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)) {
                    throw new CoolException("服务器内部错误，请联系管理员");
                }
            }
        }
        return results;
    }

    @Override
    @Transactional
    public void pakoutOrderCreate(OpenOrderPakoutParam param) {
        callApiLogSaveOrder(param, "出库单", true);
        OrderPakin order = orderService.selectByNo(param.getOrderNo());
        // 如果单据不存在则添加；如果单据存在，作业中无法修改，反之则修改单据
        if (!Cools.isEmpty(order)) {
            if (order.getSettle() > 1L) {
                throw new CoolException(param.getOrderNo() + "正在出库，无法修改单据");
            }
            orderService.remove(order.getId());
        }
        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 OrderPakin(
                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
                param.getOrderNo(),    // 订单编号
                param.getInboundDate(),    // 单据日期
                docType.getDocId(),    // 单据类型
                null,    // 项目编号
                param.getWarehouse(),    //仓库 itemName
                null,    // 调拨项目编号
                param.getOriginWarehouse(),    // 初始票据号 来源仓库
                param.getDepartment(),    // 票据号
                null,    // 客户编号
                param.getSuppliers(),    // 供应商 cstmrName
                null,    // 联系方式
                param.getUser(),    // 制单人
                null,    // 合计金额
                null,    // 优惠率
                null,    // 优惠金额
                null,    // 销售或采购费用合计
                null,    // 实付金额
                null,    // 付款类型
                param.getSalesman(),    // 业务员
                null,    // 结算天数
                null,    // 邮费支付类型
                null,    // 邮费
                null,    // 付款时间
                null,    // 发货时间
                param.getBusinessType(),    // 物流名称
                null,    // 物流单号
                1L,    // 订单状态
                1,    // 状态
                9527L,    // 添加人员
                now,    // 添加时间
                9527L,    // 修改人员
                now,    // 修改时间
                null    // 备注
        );
        order.setShipCode(param.getQuality());
        if (!orderService.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(), 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)) {
                DetlDto detlDto = DetlDto.find(list, dto.getMatnr(), dto.getBatch());
                assert detlDto != null;
                detlDto.setAnfme(detlDto.getAnfme() + detail.getAnfme());
            } else {
                list.add(dto);
            }
        }
        for (DetlDto detlDto : list) {
            Mat mat = matService.selectByMatnr(detlDto.getMatnr());
            if (Cools.isEmpty(mat)) {
                throw new CoolException(detlDto.getMatnr() + "编号商品检索失败，请先添加商品");
            }
            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 (!orderDetlService.insert(orderDetlPakout)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }
    }

    @Override
    public List<OpenOrderCompeteResult> pakoutOrderComplete(OpenOrderCompleteParam param) {
        List<OpenOrderCompeteResult> results = new ArrayList<>();
        if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
            // 指定订单
            OrderPakin order = orderService.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<OrderDetlPakout> orderDetlPakouts = orderDetlService.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)) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
            }
        } else {
            // 所有订单
            List<OrderPakin> orders = orderService.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<OrderDetlPakout> orderDetlPakouts = orderDetlService.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)) {
                    throw new CoolException("服务器内部错误，请联系管理员");
                }
            }
        }
        return results;
    }

    @Override
    @Transactional
    public List<StockVo> queryStock() {
        return locDetlService.queryStockTotal();
    }



    @Override
    @Transactional
    public void syncMat(MatSyncParam param) {
        if (Cools.isEmpty(param.getMatDetails()) || param.getMatDetails().size() <= 0) {
            throw new CoolException("商品数据为空");
        }


        for (MatSyncParam.MatParam matParam : param.getMatDetails()) {
            if (Cools.isEmpty(matParam.getMatnr())) {
                throw new CoolException("商品编码不能为空");
            }

            Date now = new Date();
            Mat mat = matService.selectByMatnr(matParam.getMatnr());
            // 分类
            Long tagId;
            // 一级分类
            if (!Cools.isEmpty(matParam.getTagId()) && !Cools.isEmpty(matParam.getGroupName())) {
                Tag priTag = tagService.selectByName(matParam.getTagId(), 1);
                if (priTag == null) {
                    Tag top = tagService.getTop();
                    NodeUtils nodeUtils = new NodeUtils();
                    nodeUtils.executePath(top.getId());
                    priTag = new Tag(
                            null,    // 编号
                            matParam.getTagId(),    // 名称
                            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(matParam.getGroupName(), 2);
                if (secTag == null) {
                    NodeUtils nodeUtils = new NodeUtils();
                    nodeUtils.executePath(priTag.getId());
                    secTag = new Tag(
                            null,    // 编号
                            matParam.getGroupName(),    // 名称
                            priTag.getId(),    // 父级
                            priTag.getName(),    // 父级名称
                            nodeUtils.path.toString(),    // 关联路径
                            nodeUtils.pathName.toString(),    // 关联路径名
                            0,    // 类型
                            null,    // 负责人
                            null,    // 图片
                            null,    // 简要描述
                            null,    // 数量
                            2,    // 等级
                            null,    // 排序
                            1,    // 状态
                            now,    // 添加时间
                            null,    // 添加人员
                            now,    // 修改时间
                            null,    // 修改人员
                            null    // 备注
                    );
                    if (tagMapper.insert(secTag) == 0) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
                tagId = secTag.getId();
            } else {
                tagId = tagService.getTop().getId();
            }
            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(tagId);
                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(tagId);
                if (!matService.update(mat, new EntityWrapper<Mat>().eq("matnr", matParam.getMatnr()))) {
                    throw new CoolException("更新已存在商品信息失败，请联系管理员");
                }
            }


            //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("更新已存在商品信息失败，请联系管理员");
//                }
//            }
        }

    }


    @Override
    public List<LocDetlByTimeDTO> selectTimeLocDetl(TimeSelectParam param) {
        ArrayList<LocDetlByTimeDTO> locDetlByTimeDTOS = new ArrayList<>();
        EntityWrapper<WrkMastLog> wrkMastLogEntityWrapper = new EntityWrapper<>();
        wrkMastLogEntityWrapper.ge("modi_time", param.getStartTime());
        wrkMastLogEntityWrapper.le("modi_time", param.getEndTime());
//        wrkMastLogEntityWrapper.isNotNull("sheet_no");
        wrkMastLogService.selectList(wrkMastLogEntityWrapper).forEach(wrkMastLog -> {
            if (wrkMastLog.getWrkSts() == 5 || wrkMastLog.getWrkSts() == 15) {
                List<WrkDetlLog> wrkDetlLogs = wrkDetlLogService.selectList(new EntityWrapper<WrkDetlLog>()
                        .eq("wrk_no", wrkMastLog.getWrkNo()).eq("zpallet", wrkMastLog.getBarcode()));
                wrkDetlLogs.forEach(wrkDetlLog -> {
                    if (wrkDetlLog.getOrderNo() != null && !wrkDetlLog.getOrderNo().isEmpty()) {
                        LocDetlByTimeDTO locDetlByTimeDTO = new LocDetlByTimeDTO();
                        if (!Cools.isEmpty(wrkDetlLog.getOrderNo())) {
                            OrderPakin order = orderService.selectByNo(wrkDetlLog.getOrderNo());
                            if (!Cools.isEmpty(order)) {
                                locDetlByTimeDTO.setDate(order.getOrderTime());
                                locDetlByTimeDTO.setWarehouse(order.getItemName());
                                locDetlByTimeDTO.setOrderType(order.getDocType$());
                            }
                            locDetlByTimeDTO.setMatnr(wrkDetlLog.getMatnr());
                            locDetlByTimeDTO.setLocNo(wrkMastLog.getIoType() < 100 ? wrkMastLog.getLocNo() : wrkMastLog.getSourceLocNo());
                            locDetlByTimeDTO.setBatch(wrkDetlLog.getBatch());
                            locDetlByTimeDTO.setAnfme(wrkDetlLog.getAnfme());
                            locDetlByTimeDTO.setOrderNo(wrkDetlLog.getOrderNo());
                            locDetlByTimeDTO.setMark(wrkDetlLog.getManu());
                            locDetlByTimeDTO.setWorkNo(wrkDetlLog.getWrkNo().toString());
                            locDetlByTimeDTOS.add(locDetlByTimeDTO);
                        }
                    }

                });
            }

        });
//        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;
    }

    @Override
    @Transactional
    public boolean agvHaiKang(String wrkNo) {
        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", Long.parseLong(wrkNo)));
        wrkMast.setWrkSts(wrkMast.getWrkStsComplete());
        wrkMastService.updateById(wrkMast);
        return true;
    }

    @Override
    @Transactional
    public void syncTag(List<TagParam> param) {

        param.forEach(tag -> {
            // 分类
            Long tagId;
            Date now = new Date();
            if (Cools.isEmpty(tag.getParentItemClassId())) {
                Tag priTag = tagService.selectByName("全部", 1);

                // 二级分类
                Tag secTag = tagService.selectByName(tag.getName(), 2);
                if (secTag == null) {
                    NodeUtils nodeUtils = new NodeUtils();
                    nodeUtils.executePath(priTag.getId());
                    secTag = new Tag(
                            null,    // 编号
                            tag.getName(),    // 名称
                            priTag.getId(),    // 父级
                            priTag.getName(),    // 父级名称
                            nodeUtils.path.toString(),    // 关联路径
                            nodeUtils.pathName.toString(),    // 关联路径名
                            0,    // 类型
                            null,    // 负责人
                            null,    // 图片
                            null,    // 简要描述
                            null,    // 数量
                            2,    // 等级
                            null,    // 排序
                            1,    // 状态
                            now,    // 添加时间
                            null,    // 添加人员
                            now,    // 修改时间
                            null,    // 修改人员
                            tag.getItemClassId()    // 备注
                    );
                    if (tagMapper.insert(secTag) == 0) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
            } else {
                Tag priTag = tagService.selectOne(new EntityWrapper<Tag>().eq("memo", tag.getParentItemClassId()));
                if (priTag == null) {
                    Tag top = tagService.getTop();
                    NodeUtils nodeUtils = new NodeUtils();
                    nodeUtils.executePath(top.getId());
                    priTag = new Tag(
                            null,    // 编号
                            tag.getParentName(),    // 名称
                            top.getId(),    // 父级
                            top.getName(),    // 父级名称
                            nodeUtils.path.toString(),    // 关联路径
                            nodeUtils.pathName.toString(),    // 关联路径名
                            0,    // 类型
                            null,    // 负责人
                            null,    // 图片
                            null,    // 简要描述
                            null,    // 数量
                            2,    // 等级
                            null,    // 排序
                            1,    // 状态
                            now,    // 添加时间
                            null,    // 添加人员
                            now,    // 修改时间
                            null,    // 修改人员
                            tag.getParentItemClassId()    // 备注
                    );
                    if (tagMapper.insert(priTag) == 0) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }

                // 二级分类
                Tag secTag = tagService.selectOne(new EntityWrapper<Tag>().eq("memo", tag.getItemClassId()));
                NodeUtils nodeUtils = new NodeUtils();
                nodeUtils.executePath(priTag.getId());
                if (secTag == null) {
                    secTag = new Tag(
                            null,    // 编号
                            tag.getName(),    // 名称
                            priTag.getId(),    // 父级
                            priTag.getName(),    // 父级名称
                            nodeUtils.path.toString(),    // 关联路径
                            nodeUtils.pathName.toString(),    // 关联路径名
                            0,    // 类型
                            null,    // 负责人
                            null,    // 图片
                            null,    // 简要描述
                            null,    // 数量
                            2,    // 等级
                            null,    // 排序
                            1,    // 状态
                            now,    // 添加时间
                            null,    // 添加人员
                            now,    // 修改时间
                            null,    // 修改人员
                            tag.getItemClassId()    // 备注
                    );
                    if (tagMapper.insert(secTag) == 0) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                } else {
                    secTag.setName(tag.getName());
                    secTag.setParentId(priTag.getId());
                    secTag.setParentName(priTag.getName());
                    secTag.setPath(nodeUtils.path.toString());
                    secTag.setPathName(nodeUtils.pathName.toString());
                    if (tagMapper.updateById(secTag) == 0) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }

                    List<Tag> tags = tagService.selectList(new EntityWrapper<Tag>().eq("parent_id", secTag.getId()));
                    if (!Cools.isEmpty(tags)) {
                        for (Tag tag1 : tags) {
                            tag1.setPath(nodeUtils.path.toString() + "," + secTag.getId());
                            tag1.setPathName(nodeUtils.pathName.toString() + "," + secTag.getName());
                            if (tagMapper.updateById(tag1) == 0) {
                                throw new CoolException("服务器内部错误，请联系管理员");
                            }
                        }
                    }


                }


            }
        });
    }

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