manyi/apps/web/core/adapter/bolai_gateway.py

# -*- coding: utf-8 -*-
# !/usr/bin/env python

import logging
import random

from typing import TYPE_CHECKING

from apps.web.core.adapter.base import SmartBox, start_error_timer
from apps.web.core.device_define.baolai import send_request
from apps.web.core.exceptions import ServiceException
from apps.web.device.models import Device

if TYPE_CHECKING:
    pass

logger = logging.getLogger(__name__)


class ChargingGatewayBox(SmartBox):
    """
    """

    def __init__(self, device):
        super(ChargingGatewayBox, self).__init__(device)
        devObj = self.device.my_obj
        self.nodeDict = devObj.nodeDict

    @property
    def isHaveStopEvent(self):
        return True

    def translate_funcode(self, funCode):
        funCodeDict = {
        }
        return funCodeDict.get(funCode, '')

    def translate_event_cmdcode(self, cmdCode):
        cmdDict = {}
        return cmdDict.get(cmdCode, '')

    def send_request(self, cmdPath, jsonPara):
        return send_request(self.device.devNo, self.device.devNo, cmdPath, jsonPara)

    def test(self, coins, port = 1):
        return self.send_request('device/plug/list', {})

    @start_error_timer(missMessages = [u"请您选择合适的充电线路、电池类型信息", u"请您选择合适的充电线路", u"该端口正在使用中"])
    def start_device(self, package, openId, attachParas):
        pass

    def analyze_event_data(self, data):
        return None
    
    # 此接口 柏来已经不维护，去掉
#     def get_node_list_from_dev(self):
#         devInfo = self.send_request('device/plug/list', {})
#         return devInfo['data']['data']['plug_list']

    def get_node(self, node):
        nodeInfo = {
                    'signal':node.get('signal',0),
                    'rssi':node.get('rssi',39),
                    'online':node.get('online',False),
                    }
        if 'suid' in node:
            nodeInfo.update({
                             'devNo':node['suid'],
                             'suid':node['suid'],
                             })
        if 'devNo' in node:
            nodeInfo.update({
                             'devNo':node['devNo'],
                             'suid':node['devNo'],
                             })
