DAL-DAZHOU-JOIN-API/src/main/java/com/steerinfo/dil/service/impl/TmstruckWeightResultServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.BmsTruckFeign;
import com.steerinfo.dil.feign.OmsFeign;
import com.steerinfo.dil.feign.TmstruckFeign;
import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.TmstrainWeightResult;
import com.steerinfo.dil.model.TmstruckReceiveResult;
import com.steerinfo.dil.model.TmstruckWeightResult;
import com.steerinfo.dil.service.ITmstruckWeightResultService;
import com.steerinfo.dil.util.DataChange;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.math.BigDecimal;

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

    @Autowired
    KDWebServiceServiceImpl KDWebServiceServiceImpl;

    @Autowired
    TmstruckWeightResultMapper tmstruckWeightResultMapper;

    @Autowired
    UtilsServiceImpl utilsService;

    @Autowired
    UtilsMapper utilsMapper;

    @Autowired
    OmsFeign omsFeign;

    @Autowired
    TmstruckFeign tmstruckFeign;

    @Autowired
    TmstruckReceiveResultMapper tmstruckReceiveResultMapper;

    @Autowired
    TmstrainWeightResultMapper tmstrainWeightResultMapper;


    //属于采购订单的订单类型（先计毛后计皮）
    final private List<Integer> judgeOrderTypeList = Arrays.asList(5, 6, 7, 8, 9, 12, 15, 17, 18);

    //老厂区需要给金蝶回传的数据订单类型
