DAL-DAZHOU-AMS-API/src/main/java/com/steerinfo/dil/service/impl/AmsSaleOrderServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.alibaba.druid.support.json.JSONUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.steerinfo.dil.feign.*;
import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.*;
import com.steerinfo.dil.service.IAmsSaleOrderService;
import com.steerinfo.dil.util.*;
import com.steerinfo.framework.utils.base.StringUtils;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * AmsSaleOrder服务实现：
 *
 * @author generator
 * @version 1.0-SNAPSHORT 2021-09-06 07:10
 * 类描述
 * 修订历史：
 * 日期：2021-09-06
 * 作者：generator
 * 参考：
 * 描述：AmsSaleOrder服务实现
 * @Copyright 湖南视拓信息技术股份有限公司. All rights reserved.
 * @see null
 */
@Service(value = "amsSaleOrderService")
public class AmsSaleOrderServiceImpl implements IAmsSaleOrderService {

    @Autowired
    private AmsSaleOrderMapper amsSaleOrderMapper;
    @Autowired
    private AmsSaleOrderMaterialMapper amsSaleOrderMaterialMapper;
    @Autowired
    private AmsSaleTrucknoMaterialMapper trucknoMaterialMapper;
    @Autowired
    TmstruckLoadResult tmstruckLoadResult;
    @Autowired
    TmstruckWeightResult tmstruckWeightResult;
    @Autowired
    TmstruckWeightResultMapper tmstruckWeightResultMapper;
    @Autowired
    TmstruckLoadResultMapper tmstruckLoadResultMapper;
    @Autowired
    AmsDispatchSaleOrderMapper amsDispatchSaleOrderMapper;
    @Autowired
    AmsSaleMaterialMapper amsSaleMaterialMapper;
    @Autowired
    AmsSaleTrucknoMaterialMapper amsSaleTrucknoMaterialMapper;
    @Autowired
    RmsReceivePlaceMapper rmsReceivePlaceMapper;
    @Autowired
    JoinFeign joinFeign;
    @Autowired
    OmstruckOrderMapper omstruckOrderMapper;
    @Autowired
    OmstruckOrderMaterialMapper omstruckOrderMaterialMapper;
    @Autowired
    AmsSaleOrderMaterialServiceImpl amsSaleOrderMaterialService;
    @Autowired
    TmsTruckFeign tmsTruckFeign;
    @Autowired
    EASUtil easUtil;
    @Autowired
    EASDeleteUtil easDeleteUtil;

    @Autowired
    EASSaleOrderUtil easSaleOrderUtil;

    @Autowired
    EASTestUtil easTestUtil;
    @Autowired
    EASDeleteTestUtil easDeleteTestUtil;
    @Autowired
    EASDeleteApproveUtil easDeleteApproveUtil;
    @Autowired
    RmsMaterialMapper rmsMaterialMapper;
    @Autowired
    TmstrainPleaseApproveResultMapper tmstrainPleaseApproveResultMapper;

    @Autowired
    WmspOutboundResultMaterialMapper wmspOutboundResultMaterialMapper;

    @Resource
    EasSaleOrderStatusUtil easSaleOrderStatusUtil;

    @Autowired
    OtmsFeign otmsFeign;

    @Autowired
    RmsFeign rmsFeign;

    @Autowired
    EasFluMakeDateUtil easFluMakeDateUtil;

    @Autowired
    EASCapacityTestUtil easCapacityTestUtil;

    @Autowired
    BmstruckFeign bmstruckFeign;

    @Autowired
    SaleLogUtil saleLogUtil;

    private static final List<Integer> dazhouLineIds = Arrays.asList(189982, 189983, 189984, 189985, 189986);
    private static final List<Integer> zhuanxianLineIds = Arrays.asList(189987,189988, 189989, 189990, 189991);



    @Override
    public List<Map<String, Object>> getSaleOrderInfo(Map<String, Object> map) {
        return amsSaleOrderMapper.getSaleOrderInfo(map);
    }

    @Override
    public List<Map<String, Object>> getSaleOrderReported(Map<String, Object> map) {
        return amsSaleOrderMapper.getSaleOrderReported(map);
    }

    @Override
    public List<Map<String, Object>> getSaleOrderDetail(Map<String, Object> map) {
        return amsSaleOrderMapper.getSaleOrderDetail(map);
    }

    @Override
    public List<Map<String, Object>> getSalePlanName() {
        return amsSaleOrderMapper.getSalePlanName();
    }

    @Override
    public List<Map<String, Object>> getShipperName() {
        return amsSaleOrderMapper.getShipperName();
    }

    @Override
    public List<Map<String, Object>> getConsigneeCompanyName() {
        return amsSaleOrderMapper.getConsigneeCompanyName();
    }

