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.DilCapacityTimesMapper;
import com.steerinfo.dil.mapper.TmstruckEnfactoryResultMapper;
import com.steerinfo.dil.mapper.UtilsMapper;
import com.steerinfo.dil.model.DilCapacityTimes;
import com.steerinfo.dil.model.TmstruckEnfactoryResult;
import com.steerinfo.dil.model.TmstruckLeaveFactoryResult;
import com.steerinfo.dil.service.ITmstruckEnfactoryResultService;
import com.steerinfo.dil.util.DataChange;
import io.swagger.models.auth.In;
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 TmstruckTimeTaskResultServiceImpl tmstruckTimeTaskResultService;

    @Autowired
    private DilCapacityTimesMapper dilCapacityTimesMapper;

    @Autowired
    private UtilsServiceImpl utilsService;

    @Autowired
    private RulesServiceImpl rulesService;

    @Autowired
    OmsFeign omsFeign;

    @Autowired
    UtilsMapper utilsMapper;


    /**
     * 派单时新增进厂实绩
     * map: 总实绩Id、线路Id、路段顺序号
     * @param map
     * @return
     */
    @Override
    public int addEnFactoryResult(Map<String, Object> map) {
        TmstruckEnfactoryResult tmstruckEnfactoryResult = new TmstruckEnfactoryResult();
        BigDecimal resultTotalId = DataChange.dataToBigDecimal(map.get("resultTotalId"));
        tmstruckEnfactoryResult.setResultTotalId(resultTotalId);
        //添加主键
        tmstruckEnfactoryResult.setResultId(tmstruckEnfactoryResultMapper.selectMaxId());
        List<Integer> gatepostIdList = utilsMapper.getLineSegmentGateCalcId(map);
        gatepostIdList.remove(null);
        //随机取门岗Id
        Integer gatepostId = utilsService.randomGetValue(gatepostIdList);
        //获取门岗ID
        tmstruckEnfactoryResult.setGatepostId(new BigDecimal(gatepostId));
        // 添加路段顺序号
        tmstruckEnfactoryResult.setSegmenSqe(DataChange.dataToBigDecimal(map.get("segmentSqe")));
        int i=tmstruckEnfactoryResultMapper.insertSelective(tmstruckEnfactoryResult);
        try{
            tmstruckEnfactoryResultMapper.clearRepeat(tmstruckEnfactoryResult);
        }catch (Exception e){
            e.printStackTrace();
        }
        return i;
    }

    /**
     * 通过运输订单号查找排队顺序号
     * @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:
            case 17:
            case 18:
                return tmstruckEnfactoryResultMapper.getCGJKEnFactoryResult(map); //apiID: 99
            case 9:
                return tmstruckEnfactoryResultMapper.getImportedDomesticNzLoadResult(map); //apiId:99
            case 10:
            case 20:
            case 23:
            case 24:
            case 15:
            case 16:
                return tmstruckEnfactoryResultMapper.getCGNZEnFactory(map); //apiId:99
            case 11:
                return tmstruckEnfactoryResultMapper.getInFactoryMaterialEnFactoryResult(map); //apiId:357
            case 12:
            case 13:
            case 14:
            case 19:
            case 100:
                return tmstruckEnfactoryResultMapper.getSporadicSuppliesEnFactoryResult(map);// apiId:416
        }
        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");
        //通过订单号查询订单类型 及总实绩Id
        Map<String, Object> mesMap = utilsMapper.getOrderTypeByOrderNumber(orderNumber);
        String capacityNumber = (String) mesMap.get("capacityNumber");
        BigDecimal resultTotalId = DataChange.dataToBigDecimal(mesMap.get("totalId"));
        int orderType = DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue();
        if(orderType == 11 || orderType == 15 || orderType == 16){//内转计时调用方法
            return orderType11Use(map, mesMap, capacityNumber, resultTotalId);
        }
        else if (orderType == 21){//调用计时作业方法
            return orderType21Use(map, orderNumber, DataChange.dataToBigDecimal(mesMap.get("orderId")));
        }
        //如果订单类型为2 则需要财务公司审核才能进厂//如果订单为销售，1,2,内转钢材异地库-4
        if(orderType == 2 || orderType == 1 ||  orderType == 4){
            Integer saleOrderStatus = tmstruckEnfactoryResultMapper.getSaleOrderStatus(DataChange.dataToBigDecimal(mesMap.get("orderId")));
            if(saleOrderStatus != 4){
               throw new Exception("审批未通过不能进厂！");
            }
        }
        Map<String, Object> selectMap = tmstruckEnfactoryResultMapper.selectEnFactoryResultId(resultTotalId);
        if(orderType == 1) {
            selectMap = tmstruckEnfactoryResultMapper.selectEnFactoryResultIdSteel(resultTotalId);
        }
        if(selectMap == null){
            if (orderType == 20 || orderType == 12 || orderType == 13 || orderType == 14) {
                selectMap = tmstruckEnfactoryResultMapper.selectEnFactoryResultIdGatepost(resultTotalId);
            }else{
                throw new Exception("该车已进厂！！");
            }
        }else{
            if(orderType != 1) {
                BigDecimal segmentSqe = DataChange.dataToBigDecimal(selectMap.get("segmentSqe"));
                BigDecimal orderSegmentSqe = DataChange.dataToBigDecimal(mesMap.get("orderSegmentSqe"));
                //如果当前路段顺序号 +1 不等于进厂路段顺序号 则不允许进厂 （针对同一路线多次进厂情况）
                if(segmentSqe.intValue() != (orderSegmentSqe.intValue() + 1)){
                    throw  new Exception("作业环节未到进厂！");
                }
            }
        }
        map.putAll(mesMap);
        map.putAll(selectMap);
        map.remove("Sqe");
        //判断委托是否发送成功
        int checkMeasureCommission = 0;
        switch (orderType){
            case 1:
            case 4:
                checkMeasureCommission = steelOrderEnFactory(map, selectMap, resultTotalId);
                break;
            case 2:
            case 3:
                checkMeasureCommission = tmstruckMeasureCommissionService.addXSMeasureCommission(map); //添加计皮委托
                break;
            case 5:
                Integer num = tmstruckEnfactoryResultMapper.selectAllEnFactoryNum(resultTotalId);
                if(num == 2){
                    //如果辅料有两次进厂，则判断还剩几次没进厂数据，如果还剩两次则发委托
                    Integer judgeNum = tmstruckEnfactoryResultMapper.selectEnFactoryNumber(resultTotalId);
                    if (judgeNum == 1){
                        checkMeasureCommission = 1;
                        break;
                    }
                }
                checkMeasureCommission = tmstruckMeasureCommissionService.addMaoMeasureCommission(map); //添加计毛委托 并发送计毛委托
                break;
            case 6:
            case 7:
            case 8:
//            case 9:
            case 10:
            case 17:
            case 18:
            case 23:
            case 24:
                checkMeasureCommission = tmstruckMeasureCommissionService.addMaoMeasureCommission(map); //添加计毛委托 并发送计毛委托
                break;
            case 12:
            case 13:
            case 14:
                //发送计量委托(查询物资顺序第一个装卸货的物资)
                Integer materialId = utilsMapper.getLxFirstMaterialId(DataChange.dataToBigDecimal(map.get("orderId")));
                map.put("materialId", materialId);
                checkMeasureCommission += tmstruckMeasureCommissionService.sendMeasureCommissionByGatepost(map);
                break;
            case 20:
                checkMeasureCommission += tmstruckMeasureCommissionService.sendMeasureCommissionByGatepost(map);
                break;
            case 19:
                checkMeasureCommission = 1;
        }
        if(checkMeasureCommission == 0){
            throw new Exception("委托发送失败");
        }else if (checkMeasureCommission == -2){
            throw new Exception("没有获取到门岗");
        }
        try {
            DilCapacityTimes dilCapacityTimes = new DilCapacityTimes();
            dilCapacityTimes.setId(dilCapacityTimesMapper.getDilCapacityTimesId());
            dilCapacityTimes.setTimesCapacityNumber(map.get("capacityNumber").toString());
            dilCapacityTimes.setTimesValue(new Date());
            dilCapacityTimes.setTimesType(new BigDecimal(1));
            dilCapacityTimesMapper.insertSelective(dilCapacityTimes);
        } catch (Exception e) {
            e.printStackTrace();
        }
        i += tmstruckEnfactoryResultMapper.updateByPrimaryKeySelective(generateEnFactoryResult(map)); //添加进厂实绩
        //修改路段顺序号
        i += utilsService.updateOrderLineSequence(map);
        utilsService.pushMesToWebsocket(capacityNumber, "车辆进厂");
        return i;

    }

    /**
     * 钢材进厂处理方法
     * @param map
     * @param selectMap
     * @param resultTotalId
     * @return
     * @throws Exception
     */
    public int steelOrderEnFactory(Map<String, Object> map, Map<String, Object> selectMap,BigDecimal resultTotalId) throws Exception{
        if(!"OK".equals(selectMap.get("insertUpdateRemark")) && DataChange.dataToBigDecimal(map.get("orderType")).intValue() == 1){
            throw new Exception("钢材科未确认进厂！");
        }
        //发送空委托
        map.put("firstMC", 1); //空委托依据
        int checkMeasureCommission = tmstruckMeasureCommissionService.addSteelMeasureCommission(map);
        if(checkMeasureCommission == 1 && DataChange.dataToBigDecimal(map.get("orderType")).intValue() == 1){
            //查询是否拼装
            Map<String, Object> isSpellingMap = tmstruckEnfactoryResultMapper.getSteelIsSpelling(resultTotalId);
            if (isSpellingMap != null) {
                int isSpelling = DataChange.dataToBigDecimal(isSpellingMap.get("isSpelling")).intValue();
                if(isSpelling == 1){
                    //拼装移出队列
                    tmstruckEnfactoryResultMapper.deleteQQSL(isSpellingMap.get("listId"));
                }else {
                    //单拼移出队列
                    tmstruckEnfactoryResultMapper.deleteQQL(isSpellingMap.get("listId"));
                }
                //修改排队实绩表
                tmstruckEnfactoryResultMapper.updateQQR(isSpellingMap.get("resultId"));
            }

        }
        return checkMeasureCommission;
    }


    /**
     * 计时作业方法
     * @Author TXF
     * @Date 2022/3/18 16:57
     * @param map
     * @param orderNumber
     * @param orderId
     * @return
     **/
    public int orderType21Use(Map<String, Object> map, String orderNumber, BigDecimal orderId) throws Exception{
        int gatepostId = DataChange.dataToBigDecimal(map.get("gatepostId")).intValue();
        if(TmstruckMeasureCommissionServiceImpl.daXingGatepost.contains(gatepostId)){
            //如果是达兴的门岗扫码则不进行计时判断
            map.put("inwardTypes",0);
            map.put("orderNumber",orderNumber);
        }else {
            //首先判断是否还有计时开始
            BigDecimal startTime = utilsMapper.getTime(DataChange.dataToBigDecimal(orderId));
            //如果计时已经开始
            if (startTime == null) {
                map.put("inwardTypes", 1);
                map.put("orderNumber", orderNumber);
            } else {
                map.put("inwardTypes", 3);
                map.put("orderNumber", orderNumber);
            }
        }
        return tmstruckTimeTaskResultService.addTimeTaskResult(map);
    }

    /**
     * 内转订单类型处理方法
     * @Author TXF
     * @Date 2022/3/18 16:59
     * @param
     * @return
     **/
    public int orderType11Use(Map<String, Object> map, Map<String, Object> mesMap, String capacityNumber, BigDecimal resultTotalId){
        //内转订单类型  没有生成实绩 直接新增
        int sqe = DataChange.dataToBigDecimal(mesMap.get("Sqe")).intValue();
        sqe = sqe + 1;
        map.put("resultId", tmstruckEnfactoryResultMapper.selectMaxId());  //插入进厂实绩Id
        map.put("Sqe", sqe); //查询路段顺序号 + 1
        map.put("totalId",resultTotalId);
        tmstruckEnfactoryResultMapper.insertSelective(generateEnFactoryResult(map));
        mesMap.put("orderLineSequence", sqe);
        utilsService.updateOrderLineSqeByOrderNumber(mesMap); //更新路段顺序号
        utilsService.pushMesToWebsocket(capacityNumber, "车辆进厂");
        return 1;
    }

    /**
     * 通过门禁进厂
     * 运输订单号 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(null));
        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);
    }

    @Override
    public int updateEnSge() {
        List<Map<String,Object>>maplist = tmstruckEnfactoryResultMapper.getEnResult();
        int i = 0;
        for (Map<String,Object>map:maplist
             ) {
            BigDecimal resultId = DataChange.dataToBigDecimal(map.get("resultId"));
            TmstruckEnfactoryResult tmstruckEnfactoryResult = new TmstruckEnfactoryResult();
            tmstruckEnfactoryResult.setResultId(resultId);
            tmstruckEnfactoryResult.setSegmenSqe(new BigDecimal(6));
            i = tmstruckEnfactoryResultMapper.updateByPrimaryKeySelective(tmstruckEnfactoryResult);
        }
        return i;
    }

    /**
     * 生成进厂实绩
     * @param map
     * @return
     */
    public TmstruckEnfactoryResult generateEnFactoryResult(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");
        if(map.get("Sqe") != null){
            tmstruckEnfactoryResult.setSegmenSqe(DataChange.dataToBigDecimal(map.get("Sqe")));
        }
        if(map.get("totalId") != null){
            tmstruckEnfactoryResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("totalId")));
            tmstruckEnfactoryResultMapper.updateEnfactoryStatus(DataChange.dataToBigDecimal(map.get("totalId")));
        }
        return 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);
    }

}