manyi/apps/web/eventer/xiaokedou.py

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

import datetime
import json
import logging
import time
from arrow import Arrow
from django.conf import settings
from apilib.monetary import RMB, VirtualCoin, Ratio
from apilib.systypes import StrEnum
from apilib.utils_string import make_title_from_dict
from apps.web.agent.models import Agent
from apps.web.constant import Const, DEALER_CONSUMPTION_AGG_KIND, FAULT_LEVEL, CONSUMETYPE, DeviceCmdCode
from apps.web.core.adapter.xiaokedou import ChargingXiaoKeDouBox
from apps.web.core.exceptions import ServiceException
from apps.web.core.networking import MessageSender
from apps.web.dealer.models import Dealer
from apps.web.device.models import Group, Device, DeviceDict, GroupDict
from apps.web.eventer.base import FaultEvent, WorkEvent, ComNetPayAckEvent, AckEventProcessorIntf, \
    IcStartAckEvent, IcRechargeAckEvent, CardRefundAckEvent, IdStartAckEvent, VirtualCardStartAckEvent
from apps.web.eventer import EventBuilder
from apps.web.user.models import CardRechargeOrder, UserVirtualCard, Card, ConsumeRecord, RechargeRecord, \
    VCardConsumeRecord, MyUser
from apps.web.user.utils import freeze_user_balance
from apilib.utils_sys import memcache_lock

logger = logging.getLogger(__name__)

class SWIPE_CARD_PARAM_OP(StrEnum):
    """
    卡的操作
    格式 描述_命令码
    """

    #: 减少 (扣费)
    DECR_00 = '00'

    #: 增加 (充值, 退费)
    INCR_01 = '01'


class SWIPE_CARD_RES(StrEnum):
    """
    回应卡的操作
    格式 描述_命令码
    """

    SUCCESS_00 = '00'

    BALANCE_NOT_ENOUGH_01 = '01'

    INVALID_CARD_02 = '02'


class CARD_TYPE(StrEnum):

    OFFLINE_CARD = "00"
    ONLINE_CARD = "01"
    MONTHLY_CARD = "02"
    FULL_CARD = "04"



class builder(EventBuilder):

    def __getEvent__(self, device_event):

        if 'order_id' in device_event:
            if device_event['order_type'] == 'com_start':
                return MyComNetPayAckEvent(self.deviceAdapter, device_event)

            elif device_event['order_type'] == 'ic_recharge':
                return MyIcRechargeAckEvent(self.deviceAdapter, device_event)

            elif device_event['order_type'] == 'ic_start':
                return MyIcStartAckEvent(self.deviceAdapter, device_event)

            elif device_event['order_type'] == 'id_start':
                return MyIdStartAckEvent(self.deviceAdapter, device_event)

            elif device_event['order_type'] == 'vir_start':
                return MyVirtualCardStartAckEvent(self.deviceAdapter, device_event)

            elif device_event['order_type'] == 'card_refund':
                return MyCardRefundAckEvent(self.deviceAdapter, device_event)

        if 'event_type' in device_event:
            if device_event['event_type'] == 'card':
                return CardEvent(self.deviceAdapter, device_event)
            else:
                return None

        event_data = self.analyze_event_data(device_event['data'])
        if event_data is None or 'cmdCode' not in event_data:
            return None

        if event_data['cmdCode'] in ['0A']:
            return JNDZEventerFailure(self.deviceAdapter, event_data)

        if event_data['cmdCode'] in ['21']:
            return ChargingJNDZReportEvent(self.deviceAdapter, event_data)

    def analyze_event_data(self, data):

        cmdCode = data[4:6]
        #: 上传设备故障
        if cmdCode == '0A':
            port = int(data[8:10], 16)
            errCode = data[10:12]

            FaultDict = {
                'A0': ['继电器粘连，请到现场排查', FAULT_LEVEL.FATAL],
                'A1': ['高温', FAULT_LEVEL.CRITICAL],
                'A2': ['低温', FAULT_LEVEL.NORMAL],
                'A3': ['空载,充电头脱落、充电器拔出', FAULT_LEVEL.NORMAL],
                'A4': ['消防（烟感）', FAULT_LEVEL.CRITICAL],
                'A5': ['总功率过载' if port == 255 else '{}号端口过载'.format(port), FAULT_LEVEL.FATAL],
                'A6': ['倾斜', FAULT_LEVEL.FATAL],
                'A7': ['水压高', FAULT_LEVEL.NORMAL],
                'A8': ['水压低', FAULT_LEVEL.NORMAL],
                'A9': ['过压', FAULT_LEVEL.NORMAL],
                'AA': ['欠压', FAULT_LEVEL.NORMAL],
                '27': ['水压高恢复', FAULT_LEVEL.NORMAL],
            }

            return {
                'status': Const.DEV_WORK_STATUS_FAULT,
                'statusInfo': FaultDict.get(errCode, ['设备故障', FAULT_LEVEL.NORMAL])[0],
                'cmdCode': cmdCode,
                'port': port,
                'errCode': errCode,
                'faultContent': FaultDict.get(errCode, [errCode, FAULT_LEVEL.NORMAL])[0],
                'level:': FaultDict.get(errCode, [errCode, FAULT_LEVEL.NORMAL])[1]
            }

        elif cmdCode == '21':
            _result = data[6: 8]
            port_num = int(data[8:10], 16)
            port_info_urat_info = data[10:170]

            port_status_desc = {
                "01": "端口空闲",
                "02": "端口正在使用",
                "03": "端口禁用",
                "04": "端口故障",
            }

            port_info = {}
            for index in xrange(0, 160, 16):
                item = port_info_urat_info[index: index + 16]
                one_port = {}
                one_port["port"] = int(item[:2], 16)
                one_port["portStatus"] = item[2:4]
                # one_port["portStatusDesc"] = port_status_desc.get(item[2:4])
                one_port["leftTime"] = int(item[4:8], 16)
                one_port["power"] = int(item[8:12], 16)
                one_port["usedElec"] = int(item[12:16], 16) * 0.01  # 转换为度要因为DevicePortReport表中的elec为,乘以 0.01
                port_info[str(one_port["port"])] = one_port

            return {"cmdCode": cmdCode, "result": _result,  "portNum": port_num,
                    "portInfo": port_info, "sourceData": data}

        else:
            logger.info("receive data <{}>, cmd is invalid".format(data))


