wms / hhwms · Files

package com.huaheng.api.erp.service;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

import javax.annotation.Resource;

import com.alibaba.fastjson.JSONObject;
import com.huaheng.api.erp.domainBack.*;
import com.huaheng.api.erp.domainBack.finishedR.ParameterFinished;
import com.huaheng.api.erp.domainBack.inventoryScrapC.ParameterInventoryScrap;
import com.huaheng.api.erp.domainBack.issuanceC.ParameterIssuance;
import com.huaheng.api.erp.domainBack.miscellaneousR.ParameterMiscellaneous;
import com.huaheng.api.erp.domainBack.noticeWmsC.ParameterNotice;
import com.huaheng.api.erp.domainBack.purchaseWmsR.ParameterPurchase;
import com.huaheng.api.erp.domainBack.saleR.Parameter;
import com.huaheng.api.erp.domainBack.scrapC.ParameterScrap;
import com.huaheng.api.erp.domainBack.shipmentWmsC.ParameterShipmentWms;
import com.huaheng.api.erp.domainBack.transferD.ParameterTransfer;
import com.huaheng.api.erp.domainBack.warehouseC.ParameterWarehouse;
import com.huaheng.common.utils.DateUtils;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.Wrappers;
import com.huaheng.framework.web.domain.ResultErpBack;

import com.huaheng.pc.config.address.domain.Address;

import com.huaheng.pc.srm.domain.SrmDetail;
import com.huaheng.pc.srm.domain.SrmHeader;

import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.service.CallBack;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.huaheng.api.erp.domain.*;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.http.OkHttpUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.framework.web.domain.ResultErp;
import com.huaheng.pc.config.address.service.AddressService;
import com.huaheng.pc.config.company.domain.Company;
import com.huaheng.pc.config.company.service.CompanyService;
import com.huaheng.pc.config.customer.domain.Customer;
import com.huaheng.pc.config.customer.service.CustomerServiceImpl;
import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.supplier.domain.Supplier;
import com.huaheng.pc.config.supplier.service.SupplierService;
import com.huaheng.pc.config.warehouse.service.WarehouseService;
import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;
import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail;
import com.huaheng.pc.receipt.receiptDetail.service.ReceiptDetailService;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
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.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;
import com.huaheng.pc.system.user.service.IUserService;

/**
 * @author 游杰
 */
@Service
public class ErpBackServiceImpl implements IErpBackService {

    @Resource
    private IErpBackTypeService erpBackTypeService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private ShipmentDetailService shipmentDetailService;

    @Resource
    private ReceiptDetailService receiptDetailService;

    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private TaskDetailService taskDetailService;
    @Resource
    private AddressService addressService;
    @Resource
    private ErpBackUpdateStatusServiceImpl erpBackUpdateStatusService;

    @Resource
    private CompanyService companyService;

    /**
     * 任务回传：
     * 单据回传：
     * 销退单（入）、超领单（出）、退料单（入）、完工入库单（入）、杂收单（入）、
     * 下阶料报废（出）、调拨单（出入）、杂发单（出）、库存报废（出）、仓退单（出）、成套发料（出）、
     * @param taskHeader
     * @return
     */

    public AjaxResult setErpBackData(TaskHeader taskHeader){
            TaskHeader task = taskHeaderService.getById(taskHeader.getId());
            if(task==null){
//                throw new ServiceException("任务信息为空");
                return AjaxResult.error("任务信息为空");
            }
            switch (task.getTaskType()){
                case QuantityConstant.TASK_TYPE_WHOLERECEIPT:
                case QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT:

                    break;
                case QuantityConstant.TASK_TYPE_WHOLESHIPMENT:
                case QuantityConstant.TASK_TYPE_SORTINGSHIPMENT:
                    break;
                default:
                    TaskHeader taskHeader1=new TaskHeader();
                    taskHeader1.setId(task.getId());
                    taskHeader1.setBackInfo("无需回传");
                    taskHeader1.setIsReturn(2);
                    taskHeaderService.updateById(taskHeader1);
                    return AjaxResult.success("无需回传");
            }
            List<TaskDetail> taskDetails = taskDetailService.findByTaskId(task.getId());
            if(taskDetails==null || taskDetails.size()==0){
                throw new ServiceException("找不到任务id为："+task.getId()+"的任务，没有任务明细");
            }

            Address address=addressService.selectAddressByParam("ERP",task.getWarehouseCode());

            List<String> billCodes = taskDetails.stream().map(TaskDetail::getBillCode).collect(Collectors.toList());
            List<BackTaskStatus> backTaskStatusList=null;
            switch(task.getInternalTaskType()){
                case 100:

                    backTaskStatusList=createReceiptBack(task,billCodes,address.getUrl(),address.getUserDef2());

                    break;
                case 200:

                    backTaskStatusList=createShipmentBack(task,billCodes,address.getUrl(),address.getUserDef2());

                    break;
                default:
                    break;
            }
            //修改入库单、出库单状态，任务头状态
            AjaxResult ajaxResult=erpBackUpdateStatusService.backTaskUpdateStatus(task,backTaskStatusList);
            return ajaxResult;

//        return AjaxResult.success("回传成功");

    }

