package com.huaheng.api.mes.controller;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.mes.dto.*;
import com.huaheng.api.mes.dto.otherReceipt.OtherReceiptDetail;
import com.huaheng.api.mes.dto.otherReceipt.OtherReceiptHeader;
import com.huaheng.api.mes.result.ReturnInfo;
import com.huaheng.api.mes.service.IMesService;
import com.huaheng.api.mes.utils.CallaMOM;
import com.huaheng.api.mes.utils.SqlServer;
import com.huaheng.api.mes.vo.InventoryVO;
import com.huaheng.api.mes.vo.InventoryTransactionVO;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.reflect.ReflectUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.aspectj.lang.annotation.ApiLogger;
import com.huaheng.framework.web.controller.BaseController;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.framework.web.domain.RetCode;
import com.huaheng.pc.config.address.service.AddressService;
import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;
import com.huaheng.pc.inventory.inventoryTransaction.domain.InventoryTransaction;
import com.huaheng.pc.inventory.inventoryTransaction.service.InventoryTransactionService;
import com.huaheng.pc.momLog.service.IMomLogService;
import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail;
import com.huaheng.pc.receipt.receiptDetail.service.ReceiptDetailService;
import com.huaheng.pc.receipt.receiptDetailHistory.domain.ReceiptDetailHistory;
import com.huaheng.pc.receipt.receiptDetailHistory.service.ReceiptDetailHistoryService;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
import com.huaheng.pc.receipt.receiptHeaderHistory.domain.ReceiptHeaderHistory;
import com.huaheng.pc.receipt.receiptHeaderHistory.service.ReceiptHeaderHistoryService;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;
import com.huaheng.pc.shipment.shipmentDetail.service.ShipmentDetailService;
import com.huaheng.pc.shipment.shipmentDetailHistory.domain.ShipmentDetailHistory;
import com.huaheng.pc.shipment.shipmentDetailHistory.service.ShipmentDetailHistoryService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;
import com.huaheng.pc.shipment.shipmentHeaderHistory.domain.ShipmentHeaderHistory;
import com.huaheng.pc.shipment.shipmentHeaderHistory.service.ShipmentHeaderHistoryService;
import com.huaheng.pc.system.user.domain.User;
import com.huaheng.pc.system.user.service.IUserService;
import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;


@RestController
@Slf4j
@RequestMapping("/API/WMS/v2")
public class MesReceiptController extends BaseController {

    @Resource
    private ReceiptHeaderService receiptHeaderService;

    @Resource
    private ReceiptDetailService receiptDetailService;

    @Resource
    private ShipmentHeaderService shipmentHeaderService;

    @Resource
    private ShipmentDetailService shipmentDetailService;

    @Resource
    private InventoryDetailService inventoryDetailService;

    @Resource
    private TaskDetailService taskDetailService;
    @Resource
    private ShipmentDetailHistoryService shipmentDetailHistoryService;
    @Resource
    private ReceiptDetailHistoryService receiptDetailHistoryService;
    @Resource
    private InventoryTransactionService inventoryTransactionService;

    @Resource
    private ShipmentHeaderHistoryService shipmentHeaderHistoryService;
    @Resource
    private ReceiptHeaderHistoryService receiptHeaderHistoryService;
    @Resource
    private MaterialService materialService;

    @Resource
    private IMomLogService momLogService;
    @Resource
    private IMesService mesService;
    @Resource
    private IUserService userService;

    @Resource
    private AddressService addressService;

