manyi/apps/web/eventer/weifule2.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 FAULT_CODE, FAULT_LEVEL, Const, ErrorCode, DEALER_CONSUMPTION_AGG_KIND, CONSUMETYPE
from apps.web.core.accounting import Accounting
from apps.web.dealer.models import Dealer
from apps.web.device.models import WeifuleDeviceOrder, Group, Device
from apps.web.eventer import EventBuilder
from apps.web.eventer.base import WorkEvent, FaultEvent
from apps.web.eventer.weifuleCommon import WeiFuLeCommonEvent
from apps.web.south_intf.platform import handle_and_notify_event_to_north_ytb
from apps.web.user.models import ServiceProgress, UserVirtualCard, VCardConsumeRecord, \
    ConsumeRecord, WeifuleCardStamp, Card, CardConsumeRecord, CardRechargeOrder, MyUser, CardRechargeRecord, \
    RechargeRecord

logger = logging.getLogger(__name__)

created_order_32 = 32
executing_order_33 = 33
finished_order_34 = 34
id_card_request_35 = 35
card_recharge_order_37 = 37
fault_event_overload_38 = 38  # 整机功率过载
fault_event_relay_39 = 39  # 继电器故障
fault_event_counter_40 = 40  # 计量芯片故障
fault_event_mcu_36 = 36  # mcu重启
power_event_41 = 999  # 待设备实现

ic_consume_event_48 = 48  # ic卡花钱的时候，会上报此事件
part_sn_event = 49  # 组件上报相关信息

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卡使用
no_load_code = 7

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

        if event_data is None:
            return None

        if event_data['fun_code'] in [created_order_32, executing_order_33, finished_order_34, id_card_request_35,
                                      card_recharge_order_37]:
            return ChargingWEIFULEWorkEvent(self.deviceAdapter, event_data)

        if event_data['fun_code'] in [fault_event_mcu_36, fault_event_overload_38, fault_event_relay_39,
                                      fault_event_counter_40]:
            return WEIFULEFaultEvent(self.deviceAdapter, event_data)

        if event_data['fun_code'] in [ic_consume_event_48]:
            return WEIFULEICCardConsume(self.deviceAdapter, event_data)

        if event_data['fun_code'] in [power_event_41]:
            return WEIFULEPowerEvent(self.deviceAdapter, event_data)


class WEIFULEPowerEvent(WorkEvent):
    def do(self, **args):
        power = int(self.event_data['power'])
        orderNo = str(self.event_data['orderNo'])
        # PowerInfoManager.instence().append_power(orderNo, power)


class WEIFULEICCardConsume(FaultEvent):
    def do(self, **args):
        cardNo = str(int(self.event_data['card_no'], 16))
        stamp = self.event_data['stamp']

        isCopy = WeifuleCardStamp.is_copy_card(cardNo, self.device['ownerId'], stamp)

        if isCopy:
            self.event_data.update({
                'faultName': u'复制卡告警',
                'faultCode': FAULT_CODE.COPY_CARD,
                'level': FAULT_LEVEL.CRITICAL,
                'desc': u'卡号为：%s的卡，极可能是复制卡，建议冻结处理。' % cardNo
            })
            super(WEIFULEICCardConsume, self).do()

        newObj = WeifuleCardStamp(
            cardNo=cardNo,
            dealerId=self.device['ownerId'],
            stamp=str(stamp),
            dateTimeAdded = datetime.datetime.now()
        )
        newObj.save()