    /**
     * 整单回传

     * 销退单（入）、调拨单（出入）、退料单（入）、完工入库单（入）、杂收单（入）、多角采购（入）

     * 整单回传的单据：查询该入库单详情是否都已完成，都完成则回传，否则不回传
     * @param task
     * @param billCodes
     * @param url
     * @return
     */

    //根据任务详情的入库单号，查找单据类型，回传到erp
    @Transactional(rollbackFor = Exception.class)

    public List<BackTaskStatus> createReceiptBack( TaskHeader task,List<String> billCodes,String url,String datakeyEntId){

        LambdaQueryWrapper<ReceiptHeader> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.in(ReceiptHeader::getCode,billCodes)
                .eq(ReceiptHeader::getWarehouseCode,task.getWarehouseCode());
        //获取任务中的入库单
        List<ReceiptHeader> list = receiptHeaderService.list(queryWrapper);
        //Integer 3无需回传，2回传成功，1回传失败
        List<BackTaskStatus> backTaskStatusList=new ArrayList<>();
        for (ReceiptHeader receiptHeader : list) {

            Company company=companyService.getCompanyByCode(receiptHeader.getCompanyCode(),receiptHeader.getWarehouseCode());

            //获取未回传任务集
            List<TaskDetail> unBackTask = getUnBackTask(receiptHeader.getCode(),receiptHeader.getWarehouseCode(),task.getId());

            List<TaskDetail> unBackTaskReturn =unBackTask;

            if(unBackTask.size()==0){

                BackTaskStatus backTaskStatus=new BackTaskStatus();
                backTaskStatus.setBillCode(receiptHeader.getCode());
                backTaskStatus.setBillId(receiptHeader.getId());
                backTaskStatus.setStatus(QuantityConstant.ISRETURN_SUCC);
                backTaskStatus.setMsg("过账成功");
                backTaskStatus.setIsSuccess(true);
                backTaskStatusList.add(backTaskStatus);

                if(StringUtils.isNotEmpty(receiptHeader.getBackMsg())){
                    receiptHeader.setBackMsg(receiptHeader.getBackMsg());
                }else{
                    receiptHeader.setBackMsg("过账成功");
                }

                receiptHeaderService.updateById(receiptHeader);

                continue;
            }
            if(StringUtils.isEmpty(receiptHeader.getReferCode())){
                BackTaskStatus backTaskStatus=new BackTaskStatus();
                backTaskStatus.setBillCode(receiptHeader.getCode());
                backTaskStatus.setBillId(receiptHeader.getId());
                backTaskStatus.setStatus(QuantityConstant.NOT_RETURN);
                backTaskStatus.setMsg("无需回传");
                backTaskStatus.setIsSuccess(true);
                backTaskStatusList.add(backTaskStatus);
                receiptHeader.setBackMsg("无需回传");
                receiptHeaderService.updateById(receiptHeader);
                continue;
            }
            if(taskAllComplete(receiptHeader.getCode(),receiptHeader.getWarehouseCode(),task.getId())){
                //同一个单据该任务还有未完成的
                continue;
            }

            Set<Integer> uniqueTaskIds =new LinkedHashSet<>();
            switch (receiptHeader.getReceiptType()){
                case QuantityConstant.SALES_R:
                case QuantityConstant.TRANSFER_R:
                case QuantityConstant.RETURN_R:
                case QuantityConstant.FINISHED_R:
                case QuantityConstant.MISCELLANEOUS_R:
                case QuantityConstant.WAREHOUSE_R:

                case QuantityConstant.PUR_R:

                    if(receiptAllComplete(receiptHeader.getId(),receiptHeader.getWarehouseCode())){
                        //同一个单据该任务还有未完成的
                        continue;
                    }

                    //先查taskdetail表还有该单据未完成任务的，再查下该单据完成任务没回传的
                    List<TaskDetail> unCompaleteTask1 = getUnBackTaskBill(receiptHeader.getCode(),receiptHeader.getWarehouseCode());
                    if(unCompaleteTask1.size()>0){
                        continue;
                    }

                    //获取未回传任务集
                    unBackTask = getUnBackTask(receiptHeader.getCode(),receiptHeader.getWarehouseCode(),null);
                    if(unBackTask.size()==0){
                        continue;
                    }

                    //将t100相同序号的汇总,整单回传的写到整单里面
                    unBackTaskReturn=erpBackTypeService.allReceiptTask(receiptHeader,unBackTask);

                    uniqueTaskIds = unBackTask.stream()
                            .map(TaskDetail::getTaskId)
                            .collect(Collectors.toSet());

                    break;
                default:
                    break;
            }

//            AjaxResult ajaxResult=getBackDataReceipt(receiptHeader,unBackTask,datakeyEntId);
            AjaxResult ajaxResult=getBackDataReceipt(receiptHeader,unBackTaskReturn,datakeyEntId);

            if(ajaxResult.hasErr()){

                BackTaskStatus backTaskStatus=new BackTaskStatus();
                backTaskStatus.setBillCode(receiptHeader.getCode());
                backTaskStatus.setBillId(receiptHeader.getId());
                backTaskStatus.setStatus(QuantityConstant.NOT_RETURN);
                backTaskStatus.setMsg("无需回传");
                backTaskStatus.setIsSuccess(true);
                backTaskStatusList.add(backTaskStatus);

                continue;
            }
            //给erp回传数据

            AjaxResult ajaxResult1=sendDataToERP(ajaxResult,url,task.getWarehouseCode(),datakeyEntId,company.getErpCompany());

//            AjaxResult ajaxResult1=AjaxResult.success("过账成功");

            if(!ajaxResult1.hasErr()){

                List<TaskDetail> unBackTaskUpdate=new ArrayList<>();

                for (TaskDetail taskDetail : unBackTask) {

                    TaskDetail taskDetail1=new TaskDetail();
                    taskDetail1.setId(taskDetail.getId());
                    taskDetail1.setBack(1);
                    unBackTaskUpdate.add(taskDetail1);

                }

                taskDetailService.updateBatchById(unBackTaskUpdate);

                //更改入库单明细表回传数
                BackTaskStatus backTaskStatus=new BackTaskStatus();
                backTaskStatus.setBillCode(receiptHeader.getCode());
                backTaskStatus.setBillId(receiptHeader.getId());
                backTaskStatus.setStatus(QuantityConstant.ISRETURN_SUCC);

                backTaskStatus.setTaskIds(uniqueTaskIds);

                backTaskStatus.setMsg(ajaxResult1.getMsg());
                backTaskStatus.setIsSuccess(true);
                backTaskStatusList.add(backTaskStatus);
            }
            if(ajaxResult1.hasErr()){

//                receiptHeader.setBackMsg(receiptHeader.getBackMsg()+",失败");
//                receiptHeaderService.updateById(receiptHeader);

                BackTaskStatus backTaskStatus=new BackTaskStatus();
                backTaskStatus.setBillCode(receiptHeader.getCode());
                backTaskStatus.setBillId(receiptHeader.getId());
                backTaskStatus.setStatus(QuantityConstant.ISRETURN_FAIL);
                backTaskStatus.setIsSuccess(false);
                backTaskStatus.setMsg(ajaxResult1.getMsg());
                backTaskStatusList.add(backTaskStatus);
            }
        }
        return backTaskStatusList;
    }