    @Override
    /**
     * map存放为前端获取的amsSaleOrder基础数据以及selectionList物资信息
     * map1为基础数据包括，收货地址，收货人等
     * map2存放的从selectionList取出的数据，包括物资id，物资名称等。
     */
    public int addAmsSaleOrder(Map<String, Object> map) throws ParseException {
        //获取前端传过来的map，
        int i = 0;
        Map<String, Object> map1 = (Map<String, Object>) map.get("amsSaleOrder");
        AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
        Integer id = (amsSaleOrderMapper.selectMaxId()).intValue();
        //生成主键id
        amsSaleOrder.setSaleOrderId(new BigDecimal(id));
        //WXSDD-年月日-8位数的顺序号
        String wxsdd = DataChange.generateEightDigitsNumber("WXSDD", id);
        amsSaleOrder.setSaleNumber(wxsdd);
        //获得是否自提
        amsSaleOrder.setSaleOrderIsselfMention((String) map1.get("saleOrderIsselfMention"));
        //获取收货地址id
        amsSaleOrder.setReceiveId(DataChange.dataToBigDecimal(map1.get("receiveId")));
        //获取发货单位id
        amsSaleOrder.setShipperId(DataChange.dataToBigDecimal(map1.get("shipperId")));
        //获取备注
        amsSaleOrder.setSaleRemark((String) map1.get("saleRemark"));
        //设置销售订单状态
        amsSaleOrder.setSaleOrderStatus(new BigDecimal(0));
        amsSaleOrder.setSaleUnitPrice(new BigDecimal(4000));
        amsSaleOrder.setSaleOrderTax("13%");
        amsSaleOrder.setInsertUsername("admin");
        amsSaleOrder.setInsertTime(new Date());
        amsSaleOrder.setUpdateUsername("admin");
        amsSaleOrder.setUpdateTime(new Date());
        amsSaleOrder.setInsertUpdateRemark("无");
        amsSaleOrder.setDeleted(new BigDecimal(0));
        amsSaleOrder.setSaleOrderStatus(new BigDecimal(0));
        //设置收款客户
        amsSaleOrder.setSaleOrderReceiveCustomer((String) map1.get("saleOrderReceiveCustomer"));
        i += amsSaleOrderMapper.insertSelective(amsSaleOrder);
        //获取车序号和物资信息进行新增车序号与物资中间表
        //一个销售订单对应多个车序号
        List<Map<String, Object>> selectionList = (List<Map<String, Object>>) map.get("selectionList");
        for (Map<String, Object> map2 : selectionList) {
            BigDecimal materialId = DataChange.dataToBigDecimal(map2.get("materialId"));
            Integer cxh = (Integer) map2.get("cxh");
            //生成车序号与物资实体
            AmsSaleOrderMaterial amsSaleOrderMaterial = new AmsSaleOrderMaterial();
            //生成主键
            amsSaleOrderMaterial.setSaleOrderMaterialId(amsSaleOrderMaterialMapper.selectMaxId());
            amsSaleOrderMaterial.setSaleOrderId(amsSaleOrder.getSaleOrderId());
            // 生成定向派单
            AmsDispatchSaleOrder amsDispatchSaleOrder = new AmsDispatchSaleOrder();
            amsDispatchSaleOrder.setDispatchId(amsDispatchSaleOrderMapper.selectOtherId());
            amsDispatchSaleOrder.setSaleOrderMaterialId(amsSaleOrderMaterial.getSaleOrderMaterialId());
            //获取收货地址
            Integer saleShipperAddressId =(Integer) map2.get("saleShipperAddressId");
            amsSaleOrderMaterial.setSaleShippingAddressId(new BigDecimal(saleShipperAddressId));
            //根据收货地址查询承运商
            Map<String,Object> map4 = amsSaleOrderMapper.selectProvince(saleShipperAddressId);
            BigDecimal carrierId = amsSaleOrderMapper.selectCarrierIdByprovince(map4);
            //获取收货方电话号码
            amsDispatchSaleOrder.setCarrierId(carrierId);
            amsDispatchSaleOrder.setDispatchTime(new Date());
            //设置成交类型
            amsDispatchSaleOrder.setDispatchType(new BigDecimal(0));
            //设置下发状态为未下发
            amsDispatchSaleOrder.setDispatchStatus(new BigDecimal(1));
            amsDispatchSaleOrder.setInsertTime(new Date());
            amsDispatchSaleOrder.setInsertUsername("admin");
            amsDispatchSaleOrderMapper.insertSelective(amsDispatchSaleOrder);
            amsSaleOrderMaterial.setSaleOrderConsigneeTel(map2.get("saleOrderConsigneeTel").toString());
            //获取收货日期
            String saleDateOfReceipt =(String) map2.get("saleDateOfReceipt");
            SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
            Date date = simpleDateFormat.parse(saleDateOfReceipt);
            amsSaleOrderMaterial.setSaleDateOfReceipt(date);
            //获取收货方姓名
            amsSaleOrderMaterial.setSaleOrderConsignee((String) map2.get("saleOrderConsignee"));
            //设置车序号
            amsSaleOrderMaterial.setSaleOrderMaterialTruckNo(new BigDecimal(cxh));
            //设置删除状态
            amsSaleOrderMaterial.setDeleted(new BigDecimal(0));
            i += amsSaleOrderMaterialMapper.insertSelective(amsSaleOrderMaterial);
            //新增车序号与物资中间表
            AmsSaleTrucknoMaterial trucknoMaterial = new AmsSaleTrucknoMaterial();
            trucknoMaterial.setTrucknoMaterialId(trucknoMaterialMapper.selectMaxId());
            //设置物资id
            trucknoMaterial.setMaterialId(materialId);
            //获取车序号物资id
            trucknoMaterial.setSaleOrderMaterialId(amsSaleOrderMaterial.getSaleOrderMaterialId());
            Integer orderPlanWeight = (Integer) map2.get("orderPlanWeight");
            trucknoMaterial.setSaleOrderMaterialNumber(DataChange.dataToBigDecimal(orderPlanWeight));
            //获取物资理重
            BigDecimal materialTheoreticalWeight = DataChange.dataToBigDecimal(map2.get("materialTheoreticalWeight"));
            //判断是否有物资理重
            if (materialTheoreticalWeight.intValue() != 0) {
                trucknoMaterial.setMaterialTheoreticalWeight(materialTheoreticalWeight);
            }
            //新增车序号与物资中间表
            i += trucknoMaterialMapper.insertSelective(trucknoMaterial);
        }
        return i;
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public int uploadSaleOrder(BigDecimal saleOrderId) throws Exception {
        AmsSaleOrder amsSaleOrder = amsSaleOrderMapper.selectByPrimaryKey(saleOrderId);
        // 调用金蝶接口，将销售订单推送到金蝶系统
        Map<String, Object> input = joinFeign.getSaleOrder(saleOrderId);
        Map<String, Object> head = (Map<String, Object>) input.get("head");
        head.put("status","");
        // 获得金蝶接口配置：正式
        Map<String, Object> totalMap = new HashMap<>();
        totalMap.putAll(easUtil.getTotalMap());
        // 获得金蝶接口配置:测试
        //totalMap.putAll(easSaleOrderUtil.getTotalMap());
        //Map<String, Object> totalMap = easSaleOrderUtil.getTotalMap();
        // 组装报文
        totalMap.put("input",input);
        System.out.println(totalMap);
        String json = JSONUtils.toJSONString(totalMap);
        System.out.println(json);
        // 得到金蝶返回结果
        Map<String,Object> s = joinFeign.pushSaleOrderToEas(totalMap);
        try {
            newFileTool.newFile("pushSaleOrderToEas："+totalMap,"金蝶通讯报文");
        }catch (Exception e){
            e.printStackTrace();
        }
        if (s == null || s.size() == 0) {
            throw new Exception(amsSaleOrder.getSaleNumber() + "登录金蝶失败！");
        }else {
            try {
                JSONObject result1 = new JSONObject(s);
                //如果status不为1,抛出异常
                if (!result1.getJSONObject("res").getString("status").equals("1")) {
                    throw new Exception(amsSaleOrder.getSaleNumber() + "上传金蝶失败！");
                }
            } catch (Exception e) {
                e.printStackTrace();
                //只抛出自定义异常
                throw new Exception(amsSaleOrder.getSaleNumber() + "上传金蝶失败！");
            }
        }
        amsSaleOrder.setSaleOrderStatus(new BigDecimal(1));
        try {
            saleLogUtil.logSaleOrder(saleOrderId,"物流上传销售订单至金蝶" ,"物流" ,SaleLogUtil.UPDATE);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return amsSaleOrderMapper.updateByPrimaryKey(amsSaleOrder);
    }

    @Override
    public List<Map<String, Object>> selectBySaleOrderId(BigDecimal saleOrderId) {
        return amsSaleOrderMapper.selectBySaleOrderId(saleOrderId);
    }

    /**
     * 修改订单信息、车序号表、车序号物资中间表
     *
     * @param map
     * @return
     */
    @Override
    @Transactional
    public int updateAmsSaleOrder(Map<String, Object> map) throws ParseException {
        int i = 0;
        int j = 0;
        Map<String, Object> map1 = (Map<String, Object>) map.get("amsSaleOrder");
        AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
        //修改销售订单表  更新销售订单基础信息
        amsSaleOrder.setSaleOrderId(DataChange.dataToBigDecimal(map1.get("saleOrderId")));
        amsSaleOrder.setShipperId(DataChange.dataToBigDecimal(map1.get("shipperId")));
        amsSaleOrder.setReceiveId(DataChange.dataToBigDecimal(map1.get("reciveId")));
        amsSaleOrder.setSaleOrderIsselfMention((String) map1.get("saleOrderIsselfMention"));
        amsSaleOrder.setSaleOrderReceiveCustomer((String) map1.get("saleOrderReciveCustomer"));
        amsSaleOrder.setSaleRemark((String) map1.get("saleRemark"));
        amsSaleOrder.setUpdateTime(new Date());
        i += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
        //根据销售订单id查找销售车序号和车序号与物资中间表主键
        List<Map<String, Object>> map2 = amsSaleOrderMapper.selectSaleOrderMaterialIdBySaleOrderId(DataChange.dataToBigDecimal(map1.get("saleOrderId")));
         for (Map<String,Object> Id:map2){
             BigDecimal truckNoMaterialId =(BigDecimal) Id.get("TruckNoMaterialId");
             BigDecimal saleOrderMaterialId=(BigDecimal) Id.get("saleOrderMaterialId");
             //删除对应的车序号表与车序号与物资中间表
           j+=amsSaleOrderMaterialMapper.deleteByPrimaryKey(saleOrderMaterialId);
           j+=trucknoMaterialMapper.deleteByPrimaryKey(truckNoMaterialId);

         }
         //新增车序号和物资中间表
        //获取车序号和物资信息进行新增车序号与物资中间表
        //一个销售订单对应多个车序号
        List<Map<String, Object>> selectionList = (List<Map<String, Object>>) map.get("selectionList");
        for (Map<String, Object> map3 : selectionList) {
            BigDecimal materialId = DataChange.dataToBigDecimal(map3.get("materialId"));
            Integer cxh = (Integer) map3.get("cxh");
            //生成车序号与物资实体
            AmsSaleOrderMaterial amsSaleOrderMaterial = new AmsSaleOrderMaterial();
            //生成主键
            amsSaleOrderMaterial.setSaleOrderMaterialId(amsSaleOrderMaterialMapper.selectMaxId());
            amsSaleOrderMaterial.setSaleOrderId(DataChange.dataToBigDecimal(map1.get("saleOrderId")));
            //获取收货地址
            amsSaleOrderMaterial.setSaleShippingAddressId(DataChange.dataToBigDecimal(map3.get("saleShipperAddressId")));
            //获取收货方电话号码

            amsSaleOrderMaterial.setSaleOrderConsigneeTel(map3.get("saleOrderConsigneeTel").toString());
            //获取收货日期
            String saleDateOfReceipt =(String) map3.get("saleDateOfReceipt");
            SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
            Date date = simpleDateFormat.parse(saleDateOfReceipt);
            amsSaleOrderMaterial.setSaleDateOfReceipt(date);
            //获取收货方姓名
            amsSaleOrderMaterial.setSaleOrderConsignee((String) map3.get("saleOrderConsignee"));
            //设置车序号
            amsSaleOrderMaterial.setSaleOrderMaterialTruckNo(new BigDecimal(cxh));
            //设置删除状态
            amsSaleOrderMaterial.setDeleted(new BigDecimal(0));
            i += amsSaleOrderMaterialMapper.insertSelective(amsSaleOrderMaterial);
            // 生成定向派单
            AmsDispatchSaleOrder amsDispatchSaleOrder = new AmsDispatchSaleOrder();
            amsDispatchSaleOrder.setDispatchId(amsDispatchSaleOrderMapper.selectOtherId());
            amsDispatchSaleOrder.setSaleOrderMaterialId(amsSaleOrderMaterial.getSaleOrderMaterialId());
            //获取收货地址
            Integer saleShipperAddressId =(Integer) map3.get("saleShipperAddressId");
            amsSaleOrderMaterial.setSaleShippingAddressId(new BigDecimal(saleShipperAddressId));
            //根据收货地址查询承运商
            Map<String,Object> map4 = amsSaleOrderMapper.selectProvince(saleShipperAddressId);
            BigDecimal carrierId = amsSaleOrderMapper.selectCarrierIdByprovince(map4);
            //获取收货方电话号码
            amsDispatchSaleOrder.setCarrierId(carrierId);
            amsDispatchSaleOrder.setDispatchTime(new Date());
            //设置成交类型
            amsDispatchSaleOrder.setDispatchType(new BigDecimal(0));
            //设置下发状态为已下发
            amsDispatchSaleOrder.setDispatchStatus(new BigDecimal(0));
            amsDispatchSaleOrder.setInsertTime(new Date());
            amsDispatchSaleOrder.setInsertUsername("admin");
            //新增车序号与物资中间表
            AmsSaleTrucknoMaterial trucknoMaterial = new AmsSaleTrucknoMaterial();
            trucknoMaterial.setTrucknoMaterialId(trucknoMaterialMapper.selectMaxId());
            //设置物资id
            trucknoMaterial.setMaterialId(materialId);
            //获取车序号物资id
            trucknoMaterial.setSaleOrderMaterialId(amsSaleOrderMaterial.getSaleOrderMaterialId());
            Integer orderPlanWeight = (Integer) map3.get("orderPlanWeight");
            trucknoMaterial.setSaleOrderMaterialNumber(DataChange.dataToBigDecimal(orderPlanWeight));
            //获取物资理重
            BigDecimal materialTheoreticalWeight = DataChange.dataToBigDecimal(map3.get("materialTheoreticalWeight"));
            //判断是否有物资理重
            if (materialTheoreticalWeight.intValue() != 0) {
                trucknoMaterial.setMaterialTheoreticalWeight(materialTheoreticalWeight);
            }
            //新增车序号与物资中间表
            i += trucknoMaterialMapper.insertSelective(trucknoMaterial);
        }

//        List<Map<String, Object>> mapList = (List<Map<String, Object>>) map.get("mapList");
//        ArrayList<Integer> list = new ArrayList<>();
//        for (Map<String, Object> truckMesMap : mapList) {
//            //修改车序号表
//            BigDecimal saleOrderMaterialId = DataChange.dataToBigDecimal(truckMesMap.get("saleOrderMaterialId"));
//            if (!list.contains(saleOrderMaterialId.intValue())) {
//                //车序号表专用字段
//                BigDecimal saleShipperAddressId = DataChange.dataToBigDecimal(truckMesMap.get("saleShipperAddressId"));
//                String saleDateOfReceipt =(String) truckMesMap.get("saleDateOfReceipt");
//                SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
//                Date date = simpleDateFormat.parse(saleDateOfReceipt);
//                String saleOrderConsignee = (String) truckMesMap.get("saleOrderConsignee");
//                String saleOrderConsigneeTel = (String) truckMesMap.get("saleOrderConsigneeTel");
//                AmsSaleOrderMaterial amsSaleOrderMaterial = new AmsSaleOrderMaterial();
//                amsSaleOrderMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
//                amsSaleOrderMaterial.setSaleOrderMaterialTruckNo(DataChange.dataToBigDecimal(truckMesMap.get("cxh")));
//                amsSaleOrderMaterial.setSaleShippingAddressId(saleShipperAddressId);
//                amsSaleOrderMaterial.setSaleDateOfReceipt(date);
//                amsSaleOrderMaterial.setSaleOrderConsignee(saleOrderConsignee);
//                amsSaleOrderMaterial.setSaleOrderConsigneeTel(saleOrderConsigneeTel);
//                i += amsSaleOrderMaterialMapper.updateByPrimaryKeySelective(amsSaleOrderMaterial);
//                list.add(saleOrderMaterialId.intValue());
//            }
//            //修改车车序号物资表
//            AmsSaleTrucknoMaterial amsSaleTrucknoMaterial = new AmsSaleTrucknoMaterial();
//            amsSaleTrucknoMaterial.setTrucknoMaterialId(DataChange.dataToBigDecimal(truckMesMap.get("trucknoMaterialId")));
//            amsSaleTrucknoMaterial.setSaleOrderMaterialNumber(DataChange.dataToBigDecimal(truckMesMap.get("orderPlanWeight")));
//            amsSaleTrucknoMaterial.setMaterialId(DataChange.dataToBigDecimal(truckMesMap.get("materialId")));
//            i += trucknoMaterialMapper.updateByPrimaryKeySelective(amsSaleTrucknoMaterial);
//        }

        return i;
    }

    @Override
    public int deleteAmsSaleOrderBySaleOrderId(BigDecimal saleOrderId) {
        //删除所有从表信息
        //amsSaleOrderMapper.deleteBySaleOrderId(saleOrderId);
        AmsSaleOrder amsSaleOrder = amsSaleOrderMapper.selectByPrimaryKey(saleOrderId);
        if(amsSaleOrder.getSaleOrderStatus().compareTo(new BigDecimal(0)) == 0) {

            amsSaleOrder.setDeleted(new BigDecimal(2));
            return amsSaleOrderMapper.updateByPrimaryKey(amsSaleOrder);
        }else{
            return -1;
        }
    }

    @Override
    public List<Map<String, Object>> getSaleOrderUpdateLog(Map<String, Object> map) {
        return amsSaleOrderMapper.getSaleOrderUpdateLog(map);
    }

    /**
     * 销售公司查询已审核的订单
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getSaleOrderListBySaleCompany(Map<String, Object> map) {
        return amsSaleOrderMapper.getSaleOrderListBySaleCompany(map);
    }

    @Override
    public List<Map<String, Object>> getAmsSaleOrderApproved(Map<String, Object> map) {
        return amsSaleOrderMapper.getAmsSaleOrderApproved(map);
    }

    @Override
    public List<Map<String, Object>> getSaleOrderList(Map<String, Object> mapValue) {
        return amsSaleOrderMapper.getSaleOrderList(mapValue);
    }

    public Map<String, Object> getCarrier(Integer addressId) {
        return amsSaleOrderMapper.selectProvince(addressId);
    }



    /**
     * 根据销售订单id查找信息
     */
    @Override
    public Map<String, Object> selectInfoBySaleOrderId(BigDecimal saleOrderId) {
        return amsSaleOrderMapper.selectInfoBySaleOrderId(saleOrderId);
    }

    /**
     * 根据销售订单id查找物资信息
     *
     * @param saleOrderId
     * @return
     */
    @Override
    public List<Map<String, Object>> selectMaterialInfoBySaleOrderId(BigDecimal saleOrderId) {
        return amsSaleOrderMapper.selectMaterialInfoBySaleOrderId(saleOrderId);
    }


    @Override
    public int addAmsDispatchSaleOrder(List<Map<String, Object>> mapValue) {
        int result = 0;
        for (Map<String,Object> map : mapValue) {
            Integer dispatchId = (Integer)map.get("dispatchId");
            AmsDispatchSaleOrder amsDispatchSaleOrder = amsDispatchSaleOrderMapper.selectByPrimaryKey(new BigDecimal(dispatchId));
            amsDispatchSaleOrder.setDispatchStatus(new BigDecimal(0));
            result = amsDispatchSaleOrderMapper.updateByPrimaryKeySelective(amsDispatchSaleOrder);
        }
        return result;
    }

    @Override
    public List<Map<String, Object>> getSaleOrderInfoes(Map<String, Object> map) {
        return amsSaleOrderMapper.getSaleOrderInfoes(map);
    }

    @Override
    public List<Map<String, Object>> getSaleOrderReportedes(Map<String, Object> map) {
        return amsSaleOrderMapper.getSaleOrderReportedes(map);
    }

    @Override
    public List<Map<String, Object>> getSaleOrderListBySaleCompanyes(Map<String, Object> map) {
        List<Map<String, Object>> resultList = amsSaleOrderMapper.getSaleOrderListBySaleCompanyes(map);
        return resultList;
    }

    @Override
    public List<Map<String, Object>> getAmsSaleOrderApprovedes(Map<String, Object> map) {
        List<Map<String,Object>> resultList = amsSaleOrderMapper.getAmsSaleOrderApprovedes(map);
        return resultList;
    }

    /*
     *  根据销售订单主键展示销售基本信息、物资信息
     * */
    @Override
    public List<Map<String, Object>> getSaleOrderAndMaterialById(Map<String,Object> mapValue) {
        List<Map<String, Object>> mapList=amsSaleOrderMapper.getSaleOrderAndMaterialById(mapValue);
        BigDecimal maxCxh = null;
        if(mapValue.get("saleOrderId") != null) {
            //如果销售订单存在,那么去获取该销售订单下最大的车序号
            maxCxh = amsSaleOrderMaterialMapper.getMaxCxh(DataChange.dataToBigDecimal(mapValue.get("saleOrderId")));
        }
        for (Map<String, Object> map : mapList) {
            map.put("maxCxh",maxCxh);
            BigDecimal number;
            BigDecimal materialNumber = (BigDecimal) map.get("materialNumber");
            BigDecimal materialWeight = (BigDecimal) map.get("materialWeight");
            String materialName =(String) map.get("materialName");
            if (materialNumber != null && materialNumber.toString().length() != 0 && !materialName.equals("钒渣")) {
                number = materialNumber;
            }
            else {
                number = materialWeight;
            }
            map.put("number",number);
        }
        return mapList;
    }

    /**
     * 销售焦炭订单
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getCokeSaleOrderList(Map<String, Object> mapValue) {
        List<Map<String,Object>> mapList = amsSaleOrderMapper.getCokeSaleOrderList(mapValue);
        for (Map<String, Object> resultMap : mapList) {
            BigDecimal saleOrderId = (BigDecimal) resultMap.get("saleOrderId");
            BigDecimal netWeight = amsSaleOrderMapper.getNetWeight(saleOrderId);
            BigDecimal carNum = amsSaleOrderMapper.getCarNum(saleOrderId);
            resultMap.put("netWeight",netWeight);
            resultMap.put("carNum",carNum);
        }
        return mapList;
    }

    /**
     * 新增钢材销售订单
     * @param mapValue
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int addSteelSaleOrder(Map<String, Object> mapValue) throws Exception {
        List<Map<String,Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");
        // 得到发货单位
        BigDecimal shipperId = DataChange.dataToBigDecimal(mapValue.get("shipperId"));
        // 收货单位
        BigDecimal receiveId = DataChange.dataToBigDecimal(mapValue.get("receiveId"));
        if (receiveId == null || receiveId.intValue() == 0) {
            receiveId = amsSaleOrderMapper.findReceiveId(mapValue.get("receiveName"));
            if (receiveId == null) {
                //if(mapValue.get("receiveName")!=null){
                //    //自动注册收货客户
                //    Map<String, Object> res = joinFeign.registerConsignee(mapValue);
                //    if("succeed".equals(res.get("status"))){
                //        receiveId=DataChange.dataToBigDecimal(res.get("data"));
                //    }else{
                //        System.out.println(res);
                //        throw new Exception("注册收货客户失败！请手动注册！");
                //    }
                //}else{
                //
                //}
                throw new Exception("下单客户不存在！！！");
            }
            //判断该收货客户有没有绑定片区
            BigDecimal saleAreaId = amsSaleOrderMapper.selectSaleAreaId(receiveId);
            if(saleAreaId == null){
                //如果片区为null,则绑定片区
                //根据片区名称去查找片区ID
                if(mapValue.get("saleArea") != null){
                    String saleAreaName = (String) mapValue.get("saleArea");
                    saleAreaId = amsSaleOrderMapper.selectSaleAreaIdByName(saleAreaName);
                    if(saleAreaId == null){
                        throw new Exception("您输入的销售片区：" + mapValue.get("saleArea") +"不存在！！");
                    }else{
                        //更新收货客户下的销售片区
                        amsSaleOrderMapper.bindSaleArea(receiveId,saleAreaId);
                    }
                }
            }
        }
        // 是否自提
        String isSelfMention = (String) mapValue.get("isSelfMention");
        // 备注
        String saleRemark = (String) mapValue.get("saleRemark");
        String saleGroupCode = null;
        Object splitStr = StringUtils.substringBetween(saleRemark,"钢材","组");
        if(splitStr == null || "".equals(splitStr)) {
            throw new Exception("您输入的摘要格式不正确,请检查后再导入!!,例:钢材某某组");
        }
        saleGroupCode = "钢" + StringUtils.substringBetween(saleRemark,"钢","组") + "组";
        // 收款客户
        String saleOrderReceiveCustomer = (String) mapValue.get("saleOrderReceiveCustomer");
        // 业务员
        BigDecimal salerId = DataChange.dataToBigDecimal(mapValue.get("salerId"));
        if (salerId == null || salerId.intValue() == 0) {
            if(mapValue.get("salerName") == null) {
                throw new Exception("您输入的业务员为空,请检查后再导入!!");
            }
            salerId = amsSaleOrderMapper.findSalerId(mapValue.get("salerName"));
            if (salerId == null) {
                throw new Exception("您输入的业务员：" + mapValue.get("salerName") +"不存在！！");
            }
        }
        BigDecimal saleOrderId = amsSaleOrderMapper.selectMaxId();
        int result = 0;
        // 销售订单
        AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
        amsSaleOrder.setReceiveId(receiveId);
        amsSaleOrder.setSaleRemark(saleRemark == null ? "":saleRemark);
        amsSaleOrder.setShipperId(shipperId);
        amsSaleOrder.setSaleOrderIsselfMention(isSelfMention);
        amsSaleOrder.setSaleOrderId(saleOrderId);
        amsSaleOrder.setSalerId(salerId);

        // 设置钢材订单
        amsSaleOrder.setSaleType(new BigDecimal(1));
        amsSaleOrder.setSaleNumber(DataChange.generateEightDigitsNumber("WXSDD",saleOrderId.intValue(),"-"));
        amsSaleOrder.setInsertTime(new Date());
        amsSaleOrder.setInsertUpdateRemark("物流新增销售订单");
        amsSaleOrder.setInsertUsername("物流");
        amsSaleOrder.setUpdateTime(new Date());
        amsSaleOrder.setDeleted(new BigDecimal(0));
        amsSaleOrder.setSaleOrderStatus(new BigDecimal(0));
        amsSaleOrder.setBusinessDate(new Date());
        // 税率默认13%
        amsSaleOrder.setSaleOrderTax("13%");
        // 含税单价某人4000
        amsSaleOrder.setSaleUnitPrice(new BigDecimal(4000));
        // 收款客户
        amsSaleOrder.setSaleOrderReceiveCustomer(saleOrderReceiveCustomer);
        // 销售订单物资表
        AmsSaleMaterial amsSaleMaterial = new AmsSaleMaterial();
        // 车序号物资表
        AmsSaleTrucknoMaterial amsSaleTrucknoMaterial = new AmsSaleTrucknoMaterial();
        // 遍历每一行
        for (Map<String, Object> map : mapList) {
            /*
             车序号表
             */
            // 得到车序号
            BigDecimal truckNo = DataChange.dataToBigDecimal(map.get("truckNo"));

            Map<String,Object> saleMap = new HashMap<>();
            saleMap.put("saleOrderId",saleOrderId);
            saleMap.put("saleOrderMaterialTruckNo",truckNo);
            // 检测销售订单下的车序号是否已存在
            List<AmsSaleOrderMaterial> amsSaleOrderMaterials = amsSaleOrderMaterialMapper.selectByParameters(saleMap);
            // 车序号表
            AmsSaleOrderMaterial amsSaleOrderMaterial = new AmsSaleOrderMaterial();
            if (amsSaleOrderMaterials == null || amsSaleOrderMaterials.size() == 0) {
                // 车序号主键
                BigDecimal saleOrderMaterialId = amsSaleOrderMaterialMapper.selectMaxId();
                BigDecimal shippingAddressId = DataChange.dataToBigDecimal(map.get("shipperAddressId"));
                if (shippingAddressId == null || shippingAddressId.intValue() == 0) {
                    String province = (String) map.get("province");
                    String district = (String) map.get("district");
                    String town = (String) map.get("town");
                    Map<String,Object> addressMap = new HashMap<>();
                    addressMap.put("province",province);
                    addressMap.put("district",district);
                    addressMap.put("town",town);
                    shippingAddressId = amsSaleOrderMapper.findAddressId(addressMap);
                    if (shippingAddressId == null) {
                        throw new Exception("您输入的：" + province + district + town + "地址不存在！！");
                    }
                }
                // 车号备注
                String truckRemark = (String) (map.get("truckRemark"));
                String place = (String) (map.get("place"));
                if (place != null && !"null".equals(place)) {
                    String addressType = rmsReceivePlaceMapper.getAddressType(shippingAddressId);
                    List<Map<String, Object>> placeIdList = amsSaleOrderMaterialMapper.getPlaceId(place,shippingAddressId);
                    if (placeIdList == null || placeIdList.size() == 0) {
                        if ("厂外库".equals(addressType)) {
                            throw new Exception("您输入的具体库房名称,不存在!请去维护");
                        }
                        RmsReceivePlace rmsReceivePlace = new RmsReceivePlace();
                        rmsReceivePlace.setPlaceId(rmsReceivePlaceMapper.selectMaxId());
                        rmsReceivePlace.setAddressId(shippingAddressId);
                        rmsReceivePlace.setAddressDeliveryAddress(place);
                        amsSaleOrderMaterial.setSaleShippingAddressId(rmsReceivePlace.getPlaceId());
                        rmsReceivePlaceMapper.insertSelective(rmsReceivePlace);
                    } else {
                        amsSaleOrderMaterial.setSaleShippingAddressId((BigDecimal) placeIdList.get(0).get("placeId"));
                    }
                }
                if (amsSaleOrderMaterial.getSaleShippingAddressId() != null && isSelfMention.equals("否") && DataChange.dataToBigDecimal(map.get("carrierId")).intValue() == 0) {
                    // 自动匹配承运商
                    List<Map<String, Object>> carrierList = getCarrierByAddress(amsSaleOrderMaterial.getSaleShippingAddressId());
                    BigDecimal carrierCount = null;
                    if(place != null && !"null".equals(place)){
                        carrierCount = amsSaleOrderMapper.getMoreCarrier(place);
                    }
                    //根据收货地址id查询备注，判断是否需要匹配承运商
                    String addressRemark = amsSaleOrderMaterialMapper.getAddressRemark(shippingAddressId);
                    // 单一承运商才进行匹配
                    if (carrierList != null && carrierList.size() == 1 && carrierList.get(0) != null  && carrierCount.intValue() == 0 && addressRemark == null) {
                        List<Map<String, Object>> list = new ArrayList<>();
                        Map<String, Object> map1 = carrierList.get(0);
                        // 传入车序号主键和承运商id
                        map1.put("saleOrderMaterialId", saleOrderMaterialId);
                        list.add(map1);
                        dispatchToCarrier(list);
                    }
                }
                if (isSelfMention.equals("是")) {
                    BigDecimal carrierId = null;
                    // 根据收货单位id查询出收货单位名称
                    if (place != null && place.contains("欧冶")) {
                        String placeRemark = amsSaleOrderMapper.selectPlaceRemark(place);
                        carrierId = amsSaleOrderMapper.selectCarrierId(placeRemark);
                    }else{
                        String consigneeName = amsSaleOrderMapper.selectConsigneeName(receiveId);
                        carrierId = amsSaleOrderMapper.selectCarrierId(consigneeName);
                    }
                    // 根据收货单位名称查询承运商id
                    List<Map<String, Object>> list = new ArrayList<>();
                    Map<String,Object> map1 = new HashMap<>();
                    // 传入车序号主键和承运商id
                    if (carrierId != null) {
                        map1.put("saleOrderMaterialId", saleOrderMaterialId);
                        map1.put("carrierId", carrierId);
                        list.add(map1);
                        dispatchToCarrier(list);
                    }
                }
                if (isSelfMention.equals("否") && DataChange.dataToBigDecimal(map.get("carrierId")).intValue() != 0) {
                    //说明有承运商
                    List<Map<String, Object>> list = new ArrayList<>();
                    Map<String, Object> carrierMap = new HashMap<>();
                    carrierMap.put("carrierId",map.get("carrierId"));
                    carrierMap.put("saleOrderMaterialId",saleOrderMaterialId);
                    list.add(carrierMap);
                    dispatchToCarrier(list);
                }
                // 收货方姓名
                String consigneeName = String.valueOf(map.get("saleOrderConsignee"));
                // 收货方电话
                String consigneeTel = String.valueOf(map.get("saleOrderConsigneeTel"));
                // 截止日期
                String dateOfReceiptStr = String.valueOf(map.get("saleDateOfReceipt"));
                SimpleDateFormat dateOfReceiptFormat = new SimpleDateFormat("yyyy-MM-dd");
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(new Date());
                calendar.add(Calendar.DATE,1);
                String dateOfReceiptDateStr = dateOfReceiptFormat.format(calendar.getTime()) + " 07:59:59";
                SimpleDateFormat dateOfReceiptFormatTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date dateOfReceiptDateNew = dateOfReceiptFormatTime.parse(dateOfReceiptDateStr);
                Date dateOfReceipt = null;
                if (!"null".equals(dateOfReceiptStr) && !"undefined".equals(dateOfReceiptStr)) {
                    dateOfReceipt = new Date(Long.valueOf(dateOfReceiptStr));
                }
                if (dateOfReceiptDateNew != null) {
                    dateOfReceipt  = dateOfReceiptDateNew;
                }
                amsSaleOrderMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
                amsSaleOrderMaterial.setSaleOrderId(saleOrderId);
                amsSaleOrderMaterial.setTruckRemark(truckRemark);
                amsSaleOrderMaterial.setSaleOrderMaterialTruckNo(truckNo);
                if(map.get("orderNo") != null) {
                    amsSaleOrderMaterial.setPreviousOrderNumber((String) map.get("orderNo"));
                }
                if (consigneeName != null && !consigneeName.equals("null")) {
                    amsSaleOrderMaterial.setSaleOrderConsignee(consigneeName);
                }
                if (consigneeTel != null && !consigneeTel.equals("null")) {
                    amsSaleOrderMaterial.setSaleOrderConsigneeTel(consigneeTel);
                }
                amsSaleOrderMaterial.setSaleDateOfReceipt(dateOfReceipt);
                amsSaleOrderMaterial.setInsertTime(new Date());
                amsSaleOrderMaterial.setUpdateTime(new Date());
                amsSaleOrderMaterial.setInsertUpdateRemark("物流新增");
                result += amsSaleOrderMaterialMapper.insertSelective(amsSaleOrderMaterial);
            }
            else {
                amsSaleOrderMaterial = amsSaleOrderMaterials.get(0);
            }
            /*
            销售订单物资表
             */
            // 物资
            BigDecimal materialId = DataChange.dataToBigDecimal(map.get("materialId"));
            if (materialId == null || materialId.intValue() == 0) {
                String name = (String) map.get("materialName");
                String specification = (String) map.get("materialSpecification");
                String model = (String) map.get("materialModel");
                Map<String,Object> materialMap = new HashMap<>();
                materialMap.put("name",name);
                materialMap.put("specification",specification);
                if (model == null || model.equals("") || model.equals("null")) {
                    model = null;
                }
                materialMap.put("model",model);
                materialId = amsSaleOrderMapper.findMaterialId(materialMap);
                if (materialId == null) {
                    throw new Exception("您输入的物资：" + name + specification + model + "不存在！！");
                }
            }
            Integer materialCount = amsSaleMaterialMapper.getMaterialCount(materialId);
            RmsMaterial rmsMaterial = new RmsMaterial();
            rmsMaterial.setMaterialId(materialId);
            if (materialCount == null) {
                materialCount = new Integer(0);
            }
            rmsMaterial.setMaterialCount(new BigDecimal(materialCount + 1));
            rmsMaterialMapper.updateByPrimaryKeySelective(rmsMaterial);
            // 物资件数
            BigDecimal materialNumber = DataChange.dataToBigDecimal(map.get("materialNumber"));
            // 物资名称
            Object materialName = map.get("materialName");
            // 钢材米数
            BigDecimal steelMeters = DataChange.dataToBigDecimal(map.get("steelMeters"));
            // 判断物资是否是盘螺或盘元/盘圆
            if (materialName != null && (materialName.toString().contains("盘螺") || materialName.toString().contains("盘元") || materialName.toString().contains("盘圆"))) {
                amsSaleMaterial.setSteelMeter(null);
            }
            else {
                amsSaleMaterial.setSteelMeter(steelMeters);
            }
            // 是否磅重销售（0：磅重；1：理重）
            BigDecimal isPoundSale = DataChange.dataToBigDecimal(map.get("isPoundSale"));
            // 销售订单物资表主键
            BigDecimal saleMaterialId = amsSaleMaterialMapper.selectMaxId();
            amsSaleMaterial.setSaleMaterialId(saleMaterialId);
            amsSaleMaterial.setSaleOrderId(saleOrderId);
            amsSaleMaterial.setMaterialId(materialId);
            amsSaleMaterial.setMaterialNumber(materialNumber);
            amsSaleMaterial.setMaterialPlanNumber(materialNumber);
            amsSaleMaterial.setSaleNo(amsSaleOrder.getSaleNumber());
            try {
                amsSaleMaterial.setTransferInOfWarehouse(saleRemark);
            } catch (Exception e) {
                e.printStackTrace();
            }
            if(saleGroupCode != null) {
                amsSaleMaterial.setTransferOutOfWarehouse(saleGroupCode);
            }
            amsSaleMaterial.setInsertTime(new Date());
            amsSaleMaterial.setUpdateTime(new Date());
            amsSaleMaterial.setIsPoundSale(isPoundSale);
            amsSaleMaterial.setInsertUpdateRemark("物流新增");
            result += amsSaleMaterialMapper.insertSelective(amsSaleMaterial);
            /*
            车序号物资表
             */
            // 车序号物资表主键
            BigDecimal truckNoMaterialId = amsSaleTrucknoMaterialMapper.selectMaxId();
            amsSaleTrucknoMaterial.setTrucknoMaterialId(truckNoMaterialId);
            amsSaleTrucknoMaterial.setSaleOrderMaterialId(amsSaleOrderMaterial.getSaleOrderMaterialId());
            amsSaleTrucknoMaterial.setMaterialId(amsSaleMaterial.getSaleMaterialId());
            amsSaleTrucknoMaterial.setSaleOrderMaterialNumber(materialNumber);
            amsSaleTrucknoMaterial.setInsertTime(new Date());
            amsSaleTrucknoMaterial.setUpdateTime(new Date());
            amsSaleTrucknoMaterial.setInsertUpdateRemark("物流新增");
            result += amsSaleTrucknoMaterialMapper.insertSelective(amsSaleTrucknoMaterial);
        }
        result += amsSaleOrderMapper.insertSelective(amsSaleOrder);

        return saleOrderId.intValue();
    }

    /**
     * 展示销售订单下的车序号和物资
     * @param saleOrderId
     * @return
     */
    @Override
    public List<Map<String, Object>> getTruckNoAndMaterialList(BigDecimal saleOrderId) {
        HashMap<String,Object> mapValue = new HashMap<>();
        mapValue.put("saleOrderId",saleOrderId);
        List<Map<String,Object>> mapList = amsSaleOrderMapper.getTruckNoAndMaterial(mapValue);
        for (Map<String,Object> map : mapList) {
            BigDecimal placeId = (BigDecimal) map.get("placeId");
            if (placeId != null) {
                List<Map<String, Object>> carrierAndPriceList = getCarrierByPlace(placeId);
                map.put("carrierAndPriceList", carrierAndPriceList);
            }
        }
        return mapList;
    }

