device-link-ykc/src/main/java/com/tmzn/devicelinkykc/message/YkcMsgHandle.java

package com.tmzn.devicelinkykc.message;

import cn.hutool.db.sql.Order;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.tmzn.devicelinkykc.constant.Constant;
import com.tmzn.devicelinkykc.constant.DeviceOnlineStatus;
import com.tmzn.devicelinkykc.constant.PortStatusConstant;
import com.tmzn.devicelinkykc.constant.RedisConstant;
import com.tmzn.devicelinkykc.constant.ykc.BillingModelConst;
import com.tmzn.devicelinkykc.constant.ykc.StatusConstant;
import com.tmzn.devicelinkykc.constant.ykc.TransConstant;
import com.tmzn.devicelinkykc.entity.BillingModel;
import com.tmzn.devicelinkykc.entity.DeviceStatus;
import com.tmzn.devicelinkykc.entity.OrderStatus;
import com.tmzn.devicelinkykc.entity.TransOrder;
import com.tmzn.devicelinkykc.frameMsg.DataConversion;
import com.tmzn.devicelinkykc.frameMsg.TransMoney;
import com.tmzn.devicelinkykc.frameMsg.frameType.*;
import com.tmzn.devicelinkykc.mapstruct.TransMapping;
import com.tmzn.devicelinkykc.msgEnum.YkcSendDevice;
import com.tmzn.devicelinkykc.openfeign.MsgService;
import com.tmzn.devicelinkykc.openfeign.transdata.DataParam;
import com.tmzn.devicelinkykc.openfeign.transdata.RpcResult;
import com.tmzn.devicelinkykc.redis.RedisCache;
import com.tmzn.devicelinkykc.service.*;
import com.tmzn.devicelinkykc.socket.DeviceConnectionMsg;
import com.tmzn.devicelinkykc.socket.SocketHandle;
//import com.tmzn.devicelinkykc.test.SendMsgToDevice;
import com.tmzn.devicelinkykc.transdata.entity.DeviceParam;
import com.tmzn.devicelinkykc.transdata.entity.MainBoard;
import com.tmzn.devicelinkykc.transdata.entity.opertype.OperEnum;
import com.tmzn.devicelinkykc.util.Encrytion;
import com.tmzn.devicelinkykc.util.ResultUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @author xp
 * @date 2024/3/13
 * @explain "  "
 */
@Component
public class YkcMsgHandle {

    private static final Logger logger = LoggerFactory.getLogger(YkcMsgHandle.class);
    private static final BigDecimal zero = new BigDecimal("0");

    @Autowired
    private RedisCache redisCache;
    @Autowired
    private OrderStatusService orderStatusService;
    @Autowired
    private DeviceStatusService deviceStatusService;
    @Autowired
    private DeviceControlerService deviceControlerService;
    @Autowired
    private CheckTime checkTime;
    @Autowired
    private BillingModelFrame billingModelFrame;
    @Autowired
    private MsgService msgService;
    @Autowired
    private BillingModelService billingModelService;
    @Autowired
    private RealTimeStatusPushFrame realTimeStatusPushFrame;
    @Autowired
    private CharngingPushFrame charngingPushFrame;
    @Autowired
    private RemoteBalanceUpdatePushFrame remoteBalanceUpdatePushFrame;
    @Autowired
    private TransMoney transMoney;
    @Autowired
    private TransactionFlowPushFrame transactionFlowPushFrame;

    @Autowired
    private TransOrderService transOrderService;
    @Autowired
    private TransMapping transMapping;