class CardEvent(WorkEvent):

    def do(self):
        if self.event_data['funCode'] == '10':
            self._do_get_balance()

    def _do_get_balance(self):
        RATIO_CONVERSION = 100

        smartbox = self.deviceAdapter  # type: ChargingXiaoKeDouBox

        cardNo = str(int(self.event_data["card_id"], 16))
        logger.info('[_do_get_balance] receive cardNo = {}'.format(cardNo))

        card = self.update_card_dealer_and_type(cardNo) # type: Card

        data = {"funCode": '10', "card_id":  self.event_data["card_id"], 'coins': 0} # 十六进制卡号

        dealer = self.device.owner

        # 无主卡或者是卡被冻结
        if not card or not card.openId or card.frozen or not dealer:
            logger.info('[_do_get_balance] receive cardNo = {}, card invalid!'.format(cardNo))
            data.update({"result": '02'})
            return self.send_mqtt(data=data)

        # 是否存在没有到账的余额 进行充值
        card_recharge_order = CardRechargeOrder.get_last_to_do_one(str(card.id))
        self.recharge_id_card(
            card=card,
            rechargeType='append',
            order=card_recharge_order
        )
        card.reload()

        ongoingList = getattr(card, 'ongoingList', [])  # 有冻结未结束的订单

        # 先不给做一张卡只能开启一单的限制
        if card.balance <= RMB(0) or ongoingList:
            logger.info('[_do_get_balance] receive cardNo = {}, card balance = {} not enough!'.format(cardNo, card.balance))
            data.update({"result": '01'})
            return self.send_mqtt(data=data)

        server_configs = smartbox.get_server_configs()
        onlineCardMinStartCoins = RMB(server_configs.get('onlineCardMinStartCoins', 0))
        onlineCardTime = server_configs.get('onlineCardTime', 720.0)   # 单位: 分钟
        onlineCardELec = server_configs.get('onlineCardELec', 3.0) # 单位: 度

        need_time = int(float(onlineCardTime))
        need_elec = int(float(onlineCardELec) * 100)

        data.update({
            'coins': int(RMB(card.balance) * 10),  # 单位: 角
            'need_time': need_time,
            'need_elec': need_elec,
            'attach_paras': {'openId': card.openId}
        })

        if float(self.device['driverVersion'].split('.')[-1]) <= 9:
            data.update({'account_rule': smartbox.get_account_rule()})
        else:
            data.update({'account_rule': smartbox.get_account_rule_new()})
            data['attach_paras'].update({'precision': 3600})

        if card.balance > onlineCardMinStartCoins:
            data.update({"result": '00'})

        else:
            data.update({"result": '01'})

        if self.device.bill_as_service_feature.on:
            serviceFee = int(self.device.bill_as_service_feature.service_charge * RATIO_CONVERSION)
            elecFee = int(self.device.bill_as_service_feature.elec_charge * RATIO_CONVERSION)
            data.update({"serviceFee": serviceFee,
                         "elecFee": elecFee,
                         "RATIO_CONVERSION": RATIO_CONVERSION,
                         "billingMethod": "billAsService"})

        self.send_mqtt(data=data)

    def send_mqtt(self, data=None, cmd=DeviceCmdCode.OPERATE_DEV_SYNC, otherData=None):
        '''
            发送mqtt 指令默认210  返回data
        '''
        result = MessageSender.send(self.device, cmd,
                                    data)
        if 'rst' in result and result['rst'] != 0:
            if result['rst'] == -1:
                raise ServiceException(
                    {'result': 2, 'description': u'该设备正在玩命找网络,请您稍候再试', 'rst': -1})
            elif result['rst'] == 1:
                raise ServiceException(
                    {'result': 2, 'description': u'该设备忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能', 'rst': 1})
        else:
            if cmd in [DeviceCmdCode.OPERATE_DEV_NO_RESPONSE, DeviceCmdCode.PASSTHROUGH_OPERATE_DEV_NO_RESPONSE]:
                return

            return result.get('data', 'ok')


class JNDZEventerFailure(FaultEvent):

    def do(self, **args):

        faultContent = self.event_data.get('faultContent', '')
        level = self.event_data.get('level', '')
        errCode = self.event_data.get('errCode')

        port = self.event_data.get('port')
        if port and port != 255:
            title = u'注意！您的设备{}号端口发出告警！'.format(port)
        else:
            title = u'注意！您的设备发出告警！'

        if errCode in ['A3']:  # 空载 无需显示在经销商后台
            return
        # else:
            # Device.update_dev_control_cache(self.device['devNo'], self.event_data)

        group = Group.get_group(self.device.groupId)

        if self.is_notify_dealer:
            self.notify_dealer(
                templateName="device_fault",
                title=title,
                device=u'{}-{}'.format(self.device.devTypeName, self.device.logicalCode),
                fault=faultContent,
                location=u'{address}-{groupName}-{groupNumber}号设备({logicalCode})'.format(address=group["address"],
                                                                                         groupName=group["groupName"],
                                                                                         groupNumber=self.device[
                                                                                             "groupNumber"],
                                                                                         logicalCode=self.device[
                                                                                             "logicalCode"]),
                notifyTime=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            )

        # 记录错误故障
        self.record(
            title=title,
            description=faultContent,
            level=level
        )


def is_server_refund(billingType, dev, dealer, agent):
    # type:(str, DeviceDict, Dealer, Agent)->bool

    if billingType != 'time':
        if 'jhCardElecRefund' in dealer.features:
            return False

        if dev.is_auto_refund:
            return True
        else:
            return False
    else:
        if 'huopo_card_time_refund' in agent.features:
            return True
        else:
            support_server_refund = dev.devType.get('features', {}).get(
                'support_server_refund', False)
            if not support_server_refund:
                return False

            if dev.is_auto_refund:
                return True
            else:
                return False


class StartAckEventPreProcessor(AckEventProcessorIntf):
    def analysis_reason(self, reason):
        FINISHED_CHARGE_REASON_MAP = {
            '00': u'购买的充电时间或者电量已经用完',
            '01': u'系统判断为异常断电（插头被拔或者松动，或者电瓶已经充满），电瓶车充电器种类繁多，可能存在误差',
            '02': u'电池已经充满',
            '03': u'警告！您的电池功率超过本机最大限制。为了公共安全，不建议您在该充电桩充电',
            '04': u'远程断电',
            '11': u'设备或是端口出现问题，被迫停止',

            # 服务器定义的停止事件
            '90': u'订单异常,设备使用期间可能存在离线时长超过一小时',
            '91': u'系统检测到充电已结束, 平台结单', # 主板轮询出来的停止(无结束上报)
            '92': u'管理员远程关闭订单',
            '95': u'继电器粘连、短路,停止充电',
            '96': u'空载,充电头脱落、充电器拔出',

            '97': u'用户远程手动停止订单',
            '98': u'您购买的时间已经用完了',
            '99': u'您购买的电量已经用完了',
            '100': u'金额已用完了',
            'EE': u'经销商强制结束',
        }
        return FINISHED_CHARGE_REASON_MAP.get(reason, '')

    def pre_processing(self, device, event_data):
        # type:(DeviceDict, dict)->dict
        
        source = json.dumps(event_data, indent=4)
        event_data['source'] = source
        
        if 'duration' in event_data and event_data['duration'] != 0:
            duration1 = event_data.get('duration')
            event_data['duration'] = round(duration1 / 60.0, 1)

            if 'fts' in event_data and 'sts' in event_data:
                duration2 = event_data['fts'] - event_data['sts']
                if abs(duration2 - duration1) < 300:
                    duration = max(duration1, duration2)
                    event_data['duration'] = round(duration / 60.0, 1)

        if 'elec' in event_data:
            elec = event_data.get('elec')
            event_data['elec'] = round(elec / 3600000.0, 3)

        if 'need_time' in event_data:
            event_data['needTime'] = event_data.pop('need_time') / 60.0

        if 'need_elec' in event_data:
            event_data['needElec'] = event_data.pop('need_elec') / 3600000.0

        if 'port' in event_data:
            pass

        if event_data['status'] == 'finished':
            event_data['reasonDesc'] = self.analysis_reason(event_data.get('reason', '91'))

            if 'need_pay' in event_data:
                precision = event_data.get('attach_paras', {}).get('precision', 1000.0)
                event_data['needPay'] = VirtualCoin(event_data.get('need_pay', 0) / (100.0 * precision)) # 单位(分 精度(老的设备为1000 新的设备为3600))

            if event_data.get('billingMethod') == 'prepaid' or event_data.get('billingMethod') == 'billAsService':
                if event_data.get('reason') in ['00', '98', '99']:
                    event_data['reasonDesc'] = '订购的套餐已用完'

        if 'sub' in event_data:
            pass


        return event_data


