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

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.mapper.TmstrainWeightResultMapper;
import com.steerinfo.dil.mapper.TmstruckReceiptResultMapper;
import com.steerinfo.dil.mapper.UtilsMapper;
import com.steerinfo.dil.model.TmstrainWeightResult;
import com.steerinfo.dil.model.TmstruckReceiptResult;
import com.steerinfo.dil.model.TmstruckWeightResult;
import com.steerinfo.dil.mapper.TmstruckWeightResultMapper;
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
    TmstruckReceiptResultMapper tmstruckReceiptResultMapper;

    @Autowired
    TmstrainWeightResultMapper tmstrainWeightResultMapper;


    //属于采购订单的订单类型（先计毛后计皮）
    final private List<Integer> judgeOrderTypeList = Arrays.asList(5, 6, 7, 8, 9, 12, 14,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") + "系统无此订单";
        }
        Integer orderType= DataChange.dataToBigDecimal(oneMap.get("orderType")).intValue();
//        if(orderType == 11){
//            TmstruckWeightResult tmstruckWeightResult = new TmstruckWeightResult();
//            tmstruckWeightResult.setResultPoundNo((String) map.get("resultPoundNo"));
//            tmstruckWeightResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
//            //首先查询这个订单号的这个物资ID是否有计量实绩
//            Map<String, Object> twoMap = tmstruckWeightResultMapper.selectResultIdByOrderNoAndMaterialId(map);
//            if(twoMap == null){//如果查出来为空，则进行新增操作
//                tmstruckWeightResult.setId(tmstruckWeightResultMapper.selectMaxId()); //新增主键
//                tmstruckWeightResult.setResultTotalId(DataChange.dataToBigDecimal(oneMap.get("totalId"))); //新增总实绩ID
//                try {
//                    addWeightResult(tmstruckWeightResult, map);
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
//            }
//        }
        //通过运输订单号查询计量实绩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);
        //推送数据
        utilsService.pushMesToWebsocket((String) stringObjectMap.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")));
        Integer 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){
            //查询还有几条没有净重的实绩
            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")); //毛重路段顺序
            }
            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){
        TmstruckReceiptResult tmstruckReceiptResult = new TmstruckReceiptResult();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //通过运输订单号查询总实绩ID
        BigDecimal resultTotalId = utilsMapper.getTotalIdByOrderNumber(orderNumber);
        tmstruckReceiptResult.setResultTotalId(resultTotalId);
        tmstruckReceiptResult.setStatus(new BigDecimal(1));
        tmstruckReceiptResult.setInsertUsername("admin");
        Date receiptTime;
        try {
            //取皮重时间为收货时间
            receiptTime = sdf.parse((String) tareWeightTime);
        } catch (ParseException e) {
            receiptTime = new Date();
            System.out.println(e.getMessage());
        }
        tmstruckReceiptResult.setInsertTime(receiptTime);
        int i = tmstruckReceiptResultMapper.updateByTotalResultId(tmstruckReceiptResult);
        if(i == 1) {
            System.out.println(orderNumber + "收货成功");
        }else {
            System.out.println(orderNumber + "收货失败");
        }
    }

    /**
     * @Author TXF
     * @Date 2022/2/18 9:55
     * @param tmstruckWeightResult
     * @param map
     * @return
     **/
    public void insertWeightResultBy11(TmstruckWeightResult tmstruckWeightResult, Map<String, Object> map){

    }

    /**
     * 添加火车计量实绩
     * @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 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);
    }

    /**
     * 上面方法的儿子方法
     * @Author TXF
     * @Date 2022/2/10 15:46
     * @param map
     * @param mesMap
     * @return
     **/
    public List<String> getMesList(Map<String, Object> map, Map<String, Object> mesMap){
        List<String> list = new ArrayList<>();
        //按照顺序添加
        list.add((String) map.get("resultPoundNo"));//磅单号
        list.add((String) mesMap.get("capacityNumber")); //车牌号
        list.add((String) map.get("resultCrossWeight")); //毛重
        list.add((String) map.get("resultCrossWeightTime")); //毛重时间
        list.add((String) map.get("resultTareWeight")); //皮重
        list.add((String) map.get("resultTareWeightTime")); //皮重时间
        list.add((String) map.get("resultNetWeight")); //净重
        list.add((String) mesMap.get("No")); //采购、销售订单号
        list.add((String) mesMap.get("easEntryId")); //采购、销售订单分录Id
        return list;
    }
}