    /**
     * 整单回传：
     * 下阶料报废（出）、杂发单（出）、库存报废（出）、仓退单（出）、成套发料（出）、超领单（出）、
     *  * 整单回传的单据：查询该出库单详情是否都已完成，都完成则回传，否则不回传
     * @param task
     * @param billCodes
     * @param url
     * @return
     */

    //根据任务详情的出库单号，查找单据类型，回传到erp
    @Transactional(rollbackFor = Exception.class)

    public List<BackTaskStatus> createShipmentBack( TaskHeader task,List<String> billCodes,String url,String datakeyEntId){

        LambdaQueryWrapper<ShipmentHeader> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.in(ShipmentHeader::getCode,billCodes)
                .eq(ShipmentHeader::getWarehouseCode,task.getWarehouseCode());
        //获取任务中的出库单
        List<ShipmentHeader> list = shipmentHeaderService.list(queryWrapper);
        //Integer 3无需回传，2回传成功，1回传失败
        List<BackTaskStatus> backTaskStatusList=new ArrayList<>();
        for (ShipmentHeader shipmentHeader : list) {

            Company company=companyService.getCompanyByCode(shipmentHeader.getCompanyCode(),shipmentHeader.getWarehouseCode());

            if(StringUtils.isEmpty(shipmentHeader.getReferCode())||shipmentHeader.getShipmentType().equals(QuantityConstant.TRANSFER_C)){

                shipmentHeader.setBackMsg("无需回传");
                shipmentHeaderService.updateById(shipmentHeader);
                BackTaskStatus backTaskStatus=new BackTaskStatus();
                backTaskStatus.setBillCode(shipmentHeader.getCode());
                backTaskStatus.setBillId(shipmentHeader.getId());
                backTaskStatus.setStatus(QuantityConstant.NOT_RETURN);
                backTaskStatus.setMsg("无需回传");
                backTaskStatus.setIsSuccess(true);
                backTaskStatusList.add(backTaskStatus);
                continue;
            }
            if(taskAllComplete(shipmentHeader.getCode(),shipmentHeader.getWarehouseCode(),task.getId())){
                //同一个单据该任务还有未完成的
                continue;
            }
            //获取未回传任务集
            List<TaskDetail> unBackTask = getUnBackTask(shipmentHeader.getCode(),shipmentHeader.getWarehouseCode(),task.getId());

            List<TaskDetail> unBackTaskReturn=unBackTask;

            if(unBackTask.size()==0){

                BackTaskStatus backTaskStatus=new BackTaskStatus();
                backTaskStatus.setBillCode(shipmentHeader.getCode());
                backTaskStatus.setBillId(shipmentHeader.getId());
                backTaskStatus.setStatus(QuantityConstant.ISRETURN_SUCC);
                backTaskStatus.setMsg("过账成功");
                backTaskStatus.setIsSuccess(true);
                backTaskStatusList.add(backTaskStatus);

                if(StringUtils.isNotEmpty(shipmentHeader.getBackMsg())){
                    shipmentHeader.setBackMsg(shipmentHeader.getBackMsg());
                }else{
                    shipmentHeader.setBackMsg("过账成功");
                }
//                shipmentHeader.setBackMsg(shipmentHeader.getBackMsg()+",过账成功");

                shipmentHeaderService.updateById(shipmentHeader);

                continue;
            }

            Set<Integer> uniqueTaskIds =new LinkedHashSet<>();
            switch (shipmentHeader.getShipmentType()){
                case QuantityConstant.SCRAP_C:
                case QuantityConstant.MISCELLANEOUS_C:
                case QuantityConstant.INVENTORYSCRAP_C:

                case QuantityConstant.ISSUANCE_C:
                case QuantityConstant.OVER_C:
                    if(shipmentAllComplete(shipmentHeader.getId(),shipmentHeader.getWarehouseCode())){
                        //同一个单据该任务还有未完成的
                        continue;
                    }

                    //先查taskdetail表还有该单据未完成任务的，再查下该单据完成任务没回传的
                    List<TaskDetail> unCompaleteTask = getUnBackTaskBill(shipmentHeader.getCode(),shipmentHeader.getWarehouseCode());
                    if(unCompaleteTask.size()>0){
                        continue;
                    }

                    //获取未回传任务集
                    unBackTask = getUnBackTask(shipmentHeader.getCode(),shipmentHeader.getWarehouseCode(),null);
                    if(unBackTask.size()==0){
                        continue;
                    }

                    unBackTaskReturn=erpBackTypeService.allShipmentTask(shipmentHeader,unBackTask);

                    uniqueTaskIds = unBackTask.stream()
                            .map(TaskDetail::getTaskId)
                            .collect(Collectors.toSet());
                    break;

                case QuantityConstant.NOTICE_C:
                    List<TaskDetail> taskDetails=getUnCompaleteTask(shipmentHeader.getCode(),shipmentHeader.getWarehouseCode(),null);
                    if(taskDetails.size()>0){
                        continue;
                    }

                    //先查taskdetail表还有该单据未完成任务的，再查下该单据完成任务没回传的
                    List<TaskDetail> unCompaleteTask1 = getUnBackTaskBill(shipmentHeader.getCode(),shipmentHeader.getWarehouseCode());
                    if(unCompaleteTask1.size()>0){
                        continue;
                    }

                    //获取未回传任务集
                    unBackTask = getUnBackTask(shipmentHeader.getCode(),shipmentHeader.getWarehouseCode(),null);
                    if(unBackTask.size()==0){
                        continue;
                    }

                    unBackTaskReturn=unBackTask;

                    uniqueTaskIds = unBackTask.stream()
                            .map(TaskDetail::getTaskId)
                            .collect(Collectors.toSet());
                    break;

                default:
                    break;
            }

//            AjaxResult ajaxResult=getBackDataShipment(shipmentHeader,unBackTask,datakeyEntId);
            AjaxResult ajaxResult=getBackDataShipment(shipmentHeader,unBackTaskReturn,datakeyEntId);

            if(ajaxResult.hasErr()){

                BackTaskStatus backTaskStatus=new BackTaskStatus();
                backTaskStatus.setBillCode(shipmentHeader.getCode());
                backTaskStatus.setBillId(shipmentHeader.getId());
                backTaskStatus.setStatus(QuantityConstant.NOT_RETURN);
                backTaskStatus.setMsg("无需回传");
                backTaskStatus.setIsSuccess(true);
                backTaskStatusList.add(backTaskStatus);

                continue;
            }

            AjaxResult ajaxResult1=sendDataToERP(ajaxResult,url,task.getWarehouseCode(),datakeyEntId,company.getErpCompany());

//            AjaxResult ajaxResult1=AjaxResult.success("过账成功");

            if(!ajaxResult1.hasErr()){

                List<TaskDetail> unBackTaskUpdate=new ArrayList<>();

                for (TaskDetail taskDetail : unBackTask) {

                    TaskDetail taskDetail1=new TaskDetail();
                    taskDetail1.setId(taskDetail.getId());
                    taskDetail1.setBack(1);
                    unBackTaskUpdate.add(taskDetail1);

                }

                taskDetailService.updateBatchById(unBackTaskUpdate);

                BackTaskStatus backTaskStatus=new BackTaskStatus();
                backTaskStatus.setBillCode(shipmentHeader.getCode());
                backTaskStatus.setBillId(shipmentHeader.getId());
                backTaskStatus.setStatus(QuantityConstant.ISRETURN_SUCC);
                backTaskStatus.setMsg(ajaxResult1.getMsg());

                backTaskStatus.setTaskIds(uniqueTaskIds);

                backTaskStatus.setIsSuccess(true);
                backTaskStatusList.add(backTaskStatus);
            }
            if(ajaxResult1.hasErr()){

//                shipmentHeader.setBackMsg(shipmentHeader.getBackMsg()+",失败");
//                shipmentHeaderService.updateById(shipmentHeader);

                BackTaskStatus backTaskStatus=new BackTaskStatus();
                backTaskStatus.setBillCode(shipmentHeader.getCode());
                backTaskStatus.setBillId(shipmentHeader.getId());
                backTaskStatus.setStatus(QuantityConstant.ISRETURN_FAIL);
                backTaskStatus.setMsg(ajaxResult1.getMsg());
                backTaskStatus.setIsSuccess(false);
                backTaskStatusList.add(backTaskStatus);
            }
        }
        return backTaskStatusList;
    }

