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

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

import copy
import datetime
import logging
import time

from typing import TYPE_CHECKING

from apps.web.constant import Const
from apps.web.core.adapter.base import SmartBox, start_error_timer, calc_signal_from_rssi
from apps.web.core.device_define.baolai import send_request
from apps.web.core.exceptions import ServiceException
from apps.web.device.models import Device
from apps.web.user.models import MyUser, ConsumeRecord

if TYPE_CHECKING:
    from apps.web.device.models import DeviceDict
    from apps.web.core.adapter.bolai_gateway import ChargingGatewayBox

logger = logging.getLogger(__name__)


class ChargingBox(SmartBox):
    """
    """

    def __init__(self, device):
        super(ChargingBox, self).__init__(device)

        devObj = self.device.my_obj
        if not devObj.gatewayNode:
            raise ServiceException({'result': 2, 'description': u'无法找到网关设备，请绑定网关'})

        gatewayObj = Device.objects.get(devNo=devObj.gatewayNode)
        # 网关可能是单独的网关，也可能是带插座的一体化设备
        if gatewayObj.devType['code'] == Const.DEVICE_TYPE_CODE_CHARGING_BL_GATEWAY:
            self.gateway_id = gatewayObj.devNo
        elif gatewayObj.devType['code'] == Const.DEVICE_TYPE_CODE_CHARGING_BL_GATEWAYPLUG:
            tempObj = Device.get_collection().find({'devNo':gatewayObj.devNo})[0]
            if 'gateImei' not in tempObj or not tempObj['gateImei']:
                raise ServiceException({'result': 2, 'description': u'网关插座一体化的设备需要先绑定一体化网关，您可以在网关插座配置中扫码绑定'})
            self.gateway_id = tempObj['gateImei']
            
        if not gatewayObj.ownerId or not gatewayObj.groupId:
            raise ServiceException({'result': 2, 'description': u'无法找到网关设备，请检查设备是否解绑'})
        
        if gatewayObj.is_expire:
            raise ServiceException({'result': 2, 'description': u'网关设备已经过期，请设备运营商及时充值'})

        for nodeIndex, nodeDevNo in gatewayObj.nodeDict.items():
            if nodeDevNo == device['devNo']:
                self.node_index = int(nodeIndex)
                break
            else:
                continue

        self.billingType = devObj.otherConf.get('billingType', 1)  # 0 :电量 1：时间  2：功率
        self.config_list = devObj.otherConf.get('config_list', [])
        self.onceCard = devObj.otherConf.get('onceCard', 100)
        self.cardTime = devObj.otherConf.get('cardTime', 180)
        self.cardElec = devObj.otherConf.get('cardElec', 1)

    @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 get_port_from_ab(self, portAB):
        portConf = {'A': 0, 'B': 1, 'C': 2}
        if portAB in portConf:
            return portConf[portAB]
        return portAB

    def get_abport_from_index(self, port):
        portConf = {'0': 'A', '1': 'B', '2': 'C'}
        return portConf.get(port)

    def send_request(self, cmdPath, jsonPara,cmdKind=2):
        return send_request(self.device.devNo, self.gateway_id, cmdPath, jsonPara,cmdKind)

    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):
        if attachParas is None:
            raise ServiceException({'result': 2, 'description': u'请您选择合适的充电线路、电池类型信息'})
        if not attachParas.has_key('chargeIndex'):
            raise ServiceException({'result': 2, 'description': u'请您选择合适的充电线路'})

        port = int(self.get_port_from_ab(attachParas['chargeIndex']))
        attachParas['chargeIndex'] = port
        unit = package.get('unit', u'分钟')
        needTime, needElec = None, None

        jsonPara = {'node_index': self.node_index, 'port_index': port, 'switch_state': 1}
        cmdPath = 'cmd/write-node'
        if self.billingType == 1:
            if unit == u'秒':
                if int(package['time']) < 60:
                    raise ServiceException({'result': 2, 'description': u'套餐的最小时间不能小于60秒'})
                needTime = int(float(package['time']) / 60.0)
                jsonPara.update({'charge_time': needTime, 'charge_mode': 1, 'charge_energy': 0})
            elif unit == u'分钟':
                needTime = int(float(package['time']))
                jsonPara.update({'charge_time': needTime, 'charge_mode': 1, 'charge_energy': 0})
            elif unit == u'小时':
                needTime = int(float(package['time']) * 60)
                jsonPara.update({'charge_time': needTime, 'charge_mode': 1, 'charge_energy': 0})
            elif unit == u'天':
                needTime = int(float(package['time']) * 60 * 24)
                jsonPara.update({'charge_time': needTime, 'charge_mode': 1, 'charge_energy': 0})
            else:
                raise ServiceException({'result': 2, 'description': u'运营商没有配置正确的套餐，请运营商配置正确的套餐'})
        elif self.billingType == 0:
            if unit == u'度':
                needElec = int(float(package['time']) * 1000)  # 微度
                jsonPara.update({'charge_energy': needElec, 'charge_mode': 0, 'charge_time': 0})
            else:
                raise ServiceException({'result': 2, 'description': u'运营商没有配置正确的套餐，请运营商配置正确的套餐'})
        else:
            if not self.config_list:
                raise ServiceException({'result': 2, 'description': u'运营商没有配置正确的分档功率，请运营商配置正确的分档功率'})
            cmdPath = 'cmd/write-node-with-power'
            coins = int(float(package['coins']) * 100)  # 单位为分
            jsonPara.update({'power': {'money': coins, 'config_list': self.config_list}})

        devInfo = self.send_request(cmdPath, jsonPara)

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

        if devInfo['rst'] == 0:  # 成功
            newValue = {
                str(port): {
                    'status': Const.DEV_WORK_STATUS_WORKING,
                    'startTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                }
            }
        else:  # TODO result的枚举列出原因
            raise ServiceException({'result': 2, 'description': u'充电插座响应异常，请您稍后再试哦'})

        servicedInfo = {}
        if self.billingType == 1:
            finishedTime = int(time.time()) + needTime * 60
            devInfo['needTime'] = needTime
            servicedInfo = {'needTime': needTime, 'billingType': 'time'}
        elif self.billingType == 0:
            finishedTime = int(time.time()) + 60 * 60 * 10  # 设定10个小时，确实很难知道可以用多久结束
            devInfo['needElec'] = float(package['time'])
            servicedInfo = {'needElec': float(package['time']), 'billingType': 'elec'}
        else:
            finishedTime = int(time.time()) + 60 * 60 * 10  # 设定10个小时，确实很难知道可以用多久结束
            servicedInfo = {'billingType': 'power'}
            newValue[str(port)].update({'power':10}) # 端口下的数据依赖心跳上报，但是心跳有时间间隔，这样查看服务的时候，因为功率是0，会认为已经结束，这里给一个初始值
        newValue.update({'finishedTime': finishedTime})
        
        Device.clear_port_control_cache(self._device['devNo'], port)
        Device.update_dev_control_cache(self._device['devNo'], newValue)

        devInfo['finished_time'] = finishedTime
        devInfo['sequanceNo'] = devInfo['data']['data']['transaction_id']
        devInfo['servicedInfo'] = servicedInfo
        
        return devInfo

    # 获取设备配置参数
    def get_dev_setting(self):
        devInfo = self.send_request('cmd/get-node-config', {'node_index': self.node_index},3)
        if devInfo['data']['code'] != 0:
            raise ServiceException({'result': 2, 'description': u'设备服务器返回错误，建议您重试，或者联系客服'})
        config = devInfo['data']['data']
        billDict = {'0': 'elec', '1': 'time', '2': 'power'}
        config.update({
            'chargeType': billDict.get(str(self.billingType)),
            'once_card': self.onceCard*0.01,
            'time': self.cardTime,
            'elec': self.cardElec,
            'config_list': self.config_list,
            'charge_full_timeout':config['charge_full_time_threshold'],
            'no_load_timeout':config['no_load_time_threshold'],
        })
        return config

    # 设置设备配置参数
    def set_dev_setting(self, setConf):
        setConf.update({'node_index': self.node_index})
        devObj = Device.objects.get(devNo=self._device['devNo'])
        billDict = {'elec': 0, 'time': 1, 'power': 2}
        devObj.otherConf.update({
            'billingType': billDict.get(setConf['chargeType']),
            'onceCard': int(float(setConf['once_card'])*100),
            'cardTime': int(setConf['time']),
            'cardElec': int(setConf['elec']),
            'config_list': setConf['config_list'],
        })
        devObj.save()

        setConf.pop('chargeType')
        setConf.pop('once_card')
        setConf.pop('time')
        setConf.pop('elec')
        setConf.pop('config_list')
        
        setConf.update({            
                        'charge_full_time_threshold':int(setConf['charge_full_timeout']),
                        'no_load_time_threshold':int(setConf['no_load_timeout'])
                        })
        setConf.pop('charge_full_timeout')
        setConf.pop('no_load_timeout')
        
        devInfo = self.send_request('cmd/set-node-config', setConf,3)
        if devInfo['data']['code'] != 0:
            raise ServiceException({'result': 2, 'description': u'设备服务器返回错误，建议您重试，或者联系客服'})

        return devInfo

    def get_port_config(self, portIndex):
        port = self.get_port_from_ab(portIndex)
        devInfo = self.send_request('cmd/get-node-config', {'node_index': self.node_index, 'port_index': port})

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

        return devInfo['data']['data']

    def set_port_config(self, portIndex, setConf):
        port = self.get_port_from_ab(portIndex)
        setConf.update({'node_index': self.node_index, 'port_index': port})
        devInfo = self.send_request('cmd/set-node-config', setConf)

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

        return devInfo

    def send_signal(self):
        devInfo = self.send_request('cmd/get-status', {'node_index': self.node_index})
        devInfo.update({
            'signal': calc_signal_from_rssi(devInfo['data']['data']['rssi']),
            'temp': devInfo['data']['data']['temperature'],
            'rssi': devInfo['data']['data']['rssi'],
            'devNo': self._device['devNo']
        })
        return devInfo

    def get_port_status_from_dev(self):
        # 先到设备上，把所有子节点的信息取出来，记录到主节点的缓存
        devInfo = self.send_request('cmd/get-status', {'node_index': self.node_index})

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

        allPorts, usedPorts = 0, 0
        result = {}
        for portInfo in devInfo['data']['data']['port_list']:
            portId = str(portInfo['index'])
            portDict = {
                'status': self.__translate_status_from_str(str(portInfo['charge_status'])),
                'watt': portInfo['power'],
                'ampr': portInfo['current'] * 0.001,
                'voltage': portInfo['voltage'],
                'elec': portInfo['energy_consumed'] * 0.001,
                'usedTime': portInfo['time_consumed'],
                'duration': portInfo['time_consumed']
            }

            sequanceNo = portInfo['transaction_id']
            if sequanceNo:
                try:
                    rcd = ConsumeRecord.objects.get(sequanceNo=sequanceNo)
                    portDict['openId'] = rcd['openId']
                    portDict['coins'] = float(str(rcd['coin']))  # 都用coins
                    portDict['money'] = float(str(rcd['money']))
                    portDict['sequanceNo'] = sequanceNo

                    if u'虚拟卡' in rcd.remarks:
                        portDict['consumeType'] = 'mobile_vcard'
                    elif u'刷卡' in rcd.remarks:
                        portDict['consumeType'] = 'card'
                        portDict['cardNo'] = rcd.servicedInfo.get('cardNo')
                    else:
                        portDict['consumeType'] = 'mobile'

                    portDict['billingType'] = 'power'
                    if rcd.servicedInfo['billingType'] == 'time':
                        portDict['billingType'] = 'time'
                        portDict['needTime'] = rcd.servicedInfo['needTime']
                        portDict['leftTime'] = rcd.servicedInfo['needTime'] - portInfo['time_consumed'] or 0

                    if rcd.servicedInfo['billingType'] == 'elec':
                        portDict['billingType'] = 'elec'
                        portDict['needElec'] = rcd.servicedInfo['needElec']

                    user = MyUser.objects(openId=portDict['openId']).first()
                    if user:
                        portDict['nickName'] = user.nickname

                except Exception, e:  # IC卡，如果没有绑定，不会有consumeRcd，应该直接从订单中拿数据
                    pass

            result[portId] = portDict

            if portInfo['charge_status'] == 1:
                usedPorts += 1

            allPorts += 1

        result.update({'usedPorts': usedPorts, 'allPorts': allPorts, 'usePorts': allPorts - usedPorts})
        Device.update_dev_control_cache(self._device['devNo'], result)

        return result

    def get_port_info(self, line):
        line = self.get_port_from_ab(line)

        portCache = Device.get_dev_control_cache(self.device.devNo)
        return portCache.get(str(line), {})

    def __translate_status_from_str(self, status):
        dictConf = {
            '0': Const.DEV_WORK_STATUS_IDLE,
            '1': Const.DEV_WORK_STATUS_WORKING,
            '2': Const.DEV_WORK_STATUS_IDLE,
            '3': Const.DEV_WORK_STATUS_IDLE,
        }
        return dictConf.get(status, Const.DEV_WORK_STATUS_FAULT)

    def get_port_status(self, force=False):
        if force:
            self.get_port_status_from_dev()

        portCache = Device.get_dev_control_cache(self._device['devNo'])
        result = {}
        for ii in range(5):
            if str(ii) in portCache:
                if ii == 0:
                    result['A'] = portCache[str(ii)]
                elif ii == 1:
                    result['B'] = portCache[str(ii)]
                elif ii == 2:
                    result['C'] = portCache[str(ii)]

        return result

    def lock_unlock_port(self, port, lock=True):
        port = self.get_port_from_ab(port)
        portInfo = self.get_port_info(port)
        if portInfo['status'] == Const.DEV_WORK_STATUS_WORKING:
            raise ServiceException({'result': 2, 'description': u'当前端口正在使用，请您先关闭掉后，再操作'})

        if lock:
            Device.update_dev_control_cache(self._device['devNo'],
                                            {str(port): {'status': Const.DEV_WORK_STATUS_FORBIDDEN}})
        else:
            Device.update_dev_control_cache(self._device['devNo'], {str(port): {'status': Const.DEV_WORK_STATUS_IDLE}})

    # 停止该端口下的所有任务
    def stop_charging_port(self, port):
        port = self.get_port_from_ab(port)
        portInfo = self.get_port_info(port)
        if portInfo.get('billingType', None) == 'power':
            devInfo = self.send_request('cmd/write-node-with-power',
                                        {'node_index': self.node_index, 'port_index': port, 'switch_state': 0,
                                         'power': {'money': 0,
                                                   'config_list': [{'power': 200, 'price': 100, 'time': 240}]}})
        else:
            devInfo = self.send_request('cmd/write-node',
                                        {'node_index': self.node_index, 'port_index': port, 'switch_state': 0,
                                         'charge_mode': 0, 'charge_time': 0, 'charge_energy': 0})

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

        if devInfo['rst'] == 0:
            Device.update_dev_control_cache(self._device['devNo'], {str(port): {'status': Const.DEV_WORK_STATUS_IDLE}})

        return True if devInfo['rst'] == 0 else False

    def add_to_gateway(self, gatewayDevNo):
        parentDev = Device.get_dev(gatewayDevNo)  # type: DeviceDict
        parentBox = parentDev.deviceAdapter  # type: ChargingGatewayBox
        parentBox.add_node(self._device['devNo'])

    def remove_from_gateway(self, gatewayDevNo):
        parentDev = Device.get_dev(gatewayDevNo)  # type: DeviceDict
        parentBox = parentDev.deviceAdapter  # type: ChargingGatewayBox
        parentBox.remove_node(self._device['devNo'])

    # 柏来有两条刷卡事件，一个是查询余额，对应的是余额播报回复；一个是开始充电事件，对应的是启动设备充电
    def response_card_start(self, portIndex, orderNo):
        jsonParas = {'node_index': self.node_index, 'port_index': portIndex, 'transaction_id': orderNo,
                     'switch_state': 1, 'charge_type': self.billingType}
        if self.billingType == 0:  # 按电量
            jsonParas.update({'charge_type': 2})
            jsonParas.update({'charge_energy': self.onceCard * 0.01 * self.cardElec * 1000})
        elif self.billingType == 1:  # 按时间
            jsonParas.update({'charge_type': 1})
            jsonParas.update({'charge_time': self.onceCard * 0.01 * self.cardTime})
        else:  # 按功率
            jsonParas.update(
                {'charge_type': 3, 'charge_power': {'money': self.onceCard, 'config_list': self.config_list}})

        devInfo = self.send_request('cmd/control-nfc-charge', jsonParas)

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

        return devInfo

    def active_deactive_port(self, port, active):
        port = self.get_port_from_ab(port)
        if active:
            raise ServiceException({'result': 2, 'description': u'该设备不支持直接打开端口'})
        return self.stop_charging_port(port)

    def set_device_function_param(self, request, lastSetConf):
        newConf = copy.deepcopy(request.POST)
        newConf.pop('logicalCode', None)
        self.set_dev_setting(newConf)

    def get_signal(self):  # 直接从缓冲中获取，如果没有的话，就是心跳没有上报上来
        result = {'rst':0}
        devInfo = Device.get_dev(self._device['devNo'])
        if devInfo['online']:
            result.update({'signal':devInfo['signal']})
            return result
        else:
            return {'signal':0,'rst':0}
        
    def response_card_balance(self, cardNo, nodeIndex, portIndex, balance):
        devInfo = self.send_request('cmd/write-card-query-response',
                                    {
                                        'node_index': nodeIndex,
                                        'port_index': portIndex,
                                        'card_no': cardNo,
                                        'balance': int(float(balance * 100)),
                                        'timeout': 10
                                    })

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

        return devInfo