//    final private List<Integer> judgeToKDTypeList = Arrays.asList(6, 17);

    /**
     * 接收达钢计量实绩信息
     *      "orderNumber":"WYSDD2021091000000002",
     *      "resultTareCalculateNumber":"1号汽车衡",
     *      "resultCrossCalculateNumber":"1号汽车衡",
     *      "resultTareWeight":40.00,
     *      "resultCrossWeight":40.00,
     *      "resultNetWeight":0,
     *      "resultTareWeightTime":"2021-09-10 09:05:22",
     *      "resultCrossWeightTime":"2021-09-10 09:05:22",
     *      "resultPoundNo":"Bd123456780",
     *      "materialId":40
     * @param mapList
     * @return
     */
    @Override
    @Transactional
    public String receiveTmsTruckWeightResultByDaGang(List<Map<String, Object>> mapList){
        //遍历列表
        StringBuilder sb = new StringBuilder();
        for (Map<String, Object> map : mapList) {
            sb.append(" ");
            String resultTareCalculateNumber = (String) map.get("resultTareCalculateNumber");
            //如果计量衡名字中含有铁专线 则代表是轨道衡 走轨道衡路线
            if(resultTareCalculateNumber.contains("铁专线")){
                sb.append(addTrainWeightResult(map));
            }else {
                //走汽车衡
                map.put("needCheckToKD", "1"); //老厂区专属变量 用于区分新、老厂区 老厂区需要给金蝶传输数据
                sb.append(addTruckWeightResult(map));
            }
        }
        return sb.toString();
    }

    /*
     * 接收达兴计量实绩
     * @Author TXF
     * @Date 2022/2/9 14:57
     * @param mapList
     * @return
     **/
    @Transactional
    @Override
    public String receiveTmsTruckWeightResultByDaXing(List<Map<String, Object>> mapList) {
        StringBuilder sb = new StringBuilder();
        //遍历列表
        for (Map<String, Object> map : mapList) {
            sb.append(addTruckWeightResult(map));
        }
        return sb.toString();
    }

    /**
     * 添加汽车衡计量实绩
     * @param map
     * @return
     */
    public String addTruckWeightResult(Map<String, Object> map) {
        //首先通过运输订单号查询订单类型
        Map<String, Object> oneMap = utilsMapper.getOrderTypeByOrderNumber((String) map.get("orderNumber")); //用于判断订单类型
        if(oneMap == null){
            return map.get("orderNumber") + "系统无此订单";
        }
        int orderType= DataChange.dataToBigDecimal(oneMap.get("orderType")).intValue();
        if(orderType == 11 || orderType == 15 || orderType == 16){
            return insertWeightResultBy11(map, oneMap);
        }
        //通过运输订单号查询计量实绩Id
        Map<String, Object> stringObjectMap = tmstruckWeightResultMapper.selectWeightIdByOrderId(map);
        if(stringObjectMap == null){
            //通过传来的运输订单号 与 物资ID查询计重实绩ID
            stringObjectMap = tmstruckWeightResultMapper.selectTotalIdByOrderNo(map);
            if(stringObjectMap == null){
                return map.get("orderNumber") + "没有此订单信息或物资信息(" + map.get("materialId") + ")错误";
            }
        }
        map.putAll(stringObjectMap);
        TmstruckWeightResult tmstruckWeightResult = null;
        try {
            tmstruckWeightResult = generateWeightResult(map);
        } catch (Exception e) {
            return e.getMessage();
        }
        //如果含有这个变量则代表是老区订单需要判断是否回传给金蝶
        if(map.get("needCheckToKD") != null){
            if(map.get("resultNetWeight") != null){
                Object resultCrossWeightTime = map.get("resultCrossWeightTime");
                if ( orderType == 6 && resultCrossWeightTime != null && !"".equals(resultCrossWeightTime)) {
                    String resultNetWeight = String.valueOf(map.get("resultNetWeight")); //如果净重不为空  或者净重不为0
                    if (!"null".equals(resultNetWeight) && !"".equals(resultNetWeight) && !"0".equals(resultNetWeight)) {
                        //回传数据给金蝶方法
                        sendMesToKD(map, orderType);
                    }
                }
            }
        }
        tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
        //如果订单类型是零星订单 需要查询一下是否还有未计量物资
        if(orderType == 12 || orderType == 13){
            dealWithLxOrder(map, stringObjectMap);
        }
        //推送数据
        utilsService.pushMesToWebsocket((String) oneMap.get("capacityNumber"), "计量");
        return map.get("orderNumber") + "成功";
    }

    /**
     * 生成汽运计量实体类
     * @Author TXF
     * @Date 2022/1/5 16:41
     * @param map
     * @return
     **/
    public TmstruckWeightResult generateWeightResult(Map<String, Object> map) throws Exception {
        TmstruckWeightResult tmstruckWeightResult = new TmstruckWeightResult();
        tmstruckWeightResult.setId(DataChange.dataToBigDecimal(map.get("weightTaskResultId")));
        int orderType = DataChange.dataToBigDecimal(map.get("orderTypee")).intValue();
        //磅单号
        tmstruckWeightResult.setResultPoundNo((String) map.get("resultPoundNo"));
        String resultCrossWeightTime = (String) map.get("resultCrossWeightTime");
        tmstruckWeightResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        //如果是采购订单 先计毛再计皮
        if(judgeOrderTypeList.contains(orderType)){
            //如果毛重数据为空 则是第一次计量为毛重  此时第一次计量时间放皮重时间里面
            if(resultCrossWeightTime == null || resultCrossWeightTime.length() == 0){
                addMaoWeightResult(tmstruckWeightResult, map);
                //更新订单中路段顺序号
                map.put("segmentSqe", map.get("grossSegmentSqe")); //毛重路段顺序
                utilsService.updateOrderLineSequence(map);
            }else {
                addWeightResult(tmstruckWeightResult, map); //添加计量实绩数据
                //更新订单中路段顺序号
                map.put("segmentSqe", map.get("tareSegmentSqe")); //皮重路段顺序
                utilsService.updateOrderLineSequence(map);
                String orderNumber = (String) map.get("orderNumber");
                //如果是采购订单 计皮后自动完成签收
                //查询是此订单是否已签收过
                Integer check = utilsMapper.checkoutReceipt(orderNumber);
                if(check == null){
                    autoReceipt(orderNumber, map.get("resultTareWeightTime"));
                }
            }
        }
        else if(orderType == 10 || orderType == 20 || orderType == 14){
            //查询还有几条没有净重的实绩
            Integer resultNum = tmstruckWeightResultMapper.selectNoNetWeightResult((String) map.get("orderNumber"));
            if(resultNum == 2){
                //如果有两条则是走先计皮后计毛顺序
                addWeightResult(tmstruckWeightResult, map); //添加计量实绩数据 （正常添加对应皮毛重方法）
                if(resultCrossWeightTime == null || resultCrossWeightTime.length() == 0){
                    map.put("segmentSqe", map.get("tareSegmentSqe")); //皮重路段顺序
                }else{
                    map.put("segmentSqe", map.get("grossSegmentSqe")); //毛重路段顺序
                }
                utilsService.updateOrderLineSequence(map);
            }else{
                //只剩一条数据时则是计毛后计皮顺序
                //如果毛重数据为空 则是第一次计量为毛重  此时第一次计量时间放皮重时间里面
                if(resultCrossWeightTime == null || resultCrossWeightTime.length() == 0){
                    addMaoWeightResult(tmstruckWeightResult, map);
                    //更新订单中路段顺序号
                    map.put("segmentSqe", map.get("grossSegmentSqe")); //毛重路段顺序
                    utilsService.updateOrderLineSequence(map);
                }else {
                    addWeightResult(tmstruckWeightResult, map); //添加计量实绩数据
                    //更新订单中路段顺序号
                    map.put("segmentSqe", map.get("tareSegmentSqe")); //皮重路段顺序
                    utilsService.updateOrderLineSequence(map);
                    String orderNumber = (String) map.get("orderNumber");
                    //如果是采购订单 计皮后自动完成签收
                    //查询是此订单是否已签收过
                    Integer check = utilsMapper.checkoutReceipt(orderNumber);
                    if(check == null){
                        autoReceipt(orderNumber, map.get("resultTareWeightTime"));
                    }
                    if(orderType == 20){
                        //此订单类型比较特殊  如果订单类型为20则需要回传金蝶
                        sendMesToKD(map, orderType);
                    }
                }
            }
        }
        else{
            addWeightResult(tmstruckWeightResult, map); //添加计量实绩数据
            // 更新订单中路段顺序号,如果毛重时间为空则为计皮：也就是销售第一次计皮，反之有毛重时间则为计毛
            if(resultCrossWeightTime == null || resultCrossWeightTime.length() == 0){
                map.put("segmentSqe", map.get("tareSegmentSqe")); //皮重路段顺序
            }else{
                map.put("segmentSqe", map.get("grossSegmentSqe")); //毛重路段顺序
            }
            if(orderType == 1){
                //如果是钢材订单，获取下一个还没计量的实绩 将毛重数据作为下一个计量实绩的皮重
                //并且是第二次传入重量才执行
                List<Map<String, Object>> steelMapList = tmstruckWeightResultMapper.getNoNetWeightResultId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
                if(steelMapList.size() >= 2){ //当前更新还未提交所以如果是拼装需要查询两个出来 以第二个为准
                    Map<String, Object> steelMap = steelMapList.get(1);
                    Object resultNetWeight = map.get("resultNetWeight");
                    if(resultNetWeight  != null && !"".equals(resultNetWeight)){
                        updateSteelAssemble(map, steelMap); //更新下一拼实绩
                        map.put("segmentSqe", steelMap.get("tareSegmentSqe")); // 修改路段顺序号直接到下一皮重路段顺序
                    }
                }
            }
            utilsService.updateOrderLineSequence(map);
        }
        return tmstruckWeightResult;
    }

    /**
     * 添加第一次为毛重数据的计量实绩
     * @param tmstruckWeightResult
     * @param map
     */
    public void addMaoWeightResult(TmstruckWeightResult tmstruckWeightResult, Map<String, Object> map) throws Exception{
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //设置毛重时间
        String firstTime = (String) map.get("resultTareWeightTime");
        tmstruckWeightResult.setResultGrossWeightTime(sdf.parse(firstTime));
        //添加毛重汽车衡
        Integer tareId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("resultTareCalculateNumber"));
        if(tareId == null){
            throw new Exception("没有此计量衡：" + map.get("resultTareCalculateNumber"));
        }
        tmstruckWeightResult.setResultGrossPlaceId(new BigDecimal(tareId));
        //设置毛重
        BigDecimal resultTareWeight = DataChange.dataToBigDecimal(map.get("resultTareWeight"));
        tmstruckWeightResult.setResultGrossWeight(resultTareWeight);
        tmstruckWeightResult.setInsertTime(new Date());
        tmstruckWeightResult.setInsertUsername("admin");
    }

    /**
     * 添加计量实绩添加数据
     * @param tmstruckWeightResult
     * @param map
     * @return
     */
    public void addWeightResult(TmstruckWeightResult tmstruckWeightResult, Map<String, Object> map) throws Exception{
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //设置皮重汽车衡
        String resultTareCalculateNumber = (String) map.get("resultTareCalculateNumber");
        if(resultTareCalculateNumber != null){
            if(!"".equals(resultTareCalculateNumber)){
                Integer tareId = tmstruckWeightResultMapper.selectTruckCalculateId(resultTareCalculateNumber);
                if(tareId == null){
                    throw new Exception("没有此皮重汽车衡：" + map.get("resultTareCalculateNumber"));
                }
                tmstruckWeightResult.setResultTarePlaceId(new BigDecimal(tareId));
            }
        }
        //设置毛重汽车衡
        String resultCrossCalculateNumber = (String) map.get("resultCrossCalculateNumber");
        if(resultCrossCalculateNumber != null){
            if(!"".equals(resultCrossCalculateNumber)){
                Integer crossId = tmstruckWeightResultMapper.selectTruckCalculateId(resultCrossCalculateNumber);
                if(crossId == null){
                    throw new Exception("没有此毛重汽车衡：" + map.get("resultCrossCalculateNumber"));
                }
                tmstruckWeightResult.setResultGrossPlaceId(new BigDecimal(crossId));
            }
        }
        //毛重
        if(map.get("resultCrossWeight") != null){
            String resultCrossWeight = String.valueOf(map.get("resultCrossWeight"));
            if(!"".equals(resultCrossWeight))
                tmstruckWeightResult.setResultGrossWeight(DataChange.dataToBigDecimal(resultCrossWeight));
        }
        //皮重
        if(map.get("resultTareWeight") != null){
            String resultTareWeight = String.valueOf(map.get("resultTareWeight"));
            if(!"".equals(resultTareWeight))
            tmstruckWeightResult.setResultTareWeight(DataChange.dataToBigDecimal(resultTareWeight));
        }
        //净重
        if(map.get("resultNetWeight") != null){
            String resultNetWeight = String.valueOf(map.get("resultNetWeight"));
            if(!"".equals(resultNetWeight)){
                tmstruckWeightResult.setResultNetWeight(DataChange.dataToBigDecimal(resultNetWeight));
            }
        }
        //设置皮重时间
        if(map.get("resultTareWeightTime") != null){
            String resultTareWeightTime = (String) map.get("resultTareWeightTime");
            if(!"".equals(resultTareWeightTime)){
                tmstruckWeightResult.setResultTareWeightTime(sdf.parse(resultTareWeightTime));
            }
        }
        //设置毛重时间
        if(map.get("resultCrossWeightTime") != null){
            String resultGrossWeightTime = (String) map.get("resultCrossWeightTime");
            if(!"".equals(resultGrossWeightTime)){
                tmstruckWeightResult.setResultGrossWeightTime(sdf.parse(resultGrossWeightTime));
            }
        }
        tmstruckWeightResult.setUpdateTime(new Date());
        tmstruckWeightResult.setUpdateUsername("admin");
    }

    /**
     * 自动签收
     * @return
     */
    public void autoReceipt(String orderNumber, Object tareWeightTime){
        TmstruckReceiveResult tmstruckReceiveResult = new TmstruckReceiveResult();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //通过运输订单号查询总实绩ID
        BigDecimal resultTotalId = utilsMapper.getTotalIdByOrderNumber(orderNumber);
        tmstruckReceiveResult.setResultTotalId(resultTotalId);
        tmstruckReceiveResult.setStatus(new BigDecimal(1));
        tmstruckReceiveResult.setInsertUsername("admin");
        Date receiptTime;
        try {
            //取皮重时间为收货时间
            receiptTime = sdf.parse((String) tareWeightTime);
        } catch (ParseException e) {
            receiptTime = new Date();
            System.out.println(e.getMessage());
        }
        tmstruckReceiveResult.setInsertTime(receiptTime);
        tmstruckReceiveResult.setUpdateTime(receiptTime);
        int i = tmstruckReceiveResultMapper.updateByTotalResultId(tmstruckReceiveResult);
        if(i == 1) {
            System.out.println(orderNumber + "收货成功");
        }else {
            System.out.println(orderNumber + "收货失败");
        }
    }

    /**
     * 纯内转订单类型
     * @Author TXF
     * @Date 2022/2/18 9:55
     * @param map
     * @return
     **/
    public String insertWeightResultBy11(Map<String, Object> map, Map<String, Object> oneMap){
        TmstruckWeightResult tmstruckWeightResult = new TmstruckWeightResult();
        tmstruckWeightResult.setResultPoundNo((String) map.get("resultPoundNo"));
        tmstruckWeightResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        int sqe = DataChange.dataToBigDecimal(oneMap.get("Sqe")).intValue(); //获取订单路段顺序号
        sqe = sqe + 1;
        Object resultNetWeight = map.get("resultNetWeight");
        if(resultNetWeight != null && !"".equals((String) resultNetWeight)){
            //判断是否有卸货实绩已经卸过货 如果有卸货实绩 则结束订单
            Integer resultId = utilsMapper.getUnloadResultByTotalId(DataChange.dataToBigDecimal(oneMap.get("totalId")));
            if(resultId != null){
                int orderIds = DataChange.dataToBigDecimal(oneMap.get("orderIds")).intValue();
                omsFeign.closeInwardOrder(orderIds, sqe, (String) resultNetWeight);
            }else {
                Map<String, Object> threeMap = new HashMap<>(); //用于更新路段顺序号
                threeMap.put("orderLineSequence", sqe);
                threeMap.put("orderNumber", map.get("orderNumber"));
                utilsMapper.updateLineSeqByOrderIdOrNum2(threeMap); //更新订单路段顺序号
            }
        }else {
            Map<String, Object> threeMap = new HashMap<>(); //用于更新路段顺序号
            threeMap.put("orderLineSequence", sqe);
            threeMap.put("orderNumber", map.get("orderNumber"));
            utilsMapper.updateLineSeqByOrderIdOrNum2(threeMap); //更新订单路段顺序号
        }
        //首先查询这个订单号的这个物资ID是否有计量实绩
        Map<String, Object> twoMap = tmstruckWeightResultMapper.selectResultIdByOrderNoAndMaterialId(map); //判断这个物资是否已经计量过
        Object resultCrossWeightTime = map.get("resultCrossWeightTime");
        if(twoMap == null){//如果查出来为空，则进行新增操作
            tmstruckWeightResult.setId(tmstruckWeightResultMapper.selectMaxId()); //新增主键
            tmstruckWeightResult.setResultTotalId(DataChange.dataToBigDecimal(oneMap.get("totalId"))); //新增总实绩ID
            if(resultCrossWeightTime == null || "".equals(String.valueOf(resultCrossWeightTime))){//只有一条数据的情况
                tmstruckWeightResult.setTareSegmentSqe(new BigDecimal(sqe));
            }
            else {
                tmstruckWeightResult.setTareSegmentSqe(new BigDecimal(sqe));
                tmstruckWeightResult.setGrossSegmentSqe(new BigDecimal(sqe));
            }
            try {
                addWeightResult(tmstruckWeightResult, map);
            } catch (Exception e) {
                return e.getMessage();
            }
            tmstruckWeightResultMapper.insertSelective(tmstruckWeightResult); //新增计量实绩
        }else {
            //如果不为空则证明进行过至少一次计量
            tmstruckWeightResult.setId(DataChange.dataToBigDecimal(twoMap.get("weightTaskResultId")));
            //取出计量数据与传进来的毛皮数据进行对比
            BigDecimal inTareWeight = DataChange.dataToBigDecimal(twoMap.get("resultTareWeight"));
            if(inTareWeight.compareTo(DataChange.dataToBigDecimal(map.get("resultTareWeight"))) > 0){
                //如果取出来的皮重 大于 传进来的皮重   则需要调换路段顺序号
                tmstruckWeightResult.setGrossSegmentSqe(DataChange.dataToBigDecimal(twoMap.get("tareSegmentSqe")));
                tmstruckWeightResult.setTareSegmentSqe(new BigDecimal(sqe));
            }
            try {
                addWeightResult(tmstruckWeightResult, map);
            } catch (Exception e) {
                return e.getMessage();
            }
            tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
        }
        //推送数据
        utilsService.pushMesToWebsocket((String) oneMap.get("capacityNumber"), "计量");
        return map.get("orderNumber") + "成功";
    }

    /**
     * 处理零星订单多拼方法
     * @Author TXF
     * @Date 2022/3/15 18:37
     * @param map
     * @param stringObjectMap
     * @return
     **/
    public void dealWithLxOrder(Map<String, Object> map, Map<String, Object> stringObjectMap){
        if(map.get("resultNetWeight") != null){
            String resultNetWeight = String.valueOf(map.get("resultNetWeight"));
            if(! ("".equals(resultNetWeight) || "null".equals(resultNetWeight))){
                //查询是否还有物资如果为空则为已经计量完成
                Integer materialId = utilsMapper.getNextMaterialId(DataChange.dataToBigDecimal(stringObjectMap.get("orderId")));
                if(materialId != null){
                    stringObjectMap.put("materialId", materialId);
                    stringObjectMap.put("asd", 1);
                    Map<String, Object> returnMap = null;
                    try {
                        returnMap = tmstruckFeign.sendMeasureCommission(stringObjectMap);
                        String code = (String) returnMap.get("code");
                        if(!"200".equals(code)){
                            System.out.println(returnMap.get("data"));
                        }
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                }
            }
        }
    }




    /**
     * 修改拼装钢材物资
     * @param map
     * @param steelMap
     */
    public void updateSteelAssemble(Map<String, Object> map, Map<String, Object> steelMap) throws Exception{
        //更新实绩
        TmstruckWeightResult steelWightModel = new TmstruckWeightResult();
        steelWightModel.setId(DataChange.dataToBigDecimal(steelMap.get("weightTaskResultId"))); //查询出来的主键
        steelMap.put("resultTareCalculateNumber", map.get("resultCrossCalculateNumber")); //皮重汽车衡即为毛重汽车衡
        steelMap.put("resultTareWeight", map.get("resultCrossWeight"));//皮重即为毛重
        steelMap.put("resultTareWeightTime", map.get("resultCrossWeightTime"));//皮重时间即为毛重时间
        addWeightResult(steelWightModel, steelMap);
        tmstruckWeightResultMapper.updateByPrimaryKeySelective(steelWightModel);
    }




/*======================================================================================================================================================================
============================================================================火运火运火运==================================================================================
======================================================================================================================================================================*/


    /**
     * 添加火车计量实绩
     * @param map
     * @return
     */
    public String addTrainWeightResult(Map<String, Object> map){
        //通过采购订单号和车皮号 查询火运总实绩ID和物资ID
        Map<String, Object> totalIdAndMateMap = tmstrainWeightResultMapper.getResultIdByPurNoAndWagonNo(map);
        if(totalIdAndMateMap == null){
            return "采购订单号"+ map.get("purchaseOrderNo")+"或车皮信息"+ map.get("orderNumber")+"错误";
        }
        if(totalIdAndMateMap.get("resultTotalId") == null){
            return "采购订单号"+ map.get("purchaseOrderNo")+"或车皮信息"+ map.get("orderNumber")+"错误";
        }
        map.putAll(totalIdAndMateMap);
        TmstrainWeightResult tmstrainWeightResult = null;
        try {
            tmstrainWeightResult = generateTrainWeightResult(map);
        } catch (Exception e) {
            return e.getMessage(); //捕获异常信息
        }
        tmstrainWeightResultMapper.insertSelective(tmstrainWeightResult);
        return map.get("orderNumber") + "成功";
    }

    /**
     * 生成火运计量实体
     * @param map
     * @return
     */
    public TmstrainWeightResult generateTrainWeightResult(Map<String, Object> map) throws Exception {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        TmstrainWeightResult tmstrainWeightResult = new TmstrainWeightResult();
        tmstrainWeightResult.setResultId(tmstrainWeightResultMapper.selectMaxId());
        //磅单号
        tmstrainWeightResult.setResultPoundNo((String) map.get("resultPoundNo"));
        //添加火运总实绩ID
        tmstrainWeightResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
        //设置物资ID
        tmstrainWeightResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        //如果没有计毛时间 则是第一次计量
        String resultCrossWeightTime = (String) map.get("resultCrossWeightTime");
        if(resultCrossWeightTime == null || resultCrossWeightTime.length() == 0){
            //设置毛重时间
            String firstTime = (String) map.get("resultTareWeightTime");
            tmstrainWeightResult.setResultGrossWeightTime(sdf.parse(firstTime));
            //添加毛重轨道衡
            Integer tareId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("resultTareCalculateNumber"));
            if(tareId == null){
                throw new Exception("没有此计量衡：" + map.get("resultTareCalculateNumber"));
            }
            tmstrainWeightResult.setResultGrossPlaceId(new BigDecimal(tareId));
            //设置毛重
            BigDecimal resultTareWeight = DataChange.dataToBigDecimal(map.get("resultTareWeight"));
            tmstrainWeightResult.setResultGrossWeight(resultTareWeight);
            tmstrainWeightResult.setInsertTime(new Date());
            tmstrainWeightResult.setInsertUsername("admin");
        }else {
            //设置皮重轨道衡
            Integer tareId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("resultTareCalculateNumber"));
            if(tareId == null){
                throw new Exception("没有此计量衡：" + map.get("resultTareCalculateNumber"));
            }
            tmstrainWeightResult.setResultTarePlaceId(new BigDecimal(tareId));
            //设置毛重轨道衡
            Integer crossId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("resultCrossCalculateNumber"));
            if(crossId == null){
                throw new Exception("没有此计量衡：" + map.get("resultCrossCalculateNumber"));
            }
            tmstrainWeightResult.setResultGrossPlaceId(new BigDecimal(crossId));
            //毛重
            BigDecimal resultCrossWeight = DataChange.dataToBigDecimal(map.get("resultCrossWeight"));
            tmstrainWeightResult.setResultGrossWeight(resultCrossWeight);
            //皮重
            BigDecimal resultTareWeight = DataChange.dataToBigDecimal(map.get("resultTareWeight"));
            tmstrainWeightResult.setResultTareWeight(resultTareWeight);
            //净重
            tmstrainWeightResult.setResultNetWeight(DataChange.dataToBigDecimal(map.get("resultNetWeight")));
            //设置皮重时间
            String resultTareWeightTime = (String) map.get("resultTareWeightTime");
            tmstrainWeightResult.setResultTareWeightTime(sdf.parse(resultTareWeightTime));
            //设置毛重时间
            String resultGrossWeightTime = (String) map.get("resultCrossWeightTime");
            tmstrainWeightResult.setResultGrossWeightTime(sdf.parse(resultGrossWeightTime));
            tmstrainWeightResult.setUpdateTime(new Date());
            tmstrainWeightResult.setUpdateUsername("admin");
        }
        return tmstrainWeightResult;
    }


    /**
     * 回传数据给金蝶方法
     * @Author TXF
     * @Date 2022/2/9 15:46
     * @param
     * @return
     **/
    public void sendMesToKD(Map<String, Object> map, Integer orderType){
        String resultTareCalculateNumber = String.valueOf(map.get("resultTareCalculateNumber"));
        if(! resultTareCalculateNumber.contains("精煤")){ //如果不是精煤称的则不回传金蝶 或者没有皮重称
            return;
        }
        String orderNumber = (String) map.get("orderNumber");
        Map<String, Object> mesMap = new HashMap<>();
        switch (orderType){
            case 6:
                //查询订单信息
                mesMap = tmstruckWeightResultMapper.getPurOrderMesToKD(orderNumber);
                break;
            case 20:
                mesMap = tmstruckWeightResultMapper.get20PurOrderMesToKD(orderNumber);
        }
        //将map数据全放进mesMap中
        map.putAll(mesMap);
        //访问金蝶接口
        KDWebServiceServiceImpl.sendMesToKD(map);
    }


    /**
     * 计量联动删除方法
     * @param mapList
     * @return
     */
    public String linkageDeleteTransportOrder(List<Map<String, Object>> mapList) {
        //联动删除
        for (Map<String, Object> map : mapList) {
            String orderNumber = (String) map.get("orderNumber");
            tmstruckWeightResultMapper.linkageDeleteTransportOrder(orderNumber);
        }
        return "success";
    }
}