    /**
     * 返回true则是还有未完成的，false则是空的
     * @param billCode
     * @param warehouseCode
     * @param taskid
     * @return
     */

    public boolean taskAllComplete(String billCode,String warehouseCode,Integer taskid){
        LambdaQueryWrapper<TaskDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(TaskDetail::getBillCode,billCode)
                .eq(TaskDetail::getWarehouseCode,warehouseCode)
                .eq(TaskDetail::getTaskId,taskid)
                .lt(TaskDetail::getStatus,QuantityConstant.TASK_STATUS_COMPLETED);
        List<TaskDetail> taskDetails = taskDetailService.list(queryWrapper);
        return !taskDetails.isEmpty();
    }

    /**
     * 检查该入库单是否有未完成的任务
     * @param receiptId
     * @param warehouseCode
     * @return
     */
    public boolean receiptAllComplete(Integer receiptId,String warehouseCode){
        LambdaQueryWrapper<ReceiptDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(ReceiptDetail::getReceiptId,receiptId)
                .eq(ReceiptDetail::getWarehouseCode,warehouseCode)
                .lt(ReceiptDetail::getProcessStamp,QuantityConstant.RECEIPT_HEADER_POSTING);
        List<ReceiptDetail> receiptDetailList = receiptDetailService.list(queryWrapper);
        return !receiptDetailList.isEmpty();
    }
    /**
     * 检查该出库单是否有未完成的任务
     * @param shipmentId
     * @param warehouseCode
     * @return
     */
    public boolean shipmentAllComplete(Integer shipmentId,String warehouseCode){
        LambdaQueryWrapper<ShipmentDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(ShipmentDetail::getShipmentId,shipmentId)
                .eq(ShipmentDetail::getWarehouseCode,warehouseCode)
                .lt(ShipmentDetail::getStatus,QuantityConstant.SHIPMENT_HEADER_COMPLETED);
        List<ShipmentDetail> shipmentDetailList = shipmentDetailService.list(queryWrapper);
        return !shipmentDetailList.isEmpty();
    }

