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

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.OmsFeign;
import com.steerinfo.dil.feign.QmsFeign;
import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.TmstruckLeaveFactoryResult;
import com.steerinfo.dil.model.TmstruckLoadResult;
import com.steerinfo.dil.model.TmstruckReceiptResult;
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.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

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

    @Autowired
    private TmstruckWeightResultMapper tmstruckWeightResultMapper;


    @Autowired
    private UtilsServiceImpl utilsService;

    @Autowired
    private UtilsMapper utilsMapper;

    @Autowired
    private TmstruckLoadResultMapper tmstruckLoadResultMapper;


    @Autowired
    OmsFeign omsFeign;

    /**
     * 派单时新增计重实绩
     * 总实绩ID、计皮点、计毛点
     * @return
     */
    @Override
    public int addWeightResult(Map<String, Object> map) {
        TmstruckWeightResult tmstruckWeightResult = new TmstruckWeightResult();
        //生成最大主键ID
        tmstruckWeightResult.setWeightTaskResultId(tmstruckWeightResultMapper.selectMaxId());
        BigDecimal resultTotalId = DataChange.dataToBigDecimal(map.get("resultTotalId"));
        tmstruckWeightResult.setResultTotalId(resultTotalId);
        // 添加路段顺序号以及汽车衡
        List<Integer> calculateList = null;
        Integer calculateId = 0;
        Object grossSegmentSqe = map.get("grossSegmentSqe");
        //获取毛重汽车衡
        if(grossSegmentSqe != null){
            tmstruckWeightResult.setGrossSegmentSqe(DataChange.dataToBigDecimal(grossSegmentSqe));
            map.put("segmentSqe", grossSegmentSqe);
            calculateList = utilsMapper.getLineSegmentGateCalcId(map);
            //取汽车衡的Id
            calculateList.remove(null);
            calculateId = utilsService.randomGetValue(calculateList);
            tmstruckWeightResult.setResultGrossPlaceId(new BigDecimal(calculateId));
        }
        Object tareSegmentSqe = map.get("tareSegmentSqe");
        if(tareSegmentSqe != null){
            tmstruckWeightResult.setTareSegmentSqe(DataChange.dataToBigDecimal(tareSegmentSqe));
            map.put("segmentSqe", tareSegmentSqe);
            calculateList = utilsMapper.getLineSegmentGateCalcId(map);
            calculateList.remove(null);
            calculateId = utilsService.randomGetValue(calculateList);
            tmstruckWeightResult.setResultTarePlaceId(new BigDecimal(calculateId));
        }
        if(map.get("isdeduct") == null){
            //添加是否需要扣水扣杂
            //通过总实绩ID查询订单类型
            Integer orderType = tmstruckWeightResultMapper.getOrderTypeByTotalId(resultTotalId);
            if("67".contains(orderType.toString()) || orderType == 10){
                tmstruckWeightResult.setIsdeduct(new BigDecimal(1));
            }
        }else {
            tmstruckWeightResult.setIsdeduct(DataChange.dataToBigDecimal(map.get("isdeduct")));
        }
        return tmstruckWeightResultMapper.insertSelective(tmstruckWeightResult);
    }

    /**
     * 查询所有计毛实绩
     * @param map
     * @return
     */

    @Override
    public List<Map<String, Object>> getAllJiMaoResult(Map<String, Object> map) {
        Integer orderType = (Integer) map.get("orderTypee");
        if(orderType==2){
            String endDate = (String) map.get("endDate");
            if (endDate!=null){
                String s = endDate.replaceAll("00:00:00", "23:59:59");
                map.put("endDate",s);
            }
        }
        switch (orderType){
            case 1:
            case 2:
            case 3:
                return tmstruckWeightResultMapper.getXSAllJiMaoResult(map); // apiID:212
            case 4:
                return tmstruckWeightResultMapper.getSteelNzJiMaoResult(map); //apiId:264
            case 5:
            case 6:
            case 7:
            case 8:
            case 17:
            case 18:
                return tmstruckWeightResultMapper.getCGAllJiMaoResult(map); //apiId:102
            case 9:
                return tmstruckWeightResultMapper.getImportedDomesticNzJiMaoResult(map); // apiID:354
            case 10:
            case 20:
            case 15:
            case 16:
            case 23:
            case 24:
                return tmstruckWeightResultMapper.getImportedDomesticNzJiMao2Result(map); // apiID:354
            case 11:
                return tmstruckWeightResultMapper.getInFactoryJiLiangResult(map);       //apiId: 358
            case 12:
            case 13:
            case 14:
            case 19:
            case 100:
                return tmstruckWeightResultMapper.getSporadicSuppliesJiMiaoResult(map); //apiId:405

        }
        return null;
    }

    /**
     * 查询所有计皮实绩
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getAllJiPiResult(Map<String, Object> map) {
        Integer orderType = (Integer) map.get("orderTypee");
        if (orderType==2){
            String endDate = (String) map.get("endDate");
            if (endDate!=null){
                String s = endDate.replaceAll("00:00:00", "23:59:59");
                map.put("endDate",s);
            }
        }
        switch (orderType){
            case 1:
            case 2:
            case 3:
                return tmstruckWeightResultMapper.getXSAllJiPiResult(map); //apiId:211
            case 4:
                return tmstruckWeightResultMapper.getSteelNzJiPiResult(map); //apiId:262
            case 5:
            case 6:
            case 7:
            case 8:
            case 17:
            case 18:
                return tmstruckWeightResultMapper.getCGAllJiPiResult(map); // apiId: 104
            case 9:
                return tmstruckWeightResultMapper.getImportedDomesticNzJiPiResult(map);// apiId: 104
            case 10:
            case 20:
                return tmstruckWeightResultMapper.getImportedDomesticNzJiPi2Result(map);// apiId: 104
            case 11:
                break;
            case 12:
            case 13:
            case 14:
            case 19:
            case 100:
                return tmstruckWeightResultMapper.getFactorySkinSporadicWeight(map); //apiId=401
        }
        return null;
    }

    /**
     * 修改钢材计量实绩。
     * @param map orderId, oldMaterialMapList, newMaterialMapList
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public int updateSteelTruckWeightResult(Map<String, Object> map){
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        List<Map<String, Object>> newMaterialMapList = (List<Map<String, Object>>) map.get("newMaterialMapList");
        List<Map<String, Object>> oldMaterialMapList = (List<Map<String, Object>>) map.get("oldMaterialMapList");
        int newSize = newMaterialMapList.size();
        int oldSize = oldMaterialMapList.size();
        //这是新增的情况
        if(newSize != oldSize){
            Map<String, Object> mapOne = tmstruckWeightResultMapper.getOldWeightMes(orderId);
            BigDecimal resultTotalId = DataChange.dataToBigDecimal(mapOne.get("resultTotalId"));
            int maxGrossSqe = DataChange.dataToBigDecimal(mapOne.get("maxGrossSqe")).intValue();
            int outFactorySqe = 0;
            if(newSize > oldSize){
                //新增计量装货和修改出厂实绩
                outFactorySqe = insertSomeResult(newSize, oldSize, maxGrossSqe, resultTotalId);
            }else{
                outFactorySqe = deleteSomeResult(newSize, oldSize, maxGrossSqe, resultTotalId);
            }
            //修改出厂实绩路段顺序号
            TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
            tmstruckLeaveFactoryResult.setResultTotalId(resultTotalId);
            tmstruckLeaveFactoryResult.setSegmentSqe(new BigDecimal(outFactorySqe));
            tmstruckWeightResultMapper.updateLeaveFactorySqe(tmstruckLeaveFactoryResult);
        }
        //查询是否已经生成过出库实绩
        BigDecimal boundResultId = tmstruckWeightResultMapper.getOutBoundResult(orderId);
        if(boundResultId != null){//如果已经扫过出库，则需要对出库表物资子表进行操作
            Map<String, Object> changeMap = checkMaterial(oldMaterialMapList, newMaterialMapList);
            if(changeMap.get("delete")!= null){
                //如果有删除的记录，需要对出库实绩物资表中进行删除
                List<BigDecimal> delete = (List<BigDecimal>) changeMap.get("delete");
                for (BigDecimal deleteMaterialId : delete) {
                    tmstruckWeightResultMapper.deleteOutBoundResult(boundResultId, deleteMaterialId);
                }
            }
            if(changeMap.get("add")!= null){
                //如果有添加的记录，需要进行添加操作
                List<Map<String, Object>> add = (List<Map<String, Object>>) changeMap.get("add");
                for (Map<String, Object> addMap : add) {
                    addMap.put("boundResultId", boundResultId);
                    addMap.put("resultMaterialId",tmstruckWeightResultMapper.getOutBoundMaterialMaxId());
                    tmstruckWeightResultMapper.addOutBoundResult(addMap);
                }
            }
            if(changeMap.get("update") != null){
                //如果有修改的记录，需要进行修改操作
                List<Map<String, Object>> update = (List<Map<String, Object>>) changeMap.get("update");
                for (Map<String, Object> updateMap : update) {
                    updateMap.put("boundResultId", boundResultId);
                    tmstruckWeightResultMapper.updateOutBoundResult(updateMap);
                }
            }
        }
        return 0;
    }



    public int insertSomeResult(int newSize, int oldSize, int maxGrossSqe, BigDecimal resultTotalId){
        //根据新增的物资情况去新增计量实绩与装货实绩并修改最终出厂路段顺序号
        for (int i = 0; i < newSize - oldSize; i++) {
            TmstruckWeightResult tmstruckWeightResult = new TmstruckWeightResult();
            tmstruckWeightResult.setId(tmstruckWeightResultMapper.selectMaxId());
            tmstruckWeightResult.setResultTotalId(resultTotalId);
            tmstruckWeightResult.setTareSegmentSqe(new BigDecimal(++ maxGrossSqe));
            tmstruckWeightResult.setInsertTime(new Date());
            //新增装车实绩
            TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
            tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
            tmstruckLoadResult.setResultTotalId(resultTotalId);
            tmstruckLoadResult.setSegmentSqe(new BigDecimal(++ maxGrossSqe));
            tmstruckLoadResult.setInsertTime(new Date());
            tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
            //新增计量实绩 毛重顺序要卡在装车之后
            tmstruckWeightResult.setGrossSegmentSqe(new BigDecimal(++ maxGrossSqe));
            tmstruckWeightResultMapper.insertSelective(tmstruckWeightResult);
        }
        return ++ maxGrossSqe;
    }

    /**
     * 删除计量实绩及装车实绩
     * @param newSize
     * @param oldSize
     * @param maxGrossSqe
     * @param resultTotalId
     * @return
     */
    public int deleteSomeResult(int newSize, int oldSize, int maxGrossSqe, BigDecimal resultTotalId ){
        for (int i = 0; i < oldSize - newSize; i++) {
            tmstruckWeightResultMapper.deleteWeightResult(resultTotalId, maxGrossSqe--);//删除计量实绩
            //装车在计毛顺序之前
            tmstruckWeightResultMapper.deleteLoadResult(resultTotalId, maxGrossSqe--);//删除装车实绩
            //计量实绩中有两个路段顺序所以需要再次减1
            maxGrossSqe --;
        }
        //出厂需要 + 1
        return maxGrossSqe + 1;
    }

    /**
     * 遍历两次物资集合，找出哪些修改哪些新增哪些删除的物资
     * @param newMaterialMapList
     * @param oldMaterialMapList
     * @return
     */
    public Map<String, Object> checkMaterial(List<Map<String, Object>> oldMaterialMapList, List<Map<String, Object>> newMaterialMapList){
        Map<String, Object> returnMap = new HashMap<>();
        List<BigDecimal> delete = new ArrayList<>(); //存放删除的物资ID
        List<Map<String, Object>> add = new ArrayList<>(); //存放添加的物资ID及件数
        List<Map<String, Object>> update = new ArrayList<>(); // 存放修改的物资Id及件数
        //先遍历old中的物资 查找有没有相同的物资     找到修改和删除的物资
        for (Map<String, Object> map : oldMaterialMapList) {
            String materialId = String.valueOf(map.get("materialId"));//拿到key
            //通过这个key去新物资集合中获取是否包含这个key
            Map<String, Object> newMap = getNewMap(Integer.parseInt(materialId), newMaterialMapList);
            if(newMap == null){
                //如果在新物资中没有找到，则代表此物资已删除
                delete.add(DataChange.dataToBigDecimal(map.get("materialId")));
            }else{ //如果找到了，取出件数进行对比
                BigDecimal newNumber = DataChange.dataToBigDecimal(newMap.get("materialNumber")); //拿到新物资中的件数
                BigDecimal oldNumber = DataChange.dataToBigDecimal(map.get("materialNumber"));
                int i = newNumber.compareTo(oldNumber);
                if(i != 0){ //如果件数不相等，则需要进行修改，添加进修改list中
                    Map<String, Object> updateMap = new HashMap<>();
                    updateMap.put("materialId", materialId);
                    updateMap.put("materialNumber", newNumber);
                    update.add(updateMap);
                }
            }
        }
        //再次遍历new中的物资 查找 新增 的物资
        for (Map<String, Object> map : newMaterialMapList) {
            String materialId = String.valueOf(map.get("materialId"));
            Map<String, Object> oldMaps = getNewMap(Integer.parseInt(materialId), oldMaterialMapList);
            if(oldMaps == null){
                //如果在旧map中没有找到，则代表是新增的物资，将新增的物资存放到新增列表中
                add.add(map);
            }
        }
        if(add.size() != 0)    returnMap.put("add", add);
        if(delete.size() != 0) returnMap.put("delete", delete);
        if(update.size() != 0) returnMap.put("update", update);
        return returnMap;
    }

    /**
     * 遍历list查看里面的map是否包含这个值
     * @param key
     * @param mapList
     * @return
     */
    public Map<String, Object> getNewMap(int key, List<Map<String, Object>> mapList){
        for (Map<String, Object> map : mapList) {
            if(map.containsValue(key)){
                return map;
            }
        }
        return null;
    }

    /**
     * 更新计量实绩  计皮点  计毛点  皮重
     * @param map
     */
