package com.huaheng.pc.shipment.kuaidiHeader.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.support.Convert;
import com.huaheng.common.utils.DataUtils;
import com.huaheng.common.utils.DateUtils;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.Wrappers;
import com.huaheng.common.utils.file.FileUploadUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.config.company.domain.Company;
import com.huaheng.pc.config.company.service.CompanyService;
import com.huaheng.pc.shipment.kuaidiDetail.domain.KuaidiDetail;
import com.huaheng.pc.shipment.kuaidiDetail.service.KuaidiDetailService;
import com.huaheng.pc.shipment.kuaidiHeader.domain.KuaidiHeader;
import com.huaheng.pc.shipment.kuaidiHeader.mapper.KuaidiHeaderMapper;
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.dict.service.IDictDataService;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.u8.domain.ICSShipmentHeader;
import com.huaheng.pc.u8.service.ICSShipmentHeaderService;
import com.huaheng.pc.u8.service.IcsKuaidiService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.File;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;


/**
 * 【请填写功能名称】 服务层实现
 *
 * @author huaheng
 * @date 2022-09-07
 */
@Service
public class KuaidiHeaderService extends ServiceImpl<KuaidiHeaderMapper, KuaidiHeader> {

    @Resource
    private IDictDataService dictDataService;
    @Resource
    private IcsKuaidiService icsKuaidiService;
    @Resource
    private KuaidiDetailService kuaidiDetailService;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private ICSShipmentHeaderService icsShipmentHeaderService;
    @Resource
    private KuaidiHeaderDataService kuaidiHeaderDataService;
    @Resource
    private CompanyService companyService;
    @Resource
    private ShipmentDetailService shipmentDetailService;


    public AjaxResult<Boolean> saveHeader(KuaidiHeader kuaidiHeader) {
        kuaidiHeader.setType("CO");
        if (dictDataService.checkConfig("shipmentType", kuaidiHeader.getType()) == false) {
            return AjaxResult.error("没有对应的出库单类型");
        }
        String code = kuaidiHeaderDataService.createCode(kuaidiHeader.getType());
        kuaidiHeader.setId(null);
        kuaidiHeader.setLastUpdated(null);
        kuaidiHeader.setLastUpdatedBy(ShiroUtils.getLoginName());
        kuaidiHeader.setCreated(null);
        kuaidiHeader.setCreatedBy(ShiroUtils.getLoginName());
        kuaidiHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
        kuaidiHeader.setCode(code);
        kuaidiHeader.setDeleted(false);
        boolean result = this.save(kuaidiHeader);
        return AjaxResult.toAjax(result);
    }


    /**
     * 从U8获取信息
     * 1、检查出库单号或者发货单号是否为空，如果为空则报错
     * 2、如果是出库单获取信息，剔除在快递单中已存在的出库单
     * 3、如果是发货单，分组，剔除在快递单中已存在的出库单
     */
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult saveU8Kuaidi(KuaidiHeader kuaidiHeader) {
        //1、检查出库单号或者发货单号是否为空，如果为空则报错
        if (StringUtils.isEmpty(kuaidiHeader.getOrderBill()) &&
                StringUtils.isEmpty(kuaidiHeader.getSourceCode())) {
            return AjaxResult.error("U8出库单号和发货单号为空，请填下U8结束出库单号或发货单单号");
        }
        //2、如果是出库单获取信息，剔除在快递单中已存在的出库单
        if (!StringUtils.isEmpty(kuaidiHeader.getOrderBill()) && StringUtils.isEmpty(kuaidiHeader.getFromCode())) {
            return saveu8KuaiOne(kuaidiHeader);

        }
        //批量获取出库单单据
        if (StringUtils.isNotEmpty(kuaidiHeader.getOrderBill()) && StringUtils.isNotEmpty(kuaidiHeader.getFromCode())) {
            return saveu8KuaiTwo(kuaidiHeader);
        }
        //3、如果是发货单，分组，剔除在快递单中已存在的出库单
        if (StringUtils.isEmpty(kuaidiHeader.getOrderBill()) && !StringUtils.isEmpty(kuaidiHeader.getSourceCode())) {
            return saveu8KuaiThree(kuaidiHeader);
        }
        return AjaxResult.success("成功");
    }