    public List<TaskDetail> getUnBackTask(String billCode,String warehouseCode,Integer taskid){
        LambdaQueryWrapper<TaskDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(TaskDetail::getBillCode,billCode)
                .eq(TaskDetail::getWarehouseCode,warehouseCode)

                .eq(StringUtils.isNotNull(taskid),TaskDetail::getTaskId,taskid)

                .eq(TaskDetail::getStatus,QuantityConstant.TASK_STATUS_COMPLETED)
                .eq(TaskDetail::getBack,0);
        List<TaskDetail> taskDetails = taskDetailService.list(queryWrapper);
        return taskDetails;
    }

    public List<TaskDetail> getUnBackTaskBill(String billCode,String warehouseCode){
        LambdaQueryWrapper<TaskDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(TaskDetail::getBillCode,billCode)
                .eq(TaskDetail::getWarehouseCode,warehouseCode)
                .lt(TaskDetail::getStatus,QuantityConstant.TASK_STATUS_COMPLETED);
        List<TaskDetail> taskDetails = taskDetailService.list(queryWrapper);
        return taskDetails;
    }

    public List<TaskDetail> getUnCompaleteTask(String billCode,String warehouseCode,Integer taskid){
        LambdaQueryWrapper<TaskDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(TaskDetail::getBillCode,billCode)
                .eq(TaskDetail::getWarehouseCode,warehouseCode)
                .eq(StringUtils.isNotNull(taskid),TaskDetail::getTaskId,taskid)
                .lt(TaskDetail::getStatus,QuantityConstant.TASK_STATUS_COMPLETED);
        List<TaskDetail> taskDetails = taskDetailService.list(queryWrapper);
        return taskDetails;
    }