    @PostMapping("/receipt")
    @ApiLogger(apiName = "添加入库单及其明细", from = "ROBOT")
    @ApiOperation("添加入库单及其明细")
    public AjaxResult receipt(@RequestBody ReceiptDTO receiptDTO) {
        AjaxResult ajaxResult = handleQuest("receipt", new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                return mesService.receipt(receiptDTO);
            }
        });
        return ajaxResult;
    }


    /**
     * 添加出库单及其明细
     *
     * @param receiptDTO
     * @return
     */
    @PostMapping("/shipment")
    @ApiLogger(apiName = "添加出库单及其明细", from = "ROBOT")
    @ApiOperation("添加出库单及其明细")
    public AjaxResult shipment(@RequestBody ReceiptDTO receiptDTO) {
        AjaxResult ajaxResult = handleQuest("shipment", new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                return mesService.shipment(receiptDTO);
            }
        });
        return ajaxResult;
    }

    private JSONObject getJsonObject(Header header, List<Detail> details) {
        JSONObject data = new JSONObject();
        JSONObject Rd_In_M = new JSONObject();
        Rd_In_M.put("MGPK", header.getId());
        Rd_In_M.put("cCode", header.getReferCode());
        JSONArray Rd_In_S = new JSONArray();
        details.forEach(detail -> {
            JSONObject json = new JSONObject();
            json.put("MGPK", header.getId());
            json.put("SGPK", detail.getId());
            json.put("cInvCode", detail.getMaterialCode());
            Rd_In_S.add(json);
        });
        data.put("Requester", "WMS");
        data.put("Rd_In_M", Rd_In_M);
        data.put("Rd_In_S", Rd_In_S);
        return data;
    }


    /**
     * 入库单参数_判空处理
     *
     * @param ajaxResult
     * @param shipmentHeader
     * @param shipemtnDetails
     */
    //private boolean enterIsNull(AjaxResult ajaxResult, Header shipmentHeader, List<Detail> shipemtnDetails) {
    //
    //    if (isNullData(ajaxResult, shipmentHeader, shipemtnDetails)) {
    //        return true;
    //    }
    //
    //    if (StringUtils.isEmpty(shipmentHeader.getRefeCodeType())) {
    //        ajaxResult.setCode(RetCode.FAIL).setMsg("单据类型不能为空!!!");
    //        return true;
    //    } else if (StringUtils.isEmpty(shipmentHeader.getReferCode())) {
    //        ajaxResult.setCode(RetCode.FAIL).setMsg("单据单号不能为空!!!");
    //        return true;
    //    } else if (shipmentHeader.getTotalQty() == null || shipmentHeader.getTotalQty().intValue() <= 0) {
    //        ajaxResult.setCode(RetCode.FAIL).setMsg("数量不能为空!!!");
    //    }
    //
    //    shipemtnDetails.forEach(shipemtnDetail -> {
    //        if (StringUtils.isEmpty(shipemtnDetail.getMaterialCode())) {
    //            ajaxResult.setCode(RetCode.FAIL).setMsg("物料编码不能为空!!!");
    //        } else if (shipemtnDetail.getTotalQty() == null || shipemtnDetail.getQty().intValue() <= 0) {
    //            ajaxResult.setCode(RetCode.FAIL).setMsg("数量不能为空!!!");
    //        }
    //    });
    //    return StringUtils.isNotEmpty(ajaxResult.getMsg());
    //}

    /**
     * 出库单参数_判空处理
     *
     * @param ajaxResult
     * @param shipmentHeader
     * @param shipemtnDetails
     */
    private boolean outIsNull(AjaxResult ajaxResult, Header shipmentHeader, List<Detail> shipemtnDetails) {
        if (isNullData(ajaxResult, shipmentHeader, shipemtnDetails)) {
            return true;
        }

        if (StringUtils.isEmpty(shipmentHeader.getReferCode())) {
            ajaxResult.setCode(RetCode.FAIL).setMsg("单据单号不能为空!!!");
            return true;
        }

        shipemtnDetails.forEach(shipemtnDetail -> {
            if (StringUtils.isEmpty(shipemtnDetail.getMaterialCode())) {
                ajaxResult.setCode(RetCode.FAIL).setMsg("物料编码不能为空!!!");
            }
        });
        return StringUtils.isNotEmpty(ajaxResult.getMsg());
    }

    /**
     * 判空处理
     */
    private boolean isNullData(AjaxResult ajaxResult, Header shipmentHeader, List<Detail> shipemtnDetails) {
        if (shipmentHeader == null) {
            ajaxResult.setCode(RetCode.FAIL).setMsg("出库单头表不能为空!!!");
            return true;
        } else if (shipemtnDetails == null || shipemtnDetails.size() < 1) {
            ajaxResult.setCode(RetCode.FAIL).setMsg("出库单明细表集不能为空!!!");
            return true;
        }
        return false;
    }

    /**
     * 入库单单据取消
     */
    @PostMapping("/cancelEnterWarehouse")
    @ApiOperation("入库单单据取消")
    @ApiLogger(apiName = "入库单单据取消", from = "ROBOT")
    public AjaxResult cancelEnterWarehouse(@RequestBody ReceiptDTO receiptDTO) {
        AjaxResult ajaxResult = handleQuest("cancelEnterWarehouse", new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = mesService.cancelEnterWarehouse(receiptDTO);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    /**
     * 出库单单据取消
     */
    @PostMapping("/cancelOutWarehouse")
    @ApiOperation("出库单单据取消")
    @ApiLogger(apiName = "出库单单据取消", from = "ROBOT")
    public AjaxResult cancelOutWarehouse(@RequestBody ReceiptDTO receiptDTO) {
        AjaxResult ajaxResult = handleQuest("cancelOutWarehouse", new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = mesService.cancelOutWarehouse(receiptDTO);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    //private AjaxResult isNull(Header header, List<Detail> details) {
    //    AjaxResult ajaxResult = new AjaxResult();
    //    boolean isNull = outIsNull(ajaxResult, header, details);
    //    details.forEach(detail -> {
    //        if (detail.getTotalQty() == null || detail.getTotalQty().intValue() <= 0) {
    //            ajaxResult.setCode(RetCode.FAIL).setMsg("总数量不能为空!!!");
    //        }
    //    });
    //    if (isNull || StringUtils.isNotEmpty(ajaxResult.getMsg())) {
    //        return ajaxResult;
    //    }
    //    return ajaxResult;
    //}

    /**
     * 查询库存
     */
    @PostMapping("/searchInventory")
    @ApiLogger(apiName = "查询库存", from = "ROBOT")
    public AjaxResult searchInventory(@RequestBody Detail detailed) {


        //List<ShipmentHeader> shipmentHeaders = shipmentHeaderService.list(new LambdaQueryWrapper<ShipmentHeader>()
        //        .gt(ShipmentHeader::getFirstStatus, QuantityConstant.SHIPMENT_CONTAINER_BUILD)
        //        .ne(ShipmentHeader::getPushSuccessStatus, 1));
        //
        //List<ShipmentDetail> shipmentDetails = new ArrayList<>();
        //for (ShipmentHeader shipmentHeader : shipmentHeaders) {
        //    List<ShipmentDetail> details = shipmentDetailService.list(new LambdaQueryWrapper<ShipmentDetail>()
        //            .gt(ShipmentDetail::getTaskQty, 0)
        //            .eq(ShipmentDetail::getShipmentId, shipmentHeader.getId()));
        //    shipmentDetails.addAll(details);
        //}

        String materialName = detailed.getMaterialName();
        String materialCode = detailed.getMaterialCode();
        String containerCode = detailed.getContainerCode();

        LambdaQueryWrapper<InventoryDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();
        // 物料编码
        if (StringUtils.isNotEmpty(materialName)) {
            lambdaQueryWrapper.eq(InventoryDetail::getMaterialName, materialName);
        }
        // 物料名称
        if (StringUtils.isNotEmpty(materialCode)) {
            lambdaQueryWrapper.eq(InventoryDetail::getMaterialCode, materialCode);
        }
        // 托盘号
        if (StringUtils.isNotEmpty(containerCode)) {
            lambdaQueryWrapper.eq(InventoryDetail::getContainerCode, containerCode);
        }

        if (StringUtils.isEmpty(materialName) && StringUtils.isEmpty(containerCode) && StringUtils.isEmpty(containerCode)) {
            lambdaQueryWrapper.gt(InventoryDetail::getQty, 0);
        }
        List<InventoryDetail> detailList = inventoryDetailService.list(lambdaQueryWrapper);

        List<InventoryVO> inventoryVOList = new ArrayList<>();
        detailList.forEach(detail -> {
            InventoryVO inventoryVO = new InventoryVO();
            BeanUtils.copyProperties(detail, inventoryVO);
            if (StringUtils.isBlank(detail.getWarehouse())) {
                inventoryVO.setWarehouse("035");
            } else {
                inventoryVO.setWarehouse(detail.getWarehouse());
            }
            inventoryVOList.add(inventoryVO);
        });

        return AjaxResult.success(inventoryVOList);

    }


    /**
     * 查询已出库部分的库存
     * 物料编码、物料名称、已出数量、仓库编码（warehouse）
     */
    @PostMapping("/queryOutboundInventory")
    @ApiLogger(apiName = "查询已出库部分的库存", from = "ROBOT")
    public AjaxResult queryOutboundInventory(@RequestBody Detail detailed) {

        // 查询符合条件的 ShipmentHeader 集合
        List<ShipmentHeader> shipmentHeaders = shipmentHeaderService.list(new LambdaQueryWrapper<ShipmentHeader>()
                .ne(ShipmentHeader::getFirstStatus, QuantityConstant.RECEIPT_HEADER_RETURN)
                .ne(ShipmentHeader::getDeleted, true));
        List<ShipmentDetail> shipmentDetailList = new ArrayList<>();
        // 查询符合条件的 ShipmentDetail 集合
        for (ShipmentHeader shipmentHeader : shipmentHeaders) {
            List<ShipmentDetail> shipmentDetails = shipmentDetailService.list(new LambdaQueryWrapper<ShipmentDetail>()
                    .ne(ShipmentDetail::getTaskQty, 0)
                    .eq(ShipmentDetail::getShipmentId, shipmentHeader.getId()));
            shipmentDetailList.addAll(shipmentDetails);
        }

        //查询符合条件的 库存交易 集合
        List<InventoryTransaction> its = new ArrayList<>();
        for (ShipmentDetail shipmentDetail : shipmentDetailList) {
            List<InventoryTransaction> inventoryTransactions = inventoryTransactionService.list(new LambdaQueryWrapper<InventoryTransaction>()
                    .eq(InventoryTransaction::getTransactionType, 20)
                    .eq(InventoryTransaction::getBillDetailId, shipmentDetail.getId()));
            if (inventoryTransactions.size() > 1) {
                // 如果查出多条数据，将taskQty字段由负数转为正数，并将taskQty的值全部累加放入第一个InventoryTransaction对象中
                InventoryTransaction firstTransaction = inventoryTransactions.get(0);
                BigDecimal totalTaskQty = BigDecimal.ZERO;
                for (int i = 1; i < inventoryTransactions.size(); i++) {
                    InventoryTransaction transaction = inventoryTransactions.get(i);
                    BigDecimal positiveTaskQty = transaction.getTaskQty().abs();
                    totalTaskQty = totalTaskQty.add(positiveTaskQty);
                }
                firstTransaction.setTaskQty(totalTaskQty);
                its.add(firstTransaction);
                //如果只有一个
            } else if (!inventoryTransactions.isEmpty()) {
                InventoryTransaction inventoryTransaction = inventoryTransactions.get(0);
                inventoryTransaction.setTaskQty(inventoryTransaction.getTaskQty().abs());
                its.add(inventoryTransaction);
            }
        }
        List<InventoryVO> inventoryVOList = new ArrayList<>();
        its.forEach(detail -> {
            InventoryVO inventoryVO = new InventoryVO();
            BeanUtils.copyProperties(detail, inventoryVO);
            if (StringUtils.isBlank(detail.getWarehouse())) {
                inventoryVO.setWarehouse("035");
            } else {
                inventoryVO.setWarehouse(detail.getWarehouse());
            }
            inventoryVOList.add(inventoryVO);
        });

        return AjaxResult.success(inventoryVOList);

    }


    /**
     * 获取出入库单明细记录
     *
     * @return AjaxResult
     */
    @PostMapping("/getShipmentDetail")
    @ApiLogger(apiName = "获取出入库单明细记录", from = "ROBOT")
    @ApiOperation("获取出入库单明细记录")
    public AjaxResult getShipmentDetail(@RequestBody GetOrderHistoryDTO getOrderHistoryDTO) {

        if (StringUtils.isEmpty(getOrderHistoryDTO.getEndTime()) || StringUtils.isEmpty(getOrderHistoryDTO.getStartTime())) {
            return AjaxResult.error("开始时间和结束时间不能为空！！！");
        }
        LambdaQueryWrapper<InventoryTransaction> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper
                .ge(InventoryTransaction::getCreated, getOrderHistoryDTO.getStartTime())
                .le(InventoryTransaction::getCreated, getOrderHistoryDTO.getEndTime());
        List<InventoryTransaction> list = inventoryTransactionService.list(lambdaQueryWrapper);
        List<InventoryTransactionVO> inventoryTransactionVOList = new ArrayList<>();
        list.forEach(inventoryTransaction -> {
            InventoryTransactionVO inventoryTransactionVO = new InventoryTransactionVO();
            BeanUtils.copyProperties(inventoryTransaction, inventoryTransactionVO);
            inventoryTransactionVOList.add(inventoryTransactionVO);
        });
        return AjaxResult.success(inventoryTransactionVOList);
    }

    /**
     * 获取sqlServer数据库中物料信息, 同步到本地数据库中
     */
    @PostMapping("/getAllMaterial")
    @ApiOperation("获取所有外部物料信息")
    public List<Material> getAllMaterial() {
        List<Material> materialList = new ArrayList<>();
        log.error("开始同步物料信息！！！");
        final String SQL_QUERY = "SELECT\n" +
                "\ta.cinvcode AS '存货编码',\n" +
                "\ta.cinvname AS '存货名称',\n" +
                "\ta.cDefWareHouse AS '仓库',\n" +
                "\te.cWhName AS '仓库名称',\n" +
                "\ta.cComUnitCode AS '单位编码',\n" +
                "\tb.cComUnitName AS '单位名称',\n" +
                "\tc.cidefine6 AS '外形尺寸',\n" +
                "\tc.cidefine7 AS '托盘类型',\n" +
                "\ta.dModifyDate AS '修改时间',\n" +
                "\ta.dSDate AS '启用时间',\n" +
                "\ta.cinvstd AS '规格',\n" +
                "\ta.Iinvweight AS '重量',\n" +
                "\tA.CPLANMETHOD AS '属性',\n" +
                "\ta.cinvccode AS '存货类别编码',\n" +
                "\td.cInvCName AS '存货类别名称',\n" +
                "\ta.cSRPolicy AS '供需政策',\n" +
                "\tc.cidefine8 AS '是否批次',\n" +
                "\tc.cidefine9 AS '是否可燃',\n" +
                "\tc.cidefine10 AS '是否平库' \n" +
                "FROM\n" +
                "\tInventory a\n" +
                "left join ComputationUnit b on a.cComUnitCode=b.cComUnitCode\n" +
                "left join Inventory_extradefine c on a.cinvcode=c.cinvcode\n" +
                "left join InventoryClass d on a.cinvccode=d.cinvccode\n" +
                "left join Warehouse e on a.cDefWareHouse = e.cWhCode\n";
        try {
            ResultSet resultSet = SqlServer.find(SQL_QUERY);

            if (resultSet == null) {
                return materialList;
            }
            while (resultSet.next()) {
                // 字段要一致
                Material material = new Material();
                material.setWarehouseCode("CS0001");
                material.setCompanyCode("BHF");

                material.setCode(resultSet.getString("存货编码")); // 物料编码
                material.setName(resultSet.getString("存货名称")); // 物料名称
                material.setDefWareHouse(resultSet.getString("仓库")); // u8仓库
                material.setCWhName(resultSet.getString("仓库名称")); // 单位编码
                material.setUnitCode(resultSet.getString("单位编码"));
                material.setUnit(resultSet.getString("单位名称"));
                material.setPhysicalDimension(resultSet.getString("外形尺寸"));
                material.setIsHigh("高托".equals(resultSet.getString("托盘类型")) ? 1 : 0);
                material.setSpec(resultSet.getString("规格"));
                material.setWeight(resultSet.getString("重量"));
                material.setCinvccode(resultSet.getString("存货类别编码"));
                material.setCInvCName(resultSet.getString("存货类别名称"));
                material.setAttribute(resultSet.getString("属性"));
                material.setPolicy(resultSet.getString("供需政策"));
                material.setIsBatch(resultSet.getString("是否批次"));
                material.setIsFlammable(resultSet.getString("是否可燃"));
                material.setIsFlat(resultSet.getString("是否平库"));
                materialList.add(material);
            }
        } catch (SQLException e) {
            log.error("同步海王物料失败！！！" + e.getMessage());
        }
        return materialList;
    }


    /**
     * 获取sqlServer数据库中物料信息, 同步到本地数据库中
     */
    @PostMapping("/getMaterial")
    @ApiOperation("获取外部物料信息")
    public List<Material> getMaterial() {
        List<Material> materialList = new ArrayList<>();
        log.error("开始同步物料信息！！！");
        // 获取新增一天以内和修改四个小时以内的物料数据
        //DATEDIFF() 函数返回两个日期之间的天数。
        //想还原sql改动，可以用cahtgpt

        final String SQL_QUERY = "SELECT\n" +
                "\ta.cinvcode AS '存货编码',\n" +
                "\ta.cinvname AS '存货名称',\n" +
                "\ta.cDefWareHouse AS '仓库',\n" +
                "\te.cWhName AS '仓库名称',\n" +
                "\ta.cComUnitCode AS '单位编码',\n" +
                "\tb.cComUnitName AS '单位名称',\n" +
                "\tc.cidefine6 AS '外形尺寸',\n" +
                "\tc.cidefine7 AS '托盘类型',\n" +
                "\ta.dModifyDate AS '修改时间',\n" +
                "\ta.dSDate AS '启用时间',\n" +
                "\ta.cinvstd AS '规格',\n" +
                "\ta.Iinvweight AS '重量',\n" +
                "\tA.CPLANMETHOD AS '属性',\n" +
                "\ta.cinvccode AS '存货类别编码',\n" +
                "\td.cInvCName AS '存货类别名称',\n" +
                "\ta.cSRPolicy AS '供需政策',\n" +
                "\tc.cidefine8 AS '是否批次',\n" +
                "\tc.cidefine9 AS '是否可燃',\n" +
                "\tc.cidefine10 AS '是否平库' \n" +
                "FROM\n" +
                "\tInventory a\n" +
                "\tLEFT JOIN ComputationUnit b ON a.cComUnitCode = b.cComUnitCode\n" +
                "\tLEFT JOIN Inventory_extradefine c ON a.cinvcode = c.cinvcode\n" +
                "\tLEFT JOIN InventoryClass d ON a.cinvccode = d.cinvccode\n" +
                "\tLEFT JOIN Warehouse e ON a.cDefWareHouse = e.cWhCode \n" +
                "WHERE\n" +
                "\t(\n" +
                "\t\tdatediff(\n" +
                "\t\t\tDAY,\n" +
                "\t\t\ta.dSDate,\n" +
                "\t\tgetdate ()) = 0 \n" +
                "\t\tOR a.dModifyDate >= DATEADD (\n" +
                "\t\t\tHOUR,\n" +
                "\t\t\t- 4,\n" +
                "\t\tGETDATE ()) \n" +
                "\t)";


        //"\tLEFT JOIN ComputationUnit b ON a.cComUnitCode= b.cComUnitCode\n" +
        //"\tLEFT JOIN Inventory_extradefine c ON a.cinvcode= c.cinvcode\n" +
        //"\tLEFT JOIN InventoryClass d ON a.cinvccode= d.cinvccode\n" +
        //"\tLEFT JOIN Warehouse e ON a.cDefWareHouse = e.cWhCode \n" +
        //"WHERE\n" +
        //"\t(\n" +
        //"\t\tdatediff( DAY, a.dSDate, getdate( ) ) = 0 \n" +
        //"\t\tOR a.dModifyDate >= DATEADD( HOUR, - 4, GETDATE( ) ) \n" +
        //"\t) \n" +
        //"\tAND a.cDefWareHouse IN ( '035', '001', '003' )";

        try {
            ResultSet resultSet = SqlServer.find(SQL_QUERY);

            if (resultSet == null) {
                return materialList;
            }
            while (resultSet.next()) {
                // 字段要一致
                Material material = new Material();
                material.setWarehouseCode("CS0001");
                material.setCompanyCode("BHF");

                material.setCode(resultSet.getString("存货编码")); // 物料编码
                material.setName(resultSet.getString("存货名称")); // 物料名称
                material.setDefWareHouse(resultSet.getString("仓库")); // u8仓库
                material.setCWhName(resultSet.getString("仓库名称")); // 单位编码
                material.setUnitCode(resultSet.getString("单位编码"));
                material.setUnit(resultSet.getString("单位名称"));
                material.setPhysicalDimension(resultSet.getString("外形尺寸"));
                material.setIsHigh("高托".equals(resultSet.getString("托盘类型")) ? 1 : 0);
                material.setSpec(resultSet.getString("规格"));
                material.setWeight(resultSet.getString("重量"));
                material.setCinvccode(resultSet.getString("存货类别编码"));
                material.setCInvCName(resultSet.getString("存货类别名称"));
                material.setAttribute(resultSet.getString("属性"));
                material.setPolicy(resultSet.getString("供需政策"));
                material.setIsBatch(resultSet.getString("是否批次"));
                material.setIsFlammable(resultSet.getString("是否可燃"));
                material.setIsFlat(resultSet.getString("是否平库"));
                materialList.add(material);
            }
        } catch (SQLException e) {
            log.error("同步海王物料失败！！！" + e.getMessage());
        }
        return materialList;
    }

    /**
     * 当前时间向推几小时
     */
    public String dateRoll(int ihour) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 获取当前时间
        LocalDateTime date = LocalDateTime.now();
        // 获取当前时间的前几小时时间
        LocalDateTime localDateTime = date.minusHours(ihour);

        return dateTimeFormatter.format(localDateTime);
    }

    /**
     * 查询站台任务明细列表
     */
    @ApiLogger(apiName = "查询站台任务明细列表", from = "ROBOT")
    @PostMapping("/kanbanInfo")
    @CrossOrigin
    public AjaxResult kanbanInfo(@RequestBody TaskDetail taskDetail) {
        String fromLocation = taskDetail.getFromLocation();
        if (StringUtils.isEmpty(fromLocation)) {
            return AjaxResult.error("站台不能为空!!!");
        }
        LambdaQueryWrapper<TaskDetail> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(TaskDetail::getFromLocation, fromLocation)
                .lt(TaskDetail::getStatus, "100");
        List<TaskDetail> taskDetailList = taskDetailService.list(wrapper);
        return AjaxResult.success(taskDetailList);
    }

    /**
     * post调用E_Rd_In（MOM）入库成功接口
     */
    //@ApiLogger(apiName = "post调用E_Rd_In（MOM）入库接口", from="ROBOT")
    @PostMapping("/postE_Rd_In")
    public ReturnInfo postE_Rd_In(@RequestBody ReceiptDetail receiptDetail) {
        if (StringUtils.isBlank(receiptDetail.getLastUpdatedBy())) {
            receiptDetail.setLastUpdatedBy("");
        }
        User user = userService.selectUserByEmail(receiptDetail.getLastUpdatedBy());
        String loginName = "";
        if (user == null) {
            loginName = "";
        } else {
            loginName = user.getLoginName();
        }
        ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptDetail.getReceiptId());
        JSONObject Rd_In_M = new JSONObject();
        Rd_In_M.put("mno", receiptHeader.getCode());
        Rd_In_M.put("MGPK", receiptHeader.getMOMID());
        Rd_In_M.put("cBusType", receiptHeader.getReceiptType());
        Rd_In_M.put("TAID", receiptHeader.getTAID());
        Rd_In_M.put("FAID", receiptHeader.getFAID());
        Rd_In_M.put("UserNo", loginName);
        Rd_In_M.put("warehouse", receiptHeader.getWarehouse());

        JSONArray jsonArray = new JSONArray();
        JSONObject Rd_In_S = new JSONObject();
        List<TaskDetail> taskDetails = taskDetailService.list(new LambdaQueryWrapper<TaskDetail>()
                .eq(TaskDetail::getInternalTaskType, 100)
                .eq(TaskDetail::getBillDetailId, receiptDetail.getId()));
        String str = computeWarehouseType(taskDetails);
        Rd_In_S.put("cidefine10", str);
        Rd_In_S.put("MGPK", receiptHeader.getMOMID());
        Rd_In_S.put("SGPK", receiptDetail.getMOMID());
        Rd_In_S.put("SNNO", receiptDetail.getSNNO());
        Rd_In_S.put("cInvCode", receiptDetail.getMaterialCode());
        Rd_In_S.put("Iquantity", receiptDetail.getTaskQty());
        Rd_In_S.put("iFQuantity", receiptDetail.getQty());
        //Rd_In_S.put("cwhcode", "");
        Rd_In_S.put("MOCode", receiptDetail.getNoticeNo());
        Rd_In_S.put("ISUrgent", receiptDetail.getIsUrgent());
        Rd_In_S.put("receiptBarcode", receiptDetail.getReceiptBarcode());
        Rd_In_S.put("warehouse", receiptHeader.getWarehouse());
        Rd_In_S.put("warehouseName", receiptHeader.getWarehouseName());
        Rd_In_S.put("creatorCode", loginName);
        Rd_In_S.put("creatorName", receiptDetail.getLastUpdatedBy());
        Rd_In_S.put("productionWorker", receiptHeader.getProductionWorker());
        Rd_In_S.put("productionWorkerName", receiptHeader.getProductionWorkerName());
        Rd_In_S.put("ifrom", receiptDetail.getIfrom());
        Rd_In_S.put("LMPKID", receiptDetail.getLMPKID());
        Rd_In_S.put("LSPKID", receiptDetail.getLSPKID());
        jsonArray.add(Rd_In_S);
        JSONObject data = new JSONObject();
        data.put("Rd_In_M", Rd_In_M);
        data.put("Rd_In_S", jsonArray);

        String action = "E_Rd_In";
        JSONObject json = new JSONObject();
        json.put("data", data);
        return postMOM(action, json, "入库回传");
    }


    /**
     * post调用E_Rd_In（MOM）其他入库成功接口（盘点入库回传）
     */
    //@ApiLogger(apiName = "post调用E_Rd_In（MOM）其他入库接口", from="ROBOT")
    @PostMapping("/postOther_E_Rd_In")
    public ReturnInfo postOther_E_Rd_In(@RequestBody List<ReceiptDetail> receiptDetails, ReceiptHeader receiptHeader) {
        OtherReceiptDomain domain = new OtherReceiptDomain();

        OtherReceiptHeader receiptHeader1 = new OtherReceiptHeader();
        receiptHeader1.setCode(receiptHeader.getCode());
        receiptHeader1.setMomId(receiptHeader.getMOMID());
        receiptHeader1.setReceiptType(receiptHeader.getReceiptType());
        receiptHeader1.setTaId(receiptHeader.getTAID());
        receiptHeader1.setFaId(receiptHeader.getFAID());
        receiptHeader1.setLastUpdatedBy(receiptHeader.getLastUpdatedBy());
        receiptHeader1.setWarehouse(receiptHeader.getWarehouse());
        receiptHeader1.setDepCode(QuantityConstant.DEFAULT_DEPT);
        receiptHeader1.setStock(receiptHeader.getWarehouse());

        List<OtherReceiptDetail> list = new ArrayList<>();
        for (ReceiptDetail receiptDetail : receiptDetails) {
            OtherReceiptDetail detail = new OtherReceiptDetail();
            List<TaskDetail> taskDetails = taskDetailService.list(new LambdaQueryWrapper<TaskDetail>()
                    .eq(TaskDetail::getInternalTaskType, 100)
                    .eq(TaskDetail::getBillDetailId, receiptDetail.getId()));
            String str = computeWarehouseType(taskDetails);
            detail.setIsFlat(str);
            detail.setMomIdByHeader(receiptHeader.getMOMID());
            detail.setMomId(receiptDetail.getMOMID());
            detail.setSnNo(receiptDetail.getSNNO());
            detail.setMaterialCode(receiptDetail.getMaterialCode());
            detail.setTaskQty(receiptDetail.getTaskQty());
            detail.setQty(receiptDetail.getQty());
            detail.setWarehouseCode(receiptHeader.getWarehouse());
            detail.setNotice(receiptDetail.getNoticeNo());
            detail.setISUrgent(receiptDetail.getIsUrgent());
            detail.setReceiptBarcode(receiptDetail.getReceiptBarcode());
            detail.setWarehouse(receiptHeader.getWarehouse());
            detail.setWarehouseName(receiptHeader.getWarehouseName());
            String lastUpdatedBy = receiptDetail.getLastUpdatedBy();
            if (StringUtils.isEmpty(lastUpdatedBy)) {
                detail.setLastUpdatedBy("");
                detail.setLastUpdatedByName("");
            } else {
                User user = userService.selectUserByEmail(lastUpdatedBy);
                String loginName;
                if (user == null) {
                    loginName = "";
                } else {
                    loginName = user.getLoginName();
                }
                detail.setLastUpdatedBy(loginName);
                detail.setLastUpdatedByName(lastUpdatedBy);
            }

            detail.setProductionWorker(receiptHeader.getProductionWorker());
            detail.setProductionWorkerName(receiptHeader.getProductionWorkerName());
            list.add(detail);
        }
        domain.setReceiptHeader(receiptHeader1);
        domain.setReceiptDetails(list);
        //返回实体
        ReturnDomain data = new ReturnDomain();
        data.setData(domain);
        String str = JSONObject.toJSONString(data);

        JSONObject jsonObject = JSONObject.parseObject(str);
        return postMOM("E_Rd_In", jsonObject, "其他入库回传");
    }

    /**
     * post调用E_Rd_In（MOM）出库成功接口
     */
    //@ApiLogger(apiName = "post调用E_Rd_Out（MOM）出库接口", from="ROBOT")
    @PostMapping("/postE_Rd_Out")
    public Boolean postE_Rd_Out(@RequestBody ShipmentHeader shipmentHeader) {
        // ShipmentHeader shipmentHeader = shipmentHeaderService.getById(shipmentHeaderID.getId());
        //StringBuffer keyField = new StringBuffer();
        JSONArray dataArray = new JSONArray();
        // 如果订单为合并类型
        if ("merge".equals(shipmentHeader.getShipmentType())) {
            // 查询所有子表
            List<ShipmentDetail> shipmentDetailList = shipmentDetailService.list(new LambdaQueryWrapper<ShipmentDetail>().eq(ShipmentDetail::getShipmentId, shipmentHeader.getId()));
            // 查询所有合并前的头表
            StringBuilder ids = new StringBuilder();
            for (ShipmentDetail shipmentDetail : shipmentDetailList) {
                ids.append(",").append(shipmentDetail.getRecordCode());
            }
            String codes = ids.substring(1, ids.length());
            String[] headerIdArr = codes.split(",");

            List<ShipmentHeader> shipmentHeaderList = new ArrayList<>();
            List<ShipmentHeaderHistory> list2 = shipmentHeaderHistoryService.list(new LambdaQueryWrapper<ShipmentHeaderHistory>().in(ShipmentHeaderHistory::getCode, headerIdArr));
            for (ShipmentHeaderHistory shipmentHeaderHistory : list2) {
                ShipmentHeader shipmentHeader1 = new ShipmentHeader();
                BeanUtils.copyProperties(shipmentHeaderHistory, shipmentHeader1);
                shipmentHeaderList.add(shipmentHeader1);
            }

            // 根据合并前的头表id分组
            Map<String, List<ShipmentDetail>> map = new HashMap<>();
            for (ShipmentDetail detail : shipmentDetailList) {
                String key = detail.getRecordCode();
                if (key != null) {
                    if (map.containsKey(key)) {
                        map.get(key).add(detail);
                    } else {
                        List<ShipmentDetail> list = new ArrayList<>();
                        list.add(detail);
                        map.put(key, list);
                    }
                }
            }

            for (String key : map.keySet()) {
                JSONObject data = new JSONObject();
                // 合并前的头表
                ShipmentHeader header = new ShipmentHeader();
                // 合并前头表对应的子表
                List<ShipmentDetail> detailList = new ArrayList<>();
                for (ShipmentHeader SH : shipmentHeaderList) {
                    if (key.equals(SH.getCode())) {
                        header = SH;
                        detailList = map.get(key);
                        break;
                    }
                }
                // 查询出库单据表头
                JSONObject Rd_Out_M = getRd_Out_M(header, shipmentHeader.getCreatedBy());
                JSONArray jsonArray = getRd_Out_S(header, detailList);
                data.put("Rd_Out_M", Rd_Out_M);
                data.put("Rd_Out_S", jsonArray);
                dataArray.add(data);
            }
        } else {
            // 查询出库单据表头
            JSONObject Rd_Out_M = getRd_Out_M(shipmentHeader, "");
            // 查询出库单据明细
            List<ShipmentDetail> shipmentDetailList = shipmentDetailService.list(new LambdaQueryWrapper<ShipmentDetail>()
                    .eq(ShipmentDetail::getShipmentId, shipmentHeader.getId()));
            JSONArray jsonArray = getRd_Out_S(shipmentHeader, shipmentDetailList);
            JSONObject data = new JSONObject();
            data.put("Rd_Out_M", Rd_Out_M);
            data.put("Rd_Out_S", jsonArray);
            dataArray.add(data);
        }

        String action = "E_Rd_Out";
        JSONObject json = new JSONObject();
        json.put("data", dataArray);
        ReturnInfo returnInfo = postMOM(action, json, "出库回传");
        if (returnInfo == null) {
            shipmentHeader.setErrorMsg("出库回传：接口地址错误或返回为空");
            shipmentHeader.setPushSuccessStatus(2);
            shipmentHeaderService.updateById(shipmentHeader);
            return false;
        }
        shipmentHeader.setPushErrorCount(shipmentHeader.getPushErrorCount() + 1);
        if (returnInfo.noError()) {
            shipmentHeader.setPushSuccessStatus(1);
            shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_HEADER_RETURN);
            shipmentHeader.setLastStatus(QuantityConstant.SHIPMENT_HEADER_RETURN);
        } else {
            shipmentHeader.setPushSuccessStatus(2);
            shipmentHeader.setErrorMsg(returnInfo.getMsg());
        }
        shipmentHeaderService.updateById(shipmentHeader);
        return true;
    }

    public JSONArray getRd_Out_S(ShipmentHeader shipmentHeader, List<ShipmentDetail> shipmentDetailList) {
        JSONArray jsonArray = new JSONArray();
        shipmentDetailList.forEach(shipmentDetail -> {
            User user = userService.selectUserByEmail(shipmentDetail.getLastUpdatedBy());
            if (user == null) {
                user = userService.selectUserByEmail(shipmentHeader.getLastUpdatedBy());
            }
            JSONObject Rd_Out_S = new JSONObject();
            Rd_Out_S.put("MGPK", shipmentHeader.getMOMID());
            Rd_Out_S.put("SGPK", shipmentDetail.getMOMID());
            Rd_Out_S.put("SNNO", shipmentDetail.getSNNO());
            Rd_Out_S.put("cInvCode", shipmentDetail.getMaterialCode());
            // 实际入库数量
            Rd_Out_S.put("Iquantity", shipmentDetail.getTaskQty());
            // MOM传入的入库数量
            Rd_Out_S.put("iFQuantity", shipmentDetail.getQty());
            //Rd_Out_S.put("cwhcode", "035");
            List<TaskDetail> taskDetails = taskDetailService.list(new LambdaQueryWrapper<TaskDetail>()
                    .eq(TaskDetail::getInternalTaskType, 200)
                    .eq(TaskDetail::getBillDetailId, shipmentDetail.getId()));
            String str = computeWarehouseType(taskDetails);
            Rd_Out_S.put("cidefine10", str);
            Rd_Out_S.put("MOCode", shipmentDetail.getNoticeNo());
            Rd_Out_S.put("ISUrgent", shipmentDetail.getIsUrgent());
            Rd_Out_S.put("updatedByNo", user.getLoginName());
            Rd_Out_S.put("updatedBy", shipmentDetail.getLastUpdatedBy());
            Rd_Out_S.put("warehouse", shipmentHeader.getWarehouse());
            Rd_Out_S.put("warehouseName", shipmentHeader.getWarehouseName());
            Rd_Out_S.put("creatorCode", shipmentHeader.getCreatorCode());
            Rd_Out_S.put("creatorName", shipmentHeader.getCreatorName());
//            Rd_Out_S.put("requestedStartDate", shipmentHeader.getRequestedStartDate());
            Rd_Out_S.put("ifrom", shipmentDetail.getIfrom());
            Rd_Out_S.put("LMPKID", shipmentDetail.getLMPKID());
            Rd_Out_S.put("LSPKID", shipmentDetail.getLSPKID());
            jsonArray.add(Rd_Out_S);
        });
        return jsonArray;
    }


    public String computeWarehouseType(List<TaskDetail> taskDetails) {
        String str;
        if (taskDetails.isEmpty()) {
            return "错误：未查询到任务！";
        }
        int flatCount = 0;
        int uprightCount = 0;
        BigDecimal flatQty = BigDecimal.ZERO;
        BigDecimal uprightQty = BigDecimal.ZERO;

        for (TaskDetail taskDetail : taskDetails) {
            if (taskDetail.getFlat() != null && taskDetail.getFlat() == 1) {
                flatCount++;
                flatQty = flatQty.add(taskDetail.getQty());

            } else {
                uprightCount++;
                uprightQty = uprightQty.add(taskDetail.getQty());
            }
        }
        if (flatCount > 0 && uprightCount == 0) {
            str = "平库";
        } else if (uprightCount > 0 && flatCount == 0) {
            str = "立库";
        } else if (flatCount > 0 && uprightCount > 0) {
            // 移除.0或.00后缀
            String flatQtyStr = flatQty.stripTrailingZeros().toPlainString();
            String uprightQtyStr = uprightQty.stripTrailingZeros().toPlainString();
            str = "平库" + flatQtyStr + "/" + "立库" + uprightQtyStr;
        } else {
            str = "未知错误";
        }
        return str;
    }

    public JSONObject getRd_Out_M(@RequestBody ShipmentHeader shipmentHeader, String name) {
        User user = userService.selectUserByEmail(shipmentHeader.getLastUpdatedBy());
        JSONObject Rd_Out_M = new JSONObject();
        Rd_Out_M.put("ISMOM", shipmentHeader.getISMOM());
        Rd_Out_M.put("mno", shipmentHeader.getCode());
        Rd_Out_M.put("MGPK", shipmentHeader.getMOMID());
        Rd_Out_M.put("cBusType", shipmentHeader.getShipmentType());
        Rd_Out_M.put("TAID", shipmentHeader.getTAID());
        Rd_Out_M.put("FAID", shipmentHeader.getFAID());
        if (user == null) {
            String UserNo = userService.selectUserByEmail(name).getLoginName();
            Rd_Out_M.put("UserNo", UserNo);
        } else {
            Rd_Out_M.put("UserNo", user.getLoginName());
        }
        Rd_Out_M.put("warehouse", shipmentHeader.getWarehouse());//仓库编码
        Rd_Out_M.put("cDepCode", "01030101");//部门编码
        //Rd_Out_M.put("cWhCode", shipmentHeader.getWarehouse());//仓库编码
        return Rd_Out_M;
    }

    /**
     * utf-8 转 GB2312
     */
    public String getGB(String action) {
        byte[] Rd_Out; //中间用ISO-8859-1过渡
        String data = null;
        try {
            Rd_Out = action.getBytes("8859_1");
            data = new String(Rd_Out, "GB2312"); //转换成GB2312字符
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return data;
    }


    /**
     * @param action  MOM行为
     * @param JObject 行为参数
     * @return
     */
    public ReturnInfo postMOM(String action, JSONObject JObject, String apiName) {
        String url = addressService.selectAddress(QuantityConstant.MOM);
        return CallaMOM.getMsg(action, JObject, apiName, url);
    }


    /**
     * 蓝牙打印入库物料明细
     */
    //@RequiresPermissions("receipt:receiptDetail:printList")
    //@Log(title = "入库-入库单明细管理", operating = "查看入库单明细", action = BusinessType.GRANT)
    @PostMapping("/receipt/printList")
    //@ApiLogger(apiName = "蓝牙打印入库物料明细", from = "PDA")
    @ResponseBody
    public AjaxResult receiptPrintList(@RequestBody ReceiptPrint receiptPrint) {

        if (receiptPrint == null) {
            return AjaxResult.error("参数为空");
        }
        String code = receiptPrint.getCode();
        String sn = receiptPrint.getSn();
        if (StringUtils.isEmpty(code) && StringUtils.isEmpty(sn)) {
            return AjaxResult.error("条码和入库单号不能同时为空");
        }
        if (StringUtils.isNotEmpty(code) && StringUtils.isNotEmpty(sn)) {
            return AjaxResult.error("条码和入库单号不能同时有值" + "，条码:" + sn + "，入库单号：" + code);
        }


        if (StringUtils.isNotEmpty(code)) {
            List<ReceiptDetail> receiptDetails = receiptDetailService.list(new LambdaQueryWrapper<ReceiptDetail>().eq(ReceiptDetail::getReceiptCode, code));
            if (!receiptDetails.isEmpty()) {
                for (ReceiptDetail receiptDetail : receiptDetails) {
                    ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptDetail.getReceiptId());
                    receiptDetail.setWarehouse(receiptHeader.getWarehouse());
                    receiptDetail.setWarehouseName(receiptHeader.getWarehouseName());
                }
                return AjaxResult.success(receiptDetails);
            }
        }


        if (StringUtils.isNotEmpty(sn)) {
            ReceiptDetail snReceiptDetail = receiptDetailService.getOne(new LambdaQueryWrapper<ReceiptDetail>().eq(ReceiptDetail::getSNNO, sn));
            if (snReceiptDetail != null) {
                List<ReceiptDetail> receiptDetails = receiptDetailService.list(new LambdaQueryWrapper<ReceiptDetail>().eq(ReceiptDetail::getReceiptCode, snReceiptDetail.getReceiptCode()));
                if (!receiptDetails.isEmpty()) {
                    for (ReceiptDetail receiptDetail : receiptDetails) {
                        ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptDetail.getReceiptId());
                        receiptDetail.setWarehouse(receiptHeader.getWarehouse());
                        receiptDetail.setWarehouseName(receiptHeader.getWarehouseName());
                    }
                    return AjaxResult.success(receiptDetails);
                }
            }
        }


        if (StringUtils.isNotEmpty(code)) {
            List<ReceiptDetailHistory> receiptDetails = receiptDetailHistoryService.list(new LambdaQueryWrapper<ReceiptDetailHistory>().eq(ReceiptDetailHistory::getReceiptCode, code));
            if (!receiptDetails.isEmpty()) {
                for (ReceiptDetailHistory receiptDetail : receiptDetails) {
                    ReceiptHeaderHistory receiptHeader = receiptHeaderHistoryService.getById(receiptDetail.getReceiptId());
                    receiptDetail.setWarehouse(receiptHeader.getWarehouse());
                    receiptDetail.setWarehouseName(receiptHeader.getWarehouseName());
                }
                return AjaxResult.success(receiptDetails);
            }
        }


        if (StringUtils.isNotEmpty(sn)) {
            ReceiptDetailHistory snReceiptDetail = receiptDetailHistoryService.getOne(new LambdaQueryWrapper<ReceiptDetailHistory>().eq(ReceiptDetailHistory::getSNNO, sn));
            if (snReceiptDetail != null) {
                List<ReceiptDetailHistory> receiptDetails = receiptDetailHistoryService.list(new LambdaQueryWrapper<ReceiptDetailHistory>().eq(ReceiptDetailHistory::getReceiptCode, snReceiptDetail.getReceiptCode()));
                if (!receiptDetails.isEmpty()) {
                    for (ReceiptDetailHistory receiptDetail : receiptDetails) {
                        ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptDetail.getReceiptId());
                        receiptDetail.setWarehouse(receiptHeader.getWarehouse());
                        receiptDetail.setWarehouseName(receiptHeader.getWarehouseName());
                    }
                    return AjaxResult.success(receiptDetails);
                }
            }
        }

        return AjaxResult.error("没有查询到数据");
    }


    /**
     * 蓝牙打印出库物料明细
     */
    @PostMapping("/shipment/printList")
    @ResponseBody
    public AjaxResult shipmentPrintList(String code) {
        if (StringUtils.isEmpty(code)) {
            return AjaxResult.error("code为空");
        }
        List<ShipmentDetail> list = shipmentDetailService.list(new LambdaQueryWrapper<ShipmentDetail>().eq(ShipmentDetail::getShipmentCode, code));
        if (!list.isEmpty()) {
            for (ShipmentDetail shipmentDetail : list) {
                ShipmentHeader shipmentHeader = shipmentHeaderService.getById(shipmentDetail.getShipmentId());
                shipmentDetail.setWarehouse(shipmentHeader.getWarehouse());
                shipmentDetail.setWarehouseName(shipmentHeader.getWarehouseName());
            }
            return AjaxResult.success(list);
        }

        List<ShipmentDetailHistory> list2 = shipmentDetailHistoryService.list(new LambdaQueryWrapper<ShipmentDetailHistory>().eq(ShipmentDetailHistory::getShipmentCode, code));
        if (!list2.isEmpty()) {
            for (ShipmentDetailHistory shipmentDetail : list2) {
                ShipmentHeaderHistory shipmentHeader = shipmentHeaderHistoryService.getById(shipmentDetail.getShipmentId());
                shipmentDetail.setWarehouse(shipmentHeader.getWarehouse());
                shipmentDetail.setWarehouseName(shipmentHeader.getWarehouseName());
            }
            return AjaxResult.success(list);
        }
        return AjaxResult.error("没有查询到数据");
    }

}