DAL-TMS-TRAIN-API/src/main/java/com/steerinfo/dil/service/impl/TmstrainLoadingResultServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.WmshBoundFeign;
import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.*;
import com.steerinfo.dil.service.ITmstrainLoadingResultService;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.framework.service.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.*;

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

    @Autowired
    private TmstrainLoadingResultMapper tmstrainLoadingResultMapper;

    @Autowired
    private TmstrainLoadingTempMapper tmstrainLoadingTempMapper;

    @Autowired
    private WmshBoundFeign wmshBoundFeign;

    @Autowired
    private TmstrainTruckTotalResultMapper tmstrainTruckTotalResultMapper;

    @Autowired
    private TmstrainTotalResultMapper tmstrainTotalResultMapper;

    @Autowired
    private TmstrainMeasureCommissionServiceImpl tmstrainMeasureCommissionService;
    @Autowired
    private TmstrainWeightResultMapper tmstrainWeightResultMapper;



    /**
     * 查看所有装车实绩
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getTmstrainWagonLoad(Map<String, Object> map) {
        BigDecimal resultType = DataChange.dataToBigDecimal(map.get("resultType"));
        switch (resultType.intValue()){
            case 1:
            case 2:
            case 3:
                List<Map<String, Object>> tmsWagonLoadInfo = tmstrainLoadingResultMapper.getTmsWagonLoadInfo(map);// apiId = 58  - 209
                for (Map<String, Object> obj : tmsWagonLoadInfo) {
                    Integer deleted = DataChange.dataToBigDecimal(obj.get("deleted")).intValue();
                    if(deleted == 0){
                        obj.put("isUnload", "已装车");
                    }else {
                        obj.put("isUnload", "已卸车");
                    }
                }
                return tmsWagonLoadInfo;
            case 4:
                return tmstrainLoadingResultMapper.selectLoadedForConverted(map); //apiId = 203
            case 10:
                //查询国产矿需要补录的装车实绩
                return tmstrainLoadingResultMapper.getNoPurOrderIdLoadResult(map); //apiId = 209
        }
        return null;
    }

    /**
     * 添加火运总实绩
     * @param loadingId
     * @return
     */
    public int addTotalResult(BigDecimal loadingId){
        TmstrainTotalResult tmstrainTotalResult = new TmstrainTotalResult();
        BigDecimal maxId = tmstrainTotalResultMapper.selectMaxId();
        tmstrainTotalResult.setId(maxId); //获取添加火运总实绩主键ID
        //生成火运单号
        tmstrainTotalResult.setTransportNum(DataChange.generateEightDigitsNumber("WTRAN", maxId.intValue()));
        //添加火运装车实绩ID
        tmstrainTotalResult.setLoadingId(loadingId);
        //新增计量实绩
        TmstrainWeightResult tmstrainWeightResult=new TmstrainWeightResult();
        tmstrainWeightResult.setResultId(tmstrainWeightResultMapper.selectMaxId());
        tmstrainWeightResult.setResultTotalId(maxId);
        tmstrainWeightResultMapper.insertSelective(tmstrainWeightResult);
        return tmstrainTotalResultMapper.insertSelective(tmstrainTotalResult);
    }

    /**
     * 进口矿新增装车实绩
     * @param tmstrainLoadingResult
     * @return
     */
    @Override
    @Transactional
    public int addTmstrainLoadingResult(TmstrainLoadingResult tmstrainLoadingResult) throws Exception{
        List<String> wagonNoList = tmstrainLoadingResult.getWagonNoList();
        if(wagonNoList.size()<=0){
            throw new Exception("车皮号异常");
        }
        //通过采购订单号获得批次ID
        BigDecimal purchaseOrderId = tmstrainLoadingResult.getPurchaseOrderRailPlanId();
        BigDecimal arrivalStationId = tmstrainLoadingResult.getArrivalStationId();
        if(arrivalStationId.intValue() == 1){
            tmstrainLoadingResult.setSendRequest(new BigDecimal(1));
        }
        BigDecimal batchId = tmstrainLoadingResultMapper.getBatchIdByPurOrderId(purchaseOrderId);
        tmstrainLoadingResult.setBatchId(batchId);
        //添加常规字段
        addRegularField(tmstrainLoadingResult);
        //准备插入
        int count = 0;
        List<Map<String,Object>> resultIdList=new ArrayList<>();
        for (String wagonNo : wagonNoList) {
            tmstrainLoadingResult.setResultWagonNo(wagonNo);
            BigDecimal maxId = tmstrainLoadingResultMapper.selectMaxId();
            //生成主键id
            tmstrainLoadingResult.setResultId(maxId);
            //通过车皮号计算车皮标重
            int wagonWeight = calculateWagonWeight(tmstrainLoadingResult.getResultWagonNo());
            tmstrainLoadingResult.setResultBillableTonnage(new BigDecimal(wagonWeight));
            count += tmstrainLoadingResultMapper.insertSelective(tmstrainLoadingResult);
            //添加火运总实绩
            count += addTotalResult(maxId);

            //计量委托实绩list
            Map<String, Object> temp = new HashMap<>();
            temp.put("resultId",maxId);
            resultIdList.add(temp);
        }
        //新增完成，发送计量委托
        if(resultIdList.size()==wagonNoList.size()){
            Map<String, Object> map = new HashMap<>();
            map.put("resultIdList",resultIdList);
            int i = tmstrainMeasureCommissionService.batchSendMeasureCommission(map);
            if(i==-1){
                return i;
            }
        }else{
            return -1;
        }
        return count;
    }

    /**
     * 添加国产矿装车实绩
     * @param list
     * @return
     */
    public int addDomesticLoadResult(List<Map<String, Object>> list) throws Exception {
        //装车临时list
        List<TmstrainLoadingTemp> loadingTemps=new ArrayList<>();
        //装车实绩list
        List<TmstrainLoadingResult> loadingResults=new ArrayList<>();
        int i = 0;
        for(Map<String,Object> map:list){
            TmstrainLoadingTemp temp=new TmstrainLoadingTemp();
            TmstrainLoadingResult result=new TmstrainLoadingResult();
            //设置序列号主键
            BigDecimal maxId = tmstrainLoadingResultMapper.selectMaxId();
            temp.setResultId(maxId);
            result.setResultId(maxId);
            //处理临时表
            temp.setSendStation((String)map.get("sendStation"));//发站
            temp.setArrivalStation((String)map.get("arrivalStation"));//到站
            temp.setMaterialName((String)map.get("materialName"));//物资
            temp.setSupplierName((String)map.get("supplierName"));//发货单位
            temp.setSendDate((String)map.get("sendDate"));//发货日期
            temp.setResultWagonNo((String) map.get("wagonNo"));//车皮号
            temp.setResultBillableTonnage(new BigDecimal((String)map.get("weight")));
            //处理实绩表
            result.setArrivalStationId(new BigDecimal((String)map.get("arrivalStationId")));
            result.setResultLoadingDate(new Date((Long)map.get("resultLoadingDate")));//装车日期
            result.setResultType(new BigDecimal((String)map.get("resultType")));//装车类型,国产矿应该为3
            result.setResultRemarks((String) map.get("resultRemarks"));
            result.setResultWagonNo((String) map.get("wagonNo"));//车皮号
            //取得发站名，查询是否存在该站台，如果存在则绑定，否则新增该站台再绑定
            String sendStationName=(String) map.get("sendStation");//发站名
            if(sendStationName!=null){
                BigDecimal sendStationId=tmstrainLoadingResultMapper.getSendStationId(sendStationName);
                if(sendStationId==null){
                    //如果没有该站，新增
                    sendStationId=tmstrainLoadingResultMapper.getMaxSendStationId().add(new BigDecimal(1));
                    Map<String,Object> station=new HashMap<>();
                    station.put("arrivalId",sendStationId);
                    station.put("arrivalName",sendStationName);
                    station.put("insertTime",new Date());
                    station.put("updateTime",new Date());
                    if(tmstrainLoadingResultMapper.addSendStation(station)<=0){
                        throw new Exception("添加发站失败");
                    }
                }
                result.setSendStationId(sendStationId);
            }
            //添加常规字段
            addRegularField(result);
            //通过车皮号计算车皮标重
            result.setResultBillableTonnage(new BigDecimal(calculateWagonWeight(result.getResultWagonNo())));
            //通过到站ID匹配计量衡 如果是老区轨道衡或者是新区轨道衡 则匹配轨道衡
            //如果到站ID是老区轨道衡
            BigDecimal arrivalStationId = result.getArrivalStationId();
            if(arrivalStationId!=null && arrivalStationId.intValue() == 1){
                result.setTrainCalculateId(new BigDecimal(13)); //设置计量衡为 铁专线（老区）
                result.setSendRequest(new BigDecimal(1));
            }
            loadingTemps.add(temp);
            loadingResults.add(result);
             i += addTotalResult(maxId);
        }
        //批量插入
        tmstrainLoadingTempMapper.batchInsert(loadingTemps);
        int count = tmstrainLoadingResultMapper.batchInsert(loadingResults);
        return count;
    }

    /**
     * 补录采购订单信息
     * @param map
     * @return
     */
    public int updateDomesticLoadResult(Map<String, Object> map){
        //获取要补录的实绩ID 列表
        List<Integer> resultIdList = (List<Integer>) map.get("resultIdList");
        TmstrainLoadingResult tmstrainLoadingResult = new TmstrainLoadingResult();
        BigDecimal purchaseOrderId = DataChange.dataToBigDecimal(map.get("purchaseOrderId"));
        if(purchaseOrderId.intValue() != 0){
            //查询补录信息
            Map<String,Object> record=tmstrainLoadingResultMapper.getRecordByPurOrderId(purchaseOrderId);
            BigDecimal materialId=DataChange.dataToBigDecimal(record.get("materialId"));
            BigDecimal supplierId=DataChange.dataToBigDecimal(record.get("supplierId"));
            BigDecimal batchId =DataChange.dataToBigDecimal(record.get("batchId"));
            //设置补录字段
            tmstrainLoadingResult.setBatchId(batchId);
            tmstrainLoadingResult.setMaterialId(materialId);
            tmstrainLoadingResult.setSendUnitId(supplierId);
        }
        tmstrainLoadingResult.setPurchaseOrderRailPlanId(purchaseOrderId); //采购订单Id
        int count = 0;
        //对每一个实绩id对应的记录修改字段
        for (Integer resultId : resultIdList) {
            tmstrainLoadingResult.setResultId(new BigDecimal(resultId)); //设置要补录的实绩主键
            count += tmstrainLoadingResultMapper.updateByPrimaryKeySelective(tmstrainLoadingResult);
        }
        //全部补录成功，发送计量委托
        if(resultIdList.size()-count==0){
//            System.out.println("发送计量委托");
            Map<String, Object> map1 = new HashMap<>();
            List<Map<String,Object>> resultIdList1=new ArrayList<>();
            for(Integer resultId:resultIdList){
                Map<String, Object> temp = new HashMap<>();
                temp.put("resultId",resultId);
                resultIdList1.add(temp);
            }
            map1.put("resultIdList",resultIdList1);
            int i = tmstrainMeasureCommissionService.batchSendMeasureCommission(map1);
            if(i==-1){
                return i;
            }
        }
        return count;
    }

    /**
     * 通过车皮标重计算车皮标重
     * @return
     */
    public int calculateWagonWeight(String wagonNo){
        String number = wagonNo.substring(0,2);
        if (number.equals("14"))
        {
            String No = wagonNo.substring(0,3);
            if (No.equals("143")||No.equals("140")||No.equals("141")||No.equals("142")){
                return 60;
            }
            else if (No.equals("145")){
                return 61;
            }
        }
        else  if(number.equals("45")||number.equals("46")){
            return 60;
        }
        else if(number.equals("42")||number.equals("47")||number.equals("48")||number.equals("49")){
            return 61;
        }
        else  if(number.equals("15")||number.equals("16")||number.equals("17")||number.equals("18")){
            return 70;
        }
        return 0;
    }

    /**
     * 添加港存库出库实绩
     * @param tmstrainLoadingResult
     * @param batchId
     */
    public void addOutWarehouse(TmstrainLoadingResult tmstrainLoadingResult, BigDecimal batchId){
        Map<String, Object> map = new HashMap<>();
        map.put("isClean",tmstrainLoadingResult.getResultIsclear());
        map.put("resultTonnage", tmstrainLoadingResult.getResultBillableTonnage());
        map.put("batchId", batchId);
        //通过发站查询发站的所属港口
        BigDecimal portId = tmstrainLoadingResultMapper.getPortIdBySendStationId(tmstrainLoadingResult.getSendStationId());
        map.put("downSwimPortId", portId);
        map.put("port", portId);
        wmshBoundFeign.addResult(map);
    }

    /**
     * 添加常规字段
     * @param tmstrainLoadingResult
     */
    public void addRegularField(TmstrainLoadingResult tmstrainLoadingResult){
        //常规字段插入
        tmstrainLoadingResult.setInsertUsername("admin");
        tmstrainLoadingResult.setInsertTime(new Date());
        tmstrainLoadingResult.setInsertUpdateRemark("无");
        tmstrainLoadingResult.setDeleted(new BigDecimal(0));
    }

    /**
     * 通过ID获取装车实绩数据
     * @param resultId
     * @return
     */
    @Override
    public List<Map<String, Object>> getTmstrainLoadingResultByResultId(BigDecimal resultId) {
        return tmstrainLoadingResultMapper.selectByResultId(resultId);
    }

    /**
     * 修改火运装车实绩
     * @param tmstrainLoadingResult
     * @return
     */
    @Override
    public int updateTmstrainLoadingResult(TmstrainLoadingResult tmstrainLoadingResult) {
        tmstrainLoadingResult.setUpdateTime(new Date());
        return tmstrainLoadingResultMapper.updateByPrimaryKeySelective(tmstrainLoadingResult);
    }

    /**
     * 删除装车作业
     * @param resultId
     * @return
     */
    @Override
    public int deleteTmstrainLoadingResultByResultId(BigDecimal resultId) {
        TmstrainLoadingResult tmstrainLoadingResult = new TmstrainLoadingResult();
        tmstrainLoadingResult.setResultId(resultId);
        tmstrainLoadingResult.setDeleted(new BigDecimal(1));
        return tmstrainLoadingResultMapper.updateByPrimaryKeySelective(tmstrainLoadingResult);
    }

    /**
     * 内转添加装车实绩
     *      "railPlanId": 1,
     *     "resultClass":"白班",
     *     "resultWagonNo":"1609999",
     *     "insertUpdateRemark": "这是第二条",
     *     "scanCodeText": "HRB400E-12-21706023-9-3077-385-20210909120037-a0691de83a1a1fef-08010103010100014-20"
     * @param map
     * @return
     */
    @Override
    @Transactional
    public int addTrainLoadResultForConverted(Map<String, Object> map) {
        int count = 0;
        TmstrainLoadingResult tmstrainLoadingResult = new TmstrainLoadingResult();
        String resultWagonNo = (String) map.get("resultWagonNo"); //车皮号
        BigDecimal railPlanId = DataChange.dataToBigDecimal(map.get("railPlanId")); //发运计划ID
        Integer loadingId = tmstrainLoadingResultMapper.getLoadingIdByWnoAndRailPlanId(resultWagonNo, railPlanId.intValue());
        //通过火运装车实绩ID查询火运总实绩ID 如果火运装车实绩不为空
        BigDecimal trainTotalId = null;
        if(loadingId != null){
            trainTotalId = tmstrainTotalResultMapper.getTotalIdByLoadingId(loadingId);
        }
        //如果没有这个车皮号和发运计划的装车实绩，则新增一条装车实绩
        if(loadingId == null){
            //获取装车实绩主键ID
            BigDecimal maxId = tmstrainLoadingResultMapper.selectMaxId();
            tmstrainLoadingResult.setId(maxId);
            //获取发运计划ID
            tmstrainLoadingResult.setPurchaseOrderRailPlanId(railPlanId);
            tmstrainLoadingResult.setResultWagonNo(resultWagonNo);
            //通过车皮号计算车皮标重
            tmstrainLoadingResult.setResultBillableTonnage(new BigDecimal(calculateWagonWeight(resultWagonNo)));
            tmstrainLoadingResult.setResultLoadingDate(new Date());
            tmstrainLoadingResult.setResultClass((String) map.get("resultClass")); //班别
            tmstrainLoadingResult.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
            tmstrainLoadingResult.setInsertTime(new Date());
            tmstrainLoadingResult.setInsertUsername("admin");
            tmstrainLoadingResult.setResultType(new BigDecimal(4)); //内转类型
            tmstrainLoadingResult.setDeleted(new BigDecimal(0)); //逻辑删除0
            //添加车皮装车实绩
            count += tmstrainLoadingResultMapper.insertSelective(tmstrainLoadingResult);
            //添加火运总实绩
            TmstrainTotalResult tmstrainTotalResult = new TmstrainTotalResult();
            trainTotalId = tmstrainTotalResultMapper.selectMaxId();
            tmstrainTotalResult.setId(trainTotalId); //获取添加火运总实绩主键ID
            //添加火运装车实绩ID
            tmstrainTotalResult.setLoadingId(maxId);
            count += tmstrainTotalResultMapper.insertSelective(tmstrainTotalResult);
        }

        //通过物资扫描结果匹配出库主键ID
        Integer outBoundResultId = tmstrainLoadingResultMapper.getOutBoundResultIdByScan((String) map.get("scanCodeText"));
        //通过出库主键查询汽运总实绩ID和物资ID
        Map<String, Object> mesMap = tmstrainLoadingResultMapper.getResultTotalIdByOutBoundResultId(outBoundResultId);
        //通过汽运总实绩ID查询该订单是否已装车（扫一件即可全部扫描上）
        Integer resultId = tmstrainLoadingResultMapper.getTrainTruckIdByTruckTotalId(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
        if(resultId != null){
            return 1; //如果已经扫描上了则默认已装车
        }
        //添加火运物资中间表
        TmstrainTruckTotalResult tmstrainTruckTotalResult = new TmstrainTruckTotalResult();
        tmstrainTruckTotalResult.setResultId(tmstrainTruckTotalResultMapper.selectMaxId());//添加火运物资中间表主键ID
        tmstrainTruckTotalResult.setTmstruckTotalResultId(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));//添加汽运总实绩ID
        tmstrainTruckTotalResult.setMaterialId(DataChange.dataToBigDecimal(mesMap.get("materialId")));//添加物资ID
        tmstrainTruckTotalResult.setTmstrainTotalResultId(trainTotalId);//添加火运总实绩ID
        tmstrainTruckTotalResult.setLoadStatus(new BigDecimal(0)); //已装车
        tmstrainTruckTotalResult.setInsertTime(new Date());
        tmstrainTruckTotalResult.setInsertUsername("admin");
        count += tmstrainTruckTotalResultMapper.insertSelective(tmstrainTruckTotalResult);

        return count;
    }

    @Override
    public List<Map<String, Object>> selectLoadByResultId(BigDecimal resultId) {
        return tmstrainLoadingResultMapper.selectLoadByResultId(resultId);
    }


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

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

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

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

    /**
     * 内转查询车皮物资信息
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getMaterialAndCarByLoadingId(Map<String, Object> map) {
        return tmstrainLoadingResultMapper.getMaterialAndCarByLoadingId(map);
    }

    /**
     * 根据物资名和外轮船名查询采购订单号
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getPurchaseOrderList(Map<String, Object> map) {
        return tmstrainLoadingResultMapper.getPurchaseOrderList(map);
    }
}