    public Map<Integer, TaskDetail> combineTaskDetailByBill(List<TaskDetail> unBackTask){
        Map<Integer, TaskDetail> detailsQtyMap =new HashMap<>();
        for (TaskDetail taskDetail : unBackTask) {
            TaskDetail taskDetail1=detailsQtyMap.get(taskDetail.getBillDetailId());
            if(taskDetail1!=null){
                BigDecimal bigDecimal =taskDetail1.getQty().add(taskDetail.getQty());
                taskDetail1.setQty(bigDecimal);
                detailsQtyMap.put(taskDetail.getBillDetailId(),taskDetail1);
            }else{
                detailsQtyMap.put(taskDetail.getBillDetailId(),taskDetail1);
            }
        }
        return detailsQtyMap;
    }

    @Transactional(rollbackFor = Exception.class)

    public AjaxResult getBackDataReceipt(ReceiptHeader receiptHeader,List<TaskDetail> unBackTask,String datakeyEntId){

        //将相同入库详情id，BillDetailId的任务详情整合到一起；
//        Map<Integer, TaskDetail> detailMap=combineTaskDetailByBill(unBackTask);
        String receipttype=receiptHeader.getReceiptType();
        ParameterApi parameterApi=new ParameterApi();
        switch (receipttype){
            case QuantityConstant.SALES_R:
                Parameter parameter=erpBackTypeService.backSalesR(receiptHeader,unBackTask);
                parameterApi.setApiName("ERP销退入库单回传");
                parameterApi.setParameter(parameter);
                parameterApi.setApiNameEn("SalesPost");
                return AjaxResult.success().setData(parameterApi);

            case QuantityConstant.MES_RECEIPT_TYPE_SI:

                ParameterFinished parameterFinishedSI=erpBackTypeService.backFinishedR(receiptHeader,unBackTask,receipttype,datakeyEntId);

                parameterApi.setApiName("ERP产成品入库单回传");

                parameterApi.setParameter(parameterFinishedSI);
                parameterApi.setApiNameEn("WorkOrderFinishCreate");

                return AjaxResult.success().setData(parameterApi);

            case QuantityConstant.PURCHASER_R:

                ParameterPurchase parameterPurchaser=erpBackTypeService.backPurchaseR(receiptHeader,null,unBackTask,receipttype,datakeyEntId);

                parameterApi.setApiName("ERP采购收货入库单回传");
                parameterApi.setParameter(parameterPurchaser);
                parameterApi.setApiNameEn("PurchaseDeliveryCreate");
                return AjaxResult.success().setData(parameterApi);

            case QuantityConstant.PURCHASE_R:

                ParameterPurchase parameterPurchase=erpBackTypeService.backPurchaseR(receiptHeader,null,unBackTask,receipttype,datakeyEntId);

                parameterApi.setApiName("ERP采购收货单入库单回传");

                parameterApi.setParameter(parameterPurchase);
                parameterApi.setApiNameEn("PurchaseDeliveryCreate");
                return AjaxResult.success().setData(parameterApi);

            case QuantityConstant.OUTSOURCED_R:

                ParameterPurchase parameterPurchased=erpBackTypeService.backPurchaseR(receiptHeader,null,unBackTask,receipttype,datakeyEntId);

                parameterApi.setApiName("ERP委外收货单入库单回传");
                parameterApi.setParameter(parameterPurchased);
                parameterApi.setApiNameEn("PurchaseDeliveryCreate");
                return AjaxResult.success().setData(parameterApi);

            case QuantityConstant.FINISHED_R:

                ParameterFinished parameterFinished=erpBackTypeService.backFinishedR(receiptHeader,unBackTask,receipttype,datakeyEntId);

                parameterApi.setApiName("ERP完工入库单回传");
                parameterApi.setParameter(parameterFinished);
                parameterApi.setApiNameEn("WorkOrderFinishPost");
                return AjaxResult.success().setData(parameterApi);
            case QuantityConstant.MISCELLANEOUS_R:
                ParameterMiscellaneous parameterMiscellaneous=erpBackTypeService.backMisceLLaneousC(receiptHeader,null,unBackTask);
                parameterApi.setApiName("ERP杂收入库单回传");
                parameterApi.setParameter(parameterMiscellaneous);

                parameterApi.setApiNameEn("ReceiveDispatchPostS");

                return AjaxResult.success().setData(parameterApi);
            case QuantityConstant.RETURN_R:
                ParameterIssuance parameterIssuance=erpBackTypeService.backIssuanceC(receiptHeader,null,unBackTask);
                parameterApi.setApiName("ERP退料入库单回传");
                parameterApi.setParameter(parameterIssuance);

                parameterApi.setApiNameEn("WorkOrderIssuePost");
                return AjaxResult.success().setData(parameterApi);

            case QuantityConstant.OVER_R:
                ParameterIssuance parameterIssuance1=erpBackTypeService.backIssuanceC(receiptHeader,null,unBackTask);
                parameterApi.setApiName("ERP超领退料单回传");
                parameterApi.setParameter(parameterIssuance1);
                parameterApi.setApiNameEn("WorkOrderIssuePost");
                return AjaxResult.success().setData(parameterApi);

            case QuantityConstant.WAREHOUSE_R:

                ParameterPurchase parameterPurchase1=erpBackTypeService.backPurchaseR(receiptHeader,null,unBackTask,receipttype,datakeyEntId);

                parameterApi.setApiName("ERP仓退入库回传");

                parameterApi.setParameter(parameterPurchase1);
                parameterApi.setApiNameEn("PurchaseDeliveryPost");

                return AjaxResult.success().setData(parameterApi);
            case QuantityConstant.TRANSFER_R:
                ParameterTransfer parameterTransfer=erpBackTypeService.backTransferC(receiptHeader,unBackTask);
                parameterApi.setApiName("ERP调拨单回传");
                parameterApi.setParameter(parameterTransfer);

                parameterApi.setApiNameEn("RequisitionNotePost");

                return AjaxResult.success().setData(parameterApi);

            case QuantityConstant.PUR_R:
                ParameterPurchase parameterPurchase2=erpBackTypeService.backPurR(receiptHeader,unBackTask);
                parameterApi.setApiName("ERP多角采购回传");
                parameterApi.setParameter(parameterPurchase2);
                parameterApi.setApiNameEn("PurchaseReceiptPost");
                return AjaxResult.success().setData(parameterApi);

            default:

                return AjaxResult.error("单据类型不用回传");

        }
    }