class ChargingJNDZReportEvent(WorkEvent):
    def do(self, **args):
        ctrInfo = Device.get_dev_control_cache(self.device.devNo)
        logger.info('ctrInfo:<{}>  upload_21:<{}>'.format(ctrInfo, self.event_data))


class MyComNetPayAckEvent(ComNetPayAckEvent):
    def __init__(self, smartBox, event_data):
        super(MyComNetPayAckEvent, self).__init__(smartBox, event_data, StartAckEventPreProcessor())

    def post_before_start(self, order=None):
    
        # 记录处理的源数据报文
        uart_source = getattr(order, 'uart_source', [])
        uart_source.append({
            'rece_running': self.event_data.get('source'),
            'time': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        })
        order.uart_source = uart_source
        order.save()

    def post_after_start(self, order=None):
        pass

    def post_before_finish(self, order=None):
    
        # 记录处理的源数据报文
        uart_source = getattr(order, 'uart_source', [])
        uart_source.append({
            'rece_finished': self.event_data.get('source'),
            'time': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        })
        order.uart_source = uart_source
        order.save()

    def post_after_finish(self, order=None):
        pass
    
    def merge_order(self, master_order, sub_orders):
        # type:(ConsumeRecord, list)->dict
        package = master_order.package
        needTime, needElec, coins = self.deviceAdapter._check_package(package)
        start_time = Arrow.fromdatetime(master_order.startTime, tzinfo=settings.TIME_ZONE)
        portDict = {'estimatedTs': int(start_time.timestamp + (needTime + 5) * 60)}

        if package.get('billingMethod') == CONSUMETYPE.POSTPAID or package.get('billingMethod') == CONSUMETYPE.BILL_AS_SERVICE_POSTPAID:
            portDict['needKind'] = 'needTime'
            portDict['needValue'] = needTime
            portDict['unit'] = u'分钟'

            portDict['coins'] = 0
            portDict['consumeType'] = package.get('billingMethod')
        else:
            unit = package.get('unit')
            portDict['coins'] = coins
            portDict['consumeType'] = CONSUMETYPE.MOBILE

            if unit == '度':
                portDict['needKind'] = 'needElec'
                portDict['needValue'] = needElec
            else:
                portDict['needKind'] = 'needTime'
                portDict['needValue'] = needTime

            for sub_order in sub_orders:
                needTime, needElec, coins = self.deviceAdapter._check_package(sub_order.package)
                portDict['coins'] += coins
                if unit == '度':
                    portDict['needValue'] += needElec
                else:
                    portDict['needValue'] += needTime


        return portDict
    
    # TODO 结束事件处理
    def do_finished_event(self, master_order, sub_orders, merge_order_info):
        # type: (ConsumeRecord, [ConsumeRecord], dict)->None

        if merge_order_info['consumeType'] == CONSUMETYPE.POSTPAID or merge_order_info['consumeType'] == CONSUMETYPE.BILL_AS_SERVICE_POSTPAID:
            self.do_postpaid_time_finished(master_order, sub_orders, merge_order_info)
        else:
            self.do_prepaid_time_finished(master_order, sub_orders, merge_order_info)

    @property
    def is_postpaid(self):
        return True

    def do_postpaid_time_finished(self, master_order, sub_orders=None, merge_order_info=None):
        duration = self.event_data.get('duration', 0)
        elec = self.event_data.get('elec', 0)

        # 做一个时间溢出的保护
        try:
            dealer = self.device.owner
            agent = Agent.objects.get(id=dealer.agentId)
            features = agent.features
            if 'time_overflow_protection' in features:
                if 'needKind' in merge_order_info and merge_order_info['needKind'] == 'needTime':
                    if abs(duration - merge_order_info['needValue']) <= 10:
                        duration = merge_order_info['needValue']
        except:
            pass

        needPay = self.event_data.get('needPay', 0)

        consumeDict = {
            'reason': self.event_data.get('reasonDesc'),
            'chargeIndex': str(master_order.used_port),
            DEALER_CONSUMPTION_AGG_KIND.DURATION: duration,
            DEALER_CONSUMPTION_AGG_KIND.ELEC: elec,
        }
        if self.device.bill_as_service_feature.on:
            ratio_conversion = self.event_data.get('ratio_conversion', 1)
            precision = self.event_data.get('precision', 3600)
            needPay = VirtualCoin(round(float(needPay) / ratio_conversion / 10, 2))
            serviceFee = round(self.event_data.get("service_fee", 0) / ratio_conversion / (1000.0 * precision), 2)
            elecFee = round(self.event_data.get("elec_fee", 0) / ratio_conversion / (1000.0 * precision), 2)
            consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.ELECFEE:elecFee})
            consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.SERVICEFEE:serviceFee})

        # 没有真正的结束, 等待状态机执行
        master_order.servicedInfo.update(consumeDict)

        logger.debug(
            'orderNo = {}, orderType = isPostpaid, usedTime = {}, needPayMoney = {}'.format(master_order.orderNo,
                                                                                            duration,
                                                                                            needPay))


        # 保护时间判断
        refundProtectionTime = int(self.device.otherConf.get('serverConfigs', {}).get('refundProtectionTime', 5))

        if duration < refundProtectionTime:
            needPay = VirtualCoin(0)

        #  先尝试用金币付款
        # 1 获取金币汇率
        coinRatio = float(self.device.otherConf.get('serverConfigs', {}).get('coinRatio', 1))

        # 2 更新订单金额
        master_order.coin = (needPay * coinRatio).mongo_amount
        master_order.money = needPay
        master_order.save()

        # 3 使用金币支付
        self.pay_order(master_order)

        master_order.reload()
        extra = [{u'使用详情': '{}号端口, {}(分钟)'.format(master_order.used_port, duration)}]
        if self.device.bill_as_service_feature.on:
            extra.append({
                u'电费金额': u'{}(金币)'.format(serviceFee),
                u'服务费金额': u'{}(金币)'.format(elecFee)
            })


        if master_order.status == ConsumeRecord.Status.FINISHED:

            if needPay == VirtualCoin(0):
                desc = ''

            else:
                if master_order.paymentInfo.get('via') == 'virtualCard':
                    desc = u'(已使用优惠卡券抵扣本次消费)'
                    master_order.update(coin=VirtualCoin(0), money=RMB(0))

                    # 结算完了进行退虚拟卡额度处理:
                    try:
                        if "rcdId" in master_order.paymentInfo:
                            consumeRcdId = master_order.paymentInfo['rcdId']
                        else:
                            consumeRcdId = master_order.paymentInfo['itemId']

                        vCardConsumeRcd = VCardConsumeRecord.objects.get(id=consumeRcdId)
                        vCard = UserVirtualCard.objects.get(id=vCardConsumeRcd.cardId)
                        vCard.refund_quota(vCardConsumeRcd, duration, 0.0, VirtualCoin(0).mongo_amount)
                    except:
                        pass

                else:
                    desc = u'(已使用账户余额自动结算本次消费)'

            extra.append({u'消费金额': u'{}(金币)'.format((needPay * coinRatio).mongo_amount)})
            if self.device.bill_as_service_feature.on:
                extra.append({
                    u'电费金额': u'{}(金币)'.format(serviceFee),
                    u'服务费金额': u'{}(金币)'.format(elecFee)
                })

        else:
            desc = u'(您的账户余额已不足以抵扣本次消费，请前往账单中心进行支付)'
            extra.append({u'消费金额': u'{}(元)'.format(master_order.money)})
            if self.device.bill_as_service_feature.on:
                extra.append({
                    u'电费金额': u'{}(金币)'.format(serviceFee),
                    u'服务费金额': u'{}(金币)'.format(elecFee)
                })

        extra.append({u'用户余额': u'{}(金币)'.format(master_order.user.calc_currency_balance(self.device.owner, self.device.group))})
        self.event_data['reasonDesc'] += desc

        self.notify_to_user(master_order.user.managerialOpenId, extra)

    def do_dealer_feature_processing(self, master_order):
        '''
            处理一些更具经销商特征要求显示或则隐藏的关于订单的信息
        '''
        pass

    def notify_to_user(self, openId, extra):
        group = Group.get_group(self.device['groupId'])
        self.notify_user_service_complete(
            service_name='充电',
            openid=openId,
            port='',
            address=group['address'],
            reason=self.event_data.get('reasonDesc'),
            finished_time=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra)

    def pay_order(self, order):
        order.status = 'running'
        order.attachParas['packageId'] = order.package.get('packageId')
        order.save()
        order.s_to_e()

    def do_prepaid_time_finished(self, master_order, sub_orders, merge_order_info):

        duration, elec = self.event_data.get('duration', 0), self.event_data.get('elec', 0)

        needKind = merge_order_info['needKind']
        needValue = merge_order_info['needValue']

        coins = VirtualCoin(merge_order_info['coins'])
        # 保护时间判断
        refundProtectionTime = int(self.device.otherConf.get('serverConfigs', {}).get('refundProtectionTime', 5))

        if duration <= refundProtectionTime:
            usedRatio = 0

        else:
            if not self.device.is_auto_refund: # 没有开启退费开关 直接退费
                usedRatio = 1

            else:
                if needKind == 'needTime':
                    # 做一个时间溢出的保护
                    duration = min(merge_order_info['needValue'], duration)
                    usedRatio = duration / (needValue * 1.0)

                else:
                    # 做一个电量溢出保护
                    elec = min(merge_order_info['needValue'], elec)
                    usedRatio = elec / (needValue * 1.0)

        usedFee = coins * usedRatio
        backCoins = coins - usedFee

        logger.debug(
            'orderNo = {}, orderType = isPostpaid, usedTime = {},coins = {}, usedFee = {}, backCoins = {}'.format(
                master_order.orderNo,
                duration, coins,
                usedFee, backCoins))


        user = master_order.user  # type: MyUser
        extra = [{u'使用详情': '{}号端口, {}(分钟)'.format(master_order.used_port, duration)}]

        if self.device.bill_as_service_feature.on:
            ratio_conversion = self.event_data.get('ratio_conversion', 1)
            precision = self.event_data.get('precision', 3600)
            serviceFee = round(self.event_data.get("service_fee", 0) / ratio_conversion / (1000.0 * precision), 2)
            elecFee = round(self.event_data.get("elec_fee", 0) / ratio_conversion / (1000.0 * precision), 2)
            extra.append({
                u'电费金额': u'{}(金币)'.format(serviceFee),
                u'服务费金额': u'{}(金币)'.format(elecFee)
            })

        if master_order.paymentInfo['via'] == 'free':
            extra.append({u'消费金额': u'当前设备免费使用'})

        elif master_order.paymentInfo['via'] in ['netPay', 'coins', 'cash', 'coin']:

            all_money = RMB(0)
            all_refund_money = RMB(0)
            orders = [master_order] + sub_orders
            refundCash = 'refundRMB_device_event' in self.device.owner.features

            for _order in orders[::-1]:
                consumeDict = {
                    'reason': self.event_data.get('reasonDesc'),
                    'chargeIndex': str(master_order.used_port),
                }

                need_back_coins, need_consume_coins, backCoins = self._calc_refund_info(backCoins, _order.coin)

                rechargeRcdId = _order.attachParas.get('linkedRechargeRecordId', '')

                if rechargeRcdId != '':
                    rechargeRcd = RechargeRecord.objects.filter(id=rechargeRcdId, isQuickPay=True).first()
                else:
                    rechargeRcd = None

                if refundCash and rechargeRcd:  # 退现金特征 + 有充值订单
                    # 退现金部分
                    user.clear_frozen_balance(str(_order.id), _order.paymentInfo['deduct'],
                                              back_coins=VirtualCoin(0),
                                              consume_coins=VirtualCoin(_order.coin))

                    refundRMB = rechargeRcd.money * (float(need_back_coins) / float(_order.coin))

                    self.refund_net_pay(user, {'rechargeRcdId': rechargeRcdId, 'openId': user.openId},
                                        refundRMB, VirtualCoin(0), consumeDict, True)

                    all_money += RMB(rechargeRcd.money)
                    all_refund_money += RMB(refundRMB)

                else:

                    user.clear_frozen_balance(str(_order.id), _order.paymentInfo['deduct'], back_coins=need_back_coins,
                                              consume_coins=need_consume_coins)

                    consumeDict.update({
                        DEALER_CONSUMPTION_AGG_KIND.COIN: _order.coin.mongo_amount,
                        DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS: need_back_coins.mongo_amount})

                if _order.orderNo == master_order.orderNo:
                    consumeDict.update({
                        DEALER_CONSUMPTION_AGG_KIND.DURATION: duration,
                        DEALER_CONSUMPTION_AGG_KIND.ELEC: elec,
                    })
                    if self.device.bill_as_service_feature.on:
                        consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.ELECFEE: elecFee})
                        consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.SERVICEFEE: serviceFee})
                _order.update_service_info(consumeDict)

            if refundCash and all_money > RMB(0):
                extra.append({u'消费金额': '{}元'.format(all_money - all_refund_money)})
                if all_refund_money > RMB(0):
                    extra.append({u'退款金额': '{}元'.format(all_refund_money)})
            else:
                extra.append({u'消费金额': '{}金币'.format(usedFee)})
                if (coins - usedFee) > VirtualCoin(0):
                    extra.append({u'退款金额': '{}金币(当充电金币数量大于或等于扫码充电金额时可抵现金，金币不可提现)'.format(coins - usedFee)})

            self.notify_to_user(master_order.user.managerialOpenId, extra)

        else:
            logger.error('not net pay rather user virtual card pay. something is wrong.')
            return


    def _calc_refund_info(self, backCoins, orderCoin):

        if backCoins >= orderCoin:
            need_back_coins = orderCoin
            need_consume_coins = VirtualCoin(0)
            backCoins -= orderCoin
        else:
            need_back_coins = backCoins
            need_consume_coins = orderCoin - need_back_coins
            backCoins = VirtualCoin(0)

        return need_back_coins, need_consume_coins, backCoins


