manyi/apps/web/eventer/bolai.py

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

import datetime
import logging
import time

from mongoengine import DoesNotExist

from apilib.monetary import RMB, VirtualCoin
from apilib.utils_string import make_title_from_dict
from apilib.utils_sys import memcache_lock
from apps.web.constant import Const
from apps.web.core.adapter.base import calc_signal_from_rssi
from apps.web.device.models import Group, Device, GroupDict
from apps.web.eventer import EventBuilder
from apps.web.eventer.base import WorkEvent
from apps.web.user.models import ServiceProgress, UserVirtualCard, VCardConsumeRecord, \
    ConsumeRecord, Card, CardRechargeOrder, MyUser, CardConsumeRecord
from apps.web.user.transaction_deprecated import refund_money

logger = logging.getLogger(__name__)

card_is_normal = 1
card_not_in_db = 2
card_is_forzen = 3
card_has_not_order = 4  # IC卡适用
card_less_balance = 5  # ID卡适用
card_type_is_ic = 6  # IC卡不允许当做ID卡使用


class builder(EventBuilder):
    def __getEvent__(self, device_event):
        return bolaiWorkEvent(self.deviceAdapter, device_event)


class bolaiWorkEvent(WorkEvent):
    # 微付乐的板子：根据设备上报上来的订单，创建正在服务的信息
    def create_progress_for_card(self, dev, consumeRcd):
        try:
            progress = ServiceProgress.objects.filter(weifuleOrderNo = consumeRcd.orderNo).first()
            if progress:
                return

            consumeOrder = consumeRcd.servicedInfo

            new_service_progress = ServiceProgress(
                open_id = consumeRcd.openId,
                device_imei = consumeRcd.devNo,
                devTypeCode = dev['devType']['code'],
                port = consumeRcd.servicedInfo['portIndex'],
                attachParas = {},
                start_time = int(time.time()),
                finished_time = 24 * 60 * 60,
                consumeOrder = consumeOrder,
                weifuleOrderNo = consumeRcd.orderNo,
                expireAt = datetime.datetime.now() + datetime.timedelta(days = 91)
            )

            new_service_progress.save()
        except Exception as e:
            logger.exception(e)

    def consume_money_for_ID_card(self, agentId, cardNo, balance, money):
        card = Card.objects.get(agentId = agentId, cardNo = cardNo)
        if card.balance < money:
            card.balance = RMB(0)
        else:
            card.balance = (card.balance - money)
        try:
            card.save()
        except Exception as e:
            logger.exception(e)

        return card

    def update_balance_for_IC_card(self, card, balance):
        card.balance = balance
        try:
            card.save()
        except Exception, e:
            pass

    def new_card_consume_record(self, card, money, sid, servicedInfo):
        group = self.device.group # type: GroupDict
        address = group.address
        group_number = self.device.groupNumber

        now = datetime.datetime.now()

        orderNo = ConsumeRecord.make_no()

        new_record = {
            'orderNo': orderNo,
            'time': now.strftime("%Y-%m-%d %H:%M:%S"),
            'dateTimeAdded': now,
            'openId': card.openId,
            'ownerId': self.device.ownerId,
            'coin': money.mongo_amount,
            'money': money.mongo_amount,
            'devNo': self.device.devNo,
            'logicalCode': self.device.logicalCode,
            'groupId': self.device.groupId,
            'address': address,
            'groupNumber': group_number,
            'groupName': group.groupName,
            'devTypeCode': self.device.devTypeCode,
            'devTypeName': self.device.devTypeName,
            'isNormal': True,
            'status': ConsumeRecord.Status.RUNNING,
            'remarks': u'刷卡消费',
            'errorDesc': '',
            'sequanceNo': sid,
            'desc': '',
            'attachParas': {},
            'servicedInfo': servicedInfo
        }
        order = ConsumeRecord(**new_record)
        order.save()

        # 刷卡消费也记录一条数据
        new_card_record = {
            'orderNo': orderNo,
            'openId': card.openId,
            'cardId': str(card.id),
            'money': money.mongo_amount,
            'balance': card.balance.mongo_amount,
            'devNo': self.device.devNo,
            'devType': self.device.devTypeName,
            'logicalCode': self.device.logicalCode,
            'groupId': self.device.groupId,
            'address': address,
            'groupNumber': group_number,
            'groupName': group.groupName,
            'result': 'success',
            'remarks': u'刷卡消费',
            'sid': sid,
            'dateTimeAdded': datetime.datetime.now(),
            'desc': '',
            'servicedInfo': servicedInfo,
            'linkedConsumeRcdOrderNo': str(order.orderNo)
        }

        card_order = CardConsumeRecord(**new_card_record)
        card_order.save()

        return order, card_order

    def __translate_reason(self, cause):
        if cause == 0:
            return u'结束充电。'
        elif cause == 1:
            return u'正在充电的时候，结束了，可能是用户拔掉充电器，或者插座脱落，或者没有接入充电器'
        elif cause == 2:
            return u'充满自停。'
        elif cause == 3:
            return u'金额已经用完。'
        elif cause == 4:
            return u'平台下发停止充电'

        return u'充电结束。'

    def response_id_card(self, msgDict):
        data = msgDict['data']
        rawCardNo = data['card_no']
        cardNo = str(int(data['card_no'], 16))

        nodeDev = self.device
        Card.record_dev_card_no(nodeDev['devNo'], cardNo)

        card = self.find_card_by_card_no(cardNo)

        # 如果没有卡，直接返回
        if card is None:
            # cardNo,nodeIndex,portIndex,balance
            return self.deviceAdapter.response_card_balance(rawCardNo, data['node_index'], data['port_index'], 0)
        elif card.frozen:
            return self.deviceAdapter.response_card_balance(rawCardNo, data['node_index'], data['port_index'], 0)

        if card.cardType == 'IC':  # 如果以前是离线卡，只能用于离线卡，需要提醒用户
            return self.deviceAdapter.response_card_balance(rawCardNo, data['node_index'], data['port_index'], 0)

        card = self.update_card_dealer_and_type(cardNo, 'ID')

        #: 首先检查订单，并进行充值
        #: 用户首先在手机客户端充值，需要这个时刻刷卡上报事件将充值的订单同步上来
        # 防止重复报文过来，导致重复充值
        with memcache_lock(key = '%s-%s-finished' % (nodeDev['devNo'], cardNo), value = '1', expire = 120) as acquired:
            if acquired:
                card_recharge_order = CardRechargeOrder.get_last_to_do_one(str(card.id))
                if card_recharge_order:
                    self.recharge_id_card(card = card, rechargeType = 'append', order = card_recharge_order)
        
                card.reload()

        self.deviceAdapter.response_card_balance(rawCardNo, data['node_index'], data['port_index'], card.balance)

        # 确定发送成功了，然后再保存到数据库中
        card.save()

    def analyse_need_from_package(self, order):
        needKind, needValue, unit = 'needElec', 0, u'度'
        if order['chrmt'] == 'TIME':
            needKind = 'needTime'
            needValue = order['amount_time'] / 60
            unit = u'分钟'
        else:
            needValue = order['amount_elec'] / 1000000.0

        return needKind, needValue, unit

    # 根据推送的事件，更新端口状态（其实可以不需要处理，既然收到了，就顺手刷新下吧）
    def update_port_from_event(self, gatewayDevNo, nodeIndex, portIndex, portInfo):
        # 先刷网关的
        nodeIndex = str(nodeIndex)
        portIndex = str(portIndex)

        value = {
            'ampere': portInfo['current'] / 1000.0,
            'power': portInfo['power'],
            'voltage': portInfo['voltage'],
            'elec': portInfo['energy_consumed']*0.001,
            'spendTime': portInfo['time_consumed'],
            'sequanceNo': portInfo['transaction_id'],
            'online': portInfo['online'],
            'status': Const.DEV_WORK_STATUS_WORKING if portInfo['charge_status'] == 1 else Const.DEV_WORK_STATUS_IDLE
        }

        info = Device.get_dev_control_cache(self.device.devNo)
        info.update({str(portIndex): value})
        Device.update_dev_control_cache(self.device.devNo, info)

    def charge_end_by_time(self, data):
        reason = self.__translate_reason(data['data']['charge_status'])

        orderNo = data['data']['transaction_id']

        nodeDev = self.device
        devNo = nodeDev['devNo']

        consumeRcd = ConsumeRecord.objects.filter(sequanceNo = orderNo).first()
        if not consumeRcd:  # 投币的不会生成订单
            return

        port = consumeRcd.attachParas['chargeIndex']
        progress = ServiceProgress.objects.filter(weifuleOrderNo = consumeRcd.orderNo).first() # type: ServiceProgress
