package com.steerinfo.dil.controller;

import com.steerinfo.dil.feign.ESFeign;
import com.steerinfo.dil.mapper.OmstruckOrderMapper;
import com.steerinfo.dil.service.IOmstruckOrderService;
import com.steerinfo.dil.util.BaseRESTfulController;
import com.steerinfo.dil.util.ColumnDataUtil;
import com.steerinfo.dil.util.PageListAdd;

import com.steerinfo.framework.controller.RESTfulResult;
import com.steerinfo.framework.service.pagehelper.PageHelper;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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


/**
 * OmstruckOrder RESTful接口：
 *
 * @author generator
 * @version 1.0-SNAPSHORT 2021-10-15 09:37
 * 类描述
 * 修订历史：
 * 日期：2021-10-15
 * 作者：generator
 * 参考：
 * 描述：OmstruckOrder RESTful接口
 * @Copyright 湖南视拓信息技术股份有限公司. All rights reserved.
 * @see null
 */
@RestController
@RequestMapping("/${api.version}/omstruckorders")
public class OmstruckOrderController extends BaseRESTfulController {

    @Autowired
    IOmstruckOrderService omstruckOrderService;
    @Autowired
    ColumnDataUtil columnDataUtil;
    @Autowired
    ESFeign esFeign;
    @Autowired
    OmstruckOrderMapper omstruckOrderMapper;