//    public int updateWeightResult(Map<String, Object> map){
//        TmstruckWeightResult tmstruckWeightResult = new TmstruckWeightResult();
//        //通过订单Id 查询路段顺序号为最小的 且没有净重的计量实绩ID
//        BigDecimal id = tmstruckWeightResultMapper.getWeightIdBySQEAndOrderId(map);
//        tmstruckWeightResult.setId(id);
//        if(map.get("tarePlaceId") != null){ //如果皮重汽车衡不为空 更新皮重汽车衡
//            tmstruckWeightResult.setResultTarePlaceId(DataChange.dataToBigDecimal(map.get("tarePlaceId")));
//        }
//        if(map.get("grossPlaceId") != null){//如果毛重汽车衡不为空 更新毛重汽车衡
//            tmstruckWeightResult.setResultGrossPlaceId(DataChange.dataToBigDecimal(map.get("grossPlaceId")));
//        }
//        if(map.get("resultTareWeight")!= null){ //如果皮重不为空 更新皮重
//            tmstruckWeightResult.setResultTareWeight(DataChange.dataToBigDecimal(map.get("resultTareWeight")));
//        }
//        return tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
//    }




    /**
     * 多拼计算计毛汽车衡
     * @param map
     */
//    public int calculateTruckCalculate(Map<String, Object> map, Integer resultTotalId){
//        //通过总实绩ID查询订单Id
//        Integer orderId = utilsService.getOrderIdByTotalId(resultTotalId);
//        //查询未装车的装车实绩
//        List<Map<String, Object>> list = rulesService.judgeLastMaterial(new BigDecimal(orderId));
//        Map<String, Object> mesMap = new HashMap<>(); //用于查询更新存放数据map
//        mesMap.put("orderId", orderId);
//        int i = 0;
//        if(list.size() == 0){
//            //如果是最后一拼则走出厂称 计算出厂称
//            mesMap.put("materialId", map.get("materialId"));
//            mesMap.put("nature", 1);
//            Integer calculate = rulesService.calculateWeighbridge(mesMap);
//            //更新汽车衡
//            mesMap.put("grossPlaceId", calculate);
//            i += updateWeightResult(mesMap);
//        }else {
//            //如果后面还有物资未装车 则走拼装秤 10号秤 (固定数据)
//            mesMap.put("materialId", map.get("materialId"));
//            mesMap.put("grossPlaceId", 10);
//            i += updateWeightResult(mesMap);
//        }
//        return i;
//    }

    /**
     * 单拼销售计算汽车衡
     * @return
     */
//    public int calculateTruckCalculateByOne(Map<String, Object> map, Integer type){
//        String orderNumber = (String) map.get("orderNumber");
//        //通过运输订单号查找物资ID、订单ID
//        Map<String, Object> oIdAndMidMap = tmstruckWeightResultMapper.getOrderIdAndMaterialIdByOrderNum(orderNumber);
//        //通过物资ID计算汽车衡
//        if(type == 1){
//            //1：进厂
//            oIdAndMidMap.put("nature", type); //1: 进厂秤
//            int calculateId = rulesService.calculateWeighbridge(oIdAndMidMap);
//            oIdAndMidMap.put("tarePlaceId", calculateId);
//
//        }else if(type == 2){
//            //2：出厂
//            oIdAndMidMap.put("nature", type); //2: 出厂称
//            int calculateId = rulesService.calculateWeighbridge(oIdAndMidMap);
//            oIdAndMidMap.put("grossPlaceId", calculateId);
//        }
//        return updateWeightResult(oIdAndMidMap);
//    }

}