manyi/apps/web/eventer/weifuleCommon.py

# -*- coding: utf-8 -*-
# !/usr/bin/env python
import datetime
import json
import logging
import time
import traceback

from typing import TYPE_CHECKING, Optional, Tuple

from apilib.monetary import VirtualCoin, RMB, Ratio
from apilib.utils_string import make_title_from_dict
from apps.web.constant import Const, START_DEVICE_STATUS, DEALER_CONSUMPTION_AGG_KIND
from apps.web.core.accounting import Accounting
from apps.web.device.models import Device, GroupDict, Group, DeviceDict
from apps.web.device.timescale import FluentedEngine
from apps.web.eventer.base import WorkEvent
from apps.web.exceptions import UnifiedConsumeOrderError
from apps.web.user.constant2 import StartDeviceType
from apps.web.user.models import ConsumeRecord, UserVirtualCard, MonthlyPackage, ServiceProgress, CardRechargeOrder, \
    Card, CardConsumeRecord, RechargeRecord, RefundMoneyRecord, VCardConsumeRecord
from apps.web.user.utils2 import generate_card_payment, ConsumeOrderStateEngine, UnifiedCardConsumeOrderManager
from apps.web.utils import set_start_key_status

logger = logging.getLogger(__name__)

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

if TYPE_CHECKING:
    pass


class WeiFuLeStatusEvent(WorkEvent):

    def do(self, **args):
        return self._do_update_charge_status()

    def __translate_status_from_str(self, status):
        dictConf = {
            'idle': Const.DEV_WORK_STATUS_IDLE,
            'busy': Const.DEV_WORK_STATUS_WORKING,
            'forbid': Const.DEV_WORK_STATUS_FORBIDDEN,
            'fault': Const.DEV_WORK_STATUS_FAULT,
            'running': Const.DEV_WORK_STATUS_WORKING,
            'link': Const.DEV_WORK_STATUS_CONNECTED,
            'estop': Const.DEV_WORK_STATUS_ESTOP,
            'ready': Const.DEV_WORK_STATUS_READY,

        }
        return dictConf.get(status, Const.DEV_WORK_STATUS_FAULT)

    def _do_update_charge_status(self):

        def do_flush():
            ctrInfo = Device.get_dev_control_cache(self.device.devNo)

            for port, status in port_status.items():
                if str(port) in ctrInfo:
                    ctrInfo[str(port)]['status'] = self.__translate_status_from_str(status)
                else:
                    ctrInfo[str(port)] = {'status': self.__translate_status_from_str(status)}

            Device.update_dev_control_cache(self.device.devNo, ctrInfo)

        source = self.event_data
        data = source.get('data', {})
        upTime = source.get('time')
        port_status = self.parse_status(data)

        if not upTime or not port_status:
            return

        import time
        now = time.time()

        need_flush = bool((now - upTime) < 10)  # 半分钟以内的状态上报为有效上报

        if not need_flush:
            logger.info('Timeout status report!')
            return

        do_flush()

    def parse_status(self, data):
        return data.get('port_status', {})


class WeiFuLeCommonEvent(object):

    def pay_apps_start_by_32(self, order, callbackSP=None):
        """
            此函数会对订单进行扣款(补扣或者抢锁扣款,依据上报的事件)
            一般callbackSP为创建服务进程函数

        """
        consumeRcd = ConsumeRecord.objects.filter(orderNo=order['id']).first()

        # 检查订单是否完成
        if consumeRcd is None or consumeRcd.isNormal:
            logger.info('weifule({}) pay by startAcion..'.format(order['id']))
            return

        # 创建锁
        result = ConsumeRecord.objects.filter(orderNo=order['id'], isNormal=False, attachParas__payBy=None).update(
            attachParas__payBy='event')

        # TODO  抢扣 或者 补扣
        if result:
            package = consumeRcd.package
            attachParas = consumeRcd.attachParas
            group = self.device.group  # type: GroupDict

            if group.is_free:
                pass

            # 先寻找是否可用 包月套餐
            monthlyPackage = MonthlyPackage.get_enable_one(
                openId=consumeRcd.openId,
                groupId=consumeRcd.groupId,
            )

            if monthlyPackage:
                monthlyPackage.deduct(consumeRcd)

            elif package.get('name') == '充满自停' and package.get('coins') == 0 and package.get('price') == 0:  # 后付费
                consumeRcd.update(isNormal=True, status='')

            else:

                # 虚拟卡查找
                vCardId = attachParas.get('vCardId')
                if vCardId:
                    vCard = UserVirtualCard.objects.filter(id=vCardId).first()
                    if not vCard:
                        consumeRcd.update(isNormal=False, status=START_DEVICE_STATUS.FAILURE,
                                          errorDesc='没有找到虚拟卡.或虚拟卡已经过期(event)')
                        self.deviceAdapter.stop(order['port'])

                    vCardConsumeOrder = vCard.consume(openId=consumeRcd.openId, group=group, dev=self.device,
                                                      package=package,
                                                      attachParas=attachParas, nickname=consumeRcd.nickname,
                                                      orderNo=consumeRcd.orderNo)
                    if not vCardConsumeOrder:
                        # 扣除虚拟卡失败. 设备又启动了, 直接发明了停止掉
                        consumeRcd.update(isNormal=False, status=START_DEVICE_STATUS.FAILURE,
                                          errorDesc='扣除虚拟卡额度的时候，出现异常，请重试(event)')
                        logger.info('vCardConsumeOrder error , devNo=<{}> stop port({}) now.'.format(self.device.devNo, order['port'], ))
                        return self.deviceAdapter.stop(order['port'])

                else:
                    user = consumeRcd.user
                    user.update(inc__total_consumed=VirtualCoin(package['coins']))
                    user.pay(coins=VirtualCoin(package['coins']))  # 允许有负值

                # 纠正订单信息
                if consumeRcd.status == START_DEVICE_STATUS.FAILURE:
                    errorDesc = consumeRcd.errorDesc + "(<{}补充扣款{}币>)".format(
                        datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                        VirtualCoin(package['coins']).mongo_amount)

                    if vCardId:
                        errorDesc += '(虚拟卡抵扣)'

                    # TODO 补充扣款只扣除金币 所以如果有充值订单 修正订单为金币支付
                    consumeRcd.update(isNormal=True,
                                      status='',
                                      errorDesc=errorDesc,
                                      rechargeRcdId='',
                                      attachParas__lastRechargeRcdId=consumeRcd.rechargeRcdId)

                else:
                    consumeRcd.update(isNormal=True,
                                      status='')

                logger.info('weifule({}) pay by event..'.format(order['id']))

            if callable(callbackSP):
                callbackSP(consumeRcd, order)

        else:
            logger.info('weifule({}) pay by startAcion..'.format(order['id']))