class MyIcStartAckEvent(IcStartAckEvent):
    def __init__(self, smartBox, event_data):
        super(MyIcStartAckEvent, self).__init__(smartBox, event_data, StartAckEventPreProcessor())

    def post_after_start(self, order=None):
        pass

    def post_after_finish(self, order=None):
        pass

    def merge_order(self, master_order, sub_orders):
        # type:(ConsumeRecord, list)->dict

        consumeModule = self.device.get('otherConf', dict()).get('consumeModule', 0)

        # 按时间计费
        if consumeModule == 0:
            billingType = 'time'
        else:
            billingType = 'elec'

        start_time = Arrow.fromdatetime(master_order.startTime, tzinfo=settings.TIME_ZONE)

        portDict = {
            'billingType': billingType
        }

        if master_order.paymentInfo['via'] == 'virtualCard':
            portDict.update({
                'vCardId': master_order.paymentInfo['itemId']
            })

        all_coins = master_order.coin
        all_money = master_order.money

        for sub_order in sub_orders:
            all_coins += sub_order.coin
            all_money += sub_order.money

        portDict['coins'] = str(all_coins)
        portDict['money'] = str(all_money)

        portDict['estimatedTs'] = int(start_time.timestamp + 12 * 60 * 60)

        return portDict

    def do_time_finished(self, card, order, merge_order_info):
        # type: (Card, ConsumeRecord, dict)->None

        duration, elec = self.event_data['duration'], self.event_data['elec']

        coins = VirtualCoin(merge_order_info['coins'])

        left = self.event_data['left']

        consumeDict = {
            'reason': self.event_data['reason'],
            'chargeIndex': str(order.used_port),
            'duration': duration,
            'elec': elec,
            'elecFee': self.deviceAdapter.calc_elec_fee(elec)
        }

        # backMoney = VirtualCoin(self.event_data['backMoney'])

        group = self.device.group  # type: GroupDict

        extra = [{
            u'实体卡号': self.event_data['cardNo']
        }]

        consumeDict.update({'balance': str(card.balance)})

        order.update_service_info(consumeDict)

        self.notify_user_service_complete(
            service_name='充电',
            openid=card.managerialOpenId if card else '',
            port=order.used_port,
            address=group.address,
            reason=self.event_data['reason'],
            finished_time=order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra)

    def do_elec_finished(self, card, order, merge_order_info):
        # type:(Card, ConsumeRecord, dict)->None

        '''
        电川的板子 按电量退费
        :return:
        '''

        leftElec = self.event_data.get('left', 0) / 100.0

        duration, elec = self.event_data['duration'], self.event_data['elec']

        try:
            consumeDict = {
                'reason': self.event_data['reasonDesc'],
                'chargeIndex': order.used_port,
                'duration': duration,
                'elec': elec,
                'elecFee': self.deviceAdapter.calc_elec_fee(elec)
            }

            # backMoney = self.event_data.get('backMoney')

            extra = [{u'实体卡号': self.event_data['cardNo']}]

            # if self.event_data['cardType'] == 'ID':
            #     if backMoney > 0:
            #         self.refund_money_for_card(RMB(backMoney), card.id)
            #         extra.append({
            #             u'退款金额': u'{}(金币)'.format(backMoney)
            #         })
            #
            #     consumeDict.update({'balance': str(card.balance + VirtualCoin(self.event_data['backMoney']))})
            # else:
            consumeDict.update({'balance': str(card.balance)})

            order.update_service_info(consumeDict)

            self.notify_user_service_complete(
                service_name='充电',
                openid=self.get_managerialOpenId_by_openId(order.openId),
                port=order.used_port,
                address=self.device.group.address,
                reason=self.event_data['reason'],
                finished_time=order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'),
                extra=extra)
        except Exception as e:
            logger.exception(e)

    def do_finished_event(self, card, order, merge_order_info):
        # type:(Card, ConsumeRecord, dict)->None

        if 'backMoney' in self.event_data and self.event_data['backMoney'] > RMB(0):
            refund_order = RechargeRecord.objects(orderNo=self.event_data['order_id']).first()
            if not refund_order:
                self.refund_money_for_card(RMB(self.event_data['backMoney']), card.id, self.event_data['order_id'])

        billing_type = merge_order_info['billingType']
        if billing_type == 'time':
            self.do_time_finished(card, order, merge_order_info)
        else:
            self.do_elec_finished(card, order, merge_order_info)