    //如果是出库单获取信息，剔除在快递单中已存在的出库单
    public AjaxResult saveu8KuaiOne(KuaidiHeader kuaidiHeader) {
        KuaidiHeader kuaidiHeader1 = new KuaidiHeader();
        kuaidiHeader1.setOrderBill(kuaidiHeader.getOrderBill());
        KuaidiHeader condition = kuaidiHeaderDataService.getByOrderBill(kuaidiHeader1);
        if (condition != null) {
            return AjaxResult.success("该出库单的快递信息已存在，请在搜索栏搜索");
        }
        kuaidiHeader.setSourceCode("");
        //(2)获取子单列表
        List<Map<String, String>> list = icsKuaidiService.getKDMeseeage(kuaidiHeader);
        List<KuaidiDetail> kuaidiDetails = new ArrayList<>();
        for (Map<String, String> map : list) {
            KuaidiDetail kuaidiDetail = this.getEntityFromU8(map);
            kuaidiDetails.add(kuaidiDetail);
        }
        //(3)根据快递子单反推快递主单，通过发货单号搜索wms出库单和中间表
        Map<String, Object> map = this.checkHeader(kuaidiDetails.get(0).getSourceCode());
        Boolean flag = ((Boolean) map.get("flag")).booleanValue();
        if (flag == false) {
            return AjaxResult.error("快递信息不存在");
        }
        KuaidiHeader header = JSONObject.parseObject(JSON.toJSONString(map.get("header")), KuaidiHeader.class);
        header.setOrderBill(kuaidiDetails.get(0).getOrderBill());
        header.setUserDef1(kuaidiDetails.get(0).getUserDef1());
        header.setWarehouseCode(QuantityConstant.WAREHOUSE_KS);
        this.save(header);
        for (KuaidiDetail detail : kuaidiDetails) {
            detail.setShipmentId(header.getId());
            detail.setShipmentCode(header.getCode());
            detail.setWarehouseCode(QuantityConstant.WAREHOUSE_KS);
            kuaidiDetailService.save(detail);
        }
        return AjaxResult.success("成功");
    }

    //批量获取出库单单据
    public AjaxResult saveu8KuaiTwo(KuaidiHeader kuaidiHeader) {
        //1、获取所有出库单信息
        List<Map<String, String>> mapList = icsKuaidiService.getKDMeseeage(kuaidiHeader);
        return saveKuaidiData(kuaidiHeader, mapList);
    }

    //批量获取出库单单据
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult saveu8KuaiTwoV1(KuaidiHeader kuaidiHeader) {
        //1、获取所有出库单信息
        String warehouseCode = kuaidiHeader.getWarehouseCode();
        List<Map<String, String>> mapList = icsKuaidiService.getKDMeseeageV1(kuaidiHeader, kuaidiHeader.getType(), kuaidiHeader.getWarehouseCode());
        return saveKuaidiData(kuaidiHeader, mapList);
    }

    public AjaxResult saveKuaidiData(KuaidiHeader kuaidiHeader, List<Map<String, String>> mapList) {
        //2、发货单分组，查看是否符合快递条件
        Set<String> hashSet = new HashSet();
        for (Map<String, String> item : mapList) {
            hashSet.add(item.get("subconsignmentcode"));
        }
        //循环判断
        for (String s : hashSet) {
            Map<String, Object> hashmap = this.checkHeader(s);
            Boolean flag = ((Boolean) hashmap.get("flag")).booleanValue();
            //不符合条件的剔除
            if (flag == false) {
                continue;
            }
            KuaidiHeader header1 = JSONObject.parseObject(JSON.toJSONString(hashmap.get("header")), KuaidiHeader.class);
            List<KuaidiDetail> kuaidiDetails = new ArrayList<>();
            for (Map<String, String> item : mapList) {
                //获取不存在快递单数据里的单据
                if (item.get("subconsignmentcode").equals(s)) {
                    KuaidiHeader condition = new KuaidiHeader();
                    condition.setOrderBill(item.get("code"));
                    condition.setWarehouseCode(kuaidiHeader.getWarehouseCode());
                    condition = kuaidiHeaderDataService.getByOrderBill(condition);
                    if (condition == null) {
                        KuaidiDetail kuaidiDetail = this.getEntityFromU8(item);
                        kuaidiDetails.add(kuaidiDetail);
                    }
                }
            }
            if (kuaidiDetails.isEmpty()) {
                continue;
            }
            Set<String> stringSet = new HashSet<>();
            //再把子单以出库单分组
            lable1:
            for (KuaidiDetail kuaidiDetail : kuaidiDetails) {
                if (kuaidiDetail.getMaterialCode().startsWith("9")) {
                    continue lable1;
                }
                stringSet.add(kuaidiDetail.getOrderBill());
            }
            for (String s1 : stringSet) {
                LambdaQueryWrapper<KuaidiHeader> lambdaQueryWrapper = Wrappers.lambdaQuery();
                lambdaQueryWrapper.eq(KuaidiHeader::getOrderBill, s1);
                lambdaQueryWrapper.eq(KuaidiHeader::getCreatedBy, header1.getCreatedBy());
                lambdaQueryWrapper.eq(KuaidiHeader::getWarehouseCode, kuaidiHeader.getWarehouseCode());
                lambdaQueryWrapper.last("limit 1");
                KuaidiHeader header = this.getOne(lambdaQueryWrapper);
                if (header == null) {
                    header = header1;
                    header.setId(null);
                }
                header.setOrderBill(s1);
                header.setWarehouseCode(kuaidiHeader.getWarehouseCode());
                header.setUserDef1(kuaidiDetails.get(0).getUserDef1());
                this.saveOrUpdate(header);
                lable2:
                for (KuaidiDetail detail : kuaidiDetails) {
                    if (detail.getOrderBill().equals(s1)) {
                        if (detail.getMaterialCode().startsWith("9")) {
                            continue lable2;
                        }
                        detail.setShipmentId(header.getId());
                        detail.setShipmentCode(header.getCode());
                        detail.setWarehouseCode(kuaidiHeader.getWarehouseCode());
                        kuaidiDetailService.save(detail);
                    }
                }
            }
        }
        return AjaxResult.success("成功");
    }