class WeiFuLePolicyProcess(WorkEvent):

    def translate_reason(self, order):
        return '充电结束'

    @staticmethod
    def _auto_parser_card_no(card_no):
        return card_no if card_no.isdigit() and len(card_no) > 8 else '{}'.format(int(card_no, 16))

    @staticmethod
    def _auto_parser_card_type(card_type):
        if card_type in ['ID', 'online_card']:
            return 'ID'
        elif card_type in ['IC', 'offline_card']:
            return 'IC'
        else:
            return ''

    @staticmethod
    def _notify_card_title(card, order):    # type: (Card, dict) -> dict

        if card:
            if card.is_id_card:
                card_title = u'在线卡片'
            elif card.is_ic_card:
                card_title = u'离线卡片'
            else:
                card_title = u'实体卡片'
            return {card_title: u'{}--No.({})'.format(card.cardName or card.nickName, card.cardNo)}
        else:
            return {}

    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.consumeDict.get('reason'),
            finished_time=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            url=self.device.deviceAdapter.custom_push_url(self.consumeRcd, self.consumeRcd.user),
            extra=extra)

    def create_progress_for_socket_order(self, consumeRcd, devInfo):
        try:
            port = int(devInfo['port'])
            progress = ServiceProgress.objects.filter(device_imei=self.device.devNo, port=port,
                                                      devTypeCode=self.device.devTypeCode).first()

            if not progress:
                progress = ServiceProgress(device_imei=self.device.devNo, port=port,
                                           devTypeCode=self.device.devTypeCode)
                progress.start_time = devInfo['create_time']
                progress.finished_time = devInfo['create_time'] + 60 * 60 * 12
                progress.isFinished = False

            else:
                if devInfo['id'] in progress.consumes:
                    return

                if progress.isFinished == False:
                    progress.finished_time = progress.finished_time + 60 * 60 * 12

                else:
                    progress.consumes = []
                    progress.start_time = devInfo['create_time']
                    progress.finished_time = devInfo['create_time'] + devInfo.get('amount_time', 60 * 60 * 12)
                    progress.isFinished = False

            progress.open_id = consumeRcd.openId
            progress.consumes.append(devInfo['id'])
            progress.status = 'running'
            progress.save()

        except Exception as e:
            logger.exception(e)

    def record_consume_for_card(self, card, money, desc=u'', servicedInfo=None, sid=None, attachParas=None):
        # type: (Card, RMB, unicode, Optional[dict], Optional[str], Optional[dict])->Tuple[ConsumeRecord, CardConsumeRecord]

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

        now = datetime.datetime.now()

        if not servicedInfo:
            servicedInfo = {}

        if not attachParas:
            attachParas = {}

        new_record = ConsumeRecord.objects.create(**{
            'orderNo': sid,
            'time': now.strftime('%Y-%m-%d %H:%M:%S'),
            'dateTimeAdded': now,
            'openId': card.openId,
            'nickname': card.nickName,
            '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': desc,
            'attachParas': attachParas,
            'servicedInfo': servicedInfo
        })

        # 刷卡消费也记录一条数据
        new_card_record = CardConsumeRecord.objects.create(**{
            'orderNo': sid,
            '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': desc,
            'servicedInfo': servicedInfo,
            'linkedConsumeRcdOrderNo': str(new_record['orderNo'])
        })

        return new_record, new_card_record

    def response_id_card(self):
        """
        回复ID卡余额查询
        """
        card_no = self.event_data['card_no']
        cardNo = self._auto_parser_card_no(card_no)

        Card.record_dev_card_no(self.device.devNo, cardNo)

        card = self.update_card_dealer_and_type(cardNo)

        resp_message = {'fun_code': self.event_data['fun_code'], 'card_no': card_no, 'balance': 0, 'policy': {}}

        # 如果没有卡，直接返回
        if not card or not card.isBinded:
            resp_message.update({'result': card_not_in_db})

        else:
            if card.frozen:
                resp_message.update({'result': card_is_forzen})

            else:
                # 遇到没有充值的订单 重新充值一次
                card_recharge_order = CardRechargeOrder.get_last_to_do_one(str(card.id))
                if card_recharge_order:
                    self.recharge_id_card(card=card, rechargeType='append', order=card_recharge_order)

                card.reload()
                oper = self.event_data.get('reduce')
                if oper:
                    result, policy, showBalance = self.generate_Idcard_rules(card)
                    resp_message.update({'result': result, 'balance': RMB.yuan_to_fen(showBalance), 'policy': policy})
                else:
                    resp_message.update({'result': card_is_normal, 'balance': RMB.yuan_to_fen(card.balance)})

        return self.deviceAdapter.send_mqtt(resp_message)

    def generate_Idcard_rules(self, card):

        _policyTemp = self.device.policyTemp.get('forIdcard', self.deviceAdapter.INIT_POLICY['forIdcard'])
        policyType = _policyTemp.get('policyType')
        billingMethod = _policyTemp.get('billingMethod')

        # 策略计费
        policy = {
            'type': policyType,
            'mode': 'price',
            'auto_stop': True,
            'over_money_stop': True,
            'open_id': card.openId,
            'billingMethod': _policyTemp['billingMethod'],
            'rule': {}
        }

        if policyType == 'time':
            # 格式化规则
            prices = sorted(_policyTemp.get('rule', {}).get('prices', []), key=lambda _: _['power'])
            for item in prices:
                item['value'] = int(float(item.pop('price')) * 100)
                item['power'] = int(item['power'])
            policy['rule'] = {'time': 'full_stop', 'prices': prices}

        elif policyType == 'elec':
            price = RMB.yuan_to_fen(_policyTemp.get('price', 1))
            policy['rule'] = {'time': 'full_stop', 'price': price}

        else:
            pass

        # 付费时间的不同 导致下发的不同的参数
        if billingMethod == 'prepaid':
            money = _policyTemp['money']
            # 预支付的启动金额不足
            if RMB(money) > RMB(card.balance):
                result = card_less_balance
                showBalance = RMB(card.balance)
            # 预支付的启动金额足够
            else:
                result = card_is_normal
                showBalance = RMB(card.balance) - RMB(money)

            # 获取预支付模式下的自动退款
            auto_refund = _policyTemp.get('autoRefund')
            policy.update({
                'auto_refund': auto_refund,
                'money': int(float(money) * 100),
            })

        # 后支付的模式
        elif billingMethod == 'postpaid':
            showBalance = card.balance

            # 对比后支付的最小启动金额
            minAfterStartCoins = _policyTemp.get('minAfterStartCoins')
            if RMB(minAfterStartCoins) > RMB(card.balance):
                result = card_less_balance  # 余额不足
            else:
                result = card_is_normal
            policy.update({
                'auto_refund': False,
                'money': int(float(card.balance) * 100)
            })

        else:
            result = card_not_in_db
            showBalance = RMB(0)

        return result, policy, showBalance

    def _do_ack_order(self, order):
        funCode = self.event_data['fun_code']
        if funCode in [32, 34]:
            try:
                self.deviceAdapter.ack_event(order['id'], funCode)
            except Exception as e:
                logger.info('ack event devNo=%s err=%s' % (self.device.devNo, e))

    def _do_created_order_32(self, order):
        if order['order_type'] == 'apps_start':  # 扫码
            self.pay_apps_start_by_32(order)

        elif order['order_type'] == 'card_start':
            self.pay_card_start_by_32(order)

        elif order['order_type'] == 'coin_start':
            self.pay_coin_start_by_32(order)

        else:
            pass

        logger.info('finished 32 !!order=<{}>'.format(order))

    def _do_exec_order_33(self, order):
        if 'exec_time' in order:
            now = datetime.datetime.fromtimestamp(order['exec_time'])
        elif 'execute_time' in order:
            now = datetime.datetime.fromtimestamp(order['execute_time'])
        else:
            now = datetime.datetime.now()

        ConsumeRecord.objects.filter(orderNo=order['id']).update(startTime=now)

        logger.info('now to exec next order <{}>'.format(order['id']))

    def _do_finished_order_34(self, order):

        # 如果是离线卡的余额回收，修改下余额，然后直接返回即可
        if order['order_type'] == 'card_refund':
            return self.end_for_card_refund(order)

        self.common_verify_order(order)

        if not self.consumeRcd:
            return

        try:
            # 初始化订单的类型(预付费, 后付费)
            self._init_common_info(order)

            self.billingMethod = self.consumeRcd.servicedInfo.get('billingMethod')

            if self.billingMethod == 'postpaid':
                self.finishe_postpaid_process(order)

            elif self.billingMethod == 'prepaid':
                self.finish_prepaid_process(order)
                self.consumeRcd.update_service_info(self.consumeDict)

            else:
                logger.info('No such process.. orderNo={}'.format(self.consumeRcd.orderNo))

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

            logger.info('order is finished.. orderNo={}'.format(self.consumeRcd.orderNo))

        except Exception as e:
            logger.exception('some exception happed,devNo=%s,e=%s' % (self.device.devNo, e))

        finally:
            ctrInfo = Device.get_dev_control_cache(self.device.devNo)
            lineInfo = ctrInfo.get(str(order['port']), {})

            # 如果缓存中要结束的端口是本单的  就清空缓存 否则不处
            if order['id'] == lineInfo.get('orderNo'):
                Device.clear_port_control_cache(self.device.devNo, order['port'])

    def common_verify_order(self, order):
        self.consumeRcd = ConsumeRecord.objects.filter(orderNo=order['id'],
                                                       status__ne='finished').first()  # type:ConsumeRecord
        if not self.consumeRcd:
            logger.info('Repeat processing!! orderNo<{}>'.format(order['id']))
            return
        else:
            self.consumeRcd.status = 'finished'
            self.consumeRcd.finishedTime = datetime.datetime.now()
            self.consumeRcd.servicedInfo['source'] = json.dumps(order)
            self.consumeRcd.save()

        if 'card_no' in order:
            cardNo = self._auto_parser_card_no(order['card_no'])
            self.card = self.update_card_dealer_and_type(cardNo=cardNo)

        progress = ServiceProgress.objects.filter(device_imei=self.device.devNo, port=int(order['port']),
                                                  devTypeCode=self.device.devTypeCode,
                                                  consumes__contains=order['id']).first()
        if progress is None:
            pass
        else:

            progress.consumes.remove(order['id'])
            if len(progress.consumes) > 0:  # 还有其他的单未处理完成
                progress.save()
            else:
                progress.status = 'finished'  # 此时为本次服务的最后一单
                progress.isFinished = True
                progress.save()

    def end_for_card_refund(self, order):
        return self.update_card_dealer_and_type(cardNo=order['card_no'], cardType='IC',
                                                balance=RMB(order['balance'] / 100.0))

    def _init_common_info(self, order):
        """
            初始化结束要用到的数据
        """

        self.refundProtectionTime = int(self.device['otherConf'].get('refundProtectionTime', 5))
        self.consumeDict = self.consumeRcd.servicedInfo

        self.duration = round(order['time'] / 60.0, 1)
        self.elec = round(order['elec'] / 1000000.0, 3)
        self.power = round(order.get('power', 0), 1)
        order['reason'] = self.translate_reason(order)

        self.consumeDict.update({'reason': order['reason'], 'duration': self.duration, 'elec': self.elec})
        # 添加一个分档功率
        if self.power:
            self.consumeDict.update({'maxPower': self.power})

        self.extra = [
            {u'使用详情': u'{}分钟(端口: {})'.format(self.duration, self.consumeDict['chargeIndex'])}
        ]

    # 32启动补扣或者刷卡建单 *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
    def pay_apps_start_by_32(self, order, callbackSP=None):
        """
            此函数会对订单进行扣款(补扣或者抢锁扣款,依据上报的事件)
            一般callbackSP为创建服务进程函数

        """
        consumeRcd = ConsumeRecord.objects.filter(orderNo=order['id']).first()  # type: ConsumeRecord

        # 检查订单是否完成
        if consumeRcd is None or consumeRcd.isNormal:
            logger.info('weifule({}) pay by startAction..'.format(order['id']))
            return

        # 创建锁
        result = ConsumeRecord.objects.filter(
            orderNo=order['id'], isNormal=False, attachParas__payBy=None).update(
            attachParas__payBy='event'
        )

        if not result:
            return

        # TODO  在线支付的抢扣或者补扣
        # 订单为免费的情况 更换状态即可
        if consumeRcd.isFree:
            logger.info("[pay_apps_start_by_32] free order = {}, event = {}".format(consumeRcd, self.event_data))
            consumeRcd.update(isNormal=True, status=START_DEVICE_STATUS.RUNNING)
            return
        # 后支付的情况  更换订单状态即可
        if consumeRcd.package.isPostpaid:
            logger.info("[pay_apps_start_by_32] post paid order = {}, event = {}".format(consumeRcd, self.event_data))
            consumeRcd.update(isNormal=True, status=START_DEVICE_STATUS.RUNNING)
        # 预支付的情况 考虑要补扣金额
        else:
            consumeRcd.frozen_payer_balance()
            # 纠正订单信息
            if consumeRcd.status == START_DEVICE_STATUS.FAILURE:
                errorDesc = consumeRcd.description + "(<{}补充扣款>)".format(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

                consumeRcd.update(isNormal=True, status=START_DEVICE_STATUS.RUNNING, errorDesc=errorDesc)

            else:
                consumeRcd.update(isNormal=True, status=START_DEVICE_STATUS.RUNNING)

            logger.info('weifule({}) pay by event..'.format(order['id']))

        set_start_key_status(start_key=consumeRcd.startKey, state=START_DEVICE_STATUS.FINISHED, order_id=str(consumeRcd.id))

        if callable(callbackSP):
            callbackSP(consumeRcd, order)

        self.create_progress_for_socket_order(consumeRcd, order)

    def pay_card_start_by_32(self, order):
        # 查找卡
        logger.debug("[pay_card_start_by_32] order = {}".format(order))
        cardNo, cardType = self._auto_parser_card_no(order['card_no']), self._auto_parser_card_type(order['card_type'])
        card = self.update_card_dealer_and_type(cardNo, cardType)  # type: Card

        # 非法卡
        if not card or not card.isBinded or card.frozen:
            logger.info("[pay_card_start_by_32], not find normal card! order = {}".format(order))
            if card and card.is_id_card:
                self.device.deviceAdapter.stop_charging_port(order["port"])
            return

        # extra = [
        #     {u'设备地址': u'{}'.format(self.device.group.address)},
        #     {u'设备编号': u'{}'.format(self.device.logicalCode)},
        #     self._notify_card_title(card, order)
        # ]
        #
        # 创建订单参数
        data = {
            'devInfo': {'logicalCode': self.device.logicalCode},
            'userInfo': {'cardId': str(card.id)},
        }

        # 从policy中构建出套餐参数
        startInfo = {
            'sequenceNo': order['id'],
            'startType': StartDeviceType.CARD,
            'port': order['port'],
            'packageId': '',
            "name": "刷卡套餐",
            "policyType": order['policy']['type'],
            "autoRefund": order['policy']['auto_refund'],
            "autoStop": order['policy']['auto_stop'],
            "billingMethod": order['policy']['billingMethod'],
            "rules": order['policy']["rule"]
        }
        # 预支付的情况 套餐的金额等于付款的金额
        if startInfo["billingMethod"] == "prepaid":
            startInfo["price"] = RMB.fen_to_yuan(order['policy']['money'])  # type:RMB
        # 后支付的情况 套餐金额暂时不变
        else:
            startInfo["price"] = RMB(0)  # type:RMB

        data["startInfo"] = startInfo

        # 根据参数组装订单
        try:
            with UnifiedCardConsumeOrderManager(**data) as manager:
                consumeRcd = manager.buildOrder()        # type: ConsumeRecord
        except UnifiedConsumeOrderError as ue:
            logger.error("[pay_card_start_by_32] order create order error = {}, order = {}".format(ue, order))
            self.device.deviceAdapter.stop_charging_port(order["port"])
            return

        # 预支付的情况下支付
        if card.is_id_card:
            # 预支付的情况下 进行扣款操作
            if not consumeRcd.isPostPaid:
                try:
                    payment = generate_card_payment(consumeRcd)
                    if payment:
                        consumeRcd.update_payment(payment)
                        consumeRcd.frozen_payer_balance()
                    if not consumeRcd.isPaid:
                        raise ValueError('')
                except Exception as e:
                    self.device.deviceAdapter.stop_charging_port(order["port"])
                    logger.exception(e)

        result = {
            "deviceStartTime": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(order["create_time"]))
        }
        ConsumeOrderStateEngine(consumeRcd).to_running(result)

        start_time_stamp = order.get('create_time')
        start_time = datetime.datetime.fromtimestamp(start_time_stamp)
        ctrInfo = Device.get_dev_control_cache(self.device.devNo)
        lineInfo = ctrInfo.get(str(order['port']), {})
        if not lineInfo or lineInfo.get('status') == Const.DEV_WORK_STATUS_IDLE:
            lineInfo = {
                'port': str(order['port']),
                'status': Const.DEV_WORK_STATUS_WORKING,
                'order_type': 'card_start',
                'startTime': start_time.strftime('%Y-%m-%d %H:%M:%S'),
                'orderNo': consumeRcd.orderNo,
            }
            Device.update_port_control_cache(self.device.devNo, lineInfo)


    # 预付费流程 *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

    def finish_prepaid_process(self, order):

        # 中间留着写业务
        self._prepaid_analyze_order_info(order)
        self._prepaid_calc_refund_coins(order)

        # 扫码的退费处理
        if order['order_type'] == 'apps_start':
            self.prepaid_end_for_app_start(order)

        # 刷卡的退费处理
        elif order['order_type'] == 'card_start' and order['card_no']:
            self.prepaid_end_for_card_start(order)

        self._prepaid_analyze_notify_info(order)

    def _prepaid_analyze_order_info(self, order):
        try:
            if order['order_type'] == 'apps_start':
                pass

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

        except:
            logger.info(traceback.format_exc())

    def _prepaid_calc_refund_coins(self, order):

        auto_refund = order['policy'].get('auto_refund', False)
        self.backCoins = RMB(0)
        money = VirtualCoin(self.consumeRcd.money)
        minFee = VirtualCoin(self.consumeRcd.package.get('minFee') or 0)

        # 免费地址:
        if self.consumeRcd.is_free:
            pass

        else:
            if self._auto_parser_card_type(order.get('card_type')) == 'IC':
                logger.info(
                    'IC card is not refundable orderNo=<{}> duration=<{}>'.format(self.consumeRcd.orderNo, self.duration))
                return

            if self.duration < self.refundProtectionTime:
                self.backCoins = money

            else:
                usedFee = min(VirtualCoin(order['money'] * 0.01), money)  # 做一个使用费用的保护 防止使用金额溢出
                usedFee = max(usedFee, minFee)  # 和最小消费做比较 取大的

                if auto_refund:
                    self.backCoins = money - usedFee

        logger.info(
            'REFUND STATUS  orderNo=<{}>, auto_refund={}, refundProtectionTime=<{}>, duration=<{}>, backCoins=<{}> minFee=<{}>'.format(
                self.consumeRcd.orderNo, auto_refund, self.refundProtectionTime, self.duration, self.backCoins, minFee
            ))

    def _prepaid_analyze_notify_info(self, order):

        # 消费部分
        if order['order_type'] == 'apps_start':
            if self.consumeDict['policyType'] == 'time':
                self.extra.extend([
                    {u'订购套餐': self.consumeDict['needTime']},
                ])


            elif self.consumeDict['policyType'] == 'elec':
                self.extra.extend([
                    {u'订购套餐': self.consumeDict['needElec']},
                    {u'消耗电量': self.consumeDict['elec']},
                ])

            else:
                pass

        elif order['order_type'] == 'card_start':
            self.extra.append(self._notify_card_title(order))

        else:
            pass

        # 金额部分
        if self.consumeRcd.is_free:
            self.extra.append({u'付费金额': u'免费使用!'})

        else:
            if self.backCoins > RMB(0):
                self.extra.append({u'使用明细': u'支付{}元，退费{}元'.format(self.consumeRcd.money, self.backCoins)})
            else:
                self.extra.append({u'使用明细': u'支付{}元'.format(self.consumeRcd.money, self.backCoins)})

            if order['order_type'] == 'card_start':
                self.extra.append({u'卡片余额': u'{}元'.format(self.card.balance)})

    def prepaid_end_for_app_start(self, order):
        # 如果需要退款，计算退款数据.
        if self.backCoins > RMB(0):
            openId = self.consumeRcd.user.openId
            lineInfo = {'openId': openId}
            refundRMB = RMB(0)
            is_temp_package = self.consumeRcd.is_temp_package

            if is_temp_package and self.consumeRcd.recharge_record_id:
                rechargeRcd = RechargeRecord.objects.filter(id=self.consumeRcd.recharge_record_id,
                                                            openId=openId,
                                                            devNo=self.device.devNo,
                                                            isQuickPay=True,
                                                            groupId=self.device.groupId).first()

                refundRMB = rechargeRcd.money * (self.backCoins.amount / self.consumeRcd.coin.amount)
                lineInfo.update({'rechargeRcdId': self.consumeRcd.recharge_record_id})

            self.refund_net_pay(self.consumeRcd.user, lineInfo,
                                refundRMB, self.backCoins, self.consumeDict, is_temp_package)

    def prepaid_end_for_card_start(self, order):

        if not self.card:  # 离线卡没有绑定或者在线卡被解绑了
            return

        # 不需要退款，直接返回.在线卡需要退费，离线卡只登记使用记录就OK
        if self.backCoins > RMB(0) and self.card.cardType == 'ID':
            self.refund_money_for_card(self.backCoins, self.card.id)
            self.consumeDict.update({
                DEALER_CONSUMPTION_AGG_KIND.REFUND_CARD: self.backCoins.mongo_amount
            })

        # 最后维护一次 订单上显示的卡余额
        self.card.reload()
        self.consumeDict.update({
            'cardBalance': self.card.balance.mongo_amount
        })

    # 后付费流程*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

    def finishe_postpaid_process(self, order):

        self._postpaid_analyze_order_info(order)
        self._postpaid_calc_used_fee(order)

        # 扫码扣除余额
        if order['order_type'] == 'apps_start':
            self.postpay_end_for_app_start(order)

        # 刷卡的扣除余额
        elif order['order_type'] == 'card_start' and order['card_no']:
            self.postpay_end_for_card_start(order)

        self._postpaid_analyze_notify_info(order)

    def _postpaid_analyze_order_info(self, order):
        pass

    def _postpaid_calc_used_fee(self, order):

        self.usedFee = VirtualCoin(order['money'] * 0.01)
        # 最小金额处理
        minFee = VirtualCoin(self.consumeRcd.package.get('minFee') or 0)

        # 免费地址:
        if self.consumeRcd.is_free:
            self.usedFee = VirtualCoin(0)

        else:
            # 使用金额不能超过本单的卡余额
            if self.duration < self.refundProtectionTime:
                self.usedFee = VirtualCoin(0)

            else:
                if order['order_type'] == 'apps_start':
                    self.usedFee = max(self.usedFee, minFee)

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

        logger.info(
            'REFUND STATUS  orderNo=<{}>, isFree={} usedFee={}, refundProtectionTime=<{}>, duration=<{}> minFee=<{}>'.format(
                self.consumeRcd.orderNo, self.consumeRcd.is_free, self.usedFee, self.refundProtectionTime,
                self.duration, minFee
            ))

    def _postpaid_analyze_notify_info(self, order):

        # 消费部分
        if order['order_type'] == 'apps_start':
            if self.consumeDict['policyType'] == 'time':

                self.extra.extend([
                    {u'订购套餐': u'{}'.format(self.consumeDict['needTime'])},
                ])

            elif self.consumeDict['policyType'] == 'elec':
                self.extra.extend([
                    {u'订购套餐': u'{}度'.format(self.consumeDict['needElec'])},
                    {u'消耗电量': u'{}度'.format(self.consumeDict['elec'])},
                ])

            # 金额部分
            if self.consumeRcd.is_free:
                self.extra.append({u'扣费金额': u'免费使用!'})

            else:
                if self.consumeRcd.status == ConsumeRecord.Status.FINISHED:
                    if self.consumeRcd.paymentInfo.get('via') == 'virtualCard':
                        desc = u'(已使用优惠卡券抵扣本次消费)'

                    else:
                        desc = u'(已使用账户余额自动结算本次消费)' if self.usedFee > VirtualCoin(0) else ''

                else:
                    desc = u'(您的账户余额已不足以抵扣本次消费，请前往账单中心进行支付)'

                self.consumeDict['reason'] += desc
                self.extra.append({u'消费金额': u'{}元'.format(self.usedFee)})

            self.extra.append(
                {u'用户余额': u'{}元'.format(
                    self.consumeRcd.user.calc_currency_balance(self.device.owner, self.device.group))})

        if order['order_type'] == 'card_start':
            self.extra.append(self._notify_card_title(order))

            if self.consumeDict['policyType'] == 'time':
                pass

            elif self.consumeDict['policyType'] == 'elec':
                self.extra.extend([
                    {u'消耗电量': '{}度'.format(self.consumeDict['elec'])}
                ])

            else:
                pass

            self.extra.append({u'扣费金额': u'{}元'.format(self.usedFee)})
            self.extra.append({u'卡片余额': u'{}元'.format(self.card.balance)})

    def postpay_end_for_app_start(self, order):

        def pay_order():
            try:
                self.consumeRcd.status = 'running'
                self.consumeRcd.attachParas['packageId'] = self.consumeRcd.package.get('packageId')
                self.consumeRcd.save()
                self.consumeRcd.s_to_e()
            except:
                pass

        # 1 更新订单金额
        self.consumeRcd.coin = self.usedFee
        self.consumeRcd.money = self.usedFee
        self.consumeRcd.servicedInfo = self.consumeDict
        self.consumeRcd.save()

        # 2 去结算
        if self.consumeRcd.is_free:
            pass

        else:
            pay_order()

        self.consumeRcd.reload()

        # 如果结算成功
        if self.consumeRcd.status == ConsumeRecord.Status.FINISHED:

            # 如果结算使用的是虚拟卡
            if self.consumeRcd.paymentInfo.get('via') == 'virtualCard':

                # 虚拟卡抵扣 更新订单金额为0
                self.consumeRcd.update(coin=VirtualCoin(0), money=RMB(0))
                try:
                    if "rcdId" in self.consumeRcd.paymentInfo:
                        consumeRcdId = self.consumeRcd.paymentInfo['rcdId']
                    else:
                        consumeRcdId = self.consumeRcd.paymentInfo['itemId']

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

                except:
                    pass

            else:
                pass

    def postpay_end_for_card_start(self, order):

        if not self.card:  # 离线卡没有绑定或者在线卡被解绑了
            return

        if self.card.cardType == 'ID':
            self.card.update(dec__balance=self.usedFee)
            self.card.reload()

            # 维护 订单上显示的卡余额
            self.consumeDict.update({
                'cardBalance': self.card.balance.mongo_amount,
                DEALER_CONSUMPTION_AGG_KIND.CONSUME_CARD: self.usedFee.mongo_amount,
            })

            # 维护一次订单
            self.consumeRcd.update(coin=self.usedFee.mongo_amount, money=self.usedFee.mongo_amount)

            CardConsumeRecord.objects.filter(orderNo=self.consumeRcd.orderNo).update(
                money=self.usedFee.mongo_amount,
                balance=self.card.balance.mongo_amount,
                finishedTime=self.consumeRcd.finishedTime,
                servicedInfo=self.consumeDict
            )

        else:
            # 异常情况 不处理
            pass

    def pay_coin_start_by_32(self, order):
        policy = order.get('policy', {})
        coin = int(policy['money'] * 0.01)
        if coin > 0:
            Accounting.syncOfflineCoin(
                self.device,
                datetime.datetime.fromtimestamp(order['create_time']).strftime('%Y-%m-%d'), coin)
            FluentedEngine().in_put_coins_udp(devNo=self.device.devNo,
                                              ts=int(time.time()),
                                              coins=coin,
                                              mode='uart')
        logger.info('devNo=<{}> This coin=<{}> consumption has been recorded!'.format(self.device.devNo, coin))