class MyIcRechargeAckEvent(IcRechargeAckEvent):
    def __init__(self, smartBox, event_data):
        super(MyIcRechargeAckEvent, self).__init__(smartBox, event_data, StartAckEventPreProcessor())


class MyCardRefundAckEvent(CardRefundAckEvent):
    def __init__(self, smartBox, event_data):
        super(MyCardRefundAckEvent, self).__init__(smartBox, event_data, CardRefundAckEventPreProcessor())


class CardRefundAckEventPreProcessor(AckEventProcessorIntf):
    def pre_processing(self, device, event_data):
        # type:(DeviceDict, dict)->dict

        if 'cardType' in event_data:
            if event_data['cardType'] == 'AA33':
                event_data['cardType'] = 'ID'
            else:
                event_data['cardType'] = 'IC'

        if 'cardNo' in event_data:
            event_data['cardNo'] = str(event_data['cardNo'])

        event_data['backMoney'] = (int(event_data['backMoney']) / 10.0)

        return event_data


class IdStartAckEventPreProcessor(AckEventProcessorIntf):
    def analysis_reason(self, reason):
        FINISHED_CHARGE_REASON_MAP = {
            '00': u'购买的充电时间或者电量已经用完',
            '01': u'系统判断为异常断电（插头被拔或者松动，或者电瓶已经充满），电瓶车充电器种类繁多，可能存在误差',
            '02': u'电池已经充满',
            '03': u'警告！您的电池功率超过本机最大限制。为了公共安全，不建议您在该充电桩充电',
            '04': u'远程断电',
            '11': u'设备或是端口出现问题，被迫停止',

            # 服务器定义的停止事件
            '90': u'订单异常,设备使用期间可能存在离线时长超过一小时',
            '91': u'主板异常停止,未知错误',  # 主板轮询出来的停止(无结束上报)
            '92': u'管理员远程关闭订单',
            '95': u'继电器粘连、短路,停止充电',
            '96': u'空载,充电头脱落、充电器拔出',

            '97': u'用户远程手动停止订单',
            '98': u'您购买的时间已经用完了',
            '99': u'您购买的电量已经用完了',
            'EE': u'经销商强制结束',
        }
        return FINISHED_CHARGE_REASON_MAP.get(reason)

    def pre_processing(self, device, event_data):
        # type:(DeviceDict, dict)->dict

        source = json.dumps(event_data, indent=4)
        event_data['source'] = source

        if 'duration' in event_data and event_data['duration'] != 0:
            duration = event_data.get('duration')
            event_data['duration'] = round(duration / 60.0, 1)

        if 'fts' in event_data and 'sts' in event_data:
            duration = event_data['fts'] - event_data['sts']
            event_data['duration'] = round(duration / 60.0, 1)

        if 'elec' in event_data:
            elec = event_data.get('elec')
            event_data['elec'] = round(elec / 3600000.0, 3)

        if 'need_time' in event_data:
            event_data['needTime'] = event_data.pop('need_time') / 60.0

        if 'need_elec' in event_data:
            event_data['needElec'] = event_data.pop('need_elec') / 3600000.0

        if 'port' in event_data:
            pass

        if event_data['status'] == 'finished':
            event_data['reasonDesc'] = self.analysis_reason(event_data.get('reason', '91'))

            if 'need_pay' in event_data:
                precision = event_data.get('attach_paras', {}).get('precision', 1000.0)
                event_data['needPay'] = VirtualCoin(
                    event_data.get('need_pay', 0) / (100.0 * precision))  # 单位(分 精度(老的设备为1000 新的设备为3600

        if 'sub' in event_data:
            subs = event_data.get('sub', [])
            for item in subs:
                if 'need_time' in event_data:
                    event_data['needTime'] = item.pop('need_time')

                if 'need_elec' in event_data:
                    event_data['needElec'] = item.pop('need_elec')

        if 'card_id' in event_data:
            event_data['cardNo'] = str(int(event_data.get('card_id'), 16))
            event_data['fee'] = 0.0


        return event_data


