DAL-TMS-TRUCK-API/src/main/java/com/steerinfo/dil/service/impl/TmstruckMeasureCommissionServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.common.cache.Weigher;
import com.steerinfo.dil.feign.JoinFeign;
import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.MeasureJsonData;
import com.steerinfo.dil.model.TmstruckMeasureCommission;
import com.steerinfo.dil.model.TmstruckTareReturnResult;
import com.steerinfo.dil.service.ITmstruckMeasureCommissionService;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.dil.util.HTTPRequestUtils;
import com.steerinfo.dil.util.getRequestUtils;
import com.steerinfo.dil.util.newFileTool;
import io.swagger.models.auth.In;
import org.apache.http.ParseException;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.IOException;
import java.math.BigDecimal;
import java.net.Inet4Address;
import java.util.*;

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

    @Autowired
    private TmstruckMeasureCommissionMapper tmstruckMeasureCommissionMapper;

    @Autowired
    private RulesMapper rulesMapper;

    @Autowired
    private UtilsMapper utilsMapper;

    @Autowired
    private RulesServiceImpl rulesService;

    @Autowired
    private MeasureJsonDataMapper measureJsonDataMapper;

    @Autowired
    private TmstruckTareReturnResultMapper tmstruckTareReturnResultMapper;


    @Autowired
    private JoinFeign joinFeign;

    private static final  String daGangUrl = "http://172.16.33.122:44325/api/logistics/TareApplyFor";

    private static final  String dagangUrlForLoad = "http://172.16.33.122:44325/api/logistics/modifyLoadPlace";

    private static final String liuPiUrl = "http://172.16.33.122:44325/api/logistics/updateTareWeight";

    private static final String daXingUrl = "http://172.16.59.251:8121/daXingWeight/OrderBusiness/addOrder.do";

    //给达钢发送委托
    private static final List<Integer> judgeDaGangNum = Arrays.asList(5, 6, 8, 11, 17,15,16,23);

    //给达兴发委托
    private static final List<Integer> judgeDaXinNum = Arrays.asList(7, 18,24);

    //销售焦炭、化产品 判断一厂二厂委托
    private static final String judgeCoke = "一厂";

    //根据门来判断委托发送依据
    public static final List<Integer> daGangGatepost = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 14);
    public static final List<Integer> daXingGatepost = Arrays.asList(8, 9, 10, 11, 12, 13);

    /**
     * 根据门岗发送委托
     * @Author TXF
     * @Date 2022/3/15 11:14
     * @param map
     * @return
     **/
    public int sendMeasureCommissionByGatepost(Map<String, Object> map){
        int gatepostId = DataChange.dataToBigDecimal(map.get("gatepostId")).intValue();
        if(daGangGatepost.contains(gatepostId)){ //给达钢发送委托
            return sendMeasureCommissionMes(map);
        }else if(daXingGatepost.contains(gatepostId)){  //给达兴发送委托
            return sendDXMeasureCommissionMes(map);
        }
        return -2; //返回-2为没有获取到门岗ID
    }


    //添加装货点发送委托给计量
    @Override
    public int addMeasureCommissionForLoding(Map<String, Object> map) throws Exception {
        int i = 0;
//        if (map.get("status")!=null) {
//            List<Map<String, Object>> mapList = tmstruckMeasureCommissionMapper.getLoadMeasure();
//            for (Map<String, Object> map1 : mapList) {
                String loadingPace = (String) map.get("warehouseName");
                String url = "http://172.16.33.122:44325/api/logistics/modifyLoadPlace";
                String ysdd = (String) map.get("orderNumber");
                String memo = (String) map.get("insertUpdateRemark");
                Map<String, Object> loadMap = new HashMap<>();
                loadMap.put("ysdd",ysdd);
                loadMap.put("loadingPace",loadingPace);
                if (memo != null) {
                    loadMap.put("memo",memo);
                }
                JSONObject json = new JSONObject(loadMap);
                String sendUrl = url ;
                String jsonData = null;
                try {
                    jsonData = HTTPRequestUtils.send(sendUrl, json,"utf-8");
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                //写入文件
                try{
                    new Thread( new Runnable() {
                        public void run(){
                            try {
                                newFileTool.newFile(sendUrl+":"+json.toJSONString(),"委托发送报文");
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }).start();
                }catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(sendUrl);
                System.out.println("装货点已发送" + json);
                MeasureJsonData measureJsonData = new MeasureJsonData();
                BigDecimal measureId = measureJsonDataMapper.selectMaxId();
                //设置主键id
                measureJsonData.setMeasureId(measureId);
                //老厂区报文
                measureJsonData.setMeasureTypeId(new BigDecimal(1));
                measureJsonData.setMeasureJsonData(jsonData);
                measureJsonData.setMeasureJsonUrl(sendUrl);
                measureJsonData.setWarehouseName(loadingPace);
                measureJsonData.setOrderNumber(ysdd);
                i = measureJsonDataMapper.insertSelective(measureJsonData);
//            }
//        }
        return i;
    }



    /**
     * 查询计量委托 0 ：计皮     1：计毛
     * @param map orderTypee 订单类型   type 是计皮还是计毛
     * @return
     */
    @Override
    public List<Map<String, Object>> getAllMeasureCommission(Map<String, Object> map) {
        return tmstruckMeasureCommissionMapper.getMeasureCommission(map);
    }

    /**
     * 添加计量委托 并发送采购订单计量委托
     * @param map {orderTypee: 订单类型
     *            resultTotalId：总实绩ID  orderId: 订单ID
     *            总实绩ID }
     * @return
     */
    public int addMaoMeasureCommission(Map<String, Object> map){
        int i = 0;
        //发送数据给计量系统 必要数据 orderTypee：订单类型  resultTotalId： 总实绩Id   orderId
        int orderType = DataChange.dataToBigDecimal(map.get("orderTypee")).intValue();
        BigDecimal factory =DataChange.dataToBigDecimal(map.get("factory"));
        if(orderType == 10){
            //获取当前订单是属于哪个厂区订单
            Integer receiveId = tmstruckMeasureCommissionMapper.getReceiveIdByRequirementOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
            if(receiveId == 1){
                i = sendMeasureCommissionMes(map);  //发送委托给达州钢铁
            }else if(receiveId == 2) {
                i = sendDXMeasureCommissionMes(map); //发送委托给达兴能源
            }
        }else if(judgeDaGangNum.contains(orderType)){
            //判断是否为厂内内转
            if (factory.intValue()==1&&orderType==11){
                i = sendMeasureCommissionMes(map);
            }else if (factory.intValue()==2&&orderType==11){
                i = sendDXMeasureCommissionMes(map);
            }else {
                //发送委托给达州钢铁
                i = sendMeasureCommissionMes(map);
            }
        }else if(judgeDaXinNum.contains(orderType)) {
            //发送委托给达兴能源
            i = sendDXMeasureCommissionMes(map);
        }

        return i;
    }


    /**
     * 发送销售订单计量委托
     * @param map
     * @return
     */
    public int addXSMeasureCommission(Map<String, Object> map){
        int i = 0;
        //发送数据给计量系统 必要数据 orderTypee：订单类型  resultTotalId： 总实绩Id   orderId
        //获取当前订单是属于哪个厂区订单
        Map<String, Object> mesMap = tmstruckMeasureCommissionMapper.getShipperIdByOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
        if(mesMap.get("saleWarehouse") != null){
            String saleWarehouse = String.valueOf(mesMap.get("saleWarehouse"));
            if(saleWarehouse.contains(judgeCoke)){ //如果是一厂焦炭库则向达钢发送委托
                map.put("isDG", "1"); //标识为老厂区
                return sendMeasureCommissionMes(map);
            }
        }
        int shipperId = DataChange.dataToBigDecimal(mesMap.get("shipperId")).intValue();
        if(shipperId == 1){
            //发送委托给达州钢铁
            i += sendMeasureCommissionMes(map);
        }
        if(shipperId == 2) {
            //发送委托给达兴能源
            i += sendDXMeasureCommissionMes(map);
        }
        return i;
    }

    /**
     * 发送钢材销售委托：只有老厂区有钢材
     * @param map
     * @return
     */
    public int addSteelMeasureCommission(Map<String, Object> map){
        Map<String, Object> measureCommission = null;
        if(map.get("firstMC") != null){ //进厂发送空委托
            measureCommission = new HashMap<>();
            measureCommission.put("flowTo","出厂钢材");
            measureCommission.put("carNum", map.get("capacityNumber"));
            measureCommission.put("transportNum", map.get("orderNumber"));
        }else {
            measureCommission = tmstruckMeasureCommissionMapper.getSteelMeasureCommission(map);
            measureCommission.put("isDel", false);
            measureCommission.put("isInsert", true);
            measureCommission.put("isRelationEAS", true);
            measureCommission.put("flowTo", "出厂钢材");
            measureCommission.put("numberOfFurnaces",map.get("numberOfFurnaces"));
            Object isPoundSale = measureCommission.get("isPoundSale");
            measureCommission.remove("isPoundSale");
            if(isPoundSale != null){
                if(DataChange.dataToBigDecimal(isPoundSale).intValue() == 0){
                    measureCommission.put("deliveryMethod", "磅重");
                }else {
                    measureCommission.put("deliveryMethod", "理重");
                }
            }else {
                String materiaName = (String) measureCommission.get("materiaName");
                if(materiaName.contains("盘螺")){ //如果名字中包含盘螺则为磅重交货
                    measureCommission.put("deliveryMethod", "磅重");
                }else {
                    measureCommission.put("deliveryMethod", "理重");
                }
            }
            //查询已经计量物资
            //Integer materialNum = tmstruckMeasureCommissionMapper.getAlreadyWeightMaterialNum(DataChange.dataToBigDecimal(map.get("orderId")));
            //查询有净重的条数，如果有净重的条数为0，则为false，否则发true
            Integer materialNum = tmstruckMeasureCommissionMapper.getNoNetWeight(DataChange.dataToBigDecimal(map.get("orderId")));
            if(materialNum == 0){
                measureCommission.put("IsAssembly", false);
            }else {
                measureCommission.put("IsAssembly", true);
            }
        }
        try {
            addMeasureCommission(map);
        } catch (Exception e) {
            e.printStackTrace();
        }
        measureCommission.put("orderType",1);
        System.out.println(measureCommission);
        return sendMesToMeasure(measureCommission);
    }

    /**
     * 零星退货-钢材进厂
     */
    /**
     * 发送退货委托:1-老厂区钢材
     * @param map
     * @return
     */
    public int addSporadicOddMeasureCommission(Map<String, Object> map){
        Map<String, Object> measureCommission = null;
        if(map.get("firstMC") != null){ //进厂发送空委托
            measureCommission = new HashMap<>();
            measureCommission.put("flowTo","销售退货");
            measureCommission.put("carNum", map.get("capacityNumber"));
            measureCommission.put("transportNum", map.get("orderNumber"));
        }else {
           //发送零星委托
            measureCommission = tmstruckMeasureCommissionMapper.sproadicMeasure(map);
            measureCommission.put("isDel", false);
            measureCommission.put("isInsert", true);
            measureCommission.put("isRelationEAS", false);
            measureCommission.put("flowTo", "销售退货");
            measureCommission.put("numberOfFurnaces",null);
            String materiaName = (String) measureCommission.get("materiaName");
            if(materiaName.contains("盘螺")){ //如果名字中包含盘螺则为磅重交货
                measureCommission.put("deliveryMethod", "磅重");
            }else {
                measureCommission.put("deliveryMethod", "理重");
            }
            //查询已经计量物资
            //Integer materialNum = tmstruckMeasureCommissionMapper.getAlreadyWeightMaterialNum(DataChange.dataToBigDecimal(map.get("orderId")));
            //查询有净重的条数，如果有净重的条数为0，则为false，否则发true
            Integer materialNum = tmstruckMeasureCommissionMapper.getNoNetWeight(DataChange.dataToBigDecimal(map.get("orderId")));
            if(materialNum == 0){
                measureCommission.put("IsAssembly", false);
            }else {
                measureCommission.put("IsAssembly", true);
            }
        }
        System.out.println(measureCommission);
        return sendMesToMeasure(measureCommission);
    }



    /**
     * 添加零星物资计量委托
     * @param map
     * @return
     */
    public int addLXMeasureCommission(Map<String, Object> map){
        int orderType = DataChange.dataToBigDecimal(map.get("orderTypee")).intValue();
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        int i = 0;
        if(orderType == 12) {
            //查询进厂收货单位
            Integer receiveId = tmstruckMeasureCommissionMapper.getLxRealReceiveIdByOrderId(orderId);
            if(receiveId == 1){
                //给达钢发送委托
                i = sendMeasureCommissionMes(map);
            }else if(receiveId == 2){
                //给达兴发送委托
                i = sendDXMeasureCommissionMes(map);
            }
        }else if(orderType == 13){
            Integer sendId = tmstruckMeasureCommissionMapper.getLxRealSendUnitIdByOrderId(orderId);
            if(sendId == 1){
                i = sendMeasureCommissionMes(map);
            }else if(sendId == 2){
                i = sendDXMeasureCommissionMes(map);
            }

        }else if(orderType == 15){
            //进厂,收货单位
            //如果是15类型的订单寻找订单父级发货单位  (现只有进厂)
            Integer receiveId = tmstruckMeasureCommissionMapper.getLxRealReceiveIdByOrderId(orderId);
            if(receiveId == 1){
                i = sendMeasureCommissionMes(map);
            }else if (receiveId == 2){
                i = sendDXMeasureCommissionMes(map);
            }
        }else if(orderType == 16){
            //出厂,发货单位
            Integer sendUnitId = tmstruckMeasureCommissionMapper.getLxRealSendUnitIdByOrderId(orderId);
            if(sendUnitId == 1){
                i = sendMeasureCommissionMes(map);
            }else if (sendUnitId == 2){
                i = sendDXMeasureCommissionMes(map);
            }
        }
        else if(orderType == 20) {//内转零星进厂
            //查询还未计量实绩
            Integer noNetWeightResult = rulesMapper.getNoNetWeightResult(orderId);
            if(noNetWeightResult != 2){
                i = sendMeasureCommissionMes(map);
            }else {
                i = sendDXMeasureCommissionMes(map);//如果有两条没有净重的实绩则需要给达兴发委托  否则给达钢发委托
            }
        }
        return i;
    }


    /**
     * 新增计毛、计皮委托
     * @return
     */
    @Override
    public int addMeasureCommission(Map<String, Object> map) {
        TmstruckMeasureCommission tmstruckMeasureCommission = new TmstruckMeasureCommission();
        //生成主键Id
        tmstruckMeasureCommission.setCommssionId(tmstruckMeasureCommissionMapper.selectMaxId());
        //添加物资ID
        tmstruckMeasureCommission.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        //添加汽车衡Id
        if(map.get("grossPlaceId") != null){
            tmstruckMeasureCommission.setCalculateId(DataChange.dataToBigDecimal(map.get("grossPlaceId")));
        }
        if(map.get("tarePlaceId") != null){
            tmstruckMeasureCommission.setCalculateId(DataChange.dataToBigDecimal(map.get("tarePlaceId")));
        }
        //添加实绩总表Id
        tmstruckMeasureCommission.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
        tmstruckMeasureCommission.setInsertTime(new Date());
        tmstruckMeasureCommission.setInsertUsername("admin");
        return tmstruckMeasureCommissionMapper.insertSelective(tmstruckMeasureCommission);
    }


    /**
     * 查询计量委托并向计量系统发送数据  调用他们接口 (老厂区）
     * 1：销售订单；2：焦炭发运计划；3：水渣发运计划；4：内转到异地库；5：采购辅料订单；6：采购老区燃料订单；
     * 7：采购新区燃料订单；8：采购进口矿(万州-厂内)；9：采购内转(达州-厂内)；10：采购内转(老区-厂内)； 11：厂内内转
     * @param map orderTypee 订单类型  type 计皮0还是计毛1类型  orderId  订单ID
     */
    public int sendMeasureCommissionMes(Map<String, Object> map){
        Map<String, Object> measureCommission = null;
        //查询计量委托
        int orderType = DataChange.dataToBigDecimal(map.get("orderTypee")).intValue();
        switch (orderType){
            case 1:
                break;
            case 2:
                measureCommission=tmstruckMeasureCommissionMapper.selectXsMeasuresion(map);
                if(measureCommission == null){
                    return 0;
                }
                measureCommission.put("isRelationEAS",true);
                measureCommission.put("flowTo","出厂");
                measureCommission.put("isDel", false);
                measureCommission.put("isInsert", true);
                measureCommission.put("IsAssembly", false);
                measureCommission.put("deliveryMethod", "磅重");
                measureCommission.put("packagesNum", 0);
                if(map.get("isDG") != null){
                    measureCommission.put("factory", "dg");
                }
                break;
            case 5:
            case 6:
            case 8:
            case 17:
                measureCommission =  tmstruckMeasureCommissionMapper.purchaseMeasure(map);
                if(measureCommission == null){
                    return 0;
                }
                measureCommission.put("isRelationEAS", true);
                measureCommission.put("flowTo", "进厂");
                measureCommission.put("isDel", false);
                measureCommission.put("isInsert", true);
                measureCommission.put("IsAssembly", false);
                measureCommission.put("deliveryMethod", "磅重");
                measureCommission.put("packagesNum", 0);
                break;
            case 11:
                //纯内转发送计量委托
                measureCommission = tmstruckMeasureCommissionMapper.purchaseNzMeasure(map);
                if(measureCommission == null){
                    return 0;
                }
                if(map.get("deletedCommission") != null){
                    measureCommission.put("isDel", true);
                    measureCommission.put("isInsert", false);
                }else {
                    measureCommission.put("isDel", false);
                    measureCommission.put("isInsert", true);
                }
                measureCommission.put("isRelationEAS", false);
                measureCommission.put("flowTo", "中转");
                measureCommission.put("IsAssembly", false);
                measureCommission.put("deliveryMethod", "磅重");
                measureCommission.put("packagesNum", 0);
                System.out.println(measureCommission);
                break;
            case 12:
            case 13:     //零星进厂、出厂
            case 14:
            case 19:
                measureCommission = tmstruckMeasureCommissionMapper.sproadicMeasure(map);
                if(measureCommission == null){
                    return 0;
                }
                measureCommission.put("steelyardNum", "null");
                measureCommission.put("demo", "无");
                measureCommission.put("isRelationEAS",false);
                if(orderType == 12){
                    measureCommission.put("flowTo","进厂");
                }else if(orderType == 13){
                    measureCommission.put("flowTo","出厂");
                }else if(orderType == 14){
                    //查询还有几次未计量实绩
                    BigDecimal resultTotalId = DataChange.dataToBigDecimal(map.get("resultTotalId"));
                    Integer count = tmstruckMeasureCommissionMapper.selectNoNetWeightResult(resultTotalId);
                    if(count > 1){ //第一次进厂
                        measureCommission.put("materiaName", measureCommission.get("materiaName") + "(出)");
                    }else { //第二次进厂
                        measureCommission.put("materiaName", measureCommission.get("materiaName") + "(入)");
                    }
                    measureCommission.put("flowTo","中转");
                }else{
                    measureCommission.put("flowTo","退货");
                }
                measureCommission.put("isDel", false);
                measureCommission.put("isInsert", true);
                measureCommission.put("deliveryMethod", "磅重");
                measureCommission.put("packagesNum", 0);
                break;
            case 20://采购内转委托总厂区
            case 15:
            case 16:
            case 23:
                measureCommission=tmstruckMeasureCommissionMapper.purchaseXqCgNzMeasure(map);
                if(measureCommission == null){
                    return 0;
                }
                if(orderType == 16){
                    measureCommission.put("factory","dg");
                }
                measureCommission.put("isRelationEAS",false);
                measureCommission.put("flowTo","进厂");
                measureCommission.put("isDel",false);
                measureCommission.put("isInsert",true);
                measureCommission.put("deliveryMethod", "磅重");
                measureCommission.put("packagesNum", 0);
        }
        if(measureCommission != null){
            map.put("materialId", measureCommission.get("materialId"));
        }
        addMeasureCommission(map); // 添加计量委托
        /*访问接口发送数据*/
        return sendMesToMeasure(measureCommission);
//        return 1;

    }


    /**
     * 发送计量委托给达兴能源 计量
     * @param map
     * @return
     */
    public int sendDXMeasureCommissionMes(Map<String, Object> map){
        Map<String, Object> measureCommission = null;
        //查询计量委托
        Integer orderType = DataChange.dataToBigDecimal(map.get("orderTypee")).intValue();
        switch (orderType){
            case 1:
            case 2:
            case 3:
                measureCommission = tmstruckMeasureCommissionMapper.saleDXMeasure(map); //订单ID  物资ID  计量实绩ID
                if(measureCommission == null)
                    return 0;
                measureCommission.put("deliveryType", "计重");
                measureCommission.put("billType", "1");
                measureCommission.put("crname", "admin");
                measureCommission.put("ended", "0");
                break;
            case 7:
            case 18:
                measureCommission =  tmstruckMeasureCommissionMapper.purchaseDXMeasure(map);
                if(measureCommission == null)
                    return 0;
                measureCommission.put("deliveryType", "计重");
                measureCommission.put("billType", "0");
                measureCommission.put("crname", "admin");
                measureCommission.put("ended", "0");
                break;
            case 10:
            case 20:
            case 24:
                //新区采购内转
                measureCommission = tmstruckMeasureCommissionMapper.purchaseXqCgNzDXMeasure(map);
                if(measureCommission == null)
                    return 0;
                measureCommission.put("deliveryType", "计重");
                measureCommission.put("crname", "admin");
                //判断还没有净重的计量实绩
                Integer weightResultCount = tmstruckMeasureCommissionMapper.selectNoNetWeightResult(DataChange.dataToBigDecimal(map.get("resultTotalId")));
                if(weightResultCount == 1){
                    //如果只剩一条未计量的数据则需要走金蝶(进厂卸货)
                    measureCommission.put("orderSource", measureCommission.get("chooseOrderSource"));
                    measureCommission.put("billType", "0");
                    measureCommission.put("item", measureCommission.get("item") + ",1");
                    measureCommission.put("goodsName",measureCommission.get("goodsName") + "null");
                }else {
                    measureCommission.put("orderSource", "0");
                    measureCommission.put("billType", "2");
                }
                measureCommission.put("ended", "0");
                break;
            case 11:
                   measureCommission = tmstruckMeasureCommissionMapper.inwardMeasure(map);
                   if(measureCommission == null){
                    return 0;
                   }
                   measureCommission.put("regionName", "无法确定汽车衡"); //无法确定汽车衡
                   measureCommission.put("deliveryType", "计重");
                   measureCommission.put("billType", "2");
                   measureCommission.put("planQuantity", "0");
                   measureCommission.put("crname", "admin");
                   measureCommission.put("orderSource", "0");
                   measureCommission.put("ended", "0");
                   System.out.println(measureCommission);
                   break;
            case 12: // 零星订单
            case 13:
            case 14:
                measureCommission = tmstruckMeasureCommissionMapper.sporadicDXMeasure(map);
                if(measureCommission == null)
                    return 0;
                if(orderType == 14){
                    Integer count = tmstruckMeasureCommissionMapper.selectNoNetWeightResult(DataChange.dataToBigDecimal(map.get("resultTotalId")));
                    if(count > 1){ //第一次进厂
                        measureCommission.put("goodsName", measureCommission.get("goodsName") + "(出)");
                    }else {//第二次进厂
                        measureCommission.put("item", measureCommission.get("item") + ",1");
                        measureCommission.put("goodsName", measureCommission.get("goodsName") + "(入)");
                    }
                }
                measureCommission.put("regionName", "无法确定汽车衡"); //无法确定汽车衡
                measureCommission.put("deliveryType", "计重");
                measureCommission.put("billType", "2");
                measureCommission.put("planQuantity", "0");
                measureCommission.put("crname", "admin");
                measureCommission.put("orderSource", "0");
                measureCommission.put("ended", "0");
                break;
            
        }
        if(measureCommission != null)
            map.put("materialId", measureCommission.get("item"));
        addMeasureCommission(map); // 添加计量委托
//        System.out.println(measureCommission);
//        return 1;
        /*访问接口发送数据*/
        return sendMesToDXMeasure(measureCommission);
    }

    /**
     *
     * 访问老厂区计量接口方法
     * @param map
     * @return
     */
    public int sendMesToMeasure(Map<String, Object> map){
        List<Map<String, Object>> sendMap = new ArrayList<>();
        sendMap.add(map);
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("data", sendMap);
        String jsonData = null;
        try {
            jsonData = HTTPRequestUtils.send(daGangUrl, jsonObject, "utf-8");
        } catch (IOException e) {
            e.printStackTrace();
        }
        //写入文件
        try{
            new Thread( new Runnable() {
                public void run(){
                    try {
                        newFileTool.newFile(daGangUrl+"："+jsonObject.toJSONString(),"委托发送报文");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }catch (Exception e) {
            e.printStackTrace();
        }
        if(!"null".equals(jsonData)){
            System.out.println(jsonData);
            HashMap hashMap = JSON.parseObject(jsonData, HashMap.class);
            boolean success = (boolean) hashMap.get("success");
            System.out.println(hashMap.get("msg"));
            if(success){
                try {
                    if(map.get("orderType") != null && (DataChange.dataToBigDecimal(map.get("orderType")).intValue() == 1 || DataChange.dataToBigDecimal(map.get("orderType")).intValue() == 4)) {
                        Object weight = hashMap.get("weight");
                        Object weightDateTime = hashMap.get("weightDateTime");
                        if(weight != null && weightDateTime != null){
                            List<Map<String,Object>> mapListWeight = new ArrayList<>();
                            Map<String, Object> weightMap = new HashMap<>();
                            weightMap.put("orderNumber",map.get("transportNum"));
                            weightMap.put("resultTareCalculateNumber","一号汽车衡");
                            weightMap.put("resultTareWeight",weight);
                            weightMap.put("resultTareWeightTime",weightDateTime);
                            weightMap.put("carNo",map.get("carNum"));
                            weightMap.put("flag","GCXS");
                            weightMap.put("needCheckToKD",1);
                            weightMap.put("resultCrossCalculateNumber","");
                            weightMap.put("resultCrossWeight","");
                            weightMap.put("resultNetWeight","");
                            weightMap.put("resultCrossWeightTime","");
                            weightMap.put("resultNetWeightTime","");
                            weightMap.put("resultPoundNo","");
                            weightMap.put("materialId","");
                            weightMap.put("wuliuRemark","委托带出皮重");
                            mapListWeight.add(weightMap);
                            joinFeign.receiveTmsTruckWeightResultByDaGang(mapListWeight);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return 1;
            }else{
                System.out.println("委托发送失败：" + jsonData);
            }
        }else{
            System.out.println("委托发送失败：" + jsonData);
        }
        return 0;
    }




//    /**
//     *
//     * 访问老厂区计量接口方法
//     * @param ysdd
//     * @param  loadingPace
//     * @return
//     */
//    public int sendUpdateLoadPlaceMeasure(String ysdd,String loadingPace){
////        List<Map<String, Object>> sendMap = new ArrayList<>();
////        sendMap.add(map);
////        JSONObject jsonObject = new JSONObject();
////        jsonObject.put("data", sendMap);
//        String jsonData = null;
//        try {
////            jsonData = HTTPRequestUtils.send(dagangUrlForLoad, jsonObject, "utf-8");
//
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//        if(!"null".equals(jsonData)){
//            System.out.println(jsonData);
//            HashMap hashMap = JSON.parseObject(jsonData, HashMap.class);
//            boolean success = (boolean) hashMap.get("success");
//            System.out.println(hashMap.get("msg"));
//            if(success){
//                return 1;
//            }
//        }else{
//            System.out.println("委托发送失败：" + jsonData);
//        }
//        return 0;
//    }


    /**
     * 访问新厂区达兴能源计量接口方法
     * @param map
     * @return
     */
    public int sendMesToDXMeasure(Map<String, Object> map){
        JSONObject jsonObject = new JSONObject();
        jsonObject.putAll(map);
        String jsonData = null;
        try {
            jsonData = HTTPRequestUtils.send(daXingUrl, jsonObject, "utf-8");
        } catch (IOException e) {
            e.printStackTrace();
            return -99;
        }
        //写入文件
        try{
            new Thread( new Runnable() {
                public void run(){
                    try {
                        newFileTool.newFile(daXingUrl+"："+jsonObject.toJSONString(),"委托发送报文");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }catch (Exception e) {
            e.printStackTrace();
        }
        if(!"null".equals(jsonData)){
            System.out.println(jsonData);
            HashMap hashMap = JSON.parseObject(jsonData, HashMap.class);
            String code = (String) hashMap.get("code");
            System.out.println(hashMap.get("msg"));
            if("0".equals(code)){
                return 1;
            }
        }
        return 0;
    }

    //发送计量委托
    @Override
    @Transactional
    public int sendMeasureCommssion(Map<String, Object> map){
        if(map.get("asd") == null){ //预防司机没更新APP点击发送委托
            return 5;
        }
        int i=0;
        //获取订单类型
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        if(map.get("materialId") == null){
            map.putAll(utilsMapper.getOrderMesByOrderId(orderId));
        }
        BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderTypee"));
        //根据运输订单id查找运输订单号
        switch (orderType.intValue()){
            case 1: //查询未装车实绩
                List<Map<String, Object>> mapList = rulesService.judgeLastMaterial(DataChange.dataToBigDecimal(map.get("orderId")));
                map.put("materialId", mapList.get(0).get("materialId"));
                i+=addXSMeasureCommission(map);
            case 2:
            case 3: //通过物资ID查询订单ID（针对单拼）
                List<Integer> materialIdList = utilsMapper.getMaterialIdByOrderId(orderId);
                map.put("materialId", materialIdList.get(0));
                i+=addXSMeasureCommission(map);
                break;
            case 12:
            case 13:
                //如果是自动发送委托 查询最近进厂的门岗
                if(map.get("materialId") != null){
                    Integer gatepostId = utilsMapper.getLastGatepostId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
                    if(gatepostId == null){
                        map.put("gatepostId", 1); //一般零星多拼只存在于老厂
                    }else {
                        map.put("gatepostId", gatepostId);
                    }
                }else {
                    //手动发送委托
                    Integer materialId = utilsMapper.getNextMaterialId(orderId);
                    if(materialId == null) {
                        return 0;
                    }else {
                        map.put("materialId", materialId);
                        map.put("gatepostId", 1);
                    }
                }
                i+=sendMeasureCommissionByGatepost(map);
                break;
            case 14:
                break;
            case 20:
                //发送计量委托(查询物资顺序第一个装卸货的物资)
                //拿到需要计量的物资ID
                Integer materialId = utilsMapper.getLxFirstMaterialId(DataChange.dataToBigDecimal(map.get("orderId")));
                map.put("materialId", materialId);
                i+=addLXMeasureCommission(map);
                break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 10:
            case 11:
            case 17:
            case 18:
            case 15:
            case 16:
                i+=addMaoMeasureCommission(map);
        }
        return i;
    }

    /* 手动发送委托稽核代码
   if(map.get("deletedCommission") != null){
            //在计量实绩中查询是否有计量数据，如果有则代表已经计量过了不允许撤回
            List<Integer> commission = tmstruckMeasureCommissionMapper.checkoutWeightCommission(map);
            if(commission.size() != 0){
                return 2;
            }
        }else {
            //查询最后发送委托的物资
            Integer alreadySentMaterialId = tmstruckMeasureCommissionMapper.getAlreadySentMaterialId(map);
            if(alreadySentMaterialId != null){
                map.put("checkMaterialId", alreadySentMaterialId);
                //判断当前订单是否有已经发送过委托 但是还未计量完成的物资
                Map<String, Object> checkoutMesMap = tmstruckMeasureCommissionMapper.checkoutWeightCommission2(map);
                if(checkoutMesMap == null){ // 为空则是这个物资还没有计量
                    return 4;
                }else {
                    //如果不为空, 判断是否有净重 如果有净重则是计量完成 否则 没有
                    if(checkoutMesMap.get("resultNetWeight") == null){
                        return 4;
                    }
                }
            }
        }

    if(i == 1 && orderType.intValue() == 11){
        //发送委托成功后修改订单物资表
        tmstruckMeasureCommissionMapper.updateOmsTruckMaterial(map);
        if(map.get("deletedCommission") != null){
            i = 3;
        }
    }
     **/


    /**
     * 发送留皮委托
     * @Author TXF
     * @Date 2022/3/8 14:35
     * @param capacityNumber
     * @return
     **/
    @Override
    synchronized public Map<String, Object> sendLiuPiMeasureCommission(String capacityNumber) throws InterruptedException {
        Map<String, Object> map = new HashMap<>();
        String num = "WZGTZDLP" + System.currentTimeMillis();
        map.put("carNumber", capacityNumber);
        map.put("purchOrder", num);
        //通过车牌号查询上一次委托发送数据
        Map<String, Object> mesMap = tmstruckTareReturnResultMapper.getMesByCapacityNum(capacityNumber);
        if(mesMap != null){
            Date lastDate = (Date) mesMap.get("returnTime");
            if((System.currentTimeMillis() - lastDate.getTime()) < 3600000){ //小于一小时重复点击 返回上一次发送的委托号
                map.put("status", "1");
                map.put("purchOrder", mesMap.get("returnNum"));
            }else {
                //进行委托发送正常流程
                dataDealWith(map, mesMap);
            }
        }else {
            dataDealWith(map, null);
        }
        Thread.sleep(1); //避免网络问题多设备同时请求导致高并发 导致委托号相同（同一时间点）
        return map;
    }

    public void dataDealWith(Map<String, Object> map, Map<String, Object> mesMap){
        String carNumber = (String) map.get("carNumber");
        //委托发送正常流程
        String isOK = sendMesToMeasure2(map);
        if("ok".equals(isOK)){
            //如果委托正常发送，则保存数据并返回
            map.put("status", "1");
            TmstruckTareReturnResult tmstruckTareReturnResult = new TmstruckTareReturnResult();
            tmstruckTareReturnResult.setId(tmstruckTareReturnResultMapper.selectMaxId());
            tmstruckTareReturnResult.setReturnTime(new Date());
            tmstruckTareReturnResult.setReturnNum((String) map.get("purchOrder"));
            tmstruckTareReturnResult.setInsertTime(new Date());
            tmstruckTareReturnResult.setInsertUsername(carNumber);
            if(mesMap == null){
                //通过车牌号查询运力ID
                tmstruckTareReturnResult.setCapacityId(utilsMapper.getCapacityIdByNum(carNumber));
            }else {
                tmstruckTareReturnResult.setCapacityId(DataChange.dataToBigDecimal(mesMap.get("capacityId")));
            }
            tmstruckTareReturnResultMapper.insertSelective(tmstruckTareReturnResult);
        }else {
            map.put("status", "0");
            map.put("mes", isOK);
        }
    }

    /**
     * 上面方法儿子方法
     * @Author TXF
     * @Date 2022/3/8 16:19
     * @param map
     * @return
     **/
    public String sendMesToMeasure2(Map<String, Object> map){
        JSONObject jsonObject = new JSONObject(map);
        String jsonData = null;
        try {
            jsonData = HTTPRequestUtils.send(liuPiUrl, jsonObject, "utf-8");
        } catch (IOException e) {
            e.printStackTrace();
        }
        //写入文件
        try{
            new Thread( new Runnable() {
                public void run(){
                    try {
                        newFileTool.newFile(liuPiUrl+"："+jsonObject.toJSONString(),"委托发送报文");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }catch (Exception e) {
            e.printStackTrace();
        }
        if(!"null".equals(jsonData)){
            System.out.println(jsonData);
            HashMap hashMap = JSON.parseObject(jsonData, HashMap.class);
            boolean success = (boolean) hashMap.get("success");
            System.out.println(hashMap.get("msg"));
            if(success){
                return "ok";
            }else {
                return (String) hashMap.get("msg");
            }
        }else{
            System.out.println("委托发送失败：" + jsonData);
        }
        return "委托发送失败";
    }
}