class WeiFuLeCarProcess(object):
    desc_map = {
        0: '订购已用完',
        1: '管理员停止',
        2: '设备故障',
        3: '充电枪拔除',
        4: '紧急停止按钮',
        5: '计量故障',
        6: '功率过载',
        7: '电压过载',
        8: '电流过载',
        9: '超过单次充电最大时长',
        10: '设备启动失败',
        11: '继电器故障',
        12: '刷卡停止',
        13: '用户远程停止',
        14: '经销商远程停止',
        15: '温度超限'
    }

    CREATED = 'created'
    RUNNING = 'running'
    WAITING = 'wait'
    FINISHED = 'finished'
    END = 'end'
    TIMEOUT = 'timeout'
    FAILURE = 'failure'

    def __init__(self, smartbox):
        self.devNo = smartbox.device.devNo
        self.fun_code = smartbox.event_data.get('fun_code')
        self.order_info = smartbox.event_data.get('order')
        self.dev = smartbox.device  # type: DeviceDict
        self.adapter = smartbox.deviceAdapter
        self.smartbox = smartbox

    def _exec_order_33(self):
        start_time = self.order_info.get('exec_time')
        start_time = datetime.datetime.fromtimestamp(start_time)

        order_id = self.order_info.get('id')

        consumeOrder = ConsumeRecord.objects.filter(orderNo=order_id, status__ne=ConsumeRecord.Status.FINISHED).first()

        if not consumeOrder:
            logger.info('no this order')
            return
        consumeOrder.update(startTime=start_time)

    def apps_start(self):
        """
          'order_type' : 'apps_start',
          'money' : 1.2388653318201,
          'id' : '86743505437857520201225084915001',
          'left_money' : 98.76113466818,
          'last_clock' : 607.31,
          'create_time' : 1608857355,
          'time' : 475.525,
          'amount' : 100,
          'elec' : 12388.653318201,
          'exec_time' : 1608857355,
          'status' : 'running',
          'last_ecnt' : 16777128
        """
        dev_stat = self.order_info.get('status')

        order = ConsumeRecord.objects.filter(orderNo=self.order_info['id']).first()
        if not order:
            logger.info('no this order')
            return

        if dev_stat == 'running':
            self._apps_start_do_record_running(dev_stat, order)

        elif dev_stat == 'waiting':
            self._apps_start_do_record_waiting(dev_stat, order)

        elif dev_stat == 'finished':
            self._apps_start_do_record_finished(dev_stat, order)

    def _apps_start_do_record_running(self, dev_stat, order):

        rechargeRcdId = order.rechargeRcdId or ''

        if order.status == self.CREATED:  # 让adapter处理
            if 'adapter' in self.order_info:  # 服务器过来直接处理
                order.update(status=self.RUNNING)

            else:
                if (time.time() - self.order_info.get('create_time', 0)) > 300:
                    ConsumeRecord.objects.filter(id=order.id, status=self.CREATED).update(status=self.RUNNING, isNormal=True)


        elif order.status == self.RUNNING:  # 设备上报
            start_time = self.order_info.get('exec_time')
            start_time = datetime.datetime.fromtimestamp(start_time)
            order.update(
                status=self.RUNNING,
                startTime=start_time
            )

        elif order.status == self.WAITING:  # 33 上来的wait单变running
            start_time = self.order_info.get('exec_time')
            start_time = datetime.datetime.fromtimestamp(start_time)
            order.update(
                status=self.RUNNING,
                startTime=start_time,
            )

        elif order.status in [self.TIMEOUT, self.FAILURE]:  # 此时已经退费,标记为后支付,不做处理
            start_time = self.order_info.get('exec_time') or self.order_info.get('create_time')
            port = self.order_info.get('port')
            start_time = datetime.datetime.fromtimestamp(start_time)
            order.update(
                status=self.RUNNING,
                coin=VirtualCoin(0),
                money=RMB(0),
                startTime=start_time,
                attachParas__payAfterUse=True,
                rechargeRcdId='',
                attachParas__last_refund_rechargeRcdId=rechargeRcdId,
                isNormal=True,
                errorDesc='设备启动已退费, 此单标记为后支付<dev_stat:{}>'.format(dev_stat),
            )

            consumeOrder = {
                'orderNo': order.orderNo,
                'coin': 0,
                'consumeType': 'postpaid',
            }

            self.adapter.register_service_progress(order.openId, order.orderNo, port, consumeOrder, order.attachParas)

            title = make_title_from_dict([
                {u'设备地址': u'{}'.format(self.dev.group.address)},
                {u'设备编号': u'{}'.format(self.dev['logicalCode'])},
            ])

            self.smartbox.notify_user(
                order.user.managerialOpenId,
                'dev_start',
                **{
                    'title': title,
                    'things': u'您的汽车充电服务已启动',
                    'remark': u'感谢您的支持!',
                    'time': start_time.strftime(Const.DATETIME_FMT)
                }
            )

        elif order.status in [self.FINISHED, self.END]:
            pass

        else:
            logger.info('error order status devStat=<{}>, order=<{}>'.format(dev_stat, order.orderNo))

    def _apps_start_do_record_waiting(self, dev_stat, order):
        # 兼容系统 全改为running单

        rechargeRcdId = order.rechargeRcdId or ''
        if order.status == self.CREATED:  # 启动过程服务器中断停留在
            if (time.time() - self.order_info.get('create_time', 0)) > 300:
                ConsumeRecord.objects.filter(id=order.id, status=self.CREATED).update(status=self.RUNNING, isNormal=True)

        elif order.status == self.RUNNING:  # 服务器成功启动置为running
            order.update(
                status=self.RUNNING
            )

        elif order.status == self.WAITING:  # 重复
            pass

        elif order.status in [self.TIMEOUT, self.FAILURE]:  # 此时已经退费,标记为后支付,不做处理
            order.update(
                status=self.RUNNING,
                coin=VirtualCoin(0),
                money=RMB(0),
                attachParas__payAfterUse=True,
                rechargeRcdId='',
                attachParas__last_refund_rechargeRcdId=rechargeRcdId,
                isNormal=True,
                errorDesc='设备启动已退费, 此单标记为后支付<dev_stat:{}>'.format(dev_stat),
            )

            consumeOrder = {
                'orderNo': order.orderNo,
                'coin': 0,
                'consumeType': 'postpaid',
            }

            self.adapter.register_service_progress(order.openId, order.orderNo, consumeOrder, order.attachParas)

        elif order.status in [self.FINISHED, self.END]:
            pass

    def _apps_start_do_record_finished(self, dev_stat, order):

        if order.status == self.CREATED:  # 启动过程中服务器出错
            ConsumeRecord.objects.filter(id=order.id, status=self.CREATED).update(status=self.RUNNING, isNormal=True)
            order.reload()
            self.pre_pay(order)

        elif order.status in [self.RUNNING, self.WAITING]:  # 正常状态的 或者修正状态的单
            payAfterUse = order.attachParas.get('payAfterUse')
            if payAfterUse:
                self.after_pay(order)
            else:
                self.pre_pay(order)

        elif order.status == self.TIMEOUT:  # 设备启动后,100事件先上(该状态为running),210回复改为timeout,后付费处理
            order.update(
                status=self.RUNNING,
                coin=VirtualCoin(0),
                money=RMB(0),
                attachParas__payAfterUse=True,
                rechargeRcdId='',
                attachParas__last_refund_rechargeRcdId=order.rechargeRcdId,
                isNormal=True,
                errorDesc='设备启动已退费, 此单标记为后支付<dev_stat:{}>'.format(dev_stat),
            )

            order.reload()
            self.after_pay(order)

        elif order.status == self.FAILURE:  # 状态位置不处理
            pass

        elif order.status in [self.FINISHED, self.END]:
            logger.info('do apps finished --> no order found or repeated submit orderNo:{}'.format(order.orderNo))
            return

        logger.info('apps start event orderNo:{} is over'.format(order))

    def pre_pay(self, order):
        openId = order.openId

        # leftMoney = RMB.fen_to_yuan(self.order_info.get('left_money', 0))  # 传过来的这个值有问题
        amount = RMB.fen_to_yuan(self.order_info.get('amount', 0))
        usedMoney = RMB.fen_to_yuan(self.order_info.get('money'))
        leftMoney = amount - usedMoney
        used_time = round(self.order_info.get('time') / 60.0, 2)
        used_elec = self.order_info.get('elec') / 10.0 ** 6
        reason = self.desc_map.get(self.order_info.get('cause'))
        execTimeStamp = self.order_info.get('exec_time')
        finishedTimeStamp = self.order_info.get('over_time')
        port = self.order_info.get('port')
        finishedTime = datetime.datetime.fromtimestamp(finishedTimeStamp)
        if not execTimeStamp:
            startTime = finishedTime
        else:
            startTime = datetime.datetime.fromtimestamp(execTimeStamp)

        status = self.order_info.get('status')

        consumeDict = {
            DEALER_CONSUMPTION_AGG_KIND.DURATION: '%d' % used_time,
            DEALER_CONSUMPTION_AGG_KIND.ELEC: '%.2f' % used_elec,
            DEALER_CONSUMPTION_AGG_KIND.COIN: amount.mongo_amount,
            'reason': reason
        }
        order.status = status
        order.startTime = startTime
        order.finishedTime = finishedTime
        order.save()

        user = order.user

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

        extra = [
            # {u'订单号': '{}'.format(order.orderNo)},
            {u'本次使用时长': '{}(分钟)'.format(used_time)},
        ]

        self.smartbox.notify_user_service_complete(
            service_name='充电',
            openid=user.managerialOpenId if user else '',
            port=port,
            address=group['address'],
            reason=reason,
            finished_time=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra
        )

        if order.attachParas.get('is_auto_refund', False):
            recharge_record = None

            if order.rechargeRcdId:
                recharge_record = RechargeRecord.objects(
                    id=order.rechargeRcdId, isQuickPay=True).first()  # type: RechargeRecord

            if recharge_record:
                refundMoneyRecord = RefundMoneyRecord.objects.filter(openId=openId,
                                                                     rechargeObjId=recharge_record.id).first()
                if not refundMoneyRecord:
                    self._do_refund_money(recharge_record, order, leftMoney, consumeDict)
            else:
                self._do_refund_coin(order, leftMoney, consumeDict)

        order.update_service_info(consumeDict)

        ServiceProgress.objects.filter(device_imei=self.devNo, weifuleOrderNo=order.orderNo).update(
            isFinished=True, finished_time=int(time.time())
        )

        self.adapter.async_update_portinfo_from_dev()

    def after_pay(self, order):
        """
            只针对设备下发之后,没有回复的故障单为后付费
        :return:
        """

        used_money = RMB.fen_to_yuan(self.order_info.get('money', 0))
        amount = RMB.fen_to_yuan(self.order_info.get('amount', 0))
        used_time = round(self.order_info.get('time') / 60.0, 2)
        used_elec = self.order_info.get('elec') / 10.0 ** 6
        reason = self.desc_map.get(self.order_info.get('cause'))
        execTimeStamp = self.order_info.get('exec_time')
        finishedTimeStamp = self.order_info.get('over_time')
        port = self.order_info.get('port')
        finishedTime = datetime.datetime.fromtimestamp(finishedTimeStamp)
        if not execTimeStamp:
            startTime = finishedTime
        else:
            startTime = datetime.datetime.fromtimestamp(execTimeStamp)

        consumeDict = {
            DEALER_CONSUMPTION_AGG_KIND.DURATION: '%d' % used_time,
            DEALER_CONSUMPTION_AGG_KIND.ELEC: '%.2f' % used_elec,
            'reason': reason,
        }

        order.startTime = startTime
        order.finishedTime = finishedTime
        coins = VirtualCoin(order.package.get('coins', 0))
        price = RMB(order.package.get('price'))
        ratio = Ratio(float(used_money) / float(amount))
        order.coin = coins * ratio
        order.money = price * ratio

        if order.money == RMB(0):
            order.coin = VirtualCoin(0)

        order.save()

        extra = [
            # {u'订单号': '{}'.format(order.orderNo)},
            {u'本次使用时长': '{}(分钟)'.format(used_time)},

        ]
        if order.money > RMB(0):
            self._pay_by_coins(order)
        else:
            order.update(status=self.FINISHED)

        order.reload()
        if order.status == self.FINISHED:
            extra.append({u'本单消费金额': '{}金币(已使用账户余额自动结算本次消费)'.format(order.coin.mongo_amount)})
            consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.COIN: order.coin.mongo_amount})
        else:
            extra.append({u'本单消费金额': '{}元((您的账户余额不足以抵扣本次消费，请前往账单中心进行支付))'.format(order.money.mongo_amount)})
            consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.SPEND_MONEY: order.money.mongo_amount})

        self.smartbox.notify_user_service_complete(
            service_name='充电结束',
            openid=order.user.managerialOpenId,
            port=str(port),
            address=self.dev.group['address'],
            reason=reason,
            finished_time=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra
        )

        order.update_service_info(consumeDict)

        ServiceProgress.objects.filter(device_imei=self.devNo, weifuleOrderNo=order.orderNo).update(
            isFinished=True, finished_time=int(time.time())
        )

    def _pay_by_coins(self, order):
        try:
            order.s_to_e()
        except Exception:
            return False

    def _do_refund_money(self, recharge_record, consumeOrder, leftMoney, consumeDict):
        logger.info('now do refund money!')

        coins = consumeOrder.coin
        openId = consumeOrder.openId

        price = recharge_record.money

        user = consumeOrder.user

        refundMoney = RMB(price) * Ratio(float(leftMoney) / float(coins))
        if refundMoney > RMB(price):
            refundMoney = RMB(price)

        if refundMoney > RMB(0):
            self.smartbox.refund_net_pay(user, {'rechargeRcdId': str(recharge_record.id), 'openId': user.openId},
                                         refundMoney,
                                         VirtualCoin(0), consumeDict, True)

            title = make_title_from_dict([
                {u'设备地址': u'{}'.format(self.dev.group.address)},
                {u'设备编号': u'{}'.format(self.dev['logicalCode'])},
            ])

            self.smartbox.notify_user(self.smartbox.get_managerialOpenId_by_openId(openId), 'refund_coins', **{
                'title': title,
                'backCount': u'金额：%s' % refundMoney,
                'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')})

        logger.info('refund cash is successful  refundMoney:{}'.format(refundMoney))

    def _do_refund_coin(self, consumeOrder, leftMoney, consumeDict):

        logger.info('now do refund coin !')

        coins = consumeOrder.coin
        openId = consumeOrder.openId

        user = consumeOrder.user

        backCoins = VirtualCoin(coins) * Ratio(float(leftMoney) / float(coins))

        if backCoins > VirtualCoin(coins):
            backCoins = VirtualCoin(coins)

        if backCoins > RMB(0):
            self.smartbox.refund_net_pay(user, {'openId': openId}, RMB(0), backCoins, consumeDict, False)

            title = make_title_from_dict([
                {u'设备地址': u'{}'.format(self.dev.group.address)},
                {u'设备编号': u'{}'.format(self.dev['logicalCode'])},
            ])

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

    # ---------------------刷卡处理-------------------------

    def card_start(self):
        status = self.order_info.get('status')
        if self.fun_code == 32:
            self._card_start_do_record_running_32()

        elif self.fun_code == 34:
            self._card_start_do_record_finished_34()


        elif self.fun_code == 33:
            self._exec_order_33()

    def card_refund(self):
        """
            离线卡:上报退费 做一次卡余额同步
        """
        status = self.order_info.get('status')
        if self.fun_code == 32:
            if status == 'finished':

                self._card_refund_do_record_finished()
            else:
                pass
        elif self.fun_code == 34:
            if status == 'finished':
                pass
                # self._card_refund_do_record_finished()
            else:
                pass

    def _card_start_do_record_running_32(self):
        # used_money = RMB.fen_to_yuan(self.order_info.get('money', 0))
        # left_money = RMB.fen_to_yuan(self.order_info.get('left_money'))
        amount = RMB.fen_to_yuan(self.order_info.get('amount', 0))
        card_balance = RMB.fen_to_yuan(self.order_info.get('balance'))
        start_time_stamp = self.order_info.get('create_time')
        start_time = datetime.datetime.fromtimestamp(start_time_stamp)
        # used_time = self.order_info.get('time') / 60
        # used_elec = self.order_info.get('elec') / 10 ** 6
        # status = self.order_info.get('status')
        order_id = self.order_info.get('id')
        card_no = self.order_info.get('card_no')
        port = self.order_info.get('port')

        card = Card.objects.filter(cardNo=card_no, cardType='IC', dealerId=self.dev.ownerId).first()

        if not card:
            logger.info('no this card  cardNo:{}'.format(card_no))
            return

        # 做一次订单号去重
        order = ConsumeRecord.objects.filter(orderNo=order_id).first()
        if order:
            logger.info('order already exists  cardNo:{}, order_id'.format(card_no, order_id))
            return

        servicedInfo = {
            'cardNo': card_no,
            'port': port,
            'cardBalance': card_balance.mongo_amount
        }

        attachParas = {
            'orderNo': order_id,
            'chargeIndex': str(port)
        }

        # 记录卡消费记录以及消费记录
        orderNo, cardOrderNo = self.smartbox.record_consume_for_card(card, amount, servicedInfo=servicedInfo,
                                                                     attachParas=attachParas)

        consumeOrder = {
            'orderNo': orderNo,
            'cardOrderNo': cardOrderNo,
            'coin': str(amount),
            'consumeType': 'card',
        }

        self._register_card_service_progress(card, port, consumeOrder, order_id)

        title = make_title_from_dict([
            {u'设备地址': u'{}'.format(self.dev.group.address)},
            {u'设备编号': u'{}'.format(self.dev['logicalCode'])},
            {u'实体卡': u'{}--No:{}'.format(card.cardName or card.nickName, card.cardNo)},
            {u'本次消费': u'{} 元'.format(amount)},
            {u'卡余额': u'{} 元'.format(card_balance)},
        ])

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

    def _card_start_do_record_finished_34(self):
        used_time = round(self.order_info.get('time') / 60.0, 2)
        finishedTimeStamp = self.order_info.get('over_time')
        finishedTime = datetime.datetime.fromtimestamp(finishedTimeStamp)
        execTimeStamp = self.order_info.get('exec_time')
        if not execTimeStamp:
            startTime = finishedTime
        else:
            startTime = datetime.datetime.fromtimestamp(execTimeStamp)
        reason = self.desc_map.get(self.order_info.get('cause'))
        card_no = self.order_info.get('card_no')
        used_elec = self.order_info.get('elec') / 10 ** 6
        card_balance = RMB.fen_to_yuan(self.order_info.get('balance'))
        amount = RMB.fen_to_yuan(self.order_info.get('amount'))
        port = self.order_info.get('port')
        order_id = self.order_info.get('id')
        # left_money = RMB.fen_to_yuan(self.order_info.get('left_money')) #这个值有问题
        used_money = RMB.fen_to_yuan(self.order_info.get('money'))
        left_money = amount - used_money

        consumeOrder = ConsumeRecord.objects.filter(devNo=self.devNo, orderNo=order_id,
                                                    status__ne=ConsumeRecord.Status.FINISHED).first()

        if not consumeOrder:
            logger.info('do card finished --> no order found or repeated submit orderNo:{}'.format(order_id))
            return

        openId = consumeOrder.openId

        consumeOrder.servicedInfo.update({
            DEALER_CONSUMPTION_AGG_KIND.REFUND_CARD: left_money.mongo_amount,
            DEALER_CONSUMPTION_AGG_KIND.CONSUME_CARD: amount.mongo_amount,
            DEALER_CONSUMPTION_AGG_KIND.SPEND_MONEY: (amount - left_money).mongo_amount,
            DEALER_CONSUMPTION_AGG_KIND.DURATION: '%d' % used_time,
            DEALER_CONSUMPTION_AGG_KIND.ELEC: '%.2f' % used_elec,
            'cardBalance': card_balance.mongo_amount,
            'reason': reason,
            'cardNo': card_no
        })
        consumeOrder.status = self.FINISHED
        consumeOrder.startTime = startTime
        consumeOrder.finishedTime = finishedTime
        consumeOrder.save()

        ServiceProgress.update_progress_and_consume_rcd(
            self.dev['ownerId'],
            {
                'open_id': openId,
                'device_imei': self.devNo,
                'isFinished': False,
                'weifuleOrderNo': order_id,
            },
            consumeOrder.servicedInfo,
            progressDict={'isFinished': True, 'finished_time': finishedTimeStamp}
        )

        user = consumeOrder.user
        group = Group.get_group(self.dev['groupId'])

        extra = [
            # {u'订单号': '{}'.format(consumeOrder.orderNo)},
            {u'本次使用时长': '{}(分钟)'.format(used_time)},
            {u'卡片余额': '{}(元)'.format(card_balance)},
        ]

        self.smartbox.notify_user_service_complete(
            service_name='刷卡充电',
            openid=user.managerialOpenId if user else '',
            port=str(port),
            address=group['address'],
            reason=reason,
            finished_time=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra
        )
        logger.info('card start event orderNo:{} is over'.format(order_id))

        self.adapter.async_update_portinfo_from_dev()

    def _register_card_service_progress(self, card, port, consumeOrder, weifuleOrderNo=None, attachParas=None):
        return ServiceProgress.objects.create(
            open_id=card.openId,
            device_imei=self.devNo,
            devTypeCode=self.dev.devTypeCode,
            port=port,
            cardId=str(card.id),
            attachParas=attachParas if attachParas else {},
            start_time=int(time.time()),
            finished_time=int(time.time() + 24 * 60 * 60),
            consumeOrder=consumeOrder if consumeOrder else {},
            weifuleOrderNo=weifuleOrderNo,
        ).id

    def _card_refund_do_record_finished(self):
        card_no = self.order_info.get('card_no')
        card_balance = RMB.fen_to_yuan(self.order_info.get('balance'))
        refundMoney = RMB.fen_to_yuan(self.order_info.get('refund'))

        finishedTime = self.order_info.get('over_time')
        finishedTime = datetime.datetime.fromtimestamp(finishedTime).strftime('%Y-%m-%d %H:%M:%S')

        card = self.smartbox.update_card_dealer_and_type(card_no, cardType='IC', balance=card_balance)
        if card:
            logger.info('Card balance sync completed, cardNo:{} , refundMoney:{} ,finishedTime:{}'.format(
                card_no, refundMoney.mongo_amount, finishedTime))

            title = make_title_from_dict([
                {u'设备地址': u'{}'.format(self.dev.group.address)},
                {u'设备编号': u'{}'.format(self.dev['logicalCode'])},
                {u'实体卡': u'{}--No:{}'.format(card.cardName, card.cardNo)},
                {u'卡余额': u'{} 元'.format(card_balance)},
            ])

            self.smartbox.notify_user(
                card.managerialOpenId,
                'refund_coins',
                **{
                    'title': title,
                    'backCount': u'%s 元' % refundMoney,
                    'finishTime': finishedTime
                }
            )

        else:
            logger.info(
                'Card balance sync failed, cardNo:{} , refundMoney:{} ,finishedTime:{}'.format(
                    card_no, refundMoney.mongo_amount, finishedTime))