class WEIFULEFaultEvent(FaultEvent):
    def do(self, **args):
        if self.event_data['fun_code'] == fault_event_mcu_36:
            self.event_data.update({
                'faultName': u'单片机告警',
                'faultCode': FAULT_CODE.MCU_REBOOT,
                'level': FAULT_LEVEL.NORMAL,
                'desc': u'充电主板上的单片机重启。'
            })
        elif self.event_data['fun_code'] == fault_event_relay_39:
            self.event_data.update({
                'faultName': u'继电器告警',
                'port': int(self.event_data['port']),
                'faultCode': FAULT_CODE.RELAY_FAULT,
                'level': FAULT_LEVEL.CRITICAL,
                'desc': u'继电器发送粘连。'
            })
        elif self.event_data['fun_code'] == fault_event_counter_40:
            self.event_data.update({
                'faultName': u'计量芯片告警',
                'port': int(self.event_data['port']),
                'faultCode': FAULT_CODE.COUNTER_FAULT,
                'level': FAULT_LEVEL.CRITICAL,
                'desc': u'计量芯片获取功率失败。'
            })
        elif self.event_data['fun_code'] == fault_event_overload_38:
            self.event_data.update({
                'faultName': u'整机功率过载告警',
                'faultCode': FAULT_CODE.DEV_OVERLOAD,
                'level': FAULT_LEVEL.FATAL,
                'desc': u'整机功率超过7500瓦。'
            })
        else:
            pass
        super(WEIFULEFaultEvent, self).do()