    @Transactional(rollbackFor = Exception.class)

    public AjaxResult getBackDataShipment(ShipmentHeader shipmentHeader,List<TaskDetail> unBackTask,String datakeyEntId){

        String shipmenttype=shipmentHeader.getShipmentType();
        ParameterApi parameterApi=new ParameterApi();
        switch (shipmenttype){
            case QuantityConstant.NOTICE_C:

                ParameterShipmentWms parameter=erpBackTypeService.backShipmentWmsC(null,shipmentHeader,unBackTask,datakeyEntId);

                parameterApi.setApiName("ERP出货通知单回传");
                parameterApi.setParameter(parameter);
                parameterApi.setApiNameEn("DeliveryOrderCreate");

                parameterApi.setAcct(parameter.getMaster().get(0).getXmdkcnfid());

                return AjaxResult.success().setData(parameterApi);
            case QuantityConstant.MISCELLANEOUS_C:
                ParameterMiscellaneous parameterMiscellaneous=erpBackTypeService.backMisceLLaneousC(null,shipmentHeader,unBackTask);
                parameterApi.setApiName("ERP杂发出库回传");
                parameterApi.setParameter(parameterMiscellaneous);

                parameterApi.setApiNameEn("ReceiveDispatchPostF");

                return AjaxResult.success().setData(parameterApi);

            case QuantityConstant.ISSUANCE_C:
                ParameterIssuance parameterIssuance=erpBackTypeService.backIssuanceC(null,shipmentHeader,unBackTask);
                parameterApi.setApiName("ERP成套发料出库回传");
                parameterApi.setParameter(parameterIssuance);
                parameterApi.setApiNameEn("WorkOrderIssuePost");
                return AjaxResult.success().setData(parameterApi);

            case QuantityConstant.OVER_C:
                ParameterIssuance parameterIssuance1=erpBackTypeService.backIssuanceC(null,shipmentHeader,unBackTask);
                parameterApi.setApiName("ERP超领出库回传");
                parameterApi.setParameter(parameterIssuance1);

                parameterApi.setApiNameEn("WorkOrderOverPost");

                return AjaxResult.success().setData(parameterApi);
            case QuantityConstant.SCRAP_C:
                ParameterScrap parameterScrap=erpBackTypeService.backScrapC(shipmentHeader,unBackTask);
                parameterApi.setApiName("ERP下阶料报废出库回传");
                parameterApi.setParameter(parameterScrap);

                parameterApi.setApiNameEn("NextLevelMaterialPost");

                return AjaxResult.success().setData(parameterApi);
            case QuantityConstant.INVENTORYSCRAP_C:
                ParameterInventoryScrap parameterInventoryScrap=erpBackTypeService.backInventoryScrapC(shipmentHeader,unBackTask);
                parameterApi.setApiName("ERP库存报废出库回传");
                parameterApi.setParameter(parameterInventoryScrap);

                parameterApi.setApiNameEn("InventoryScrapFormPost");

                return AjaxResult.success().setData(parameterApi);

            case QuantityConstant.TRANSFER_C:
                return AjaxResult.error("单据类型不用回传");

            default:

                return AjaxResult.error("单据类型不用回传");

        }
    }