class MyIdStartAckEvent(IdStartAckEvent):
    def __init__(self, smartBox, event_data):
        super(MyIdStartAckEvent, self).__init__(smartBox, event_data, IdStartAckEventPreProcessor())

    def post_before_finish(self, order=None):
        # 记录处理的源数据报文
        uart_source = getattr(order, 'uart_source', [])
        uart_source.append({
            'rece_finished': self.event_data.get('source'),
            'time': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        })
        order.uart_source = uart_source
        order.save()

    def post_after_start(self, order=None):
        # 通知用户，已经扣费
        title = make_title_from_dict([
            {u'设备地址': u'{}'.format(self.device.group.address)},
            {u'设备编号': u'{}'.format(self.device['logicalCode'])},
            {u'实体卡': u'{}--No:{}'.format(self.card.cardName or self.card.nickName, self.card.cardNo)},
        ])

        start_time_stamp = self.event_data.get('sts', time.time())
        start_time = datetime.datetime.fromtimestamp(start_time_stamp)

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

    def post_after_finish(self, order=None):
        pass

    def merge_order(self, master_order, sub_orders):
        # type:(ConsumeRecord, list)->dict

        billingType = self.device.get('otherConf', dict()).get('billingType', 'time')

        start_time = Arrow.fromdatetime(master_order.startTime, tzinfo=settings.TIME_ZONE)

        portDict = {
            'billingType': billingType,
            'consumeType': 'postpaid'
        }
        if self.device.bill_as_service_feature.on:
            billingType = 'elec'
            portDict.update({
                'billingType': billingType,
                'consumeType': "billAsServicePostpaid"
            })

        all_coins = master_order.coin
        all_money = master_order.money
        all_consume_time = self.event_data.get('needTime', 0)
        all_consume_elec = self.event_data.get('needElec', 0)

        for sub_order in sub_orders:
            all_coins += sub_order.coin
            all_money += sub_order.money

        if self.event_data.get('sub', []):
            for _ in self.event_data['sub']:
                all_consume_time += _.get('needTime', 0)
                all_consume_elec += _.get('needElec', 0)

        portDict['coins'] = str(all_coins)
        portDict['money'] = str(all_money)

        if billingType == 'time':
            portDict['needKind'] = 'needTime'
            portDict['needValue'] = all_consume_time
            portDict['unit'] = u'分钟'
            portDict['estimatedTs'] = int(start_time.timestamp + all_consume_time * 60)

        elif billingType == 'elec':
            portDict['needKind'] = 'needElec'
            portDict['needValue'] = round(all_consume_elec / 100.0, 2)
            portDict['unit'] = u'度'
            portDict['estimatedTs'] = int(start_time.timestamp + 12 * 60 * 60)

        else:
            pass

        return portDict

    def do_time_finished(self, order, merge_order_info):
        # type: (ConsumeRecord, dict)->None

        duration, elec = self.event_data['duration'], self.event_data['elec']

        coins = VirtualCoin(merge_order_info['coins'])

        left = self.event_data['leftTime']

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

        dealer = Dealer.objects(id=group['ownerId']).first()
        if not dealer:
            logger.error('dealer is not found, dealerId=%s' % group['ownerId'])
            return

        agent = Agent.objects(id=dealer.agentId).first()
        if not agent:
            logger.error('agent is not found, agentId=%s' % dealer.agentId)
            return

        consumeDict = {
            'reason': self.event_data['reason'],
            'chargeIndex': str(order.used_port),
            'duration': duration,
            'elec': elec,
            'cardNo': self.event_data['cardNo'],
            'elecFee': self.deviceAdapter.calc_elec_fee(elec)
        }

        auto_refund = self.device.is_auto_refund
        refundProtectionTime = int(self.device['otherConf'].get('serverConfigs', {}).get('refundProtectionTime', 5))

        logger.debug('{} auto refund enable switch is {}. refund protect time = {}'.format(
            repr(self.device), str(auto_refund), refundProtectionTime))

        if left > merge_order_info['needValue']:
            left = merge_order_info['needValue']

        real_back_coins = coins * Ratio(float(left) / float(merge_order_info['needValue']))

        if auto_refund:
            if duration < refundProtectionTime:
                backMoney = coins
            else:
                backMoney = real_back_coins
        else:
            backMoney = VirtualCoin(0)

        if backMoney and backMoney > RMB(0):
            if is_server_refund('time', self.device, dealer, agent):
                logger.info(
                    'ready to server refund money <{}> for user card <{}> in device<{}>'.format(
                        backMoney,
                        str(self.card.id),
                        self.device.devNo))

            consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.REFUND_CARD: backMoney.mongo_amount})

            self.refund_money_for_card(backMoney, self.card.id, order.orderNo)

            self.notify_user(self.card.managerialOpenId, 'refund_coins', **{
                'title': u'退币完成！您的卡号是%s,卡别名:%s' % (self.card.cardNo, self.card.nickName),
                'backCount': u'金币：%s' % backMoney,
                'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            })

        extra = [{
            u'实体卡号': self.event_data['cardNo']
        }]

        order.update_service_info(consumeDict)

        self.notify_user_service_complete(
            service_name='充电',
            openid=self.card.managerialOpenId if self.card else '',
            port=order.used_port,
            address=group.address,
            reason=self.event_data['reasonDesc'],
            finished_time=order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra)

    def do_elec_finished(self, order, merge_order_info):
        # type:(ConsumeRecord, dict)->None

        '''
        电川的板子 按电量退费
        :return:
        '''

        leftElec = self.event_data.get('leftElec', 0)

        duration, elec = self.event_data['duration'], self.event_data['elec']

        coins = VirtualCoin(merge_order_info['coins'])
        group = Group.get_group(self.device['groupId'])

        dealer = Dealer.objects(id=group['ownerId']).first()
        if not dealer:
            logger.error('dealer is not found, dealerId=%s' % group['ownerId'])
            return

        agent = Agent.objects(id=dealer.agentId).first()
        if not agent:
            logger.error('agent is not found, agentId=%s' % dealer.agentId)
            return

        try:
            consumeDict = {
                'reason': self.event_data['reasonDesc'],
                'chargeIndex': order.used_port,
                'duration': duration,
                'elec': elec,
                'elecFee': self.deviceAdapter.calc_elec_fee(elec)
            }

            if leftElec > merge_order_info['needValue']:
                leftElec = merge_order_info['needValue']

            backMoney = coins * Ratio(leftElec / merge_order_info['needValue'])

            if backMoney and backMoney > RMB(0):
                if is_server_refund('elec', self.device, dealer, agent):
                    logger.info(
                        'ready to server refund money <{}> for user card <{}> in device<{}>'.format(
                            backMoney,
                            str(self.card.id),
                            self.device.devNo))

                consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.REFUND_CARD: backMoney.mongo_amount})

                self.refund_money_for_card(backMoney, self.card.id, order.orderNo)

                self.notify_user(self.card.managerialOpenId, 'refund_coins', **{
                    'title': u'退币完成！您的卡号是%s,卡别名:%s' % (self.card.cardNo, self.card.nickName),
                    'backCount': u'金币：%s' % backMoney,
                    'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                })

            extra = [{u'实体卡号': self.event_data['cardNo']}]

            consumeDict.update({'balance': str(self.card.balance)})

            order.update_service_info(consumeDict)

            self.notify_user_service_complete(
                service_name='充电',
                openid=self.get_managerialOpenId_by_openId(order.openId),
                port=order.used_port,
                address=self.device.group.address,
                reason=self.event_data['reasonDesc'],
                finished_time=order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'),
                extra=extra)
        except Exception as e:
            logger.exception(e)

    def do_finished_event(self, order, merge_order_info):
        # type:(ConsumeRecord, dict)->None


        self.do_postpaid_time_finished(order, merge_order_info)

    def do_postpaid_time_finished(self, master_order, merge_order_info):
        extra = []
        duration = self.event_data.get('duration', 0)
        elec = self.event_data.get('elec', 0)
        needPay = self.event_data.get('needPay', 0)

        consumeDict = {
            'reason': self.event_data.get('reasonDesc'),
            'chargeIndex': str(master_order.used_port),
            DEALER_CONSUMPTION_AGG_KIND.DURATION: duration,
            DEALER_CONSUMPTION_AGG_KIND.ELEC: elec,
        }

        if self.device.bill_as_service_feature.on:
            ratio_conversion = self.event_data.get('ratio_conversion', 100)
            precision = self.event_data.get('precision', 3600)
            needPay = VirtualCoin(round(float(needPay) / ratio_conversion / 10, 2))
            serviceFee = round(self.event_data.get("service_fee", 0) / ratio_conversion / (1000.0 * precision), 2)
            elecFee = round(self.event_data.get("elec_fee", 0) / ratio_conversion / (1000.0 * precision), 2)
            consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.ELECFEE: elecFee})
            consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.SERVICEFEE: serviceFee})
            extra.append({
                u'电费金额': u'{}(金币)'.format(serviceFee),
                u'服务费金额': u'{}(金币)'.format(elecFee)
            })

        logger.debug(
            'orderNo = {}, orderType = isPostpaid, usedTime = {}, needPayMoney = {}'.format(master_order.orderNo,
                                                                                            duration,
                                                                                            needPay))


        # 保护时间判断
        refundProtectionTime = int(self.device.otherConf.get('serverConfigs', {}).get('refundProtectionTime', 5))

        if duration < refundProtectionTime:
            needPay = VirtualCoin(0)


        master_order.coin = needPay
        master_order.money = needPay
        master_order.save()

        # 3 使用金币支付()
        self.pay_by_card(master_order)

        self.card.reload()

        extra.append({u'使用详情': '{}号端口, {}(分钟)'.format(master_order.used_port, duration)})

        consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.CONSUME_CARD: master_order.coin.mongo_amount})

        master_order.update_service_info(consumeDict)

        extra.append({u'消费金额': u'{}(金币)'.format(needPay.mongo_amount)})
        if self.card.balance >= RMB(0):
            extra.append({u'卡余额': u'{}(金币)'.format(self.card.balance)})
        else:
            extra.append({u'卡余额': u'已欠费{}(金币)'.format(abs(self.card.balance))})

        self.notify_to_user(self.card.managerialOpenId, extra)

    def notify_to_user(self, openId, extra):
        group = Group.get_group(self.device['groupId'])
        self.notify_user_service_complete(
            service_name='充电',
            openid=openId,
            port=self.event_data.get('port'),
            address=group['address'],
            reason=self.event_data.get('reasonDesc'),
            finished_time=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra)

    def checkout_order(self, order):
        #冻结卡不让其他设备使用
        self.card.freeze_balance(str(order.id), VirtualCoin(0))
        self.card.reload()

    def pay_by_card(self, order):
        # 1 接触冻结状态
        self.card.clear_frozen_balance(str(order.id), VirtualCoin(0))
        # 2 扣除费用
        self.card.update(dec__balance=round(order.coin, 2))


