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

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.AmsFeign;
import com.steerinfo.dil.feign.BmsShipFeign;
import com.steerinfo.dil.feign.BmsTruckFeign;
import com.steerinfo.dil.feign.OmsFeign;
import com.steerinfo.dil.mapper.TmstruckEnfactoryResultMapper;
import com.steerinfo.dil.mapper.TmstruckLeaveFactoryResultMapper;
import com.steerinfo.dil.mapper.UtilsMapper;
import com.steerinfo.dil.model.TmstruckLeaveFactoryResult;
import com.steerinfo.dil.service.ITmstruckLeaveFactoryResultService;
import com.steerinfo.dil.service.IUtilsService;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.framework.controller.RESTfulResult;
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.SimpleDateFormat;
import java.util.*;

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

    @Autowired
    private TmstruckLeaveFactoryResultMapper tmstruckLeaveFactoryResultMapper;

    @Autowired
    private TmstruckEnfactoryResultMapper tmstruckEnfactoryResultMapper;

    @Autowired
    private UtilsServiceImpl utilsService;

    @Autowired
    private UtilsMapper utilsMapper;

    @Autowired
    private RulesServiceImpl rulesService;

    @Autowired
    OmsFeign omsFeign;

    @Autowired
    AmsFeign amsFeign;

    /**
     * 查看运输线路是否为出厂
     * @param orderNumber
     * @return
     */
    @Override
    public Integer selectTransportRoute(String orderNumber) {
        return tmstruckLeaveFactoryResultMapper.selectTransportRoute(orderNumber);
    }


    /**
     * 派单后新增出厂实绩
     * 总实绩ID、线路终点
     * @param map
     * @return
     */
    @Override
    public int addLeaveFactory(Map<String, Object> map) {
        TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
        //添加主键
        tmstruckLeaveFactoryResult.setId(tmstruckLeaveFactoryResultMapper.selectMaxId());
        //添加总实绩ID
        BigDecimal resultTotalId = DataChange.dataToBigDecimal(map.get("resultTotalId"));
        tmstruckLeaveFactoryResult.setResultTotalId(resultTotalId);
        List<Integer> gatepostIdList = utilsMapper.getLineSegmentGateCalcId(map);
        gatepostIdList.remove(null);
        //随机取门岗值
        Integer gatepostId = utilsService.randomGetValue(gatepostIdList);
        //获取门岗ID
        tmstruckLeaveFactoryResult.setGatepostId(new BigDecimal(gatepostId));
        //添加路段顺序号
        tmstruckLeaveFactoryResult.setSegmentSqe(DataChange.dataToBigDecimal(map.get("segmentSqe")));
        //添加门岗ID 出厂门岗为线路的终点
        return tmstruckLeaveFactoryResultMapper.insertSelective(tmstruckLeaveFactoryResult);
    }

    @Override
    public Map<String, Object> getTruckFactoryResult(String nu) {
        return tmstruckLeaveFactoryResultMapper.getTruckFactoryResult(nu);
    }

    /**
     * APP查询出厂信息
     * @param orderNumber
     * @return
     */
    @Override
    public List<Map<String, Object>> getLeaveFactoryList(String orderNumber) {
        return tmstruckLeaveFactoryResultMapper.getLeaveFactoryList(orderNumber);
    }


    /**
     * 查询所有的出厂实绩
     * 1：销售订单；2：焦炭发运计划；3：水渣发运计划；4：内转到异地库；5：采购辅料订单；6：采购老区燃料订单；
     * 7：采购新区燃料订单；8：采购进口矿(万州-厂内)；9：采购内转(达州-厂内)；10：采购内转(老区-厂内)； 11：厂内内转
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getLeaveFactoryResult(Map<String, Object> map) {
        Integer orderType = (Integer) map.get("orderTypee");
        switch (orderType){
            case 1:
            case 2:
            case 3:
                return tmstruckLeaveFactoryResultMapper.selectAllLeaveFacatoryForSale(map);
            case 4:
                return tmstruckLeaveFactoryResultMapper.selectSteelNzLeaveFactory(map);
            case 5:
            case 6:
            case 7:
            case 8:
            case 17:
            case 18:
                return tmstruckLeaveFactoryResultMapper.getCGLeaveFactoryResult(map); //apiId:110
            case 9:
                return tmstruckLeaveFactoryResultMapper.getImportedDomesticNzEnFactoryResult(map); //apiId:110
            case 10:
                return tmstruckEnfactoryResultMapper.getCgNzOutFactory(map);
            case 11:
                return tmstruckLeaveFactoryResultMapper.getInFactoryOutFactoryResult(map); //apiId:361
            case 12:
            case 13:
            case 15:
            case 16:
                 return tmstruckLeaveFactoryResultMapper.getSporadicLeaveFactory(map);//apiId:421
        }
        return null;
    }


    /**
     * 通过 PDA 出厂
     * 1：销售订单；2：焦炭发运计划；3：水渣发运计划；4：内转到异地库；5：采购辅料订单；6：采购老区燃料订单；
     * 7：采购新区燃料订单；8：采购进口矿(万州-厂内)；9：采购内转(达州-厂内)；10：采购内转(老区-厂内)； 11：厂内内转
     * @param map
     * @return
     */
    @Transactional
    public int leaveFactoryByPDA(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 = tmstruckLeaveFactoryResultMapper.selectResultId(substring);
        if(selectMap == null){
            throw new Exception("该车已出厂！！");
        }
        map.putAll(selectMap);
        map.put("orderNumber", substring);
        BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderTypee"));
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        i += updateLeaveResultByPDA(map); //更新出厂实绩
        //更新路段顺序号
        i += utilsService.updateOrderLineSequence(map);
        switch (orderType.intValue()){
            case 1:
                break;
            case 2:
            case 3:
                //查询司机是否已确认订单 如果订单未确认 则不允许出厂
                Integer driverConfirmation = utilsMapper.getDriverConfirmation(orderId);
                if(driverConfirmation == null){
                    throw new Exception("请提醒司机确认订单！");
                }
                i += utilsService.closeOrderNormally(map);
                // 判断是否要自动派单
                Map<String,Object> mapValue = omsFeign.getSaleAllMessages(orderId.intValue());
                Object closeStatus = mapValue.get("closeStatus");
                if (closeStatus != null && DataChange.dataToBigDecimal(closeStatus).intValue() == 0) {
                    amsFeign.dispatchTruckOrderByCarrier(mapValue);
                }
                break;
            case 4:
                break;
            case 6:
            case 7:
                //判断出厂路段顺序号是否为最后一个 采购订单关闭订单
                i += utilsService.closeOrderNormally(map);
                //查询是否为一车多趟采购订单类型
                Integer isMoreTripsStatus = tmstruckLeaveFactoryResultMapper.getIsMoreTripsStatus(DataChange.dataToBigDecimal(selectMap.get("orderId")));
                if(isMoreTripsStatus != null && isMoreTripsStatus == 1){
                    //如果是一车多趟 则重新下一个运输订单
                    omsFeign.addNewTransportOrder(orderId.intValue());
                }
                break;
            case 5:
            case 8:
            case 9:
            case 17:
            case 18:
                //判断出厂路段顺序号是否为最后一个 采购订单关闭订单
                i += utilsService.closeOrderNormally(map);
//                i += utilsService.updateCapacityStatus(map, 0); //修改运力状态 0：空闲中
                //采购出厂 通过feign调用新增详单
//                try {
//                    bmsShipFeign.addDetailsOrder(DataChange.dataToBigDecimal(map.get("resultId"))); // 出厂实绩Id
//                    bmsTruckFeign.addDetailsOrder(DataChange.dataToBigDecimal(map.get("orderId")));  // 运单ID
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
                break;
            case 10:
                //生成新的采购内转运输订单

                //判断出厂路段顺序号是否为最后一个 采购订单关闭订单
                i += utilsService.closeOrderNormally(map);
                //根据运输订单ID查询路段顺序号
                Integer seq = tmstruckLeaveFactoryResultMapper.getSeq(orderId);
                if(seq == 10){
                    //判断是否满足条件--计划是否被启用
                    Integer j = tmstruckLeaveFactoryResultMapper.getPlanEnable(orderId);
                    if(j == 1){
                        //生成新的运输订单
                        omsFeign.addPurInwardOrder(orderId);
                    }

                }
                break;
            case 11:
                break;
            case 12:
            case 13:
            case 15:
            case 16:
                //生成新的零星订单
                omsFeign.pushMessageToDriver(map);
                //关闭当前订单
                i += utilsService.closeOrderNormally(map);
                break;
        }
        utilsService.pushMesToWebsocket((String) map.get("capacityNumber"), "出厂");
        return i;
    }

    /**
     * 更新出厂实绩
     * @param mapValue {运输订单号:orderNumber 门岗名称:gatepostName}
     * @return
     */
    public int updateLeaveResultByPDA(Map<String, Object> mapValue){
        TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
        tmstruckLeaveFactoryResult.setResultId(DataChange.dataToBigDecimal(mapValue.get("resultId")));
        //通过门岗名称获取门岗ID
        if(mapValue.get("gatepostId") == null){
            Integer gatepostId = tmstruckEnfactoryResultMapper.selectGatepostIdByGatepostName((String) mapValue.get("gatepostName"));
            if(gatepostId != null){
                tmstruckLeaveFactoryResult.setGatepostId(new BigDecimal(gatepostId));
            }
        }else {
            tmstruckLeaveFactoryResult.setGatepostId(DataChange.dataToBigDecimal(mapValue.get("gatepostId")));
        }
        //设置常规字段 添加 出厂时间 和 出厂方式
        tmstruckLeaveFactoryResult.setResultOutGateTime(new Date());
        tmstruckLeaveFactoryResult.setResultOutMode("手动抬杠");
        tmstruckLeaveFactoryResult.setInsertUsername("admin");
        tmstruckLeaveFactoryResult.setInsertTime(new Date());
        return tmstruckLeaveFactoryResultMapper.updateByPrimaryKeySelective(tmstruckLeaveFactoryResult);
    }

    /**
     * 通过总实绩Id修改出厂实绩出厂门岗
     * @param resultTotalId
     * @param gatepostId
     * @return
     */
    public int updateLeaveFactoryGatepostId(Integer resultTotalId, Integer gatepostId){
        TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
        //通过总实绩ID查询出产实绩
        BigDecimal resultId = tmstruckLeaveFactoryResultMapper.getResultIdByTotalId(resultTotalId);
        tmstruckLeaveFactoryResult.setResultId(resultId);
        tmstruckLeaveFactoryResult.setGatepostId(new BigDecimal(gatepostId));
        return tmstruckLeaveFactoryResultMapper.updateByPrimaryKeySelective(tmstruckLeaveFactoryResult);
    }

    /**
     * 查询零星物资出厂列表
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getSporadicLeaveFactory(Map<String, Object> mapValue) {
        return tmstruckLeaveFactoryResultMapper.getSporadicLeaveFactory(mapValue);
    }
}