    public SendOut createSendOut( Payload payload,String api,String datakeyEntId,String datakeyCompanyId){

        SendOut sendOut=new SendOut();
        Host host=new Host();
        ErpService service=new ErpService();
        service.setName(api);
        Datakey datakey=new Datakey();

        datakey.setEntId(datakeyEntId);
        datakey.setCompanyId(datakeyCompanyId);

        host.setTimestamp(DateUtils.getNowTime());

        sendOut.setHost(host);
        sendOut.setService(service);
        sendOut.setDatakey(datakey);
        sendOut.setPayload(payload);
        return sendOut;
    }

    public AjaxResult sendDataToERP(AjaxResult ajaxResult,String url,String warehouseCode,String datakeyEntId,String datakeyCompanyId){

        Payload payload=new Payload();
        StdData stdData=new StdData();
        ParameterApi parameterApi=(ParameterApi)ajaxResult.getData();
        stdData.setParameter(parameterApi.getParameter());
        payload.setStd_data(stdData);
        //构建回传体

        SendOut sendOut=createSendOut(payload,parameterApi.getApiNameEn(),datakeyEntId,datakeyCompanyId);

        if(StringUtils.isNotEmpty(parameterApi.getApiNameEn())&&
                parameterApi.getApiNameEn().equals("DeliveryOrderCreate")){

            if(StringUtils.isNotEmpty(parameterApi.getAcct())){

                sendOut.getHost().setAcct(parameterApi.getAcct().toLowerCase());

            }
        }

        String jsonString = JSONObject.toJSONString(sendOut);

        String result=OkHttpUtils.bodypost(url,jsonString,warehouseCode,parameterApi.getApiName());

        if (StringUtils.isEmpty(result)) {

            return AjaxResult.error("ERP接口地址错误或服务器连接不到或返回为空");

        }
        ResultErpBack ajaxResult1 = JSON.parseObject(result, ResultErpBack.class);
        return ajaxResult1.responseAnalyz();
//        if(ajaxResult1.responseAnalyz().hasErr()){
//            return AjaxResult.error(ajaxResult1.responseAnalyz().getMsg());
//        }
//        return AjaxResult.success(ajaxResult1.responseAnalyz().getMsg());
    }

    public AjaxResult createErpYanTui(List<SrmDetail> details, SrmHeader srmHeader){

        Address address=addressService.selectAddressByParam("ERP",srmHeader.getWarehouseCode());
        ParameterPurchase parameterPurchase=erpBackTypeService.backYanTuiR(srmHeader,details,address.getUserDef2());

        ParameterApi parameterApi=new ParameterApi();
        parameterApi.setApiName("ERP销退入库单回传");
        parameterApi.setParameter(parameterPurchase);
        parameterApi.setApiNameEn("PurchaseDeliveryCreate");
        AjaxResult ajaxResult=AjaxResult.success().setData(parameterApi);

        String companyCode=details.get(0).getCompanyCode();

        Company company=companyService.getCompanyByU8Code(companyCode);

        AjaxResult ajaxResult1=sendDataToERP(ajaxResult,address.getUrl(),srmHeader.getWarehouseCode(),address.getUserDef2(),company.getErpCompany());

        return ajaxResult1;

    }

}