DAI_DAZHOU-OMS/src/main/java/com/steerinfo/dil/service/impl/OmstruckOrderServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.baomidou.mybatisplus.extension.api.R;
import com.steerinfo.dil.feign.AmsFeign;
import com.steerinfo.dil.feign.IMFeign;
import com.steerinfo.dil.feign.TmsTruckFeign;
import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.*;
import com.steerinfo.dil.service.IOmstruckOrderService;
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.text.SimpleDateFormat;
import java.util.*;

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

    @Autowired
    private OmstruckOrderMapper omstruckOrderMapper;


    @Autowired
    private OmstruckOrderMaterialMapper omstruckOrderMaterialMapper;

    @Autowired
    private AmsFeign amsFeign;

    @Autowired
    private TmsTruckFeign tmsTruckFeign;

    @Autowired
    private IMFeign imFeign;

    @Autowired
    RmsCapacityMapper rmsCapacityMapper;

    @Autowired
    RmsDriverCapacityMapper rmsDriverCapacityMapper;

    @Autowired
    AmstruckInwardPlanMapper amstruckInwardPlanMapper;

    @Autowired
    OmstruckOrderSeparateServiceImpl omstruckOrderSeparateService;

    @Autowired
    OmstruckOrderSeparateMapper omstruckOrderSeparateMapper;

    /**
     * 用于远程调用运输订单新增
     *
     * @param omstruckOrder
     * @return
     */
    @Override
    public int insertSelective(OmstruckOrder omstruckOrder) {
        return omstruckOrderMapper.insertSelective(omstruckOrder);
    }

    /**
     * 查询所有运输订单
     * 获取已下发的运输订单 用于websocket
     *
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getAllTruckOrder(Map<String, Object> map) {
        return omstruckOrderMapper.getAllTruckOrder(map);
    }

    /**
     * 新增运输订单
     *
     * @param map
     * @return
     */
    @Override
    @Transactional
    public int addPurOrder(Map<String, Object> map) {
        BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderType"));
        int i = 0;
        switch (orderType.intValue()) {
            case 1:
            case 2:
            case 3:
                i = dispatchSteelOrder(map);//新增焦炭发运计划订单
                break;
            case 4:
                break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 17:
            case 18:
                i = addCGPurOrders(map);
                break;
//            case 8:
//                i = addCGPurOrder(map); //新增采购运输订单
//                break;
            case 9:
                break;
            case 10:
                break;
            case 11:

        }

        return i;
    }

    /**
     * 新增采购其他订单
     * @return
     */
    public int addCGPurOrders(Map<String, Object> map){
        //从map中获取司机运力列表
        List<Map<String, Object>> driverCapacityIdList = (List<Map<String, Object>>) map.get("driverCapacityIdList");
        BigDecimal purchaseOrderId = DataChange.dataToBigDecimal(map.get("purchaseOrderId"));
        //是否一车多趟 有则更新采购订单
        Object isMoreTrips = map.get("isMoreTrips");
        if(isMoreTrips != null){
            boolean trips = (boolean) isMoreTrips;
            if(trips){
                //更新采购订单为一车多趟类型
                omstruckOrderSeparateMapper.updateAPOisMoreTrips(DataChange.dataToBigDecimal(map.get("purchaseOrderId")));
            }
        }
        //物资ID
        Object materialId = map.get("materialId");
        BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderType"));
        //预计进厂时间
        Date orderEntryTime = null;
        if(map.get("orderEntryTime") != null){
            try {
                orderEntryTime = new Date((long) map.get("orderEntryTime"));
            } catch (Exception e) {
                System.out.println("预估进厂日期转换失败");
            }
        }
        int count = 0;
        for (Map<String, Object> capacityMap : driverCapacityIdList) {
            map.put("carrierId",capacityMap.get("carrierId"));
            map.put("priceId",capacityMap.get("priceId"));
            //添加运输订单
            OmstruckOrder omstruckOrder = generateOmsTruckOrder(map);
            omstruckOrder.setOrderPlanId(purchaseOrderId);
            omstruckOrder.setCapacityId(DataChange.dataToBigDecimal(capacityMap.get("capacityId"))); //添加运力ID
            omstruckOrder.setOrderEntryTime(orderEntryTime);
            count += omstruckOrderMapper.insertSelective(omstruckOrder);
            BigDecimal orderId = omstruckOrder.getOrderId();
            //添加运输订单子表
            capacityMap.put("materialId", materialId);
            capacityMap.put("orderType", orderType);
            addOrderMaterial(capacityMap,orderId);
            //添加总实绩
            capacityMap.put("orderId", orderId);
            tmsTruckFeign.addTotalResult(capacityMap);
        }
        return count;
    }


    /**
     * 新增采购进口矿运输订单订单
     *
     * @param map
     * @return
     */
    @Transactional
    public int addCGPurOrder(Map<String, Object> map) {
        //生成运输订单号和主键
        OmstruckOrder omstruckOrder = generateOmsTruckOrder(map);
        Object orderEntryTime = map.get("orderEntryTime");
        if (orderEntryTime != null) {
            omstruckOrder.setOrderEntryTime(new Date((long) orderEntryTime)); //新增预计进厂时间
        }
        if (map.get("orderMaterialWeight") != null) {
            amsFeign.updateMaterial(map); //更改运输计划子表 增加已分配重量 减少未分配重量  feign调用ams
        }
        //添加运力Id
        BigDecimal capacityId = DataChange.dataToBigDecimal(map.get("capacityId"));
        omstruckOrder.setCapacityId(capacityId);
        //新增运输订单
        omstruckOrderMapper.insertSelective(omstruckOrder);
        //更新运力状态为待运输：2
//        map.put("capacityStatus", 2);
//        omstruckOrderMapper.updateCapacityByCarIdOrNum(map);
        //新增运输订单子表
        addOrderMaterial(map, omstruckOrder.getOrderId());
        //新增实绩总表关联订单 feign 调用truckTms
        map.put("orderId", omstruckOrder.getOrderId());
        tmsTruckFeign.addTotalResult(map);
        return 1;
    }

    /**
     * 生成运输订单实体类
     */
    public OmstruckOrder generateOmsTruckOrder(Map<String, Object> map) {
        BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderType"));
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        //生成订单主键Id
        BigDecimal maxId = omstruckOrderMapper.selectMaxId();
        omstruckOrder.setOrderId(maxId);
        //生成运输订单号
        int id = maxId.intValue();
        String orderNumber = DataChange.generateEightDigitsNumber("WYSDD", id);
        omstruckOrder.setOrderNumber(orderNumber);
        //设置线路
        omstruckOrder.setLineId(DataChange.dataToBigDecimal(map.get("lineId")));
        //添加当前订单所属承运商Id与运价ID
        Object carrierId = map.get("carrierId");
        Object priceId = map.get("priceId");
        if(carrierId != null) omstruckOrder.setCarrierId(DataChange.dataToBigDecimal(carrierId));
        if (priceId != null) omstruckOrder.setPriceId(DataChange.dataToBigDecimal(priceId));
        //运单状态 刚分配默认为未下发
        omstruckOrder.setOrderStatus(new BigDecimal(3));
        switch (orderType.intValue()) {
            case 1:
                omstruckOrder.setOrderPlanId(DataChange.dataToBigDecimal(map.get("saleOrderMaterialId")));
                break;
            case 2:
            case 3:
                omstruckOrder.setOrderPlanId(DataChange.dataToBigDecimal(map.get("dayPlanId")));
                break;
            case 4:
                break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 17:
            case 18:
                if (map.get("purchaseOrderId") != null)  omstruckOrder.setOrderPlanId(DataChange.dataToBigDecimal(map.get("purchaseOrderId"))); //订单ID
                if (map.get("unloadPointId") != null)  omstruckOrder.setUnloadPointId(DataChange.dataToBigDecimal(map.get("unloadPointId")));// 添加卸货点
                break;
            case 9:
                break;
            case 10:
                break;
            case 11:
        }
        //添加订单类型
        omstruckOrder.setOrderType(orderType);
        omstruckOrder.setInsertUsername("admin");
        omstruckOrder.setInsertTime(new Date());
        return omstruckOrder;
    }

    /**
     * 新增订单子表
     *
     * @param map
     * @param
     */
    public void addOrderMaterial(Map<String, Object> map, BigDecimal orderId) {
        BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderType"));
        OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
        switch (orderType.intValue()) {
            case 1:
                //获得销售物资id
                //生成子表主键
                omstruckOrderMaterial.setOrderMaterialId(omstruckOrderMaterialMapper.selectMaxId());
                Integer saleOrderMaterialId = (Integer) map.get("saleOrderMaterialId");
                //通过车序号id查找物资件数和物资重量
                Map<String, Object> map1 = omstruckOrderMapper.selectTheoreticalWeightAndMaterialNumber(saleOrderMaterialId);
                BigDecimal materialNumber = (BigDecimal) map1.get("materialNumber");
                BigDecimal weight = (BigDecimal) map1.get("weight");
                //设置物资理重和物资件数
                omstruckOrderMaterial.setOrderMaterialWeight(DataChange.dataToBigDecimal(weight));
                omstruckOrderMaterial.setOrderMaterialNumber(DataChange.dataToBigDecimal(materialNumber));
                //通过销售订单车序号id查找物资id
                List<Map<String, Object>> materialList = omstruckOrderMapper.selectMaterialIdBysaleOrderMaterialId(saleOrderMaterialId);
                for (int i = 0; i < materialList.size(); i++) {
                    Map<String, Object> map2 = materialList.get(i);
                    BigDecimal materialId = (BigDecimal) map2.get("materialId");
                    omstruckOrderMaterial.setMaterialId(materialId);
                }
                //执行新增
                omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
                break;
            case 2:
            case 3:
                //获取发运计划id
                //生成子表主键
                omstruckOrderMaterial.setOrderMaterialId(omstruckOrderMaterialMapper.selectMaxId());
                Integer dayPlanId = (Integer) map.get("dayPlanId");
                //设置订单id
                omstruckOrderMaterial.setOrderId(orderId);
                //根据发运计划id查找物资id和物资重量
                map = omstruckOrderMapper.selectMaterialIdAndWeightByDayPlanId(dayPlanId);
                BigDecimal materialId = (BigDecimal) map.get("materialId");
                BigDecimal materialWeight = (BigDecimal) map.get("materialWeight");
                //设置物资id
                omstruckOrderMaterial.setMaterialId(DataChange.dataToBigDecimal(materialId));
                //设置物资重量
                omstruckOrderMaterial.setOrderMaterialWeight(DataChange.dataToBigDecimal(materialWeight));
                omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
                break;
            case 4:
                break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 17:
            case 18:
                //生成子表主键
                omstruckOrderMaterial.setOrderMaterialId(omstruckOrderMaterialMapper.selectMaxId());
                omstruckOrderMaterial.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
                omstruckOrderMaterial.setOrderId(orderId);
                Object orderMaterialWeight =  map.get("orderMaterialWeight");
                if (orderMaterialWeight != null) {
                    if (orderMaterialWeight.toString().length() != 0) {
                        omstruckOrderMaterial.setOrderMaterialWeight(DataChange.dataToBigDecimal(map.get("orderMaterialWeight")));
                    }
                }
                Object orderMaterialNumber =  map.get("orderMaterialNumber");
                if(orderMaterialNumber != null ) {
                    if (orderMaterialNumber.toString().length() != 0) {
                        omstruckOrderMaterial.setOrderMaterialNumber(DataChange.dataToBigDecimal(map.get("orderMaterialNumber")));
                    }
                }
                omstruckOrderMaterial.setInsertUsername("admin");
                omstruckOrderMaterial.setInsertTime(new Date());
                omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
                break;
            case 9:
                break;
            case 10:
                break;
            case 11:
        }
    }


    /**
     * 修改运输订单 和订单子表
     *
     * @param map
     * @return
     */
    @Override
    @Transactional
    public int updateOrder(Map<String, Object> map) {
        //修改运输订单运力ID
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        BigDecimal orderType;
        if(map.get("orderType") == null){
            //查询订单类型
            orderType = new BigDecimal(omstruckOrderMapper.getOrderTypeByOrderNumber(orderId));
        }else{
            orderType = DataChange.dataToBigDecimal(map.get("orderType"));
        }
        omstruckOrder.setOrderId(orderId);
        if (map.get("unloadPointId") != null) {
            omstruckOrder.setUnloadPointId(DataChange.dataToBigDecimal(map.get("unloadPointId")));
        }
        if (map.get("capacityId") != null) {
            omstruckOrder.setCapacityId(DataChange.dataToBigDecimal(map.get("capacityId")));
        }
        if(map.get("orderEntryTime") != null){
            omstruckOrder.setOrderEntryTime(new Date((long) map.get("orderEntryTime")));
        }
        if(map.get("unloadPointId")!=null || map.get("capacityId") != null || map.get("orderEntryTime") != null){
            omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        }
        switch (orderType.intValue()) {
            case 1:
                break;
            case 2:
                break;
            case 3:
                break;
            case 4:
                break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 17:
            case 18:
                //修改运输订单子表物资重量
                OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
                //添加子表主键 通过订单ID查询出子表主键
                BigDecimal orderMaterialId = omstruckOrderMaterialMapper.getOrderMaterialIdByOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
                omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
                if (map.get("orderMaterialWeight") != null) {
                    omstruckOrderMaterial.setOrderMaterialWeight(DataChange.dataToBigDecimal(map.get("orderMaterialWeight")));
                    if(orderType.intValue() == 8)
                        amsFeign.updateMaterial(map);//修改运输计划子表 已分配未分配重量
                }
                if(map.get("orderMaterialNumber") != null) {
                    omstruckOrderMaterial.setOrderMaterialNumber(DataChange.dataToBigDecimal(map.get("orderMaterialNumber")));
                }
                if (map.get("materialId") != null) {
                    omstruckOrderMaterial.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
                }
                if(map.get("orderMaterialWeight") != null || map.get("orderMaterialNumber") != null || map.get("materialId") != null){
                    omstruckOrderMaterialMapper.updateByPrimaryKeySelective(omstruckOrderMaterial);
                }
                break;
            case 9:
                break;
            case 10:
                break;
            case 11:
        }
        return 1;
    }

    /**
     * 逻辑删除未下发订单
     *
     * @param map
     * @return
     */
    @Override
    @Transactional
    public int deleteOrder(Map<String, Object> map) {
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
        //设置状态为逻辑删除：7
        omstruckOrder.setOrderStatus(new BigDecimal(7));
        int i = omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        //若是传来物资重量则修改已分配未分配重量
        if (map.get("orderMaterialWeight") != null) {
            amsFeign.updateMaterial(map); //feign调用
        }
//        //通过车牌号修改运输状态为空闲中 0
//        String capacityNumber = (String) map.get("capacityNumber");
//        HashMap<String, Object> changeStatusMap = new HashMap<>();
//        changeStatusMap.put("capacityNumber", capacityNumber);
//        changeStatusMap.put("capacityStatus", 0);
//        int i1 = omstruckOrderMapper.updateCapacityByCarIdOrNum(changeStatusMap);
        return i;
    }

    /**
     * 运单派发、下发
     * 运单ID
     *
     * @param mapValue
     * @return
     */
    @Override
    @Transactional
    public int dispatchOrder(Map<String, Object> mapValue) {
        List<Map<String,Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");
        int result = 0;
        for (Map<String, Object> map : mapList) {
            Integer orderId = (Integer) map.get("orderId");
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            omstruckOrder.setOrderId(new BigDecimal(orderId));
            //生成订单下发时间 修改订单表
            omstruckOrder.setOrderIssueTime(new Date());
            //设置状态为已下发：4
            omstruckOrder.setOrderStatus(new BigDecimal(4));
            //下发 推送数据给 websocket
            pushMesToWebsocket(map);
            result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        }
        return result;
    }

    /**
     * 发送消息到 websocket 推送消息
     * orderId  订单Id
     * @return
     */
    public void pushMesToWebsocket(Map<String, Object> map) {
        Map<String, Object> mesMap = omstruckOrderMapper.pushMesToWebsocket(map);
        //添加消息实体
        HashMap<Object, Object> mapp = new HashMap<>();
        mapp.put("messageType", 3);
        mapp.put("sendPerson", "system");
        mapp.put("receivePerson", mesMap.get("capacityNumber"));
        mapp.put("messageContent", mesMap);
        mapp.put("createTime", new Date());
        ArrayList<Object> list = new ArrayList<>();
        list.add(mapp);
        //调用websocket接口推送
        HashMap<Object, Object> sendMap = new HashMap<>();
        //将消息实体放入list中存到map中
        sendMap.put("messages", list);
        String s = imFeign.sendToUser(sendMap);
        System.out.println(s);
    }

    @Override//判断一车多单是否还有订单，如果又就再推送消息给他
    public void pushMessageToDriver(Map<String, Object> mapValue) {
        Map<String,Object> mapAddOrder  =omstruckOrderMapper.getSporadicOrdermapAddOrder(new BigDecimal(mapValue.get("orderId").toString()));
        BigDecimal sporadicOrderTimes = DataChange.dataToBigDecimal(mapAddOrder.get("sporadicOrderTimes"));
        BigDecimal sporadicOrderId = DataChange.dataToBigDecimal(mapAddOrder.get("sporadicOrderId"));
        BigDecimal transStatus = DataChange.dataToBigDecimal(mapAddOrder.get("transStatus"));
        BigDecimal orderId = DataChange.dataToBigDecimal(mapValue.get("orderId"));
        //获取运输订单类型
        Integer orderType = omstruckOrderMapper.getOrderTypeByOrderId(orderId);
        BigDecimal capacityId = DataChange.dataToBigDecimal(mapAddOrder.get("capacityId"));
        Map<String, Object> addMapSporadicOrder = new HashMap<>();
        addMapSporadicOrder.put("sporadicOrderId",sporadicOrderId);
        addMapSporadicOrder.put("orderId",orderId);
        List<Map<String,Object>> mapList = new ArrayList<>();
        Map<String,Object> map=new HashMap<>();
        map.put("capacityId",capacityId);
        mapList.add(map);
        addMapSporadicOrder.put("mapList",mapList);
        switch (orderType) {
            case 13:
            case 19:
            case 12:
            case 14:
                if (transStatus.intValue()==1){
                    amsFeign.addSporadicOrderTimes(addMapSporadicOrder);
                }
                break;
            //普通零星
            case  15:
            case  16:
                if (sporadicOrderTimes.intValue() > 0) {
                    //mapvalue需要orderId,零星订单id，maplist放一个运力id
                    amsFeign.addSporadicOrderTimes(addMapSporadicOrder);
                }
        }
    }

    //撤销订单
    @Transactional
    @Override
    public int undoOrder(Map<String, Object> map) throws Exception{
        int result=0;
        BigDecimal orderId =DataChange.dataToBigDecimal(map.get("orderId"));
        Map<String, Object> mesMap = omstruckOrderSeparateMapper.getOrderMesByOrderId(orderId);
        BigDecimal orderPlanId = DataChange.dataToBigDecimal(mesMap.get("orderPlanId"));
        int orderType = DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue();
        BigDecimal resultTotalId = DataChange.dataToBigDecimal(mesMap.get("resultTotalId"));
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(orderId));
        omstruckOrder.setOrderStatus(new BigDecimal(4));
        //讲路段顺序号设为空，适应进厂以后扫码
        omstruckOrder.setOrderLineSequence(new BigDecimal(0));
        result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        if(orderType == 11 ){
            result += omstruckOrderMapper.deleteLoadResult(resultTotalId);
            return result ;
        }
        if (orderType==21){
            //根据总实绩id查找计时实绩id
            int timeTaskByTotalId = omstruckOrderMapper.getTimeTaskByTotalId(resultTotalId);
            if (timeTaskByTotalId!=0)
            {
                throw new Exception("已经计时开始");
            }else {
                result += omstruckOrderMapper.deleteTimeTaskByTotalId(resultTotalId);
            }
        }
        //通过总实绩ID删除所有已经生成的实绩
        result += omstruckOrderMapper.deleteEnResult(resultTotalId);
        result += omstruckOrderMapper.deleteWeightResult(resultTotalId);
        result += omstruckOrderMapper.deleteUnloadResult(resultTotalId);
        result += omstruckOrderMapper.deleteLoadResult(resultTotalId);
        result += omstruckOrderMapper.deleteLeaveResult(resultTotalId);
        if(orderType == 12 || orderType == 13 || orderType == 14 || orderType == 19){
            Map<String, Object> sporadicOrderTimes = omstruckOrderMapper.getSporadicOrderTimes(orderId);
            BigDecimal orderTimes =(BigDecimal)sporadicOrderTimes.get("orderTimes");
            BigDecimal transTimes = (BigDecimal)sporadicOrderTimes.get("transTimes");
            //更新趟次
            omstruckOrderSeparateService.updateTimes(orderPlanId,orderTimes.intValue()+1);
            //更新状态
            omstruckOrderSeparateMapper.updateSporadicStatus(orderPlanId,1);
            //更新已运输趟次
            if (transTimes.intValue()>0) {
                omstruckOrderSeparateMapper.updateTranTimes(orderPlanId, transTimes.intValue() - 1);
            }
        }

        return result;
    }
   //修改运力
    @Override
    public int updateCapacityId(Map<String,Object> map) {
        int result=0;
        OmstruckOrder omstruckOrder=new OmstruckOrder();
        BigDecimal orderId =DataChange.dataToBigDecimal(map.get("orderId"));
        BigDecimal capacityId =DataChange.dataToBigDecimal(map.get("capacityId"));
        omstruckOrder.setOrderId(orderId);
        omstruckOrder.setCapacityId(capacityId);
        result+=omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        return result;
    }

    //采购内转派单
    @Override
    public int addPurInwardOrder(Map<String, Object> mapValue) {
        int result = 0;
        List<Map<String,Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");

        BigDecimal planId = DataChange.dataToBigDecimal(mapValue.get("planId"));
        BigDecimal lineId = DataChange.dataToBigDecimal(mapValue.get("lineId"));
        BigDecimal orderType = DataChange.dataToBigDecimal(mapValue.get("orderType"));
        AmstruckInwardPlan amstruckInwardPlan = amstruckInwardPlanMapper.selectByPrimaryKey(planId);
        amstruckInwardPlan.setPlanStatus(new BigDecimal(3));
        result += amstruckInwardPlanMapper.updateByPrimaryKeySelective(amstruckInwardPlan);
        BigDecimal materialId = omstruckOrderMapper.getInwardMaterial(planId);
        for (Map<String,Object> orderMap : mapList) {
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            String capacityNumber = (String)orderMap.get("capacityNumber");
            Map<String,Object> capacityMap = new HashMap<>();
            capacityMap.put("capacityNumber",capacityNumber);
            List<RmsCapacity> rmsCapacities = rmsCapacityMapper.selectByParameters(capacityMap);
            RmsCapacity rmsCapacity = rmsCapacities.get(0);
//            rmsCapacity.setCapacityStatus(new BigDecimal(2));
            result +=rmsCapacityMapper.updateByPrimaryKeySelective(rmsCapacity);
            BigDecimal capacityId = rmsCapacity.getCapacityId();
            capacityMap.clear();
            capacityMap.put("capacityId",capacityId);
            BigDecimal orderId = omstruckOrderMapper.selectMaxId();
            // 添加总实绩
            Map<String,Object> orderIdMap = new HashMap<>();
            orderIdMap.put("orderId",orderId);
            tmsTruckFeign.addTotalResult(orderIdMap);
            omstruckOrder.setOrderId(orderId);
            omstruckOrder.setOrderPlanId(planId);
            String orderNumber = DataChange.generateEightDigitsNumber("WYSDD", orderId.intValue());
            omstruckOrder.setOrderNumber(orderNumber);
            omstruckOrder.setOrderIssueTime(new Date());
            omstruckOrder.setOrderStatus(new BigDecimal(4));
            omstruckOrder.setCapacityId(capacityId);
            omstruckOrder.setInsertTime(new Date());
            omstruckOrder.setUpdateTime(new Date());
            omstruckOrder.setInsertUsername("admin");
            omstruckOrder.setUpdateUsername("admin");
            omstruckOrder.setInsertUpdateRemark("无");
            omstruckOrder.setDeleted(new BigDecimal(0));
            omstruckOrder.setOrderType(orderType);
            omstruckOrder.setLineId(lineId);
            result +=omstruckOrderMapper.insertSelective(omstruckOrder);
            OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
            BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
            omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
            omstruckOrderMaterial.setOrderId(orderId);
            omstruckOrderMaterial.setMaterialId(materialId);
            omstruckOrderMaterial.setInsertTime(new Date());
            omstruckOrderMaterial.setUpdateTime(new Date());
            omstruckOrderMaterial.setInsertUsername("admin");
            omstruckOrderMaterial.setUpdateUsername("admin");
            omstruckOrderMaterial.setInsertUpdateRemark("无");
            result +=omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
        }
       return result;
    }

    @Override
    public List<Map<String, Object>> getPurInwardOrderList(Map<String, Object> mapValue) {
        List<Map<String,Object>> mapList = omstruckOrderMapper.getPurInwardOrderList(mapValue);
        for (Map<String,Object>map:mapList
             ) {
            map.put("loadName","化工园区铁专线");
        }
        return mapList;
    }

    @Override
    public int addPurInwardOrder1(BigDecimal orderId) {
        //根据运输订单id查询信息
        Map<String,Object>map = omstruckOrderMapper.selectOrderMap(orderId);
        BigDecimal planId = DataChange.dataToBigDecimal(map.get("planId"));
        BigDecimal lineId = DataChange.dataToBigDecimal(map.get("lineId"));
        BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderType"));
        BigDecimal capacityId = DataChange.dataToBigDecimal(map.get("capacityId"));
        BigDecimal materialId = DataChange.dataToBigDecimal(map.get("materialId"));
        int result = 0;
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        BigDecimal orderIds = omstruckOrderMapper.selectMaxId();
        // 添加总实绩
        Map<String,Object> orderIdMap = new HashMap<>();
        orderIdMap.put("orderId",orderIds);
        tmsTruckFeign.addTotalResult(orderIdMap);
        omstruckOrder.setOrderId(orderIds);
        omstruckOrder.setOrderPlanId(planId);
        String orderNumber = DataChange.generateEightDigitsNumber("WYSDD", orderIds.intValue());
        omstruckOrder.setOrderNumber(orderNumber);
        omstruckOrder.setOrderIssueTime(new Date());
        omstruckOrder.setOrderStatus(new BigDecimal(4));
        omstruckOrder.setCapacityId(capacityId);
        omstruckOrder.setInsertTime(new Date());
        omstruckOrder.setUpdateTime(new Date());
        omstruckOrder.setInsertUsername("admin");
        omstruckOrder.setUpdateUsername("admin");
        omstruckOrder.setInsertUpdateRemark("无");
        omstruckOrder.setDeleted(new BigDecimal(0));
        omstruckOrder.setOrderType(orderType);
        omstruckOrder.setLineId(lineId);
        result +=omstruckOrderMapper.insertSelective(omstruckOrder);
        OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
        BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
        omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
        omstruckOrderMaterial.setOrderId(orderIds);
        omstruckOrderMaterial.setMaterialId(materialId);
        omstruckOrderMaterial.setInsertTime(new Date());
        omstruckOrderMaterial.setUpdateTime(new Date());
        omstruckOrderMaterial.setInsertUsername("admin");
        omstruckOrderMaterial.setUpdateUsername("admin");
        omstruckOrderMaterial.setInsertUpdateRemark("无");
        result +=omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
        return result;
    }

    @Override
    public int refuseCtrlZ(Map<String, Object> map) {
        return omstruckOrderMapper.refuseCtrlZ(map);
    }

    /**
     * 销售物流，下发订单
     *
     * @param map
     * @return
     */
    @Override
    public int dispatchOrderForSale(Map<String, Object> map) {
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        Integer orderId = (Integer) map.get("orderId");
        Integer orderType = (Integer) map.get("orderType");
        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(orderId));
        if (orderType == 2 || orderType == 3) {
            Integer loadId = (Integer) map.get("LoadId");
            if (loadId != null) {
                //根据运输订单id查找装车实绩id
                omstruckOrder.setUnloadPointId(DataChange.dataToBigDecimal(loadId));

            }
        }
        //设置下发状态
        omstruckOrder.setOrderIssueTime(new Date());
        omstruckOrder.setOrderStatus(new BigDecimal(4));
