manyi/apps/web/eventer/anxin.py

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

import datetime
import logging
import time
from decimal import Decimal

from mongoengine import DoesNotExist

from apilib.monetary import RMB
from apilib.utils_datetime import to_datetime
from apps.web.constant import Const, DEALER_CONSUMPTION_AGG_KIND
from apps.web.core.accounting import Accounting
from apps.web.device.models import Device, Group
from apps.web.eventer.base import FaultEvent, WorkEvent
from apps.web.eventer import EventBuilder
from apps.web.report.utils import record_consumption_stats
from apps.web.south_intf.platform import notify_event_to_north, notify_event_to_north_v2
from apps.web.user.models import ServiceProgress, UserVirtualCard, VCardConsumeRecord, CardRechargeOrder, Card, MyUser, \
    ConsumeRecord
from apps.web.user.transaction_deprecated import refund_money

logger = logging.getLogger(__name__)


class builder(EventBuilder):
    def __getEvent__(self, device_event):
        event_data = self.deviceAdapter.analyze_event_data(device_event['data'])

        if event_data is None or 'cmdCode' not in event_data:
            return None

        if 'duration' in device_event:
            event_data.update({'duration': device_event['duration']})

        fun_code = event_data['cmdCode']

        if fun_code in ['06', '10', '20', '16', '11', '12']:
            return ChargingAnxinWorkEvent(self.deviceAdapter, event_data)

        if fun_code == '0A':
            return FaultEvent(self.deviceAdapter, event_data)

        return None


