DAL-DAZHOU-AMS-API/src/main/java/com/steerinfo/dil/service/impl/AmsSaleOrderMaterialServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.IMFeign;
import com.steerinfo.dil.feign.TmsTruckFeign;
import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.*;
import com.steerinfo.dil.service.IAmsSaleOrderMaterialService;
import com.steerinfo.dil.util.DataChange;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

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

    @Autowired
    private AmsSaleOrderMaterialMapper amsSaleOrderMaterialMapper;
    @Autowired
    AmsSaleTrucknoMaterialMapper amsSaleTrucknoMaterialMapper;
    @Autowired
    AmsDispatchSaleOrderMapper amsDispatchSaleOrderMapper;
    @Autowired
    OmstruckOrderMapper omstruckOrderMapper;
    @Autowired
    OmstruckOrderMaterialMapper omstruckOrderMaterialMapper;
    @Autowired
    IMFeign imFeign;
    @Autowired
    TmsTruckFeign tmsTruckFeign;
    @Autowired
    AmsSaleOrderMapper amsSaleOrderMapper;
    @Autowired
    AmsContractTransportPriceMapper amsContractTransportPriceMapper;
    @Autowired
    RmsReceivePlaceMapper rmsReceivePlaceMapper;

    @Override
    public int addAmsSaleOrderMaterial(AmsSaleOrderMaterial amsSaleOrderMaterial) {
        long id;
        if(amsSaleOrderMaterialMapper.selectMaxId()==null){
            id = 1;
        }else {
            id = amsSaleOrderMaterialMapper.selectMaxId().longValue()+1;
        }
        //生成主键id
        amsSaleOrderMaterial.setSaleOrderMaterialId(new BigDecimal(id));
        //生成车序号
        amsSaleOrderMaterial.setSaleOrderMaterialTruckNo(new BigDecimal(id));
        //常规字段
        amsSaleOrderMaterial.setInsertUsername("admin");
        amsSaleOrderMaterial.setInsertTime(new Date());
        amsSaleOrderMaterial.setUpdateUsername("admin");
        amsSaleOrderMaterial.setUpdateTime(new Date());
        amsSaleOrderMaterial.setInsertUpdateRemark("无");
        amsSaleOrderMaterial.setDeleted(new BigDecimal(0));
        amsSaleOrderMaterial.setUpdated(new BigDecimal(0));
        return amsSaleOrderMaterialMapper.insert(amsSaleOrderMaterial);
    }

    @Override
    public List<Map<String, Object>> selectBySaleOrderMaterialId(BigDecimal saleOrderMaterialId) {
        return amsSaleOrderMaterialMapper.selectBySaleOrderMaterialId(saleOrderMaterialId);
    }

    @Override
    public int updateAmsSaleOrderMaterial(AmsSaleOrderMaterial amsSaleOrderMaterial) {
        amsSaleOrderMaterial.setUpdateTime(new Date());
        return amsSaleOrderMaterialMapper.updateByPrimaryKeySelective(amsSaleOrderMaterial);
    }

    @Override
    public int deleteAmsSaleOrderMaterialBySaleOrderMaterialId(BigDecimal saleOrderMaterialId) {
        AmsSaleOrderMaterial amsSaleOrderMaterial = amsSaleOrderMaterialMapper.selectByPrimaryKey(saleOrderMaterialId);
        amsSaleOrderMaterial.setDeleted(new BigDecimal(1));
        return amsSaleOrderMaterialMapper.updateByPrimaryKey(amsSaleOrderMaterial);
    }

    @Override
    public String getAddress(BigDecimal saleOrderMaterialId) {
        return amsSaleOrderMaterialMapper.getAddress(saleOrderMaterialId);
    }

    @Override
    public int updateAddress(Map<String, Object> map) {
        String saleOrderMaterialId = map.get("saleOrderMaterialId").toString();
        //查询收货地址表中是否有该地址，无则新增，有则取收货地址Id
        String saleShippingAddress = (String) map.get("saleShippingAddress");
        BigDecimal addressId = amsSaleOrderMaterialMapper.getReceiveAddressId(saleShippingAddress);
        //获得原车次表信息
        AmsSaleOrderMaterial amsSaleOrderMaterial1 = amsSaleOrderMaterialMapper.selectByPrimaryKey(new BigDecimal(saleOrderMaterialId));
        if(addressId!=null){
            long id;
            if(amsSaleOrderMaterialMapper.selectMaxId()==null){
                id = 1;
            }else {
                id = amsSaleOrderMaterialMapper.selectMaxId().longValue()+1;
            }
            //生成主键id
            amsSaleOrderMaterial1.setSaleOrderMaterialId(new BigDecimal(id));
            amsSaleOrderMaterial1.setSaleShippingAddressId(addressId);
            //新增修改了地址的数据
            amsSaleOrderMaterialMapper.insert(amsSaleOrderMaterial1);
        }else {
            //新增收货地址，取得收货地址的Id
            Map<String,Object> mapReceive = new HashMap<>();
            long id;
            if(amsSaleOrderMaterialMapper.selectMaxIdReceive()==null){
                id = 1;
            }else {
                id = amsSaleOrderMaterialMapper.selectMaxIdReceive().longValue()+1;
            }
            mapReceive.put("addressId",new BigDecimal(id));
            mapReceive.put("addressDeliveryAddress",saleShippingAddress);
            amsSaleOrderMaterialMapper.insertReceiveAddress(mapReceive);
            //新增修改了地址的数据
            long id1;
            if(amsSaleOrderMaterialMapper.selectMaxId()==null){
                id1 = 1;
            }else {
                id1 = amsSaleOrderMaterialMapper.selectMaxId().longValue()+1;
            }
            //生成主键id
            amsSaleOrderMaterial1.setSaleOrderMaterialId(new BigDecimal(id1));
            amsSaleOrderMaterial1.setSaleShippingAddressId(new BigDecimal(id));
            //新增修改了地址的数据
            amsSaleOrderMaterialMapper.insert(amsSaleOrderMaterial1);

        }
        //修改原地址记录状态
        AmsSaleOrderMaterial amsSaleOrderMaterial2 = amsSaleOrderMaterialMapper.selectByPrimaryKey(new BigDecimal(saleOrderMaterialId));
        amsSaleOrderMaterial2.setUpdated(new BigDecimal(1));
        return amsSaleOrderMaterialMapper.updateByPrimaryKeySelective(amsSaleOrderMaterial2);
    }

    @Override
    public List<Map<String, Object>> getAddressDeliveryAddress() {
        return amsSaleOrderMaterialMapper.getAddressDeliveryAddress();
    }

    public List<Map<String, Object>> getSaleMaterial(Map<String, Object> mapValue) {
        return amsSaleOrderMaterialMapper.getSaleMaterial(mapValue);
    }


    public Integer selectById(BigDecimal saleOrderMaterialId) {
        return amsSaleOrderMaterialMapper.selectById(saleOrderMaterialId);
    }

    public Integer selectByCxh(Map<String, Object> m) {
        return amsSaleOrderMaterialMapper.selectByCxh(m);
    }

    /**
     * 展示车序号信息
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getTruckNoList(Map<String, Object> mapValue) {
        List<Map<String,Object>> mapList = amsSaleOrderMaterialMapper.getTruckNoList(mapValue);
        return mapList;
    }

    /**
     * 添加车序号与物资
     * @param mapList
     * @return
     */
    @Transactional
    @Override
    public int addTruckNo(List<Map<String, Object>> mapList) {
        int result = 0;
        for (Map<String, Object> map : mapList) {
            // 销售订单id
            BigDecimal saleOrderId = DataChange.dataToBigDecimal(map.get("saleOrderId"));
            // 车序号
            BigDecimal truckNo = DataChange.dataToBigDecimal(map.get("truckNo"));
            AmsSaleOrderMaterial amsSaleOrderMaterial;
            Map<String,Object> saleMap = new HashMap<>();
            saleMap.put("saleOrderId",saleOrderId);
            saleMap.put("saleOrderMaterialTruckNo",truckNo);
            // 检测销售订单下的车序号是否已存在
            List<AmsSaleOrderMaterial> amsSaleOrderMaterials = amsSaleOrderMaterialMapper.selectByParameters(saleMap);
            // 如果已存在则不处理
            if (amsSaleOrderMaterials != null && amsSaleOrderMaterials.size() != 0) {
                amsSaleOrderMaterial = amsSaleOrderMaterials.get(0);
            }
            // 如果不存在则新增车序号
            else {
                amsSaleOrderMaterial = new AmsSaleOrderMaterial();
                // 收货地址id
                BigDecimal shippingAddressId = DataChange.dataToBigDecimal(map.get("shippingAddressId"));
                String place = (String) (map.get("place"));
                if (place != null) {
                    List<Map<String, Object>> placeIdList = amsSaleOrderMaterialMapper.getPlaceId(place,shippingAddressId);
                    if (placeIdList == null || placeIdList.size() == 0) {
                        RmsReceivePlace rmsReceivePlace = new RmsReceivePlace();
                        rmsReceivePlace.setPlaceId(rmsReceivePlaceMapper.selectMaxId());
                        rmsReceivePlace.setAddressId(shippingAddressId);
                        rmsReceivePlace.setAddressDeliveryAddress(place);
                        amsSaleOrderMaterial.setSaleShippingAddressId(rmsReceivePlace.getPlaceId());
                        rmsReceivePlaceMapper.insertSelective(rmsReceivePlace);
                    } else {
                        amsSaleOrderMaterial.setSaleShippingAddressId((BigDecimal) placeIdList.get(0).get("placeId"));
                    }
                }
                // 截止日期
//                String dateOfReceiptStr = (String) map.get("dateOfReceipt");
//                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                Date dateOfReceipt = new Date((Long) map.get("dateOfReceipt"));
//                try {
//                    dateOfReceipt = sdf.parse(dateOfReceiptStr);
//                } catch (ParseException e) {
//                    e.printStackTrace();
//                }
                // 收货方姓名
                String orderConsignee = (String) map.get("orderConsignee");
                // 收货方联系方式
                Object orderConsigneeTel = map.get("orderConsigneeTel");
                BigDecimal saleOrderMaterialId = amsSaleOrderMaterialMapper.selectMaxId();
                amsSaleOrderMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
                amsSaleOrderMaterial.setSaleOrderId(saleOrderId);
                amsSaleOrderMaterial.setSaleOrderMaterialTruckNo(truckNo);
                // 钢材收货日期
                amsSaleOrderMaterial.setSaleDateOfReceipt(dateOfReceipt);
                amsSaleOrderMaterial.setSaleOrderConsignee(orderConsignee);
                if (orderConsignee != null) {
                    amsSaleOrderMaterial.setSaleOrderConsigneeTel(orderConsigneeTel.toString());
                }
                Object priceId = map.get("priceId");
                if(priceId != null && !"".equals(priceId)) amsSaleOrderMaterial.setPriceId(DataChange.dataToBigDecimal(priceId));
                amsSaleOrderMaterial.setInsertTime(new Date());
                amsSaleOrderMaterial.setInsertUsername("admin");
                amsSaleOrderMaterial.setDeleted(new BigDecimal(0));
                amsSaleOrderMaterial.setInsertUpdateRemark("无");
                amsSaleOrderMaterial.setUpdated(new BigDecimal(0));
                amsSaleOrderMaterial.setIssueStatus(new BigDecimal(0));
                result += amsSaleOrderMaterialMapper.insertSelective(amsSaleOrderMaterial);
            }
            // 新增车序号与物资中间表
            AmsSaleTrucknoMaterial amsSaleTrucknoMaterial = new AmsSaleTrucknoMaterial();
            // 物资id
            BigDecimal materialId = DataChange.dataToBigDecimal(map.get("saleMaterialId"));
            // 物资数量
            BigDecimal materialNumber = DataChange.dataToBigDecimal(map.get("materialNumber"));
            BigDecimal saleTrucknoMaterialId = amsSaleTrucknoMaterialMapper.selectMaxId();
            amsSaleTrucknoMaterial.setTrucknoMaterialId(saleTrucknoMaterialId);
            amsSaleTrucknoMaterial.setMaterialId(materialId);
            amsSaleTrucknoMaterial.setSaleOrderMaterialId(amsSaleOrderMaterial.getSaleOrderMaterialId());
            amsSaleTrucknoMaterial.setSaleOrderMaterialNumber(materialNumber);
            amsSaleTrucknoMaterial.setInsertTime(new Date());
            amsSaleTrucknoMaterial.setInsertUsername("admin");
            amsSaleTrucknoMaterial.setInsertUpdateRemark("无");
            result += amsSaleTrucknoMaterialMapper.insertSelective(amsSaleTrucknoMaterial);
        }
        return result;
    }

    /**
     * 下发车序号
     * @param mapList
     * @return
     */
    @Override
    public int issueTruckNo(List<Map<String, Object>> mapList) {
        int result = 0;
        for (Map<String, Object> map : mapList) {
            BigDecimal saleOrderMaterialId = DataChange.dataToBigDecimal(map.get("saleOrderMaterialId"));
            AmsSaleOrderMaterial amsSaleOrderMaterial = new AmsSaleOrderMaterial();
            amsSaleOrderMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
            amsSaleOrderMaterial.setIssueStatus(new BigDecimal(1));
            result += amsSaleOrderMaterialMapper.updateByPrimaryKeySelective(amsSaleOrderMaterial);
        }
        return result;
    }

    /**
     * 展示车序号下的物资详情
     * @param saleOrderMaterialId
     * @return
     */
    @Override
    public List<Map<String, Object>> getTruckNoMaterialList(BigDecimal saleOrderMaterialId) {
        List<Map<String, Object>> mapList = amsSaleOrderMaterialMapper.getTruckNoMaterialList(saleOrderMaterialId);
        return mapList;
    }

    /**
     * 销售订单下的物资
     * @param saleOrderId
     * @return
     */
    @Override
    public List<Map<String, Object>> getSaleMaterialList(BigDecimal saleOrderId) {
        List<Map<String, Object>> saleMaterialList = amsSaleOrderMaterialMapper.getSaleMaterialList(saleOrderId);
        return saleMaterialList;
    }

    /**
     * 销售直接派发销售订单
     * @param mapValue
     * @return
     */
    @Transactional
    @Override
    public int dispatchTruckOrderBySale(Map<String, Object> mapValue) {
        int result = 0;
        // 得到列内容
        List<Map<String,Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");
        // 销售订单主键
        BigDecimal saleOrderId = DataChange.dataToBigDecimal(mapValue.get("saleOrderId"));
        if(mapValue.get("sendAgain") == null){
            // 得到销售订单中的总重量和销售订单下的总净重
            BigDecimal saleMaterialWeight = amsSaleOrderMaterialMapper.getMaterialWeightByOrderId(saleOrderId);
            BigDecimal saleMaterialNetWeight = amsSaleOrderMaterialMapper.getMaterialNetWeightBySaleId(saleOrderId);
            if (saleMaterialNetWeight == null) {
                saleMaterialNetWeight = new BigDecimal(0);
            }
            // 计算净重所占销售订单中的比例
            Double percent = saleMaterialNetWeight.doubleValue()/saleMaterialWeight.doubleValue();
            if (percent >= 0.97) {
                return -1;
            }
        }
        // 车序号计数
        int count = 1;
        // 遍历每一个列
        for (Map<String, Object> map : mapList) {
            // 销售订单-物资中间表id
            BigDecimal saleMaterialId = DataChange.dataToBigDecimal(map.get("saleMaterialId"));
            // 物资id
            BigDecimal materialId = DataChange.dataToBigDecimal(map.get("materialId"));
            // 承运商id
            BigDecimal carrierId = DataChange.dataToBigDecimal(map.get("carrierId"));
            // 运输线路id
            BigDecimal lineId = DataChange.dataToBigDecimal(map.get("lineId"));
            // 通过线路id判断是否是钢材
            BigDecimal isSteel = amsSaleOrderMaterialMapper.getIsSteel(lineId);
            // 物资重量
            BigDecimal materialNumber = DataChange.dataToBigDecimal(map.get("orderPlanWeight"));
            // 车牌号
            String capacityNumber = (String) map.get("capacityNumber");
            // 得到运力id
            BigDecimal capacityId = amsSaleOrderMaterialMapper.getCapacityId(capacityNumber);
            // 收货方姓名
            String consigneeName = String.valueOf(map.get("saleOrderConsignee"));
            // 收货方电话
            String consigneeTel = String.valueOf(map.get("saleOrderConsigneeTel"));
            // 截止日期
            String dateOfReceiptStr = String.valueOf(map.get("saleDateOfReceipt"));
            Date dateOfReceipt = null;
            if (!"null".equals(dateOfReceiptStr) && !"undefined".equals(dateOfReceiptStr)) {
                dateOfReceipt = new Date(Long.valueOf(dateOfReceiptStr));
            }
            /*
             车序号表
             */
            AmsSaleOrderMaterial amsSaleOrderMaterial = new AmsSaleOrderMaterial();
            // 收货地址id
            BigDecimal shippingAddressId = DataChange.dataToBigDecimal(map.get("saleShipperAddressId"));
            String place = (String) (map.get("place"));
            if (place != null) {
                List<Map<String, Object>> placeIdList = amsSaleOrderMaterialMapper.getPlaceId(place,shippingAddressId);
                if (placeIdList == null || placeIdList.size() == 0) {
                    RmsReceivePlace rmsReceivePlace = new RmsReceivePlace();
                    rmsReceivePlace.setPlaceId(rmsReceivePlaceMapper.selectMaxId());
                    rmsReceivePlace.setAddressId(shippingAddressId);
                    rmsReceivePlace.setAddressDeliveryAddress(place);
                    amsSaleOrderMaterial.setSaleShippingAddressId(rmsReceivePlace.getPlaceId());
                    rmsReceivePlaceMapper.insertSelective(rmsReceivePlace);
                } else {
                    amsSaleOrderMaterial.setSaleShippingAddressId((BigDecimal) placeIdList.get(0).get("placeId"));
                }
            }
            // 主键
            BigDecimal saleOrderMaterialId = amsSaleOrderMaterialMapper.selectMaxId();
            amsSaleOrderMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
            // 销售订单主键
            amsSaleOrderMaterial.setSaleOrderId(saleOrderId);
            // 车序号
            amsSaleOrderMaterial.setSaleOrderMaterialTruckNo(new BigDecimal(count));
            // 截止日期
            amsSaleOrderMaterial.setSaleDateOfReceipt(dateOfReceipt);
            // 收货方姓名
            if (!consigneeName.equals("null") && !consigneeName.equals("undefined")) {
                amsSaleOrderMaterial.setSaleOrderConsignee(consigneeName);
            }
            // 收货方联系方式
            if (!consigneeTel.equals("null") && !consigneeTel.equals("undefined")) {
                amsSaleOrderMaterial.setSaleOrderConsigneeTel(consigneeTel);
            }
            // 下发状态
            amsSaleOrderMaterial.setIssueStatus(new BigDecimal(2));
            /*
             车序号与物资子表
             */
            AmsSaleTrucknoMaterial amsSaleTrucknoMaterial = new AmsSaleTrucknoMaterial();
            // 主键
            BigDecimal truckNoMaterialId = amsSaleTrucknoMaterialMapper.selectMaxId();
            amsSaleTrucknoMaterial.setTrucknoMaterialId(truckNoMaterialId);
            // 销售订单-物资中间表id
            amsSaleTrucknoMaterial.setMaterialId(saleMaterialId);
            // 车序号主键
            amsSaleTrucknoMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
            // 物资重量
            amsSaleTrucknoMaterial.setSaleOrderMaterialNumber(materialNumber);
            /*
             定向派单表
             */
            AmsDispatchSaleOrder amsDispatchSaleOrder = new AmsDispatchSaleOrder();
            // 主键
            BigDecimal dispatchId = amsDispatchSaleOrderMapper.selectOtherId();
            amsDispatchSaleOrder.setDispatchId(dispatchId);
            // 车序号表id
            amsDispatchSaleOrder.setSaleOrderMaterialId(saleOrderMaterialId);
            // 承运商id
            amsDispatchSaleOrder.setCarrierId(carrierId);
            // 派单时间和成交时间
            amsDispatchSaleOrder.setDispatchTime(new Date());
            amsDispatchSaleOrder.setDispatchDealTime(new Date());
            // 成交类型
            amsDispatchSaleOrder.setDispatchType(new BigDecimal(0));
            // 车序号状态
            amsDispatchSaleOrder.setDispatchStatus(new BigDecimal(2));
            /*
             运输订单
             */
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            // 运输订单主键
            BigDecimal orderId = omstruckOrderMapper.selectMaxId();
            omstruckOrder.setOrderId(orderId);
            // 车序号主键
            omstruckOrder.setOrderPlanId(saleOrderMaterialId);
            //添加承运商ID 和 运价ID
//            Object priceId = map.get("priceId");
            Object priceId = map.get("priceId");
            if (priceId != null) {
                omstruckOrder.setPriceId(DataChange.dataToBigDecimal(priceId));
            }
            omstruckOrder.setCarrierId(carrierId);
            // 运输订单号
            omstruckOrder.setOrderNumber(DataChange.generateEightDigitsNumber("WYSDD",orderId.intValue()));
            // 运力id
            omstruckOrder.setCapacityId(capacityId);
            // 承运商
            omstruckOrder.setCarrierId(carrierId);
            // 下发时间
            omstruckOrder.setOrderIssueTime(new Date());
            // 运单状态
            omstruckOrder.setOrderStatus(new BigDecimal(4));
            BigDecimal status;
            // 钢材
            if (isSteel != null && isSteel.intValue() == 1) {
                status = new BigDecimal(1);
            }
            // 非钢材（危化品，焦炭，副产品）
            else {
                status = new BigDecimal(2);
            }
            // 订单类型
            omstruckOrder.setOrderType(status);
            // 运输线路id
            omstruckOrder.setLineId(lineId);
            omstruckOrder.setInsertTime(new Date());
            /*
             运输订单子表
             */
            OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
            // 主键
            BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
            omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
            // 运输订单id
            omstruckOrderMaterial.setOrderId(orderId);
            // 物资id
            omstruckOrderMaterial.setMaterialId(materialId);
            // 物资重量
            omstruckOrderMaterial.setOrderMaterialWeight(materialNumber);
            omstruckOrderMaterial.setInsertTime(new Date());
            // 新增车序号表
            result += amsSaleOrderMaterialMapper.insertSelective(amsSaleOrderMaterial);
            // 新增车序号-物资中间表
            result += amsSaleTrucknoMaterialMapper.insertSelective(amsSaleTrucknoMaterial);
            // 新增定向派单表
            result += amsDispatchSaleOrderMapper.insertSelective(amsDispatchSaleOrder);
            // 新增运输订单
            result += omstruckOrderMapper.insertSelective(omstruckOrder);
            // 新增运输订单子表
            result += omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
            // 调用websocket
            Map<String,Object> orderIdMap = new HashMap<>();
            orderIdMap.put("orderId",orderId);
            pushMesToWebsocket(orderIdMap);
            // 生成运输执行总实绩
            result += tmsTruckFeign.addTotalResult(orderIdMap);
            // 车序号累加
            count++;
        }

        return result;
    }

    @Override
    public int updateInwardConsignee(Map<String, Object> mapValue) {
        if(mapValue.get("saleMaterialId") != null && mapValue.get("sendStationId") != null ){
            amsSaleOrderMaterialMapper.updateSendStation(mapValue);
        }
        if(mapValue.get("saleOrderId") != null && mapValue.get("consigneeId") != null){
            amsSaleOrderMaterialMapper.updateInwardConsignee(mapValue);
        }
        return 1;
    }

    /**
     * 内转钢材派发订单
     * @param mapValue
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int dispatchInwardTruckOrderBySale(Map<String, Object> mapValue) {
        int result = 0;
        // 得到列内容
        List<Map<String,Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");
        // 销售订单主键
        BigDecimal saleOrderId = DataChange.dataToBigDecimal(mapValue.get("saleOrderId"));
        // 车序号计数
        int count = 1;
        /*
        车序号表,只生成一次,对应多个子表(物资)
        */
        AmsSaleOrderMaterial amsSaleOrderMaterial = new AmsSaleOrderMaterial();
        // 主键
        BigDecimal saleOrderMaterialId = amsSaleOrderMaterialMapper.selectMaxId();
        amsSaleOrderMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
        // 销售订单主键
        amsSaleOrderMaterial.setSaleOrderId(saleOrderId);
        // 车序号
        amsSaleOrderMaterial.setSaleOrderMaterialTruckNo(new BigDecimal(count));
        // 下发状态
        amsSaleOrderMaterial.setIssueStatus(new BigDecimal(2));
        // 新增车序号表
        result += amsSaleOrderMaterialMapper.insertSelective(amsSaleOrderMaterial);
        BigDecimal orderId = omstruckOrderMapper.selectMaxId();
        if(mapList.size()>=1){
            //更新发站
            Map<String,Object> map=mapList.get(0);
            amsSaleOrderMaterialMapper.updateSendStation(map);
            /*
             运输订单
             */
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            // 运输订单主键
            omstruckOrder.setOrderId(orderId);
            // 车序号主键
            omstruckOrder.setOrderPlanId(saleOrderMaterialId);
            //添加承运商ID 和 运价ID
//            Object priceId = map.get("priceId");
            Object priceId = map.get("priceId");
            if (priceId != null) {
                omstruckOrder.setPriceId(DataChange.dataToBigDecimal(priceId));
            }
            // 承运商id
            BigDecimal carrierId = DataChange.dataToBigDecimal(map.get("carrierId"));
            // 运输线路id
            BigDecimal lineId = DataChange.dataToBigDecimal(map.get("lineId"));
            // 车牌号
            String capacityNumber = (String) map.get("capacityNumber");
            // 得到运力id
            BigDecimal capacityId = amsSaleOrderMaterialMapper.getCapacityId(capacityNumber);
            // 运输订单号
            omstruckOrder.setOrderNumber(DataChange.generateEightDigitsNumber("WYSDD",orderId.intValue()));
            // 运力id
            omstruckOrder.setCapacityId(capacityId);
            // 承运商
            omstruckOrder.setCarrierId(carrierId);
            // 下发时间
            omstruckOrder.setOrderIssueTime(new Date());
            // 运单状态
            omstruckOrder.setOrderStatus(new BigDecimal(4));
            // 订单类型
            omstruckOrder.setOrderType(new BigDecimal(4));
            // 运输线路id
            omstruckOrder.setLineId(lineId);
            omstruckOrder.setInsertTime(new Date());
            // 新增运输订单
            result += omstruckOrderMapper.insertSelective(omstruckOrder);
        }
        // 遍历每一个列
        for (Map<String, Object> map : mapList) {
            // 销售订单-物资中间表id
            BigDecimal saleMaterialId = DataChange.dataToBigDecimal(map.get("saleMaterialId"));
            // 物资id
            BigDecimal materialId = DataChange.dataToBigDecimal(map.get("materialId"));
            // 承运商id
            BigDecimal carrierId = DataChange.dataToBigDecimal(map.get("carrierId"));
            // 运输线路id
            BigDecimal lineId = DataChange.dataToBigDecimal(map.get("lineId"));
            // 通过线路id判断是否是钢材
            BigDecimal isSteel = amsSaleOrderMaterialMapper.getIsSteel(lineId);
            // 物资重量
            BigDecimal materialNumber = DataChange.dataToBigDecimal(map.get("materialWeight"));
            // 物资数量
            BigDecimal materialNum = DataChange.dataToBigDecimal(map.get("materialNum"));
            // 车牌号
            String capacityNumber = (String) map.get("capacityNumber");
            // 得到运力id
            BigDecimal capacityId = amsSaleOrderMaterialMapper.getCapacityId(capacityNumber);
            // 收货方姓名
            String consigneeName = String.valueOf(map.get("consigneeName"));
            // 收货方电话
            //String consigneeTel = String.valueOf(map.get("saleOrderConsigneeTel"));
            // 截止日期
            String dateOfReceiptStr = String.valueOf(map.get("saleDateOfReceipt"));
            Date dateOfReceipt = null;
            if (!"null".equals(dateOfReceiptStr) && !"undefined".equals(dateOfReceiptStr)) {
                dateOfReceipt = new Date(Long.valueOf(dateOfReceiptStr));
            }

            /*
             车序号与物资子表
             */
            AmsSaleTrucknoMaterial amsSaleTrucknoMaterial = new AmsSaleTrucknoMaterial();
            // 主键
            BigDecimal truckNoMaterialId = amsSaleTrucknoMaterialMapper.selectMaxId();
            amsSaleTrucknoMaterial.setTrucknoMaterialId(truckNoMaterialId);
            // 销售订单-物资中间表id
            amsSaleTrucknoMaterial.setMaterialId(saleMaterialId);
            // 车序号主键
            amsSaleTrucknoMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
            // 物资重量
            amsSaleTrucknoMaterial.setMaterialTheoreticalWeight(materialNumber);
            amsSaleTrucknoMaterial.setSaleOrderMaterialNumber(materialNum);
            /*
             定向派单表
             */
            AmsDispatchSaleOrder amsDispatchSaleOrder = new AmsDispatchSaleOrder();
            // 主键
            BigDecimal dispatchId = amsDispatchSaleOrderMapper.selectOtherId();
            amsDispatchSaleOrder.setDispatchId(dispatchId);
            // 车序号表id
            amsDispatchSaleOrder.setSaleOrderMaterialId(saleOrderMaterialId);
            // 承运商id
            amsDispatchSaleOrder.setCarrierId(carrierId);
            // 派单时间和成交时间
            amsDispatchSaleOrder.setDispatchTime(new Date());
            amsDispatchSaleOrder.setDispatchDealTime(new Date());
            // 成交类型
            amsDispatchSaleOrder.setDispatchType(new BigDecimal(0));
            // 车序号状态
            amsDispatchSaleOrder.setDispatchStatus(new BigDecimal(2));

            /*
             运输订单子表
             */
            OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
            // 主键
            BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
            omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
            // 运输订单id
            omstruckOrderMaterial.setOrderId(orderId);
            // 物资id
            omstruckOrderMaterial.setMaterialId(materialId);
            // 物资重量
            omstruckOrderMaterial.setOrderMaterialWeight(materialNumber);
            //物资数量
            omstruckOrderMaterial.setOrderMaterialNumber(materialNum);
            omstruckOrderMaterial.setInsertTime(new Date());
            // 新增车序号-物资中间表
            result += amsSaleTrucknoMaterialMapper.insertSelective(amsSaleTrucknoMaterial);
            // 新增定向派单表
            result += amsDispatchSaleOrderMapper.insertSelective(amsDispatchSaleOrder);

            // 新增运输订单子表
            result += omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
            // 车序号累加
            count++;
        }
        // 调用websocket
        Map<String,Object> orderIdMap = new HashMap<>();
        orderIdMap.put("orderId",orderId);
        pushMesToWebsocket(orderIdMap);
        // 生成运输执行总实绩
        result += tmsTruckFeign.addTotalResult(orderIdMap);
        return result;
    }

    /**
     * 承运商直接派发销售订单
     * @param mapValue
     * @return
     */
    @Override
    public int dispatchTruckOrderByCarrier(Map<String, Object> mapValue) {
        int result = 0;
        // 得到列内容
        List<Map<String,Object>> mapList = (List<Map<String, Object>>) mapValue.get("mapList");
        // 销售订单主键
        BigDecimal saleOrderId = DataChange.dataToBigDecimal(mapValue.get("saleOrderId"));
        // 得到最大的车序号
        BigDecimal count = DataChange.dataToBigDecimal(mapValue.get("truckNo"));
        // 车序号计数
        if (count.intValue() == 0) {
            count = new BigDecimal(1);
        }
        // 遍历每一个列
        for (Map<String, Object> map : mapList) {
            // 销售订单-物资中间表id
            BigDecimal saleMaterialId = DataChange.dataToBigDecimal(map.get("saleMaterialId"));
            // 物资id
            BigDecimal materialId = DataChange.dataToBigDecimal(map.get("materialId"));
            // 收货地址id
            BigDecimal saleShippingAddressId = DataChange.dataToBigDecimal(map.get("saleShippingAddressId"));
            if (saleShippingAddressId.intValue() == 0) {
                saleShippingAddressId = null;
            }
            // 承运商id
            BigDecimal carrierId = DataChange.dataToBigDecimal(map.get("carrierId"));
            // 运输线路id
            BigDecimal lineId = DataChange.dataToBigDecimal(map.get("lineId"));
            // 通过线路id判断是否是钢材
            BigDecimal isSteel = amsSaleOrderMaterialMapper.getIsSteel(lineId);
            // 物资重量
            BigDecimal materialNumber = DataChange.dataToBigDecimal(map.get("orderPlanWeight"));
            // 车牌号
            String capacityNumber = (String) map.get("capacityNumber");
            // 得到运力id
            BigDecimal capacityId = amsSaleOrderMaterialMapper.getCapacityId(capacityNumber);
            // 收货方姓名
            String consigneeName = String.valueOf(map.get("saleOrderConsignee"));
            // 收货方电话
            String consigneeTel = String.valueOf(map.get("saleOrderConsigneeTel"));
            // 截止日期
            String dateOfReceiptStr = "4102415999000";
            Date dateOfReceipt = new Date(Long.valueOf(dateOfReceiptStr));
            /*
             车序号表
             */
            AmsSaleOrderMaterial amsSaleOrderMaterial = new AmsSaleOrderMaterial();
            // 主键
            BigDecimal saleOrderMaterialId = amsSaleOrderMaterialMapper.selectMaxId();
            amsSaleOrderMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
            // 销售订单主键
            amsSaleOrderMaterial.setSaleOrderId(saleOrderId);
            // 车序号
            amsSaleOrderMaterial.setSaleOrderMaterialTruckNo(count);
            // 收货地址
            amsSaleOrderMaterial.setSaleShippingAddressId(saleShippingAddressId);
            // 截止日期
            amsSaleOrderMaterial.setSaleDateOfReceipt(dateOfReceipt);
            // 收货方姓名
            if (!consigneeName.equals("null") && !consigneeName.equals("undefined")) {
                amsSaleOrderMaterial.setSaleOrderConsignee(consigneeName);
            }
            // 收货方联系方式
            if (!consigneeTel.equals("null") && !consigneeTel.equals("undefined")) {
                amsSaleOrderMaterial.setSaleOrderConsigneeTel(consigneeTel);
            }
            // 下发状态
            amsSaleOrderMaterial.setIssueStatus(new BigDecimal(2));
            /*
             车序号与物资子表
             */
            AmsSaleTrucknoMaterial amsSaleTrucknoMaterial = new AmsSaleTrucknoMaterial();
            // 主键
            BigDecimal truckNoMaterialId = amsSaleTrucknoMaterialMapper.selectMaxId();
            amsSaleTrucknoMaterial.setTrucknoMaterialId(truckNoMaterialId);
            // 销售订单-物资中间表id
            amsSaleTrucknoMaterial.setMaterialId(saleMaterialId);
            // 车序号主键
            amsSaleTrucknoMaterial.setSaleOrderMaterialId(saleOrderMaterialId);
            // 物资重量
            amsSaleTrucknoMaterial.setSaleOrderMaterialNumber(materialNumber);
            /*
             定向派单表
             */
            AmsDispatchSaleOrder amsDispatchSaleOrder = new AmsDispatchSaleOrder();
            // 主键
            BigDecimal dispatchId = amsDispatchSaleOrderMapper.selectOtherId();
            amsDispatchSaleOrder.setDispatchId(dispatchId);
            // 车序号表id
            amsDispatchSaleOrder.setSaleOrderMaterialId(saleOrderMaterialId);
            // 承运商id
            amsDispatchSaleOrder.setCarrierId(carrierId);
            // 派单时间和成交时间
            amsDispatchSaleOrder.setDispatchTime(new Date());
            amsDispatchSaleOrder.setDispatchDealTime(new Date());
            // 成交类型
            amsDispatchSaleOrder.setDispatchType(new BigDecimal(0));
            // 车序号状态
            amsDispatchSaleOrder.setDispatchStatus(new BigDecimal(2));
            /*
             运输订单
             */
            OmstruckOrder omstruckOrder = new OmstruckOrder();
            String orgCode =(String) mapValue.get("orgCode");
            if (orgCode==null||orgCode.equals("")){

            }else {
                omstruckOrder.setOptionerCode(orgCode);
            }
            // 运输订单主键
            BigDecimal orderId = omstruckOrderMapper.selectMaxId();
            omstruckOrder.setOrderId(orderId);
            omstruckOrder.setCarrierId(carrierId);
            // 车序号主键
            omstruckOrder.setOrderPlanId(saleOrderMaterialId);
            // 运输订单号
            omstruckOrder.setOrderNumber(DataChange.generateEightDigitsNumber("WYSDD",orderId.intValue()));
            // 运力id
            omstruckOrder.setCapacityId(capacityId);
            // 下发时间
            omstruckOrder.setOrderIssueTime(new Date());
            // 承运商
            omstruckOrder.setCarrierId(carrierId);
            // 运单状态
            omstruckOrder.setOrderStatus(new BigDecimal(4));
            BigDecimal status;
            status = new BigDecimal(2);
            // 非钢材（危化品和焦炭）
//            if (isSteel != null && (isSteel.intValue() == 3 || isSteel.intValue() == 4 || isSteel.intValue() == 6)) {
//                status = new BigDecimal(2);
//            }
//            // 钢材
//            else {
//                status = new BigDecimal(1);
//            }
            // 订单类型
            omstruckOrder.setOrderType(status);
            // 运输线路id
            omstruckOrder.setLineId(lineId);
            omstruckOrder.setInsertTime(new Date());
            /*
             运输订单子表
             */
            OmstruckOrderMaterial omstruckOrderMaterial = new OmstruckOrderMaterial();
            // 主键
            BigDecimal orderMaterialId = omstruckOrderMaterialMapper.selectMaxId();
            omstruckOrderMaterial.setOrderMaterialId(orderMaterialId);
            // 运输订单id
            omstruckOrderMaterial.setOrderId(orderId);
            // 物资id
            omstruckOrderMaterial.setMaterialId(materialId);
            // 物资重量
            omstruckOrderMaterial.setOrderMaterialWeight(materialNumber);
            // 新增车序号表
            result += amsSaleOrderMaterialMapper.insertSelective(amsSaleOrderMaterial);
            // 新增车序号-物资中间表
            result += amsSaleTrucknoMaterialMapper.insertSelective(amsSaleTrucknoMaterial);
            // 新增定向派单表
            result += amsDispatchSaleOrderMapper.insertSelective(amsDispatchSaleOrder);
            // 新增运输订单
            result += omstruckOrderMapper.insertSelective(omstruckOrder);
            // 新增运输订单子表
            result += omstruckOrderMaterialMapper.insertSelective(omstruckOrderMaterial);
            // 调用websocket
            Map<String,Object> orderIdMap = new HashMap<>();
            orderIdMap.put("orderId",orderId);
            pushMesToWebsocket(orderIdMap);
            // 生成运输执行总实绩
            result += tmsTruckFeign.addTotalResult(orderIdMap);
            // 车序号累加
            count = new BigDecimal(count.intValue() + 1);
        }
        // 修改状态为开启状态
        AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
        amsSaleOrder.setSaleOrderId(saleOrderId);
        amsSaleOrder.setCloseStatus(new BigDecimal(0));
        result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
        return result;
    }

    /**
     * 关闭销售订单
     * @param saleOrderId
     * @return
     */
    @Override
    public int closeSaleOrder(BigDecimal saleOrderId) {
        AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
        amsSaleOrder.setSaleOrderId(saleOrderId);
        amsSaleOrder.setCloseStatus(new BigDecimal(1));
        int result = amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
        return result;
    }

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

    @Override
    public Map<String, Object> getPriceMap(Map<String, Object> map) {
        Object addressId = map.get("addressId");
        String place = (String) map.get("place");
        Map<String,Object> priceMap = new HashMap<>();
        priceMap.put("addressId",addressId);
        priceMap.put("place",place);
        BigDecimal priceId = omstruckOrderMapper.getPriceId(priceMap);
        BigDecimal priceValue;
        if (priceId == null) {
            priceValue = omstruckOrderMapper.findMaxPrice(addressId);
            if (priceValue != null) {
                priceMap.put("priceValue", priceValue);
                List<Map<String, Object>> priceIdList = omstruckOrderMapper.findMaxPriceId(priceMap);
                priceId = (BigDecimal) priceIdList.get(0).get("priceId");
            }
            else {
                Map<String,Object> map1 = new HashMap<>();
                map1.put("priceValue",-1);
                map1.put("priceId",-1);
                return map1;
            }
        }
        else {
            AmsContractTransportPrice amsContractTransportPrice = amsContractTransportPriceMapper.selectByPrimaryKey(priceId);
            priceValue = amsContractTransportPrice.getPriceValue();
        }
        priceMap.put("priceId",priceId);
        priceMap.put("priceValue",priceValue);
        return priceMap;
    }

    /**
     * 得到单价和单价id
     * @param map
     * @return
     */
    @Override
    public Map<String, Object> getBenPrice(Map<String, Object> map) {
        BigDecimal saleOrderId = DataChange.dataToBigDecimal(map.get("saleOrderId"));
        BigDecimal carrierId = DataChange.dataToBigDecimal(map.get("carrierId"));
        Map<String, Object> saleMessage = amsSaleOrderMaterialMapper.getSaleMessage(saleOrderId);
        String isSelfMention = (String) saleMessage.get("isSelfMention");
        BigDecimal receiveId = (BigDecimal) saleMessage.get("receiveId");
        BigDecimal priceId = null;
        BigDecimal priceValue = null;
        Map<String,Object> resultMap = new HashMap<>();
        List<Map<String,Object>> mapList = amsSaleOrderMaterialMapper.getPriceList(carrierId);
        if ((isSelfMention.equals("否") && receiveId.intValue() == 1516) && (mapList != null && mapList.size() != 0)) {
            Map<String, Object> priceMap = mapList.get(1);
            priceId = (BigDecimal) priceMap.get("priceId");
            priceValue = (BigDecimal) priceMap.get("priceValue");
        }
        if ((isSelfMention.equals("否") && receiveId.intValue() == 836) && (mapList != null && mapList.size() != 0)) {
            Map<String, Object> priceMap = mapList.get(0);
            priceId = (BigDecimal) priceMap.get("priceId");
            priceValue = (BigDecimal) priceMap.get("priceValue");
        }
        resultMap.put("priceId",priceId);
        resultMap.put("priceValue",priceValue);
        return resultMap;
    }


}