    //3、如果是发货单，分组，剔除在快递单中已存在的出库单
    public AjaxResult saveu8KuaiThree(KuaidiHeader kuaidiHeader) {
        //(1)检验发货单号的发货信息是否可以快递
        Map<String, Object> hashmap = this.checkHeader(kuaidiHeader.getSourceCode());
        Boolean flag = ((Boolean) hashmap.get("flag")).booleanValue();
        if (flag == false) {
            return AjaxResult.error("快递信息不存在");
        }
        KuaidiHeader header = JSONObject.parseObject(JSON.toJSONString(hashmap.get("header")), KuaidiHeader.class);
        //(2) 分组，以出库单号为分组基准
        List<Map<String, String>> mapList = icsKuaidiService.getKDMeseeage(kuaidiHeader);
        Set<String> hashSet = new HashSet();
        for (Map<String, String> item : mapList) {
            hashSet.add(item.get("code"));
        }
        int number = 0;
        for (String item : hashSet) {
            List<KuaidiDetail> kuaidiDetails = new ArrayList<>();

            //(3)剔除在快递单中已存在的出库单
            KuaidiHeader condition = new KuaidiHeader();
            condition.setOrderBill(item);
            condition = kuaidiHeaderDataService.getByOrderBill(condition);
            if (condition == null) {
                for (Map<String, String> map : mapList) {
                    if (map.get("code").equals(item)) {
                        KuaidiDetail kuaidiDetail = this.getEntityFromU8(map);
                        kuaidiDetails.add(kuaidiDetail);
                    }
                }
            }
            if (kuaidiDetails.isEmpty()) {
                number++;
                continue;
            }
            //(4)生成主单和子单
            header.setId(null);
            header.setOrderBill(item);
            header.setUserDef1(kuaidiDetails.get(0).getUserDef1());
            header.setWarehouseCode(QuantityConstant.WAREHOUSE_KS);
            this.save(header);
            for (KuaidiDetail detail : kuaidiDetails) {
                detail.setShipmentId(header.getId());
                detail.setShipmentCode(header.getCode());
                detail.setWarehouseCode(QuantityConstant.WAREHOUSE_KS);
                kuaidiDetailService.save(detail);
            }
        }
        if (number == hashSet.size()) {
            return AjaxResult.success("该发货单号的快递信息都存在，请在搜索栏以发货单号搜索");
        }
        return AjaxResult.success("成功");
    }