#         cmdPath = 'cmd/get-status'
#         jsonPara = {
#             'node_index': node['node_index']
#         }
# 
#         devInfo = self.send_request(cmdPath, jsonPara)
# 
#         nodeInfo = {'signal': calc_signal_from_rssi(devInfo['data']['data']['rssi']),
#                     'temp': devInfo['data']['data']['temperature'],
#                     'rssi': devInfo['data']['data']['rssi'],
#                     'devNo': node['suid'],
#                     'volt': max(devInfo['data']['data']['port_list'][0]['voltage'],
#                                 devInfo['data']['data']['port_list'][1]['voltage'])}
# 
#         # 这里插座离线后，rssi不准确，以插口状态为准
#         if devInfo['data']['data']['port_list'][0]['online'] and devInfo['data']['data']['port_list'][1]['online']:
#             nodeInfo.update({'online': True})
#         else:
#             nodeInfo.update({'online': False})
#             nodeInfo.update({'signal': 0})

        return nodeInfo

    # 获取设备配置参数
    def get_dev_setting(self):
        devInfo = self.send_request('cmd/get-gateway-config', {})
        if devInfo['data']['code'] != 0:
            raise ServiceException({'result': 2, 'description': u'设备服务器返回错误，建议您重试，或者联系客服'})
        return devInfo['data']

    # 设置设备配置参数
    def set_dev_setting(self, setConf):
        setConf.update({})
        devInfo = self.send_request('cmd/set-gateway-config', setConf)
        if devInfo['data']['code'] != 0:
            raise ServiceException({'result': 2, 'description': u'设备服务器返回错误，建议您重试，或者联系客服'})
        return devInfo

    def set_device_function_param(self, request, lastSetConf):
        pass

    def get_dev_online_status(self):
        devInfo = self.send_request('device/gateway/detail', {})
        return devInfo['data']['plug_gateway']['is_online']

    def update_dev_info(self):
        devInfo = self.send_request('device/gateway/update',
                                    {'province': '', 'city': '', 'county': '',
                                     'address': '', 'longitude': 0.0, 'latitude': 0.0})
        if devInfo['data']['code'] != 0:
            raise ServiceException({'result': 2, 'description': u'设备服务器返回错误，建议您重试，或者联系客服'})

    def add_node(self, nodeDevNo):
        # 首先检查子节点是否已经注册了
        devObj = Device.objects.filter(devNo = nodeDevNo).first()
        if devObj is None:
            raise ServiceException({'result': 2, 'description': u'请先扫码注册子设备插座，然后再加入网关'})
        # 检查是否绑定在其他主节点，如果绑定了其他主节点，必须提示
        if devObj.gatewayNode and devObj.gatewayNode != self._device['devNo']:
            raise ServiceException({'result': 2, 'description': u'该子节点已经绑定在其他主节点下，请先解绑后，再重新添加'})
        
        nodeList = self.get_node_list()
        # 首先检查是否已经添加进来了
        exist = devObj.gatewayNode == self._device['devNo']
        sendList = [{'node_index': node['node_index'], 'plug_id': node['suid']} for node in nodeList]
        
        if exist: # 如果已经存在了，直接下发就Ok
            pass
        else:
            nodeIndexList = [node['node_index'] for node in nodeList]
            ii = 1
            for ii in range(1, 50):
                if ii not in nodeIndexList:
                    break
                else:
                    continue
            sendList.append({'node_index': ii, 'plug_id': nodeDevNo})
            
        devInfo = self.send_request('cmd/build-network',
                                    {'channel': random.randint(1, 8),
                                     'plug_list': sendList, 'timeout': 15})
        if devInfo['data']['code'] != 0:
            raise ServiceException({'result': 2, 'description': u'设备服务器返回错误，建议您重试，或者联系客服'})

        # 主节点内容更新
        devObj = Device.objects.get(devNo = self._device['devNo'])
        devObj.nodeDict.update({str(ii):nodeDevNo})
        devObj.save()

        # 子节点的也要更新
        devObj = Device.objects.get(devNo = nodeDevNo)
        devObj.gatewayNode = self._device['devNo']
        devObj.save()

    def remove_node(self, nodeDevNo):
        nodeList = self.get_node_list()
        sendList = []
        index = -1
        nodeDict = {}
        for node in nodeList:
            if node['suid'] != nodeDevNo:
                sendList.append({'node_index': node['node_index'], 'plug_id': node['suid']})
                nodeDict[node['node_index']] = node['suid']
            else:
                index = node['node_index']

        if index == -1:
            return

        devInfo = self.send_request('cmd/build-network',
                                    {'channel': random.randint(1, 8),
                                     'plug_list': sendList, 'timeout': 5})

        if devInfo['data']['code'] != 0:
            raise ServiceException({'result': 2, 'description': u'设备服务器返回错误，建议您重试，或者联系客服'})

        # 主节点更新
        try:
            devObj = Device.objects.get(devNo = self._device['devNo'])
            devObj.nodeDict = nodeDict
            devObj.save()
        except Exception, e:
            pass

        # 子节点更新
        try:
            devObj = Device.objects.get(devNo = nodeDevNo)
            devObj.gatewayNode = ''
            devObj.save()
        except Exception, e:
            return

    def set_batch_ports_config(self, maxCurrent, maxPower):
        if maxCurrent <= 0 or maxCurrent >= 20:
            raise ServiceException({'result': 2, 'description': u'电流允许的范围是0-20安'})
        if maxPower <= 0 or maxPower >= 2500:
            raise ServiceException({'result': 2, 'description': u'功率允许的范围是0-2500瓦'})

        devInfo = self.send_request('cmd/set-node-config/batch',
                                    {'max_current': maxCurrent,
                                     'max_power': maxCurrent})

        if devInfo['data']['code'] != 0:
            raise ServiceException({'result': 2, 'description': u'设备服务器返回错误，建议您重试，或者联系客服'})

        return devInfo

    def get_node_config(self, nodeIndex):
        devInfo = self.send_request('cmd/get-node-system-config',
                                    {'node_index': nodeIndex})
        return devInfo['data']

    def set_node_config(self, nodeIndex, config):
        config.update({'node_index': nodeIndex, 'timeout': 10})
        devInfo = self.send_request('cmd/set-node-config', config)
        if devInfo['data']['code'] != 0:
            raise ServiceException({'result': 2, 'description': u'设备服务器返回错误，建议您重试，或者联系客服'})
        return devInfo

    def get_signal(self):
        devInfo = self.send_request('device/gateway/detail', {})
        devInfo.update({'signal': devInfo['data']['data']['gateway']['rssi']})
        if devInfo['signal'] > 5:
            Device.update_online_cache(self._device['devNo'], True, devInfo['signal'])
        return devInfo

    def get_node_list(self):
        result = []
        for index,nodeDevNo in self.nodeDict.items():
            nodeDevInfo = Device.get_dev(nodeDevNo)
            nodeInfo = self.get_node(nodeDevInfo)
            nodeInfo.update({'node_index':int(index)})
            result.append(nodeInfo)
        return result
    
#         nodeList = self.get_node_list_from_dev()
#         result = []
#         for node in nodeList:
#             nodeInfo = self.get_node(node)
#             result.append(nodeInfo)
#         return result

    def get_node_devNo(self, nodeIndex):
        return self.nodeDict.get(str(nodeIndex))