    /**
     * 销售钢材派车
     * @param mapList
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int dispatchSteelOrder(List<Map<String, Object>> mapList) throws Exception {
        Map<String, Object> stringObjectMap = mapList.get(0);
        Integer isCheckGps = amsSaleOrderMapper.getDispachSwitch();
        Integer saleStatus = amsSaleOrderMapper.findStatus(DataChange.dataToBigDecimal(stringObjectMap.get("saleOrderMaterialId")));
        String selfMention = amsSaleOrderMapper.findSelfMention(DataChange.dataToBigDecimal(stringObjectMap.get("saleOrderMaterialId")));
        //如果这个车序号下面有运单,则证明已经派了
        Map<String,Object> orderMap = amsSaleOrderMapper.getSteelOrderMap(DataChange.dataToBigDecimal(stringObjectMap.get("saleOrderMaterialId")));
        //判断该车序号对应的分录是否全部关闭
        Integer flCount = amsSaleMaterialMapper.getAbleFlcount(DataChange.dataToBigDecimal(stringObjectMap.get("saleOrderMaterialId")));
        if(flCount == 0 && !"取消".equals(stringObjectMap.get("capacityNumber")) &&  !"待定".equals(stringObjectMap.get("capacityNumber"))) {
            throw new Exception("该运单下所有分录被关闭,无法派车");
        }
        if (orderMap != null) {
            throw new Exception("该订单已派发,无法重复派车");
        }
        if (saleStatus == 1) {
            throw new Exception("订单未审核，无法派车！");
        }
        int result = 0;
        // 遍历每一行
        for (Map<String,Object> map : mapList) {
            //得到此次是否校验GPS
            boolean onceCheck = true;
            try{
                onceCheck = (boolean) map.get("isCheckGPS");
            }catch (Exception e){
                //取值失败不处理，默认校验GPS
            }
            // 得到车牌号
            String capacityNumber = (String) map.get("capacityNumber");
            // 得到运力id
            BigDecimal capacityId = amsSaleOrderMaterialMapper.getCapacityId(capacityNumber);
            //Map<String,Object> details = amsSaleOrderMapper.getOrderIdByCapacity(map);
            //if(details!=null && details.get("orderId")!=null){
            //    if(details.get("isEn")==null){
            //        throw new Exception(capacityNumber+"有未进厂的运输订单任务，无法派单");
            //    }else if(details.get("isLeave")==null){
            //        throw new Exception(capacityNumber+"有未出厂的运输订单任务，无法派单");
            //    }else if(details.get("isArrival")==null){
            //        throw new Exception(capacityNumber+"有未抵达的运输订单任务，无法派单");
            //    }else if(details.get("isReceipt")==null){
            //        throw new Exception(capacityNumber+"有未签收的运输订单任务，无法派单");
            //    }
            //    throw new Exception(capacityNumber+"有未完成的运输订单任务，无法派单");
            //}
            //校验该车是否存在手机号
            String tel=omstruckOrderMapper.getTelByCapacityId(capacityId);//数据库的手机号
            String driverTel = (String) map.get("driverTel");//填写的手机号
            if(tel==null || "".equals(tel)){
                throw new Exception("该车没有电话号码，无法派车！请去资源管理-运力维护该车的电话号码！");
            }
            //查询车牌号是否是黑名单
            if(amsSaleOrderMapper.isBlackList(capacityNumber)>0){
                throw new Exception("该车在黑名单中，无法派车！请联系销售公司！");
            }
            // 得到车序号表主键
            BigDecimal saleOrderMaterialId = DataChange.dataToBigDecimal(map.get("saleOrderMaterialId"));
            //判断是欧冶
            String placeAddress = amsSaleOrderMapper.getPlaceAddress(saleOrderMaterialId);
            //非自提，单次校验且全局校验，且车不允许无GPS
            int isGPS = amsSaleOrderMapper.isGPS(capacityNumber);
            if (placeAddress != null && placeAddress.contains("欧冶") && onceCheck && onceCheck && (isCheckGps!=null && isCheckGps==0) && isGPS <= 0) {
                Map<String,Object> data=null;
                try{
                    data= (Map<String,Object>)otmsFeign.getCurrentLocation(capacityNumber).getData();
                }catch (Exception e){
                    throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
                }
                if(data==null || !"1001".equals(""+data.get("status"))){
                    throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
                }
            }
            if((selfMention==null || selfMention.equals("否")) && onceCheck && (isCheckGps!=null && isCheckGps==0) && isGPS <= 0){
                Map<String,Object> data=null;
                try{
                    data= (Map<String,Object>)otmsFeign.getCurrentLocation(capacityNumber).getData();
                }catch (Exception e){
                    throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
                }
                if(data==null || !"1001".equals(""+data.get("status"))){
                    throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
                }
            }
            //校验结束，上传金蝶
            if(!map.containsKey("oYeFlag")) {
                //不是欧冶库的可直接同步车号
                if(placeAddress == null || !placeAddress.contains("欧冶")){
                    pushCarNumberToEas(map);
                }
            }

            // 得到承运商
            BigDecimal carrierId = DataChange.dataToBigDecimal(map.get("carrierId"));
            // 查询到车序号的单价
            BigDecimal priceId = amsSaleOrderMapper.getOrderPrice(map);
            // 得到详细地址id
            BigDecimal placeId = amsSaleOrderMapper.getPlaceId(saleOrderMaterialId);
            // 如果已经设置单价则不覆盖，详细地址匹配不到单价，则匹配省市县内最高的一条单价(只给非自提的进行匹配)
            if (priceId == null && placeId != null && selfMention.equals("否")) {
                 priceId = amsSaleOrderMapper.getPriceIdByPlaceId(placeId);
            }
            // 运输线路id
            BigDecimal lineId = DataChange.dataToBigDecimal(map.get("lineId"));
            if(map.containsKey("oYeFlag")) {
                lineId = null;
            }
            BigDecimal isSteel = new BigDecimal(1);
            //try{
            //    //不为空且为新手机号，则修改电话号码
            //    if(driverTel!=null && !"".equals(driverTel) && !driverTel.equals(tel)){
            //        Map<String,Object> map1=new HashMap<>();
            //        map1.put("capacityNumber",capacityNumber);
            //        map1.put("capacityTel",driverTel);
            //        //在得到司机电话后给运力添加电话号码(通过车牌号)
            //        rmsFeign.updateCapacity(map1);
            //    }
            //}catch (Exception e){
            //    e.printStackTrace();
            //}
            if (capacityId == null) {
                return 0;
            }
            List<Map<String, Object>> materialList = amsSaleOrderMaterialMapper.getMaterial(saleOrderMaterialId);
            /*
             定向派单表
             */
            // 通过车序号主键确认定向派单是否已存在
            BigDecimal dispatchId0 = amsDispatchSaleOrderMapper.isDispatchExist(saleOrderMaterialId);
            if (dispatchId0 == null || dispatchId0.toString().length() == 0) {
                AmsDispatchSaleOrder amsDispatchSaleOrder = new AmsDispatchSaleOrder();
                // 主键
                BigDecimal dispatchId = amsDispatchSaleOrderMapper.selectOtherId();
                amsDispatchSaleOrder.setDispatchId(dispatchId);
                // 车序号表id
                amsDispatchSaleOrder.setSaleOrderMaterialId(saleOrderMaterialId);
                // 承运商id
                amsDispatchSaleOrder.setCarrierId(carrierId);
                // 派单时间和成交时间
                amsDispatchSaleOrder.setDispatchTime(new Date());
                amsDispatchSaleOrder.setDispatchDealTime(new Date());
                // 成交类型
                amsDispatchSaleOrder.setDispatchType(new BigDecimal(2));
                // 车序号状态
                amsDispatchSaleOrder.setDispatchStatus(new BigDecimal(2));
                result += amsDispatchSaleOrderMapper.insertSelective(amsDispatchSaleOrder);
            }
            // 如果已经匹配过承运商或者给某个承运商授权过，则派车时做修改承运商操作
            else {
                AmsDispatchSaleOrder amsDispatchSaleOrder = amsDispatchSaleOrderMapper.selectByPrimaryKey(dispatchId0);
                amsDispatchSaleOrder.setCarrierId(carrierId);
                result += amsDispatchSaleOrderMapper.updateByPrimaryKeySelective(amsDispatchSaleOrder);
            }
            /*
             运输订单
             */
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            Map<String, Object> map1 = new HashMap<>();
            map1.put("orderType", new BigDecimal(2));
            map1.put("orderPlanId", saleOrderMaterialId);
            List<OmstruckOrder> omstruckOrders = omstruckOrderMapper.selectByParameters(map1);
            if (omstruckOrders == null || omstruckOrders.size() == 0) {
                // 运输订单主键
                BigDecimal orderId = omstruckOrderMapper.selectMaxId();
                omstruckOrder.setOrderId(orderId);
                // 车序号主键
                omstruckOrder.setOrderPlanId(saleOrderMaterialId);
                //添加承运商ID 和 运价ID
//            Object priceId = map.get("priceId");
                if (priceId != null) {
                    omstruckOrder.setPriceId(priceId);
                } else {
                    omstruckOrder.setPriceId(new BigDecimal(0));
                }
                omstruckOrder.setCarrierId(carrierId);
                // 运输订单号
                omstruckOrder.setOrderNumber(DataChange.generateEightDigitsNumber("WYSDD", orderId.intValue()));
                // 运力id
                omstruckOrder.setCapacityId(capacityId);
                // 承运商
                omstruckOrder.setCarrierId(carrierId);
                // 是否可作业
                omstruckOrder.setCanWork(new BigDecimal(0));
                // 下发时间
                omstruckOrder.setOrderIssueTime(new Date());
                // 运单状态
                omstruckOrder.setOrderStatus(new BigDecimal(4));
                // 司机电话
                if(tel != null && !"".equals(tel)){
                    omstruckOrder.setDriverTel(tel);
                }
                BigDecimal status;
                // 钢材
                status = new BigDecimal(1);
                // 订单类型
                omstruckOrder.setOrderType(status);
                // 运输线路id
                omstruckOrder.setLineId(lineId);
                omstruckOrder.setInsertTime(new Date());
                omstruckOrder.setInsertUsername("");
                if(map.containsKey("oYeFlag")) {
                    omstruckOrder.setArrivalFlag(new BigDecimal(1));
                }
                //如果这个车序号下面有运单,则证明已经派了
                Map<String,Object> orderMap1 = amsSaleOrderMapper.getSteelOrderMap(saleOrderMaterialId);
                if (orderMap1 != null) {
                    continue;
                }
                result += omstruckOrderMapper.insertSelective(omstruckOrder);
                //插入日志
                saleLogUtil.logOrder(orderId,"普通派单,派车号:" + capacityNumber,map,SaleLogUtil.INSERT);
            } else {
                omstruckOrder = omstruckOrders.get(0);
            }
            for (Map<String, Object> materialMap : materialList) {
                BigDecimal materialId = (BigDecimal) materialMap.get("materialId");
                BigDecimal materialWeight = (BigDecimal) materialMap.get("materialWeight");
                BigDecimal materialNumber = (BigDecimal) materialMap.get("materialNumber");
                BigDecimal saleMaterialId = (BigDecimal) materialMap.get("saleMaterialId");

                /*
                运输订单物资子表
                */
                OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
                // 主键
                BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
                omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
                // 运输订单id
                omstruckOrderMaterial.setOrderId(omstruckOrder.getOrderId());
                // 物资id
                omstruckOrderMaterial.setMaterialId(materialId);
                // 物资重量
                omstruckOrderMaterial.setOrderMaterialWeight(materialWeight);
                // 物资件数
                omstruckOrderMaterial.setOrderMaterialNumber(materialNumber);
                omstruckOrderMaterial.setSaleMaterialId(saleMaterialId);
                if(map.containsKey("oYeFlag")) {
                    //查询装货地点
                    BigDecimal warehouseId = amsSaleMaterialMapper.selectWarehouseId(saleMaterialId);
                    if (warehouseId != null) {
                        omstruckOrderMaterial.setMaterialPriority(warehouseId);
                    }
                }
                try {
                    BigDecimal deleted = (BigDecimal) materialMap.get("DELETED");
                    if(deleted != null) {
                        omstruckOrderMaterial.setMaterialPriority(new BigDecimal(71));
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                // 新增运输订单子表
                result += omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
            }
            // 调用websocket
            Map<String, Object> orderIdMap = new HashMap<>();
            orderIdMap.put("orderId", omstruckOrder.getOrderId());
            try {
                amsSaleOrderMaterialService.pushMesToWebsocket(orderIdMap);
            } catch (Exception e) {
                e.printStackTrace();
            }
            // 生成运输执行总实绩
            result += tmsTruckFeign.addTotalResult(orderIdMap);
        }
        return  result;
    }

    /**
     * 钢材批量派车或改车
     * @param mapList
     * @return
     * @throws Exception
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int batchUpdateCapacity(List<Map<String, Object>> mapList) throws Exception {
        //先派车
        for(Map<String, Object> item:mapList){
            String capacityIds=""+item.get("capacityIds");
            if(capacityIds.equals("0")){
                //钢材派车
                dispatchSteelOrderNotPush(item);
            }else{
                //钢材改车
                updateSteelOrderNotPush(item);
            }
        }
        //再上传金蝶
        batchPushCarNumberToEas(mapList);
        return 0;
    }

    @Override
    public int updateSaleOrderRemark(List<Map<String, Object>> list) {
        int i = 0;
        for(Map<String,Object> map :list) {
            BigDecimal saleOrderId = DataChange.dataToBigDecimal(map.get("saleOrderId"));
            AmsSaleOrder amsSaleOrder = amsSaleOrderMapper.selectByPrimaryKey(saleOrderId);
            amsSaleOrder.setInsertUpdateRemark("重新设置继续装");
            i += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
        }
        return i;
    }

    @Override
    public int continueSteelOrder(List<Map<String, Object>> mapList) throws Exception {
        int result = 0;
        // 遍历每一行
        for (Map<String,Object> map : mapList) {
            List<OmstruckOrder> orders=omstruckOrderMapper.selectByParameters(map);
            if(orders==null || orders.size()<=0){
                if(map.get("deleteFlag") != null) {
                    orders = (List<OmstruckOrder>) map.get("previousOrders");
                    if(orders==null || orders.size()<=0) {
                        throw new Exception("没有对应的运输订单");
                    }
                }else{
                    throw new Exception("没有对应的运输订单");
                }
            }
            OmstruckOrder omstruckOrder=orders.get(0);
            // 得到车序号表主键
            BigDecimal saleOrderMaterialId = DataChange.dataToBigDecimal(map.get("saleOrderMaterialId"));
            // 得到承运商
            BigDecimal carrierId = omstruckOrder.getCarrierId();
            //查询车序号表物资
            List<Map<String, Object>> materialList = amsSaleOrderMaterialMapper.getMaterial(saleOrderMaterialId);
            if(materialList==null||materialList.size()<=0){
                throw new Exception("车序号没有剩余物资");
            }
            // 程序根据剩余多少拼生成运输线路id 110001 到 110010（单拼到十拼）
            BigDecimal lineId = DataChange.dataToBigDecimal(110000+materialList.size());
            if(omstruckOrder.getOrderType() != null && omstruckOrder.getOrderType().intValue() == 4) {
                //如果是内转钢材的,那么需要切换路线,判断是到专线还是到达州站
                if(zhuanxianLineIds.contains(omstruckOrder.getLineId().intValue())){
                    lineId = DataChange.dataToBigDecimal(zhuanxianLineIds.get(materialList.size() - 1));
                }else{
                    lineId = DataChange.dataToBigDecimal(dazhouLineIds.get(materialList.size() - 1));
                }
            }
            /*
             定向派单表
             */
            // 通过车序号主键确认定向派单是否已存在
            BigDecimal dispatchId0 = amsDispatchSaleOrderMapper.isDispatchExist(saleOrderMaterialId);
            if (dispatchId0 == null || dispatchId0.toString().length() == 0) {
                AmsDispatchSaleOrder amsDispatchSaleOrder = new AmsDispatchSaleOrder();
                // 主键
                BigDecimal dispatchId = amsDispatchSaleOrderMapper.selectOtherId();
                amsDispatchSaleOrder.setDispatchId(dispatchId);
                // 车序号表id
                amsDispatchSaleOrder.setSaleOrderMaterialId(saleOrderMaterialId);
                // 承运商id
                amsDispatchSaleOrder.setCarrierId(carrierId);
                // 派单时间和成交时间
                amsDispatchSaleOrder.setDispatchTime(new Date());
                amsDispatchSaleOrder.setDispatchDealTime(new Date());
                // 成交类型
                amsDispatchSaleOrder.setDispatchType(new BigDecimal(2));
                // 车序号状态
                amsDispatchSaleOrder.setDispatchStatus(new BigDecimal(2));
                result += amsDispatchSaleOrderMapper.insertSelective(amsDispatchSaleOrder);
            }
            // 如果已经匹配过承运商或者给某个承运商授权过，则派车时做修改承运商操作
            else {
                AmsDispatchSaleOrder amsDispatchSaleOrder = amsDispatchSaleOrderMapper.selectByPrimaryKey(dispatchId0);
                amsDispatchSaleOrder.setCarrierId(carrierId);
                result += amsDispatchSaleOrderMapper.updateByPrimaryKeySelective(amsDispatchSaleOrder);
            }
            /*
             运输订单
             */
            // 运输订单主键
            BigDecimal orderId = omstruckOrderMapper.selectMaxId();
            omstruckOrder.setOrderId(orderId);
            // 车序号主键
            omstruckOrder.setOrderPlanId(saleOrderMaterialId);
            // 是否可作业
            omstruckOrder.setCanWork(new BigDecimal(0));
            // 下发时间
            omstruckOrder.setOrderIssueTime(new Date());
            //如果该订单已有出厂实绩,不允许生成继续装
            // 运单状态
            if(omstruckOrder.getOrderReceiveRefuseTime()!=null){
                omstruckOrder.setOrderStatus(new BigDecimal(7));
            }else{
                omstruckOrder.setOrderStatus(new BigDecimal(4));
            }
            //路段顺序号
            //omstruckOrder.setOrderLineSequence(new BigDecimal(2));
            // 运输线路id
            omstruckOrder.setLineId(lineId);
            omstruckOrder.setInsertTime(new Date());
            omstruckOrder.setInsertUsername("continue");
            result += omstruckOrderMapper.insertSelective(omstruckOrder);
            //插入日志
            saleLogUtil.logOrder(orderId,"继续装派单",map,SaleLogUtil.INSERT);
            for (Map<String, Object> materialMap : materialList) {
                BigDecimal materialId = (BigDecimal) materialMap.get("materialId");
                BigDecimal materialWeight = (BigDecimal) materialMap.get("materialWeight");
                BigDecimal materialNumber = (BigDecimal) materialMap.get("materialNumber");
                BigDecimal saleMaterialId = (BigDecimal) materialMap.get("saleMaterialId");
                /*
                运输订单物资子表
                */
                OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
                // 主键
                BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
                omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
                // 运输订单id
                omstruckOrderMaterial.setOrderId(omstruckOrder.getOrderId());
                // 物资id
                omstruckOrderMaterial.setMaterialId(materialId);
                // 物资重量
                omstruckOrderMaterial.setOrderMaterialWeight(materialWeight);
                // 物资件数
                omstruckOrderMaterial.setOrderMaterialNumber(materialNumber);
                omstruckOrderMaterial.setSaleMaterialId(saleMaterialId);
                try {
                    BigDecimal deleted = (BigDecimal) materialMap.get("DELETED");
                    if(deleted != null) {
                        omstruckOrderMaterial.setMaterialPriority(new BigDecimal(71));
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                // 新增运输订单子表
                result += omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
            }
            // 调用websocket
            Map<String, Object> orderIdMap = new HashMap<>();
            orderIdMap.put("orderId", omstruckOrder.getOrderId());
            amsSaleOrderMaterialService.pushMesToWebsocket(orderIdMap);
            orderIdMap.put("orderIdOld", map.get("orderId"));
            orderIdMap.put("resultTotalIdOld",map.get("resultTotalId"));
            // 生成所有实绩
            result += tmsTruckFeign.copyAllResult(orderIdMap);
        }
        return  result;
    }
    /**
     * 根据详细地址匹配承运商
     * @param placeId
     * @return
     */
    @Override
    public synchronized List<Map<String,Object>> getCarrierByPlace(BigDecimal placeId) {
        BigDecimal addressId = amsSaleOrderMapper.getAddressByPlace(placeId);
        List<Map<String,Object>> mapList = amsSaleOrderMapper.getCarrierByPlace(placeId);
        return mapList;
    }