    //根据获取的U8的信息生成快递子单
    public KuaidiDetail getEntityFromU8(Map<String, String> map) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = new Date();
        try {
            date = simpleDateFormat.parse(map.get("date"));
        } catch (ParseException e) {
            throw new ServiceException("时间转换格式错误");
        }
        KuaidiDetail kuaidiDetail = new KuaidiDetail();
        kuaidiDetail.setUWarehouseCode(map.get("warehousecode"));
        kuaidiDetail.setUnit(map.get("cmassunitname"));
        kuaidiDetail.setWarehouseId(1);
        kuaidiDetail.setWarehouseCode("CS0001");
        kuaidiDetail.setSourceCode(map.get("subconsignmentcode"));
        kuaidiDetail.setMaterialCode(map.get("inventorycode"));
        kuaidiDetail.setInventoryStatus("good");
        kuaidiDetail.setQty(new BigDecimal(map.get("quantity")));
        kuaidiDetail.setCreated(date);
        kuaidiDetail.setCreatedBy(map.get("maker"));
        kuaidiDetail.setOrderBill(map.get("code"));
        kuaidiDetail.setUserDef1(map.get("auditdate"));
        return kuaidiDetail;
    }

    /**
     * 根据wms出库单或者中间表检验发货单信息
     *
     * @param code
     * @return
     */
    public Map<String, Object> checkHeader(String code) {
        //先查看是否存在此发货单的快递信息
        //wms出库单检验
        Boolean flag = true;
        LambdaQueryWrapper<ShipmentHeader> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(ShipmentHeader::getSourceCode, code);
        lambdaQueryWrapper.eq(ShipmentHeader::getKdEable, 1);
        lambdaQueryWrapper.last("limit 1");
        ShipmentHeader shipmentHeader = shipmentHeaderService.getOne(lambdaQueryWrapper);
        ICSShipmentHeader icsShipmentHeader = new ICSShipmentHeader();
        if (shipmentHeader == null || StringUtils.isEmpty(shipmentHeader.getRecMobile())) {
            //wms中间表检验
            icsShipmentHeader.setCDLCode(code);
            icsShipmentHeader.setCSCName("快递");
            icsShipmentHeader = icsShipmentHeaderService.selectModel(icsShipmentHeader);
            if (icsShipmentHeader == null || StringUtils.isEmpty(icsShipmentHeader.getRecMobile())) {
                flag = false;
            }
        }
        KuaidiHeader header = new KuaidiHeader();
        if (shipmentHeader != null && StringUtils.isNotEmpty(shipmentHeader.getRecMobile())) {
            header = kuaidiHeaderDataService.getModelByShipment(shipmentHeader);
        }
        if (shipmentHeader == null && icsShipmentHeader != null && StringUtils.isNotEmpty(icsShipmentHeader.getRecMobile())) {
            header = kuaidiHeaderDataService.getModelByICSShipment(icsShipmentHeader);
        }
        Map<String, Object> map = new HashMap<>();
        map.put("flag", flag);
        map.put("header", header);
        return map;
    }


    public Boolean importData(List<KuaidiHeader> maps, Boolean num) {
        //实体转换
        int number = 0;
        for (KuaidiHeader map : maps) {
            if (StringUtils.isNull(map.getCompanyId())) {
                continue;
            }
            KuaidiHeader kuaidiHeader = new KuaidiHeader();
            kuaidiHeader.setType("CO");
            String code = kuaidiHeaderDataService.createCode(kuaidiHeader.getType());
            //检查数据
            kuaidiHeaderDataService.checkImport(map);
            Company company = companyService.getById(DataUtils.getInteger(map.getCompanyId()));
            if (company == null) {
                throw new ServiceException("公司ID错误");
            }
            kuaidiHeader = kuaidiHeaderDataService.createHeaderByImport(kuaidiHeader, map, company);
            if (num == true) {
                if (StringUtils.isNotNull(map.getTotalWeight())) {
                    kuaidiHeader.setTotalWeight(map.getTotalWeight().toString());
                } else {
                    throw new ServiceException("重量为空");
                }
                if (StringUtils.isNotNull(map.getKuaidiCom())) {
                    kuaidiHeader.setKuaidiCom(map.getKuaidiCom().toString());
                } else {
                    throw new ServiceException("快递公司为空");
                }
                if (StringUtils.isNotNull(map.getTrackCode())) {
                    kuaidiHeader.setTrackCode(map.getTrackCode().toString());
                } else {
                    throw new ServiceException("快递单号为空");
                }
            }
            kuaidiHeader.setKuaidiCom("");
            kuaidiHeader.setDeleted(num);
            kuaidiHeader.setCode(code);
            kuaidiHeader.setWarehouseId(2);
            kuaidiHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
            kuaidiHeader.setCreated(new Date());
            kuaidiHeader.setCreatedBy(ShiroUtils.getUserName());
            kuaidiHeader.setEnable(1);
            boolean tag = this.save(kuaidiHeader);
            if (!tag) {
                throw new ServiceException("存储快递信息失败");
            }
        }
        return true;
    }

    @Transactional
    public AjaxResult sendKD(KuaidiHeader kuaidiHeader) {
        //查出销售单的快递信息

        return kuaidiHeaderDataService.sendKD(kuaidiHeader);
    }

    //批量导入到快递100
    @Transactional
    public AjaxResult sendKDS(KuaidiHeader kuaidiHeader) {
        String ids = kuaidiHeader.getOrderBill();
        if (StringUtils.isEmpty(ids)) {
            return AjaxResult.error("没有选中快递数据");
        }

        for (Integer id : Convert.toIntArray(ids)) {
            KuaidiHeader header = this.getById(id);
            if (header == null) {
                return AjaxResult.error("id为" + id + "的快递信息不存在");
            }
            header.setKuaidiCom(kuaidiHeader.getKuaidiCom());
            kuaidiHeaderDataService.sendKD(header);
        }
        return AjaxResult.success("成功");
    }


    //快递打印
    public AjaxResult printKD(String kuaidiNum, String warehouseCode) {
        if (StringUtils.isEmpty(kuaidiNum)) {
            return AjaxResult.error("没有导入快递信息");
        }
        return kuaidiHeaderDataService.printKD(kuaidiNum, warehouseCode);
    }

    //快递批量打印
    public AjaxResult printKDS(String ids) {
        if (StringUtils.isEmpty(ids)) {
            return AjaxResult.error("没有选中快递数据");
        }
        Integer[] kdIds = Convert.toIntArray(ids);
        if (kdIds.length > 19) {
            return AjaxResult.error("一次性批量快递打印只能在20张以内");
        }

        StringBuilder sb = new StringBuilder();
        boolean flag = false;
        String kuaidiNum = "";
        String warehouseCode = QuantityConstant.WAREHOUSE_KS;
        for (Integer id : kdIds) {
            KuaidiHeader header = this.getById(id);
            if (header == null) {
                return AjaxResult.error("id为" + id + "的快递信息不存在");
            }
            if (StringUtils.isEmpty(header.getKuaidiNum())) {
                return AjaxResult.error("id为" + id + "的快递信息没有导入到快递100");
            }
            if (flag) {
                sb.append(",");
            } else {
                flag = true;
            }
            sb.append(header.getKuaidiNum());
            warehouseCode = header.getWarehouseCode();
        }
        kuaidiNum = sb.toString();
        return kuaidiHeaderDataService.printKD(kuaidiNum, warehouseCode);
    }

    private static String fileUrl = "D:\\wmsfile\\wmsfile\\";
    private static String pictureUrl = "http://172.16.2.10:8016/wms/profile/wmsfile/";

    //获取图片地址
    public AjaxResult getPicture() {
        //获取图片的判断条件，要有重量，快递单号，status=0
        KuaidiHeader kuaidiHeader = this.getModelForPicture();
        if (kuaidiHeader == null) {
            return AjaxResult.success("没有符合条件的快递单");
        }
        String[] codes = Convert.toStrArray(kuaidiHeader.getTrackCode());

//        String filePath = HuaHengConfig.getProfile() +"wmsfile/"+ codes[0]+".jpg";
        String filePath = fileUrl + codes[0] + ".jpg";
        File file = new File(filePath);
        MultipartFile multipartFile = null;
        try {
            multipartFile = FileUploadUtils.fileToMultipartFile(file);
        } catch (Exception e) {
            kuaidiHeader.setStatus(2L);
            this.updateById(kuaidiHeader);
            throw new ServiceException("图片不存在");
        }
        try {
            FileUploadUtils.upload(multipartFile);
        } catch (Exception e) {
            throw new ServiceException("图片上传失败");
        }

        kuaidiHeader.setStatus(1L);
        kuaidiHeader.setPicture(pictureUrl + codes[0] + ".jpg");
        this.updateById(kuaidiHeader);
        return AjaxResult.success("成功");
    }

    public KuaidiHeader getModelForPicture() {
        LambdaQueryWrapper<KuaidiHeader> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.ne(KuaidiHeader::getTrackCode, "");
        lambdaQueryWrapper.ne(KuaidiHeader::getTotalWeight, "");
        lambdaQueryWrapper.eq(KuaidiHeader::getStatus, 0L);
        lambdaQueryWrapper.last("limit 1");
        return this.getOne(lambdaQueryWrapper);
    }


    public AjaxResult saveShipmentKuadi(){
        LambdaQueryWrapper<ShipmentHeader> wrapper=new LambdaQueryWrapper<>();
//        wrapper.eq(ShipmentHeader::getWarehouseCode,QuantityConstant.WAREHOUSE_KS);
        wrapper.ge(ShipmentHeader::getLastStatus,QuantityConstant.SHIPMENT_HEADER_COMPLETED);
        wrapper.apply("(recMobile is not null and recMobile != '') ");
        wrapper.apply("(referCode is not null and referCode != '') ");
        wrapper.ge(ShipmentHeader::getLastUpdated, DateUtils.getNowPreDays("yyyy-MM-dd",1));
        wrapper.orderByDesc(ShipmentHeader::getId);
        List<ShipmentHeader> list=shipmentHeaderService.list(wrapper);
        for(ShipmentHeader header:list){
            LambdaQueryWrapper<KuaidiHeader> wrapper1=new LambdaQueryWrapper<>();
//            wrapper1.eq(KuaidiHeader::getWarehouseCode,QuantityConstant.WAREHOUSE_KS);
            wrapper1.eq(KuaidiHeader::getSourceCode,header.getReferCode());
            wrapper1.last("limit 1");
            KuaidiHeader kuaidiHeader=this.getOne(wrapper1);
            if(kuaidiHeader!=null){
                continue;
            }
            kuaidiHeader=new KuaidiHeader();
            kuaidiHeader.setWarehouseCode(header.getWarehouseCode());
            kuaidiHeader.setSourceCode(header.getReferCode());
            kuaidiHeader.setOrderBill(header.getReferCode());
            kuaidiHeader.setCode(header.getReferCode());
            kuaidiHeader.setRecName(header.getRecName());
            kuaidiHeader.setRecAddr(header.getRecAddr());
            kuaidiHeader.setRecMobile(header.getRecMobile());
            kuaidiHeader.setRecCompany(header.getRecCompany());
            kuaidiHeader.setSendAddr(header.getSendAddr());
            kuaidiHeader.setSendName(header.getSendName());
            kuaidiHeader.setSendMobile(header.getSendMobile());
            kuaidiHeader.setSendCompany(header.getSendCompany());
            kuaidiHeader.setDeleted(false);
            kuaidiHeader.setCreatedBy(header.getCreatedBy());
            kuaidiHeader.setLastUpdatedBy(header.getCreatedBy());
//            kuaidiHeader.setKuaidiCom(header.getKuaidiCom());
            if(!this.save(kuaidiHeader)){
                continue;
            }
            List<ShipmentDetail> shipmentDetails=shipmentDetailService.getListByShipmentHeaderId(header.getId(),header.getWarehouseCode());
            List<KuaidiDetail> kuaidiDetails=new ArrayList<>();
            for (ShipmentDetail detail:shipmentDetails) {
                KuaidiDetail kuaidiDetail = new KuaidiDetail();
                kuaidiDetail.setShipmentId(kuaidiHeader.getId());
                kuaidiDetail.setShipmentCode(kuaidiHeader.getCode());
                kuaidiDetail.setWarehouseCode(header.getWarehouseCode());
                kuaidiDetail.setMaterialCode(detail.getMaterialCode());
                kuaidiDetail.setQty(detail.getQty());
                kuaidiDetail.setUWarehouseCode(detail.getUWarehouseCode());
                kuaidiDetail.setUnit(detail.getMaterialUnit());
                kuaidiDetail.setInventoryStatus(detail.getInventorySts());
                kuaidiDetail.setWarehouseId(detail.getWarehouseId());
                kuaidiDetail.setOrderBill(kuaidiHeader.getOrderBill());
                kuaidiDetail.setCreated(detail.getCreated());
                kuaidiDetail.setCreatedBy(detail.getCreatedBy());
                kuaidiDetail.setLastUpdated(detail.getLastUpdated());
                kuaidiDetail.setLastUpdatedBy(detail.getLastUpdatedBy());
                kuaidiDetail.setDeleted(detail.getDeleted());
                kuaidiDetails.add(kuaidiDetail);
            }
            if(!kuaidiDetailService.saveBatch(kuaidiDetails)){
                continue;
            }
        }
        return AjaxResult.success();
    }
}