class ChargingWEIFULEWorkEvent(WorkEvent, WeiFuLeCommonEvent):
    # 微付乐的板子：根据设备上报上来的订单，创建正在服务的信息
    def create_progress_for_weifule_order(self, consumeRcd, order):
        try:
            progress = ServiceProgress.objects.filter(weifuleOrderNo=order['id']).first()
            if progress:
                return

            port = int(order['port'])
            attachParas = consumeRcd.attachParas

            needKind, needValue, unit = self.analyse_need_from_package(order)

            consumeOrder = {
                'orderNo': consumeRcd.orderNo,
                'coin': consumeRcd.coin.mongo_amount,
                'money': consumeRcd.money.mongo_amount,
                'unit': unit,
                'consumeType': 'mobile_vcard' if u'虚拟卡' in consumeRcd.remarks else 'mobile'
            }
            if needKind:
                consumeOrder.update({needKind: needValue})

            new_service_progress = ServiceProgress(
                open_id=consumeRcd.openId,
                device_imei=consumeRcd.devNo,
                devTypeCode=self.device['devType']['code'],
                port=port,
                attachParas=attachParas if attachParas else {},
                start_time=int(order['create_time']),
                finished_time=int(order['create_time']) + 24 * 60 * 60,
                consumeOrder=consumeOrder,
                weifuleOrderNo=order['id']
            )

            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)
        #             card.showBalance = card.balance #只有微付乐是创建订单成功后才真正扣费
        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 is_order_accepted(self, orderNo, funCode):
        return True if WeifuleDeviceOrder.objects.filter(orderNo=orderNo, funCode=funCode).count() > 0 else False

    def record_order_event(self, order, funCode):
        newObj = WeifuleDeviceOrder(orderNo=order['id'], funCode=funCode, order=order)
        try:
            newObj.save()
        except Exception, e:
            logger.exception('save order event error=%s' % e)
            pass

    def record_consume_for_card(self, card, money, orderNo):

        group = Group.get_group(self.device['groupId'])
        address = group['address']
        group_number = self.device['groupNumber']

        now = datetime.datetime.now()

        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,
            'remarks': u'刷卡消费',
            'errorDesc': '',
            'sequanceNo': '',
            'desc': '',
            'attachParas': {},
            'servicedInfo': {}
        }
        ConsumeRecord.get_collection().insert_one(new_record)

        # 刷卡消费也记录一条数据
        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['devType']['name'],
            'logicalCode': self.device['logicalCode'],
            'groupId': self.device['groupId'],
            'address': address,
            'groupNumber': group_number,
            'groupName': group['groupName'],
            'result': 'success',
            'remarks': u'刷卡消费',
            'sequanceNo': '',
            'dateTimeAdded': datetime.datetime.now(),
            'desc': '',
            'servicedInfo': {},
            'linkedConsumeRcdOrderNo': str(new_record['orderNo'])
        }

        CardConsumeRecord.get_collection().insert(new_card_record)

        return new_record['orderNo'], new_card_record['orderNo']

    def __translate_reason(self, cause, chrmt):
        if cause == 0:
            if chrmt == 'TIME':
                return u'订购时间已经用完。'
            else:
                return u'订购电量已经用完。'
        elif cause == 1:
            return u'用户拔掉充电器，或者插座脱落。'
        elif cause == 2:
            return u'端口禁用。'
        elif cause == 3:
            return u'远程停止。'
        elif cause == 4:
            return u'整机过载，系统为了安全，关闭掉所有充电端口。'
        elif cause == 5:
            return u'充电端口电流过载，系统为了安全，关闭此充电端口。'
        elif cause == 6:
            return u'端口功率过载，系统为了安全，关闭此充电端口。'
        elif cause == 7:
            return u'端口空载。可能是插座松动、充电端口故障、或者充电电池故障。'
        elif cause == 8:
            return u'充满自停。'
        elif cause == 9:
            return u'计量芯片故障'
        elif cause == 20:
            return u'端口功率过小。可能是电池已经充满，也可能是所接负载功率太小'
        
        return u'充电结束。'

    def deal_with_ic_charge_event(self, msgDict):
        cardNo = str(int(self.event_data['card_no'], 16))
        card = self.update_card_dealer_and_type(cardNo, 'IC')

        if not card:
            return self.deviceAdapter.response_card_charge_result(self.event_data['card_no'], card_not_in_db)
        elif card.frozen:
            return self.deviceAdapter.response_card_charge_result(self.event_data['card_no'], card_is_forzen)

        preBalance = RMB(self.event_data['balance'] / 100.0)
        self.update_balance_for_IC_card(card, preBalance)
        rechargeOrder = CardRechargeOrder.get_last_to_do_one(str(card.id))

        if rechargeOrder:
            self.recharge_ic_card(card=card,
                                  preBalance=preBalance,
                                  rechargeType='append',
                                  order=rechargeOrder,
                                  need_verify=False)
        else:
            return self.deviceAdapter.response_card_charge_result(self.event_data['card_no'], card_has_not_order)

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

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

        card = self.find_card_by_card_no(cardNo)

        # 如果没有卡，直接返回
        if card is None:
            return self.deviceAdapter.response_card_balance(cardNo=data['card_no'], balance=0, result=card_not_in_db)
        elif card.frozen:
            return self.deviceAdapter.response_card_balance(cardNo=data['card_no'], balance=0, result=card_is_forzen)

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

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

        #: 首先检查订单，并进行充值
        #: 用户首先在手机客户端充值，需要这个时刻刷卡上报事件将充值的订单同步上来
        card_recharge_order = CardRechargeOrder.get_last_to_do_one(str(card.id))
        if card_recharge_order:
            result = self.recharge_id_card(card=card,
                                           rechargeType='append',
                                           order=card_recharge_order)

        card.reload()

        fee = RMB(data['fee'] / 100.0)
        if card.showBalance >= fee:
            result = card_is_normal
        #             balance = card.showBalance * 100
        else:
            result = card_less_balance
        #             balance = card.showBalance * 100

        if result == card_is_normal:
            card.showBalance -= fee

        self.deviceAdapter.response_card_balance(data['card_no'], card.showBalance, result)  # 返回的cardNo为16进制

        # 确定发送成功了，然后再保存到数据库中
        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 do(self, **args):
        devNo = self.device['devNo']
        funCode = self.event_data['fun_code']
        if funCode == card_recharge_order_37:  # 如果是卡充值，直接回复订单
            self.deal_with_ic_charge_event(self.event_data)
        elif funCode == id_card_request_35:
            self.response_id_card(self.event_data)
        else:  # 处理任务事件
            order = self.event_data['order']

            logger.info('weifule charging event detected, devNo=%s' % (devNo,))
            with memcache_lock(key = '%s-%s-%s-finished' % (devNo, order['id'], funCode), value = 1,
                               expire = 120) as acquired:
                if acquired:
                    self.deal_order(devNo, funCode, order, self.event_data)

    def deal_order(self, devNo, funCode, order, msgDict):
        dealer = Dealer.get_dealer(self.device['ownerId'])
        # 开始充电最重要的功能核对订单，以及记录订单。
        # 扫码情况下，需要检查订单，如果订单成功了，就不需要核查，如果订单失败的，需要核查，然后把没有扣的钱扣掉
        # 刷卡情况下，正式把刷卡的钱扣掉，并产生消费的订单。
        # 投币情况下，把投币扣费的记录记录下来即可

        # 首先，统一回复确认报文
        if funCode in [created_order_32, executing_order_33, finished_order_34, id_card_request_35]:
            try:
                self.deviceAdapter.ack_event(order['id'], funCode)
            except Exception, e:
                logger.info('ack event devNo=%s err=%s' % (devNo, e))
                pass

        if funCode == created_order_32 and order['order_type'] != 'card_charge':  # 订单创建成功，开始收单，并检查账单

            # 回收余额也会有订单，但是没有端口，不需要处理，直接pass掉
            if order['order_type'] == 'card_refund':
                return

            # 首先把端口状态给刷新掉(虽然是任务在设备上排队的通知，端口肯定是要忙起来的，先搞成忙)
            Device.update_dev_control_cache(self.device['devNo'], {
                str(order['port']): {'status': Const.DEV_WORK_STATUS_WORKING}
            }
                                            )

            if order['order_type'] == 'coin_start':  # 投币，直接记账即可

                Accounting.recordOfflineCoin(self.device,
                                             int(time.time()),
                                             int(order.get('coins', 0) * 0.01))
            elif order['order_type'] == 'card_start':  # 刷卡

                cardNo = str(int(order['card_no'], 16))

                # 登记下卡相关信息
                if order['card_type'] == 'offline_card':
                    card = self.update_card_dealer_and_type(cardNo, 'IC', balance=RMB(order['balance'] / 100.0))
                    if card:
                        self.update_balance_for_IC_card(card, RMB(order['balance'] / 100.0))
                    else:
                        return
                    # 如果卡冻结了，马上把端口关闭
                    if card.frozen:
                        logger.info('this card=%s is frozen,so shut down the port which opened by the card' % cardNo)
                        self.deviceAdapter.stop_charging_port(order['port'])

                else:
                    card = self.update_card_dealer_and_type(cardNo, 'ID')
                    balance = card.balance - RMB(order['coins'] / 100.0)
                    self.update_card_balance(card, balance)
                    # 卡的显示余额同步下
                    card.showBalance = card.balance
                    card.save()

                fee = RMB(order['coins'] / 100.0)

                # 记录卡消费记录以及消费记录
                orderNo, cardOrderNo = self.record_consume_for_card(card, fee, order['id'])

                # 记录当前服务的progress,便于手机界面查询进度
                needKind, needValue, unit = self.analyse_need_from_package(order)
                consumeDict = {'orderNo': orderNo, 'money': order['coins'] / 100.0, 'coin': order['coins'] / 100.0,
                               'cardOrderNo': cardOrderNo, needKind: needValue, 'unit': unit}
                ServiceProgress.register_card_service_for_weifule(self.device, order['port'], card, consumeDict)

                # 通知用户，已经扣费
                title = make_title_from_dict([
                    {u"设备地址": u"{}".format(self.device.group.address)},
                    {u"设备编号": u"{}".format(self.device["logicalCode"])},
                    {u"实体卡": u"{}--No:{}".format(card.cardName or card.nickName, card.cardNo)},
                    {u"本次消费": u"{} 元".format(fee)},
                    {u"卡余额": u"{} 元".format(card.balance)},
                ])
                start_time_stamp = order.get("create_time")
                start_time = datetime.datetime.fromtimestamp(start_time_stamp)

                self.notify_user(
                    card.managerialOpenId,
                    'dev_start',
                    **{
                        'title': title,
                        'things': u'刷卡消费',
                        'remark': u'感谢您的支持!',
                        'time': start_time.strftime(Const.DATETIME_FMT)
                    }
                )

            elif order['order_type'] == 'apps_start':  # 扫码
                self.pay_apps_start_by_32(order, callbackSP=self.create_progress_for_weifule_order)

            elif order['order_type'] == 'card_charge':
                pass

        # 如果是启动了订单，需要更新端口状态，需要刷新服务状态
        elif funCode == executing_order_33 and order['order_type'] != 'card_charge':

            progress = ServiceProgress.objects.filter(weifuleOrderNo=order['id']).first()
            if (not progress) or (not order.has_key('port')):  # 只有卡充值的时候，order才没有port
                return

            Device.update_dev_control_cache(self.device['devNo'], {
                str(order['port']): {
                    'status': Const.DEV_WORK_STATUS_WORKING,
                    'openId': progress.open_id,
                    'startTime': datetime.datetime.now().strftime(Const.DATETIME_FMT)
                }
            }
                                            )
            progress.status = 'running'
            progress.runningTime = datetime.datetime.now()
            progress.save()

        # 订单结束，需要把进行账单核对、记录更新、通知、退费等;
        elif funCode == finished_order_34 and order['order_type'] != 'card_charge':

            # 如果是离线卡的余额回收，修改下余额，然后直接返回即可
            if order['order_type'] == 'card_refund':
                card = Card.objects.filter(agentId=dealer['agentId'], cardNo=str(int(order['card_no'], 16))).first()
                if card is None:
                    return
                else:
                    card.balance = RMB(order['balance'] / 100.0)
                    card.save()
                return

            order['reason'] = self.__translate_reason(order['cause'], order['chrmt'])

            devCache = Device.get_dev_control_cache(self.device['devNo']).get(str(order['port']), {})
            if devCache.get('isAPI', False) is True:
                logger.info('handle api push service, devNo=%s' % self.device['devNo'])
                Device.clear_port_control_cache(devNo, order['port'])
                self.event_data.update({'deviceCode': self.device['logicalCode']})
                return handle_and_notify_event_to_north_ytb(self.device["devNo"], self.event_data)

            progress = ServiceProgress.objects.filter(weifuleOrderNo=order['id']).first()
            if progress is None:
                logger.info('Duplicate data pass....')
                return

            progress.status = 'finished'
            progress.isFinished = True
            progress.save()

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

            if consumeRcd.status == 'finished':
                logger.info('Repeat processing!! orderNo<{}>'.format(consumeRcd.orderNo))
                return

            try:
                logger.info('source data saving....')
                consumeRcd.update(source=order, status='finished')
            except:
                logger.info('Failed to save source data')
                pass

            try:
                group = Group.get_group(self.device['groupId'])

                consumeDict = {
                    'reason': order['reason'],
                    'chargeIndex': order['port'],
                    'duration': round(order['time'] / 60.0, 1),
                    'elec': round(order['elec'] / 1000000.0, 2)
                }

                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
                
                package = consumeRcd.package
                if package.get('name') == '充满自停' and package.get('coins') == 0 and package.get('price') == 0:  # 后付费
                    coins = round(order.get('coins', 1000) * 0.01, 2)
                    usedFee = VirtualCoin(0)
                    usedTime = order['time'] / 60
                    if order['chrmt'] == 'TIME':

                        leftTime = order['left_time'] / 60 if order['left_time'] > 0 else 0
                        actualNeedTime = usedTime + leftTime
                        usedFee = VirtualCoin(coins * (float(usedTime) / float(actualNeedTime)))
                    elif order['chrmt'] == 'ELEC':
                 
                        needElec = order['amount_elec'] / 1000000.0
                        usedElec = order['elec'] / 1000000.0
                        usedFee = VirtualCoin(coins * (float(usedElec) / float(needElec)))

                    
                    cause = int(order.get(u'cause', 0))
                    if cause == no_load_code:
                        usedFee = VirtualCoin(0)

                    consumeDict.update({
                        DEALER_CONSUMPTION_AGG_KIND.SPEND_MONEY: usedFee.mongo_amount
                    })
                    
                    
                    user = MyUser.objects(openId=consumeRcd.openId, groupId=self.device['groupId']).first()
                    if not user:
                        return
                    
                    try:
                        user.pay(coins=usedFee)
                        Accounting.recordNetPayCoinCount(devNo)
                        user.update(inc__total_consumed=usedFee)
                        consumeRcd.update(coin=usedFee.mongo_amount)
                    except Exception:
                        pass
                    
                    user.reload()
                    titleDictList = [
                        {u'设备编号': self.device['logicalCode']},
                        {u'端口': order['port']},
                        {u'地址': group['address']},
                        {u'结束原因': order['reason']},
                        {u'充电时间': u'%s分钟' % round(usedTime, 1)},
                        {u'本次服务费用': u'%s币' % usedFee},

                    ]
                    notifyDict.update(
                        {
                            'title': make_title_from_dict(titleDictList)
                        }
                    )
                    
                    # 通知服务结束
                    notifyOpenId = user.managerialOpenId if user else ''
                    self.notify_user(notifyOpenId, 'service_complete', **notifyDict)

                    ServiceProgress.update_progress_and_consume_rcd(self.device['ownerId'],
                                                                    {'weifuleOrderNo': order['id']},
                                                                    consumeDict)
                    
                else:
                    backCoins = VirtualCoin(0)
                    refundProtection = self.device['otherConf'].get('refundProtection', 5)
                    if order['chrmt'] == 'TIME':  # 按照时间计费
                        needTime = round(order['amount_time'] / 60.0, 1)
                        usedTime = round(order['time'] / 60.0, 1)
                        leftTime = order['left_time'] / 60.0 if order['left_time'] > 0 else 0
                        leftTimeStr = round(leftTime, 1)
                        actualNeedTime = round((usedTime + leftTime), 1)
                        consumeDict.update({
                            'needTime': needTime,
                            'leftTime': leftTimeStr,
                            'actualNeedTime': u'动态功率计算为%s分钟' % actualNeedTime,
                        })
    
                        titleDictList = [
                            {u'设备编号': self.device['logicalCode']},
                            {u'端口': order['port']},
                            {u'地址': group['address']},
                            {u'结束原因': order['reason']},
                            {u'订购时间': u'%s分钟' % needTime},
                            {u'应充时间': u'%s分钟' % actualNeedTime},
                            {u'充电时间': u'%s分钟' % usedTime},
                            {u'剩余时间': u'%s分钟' % leftTimeStr}
                        ]
    
                        notifyDict.update(
                            {
                                'title': make_title_from_dict(titleDictList)
                            }
                        )
                        
                        if int(order.get(u'cause', 0)) == no_load_code or usedTime <= refundProtection:  # 判断空载
                            backCoins = coins
                        else:
                            if self.device.is_auto_refund:
                                backCoins = coins * (float(leftTime) / float(actualNeedTime))
                            

                        titleDictList = [
                            {u'设备编号': self.device['logicalCode']},
                            {u'端口': order['port']},
                            {u'预定时间': u'%s分钟' % needTime},
                            {u'应充时间': u'%s分钟' % actualNeedTime},
                            {u'充电时间': u'%s分钟' % usedTime},
                            {u'剩余时间': u'%s分钟' % leftTimeStr},
                        ]
                        refundDict.update(
                            {
                                'title': make_title_from_dict(titleDictList),
                                'backCount': u'金币：%s' % backCoins
                            }
                        )
                    else:
                        needElec = round(order['amount_elec'] / 1000000.0, 2)
                        usedTime = round(order['time'] / 60.0, 1)
                        usedElec = round(order['elec'] / 1000000.0, 2)
                        leftElec = needElec - usedElec if needElec > usedElec else 0.0
                        leftElec = round(leftElec, 2)
                        titleDictList = [
                            {u'设备编号': self.device['logicalCode']},
                            {u'端口': order['port']},
                            {u'结束原因': order['reason']},
                            {u'订购电量': u'%s度' % needElec},
                            {u'充电时间': u'%s分钟' % usedTime},
                            {u'消耗电量': u'%s度' % usedElec},
                            {u'剩余电量': u'%s度' % leftElec},
                        ]
                        notifyDict.update(
                            {
                                'title': make_title_from_dict(titleDictList)
                            }
                        )

                        if int(order.get(u'cause', 0)) == no_load_code or usedTime <= refundProtection:  # 判断空载
                            backCoins = coins
                        else:
                            if self.device.is_auto_refund:
                                backCoins = coins * (float(leftElec) / float(needElec))
                        
                        titleDictList = [
                            {u'设备编号': self.device['logicalCode']},
                            {u'端口': order['port']},
                            {u'结束原因': order['reason']},
                            {u'订购电量': u'%s度' % needElec},
                            {u'充电时间': u'%s分钟' % usedTime},
                            {u'消耗电量': u'%s度' % usedElec},
                            {u'剩余电量': u'%s度' % leftElec},
                        ]

                        if consumeRcd.package.get('billingMethod') == CONSUMETYPE.BILL_AS_SERVICE:
                            usedCoins = coins - backCoins
                            titleDictList.append(
                                {u'电量费用': self.device.bill_as_service_feature.current_elec_fee(usedCoins)})
                            titleDictList.append(
                                {u'服务费': self.device.bill_as_service_feature.current_service_fee(usedCoins)})

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

                    logger.info(
                        'REFUND STATUS  orderNo=<{}>, refundSwitch={}, refundProtectionTime=<{}>, backCoins=<{}>'.format(
                            consumeRcd.orderNo, self.device.is_auto_refund, refundProtection, backCoins.mongo_amount
                        ))
                    
                    if u'虚拟卡' in consumeRcd.remarks:
                        # 退额度
                        try:
                            vRcd = VCardConsumeRecord.objects.get(orderNo=order['id'])
                            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 backCoins > RMB(0):
                            if order['chrmt'] == 'TIME':
                                vCard.refund_quota(vRcd, usedTime, 0.0, backCoins.mongo_amount)
                            else:
                                vCard.refund_quota(vRcd, 0.0, usedElec, backCoins.mongo_amount)
                    # 刷卡的方式
                    elif order['order_type'] == 'card_start' and order['card_no']:

                        consumeDict.update({
                            'cardNo': str(int(order['card_no'], 16)),
                            'port': order['port'],
                        })

                        dealer = Dealer.get_dealer(ownerId=self.device['ownerId'])
                        card = Card.objects.filter(agentId=dealer['agentId'], cardNo=str(int(order['card_no'], 16))).first()
                        if card is None:  # 离线卡没有绑定或者在线卡被解绑了
                            return
    
                        # 先通知
                        notifyOpenId = card.managerialOpenId if card else ''
                        self.notify_user(notifyOpenId, 'service_complete', **notifyDict)
    
                        # 不需要退款，直接返回.在线卡需要退费，离线卡只登记使用记录就OK
                        if backCoins > RMB(0) 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)
    
                    else:  # 扫码的
                        user = MyUser.objects(openId=consumeRcd.openId, groupId=self.device['groupId']).first()
                        if not user:
                            return
    
                        # 通知服务结束
                        notifyOpenId = user.managerialOpenId if user else ''
                        self.notify_user(notifyOpenId, 'service_complete', **notifyDict)
    
                        if backCoins > RMB(0):
                            refundCash = 'refundRMB_device_event' in self.device.owner.features
                            rechargeRcdId = consumeRcd.rechargeRcdId
                            if rechargeRcdId:
                                rechargeRcd = RechargeRecord.objects.filter(id=rechargeRcdId, isQuickPay=True).first()
                            else:
                                rechargeRcd = None
    
                            if refundCash is True and rechargeRcd is not None:  # 退现金特征 + 有充值订单
                                refundRMB = rechargeRcd.money * (backCoins.amount / coins.amount)
                                self.refund_net_pay(user, {'rechargeRcdId': rechargeRcdId, 'openId': user.openId},
                                                    refundRMB, VirtualCoin(0), consumeDict, True)

                                refundDict.update({'backCount': u'金额：%s' % refundRMB})
                                self.notify_user(notifyOpenId, 'refund_coins', **refundDict)
    
                            else:
                                self.refund_net_pay(user, {'openId': user.openId}, RMB(0), backCoins, consumeDict,
                                                    False)
        
                                self.notify_user(notifyOpenId, 'refund_coins', **refundDict)

                    ServiceProgress.update_progress_and_consume_rcd(self.device['ownerId'], {'weifuleOrderNo': order['id']},
                                                                    consumeDict)

            except Exception, e:
                logger.exception('some exception happed,devNo=%s,e=%s' % (devNo, e))
            finally:
                Device.clear_port_control_cache(devNo, order['port'])

                try:
                    self.deviceAdapter.get_port_status_from_dev()
                except:
                    pass


        elif funCode == finished_order_34 and order['order_type'] == 'card_charge':
            self.update_card_recharge_for_success_event(order['id'], RMB(order['balance'] / 100.0))

        else:
            pass

    def recharge_ic_card(self, card, preBalance, rechargeType, order, need_verify = True):
        # type:(Card, RMB, str, CardRechargeOrder, bool)->bool

        """
        # rechargeType有两种，一种是用直接覆写overwrite的方式，一种是append追加钱的方式。
        # 不同的的设备，充值的方式还不一样.注意：money是实际用户付的钱，coins是给用户充值的钱，比如付10块（money），充15（coins）。
        :param card:
        :param preBalance:
        :param rechargeType:
        :param order:
        :return:
        """
        if not order or order.coins == RMB(0):
            return False

        status = Card.get_card_status(str(card.id))
        if status == 'busy':
            return False

        Card.set_card_status(str(card.id), 'busy')

        try:
            # IC卡需要下发到设备，设备写卡，把余额打入卡中
            if rechargeType == 'overwrite':
                sendMoney = preBalance + order.coins
            else:
                sendMoney = order.coins

            # 先判断order最近一次充值是否OK. 满足三个条件在认为上次充值成功:
            # 1、操作时间已经超过三天
            # 2、操作结果是串口超时, 即result == 1
            # 3、当前余额大于最后一次充值操作的充值前余额
            if need_verify and len(order.operationLog) > 0:
                log = order.operationLog[-1]

                result = log['result']
                time_delta = (datetime.datetime.now() - log['time']).total_seconds()
                last_pre_balance = RMB(log['preBalance'])

                if (result == ErrorCode.DEVICE_CONN_FAIL or result == ErrorCode.BOARD_UART_TIMEOUT ) \
                        and (time_delta > 3 * 24 * 3600 or preBalance > last_pre_balance):
                    logger.debug('{} recharge verify result is finished.'.format(repr(card)))
                    order.update_after_recharge_ic_card(device = self.device,
                                                        sendMoney = sendMoney,
                                                        preBalance = preBalance,
                                                        result = ErrorCode.SUCCESS,
                                                        description = u'充值校验结束')
                    # 现将订单状态改为待充值


                    CardRechargeRecord.add_record(
                        card = card,
                        group = Group.get_group(order.groupId),
                        order = order,
                        device = self.device)

                    return False

            if self.device.support_reliable:  # 如果是新版本的，只管发，结果根据异步的事件进行处理
                self.deviceAdapter.recharge_card_async(card.cardNo, sendMoney, str(order.id))
                return False
            else:
                operation_result, balance = self.deviceAdapter.recharge_card(card.cardNo, sendMoney,str(order.id))
                order.update_after_recharge_ic_card(device = self.device,
                                                    sendMoney = sendMoney,
                                                    preBalance = preBalance,
                                                    syncBalance = balance,
                                                    result = operation_result['result'],
                                                    description = operation_result['description'])

                if operation_result['result'] != ErrorCode.SUCCESS:
                    return False

                if not balance:
                    balance = preBalance + order.coins

                CardRechargeRecord.add_record(
                    card = card,
                    group = Group.get_group(order.groupId),
                    order = order,
                    device = self.device)

                # 刷新卡里面的余额
                card.balance = balance
                card.lastMaxBalance = balance
                card.save()

                return True
        except Exception as e:
            logger.exception(e)
            return False
        finally:
            Card.set_card_status(str(card.id), 'idle')