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

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.OmsFeign;
import com.steerinfo.dil.mapper.TmstruckEnfactoryResultMapper;
import com.steerinfo.dil.mapper.UtilsMapper;
import com.steerinfo.dil.model.TmstruckEnfactoryResult;
import com.steerinfo.dil.service.ITmstruckEnfactoryResultService;
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.util.*;

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

    @Autowired
    private TmstruckEnfactoryResultMapper tmstruckEnfactoryResultMapper;

    @Autowired
    private TmstruckMeasureCommissionServiceImpl tmstruckMeasureCommissionService;

    @Autowired
    private TmstruckWeightResultServiceImpl tmstruckWeightResultService;

    @Autowired
    private UtilsServiceImpl utilsService;

    @Autowired
    private RulesServiceImpl rulesService;

    @Autowired
    OmsFeign omsFeign;

    @Autowired
    UtilsMapper utilsMapper;


    /**
     * 派单时新增进厂实绩
     * map: 总实绩Id、线路起点
     * @param map
     * @return
     */
    @Override
    public int addEnFactoryResult(Map<String, Object> map) {
        TmstruckEnfactoryResult tmstruckEnfactoryResult = new TmstruckEnfactoryResult();
        BigDecimal resultTotalId = DataChange.dataToBigDecimal(map.get("resultTotalId"));
        //生成进厂作业主键Id
        //添加主键
        tmstruckEnfactoryResult.setResultId(tmstruckEnfactoryResultMapper.selectMaxId());
        //通过总实绩ID查询订单类型
        Integer orderType = utilsMapper.getOrderTypeByTotalId(resultTotalId);
        if(!"123".contains(orderType.toString())){
            //通过物资计算门岗 (暂时定死)
            tmstruckEnfactoryResult.setGatepostId(new BigDecimal(1));
        }
        //添加实绩总表Id
        tmstruckEnfactoryResult.setResultTotalId(resultTotalId);
        // 添加路段顺序号
        tmstruckEnfactoryResult.setSegmenSqe(DataChange.dataToBigDecimal(map.get("segmentSqe")));
        return tmstruckEnfactoryResultMapper.insertSelective(tmstruckEnfactoryResult);
    }

    /**
     * 通过运输订单号查找排队顺序号
     * @param orderNumber
     * @return
     */
    @Override
    public Integer selectNodeNumber(String orderNumber) {
        return tmstruckEnfactoryResultMapper.selectNodeNumber(orderNumber);
    }

    /**
     * 获取进厂实绩
     * 1：销售订单；2：焦炭发运计划；3：水渣发运计划；4：内转到异地库；5：采购辅料订单；6：采购老区燃料订单；
     * 7：采购新区燃料订单；8：采购进口矿(万州-厂内)；9：采购内转(达州-厂内)；10：采购内转(老区-厂内)； 11：厂内内转
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getAllEnFactoryResult(Map<String, Object> map) {
        Integer orderType = (Integer) map.get("orderTypee");
        switch (orderType){
            case 1:
            case 2:
            case 3:
                return tmstruckEnfactoryResultMapper.getXSEnFactoryResult(map); //apiId:210
            case 4:
                return tmstruckEnfactoryResultMapper.getSteelNZEnFactoryResult(map); //apiId:261
            case 5:
            case 6:
            case 7:
            case 8:
                return tmstruckEnfactoryResultMapper.getCGJKEnFactoryResult(map); //apiID: 99
            case 9:
                return tmstruckEnfactoryResultMapper.getImportedDomesticNzLoadResult(map); //apiId:99
            case 10:
                return tmstruckEnfactoryResultMapper.getCGNZEnFactory(map);
            case 11:
                return tmstruckEnfactoryResultMapper.getInFactoryMaterialEnFactoryResult(map); //apiId:357
            case 12:
            case 13:
                return tmstruckEnfactoryResultMapper.getSporadicSuppliesEnFactoryResult(map);// apiId:403
        }
        return null;
    }

    /**
     * 通过运输订单id查询物资信息
     * @param orderId
     * @return
     */
    @Override
    public List<Map<String, Object>> getMaterial(Integer orderId) {
        return tmstruckEnfactoryResultMapper.getMaterial(orderId);
    }


    /**
     * 通过PDA进厂
     * orderNumber 运输订单号 gatepostId 门岗Id
     * 1：销售订单；2：焦炭发运计划；3：水渣发运计划；4：内转到异地库；5：采购辅料订单；6：采购老区燃料订单；
     * 7：采购新区燃料订单；8：采购进口矿(万州-厂内)；9：采购内转(达州-厂内)；10：采购内转(老区-厂内)； 11：厂内内转
     * @param map
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public int enFactoryResultByPDA(Map<String, Object> map) throws Exception {
        int i = 0;
        //通过运输订单号查询订单类型
        String orderNumber = (String) map.get("orderNumber");
        String substring = orderNumber.substring(0, orderNumber.length() - 1);
        Map<String, Object> selectMap = tmstruckEnfactoryResultMapper.selectEnFactoryResultId(substring);
        if(selectMap == null){
            throw new Exception("该车已进厂！！");
        }
        map.putAll(selectMap);
        BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderTypee"));
        BigDecimal lineSqe = DataChange.dataToBigDecimal(map.get("segmentSqe"));
        i += updateEnFactoryResultByPDA(map); //添加进厂实绩
        //修改路段顺序号
        i += utilsService.updateOrderLineSequence(map);
        //判断委托是否发送成功
        int checkMeasureCommission = 0;
        switch (orderType.intValue()){
            case 1:
            case 4:
                //查询未装车实绩
                List<Map<String, Object>> mapList = rulesService.judgeLastMaterial(DataChange.dataToBigDecimal(map.get("orderId")));
                if(mapList.size() == 1){
                    //如果是单拼 不需要走计算 直接走钢材的汽车衡(钢材)
                    Map<String, Object> mesMap = new HashMap<>();
                    mesMap.put("materialId",mapList.get(0).get("materialId"));
                    map.put("materialId", mapList.get(0).get("materialId"));
                    mesMap.put("nature", 1);
                    mesMap.put("orderId", map.get("orderId"));
                    //计算计皮汽车衡
                    int tarePlaceId = rulesService.calculateWeighbridge(mesMap);
                    mesMap.put("tarePlaceId", tarePlaceId);
                    //更新汽车衡
                    i += tmstruckWeightResultService.updateWeightResult(mesMap);
                }else {
                    //如果是多拼
                    Map<String, Object> mesMap = rulesService.calculateMaterial(mapList);
                    //获取物资ID
                    HashMap<String, Object> calculateMap = new HashMap<>();
                    calculateMap.put("orderId", map.get("orderId"));
                    calculateMap.put("materialId", mesMap.get("materialId"));
                    calculateMap.put("nature", 1); // 1：进厂秤
                    //计算计皮汽车衡
                    int tarePlaceId = rulesService.calculateWeighbridge(calculateMap);
                    calculateMap.put("tarePlaceId", tarePlaceId);
                    //更新汽车衡
                    i += tmstruckWeightResultService.updateWeightResult(calculateMap);
                }
                checkMeasureCommission = tmstruckMeasureCommissionService.addXSMeasureCommission(map); //添加计皮委托
                break;
            case 2:
            case 3:
                //计算计皮汽车衡并更新计量实绩
                i += tmstruckWeightResultService.calculateTruckCalculateByOne(map, 1);
                //焦炭 水渣 等只会有一种物资
                checkMeasureCommission += tmstruckMeasureCommissionService.addMaoMeasureCommission(map); //添加计量委托
                break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 9:
                //计算计毛汽车衡并更新计量实绩 (暂时无法计算汽车衡)  需要写一个单独的方法 先计皮再计毛的
                map.put("grossPlaceId", 18);
                i += tmstruckWeightResultService.updateWeightResult(map);
                //通过订单ID查询物资Id
                List<Integer> materialIdList = utilsMapper.getMaterialIdByOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
                map.put("materialId", materialIdList.get(0));
                checkMeasureCommission = tmstruckMeasureCommissionService.addMaoMeasureCommission(map); //添加计毛委托 并发送计毛委托
                break;
            case 10: // 采购内转（老区-厂内） 没有进厂
                if(lineSqe.intValue() == 1){
                   //计算计皮汽车衡并更新计量实绩
                    map.put("tarePlaceId",15);
                    i += tmstruckWeightResultService.updateWeightResult(map);
                    checkMeasureCommission = tmstruckMeasureCommissionService.addMaoMeasureCommission(map); //添加计量委托
                }else{
                    map.put("grossPlaceId",18);
                    i += tmstruckWeightResultService.updateWeightResult(map);
                    checkMeasureCommission = tmstruckMeasureCommissionService.addMaoMeasureCommission(map); //添加计量委托

                }
                break;
            case 11:
            case 12:
                //更新计量实绩
                map.put("grossPlaceId", 5);
                i += tmstruckWeightResultService.updateWeightResult(map);
                //发送计量委托
                List<Integer> materialIdByOrderId = utilsMapper.getMaterialIdByOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
                map.put("materialId", materialIdByOrderId.get(0));
                //默认收货单位为新厂区
                checkMeasureCommission += tmstruckMeasureCommissionService.addLXMeasureCommission(map);
                break;
            case 13:
                //更新计量实绩
                map.put("grossPlaceId", 5);
                i += tmstruckWeightResultService.updateWeightResult(map);
                //发送计量委托
                List<Integer> materialIdByOrderId1 = utilsMapper.getMaterialIdByOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
                map.put("materialId", materialIdByOrderId1.get(0));
                //默认收货单位为新厂区
                checkMeasureCommission += tmstruckMeasureCommissionService.addLXMeasureCommission(map);

        }
        if(checkMeasureCommission == 0){
            throw new Exception("委托发送失败");
        }
        utilsService.pushMesToWebsocket((String) map.get("capacityNumber"), "车辆进厂");
        return i;
    }


    /**
     * 通过门禁进厂
     * 运输订单号 orderNumber，车牌号capacityNumber，
     * 门岗名称 gatepostName，进厂时间 resultEntryGateTime，（进厂方式）
     * @param map
     * @return
     */
    public int enFactoryResultByMJ(Map<String, Object> map){
        int i = 0;
        //通过运输订单号查询订单类型
        String orderNumber = (String) map.get("orderNumber");
        String subString = orderNumber.substring(0,orderNumber.length() - 1);
        map.putAll(tmstruckEnfactoryResultMapper.selectEnFactoryResultId(subString));
        BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderTypee"));
        switch (orderType.intValue()){
            case 1:
            case 4:
                i += updateEnFactoryResultByMJ(map); //添加进厂实绩
//                i += tmstruckMeasureCommissionService.addPiMeasureCommission(map); //添加计皮委托
                break;
            case 2:
                break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 9:
                i += updateEnFactoryResultByMJ(map); //添加进厂实绩
                i += tmstruckMeasureCommissionService.addMaoMeasureCommission(map); //添加计毛委托 并发送计毛委托
                break;
            case 10: // 采购内转（老区-厂内）
                break;
            case 11:
                break;
            case 12:
                break;

        }
        omsFeign.pushMesToWebsocket(map);
        return i;
    }

    /**
     * APP查询进厂实绩
     * @return
     */
    @Override
    public List<Map<String, Object>> getEnfactoryResultList() {
        return tmstruckEnfactoryResultMapper.getEnfactoryResultList();
    }

    /**
     * APP通过运输订单id查询进厂实绩
     * @param orderNumber
     * @return
     */
    @Override
    public List<Map<String, Object>> getEnfactoryMessageByOrderId(String orderNumber) {
        return tmstruckEnfactoryResultMapper.getEnfactoryMessageByOrderId(orderNumber);
    }

    /**
     * 通过PDA添加进厂实绩方法
     * @param map
     * @return
     */
    public int updateEnFactoryResultByPDA(Map<String, Object> map){
        TmstruckEnfactoryResult tmstruckEnfactoryResult = new TmstruckEnfactoryResult();
        //获取进厂实绩id
        tmstruckEnfactoryResult.setResultId(DataChange.dataToBigDecimal(map.get("resultId")));
        //添加门岗
        tmstruckEnfactoryResult.setGatepostId(DataChange.dataToBigDecimal(map.get("gatepostId")));
        //添加进厂时间
        tmstruckEnfactoryResult.setResultEntryGateTime(new Date());
        tmstruckEnfactoryResult.setInsertTime(new Date());
        tmstruckEnfactoryResult.setResultEntryMode("手动抬杠");
        tmstruckEnfactoryResult.setInsertUsername("admin");
        return tmstruckEnfactoryResultMapper.updateByPrimaryKeySelective(tmstruckEnfactoryResult);
    }

    /**
     * 通过门禁系统添加进厂实绩方法
     * @param map
     * @return
     */
    public int updateEnFactoryResultByMJ(Map<String, Object> map){
        TmstruckEnfactoryResult tmstruckEnfactoryResult=new TmstruckEnfactoryResult();
        //进门方式
        tmstruckEnfactoryResult.setResultEntryMode("自动抬杆");
        //添加进厂时间
        tmstruckEnfactoryResult.setResultEntryGateTime(new Date((long) map.get("resultEntryGateTime")));
        //添加门岗
        String gatepostName = (String) map.get("gatepostName");
        Integer gatepostNameId = tmstruckEnfactoryResultMapper.selectGatepostIdByGatepostName(gatepostName);
        tmstruckEnfactoryResult.setGatepostId(new BigDecimal(gatepostNameId));

        tmstruckEnfactoryResult.setInsertTime(new Date());
        tmstruckEnfactoryResult.setInsertUsername("admin");
        return tmstruckEnfactoryResultMapper.updateByPrimaryKeySelective(tmstruckEnfactoryResult);
    }

}