class ChargingAnxinWorkEvent(WorkEvent):
    def do(self, **args):
        devNo = self.device['devNo']
        logger.info('anxin charging event detected, devNo=%s,info=%s' % (devNo, self.event_data))

        if self.event_data['cmdCode'] == '10':  # 刷卡消费的，分为扣费和退费两种
            cardNo = self.event_data['cardNo']
            preFee = RMB(self.event_data['preFee'])
            oper = self.event_data['oper']

            card = self.update_card_dealer_and_type(cardNo)

            # 首先检查订单，并进行充值
            card_recharge_order = CardRechargeOrder.get_last_to_do_one(str(card.id))  # type: CardRechargeOrder

            result = self.recharge_id_card(card = card,
                                           rechargeType = 'append',
                                           order = card_recharge_order)

            # 暂时保留. 按照流程应该不需要在重新加载
            card.reload()

            logger.info('cardNo=%s,openId=%s,result=%s,preFee=%s,curinfo=%s' % (
                cardNo, card.openId, result, preFee, self.event_data))

            try:
                # 扣费
                if oper == '00':
                    leftBalance = result['balance']
                    res = '00'
                    if card.openId == '' or card.frozen:
                        res = '02'
                        leftBalance = RMB(0)
                    elif result['balance'] < preFee:
                        res = '01'

                    if res == '00':
                        self.consume_money_for_card(card, preFee)

                        # 记录卡消费记录以及消费记录
                        orderNo, cardOrderNo = self.record_consume_for_card(card, preFee)

                        # 记录当前服务的progress.没有上报端口号，所以先用-1标记，表示端口未知。端口等消费的时候会报上来
                        ServiceProgress.register_card_service(self.device, -1, card,
                                                              {'orderNo': orderNo, 'money': self.event_data['preFee'],
                                                               'coin': self.event_data['preFee'], 'needTime': 0,
                                                               'cardOrderNo': cardOrderNo})
                        leftBalance -= preFee

                    try:
                        self.deviceAdapter.response_use_card(res, leftBalance)

                    except Exception, e:  # 启动失败需要把金币还回去
                        logger.info('resp back error=%s' % e)
                        return

                    if res in ['01', '02']:
                        return

                    self.event_data['openId'] = card.openId
                    self.event_data['cardId'] = str(card.id)
                    self.event_data['startTime'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')

                    Device.update_dev_control_cache(devNo, self.event_data)

                    # 通知微信，已经扣费
                    self.notify_balance_has_consume_for_card(card, preFee)


                # 退费.卡的退费完全由设备决定，设备告诉我退费，我就退。刷卡充电结束后，不要去退费。
                elif oper == '01':
                    try:
                        res = '00'
                        self.deviceAdapter.response_use_card(res, card.balance + preFee)
                    except Exception, e:  # 启动失败需要把金币还回去
                        logger.info('resp back error=%s' % e)
                        return

                    self.refund_money_for_card(preFee, str(card.id))

                    # 通知微信，已经退费
                    self.notify_user(card.managerialOpenId, 'refund_coins', **{
                        'title': u'退币完成！您的卡号是%s,卡别名:%s' % (card.cardNo, card.nickName),
                        'backCount': u'金币：%s' % preFee,
                        'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                    })
            except Exception, e:
                logger.error('use card=%s catche exception=%s' % (cardNo, e))

        elif self.event_data['cmdCode'] in ['06', '16']:  # 结束的命令
            lineInfo = Device.update_port_control_cache(devNo, self.event_data)

            try:
                group = Group.get_group(self.device['groupId'])
                if not lineInfo.has_key('coins'):
                    return

                if 'duration' in self.event_data and self.event_data['duration'] > 0:
                    usedTime = self.event_data['duration']
                else:
                    if (not lineInfo) or (not lineInfo.has_key('startTime')):
                        return

                    startTime = to_datetime(lineInfo['startTime'])
                    nowTime = datetime.datetime.now()

                    # 如果web服务器时间和事件监控服务器时间不一致，导致开始时间比事件时间还大
                    if startTime > nowTime:
                        usedTime = 0
                    else:
                        usedTime = int(round(((nowTime - startTime).total_seconds() / 60.0)))

                cardId = lineInfo.get('cardId', '')
                vCardId = lineInfo.get('vCardId', None)
                money = RMB(lineInfo['coins'])
                price = lineInfo.get('price', 0.0)
                leftTime = self.event_data['leftTime']
                billingType = lineInfo.get('billingType', 'time')
                consumeType = lineInfo.get('consumeType', '')
                backCoins, backPrice = 0.0, 0.0

                # 刷卡或者万一缓存重启了，出现needElec为空的,作为1000度电吧，就会一定使用设备上报的电量
                if lineInfo.has_key('elec') and lineInfo.has_key('needElec'):
                    spendElec = round(lineInfo['needElec'] - lineInfo['elec'], 2) if lineInfo.get(
                        'elec') < lineInfo.get('needElec') else 0.0
                else:
                    spendElec = 0.0

                if leftTime == 65535:
                    actualNeedTime = 0
                    backCoins = money
                    backPrice = price
                    usedTime = 0
                    spendElec = 0.0
                else:
                    actualNeedTime = usedTime + leftTime
                    leftTimeStr = leftTime

                    if billingType == 'time':
                        needTime = lineInfo['needTime']
                        backCoins = money * (float(leftTime) / float(actualNeedTime))

                    else:
                        backCoins = RMB(money.amount - money.amount * (
                                    Decimal(lineInfo.get('needElec', 1000)) - Decimal(
                                str(lineInfo.get('elec')))) / Decimal(lineInfo.get('needElec', 1000)))

                if backCoins > money:
                    backCoins = money

                backPrice = round(price * float(backCoins) / float(money), 2)

                if vCardId is None and cardId == '':  # 扫码的方式
                    openId = lineInfo['openId']

                    billingType = lineInfo.get('billingType', 'time')
                    if billingType == 'time':
                        leftTimeStr = leftTime if leftTime != 65535 else lineInfo['needTime']
                        title = u'%s 按动态功率计算总时间为:%s分钟,剩余时间:%s分钟' % (
                            self.event_data['reason'],
                            actualNeedTime,
                            leftTimeStr)
                    else:
                        title = u'%s %s元购买%s度电量,实际使用电量为:%s度' % (
                            self.event_data['reason'],
                            money, lineInfo.get('needElec', 1000),
                            spendElec
                        )

                    # 通知充电完成
                    user = MyUser.objects(openId = openId, groupId = self.device['groupId']).first()
                    self.notify_user(user.managerialOpenId, 'service_complete',
                                     **{
                                         'title': title,
                                         'service': u'充电服务(设备编号：%s,端口：%s,地址：%s)' % (
                                             self.device['logicalCode'], self.event_data['port'], group['address']),
                                         'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                         'remark': u'谢谢您的支持'
                                     })

                    consumeDict = {'chargeIndex': lineInfo['port'],
                                   'reason': lineInfo['reason'],
                                   'elec': spendElec, 'actualNeedTime': u'动态功率计算为%s分钟' % actualNeedTime,
                                   'duration': usedTime, 'elecFee': self.calc_elec_fee(spendElec)}
                    if billingType == 'time':
                        leftTimeStr = leftTime if leftTime != 65535 else lineInfo['needTime']
                        consumeDict.update({'leftTime': leftTimeStr, 'needTime': u'扫码订购%s分钟' % lineInfo['needTime']})
                    else:
                        consumeDict.update({'needElec': lineInfo['needElec']})

                    # 如果需要退款，计算退款数据.
                    if not self.device.is_auto_refund:
                        consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.COIN: money.mongo_amount})

                        ServiceProgress.update_progress_and_consume_rcd(
                            self.device['ownerId'],
                            {'open_id': openId, 'device_imei': self.device['devNo'],
                             'port': lineInfo['port'], 'isFinished': False}, consumeDict
                        )
                    else:
                        # 扫码退钱, 退到个人账号
                        refund_money(self.device, backCoins, lineInfo['openId'])

                        consumeDict.update({
                            DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS: backCoins.mongo_amount,
                            DEALER_CONSUMPTION_AGG_KIND.COIN: (money - backCoins).mongo_amount
                        })

                        ServiceProgress.update_progress_and_consume_rcd(
                            self.device['ownerId'],
                            {'open_id': openId, 'device_imei': self.device['devNo'],
                             'port': lineInfo['port'], 'isFinished': False}, consumeDict)

                        if billingType == 'time':
                            leftTimeStr = leftTime if leftTime != 65535 else lineInfo['needTime']
                            desc = u'您使用的%s号端口充电，共付款:%s元，充电预定时间为:%s分钟，剩余时间:%s分钟,给您退款:%s元' % (
                                lineInfo['port'], money, lineInfo['needTime'], leftTimeStr, backCoins)
                        else:
                            desc = u'您使用的%s号端口充电，共付款:%s元，充电预定电量为:%s度，使用:%s度,给您退款:%s元' % (
                                lineInfo['port'], money, lineInfo.get('needElec', 1), spendElec, backCoins)

                        self.notify_user(user.managerialOpenId if user else '', 'refund_coins', **{
                            'title': desc,
                            'backCount': u'金币：%s' % backCoins,
                            'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                        })
                elif vCardId is not None:  # 使用的是虚拟卡
                    billingType = lineInfo.get('billingType', 'time')
                    if billingType == 'time':
                        leftTimeStr = leftTime if leftTime != 65535 else lineInfo['needTime']
                        title = u'%s 按动态功率计算总时间为:%s分钟,剩余时间:%s分钟' % (
                            self.event_data['reason'],
                            actualNeedTime,
                            leftTimeStr)
                    else:
                        title = u'%s %s元购买%s度电量,实际使用电量为:%s度' % (
                            self.event_data['reason'],
                            money, lineInfo.get('needElec', 1000),
                            spendElec
                        )

                    # 通知充电完成
                    try:
                        vCard = UserVirtualCard.objects.get(id = vCardId)
                    except DoesNotExist, e:
                        logger.info('can not find the vCard id = %s' % vCardId)
                        return

                    self.notify_user(self.get_managerialOpenId_by_openId(lineInfo['openId']), 'service_complete',
                                     **{
                                         'title': title,
                                         'service': u'充电服务(设备编号：%s,端口：%s,地址：%s)' % (
                                             self.device['logicalCode'], self.event_data['port'], group['address']),
                                         'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                         'remark': u'谢谢您的支持'
                                     })

                    consumeDict = {'chargeIndex': lineInfo['port'],
                                   'reason': lineInfo['reason'],
                                   'elec': spendElec, 'actualNeedTime': u'动态功率计算为%s分钟' % actualNeedTime,
                                   'duration': usedTime,
                                   'elecFee': self.calc_elec_fee(spendElec)}

                    ServiceProgress.update_progress_and_consume_rcd(
                        self.device['ownerId'],
                        {'open_id': lineInfo['openId'], 'device_imei': self.device['devNo'],
                         'port': lineInfo['port'], 'isFinished': False}, consumeDict
                    )

                    consumeRcdId = lineInfo.get('consumeRcdId', None)
                    if consumeRcdId is None:
                        logger.info('can not find consume rcd id')
                        return
                    try:
                        vCardConsumeRcd = VCardConsumeRecord.objects.get(id = consumeRcdId)
                    except DoesNotExist, e:
                        logger.info('can not find the consume rcd id = %s' % consumeRcdId)
                        return

                    vCard.refund_quota(vCardConsumeRcd, usedTime, spendElec, backCoins.mongo_amount)

                elif cardId != '':  # 刷卡的方式，分ID卡和IC卡两种
                    card = Card.objects.get(id = cardId)
                    if card.cardType == 'ID':
                        consumeDict = {'chargeIndex': lineInfo['port'], 'leftTime': leftTimeStr,
                                       'reason': lineInfo['reason'], 'actualNeedTime': u'动态功率计算为%s分钟' % actualNeedTime,
                                       'elec': spendElec, 'duration': usedTime, 'needElec': lineInfo['needElec'],
                                       'elecFee': self.calc_elec_fee(spendElec)}

                        if billingType == 'time':
                            self.notify_user(card.managerialOpenId if card else '', 'service_complete',
                                             **{
                                                 'title': u'%s 卡号：%s(%s)，按动态功率计算总时间为:%s分钟,剩余时间:%s分钟' % (
                                                     self.event_data['reason'],
                                                     card.cardNo,
                                                     card.cardName,
                                                     actualNeedTime,
                                                     leftTimeStr),
                                                 'service': u'充电服务(设备编号：%s,端口：%s 地址：%s)' % (
                                                     self.device['logicalCode'], self.event_data['port'],
                                                     group['address']),
                                                 'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                                 'remark': u'谢谢您的支持'
                                             })

                            ServiceProgress.update_progress_and_consume_rcd(
                                self.device['ownerId'],
                                {'cardId': cardId, 'device_imei': self.device['devNo'],
                                 'port': lineInfo['port'], 'isFinished': False},
                                {'chargeIndex': lineInfo['port'], 'leftTime': leftTimeStr,
                                 'needTime': u'刷卡订购%s分钟' % needTime, 'reason': lineInfo['reason'],
                                 'elec': spendElec, 'duration': usedTime,
                                 'actualNeedTime': u'动态功率计算为%s分钟' % actualNeedTime,
                                 'elecFee': self.calc_elec_fee(spendElec)})

                            if not self.device.is_auto_refund:
                                consumeDict.update({
                                    DEALER_CONSUMPTION_AGG_KIND.CONSUME_CARD: money.mongo_amount
                                })

                                ServiceProgress.update_progress_and_consume_rcd(
                                    self.device['ownerId'],
                                    {'cardId': cardId, 'device_imei': self.device['devNo'],
                                     'port': lineInfo['port'], 'isFinished': False}, consumeDict
                                )
                                return
                            else:
                                consumeDict.update({
                                    DEALER_CONSUMPTION_AGG_KIND.REFUND_CARD: backCoins.mongo_amount,
                                    DEALER_CONSUMPTION_AGG_KIND.CONSUME_CARD: (money - backCoins).mongo_amount
                                })

                                self.refund_money_for_card(backCoins, str(card.id))

                                ServiceProgress.update_progress_and_consume_rcd(
                                    self.device['ownerId'],
                                    {'open_id': lineInfo['openId'], 'device_imei': self.device['devNo'],
                                     'port': lineInfo['port'], 'isFinished': False}, consumeDict)

                                leftTimeStr = leftTime if leftTime != 65535 else lineInfo['needTime']
                                desc = u'您使用的%s号端口充电，共付款:%s元，充电预定时间为:%s分钟，剩余时间:%s分钟,给您退款:%s元' % (
                                    lineInfo['port'], money, lineInfo['needTime'], leftTimeStr, backCoins)

                                self.notify_user(card.managerialOpenId if card else '', 'refund_coins', **{
                                    'title': desc,
                                    'backCount': u'金币：%s' % backCoins,
                                    'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                                })

                                return
                        else:
                            self.notify_user(card.managerialOpenId if card else '', 'service_complete',
                                             **{
                                                 'title': u'%s 卡号：%s(%s)，%s元购买%s度电量,实际使用电量为:%s度' % (
                                                     self.event_data['reason'],
                                                     card.cardNo,
                                                     card.cardName,
                                                     money,
                                                     lineInfo['needElec'],
                                                     spendElec),
                                                 'service': u'充电服务(设备编号：%s,端口：%s 地址：%s)' % (
                                                     self.device['logicalCode'], self.event_data['port'],
                                                     group['address']),
                                                 'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                                 'remark': u'谢谢您的支持'
                                             })

                            consumeDict = {'chargeIndex': lineInfo['port'], 'leftTime': leftTimeStr,
                                           'reason': lineInfo['reason'],
                                           'elec': spendElec, 'duration': usedTime, 'needElec': lineInfo['needElec'],
                                           'elecFee': self.calc_elec_fee(spendElec)}

                            if not self.device.is_auto_refund:
                                consumeDict.update({
                                    DEALER_CONSUMPTION_AGG_KIND.CONSUME_CARD: money.mongo_amount
                                })

                                ServiceProgress.update_progress_and_consume_rcd(
                                    self.device['ownerId'],
                                    {'cardId': cardId, 'device_imei': self.device['devNo'],
                                     'port': lineInfo['port'], 'isFinished': False}, consumeDict
                                )
                            else:
                                consumeDict.update({
                                    DEALER_CONSUMPTION_AGG_KIND.REFUND_CARD: backCoins.mongo_amount,
                                    DEALER_CONSUMPTION_AGG_KIND.CONSUME_CARD: (money - backCoins).mongo_amount
                                })

                                self.refund_money_for_card(backCoins, str(card.id))

                                ServiceProgress.update_progress_and_consume_rcd(
                                    self.device['ownerId'],
                                    {'open_id': lineInfo['openId'], 'device_imei': self.device['devNo'],
                                     'port': lineInfo['port'], 'isFinished': False}, consumeDict)

                                desc = u'您使用的%s号端口充电，共付款:%s元，充电预定电量为:%s度，使用:%s度,给您退款:%s元' % (
                                    lineInfo['port'], money, lineInfo.get('needElec', 0.0), spendElec, backCoins)

                                self.notify_user(card.managerialOpenId if card else '', 'refund_coins', **{
                                    'title': desc,
                                    'backCount': u'金币：%s' % backCoins,
                                    'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                                })
                    else:  # IC卡
                        self.notify_user(card.managerialOpenId if card else '', 'service_complete',
                                         **{
                                             'title': u'%s 卡号：%s(%s)，总时间为:%s分钟' % (
                                                 self.event_data['reason'],
                                                 card.cardNo,
                                                 card.cardName,
                                                 usedTime),
                                             'service': u'充电服务(设备编号：%s,端口：%s 地址：%s)' % (
                                                 self.device['logicalCode'], self.event_data['port'], group['address']),
                                             'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                             'remark': u'谢谢您的支持'
                                         })

                        ServiceProgress.update_progress_and_consume_rcd(
                            self.device['ownerId'],
                            {'cardId': cardId, 'device_imei': self.device['devNo'],
                             'port': lineInfo['port'], 'isFinished': False},
                            {'chargeIndex': lineInfo['port'], 'leftTime': leftTimeStr,
                             'needTime': u'刷卡订购%s分钟' % needTime, 'reason': lineInfo['reason'],
                             'elec': spendElec, 'duration': usedTime,
                             'actualNeedTime': u'动态功率计算为%s分钟' % actualNeedTime,
                             'elecFee': self.calc_elec_fee(spendElec)})
                        return

                elif consumeType == 'coin':
                    CoinConsumeRcd = ConsumeRecord.objects.get(
                        orderNo = lineInfo['consumeOrderNo'])  # type: ConsumeRecord
                    CoinConsumeRcd.servicedInfo['elec'] = spendElec
                    CoinConsumeRcd.servicedInfo['actualNeedTime'] = u'动态功率计算为%s分钟' % actualNeedTime
                    CoinConsumeRcd.servicedInfo['needTime'] = u'投币订购%s分钟' % needTime
                    CoinConsumeRcd.servicedInfo['reason'] = lineInfo['reason']
                    CoinConsumeRcd.servicedInfo['chargeIndex'] = lineInfo['port']
                    CoinConsumeRcd.finishedTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                    CoinConsumeRcd.save()

                    valueDict = {
                        DEALER_CONSUMPTION_AGG_KIND.ELEC: spendElec,
                        DEALER_CONSUMPTION_AGG_KIND.ELECFEE: self.calc_elec_fee(spendElec)
                    }
                    status = CoinConsumeRcd.update_agg_info(valueDict)
                    if status:
                        record_consumption_stats(CoinConsumeRcd)
                    else:
                        logger.error(
                            '[update_progress_and_consume_rcd] failed to update_agg_info record=%r' % (CoinConsumeRcd,))

            except Exception, e:
                logger.exception('deal with jingneng devNo=%s event e=%s' % (devNo, e))
            finally:
                Device.clear_port_control_cache(devNo, str(self.event_data['port']))

                try:
                    dataDict = {'backMoney': backPrice, 'backCoins': backCoins.mongo_amount}
                    if lineInfo.has_key('orderNo'):
                        dataDict.update({'orderNo': lineInfo['orderNo']})
                    notify_event_to_north_v2(self.device["devNo"], self.event_data)
                    notify_event_to_north(self.dealer, self.device, level = Const.EVENT_NORMAL,
                                          desc = self.event_data['reason'], dataDict = dataDict)
                except Exception:
                    pass

        elif self.event_data['cmdCode'] == '20':  # 启动了端口,主要记录下投币数据
            consumeType = self.event_data['consumeType']
            if consumeType == 'coin':
                self.event_data.update({'startTime': datetime.datetime.now().strftime(Const.DATETIME_FMT)})

                Device.update_port_control_cache(self.device['devNo'], self.event_data)  # 记录该端口累计需要的时间和钱,cardId

                Accounting.recordOfflineCoin(self.device,
                                             int(time.time()),
                                             int(self.event_data['coins']),
                                             port = self.event_data.get('port', None))

                self.event_data.update({'needElec': self.event_data['elec']})
                self.event_data.update({'consumeOrderNo': self.record_consume_for_coin(RMB(self.event_data['coins']))})
                Device.update_port_control_cache(self.device['devNo'], self.event_data)

            elif consumeType == 'card':
                port = self.event_data['port']

                consumeDict = {'chargeIndex': port, 'elec': self.event_data['elec'],
                               'money': self.event_data['coins'], 'needTime': u'刷卡订购%s分钟' % self.event_data['needTime']}
                queryDict = {'device_imei': self.device['devNo'],
                             'port': -1, 'isFinished': False,
                             'cardId': {'$ne': ''}, 'start_time': {'$gte': int(time.time()) - 3600}}
                progressDict = {'port': port}

                ServiceProgress.update_progress_and_consume_rcd(ownerId = self.device['ownerId'], queryDict = queryDict,
                                                                consumeDict = consumeDict, updateConsume = True,
                                                                progressDict = progressDict)

                # 找出对应的卡的ID记录到端口内存数据
                queryDict.update(progressDict)
                rcds = ServiceProgress.get_collection().find(queryDict, {'cardId': 1, 'open_id': 1},
                                                             sort = [('start_time', -1)])
                if rcds.count() == 0:
                    return

                rcd = rcds[0]
                dev = Device.objects.get(devNo = self.device['devNo'])
                billingType = dev.otherConf.get('billingType', 'time')

                self.event_data.update({'billingType': billingType})
                self.event_data.update({'cardId': rcd['cardId']})
                self.event_data.update({'openId': rcd['open_id']})

                self.event_data.update({'coins': self.event_data['coins']})
                self.event_data.update({'needElec': self.event_data['elec']})
                self.event_data.update({'needTime': self.event_data['needTime']})

                self.event_data.update({'startTime': datetime.datetime.now().strftime(Const.DATETIME_FMT)})
                self.event_data.update({'isStart': True, 'status': Const.DEV_WORK_STATUS_WORKING})

                Device.update_port_control_cache(self.device['devNo'], self.event_data)

            elif consumeType == 'server':
                port = self.event_data['port']
                # 强制更新信息, 避免代码进入错误流程
                Device.update_port_control_cache(self.device['devNo'], self.event_data)  # 记录该端口累计需要的时间和钱

                consumeDict = {'chargeIndex': self.event_data['port'], 'elec': self.event_data['elec'],
                               'needTime': u'订购%s分钟' % self.event_data['needTime']}
                queryDict = {'device_imei': self.device['devNo'],
                             'port': port, 'isFinished': False,
                             'start_time': {'$gte': int(time.time()) - 3600}}
                progressDict = {'port': self.event_data['port']}

                ServiceProgress.update_progress_and_consume_rcd(ownerId = self.device['ownerId'],
                                                                queryDict = queryDict, consumeDict = consumeDict,
                                                                updateConsume = True, progressDict = progressDict)

        elif self.event_data['cmdCode'] == '11' and self.event_data['oper'] == '01':  # IC卡扣费
            cardType = self.event_data['cardType']
            card = self.update_card_dealer_and_type(self.event_data['cardNo'], cardType)

            fee = RMB(self.event_data['preFee'])
            card.balance = RMB(self.event_data['balance']) - fee

            try:
                card.save()
            except Exception, e:
                logger.exception(e)

            orderNo, cardOrderNo = self.record_consume_for_card(card, fee)

            # 记录当前服务的progress.没有上报端口号，所以先用-1标记，表示端口未知。端口等消费的时候会报上来
            ServiceProgress.register_card_service(self.device, self.event_data['port'], card,
                                                  {'orderNo': orderNo, 'money': self.event_data['preFee'],
                                                   'coin': self.event_data['preFee'], 'cardOrderNo': cardOrderNo})

            # 通知微信，已经扣费
            self.notify_balance_has_consume_for_card(card, fee)

            self.event_data.update({'cardId': str(card.id)})
            self.event_data.update({'openId': card.openId})
            self.event_data.update({'coins': self.event_data['preFee']})
            self.event_data.update({'startTime': datetime.datetime.now().strftime(Const.DATETIME_FMT)})
            self.event_data.update({'isStart': True, 'status': Const.DEV_WORK_STATUS_WORKING})
            Device.update_port_control_cache(self.device['devNo'], self.event_data)  # 记录该端口累计需要的时间和钱,cardId

        elif self.event_data['cmdCode'] == '11' and self.event_data['oper'] == '03':  # IC卡退费
            card = self.update_card_dealer_and_type(self.event_data['cardNo'], 'IC')
            self.refund_money_for_card(RMB(self.event_data['preFee']), card.id)

        elif self.event_data['cmdCode'] == '12':
            cardNo = self.event_data['cardNo']

            card = self.update_card_dealer_and_type(cardNo, 'IC')  # type: Card
            if card.frozen:
                logger.debug('{} has been frozen.'.format(repr(card)))
                return

            preBalance = RMB(self.event_data['balance'])

            order = CardRechargeOrder.get_last_to_do_one(str(card.id))  # type: CardRechargeOrder

            # 为了测试，测试OK删除
            if order.money == RMB(0.0):
                try:
                    cardData = self.deviceAdapter.recharge_card(cardNo, RMB(0.0))
                    Card.objects(id = card.id).update_one(set__balance = cardData['balance'])
                except Exception as e:
                    logger.exception('recharge card error=%s' % e)
            else:
                self.recharge_ic_card(card = card,
                                      preBalance = preBalance,
                                      rechargeType = 'append',
                                      order = order,
                                      need_verify = False)