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

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.BmsShipFeign;
import com.steerinfo.dil.feign.BmsTruckFeign;
import com.steerinfo.dil.feign.IMFeign;
import com.steerinfo.dil.mapper.UtilsMapper;
import com.steerinfo.dil.service.IUtilsService;
import com.steerinfo.dil.util.DataChange;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * @ author    :TXF
 * @ time      :2021/10/26 14:42
 */

@Service(value = "utilsService")
public class UtilsServiceImpl implements IUtilsService {
    @Autowired
    private UtilsMapper utilsMapper;

    @Autowired
    private IMFeign imFeign;

    @Autowired
    private BmsTruckFeign bmsTruckFeign;
    /**
     * 查询运输订单ID主键
     * @return
     */
    @Override
    public BigDecimal selectOrderMaxId() {
        return utilsMapper.selectOrderMaxId();
    }

    /**
     * 查询运输订单子表主键ID
     * @return
     */
    @Override
    public BigDecimal selectOrderMaterialMaxId() {
        return utilsMapper.selectOrderMaterialMaxId();
    }

    /**
     * 修改运力状态
     * @param map {必要参数：capacityId 运力ID  或者 capacityNumber 车牌号}
     * @param status 类型
     * @return
     */
    public int updateCapacityStatus(Map<String, Object> map, Integer status){
        map.put("capacityStatus", status);
        return  utilsMapper.updateCapacityByCarIdOrNum(map);
    }


    /**
     * 修改订单状态为结束
     * @param map {orderId 订单Id 或运输订购单号
     * @return
     */
    public int closeOrderNormally(Map<String, Object> map){
        //查询订单路段顺序号以及查询路段顺序号
        Map<String, Object> mesMap = utilsMapper.getLineSeqAndOrderSeq(map);
        BigDecimal orderSeq = DataChange.dataToBigDecimal(mesMap.get("orderSeq"));
        BigDecimal maxSeq = DataChange.dataToBigDecimal(mesMap.get("maxSeq"));
        if(orderSeq.intValue() == maxSeq.intValue()){
            map.put("orderStatus", 2);
            return utilsMapper.updateOrderStatusByOrderIdOrNum(map);
        }
        if(map.get("priceId")!=null){
            //如果有价格ID 则说明需要结算 调用新增详单接口
//            bmsTruckFeign.addDetailsOrder(DataChange.dataToBigDecimal(map.get("orderId")));
        }
        return 0;
    }

    /**
     * 通过仓库名称查询仓库Id
     * @param warehouseName
     * @return
     */
    @Override
    public Integer queryWarehouseIdByName(String warehouseName) {
        return utilsMapper.queryWarehouseIdByName(warehouseName);
    }

    /**
     * 用于更新路段顺序号 取实绩中的路段顺序号
     * @param map 运输订单号 或者是运输订单ID    实绩中的路段顺序号
     * @return
     */
    public int updateOrderLineSequence(Map<String, Object> map){
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        if(orderId.intValue() == 0){
            //如果没有传入运输订单Id则需要传入了运输订单号
            orderId = utilsMapper.getOrderIdByOrderNumber((String) map.get("orderNumber"));
        }
        //根据订单查询里面订单里面的路段顺序号
        BigDecimal orderLineSequence = utilsMapper.getOrderSeq(orderId);
        //这是该实绩的路段顺序号
        BigDecimal segmentSqe = DataChange.dataToBigDecimal(map.get("segmentSqe"));
        if(segmentSqe.intValue() == 0){
            return 0;
        }
        //如果订单里面路段顺序号 大于 实绩里面路段顺序号,则不更新
        if (orderLineSequence != null && segmentSqe != null && orderLineSequence.intValue() > segmentSqe.intValue()) {
            segmentSqe = orderLineSequence;
        }
        Map<String, Object> mesMap = new HashMap<>();
        mesMap.put("orderId", orderId);
        mesMap.put("orderLineSequence", segmentSqe);
        return utilsMapper.updateLineSeqByOrderIdOrNum(mesMap);
    }

    /**
     * 厂内内转订单专属更新路段顺序号方法
     * @Author TXF
     * @Date 2022/2/17 22:02
     * @param map
     * @return
     **/
    public int updateOrderLineSqeByOrderNumber(Map<String, Object> map){
        return utilsMapper.updateLineSeqByOrderIdOrNum(map);
    }


    /**
     * 通过月台名称查询月台Id
     * @param platformName
     * @return
     */
    @Override
    public Integer queryPlatformIdByName(String platformName) {
        return utilsMapper.queryPlatformIdByName(platformName);
    }

    /**
     * 查询路段顺序号
     * @param orderId
     * @return
     */
    @Override
    public Integer getLineSequenceByOrderId(BigDecimal orderId) {
        return utilsMapper.getLineSequenceByOrderId(orderId);
    }

    /**
     * 查询订单中所需要运输的物资  物资表对订单表 一对多
     * @param map 运输订单号 orderNumber
     * @return
     */
    @Override
    public List<Integer> getAllMaterialId(Map<String, Object> map) {
        return utilsMapper.getAllMaterialId(map);
    }


    /**
     * 通过总实绩ID查询订单Id
     * @param resultTotalId
     * @return
     */
    @Override
    public Integer getOrderIdByTotalId(Integer resultTotalId) {
        return utilsMapper.getOrderIdByTotalId(resultTotalId);
    }

    /**
     * 推送消息给websocket
     * @param capacityNumber
     * @param pushMes
     */
    @Override
    public void pushMesToWebsocket(String capacityNumber, String pushMes) {
        //添加消息实体
        HashMap<Object, Object> mesMap = new HashMap<>();
        mesMap.put("messageType", 4); //用于进厂后 刷新消息
        mesMap.put("sendPerson", "system");
        mesMap.put("receivePerson", capacityNumber);
        mesMap.put("messageContent", pushMes + new Date());
        mesMap.put("createTime", new Date());
        ArrayList<Object> list = new ArrayList<>();
        list.add(mesMap);
        //调用websocket接口推送
        HashMap<Object, Object> sendMap = new HashMap<>();
        //将消息实体放入list中存到map中
        sendMap.put("messages", list);
        try {
            imFeign.sendToUser(sendMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public int randomGetValue(List<Integer> dataList){
        if(dataList.size() != 0&&dataList !=null){
            if(dataList.size() == 1){
                return dataList.get(0);
            }else {
                //如果有多个值则随机取一个
                Random random = new Random();
                int i = random.nextInt(dataList.size());
                return dataList.get(i);
            }
        }else {
            return 0;
        }
    }

    public int closeOrderSteel(Map<String, Object> map) {
        map.put("orderStatus", 2);
        return utilsMapper.updateOrderStatusByOrderIdOrNum(map);
    }
}