DAL-DAZHOU-AMS-API/src/main/java/com/steerinfo/dil/controller/AmsSaleOrderController.java

package com.steerinfo.dil.controller;

import com.alibaba.druid.support.json.JSONUtils;
import com.steerinfo.dil.feign.ColumnDataFeign;
import com.steerinfo.dil.feign.ESFeign;
import com.steerinfo.dil.feign.JoinFeign;
import com.steerinfo.dil.mapper.AmsDispatchSaleOrderMapper;
import com.steerinfo.dil.mapper.AmsSaleOrderMapper;
import com.steerinfo.dil.model.AmsDispatchSaleOrder;
import com.steerinfo.dil.service.IAmsSaleOrderService;
import com.steerinfo.dil.service.impl.AmsDispatchSaleOrderServiceImpl;
import com.steerinfo.dil.service.impl.AmsSaleOrderCarrierServiceImpl;
import com.steerinfo.dil.service.impl.AmsSaleOrderMaterialServiceImpl;
import com.steerinfo.dil.util.*;
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.ApiModelProperty;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

//import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ;

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

    @Autowired
    IAmsSaleOrderService amsSaleOrderService;
    @Autowired
    AmsSaleOrderMaterialServiceImpl amsSaleOrderMaterialService;
    @Autowired
    AmsDispatchSaleOrderServiceImpl amsDispatchSaleOrderService;
    @Autowired
    ColumnDataFeign columnDataFeign;
    @Autowired
    AmsDispatchSaleOrderMapper amsDispatchSaleOrderMapper;
    @Autowired
    ColumnDataUtil columnDataUtil;
    @Autowired
    ESFeign esFeign;
    @Autowired
    AmsSaleOrderCarrierServiceImpl  amsSaleOrderCarrierService;
    @Autowired
    EASTestUtil easTestUtil;
    @Autowired
    EASUtil easUtil;
    @Autowired
    JoinFeign joinFeign;
    @Autowired
    EASDeleteUtil easDeleteUtil;
    @Autowired
    EASCapacityTestUtil easCapacityTestUtil;

    @Autowired
    private AmsSaleOrderMapper amsSaleOrderMapper;

    private final SimpleDateFormat sdfDateTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    private List< List<Map<String,Object>> > retryQueen=new ArrayList<>();

    @ApiOperation(value="查询未上报销售订单信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "apiId(98)", value = "表头", required = false, dataType = "Interger")
    })
    @PostMapping("/getSaleOrderInfo")
    public RESTfulResult getSaleOrderInfo(@RequestBody(required=false) Map<String,Object> mapValue,
                                         Integer apiId,
                                         Integer pageNum,
                                         Integer pageSize){

        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> amsSaleOrder1 = amsSaleOrderService.getSaleOrderInfo(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,amsSaleOrder1);
        return success(pageList);
    }

    @ApiOperation(value="查询已上报销售订单信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "apiId(98)", value = "表头", required = false, dataType = "Interger")
    })
    @PostMapping("/getSaleOrderReported")
    public RESTfulResult getSaleOrderReported(@RequestBody(required=false) Map<String,Object> mapValue,
                                          Integer apiId,
                                          Integer pageNum,
                                          Integer pageSize){

        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> amsSaleOrder1 = amsSaleOrderService.getSaleOrderReported(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,amsSaleOrder1);
        return success(pageList);
    }

    @ApiOperation(value="查询财务已审批销售订单信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "apiId(105)", value = "表头", required = false, dataType = "Interger")
    })
    @PostMapping("/getAmsSaleOrderApproved")
    public RESTfulResult getAmsSaleOrderApproved(@RequestBody(required=false) Map<String,Object> mapValue,
                                              Integer apiId,
                                              Integer pageNum,
                                              Integer pageSize){

        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> amsSaleOrder1 = amsSaleOrderService.getAmsSaleOrderApproved(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,amsSaleOrder1);
        return success(pageList);
    }

    @ApiOperation(value="根据销售订单号查询销售订单详细信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "apiId(100)", value = "表头", required = false, dataType = "Interger")
    })
    @PostMapping("/getSaleOrderDetail")
    public RESTfulResult getSaleOrderDetail(BigDecimal saleOrderId,@RequestBody(required=false) Map<String,Object> mapValue,
                                          Integer apiId,
                                          Integer pageNum,
                                          Integer pageSize){
        if (mapValue == null) {
            mapValue = new HashMap<>();
        }
        mapValue.put("saleOrderId",saleOrderId);
        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> amsSaleOrderDetail1 = amsSaleOrderService.getSaleOrderDetail(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,amsSaleOrderDetail1);
        return success(pageList);
    }

    /**
     * 上传销售订单
     * @param saleOrderId
     * @return
     */
    @ApiOperation(value="上传销售订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "saleOrderId", value = "销售订单ID", required = false, dataType = "java.math.BigDecimal")
    })
    @PostMapping(value = "/uploadSaleOrder")
    public RESTfulResult uploadSaleOrder(@RequestParam BigDecimal saleOrderId) throws Exception {
        int i = amsSaleOrderService.uploadSaleOrder(saleOrderId);
        return success(i);
    }


    /**
     * 新增销售订单
     * @param map
     * @return
     */
    @ApiOperation(value="新增销售订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "amsSaleOrder", value = "销售订单对象", required = false, dataType = "AmsSaleOrder")
    })
    @PostMapping(value = "/addAmsSaleOrder")
    public RESTfulResult addAmsSaleOrder(@RequestBody(required = false) Map<String, Object> map) throws ParseException {
        int i = amsSaleOrderService.addAmsSaleOrder(map);
        return success(i);
    }

    /**
     * 通过主键渲染销售订单信息
     * @param saleOrderId
     * @return
     */
    @ApiOperation(value="通过主键渲染销售订单信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "saleOrderId", value = "主键Id", required = false, dataType = "java.math.BigDecimal")
    })
    @PostMapping(value = "/getAmsSaleOrderBySaleOrderId")
    public RESTfulResult getAmsSaleOrderBySaleOrderId(@RequestParam BigDecimal saleOrderId){
        Map<String, Object> maps = amsSaleOrderService.selectInfoBySaleOrderId(saleOrderId);
        List<Map<String, Object>> maps1= amsSaleOrderService.selectMaterialInfoBySaleOrderId(saleOrderId);
        Map map=new HashMap();
        map.put("maps",maps);
        map.put("maps1",maps1);

        return success(map);
    }




    /**steelMaterialId
     * 通过主键修改销售订单
     * @param map
     * @return
     */
    @ApiOperation(value="通过主键修改销售订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "amsSaleOrder", value = "销售订单对象", required = false, dataType = "AmsSaleOrder")
    })
    @PostMapping(value = "/updateAmsSaleOrder")
    public RESTfulResult updateAmsSaleOrder(@RequestBody(required = false) Map<String,Object> map) throws ParseException {
        int i = amsSaleOrderService.updateAmsSaleOrder(map);
        return success(i);
    }

    /**
     * 通过主键删除销售订单
     * @param saleOrderIds
     * @return
     */
    @ApiOperation(value="通过主键删除销售订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "saleOrderId", value = "主键Id", required = false, dataType = "java.math.BigDecimal")
    })
    @PostMapping(value = "/deleteAmsSaleOrderBySaleOrderId")
    public RESTfulResult deleteAmsSaleOrderBySaleOrderId(@RequestBody(required = false)List<Map<String,Object>> saleOrderIds) throws Exception {
        if(saleOrderIds==null || saleOrderIds.size()<=0){
            return failed("没有选中数据");
        }
        int i = 0;
        for(Map<String,Object> temp:saleOrderIds){
            i += amsSaleOrderService.deleteAmsSaleOrderBySaleOrderId(DataChange.dataToBigDecimal(temp.get("saleOrderId")));
        }
        return success(i);
    }

    @ApiOperation(value="根据销售订单号查询销售订单修改日志")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "apiId(100)", value = "表头", required = false, dataType = "Interger")
    })
    @PostMapping("/getSaleOrderUpdateLog")
    public RESTfulResult getSaleOrderUpdateLog(BigDecimal saleOrderId,@RequestBody(required=false) Map<String,Object> mapValue,
                                            Integer apiId,
                                            Integer pageNum,
                                            Integer pageSize){
        if (mapValue == null) {
            mapValue = new HashMap<>();
        }
        mapValue.put("saleOrderId",saleOrderId);
        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> amsSaleOrderUpdate1 = amsSaleOrderService.getSaleOrderUpdateLog(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,amsSaleOrderUpdate1);
        return success(pageList);
    }

    /**
     * 获取销售计划名称
     * @param
     * @return
     */
    @ApiOperation(value="获取销售计划名称")
    @ApiImplicitParams({
    })
    @GetMapping(value = "/getSalePlanName")
    public RESTfulResult getSalePlanName(){
        return success(amsSaleOrderService.getSalePlanName());
    }

    /**
     * 获取发货单位
     * @param
     * @return
     */
    @ApiOperation(value="获取发货单位")
    @ApiImplicitParams({
    })
    @GetMapping(value = "/getShipperName")
    public RESTfulResult getShipperName(){
        return success(amsSaleOrderService.getShipperName());
    }

    /**
     * 获取收货单位
     * @param
     * @return
     */
    @ApiOperation(value="获取收货单位")
    @ApiImplicitParams({
    })
    @GetMapping(value = "/getConsigneeCompanyName")
    public RESTfulResult getConsigneeCompanyName(){
        return success(amsSaleOrderService.getConsigneeCompanyName());
    }
    /**
     * 展示销售公司已审核销售订单的车序号列表
     * @param mapValue
     * @param pageNum
     * @param pageSize
     * @param apiId
     * @return
     */
    @ApiModelProperty(value = "展示销售公司已审核销售订单的车序号列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "181", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getSaleOrderList")
    public RESTfulResult getSaleOrderList(@RequestBody(required = false) Map<String,Object> mapValue,
                                          Integer pageNum,
                                          Integer pageSize,
                                          Integer apiId,
                                          Integer status,
                                          String con) {
        if (status!=null){
            mapValue.put("status",status);
        }
        PageHelper.startPage(pageNum,pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getSaleOrderList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,saleOrderList);
        return success(pageList);

    }

    /**
     * 销售公司查询已审核的订单
     *
     */
    @ApiModelProperty(value = "展示销售公司已审核销售订单的车序号列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "181", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getSaleOrderListBySaleCompany")
    public RESTfulResult getSaleOrderListBySaleCompany(@RequestBody(required = false) Map<String,Object> mapValue,
                                          Integer pageNum,
                                          Integer pageSize,
                                          Integer apiId) {
        PageHelper.startPage(pageNum,pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getSaleOrderListBySaleCompany(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,saleOrderList);
        return success(pageList);

    }




    /**
     * 固定派单：通过车序号查询收货地址，截取收货地址的区域，去资源管理中查询对应的承运商,将车序号与承运商绑定
     */
    @PostMapping("/addAmsDispatchSaleOrder")
    public RESTfulResult addAmsDispatchSaleOrder(@RequestBody(required = false) List<Map<String,Object>> mapValue){
//        if(mapValue==null){
//            return failed();
//        }
//        for (Map<String,Object> m:mapValue
//        ) {
//            Integer id = Integer.parseInt(m.get("saleOrderMaterialId").toString()) ;
//            System.out.println(id);
//            //通过主键Id获取地址id
//            Integer a=amsSaleOrderMaterialService.selectById(new BigDecimal(id));
//            //通过地址id查询省市县
//            Map<String,Object> province = amsSaleOrderService.getCarrier(a);
//            //根据省市县查询承运商
//            List<Map<String,Object>> carrierList=amsSaleOrderService.selectCarrierIdByprovince(province);
//            //判断是否只有一个承运商
//            //如果收货地区为成都重庆，则有多个一个地区对应多个承运商
//            if(carrierList.size()==1) {
//                //新增固定派单
//                AmsDispatchSaleOrder ad = new AmsDispatchSaleOrder();
//                ad.setDispatchId(DataChange.dataToBigDecimal(m.get("dispatchId")));
//                ad.setSaleOrderMaterialId(new BigDecimal(id));
//                ad.setCarrierId(carrierList.get(0));
//                ad.setDispatchDealTime(new Date());
//                ad.setDispatchTime(new Date());
//                //成交类型（0：定向派单；1：公开抢单）
//                ad.setDispatchType(new BigDecimal(0));
//                //销售订单车序号状态（0：已下发；1：未下发）
//                ad.setDispatchStatus(new BigDecimal(0));
//                int i = amsDispatchSaleOrderMapper.updateByPrimaryKeySelective(ad);
//                return success(i);
//            }
//        }
        int result = amsSaleOrderService.addAmsDispatchSaleOrder(mapValue);
        return success(result);
    }
    /**
     * 公开派单：查询未分派车辆的销售订单的车序号
     */
    @ApiModelProperty(value = "展示车序号列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "182", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getAmsSaleOrderMaterial")
    public RESTfulResult getAmsSaleOrderMaterial(@RequestBody(required = false) Map<String,Object> mapValue,
                                                 Integer pageNum,
                                                 Integer pageSize,
                                                 Integer apiId,
                                                 Integer status) {
        mapValue.put("status",status);
        PageHelper.startPage(pageNum, pageSize);
        //分页查询数据
        List<Map<String, Object>> columnList = amsSaleOrderMaterialService.getSaleMaterial(mapValue);
        PageListAdd data = columnDataUtil.tableColumnData(apiId, null, columnList);
        return success(data);
    }

    /**
     * 公开派单：新增公开派单
     */
    @PostMapping("/addOpenAmsDispatchSaleOrder/{orderMaterialId}")
    public RESTfulResult addOpenAmsDispatchSaleOrder(@PathVariable("orderMaterialId") BigDecimal orderMaterialId){
        if(orderMaterialId==null){
            return failed();
        }
        //新增公开派单
        AmsDispatchSaleOrder ad = new AmsDispatchSaleOrder();
        Integer id = amsDispatchSaleOrderMapper.selectDispatchIdBySaleOrderMaterialId(orderMaterialId.intValue());
        ad.setDispatchId(DataChange.dataToBigDecimal(id));
        ad.setSaleOrderMaterialId(orderMaterialId);
        //成交类型（0：定向派单；1：公开抢单）
        ad.setDispatchType(new BigDecimal(1));
        //销售订单车序号状态（0：已下发；1：未下发）
        ad.setDispatchStatus(new BigDecimal(1));
        //更新公开派单状态
        amsDispatchSaleOrderMapper.updateByPrimaryKeySelective(ad);
        return success("更新成功");

    }

    /**
     * 删除公开派单
     */
    @PostMapping("/deleteAmsDispatchSaleOrder/{dispatchId}")
    public RESTfulResult deleteAmsDispatchSaleOrder(@PathVariable("dispatchId") BigDecimal dispatchId) {
        amsDispatchSaleOrderService.delete(dispatchId);
        return success("删除成功");
    }

    /**
     * 公开派单：查询公开派单
     */
    @ApiModelProperty(value = "展示公开派单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "181", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getOpenDispatchSaleOrder")
    public RESTfulResult getOpenDispatchSaleOrder(@RequestBody(required = false) Map<String,Object> mapValue,
                                                  Integer pageNum,
                                                  Integer pageSize,
                                                  Integer apiId) {
        PageHelper.startPage(pageNum, pageSize);
        //分页查询数据
        List<Map<String, Object>> columnList = amsDispatchSaleOrderService.getOpenDispatchSaleOrder(mapValue);
        PageListAdd data = columnDataUtil.tableColumnData(apiId, null, columnList);
        return success(data);
    }

    /**
     *公开派单：修改公开派单
     */
    @PostMapping("/updateOpenDispatchSaleOrder")
    public RESTfulResult updateOpenDispatchSaleOrder(@RequestBody AmsDispatchSaleOrder amsDispatchSaleOrder) {
        if(amsDispatchSaleOrder.getCarrierId()!=null){
            amsDispatchSaleOrder.setDispatchStatus(new BigDecimal(1));
        }
        amsDispatchSaleOrder.setDispatchDealTime(new Date());
        amsDispatchSaleOrder.setUpdateTime(new Date());
        amsDispatchSaleOrder.setUpdateUsername("admin");
        amsDispatchSaleOrderService.modify(amsDispatchSaleOrder);
        return success("修改成功");
    }

    @ApiOperation(value="查询未上报的销售订单信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "apiId(408)", value = "表头", required = false, dataType = "Interger")
    })
    @PostMapping("/getSaleOrderInfoes")
    public RESTfulResult getSaleOrderInfoes(@RequestBody(required=false) Map<String,Object> mapValue,
                                            Integer apiId,
                                            Integer pageNum,
                                            Integer pageSize,
                                            String consigneeSsoId,
                                            String con,
                                            String startTime,
                                            String endTime,
                                            String saler
                                            ){
        if (consigneeSsoId != null && !"".equals(consigneeSsoId) && !"null".equals(consigneeSsoId)) {
            mapValue.put("consigneeSsoId",consigneeSsoId);
        }
        if (con != null && !"".equals(con) && !"null".equals(con)) {
            mapValue.put("con",con);
        }
        if (saler != null && !"".equals(saler) && !"null".equals(saler)){
            mapValue.put("saler","%" + saler + "%");
        }
        DataChange.queryDataByDateTime(startTime, endTime, mapValue, sdfDateTime);//根据时间段查询数据
        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> amsSaleOrder1 = amsSaleOrderService.getSaleOrderInfoes(mapValue);
        //调整列宽
        List<Map<String, Object>> columnDataList = columnDataFeign.getColumnData(apiId);
        int i=0;
        for (Map<String, Object> columnData : columnDataList) {
            //每个表头字段的过滤条件
            if (i==0){
                columnData.put("min-width","155px");
            }else if (i==1){
                columnData.put("min-width","127px");
            }else if (i==2){
                columnData.put("min-width","88px");
            }else if (i==3){
                columnData.put("min-width","98px");
            }
            if (DataChange.dataToBigDecimal(columnData.get("isFilter")).intValue() != 0) {
                columnData.put("filters", setListMap(amsSaleOrder1, columnData.get("prop").toString()));
            }

            i++;
        }
        PageListAdd pageList = new PageListAdd(amsSaleOrder1);
        pageList.setColumnData(columnDataList);
        //PageListAdd pageList = columnDataUtil.tableColumnData4(apiId, null,amsSaleOrder1);
        return success(pageList);
    }

    //列宽调整条件
    private Set<Map<String, Object>> setListMap(List<Map<String, Object>> list, String name) {
        Set<Map<String, Object>> setString = new HashSet<>();
        for (Map<String, Object> map : list) {//遍历每条数据
            Map<String, Object> map1 = new HashMap<>();
            //map.get(name)获取每条数据中对应表头字段的数据
            map1.put("text", map.get(name));
            if (map.get(name) != null) {
                map1.put("value", map.get(name));
                setString.add(map1);
            }
        }
        return setString;
    }

    @ApiOperation(value="查询已上报销售订单信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "apiId(408)", value = "表头", required = false, dataType = "Interger")
    })
    @PostMapping("/getSaleOrderReportedes")
    public RESTfulResult getSaleOrderReportedes(@RequestBody(required=false) Map<String,Object> mapValue,
                                                Integer apiId,
                                                Integer pageNum,
                                                Integer pageSize,
                                                String consigneeSsoId,
                                                String con,
                                                String startTime,
                                                String endTime,
                                                String saler){
        if (consigneeSsoId != null && !"".equals(consigneeSsoId) && !"null".equals(consigneeSsoId)) {
            mapValue.put("consigneeSsoId",consigneeSsoId);
        }
        if (con != null && !"".equals(con) && !"null".equals(con)) {
            mapValue.put("con",con);
        }
        if (saler != null && !"".equals(saler) && !"null".equals(saler)) {
            mapValue.put("saler","%" + saler + "%");
        }
        DataChange.queryDataByDateTime(startTime, endTime, mapValue, sdfDateTime);//根据时间段查询数据
        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> amsSaleOrder1 = amsSaleOrderService.getSaleOrderReportedes(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,amsSaleOrder1);
        return success(pageList);
    }

    @ApiModelProperty(value = "展示已审核销售订单列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "409/475", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getSaleOrderListBySaleCompanyes")
    public RESTfulResult getSaleOrderListBySaleCompanyes(@RequestBody(required = false) Map<String,Object> mapValue,
                                                         Integer pageNum,
                                                         Integer pageSize,
                                                         Integer apiId,
                                                         String con,
                                                         Integer shipperId,
                                                         @RequestParam(required = false) Integer saleType,
                                                         String consigneeSsoId,
                                                         @RequestParam(required = false) String startTime,
                                                         @RequestParam(required = false)String endTime,
                                                         String saler
                                                         ) {
        if (con != null  && !"".equals(con) && !"null".equals(con)) {
            mapValue.put("con", "%" + con + "%");
        }
        if(shipperId != null  && !"".equals(shipperId) && !"null".equals(shipperId)){
            mapValue.put("shipperId", shipperId);
        }
        if (consigneeSsoId != null  && !"".equals(consigneeSsoId) && !"null".equals(consigneeSsoId)) {
            mapValue.put("consigneeSsoId",consigneeSsoId);
        }
        if (saler != null && !"".equals(saler) && !"null".equals(saler)) {
            mapValue.put("saler","%" + saler + "%");
        }
        mapValue.put("saleType",saleType);
        DataChange.queryDataByDateTime(startTime, endTime, mapValue, sdfDateTime);//根据时间段查询数据
        //不分页筛选数据
        PageHelper.startPage(pageNum,pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getSaleOrderListBySaleCompanyes(mapValue);
        //调整列宽
        List<Map<String, Object>> columnDataList = columnDataFeign.getColumnData(apiId);
        int i=0;
        for (Map<String, Object> columnData : columnDataList) {
            //每个表头字段的过滤条件
            if (i==0){
                columnData.put("min-width","155px");
            }else if (i==1){
                columnData.put("min-width","127px");
            }else if (i==2){
                columnData.put("min-width","88px");
            }else if (i==3){
                columnData.put("min-width","96px");
            }
            if (DataChange.dataToBigDecimal(columnData.get("isFilter")).intValue() != 0) {
                columnData.put("filters", setListMap(saleOrderList,columnData.get("prop").toString()));
            }
            i++;
        }
        PageListAdd pageList = new PageListAdd(saleOrderList);
        pageList.setColumnData(columnDataList);
        //PageListAdd pageList = columnDataUtil.tableColumnData4(apiId, null,saleOrderList);
        return success(pageList);
    }

    @ApiOperation(value="查询财务已审批销售订单信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "apiId(409)", value = "表头", required = false, dataType = "Interger")
    })
    @PostMapping("/getAmsSaleOrderApprovedes")
    public RESTfulResult getAmsSaleOrderApprovedes(@RequestBody(required=false) Map<String,Object> mapValue,
                                                   Integer apiId,
                                                   Integer pageNum,
                                                   Integer pageSize,
                                                   @RequestParam String con){
        if (con != null && !"undefined".equals(con)) {
            mapValue.put("con", con);
        }
        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> amsSaleOrder1 = amsSaleOrderService.getAmsSaleOrderApprovedes(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,amsSaleOrder1);
        return success(pageList);
    }

    /*
     *  根据销售订单主键展示销售基本信息、物资信息
     *  apiId:410
     * */
    @PostMapping(value="/getSaleOrderAndMaterialById")
    public RESTfulResult  getSaleOrderAndMaterialById(@RequestBody(required=false) Map<String,Object> mapValue,
                                                      Integer apiId,
                                                      Integer pageNum,
                                                      Integer pageSize,
                                                      BigDecimal saleOrderId){
        if (mapValue == null) {
            mapValue = new HashMap<>();
        }
        mapValue.put("saleOrderId",saleOrderId);
        PageHelper.startPage(pageNum,pageSize);
        List<Map<String, Object>> columndata = amsSaleOrderService.getSaleOrderAndMaterialById(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,columndata);
        return success(pageList);
    }

    @ApiModelProperty(value = "展示销售焦炭订单列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "409", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getCokeSaleOrderList")
    public RESTfulResult getCokeSaleOrderList(@RequestBody(required = false) Map<String,Object> mapValue,
                                              Integer pageNum,
                                              Integer pageSize,
                                              Integer apiId,
                                              String con) {
        if (con != null && !con.equals("undefined")) {
            mapValue.put("con","%" + con + "%");
        }
        //不分页筛选数据
        PageHelper.startPage(pageNum,pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getCokeSaleOrderList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,saleOrderList);
        return success(pageList);
    }

    @ApiModelProperty(value = "销售订单批量授权给承运商")
    @PostMapping("/saleOrderEmpowerCarrier")
    public RESTfulResult saleOrderEmpowerCarrier(@RequestBody(required = false) Map<String,Object> mapValue) {
        //获得订单ID集合 saleOrderIds
        List<Map<String,Integer>> saleOrderIds= (List<Map<String, Integer>>) mapValue.get("saleOrderIds");
        //获得承运商 carrierId
        BigDecimal carrierId=  new BigDecimal(mapValue.get("carrierId").toString());
        //销售订单授权承运商中间表
        int i= amsSaleOrderCarrierService.addAmsSaleOrderCarrier(carrierId,saleOrderIds);
        return success(i);
    }

    @ApiModelProperty(value = "展示销售公司下发给承运商的销售订单列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "409", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getSaleOrderListByCarrierSsoId")
    public RESTfulResult getSaleOrderListByCarrierSsoId(@RequestBody(required = false) Map<String,Object> mapValue,
                                                        String carrierSsoId,
                                                         Integer pageNum,

                                                         Integer pageSize,
                                                         Integer apiId,
                                                         String con) {
        if (con != null  && !"".equals(con) && !"null".equals(con)) {
            mapValue.put("con", con);

        }
        if (carrierSsoId!=null){
            mapValue.put("carrierSsoId",carrierSsoId);
        }

        //不分页筛选数据
        PageHelper.startPage(pageNum,pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getSaleOrderListByCarrierSsoId(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,saleOrderList);
        return success(pageList);
    }

    @ApiModelProperty(value = "新增钢材销售订单")
    @PostMapping("/addSteelSaleOrder")
    public RESTfulResult addSteelSaleOrder(@RequestBody Map<String,Object> mapValue){
        System.out.println(mapValue);
        try {
            // 成功
            int result = amsSaleOrderService.addSteelSaleOrder(mapValue);
            return success(result);
        } catch (Exception e) {
            // 失败
            return failed(e.getMessage());
        }
    }

    @ApiModelProperty(value = "展示销售订单下的车序号和物资")
    @PostMapping("/getTruckNoAndMaterialList")
    public RESTfulResult getTruckNoAndMaterialList(@RequestParam Integer saleOrderId) {
        List<Map<String,Object>> mapList = amsSaleOrderService.getTruckNoAndMaterialList(new BigDecimal(saleOrderId));
        return success(mapList);
    }

    @ApiModelProperty(value = "钢材派单")
    @PostMapping("/dispatchSteelOrder")
    public RESTfulResult dispatchSteelOrder(@RequestBody List<Map<String,Object>> mapList) throws Exception {
        int result;
        try {
            result = amsSaleOrderService.dispatchSteelOrder(mapList);
        } catch (Exception e) {
            e.printStackTrace();
            return failed(e.getMessage());
        }
        if (result == 0) {
            return failed("匹配不到车牌号！");
        }
        else {
                // 调用EAS接口将车牌号传给金蝶
                Map<String,Object> input = joinFeign.findCarNumberByOrderList(mapList);
                Map<String, Object> totalMap = easCapacityTestUtil.getTotalMap();
                totalMap.put("input",input);
                System.out.println(totalMap);
                String json = JSONUtils.toJSONString(totalMap);
                System.out.println(json);
                Map<String,Object> s = joinFeign.pushCarNumberToEas(totalMap);
                if (s == null || s.size() == 0) {
                    try{
                        //失败，存入重试队列，准备重试
                        retryQueen.add(mapList);
                    }catch (Exception e){
                        System.out.println("保存失败车牌失败");
                    }
                    throw new Exception("登录金蝶失败");
                }
            System.out.println(s);
            return success(result);
        }
    }

    @ApiModelProperty(value = "钢材继续装派单")
    @PostMapping("/continueSteelOrder")
    public RESTfulResult continueSteelOrder(@RequestBody List<Map<String,Object>> mapList) throws Exception {
        int result;
        try {
            result = amsSaleOrderService.continueSteelOrder(mapList);
        } catch (Exception e) {
            e.printStackTrace();
            return failed(e.getMessage());
        }
        // 调用EAS接口将车牌号传给金蝶
        Map<String,Object> input = joinFeign.findCarNumberByOrderList(mapList);
        Map<String, Object> totalMap = easCapacityTestUtil.getTotalMap();
        totalMap.put("input",input);
        System.out.println(totalMap);
        String json = JSONUtils.toJSONString(totalMap);
        System.out.println(json);
        Map<String,Object> s = joinFeign.pushCarNumberToEas(totalMap);
        if (s == null || s.size() == 0) {
            try{
                //失败，存入重试队列，准备重试
                retryQueen.add(mapList);
            }catch (Exception e){
                System.out.println("保存失败车牌失败");
            }
            throw new Exception("登录金蝶失败");
        }
        System.out.println(s);
        return success(result);
    }

    @ApiModelProperty(value = "根据详细地址匹配承运商")
    @GetMapping("/getCarrierByPlace")
    public RESTfulResult getCarrierByPlace(@RequestParam Integer placeId) {
        List<Map<String,Object>> result = amsSaleOrderService.getCarrierByPlace(new BigDecimal(placeId));
        return success(result);
    }

    @ApiModelProperty(value = "根据详细地址和承运商匹配单价")
    @PostMapping("/getPriceByCarrierAndPlace")
    public RESTfulResult getPriceByCarrierAndPlace(@RequestBody Map<String,Object> mapValue) {
        Map<String,Object> result = amsSaleOrderService.getPriceByCarrierAndPlace(mapValue);
        return success(result);
    }

    @ApiModelProperty(value = "将车序号下发给承运商")
    @PostMapping("/dispatchToCarrier")
    public RESTfulResult dispatchToCarrier(@RequestBody(required = false) List<Map<String,Object>> mapList) {
        int result = amsSaleOrderService.dispatchToCarrier(mapList);
        return success(result);
    }

    @ApiModelProperty(value = "销售钢材承运商查询销售订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "409", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getSaleOrderListToCarrier")
    public RESTfulResult getSaleOrderListToCarrier(@RequestBody(required = false) Map<String, Object> mapValue,
                                                   Integer pageNum,
                                                   Integer pageSize,
                                                   Integer apiId,
                                                   String carrierSsoId,
                                                   String con,
                                                   @RequestParam(required = false) String startTime,
                                                   @RequestParam(required = false) String endTime) {
        if (con != null && !"".equals(con) && !"null".equals(con)) {
            mapValue.put("con", "%" + con + "%");
        }
        if ((carrierSsoId != null && !"".equals(carrierSsoId)) && !"undefined".equals(carrierSsoId) && !"null".equals(carrierSsoId)) {
            mapValue.put("carrierSsoId", carrierSsoId);
        }
        DataChange.queryDataByDateTime(startTime, endTime, mapValue,sdfDateTime);//根据时间段查询数据
        //不分页筛选数据
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getSaleOrderListToCarrier(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null, saleOrderList);
        return success(pageList);
    }

    /**
     * 展示未匹配承运商的车序号
     *
     * @param mapValue
     * @return
     */
    @ApiOperation(value = "展示未匹配承运商的车序号")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "map", value = "销售订单物资信息map", required = false, dataType = "java.util.Map"),
            @ApiImplicitParam(name = "apiId", value = "411", required = false, dataType = "java.util.Map")
    })
    @PostMapping(value = "/getSteelTruckNoList")
    public RESTfulResult getSteelTruckNoList(@RequestBody(required = false) Map<String, Object> mapValue,
                                             Integer apiId,
                                             Integer pageNum,
                                             Integer pageSize,
                                             String con,
                                             @RequestParam(required = false) String startTime,
                                             @RequestParam(required = false)String endTime) {
        if (con != null && !con.equals("undefined") && !con.equals("null")) {
            mapValue.put("con", "%" + con + "%");
        }
        DataChange.queryDataByDateTime(startTime, endTime, mapValue,sdfDateTime);//根据时间段查询数据
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getSteelTruckNoList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId,null, saleOrderList);
        return success(pageList);
    }

    @ApiModelProperty(value = "展示销售订单下的车序号和物资")
    @PostMapping("/getTruckNoMaterial")
    public RESTfulResult getTruckNoMaterial(@RequestParam Integer saleOrderMaterialId) {
        List<Map<String,Object>> mapList = amsSaleOrderService.getTruckNoMaterial(new BigDecimal(saleOrderMaterialId));
        return success(mapList);
    }

    /**
     * 展示已分配承运商但未派车的车序号
     *
     * @param mapValue
     * @return
     */
    @ApiOperation(value = "展示已分配承运商但未派车的车序号")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "map", value = "销售订单物资信息map", required = false, dataType = "java.util.Map"),
            @ApiImplicitParam(name = "apiId", value = "466", required = false, dataType = "java.util.Map")
    })
    @PostMapping(value = "/getNoCarTruckNoList")
    public RESTfulResult getNoCarTruckNoList(@RequestBody(required = false) Map<String, Object> mapValue,
                                             Integer apiId,
                                             Integer pageNum,
                                             Integer pageSize,
                                             String con,
                                             @RequestParam(required = false) String startTime,
                                             @RequestParam(required = false)String endTime) {
        if (con != null && !con.equals("undefined") && !con.equals("null")) {
            mapValue.put("con", "%" + con + "%");
        }
        DataChange.queryDataByDateTime(startTime, endTime, mapValue,sdfDateTime);//根据时间段查询数据
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getNoCarTruckNoList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId,null, saleOrderList);
        return success(pageList);
    }

    /**
     * 展示已派车的车序号
     *
     * @param mapValue
     * @return
     */
    @ApiOperation(value = "展示已派车的车序号")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "map", value = "销售订单物资信息map", required = false, dataType = "java.util.Map"),
            @ApiImplicitParam(name = "apiId", value = "466", required = false, dataType = "java.util.Map")
    })
    @PostMapping(value = "/getHaveCarTruckNoList")
    public RESTfulResult getHaveCarTruckNoList(@RequestBody(required = false) Map<String, Object> mapValue,
                                             Integer apiId,
                                             Integer pageNum,
                                             Integer pageSize,
                                             String con,
                                             String startTime,
                                             String endTime) {
        if (con != null && !con.equals("undefined") && !con.equals("null")) {
            mapValue.put("con", "%" + con + "%");
        }
        DataChange.queryDataByDateTime(startTime, endTime, mapValue,sdfDateTime);
        //根据时间段查询数据
        if(pageNum ==null && pageSize==null){

        }else {
            PageHelper.startPage(pageNum, pageSize);
        }
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getHaveCarTruckNoList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId,null, saleOrderList);
        return success(pageList);
    }

    @ApiModelProperty(value = "删除上一条销售订单")
    @PostMapping("/deleteSaleOrderById")
    public RESTfulResult deleteSaleOrderById(@RequestParam Integer saleOrderId) {
        int result = amsSaleOrderService.deleteSaleOrderById(new BigDecimal(saleOrderId));
        return success(result);
    }

    @ApiModelProperty(value = "检查规格型号的格式对不对")
    @PostMapping("/queryFormat")
    public RESTfulResult queryFormat(@RequestBody List<Map<String,Object>> mapList){
        for (Map<String, Object> map : mapList) {
            String specification = (String) map.get("Specification");
            Integer count = amsDispatchSaleOrderMapper.queryFormatCount(specification);
            if (count.compareTo(0)==0){
                return failed(count);
            }
        }
        return success();
    }

    @ApiModelProperty(value = "查询物资ID并赋值")
    @PostMapping(value = "/queryMaterial")
    RESTfulResult queryMaterial(@RequestBody List<Map<String,Object>> mapList){
        List<Map<String,Object>> mapList1=mapList;
        for (Map<String, Object> map : mapList1) {
            String specification = (String) map.get("Specification");
            String materialName = (String) map.get("materialName");
            BigDecimal materialid = amsDispatchSaleOrderMapper.queryMaterial(specification, materialName);
            if (materialid ==null){
                return failed();
            }
            map.remove("materialId");
            map.put("materialId",materialid);
        }
        return success(mapList1);
    }


    @ApiModelProperty(value = "查询出销售订单下的所有数据")
    @PostMapping("/getAllSaleMessages")
    public RESTfulResult getAllSaleMessages(@RequestParam Integer saleOrderId) {
        Map<String,Object> saleMap = amsSaleOrderService.getAllSaleMessages(new BigDecimal(saleOrderId));
        return success(saleMap);
    }

    @ApiModelProperty(value = "修改承运商授权")
    @PostMapping("/updateTruckNoCarrier")
    public RESTfulResult updateTruckNoCarrier(@RequestBody Map<String,Object> mapValue) {
        int result = amsSaleOrderService.updateTruckNoCarrier(mapValue);
        try {
            List<Map<String,Object>> mapList = new ArrayList<>();
            mapList.add(mapValue);
            Map<String, Object> input = joinFeign.findCarNumberByOrderList(mapList);
            Map<String, Object> totalMap = easCapacityTestUtil.getTotalMap();
            totalMap.put("input", input);
            System.out.println(totalMap);
            String json = JSONUtils.toJSONString(totalMap);
            System.out.println(json);
            Map<String, Object> s = joinFeign.pushCarNumberToEas(totalMap);
            System.out.println("-------------------------------------");
            System.out.println(s);
            System.out.println("-------------------------------------");
            if (s == null || s.size() == 0) {
                //失败，存入重试队列，准备重试
                retryQueen.add(mapList);
            }
            return success(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return success(result);
    }

    /**
     * 批量上传销售订单
     * @param saleOrderIdList
     * @return
     */
    @ApiOperation(value="批量上传销售订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "saleOrderId", value = "销售订单ID", required = false, dataType = "java.math.BigDecimal")
    })
    @PostMapping(value = "/uploadSaleOrderList")
    public RESTfulResult uploadSaleOrderList(@RequestBody List<Map<String,Object>> saleOrderIdList){
        int i = amsSaleOrderService.uploadSaleOrderList(saleOrderIdList);
        return success(i);
    }

    @ApiModelProperty(value = "新增钒渣销售订单（未被使用，实际是走水渣的路线）")
    @PostMapping("/addVanadiumSaleOrder")
    public RESTfulResult addVanadiumSaleOrder(@RequestBody Map<String,Object> mapValue) {
        int result = amsSaleOrderService.addVanadiumSaleOrder(mapValue);
        return success(result);
    }

    @ApiModelProperty(value = "自动匹配出最近的一个地址")
    @PostMapping("/matchingAddressRecently")
    public RESTfulResult matchingAddressRecently(@RequestParam BigDecimal receiveId) {
        List<Map<String,Object>> mapList = amsSaleOrderService.matchingAddressRecently(receiveId);
        return success(mapList);
    }

    @ApiModelProperty(value = "自动匹配上一条运单的司机电话")
    @PostMapping("/matchingDriverTelRecently")
    public RESTfulResult matchingDriverTelRecently(@RequestParam String capacityNumber) {
        String driverTel = amsSaleOrderService.matchingDriverTelRecently(capacityNumber);
        return success(driverTel);
    }

    /**
     * 查询内转焦炭订单
     *
     * @param mapValue
     * @return
     */
    @ApiOperation(value = "查询内转焦炭订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "map", value = "查询内转焦炭订单", required = false, dataType = "java.util.Map"),
            @ApiImplicitParam(name = "apiId", value = "168", required = false, dataType = "java.util.Map")
    })
    @PostMapping(value = "/getCokeInwardOrderList")
    public RESTfulResult getCokeInwardOrderList(@RequestBody(required = false) Map<String, Object> mapValue,
                                               Integer apiId,
                                               Integer pageNum,
                                               Integer pageSize,
                                               Integer orderStatus,
                                               String con) {
        if (con != null && !con.equals("undefined") && !con.equals("null")) {
            mapValue.put("con", "%" + con + "%");
        }
        if (orderStatus != null) {
            mapValue.put("orderStatus",orderStatus);
        }
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getCokeInwardOrderList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId,null, saleOrderList);
        return success(pageList);
    }

    /**
     * 修改收货地址
     *
     * @param mapValue
     * @return
     */
    @ApiOperation(value = "修改收货地址")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "map", value = "修改收货地址", required = false, dataType = "java.util.Map")
    })
    @PostMapping(value = "/updateCarAddress")
    @Transactional
    public RESTfulResult updateCarAddress(@RequestBody Map<String, Object> mapValue) throws Exception {
        int result = amsSaleOrderService.updateCarAddress(mapValue);
        //查询单拼的数据
        try {
            BigDecimal orderId = DataChange.dataToBigDecimal(mapValue.get("orderId"));
            BigDecimal capacityIdS=amsSaleOrderMapper.queueSingle(orderId);
            if (capacityIdS !=null){
                //删除单拼
                amsSaleOrderMapper.delectQueueS(capacityIdS);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        if (result == 0) {
            // 如果返回结果为0，则认定是关闭了车辆
            BigDecimal saleOrderMaterialId = DataChange.dataToBigDecimal(mapValue.get("saleOrderMaterialId"));
            List<Map<String, Object>> saleMaterialIdList = amsSaleOrderService.getSaleMaterialId(saleOrderMaterialId);
            String wholeOrder = "0";
            String status = "close";
            String reason = "收货地址修改超过片区范围";
            // 循环调用关闭金蝶分录接口
            for (Map<String, Object> head : saleMaterialIdList) {
                head.put("wholeOrder", wholeOrder);
                head.put("status", status);
                head.put("reason", reason);
                Map<String, Object> input = new HashMap<>();
                input.put("head", head);
                Map<String, Object> totalMap = easUtil.getTotalMap();
                totalMap.put("input", input);
                String json = JSONUtils.toJSONString(totalMap);
                System.out.println("--------------------------------------------");
                System.out.println(json);
                System.out.println("--------------------------------------------");
                Map<String, Object> resultMap = joinFeign.deleteSaleOrderToEas(totalMap);
                System.out.println("--------------------------------------------");
                System.out.println(resultMap);
                //Map<String,Object> outMap = (Map<String,Object>) resultMap.get("output");
                //JSONObject jsonObject = new JSONObject(outMap);
                //System.out.println(jsonObject);

            }
        }
        return success(result);
    }


    /**
     * 修改销售订单中的物资
     *
     * @param mapValue
     * @return
     */
    @ApiOperation(value = "修改销售订单中的物资")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "map", value = "修改收货地址", required = false, dataType = "java.util.Map")
    })
    @PostMapping(value = "/updateAllMaterialInSale")
    public RESTfulResult updateAllMaterialInSale(@RequestBody Map<String, Object> mapValue) {
        //分页数据
        int result = amsSaleOrderService.updateAllMaterialInSale(mapValue);
        BigDecimal saleOrderId = DataChange.dataToBigDecimal(mapValue.get("saleOrderId"));
//         调用金蝶接口，将销售订单推送到金蝶系统
        Map<String, Object> input = joinFeign.getSaleOrder(saleOrderId);
        Map<String, Object> head = (Map<String, Object>) input.get("head");
        head.put("status", "update");
        // 获得金蝶接口配置:正式
//        Map<String, Object> totalMap = easUtil.getTotalMap();
        // 获得金蝶接口配置:测试
        Map<String, Object> totalMap = easUtil.getTotalMap();
        // 组装报文
        totalMap.put("input", input);
        System.out.println(totalMap);
        String json = JSONUtils.toJSONString(totalMap);
        System.out.println(json);
        Map<String,Object> resultMap = joinFeign.pushSaleOrderToEas(totalMap);
        System.out.println(resultMap);
        return success(result);
    }

    @ApiModelProperty(value = "展示副产品销售订单列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "481", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getFuSaleOrderList")
    public RESTfulResult getFuSaleOrderList(@RequestBody(required = false) Map<String, Object> mapValue,
                                            Integer pageNum,
                                            Integer pageSize,
                                            Integer apiId,
                                            String con,
                                            BigDecimal deleted,
                                            @RequestParam(required = false) String startTime,
                                            @RequestParam(required = false)String endTime
    ) {
        if (con != null && !"".equals(con) && !"null".equals(con)) {
            mapValue.put("con", con);
        }
        DataChange.queryDataByDateTime(startTime, endTime, mapValue, sdfDateTime);//根据时间段查询数据
        mapValue.put("deleted",deleted);
        //不分页筛选数据
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getFuSaleOrderList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData4(apiId, null, saleOrderList);
        return success(pageList);
    }

    @ApiModelProperty(value = "同步关闭金蝶订单")
    @PostMapping("/deleteSaleOrderSame")
    public RESTfulResult deleteSaleOrderSame(@RequestBody Map<String,Object> mapValue) {
        int result = amsSaleOrderService.deleteSaleOrderSame(mapValue);
        return success(result);
    }

    @ApiModelProperty(value = "展示反审批的钢材订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "481", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getSteelOrderDeletedList")
    public RESTfulResult getSteelOrderDeletedList(@RequestBody(required = false) Map<String, Object> mapValue,
                                            Integer pageNum,
                                            Integer pageSize,
                                            Integer apiId,
                                            String con,
                                                  String consigneeSsoId,
                                                  @RequestParam(required = false) String startTime,
                                                  @RequestParam(required = false) String endTime,String saler
    ) {
        if (con != null && !"".equals(con) && !"null".equals(con)) {
            mapValue.put("con", con);
        }
        if (consigneeSsoId != null && !"".equals(consigneeSsoId) && !"null".equals(consigneeSsoId)) {
            mapValue.put("consigneeSsoId", consigneeSsoId);
        }
        if (saler != null && !"".equals(saler) && !"null".equals(saler)) {
            mapValue.put("saler", saler);
        }
        DataChange.queryDataByDateTime(startTime, endTime, mapValue, sdfDateTime);//根据时间段查询数据
        //不分页筛选数据
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getSteelOrderDeletedList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null, saleOrderList);
        return success(pageList);
    }

    @ApiModelProperty(value = "展示所有状态销售订单列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "409/475", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getAllSteelSaleOrderList")
    public RESTfulResult getAllSteelSaleOrderList(@RequestBody(required = false) Map<String,Object> mapValue,
                                                         Integer pageNum,
                                                         Integer pageSize,
                                                         Integer apiId,
                                                         String con,
                                                         Integer shipperId,
                                                         @RequestParam(required = false) Integer saleType,
                                                         String consigneeSsoId
//                                                         String startDate,
//                                                         String endDate
    ) {
        if (con != null  && !"".equals(con) && !"null".equals(con)) {
            mapValue.put("con", con);
        }
        if(shipperId != null  && !"".equals(shipperId) && !"null".equals(shipperId)){
            mapValue.put("shipperId", shipperId);
        }
        if (consigneeSsoId != null  && !"".equals(consigneeSsoId) && !"null".equals(consigneeSsoId)) {
            mapValue.put("consigneeSsoId",consigneeSsoId);
        }
        mapValue.put("saleType",saleType);
//        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
//        if(startDate != null  && !"".equals(startDate) && !"null".equals(startDate)){
//            Date startTime=new Date(Long.parseLong(startDate));
//            String startTime1=simpleDateFormat.format(startTime);
//            mapValue.put("startTime",startTime1);
//        }
//        if(endDate != null  && !"".equals(endDate) && !"null".equals(endDate)){
//            Date endTime=new Date(Long.parseLong(endDate));
//            String endTime1=simpleDateFormat.format(endTime);
//            mapValue.put("endTime",endTime1);
//        }
        //不分页筛选数据
        PageHelper.startPage(pageNum,pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getAllSteelSaleOrderList(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, null,saleOrderList);
        return success(pageList);
    }

    @ApiModelProperty(value = "修改厂内未装货车辆的运单车牌号")
    @PostMapping("/updateCapacityNumberInFactory")
    public RESTfulResult updateCapacityNumberInFactory(@RequestBody Map<String,Object> mapValue) {
        Map<String, Object> result = new HashMap<>();
        try{
            result = amsSaleOrderService.updateCapacityNumberInFactory(mapValue);
        }catch (Exception e){
            e.printStackTrace();
            return failed(e.getMessage());
        }
        int result1= (int) result.get("result");
        if (result1 == 0) {
            return failed("已装货车辆不允许修改车牌");
        }
        else {
            // 调用EAS接口将车牌号传给金蝶
            List<Map<String,Object>> mapList = new ArrayList<>();
            mapList.add(mapValue);
            Map<String, Object> input = joinFeign.findCarNumberByOrderList(mapList);
            Map<String, Object> totalMap = easCapacityTestUtil.getTotalMap();
            totalMap.put("input", input);
            System.out.println(totalMap);
            String json = JSONUtils.toJSONString(totalMap);
            System.out.println(json);
            Map<String, Object> s = joinFeign.pushCarNumberToEas(totalMap);
            System.out.println("-------------------------------------");
            System.out.println(s);
            System.out.println("-------------------------------------");
            if (s == null || s.size() == 0) {
                //失败，存入重试队列，准备重试
                retryQueen.add(mapList);
            }
            return success(result);
        }
    }

    @ApiModelProperty(value = "修改收货客户的电话(销售)")
    @PostMapping("/updateConsigneeTel")
    public RESTfulResult updateConsigneeTel(@RequestBody Map<String,Object> mapValue){
        int result=amsSaleOrderService.updateConsigneeTel(mapValue);
        if (result ==0){
            return failed("更新收货客户电话失败");
        }else {
            return success("更新收货客户电话成功");
        }
    }


    @ApiModelProperty(value = "展示下发给承运商的车序号和物资")
    @PostMapping("/getCarrierTruckNoAndMaterialList")
    public RESTfulResult getCarrierTruckNoAndMaterialList(@RequestBody Map<String,Object> map) {
        List<Map<String,Object>> mapList = amsSaleOrderService.getCarrierTruckNoAndMaterialList(map);
        return success(mapList);
    }

    @ApiModelProperty(value = "关闭单个钢材物资分录")
    @PostMapping("/closeSteelMaterialId")
    public RESTfulResult closeSteelMaterialId(@RequestBody Map<String, Object> mapValue) {
        int result = amsSaleOrderService.closeSteelMaterialId(mapValue);
        if (result == 0) {
            return failed("该物资已装货，无法关闭物资分录！！");
        }
        if (mapValue.get("closeEntryFlag") != null && DataChange.dataToBigDecimal(mapValue.get("closeEntryFlag")).intValue() == 1) {
            return success(result);
        }
        String reason = (String) mapValue.get("reason");
        String number = (String) mapValue.get("number");
        String closeEntryId = (String) mapValue.get("closeEntryId");
        BigDecimal closeWlEntryId = DataChange.dataToBigDecimal(mapValue.get("saleMaterialId"));
        String wholeOrder = "0";
        String status = "close";
        Map<String,Object> head = new HashMap<>();
        // 销售订单号
        head.put("number",number);
        // 关闭原因
        head.put("reason",reason);
        // 金蝶分录
        head.put("closeEntryId",closeEntryId);
        // 是否整单：（0：分录，1：整单）
        head.put("wholeOrder",wholeOrder);
        // 物流销售订单分录主键
        head.put("closeWlEntryId",closeWlEntryId);
        // 状态：close为关闭
        head.put("status",status);
        Map<String,Object> input = new HashMap<>();
        Map<String, Object> totalMap = easUtil.getTotalMap();
        input.put("head",head);
        totalMap.put("input",input);
        // 调用金蝶关闭接口
        String json = JSONUtils.toJSONString(totalMap);
        System.out.println(json);
        Map<String,Object> resultMap = joinFeign.deleteSaleOrderToEas(totalMap);
        System.out.println(resultMap);
        return success(result);
    }

    /**
     * @author:zyf
     * @version:1.0
     * @Date:2022-10-20
     * @Description:批量关闭分录
     */
    @ApiOperation(value = "关闭分录")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "list", value = "批量关闭分录", required = false, dataType = "java.util.List")
    })
    @PostMapping(value = "/closingEntries")
    @Transactional
    public RESTfulResult closingEntries(@RequestBody List<Map<String, Object>> mapList){
        if (mapList.isEmpty()){
            return failed("没有分录数据");
        }else {
            try{
                for (Map<String, Object> map : mapList) {
                    String reason="关闭每日八点之前的订单";
                    String number="";
                    String closeEntryId="";
                    BigDecimal closeWlEntryId=BigDecimal.ZERO;
                    if (!("".equals(map.get("number")))&&map.get("number")!=null){
                        number = (String)map.get("number");
                    }else {
                        continue;
                    }
                    if (!("".equals(map.get("closeEntryId")))&&map.get("closeEntryId")!=null){
                        closeEntryId =(String) map.get("closeEntryId");
                    }else {
                        continue;
                    }
                    if (!("".equals(map.get("saleMaterialId")))&&map.get("saleMaterialId")!=null){
                        closeWlEntryId=DataChange.dataToBigDecimal(map.get("saleMaterialId"));
                    }else {
                        continue;
                    }
                    amsSaleOrderService.updateAMSDeleted(closeWlEntryId);
                    String wholeOrder = "0";
                    String status = "close";
                    //需要的数据
                    Map<String,Object> head = new HashMap<>();
                    // 销售订单号
                    head.put("number",number);
                    // 关闭原因
                    head.put("reason",reason);
                    // 金蝶分录
                    head.put("closeEntryId",closeEntryId);
                    // 是否整单：（0：分录，1：整单）
                    head.put("wholeOrder",wholeOrder);
                    // 物流销售订单分录主键
                    head.put("closeWlEntryId",closeWlEntryId);
                    // 状态：close为关闭
                    head.put("status",status);
                    Map<String,Object> input = new HashMap<>();
                    Map<String, Object> totalMap = easUtil.getTotalMap();
                    input.put("head",head);
                    totalMap.put("input",input);
                    // 调用金蝶关闭接口
                    String json = JSONUtils.toJSONString(totalMap);
                    System.out.println(json);
                    Map<String,Object> resultMap = joinFeign.deleteSaleOrderToEas(totalMap);
                    System.out.println(resultMap);
                }
            }catch (Exception e){
                System.out.println("e"+e.getMessage());
            }
        }
        return success("分录成功删除");
    }

    @ApiModelProperty(value = "展示已审核化产焦炭销售订单列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "409/475", required = false, dataType = "BigDecimal")
    })
    @PostMapping("/getSaleCokeOrder")
    public RESTfulResult getSaleCokeOrder(@RequestBody(required = false) Map<String, Object> mapValue,
                                             Integer pageNum,
                                             Integer pageSize,
                                             Integer apiId,
                                             String con,
                                             String consigneeSsoId,
                                             Integer shipperId,
                                             @RequestParam(required = false) String startTime,
                                             @RequestParam(required = false) String endTime
    ) {
        if (con != null && !"".equals(con) && !"null".equals(con)) {
            mapValue.put("con", con);
        }
        if (consigneeSsoId != null && !"".equals(consigneeSsoId) && !"null".equals(consigneeSsoId)) {
            mapValue.put("consigneeSsoId",consigneeSsoId);
        }
        if (shipperId != null && !"".equals(shipperId) && !"null".equals(shipperId)) {
            mapValue.put("shipperId", shipperId);
        }
        DataChange.queryDataByDateTime(startTime, endTime, mapValue, sdfDateTime);//根据时间段查询数据
        //不分页筛选数据
        PageHelper.startPage(pageNum, pageSize);
        //分页数据
        List<Map<String, Object>> saleOrderList = amsSaleOrderService.getSaleCokeOrder(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData4(apiId, null, saleOrderList);
        return success(pageList);
    }

    @ApiModelProperty(value = "反关闭金蝶单个分录")
    @PostMapping("/adverseCloseSaleMaterial")
    public RESTfulResult adverseCloseSaleMaterial(@RequestParam Integer saleMaterialId) {
        int result = amsSaleOrderService.adverseCloseSaleMaterial(new BigDecimal(saleMaterialId));
        return success(result);
    }

    @ApiModelProperty(value = "金蝶反关闭单个分录")
    @PostMapping("/adverseCloseSaleMaterialByEas")
    public RESTfulResult adverseCloseSaleMaterialByEas(@RequestParam BigDecimal saleMaterialId) {
        int result = amsSaleOrderService.adverseCloseSaleMaterialByEas(saleMaterialId);
        return success(result);
    }


    @ApiModelProperty(value = "反关闭金蝶整个销售订单")
    @PostMapping("/adverseCloseSaleOrder")
    public RESTfulResult adverseCloseSaleOrder(@RequestParam Integer saleOrderId) {
        int result = amsSaleOrderService.adverseCloseSaleOrder(new BigDecimal(saleOrderId));
        return success(result);
    }

    //库存调拨单
    @ApiOperation(value = "库存调拨单")
    @PostMapping("/getKucunList")
    public RESTfulResult getKucunList(@RequestBody(required = false)Map<String,Object>map,
                                      String startTime,
                                      String endTime,
                                      String remark,
                                      String transferIndep,
                                      String consigneeName,
                                      String totheStation){
        if(remark != null && !"null".equals(remark)&&!"".equals(remark)){
            map.put("remark","%" + remark + "%");
        }
        if(transferIndep != null && !"null".equals(transferIndep) && !"".equals(transferIndep)){
            map.put("transferIndep","%" + transferIndep + "%");
        }
        if(consigneeName != null && !"null".equals(consigneeName) && !"".equals(consigneeName)){
            map.put("consigneeName","%" + consigneeName + "%");
        }
        if(totheStation != null && !"null".equals(totheStation) && !"".equals(totheStation)){
            map.put("totheStation","%" + totheStation + "%");
        }
        DataChange.queryDataByDateTime(startTime, endTime, map, sdfDateTime);//根据时间段查询数据
        List<Map<String,Object>> mapList = amsSaleOrderService.getKucunList(map);
        return success(mapList);
    }


    @ApiOperation("批量新增销售订单")
    @PostMapping("addSteelSaleOrderList")
    @Transactional(rollbackFor = Exception.class)
    public RESTfulResult addSteelSaleOrderList(@RequestBody List<Map<String,Object>> mapList) throws Exception {
        int count = 0;
        String saleOrderNo = null;
        System.out.println("------销售订单批量导入Excel导入-----");
        System.out.println(mapList);
        System.out.println("------销售订单批量导入Excel导入-----");
        try {
            for (Map<String,Object> map:mapList
                 ) {
                saleOrderNo = map.get("saleOrderNo").toString();
                    count++;
                    int saleOrderId= amsSaleOrderService.addSteelSaleOrder(map);
                }
        } catch (Exception e) {
            System.out.println(e);
            throw new Exception("销售订单编号为:" + saleOrderNo + e.getMessage());
            //return failed("销售订单编号为:" + saleOrderNo + e.getMessage());
        }
        return success(count);
    }

    @ApiOperation("反关闭运单")
    @PostMapping("reverseCloseOrder")
    public RESTfulResult reverseCloseOrder(@RequestBody(required = false) Map<String,Object> map){
        //反关闭运单
        int result = amsSaleOrderService.reverseCloseOrder(map);
        return success(result);
    }

    @ApiOperation("查询销售订单状态")
    @PostMapping("getSaleOrderStatus")
    public RESTfulResult getSaleOrderStatus(@RequestParam String saleNumber){
        int result = amsSaleOrderService.getSaleOrderStatus(saleNumber);
        return success(result);
    }

    @ApiOperation("批量新增未装销售订单")
    @PostMapping("addUnloadSteelSaleOrderList")
    public RESTfulResult addUnloadSteelSaleOrderList(@RequestBody List<Map<String,Object>> mapList){
        int count = 0;
        String saleOrderNo = null;
        System.out.println("------销售订单批量导入Excel导入-----");
        System.out.println(mapList);
        System.out.println("------销售订单批量导入Excel导入-----");
        try {
            for (Map<String,Object> map:mapList
            ) {
                saleOrderNo = map.get("saleOrderNo").toString();
                count++;
                int saleOrderId= amsSaleOrderService.addSteelSaleOrder(map);
                if (map.get("isUploadEas") != null && saleOrderId != 0) {
                    amsSaleOrderService.uploadSaleOrder(new BigDecimal(saleOrderId));
                }
            }
        } catch (Exception e) {
            return failed("销售订单编号为:" + saleOrderNo + e.getMessage());
        }
        return success(count);
    }

    /**
     * 重试上传车牌号到金蝶,5min一次
     */
    @Scheduled(fixedRate=1000*60*5)
    public void retryPushCarNumberToEas(){
        List<List<Map<String,Object>>> newRetry=new ArrayList<>();
        if(retryQueen.size()<=0){
            //没有需要重传的，直接退出
            return;
        }
        System.out.println("开始重传，目前失败数量："+retryQueen.size());
        for(List<Map<String,Object>> mapList:retryQueen){
            // 调用EAS接口将车牌号传给金蝶
            Map<String,Object> input = joinFeign.findCarNumberByOrderList(mapList);
            Map<String, Object> totalMap = easCapacityTestUtil.getTotalMap();
            totalMap.put("input",input);
            System.out.println(totalMap);
            String json = JSONUtils.toJSONString(totalMap);
            System.out.println(json);
            Map<String,Object> s = joinFeign.pushCarNumberToEas(totalMap);
            if (s == null || s.size() == 0) {
                //失败，存入新的重试队列，准备下一次重试
                newRetry.add(mapList);
                System.out.println("重试:登录金蝶失败");
            }else{
                System.out.println("重试:上传车牌成功");
            }
        }
        //结束，替换掉旧的队列
        retryQueen=newRetry;
        System.out.println("重传结束，剩余失败数量："+retryQueen.size());
    }

}