//        pushMesToWebsocket(map); //下发 推送数据给 websocket
        return omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
    }

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

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

    /**
     * 司机接单、拒绝 0：拒绝   1：接收
     * 需要接收参数 主键Id 与 接收拒绝操作码
     *
     * @param map
     * @return
     */
    @Override
    @Transactional
    public synchronized int driverReceiveOrRefuse(Map<String, Object> map) throws RuntimeException {
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        if((Integer) map.get("orderReceiveStatus") == 1) {
            List<Integer> orderIdList = omstruckOrderMapper.getReceiveOrderIdListByCapacityNum((String) map.get("capacityNumber"));
            if (orderIdList.size() > 0) {
                throw  new RuntimeException("已有接收的订单！");
            }
            omstruckOrder.setOrderStatus(new BigDecimal(5)); //5 ：已接收
            //通过订单ID查询信息
            Map<String, Object> orderMessage = omstruckOrderSeparateMapper.getOrderMessagge(orderId);
            int orderStatus = DataChange.dataToBigDecimal(orderMessage.get("orderStatus")).intValue();
            if(orderStatus == 5 || orderStatus == 6) {
                throw new RuntimeException("订单已被接收或已被拒绝!");
            }
            int orderType = DataChange.dataToBigDecimal(orderMessage.get("orderType")).intValue();
            if(orderType == 11){
                //发送计量委托
                orderMessage.put("asd", 1);
                orderMessage.put("orderId", orderId);
                tmsTruckFeign.sendMeasureCommission(orderMessage);
            }else if(orderType!=21){
                //添加各个实绩
                omstruckOrderSeparateService.addAllSonResult(orderMessage);
            }
            //判断订单是否是一车多单
            if (orderType ==12 || orderType ==13 || orderType ==14 || orderType ==19) {
                //通过订单查询趟次
                Map<String, Object> sporadicOrderTimes = omstruckOrderMapper.getSporadicOrderTimes(orderId);
                BigDecimal orderTimes = DataChange.dataToBigDecimal(sporadicOrderTimes.get("orderTimes"));
                //通过订单id查询已运输趟次
                BigDecimal transTimes=DataChange.dataToBigDecimal(sporadicOrderTimes.get("transTimes"));
                //生成作业实绩之后、更改订单数量
                if (orderMessage.containsKey("orderPlanId") && orderTimes.intValue() > 0) {
                    int state =0;
                    //如果运输趟次,接完之后将变成0
                    if(orderTimes.intValue() == 1){
                        //修改零星订单运输状态
                        state +=omstruckOrderSeparateMapper.updateSporadicStatus(DataChange.dataToBigDecimal(orderMessage.get("orderPlanId")),0);
                    }
                    state+=omstruckOrderSeparateService.updateTimes(new BigDecimal(orderMessage.get("orderPlanId").toString()), orderTimes.intValue() - 1);
                    //接收订单以后已运输订单趟次+1
                    state+=omstruckOrderSeparateMapper.updateTranTimes(DataChange.dataToBigDecimal(orderMessage.get("orderPlanId").toString()),transTimes.intValue()+1);
                }
            }
        } else { //其他状态都视为 拒绝接单
            omstruckOrder.setOrderStatus(new BigDecimal(6));
            //添加拒绝原因
            omstruckOrder.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
        }
        omstruckOrder.setOrderId(orderId);
        //生成接收/拒绝时间
        Date receiveTime = new Date();
        omstruckOrder.setOrderReceiveRefuseTime(receiveTime);
        //计算司机从派单到操作时长
        Date issueTime = omstruckOrderMapper.getInsertTimeById(orderId.intValue());
        long time = receiveTime.getTime() - issueTime.getTime();
        long min = time / (1000 * 60);
        omstruckOrder.setOrderCommunicationDuration(new BigDecimal(min));
        return  omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
    }

    //根据承运商获取销售订单
    @Override
    public List<Map<String, Object>> selectSaleOrderForCarrier(Map<String, Object> map) {
        Integer carrierId = (Integer) map.get("carrierId");
        List<Map<String, Object>> maps = omstruckOrderMapper.selectSaleMaterialIdByCarrierId(carrierId);
        List<Map<String, Object>> list = null;
        for (Map<String, Object> map1 : maps) {
            BigDecimal saleOrderMaterialId = (BigDecimal) map1.get("saleOrderMaterialId");
            list = omstruckOrderMapper.selectSaleBySaleOrderMaterialId(saleOrderMaterialId.intValue());
        }
        return list;
    }

    /**
     * 查询已接收的焦炭发运计划
     *
     * @param
     * @return
     */
    @Override
    public List<Map<String, Object>> selectCokeDayPlanAndRecived(Map<String, Object> map) {
        return omstruckOrderMapper.selectCokeDayPlanAndRecived(map);
    }

    /**
     * 查询已接收的水渣发运计划
     *
     * @param
     * @return
     */
    @Override
    public List<Map<String, Object>> selectWaterSlagDayPlanAndRecived(Integer carrierId) {
        return omstruckOrderMapper.selectWaterSlagDayPlanAndRecived(carrierId);
    }

    /**
     * 司机接单推送数据
     * 车牌号
     * @param
     * @return
     */
    @Override
    public List<Map<String, Object>> sendMesToDriver(Map<String, Object> map) {
        //通过车牌号匹配运力ID
        BigDecimal capacityId = omstruckOrderMapper.getCapacityIdByCapacityNum((String) map.get("capacityNumber"));
        if (capacityId == null) {
            return null;
        }
        map.put("capacityId", capacityId);
        //通过运力Id匹配 已下发的运输订单
        List<Map<String, Object>> truckOrderByCapacityNum;
        if ((Integer) map.get("orderType") == 1 || (Integer) map.get("orderType") == 2) {
            truckOrderByCapacityNum = omstruckOrderMapper.getSaleTruckOrderByCapacityNum(map);
        } else {
            truckOrderByCapacityNum = omstruckOrderMapper.getTruckOrderByCapacityNum(map);
        }
        return truckOrderByCapacityNum;
    }

    /**
     * 得到作业时间和地点
     *
     * @param orderId
     * @return
     */
    @Override
    public List<Map<String, Object>> selectPlaceAndTime(BigDecimal orderId) {
        List<Map<String, Object>> mapList = omstruckOrderMapper.selectPlaceAndTime(orderId);
        Map<String, Object> map = mapList.get(0);
        String entryGatepost = (String) map.get("entryGatepost");
        Date entryTime = (Date) map.get("entryTime");
        String entryResult = entryGatepost + "/" + entryTime;
        String grossCalculate = (String) map.get("grossCalculate");
        Date grossTime = (Date) map.get("grossTime");
        String grossResult = grossCalculate + "/" + grossTime;
        String unloadWarhouse = (String) map.get("unloadWarhouse");
        Date unloadTime = (Date) map.get("unloadTime");
        String unloadResult = unloadWarhouse + "/" + unloadTime;
        String tareCalculate = (String) map.get("tareCalculate");
        Date tareTime = (Date) map.get("tareTime");
        String tareResult = tareCalculate + "/" + tareTime;
        String leaveGatepost = (String) map.get("leaveGatepost");
        Date outTime = (Date) map.get("outTime");
        String leaveResult = leaveGatepost + "/" + outTime;
        String receiptWarhouse = (String) map.get("receiptWarhouse");
        Date receiptTime = (Date) map.get("receiptTime");
        String receiptResult = receiptWarhouse + "/" + receiptTime;
        List<Map<String, Object>> resultList = new ArrayList<>();
        Map<String, Object> map1 = new HashMap<>();
        map1.put("title", "进厂门岗/时间");
        map1.put("desc", entryResult);
        resultList.add(map1);
        Map<String, Object> map2 = new HashMap<>();
        map2.put("title", "毛重衡器/时间");
        map2.put("desc", grossResult);
        resultList.add(map2);
        Map<String, Object> map3 = new HashMap<>();
        map3.put("title", "卸货地点/时间");
        map3.put("desc", unloadResult);
        resultList.add(map3);
        Map<String, Object> map4 = new HashMap<>();
        map4.put("title", "皮重衡器/时间");
        map4.put("desc", tareResult);
        resultList.add(map4);
        Map<String, Object> map5 = new HashMap<>();
        map5.put("title", "出厂门岗/时间");
        map5.put("desc", leaveResult);
        resultList.add(map5);
        if ((Integer) map.get("orderType") == 1) {
            Map<String, Object> map6 = new HashMap<>();
            map5.put("title", "异地库/时间");
            map5.put("desc", receiptResult);
            resultList.add(map6);
        }
        Map<String, Object> map7 = new HashMap<>();
        BigDecimal orderLineSequence = (BigDecimal) map.get("orderLineSequence");
        map7.put("orderLineSequence", orderLineSequence);
        resultList.add(map7);
        return resultList;
    }

    /**
     * 查询已下发未接受的销售订单信息
     *
     * @param orderType
     * @return
     */
    @Override
    public List<Map<String, Object>> getOrderUnReceive(BigDecimal orderType) {
        return omstruckOrderMapper.getOrderUnReceive(orderType);
    }

    /**
     * 查询已下发已接受的销售订单信息
     *
     * @param orderType
     * @return
     */
    @Override
    public List<Map<String, Object>> getOrderReceived(BigDecimal orderType) {
        return omstruckOrderMapper.getOrderReceived(orderType);
    }

    /**
     * 分派钢材销售订单
     *
     * @param map
     * @return
     */
    @Override
    public int dispatchSteelOrder(Map<String, Object> map) {
        //新增运单（销售钢材订单）
        //生成运输订单号和主键以及绑定运力
        OmstruckOrder omstruckOrder = generateOmsTruckOrder(map);
        //设置线路  遗留问题,设置为进门门岗
        omstruckOrder.setLineId(new BigDecimal(1));
        //新增运输订单
        omstruckOrderMapper.insertSelective(omstruckOrder);
        //更新运力状态为待运输：2
//        map.put("capacityStatus", 2);
//        omstruckOrderMapper.updateCapacityById(map);
        //新增运输订单子表
        addOrderMaterial(map, omstruckOrder.getOrderId());
        //新增实绩总表关联订单 feign调用
        map.put("orderId", omstruckOrder.getOrderId());
        tmsTruckFeign.addTotalResult(map);
        return 6;
    }


    //设置销售订单下发状态
    @Override
    public int IssueSteelOrder(Map<String, Object> map) {
        //设置下发状态
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        Integer orderId = (Integer) map.get("orderId");
        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(orderId));
        omstruckOrder.setOrderIssueTime(new Date());
        //设置下发状态值：4
        omstruckOrder.setOrderStatus(new BigDecimal(4));
        return 2;
    }

    //销售模块查看所有订单
    @Override
    public List<Map<String, Object>> selectAllOrderForSale(Map<String, Object> map) {
        //map获取承运商
        Integer carrierId = (Integer) map.get("carrierId");
        Integer saleOrderMaterialId = (Integer) map.get("saleOrderMaterialId");
        List<Map<String, Object>> maps = omstruckOrderMapper.selectSaleMaterialIdByCarrierId(carrierId);
        //根据车序号查找运输订单
        List<Map<String, Object>> mapList = null;
        List<Map<String, Object>> maps1 = new ArrayList<>();
        //判断获取的车序号是否属于承运商
        for (Map<String, Object> map1 : maps) {
            BigDecimal compareNum = DataChange.dataToBigDecimal(map1.get("saleOrderMaterialId"));
            if (compareNum.intValue() == saleOrderMaterialId) {
                mapList = omstruckOrderMapper.selectAllOrderForSale(map);
                for (int i = 0; i < mapList.size(); i++) {
                    Map<String, Object> map2 = mapList.get(i);
                    if (map2.get("orderId") == null) {
                        return maps1;
                    }

                }

                return mapList;
            }
        }
        return maps1;

    }

    @Override
    public List<Map<String, Object>> selectTransportOrderForSale(Map<String, Object> map) {
        String carrierSsoId = (String) map.get("carrierSsoId");
        BigDecimal carrierId = omstruckOrderMapper.getCarrierIdBySSO(carrierSsoId);
        map.put("carrierId",carrierId);
        List<Map<String, Object>> mapList = omstruckOrderMapper.selectTransportOrderForSale(map);
        int count = 1;
        for (Map<String, Object> stringObjectMap : mapList) {
            stringObjectMap.put("ROW_ID",count);
            count ++;
        }
        return mapList;
    }

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

    //根据销售订单id查找信息
    @Override
    public List<Map<String, Object>> selectInfoBySaleOrderId(Integer saleOrderId) {
        return omstruckOrderMapper.selectInfoBySaleOrderId(saleOrderId);
    }

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

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


    /**
     * 查找司机排班表信息
     *
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> selectCapacityAndDriver(Map<String, Object> map) {
        return omstruckOrderMapper.selectCapacityAndDriver(map);
    }


    /**
     * 查询所有运力信息
     *
     * @return
     */
    @Override
    public List<Map<String, Object>> getAllCapacity(Map<String, Object> map) {
        return omstruckOrderMapper.getAllCapacity(map);
    }


    /**
     * 用于后台展示司机接单未接单数据
     *
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getReceiveRefuseOrder(Map<String, Object> map) {
        return omstruckOrderMapper.getTruckOrderByCapacityNum(map);
    }


    /**
     * 通过运输订单号查询运单所有信息 包含作业路径名称
     *
     * @param map 传运输订单号
     * @return
     */
    @Override
    public List<Map<String, Object>> getOrderMesByOrderNum(Map<String, Object> map) {
        return omstruckOrderMapper.getTruckOrderByCapacityNum(map);
    }

    /**
     * 查询所有司机已拒绝的订单
     * 车牌号
     *
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getReceiveRefuseOrderByCapacityId(Map<String, Object> map) {
        //通过车牌号查询运力Id
        BigDecimal capacityId = omstruckOrderMapper.getCapacityIdByCapacityNum((String) map.get("capacityNumber"));
        map.put("capacityId", capacityId);
        return omstruckOrderMapper.getReceiveRefuseOrderByCapacityId(map);
    }


    /**
     * 通过运单号查询订单详情
     * 运输订单号
     *
     * @param
     * @return
     */
    @Override
    public List<Map<String, Object>> getOrderByOrderId(BigDecimal orderId) {
        return omstruckOrderMapper.getOrderByOrderId(orderId);
    }

    /**
     * 查看运输派单
     *
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getTransportDispatch(Map<String, Object> map) {
        return  omstruckOrderMapper.getTransportDispatch(map);
    }

    /**
     * 用于更新路段顺序号
     *
     * @param map orderId
     * @return
     */
    public int updateOrderLineSequence(Map<String, Object> map, Integer lineSequence) {
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
        omstruckOrder.setOrderLineSequence(new BigDecimal(lineSequence));
        return omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
    }

    //新增内转运输订单
    @Override
    public int insert(OmstruckOrder omstruckOrder) {
        //生成订单主键Id
        BigDecimal maxId = omstruckOrderMapper.selectMaxId();
        omstruckOrder.setOrderId(maxId);
        //生成运输订单号
        int id = maxId.intValue();
        String orderNumber = DataChange.generateEightDigitsNumber("WYSDD", id);
        omstruckOrder.setOrderNumber(orderNumber);
        //设置状态为未下发
        omstruckOrder.setOrderStatus(new BigDecimal(3));
        //设置运输订单的类型
        omstruckOrder.setOrderType(new BigDecimal(11));
        omstruckOrder.setInsertTime(new Date());
        omstruckOrder.setInsertUsername("admin");
        return omstruckOrderMapper.insertSelective(omstruckOrder);
    }


    //通过物资id查询批次表匹配最新的批次，关联最新的采购订单号
    @Override
    public Map<String, Object> selectNewOrderId(Map<String, Object> map) {
        return omstruckOrderMapper.selectNewOrderId(map);
    }

    //app司机接单查询数据
    @Override
    public Map<String, Object> sendMesToDriverApp(Map<String, Object> map) {
        //通过车牌号匹配运力ID
        BigDecimal capacityId = omstruckOrderMapper.getCapacityIdByCapacityNum((String) map.get("capacityNumber"));
        map.put("capacityId", capacityId);
        if (capacityId == null) {
            return null;
        }
        //通过运力Id匹配 已下发的运输订单
        Map<String, Object> truckOrderByCapacityNum = new HashMap<>();
        if ((Integer) map.get("orderType") == 1 || (Integer) map.get("orderType") == 2) {
            //查询主干信息
            Map<String, Object> map1 = omstruckOrderMapper.getSaleTruckOrderByCapacityId(map);
            //查询物资信息
            List<Map<String, Object>> mapList = omstruckOrderMapper.getSaleTruckOrderByCapacityNumMaterial(map);
            truckOrderByCapacityNum.put("orderf", map1);
            truckOrderByCapacityNum.put("materialList", mapList);
        }
        return truckOrderByCapacityNum;

    }


    @Override
    public BigDecimal selectCapacityId(BigDecimal carrierId, String capacityNumber) {
        return omstruckOrderMapper.selectCapacityId(carrierId, capacityNumber);
    }

    /**
     * 车牌号下拉
     *
     * @return
     */
    @Override
    public List<Map<String, Object>> getDriverCapacity() {
        return omstruckOrderMapper.getDriverCapacity();
    }

    /**
     * 派单信息
     *
     * @param dispatchId
     * @return
     */
    @Override
    public Map<String, Object> getTruckNoDispatchMap(Integer dispatchId) {
        Map<String, Object> map = omstruckOrderMapper.getTruckNoDispatchMap(new BigDecimal(dispatchId));
        List<BigDecimal> orderIdList = omstruckOrderMapper.getNullOrNotNull(new BigDecimal(dispatchId));
        if (orderIdList != null || orderIdList.size() != 0) {
            return null;
        }
        List<Map<String, Object>> materialMessages = omstruckOrderMapper.getMaterialMessages(new BigDecimal(dispatchId));
        String allMaterialName = "";
        String allMaterialNumber = "";
        String allMaterialTheoreticalWeight = "";
        String allMaterialSpecificationModel = "";
        if (materialMessages == null || materialMessages.size() == 0) {
        } else {
            for (Map<String, Object> materialMap : materialMessages) {
                if (materialMap != null) {
                    String materialName = (String) materialMap.get("materialName");
                    allMaterialName += materialName + "/";
                    String materialTheoreticalWeight = materialMap.get("materialTheoreticalWeight").toString();
                    if (materialTheoreticalWeight != null) {
                        allMaterialTheoreticalWeight += materialTheoreticalWeight + "/";
                    }
                    String saleOrderMaterialNumber = materialMap.get("saleOrderMaterialNumber").toString();
                    allMaterialNumber += saleOrderMaterialNumber + "/";
                    String specificationModel = materialMap.get("specificationModel").toString();
                    if (specificationModel != null) {
                        allMaterialSpecificationModel += specificationModel + "/";
                    }
                }
            }
            String subMaterialName = null;
            String subMaterialNumber = null;
            String subMaterialTheoreticalWeight = null;
            String subMaterialSpecificationModel = null;
            if (allMaterialName.length() >= 2) {
                subMaterialName = allMaterialName.substring(0, allMaterialName.length() - 2);
            }
            if (allMaterialName.length() < 2) {
                subMaterialName = allMaterialName;
            }
            if (allMaterialNumber.length() >= 2) {
                subMaterialNumber = allMaterialNumber.substring(0, allMaterialNumber.length() - 2);
            }
            if (allMaterialNumber.length() < 2) {
                subMaterialNumber = allMaterialNumber;
            }
            if (allMaterialTheoreticalWeight.length() >= 2) {
                subMaterialTheoreticalWeight = allMaterialTheoreticalWeight.substring(0, allMaterialTheoreticalWeight.length() - 2);
            }
            if (allMaterialTheoreticalWeight.length() < 2) {
                subMaterialTheoreticalWeight = allMaterialTheoreticalWeight;
            }
            if (allMaterialSpecificationModel.length() >= 2) {
                subMaterialSpecificationModel = allMaterialSpecificationModel.substring(0, allMaterialSpecificationModel.length() - 2);
            }
            if (allMaterialSpecificationModel.length() < 2) {
                subMaterialSpecificationModel = allMaterialSpecificationModel;
            }
            map.put("allMaterialName", subMaterialName);
            map.put("allMaterialNumber", subMaterialNumber);
            map.put("allMaterialTheoreticalWeight", subMaterialTheoreticalWeight);
            map.put("allMaterialSpecificationModel", subMaterialSpecificationModel);
        }
        return map;
    }

    /**
     * 承运商分派运输订单给司机
     * @param dispatchId
     * @param orderType
     * @param capacityNumber
     * @param carrierId
     * @return
     */
    @Override
    public int addAppTruckOrder(Integer dispatchId, Integer orderType, String capacityNumber, Integer carrierId) {
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        BigDecimal orderId = omstruckOrderMapper.selectMaxId();
        Map<String,Object> orderIdMap = new HashMap<>();
        orderIdMap.put("orderId",orderId);
        tmsTruckFeign.addTotalResult(orderIdMap);
        omstruckOrder.setOrderId(orderId);
        BigDecimal saleOrderMaterialId = omstruckOrderMapper.getSaleMaterialId(new BigDecimal(dispatchId));
        omstruckOrder.setOrderPlanId(saleOrderMaterialId);
        String orderNumber = DataChange.generateEightDigitsNumber("WYSDD", orderId.intValue());
        omstruckOrder.setOrderNumber(orderNumber);
        omstruckOrder.setOrderIssueTime(new Date());
        omstruckOrder.setOrderStatus(new BigDecimal(4));
        omstruckOrder.setInsertTime(new Date());
        omstruckOrder.setUpdateTime(new Date());
        omstruckOrder.setInsertUsername("admin");
        omstruckOrder.setUpdateUsername("admin");
        omstruckOrder.setInsertUpdateRemark("无");
        omstruckOrder.setDeleted(new BigDecimal(0));
        omstruckOrder.setOrderType(new BigDecimal(orderType));
        BigDecimal capacityId = omstruckOrderMapper.getCapacityId(capacityNumber);
        omstruckOrder.setCapacityId(capacityId);
//        omstruckOrder.setCarrierId();
//        BigDecimal driverCapacityId = omstruckOrderMapper.getDriverCapacityId(capacityId);
//        omstruckOrder.setDriverCapacityId(driverCapacityId);
//        RmsDriverCapacity rmsDriverCapacity = rmsDriverCapacityMapper.selectByPrimaryKey(driverCapacityId);
//        rmsDriverCapacity.setCarrierId(new BigDecimal(carrierId));
//        rmsDriverCapacityMapper.updateByPrimaryKeySelective(rmsDriverCapacity);
        List<Map<String, Object>> mapList = omstruckOrderMapper.getMaterialMessages(new BigDecimal(dispatchId));
        if (mapList != null && mapList.size() != 0) {
            for (Map<String, Object> map : mapList) {
                OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
                BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
                omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
                omstruckOrderMaterial.setOrderId(orderId);
                omstruckOrderMaterial.setInsertTime(new Date());
                omstruckOrderMaterial.setUpdateTime(new Date());
                omstruckOrderMaterial.setInsertUsername("admin");
                omstruckOrderMaterial.setUpdateUsername("admin");
                omstruckOrderMaterial.setInsertUpdateRemark("无");
                if (map != null) {
                    BigDecimal materialTheoreticalWeight = (BigDecimal) map.get("materialTheoreticalWeight");
                    BigDecimal saleOrderMaterialNumber = (BigDecimal) map.get("saleOrderMaterialNumber");
                    BigDecimal materialId = (BigDecimal) map.get("materialId");
                    omstruckOrderMaterial.setOrderMaterialWeight(materialTheoreticalWeight);
                    omstruckOrderMaterial.setMaterialId(materialId);
                    omstruckOrderMaterial.setOrderMaterialNumber(saleOrderMaterialNumber);
                }
                omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
            }
        }
//        RmsCapacity rmsCapacity = new RmsCapacity();
//        rmsCapacity.setCapacityId(capacityId);
//        rmsCapacity.setCapacityStatus(new BigDecimal(2));
//        rmsCapacityMapper.updateByPrimaryKeySelective(rmsCapacity);
        int result = omstruckOrderMapper.insertSelective(omstruckOrder);
        // 调用websocket推送数据给司机
        pushMesToWebsocket(orderIdMap);
        return result;
    }

    /**
     * 根据运单id关闭订单
     * @param orderId
     * @return
     */
    @Override
    public int closeOmstruckOrder(BigDecimal orderId) {
        OmstruckOrder omstruckOrder = omstruckOrderMapper.selectByPrimaryKey(orderId);
        omstruckOrder.setOrderStatus(new BigDecimal(7));
        int result = omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        return result;
    }

    /**
     * 查询所有车牌号和司机
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getCapacityAndDriverList(Map<String, Object> mapValue) {
        return omstruckOrderMapper.getCapacityAndDriver(mapValue);
    }

    @Override
    public int closeOrder(Map<String, Object> map) {
        Integer orderId =(Integer) map.get("orderId");
        OmstruckOrder omstruckOrder=new OmstruckOrder();
        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(orderId));
        omstruckOrder.setOrderStatus(new BigDecimal(8));
        omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        return 1;
    }

    /**
     * 分解内转计划（新增运输订单）
     * @param mapValue
     * @return
     */
    @Transactional
    @Override
    public int addInwardOrder(Map<String, Object> mapValue) {
        int result = 0;
        BigDecimal orderType;
        List<Map<String,Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");
        BigDecimal planId = DataChange.dataToBigDecimal(mapValue.get("planId")) ;
        BigDecimal lineId = DataChange.dataToBigDecimal(mapValue.get("lineId")) ;
        orderType = DataChange.dataToBigDecimal(mapValue.get("orderType"));
        String userId=(String) mapValue.get("userId");
        //根据计划查找需求，如果是计时，就添加新的订单类型
        String inwardType = amstruckInwardPlanMapper.getInwardByPlanId(planId);
        if (inwardType.equals("计时")) {
            mapValue.remove(orderType);
            orderType = BigDecimal.valueOf(21);
            mapValue.put("orderType", orderType);
        }
        Integer carrierId = (Integer) mapValue.get("carrierId");
        AmstruckInwardPlan amstruckInwardPlan = amstruckInwardPlanMapper.selectByPrimaryKey(planId);
        amstruckInwardPlan.setPlanStatus(new BigDecimal(3));
        result += amstruckInwardPlanMapper.updateByPrimaryKeySelective(amstruckInwardPlan);
        for (Map<String,Object> orderMap : mapList) {
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            omstruckOrder.setInsertUsername(userId);
            String capacityNumber = (String)orderMap.get("capacityNumber");
            List<Map<String,Object>>orderMaterialList = (List<Map<String,Object>>)orderMap.get("orderMaterialList");
            Map<String,Object> capacityMap = new HashMap<>();
            capacityMap.put("capacityNumber",capacityNumber);
            List<RmsCapacity> rmsCapacities = rmsCapacityMapper.selectByParameters(capacityMap);
            RmsCapacity rmsCapacity = rmsCapacities.get(0);
//            rmsCapacity.setCapacityStatus(new BigDecimal(2));
            result +=rmsCapacityMapper.updateByPrimaryKeySelective(rmsCapacity);
            BigDecimal capacityId = rmsCapacity.getCapacityId();
            capacityMap.clear();
            capacityMap.put("capacityId",capacityId);
            BigDecimal orderId = omstruckOrderMapper.selectMaxId();
            // 添加总实绩
            Map<String,Object> orderIdMap = new HashMap<>();
            orderIdMap.put("orderId",orderId);
            tmsTruckFeign.addTotalResult(orderIdMap);
            omstruckOrder.setOrderId(orderId);
            omstruckOrder.setOrderPlanId(planId);
            String orderNumber = DataChange.generateEightDigitsNumber("WYSDD", orderId.intValue());
            omstruckOrder.setOrderNumber(orderNumber);
            omstruckOrder.setOrderIssueTime(new Date());
            omstruckOrder.setOrderStatus(new BigDecimal(4));
            omstruckOrder.setCapacityId(capacityId);
            omstruckOrder.setInsertTime(new Date());
            omstruckOrder.setUpdateTime(new Date());
            omstruckOrder.setInsertUpdateRemark("无");
            omstruckOrder.setDeleted(new BigDecimal(0));
            omstruckOrder.setOrderType(orderType);
            if(lineId != null){
                omstruckOrder.setLineId(lineId);
            }
            omstruckOrder.setCarrierId(new BigDecimal(carrierId));
            result +=omstruckOrderMapper.insertSelective(omstruckOrder);
            for (Map<String,Object>orderMaterial:orderMaterialList
            ) {
                OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
                BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
                BigDecimal materialId = DataChange.dataToBigDecimal(orderMaterial.get("materialId"));
                omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
                omstruckOrderMaterial.setOrderId(orderId);
                omstruckOrderMaterial.setMaterialId(materialId);
                if (orderMaterial.get("materialCount")!=null) {
                    omstruckOrderMaterial.setOrderMaterialNumber(DataChange.dataToBigDecimal(orderMaterial.get("materialCount")));
                }
                omstruckOrderMaterial.setInsertTime(new Date());
                omstruckOrderMaterial.setInsertUsername(userId);
                omstruckOrderMaterial.setUpdateTime(new Date());
                if (orderMaterial.get("materialWeight")!=null) {
                    omstruckOrderMaterial.setOrderMaterialWeight(DataChange.dataToBigDecimal(orderMaterial.get("materialWeight")));
                }
                result +=omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
            }
        }
        return result;
    }

    /**
     * 查询分解计划
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getInwardOrderList(Map<String, Object> mapValue) {
        List<Map<String,Object>> mapList = omstruckOrderMapper.getInwardOrderList(mapValue);
        return mapList;
    }

    /**
     * 下发计划
     * @param mapList
     * @return
     */
    @Override
    public int issuePlanOrder(List<Map<String, Object>> mapList) {
        int result = 0;
        for (Map<String,Object> map : mapList) {
            Integer orderId = (Integer) map.get("orderId");
            OmstruckOrder omstruckOrder = omstruckOrderMapper.selectByPrimaryKey(new BigDecimal(orderId));
            omstruckOrder.setOrderStatus(new BigDecimal(4));
            omstruckOrder.setOrderIssueTime(new Date());
            result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        }
        return result;
    }

    /**
     * 分派计划
     * @param mapList
     * @return
     */
    @Override
    public int apportionInwardOrder(List<Map<String, Object>> mapList) {
        int result = 0;
        for (Map<String,Object> map : mapList) {
            BigDecimal orderId = new BigDecimal((Integer) map.get("orderId"));
            OmstruckOrder omstruckOrder = omstruckOrderMapper.selectByPrimaryKey(orderId);
            omstruckOrder.setOrderIssueTime(new Date());
            omstruckOrder.setOrderStatus(new BigDecimal(4));
//            Map<Object, Object> map9 = new HashMap<>();
//            long data = new Date().getTime();
//            //根据运输订单id查询车牌号
//            String capacityNumber = omstruckOrderMapper.selectCapacityNumber(orderId);
//            BigDecimal orderType = omstruckOrderMapper.selectOrderType(orderId);
//
//            map9.put("receivePerson",capacityNumber);
//            map9.put("messageType",2);
//            map9.put("snedPerson","system");
//            map9.put("creatTime",data);

            result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        }
        return result;
    }

    /**
     * 司机APP端查询下发给自己运输订单
     * @param capacityNumber
     * @return
     */
    @Override
    public List<Map<String, Object>> sendOrderToApp(String capacityNumber) {
        //通过车牌号匹配运力ID
        BigDecimal capacityId = omstruckOrderMapper.getCapacityIdByCapacityNum(capacityNumber);
        List<Map<String,Object>> resultList = omstruckOrderMapper.getResultList(capacityId);
        for (Map<String,Object> map : resultList) {
            BigDecimal orderId = (BigDecimal) map.get("orderId");
            BigDecimal orderType = (BigDecimal) map.get("orderType");
            // 查询物资信息
            List<Map<String,Object>> materialMapList = omstruckOrderMapper.getMaterialMes(orderId);
            String allMaterialName = "";
            String allMaterialNumber = "";
            String allMaterialWeight = "";
            String allMaterialSpecificationModel = "";
            // 对物资信息进行处理
            if (materialMapList == null && materialMapList.size() == 0) {
            } else {
                for (Map<String,Object> materialMap : materialMapList) {
                    String materialName = (String) materialMap.get("materialName");
                    BigDecimal materialNumber =  (BigDecimal) materialMap.get("materialNumber");
                    BigDecimal materialWeight =  (BigDecimal) materialMap.get("materialWeight");
                    String materialModel = (String) materialMap.get("materialModel");
                    String materialSpecification = (String) materialMap.get("materialSpecification");
                    if (materialName != null) {
                        allMaterialName += materialName + "/";
                    }
                    if (materialNumber != null) {
                        allMaterialNumber += materialNumber.toString() + "/";
                    }
                    if (materialWeight != null) {
                        allMaterialWeight += materialWeight.toString() + "/";
                    }
                    if (materialSpecification != null || materialModel != null) {
                        allMaterialSpecificationModel += materialSpecification + materialModel + "/";
                    }
                }
                String subMaterialName = "";
                String subMaterialNumber = "";
                String subMaterialWeight = "";
                String subMaterialSpecificationModel = "";
                if (allMaterialName.length() >= 2) {
                    subMaterialName = allMaterialName.substring(0, allMaterialName.length() - 2);
                }
                if (allMaterialName.length() < 2) {
                    subMaterialName = allMaterialName;
                }
                if (allMaterialNumber.length() >= 2) {
                    subMaterialNumber = allMaterialNumber.substring(0, allMaterialNumber.length() - 1);
                }
                if (allMaterialNumber.length() < 2) {
                    subMaterialNumber = allMaterialNumber;
                }
                if (allMaterialWeight.length() >= 2) {
                    subMaterialWeight = allMaterialWeight.substring(0, allMaterialWeight.length() - 1);
                }
                if (allMaterialWeight.length() < 2) {
                    subMaterialWeight = allMaterialWeight;
                }
                if (allMaterialSpecificationModel.length() >= 2) {
                    subMaterialSpecificationModel = allMaterialSpecificationModel.substring(0, allMaterialSpecificationModel.length() - 2);
                }
                if (allMaterialSpecificationModel.length() < 2) {
                    subMaterialSpecificationModel = allMaterialSpecificationModel;
                }
                map.put("allMaterialName", subMaterialName);
                map.put("allMaterialNumber", subMaterialNumber);
                map.put("allMaterialWeight", subMaterialWeight);
                map.put("allMaterialSpecificationModel", subMaterialSpecificationModel);
            }
            Map<String,Object> orderMap = null;
            int intValue = orderType.intValue();
            if (intValue == 1 || intValue == 2 || intValue == 3) {
                orderMap = omstruckOrderMapper.getSaleOrderMap(orderId);
            }
            if (intValue == 4) {
                orderMap = omstruckOrderMapper.getSteelInwardOrderMap(orderId);
            }
            if (intValue == 5 || intValue == 6 || intValue == 7 || intValue == 8) {
                orderMap = omstruckOrderMapper.getPurchaseOrderMap(orderId);
            }
            if (intValue == 9 || intValue == 10 || intValue == 11) {
                orderMap = omstruckOrderMapper.getInwardOrderMap(orderId);
            }
            map.putAll(orderMap);
        }
        return resultList;
    }

    //新增内转异地库计划订单(新增运输订单)
    @Override
    public int apportionInwardOffsetOrder(Map<String, Object> mapValue) {
        int result = 0;
        List<Map<String,Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");
        String dayPlanId = (String) mapValue.get("dayPlanId");
        Integer lineId = (Integer) mapValue.get("lineId");
        String orderType = (String) mapValue.get("orderType");
//        Integer carrierId = (Integer) mapValue.get("carrierId");
//        AmstruckInwardPlan amstruckInwardPlan = amstruckInwardPlanMapper.selectByPrimaryKey(new BigDecimal(planId));
//        amstruckInwardPlan.setPlanStatus(new BigDecimal(3));
//        result += amstruckInwardPlanMapper.updateByPrimaryKeySelective(amstruckInwardPlan);
        BigDecimal materialId = omstruckOrderMapper.getInwardMaterial(new BigDecimal(dayPlanId));
        for (Map<String,Object> orderMap : mapList) {
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            String capacityNumber = (String)orderMap.get("capacityNumber");
            BigDecimal materialNumber = DataChange.dataToBigDecimal(orderMap.get("materialNumber")) ;
//            BigDecimal materialWeight = DataChange.dataToBigDecimal(orderMap.get("materialWeight"));
            Map<String,Object> capacityMap = new HashMap<>();

            capacityMap.put("capacityNumber",capacityNumber);
            List<RmsCapacity> rmsCapacities = rmsCapacityMapper.selectByParameters(capacityMap);
            RmsCapacity rmsCapacity = rmsCapacities.get(0);
            rmsCapacity.setCapacityStatus(new BigDecimal(2));
            result +=rmsCapacityMapper.updateByPrimaryKeySelective(rmsCapacity);
            BigDecimal capacityId = rmsCapacity.getCapacityId();
            capacityMap.clear();
            capacityMap.put("capacityId",capacityId);
            List<RmsDriverCapacity> rmsDriverCapacities = rmsDriverCapacityMapper.selectByParameters(capacityMap);
            RmsDriverCapacity rmsDriverCapacity = rmsDriverCapacities.get(0);
            BigDecimal dcId = rmsDriverCapacity.getDriverCapacityId();
            if(dcId!=null){
                BigDecimal orderId = omstruckOrderMapper.selectOrderId(dcId);
                OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
                BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
                omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
                omstruckOrderMaterial.setOrderId(orderId);
                omstruckOrderMaterial.setMaterialId(materialId);
                omstruckOrderMaterial.setOrderMaterialNumber(materialNumber);
                omstruckOrderMaterial.setInsertTime(new Date());
                omstruckOrderMaterial.setUpdateTime(new Date());
                omstruckOrderMaterial.setInsertUsername("admin");
                omstruckOrderMaterial.setUpdateUsername("admin");
                omstruckOrderMaterial.setInsertUpdateRemark("无");
            }
//            rmsDriverCapacity.setCarrierId(new BigDecimal(carrierId));
            result +=rmsDriverCapacityMapper.updateByPrimaryKeySelective(rmsDriverCapacity);
            BigDecimal orderId = omstruckOrderMapper.selectMaxId();
            omstruckOrder.setOrderId(orderId);
            omstruckOrder.setOrderPlanId(new BigDecimal(dayPlanId));
            String orderNumber = DataChange.generateEightDigitsNumber("WYSDD", orderId.intValue());
            omstruckOrder.setOrderNumber(orderNumber);
            omstruckOrder.setOrderIssueTime(new Date());
            omstruckOrder.setOrderStatus(new BigDecimal(3));
            omstruckOrder.setInsertTime(new Date());
            omstruckOrder.setUpdateTime(new Date());
            omstruckOrder.setInsertUsername("admin");
            omstruckOrder.setUpdateUsername("admin");
            omstruckOrder.setInsertUpdateRemark("无");
            omstruckOrder.setDeleted(new BigDecimal(0));
            omstruckOrder.setOrderType(new BigDecimal(orderType));
            omstruckOrder.setLineId(new BigDecimal(lineId));
            result +=omstruckOrderMapper.insertSelective(omstruckOrder);
            OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
            BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
            omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
            omstruckOrderMaterial.setOrderId(orderId);
            omstruckOrderMaterial.setMaterialId(materialId);
            omstruckOrderMaterial.setOrderMaterialNumber(materialNumber);
            omstruckOrderMaterial.setInsertTime(new Date());
            omstruckOrderMaterial.setUpdateTime(new Date());
            omstruckOrderMaterial.setInsertUsername("admin");
            omstruckOrderMaterial.setUpdateUsername("admin");
            omstruckOrderMaterial.setInsertUpdateRemark("无");
//            omstruckOrderMaterial.setOrderMaterialWeight(materialWeight);
            result +=omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
        }
        return result;



    }

    /**
     * 查询运单下的所有信息
     * @param capacityNumber
     * @return
     */
    @Override
    public List<Map<String, Object>> getAllOrderMessage(String capacityNumber) {
        List<Map<String, Object>> resultList;
        // 判断是走采购，销售还是内转
        resultList = omstruckOrderMapper.getResultListByCapacity(capacityNumber);
        // 如果不是内转则取下面的orderId和orderType
        if (resultList == null || resultList.size() == 0) {
            //通过车牌号匹配运力ID
            BigDecimal capacityId = omstruckOrderMapper.getCapacityIdByCapacityNum(capacityNumber);
            BigDecimal driverCapacityId = omstruckOrderMapper.getDriverCapacityId(capacityId);
            resultList = omstruckOrderMapper.getResultList(driverCapacityId);
        }
        // 循环遍历出每一条运输订单的信息
        for (Map<String, Object> map : resultList) {
            BigDecimal orderId = (BigDecimal) map.get("orderId");
            BigDecimal orderType = (BigDecimal) map.get("orderType");
            // 查询物资信息
            List<Map<String, Object>> materialMapList = omstruckOrderMapper.getMaterialMes(orderId);
            String allMaterialName = "";
            String allMaterialNumber = "";
            String allMaterialWeight = "";
            String allMaterialSpecificationModel = "";
            // 对物资信息进行处理
            if (materialMapList == null && materialMapList.size() == 0) {
            } else {
                for (Map<String, Object> materialMap : materialMapList) {
                    String materialName = (String) materialMap.get("materialName");
                    BigDecimal materialNumber = (BigDecimal) materialMap.get("materialNumber");
                    BigDecimal materialWeight = (BigDecimal) materialMap.get("materialWeight");
                    String materialModel = (String) materialMap.get("materialModel");
                    String materialSpecification = (String) materialMap.get("materialSpecification");
                    if (materialName != null) {
                        allMaterialName += materialName + "/";
                    }
                    if (materialNumber != null) {
                        allMaterialNumber += materialNumber.toString() + "/";
                    }
                    if (materialWeight != null) {
                        allMaterialWeight += materialWeight.toString() + "/";
                    }
                    if (materialSpecification != null || materialModel != null) {
                        allMaterialSpecificationModel += materialSpecification + materialModel + "/";
                    }
                }
                String subMaterialName = "";
                String subMaterialNumber = "";
                String subMaterialWeight = "";
                String subMaterialSpecificationModel = "";
                if (allMaterialName.length() >= 2) {
                    subMaterialName = allMaterialName.substring(0, allMaterialName.length() - 2);
                }
                if (allMaterialName.length() < 2) {
                    subMaterialName = allMaterialName;
                }
                if (allMaterialNumber.length() >= 2) {
                    subMaterialNumber = allMaterialNumber.substring(0, allMaterialNumber.length() - 1);
                }
                if (allMaterialNumber.length() < 2) {
                    subMaterialNumber = allMaterialNumber;
                }
                if (allMaterialWeight.length() >= 2) {
                    subMaterialWeight = allMaterialWeight.substring(0, allMaterialWeight.length() - 1);
                }
                if (allMaterialWeight.length() < 2) {
                    subMaterialWeight = allMaterialWeight;
                }
                if (allMaterialSpecificationModel.length() >= 2) {
                    subMaterialSpecificationModel = allMaterialSpecificationModel.substring(0, allMaterialSpecificationModel.length() - 2);
                }
                if (allMaterialSpecificationModel.length() < 2) {
                    subMaterialSpecificationModel = allMaterialSpecificationModel;
                }
                map.put("allMaterialName", subMaterialName);
                map.put("allMaterialNumber", subMaterialNumber);
                map.put("allMaterialWeight", subMaterialWeight);
                map.put("allMaterialSpecificationModel", subMaterialSpecificationModel);
            }
            Map<String, Object> orderMap = null;
            int intValue = orderType.intValue();
            if (intValue == 1 || intValue == 2 || intValue == 3) {
                orderMap = omstruckOrderMapper.getSaleMap(orderId);
            }
            if (intValue == 4) {
                orderMap = omstruckOrderMapper.getSteelInwardMap(orderId);
            }
            if (intValue == 5 || intValue == 6 || intValue == 7 || intValue == 8) {
                orderMap = omstruckOrderMapper.getPurchaseMap(orderId);
            }
            if (intValue == 9 || intValue == 10 || intValue == 11) {
                orderMap = omstruckOrderMapper.getInwardMap(orderId);
            }
            map.putAll(orderMap);
        }
        return resultList;
    }
    /**
     * 司机确认订单
     * orderNumber 运输订单号
     * @param map
     * @return
     */
    @Override
    public int driverConfirmation(Map<String, Object> map) {
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        BigDecimal orderId;
        //通过运输订单号查询运输订单Id
        if(map.get("orderId") == null){
            orderId = new BigDecimal(omstruckOrderMapper.getOrderIdByOrderNumber((String) map.get("orderNumber")));
        }else {
            orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        }
        Map<String, Object> seqMap = omstruckOrderMapper.getMaxLineSeqByOrderId(orderId);
        if(seqMap != null){
            //如果没有到最后一步之前 不允许确认
            BigDecimal orderLineSequence = DataChange.dataToBigDecimal(seqMap.get("orderLineSequence"));
            BigDecimal maxSegmentSqe = DataChange.dataToBigDecimal(seqMap.get("segmentSqe"));
            int i = maxSegmentSqe.intValue() - orderLineSequence.intValue();
            if( i != 1){
                return 0;
            }
        }

        omstruckOrder.setOrderId(orderId);
        //设置司机确认订单
        omstruckOrder.setDriverConfirmation(new BigDecimal(1));
        omstruckOrder.setUpdateTime(new Date());
        return omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
    }

    /**
     * 查询订单是否确认
     * @Author TXF
     * @Date 2022/1/4 23:36
     * @param map {orderId}
     * @return
     **/
    public boolean getDriverConfirmation(Map<String, Object> map){
        Integer driverConfirmation = omstruckOrderMapper.getDriverConfirmation(DataChange.dataToBigDecimal(map.get("orderId")));
        if(driverConfirmation == null){
            return true;
        }else {
            return false;
        }
    }

    /**
     * 通过运输订单号查询订单信息给司机
     * @param map
     * @return
     */
    public Map<String, Object> getMessageToApp(Map<String, Object> map){
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        Integer orderType;
        String inwardType="";
        //获取订单类型
        if(map.get("orderType") == null){
            orderType = omstruckOrderMapper.getOrderTypeByOrderNumber(orderId);
        }else {
            orderType = DataChange.dataToBigDecimal(map.get("orderType")).intValue();
        }
        Map<String, Object> mesMap = new HashMap<>();
        switch (orderType){
            case 1:
            case 2:
                mesMap = omstruckOrderMapper.getXSOrderMessageToApp(map);
                break;
            case 3:
            case 4:
                mesMap = omstruckOrderMapper.getFYJHOrderMessageToApp(map);
                break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 17:
            case 18:
                mesMap = omstruckOrderMapper.getCGOrderMessageToApp(map);
                break;
            case 9:
            case 10:
            case 20:
                mesMap = omstruckOrderMapper.getNZOrderMessageToApp(map);
                mesMap.put("loadName","化工园区铁专线");
                BigDecimal organizationId =(BigDecimal) mesMap.get("organizationId");
                if (organizationId.intValue()==1){
                    mesMap.put("organizationCode","一厂");
                }else if (organizationId.intValue()==2){
                    mesMap.put("organizationCode","二厂");
                }
                break;
            case 11:
                mesMap = omstruckOrderMapper.getInwardOrderMessageToApp(map);
                inwardType += "计重";
                mesMap.put("inwardType", inwardType);
                break;
            case 21:
                mesMap = omstruckOrderMapper.getInwardTimeOrderMessageToApp(map);
                inwardType += "计时";
                mesMap.put("inwardType", inwardType);
                break;
            case 12:
            case 13:
            case 14:
                mesMap = omstruckOrderMapper.getSporadicOrder(map);
                break;
            case 19:
                 mesMap=omstruckOrderMapper.getSporadicOrder(map);
                 mesMap.put("type", "零星退货");
        }
        mesMap.put("materialMesList", omstruckOrderMapper.getMaterialMes(orderId));

        return mesMap;
    }


    /**
     * 通过车牌号查询所有已下发未接收的订单信息
     * @param map
     * @return
     */
    public List<Map<String, Object>> getAllOrderMessagesByCapacityNum(Map<String, Object> map){
        String capacityNumber = (String) map.get("capacityNumber");
        //通过车牌号查询所有未下发的订单ID
        List<Map<String, Object>> orderMesList = omstruckOrderMapper.getOrderIdListByCapacityNumber(capacityNumber);
        List<Map<String, Object>> mesMapList = new ArrayList<>();
        for (Map<String, Object> orderMesMap: orderMesList) {
            int orderType = DataChange.dataToBigDecimal(orderMesMap.get("orderType")).intValue();
            //如果订单类型为2 则判断订单发货日期是否为当日 如果不是当日则不给显示
            if(orderType == 2){
                Integer judgeDate = omstruckOrderSeparateMapper.getDeliveryDate(orderMesMap.get("orderId"));
                if(judgeDate == null){ // 数据为空则是已过截止日期 关闭订单
                    omstruckOrderMapper.closeTruckOrder(DataChange.dataToBigDecimal(orderMesMap.get("orderId")));
                    continue;
                }
            }
            if(orderType == 10|| orderType == 20){
                Integer planEnable = omstruckOrderSeparateMapper.getOrderPlanEnable(orderMesMap.get("orderId"));
                if(planEnable == 0){ // 数据为0则失效
                    omstruckOrderMapper.closeTruckOrder(DataChange.dataToBigDecimal(orderMesMap.get("orderId")));
                    continue;
                }
            }
            if(orderType == 12|| orderType == 13 || orderType == 14 || orderType == 19){
                Integer sporadicStatus = omstruckOrderSeparateMapper.getSporadicStatus(orderMesMap.get("orderId"));
                if(sporadicStatus == 0){ // 数据为0则失效
                    omstruckOrderMapper.closeTruckOrder(DataChange.dataToBigDecimal(orderMesMap.get("orderId")));
                    continue;
                }
            }
            //如果订单类型为11 当订单大于截止日期时，不显示订单
            if(orderType == 11 || orderType == 21){
                int result = omstruckOrderSeparateMapper.getInward(orderMesMap.get("orderId"));
                if(result == 0){
                    omstruckOrderMapper.closeTruckOrder(DataChange.dataToBigDecimal(orderMesMap.get("orderId")));
                    continue;
                }
            }

            Map<String, Object> mesMap = getMessageToApp(orderMesMap);
            mesMapList.add(mesMap);
        }
        return  mesMapList;
    }

    /**
     * 新增进口矿
     * @param mapValue
     * @return
     */
    @Transactional
    @Override
    public int addInputOrder(Map<String, Object> mapValue) {
        List<Map<String,Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");
        BigDecimal purchaseOrderId = new BigDecimal((Integer) mapValue.get("purchaseOrderId"));
        BigDecimal materialId = new BigDecimal((Integer) mapValue.get("materialId"));
        BigDecimal orderType = new BigDecimal((Integer) mapValue.get("orderType"));
        BigDecimal lineId = new BigDecimal((Integer) mapValue.get("lineId"));
        Integer planId = (Integer) mapValue.get("planId");
        int result = 0;
        for (Map<String, Object> map : mapList) {
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
            BigDecimal orderId = omstruckOrderMapper.selectMaxId();
            BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
            String capacityNumber = (String)map.get("capacityNumber");
            BigDecimal capacityId = omstruckOrderMapper.getCapacityId(capacityNumber);
            BigDecimal materialWeight = DataChange.dataToBigDecimal(map.get("orderMaterialWeight"));
            String unloadPoint = (String) map.get("unloadPoint");
            BigDecimal unloadPointId = omstruckOrderMapper.getUnloadPointId(unloadPoint);
//            Date orderEntryTime = new Date((Long) map.get("orderEntryTime"));
            // 运输订单
            omstruckOrder.setOrderId(orderId);
            omstruckOrder.setOrderNumber(DataChange.generateEightDigitsNumber("WYSDD",orderId.intValue()));
            omstruckOrder.setCapacityId(capacityId);
            omstruckOrder.setOrderPlanId(purchaseOrderId);
            omstruckOrder.setOrderType(orderType);
            omstruckOrder.setOrderStatus(new BigDecimal(3));
            omstruckOrder.setLineId(lineId);
            omstruckOrder.setUnloadPointId(unloadPointId);
//            omstruckOrder.setOrderEntryTime(orderEntryTime);
            omstruckOrder.setInsertTime(new Date());
            omstruckOrder.setInsertUsername("admin");
            // 运输订单子表
            omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
            omstruckOrderMaterial.setOrderId(orderId);
            omstruckOrderMaterial.setOrderMaterialWeight(materialWeight);
            omstruckOrderMaterial.setMaterialId(materialId);
            omstruckOrderMaterial.setInsertTime(new Date());
            omstruckOrderMaterial.setInsertUsername("admin");
            result += omstruckOrderMapper.insertSelective(omstruckOrder);
            result += omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
            //新增实绩总表关联订单 feign 调用truckTms
            map.put("orderId", omstruckOrder.getOrderId());
            tmsTruckFeign.addTotalResult(map);
            //更改运输计划子表 增加已分配重量 减少未分配重量  feign调用ams
            map.put("planId",planId);
            amsFeign.updateMaterial(map);
        }
        return result;
    }
}