#         if progress is None or progress.status == 'finished':
#             return

        progress.status = 'finished'
        progress.isFinished = True
        progress.expireAt = datetime.datetime.now()
        progress.save()

        try:
            group = Group.get_group(nodeDev['groupId'])
            servicedInfo = consumeRcd.servicedInfo
            billingType = servicedInfo['billingType']
            usedTime = data['data']['time_consumed']
            usedElec = data['data']['energy_consumed'] * 0.001
            consumeDict = {
                'reason': reason,
                'chargeIndex': port,
                'duration': usedTime,
                'elec': usedElec
            }
            consumeDict.update(servicedInfo)
            notifyDict = {
                'service': u'充电服务完成',
                'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                'remark': u'谢谢您的支持'
            }

            refundDict = {
                'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            }

            coins = consumeRcd.coin

            if billingType == 'time':  # 按照时间计费
                needTime = servicedInfo['needTime']

                leftTime = needTime - usedTime if needTime > usedTime else 0
                leftTimeStr = leftTime
                consumeDict.update({
                    'needTime': needTime,
                    'leftTime': leftTimeStr,
                })

                titleDictList = [
                    {u'设备编号': nodeDev['logicalCode']},
                    {u'端口': 'A' if port == 0 else 'B'},
                    {u'地址': group['address']},
                    {u'结束原因': reason},
                    {u'订购时间': u'%s分钟' % needTime},
                    {u'充电时间': u'%s分钟' % usedTime},
                    {u'剩余时间': u'%s分钟' % leftTimeStr}
                ]

                notifyDict.update(
                    {
                        'title': make_title_from_dict(titleDictList)
                    }
                )

                backCoins = coins * (float(leftTime) / float(needTime))

                titleDictList = [
                    {u'设备编号': nodeDev['logicalCode']},
                    {u'端口': 'A' if port == 0 else 'B'},
                    {u'付款': u'%s元' % coins},
                    {u'预定时间': u'%s分钟' % needTime},
                    {u'充电时间': u'%s分钟' % usedTime},
                    {u'剩余时间': u'%s分钟' % leftTimeStr},
                ]
                refundDict.update(
                    {
                        'title': make_title_from_dict(titleDictList),
                        'backCount': u'金币：%s' % backCoins
                    }
                )
            else:  # 按电量付费的
                needElec = servicedInfo['needElec']

                leftElec = needElec - usedElec if needElec > usedElec else 0.0
                consumeDict.update({
                    'needElec': needElec,
                    'leftElec': leftElec
                })
                titleDictList = [
                    {u'设备编号': nodeDev['logicalCode']},
                    {u'端口': 'A' if port == 0 else 'B'},
                    {u'结束原因': reason},
                    {u'订购电量': u'%s度' % needElec},
                    {u'消耗电量': u'%s度' % usedElec},
                    {u'剩余电量': u'%s分钟' % leftElec},
                ]
                notifyDict.update(
                    {
                        'title': make_title_from_dict(titleDictList)
                    }
                )

                backCoins = coins * (float(leftElec) / float(needElec))

                titleDictList = [
                    {u'设备编号': nodeDev['logicalCode']},
                    {u'端口': 'A' if port == 0 else 'B'},
                    {u'结束原因': reason},
                    {u'订购电量': u'%s度' % needElec},
                    {u'消耗电量': u'%s度' % usedElec},
                    {u'剩余电量': u'%s度' % leftElec},
                ]
                refundDict.update(
                    {
                        'title': make_title_from_dict(titleDictList),
                        'backCount': u'金币：%s' % backCoins
                    }
                )

            if u'虚拟卡' in consumeRcd.remarks:
                # 退额度
                try:
                    vRcd = VCardConsumeRecord.objects.get(orderNo = consumeRcd.orderNo)
                    vCard = UserVirtualCard.objects.get(id = vRcd.cardId)
                except DoesNotExist, e:
                    logger.info('can not find the vCard id = %s' % vRcd.cardId)
                    return

                # 通知服务结束
                notifyOpenId = self.get_managerialOpenId_by_openId(vRcd.openId) if vCard else ''
                self.notify_user(notifyOpenId, 'service_complete', **notifyDict)

                # 不需要退款，直接返回，不通知
                if self.device.is_auto_refund:
                    if billingType == 'time':
                        vCard.refund_quota(vRcd, usedTime, 0.0, backCoins.mongo_amount)
                    else:
                        vCard.refund_quota(vRcd, 0.0, usedElec, backCoins.mongo_amount)
            else:  # 扫码的
                user = MyUser.objects(openId = consumeRcd.openId, groupId = nodeDev['groupId']).first()
                if not user:
                    return

                # 通知服务结束
                notifyOpenId = user.managerialOpenId if user else ''
                self.notify_user(notifyOpenId, 'service_complete', **notifyDict)

                # 如果需要退款，计算退款数据.
                if self.device.is_auto_refund:
                    consumeDict.update({'refundedMoney': str(backCoins)})
                    refund_money(nodeDev, backCoins, consumeRcd.openId)
                    self.notify_user(notifyOpenId, 'refund_coins', **refundDict)

            ServiceProgress.update_progress_and_consume_rcd(nodeDev['ownerId'], {'weifuleOrderNo': consumeRcd.orderNo},
                                                            consumeDict)
        except Exception, e:
            logger.exception('some exception happed,devNo=%s,e=%s' % (devNo, e))
        finally:
            self.deviceAdapter.get_port_status_from_dev()
    
    # 功率计费模式下，根据返回的数据，计算消耗的钱
    def calc_spend_money(self,data):
        settle_power = data['data']['settle_power']
        usedTime = data['data']['time_consumed']
        config_list = self.device.my_obj.otherConf.get('config_list', [])
        powerList = []
        configDict = {}
        for _ in config_list:
            configDict[_['power']] = _
            powerList.append(_['power'])
        
        powerList.sort()
        for power in powerList:
            if settle_power < power:
                break
            else:
                continue
        pricePower = power
        
        priceConfig = configDict[pricePower]
        spendMoney = VirtualCoin(usedTime/priceConfig['time']*100*0.01)
        return spendMoney
        
    def charge_end_by_power(self, data):
        reason = self.__translate_reason(data['data']['charge_status'])
        orderNo = data['data']['transaction_id']
        
        nodeDev = self.device
        devNo = nodeDev['devNo']

        consumeRcd = ConsumeRecord.objects.filter(sequanceNo = orderNo).first()
        if not consumeRcd:  # 投币的不会生成订单
            return
        port = consumeRcd.attachParas['chargeIndex']

        progress = ServiceProgress.objects.filter(weifuleOrderNo = consumeRcd.orderNo).first() # type: ServiceProgress
        if progress is None or progress.status == 'finished':
            return

        progress.status = 'finished'
        progress.isFinished = True
        progress.expireAt = datetime.datetime.now()
        progress.save()

        try:
            group = Group.get_group(nodeDev['groupId'])
            spendMoney = self.calc_spend_money(data)
            usedTime = data['data']['time_consumed']
            usedElec = data['data']['energy_consumed'] * 0.001
            consumeDict = {
                'reason': reason,
                'chargeIndex': port,
                'spendMoney': str(spendMoney),
                'power': data['data']['settle_power'],
                'usedTime': usedTime,
                'usedElec': usedElec,
                'power': data['data']['power'],
                'current': data['data']['current']
            }
            consumeDict.update(consumeRcd.servicedInfo)
            
            notifyDict = {
                'service': u'充电服务完成',
                'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                'remark': u'谢谢您的支持'
            }

            refundDict = {
                'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            }

            coins = consumeRcd.coin
            backCoins = coins - spendMoney if coins > spendMoney else VirtualCoin(0.0) 
            usedTime = data['data']['time_consumed']
            consumeDict.update({
                'duration': usedTime,
            })

            titleDictList = [
                {u'设备编号': nodeDev['logicalCode']},
                {u'端口': 'A' if port == 0 else 'B'},
                {u'地址': group['address']},
                {u'结束原因': reason},
                {u'结算功率': u'%s瓦' % data['data']['settle_power']},
                {u'使用时间': u'%s分钟' % usedTime}
            ]

            notifyDict.update(
                {
                    'title': make_title_from_dict(titleDictList)
                }
            )

            refundDict.update(
                {
                    'title': make_title_from_dict(titleDictList),
                    'backCount': u'金币：%s' % backCoins
                }
            )

            if u'虚拟卡' in consumeRcd.remarks:
                # 退额度
                try:
                    vRcd = VCardConsumeRecord.objects.get(orderNo = consumeRcd.orderNo)
                    vCard = UserVirtualCard.objects.get(id = vRcd.cardId)
                except DoesNotExist, e:
                    logger.info('can not find the vCard id = %s' % vRcd.cardId)
                    return

                # 通知服务结束
                notifyOpenId = self.get_managerialOpenId_by_openId(vRcd.openId) if vCard else ''
                self.notify_user(notifyOpenId, 'service_complete', **notifyDict)

                # 不需要退款，直接返回，不通知
                if self.device.is_auto_refund:
                    vCard.refund_quota(vRcd, 0.0, 0.0, backCoins.mongo_amount)

            else:  # 扫码的
                user = MyUser.objects(openId = consumeRcd.openId, groupId = nodeDev['groupId']).first()
                if not user:
                    return

                # 通知服务结束
                notifyOpenId = user.managerialOpenId if user else ''
                self.notify_user(notifyOpenId, 'service_complete', **notifyDict)

                # 如果需要退款，计算退款数据.
                if self.device.is_auto_refund:
                    consumeDict.update({'refundedMoney': str(backCoins)})
                    refund_money(nodeDev, backCoins, consumeRcd.openId)
                    self.notify_user(notifyOpenId, 'refund_coins', **refundDict)

            ServiceProgress.update_progress_and_consume_rcd(nodeDev['ownerId'], {'weifuleOrderNo': consumeRcd.orderNo},
                                                            consumeDict)
        except Exception, e:
            logger.exception('some exception happed,devNo=%s,e=%s' % (devNo, e))
        finally:
            self.deviceAdapter.get_port_status_from_dev()
            
    def charge_end_by_card(self, data):
        reason = self.__translate_reason(data['data']['charge_status'])
        sequanceNo = data['data']['transaction_id']

        devNo = self.device.devNo

        order = ConsumeRecord.objects.filter(sequanceNo = sequanceNo).first()
        if not order:  # 投币的不会生成订单
            return

        progress = ServiceProgress.objects.filter(weifuleOrderNo = order.orderNo).first() # type: ServiceProgress
        if progress is None or progress.status == 'finished':
            return

        progress.status = 'finished'
        progress.isFinished = True
        progress.expireAt = datetime.datetime.now()
        progress.save()

        servicedInfo = order.servicedInfo
        port = servicedInfo['portIndex']

        try:
            group = Group.get_group(self.device.groupId)
            servicedInfo = order.servicedInfo
            billingType = servicedInfo['billingType']
            usedTime = data['data']['time_consumed']
            usedElec = data['data']['energy_consumed'] * 0.001
            consumeDict = {
                'reason': reason,
                'chargeIndex': port,
                'duration': usedTime,
                'elec': usedElec
            }
            consumeDict.update(servicedInfo)
            
            notifyDict = {
                'service': u'充电服务完成',
                'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                'remark': u'谢谢您的支持'
            }

            refundDict = {
                'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            }

            coins = order.coin

            if billingType == 'time':  # 按照时间计费
                needTime = servicedInfo['needTime']

                leftTime = needTime - usedTime if needTime > usedTime else 0
                leftTimeStr = leftTime
                consumeDict.update({
                    'needTime': needTime,
                    'leftTime': leftTimeStr,
                })

                titleDictList = [
                    {u'设备编号': self.device.logicalCode},
                    {u'端口': 'A' if port == 0 else 'B'},
                    {u'地址': group['address']},
                    {u'结束原因': reason},
                    {u'订购时间': u'%s分钟' % needTime},
                    {u'充电时间': u'%s分钟' % usedTime},
                    {u'剩余时间': u'%s分钟' % leftTimeStr}
                ]

                notifyDict.update(
                    {
                        'title': make_title_from_dict(titleDictList)
                    }
                )

                backCoins = coins * (float(leftTime) / float(needTime))

                titleDictList = [
                    {u'设备编号': self.device.logicalCode},
                    {u'端口': 'A' if port == 0 else 'B'},
                    {u'付款': u'%s元' % coins},
                    {u'预定时间': u'%s分钟' % needTime},
                    {u'充电时间': u'%s分钟' % usedTime},
                    {u'剩余时间': u'%s分钟' % leftTimeStr},
                ]
                refundDict.update(
                    {
                        'title': make_title_from_dict(titleDictList),
                        'backCount': u'金币：%s' % backCoins
                    }
                )
            else:  # 按电量付费的
                needElec = servicedInfo['needElec']

                leftElec = needElec - usedElec if needElec > usedElec else 0.0
                consumeDict.update({
                    'needElec': needElec,
                    'leftElec': leftElec
                })
                titleDictList = [
                    {u'设备编号': self.device.logicalCode},
                    {u'端口': 'A' if port == 0 else 'B'},
                    {u'结束原因': reason},
                    {u'订购电量': u'%s度' % needElec},
                    {u'消耗电量': u'%s度' % usedElec},
                    {u'剩余电量': u'%s分钟' % leftElec},
                ]
                notifyDict.update(
                    {
                        'title': make_title_from_dict(titleDictList)
                    }
                )

                backCoins = coins * (float(leftElec) / float(needElec))

                titleDictList = [
                    {u'设备编号': self.device.logicalCode},
                    {u'端口': 'A' if port == 0 else 'B'},
                    {u'结束原因': reason},
                    {u'订购电量': u'%s度' % needElec},
                    {u'消耗电量': u'%s度' % usedElec},
                    {u'剩余电量': u'%s度' % leftElec},
                ]
                refundDict.update(
                    {
                        'title': make_title_from_dict(titleDictList),
                        'backCount': u'金币：%s' % backCoins
                    }
                )

            dealer = self.device.owner
            card = Card.objects.filter(agentId = dealer.agentId, cardNo = str(servicedInfo['cardNo'])).first()
            if card is None:  # 离线卡没有绑定或者在线卡被解绑了
                return

            # 先通知
            notifyOpenId = card.managerialOpenId if card else ''
            self.notify_user(notifyOpenId, 'service_complete', **notifyDict)

            # 不需要退款，直接返回.在线卡需要退费，离线卡只登记使用记录就OK
            if self.device.is_auto_refund and card.cardType == 'ID':
                card = self.refund_money_for_card(RMB(backCoins), card.id)
                card.showBalance = card.balance
                card.save()
                consumeDict.update({'refundedMoney': str(backCoins)})
                self.notify_user(notifyOpenId, 'refund_coins', **refundDict)

            ServiceProgress.update_progress_and_consume_rcd(self.device.ownerId, {'weifuleOrderNo': order.orderNo},
                                                            consumeDict)
        except Exception, e:
            logger.exception('some exception happed,devNo=%s,e=%s' % (devNo, e))
        finally:
            self.deviceAdapter.get_port_status_from_dev()

    def start_charge_by_card(self, data):
        sequanceNo = data['data']['transaction_id']

        order = ConsumeRecord.objects.filter(sequanceNo = sequanceNo).first()
        if order:
            logger.debug('start event of device<devNo={}> has been done. sequanceNo = {}'.format(
                self.device.devNo, sequanceNo))
            return

        cardNo = str(int(data['data']['card']['no'], 16))
        nodeIndex = data['data']['node_index']
        portIndex = data['data']['port_index']
        card = self.find_card_by_card_no(cardNo)
        if not card:
            return
        
        # 获取卡充电相关配置
        otherConf = self.device.my_obj.otherConf
        billingType = otherConf.get('billingType', 1)  # 0 :电量 1：时间  2：功率
        config_list = otherConf.get('config_list', [])
        onceCard = otherConf.get('onceCard', 100)
        cardTime = otherConf.get('cardTime', 180)
        cardElec = otherConf.get('cardElec', 1)
        
        # 检查是否余额够
        if card.balance < RMB(onceCard*0.01):
            return 
        
        jsonPara = {
            # 'gateway_id': data['gateway_id'],
            'node_index': nodeIndex,
            'port_index': portIndex,
            'transaction_id': sequanceNo,
            'switch_state': 1,
            'timeout': 15
        }
        servicedInfo = {}
        if billingType == 1:
            jsonPara.update({
                'charge_type': 1,
                'charge_time': onceCard * cardTime * 0.01,
                'charge_energy': 0
            })
            servicedInfo.update(
                {'billingType': 'time', 'cardNo': cardNo, 'nodeIndex': nodeIndex, 'portIndex': portIndex,
                 'needTime': cardTime * onceCard * 0.01})
        elif billingType == 0:
            jsonPara.update({
                'charge_type': 2,
                'charge_energy': onceCard * cardElec * 0.01,
                'charge_time': 0
            })
            servicedInfo.update(
                {'billingType': 'elec', 'cardNo': cardNo, 'nodeIndex': nodeIndex, 'portIndex': portIndex,
                 'needElec': cardElec * onceCard * 0.01})
        else:  # 按照功率充电
            jsonPara.update({
                'charge_type': 3,
                'charge_power': {'money': onceCard, 'config_list': config_list}
            })
            servicedInfo.update(
                {'billingType': 'power', 'cardNo': cardNo, 'nodeIndex': nodeIndex, 'portIndex': portIndex,
                 'configList': config_list})

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

        if devInfo['data']['code'] != 0:
            logger.info('start device by card failed,devNo=%s', self.device.devNo)
            return

        order, _ = self.new_card_consume_record(card = card,
                                                money = RMB(onceCard * 0.01),
                                                sid = sequanceNo,
                                                servicedInfo = servicedInfo)

        self.create_progress_for_card(self.device, order)
        self.consume_money_for_card(card, RMB(onceCard * 0.01))


    def do_gateway(self, data):
        if data['type'] == 'EVENT_GATEWAY_HEARTBEAT':
            logger.info('receive EVENT_GATEWAY_HEARTBEAT')
            Device.update_online_cache(self.device.devNo, True, data['data']['rssi'],(long(time.time() * 1000) - 600000 ))
            # 如果是独立机的网关心跳，里面有插座的状态
            if 'port_0' in data['data']:
                self.update_port_from_event(data['gateway_id'], 0, 0, data['data']['port_0'])
            if 'port_1' in data['data']:
                self.update_port_from_event(data['gateway_id'], 0, 1, data['data']['port_1'])
                
    def do_node(self, data):
        if data['type'] == 'EVENT_PLUG_HEARTBEAT': #　
            logger.info('receive EVENT_PLUG_HEARTBEAT')
            self.update_port_from_event(data['gateway_id'], data['data']['node_index'], data['data']['port_index'],
                                        data['data'])
            Device.update_online_cache(self.device.devNo, True)
 
        elif data['type'] == 'EVENT_PLUG_MP_HEARTBEAT':#　插座心跳
            logger.info('receive EVENT_PLUG_MP_HEARTBEAT')
            self.update_port_from_event(data['gateway_id'], data['data']['node_index'], 0, data['data']['port_0'])
            self.update_port_from_event(data['gateway_id'], data['data']['node_index'], 1, data['data']['port_1'])
            
            online = bool(data['data']['port_0']['online'] | data['data']['port_0']['online'])
            signal = calc_signal_from_rssi(data['data']['rssi'])# 将插座和网关的信号值，转为0-32的信号强弱数据
            if online:
                Device.update_online_cache(self.device.devNo, True,signal,(long(time.time() * 1000) + 3600000 ))
            else:
                Device.update_online_cache(self.device.devNo, False,0)
                
            Device.update_field(dev_no = self.device.devNo, update = True, rssi = data['data']['rssi'])
            
        elif data['type'] == 'EVENT_CHARGE_FINISHED':
            self.charge_end_by_time(data)
        elif data['type'] == 'EVENT_CHARGE_FINISHED_3':
            self.charge_end_by_power(data)
        elif data['type'] == 'EVENT_NFC_BALANCE_QUERY':  # 刷卡查询余额
            self.response_id_card(data)
        elif data['type'] == 'EVENT_NFC_CHARGE_STARTED':  # 开始刷卡，然后启动刷卡
            self.start_charge_by_card(data)
        elif data['type'] == 'EVENT_NFC_CHARGE_FINISHED':
            self.charge_end_by_card(data)

    def do(self, **args):
        data = self.event_data

        if data['nodeType'] == 'node':
            self.do_node(data)
        else:
            self.do_gateway(data)