class MyVirtualCardStartAckEvent(VirtualCardStartAckEvent):
    def __init__(self, smartBox, event_data):
        super(MyVirtualCardStartAckEvent, self).__init__(smartBox, event_data, StartAckEventPreProcessor())

    def post_after_start(self, order=None, card=None):
        pass

    def post_after_finish(self, order=None):
        pass

    def merge_order(self, master_order, sub_orders):
        # type:(ConsumeRecord, list)->dict

        billingType = self.device.get('otherConf', dict()).get('billingType', 'time')

        start_time = Arrow.fromdatetime(master_order.startTime, tzinfo=settings.TIME_ZONE)

        portDict = {
            'billingType': billingType
        }

        all_coins = master_order.coin
        all_money = master_order.money
        all_consume_time = self.event_data.get('needTime', 0)
        all_consume_elec = self.event_data.get('needElec', 0)

        if self.event_data.get('sub', []):
            for _ in self.event_data['sub']:
                all_consume_time += _.get('needTime', 0)
                all_consume_elec += _.get('needElec', 0)

        portDict['coins'] = str(all_coins)
        portDict['money'] = str(all_money)

        if billingType == 'time':
            portDict['needKind'] = 'needTime'
            portDict['needValue'] = all_consume_time
            portDict['unit'] = u'分钟'
            portDict['estimatedTs'] = int(start_time.timestamp + all_consume_time * 60)
        elif billingType == 'elec':
            portDict['needKind'] = 'needElec'
            portDict['needValue'] = round(all_consume_elec / 100.0, 2)
            portDict['unit'] = u'度'
            portDict['estimatedTs'] = int(start_time.timestamp + 12 * 60 * 60)
        else:
            pass

        return portDict

    def checkout_order(self, order):
        group = Group.get_group(self.device.groupId)  # type:GroupDict
        freeze_user_balance(self.device, group, order, self.virtualCard)

    def do_time_finished(self,  order, sub_orders, merge_order_info):
        # type: (ConsumeRecord, list, dict)->None

        duration, elec = self.event_data['duration'], self.event_data['elec']

        consumeDict = {
            'reason': self.event_data['reasonDesc'],
            'chargeIndex': str(order.used_port),
            'duration': duration,
            'elec': elec,
            'cardNo': self.event_data['cardNo'],
            'elecFee': self.deviceAdapter.calc_elec_fee(elec)
        }

        auto_refund = self.device.is_auto_refund
        refundProtectionTime = int(self.device['otherConf'].get('serverConfigs', {}).get('refundProtectionTime', 5))

        logger.debug('{} auto refund enable switch is {}. refund protect time = {}'.format(
            repr(self.device), str(auto_refund), refundProtectionTime))

        if auto_refund:
            order_need_time = order.package.get('time')

            if order_need_time >= duration:
                usedTime = duration
                duration = 0
            else:
                usedTime = order_need_time
                duration -= order_need_time

            success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(transaction_id=str(order.id),
                                                                                    usedTime=usedTime, spendElec=0,
                                                                                    backCoins=VirtualCoin(
                                                                                        0).mongo_amount)

            self.insert_vCard_consume_record(self.virtualCard, order, success, consumeTotal, consumeDay)

            for sub_order in sub_orders:

                order_need_time = sub_order.package.get('time')

                if order_need_time >= duration:
                    usedTime = duration
                    duration = 0
                else:
                    usedTime = order_need_time
                    duration -= order_need_time

                success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(
                    transaction_id=str(sub_order.id),
                    usedTime=usedTime, spendElec=0,
                    backCoins=VirtualCoin(0).mongo_amount)

                self.insert_vCard_consume_record(self.virtualCard, sub_order, success, consumeTotal, consumeDay)

        else:
            order_need_time = order.package.get('time')
            success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(transaction_id=str(order.id),
                                                                                    usedTime=order_need_time,
                                                                                    spendElec=0,
                                                                                    backCoins=VirtualCoin(
                                                                                        0).mongo_amount)

            self.insert_vCard_consume_record(self.virtualCard, order, success, consumeTotal, consumeDay)

            for sub_order in sub_orders:
                order_need_time = sub_order.package.get('time')
                success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(
                    transaction_id=str(sub_order.id),
                    usedTime=order_need_time, spendElec=0,
                    backCoins=VirtualCoin(0).mongo_amount)

                self.insert_vCard_consume_record(self.virtualCard, sub_order, success, consumeTotal, consumeDay)

        group = self.device.group  # type: GroupDict

        extra = [{
            u'虚拟卡号': self.virtualCard.cardNo
        }]

        order.update_service_info(consumeDict)

        self.notify_user_service_complete(
            service_name='充电',
            openid=self.card.managerialOpenId if self.card else '',
            port=order.used_port,
            address=group.address,
            reason=self.event_data['reasonDesc'],
            finished_time=order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra)

    def do_elec_finished(self, order, sub_orders, merge_order_info):
        # type:(ConsumeRecord, list, dict)->None

        duration, elec = self.event_data['duration'], self.event_data['elec']

        consumeDict = {
            'reason': self.event_data['reasonDesc'],
            'chargeIndex': str(order.used_port),
            'duration': duration,
            'elec': elec,
            'cardNo': self.event_data['cardNo'],
            'elecFee': self.deviceAdapter.calc_elec_fee(elec),
        }

        auto_refund = self.device.is_auto_refund
        refundProtectionTime = int(self.device['otherConf'].get('serverConfigs', {}).get('refundProtectionTime', 5))

        logger.debug('{} auto refund enable switch is {}. refund protect time = {}'.format(
            repr(self.device), str(auto_refund), refundProtectionTime))

        if auto_refund:
            order_need_time = order.package.get('time')

            if order_need_time >= elec:
                usedTime = duration
                duration = 0
            else:
                usedTime = order_need_time
                elec -= order_need_time

            success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(transaction_id=str(order.id),
                                                                                    usedTime=usedTime, spendElec=0,
                                                                                    backCoins=VirtualCoin(
                                                                                        0).mongo_amount)

            self.insert_vCard_consume_record(self.virtualCard, order, success, consumeTotal, consumeDay)

            for sub_order in sub_orders:

                order_need_time = order.package.get('time')

                if order_need_time >= duration:
                    usedTime = duration
                    duration = 0
                else:
                    usedTime = order_need_time
                    duration -= order_need_time

                success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(
                    transaction_id=str(sub_order.id),
                    usedTime=usedTime, spendElec=0,
                    backCoins=VirtualCoin(0).mongo_amount)

                self.insert_vCard_consume_record(self.virtualCard, sub_order, success, consumeTotal, consumeDay)
        else:
            order_need_time = order.package.get('time')
            success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(
                transaction_id=str(order.id),
                usedTime=order_need_time, spendElec=0,
                backCoins=VirtualCoin(
                    0).mongo_amount)

            self.insert_vCard_consume_record(self.virtualCard, order, success, consumeTotal, consumeDay)

            for sub_order in sub_orders:
                order_need_time = sub_order.package.get('time')
                success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(
                    transaction_id=str(sub_order.id),
                    usedTime=order_need_time, spendElec=0,
                    backCoins=VirtualCoin(0).mongo_amount)

                self.insert_vCard_consume_record(self.virtualCard, sub_order, success, consumeTotal, consumeDay)

        extra = [{
            u'虚拟卡号': self.virtualCard.cardNo
        }]

        order.update_service_info(consumeDict)

        self.notify_user_service_complete(
            service_name='充电',
            openid=self.get_managerialOpenId_by_openId(order.openId),
            port=order.used_port,
            address=self.device.group.address,
            reason=self.event_data['reason'],
            finished_time=order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra)

    def do_finished_event(self,  order, sub_orders, merge_order_info):
        # type:(ConsumeRecord, list, dict)->None

        billing_type = merge_order_info['billingType']
        if billing_type == 'time':
            self.do_time_finished(order, sub_orders, merge_order_info)
        else:
            self.do_elec_finished(order, sub_orders, merge_order_info)

    def insert_vCard_consume_record(self, vCard, order, success, consumeTotal, consumeDay):
        try:
            if success and consumeDay['count'] > 0:
                record = VCardConsumeRecord(
                    orderNo=VCardConsumeRecord.make_no(order.logicalCode),
                    openId=order.openId,
                    nickname=order.nickname,
                    cardId=str(vCard.id),
                    dealerId=vCard.dealerId,
                    devNo=order.devNo,
                    devTypeCode = self.device.devTypeCode,
                    devTypeName = self.device.devTypeName,
                    logicalCode=order.logicalCode,
                    groupId=order.groupId,
                    address=order.address,
                    groupNumber=order.groupNumber,
                    groupName=order.groupName,
                    attachParas=order.attachParas,
                    consumeData=consumeTotal,
                    consumeDayData=consumeDay
                )
                record.save()
        except Exception as e:
            logger.exception(e)