    /**
     * 根据省市县匹配承运商
     * @param placeId
     * @return
     */
    public synchronized List<Map<String,Object>> getCarrierByAddress(BigDecimal placeId) {
        BigDecimal addressId = amsSaleOrderMapper.getAddressByPlace(placeId);
        List<Map<String,Object>> mapList = amsSaleOrderMapper.getCarrierByAddress(addressId);
        try {
            if(mapList != null  && mapList.size() != 1) {
                mapList = amsSaleOrderMapper.getNextCarrier(addressId.intValue());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return mapList;
    }

    /**
     * 根据详细地址和承运商匹配单价
     * @param mapValue
     * @return
     */
    @Override
    public Map<String, Object> getPriceByCarrierAndPlace(Map<String, Object> mapValue) {
        Map<String,Object> map = amsSaleOrderMapper.getPriceByCarrierAndPlace(mapValue);
        return map;
    }

    /**
     * 将车序号下发给承运商
     * @param mapList
     * @return
     */
    @Override
    public int dispatchToCarrier(List<Map<String,Object>> mapList) {
        int result = 0;
        // 遍历每一行
        for (Map<String, Object> map : mapList) {
            // 得到承运商
            BigDecimal carrierId =DataChange.dataToBigDecimal(map.get("carrierId"));
            // 得到车序号表主键
            BigDecimal saleOrderMaterialId =DataChange.dataToBigDecimal(map.get("saleOrderMaterialId"));
            //判断该车序号有没有被授权
            List<BigDecimal> dispatchCarriers = amsDispatchSaleOrderMapper.getDispatchCarriers(saleOrderMaterialId);
            //如果有的话删除授权，重新新增
            for(BigDecimal dispatchId : dispatchCarriers) {
                amsDispatchSaleOrderMapper.deleteByPrimaryKey(dispatchId);
            }
            //判断该车序号有没有被授权
            AmsDispatchSaleOrder amsDispatchSaleOrder = new AmsDispatchSaleOrder();
            BigDecimal dispatchId = amsDispatchSaleOrderMapper.selectOtherId();
            amsDispatchSaleOrder.setDispatchId(dispatchId);
            amsDispatchSaleOrder.setCarrierId(carrierId);
            amsDispatchSaleOrder.setSaleOrderMaterialId(saleOrderMaterialId);
            amsDispatchSaleOrder.setInsertTime(new Date());
            amsDispatchSaleOrder.setInsertUpdateRemark("授权承运商");
            // 派单时间和成交时间
            amsDispatchSaleOrder.setDispatchTime(new Date());
            amsDispatchSaleOrder.setDispatchDealTime(new Date());
            // 成交类型
            amsDispatchSaleOrder.setDispatchType(new BigDecimal(2));
            // 车序号状态
            amsDispatchSaleOrder.setDispatchStatus(new BigDecimal(2));
            result += amsDispatchSaleOrderMapper.insertSelective(amsDispatchSaleOrder);
            //判断有没有运输订单
            int countOrder = amsSaleOrderMaterialMapper.getOrderCount(saleOrderMaterialId);
            if (countOrder > 0) {
                amsSaleOrderMaterialMapper.updateOrderCarrier(saleOrderMaterialId,carrierId);
            }
        }
        return result;
    }

    @Override
    public List<Map<String, Object>> getSaleOrderListToCarrier(Map<String, Object> map) {
        List<Map<String, Object>> resultList = amsSaleOrderMapper.getSaleOrderListToCarrier(map);
        if (resultList.isEmpty()){

        }else {
            for (Map<String, Object> stringObjectMap : resultList) {
                try {
                    BigDecimal saleShippingAddressId = (BigDecimal) stringObjectMap.get("saleShippingAddressId");
                    if (saleShippingAddressId!=null&&!("".equals(saleShippingAddressId))){
                        String address = amsSaleOrderMapper.getshippingAddress(saleShippingAddressId);
                        stringObjectMap.put("saleShippingAddress",address);
                    }
                }catch (Exception e){
                    System.out.println("e"+e.getMessage());
                    stringObjectMap.put("saleShippingAddress","");
                }

            }
        }
        return resultList;
    }

    @Override
    public List<Map<String, Object>> getSaleOrderListByCarrierSsoId(Map<String, Object> map) {
        List<Map<String, Object>> resultList = amsSaleOrderMapper.getSaleOrderListByCarrierSsoId(map);
        return resultList;
    }

    /**
     * 同步金蝶删除
     * @param saleOrderId
     * @return
     */
    @Override
    public int deleteSaleOrderById(BigDecimal saleOrderId) {
        int result = 0;
        AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
        amsSaleOrder.setSaleOrderId(saleOrderId);
        amsSaleOrder.setDeleted(new BigDecimal(2));
        // 如果是已经上传金蝶的销售订单，则同步删除
        AmsSaleOrder amsSaleOrder1 = amsSaleOrderMapper.selectByPrimaryKey(saleOrderId);
        if (amsSaleOrder1.getSaleOrderStatus().intValue() == 4) {
            String reason = "修改物资关闭上一条销售订单";
            String number = amsSaleOrder1.getSaleNumber();
            String wholeOrder = "1";
            String status = "close";
            Map<String,Object> head = new HashMap<>();
            head.put("number",number);
            head.put("reason",reason);
            head.put("wholeOrder",wholeOrder);
            head.put("status",status);
            Map<String,Object> input = new HashMap<>();
            Map<String, Object> totalMap = easDeleteApproveUtil.getTotalMap();
            input.put("head",head);
            totalMap.put("input",input);
            // 调用金蝶关闭接口
            String json = JSONUtils.toJSONString(totalMap);
            System.out.println(json);
            Map<String,Object> resultMap = joinFeign.deleteSaleOrderToEas(totalMap);
            try {
                newFileTool.newFile("deleteSaleOrderToEas："+totalMap,"金蝶通讯报文");
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println(resultMap);
        }else if(amsSaleOrder1.getSaleOrderStatus().intValue() == 1 || amsSaleOrder1.getSaleOrderStatus().intValue() == 2){
            String reason = "修改物资关闭上一条销售订单";
            String number = amsSaleOrder1.getSaleNumber();
            Map<String, Object> deleteMap = new HashMap<>();
            deleteMap.put("saleOrderId",saleOrderId);
            deleteMap.put("reason",reason);
            deleteMap.put("number",number);
            deleteSaleOrderSame(deleteMap);
        }
        // 如果是副产品订单则关闭时同步关闭未进厂的运单
        Map<String,Object> map = new HashMap<>();
        map.put("saleOrderId",saleOrderId);
        List<AmsSaleMaterial> amsSaleMaterials = amsSaleMaterialMapper.selectByParameters(map);
        if (amsSaleMaterials != null && amsSaleMaterials.get(0).getSaleWarehouse() != null && amsSaleMaterials.get(0).getSaleWarehouse().equals("副产品库")) {
            result += amsSaleOrderMapper.closeOrderNotIn(saleOrderId);
        }
        try {
            saleLogUtil.logSaleOrder(saleOrderId,"物流删除/关闭销售订单" ,"物流" ,SaleLogUtil.CLOSE);
        } catch (Exception e) {
            e.printStackTrace();
        }
        result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
        return result;
    }

    /**
     * 查询出销售订单下的所有数据
     * @param saleOrderId
     * @return
     */
    @Override
    public Map<String, Object> getAllSaleMessages(BigDecimal saleOrderId) {
        Map<String,Object> saleMap = amsSaleOrderMapper.getSaleMapMessages(saleOrderId);
        List<Map<String,Object>> mapList = amsSaleOrderMapper.getSaleListMessages(saleOrderId);
        saleMap.put("mapList",mapList);
        return saleMap;
    }

    /**
     * 修改承运商授权
     * @param mapValue
     * @return
     */
    @Override
    public int updateTruckNoCarrier(Map<String, Object> mapValue) {
        BigDecimal carrierId = DataChange.dataToBigDecimal(mapValue.get("carrierId"));
        mapValue.remove("carrierId");
        List<AmsDispatchSaleOrder> amsDispatchSaleOrders = amsDispatchSaleOrderMapper.selectByParameters(mapValue);
        AmsDispatchSaleOrder amsDispatchSaleOrder = amsDispatchSaleOrders.get(0);
        amsDispatchSaleOrder.setCarrierId(carrierId);
        int countOrder = amsSaleOrderMaterialMapper.getOrderCount(amsDispatchSaleOrder.getSaleOrderMaterialId());
        if (countOrder > 0) {
            amsSaleOrderMaterialMapper.updateOrderCarrier(amsDispatchSaleOrder.getSaleOrderMaterialId(),carrierId);
        }
        int result = amsDispatchSaleOrderMapper.updateByPrimaryKeySelective(amsDispatchSaleOrder);
        return result;
    }

    /**
     * 批量上传销售订单至金蝶
     * @param saleOrderIdList
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int uploadSaleOrderList(List<Map<String, Object>> saleOrderIdList) {
        int result = 0;
        for (Map<String, Object> map : saleOrderIdList) {
            AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
            BigDecimal saleOrderId = DataChange.dataToBigDecimal(map.get("saleOrderId"));
            // 调用金蝶接口，将销售订单推送到金蝶系统
            Map<String, Object> input = joinFeign.getSaleOrder(saleOrderId);
            Map<String, Object> head = (Map<String, Object>) input.get("head");
            head.put("status","");
            // 获得金蝶接口配置:正式
//            Map<String, Object> totalMap = easUtil.getTotalMap();
            Map<String, Object> totalMap = new HashMap<>();
            totalMap.putAll(easUtil.getTotalMap());
            // 组装报文
            totalMap.put("input",input);
            System.out.println(totalMap);
            String json = JSONUtils.toJSONString(totalMap);
            System.out.println(json);
            Map<String,Object> s = joinFeign.pushSaleOrderToEas(totalMap);
            try {
                newFileTool.newFile("pushSaleOrderToEas："+totalMap,"金蝶通讯报文");
            }catch (Exception e){
                e.printStackTrace();
            }
            if (s == null || s.size() == 0) {
                continue;
            }else {
                try {
                    JSONObject result1 = new JSONObject(s);
                    //如果status不为1,抛出异常
                    if (!result1.getJSONObject("res").getString("status").equals("1")) {
                        continue;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    //只抛出自定义异常
                   continue;
                }
            }
            amsSaleOrder.setSaleOrderId(saleOrderId);
            amsSaleOrder.setSaleOrderStatus(new BigDecimal(1));
            try {
                saleLogUtil.logSaleOrder(saleOrderId,"物流上传销售订单至金蝶" ,"物流" ,SaleLogUtil.UPDATE);
            } catch (Exception e) {
                e.printStackTrace();
            }
            result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
        }
        return result;
    }

    /**
     * 新增钒渣销售订单
     * @param mapValue
     * @return
     */
    @Override
    public int addVanadiumSaleOrder(Map<String, Object> mapValue) {
        List<Map<String,Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");
        // 得到发货单位
        BigDecimal shipperId = DataChange.dataToBigDecimal(mapValue.get("shipperId"));
        // 收货单位
        BigDecimal receiveId = DataChange.dataToBigDecimal(mapValue.get("receiveId"));
        // 是否自提
        String isSelfMention = (String) mapValue.get("isSelfMention");
        // 备注
        String saleRemark = (String) mapValue.get("saleRemark");
        // 收款客户
        String saleOrderReceiveCustomer = (String) mapValue.get("saleOrderReceiveCustomer");
        // 业务员
        BigDecimal salerId = DataChange.dataToBigDecimal(mapValue.get("salerId"));
        BigDecimal saleOrderId = amsSaleOrderMapper.selectMaxId();
        int result = 0;
        // 销售订单
        AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
        amsSaleOrder.setReceiveId(receiveId);
        amsSaleOrder.setSaleRemark(saleRemark == null ? "":saleRemark);
        amsSaleOrder.setShipperId(shipperId);
        amsSaleOrder.setSaleOrderIsselfMention(isSelfMention);
        amsSaleOrder.setSaleOrderId(saleOrderId);
        amsSaleOrder.setSalerId(salerId);
        // 设置钒渣订单
        amsSaleOrder.setSaleType(new BigDecimal(2));
        amsSaleOrder.setSaleNumber(DataChange.generateEightDigitsNumber("WXSDD",saleOrderId.intValue(),"-"));
        amsSaleOrder.setInsertTime(new Date());
        amsSaleOrder.setInsertUpdateRemark("物流新增销售订单");
        amsSaleOrder.setInsertUsername("物流");
        amsSaleOrder.setUpdateTime(new Date());
        amsSaleOrder.setDeleted(new BigDecimal(0));
        amsSaleOrder.setSaleOrderStatus(new BigDecimal(0));
        // 税率默认13%
        amsSaleOrder.setSaleOrderTax("13%");
        // 含税单价某人4000
        amsSaleOrder.setSaleUnitPrice(new BigDecimal(4000));
        // 收款客户
        amsSaleOrder.setSaleOrderReceiveCustomer(saleOrderReceiveCustomer);
        // 销售订单物资表
        AmsSaleMaterial amsSaleMaterial = new AmsSaleMaterial();
        // 车序号物资表
        AmsSaleTrucknoMaterial amsSaleTrucknoMaterial = new AmsSaleTrucknoMaterial();
        // 遍历每一行
        for (Map<String, Object> map : mapList) {
            /*
             车序号表
             */
            // 得到车序号
            BigDecimal truckNo = DataChange.dataToBigDecimal(map.get("truckNo"));
            Map<String,Object> saleMap = new HashMap<>();
            saleMap.put("saleOrderId",saleOrderId);
            saleMap.put("saleOrderMaterialTruckNo",truckNo);
            // 检测销售订单下的车序号是否已存在
            List<AmsSaleOrderMaterial> amsSaleOrderMaterials = amsSaleOrderMaterialMapper.selectByParameters(saleMap);
            // 车序号表
            AmsSaleOrderMaterial amsSaleOrderMaterial = new AmsSaleOrderMaterial();
            if (amsSaleOrderMaterials == null || amsSaleOrderMaterials.size() == 0) {
                // 车序号主键
                BigDecimal saleOrderMaterialId = amsSaleOrderMaterialMapper.selectMaxId();
                BigDecimal shippingAddressId = DataChange.dataToBigDecimal(map.get("shipperAddressId"));
                // 车号备注
                String truckRemark = (String) (map.get("truckRemark"));
                String place = (String) (map.get("place"));
                if (place != null && !"null".equals(place)) {
                    List<Map<String, Object>> placeIdList = amsSaleOrderMaterialMapper.getPlaceId(place,shippingAddressId);
                    if (placeIdList == null || placeIdList.size() == 0) {
                        RmsReceivePlace rmsReceivePlace = new RmsReceivePlace();
                        rmsReceivePlace.setPlaceId(rmsReceivePlaceMapper.selectMaxId());
                        rmsReceivePlace.setAddressId(shippingAddressId);
                        rmsReceivePlace.setAddressDeliveryAddress(place);
                        amsSaleOrderMaterial.setSaleShippingAddressId(rmsReceivePlace.getPlaceId());
                        rmsReceivePlaceMapper.insertSelective(rmsReceivePlace);
                    } else {
                        amsSaleOrderMaterial.setSaleShippingAddressId((BigDecimal) placeIdList.get(0).get("placeId"));
                    }
                }
                if (amsSaleOrderMaterial.getSaleShippingAddressId() != null && isSelfMention.equals("否")) {
                    // 自动匹配承运商
                    List<Map<String, Object>> carrierList = getCarrierByPlace(amsSaleOrderMaterial.getSaleShippingAddressId());
                    // 单一承运商才进行匹配
                    if (carrierList != null && carrierList.size() == 1) {
                        List<Map<String, Object>> list = new ArrayList<>();
                        Map<String, Object> map1 = carrierList.get(0);
                        // 传入车序号主键和承运商id
                        map1.put("saleOrderMaterialId", saleOrderMaterialId);
                        map1.put("carrierId", map1.get("value"));
                        list.add(map1);
                        dispatchToCarrier(list);
                    }
                }
                if (isSelfMention.equals("是")) {
                    // 根据收货单位id查询出收货单位名称
                    String consigneeName = amsSaleOrderMapper.selectConsigneeName(receiveId);
                    // 根据收货单位名称查询承运商id
                    BigDecimal carrierId = amsSaleOrderMapper.selectCarrierId(consigneeName);
                    List<Map<String, Object>> list = new ArrayList<>();
                    Map<String,Object> map1 = new HashMap<>();
                    // 传入车序号主键和承运商id
                    if (carrierId != null) {
                        map1.put("saleOrderMaterialId", saleOrderMaterialId);
                        map1.put("carrierId", carrierId);
                        list.add(map1);
                        dispatchToCarrier(list);
                    }
                }
                // 收货方姓名
                String consigneeName = String.valueOf(map.get("saleOrderConsignee"));
                // 收货方电话
                String consigneeTel = String.valueOf(map.get("saleOrderConsigneeTel"));
                // 截止日期
                String dateOfReceiptStr = String.valueOf(map.get("saleDateOfReceipt"));
                Date dateOfReceipt = null;
                if (!"null".equals(dateOfReceiptStr) && !"undefined".equals(dateOfReceiptStr)) {
                    dateOfReceipt = new Date(Long.valueOf(dateOfReceiptStr));
                }
                amsSaleOrderMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
                amsSaleOrderMaterial.setSaleOrderId(saleOrderId);
                amsSaleOrderMaterial.setTruckRemark(truckRemark);
                amsSaleOrderMaterial.setSaleOrderMaterialTruckNo(truckNo);
                if (consigneeName != null && !consigneeName.equals("null")) {
                    amsSaleOrderMaterial.setSaleOrderConsignee(consigneeName);
                }
                if (consigneeTel != null && !consigneeTel.equals("null")) {
                    amsSaleOrderMaterial.setSaleOrderConsigneeTel(consigneeTel);
                }
                amsSaleOrderMaterial.setSaleDateOfReceipt(dateOfReceipt);
                amsSaleOrderMaterial.setInsertTime(new Date());
                amsSaleOrderMaterial.setUpdateTime(new Date());
                amsSaleOrderMaterial.setInsertUpdateRemark("物流新增");
                result += amsSaleOrderMaterialMapper.insertSelective(amsSaleOrderMaterial);
            }
            else {
                amsSaleOrderMaterial = amsSaleOrderMaterials.get(0);
            }
            /*
            销售订单物资表
             */
            // 物资
            BigDecimal materialId = DataChange.dataToBigDecimal(map.get("materialId"));
            // 物资件数
            BigDecimal materialNumber = DataChange.dataToBigDecimal(map.get("materialNumber"));
            // 钢材米数
            BigDecimal steelMeters = DataChange.dataToBigDecimal(map.get("steelMeters"));
            // 是否磅重销售（0：磅重；1：理重）
            BigDecimal isPoundSale = DataChange.dataToBigDecimal(map.get("isPoundSale"));
            // 销售订单物资表主键
            BigDecimal saleMaterialId = amsSaleMaterialMapper.selectMaxId();
            amsSaleMaterial.setSaleMaterialId(saleMaterialId);
            amsSaleMaterial.setSaleOrderId(saleOrderId);
            amsSaleMaterial.setMaterialId(materialId);
            amsSaleMaterial.setMaterialNumber(materialNumber);
            amsSaleMaterial.setInsertTime(new Date());
            amsSaleMaterial.setUpdateTime(new Date());
            if (steelMeters != null && !steelMeters.toString().equals("0")) {
                amsSaleMaterial.setSteelMeter(steelMeters);
            }
            amsSaleMaterial.setIsPoundSale(isPoundSale);
            amsSaleMaterial.setInsertUpdateRemark("物流新增");
            result += amsSaleMaterialMapper.insertSelective(amsSaleMaterial);
            /*
            车序号物资表
             */
            // 车序号物资表主键
            BigDecimal truckNoMaterialId = amsSaleTrucknoMaterialMapper.selectMaxId();
            amsSaleTrucknoMaterial.setTrucknoMaterialId(truckNoMaterialId);
            amsSaleTrucknoMaterial.setSaleOrderMaterialId(amsSaleOrderMaterial.getSaleOrderMaterialId());
            amsSaleTrucknoMaterial.setMaterialId(amsSaleMaterial.getSaleMaterialId());
            amsSaleTrucknoMaterial.setSaleOrderMaterialNumber(materialNumber);
            amsSaleTrucknoMaterial.setInsertTime(new Date());
            amsSaleTrucknoMaterial.setUpdateTime(new Date());
            amsSaleTrucknoMaterial.setInsertUpdateRemark("物流新增");
            result += amsSaleTrucknoMaterialMapper.insertSelective(amsSaleTrucknoMaterial);
        }
        result += amsSaleOrderMapper.insertSelective(amsSaleOrder);
        return result;
    }

    /**
     * 自动匹配出最近的一个地址
     * @param receiveId
     * @return
     */
    @Override
    public List<Map<String, Object>> matchingAddressRecently(BigDecimal receiveId) {
        List<Map<String,Object>> mapList = amsSaleOrderMapper.matchingAddressRecently(receiveId);
        List<Map<String,Object>> salerList = amsSaleOrderMapper.getSalerByReceiveId(receiveId);
        if (mapList != null && mapList.size() != 0) {
            if (salerList != null && salerList.size() !=0) {
                Map<String, Object> salerMap = salerList.get(0);
                for (Map<String, Object> map : mapList) {
                    map.putAll(salerMap);
                }
            }
        }
        return mapList;
    }

    /**
     * 自动匹配上一条运单的司机电话
     * @param capacityNumber
     * @return
     */
    @Override
    public String matchingDriverTelRecently(String capacityNumber) {
        String driverTel = amsSaleOrderMapper.matchingDriverTelRecently(capacityNumber);
        return driverTel;
    }

    /**
     * 查询内转焦炭订单
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getCokeInwardOrderList(Map<String, Object> mapValue) {
        return amsSaleOrderMapper.getCokeInwardOrderList(mapValue);
    }

    /**
     * 修改收货地址
     * @param mapValue
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int  updateCarAddress(Map<String, Object> mapValue) {
        // 判断是否需要删除金蝶分录
        Integer isCloseEas = (Integer) mapValue.get("isCloseEas");
        String operateName = (String) mapValue.get("operateName");
        int result = 0;
        // 运输订单id
        BigDecimal orderId = DataChange.dataToBigDecimal(mapValue.get("orderId"));
        // 车序号id
        BigDecimal saleOrderMaterialId = DataChange.dataToBigDecimal(mapValue.get("saleOrderMaterialId"));
        // 是
        if (isCloseEas == 0 && orderId != null && orderId.intValue() != 0) {
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            omstruckOrder.setOrderId(orderId);
            omstruckOrder.setOrderStatus(new BigDecimal(7));
            omstruckOrder.setInsertUpdateRemark("修改收货地址将状态改为7");
            if(operateName != null){
                omstruckOrder.setOptionerCode(operateName);
            }
            omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
            //插入日志
            saleLogUtil.logOrder(orderId,"关闭分录,同步关闭运单",mapValue,SaleLogUtil.UPDATE);
            // 得到销售订单物资表主键
            List<Map<String,Object>> saleMaterialIdList = amsSaleOrderMapper.getSaleMaterialId(saleOrderMaterialId);
            for (Map<String, Object> map : saleMaterialIdList) {
                // 关闭销售订单物资子表
                BigDecimal saleMaterialId = (BigDecimal) map.get("saleMaterialId");
                AmsSaleMaterial amsSaleMaterial = new AmsSaleMaterial();
                amsSaleMaterial.setDeleted(new BigDecimal(0));
                amsSaleMaterial.setSaleMaterialId(saleMaterialId);
                amsSaleMaterialMapper.updateByPrimaryKeySelective(amsSaleMaterial);
            }
            return 0;
        }
        //插入日志
        saleLogUtil.logOrder(orderId,"修改收货地址",mapValue,SaleLogUtil.UPDATE);
        // 判断是否需要修改派车
        Object isNewCar = mapValue.get("isNewCar");
        // 省市县ID
        BigDecimal shippingAddressId = DataChange.dataToBigDecimal(mapValue.get("shipperAddressId"));
        // 具体地址
        String place = (String) mapValue.get("place");
        Integer addressid1= (Integer) mapValue.get("placeId");
        BigDecimal addressid2 =BigDecimal.ZERO;
        AmsSaleOrderMaterial amsSaleOrderMaterial = amsSaleOrderMaterialMapper.selectByPrimaryKey(saleOrderMaterialId);
        if (place != null && !("".equals(place))) {
            List<Map<String, Object>> placeIdList = amsSaleOrderMaterialMapper.getPlaceId(place,shippingAddressId);
            if (placeIdList == null || placeIdList.size() == 0) {
                RmsReceivePlace rmsReceivePlace = new RmsReceivePlace();
                BigDecimal placeId = rmsReceivePlaceMapper.selectMaxId();
                rmsReceivePlace.setPlaceId(placeId);
                rmsReceivePlace.setAddressId(shippingAddressId);
                rmsReceivePlace.setAddressDeliveryAddress(place);
                amsSaleOrderMaterial.setSaleShippingAddressId(rmsReceivePlace.getPlaceId());
                rmsReceivePlaceMapper.insertSelective(rmsReceivePlace);
                addressid2 = placeId;
            } else {
                addressid2 =(BigDecimal) placeIdList.get(0).get("placeId");
                amsSaleOrderMaterial.setSaleShippingAddressId((BigDecimal) placeIdList.get(0).get("placeId"));
            }
        }
        try{
            //修改单价
            Map<String,Object> data=new HashMap<>();
            List<Map<String,Object>> mapList = new ArrayList<>();
            mapValue.put("priceId",DataChange.dataToBigDecimal(amsSaleOrderMaterialMapper.getPriceByPlace(addressid2)));
            mapList.add(mapValue);
            data.put("mapList",mapList);
            bmstruckFeign.updateBatchDetailsOrder(data);
        }catch (Exception e){
            e.printStackTrace();
        }
        String addressids="";
        addressids =addressid1+","+addressid2;
        amsSaleOrderMaterial.setShippingAddressIds(addressids);
        amsSaleOrderMaterialMapper.setHistoryAddressId(mapValue);//修改历史地址
        result += amsSaleOrderMaterialMapper.updateByPrimaryKeySelective(amsSaleOrderMaterial);
        //给改了收货地址的车换单价
        try {
            if(orderId != null && orderId.intValue() != 0){
                //1.查看地址是否存在单价
                BigDecimal priceId = amsSaleOrderMaterialMapper.getPriceIdForUpdate(addressid2);
                if (priceId!=null){
                    //把当前的单价给修改进运输单中
                    amsSaleOrderMaterialMapper.updateOmstruckOrder(priceId,orderId);
                }else {
                    //把0存入运输单中
                    priceId=BigDecimal.ZERO;
                    amsSaleOrderMaterialMapper.updateOmstruckOrder(priceId,orderId);
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("e"+e.getMessage());
        }
        // 需要换车
        if (isNewCar != null && (Integer) isNewCar == 0) {
            // 根据车序号得到定向派单表主键
            BigDecimal dispatchId = amsSaleOrderMapper.getDispatchId(saleOrderMaterialId);
            if (dispatchId != null) {
                amsDispatchSaleOrderMapper.deleteByPrimaryKey(dispatchId);
            }
            if (orderId != null) {
                omstruckOrderMapper.deleteByPrimaryKey(orderId);
            }
            if (amsSaleOrderMaterial.getSaleShippingAddressId() != null) {
                // 自动匹配承运商
                List<Map<String, Object>> carrierList = getCarrierByPlace(amsSaleOrderMaterial.getSaleShippingAddressId());
                // 单一承运商才进行匹配
                if (carrierList != null && carrierList.size() == 1) {
                    List<Map<String, Object>> list = new ArrayList<>();
                    Map<String, Object> map1 = carrierList.get(0);
                    // 传入车序号主键和承运商id
                    map1.put("saleOrderMaterialId", saleOrderMaterialId);
                    map1.put("carrierId", map1.get("value"));
                    list.add(map1);
                    dispatchToCarrier(list);
                }
            }
        }
        return result;
    }

    /**
     * 展示未匹配承运商的车序号
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getSteelTruckNoList(Map<String, Object> mapValue) {
        List<Map<String, Object>> resultList = amsSaleOrderMapper.getSteelTruckNoList(mapValue);
        return resultList;
    }

    /**
     * 展示车序号的详情
     * @param saleOrderMaterialId
     * @return
     */
    @Override
    public List<Map<String, Object>> getTruckNoMaterial(BigDecimal saleOrderMaterialId) {
        List<Map<String,Object>> mapList = amsSaleOrderMapper.getTruckNoMaterialAndCarrier(saleOrderMaterialId);
        for (Map<String,Object> map : mapList) {
            BigDecimal placeId = (BigDecimal) map.get("placeId");
            if (placeId != null) {
                List<Map<String, Object>> carrierAndPriceList = getCarrierByPlace(placeId);
                map.put("carrierAndPriceList", carrierAndPriceList);
            }
        }
        return mapList;
    }

    /**
     * 展示已分配承运商但未派车的车序号
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getNoCarTruckNoList(Map<String, Object> mapValue) {
        List<Map<String, Object>> resultList = amsSaleOrderMapper.getCarrierTruckNoList(mapValue);
        return resultList;
    }

    /**
     * 展示已派车的车序号
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getHaveCarTruckNoList(Map<String, Object> mapValue) {
        List<Map<String, Object>> resultList = amsSaleOrderMapper.getHaveCarTruckNoList(mapValue);
        return resultList;
    }

    /**
     * 修改销售订单中的物资
     * @param mapValue
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int updateAllMaterialInSale(Map<String, Object> mapValue) {
        int result = 0;
        // 得到销售订单主键
        BigDecimal saleOrderId = DataChange.dataToBigDecimal(mapValue.get("saleOrderId"));
        BigDecimal saleOrderMaterialId = DataChange.dataToBigDecimal(mapValue.get("saleOrderMaterialId"));
        BigDecimal orderId = DataChange.dataToBigDecimal(mapValue.get("orderId"));
        // 将车辆改为不可作业状态
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        omstruckOrder.setOrderId(orderId);
        omstruckOrder.setCanWork(new BigDecimal(1));
        omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        //插入日志
        saleLogUtil.logOrder(orderId,"修改销售订单中的物资:改为不可作业",mapValue,SaleLogUtil.UPDATE);
        // 得到运单中的物资
        List<Map<String, Object>> oldList = omstruckOrderMaterialMapper.getMaterialList(orderId);
        Map<String, Object> toTmsMap = new HashMap<>();
        Map<String, Object> truckNoMap = new HashMap<>();
        truckNoMap.put("saleOrderMaterialId",saleOrderMaterialId);
        toTmsMap.put("orderId", orderId);
        toTmsMap.put("oldMaterialMapList", oldList);
        // 得到所有的物资
        List<Map<String, Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");
        /*
         删除三个物资表数据
         */
        List<AmsSaleTrucknoMaterial> amsSaleTrucknoMaterials = amsSaleTrucknoMaterialMapper.selectByParameters(truckNoMap);
        for (AmsSaleTrucknoMaterial amsSaleTrucknoMaterial : amsSaleTrucknoMaterials) {
            // 销售订单物资子表
            amsSaleMaterialMapper.deleteByPrimaryKey(amsSaleTrucknoMaterial.getMaterialId());
            // 车序号子表
            amsSaleTrucknoMaterialMapper.deleteByPrimaryKey(amsSaleTrucknoMaterial.getTrucknoMaterialId());
        }
        // 运输订单物资子表
        List<OmstruckOrderMaterial> omstruckOrderMaterials = omstruckOrderMaterialMapper.selectByParameters(toTmsMap);
        for (OmstruckOrderMaterial omstruckOrderMaterial : omstruckOrderMaterials) {
            omstruckOrderMaterialMapper.deleteByPrimaryKey(omstruckOrderMaterial.getOrderMaterialId());
        }
        /*
        重新新增三个表
         */
        for (Map<String, Object> map : mapList) {
            Object saleMaterialId = map.get("saleMaterialId");
            BigDecimal materialId = DataChange.dataToBigDecimal(map.get("materialId"));
            BigDecimal materialNumber = DataChange.dataToBigDecimal(map.get("orderPlanWeight"));
            Object trucknoMaterialId = map.get("trucknoMaterialId");
            BigDecimal isPoundSale = DataChange.dataToBigDecimal(map.get("isPound"));
            Object materialWeight = map.get("materialWeight");
            Object steelMeter = map.get("meterNumber");
            Object easId = map.get("easId");
            Object warehouse = map.get("warehouse");
            // 销售订单分录表
            AmsSaleMaterial amsSaleMaterial = new AmsSaleMaterial();
            // 车序号子表
            AmsSaleTrucknoMaterial amsSaleTrucknoMaterial = new AmsSaleTrucknoMaterial();
            // 运输订单子表
            OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
//            if (saleMaterialId != null) {
//                amsSaleMaterial.setSaleMaterialId(DataChange.dataToBigDecimal(saleMaterialId));
//                amsSaleTrucknoMaterial.setTrucknoMaterialId(DataChange.dataToBigDecimal(trucknoMaterialId));
//            }
//            if (saleMaterialId == null){
                amsSaleMaterial.setSaleMaterialId(amsSaleMaterialMapper.selectMaxId());
                amsSaleTrucknoMaterial.setTrucknoMaterialId(amsSaleTrucknoMaterialMapper.selectMaxId());
//            }
            if (easId != null) {
                amsSaleMaterial.setEasPrimaryId(easId.toString());
            }
            if (warehouse != null) {
                amsSaleMaterial.setSaleWarehouse(warehouse.toString());
            }
            if (steelMeter != null) {
                amsSaleMaterial.setSteelMeter(DataChange.dataToBigDecimal(steelMeter));
            }
            if (materialWeight != null) {
                amsSaleMaterial.setMaterialWeight(DataChange.dataToBigDecimal(materialWeight));
                omstruckOrderMaterial.setOrderMaterialWeight(DataChange.dataToBigDecimal(materialWeight));
            }
            amsSaleMaterial.setSaleOrderId(saleOrderId);
            amsSaleMaterial.setIsPoundSale(isPoundSale);
            amsSaleMaterial.setMaterialId(materialId);
            amsSaleMaterial.setDeleted(new BigDecimal(0));
            amsSaleMaterial.setMaterialNumber(materialNumber);
            amsSaleMaterial.setUpdateTime(new Date());
            result += amsSaleMaterialMapper.insertSelective(amsSaleMaterial);
            // 车序号子表
            amsSaleTrucknoMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
            amsSaleTrucknoMaterial.setMaterialId(amsSaleMaterial.getSaleMaterialId());
            amsSaleTrucknoMaterial.setSaleOrderMaterialNumber(materialNumber);
            amsSaleTrucknoMaterial.setUpdateTime(new Date());
            result += amsSaleTrucknoMaterialMapper.insertSelective(amsSaleTrucknoMaterial);
            // 运输订单子表
            omstruckOrderMaterial.setOrderMaterialId(omstruckOrderMaterialMapper.selectMaxId());
            omstruckOrderMaterial.setOrderId(orderId);
            omstruckOrderMaterial.setMaterialId(materialId);
            omstruckOrderMaterial.setOrderMaterialNumber(materialNumber);
            result += omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
        }
        // 得到运单中的物资
        List<Map<String, Object>> newList = omstruckOrderMaterialMapper.getMaterialList(orderId);
        toTmsMap.put("newMaterialMapList", newList);
        // 修改实绩结果
        Map<String, Object> updateResult = tmsTruckFeign.update(toTmsMap);
        System.out.println(updateResult);
        return result;
    }

    /**
     * 副产品订单
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getFuSaleOrderList(Map<String, Object> map) {
        List<Map<String, Object>> resultList = amsSaleOrderMapper.getFuSaleOrderList(map);
        return resultList;
    }

    /**
     * 同步关闭金蝶销售订单
     * @param mapValue
     * @return
     */
    @Override
    public int deleteSaleOrderSame(Map<String, Object> mapValue) {
        int result = 0;
        BigDecimal saleOrderId = DataChange.dataToBigDecimal(mapValue.get("saleOrderId"));
        String reason = (String) mapValue.get("reason");
        String number = (String) mapValue.get("number");
        Map<String,Object> head = new HashMap<>();
        Map<String,Object> input = new HashMap<>();
        // 销售订单号
        input.put("number",number);
        Map<String, Object> totalMap = easDeleteUtil.getTotalMap();
        totalMap.put("input",input);
        // 调用金蝶关闭接口
        String json = JSONUtils.toJSONString(totalMap);
        System.out.println(json);
        Map<String,Object> resultMap = joinFeign.deleteSaleOrderToEas(totalMap);
        try {
            newFileTool.newFile("deleteSaleOrderToEas："+totalMap,"金蝶通讯报文");
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(resultMap);
        AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
        amsSaleOrder.setSaleOrderId(saleOrderId);
        amsSaleOrder.setDeleted(new BigDecimal(2));
        amsSaleOrder.setInsertUpdateRemark(reason);
        saleLogUtil.logSaleOrder(saleOrderId,"删除销售订单",mapValue.get("userName") + "",SaleLogUtil.DELETE);
        result += amsSaleOrderMapper.closeOrderNotIn(saleOrderId);
        result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
        return result;
    }

    /**
     * 展示反审批的钢材订单
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getSteelOrderDeletedList(Map<String, Object> mapValue) {
        List<Map<String, Object>> mapList = amsSaleOrderMapper.getSteelOrderDeletedList(mapValue);
        return mapList;
    }

    /**
     * 展示所有状态销售订单列表
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getAllSteelSaleOrderList(Map<String, Object> mapValue) {
        return amsSaleOrderMapper.getAllSteelSaleOrderList(mapValue);
    }

    /**
     * 修改厂内未装货车辆的运单车牌号
     * @param mapValue
     * @return
     */
    @Override
    public Map<String, Object> updateCapacityNumberInFactory(Map<String, Object> mapValue) throws Exception {
        Object lineSequence = mapValue.get("lineSequence");
        Object carStatus = mapValue.get("carStatus");
        if(carStatus == null) {
            carStatus = omstruckOrderMapper.getOrderStatus(DataChange.dataToBigDecimal(mapValue.get("orderId")));
        }
        BigDecimal orderTypee = omstruckOrderMapper.getOrderType(DataChange.dataToBigDecimal(mapValue.get("orderId")));
        if(orderTypee.compareTo(new BigDecimal(4)) == 0) {
            mapValue.put("driverTel",mapValue.get("mapValue") + "");
            mapValue.put("isCheckGPS",false);
        }
        int result = 0;
        if (mapValue.get("orderId") == null) {
            throw new Exception("还未派车,不允许修改车牌号");
        }
        //收货客户
        String addressPlace = omstruckOrderMapper.getAddressPlace(DataChange.dataToBigDecimal(mapValue.get("orderId")));
        //判断该车序号对应的分录是否全部关闭
        if(mapValue.get("saleOrderMaterialId") != null && DataChange.dataToBigDecimal(mapValue.get("capacityId")).compareTo(new BigDecimal(35128)) != 0) {
            Integer flCount = amsSaleMaterialMapper.getAbleFlcount(DataChange.dataToBigDecimal(mapValue.get("saleOrderMaterialId")));
            if(flCount == 0) {
                throw new Exception("该运单下所有分录被关闭,无法派车");
            }
        }
        //查询输入进来的车牌号是否与原有车牌号一致,如果一致则退出
        BigDecimal oldCapacityId = omstruckOrderMapper.getOldCapacityId(DataChange.dataToBigDecimal(mapValue.get("orderId")));
        String oldCapacityNumber = omstruckOrderMapper.getOldCapacityNumber(oldCapacityId);
        mapValue.put("updateFlag",1);
        mapValue.put("oldCapacityNumber",oldCapacityNumber);
        if(oldCapacityId.compareTo(DataChange.dataToBigDecimal(mapValue.get("capacityId"))) == 0) {
            mapValue.put("result",1);
            //已接单或者不是欧冶库的可直接同步车号
            if(addressPlace == null || !addressPlace.contains("欧冶") || "5".equals(carStatus.toString())) {
                pushCarNumberToEas(mapValue);
            }
            return mapValue;
        }
        //校验该车是否存在手机号
        String tel=omstruckOrderMapper.getTelByCapacityId(DataChange.dataToBigDecimal(mapValue.get("capacityId")));
        String driverTel = (String) mapValue.get("driverTel");//填写的手机号
        if(tel==null || "".equals(tel)){
            throw new Exception("该车没有电话号码，无法派车！请去资源管理-运力维护该车的电话号码!");
        }
        Integer isCheckGps = amsSaleOrderMapper.getDispachSwitch();
        String capacityNo = (String) mapValue.get("capacityNo");
        //得到此次是否校验GPS
        boolean onceCheck = true;
        //查询是否自提
        String selfMention = "否";
        try{
            selfMention = amsSaleOrderMapper.findSelfMention(DataChange.dataToBigDecimal(mapValue.get("saleOrderMaterialId")));
            onceCheck = (boolean) mapValue.get("isCheckGPS");
        }catch (Exception e){
            //取值失败不处理，取默认值
        }
        //查询车牌号是否是黑名单
        if(amsSaleOrderMapper.isBlackList(capacityNo)>0){
            throw new Exception("该车在黑名单中，无法派车！请联系销售公司！");
        }
        //非自提，单次校验且全局校验，且车辆不允许无GPS
        int isGPS=amsSaleOrderMapper.isGPS(capacityNo);
        String placeAddress = amsSaleOrderMapper.getPlaceAddress(DataChange.dataToBigDecimal(mapValue.get("saleOrderMaterialId")));
        if (placeAddress != null && placeAddress.contains("欧冶") && onceCheck && (isCheckGps!=null && isCheckGps==0) && isGPS <= 0) {
            Map<String,Object> data=null;
            try{
                data= (Map<String,Object>)otmsFeign.getCurrentLocation(capacityNo).getData();
            }catch (Exception e){
                throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
            }
            if(data==null || !"1001".equals(""+data.get("status"))){
                throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
            }
        }

        if((selfMention==null || selfMention.equals("否")) && onceCheck && (isCheckGps!=null && isCheckGps==0) && isGPS <= 0){
            Map<String,Object> data=null;
            try{
                data= (Map<String,Object>)otmsFeign.getCurrentLocation(capacityNo).getData();
            }catch (Exception e){
                throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
            }
            if(data==null || !"1001".equals(""+data.get("status"))){
                throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
            }
        }
        if(!mapValue.containsKey("oYeFlag")) {
            //不是欧冶库的可直接同步车号
            if(addressPlace == null || !addressPlace.contains("欧冶")) {
                pushCarNumberToEas(mapValue);
            }
        }
        //try{
        //    //不为空且为新手机号，则修改电话号码
        //    if(driverTel!=null && !"".equals(driverTel) && !driverTel.equals(tel)){
        //        Map<String,Object> map1=new HashMap<>();
        //        map1.put("capacityNumber",capacityNo);
        //        map1.put("capacityTel",driverTel);
        //        //在得到司机电话后给运力添加电话号码(通过车牌号)
        //        rmsFeign.updateCapacity(map1);
        //        mapValue.put("capacityTel",driverTel);
        //    }else{
        //        mapValue.put("capacityTel",tel);
        //    }
        //}catch (Exception e){
        //    e.printStackTrace();
        //}
        saleLogUtil.logOrder(DataChange.dataToBigDecimal(mapValue.get("orderId")),"修改车牌号,当前车牌号为:" + capacityNo + "上一个车牌号为:" + oldCapacityNumber,mapValue,SaleLogUtil.UPDATE);
        if ("4".equals(carStatus.toString()) || lineSequence == null || "0".equals(lineSequence.toString()) || "1".equals(lineSequence.toString()) || "2".equals(lineSequence.toString())) {
            String capacityids="";
            Integer capacityid1= (Integer) mapValue.get("capacityIds");
            Integer capacityid2= (Integer) mapValue.get("capacityId");
            if (capacityid1!=null && !("".equals(capacityid1))){
                capacityids=capacityid1+","+capacityid2;
            }
            mapValue.put("capacityids",capacityids);
            //这是修改车牌号
            //取消是新车牌号,那么不删除排队信息，不删除实绩信息，将运单状态变为7
            if (DataChange.dataToBigDecimal(mapValue.get("capacityId")).compareTo(new BigDecimal(35128)) != 0) {
                //根据订单id查询车牌号改动记录
                String oldCpacityIds = omstruckOrderMapper.getOrderCapacityHistory(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                BigDecimal oldOldCapacityId = null;
                if(oldCpacityIds != null) {
                    oldOldCapacityId = DataChange.dataToBigDecimal(oldCpacityIds.split(",")[0]);
                }
                //如果旧车号是取消，且取消的前一个车与该车相等,那么就将状态还原
                if (oldOldCapacityId != null && oldCapacityId != null && oldCapacityId.compareTo(new BigDecimal(35128)) == 0 && DataChange.dataToBigDecimal(mapValue.get("capacityId")).compareTo(oldOldCapacityId) == 0 ) {
                    //判断该订单下有没有子实绩
                    BigDecimal  resultId = amsSaleOrderMaterialMapper.selectEnFactory(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                    if(resultId == null) {
                        OmstruckOrder omstruckOrder = new OmstruckOrder();
                        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                        omstruckOrder.setOrderStatus(new BigDecimal(4));
                        omstruckOrder.setOrderLineSequence(new BigDecimal(0));
                        omstruckOrder.setInsertUpdateRemark("将取消改回来原来的车状态不变!");
                        if(tel != null && !"".equals(tel)){
                            omstruckOrder.setDriverTel(tel);
                        }
                        /*omstruckOrder.set*/
                        result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
                    }else{
                        OmstruckOrder omstruckOrder = new OmstruckOrder();
                        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                        omstruckOrder.setOrderStatus(new BigDecimal(5));
                        if(tel != null && !"".equals(tel)){
                            omstruckOrder.setDriverTel(tel);
                        }
                        omstruckOrder.setInsertUpdateRemark("将取消改回来原来的车状态不变!");
                        /*omstruckOrder.set*/
                        result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
                    }

                }else{
                    //查询运输订单的状态和总实绩ID
                    Map<String, Object> orderMesMap = amsSaleOrderMapper.getOrderMes(mapValue);
                    BigDecimal resultTotalId = DataChange.dataToBigDecimal(orderMesMap.get("resultTotalId"));
                    //将排队信息删掉
                    // 修改车牌号后保留原排队记录2024年4月23日10:28:53
                    Map<String, Object> isSpellingMap = omstruckOrderMapper.getSteelIsSpelling(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                    //查看是存在排队记录
                    BigDecimal listId = null;
                    if(isSpellingMap != null && isSpellingMap.get("listId") != null){
                        listId = omstruckOrderMapper.getListId(DataChange.dataToBigDecimal(isSpellingMap.get("listId")));
                    }
                    if(listId != null && listId.longValue() > 0){
                        /**
                        int isSpelling = DataChange.dataToBigDecimal(isSpellingMap.get("isSpelling")).intValue();
                        if(isSpelling == 1 ){
                            result += omstruckOrderMapper.deleteSpellingList(isSpellingMap.get("listId"));
                        }else{
                            result += omstruckOrderMapper.deleteQueueList(isSpellingMap.get("listId"));
                        }
                         */
                        System.out.println("修改车牌号后保留原排队记录");
                        //查询车辆是否放行
                        isSpellingMap.put("insertUpdateRemark", "车辆排队中");
                        String insertUpdateRemark = omstruckOrderMapper.getPassthrough(resultTotalId);
                        if("OK".equals(insertUpdateRemark)){
                            isSpellingMap.put("insertUpdateRemark", "车辆已放行");
                        }
                        //修改排队实绩车牌号
                        isSpellingMap.put("capacityId", mapValue.get("capacityId"));
                        result += omstruckOrderMapper.updateCapacityIdByQueue(isSpellingMap);
                        int isSpelling = DataChange.dataToBigDecimal(isSpellingMap.get("isSpelling")).intValue();
                        if(isSpelling != 1 ){
                            result += omstruckOrderMapper.updateCapacityIdByQueueList(isSpellingMap);
                        }
                    } else {
                         if (resultTotalId != null && resultTotalId.longValue() > 0) {
                             omstruckOrderMapper.deleteQueuingPerformance(resultTotalId);
                         }
                    }
                    //若是接单之后还需要删除实绩且将状态变为4
                    //删除排队实绩
                    /**
                    if (resultTotalId !=null && !("".equals(resultTotalId))){
                        omstruckOrderMapper.deleteQueuingPerformance(resultTotalId);
                    }
                     */
                    OmstruckOrder omstruckOrder = new OmstruckOrder();
                    omstruckOrder.setOrderId(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                    // 设置新的运输订单号
                    omstruckOrder.setOrderNumber(DataChange.generateEightDigitsNumber("WYSDD", omstruckOrderMapper.selectMaxId().intValue()));
                    omstruckOrder.setOrderStatus(new BigDecimal(4));
                    omstruckOrder.setOrderLineSequence(new BigDecimal(0));
                    if(tel != null && !"".equals(tel)){
                        omstruckOrder.setDriverTel(tel);
                    }
                        /*omstruckOrder.set*/
                    result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
                    //插入日志
                    result += omstruckOrderMapper.deleteEnResult(resultTotalId);
                    result += omstruckOrderMapper.deleteWeightResult(resultTotalId);
                    result += omstruckOrderMapper.deleteLoadResult(resultTotalId);
                    result += omstruckOrderMapper.deleteLeaveResult(resultTotalId);
                    //修改总实绩状态
                    try {
                        omstruckOrderMapper.updateTotalOrderStatus(resultTotalId);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }else{
                OmstruckOrder omstruckOrder = new OmstruckOrder();
                omstruckOrder.setOrderId(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                if(tel != null && !"".equals(tel)){
                    omstruckOrder.setDriverTel(tel);
                }
                omstruckOrder.setOrderStatus(new BigDecimal(7));
                omstruckOrder.setInsertUpdateRemark("取消车牌号,保留实绩将状态变为7");
                result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
            }
            result += amsSaleOrderMapper.updateCapacityNumberInFactory(mapValue);
        }
        mapValue.put("result",result);
        return mapValue;

    }

    @Override
    public int updateConsigneeTel(Map<String, Object> mapValue) {
        String saleOrderNo= (String) mapValue.get("saleOrderNo");
        Integer saleOrderMaterialId= (Integer) mapValue.get("saleOrderMaterialId");
        String consigneeTel= (String) mapValue.get("consigneeTel");
        int result = 0;
        if (saleOrderNo!=null&&!("".equals(saleOrderNo)) && saleOrderMaterialId!=null && !("".equals(saleOrderMaterialId))){
            BigDecimal id = DataChange.dataToBigDecimal(saleOrderMaterialId);
            if (id!=null&&!("".equals(id))){
                result += amsSaleOrderMapper.updateForTel(id,consigneeTel);
            }
        }
        return result;
    }

    @Override
    public List<Map<String, Object>> getSaleMaterialId(BigDecimal saleOrderMaterialId) {
        return amsSaleOrderMapper.getSaleMaterialId(saleOrderMaterialId);
    }

    /**
     * 展示下发给承运商的车序号和物资
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getCarrierTruckNoAndMaterialList(Map<String,Object> map) {
        Object carrierSsoId = map.get("carrierSsoId");
        if (carrierSsoId != null && ("".equals(carrierSsoId)) || "null".equals(carrierSsoId) || "undefined".equals(carrierSsoId)) {
            map.replace("carrierSsoId",null);
        }
        List<Map<String,Object>> mapList = amsSaleOrderMapper.getTruckNoAndMaterial(map);
        for (Map<String,Object> mapValue : mapList) {
            BigDecimal placeId = (BigDecimal) mapValue.get("placeId");
            if (placeId != null) {
                List<Map<String, Object>> carrierAndPriceList = getCarrierByPlace(placeId);
                mapValue.put("carrierAndPriceList", carrierAndPriceList);
            }
        }
        return mapList;
    }

    @Override
    public int updateAMSDeleted(BigDecimal closeWlEntryId) {
        return amsSaleOrderMapper.updateAMSDeleted(closeWlEntryId);
    }


    /**
     * 同步关闭金蝶物资分录
     * @param mapValue
     * @return
     */
    @Override
    @Transactional
    public int closeSteelMaterialId(Map<String, Object> mapValue) {
        int result = 0;
        Object orderId = mapValue.get("orderId");
        Integer orderStatus = (Integer) mapValue.get("orderStatus");
        BigDecimal saleOrderMaterialId = DataChange.dataToBigDecimal(mapValue.get("saleOrderMaterialId"));
        List<Map<String, Object>> loadIdList = amsSaleMaterialMapper.findLoadIdList(saleOrderMaterialId);
        List<Map<String, Object>> weightIdList = amsSaleMaterialMapper.findWeightIdList(saleOrderMaterialId);
        String reason = (String) mapValue.get("reason");
        BigDecimal saleMaterialId = DataChange.dataToBigDecimal(mapValue.get("saleMaterialId"));
        try {
            BigDecimal saleOrderId = amsSaleOrderMapper.getSaleOrderIdByASOM(saleOrderMaterialId);
            saleLogUtil.logSaleOrder(saleOrderId,"物流同步关闭金蝶分录,分录为" + saleMaterialId ,"物流" ,SaleLogUtil.CLOSE);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 如果还未派车
        if (orderId == null) {
            // 订单子表设为关闭状态
            AmsSaleMaterial amsSaleMaterial = new AmsSaleMaterial();
            amsSaleMaterial.setSaleMaterialId(saleMaterialId);
            amsSaleMaterial.setDeleted(new BigDecimal(0));
            amsSaleMaterial.setInsertUpdateRemark(reason);
            result += amsSaleMaterialMapper.updateByPrimaryKeySelective(amsSaleMaterial);
            return result;
        }
        orderStatus = omstruckOrderMapper.getOrderStatus(DataChange.dataToBigDecimal(orderId));
        // 订单子表设为关闭状态
        AmsSaleMaterial amsSaleMaterial = new AmsSaleMaterial();
        amsSaleMaterial.setSaleMaterialId(saleMaterialId);
        amsSaleMaterial.setDeleted(new BigDecimal(0));
        amsSaleMaterial.setInsertUpdateRemark(reason);
        // 已派车
        if ((loadIdList == null || loadIdList.size() == 0) && orderStatus == 5) {
            return result;
        }
        //判断该分录对应净重有没有出来
        int netWeightCount = amsSaleMaterialMapper.getSaleMaterialWeight(mapValue);
        //判断关闭分录是否为最后一拼
        int asmMaterialCount = amsSaleMaterialMapper.getSaleMaterialDelete(saleOrderMaterialId);
        if (asmMaterialCount > 1 && orderStatus == 5 && netWeightCount == 0) {
                // 删除实绩表
                Map<String, Object> loadMap = loadIdList.get(0);
                Map<String, Object> weightMap = weightIdList.get(0);
                BigDecimal loadId = (BigDecimal) loadMap.get("loadId");
                BigDecimal weightId = (BigDecimal) weightMap.get("weightId");
                int i = amsSaleMaterialMapper.deleteWeightResult(weightId);
                if(i != 0) {
                    result += amsSaleMaterialMapper.deleteLoadResult(loadId);
                    result += amsSaleMaterialMapper.deleteWmspOutResult(mapValue);
                }
        }else if(asmMaterialCount <= 1 && netWeightCount == 0){
                //关闭运输订单
                OmstruckOrder omstruckOrder = new OmstruckOrder();
                omstruckOrder.setOrderId(DataChange.dataToBigDecimal(orderId));
                //如果是单拼或者只剩一条分录没有关闭了则将状态设为7
                omstruckOrder.setOrderStatus(new BigDecimal(7));
                omstruckOrder.setUpdateTime(new Date());
                omstruckOrder.setInsertUpdateRemark("关闭分录,同步关闭运输订单");
                result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
                //插入日志
                saleLogUtil.logOrder(omstruckOrder.getOrderId(),"关闭分录,同步关闭运输订单",mapValue,SaleLogUtil.UPDATE);
        }
        result += amsSaleMaterialMapper.updateByPrimaryKeySelective(amsSaleMaterial);
        if(netWeightCount == 0) {
            result += amsSaleMaterialMapper.updateOrderMaterialToClose(mapValue);
        }
        return result;
    }

    /**
     * 展示已审核化产焦炭销售订单列表
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getSaleCokeOrder(Map<String, Object> mapValue) {
        List<Map<String, Object>> resultList = amsSaleOrderMapper.getSaleCokeOrder(mapValue);
        return resultList;
    }

    /**
     * 反关闭金蝶单个分录
     * @param saleMaterialId
     * @return
     */
    @Override
    public int adverseCloseSaleMaterial(BigDecimal saleMaterialId) {
        Map<String,Object> head = new HashMap<>();
        Map<String,Object> input = new HashMap<>();
        // 0：代表不关闭整单
        String wholeOrder = "0";
        // unClose : 代表反关闭
        String status = "unClose";
        AmsSaleMaterial amsSaleMaterial = amsSaleMaterialMapper.selectByPrimaryKey(saleMaterialId);
        int result = amsSaleMaterialMapper.adverseCloseSaleMaterial(saleMaterialId);
        AmsSaleOrder amsSaleOrder = amsSaleOrderMapper.selectByPrimaryKey(amsSaleMaterial.getSaleOrderId());
        // 根据分录id查询运单id，物资id，总实绩id
        Map<String,Object> saleMaterialMap = amsSaleOrderMapper.getSaleMaterialMessage(saleMaterialId);
        BigDecimal orderId = (BigDecimal) saleMaterialMap.get("orderId");
        BigDecimal orderStatus = (BigDecimal) saleMaterialMap.get("orderStatus");
        //查询订单字表条数
        int orderMaterialNum = omstruckOrderMapper.getOrderMaterialNum(orderId);
        //查询计量实绩条数
        int weightResultNum = omstruckOrderMapper.getWeightResultNum(orderId);
        if (orderId != null && orderStatus.intValue() == 5 && orderMaterialNum != weightResultNum) {
            BigDecimal resultTotalId = (BigDecimal) saleMaterialMap.get("resultTotalId");
            BigDecimal materialId = (BigDecimal) saleMaterialMap.get("materialId");
            // 根据总实绩id查询订单中的最大路段顺序号
            // 得到皮重顺序号
            int tareNum = (weightResultNum + 1) * 3 - 1;
            // 得到装货顺序号
            int loadNum =  (weightResultNum + 1) * 3;
            // 得到毛重顺序号
            int grossNum = (weightResultNum + 1) * 3 + 1;
            // 装货实绩
            TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
            TmstruckWeightResult tmstruckWeightResult = new TmstruckWeightResult();
            tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
            tmstruckLoadResult.setResultTotalId(resultTotalId);
            tmstruckLoadResult.setSegmentSqe(new BigDecimal(loadNum));
            result += tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
            // 计量实绩
            tmstruckWeightResult.setWeightTaskResultId(tmstruckWeightResultMapper.selectMaxId());
            tmstruckWeightResult.setResultTotalId(resultTotalId);
            tmstruckWeightResult.setResultTarePlaceId(new BigDecimal(10));
            tmstruckWeightResult.setResultGrossPlaceId(new BigDecimal(2));
            tmstruckWeightResult.setGrossSegmentSqe(new BigDecimal(grossNum));
            tmstruckWeightResult.setTareSegmentSqe(new BigDecimal(tareNum));
            result += tmstruckWeightResultMapper.insertSelective(tmstruckWeightResult);
            // 出库子表
            BigDecimal outBoundId = (BigDecimal) saleMaterialMap.get("outBoundId");
            BigDecimal materialNumber = (BigDecimal) saleMaterialMap.get("materialNumber");
            if (outBoundId != null) {
                BigDecimal resultMaterialId = wmspOutboundResultMaterialMapper.getSeqNumber("seq__WMSP_OUTBOUND_RESUL_TMATRIAL");
                WmspOutboundResultMaterial wmspOutboundResultMaterial = new WmspOutboundResultMaterial();
                wmspOutboundResultMaterial.setResultMaterialId(resultMaterialId);
                wmspOutboundResultMaterial.setOutboundResultId(outBoundId);
                wmspOutboundResultMaterial.setMaterialId(materialId);
                wmspOutboundResultMaterial.setMaterialNumber(materialNumber);
                wmspOutboundResultMaterial.setInsertTime(new Date());
                wmspOutboundResultMaterial.setInsertUsername("admin");
                wmspOutboundResultMaterial.setStatus(new BigDecimal(1));
                result += wmspOutboundResultMaterialMapper.insertSelective(wmspOutboundResultMaterial);
            }
        }
        //去掉取消装货
        result += omstruckOrderMaterialMapper.updateOmsMaterial(saleMaterialMap);
        if (orderId != null && orderStatus.intValue() == 7) {
            //如果订单被关闭,那么还原
            //判断下面有没有实绩
            int resultCount = omstruckOrderMapper.getResultCount(orderId);
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            if (resultCount == 0) {
                omstruckOrder.setOrderId(orderId);
                omstruckOrder.setOrderStatus(new BigDecimal(4));
                omstruckOrder.setInsertUpdateRemark("反关闭分录,运单同步开启");
                omstruckOrder.setUpdateTime(new Date());
                omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
            }else{
                omstruckOrder.setOrderId(orderId);
                omstruckOrder.setOrderStatus(new BigDecimal(5));
                omstruckOrder.setInsertUpdateRemark("反关闭分录,运单同步开启");
                omstruckOrder.setUpdateTime(new Date());
                omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
            }
            //插入日志
            saleLogUtil.logOrder(omstruckOrder.getOrderId(),"反关闭分录,运单同步开启",null,SaleLogUtil.UPDATE);
        }
        // 设置反关闭分录id
        head.put("unCloseEntryId",amsSaleMaterial.getEasPrimaryId());
        // 设置是否整单
        head.put("wholeOrder",wholeOrder);
        // 设置销售订单号
        head.put("number",amsSaleOrder.getSaleNumber());
        // 设置状态：unClose，反关闭；close，关闭
        head.put("status",status);
        input.put("head",head);
        // 测试
        Map<String, Object> totalMap = easUtil.getTotalMap();
        // 正式
//        Map<String, Object> totalMap = easDeleteUtil.getTotalMap();
        input.put("head",head);
        totalMap.put("input",input);
        // 调用金蝶关闭接口
        String json = JSONUtils.toJSONString(totalMap);
        System.out.println(json);
        Map<String,Object> resultMap = joinFeign.deleteSaleOrderToEas(totalMap);
        try {
            newFileTool.newFile("deleteSaleOrderToEas："+totalMap,"金蝶通讯报文");
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(resultMap);
        return result;
    }

    /**
     * 反关闭金蝶整个销售订单
     * @param saleOrderId
     * @return
     */
    @Override
    public int adverseCloseSaleOrder(BigDecimal saleOrderId) {
        Map<String,Object> head = new HashMap<>();
        Map<String,Object> input = new HashMap<>();
        // 0：代表不关闭整单
        String wholeOrder = "1";
        // unClose : 代表反关闭
        String status = "unClose";
        AmsSaleOrder amsSaleOrder = amsSaleOrderMapper.selectByPrimaryKey(saleOrderId);
        amsSaleOrder.setDeleted(new BigDecimal(0));
        // 开启所有的分录
        int result = amsSaleMaterialMapper.openAllSaleMaterial(amsSaleOrder.getSaleOrderId());
        result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
        // 设置是否整单
        head.put("wholeOrder",wholeOrder);
        // 设置销售订单号
        head.put("number",amsSaleOrder.getSaleNumber());
        // 设置状态：unClose，反关闭；close，关闭
        head.put("status",status);
        input.put("head",head);
        // 测试
        Map<String, Object> totalMap = easUtil.getTotalMap();
        // 正式
//        Map<String, Object> totalMap = easDeleteUtil.getTotalMap();
        input.put("head",head);
        totalMap.put("input",input);
        // 调用金蝶关闭接口
        String json = JSONUtils.toJSONString(totalMap);
        System.out.println(json);
        Map<String,Object> resultMap = joinFeign.deleteSaleOrderToEas(totalMap);
        try {
            saleLogUtil.logSaleOrder(saleOrderId,"物流关闭销售订单" ,"物流" ,SaleLogUtil.CLOSE);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            newFileTool.newFile("deleteSaleOrderToEas："+totalMap,"金蝶通讯报文");
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(resultMap);
        return result;
    }

    @Override
    public List<Map<String, Object>> getKucunList(Map<String, Object> map) {
        HashSet<Map<String,Object>> filterConsigneeList = new HashSet<>();
        HashSet<Map<String,Object>> filterToStationList = new LinkedHashSet<>();
        HashSet<Map<String,Object>> filtermaterialNameList = new LinkedHashSet<>();
        HashSet<Map<String,Object>> filtermaterialSpaList = new LinkedHashSet<>();
        List<Map<String,Object>> mapList = amsSaleOrderMapper.getKucunList(map);
        for(int j = 0;j < mapList.size() ; j++ ) {
            Map<String,Object> stringObjectMap = mapList.get(j);
            Map<String,Object> filterConsigneeMap = new HashMap<>();
            filterConsigneeMap.put("text",stringObjectMap.get("receiveName"));
            filterConsigneeMap.put("value",stringObjectMap.get("receiveName"));
            filterConsigneeList.add(filterConsigneeMap);
            Map<String,Object> filterToStationMap = new HashMap<>();
            filterToStationMap.put("text",stringObjectMap.get("toTheStation"));
            filterToStationMap.put("value",stringObjectMap.get("toTheStation"));
            filterToStationList.add(filterToStationMap);
            Map<String,Object> filtermaterialNameMap = new HashMap<>();
            filtermaterialNameMap.put("text",stringObjectMap.get("materialName"));
            filtermaterialNameMap.put("value",stringObjectMap.get("materialName"));
            filtermaterialNameList.add(filtermaterialNameMap);
            Map<String,Object> filtermaterialSpaMap = new HashMap<>();
            filtermaterialSpaMap.put("text",stringObjectMap.get("materialSpa"));
            filtermaterialSpaMap.put("value",stringObjectMap.get("materialSpa"));
            filtermaterialSpaList.add(filtermaterialSpaMap);
        }
        if(mapList.size() > 0) {
            mapList.get(0).put("filterConsigneeList",filterConsigneeList);
            mapList.get(0).put("filterToStationList",filterToStationList);
            mapList.get(0).put("filtermaterialNameList",filtermaterialNameList);
            mapList.get(0).put("filtermaterialSpaList",filtermaterialSpaList);
        }
        return mapList;
    }

    //反关闭
    @Override
    public int reverseCloseOrder(Map<String, Object> map) {
        Integer isOpenEas = (Integer) map.get("isOpenEas");
        String operateName = (String) map.get("operateName");
        int result = 0;
        // 运输订单id
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        // 车序号id
        BigDecimal saleOrderMaterialId = DataChange.dataToBigDecimal(map.get("saleOrderMaterialId"));
        Map<String,Object> head = new HashMap<>();
        Map<String,Object> input = new HashMap<>();
        // 0：代表不关闭整单
        String wholeOrder = "0";
        // unClose : 代表反关闭
        String status = "unClose";
        if( orderId != null && orderId.intValue() != 0){
            //根据订单id查询下面的实绩个数
            int resultCount = amsSaleMaterialMapper.getOrderResults(orderId);
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            omstruckOrder.setOrderId(orderId);
            if(resultCount == 0){
                omstruckOrder.setOrderStatus(new BigDecimal(4));
            }else{
                omstruckOrder.setOrderStatus(new BigDecimal(5));
            }
            if(operateName != null){
                omstruckOrder.setOptionerCode(operateName);
            }
            omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
            //插入日志
            saleLogUtil.logOrder(omstruckOrder.getOrderId(),"反关闭",null,SaleLogUtil.UPDATE);
            // 根据车序号主键修改子表
            amsSaleMaterialMapper.updateSaleMaterial(saleOrderMaterialId);
            //查询分录ID，修改金蝶
            List<Map<String,Object>> saleMaterialIdList = amsSaleOrderMapper.getSaleMaterialId(saleOrderMaterialId);
            for(Map<String,Object> easMap:saleMaterialIdList){
                // 设置反关闭分录id
                head.put("unCloseEntryId",easMap.get("closeEntryId"));
                // 设置是否整单
                head.put("wholeOrder",wholeOrder);
                // 设置销售订单号
                head.put("number",map.get("saleNumber"));
                // 设置状态：unClose，反关闭；close，关闭
                head.put("status",status);
                input.put("head",head);
                input.put("unCancel",true);
                Map<String, Object> totalMap = easUtil.getTotalMap();
                input.put("head",head);
                totalMap.put("input",input);
                // 调用金蝶关闭接口
                String json = JSONUtils.toJSONString(totalMap);
                System.out.println(json);
                Map<String,Object> resultMap = joinFeign.deleteSaleOrderToEas(totalMap);
                try {
                    newFileTool.newFile("deleteSaleOrderToEas："+totalMap,"金蝶通讯报文");
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println(resultMap);
            }
            try {
                //发送给计量
                Map<String, Object> cancelOrderMap = new HashMap<>();
                if(map.get("capacityNo")!=null){
                    cancelOrderMap.put("orderID",map.get("capacityNo"));
                }else{
                    cancelOrderMap.put("orderID","空白");
                }
                cancelOrderMap.put("changeStatus",2);
                cancelOrderMap.put("content",map.get("capacityNo"));
                System.out.println("联动计量撤销取消：" + map.get("capacityNo"));
                String url = "http://172.16.33.122:44325/api/logistics/CancleOrdersBill";
                JSONObject cancelOrderJson = new JSONObject(cancelOrderMap);
                System.out.println("联动计量撤销取消报文：" + cancelOrderJson);
                String sendUrl = url ;
                String jsonData = null;
                jsonData = HTTPRequestUtils.send(sendUrl, cancelOrderJson,"utf-8");
                System.out.println("联动计量撤销取消响应：" + jsonData);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return 0;

        }
        return 1;
    }

    @Override
    public int getSaleOrderStatus(String saleNumber) {
        int result = 0;
        Map<String,Object> input = new HashMap<>();
        // 销售订单号
        input.put("number",saleNumber);
        Map<String, Object> totalMap = easSaleOrderStatusUtil.getTotalMap();
        totalMap.put("input",input);
        // 调用金蝶关闭接口
        String json = JSONUtils.toJSONString(totalMap);
        System.out.println(json);
        Map<String,Object> resultMap = joinFeign.deleteSaleOrderToEas(totalMap);
        try {
            newFileTool.newFile("deleteSaleOrderToEas："+totalMap,"金蝶通讯报文");
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(resultMap);
        String outPutMap = (String) resultMap.get("output");
        JSONObject jsonObject = JSON.parseObject(outPutMap);
        if(jsonObject != null){
            result = DataChange.dataToBigDecimal(jsonObject.get("NumberStatus")).intValue();
        }
        if(result == 7){
            //如果为7则更新
            amsSaleOrderMapper.updateSaleOrderStatus(saleNumber);
            try {
                BigDecimal saleOrderId = amsSaleOrderMapper.getSaleOrderId(saleNumber);
                saleLogUtil.logSaleOrder(saleOrderId,"物流查询金蝶销售订单,物流同步关闭" ,"物流" ,SaleLogUtil.CLOSE);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    @Override
    public int adverseCloseSaleMaterialByEas(BigDecimal saleMaterialId) {
        AmsSaleMaterial amsSaleMaterial = amsSaleMaterialMapper.selectByPrimaryKey(saleMaterialId);
        int result = amsSaleMaterialMapper.adverseCloseSaleMaterial(saleMaterialId);
        AmsSaleOrder amsSaleOrder = amsSaleOrderMapper.selectByPrimaryKey(amsSaleMaterial.getSaleOrderId());
        // 根据分录id查询运单id，物资id，总实绩id
        Map<String,Object> saleMaterialMap = amsSaleOrderMapper.getSaleMaterialMessage(saleMaterialId);
        BigDecimal orderId = (BigDecimal) saleMaterialMap.get("orderId");
        BigDecimal orderStatus = (BigDecimal) saleMaterialMap.get("orderStatus");
        //查询订单字表条数
        int orderMaterialNum = omstruckOrderMapper.getOrderMaterialNum(orderId);
        //查询计量实绩条数
        int weightResultNum = omstruckOrderMapper.getWeightResultNum(orderId);
        if (orderId != null && orderStatus.intValue() == 5 && orderMaterialNum != weightResultNum) {
            BigDecimal resultTotalId = (BigDecimal) saleMaterialMap.get("resultTotalId");
            BigDecimal materialId = (BigDecimal) saleMaterialMap.get("materialId");
            // 根据总实绩id查询订单中的最大路段顺序号
            // 得到皮重顺序号
            int tareNum = (weightResultNum + 1) * 3 - 1;
            // 得到装货顺序号
            int loadNum =  (weightResultNum + 1) * 3;
            // 得到毛重顺序号
            int grossNum = (weightResultNum + 1) * 3 + 1;
            // 装货实绩
            TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
            TmstruckWeightResult tmstruckWeightResult = new TmstruckWeightResult();
            tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
            tmstruckLoadResult.setResultTotalId(resultTotalId);
            tmstruckLoadResult.setSegmentSqe(new BigDecimal(loadNum));
            result += tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
            // 计量实绩
            tmstruckWeightResult.setWeightTaskResultId(tmstruckWeightResultMapper.selectMaxId());
            tmstruckWeightResult.setResultTotalId(resultTotalId);
            tmstruckWeightResult.setResultTarePlaceId(new BigDecimal(10));
            tmstruckWeightResult.setResultGrossPlaceId(new BigDecimal(2));
            tmstruckWeightResult.setGrossSegmentSqe(new BigDecimal(grossNum));
            tmstruckWeightResult.setTareSegmentSqe(new BigDecimal(tareNum));
            result += tmstruckWeightResultMapper.insertSelective(tmstruckWeightResult);

            // 出库子表
            BigDecimal outBoundId = (BigDecimal) saleMaterialMap.get("outBoundId");
            BigDecimal materialNumber = (BigDecimal) saleMaterialMap.get("materialNumber");
            if (outBoundId != null) {
                BigDecimal resultMaterialId = wmspOutboundResultMaterialMapper.getSeqNumber("seq__WMSP_OUTBOUND_RESUL_TMATRIAL");
                WmspOutboundResultMaterial wmspOutboundResultMaterial = new WmspOutboundResultMaterial();
                wmspOutboundResultMaterial.setResultMaterialId(resultMaterialId);
                wmspOutboundResultMaterial.setOutboundResultId(outBoundId);
                wmspOutboundResultMaterial.setMaterialId(materialId);
                wmspOutboundResultMaterial.setMaterialNumber(materialNumber);
                wmspOutboundResultMaterial.setInsertTime(new Date());
                wmspOutboundResultMaterial.setInsertUsername("admin");
                wmspOutboundResultMaterial.setStatus(new BigDecimal(1));
                result += wmspOutboundResultMaterialMapper.insertSelective(wmspOutboundResultMaterial);
            }
        }
        //去掉取消装货
        result += omstruckOrderMaterialMapper.updateOmsMaterial(saleMaterialMap);
        if (orderId != null && orderStatus.intValue() == 7) {
            //如果订单被关闭,那么还原
            //判断下面有没有实绩
            int resultCount = omstruckOrderMapper.getResultCount(orderId);
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            if (resultCount == 0) {
                omstruckOrder.setOrderId(orderId);
                omstruckOrder.setOrderStatus(new BigDecimal(4));
                omstruckOrder.setInsertUpdateRemark("反关闭分录,运单同步开启");
                omstruckOrder.setUpdateTime(new Date());
                omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
              }else{
                omstruckOrder.setOrderId(orderId);
                omstruckOrder.setOrderStatus(new BigDecimal(5));
                omstruckOrder.setInsertUpdateRemark("反关闭分录,运单同步开启");
                omstruckOrder.setUpdateTime(new Date());
                omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
            }
            //插入日志
            saleLogUtil.logOrder(orderId,"反关闭分录,运单同步开启",null,SaleLogUtil.UPDATE);
        }
        return result;
    }

    @Override
    public List<String> getEasPrimaryIds(Map<String, Object> map) {
        List<String> easPrimaryIds = amsSaleOrderMapper.getEasPrimaryIds(map);
        String easPrimaryList = "";
        for (String easPrimaryId :easPrimaryIds) {
            easPrimaryList = easPrimaryList + '\'' +  easPrimaryId + '\'' + ',';
        }
        easPrimaryList = easPrimaryList.substring(0,easPrimaryList.length() - 1);
        ArrayList<String> easPrimaryList1 = new ArrayList<>();
        easPrimaryList1.add(easPrimaryList);
        Map<String,Object> totalMap = easFluMakeDateUtil.getTotalMap();
        Map<String, Object> input = new HashMap<>();
        input.put("defineSqlNumber","defineXSCKTime");
        input.put("defineSqlparams",easPrimaryList1);
        totalMap.put("input",input);
        totalMap.put("outerSystem","DG");
        JSONObject jsonObject = new JSONObject(totalMap);
        Map<String,Object> resultMap = joinFeign.deleteSaleOrderToEas(totalMap);
        try {
            newFileTool.newFile("deleteSaleOrderToEas："+totalMap,"金蝶通讯报文");
        }catch (Exception e){
            e.printStackTrace();
        }
        String outPut = (String) resultMap.get("output");
        JSONObject outputjson = JSONObject.parseObject(outPut);
        Map<String,Object> outputMap = (Map<String,Object>) outputjson;
        List<Map<String,Object>> rowSetList = (List<Map<String,Object>>) outputMap.get("rowset");
        for (Map<String,Object> rowSet : rowSetList) {
            Map<String, Object> easMap = new HashMap<>();
            String easprimaryIdMakeDate = (String) rowSet.get("FCREATETIME");
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date easprimaryIdMakeDate1 = null;
            try {
                easprimaryIdMakeDate1 = sdf.parse(easprimaryIdMakeDate);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            rowSet.put("easprimaryIdMakeDate",easprimaryIdMakeDate1);
            amsSaleMaterialMapper.updateSaleMaterialMakeDate(rowSet);
        }
        return easPrimaryIds;
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public synchronized int addSteelSaleOrderLoading(Map<String, Object> mapValue) throws Exception {
        List<Map<String,Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");
        //如果前端传输过来的销售订单id不是空,则改变为已上传
        if (mapValue.get("saleOrderId") != null) {
            //先判断该销售订单有没有被上传,如果传了则不允许重复上传
            if (mapValue.get("saleOrderNo") != null) {
                int count1 = amsSaleOrderMaterialMapper.selectSaleOrdeNoIsUpload(mapValue.get("saleOrderNo").toString());
                if(count1 != 0) {
                    return 0;
                }
                amsSaleOrderMapper.updateOldSaleOrderUploadByNo(mapValue.get("saleOrderNo").toString());
            }else{
                int count = amsSaleOrderMaterialMapper.selectSaleOrderIdIsUpload(DataChange.dataToBigDecimal(mapValue.get("saleOrderId")));
                if(count != 0) {
                    return 0;
                }
                amsSaleOrderMapper.updateOldSaleOrderUpload(DataChange.dataToBigDecimal(mapValue.get("saleOrderId")));
            }
        }
        // 得到发货单位
        BigDecimal shipperId = DataChange.dataToBigDecimal(mapValue.get("shipperId"));
        // 收货单位
        BigDecimal receiveId = DataChange.dataToBigDecimal(mapValue.get("receiveId"));
        // 是否自提
        String isSelfMention = (String) mapValue.get("isSelfMention");
        // 备注
        String saleRemark = (String) mapValue.get("saleRemark");
        String saleGroupCode = null;
        try {
            saleGroupCode = "钢" + StringUtils.substringBetween(saleRemark,"钢","组") + "组";
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 收款客户
        String saleOrderReceiveCustomer = (String) mapValue.get("saleOrderReceiveCustomer");
        // 业务员
        BigDecimal salerId = DataChange.dataToBigDecimal(mapValue.get("salerId"));
        BigDecimal saleOrderId = amsSaleOrderMapper.selectMaxId();
        int result = 0;
        // 销售订单
        AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
        amsSaleOrder.setReceiveId(receiveId);
        amsSaleOrder.setSaleRemark(saleRemark == null ? "":saleRemark);
        amsSaleOrder.setShipperId(shipperId);
        amsSaleOrder.setSaleOrderIsselfMention(isSelfMention);
        amsSaleOrder.setSaleOrderId(saleOrderId);
        amsSaleOrder.setSalerId(salerId);
        // 设置钢材订单
        amsSaleOrder.setSaleType(new BigDecimal(1));
        amsSaleOrder.setSaleNumber(DataChange.generateEightDigitsNumber("WXSDD",saleOrderId.intValue(),"-"));
        amsSaleOrder.setInsertTime(new Date());
        amsSaleOrder.setInsertUpdateRemark("物流新增继续装销售订单");
        amsSaleOrder.setInsertUsername("物流");
        amsSaleOrder.setUpdateTime(new Date());
        amsSaleOrder.setDeleted(new BigDecimal(0));
        amsSaleOrder.setSaleOrderStatus(new BigDecimal(0));
        amsSaleOrder.setBusinessDate(new Date());
        // 税率默认13%
        amsSaleOrder.setSaleOrderTax("13%");
        // 含税单价某人4000
        amsSaleOrder.setSaleUnitPrice(new BigDecimal(4000));
        // 收款客户
        amsSaleOrder.setSaleOrderReceiveCustomer(saleOrderReceiveCustomer);
        // 销售订单物资表
        AmsSaleMaterial amsSaleMaterial = new AmsSaleMaterial();
        // 车序号物资表
        AmsSaleTrucknoMaterial amsSaleTrucknoMaterial = new AmsSaleTrucknoMaterial();
        // 遍历每一行
        for (Map<String, Object> map : mapList) {
            /*
             车序号表
             */
            // 得到车序号
            BigDecimal truckNo = DataChange.dataToBigDecimal(map.get("truckNo"));

            Map<String,Object> saleMap = new HashMap<>();
            saleMap.put("saleOrderId",saleOrderId);
            saleMap.put("saleOrderMaterialTruckNo",truckNo);
            // 检测销售订单下的车序号是否已存在
            List<AmsSaleOrderMaterial> amsSaleOrderMaterials = amsSaleOrderMaterialMapper.selectByParameters(saleMap);
            // 车序号表
            AmsSaleOrderMaterial amsSaleOrderMaterial = new AmsSaleOrderMaterial();
            if (amsSaleOrderMaterials == null || amsSaleOrderMaterials.size() == 0) {
                // 车序号主键
                BigDecimal saleOrderMaterialId = amsSaleOrderMaterialMapper.selectMaxId();
                BigDecimal shippingAddressId = DataChange.dataToBigDecimal(map.get("shipperAddressId"));
                // 车号备注
                String truckRemark = (String) (map.get("truckRemark"));
                String place = (String) (map.get("place"));
                amsSaleOrderMaterial.setSaleShippingAddressId(DataChange.dataToBigDecimal(map.get("placeId")));
                if (amsSaleOrderMaterial.getSaleShippingAddressId() != null && isSelfMention.equals("否") && DataChange.dataToBigDecimal(map.get("carrierId")).intValue() == 0) {
                    // 自动匹配承运商
                    List<Map<String, Object>> carrierList = getCarrierByAddress(amsSaleOrderMaterial.getSaleShippingAddressId());
                    BigDecimal carrierCount = null;
                    if(place != null && !"null".equals(place)){
                        carrierCount = amsSaleOrderMapper.getMoreCarrier(place);
                    }
                    //根据收货地址id查询备注，判断是否需要匹配承运商
                    String addressRemark = amsSaleOrderMaterialMapper.getAddressRemark(shippingAddressId);
                    // 单一承运商才进行匹配
                    if (carrierList != null && carrierList.size() == 1 && carrierList.get(0) != null  && carrierCount.intValue() == 0 && addressRemark == null) {
                        List<Map<String, Object>> list = new ArrayList<>();
                        Map<String, Object> map1 = carrierList.get(0);
                        // 传入车序号主键和承运商id
                        map1.put("saleOrderMaterialId", saleOrderMaterialId);
                        list.add(map1);
                        dispatchToCarrier(list);
                    }
                }
                if (isSelfMention.equals("是")) {
                    BigDecimal carrierId = null;
                    // 根据收货单位id查询出收货单位名称
                    if (place != null && place.contains("欧冶")) {
                        String placeRemark = amsSaleOrderMapper.selectPlaceRemark(place);
                        carrierId = amsSaleOrderMapper.selectCarrierId(placeRemark);
                    }else{
                        String consigneeName = amsSaleOrderMapper.selectConsigneeName(receiveId);
                        carrierId = amsSaleOrderMapper.selectCarrierId(consigneeName);
                    }
                    // 根据收货单位名称查询承运商id
                    List<Map<String, Object>> list = new ArrayList<>();
                    Map<String,Object> map1 = new HashMap<>();
                    // 传入车序号主键和承运商id
                    if (carrierId != null) {
                        map1.put("saleOrderMaterialId", saleOrderMaterialId);
                        map1.put("carrierId", carrierId);
                        list.add(map1);
                        dispatchToCarrier(list);
                    }
                }
                if (DataChange.dataToBigDecimal(map.get("carrierId")).intValue() != 0) {
                    //说明有承运商
                    List<Map<String, Object>> list = new ArrayList<>();
                    Map<String, Object> carrierMap = new HashMap<>();
                    carrierMap.put("carrierId",map.get("carrierId"));
                    carrierMap.put("saleOrderMaterialId",saleOrderMaterialId);
                    list.add(carrierMap);
                    dispatchToCarrier(list);
                }
                // 收货方姓名
                String consigneeName = String.valueOf(map.get("saleOrderConsignee"));
                // 收货方电话
                String consigneeTel = String.valueOf(map.get("saleOrderConsigneeTel"));
                // 截止日期
                String dateOfReceiptStr = String.valueOf(map.get("saleDateOfReceipt"));
                Date oldDateOfReceipt = amsSaleOrderMaterialMapper.getOldDateOfReceipt(DataChange.dataToBigDecimal(mapValue.get("saleOrderId")));
                Date dateOfReceipt = null;
                if (!"null".equals(dateOfReceiptStr) && !"undefined".equals(dateOfReceiptStr)) {
                    dateOfReceipt = new Date(Long.valueOf(dateOfReceiptStr));
                }
                if(oldDateOfReceipt != null) {
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(oldDateOfReceipt);
                    calendar.add(Calendar.DATE,1);
                    dateOfReceipt = calendar.getTime();
                }
                amsSaleOrderMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
                amsSaleOrderMaterial.setSaleOrderId(saleOrderId);
                amsSaleOrderMaterial.setTruckRemark(truckRemark);
                amsSaleOrderMaterial.setSaleOrderMaterialTruckNo(truckNo);
                if(map.get("orderNo") != null) {
                    amsSaleOrderMaterial.setPreviousOrderNumber((String) map.get("orderNo"));
                    //如果该订单已有出厂实绩,不允许生成继续装
                    //int outFactoryResult = amsSaleOrderMapper.selectOutFactoryResult((String) map.get("orderNo"));
                    //if(outFactoryResult > 0) {
                    //    return 0;
                    //}
                }
                if (consigneeName != null && !consigneeName.equals("null")) {
                    amsSaleOrderMaterial.setSaleOrderConsignee(consigneeName);
                }
                if (consigneeTel != null && !consigneeTel.equals("null")) {
                    amsSaleOrderMaterial.setSaleOrderConsigneeTel(consigneeTel);
                }
                amsSaleOrderMaterial.setSaleDateOfReceipt(dateOfReceipt);
                amsSaleOrderMaterial.setInsertTime(new Date());
                amsSaleOrderMaterial.setUpdateTime(new Date());
                amsSaleOrderMaterial.setInsertUpdateRemark("物流新增继续装");
                amsSaleOrderMaterial.setWarrantyNumber(new BigDecimal(1));
                result += amsSaleOrderMaterialMapper.insertSelective(amsSaleOrderMaterial);
            }
            else {
                amsSaleOrderMaterial = amsSaleOrderMaterials.get(0);
            }
            /*
            销售订单物资表
             */
            // 物资
            BigDecimal materialId = DataChange.dataToBigDecimal(map.get("materialId"));
            Integer materialCount = amsSaleMaterialMapper.getMaterialCount(materialId);
            RmsMaterial rmsMaterial = new RmsMaterial();
            rmsMaterial.setMaterialId(materialId);
            if (materialCount == null) {
                materialCount = new Integer(0);
            }
            rmsMaterial.setMaterialCount(new BigDecimal(materialCount + 1));
            rmsMaterialMapper.updateByPrimaryKeySelective(rmsMaterial);
            // 物资件数
            BigDecimal materialNumber = DataChange.dataToBigDecimal(map.get("materialNumber"));
            // 物资名称
            Object materialName = map.get("materialName");
            // 钢材米数
            BigDecimal steelMeters = DataChange.dataToBigDecimal(map.get("steelMeters"));
            // 判断物资是否是盘螺或盘元/盘圆
            if (materialName != null && (materialName.toString().contains("盘螺") || materialName.toString().contains("盘元") || materialName.toString().contains("盘圆"))) {
                amsSaleMaterial.setSteelMeter(null);
            }
            else {
                amsSaleMaterial.setSteelMeter(steelMeters);
            }
            // 是否磅重销售（0：磅重；1：理重）
            BigDecimal isPoundSale = DataChange.dataToBigDecimal(map.get("isPoundSale"));
            // 销售订单物资表主键
            BigDecimal saleMaterialId = amsSaleMaterialMapper.selectMaxId();
            amsSaleMaterial.setSaleMaterialId(saleMaterialId);
            amsSaleMaterial.setSaleOrderId(saleOrderId);
            amsSaleMaterial.setMaterialId(materialId);
            amsSaleMaterial.setMaterialNumber(materialNumber);
            amsSaleMaterial.setMaterialPlanNumber(materialNumber);
            amsSaleMaterial.setInsertTime(new Date());
            amsSaleMaterial.setUpdateTime(new Date());
            amsSaleMaterial.setIsPoundSale(isPoundSale);
            amsSaleMaterial.setInsertUpdateRemark("物流新增");
            amsSaleMaterial.setSaleNo(amsSaleOrder.getSaleNumber());
            try {
                amsSaleMaterial.setTransferInOfWarehouse(saleRemark);
            } catch (Exception e) {
                e.printStackTrace();
            }
            if(saleGroupCode != null) {
                amsSaleMaterial.setTransferOutOfWarehouse(saleGroupCode);
            }
            result += amsSaleMaterialMapper.insertSelective(amsSaleMaterial);
            /*
            车序号物资表
             */
            // 车序号物资表主键
            BigDecimal truckNoMaterialId = amsSaleTrucknoMaterialMapper.selectMaxId();
            amsSaleTrucknoMaterial.setTrucknoMaterialId(truckNoMaterialId);
            amsSaleTrucknoMaterial.setSaleOrderMaterialId(amsSaleOrderMaterial.getSaleOrderMaterialId());
            amsSaleTrucknoMaterial.setMaterialId(amsSaleMaterial.getSaleMaterialId());
            amsSaleTrucknoMaterial.setSaleOrderMaterialNumber(materialNumber);
            amsSaleTrucknoMaterial.setInsertTime(new Date());
            amsSaleTrucknoMaterial.setUpdateTime(new Date());
            amsSaleTrucknoMaterial.setInsertUpdateRemark("物流新增");
            result += amsSaleTrucknoMaterialMapper.insertSelective(amsSaleTrucknoMaterial);
        }
        result += amsSaleOrderMapper.insertSelective(amsSaleOrder);
        return saleOrderId.intValue();
    }

    @Override
    public BigDecimal selectTransPortOrder(BigDecimal closeWlEntryId) {
        return amsSaleMaterialMapper.selectTransPortOrderId(closeWlEntryId);
    }

    @Override
    public int updateTransportOrderStatus(BigDecimal orderId) {
        //查询该运单下有没有净重,没有净重就变为7，有净重就变为2
        int netWeight = omstruckOrderMapper.selectNetWeightCount(orderId);
        //查询该运单有没有出厂,没有出厂才变2
        int outFactory = omstruckOrderMapper.selectOutFactory(orderId);
        int orderStatus = 7;
        if((netWeight > 0 ) && outFactory == 0) {
            orderStatus = 2;
        }
        if(netWeight > 0 && outFactory > 0) {
            orderStatus = 5;
        }
        return amsSaleOrderMaterialMapper.updateTransportOrderStatus(orderId,orderStatus);
    }

    @ApiOperation("定时获取制单日期")
    @Scheduled(fixedRate = 20 * 60 * 1000)
    public void getMakeDateTime() {
        Map<String, Object> Map = new HashMap<>();
        getEasPrimaryIds(Map);
        disposeTransOrder();
    }

    private int disposeTransOrder() {
        //查询过了截止日期的销售订单
        int i = amsSaleOrderMapper.getTransOrderIds();
        return i;
    }

    /**
     * 推送车牌号给金蝶
     * @param map
     * @return
     */
    @Override
    public int pushCarNumberToEas(Map<String, Object> map) throws Exception {
        // 调用EAS接口将车牌号传给金蝶
        List<Map<String,Object>> mapList = new ArrayList<>();
        mapList.add(map);
        Map<String,Object> input = joinFeign.findCarNumberByOrderList(mapList);
        try{
            //存在capacityId则判断是否取消或撤销取消
            if(map.get("capacityId")!=null){
                List<Map<String,Object>> entriesList = (List<Map<String,Object>>) input.get("entries");
                //新车号、当前车号、旧车号
                String capacityId ="" + map.get("capacityId");
                Map<String,Object>  capacityDetails=  amsSaleOrderMapper.getCapacityDetailByAsom(map);
                if(capacityDetails!=null && capacityDetails.get("nowCapcaityId")!=null){
                    //存在当前车号，判断是否存在取消或撤销取消
                    String nowCapcaityId ="" + capacityDetails.get("nowCapcaityId");
                    if(capacityId.equals("35128") && !capacityId.equals(nowCapcaityId)){
                        //判断是否正常转取消:新车号为取消且不等于旧车号
                        input.put("cancel",true);
                        for(Map<String,Object> entriesMap : entriesList) {
                            entriesMap.put("changeStatus",1);
                        }
                    }else if(capacityDetails.get("oldCapacityIds")!=null){
                        //存在旧车号，判断是否撤销取消:当前车号为取消，且最近的旧车号等于新车号
                        String[] oldCapacityIds =("" + capacityDetails.get("oldCapacityIds")).split(",");
                        String lastOldCapacity = oldCapacityIds[0];
                        if(nowCapcaityId.equals("35128") && lastOldCapacity.equals(capacityId)){
                            input.put("unCancel",true);
                            for(Map<String,Object> entriesMap : entriesList) {
                                entriesMap.put("changeStatus",2);
                            }
                        }
                    }
                    //发送给计量
                    if(input.get("cancel")!=null || input.get("unCancel")!=null){
                        Map<String, Object> cancelOrderMap = new HashMap<>();
                        cancelOrderMap.put("orderID",capacityDetails.get("orderNumber"));
                        if(input.get("cancel")!=null){
                            cancelOrderMap.put("changeStatus",1);
                            cancelOrderMap.put("content","取消");
                            System.out.println("联动计量取消：" + map.get("oldCapacityNumber"));
                        }else if(input.get("unCancel")!=null){
                            cancelOrderMap.put("changeStatus",2);
                            cancelOrderMap.put("content",map.get("capacityNo"));
                            System.out.println("联动计量撤销取消：" + map.get("oldCapacityNumber"));
                        }
                        String url = "http://172.16.33.122:44325/api/logistics/CancleOrdersBill";
                        JSONObject cancelOrderJson = new JSONObject(cancelOrderMap);
                        System.out.println("联动计量撤销取消报文：" + cancelOrderJson);
                        String sendUrl = url ;
                        String jsonData =  HTTPRequestUtils.send(sendUrl, cancelOrderJson,"utf-8");
                        System.out.println("联动计量撤销取消响应：" + jsonData);
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        Map<String,Object> totalMap = new HashMap<>();
        //正式
        totalMap.putAll(easCapacityTestUtil.getTotalMap());
        ////测试
        //totalMap.putAll(easTestUtil.getTotalMap());
        totalMap.put("input",input);
        Map<String,Object> s = joinFeign.pushCarNumberToEas(totalMap);
        System.out.println(totalMap);
        String json = JSONUtils.toJSONString(totalMap);
        System.out.println(json);
        totalMap.put("output",s);
        try {
            newFileTool.newFile("pushCarNumberToEas："+totalMap,"金蝶通讯报文");
        }catch (Exception e){
            e.printStackTrace();
        }
        if (s == null || s.size() == 0) {
            throw new Exception("登录金蝶失败!请重试派车!");
        }else {
            try {
                JSONObject result = new JSONObject(s);
                //如果status不为1,抛出异常
                if (!result.getJSONObject("res").getString("status").equals("1")) {
                    throw new Exception("上传金蝶失败！请重试派车:" + result.getJSONObject("requestException").getString("message"));
                }
            } catch (Exception e) {
                e.printStackTrace();
                //只抛出自定义异常
                if (e.getMessage().contains("Exception")) {
                    throw new Exception("上传金蝶失败！请重试派车!");
                } else {
                    throw new Exception(e.getMessage());
                }

            }
        }
        return 1;
    }

    /**
     * 批量推送
     * @param mapList
     * @return
     * @throws Exception
     */
    @Override
    public int batchPushCarNumberToEas(List<Map<String, Object>> mapList) throws Exception {
        Map<String, Object> input = joinFeign.findCarNumberByOrderList(mapList);
        Map<String, Object> totalMap = new HashMap<>();
        totalMap.putAll(easCapacityTestUtil.getTotalMap());
        totalMap.put("input", input);
        Map<String, Object> s = joinFeign.pushCarNumberToEas(totalMap);
        System.out.println(totalMap);
        String json = JSONUtils.toJSONString(totalMap);
        System.out.println(json);
        totalMap.put("output", s);
        System.out.println(totalMap);
        try {
            newFileTool.newFile("pushCarNumberToEas：" + totalMap, "金蝶通讯报文");
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (s == null || s.size() == 0) {
            throw new Exception("登录金蝶失败!请重试派车!");
        } else {
            try {
                JSONObject result = new JSONObject(s);
                //如果status不为1,抛出异常
                if (!result.getJSONObject("res").getString("status").equals("1")) {
                    throw new Exception("上传金蝶失败！请重试派车:" + result.getJSONObject("requestException").getString("message"));
                }
            } catch (Exception e) {
                e.printStackTrace();
                //只抛出自定义异常
                if (e.getMessage().contains("Exception")) {
                    throw new Exception("上传金蝶失败！请重试派车!");
                } else {
                    throw new Exception(e.getMessage());
                }

            }

        }

        try{
            //存在capacityId则判断是否取消或撤销取消
            for(Map<String, Object> map : mapList){
                if(map.get("capacityId")!=null){
                    //新车号、当前车号、旧车号
                    String capacityId ="" + map.get("capacityId");
                    Map<String,Object>  capacityDetails=  amsSaleOrderMapper.getCapacityDetailByAsom(mapList.get(0));
                    Map<String, Object> cancelOrderMap = new HashMap<>();
                    cancelOrderMap.put("orderID",capacityDetails.get("orderNumber"));
                    if(capacityDetails!=null && capacityDetails.get("nowCapcaityId")!=null){
                        //存在当前车号，判断是否存在取消或撤销取消
                        String nowCapcaityId ="" + capacityDetails.get("nowCapcaityId");
                        if(capacityId.equals("35128") && !capacityId.equals(nowCapcaityId)){
                            //判断是否正常转取消:新车号为取消且不等于旧车号
//                            input.put("cancel",true);
                            cancelOrderMap.put("changeStatus",1);
                            cancelOrderMap.put("content","取消");
                            System.out.println("联动计量取消：" + map.get("oldCapacityNumber"));
                        }else if(capacityDetails.get("oldCapacityIds")!=null){
                            //存在旧车号，判断是否撤销取消:当前车号为取消，且最近的旧车号等于新车号
                            String[] oldCapacityIds =("" + capacityDetails.get("oldCapacityIds")).split(",");
                            String lastOldCapacity = oldCapacityIds[0];
                            if(nowCapcaityId.equals("35128") && lastOldCapacity.equals(capacityId)){
//                                input.put("unCancel",true);
                                cancelOrderMap.put("changeStatus",2);
                                cancelOrderMap.put("content",map.get("capacityNo"));
                                System.out.println("联动计量撤销取消：" + map.get("oldCapacityNumber"));
                            }
                        }
                        //发送给计量
                        if(cancelOrderMap.get("changeStatus")!=null ){
                            String url = "http://172.16.33.122:44325/api/logistics/CancleOrdersBill";
                            JSONObject cancelOrderJson = new JSONObject(cancelOrderMap);
                            System.out.println("联动计量撤销取消报文：" + cancelOrderJson);
                            String sendUrl = url ;
                            String jsonData =  HTTPRequestUtils.send(sendUrl, cancelOrderJson,"utf-8");
                            System.out.println("联动计量撤销取消响应：" + jsonData);
                        }
                    }
                }

            }
            }catch (Exception e){
            e.printStackTrace();
        }
        return 1;
    }

    /**
     * 钢材派车，不上传金蝶
     * @param map
     * @return
     * @throws Exception
     */
    private int dispatchSteelOrderNotPush(Map<String, Object> map) throws Exception {
        Integer isCheckGps = amsSaleOrderMapper.getDispachSwitch();
        Integer saleStatus = amsSaleOrderMapper.findStatus(DataChange.dataToBigDecimal(map.get("saleOrderMaterialId")));
        String selfMention = amsSaleOrderMapper.findSelfMention(DataChange.dataToBigDecimal(map.get("saleOrderMaterialId")));
        //如果这个车序号下面有运单,则证明已经派了
        Map<String,Object> orderMap = amsSaleOrderMapper.getSteelOrderMap(DataChange.dataToBigDecimal(map.get("saleOrderMaterialId")));
        //判断该车序号对应的分录是否全部关闭
        Integer flCount = amsSaleMaterialMapper.getAbleFlcount(DataChange.dataToBigDecimal(map.get("saleOrderMaterialId")));
        if(flCount == 0) {
            throw new Exception("该运单下所有分录被关闭,无法派车");
        }
        if (orderMap != null) {
            throw new Exception("该订单已派发,无法重复派车");
        }
        if (saleStatus == 1) {
            throw new Exception("订单未审核，无法派车！");
        }
        int result = 0;
        //得到此次是否校验GPS
        boolean onceCheck = true;
        try{
            onceCheck = (boolean) map.get("isCheckGPS");
        }catch (Exception e){
            //取值失败不处理，默认校验GPS
        }
        // 得到车牌号
        String capacityNumber = (String) map.get("capacityNumber");
        // 得到运力id
        BigDecimal capacityId = amsSaleOrderMaterialMapper.getCapacityId(capacityNumber);
        //校验该车是否存在手机号
        String tel=omstruckOrderMapper.getTelByCapacityId(capacityId);//数据库的手机号
        String driverTel = (String) map.get("driverTel");//填写的手机号
        if(tel==null || "".equals(tel)){
            throw new Exception("该车没有电话号码，无法派车！请去资源管理-运力维护该车的电话号码！");
        }
        //查询车牌号是否是黑名单
        if(amsSaleOrderMapper.isBlackList(capacityNumber)>0){
            throw new Exception("该车在黑名单中，无法派车！请联系销售公司！");
        }
        //非自提，单次校验且全局校验，且车不允许无GPS
        int isGPS=amsSaleOrderMapper.isGPS(capacityNumber);
        if((selfMention==null || selfMention.equals("否")) && onceCheck && (isCheckGps!=null && isCheckGps==0) && isGPS <= 0){
            Map<String,Object> data=null;
            try{
                data= (Map<String,Object>)otmsFeign.getCurrentLocation(capacityNumber).getData();
            }catch (Exception e){
                throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
            }
            if(data==null || !"1001".equals(""+data.get("status"))){
                throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
            }
        }
        // 得到车序号表主键
        BigDecimal saleOrderMaterialId = DataChange.dataToBigDecimal(map.get("saleOrderMaterialId"));
        // 得到承运商
        BigDecimal carrierId = DataChange.dataToBigDecimal(map.get("carrierId"));
        // 查询到车序号的单价
        BigDecimal priceId = amsSaleOrderMapper.getOrderPrice(map);
        // 得到详细地址id
        BigDecimal placeId = amsSaleOrderMapper.getPlaceId(saleOrderMaterialId);
        // 如果已经设置单价则不覆盖，详细地址匹配不到单价，则匹配省市县内最高的一条单价(只给非自提的进行匹配)
        if (priceId == null && placeId != null && selfMention.equals("否")) {
            priceId = amsSaleOrderMapper.getPriceIdByPlaceId(placeId);
        }
        // 运输线路id
        BigDecimal lineId = DataChange.dataToBigDecimal(map.get("lineId"));
        if(lineId==null || lineId.compareTo(BigDecimal.ZERO)==0){
            throw new Exception("线路异常!");
        }
        BigDecimal isSteel = new BigDecimal(1);
        if (capacityId == null) {
            return 0;
        }
        List<Map<String, Object>> materialList = amsSaleOrderMaterialMapper.getMaterial(saleOrderMaterialId);
        /*
         定向派单表
         */
        // 通过车序号主键确认定向派单是否已存在
        BigDecimal dispatchId0 = amsDispatchSaleOrderMapper.isDispatchExist(saleOrderMaterialId);
        if (dispatchId0 == null || dispatchId0.toString().length() == 0) {
            AmsDispatchSaleOrder amsDispatchSaleOrder = new AmsDispatchSaleOrder();
            // 主键
            BigDecimal dispatchId = amsDispatchSaleOrderMapper.selectOtherId();
            amsDispatchSaleOrder.setDispatchId(dispatchId);
            // 车序号表id
            amsDispatchSaleOrder.setSaleOrderMaterialId(saleOrderMaterialId);
            // 承运商id
            amsDispatchSaleOrder.setCarrierId(carrierId);
            // 派单时间和成交时间
            amsDispatchSaleOrder.setDispatchTime(new Date());
            amsDispatchSaleOrder.setDispatchDealTime(new Date());
            // 成交类型
            amsDispatchSaleOrder.setDispatchType(new BigDecimal(2));
            // 车序号状态
            amsDispatchSaleOrder.setDispatchStatus(new BigDecimal(2));
            result += amsDispatchSaleOrderMapper.insertSelective(amsDispatchSaleOrder);
        }
        // 如果已经匹配过承运商或者给某个承运商授权过，则派车时做修改承运商操作
        else {
            AmsDispatchSaleOrder amsDispatchSaleOrder = amsDispatchSaleOrderMapper.selectByPrimaryKey(dispatchId0);
            amsDispatchSaleOrder.setCarrierId(carrierId);
            result += amsDispatchSaleOrderMapper.updateByPrimaryKeySelective(amsDispatchSaleOrder);
        }
        /*
         运输订单
         */
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        Map<String, Object> map1 = new HashMap<>();
        map1.put("orderType", new BigDecimal(2));
        map1.put("orderPlanId", saleOrderMaterialId);
        List<OmstruckOrder> omstruckOrders = omstruckOrderMapper.selectByParameters(map1);
        if (omstruckOrders == null || omstruckOrders.size() == 0) {
            // 运输订单主键
            BigDecimal orderId = omstruckOrderMapper.selectMaxId();
            omstruckOrder.setOrderId(orderId);
            // 车序号主键
            omstruckOrder.setOrderPlanId(saleOrderMaterialId);
            //添加承运商ID 和 运价ID
//            Object priceId = map.get("priceId");
            if (priceId != null) {
                omstruckOrder.setPriceId(priceId);
            } else {
                omstruckOrder.setPriceId(new BigDecimal(0));
            }
            omstruckOrder.setCarrierId(carrierId);
            // 运输订单号
            omstruckOrder.setOrderNumber(DataChange.generateEightDigitsNumber("WYSDD", orderId.intValue()));
            // 运力id
            omstruckOrder.setCapacityId(capacityId);
            // 承运商
            omstruckOrder.setCarrierId(carrierId);
            // 是否可作业
            omstruckOrder.setCanWork(new BigDecimal(0));
            // 下发时间
            omstruckOrder.setOrderIssueTime(new Date());
            // 运单状态
            omstruckOrder.setOrderStatus(new BigDecimal(4));
            // 司机电话
            if(tel != null && !"".equals(tel)){
                omstruckOrder.setDriverTel(tel);
            }
            BigDecimal status;
            // 钢材
            status = new BigDecimal(1);

            // 订单类型
            omstruckOrder.setOrderType(status);
            // 运输线路id
            omstruckOrder.setLineId(lineId);
            omstruckOrder.setInsertTime(new Date());
            omstruckOrder.setInsertUsername("");
            result += omstruckOrderMapper.insertSelective(omstruckOrder);
            //插入日志
            saleLogUtil.logOrder(orderId,"普通派单,当前派车为:" + capacityNumber,map,SaleLogUtil.INSERT);
        } else {
            omstruckOrder = omstruckOrders.get(0);
        }
        for (Map<String, Object> materialMap : materialList) {
            BigDecimal materialId = (BigDecimal) materialMap.get("materialId");
            BigDecimal materialWeight = (BigDecimal) materialMap.get("materialWeight");
            BigDecimal materialNumber = (BigDecimal) materialMap.get("materialNumber");
            BigDecimal saleMaterialId = (BigDecimal) materialMap.get("saleMaterialId");

            /*
            运输订单物资子表
            */
            OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
            // 主键
            BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
            omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
            // 运输订单id
            omstruckOrderMaterial.setOrderId(omstruckOrder.getOrderId());
            // 物资id
            omstruckOrderMaterial.setMaterialId(materialId);
            // 物资重量
            omstruckOrderMaterial.setOrderMaterialWeight(materialWeight);
            // 物资件数
            omstruckOrderMaterial.setOrderMaterialNumber(materialNumber);
            omstruckOrderMaterial.setSaleMaterialId(saleMaterialId);
            try {
                BigDecimal deleted = (BigDecimal) materialMap.get("DELETED");
                if(deleted != null) {
                    omstruckOrderMaterial.setMaterialPriority(new BigDecimal(71));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            // 新增运输订单子表
            result += omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
        }
        // 调用websocket
        Map<String, Object> orderIdMap = new HashMap<>();
        orderIdMap.put("orderId", omstruckOrder.getOrderId());
        try {
            amsSaleOrderMaterialService.pushMesToWebsocket(orderIdMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 生成运输执行总实绩
        result += tmsTruckFeign.addTotalResult(orderIdMap);
        return  result;
    }

    /**
     * 钢材改车，不上传金蝶
     * @param mapValue
     * @return
     * @throws Exception
     */
    private int updateSteelOrderNotPush(Map<String, Object> mapValue) throws Exception {
        Object lineSequence = mapValue.get("lineSequence");
        int result = 0;
        if (mapValue.get("orderId") == null) {
            throw new Exception("还未派车,不允许修改车牌号");
        }
        //判断该车序号对应的分录是否全部关闭
        if(mapValue.get("saleOrderMaterialId") != null && DataChange.dataToBigDecimal(mapValue.get("capacityId")).compareTo(new BigDecimal(35128)) != 0) {
            Integer flCount = amsSaleMaterialMapper.getAbleFlcount(DataChange.dataToBigDecimal(mapValue.get("saleOrderMaterialId")));
            if(flCount == 0) {
                throw new Exception("该运单下所有分录被关闭,无法派车");
            }
        }
        //查询输入进来的车牌号是否与原有车牌号一致,如果一致则退出
        BigDecimal oldCapacityId = omstruckOrderMapper.getOldCapacityId(DataChange.dataToBigDecimal(mapValue.get("orderId")));
        String oldCapacityNumber = omstruckOrderMapper.getOldCapacityNumber(oldCapacityId);
        if(oldCapacityId.compareTo(DataChange.dataToBigDecimal(mapValue.get("capacityId"))) == 0) {
            return 1;
        }
        //校验该车是否存在手机号
        String tel=omstruckOrderMapper.getTelByCapacityId(DataChange.dataToBigDecimal(mapValue.get("capacityId")));
        String driverTel = (String) mapValue.get("driverTel");//填写的手机号
        if(tel==null || "".equals(tel)){
            throw new Exception("该车没有电话号码，无法派车！请去资源管理-运力维护该车的电话号码!");
        }
        Integer isCheckGps = amsSaleOrderMapper.getDispachSwitch();
        String capacityNo = (String) mapValue.get("capacityNumber");
        //得到此次是否校验GPS
        boolean onceCheck = true;
        //查询是否自提
        String selfMention = "否";
        try{
            selfMention = amsSaleOrderMapper.findSelfMention(DataChange.dataToBigDecimal(mapValue.get("saleOrderMaterialId")));
            onceCheck = (boolean) mapValue.get("isCheckGPS");
        }catch (Exception e){
            //取值失败不处理，取默认值
        }
        //查询车牌号是否是黑名单
        if(amsSaleOrderMapper.isBlackList(capacityNo)>0){
            throw new Exception("该车在黑名单中，无法派车！请联系销售公司！");
        }
        //非自提，单次校验且全局校验，且车辆不允许无GPS
        int isGPS=amsSaleOrderMapper.isGPS(capacityNo);
        if((selfMention==null || selfMention.equals("否")) && onceCheck && (isCheckGps!=null && isCheckGps==0) && isGPS <= 0){
            Map<String,Object> data=null;
            try{
                data= (Map<String,Object>)otmsFeign.getCurrentLocation(capacityNo).getData();
            }catch (Exception e){
                throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
            }
            if(data==null || !"1001".equals(""+data.get("status"))){
                throw new Exception("该车没有GPS定位信息，请联系销售公司物流部，申请是否可以派车。");
            }
        }
        saleLogUtil.logOrder(DataChange.dataToBigDecimal(mapValue.get("orderId")),"修改车牌号,当前车号为:" + capacityNo + "上一个车牌号为:" + oldCapacityNumber,mapValue,SaleLogUtil.UPDATE);
        if (lineSequence == null || "0".equals(lineSequence.toString()) || "1".equals(lineSequence.toString()) || "2".equals(lineSequence.toString())) {
            String capacityids="";
            Integer capacityid1= (Integer) mapValue.get("capacityIds");
            Integer capacityid2= (Integer) mapValue.get("capacityId");
            if (capacityid1!=null && !("".equals(capacityid1))){
                capacityids=capacityid1+","+capacityid2;
            }
            mapValue.put("capacityids",capacityids);
            //这是修改车牌号
            //取消是新车牌号,那么不删除排队信息，不删除实绩信息，将运单状态变为7
            if (DataChange.dataToBigDecimal(mapValue.get("capacityId")).compareTo(new BigDecimal(35128)) != 0) {
                //根据订单id查询车牌号改动记录
                String oldCpacityIds = omstruckOrderMapper.getOrderCapacityHistory(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                BigDecimal oldOldCapacityId = null;
                if(oldCpacityIds != null) {
                    oldOldCapacityId = DataChange.dataToBigDecimal(oldCpacityIds.split(",")[0]);
                }
                //如果旧车号是取消，且取消的前一个车与该车相等,那么就将状态还原
                if (oldOldCapacityId != null && oldCapacityId != null && oldCapacityId.compareTo(new BigDecimal(35128)) == 0 && DataChange.dataToBigDecimal(mapValue.get("capacityId")).compareTo(oldOldCapacityId) == 0 ) {
                    //判断该订单下有没有子实绩
                    BigDecimal  resultId = amsSaleOrderMaterialMapper.selectEnFactory(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                    if(resultId == null) {
                        OmstruckOrder omstruckOrder = new OmstruckOrder();
                        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                        omstruckOrder.setOrderStatus(new BigDecimal(4));
                        omstruckOrder.setOrderLineSequence(new BigDecimal(0));
                        omstruckOrder.setInsertUpdateRemark("将取消改回来原来的车状态不变!");
                        if(tel != null && !"".equals(tel)){
                            omstruckOrder.setDriverTel(tel);
                        }
                        /*omstruckOrder.set*/
                        result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
                    }else{
                        OmstruckOrder omstruckOrder = new OmstruckOrder();
                        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                        omstruckOrder.setOrderStatus(new BigDecimal(5));
                        if(tel != null && !"".equals(tel)){
                            omstruckOrder.setDriverTel(tel);
                        }
                        omstruckOrder.setInsertUpdateRemark("将取消改回来原来的车状态不变!");
                        /*omstruckOrder.set*/
                        result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
                    }

                }else{
                    //将排队信息删掉
                    Map<String, Object> isSpellingMap = omstruckOrderMapper.getSteelIsSpelling(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                    if(isSpellingMap != null && isSpellingMap.get("listId") != null){
                        int isSpelling = DataChange.dataToBigDecimal(isSpellingMap.get("isSpelling")).intValue();
                        if(isSpelling == 1 ){
                            result += omstruckOrderMapper.deleteSpellingList(isSpellingMap.get("listId"));
                        }else{
                            result += omstruckOrderMapper.deleteQueueList(isSpellingMap.get("listId"));
                        }
                    }
                    //若是接单之后还需要删除实绩且将状态变为4
                    //查询运输订单的状态和总实绩ID
                    Map<String, Object> orderMesMap = amsSaleOrderMapper.getOrderMes(mapValue);
                    BigDecimal resultTotalId = DataChange.dataToBigDecimal(orderMesMap.get("resultTotalId"));
                    //删除排队实绩
                    if (resultTotalId !=null && !("".equals(resultTotalId))){
                        omstruckOrderMapper.deleteQueuingPerformance(resultTotalId);
                    }
                    OmstruckOrder omstruckOrder = new OmstruckOrder();
                    omstruckOrder.setOrderId(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                    // 设置新的运输订单号
                    omstruckOrder.setOrderNumber(DataChange.generateEightDigitsNumber("WYSDD", omstruckOrderMapper.selectMaxId().intValue()));
                    omstruckOrder.setOrderStatus(new BigDecimal(4));
                    omstruckOrder.setOrderLineSequence(new BigDecimal(0));
                    if(tel != null && !"".equals(tel)){
                        omstruckOrder.setDriverTel(tel);
                    }
                    /*omstruckOrder.set*/
                    result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
                    //插入日志
                    result += omstruckOrderMapper.deleteEnResult(resultTotalId);
                    result += omstruckOrderMapper.deleteWeightResult(resultTotalId);
                    result += omstruckOrderMapper.deleteLoadResult(resultTotalId);
                    result += omstruckOrderMapper.deleteLeaveResult(resultTotalId);
                }
            }else{
                OmstruckOrder omstruckOrder = new OmstruckOrder();
                omstruckOrder.setOrderId(DataChange.dataToBigDecimal(mapValue.get("orderId")));
                if(tel != null && !"".equals(tel)){
                    omstruckOrder.setDriverTel(tel);
                }
                omstruckOrder.setOrderStatus(new BigDecimal(7));
                omstruckOrder.setInsertUpdateRemark("取消车牌号,保留实绩将状态变为7");
                result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
            }
            result += amsSaleOrderMapper.updateCapacityNumberInFactory(mapValue);
        }
        return result;
    }
}