    /**
     * 展示承运商接收销售公司已接受的销售订单
     *
     * @param
     * @param pageNum
     * @param pageSize
     * @param apiId
     * @return
     */
    @ApiOperation(value = "展示承运商接收销售公司已接受的销售订单", notes = "分页查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "168", required = false, dataType = "BigDecimal"),

    })
    @PostMapping(value = "/getSaleOrderForCarrierList/{carrierId}")
    public RESTfulResult getSaleOrderForCarrierList(@RequestBody(required = false) Map<String, Object> map,
                                                    Integer pageNum,
                                                    Integer pageSize,
                                                    Integer apiId,
                                                    @PathVariable("carrierId") Integer carrierId,

                                                    String con
    ) {
        int count = 0;
        //设置承运商
        if (carrierId != null) {
            map.put("carrierId", carrierId);
        }
        //框计算
        if (con != null) {
            if (!"undefined".equals(con)) {
                String index = "get_sale_order_list";//设置要查询的索引名称
                return success(esFeign.getConResult(map, index, apiId, pageNum, pageSize, con));//获取查询结果
            }
        }
        //不分页筛选数据
        List<Map<String, Object>> allSaleOrderForCarrier = null;
        //如果有条件查询则跳过初始化，和创建索引
        if (map.size() == count) {
            //将查询结果存入索引中
            allSaleOrderForCarrier = omstruckOrderService.selectSaleOrderForCarrier(map);
            Map<String, Object> map1 = new HashMap<>();
            //添加索引
            map1.put("index", "get_sale_order_list");
            //添加id
            map1.put("indexId", "saleOrderId");
            allSaleOrderForCarrier.add(map1);
            //新建索引
            esFeign.insertIndex(allSaleOrderForCarrier);
            //删除
            allSaleOrderForCarrier.remove(allSaleOrderForCarrier.size() - 1);
        }
        if (allSaleOrderForCarrier == null)
            allSaleOrderForCarrier = omstruckOrderService.selectSaleOrderForCarrier(map);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderForCarrier = omstruckOrderService.selectSaleOrderForCarrier(map);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, allSaleOrderForCarrier, saleOrderForCarrier);
        return success(pageList);
    }

    /**
     * 查询所有已经接收的焦炭发运日计划
     *
     * @param map
     * @param pageNum
     * @param pageSize
     * @param apiId
     * @return
     */
    @ApiOperation(value = "查询所有已经接收的焦炭发运日计划", notes = "分页查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "169", required = false, dataType = "BigDecimal"),

    })
    @PostMapping(value = "/getCokeDayPlanAndRecivedList/{carrierId}")
    public RESTfulResult getCokeDayPlanAndRecivedList(@RequestBody(required = false) Map<String, Object> map,
                                                      Integer pageNum,
                                                      Integer pageSize,
                                                      Integer apiId,
                                                      @PathVariable("carrierId") Integer carrierId,
                                                      String con
    ) {
        int count = 0;
        //设置承运商
        if (carrierId != null) {
            map.put("carrierId", carrierId);
        }
        //框计算
        if (con != null) {
            if (!"undefined".equals(con)) {
                String index = "get_coke_dayplan_list";//设置要查询的索引名称
                return success(esFeign.getConResult(map, index, apiId, pageNum, pageSize, con));//获取查询结果
            }
        }
        //不分页筛选数据
        List<Map<String, Object>> allCokeDayPlanAndRecivedList = null;
        //如果有条件查询则跳过初始化，和创建索引
        if (map.size() == count) {
            //将查询结果存入索引中
            allCokeDayPlanAndRecivedList = omstruckOrderService.selectSaleOrderForCarrier(map);
            Map<String, Object> map1 = new HashMap<>();
            //添加索引
            map1.put("index", "get_coke_dayplan_list");
            //添加id
            map1.put("indexId", "cokeDayPlanId");
            allCokeDayPlanAndRecivedList.add(map1);
            //新建索引
            esFeign.insertIndex(allCokeDayPlanAndRecivedList);
            //删除
            allCokeDayPlanAndRecivedList.remove(allCokeDayPlanAndRecivedList.size() - 1);
        }
        if (allCokeDayPlanAndRecivedList == null)
            allCokeDayPlanAndRecivedList = omstruckOrderService.selectCokeDayPlanAndRecived(map);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> CokeDayPlanAndRecived = omstruckOrderService.selectCokeDayPlanAndRecived(map);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, allCokeDayPlanAndRecivedList, CokeDayPlanAndRecived);
        return success(pageList);
    }

    /**
     * 查询所有已经接收的水渣发运日计划
     *
     * @param
     * @param pageNum
     * @param pageSize
     * @param apiId
     * @return
     */
    @ApiOperation(value = "查询所有已经接收的水渣发运日计划", notes = "分页查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "170", required = false, dataType = "BigDecimal"),

    })
    @PostMapping(value = "/getWaterSlagDayPlanAndRecivedList/{carrierId}")
    public RESTfulResult getWaterSlagDayPlanAndRecivedList(@RequestBody(required = false) Map<String, Object> map,
                                                           @PathVariable("carrierId") Integer carrierId,
                                                           Integer pageNum,
                                                           Integer pageSize,
                                                           Integer apiId,
                                                           String con


    ) {

        int count = 0;
        //设置承运商
        if (carrierId != null) {
            map.put("carrierId", carrierId);
            count++;
        }
        //框计算
        if (con != null) {
            if (!"undefined".equals(con)) {
                String index = "get_waterslag_dayplan_list";//设置要查询的索引名称
                return success(esFeign.getConResult(map, index, apiId, pageNum, pageSize, con));//获取查询结果
            }
        }
        //不分页筛选数据
        List<Map<String, Object>> allWaterSlagDayPlanAndRecivedList = null;
        //如果有条件查询则跳过初始化，和创建索引
        if (map.size() == count) {
            //将查询结果存入索引中
            allWaterSlagDayPlanAndRecivedList = omstruckOrderService.selectSaleOrderForCarrier(map);
            Map<String, Object> map1 = new HashMap<>();
            //添加索引
            map1.put("index", "get_waterslag_dayplan_list");
            //添加id
            map1.put("indexId", "cokeDayPlanId");
            allWaterSlagDayPlanAndRecivedList.add(map1);
            //新建索引
            esFeign.insertIndex(allWaterSlagDayPlanAndRecivedList);
            //删除
            allWaterSlagDayPlanAndRecivedList.remove(allWaterSlagDayPlanAndRecivedList.size() - 1);
        }
        if (allWaterSlagDayPlanAndRecivedList == null)
            allWaterSlagDayPlanAndRecivedList = omstruckOrderService.selectCokeDayPlanAndRecived(map);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> CokeDayPlanAndRecived = omstruckOrderService.selectCokeDayPlanAndRecived(map);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, allWaterSlagDayPlanAndRecivedList, CokeDayPlanAndRecived);
        return success(pageList);

    }

    @ApiOperation(value = "查询已经形成订单的销售订单", notes = "分页查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "168", required = false, dataType = "BigDecimal"),

    })
    @PostMapping(value = "/selectAllOrderForSale/{carrierId}")
    public RESTfulResult selectAllOrderForSale(@RequestBody(required = false) Map<String, Object> mapValue,
                                               @PathVariable Integer carrierId,
                                               Integer apiId,
                                               Integer pageNum,
                                               Integer pageSize,
                                               Integer orderType,
                                               Integer orderStatus,
                                               Integer saleOrderMaterialId,
                                               String con

    ) {
        int count = 0;
        //承运商
        if (carrierId != null) {
            mapValue.put("carrierId", carrierId);
            count++;
        }
        if (saleOrderMaterialId != null) {
            mapValue.put("saleOrderMaterialId", saleOrderMaterialId);
            count++;
        }
        if (orderStatus != null) {
            mapValue.put("orderStatus", orderStatus);
            count++;
        }
        if (orderType != null) {
            mapValue.put("orderTypee", orderType);
            count++;
        }
        //框计算
        if (con != null) {
            if (!"undefined".equals(con)) {
                String index = "get_all_order_sale";//设置要查询的索引名称
                return success(esFeign.getConResult(mapValue, index, apiId, pageNum, pageSize, con));//获取查询结果
            }
        }
        //不分页筛选数据
        List<Map<String, Object>> allSaleOrderList = null;
        //如果有条件查询则跳过初始化，和创建索引
        if (mapValue.size() == count) {
            //将查询结果存入索引中
            allSaleOrderList = omstruckOrderService.selectAllOrderForSale(mapValue);
            Map<String, Object> map1 = new HashMap<>();
            //添加索引
            map1.put("index", "get_all_order_sale");
            //添加id
            map1.put("indexId", "orderSaleId");
            allSaleOrderList.add(map1);
            //新建索引
            esFeign.insertIndex(allSaleOrderList);
            //删除
            allSaleOrderList.remove(allSaleOrderList.size() - 1);
        }
        if (allSaleOrderList == null)
            allSaleOrderList = omstruckOrderService.selectAllOrderForSale(mapValue);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> selectAllOrderForSale = omstruckOrderService.selectAllOrderForSale(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, allSaleOrderList, selectAllOrderForSale);
        return success(pageList);

    }
    @ApiOperation(value="判断一车多单是否还有订单，如果还有就推送消息再给司机")
    @ApiImplicitParams({
            @ApiImplicitParam(name ="mapValue",value = "orderId")
    })
    @PostMapping("/pushMessageToDriver")
    public RESTfulResult pushMessageToDriver(@RequestBody Map<String,Object> mapValue){
        omstruckOrderService.pushMessageToDriver(mapValue);
        return null;
    }

    @ApiOperation(value = "司机接收、拒绝接单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "map", value = "运输订单主键id加同意/拒绝状态码/拒绝原因insertUpdateRemark", required = false, dataType = "Map"),
            @ApiImplicitParam(name = "map", value = "运输订单主键id加同意/拒绝状态码/拒绝原因insertUpdateRemark", required = false, dataType = "Map"),
    })
    @PostMapping("/driverReceiveOrRefuse")
    public RESTfulResult driverReceiveOrRefuse(@RequestBody Map<String, Object> map) {
        try {
            int i = omstruckOrderService.driverReceiveOrRefuse(map);
            return success(i);
        } catch (Exception e) {
            return failed(e.getMessage());
        }
    }

    @ApiOperation(value = "司机APP端调用接口查询数据 4 已下发 5 已接收")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "map", value = "orderStatus/capacityNumber/orderType", required = false, dataType = "Map"),
    })
    @PostMapping("/sendMesToDriver1")
    public RESTfulResult sendMesToDriver1(@RequestBody Map<String, Object> map) {
        List<Map<String, Object>> mesToDriver = omstruckOrderService.sendMesToDriver(map);
        return success(mesToDriver);
    }

    @ApiOperation(value = "通过运输订单ID查询实绩地点和时间")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "orderId", value = "运输订单Id", required = false, dataType = "Integer"),
    })
    @PostMapping("/selectPlaceAndTime/{orderId}")
    public RESTfulResult selectPlaceAndTime(@PathVariable("orderId") Integer orderId) {
        List<Map<String, Object>> placeAndTime = omstruckOrderService.selectPlaceAndTime(new BigDecimal(orderId));
        return success(placeAndTime);
    }

    @ApiOperation(value = "查询已下发未接受的销售订单信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "orderType", value = "运单类型", required = false, dataType = "Integer"),
    })
    @PostMapping("/getOrderUnReceive/{orderType}")
    public RESTfulResult getOrderUnReceive(@PathVariable("orderType") Integer orderType) {
        List<Map<String, Object>> orderMapList = omstruckOrderService.getOrderUnReceive(new BigDecimal(orderType));
        return success(orderMapList);
    }

    @ApiOperation(value = "查询已下发已接受的销售订单信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "orderType", value = "运单类型", required = false, dataType = "Integer"),
    })
    @PostMapping("/getOrderReceived/{orderType}")
    public RESTfulResult getOrderReceived(@PathVariable("orderType") Integer orderType) {
        List<Map<String, Object>> orderMapList = omstruckOrderService.getOrderReceived(new BigDecimal(orderType));
        return success(orderMapList);
    }

    @ApiOperation(value = "查询所有运输订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(86)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "status", value = "状态码", required = false, dataType = "Integer"),
    })
    @PostMapping("/getAllTruckOrder")
    public RESTfulResult getAllTruckOrder(@RequestBody(required = false) Map<String, Object> mapValue,
                                          Integer apiId,
                                          Integer pageNum,
                                          Integer pageSize,
                                          Integer orderStatus,
                                          Integer planId,
                                          Integer orderType,
                                          Integer fuelOrder,
                                          String con,
                                          String carrierSSOId) {
        if (orderStatus != null) {
            mapValue.put("orderStatus", orderStatus);
        }
        if (planId != null && !"undefined".equals(planId)) {
            mapValue.put("planId", planId);
        }
        if (orderType != null) {
            mapValue.put("orderTypee", orderType);
        }
        if (fuelOrder != null) {
            mapValue.put("fuelOrder", fuelOrder);
        }
        if(carrierSSOId != null){
            if(!"null".equals(carrierSSOId)) {
                mapValue.put("carrierSSOId", carrierSSOId);
            }
        }
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> truckOrder = omstruckOrderService.getAllTruckOrder(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null, truckOrder);
        return success(pageList);
    }

    @ApiOperation(value = "不适用表头返回数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "运输计划实绩对象", required = false, dataType = "Map"),
    })
    @PostMapping("/getAllTruckOrderReturnListMap")
    public RESTfulResult getAllTruckOrderReturnListMap(
            Integer orderStatus,
            Integer planId,
            Integer orderType) {
        Map<String, Object> map = new HashMap<>();
        if (orderStatus != null) {
            map.put("orderStatus", orderStatus);
        }
        if (planId != null) {
            map.put("planId", planId);
        }
        if (orderType != null) {
            map.put("orderType", orderType);
        }
        List<Map<String, Object>> truckOrder = omstruckOrderService.getAllTruckOrder(map);
        return success(truckOrder);
    }

    @ApiOperation(value = "查询所有空闲的运力信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(85)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
    })
    @PostMapping("/getAllCapacity")
    public RESTfulResult getAllCapacity(@RequestBody(required = false) Map<String, Object> mapValue,
                                        Integer apiId,
                                        Integer pageNum,
                                        Integer pageSize,
                                        Integer carrierId
    ) {
        if (mapValue == null) {
            mapValue = new HashMap<>();
        }
        if (carrierId != null) {
            mapValue.put("carrierId", carrierId);
        }
        mapValue.put("capacityTypeId", 1);
        mapValue.put("capacityStatus", 0);
        //不分页筛选数据
        List<Map<String, Object>> allCapacity = omstruckOrderService.getAllCapacity(mapValue);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> capacity = omstruckOrderService.getAllCapacity(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, allCapacity, capacity);
        return success(pageList);
    }

    @ApiOperation(value = "分解运输计划后 新增订单  或者直接新增订单 ")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "运输计划实绩对象", required = false, dataType = "Map"),
            @ApiImplicitParam(name = "orderType", value = "运输订单类型:1表示销售订单，3表示运输订单", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "saleOrderId", value = "销售订单", required = false, dataType = "Integer"),
    })
    @PostMapping("/addPurOrder")
    public RESTfulResult addPurOrder(@RequestBody(required = false) Map<String, Object> mapValue) {
        int i = omstruckOrderService.addPurOrder(mapValue);
        return success(i);
    }



    @ApiOperation(value = "撤销订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "运输计划实绩对象", required = false, dataType = "Map"),
            @ApiImplicitParam(name = "orderId", value = "运输订单类型:1表示销售订单，3表示运输订单", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "saleOrderId", value = "销售订单", required = false, dataType = "Integer"),
    })
    @PostMapping("/undoOrder")
    public RESTfulResult undoOrder(@RequestBody(required = false) Map<String, Object> mapValue) {
        int i = omstruckOrderService.undoOrder(mapValue);
        return success(i);
    }

    @PostMapping("/refuseCtrlZ")
    public RESTfulResult refuseCtrlZ(@RequestBody(required = false) Map<String,Object>map){
        int i = omstruckOrderService.refuseCtrlZ(map);
        return success(i);
    }

    @ApiOperation(value = "新增采购进口矿订单 ")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "运输计划实绩对象", required = false, dataType = "Map"),
    })
    @PostMapping("/addInputOrder")
    public RESTfulResult addInputOrder(@RequestBody(required = false) Map<String, Object> mapValue) {
        int i = omstruckOrderService.addInputOrder(mapValue);
        return success(i);
    }

    @ApiOperation(value = "修改分派计划")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "planId", value = "运输计划Id", required = false, dataType = "Integer"),
    })
    @PostMapping("/updateOrder")
    public RESTfulResult updateOrder(@RequestBody Map<String, Object> map) {
        int i = omstruckOrderService.updateOrder(map);
        return success(i);
    }

    @ApiOperation(value = "派单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "planId", value = "运输计划Id", required = false, dataType = "Integer"),
    })
    @PostMapping("/dispatchOrder")
    public RESTfulResult dispatchOrder(@RequestBody(required = false) Map<String, Object> mapValue) {
        int i = omstruckOrderService.dispatchOrder(mapValue);
        return success(i);
    }


    @ApiOperation(value = "销售物流，查询所有已经形成订单的焦炭发运计划", notes = "分页查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "169", required = false, dataType = "BigDecimal"),

    })
    @PostMapping(value = "/getCokeRailDayPlanForGenOrder/{carrierId}")
    public RESTfulResult getCokeRailDayPlanForGenOrder(@RequestBody(required = false) Map<String, Object> map,
                                                       @PathVariable("carrierId") Integer carrierId,
                                                       Integer pageNum,
                                                       Integer pageSize,
                                                       Integer apiId,
                                                       Integer dayPlanId,
                                                       Integer orderType,
                                                       Integer orderStatus,
                                                       String con


    ) {

        int count = 0;

        if (carrierId != null) {
            map.put("carrierId", carrierId);
            count++;
        }
        if (orderStatus != null) {
            map.put("orderStatus", orderStatus);
            count++;
        }
        if (dayPlanId != null) {
            map.put("dayPlanId", dayPlanId);
            count++;
        }
        if (orderType != null) {
            map.put("orderTypeId", orderType);
            count++;
        }
        //框计算
        if (con != null) {
            if (!"undefined".equals(con)) {
                String index = "get_coke_dayplan_order";//设置要查询的索引名称
                return success(esFeign.getConResult(map, index, apiId, pageNum, pageSize, con));//获取查询结果
            }
        }
        //不分页筛选数据
        List<Map<String, Object>> allCokeRailPlanOrderListForOrder = null;
        //如果有条件查询则跳过初始化，和创建索引
        if (map.size() == count) {
            //将查询结果存入索引中
            allCokeRailPlanOrderListForOrder = omstruckOrderService.selectCokeRailPlanForOrder(map);
            Map<String, Object> map1 = new HashMap<>();
            //添加索引
            map1.put("index", "get_coke_dayplan_order");
            //添加id
            map1.put("indexId", "cokeDayPlanOrderId");
            allCokeRailPlanOrderListForOrder.add(map1);
            //新建索引
            esFeign.insertIndex(allCokeRailPlanOrderListForOrder);
            //删除
            allCokeRailPlanOrderListForOrder.remove(allCokeRailPlanOrderListForOrder.size() - 1);
        }
        if (allCokeRailPlanOrderListForOrder == null)
            allCokeRailPlanOrderListForOrder = omstruckOrderService.selectCokeRailPlanForOrder(map);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> CokeDayPlanAndRecived = omstruckOrderService.selectCokeRailPlanForOrder(map);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, allCokeRailPlanOrderListForOrder, CokeDayPlanAndRecived);
        return success(pageList);

    }


    @ApiOperation(value = "销售物流。查询所有已经形成订单的水渣发运计划", notes = "分页查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "170", required = false, dataType = "BigDecimal"),

    })
    @PostMapping(value = "/getWaterslagDayPlanForGenOrder/{carrierId}")
    public RESTfulResult getWaterslagDayPlanForGenOrder(@RequestBody(required = false) Map<String, Object> map,
                                                        @PathVariable("carrierId") Integer carrierId,
                                                        Integer pageNum,
                                                        Integer pageSize,
                                                        Integer apiId,
                                                        Integer dayPlanId,
                                                        Integer orderType,
                                                        Integer orderStatus,
                                                        String con


    ) {

        int count = 0;
        //设置承运商
        if (carrierId != null) {
            map.put("carrierId", carrierId);
            count++;
        }
        if (dayPlanId != null) {
            map.put("dayPlanId", dayPlanId);
            count++;
        }
        if (orderStatus != null) {
            map.put("orderStatus", orderStatus);
            count++;
        }
        if (orderType != null) {
            map.put("orderType", orderType);
            count++;
        }
        //框计算
        if (con != null) {
            if (!"undefined".equals(con)) {
                String index = "get_water_slagplan_order";//设置要查询的索引名称
                return success(esFeign.getConResult(map, index, apiId, pageNum, pageSize, con));//获取查询结果
            }
        }
        //不分页筛选数据
        List<Map<String, Object>> allCokeRailPlanOrderListForOrder = null;
        //如果有条件查询则跳过初始化，和创建索引
        if (map.size() == count) {
            //将查询结果存入索引中
            allCokeRailPlanOrderListForOrder = omstruckOrderService.selectWaterSlagForOrder(map);
            Map<String, Object> map1 = new HashMap<>();
            //添加索引
            map1.put("index", "get_water_slagplan_order");
            //添加id
            map1.put("indexId", "getwaterSlagId");
            allCokeRailPlanOrderListForOrder.add(map1);
            //新建索引
            esFeign.insertIndex(allCokeRailPlanOrderListForOrder);
            //删除
            allCokeRailPlanOrderListForOrder.remove(allCokeRailPlanOrderListForOrder.size() - 1);
        }
        if (allCokeRailPlanOrderListForOrder == null)
            allCokeRailPlanOrderListForOrder = omstruckOrderService.selectWaterSlagForOrder(map);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> CokeDayPlanAndRecived = omstruckOrderService.selectWaterSlagForOrder(map);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, allCokeRailPlanOrderListForOrder, CokeDayPlanAndRecived);
        return success(pageList);

    }

    @ApiOperation(value = "销售司机派单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "planId", value = "运输计划Id", required = false, dataType = "Integer"),
    })
    @PostMapping("/dispatchOrderForSale")
    public RESTfulResult dispatchOrderForSale(@RequestBody(required = false) Map<String, Object> map) {
        int i = omstruckOrderService.dispatchOrderForSale(map);
        return success(i);
    }

    @ApiOperation(value = "逻辑删除运单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "planId", value = "运输计划Id", required = false, dataType = "Integer"),
    })
    @PostMapping("/deleteOrder")
    public RESTfulResult deleteOrder(@RequestBody(required = false) Map<String, Object> map,
                                     Integer planId) {
        if (planId != null) {
            map.put("planId", planId);
        }
        Object orderMaterialWeight = map.get("orderMaterialWeight");
        if (orderMaterialWeight != null) {
            if (orderMaterialWeight instanceof Integer) {
                map.put("orderMaterialWeight", -((Integer) orderMaterialWeight));
            } else if (orderMaterialWeight instanceof Double) {
                map.put("orderMaterialWeight", -((Double) orderMaterialWeight));
            }
            //模拟前端传来新重量 复用
            map.put("weight", 0);
        }
        int i = omstruckOrderService.deleteOrder(map);
        return success(i);
    }

    @ApiOperation(value = "司机接单信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(117)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
    })
    @PostMapping("/getReceiveRefuseOrder/{orderReceiveStatus}")
    public RESTfulResult getReceiveRefuseOrder(@RequestBody(required = false) Map<String, Object> mapValue,
                                               Integer apiId,
                                               Integer pageNum,
                                               Integer pageSize,
                                               @PathVariable Integer orderReceiveStatus,
                                               Integer orderType,
                                               Integer orderStatus,
                                               String con
    ) {
        int count = 0;
        if (orderType != null) {
            mapValue.put("orderTypee", orderType);
            count++;
        }
        if (orderReceiveStatus != null) {
            mapValue.put("orderReceiveStatus", orderReceiveStatus);
            count++;
        }
        if (orderStatus != null) {
            mapValue.put("orderStatus", orderStatus);
            count++;
        }
        //框计算
        if (con != null) {
            if (!"undefined".equals(con)) {
                String index = "get_receiverefuse_list";//设置要查询的索引名称
                return success(esFeign.getConResult(mapValue, index, apiId, pageNum, pageSize, con));//获取查询结果
            }
        }
        //不分页筛选数据
        List<Map<String, Object>> allOrder = null;
        //如果有条件查询则跳过初始化，和创建索引
        if (mapValue.size() == count) {
            //将查询结果存入索引中
            allOrder = omstruckOrderService.getReceiveRefuseOrder(mapValue);
            Map<String, Object> map = new HashMap<>();
            //添加索引
            map.put("index", "get_receiverefuse_list");
            //添加id
            map.put("indexId", "orderReceiveId");
            allOrder.add(map);
            //新建索引
            esFeign.insertIndex(allOrder);
            //删除
            allOrder.remove(allOrder.size() - 1);
        }
        if (allOrder == null)
            allOrder = omstruckOrderService.getReceiveRefuseOrder(mapValue);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> order = omstruckOrderService.getReceiveRefuseOrder(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, allOrder, order);
        return success(pageList);
    }

    //销售物流接收订单，订单类型为已下发，司机接单状态为已下发，未下发。
    @ApiOperation(value = "pc端展示司机信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(226)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
    })
    @PostMapping("/getDriverInfoForSale")
    public RESTfulResult getDriverInfoForSale(@RequestBody(required = false) Map<String, Object> mapValue,
                                              Integer apiId,
                                              Integer pageNum,
                                              Integer pageSize,
                                              Integer orderType,
                                              Integer orderStatus,
                                              String con,
                                              String carrierSsoId
    ) {
        if (orderType != null) {
            mapValue.put("orderTypee", orderType);
        }

        if (orderStatus != null) {
            mapValue.put("orderStatus", orderStatus);
        }
        if (con != null && (con.equals("") || con.equals("undefined"))) {
            con = null;
        }
        if (con != null && con.length() != 0) {
            mapValue.put("con", "%" + con + "%");
        }
        mapValue.put("carrierSsoId",carrierSsoId);
        //不分页筛选数据
        List<Map<String, Object>> DiverInfoForSale = omstruckOrderService.selectTransportOrderForSale(mapValue);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> diverInfoForSaleorder = omstruckOrderService.selectTransportOrderForSale(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, DiverInfoForSale, diverInfoForSaleorder);
        return success(pageList);
    }


    @ApiOperation(value = "司机APP端调用接口查询数据 4 已下发 5 已接收")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "capacityNumber", value = "运输计划Id", required = false, dataType = "String"),
    })
    @PostMapping("/sendMesToDriver2")
    public RESTfulResult sendMesToDriver2(String capacityNumber, Integer orderStatus) {
        HashMap<String, Object> map = new HashMap<>();
        if (orderStatus != null)
            map.put("orderStatus", orderStatus);
        if (capacityNumber != null)
            map.put("capacityNumber", capacityNumber);
        List<Map<String, Object>> mesToDriver = omstruckOrderService.sendMesToDriver(map);
        return success(mesToDriver);
    }

    @ApiOperation(value = "通过车牌获取所有已拒绝的订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "capacityNumber", value = "运输计划Id", required = false, dataType = "String"),
    })
    @PostMapping("/getRefuseOrderByCapacityNum")
    public RESTfulResult getReceiveRefuseOrderByCapacityId(String capacityNumber) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("capacityNumber", capacityNumber);
        List<Map<String, Object>> receiveRefuseOrderByCapacityId = omstruckOrderService.getReceiveRefuseOrderByCapacityId(map);
        return success(receiveRefuseOrderByCapacityId);
    }

    @ApiOperation(value = "通过运输订单ID查询运单信息 包含各个作业路径")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "capacityNumber", value = "运输计划Id", required = false, dataType = "String"),
    })
    @PostMapping("/getOrderMesByOrderNum/{orderId}")
    public RESTfulResult getOrderMesByOrderNum(@PathVariable("orderId") Integer orderId) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("orderId", orderId);
        List<Map<String, Object>> mesToDriver = omstruckOrderService.getOrderMesByOrderNum(map);
        return success(mesToDriver);
    }


    @ApiOperation(value = "通过运输订单ID查询运单信息")
    @PostMapping("/selectOrderByOrderId/{orderId}")
    public RESTfulResult selectOrderByOrderId(@PathVariable("orderId") Integer orderId) {
        List<Map<String, Object>> mapList = omstruckOrderService.getOrderByOrderId(new BigDecimal(orderId));
        return success(mapList);
    }




    @ApiOperation(value = "查看运输派单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(117)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
    })
    @PostMapping("/getTransportDispatch")
    public RESTfulResult getTransportDispatch(@RequestBody(required = false) Map<String, Object> mapValue,
                                              Integer apiId,
                                              Integer pageNum,
                                              Integer pageSize,
                                              Integer orderType,
                                              Integer orderStatus,
                                              Integer fuelOrder,
                                              String carrierSSOId,
                                              String con
    ) {
        int count = 0;
        if (orderType != null) {
            mapValue.put("orderTypee", orderType);
            count++;
        }
        if (orderStatus != null) {
            mapValue.put("orderStatus", orderStatus);
            count++;
        }
        if (fuelOrder != null) {
            mapValue.put("fuelOrder", fuelOrder);
            count++;
        }
        if(carrierSSOId != null){
            if(!"null".equals(carrierSSOId)){
                mapValue.put("carrierSSOId", carrierSSOId);
            }
        }
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> order = omstruckOrderService.getTransportDispatch(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null, order);
        return success(pageList);
    }

    @ApiOperation(value = "根据运单id关闭订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "orderId", value = "运单主键", required = false, dataType = "Integer"),
    })
    @PostMapping("/closeOmstruckOrder")
    public RESTfulResult closeOmstruckOrder(@RequestParam Integer orderId) {
        int result = omstruckOrderService.closeOmstruckOrder(new BigDecimal(orderId));
        return success(result);
    }

    @ApiOperation(value = "根据运单id修改运力")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "orderId", value = "运单主键", required = false, dataType = "Integer"),
    })
    @PostMapping("/updateCapacityId")
    public RESTfulResult updateCapacityId(@RequestBody Map<String,Object> map) {
        int result = omstruckOrderService.updateCapacityId(map);
        return success(result);
    }




    @ApiOperation(value = "查询所有空闲的司机排班信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(186)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
    })
    @PostMapping("/getCapacityForLeisure/{carrierId}")
    public RESTfulResult getCapacityForLeisure(@RequestBody(required = false) Map<String, Object> mapValue,
                                               Integer apiId,
                                               Integer pageNum,
                                               Integer pageSize,
                                               @PathVariable Integer carrierId

    ) {
        if (carrierId != null) {
            mapValue.put("carrierId", carrierId);
        }
        //不分页筛选数据
        List<Map<String, Object>> allCapacity = omstruckOrderService.selectCapacityAndDriver(mapValue);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> capacity = omstruckOrderService.selectCapacityAndDriver(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, allCapacity, capacity);
        return success(pageList);
    }

    //通过物资id查询批次表匹配最新的批次，关联最新的采购订单号
    @PostMapping("/selectNewOrderId")
    public RESTfulResult selectNewOrderId(@RequestBody(required = false) Map<String, Object> map) {
        return success(omstruckOrderService.selectNewOrderId(map));
    }

    //查询所有的收货单位
    @GetMapping("/getReceivingUnit")
    public RESTfulResult getReceivingUnit(){
        List<Map<String, Object>> receivingUnit = omstruckOrderMapper.getReceivingUnit();
        return success(receivingUnit);
    }


    //查询所有的发货单位
    @GetMapping("/getSupplier")
    public RESTfulResult getSupplier(){
        List<Map<String, Object>> mes = omstruckOrderMapper.getSupplier();
        return success(mes);
    }

    //展示销售订单信息
    @ApiOperation(value = "展示销售订单信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(234)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
    })
    @PostMapping("/selectSteelSaleForCarrier/{carrierId}")
    public RESTfulResult selectSteelSaleForCarrier(@RequestBody(required = false) Map<String, Object> mapValue,
                                                   Integer apiId,
                                                   Integer pageNum,
                                                   Integer pageSize,
                                                   @PathVariable Integer carrierId

    ) {
        if (carrierId != null) {
            mapValue.put("carrierId", carrierId);
        }
        //不分页筛选数据
        List<Map<String, Object>> steelSaleForCarrier = omstruckOrderService.selectSteelSaleForCarrier(mapValue);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> steelSaleForCarrier1 = omstruckOrderService.selectSteelSaleForCarrier(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, steelSaleForCarrier, steelSaleForCarrier1);
        return success(pageList);
    }

    //展示发运计划信息
    @ApiOperation(value = "展示发运计划信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(236)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
    })
    @PostMapping("/selectCokeRailPlan/{carrierId}")
    public RESTfulResult selectCokeRailPlan(@RequestBody(required = false) Map<String, Object> mapValue,
                                            Integer apiId,
                                            Integer pageNum,
                                            Integer pageSize,
                                            @PathVariable Integer carrierId,
                                            Integer orderType

    ) {
        if (carrierId != null) {
            mapValue.put("carrierId", carrierId);
        }
        if (orderType != null) {
            mapValue.put("orderType", orderType);
        }
        //不分页筛选数据
        List<Map<String, Object>> steelSaleForCarrier = omstruckOrderService.selectCokeRailPlan(mapValue);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> steelSaleForCarrier1 = omstruckOrderService.selectCokeRailPlan(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, steelSaleForCarrier, steelSaleForCarrier1);
        return success(pageList);
    }

    //根据发运计划查找信息
    //通过销售订单id查找信息
    //展示销售订单信息
    @ApiOperation(value = " 通过发运计划id查找信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(238)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
    })
    @PostMapping("/selectInfoByDayPlanId/{dayPlanId}")
    public RESTfulResult selectInfoByDayPlanId(@RequestBody(required = false) Map<String, Object> mapValue,
                                               Integer apiId,
                                               Integer pageNum,
                                               Integer pageSize,
                                               @PathVariable Integer dayPlanId,
                                               Integer orderType


    ) {
        if (dayPlanId != null) {
            mapValue.put("dayPlanId", dayPlanId);
        }
        if (orderType != null) {
            mapValue.put("orderType", orderType);
        }
        //不分页筛选数据
        List<Map<String, Object>> steelSaleForCarrier = omstruckOrderService.selectInfoByDayPlanId(mapValue);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> steelSaleForCarrier1 = omstruckOrderService.selectInfoByDayPlanId(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, steelSaleForCarrier, steelSaleForCarrier1);
        return success(pageList);
    }

    //通过销售订单id查找信息
    //展示销售订单信息
    @ApiOperation(value = " 通过销售订单id查找信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(235)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
    })
    @PostMapping("/selectInfoBySaleOrderId/{saleOrderId}")
    public RESTfulResult selectInfoBySaleOrderId(@RequestBody(required = false) Map<String, Object> mapValue,
                                                 Integer apiId,
                                                 Integer pageNum,
                                                 Integer pageSize,
                                                 @PathVariable Integer saleOrderId


    ) {
        mapValue.put("saleOrderId", saleOrderId);
        //不分页筛选数据
        List<Map<String, Object>> steelSaleForCarrier = omstruckOrderService.selectInfoBySaleOrderId(saleOrderId);
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> steelSaleForCarrier1 = omstruckOrderService.selectInfoBySaleOrderId(saleOrderId);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, steelSaleForCarrier, steelSaleForCarrier1);
        return success(pageList);

    }

    @ApiOperation(value = "司机APP端调用接口查询数据 4 已下发 5 已接收")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "map", value = "orderStatus/capacityNumber/orderType", required = false, dataType = "Map"),
    })
    @PostMapping("/sendMesToDriverApp")
    public RESTfulResult sendMesToDriverApp(@RequestBody Map<String, Object> map) {
        Map<String, Object> mesToDriverApp = omstruckOrderService.sendMesToDriverApp(map);
        return success(mesToDriverApp);

    }

    @ApiOperation(value = "车牌号下拉")
    @GetMapping("/getDriverCapacity")
    public RESTfulResult getDriverCapacity() {
        List<Map<String, Object>> mapList = omstruckOrderService.getDriverCapacity();
        return success(mapList);
    }

    @ApiOperation(value = "派单信息")
    @PostMapping("/getTruckNoDispatchMap")
    public RESTfulResult getTruckNoDispatchMap(@RequestParam Integer dispatchId) {
        Map<String, Object> map = omstruckOrderService.getTruckNoDispatchMap(dispatchId);
        return success(map);
    }

    @ApiOperation(value = "承运商分派运输订单给司机")
    @PostMapping("/addAppTruckOrder")
    public RESTfulResult addAppTruckOrder(@RequestParam Integer dispatchId,
                                          @RequestParam Integer orderType,
                                          @RequestParam String capacityNumber,
                                          @RequestParam Integer carrierId) {
        int result = omstruckOrderService.addAppTruckOrder(dispatchId, orderType, capacityNumber,carrierId);
        return success(result);
    }
    @ApiOperation(value = "关闭订单")
    @PostMapping("/CloseOrder")
    public  RESTfulResult CloseOrder(@RequestBody(required = false)Map<String,Object> map){
      int result=omstruckOrderService.closeOrder(map);
      return success(result);
    }

    @ApiOperation(value = " 查询所有车牌号和司机")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(246)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
    })
    @PostMapping("/getCapacityAndDriverList")
    public RESTfulResult getCapacityAndDriverList(@RequestBody(required = false) Map<String, Object> mapValue,
                                                  Integer apiId,
                                                  Integer pageNum,
                                                  Integer pageSize,
                                                  String con,
                                                  String carrierId) {
        if (con != null) {
            if(!"undefined".equals(con)){
                String index="get_capacity_driver";//设置要查询的索引名称
                return success(esFeign.getConResult(mapValue,index,apiId,pageNum,pageSize,con));//获取查询结果
            }
        }
        if (carrierId != null && !"undefined".equals(carrierId)){
            mapValue.put("carrierIds",carrierId);
        }
        List<Map<String, Object>> dispatchSaleOrderList = null;
        if (mapValue.size() == 0) {
            //将查询结果存入索引中
            dispatchSaleOrderList = omstruckOrderService.getCapacityAndDriverList(mapValue);
            Map<String, Object> map1 = new HashMap<>();
            //添加索引
            map1.put("index","get_capacity_driver");
            //添加id
            map1.put("indexId","driverCapacityId");
            dispatchSaleOrderList.add(map1);
            //新建索引
            esFeign.insertIndex(dispatchSaleOrderList);
            //删除
            dispatchSaleOrderList.remove(dispatchSaleOrderList.size()-1);
        }
        if (dispatchSaleOrderList == null) {
            dispatchSaleOrderList = omstruckOrderService.getCapacityAndDriverList(mapValue);
        }
        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> columnList = omstruckOrderService.getCapacityAndDriverList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, dispatchSaleOrderList,columnList);
        return success(pageList);
    }

    //=================================================================================================
    // 内转运输订单
    @ApiOperation(value = "分解内转计划（新增运输订单）")
    @PostMapping("/addInwardOrder")
    public RESTfulResult addInwardOrder(@RequestBody Map<String,Object> mapValue) {
        int result = omstruckOrderService.addInwardOrder(mapValue);
        return success(result);
    }

    //采购内转派单
    @ApiOperation(value = "采购内转派单")
    @PostMapping("/addPurInwardOrder")
    public RESTfulResult addPurInwardOrder(@RequestBody(required = false) Map<String,Object>mapValue) {
        int result = omstruckOrderService.addPurInwardOrder(mapValue);
        return success(result);
    }

    //采购内转派单查询
    @ApiOperation(value = "采购内转运输订单")
    @PostMapping("/getPurInwardOrderList")
    public RESTfulResult getPurInwardOrderList(@RequestBody(required = false) Map<String,Object>mapValue,
                                               Integer apiId,
                                               Integer pageNum,
                                               Integer pageSize,
                                               Integer orderStatus,
                                               String carrierId,
                                               String con,
                                               Integer planEnableStatus) {
       if(con != null){
           if(!"undefined".equals(con)){
               String index = "get_purinward_order_list";
               return success(esFeign.getConResult(mapValue,index,apiId,pageNum,pageSize,con));//获取查询结果
           }
       }
        int count = 0;
        if (mapValue == null) {
            mapValue = new HashMap<>();
        }
        if (carrierId != null && !"undefined".equals(carrierId)) {
            mapValue.put("carrierId",carrierId);
            count++;
        }
        if (planEnableStatus != null && !"undefined".equals(planEnableStatus)) {
            mapValue.put("planEnableStatus",planEnableStatus);
            count++;
        }
        mapValue.put("orderStatus",orderStatus);
        count++;
        List<Map<String, Object>> dispatchSaleOrderList = null;
        if (mapValue.size() == count) {
            //将查询结果存入索引中
            dispatchSaleOrderList = omstruckOrderService.getPurInwardOrderList(mapValue);
            Map<String, Object> map1 = new HashMap<>();
            //添加索引
            map1.put("index","get_purinward_order_list");
            //添加id
            map1.put("indexId","inwardOrderId");
            dispatchSaleOrderList.add(map1);
            //新建索引
            esFeign.insertIndex(dispatchSaleOrderList);
            //删除
            dispatchSaleOrderList.remove(dispatchSaleOrderList.size()-1);
        }
        if (dispatchSaleOrderList == null) {
            dispatchSaleOrderList = omstruckOrderService.getPurInwardOrderList(mapValue);
        }
        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> columnList = omstruckOrderService.getPurInwardOrderList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, dispatchSaleOrderList,columnList);
        return success(pageList);
    }

    @ApiOperation(value = " 分解/分派计划查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "mapValue", value = "表头和参数", required = false, dataType = "map"),
            @ApiImplicitParam(name = "apiId(260)", value = "动态表头", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageNum", value = "页码", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "页", required = false, dataType = "Integer"),
    })
    @PostMapping("/getInwardOrderList")
    public RESTfulResult getInwardOrderList(@RequestBody(required = false) Map<String, Object> mapValue,
                                                  Integer apiId,
                                                  Integer pageNum,
                                                  Integer pageSize,
                                                  Integer orderStatus,
                                                  String carrierId,
                                                  String con) {
        if (mapValue == null) {
            mapValue = new HashMap<>();
        }
        if (carrierId != null && !"undefined".equals(carrierId)) {
            mapValue.put("carrierId",carrierId);
        }
        mapValue.put("orderStatus",(orderStatus));
        List<Map<String, Object>>    dispatchSaleOrderList = omstruckOrderService.getInwardOrderList(mapValue);
        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> columnList = omstruckOrderService.getInwardOrderList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, dispatchSaleOrderList,columnList);
        return success(pageList);
    }

    @ApiOperation(value = "分派计划")
    @PostMapping("/apportionInwardOrder")
    public RESTfulResult apportionInwardOrder(@RequestBody List<Map<String,Object>> mapList) {
        int result = omstruckOrderService.apportionInwardOrder(mapList);
        return success(result);
    }

    @ApiOperation(value = "下发计划")
    @PostMapping("/issuePlanOrder")
    public RESTfulResult issuePlanOrder(@RequestBody List<Map<String,Object>> mapList) {
        int result = omstruckOrderService.issuePlanOrder(mapList);
        return success(result);
    }


    @ApiOperation(value = "司机APP端查询下发给自己运输订单")
    @PostMapping("/sendOrderToApp")
    public List<Map<String,Object>> sendOrderToApp(@RequestParam String capacityNumber) {
        List<Map<String,Object>> mapList = omstruckOrderService.sendOrderToApp(capacityNumber);
        return mapList;
    }

    @ApiOperation(value = "分解异地库计划")
    @PostMapping("/apportionInwardOffsetOrder")
    public RESTfulResult apportionInwardOffsetOrder(@RequestBody Map<String,Object>mapvalue) {
        int result = omstruckOrderService.apportionInwardOffsetOrder(mapvalue);
        return success(result);
    }


    @ApiOperation(value = "查询司机的所有运输订单信息")
    @PostMapping("/getAllOrderMessage")
    public List<Map<String,Object>> getAllOrderMessage(@RequestParam String capacityNumber) {
        List<Map<String,Object>> mapList = omstruckOrderService.getAllOrderMessage(capacityNumber);
        return mapList;
    }


    @ApiOperation(value = "司机确认订单")
    @PostMapping("/driverConfirmation")
    public RESTfulResult driverConfirmation(@RequestBody(required = false) Map<String,Object> mapvalue) {
        int result = omstruckOrderService.driverConfirmation(mapvalue);
        if(result == 0){
            return failed(result);
        }
        return success(result);
    }

    @ApiOperation(value = "查询订单是否确认")
    @PostMapping("/getDriverConfirmation")
    public RESTfulResult getDriverConfirmation(@RequestBody(required = false) Map<String,Object> map) {
        boolean result = omstruckOrderService.getDriverConfirmation(map);
        return success(result);
    }

    @ApiOperation(value = "通过运输订单Id查询订单信息给司机")
    @PostMapping("/getMessageToApp")
    public Map<String, Object> getMessageToApp(@RequestBody(required = false) Map<String,Object> mapvalue) {
        if(mapvalue.get("orderId") == null && mapvalue.get("orderNumber") == null){
            return null;
        }
        if(mapvalue.get("orderId") == null){
            //通过运输订单号查询运输订单Id
            String orderNumber = (String) mapvalue.get("orderNumber");
            if("\n".equals(orderNumber.substring(orderNumber.length()-1))){
                orderNumber = orderNumber.substring(0, orderNumber.length() - 1);
            }
            Integer id = omstruckOrderMapper.getOrderIdByOrderNumber(orderNumber);
            mapvalue.put("orderId", id);
        }
        return omstruckOrderService.getMessageToApp(mapvalue);
    }

    @ApiOperation(value = "通过车牌号查询所有已下发未接收的订单信息")
    @PostMapping("/getAllOrderMessagesByCapacityNum")
    public List<Map<String, Object>> getAllOrderMessagesByCapacityNum(@RequestBody(required = false) Map<String,Object> mapvalue) {
        return omstruckOrderService.getAllOrderMessagesByCapacityNum(mapvalue);
    }

    @ApiOperation(value = "通过车牌号查询该车牌下所有已接收的订单ID")
    @PostMapping("/getReceiveOrderIdListByCapacityNum")
    public List<Integer> getReceiveOrderIdListByCapacityNum(@RequestBody(required = false) Map<String,Object> mapvalue) {
        String capacityNumber = (String) mapvalue.get("capacityNumber");
        return omstruckOrderMapper.getReceiveOrderIdListByCapacityNum(capacityNumber);
    }


    @ApiOperation(value = "通过车牌号查询该车牌下所有已接收的订单ID")
    @PostMapping("/getAllRefuseOrderNumberByCapacity")
    public List<Map<String, Object>> getAllRefuseOrderNumberByCapacity(@RequestBody(required = false) Map<String,Object> mapvalue) {
        String capacityNumber = (String) mapvalue.get("capacityNumber");
        return omstruckOrderMapper.getAllRefuseOrderNumberByCapacity(capacityNumber);
    }

    @ApiOperation(value = "通过运单下的物资信息")
    @PostMapping("/getOrderMaterialList")
    public RESTfulResult getOrderMaterialList(@RequestParam Integer orderId) {
        List<Map<String, Object>> orderMaterialList = omstruckOrderMapper.getOrderMaterialList(new BigDecimal(orderId));
        return success(orderMaterialList);
    }
}