    public void startListening(DeviceConnectionMsg deviceConnectionMsg) {

        Runnable listener = () -> {
            boolean temp = true;
            while (temp) {
                // 接收数据帧
                byte[] receiveData = new byte[1024];
                int length = 0;
                try {
                    if (deviceConnectionMsg.getSocket().isConnected()) {
                        length = deviceConnectionMsg.getSocket().getInputStream().read(receiveData);
                    } else {
                        logger.info("receiveYKCData socket no>>>>");
                    }
                    if (length < 0) {
                        return;
                    }
                } catch (IOException e) {
                    //e.printStackTrace();
                    String message = e.getMessage();
                    logger.info(deviceConnectionMsg.getDeviceId() + ":Receive YKC dataMsg IOException !!!!!!!:" + message + "!!!!!!!!" + message + "!!!!!!!!" + message + "!!!!!!!!" + message + "!!!!!!!!");
                    //异常后操作删除所有的缓存,重新获取
                    DataParam dataParam = new DataParam();
                    dataParam.setDeviceId(deviceConnectionMsg.getImei());
                    dataParam.setCcid(deviceConnectionMsg.getImei());
                    JSONObject object1 = new JSONObject();
                    dataParam.setData(object1);
                    dataParam.setType(OperEnum.PortDetail.getType());
                    msgService.sendMsg(dataParam);
                    temp = false;
                    continue;
                }
                byte[] response = new byte[length];
                //将接收到的消息类型拿到进行判断
                System.arraycopy(receiveData, 0, response, 0, response.length);
                String s = Integer.toHexString(response[5] & 0xFF);
                int framType = response[5] & 0xFF;//Integer.parseInt(s);
                int encry = response[4] & 0xFF;

                //消息体
                byte[] respone_msg = Arrays.copyOfRange(response, 6, response.length - 2);
                if (encry == 0) {
                    logger.info("{},未加密消息,frame:{},data:{}",deviceConnectionMsg.getDeviceId(),framType, DataConversion.bytesToHexString(respone_msg));
                } else {
                    try {
                        String key = redisCache.getCacheMapValue(RedisConstant.YKC_KEY_MAP,deviceConnectionMsg.getDeviceId());
//                        String key = redisCache.getCacheObject(RedisConstant.KEYS + deviceConnectionMsg.getDeviceId());
                        respone_msg = Encrytion.decrypt(respone_msg, key.getBytes());

                        logger.info("{},加密消息,frame:{},data:{}",deviceConnectionMsg.getDeviceId(),framType, DataConversion.bytesToHexString(respone_msg));
                    } catch (Exception e) {
                        logger.info("{},ykc->msg decrypt Exception",deviceConnectionMsg.getDeviceId());
                        e.printStackTrace();
                    }
                }
                if (framType == YkcSendDevice.LOGIN_RESPONSE.getFrameType()) {
                    logger.info("↓↓↓↓↓"+deviceConnectionMsg.getDeviceId()+"登录认证应答"+framType);
                    //处理登录成功与否
                    boolean res = loginResponse(deviceConnectionMsg, respone_msg);
                    //计费模型请求
                    if(res){
                        logger.info("↓↓↓↓↓"+deviceConnectionMsg.getDeviceId()+"请求计费模型");
                        billingModelFrame.checkBillingModel(deviceConnectionMsg);
                    }

                } else if (framType == YkcSendDevice.HEART_RESPONSE.getFrameType()) {
                    //TODO:个人理解,枪不管故障还是正常都会有心跳,心跳应答正常说明设备是正常的状态,所以这里不管是同一设备的几号枪心跳都缓存下来心跳应答时间
                    //  logger.info("ykc->dev"+deviceConnectionMsg.getDeviceId()+"↓↓↓↓↓↓↓↓↓↓↓↓↓心跳包应答消息↓↓↓↓↓↓↓↓↓↓↓↓↓"+framType);
                    deviceConnectionMsg.setHeartTime(System.currentTimeMillis());
//                    logger.info("===========心跳包应答============over");

                } else if (framType == YkcSendDevice.BILLING_MODEL_VALIDATE_RESPONSE.getFrameType()) {
                    billingModelHandle(deviceConnectionMsg, respone_msg);

                } else if (framType == YkcSendDevice.BILLING_MODEL_RESPONSE.getFrameType()) {
                    logger.info("↓↓↓↓↓" + deviceConnectionMsg.getDeviceId() + "计费模型请求应答" + framType);
                    try {
                        billingModelFrame.setBillingModel(deviceConnectionMsg, respone_msg);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                } else if (framType == YkcSendDevice.BILLING_MODEL_VALIDATE_RESPONSE_SG.getFrameType()) {
                    logger.info("↓↓↓↓↓" + deviceConnectionMsg.getDeviceId() + "深谷计费模型请求应答" + framType);
                    try {
                        billingModelFrame.setSgBillingModel(deviceConnectionMsg, respone_msg);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } else if (framType == YkcSendDevice.TRANSACTION_RECORDS_RESPONSE.getFrameType()) {
                    logger.info("↓↓↓↓↓" + deviceConnectionMsg.getDeviceId() + "交易记录确认");
                    byte[] trans = Arrays.copyOfRange(respone_msg, 0, 16);
                    byte[] reason = Arrays.copyOfRange(respone_msg, 16, 17);
                    QueryWrapper<OrderStatus> orderStatusQueryWrapper = new QueryWrapper<>();
                    orderStatusQueryWrapper.eq("trans_order", trans);
                    OrderStatus one = orderStatusService.getOne(orderStatusQueryWrapper);

                    QueryWrapper<TransOrder> transOrderQueryWrapper = new QueryWrapper<>();
                    transOrderQueryWrapper.eq("trans_order", trans);
                    TransOrder transOrderServiceOne = transOrderService.getOne(transOrderQueryWrapper);

                    if (reason[0] == 0x00) {
                        one.setTransactionOrderReplyStatus(StatusConstant.TRANSACTION_ORDER_REPLY_STATUS_SUCC);

                        transOrderServiceOne.setFlage(StatusConstant.TRANSACTION_ORDER_REPLY_STATUS_SUCC);
                    } else if (reason[0] == 0x01) {
                        one.setTransactionOrderReplyStatus(StatusConstant.TRANSACTION_ORDER_REPLY_STATUS_FAIL);
                    } else if (reason[0] == 0x02) {
                        one.setTransactionOrderReplyStatus(StatusConstant.TRANSACTION_ORDER_REPLY_STATUS_ILLEGAL);
                    }
                    //接收到后将订单校验从redis剔除
                    orderStatusService.updateById(one);
                    transOrderService.updateById(transOrderServiceOne);
                } else if (framType == YkcSendDevice.DEVICE_STATUS_REQUEST.getFrameType()) {
                    logger.info("↓↓↓↓↓{}读取实时监测数据",deviceConnectionMsg.getDeviceId());

                } else if (framType == YkcSendDevice.START_CHARNGING_REQUEST.getFrameType() || framType == YkcSendDevice.START_CHARNGING_REQUEST_16.getFrameType()) {
                    logger.info("↓↓↓↓↓{}运营平台远程控制启机" + framType,deviceConnectionMsg.getDeviceId());
                    startChargingRequest(deviceConnectionMsg, respone_msg);

                } else if (framType == YkcSendDevice.STOP_CHARNGING_REQUEST.getFrameType()) {
                    logger.info("↓↓↓↓↓{}运营平台远程停机",deviceConnectionMsg.getDeviceId());
                    stopChargingRequest(deviceConnectionMsg, respone_msg);

                } else if (framType == YkcSendDevice.UPDATE_BALANCE.getFrameType()) {
                    logger.info("↓↓↓↓↓{}远程更新余额",deviceConnectionMsg.getDeviceId());
                    try {
                        remoteBalanceUpdate(deviceConnectionMsg, respone_msg);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                } else if (framType == YkcSendDevice.CHECKTIME.getFrameType()) {
                    logger.info("↓↓↓↓↓{}对时设置" + framType,deviceConnectionMsg.getDeviceId());
                    checkTime.checkTimeSend(deviceConnectionMsg);

                } else if (framType == YkcSendDevice.BILLING_MODEL_SETTING_SG.getFrameType()) {
                    logger.info("↓↓↓↓↓{}深谷计费模型设置",deviceConnectionMsg.getDeviceId());
                    try {
                        //有异常就是失败
                        billingModelFrame.setSgBillingModel(deviceConnectionMsg, respone_msg);
                        billingModelFrame.resp(deviceConnectionMsg, (byte) 1);
                    } catch (Exception e) {
                        billingModelFrame.resp(deviceConnectionMsg, (byte) 0);
                        e.printStackTrace();
                    }

                } else if (framType == YkcSendDevice.BILLING_MODEL_SETTING.getFrameType()) {
                    logger.info("↓↓↓↓↓{}计费模型设置",deviceConnectionMsg.getDeviceId());
                    try {
                        //有异常就是失败
                        billingModelFrame.setBillingModel(deviceConnectionMsg, respone_msg);
                        billingModelFrame.resp(deviceConnectionMsg, (byte) 1);
                    } catch (Exception e) {
                        billingModelFrame.resp(deviceConnectionMsg, (byte) 0);
                        e.printStackTrace();
                    }

                } else if (framType == YkcSendDevice.REMOTE_REBOOT.getFrameType()) {
                    logger.info("↓↓↓↓↓{}远程重启",deviceConnectionMsg.getDeviceId());

                } else if (framType == YkcSendDevice.UPLOAD_FILE_UPDATE.getFrameType()) {
                    logger.info("↓↓↓↓↓{}远程更新",deviceConnectionMsg.getDeviceId());

                }
            }
        };
        Thread thread = new Thread(listener);
        thread.start();
    }

    /**
     * 登录回复消息处理
     *
     * @param deviceConnectionMsg
     * @param respone_msg
     */
    private boolean loginResponse(DeviceConnectionMsg deviceConnectionMsg, byte[] respone_msg) {
        int login_result = respone_msg[7] & 0xFF;
        if (ResultUtil.isSuccess(login_result)) {
            //登录成功,相当于初始化心跳包接收时间更新,初始化心跳包时间相当于登录成功,心跳包能正常上传
            logger.info("{}login successfully", deviceConnectionMsg.getDeviceId());
            deviceConnectionMsg.setHeartTime(System.currentTimeMillis());
            deviceConnectionMsg.setLoginStatus(Constant.DEVICE_LOGIN_STATUS);
            return true;
        } else {
            logger.info("{}login failed ,waitting for retry", deviceConnectionMsg.getDeviceId());
            //登录失败等心跳包10秒后进行重试
            return false;
        }
    }

    /**
     * 接收到云快充启机指令的处理
     *
     * @param deviceConnectionMsg
     * @param respone_msg
     */
    private void startChargingRequest(DeviceConnectionMsg deviceConnectionMsg, byte[] respone_msg) {

        try {
            //1.解析出启动充电流水号
            //查询设备sn和imie

            QueryWrapper<DeviceStatus> deviceStatusQueryWrapper = new QueryWrapper<>();
            deviceStatusQueryWrapper.eq("pile_code", deviceConnectionMsg.getDeviceId());
            List<DeviceStatus> list = deviceStatusService.list(deviceStatusQueryWrapper);
            //可能双枪
            DeviceStatus deviceStatus = list.get(0);
            //切出订单号,保存在连接的该设备中
            byte[] transOrder = Arrays.copyOfRange(respone_msg, 0, 16);
            //测试
            t = transOrder;
            byte[] guns = Arrays.copyOfRange(respone_msg, 23, 24);
            byte[] card = Arrays.copyOfRange(respone_msg, 32, 40);
            byte[] logCard = Arrays.copyOfRange(respone_msg, 24, 32);
            byte[] startMoney = Arrays.copyOfRange(respone_msg, respone_msg.length - 6, respone_msg.length - 2);
            boolean temp = false;
            int result = 0x00;    //失败
            int reason = 0x00;   //无
            if (guns[0] == 1) {
                DeviceStatus oneDeviceStatus = redisCache.getCacheMapValue(RedisConstant.ONLINE_DEVICE_ONE, deviceConnectionMsg.getDeviceId());
                logger.info(oneDeviceStatus.toString());
                if (oneDeviceStatus.getOnlineStatus() == StatusConstant.OFFLINE || StatusConstant.OFFLINE == oneDeviceStatus.getGunStatus()) {
                    //离线上报
                    reason = 0x04;
                    temp = true;
                } else if (StatusConstant.CHARGING == oneDeviceStatus.getGunStatus()) {
                    //枪已在充电中
                    reason = 0x02;
                    temp = true;
                } else if (StatusConstant.FAULT == oneDeviceStatus.getGunStatus()) {
                    //枪故障
                    reason = 0x03;
                    temp = true;
                } else if (StatusConstant.INSERT_GUNS_NO == oneDeviceStatus.getInsertGunStatus()) {
                    //未插枪
                    reason = 0x05;
                    temp = false;
                } else if (PortStatusConstant.EMERGENCY_STOP == oneDeviceStatus.getGunStatus()) {
                    //急停没复位,也是启充失败
                    temp = true;
                }
            } else if (guns[0] == 2) {
                DeviceStatus twoDeviceStatus = redisCache.getCacheMapValue(RedisConstant.ONLINE_DEVICE_TWO, deviceConnectionMsg.getDeviceId());
                if (twoDeviceStatus.getOnlineStatus() == StatusConstant.OFFLINE || StatusConstant.OFFLINE == twoDeviceStatus.getGunStatus()) {
                    //离线上报
                    reason = 0x04;
                    temp = true;
                } else if (StatusConstant.CHARGING == twoDeviceStatus.getGunStatus()) {
                    //枪已在充电中
                    reason = 0x02;
                    temp = true;
                } else if (StatusConstant.FAULT == twoDeviceStatus.getGunStatus()) {
                    //枪故障
                    reason = 0x03;
                    temp = true;
                } else if (StatusConstant.INSERT_GUNS_NO == twoDeviceStatus.getInsertGunStatus()) {
                    //未插枪
                    reason = 0x05;
                    temp = true;
                } else if (PortStatusConstant.EMERGENCY_STOP == twoDeviceStatus.getGunStatus()) {
                    //急停没复位,也是启充失败
                    temp = true;
                }
            }
            if (temp) {
                logger.info("启动失败{}:reason:{}" ,deviceConnectionMsg.getDeviceId(), reason);
                charngingPushFrame.startStatus(deviceConnectionMsg, transOrder, guns[0], result, reason);
                Map<String, BigDecimal> compute = transMoney.getTransData();
                transactionFlowPushFrame.sendTrans(deviceConnectionMsg, transOrder, deviceStatus.getPileCode(), guns[0], System.currentTimeMillis(), System.currentTimeMillis(), new BillingModel(), card, compute, TransConstant.START_FAIL);
                return;
            }
            BigDecimal bigDecimalmoney = DataConversion.arrToBigDec(startMoney, 2, 2).setScale(2, BigDecimal.ROUND_UP);
            logger.info("{}开始充电,startMoney" + bigDecimalmoney + "sbyt+" + DataConversion.bytesToHexString(startMoney),deviceConnectionMsg.getDeviceId());
            OrderStatus orderStatus = new OrderStatus();
            orderStatus.setDeviceSn(deviceStatus.getDeviceSn());
            orderStatus.setDeviceImei(deviceConnectionMsg.getImei());
            orderStatus.setPileCode(deviceStatus.getPileCode());
            orderStatus.setGunsCode(guns[0]);
            orderStatus.setStartMoney(bigDecimalmoney);
            orderStatus.setCard(card);
            orderStatus.setTransOrder(transOrder);
            orderStatus.setCreateTime(System.currentTimeMillis());
            //2.保存交易流水号并记录本次交易流水状态
            orderStatusService.save(orderStatus);
            this.saveOrder(orderStatus);
            //setMoney(orderStatus);//让设备记余额不足情况,启充时要传启充金额money,传0就是启充默认值
            //3.向设备发送启机指令
            if (reason == 0x05) {
                //未插枪不启充设备,但是返回未插枪
                logger.info("{}未插枪等待充电订单:" + DataConversion.bytesToHexString(transOrder),deviceConnectionMsg.getDeviceId());
                charngingPushFrame.startStatus(deviceConnectionMsg, transOrder, guns[0], result, reason);
                redisCache.setCacheObject(RedisConstant.NO_INSERT_GUN_YKC + deviceStatus.getPileCode(), DataConversion.bytesToHexString(transOrder), 60 * 1000, TimeUnit.MILLISECONDS);
            } else {
                deviceControlerService.startCharge(deviceStatus.getDeviceImei(), deviceStatus.getDeviceImei(), (int) guns[0], 0);
            }

            String gunCode = String.valueOf(guns[0]);
            //标记最后订单时间 5分钟内不上报空闲状态 避免刚下单状态还没更新就被freeTask任务给顶掉了
            redisCache.setCacheMapValue(RedisConstant.PILE_GUN_PAY_TIME, orderStatus.getPileCode() + "_" + gunCode, System.currentTimeMillis());


            //TODO:在处理设备消息的地方需要处理设备启动充电是否成功
            //TODO:保存交易流水时保存一个交易订单

        } catch (Exception e) {
            logger.info("{}启动充电异常,{}",deviceConnectionMsg.getDeviceId(),e.getMessage());
            realTimeStatusPushFrame.deviceStatusPush(deviceConnectionMsg, t, deviceConnectionMsg.getDeviceId(), (byte) 1, (byte) 2, (byte) 1, 0, 0, zero, zero, 0);
            e.printStackTrace();
        }
    }

    private static byte[] t = new byte[16];

    /**
     * 计费模型校验应答处理
     *
     * @param deviceConnectionMsg
     * @param respone_msg
     */
    private void billingModelHandle(DeviceConnectionMsg deviceConnectionMsg, byte[] respone_msg) {
        byte[] modelNum = Arrays.copyOfRange(respone_msg, 7, 9);
        byte[] result = Arrays.copyOfRange(respone_msg, 9, 10);
        logger.info("计费模型验证应答" + deviceConnectionMsg.getDeviceId() + ">>modelNum:" + DataConversion.bytesToHexString(modelNum) + ";result:" + DataConversion.bytesToHexString(result));
        if (result[0] == BillingModelConst.DIFFERENT) {
            logger.info("获取计费模型{}", deviceConnectionMsg.getDeviceId());
            //不一致请求计费模型,再向平台请求计费模型0x09
            billingModelFrame.getBillingModel(deviceConnectionMsg);
        }
    }


    /**
     * 停机指令处理
     *
     * @param deviceConnectionMsg
     * @param respone_msg
     */
    private void stopChargingRequest(DeviceConnectionMsg deviceConnectionMsg, byte[] respone_msg) {
        byte[] guns = Arrays.copyOfRange(respone_msg, 7, 8);
        //查询设备sn和imie
        QueryWrapper<DeviceStatus> deviceStatusQueryWrapper = new QueryWrapper<>();
        deviceStatusQueryWrapper.eq("pile_code", deviceConnectionMsg.getDeviceId());
        List<DeviceStatus> list = deviceStatusService.list(deviceStatusQueryWrapper);
        DeviceStatus deviceStatus = list.get(0);

        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        RpcResult rpcResult = deviceControlerService.stopCharge(deviceStatus.getDeviceImei(), deviceStatus.getDeviceImei(), (int) guns[0]);

        if (rpcResult.isOk()) {
            //发送停充成功,一般没有指令发送成功设备不执行
         /*   //deviceStatus.setGunStatus((byte) PortStatusConstant.INSERT_GUN);
            deviceStatus.setOnlineStatus(DeviceOnlineStatus.ONLINE);
            deviceStatus.setUpdateTime(System.currentTimeMillis());
            deviceStatusService.updateById(deviceStatus);*/
            QueryWrapper<OrderStatus> orderStatusQueryWrapper = new QueryWrapper<>();
            orderStatusQueryWrapper.eq("device_imei", deviceStatus.getDeviceImei()).eq("guns_code", guns[0]).orderByDesc("create_time").last("limit 1");
            OrderStatus statusServiceOne = orderStatusService.getOne(orderStatusQueryWrapper);
            statusServiceOne.setEndTime(System.currentTimeMillis());
            statusServiceOne.setReasonStopCharging(TransConstant.APP_REMOTE_STOP);
            orderStatusService.updateById(statusServiceOne);

            redisCache.setCacheMapValue(guns[0] == 1 ? RedisConstant.ONLINE_DEVICE_ONE : RedisConstant.ONLINE_DEVICE_TWO, deviceStatus.getPileCode(), deviceStatus);
        } else {
            logger.info("stop charging  device:" + deviceStatus.getDeviceSn() + ";port:" + guns[0] + "stop charnging fail");
        }
        //获取端口状态
        DeviceParam deviceParam = new DeviceParam();
        deviceParam.setDeviceId(deviceStatus.getDeviceImei());
        deviceParam.setCcid(deviceStatus.getDeviceImei());
        deviceControlerService.sendPortDetailCmd(deviceParam);
    }

    /***
     * 远程余额更新
     * @param deviceConnectionMsg
     * @param respone_msg
     */
    private void remoteBalanceUpdate(DeviceConnectionMsg deviceConnectionMsg, byte[] respone_msg) throws Exception {
        byte[] pileCode = Arrays.copyOfRange(respone_msg, 0, 7);
        byte[] guns = Arrays.copyOfRange(respone_msg, 7, 8);
        byte[] card = Arrays.copyOfRange(respone_msg, 8, 16);
        byte[] balance = Arrays.copyOfRange(respone_msg, 16, 20);
        BigDecimal bigDecimal = DataConversion.arrToBigDec(balance, 2, 2);

        String pile = DataConversion.bytesToHexString(pileCode);

        logger.info("更新余额>>" + bigDecimal + ";pileCode:" + pile);
        //TODO:1.这里更新的余额需要针对充电桩使用的人员进行修改;(考虑后台计费);2.更新操作完成时候响应云快充更新结果
        //拿当前的订单去更新余额
        QueryWrapper<OrderStatus> orderStatusQueryWrapper = new QueryWrapper<>();
        orderStatusQueryWrapper.eq("pile_code", pile).eq("guns_code", guns[0]).eq("card", card).orderByDesc("create_time").last("limit 1");
        OrderStatus statusServiceOne = orderStatusService.getOne(orderStatusQueryWrapper);

        QueryWrapper<BillingModel> billingModelQueryWrapper = new QueryWrapper<>();
        billingModelQueryWrapper.eq("pile_code", pile);
        BillingModel model = billingModelService.getOne(billingModelQueryWrapper);

        //后台计费
        Map<String, BigDecimal> map = transMoney.compute(1, model, statusServiceOne.getCreateTime(), System.currentTimeMillis());
        BigDecimal money = statusServiceOne.getStartMoney().subtract(map.get("money")).setScale(4, BigDecimal.ROUND_DOWN);
        BigDecimal add = money.add(bigDecimal);
        statusServiceOne.setStartMoney(add);
        orderStatusService.updateById(statusServiceOne);
        //这里测试默认更新成功
        remoteBalanceUpdatePushFrame.updateBalance(deviceConnectionMsg, card, (byte) 0x00);

    }

    //保存订单开始状态,记录充电的交易流水
    private void saveOrder(OrderStatus orderStatus) {
        TransOrder transOrder = transMapping.orderStatusToTransOrder(orderStatus);
        byte[] transOrders = new byte[8];
        System.arraycopy(orderStatus.getTransOrder(), 8, transOrders, 0, transOrders.length);
        //为了云快充app显示的订单号一致,将订单号格式转化一下
        transOrder.setTrans(DataConversion.bytesToHexString(transOrders));
        boolean b = transOrderService.saveOrUpdate(transOrder);
        logger.info("保存订单>>>>>" + DataConversion.bytesToHexString(orderStatus.getTransOrder()) + "结果:" + b);
    }

    //余额不足解决办法,将下发的余额和尖峰平谷中最贵的价格发送到主板参数中,配合主板参数进行余额不足判定
    private void setMoney(OrderStatus orderStatus) {

        QueryWrapper<BillingModel> orderStatusQueryWrapper = new QueryWrapper<>();
        orderStatusQueryWrapper.eq("pile_code", orderStatus.getPileCode());
        BillingModel billingModel = billingModelService.getOne(orderStatusQueryWrapper);
        MainBoard mainBoard = new MainBoard();
        mainBoard.setBottomPrice(billingModel.getSharpPrice().add(billingModel.getSharpServiceFee()).intValue());
        mainBoard.setBottomServicePrice(0);
        mainBoard.setPeakPrice(billingModel.getSharpPrice().add(billingModel.getSharpServiceFee()).intValue());
        mainBoard.setPeakServicePrice(0);
        mainBoard.setBottomStart(0);
        mainBoard.setBottomEnd(24);
        mainBoard.setFeeType(0x00);
        //设置主板参数
        deviceControlerService.setMainBoard(orderStatus.getDeviceImei(), orderStatus.getDeviceImei(), mainBoard);

    }

}