manyi/apps/web/user/utils.py

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

import datetime
import hashlib
import json
import logging
import os
import string
import time
import traceback
import urllib
import urlparse
from collections import defaultdict, OrderedDict
from decimal import Decimal
from functools import wraps, partial

import requests
from aliyunsdkcore.http.method_type import GET
from django.conf import settings
from django.core.cache import cache
from django.utils.module_loading import import_string
from mongoengine import NotUniqueError, DoesNotExist, MultipleObjectsReturned, Q
from requests.exceptions import ConnectTimeout
from typing import TYPE_CHECKING, Optional, Union, Dict

from apilib.monetary import VirtualCoin, RMB, Ratio
from apilib.utils import fix_dict
from apilib.utils_json import JsonResponse
from apilib.utils_string import cn, get_random_str
from apilib.utils_url import before_frag_add_query
from apps import serviceCache
from apps.web.agent.models import Agent, MoniApp
from apps.web.common.models import ExceptionLog, MonthlyPackageTemp
from apps.web.common.proxy import ClientConsumeModelProxy
from apps.web.common.transaction import OrderNoMaker, OrderMainType, UserPaySubType
from apps.web.constant import Const, ErrorCode, USER_RECHARGE_TYPE, APP_TYPE, AppPlatformType
from apps.web.core import PayAppType, ROLE
from apps.web.core.accounting import Accounting
from apps.web.core.auth.wechat import WechatAuthBridge
from apps.web.core.bridge import WechatClientProxy
from apps.web.core.exceptions import ServiceException, InvalidParameter, InterceptException
from apps.web.core.helpers import ActionDeviceBuilder
from apps.web.core.models import WechatPayApp, WechatAuthApp
from apps.web.dealer.models import Dealer, VirtualCard
from apps.web.device.define import DeviceChannelType
from apps.web.device.models import Device, Group
from apps.web.exceptions import UserServerException
from apps.web.helpers import get_wechat_auth_bridge, get_wechat_user_manager_mp_proxy, get_app, get_user_manager_agent, \
    DealerCustomizedBrandVisitor, AgentCustomizedBrandVisitor, get_platform_promotion_pay_gateway
from apps.web.report.ledger import Ledger
from apps.web.user import Cookies, UserAuthState
from apps.web.user.conf import USER_AUTH_REDIRECT_URL
from apps.web.user.models import MyUser, Card, RechargeRecord, UserVirtualCard, \
    ServiceProgress, ConsumeRecord, MoniUser, BlackListUsers, Redpack, MyUserDetail
from apps.web.user.payments import gen_quick_pay_purchase_subject, gen_recharge_purchase_subject
from apps.web.user.utils2 import ConsumeOrderStateEngine
from apps.web.utils import supported_app, detect_wechat_client, detect_alipay_client, detect_jdpay_client, \
    detect_jdjr_client, NotSupportedPlatformResponseRedirect, \
    UserRechargeResponseRedirect, UserCenterResponseRedirect, FollowGZHResponseRedirect, \
    CardRechargeResponseRedirect, BtDeviceResponseRedirect, NetDeviceResponseRedirect, HuopoDoorResponseRedirect, \
    ExternalResponseRedirect, CountDownResponseRedirect, \
    MoniGZHResponseRedirect, OneCardGateResponseRedirect, concat_front_end_url

logger = logging.getLogger(__name__)

if TYPE_CHECKING:
    from apps.web.device.models import GroupDict, DeviceDict

    from django.http.response import HttpResponse, HttpResponseRedirect

    from apps.web.core.payment import PaymentGateway, WechatMiniPaymentGatewayT
    from django.core.handlers.wsgi import WSGIRequest
    from apps.web.core import PayAppBase
    from apps.web.dealer.models import OnSale


def get_homepage_response(platform_type, user, dev, chargeIndex, product_agent):
    # type:(str, MyUser, DeviceDict, str, Agent)->HttpResponseRedirect

    def _set_recent_cookies(response):
        # type: (HttpResponse)->None
        response.set_cookie(
            key = Cookies.Recent_DevNo, value = dev.devNo, max_age = 24 * 3600, domain = settings.COOKIE_DOMAIN)

    if platform_type == AppPlatformType.WECHAT:
        moniFollowEnable = dev.owner.supports("moniAPPEnable")

        if moniFollowEnable:
            wechat_mp_proxy = get_wechat_user_manager_mp_proxy(product_agent)
            bound_open_id = user.get_bound_pay_openid(wechat_mp_proxy.bound_openid_key)

            if not bound_open_id:
                logger.error('no bound open id.')
                moniFollowEnable = False
            else:
                moniUser = MoniUser.objects(moniAppId = wechat_mp_proxy.appid, moniOpenId = bound_open_id).first()
                if moniUser:
                    if (datetime.datetime.now() - moniUser.checkTime).total_seconds() > 24 * 60 * 60 * 30:
                        moniFollowEnable = True
                    else:
                        moniFollowEnable = False

        if moniFollowEnable:
            # 再查找一次moniApp
            inhouseMoniApp = MoniApp.get_inhouse_app()

            moniAuthProxy = WechatClientProxy(
                WechatAuthApp(appid = inhouseMoniApp.appid, secret = inhouseMoniApp.secret))
            boundOpenId = user.get_bound_pay_openid(moniAuthProxy.bound_openid_key)

            # 找到openId 进行判断 如果不存在boundOpenId 那么需要进行鉴权
            if not boundOpenId:
                moniAuthBridge = WechatAuthBridge(moniAuthProxy.app)
                userState = UserAuthState.by_dev(
                    devNo = dev.devNo,
                    productAgentId = str(product_agent.id),
                    agentId = str(dev.owner.agentId),
                    chargeIndex = chargeIndex,
                    uid = str(user.id),
                    appid = inhouseMoniApp.appid
                )
                return ExternalResponseRedirect(
                    moniAuthBridge.generate_auth_url_base_scope(
                        redirect_uri = USER_AUTH_REDIRECT_URL.MONI_BASE,
                        payload = userState.encode()
                    )
                )

            # 存在 boundOpenId 的情况下 去判断下用户到底有没有关注
            moniUser = MoniUser.get_or_create(
                moniOpenId = boundOpenId, moniAppId = moniAuthProxy.appid,
                openId = user.openId, subLogicalCode = dev.logicalCode, subDealerId = dev.ownerId,
                subAgentId = dev.owner.agentId, subPoint = "scabCode"
            )
            if moniUser and moniUser.isSubscribe:
                moniSubscribed = True
            else:
                moniSubscribed = moniAuthProxy.is_subscribe_gzh(boundOpenId)

            # 没有订阅的 需要关注去订阅了 订阅的二维码由appId生成
            if not moniSubscribed:
                logicalCode = dev.logicalCode if dev else ""
                productAgentId = str(product_agent.id)
                openId = user.openId
                chargeIndex = chargeIndex or ""

                # 通过参数生成二维码
                sceneStr = "{}:{}:{}:{}".format(productAgentId, openId, logicalCode, chargeIndex)

                ticket = moniAuthProxy.get_qr_str_scene(sceneStr)
                if ticket:
                    return MoniGZHResponseRedirect(ticket)

    # 霍珀首页适配
    if dev["devType"]["code"] == Const.DEVICE_TYPE_CODE_HP_GATE:
        response = HuopoDoorResponseRedirect(l = dev.logicalCode, port = chargeIndex)
        _set_recent_cookies(response)
        return response

    if dev["devType"]["code"] == Const.DEVICE_TYPE_CODE_ONE_CARD:
        response = OneCardGateResponseRedirect(l = dev.logicalCode, port = chargeIndex)
        _set_recent_cookies(response)
        return response

    if dev["devType"]["code"] == Const.DEVICE_TYPE_CODE_AHZT:
        response = CardRechargeResponseRedirect(l = dev.logicalCode)
        _set_recent_cookies(response)
        return response

    # 久恒门禁
    if dev['devType']['code'] == Const.DEVICE_TYPE_CODE_JH_GATE:
        balance = user.calc_currency_balance(dev.owner, dev.group)
        if balance > VirtualCoin(0):
            smart_box = ActionDeviceBuilder.create_action_device(dev)
            try:
                smart_box.start(None, user.openId, None)
            except ServiceException as e:
                logger.error(str(e))

            response = UserCenterResponseRedirect()
        else:
            response = UserRechargeResponseRedirect(dev.logicalCode)

        _set_recent_cookies(response)
        return response

    # 支付宝蓝牙流程
    if dev.channelType == DeviceChannelType.Channel_BT:
        response = BtDeviceResponseRedirect(l = dev.logicalCode, port = chargeIndex)
        _set_recent_cookies(response)
        return response

    # 支持倒计时页面
    smart_box = ActionDeviceBuilder.create_action_device(dev)
    if smart_box.support_count_down(user.openId, chargeIndex) and dev['status'] in [Const.DEV_WORK_STATUS_WORKING,
                                                                                    Const.DEV_WORK_STATUS_PAUSE]:
        response = CountDownResponseRedirect(devNo = dev.devNo, port = chargeIndex)
        _set_recent_cookies(response)
        return response

    response = NetDeviceResponseRedirect(l = dev.logicalCode, port = chargeIndex)
    _set_recent_cookies(response)
    return response


def auth_wechat_pay_app(user, dealer, product_agent, state, redirect_uri):
    # type:(MyUser, Dealer, Agent, UserAuthState, str)->Optional[HttpResponseRedirect]

    app = get_app(source = product_agent,
                  app_type = APP_TYPE.WECHAT_ENV_PAY,
                  role = ROLE.myuser)  # type: PayAppBase

    if isinstance(app, WechatPayApp):
        auth_bridge = WechatAuthBridge(app)  # type: WechatAuthBridge

        bound_open_id = user.get_bound_pay_openid(auth_bridge.bound_openid_key)
        if bound_open_id:
            logger.debug('auth bridge<{}> has openid<{}>'.format(repr(auth_bridge), bound_open_id))
            return None
        else:
            logger.debug('auth bridge<{}> need auth to get openid'.format(repr(auth_bridge)))
            return ExternalResponseRedirect(
                auth_bridge.generate_auth_url_base_scope(redirect_uri = redirect_uri,
                                                         payload = state.encode()))


def auth_wechat_manager_app(my_user, product_agent, state, dev):
    # type:(MyUser, Agent, UserAuthState, DeviceDict)->Optional[HttpResponseRedirect]

    auth_bridge = get_wechat_auth_bridge(product_agent, APP_TYPE.WECHAT_AUTH)
    manager_auth_bridge = get_wechat_auth_bridge(product_agent, APP_TYPE.WECHAT_USER_MANAGER)

    manager_openid = my_user.get_bound_pay_openid(manager_auth_bridge.bound_openid_key)

    if manager_openid and (my_user.managerialOpenId != manager_openid):
        my_user.managerialAppId = manager_auth_bridge.appid
        my_user.managerialOpenId = manager_openid
        my_user.save()

    if manager_openid:
        force_follow_gzh = dev.owner.force_follow_gzh
        if force_follow_gzh:
            wechat_mp_proxy = get_wechat_user_manager_mp_proxy(product_agent)
            if not wechat_mp_proxy.is_subscribe_gzh(manager_openid):
                logger.debug(
                    'user<openId={},groupId={}> need to subscribe gzh.'.format(my_user.openId, my_user.groupId))
                MoniUser.get_or_create(
                    moniOpenId = manager_openid, moniAppId = wechat_mp_proxy.appid,
                    openId = my_user.openId, subLogicalCode = dev.logicalCode, subDealerId = dev.ownerId,
                    subAgentId = dev.owner.agentId, subPoint = "scabCode", checkTime = datetime.datetime.now())
                return FollowGZHResponseRedirect(agentId = str(product_agent.id))

    if manager_openid and my_user.nickname:
        return None

    if auth_bridge.appid == manager_auth_bridge.appid:
        if dev.owner.show_auth_window:
            return ExternalResponseRedirect(
                manager_auth_bridge.generate_auth_url_user_scope(
                    redirect_uri = USER_AUTH_REDIRECT_URL.WECHAT_MANAGER_AUTH_USER,
                    payload = state.encode()))
        else:
            return None

    else:
        if manager_openid:
            if dev.owner.show_auth_window:
                return ExternalResponseRedirect(
                    manager_auth_bridge.generate_auth_url_user_scope(
                        redirect_uri = USER_AUTH_REDIRECT_URL.WECHAT_MANAGER_AUTH_USER,
                        payload = state.encode()))
            else:
                return None
        else:
            return ExternalResponseRedirect(
                manager_auth_bridge.generate_auth_url_base_scope(
                    redirect_uri = USER_AUTH_REDIRECT_URL.WECHAT_MANAGER_AUTH_BASE,
                    payload = state.encode()))


def login_required(func = None, error_response = None):
    if func is None: return partial(login_required, error_response = error_response)

    @wraps(func)
    def wrapper(request, *args, **kwargs):
        if not supported_app(request):
            return NotSupportedPlatformResponseRedirect()

        is_right_role = lambda r: r == request.user.__class__.__name__

        if hasattr(request, 'user') and request.user:
            if (request.user.is_authenticated()) and (any(map(is_right_role, (ROLE.myuser)))):
                return func(request, *args, **kwargs)

        if error_response is None:
            return JsonResponse({"payload": {}}, status = 401)
        else:
            return error_response() if callable(error_response) else error_response

    return wrapper


def user_balance_cache(openId):
    # type:(str)->str
    return 'balance_{openId}'.format(openId = openId)


def user_last_time_use_ended_cache(openId, logicalCode):
    # type:(str, str)->str
    return 'last_time_use_{openId}_{logicalCode}'.format(openId = openId, logicalCode = logicalCode)


def moyaya_half_price_cache(openId, logicalCode):
    # type:(str, str)->str
    return 'half_price_{openId}_{logicalCode}'.format(openId = openId, logicalCode = logicalCode)


def parse_auth_payload(request):
    # type: (WSGIRequest)->UserAuthState

    state_str = request.GET.get('payload', None)

    if state_str is None:
        raise InvalidParameter(u'所传参数为空')

    state = UserAuthState.decode(state_str)
    if not state.is_valid():
        raise InvalidParameter(u'网络开小差了, 重新扫码试试喔(%s)' % ErrorCode.USER_STATE_IS_NOT_VALID)

    return state


def calc_real_package(openId, logicalCode, package):
    coins = VirtualCoin(package['coins'])
    money = RMB(package['price'])

    if VirtualCoin(serviceCache.get(moyaya_half_price_cache(openId, logicalCode), -1)) == coins:
        money = money * Decimal('0.50')

    return coins, money


class OrderBuilderContext(object):
    def __init__(self, user, device, group, pay_gateway):
        self.user = user
        self.device = device
        self.group = group
        self.pay_gateway = pay_gateway
        self.dealer = self.device_or_group.owner

    @property
    def device_or_group(self):
        return self.device or self.group


class RechargeRecordBuilder(object):
    @staticmethod
    def _new_recharge_record(context, out_trade_no, via, money, coins, subject, attachParas, **kwargs):
        # type: (OrderBuilderContext, str, str, RMB, VirtualCoin, basestring, Dict, Dict)->RechargeRecord

        extra_info = kwargs.pop('extraInfo', {})
        extra_info.update({
            'dealerId': context.device_or_group.ownerId,
            'agentId': context.user.agentId
        })

        if money <= RMB(0):
            raise ServiceException({'result': 0, 'description': u'支付金额不得小于或等于0'})

        if context.pay_gateway:
            gateway_type = context.pay_gateway.gateway_type
            assert gateway_type in AppPlatformType.choices(), 'invalid pay gateway type'

            pay_app_type = context.pay_gateway.pay_app_type
            assert pay_app_type in PayAppType.choices(), 'invalid pay app type'

        payload = {
            'orderNo': out_trade_no,
            'ownerId': context.device_or_group.ownerId,

            'money': money,
            'coins': coins,

            'wxOrderNo': '',
            'result': RechargeRecord.PayResult.UNPAY,
            'via': via,
            'subject': subject,
            'attachParas': attachParas,
            'extraInfo': extra_info
        }

        payload.update(context.device_or_group.identity_info)

        payload.update(**kwargs)

        try:
            return RechargeRecord.issue_pay_record(context=context, **payload)
        except NotUniqueError:
            raise ServiceException({'result': 0, 'description': u'您已发起支付'})

    @staticmethod
    def new_recharge_record(payParam):
        # type: (PayParam)->RechargeRecord

        user = payParam._payer
        device = payParam._device
        group = payParam._group
        ruleId = payParam._ruleId
        attachParas = payParam._attachParas
        pay_gateway = payParam._payGateway

        if not group.rule_is_accepted(ruleId):
            raise ServiceException({'result': 0, 'description': u'组内未找到所提供ruleId'})

        money = RMB(ruleId)
        coins = VirtualCoin(group['ruleDict'][ruleId])

        if coins <= VirtualCoin(0):
            raise ServiceException({'result': 0, 'description': u'充值金币数额不得小于或等于0'})

        logger.info(
            'make new recharge order. gateway = %s; user = %s; ruleId = %s, money = %s, attachParas = %s'
            % (pay_gateway.gateway_type, repr(user), ruleId, money, attachParas))

        order_no = OrderNoMaker.make_order_no_32(
            identifier = device.logicalCode, main_type = OrderMainType.PAY, sub_type = UserPaySubType.RECHARGE)

        context = OrderBuilderContext(user = user, device = device, group = group, pay_gateway = pay_gateway)
        return RechargeRecordBuilder._new_recharge_record(context=context,
                                                          out_trade_no = order_no,
                                                          via = USER_RECHARGE_TYPE.RECHARGE,
                                                          money = money,
                                                          coins = coins,
                                                          subject = payParam.subject,
                                                          attachParas = attachParas,
                                                          **{
                                                              'isQuickPay': False,
                                                              'selectedQuickPayPackageId': None
                                                          })

    @staticmethod
    def new_start_device_record(payParam):
        consumeOrder = payParam._order  # type: ConsumeRecord
        pay_gateway = payParam._payGateway
        attachParas = payParam._attachParas

        order_no = OrderNoMaker.make_order_no_32(
            identifier=consumeOrder.logicalCode,
            main_type=OrderMainType.PAY,
            sub_type=UserPaySubType.QUICK_PAY
        )

        context = OrderBuilderContext(
            user=consumeOrder.user,
            device=consumeOrder.device,
            group=consumeOrder.group,
            pay_gateway=pay_gateway
        )
        return RechargeRecordBuilder._new_recharge_record(
            context=context,
            out_trade_no=order_no,
            via=USER_RECHARGE_TYPE.START_DEVICE,
            money=consumeOrder.price,
            coins=consumeOrder.price,
            subject=payParam.subject,
            attachParas=attachParas,
            **{
                'isQuickPay': True,
            })

    @staticmethod
    def new_consume_order_recharge_record(payParam):
        # type: (PayParam)->RechargeRecord

        consumeRecord = payParam._consumeRecord
        user = payParam._payer
        device = payParam._device
        group = payParam._group
        attachParas = payParam._attachParas
        pay_gateway = payParam._payGateway

        money = RMB(consumeRecord.price)
        coins = VirtualCoin(consumeRecord.price)

        logger.info('make charge consume order. user = %s; money = %s' % (repr(user), money))

        order_no = OrderNoMaker.make_order_no_32(
            identifier=device.logicalCode,
            main_type=OrderMainType.PAY,
            sub_type=UserPaySubType.CASH_PAY
        )
        attachParas.update({"orderNo": consumeRecord.orderNo})

        context = OrderBuilderContext(user=user, device=device, group=group, pay_gateway=pay_gateway)

        return RechargeRecordBuilder._new_recharge_record(
            context=context,
            out_trade_no=order_no,
            via=USER_RECHARGE_TYPE.RECHARGE_CASH,
            money=money,
            coins=coins,
            subject=payParam.subject,
            attachParas=attachParas
        )

    @staticmethod
    def new_card_recharge_record(payParam):
        card = payParam._card
        user = payParam._payer
        device = payParam._device
        group = payParam._group
        attachParas = payParam._attachParas
        pay_gateway = payParam._payGateway

        attachParas.update({
            'cardNo': card.cardNo
        })

        if card.id:  # 直接设备充值的时候构造了一个内存Card, id为空
            attachParas.update({
                'cardId': str(card.id),
            })

        money = RMB(attachParas.get('price', 0))
        coins = VirtualCoin(attachParas.get('coins'))

        logger.info('make charge card order. user = %s; money = %s' % (repr(user), money))

        order_no = OrderNoMaker.make_order_no_32(identifier=str(attachParas['cardNo']),
                                                 main_type=OrderMainType.PAY,
                                                 sub_type=UserPaySubType.CARD_RECHARGE)

        context = OrderBuilderContext(user=user, device=device, group=group, pay_gateway=pay_gateway)
        return RechargeRecordBuilder._new_recharge_record(context=context,
                                                          out_trade_no=order_no,
                                                          via=USER_RECHARGE_TYPE.RECHARGE_CARD,
                                                          money=money,
                                                          coins=coins,
                                                          subject=payParam.subject,
                                                          attachParas=attachParas)




class BatteryInfo(object):
    TOKEN_URL = "http://litapi.gmiot.net/1/auth/access_token?"
    TRACK_URL = "http://litapi.gmiot.net/1/devices/tracking?"

    ACCOUNT = "15595278025"
    PW = 'aqkj168'

    TOKEN_FIELD_NAME = "access_token"
    STATUS_FIELD_NAME = "status"

    TOKEN_CACHE_PRE = "AQ_API_TOKEN"

    TOKEN_EXPIRE_TIME = 3600

    @staticmethod
    def myMd5(data):
        return hashlib.md5(data.encode("utf-8")).hexdigest().lower()

    @staticmethod
    def getTokenSign(ntime, pw):
        return BatteryInfo.myMd5(BatteryInfo.myMd5(pw) + ntime)

    @staticmethod
    def sendRequest(url, timeout = 3):
        try:
            result = requests.post(url = url, timeout = timeout)
            if result.status_code != 200:
                raise Exception(u"response status is not equal 200")
        except Exception as e:
            logger.info("api request error, reason is %s" % e)
            raise e

        jsonData = result.json()
        if jsonData.get("ret") != 0:
            logger.error("api request return error ret code ret is %s and msg is %s" % (
                jsonData.get("ret"), jsonData.get("msg")))

        return jsonData

    @staticmethod
    def joinUrl(url, **kwargs):
        from six.moves.urllib import parse
        query_params = parse.urlencode(kwargs)
        return "{}{}".format(url, query_params)

    @staticmethod
    def decodeStatus(status):
        # 第七到八个字节是电池电压信息 单位0.01v
        return int(status[12: 14], 16) + (int(status[14:16], 16) * 0.01)

    @property
    def token(self):
        # 缓存获取token
        token = serviceCache.get(self.TOKEN_CACHE_PRE)
        if not token:
            ntime = str(int(time.time()))
            url = self.joinUrl(self.TOKEN_URL, account = self.ACCOUNT, time = ntime,
                               signature = self.getTokenSign(ntime, self.PW))
            data = self.sendRequest(url)
            token = data.get(self.TOKEN_FIELD_NAME)

            serviceCache.set(self.TOKEN_CACHE_PRE, token, 3600)

        return token

    def getBatteryInfo(self, imeis):
        """ 获取电池状态 """
        url = self.joinUrl(self.TRACK_URL, access_token = self.token, imeis = imeis)

        result = dict()
        data = self.sendRequest(url = url).get("data")
        if not data:
            return dict()
        for item in data:
            # 添加电压解析信息
            item.update({"voltage": self.decodeStatus(item.get(self.STATUS_FIELD_NAME))})
            result.update(
                {
                    item.get("imei"): item
                }
            )

        return result

    def __call__(self, imeis):
        if isinstance(imeis, list):
            imeis = ",".join(imeis)
        return self.getBatteryInfo(imeis)


batteryInfo = BatteryInfo()


class IsNeedRenew(object):
    """
    虚拟卡是否即将过期
    """

    def __init__(self, userCard = None):
        self._userCard = userCard

    def check_renew(self):
        if not self._userCard or not self._userCard.cardTypeId or self._userCard.continueTime:
            return False, -1

        cardType = self.cardType
        # 有的暂停发售的卡也需要能够续卡
        if cardType is None or (not cardType.renewIgnoreStatus and cardType.status != 1) or (
                cardType.renewIgnoreStatus and cardType.status not in [0, 1]):
            return False, -1

        nowTime = datetime.datetime.now()
        leftDays = (self._userCard.expiredTime - nowTime).days
        if -cardType.needRenewMax < leftDays < cardType.needRenewMin:
            return True, leftDays

        return False, -1

    @property
    def cardType(self):
        """
        快速查询, 考虑是否需要用缓存实现
        :return:
        """
        # TODO　缓存实现
        cardTypeId = self._userCard.cardTypeId
        _cardType = VirtualCard.objects.filter(id = cardTypeId).first()
        return _cardType

    def __call__(self, userCard):
        self._userCard = userCard
        return self.check_renew()


is_need_renew = IsNeedRenew()


def check_user_tel(user):
    return False if user.phone else True


# 校验用户是否绑定了校园卡
def check_user_bind_card(user):
    return False if user.extra.get('campus_user_num', None) else True


def check_black_user(dealerId, openId):
    return BlackListUsers.check_black(openId = openId, dealerId = dealerId)


def user_pay_coin(openId, devNo, groupId, ownerId, payCount):
    """
    对用户的金币进行扣款 逐个地址进行扣除
    """
    deduct_list = []

    try:
        Accounting.recordNetPayCoinCount(devNo)

        first_user = MyUser.objects(openId = openId, groupId = groupId).get()
        first_user.update(inc__total_consumed = payCount)

        user_list = [first_user]

        group_list = [str(_.id) for _ in Group.objects(ownerId = ownerId, id__ne = groupId).only('id')]
        last_users = MyUser.objects(openId = openId, balance__gt = 0.0, groupId__in = group_list)

        user_list += list(last_users)

        should_pay = VirtualCoin(payCount)
        for user in user_list:  # type: MyUser
            min_pay = min(VirtualCoin(user.balance), VirtualCoin(should_pay))

            deduct_list.append({
                'id': str(user.id),
                'field': 'balance',
                'before': VirtualCoin(user.balance).mongo_amount,
                'coins': min_pay.mongo_amount
            })

            user.pay(coins=min_pay)

            should_pay -= min_pay
            if should_pay <= VirtualCoin(0):
                break

        # 当前经销商下的所有余额都扣完了，还不够，就要扣代理商下的了(实际也只有代理商支持代理商扣费，才可能到此分支)
        # TODO 这里明显隐含了关系，需要显示出来
        if should_pay > VirtualCoin(0):
            my_users = MyUser.objects.filter(openId = openId, balance__gt = 0.0)

            agentDict = defaultdict()
            for user in my_users:
                if user.is_product_user():
                    # TODO 目前自定义公众号进入构成的用户并不记录任何金额信息, 所以直接跳过
                    continue

                tempGroup = Group.get_group(user.groupId)
                if tempGroup:
                    groupDealer = Dealer.objects(id = tempGroup['ownerId']).get()

                    if tempGroup['ownerId'] in agentDict:
                        groupAgentId = agentDict[tempGroup['ownerId']]
                        if groupDealer.agentId != groupAgentId:
                            continue
                    else:
                        groupAgentId = groupDealer.agentId
                        agentDict[tempGroup['ownerId']] = groupDealer.agentId

                    min_pay = min(user.balance, should_pay)  # type: VirtualCoin

                    deduct_list.append({
                        'id': str(user.id),
                        'field': 'balance',
                        'before': VirtualCoin(user.balance).mongo_amount,
                        'coins': min_pay.mongo_amount
                    })

                    user.pay(coins = min_pay)

                    should_pay -= min_pay
                    if should_pay <= VirtualCoin(0):
                        break

        if should_pay > VirtualCoin(0) or should_pay < VirtualCoin(0):
            raise UserServerException(u'支付扣除金币异常')

    except UserServerException, e:
        logger.error('user<openId={}> has not enough coins to pay for {}. something is wrong.'.format(openId, devNo))

        ExceptionLog.log(
            user = '{}<openId={}>'.format(MyUser.__class__.__name__, openId),
            exception = e.message,
            extra = {'devNo': devNo, 'deduct': deduct_list})

    except Exception as e:
        logger.exception(e)

        ExceptionLog.log(
            user = '{}<openId={}>'.format(MyUser.__class__.__name__, openId),
            exception = traceback.format_exc(),
            extra = {'devNo': devNo, 'deduct': deduct_list})


def freeze_user_balance(device, group, order, virtual_card = None):
    # type: (DeviceDict, GroupDict, ConsumeRecord, UserVirtualCard)->bool

    if order.paymentInfo['via'] == 'free':
        return True

    elif order.paymentInfo['via'] in ['netPay', 'coins', 'cash', 'coin']:
        MyUser.freeze_balance(str(order.id), order.paymentInfo['deduct'])

    elif order.paymentInfo['via'] == 'virtualCard':
        if not virtual_card:
            virtual_card = UserVirtualCard.objects(id = str(order.paymentInfo['itemId'])).first()  # type: UserVirtualCard

        if virtual_card:
            virtual_card.freeze_quota(order.package, str(order.id))
    else:
        raise ServiceException({'result': 0, 'description': u"不支持的支付类型"})


def recover_user_frozen_balance(device, group, order, virtual_card = None):
    # type: (DeviceDict, GroupDict, ConsumeRecord, UserVirtualCard)->bool

    if order.paymentInfo['via'] == 'free':
        return True
    elif order.paymentInfo['via'] in ['netPay', 'coins', 'cash', 'coin']:
        MyUser.recover_frozen_balance(str(order.id), order.paymentInfo['deduct'])
    elif order.paymentInfo['via'] == 'virtualCard':
        if not virtual_card:
            virtual_card = UserVirtualCard.objects(
                id = str(order.paymentInfo['itemId'])).first()  # type: UserVirtualCard

        if virtual_card:
            virtual_card.recover_frozen_quota(str(order.id))
    else:
        raise ServiceException({'result': 0, 'description': u"不支持的支付类型"})


def clear_frozen_user_balance(device, order, usedTime, spendElec, backCoins, user = None, virtual_card = None):
    # type: (DeviceDict, ConsumeRecord, float, float, VirtualCoin, MyUser, UserVirtualCard)->bool

    if order.paymentInfo['via'] == 'free':
        return True

    elif order.paymentInfo['via'] in ['netPay', 'coins', 'cash', 'coin']:
        if not user:
            user = MyUser.objects(openId = order.openId, groupId = order.groupId).first()  # type: MyUser

        if user:
            user.clear_frozen_balance(str(order.id), order.paymentInfo['deduct'], backCoins, order.coin)

    elif order.paymentInfo['via'] == 'virtualCard':
        if not virtual_card:
            virtual_card = UserVirtualCard.objects(
                id = str(order.paymentInfo['itemId'])).first()  # type: UserVirtualCard

        if virtual_card:
            virtual_card.clear_frozen_quota(str(order.id), usedTime, spendElec, backCoins)
    else:
        raise ServiceException({'result': 0, 'description': u"不支持的支付类型"})


def vCard_pay_coin(order, vCard, dev, group, package, attachParas, user = None):
    # type:(ConsumeRecord, UserVirtualCard, DeviceDict, GroupDict, dict, dict, MyUser)->None

    devNo = dev.devNo
    groupId = group['groupId']

    if not user:
        try:
            user = MyUser.objects(openId = order.openId, groupId = groupId).get()
        except DoesNotExist as e:
            logger.error('cannot find user openId=%s, groupId=%s' % (order.openId, groupId))
            raise e

    nickname = user.nickname

    # 扣除卡的额度，并把缓存记录到缓存中
    consumeRcd = vCard.consume(openId = order.openId, group = group, dev = dev, package = package,
                               attachParas = attachParas, nickname = nickname)
    if not consumeRcd:
        raise ServiceException({'result': 2, 'description': u"扣除虚拟卡额度的时候，出现异常，请重试"})
    else:
        # TODO 巨大的错误 对于冻结的方式来说 ，itemId 指的是卡Id 对于pay 方式来说 这个id又指的是 消费id  指代不一致 容易导致问题
        # TODO 这个地方重新修改 统一规定为 卡的ID 将代码全部检查一遍 之前定义为rcd id的全部重写逻辑
        order.paymentInfo = {
            'itemId': str(vCard.id),
            'via': "virtualCard",
            "money": RMB(order.money).mongo_amount,
            "coins": VirtualCoin(order.coin).mongo_amount,
            "rcdId": str(consumeRcd.id),
        }
        order.save()

        cInfo = Device.get_dev_control_cache(devNo)
        if attachParas.has_key('chargeIndex'):
            port = attachParas.get('chargeIndex')
            if cInfo.has_key(port):
                cInfo[port].update({'consumeRcdId': str(consumeRcd.id)})
                Device.update_dev_control_cache(devNo, cInfo)

    return consumeRcd


BUILDER_MAP = {
    "RECHARGE": RechargeRecordBuilder.new_recharge_record,
    "START_DEVICE": RechargeRecordBuilder.new_start_device_record,
    "RECHARGE_ORDER": RechargeRecordBuilder.new_consume_order_recharge_record,
    "RECHARGE_CARD": RechargeRecordBuilder.new_card_recharge_record,
}


class PayParam(object):
    """
    用户进入 payGateway 的时候 对于前台入参的解析校验
    所有的拉起支付,必定需要传入logicalCode或者groupId以及type参数
    """

    def __init__(self, request):
        # type: (WSGIRequest)->None

        self._request = request

        self._clientName = self._get_client_env(request)

        self._ua = request.META.get('HTTP_USER_AGENT')

        self._payer = request.user

        self._payload = self._parse_payload(request)

        self._recordBuilderKey = None

        self._consumeRecord = None
        self._vCard = None
        self._card = None
        self._order = None

        self._payType = self._payload.get("type", None)
        self._attachParas = self._fix_attach_paras(self.payload.get('attachParas', dict()))
        if self._payload.get('logicalCode', None):
            self._device = Device.get_dev_by_l(self._payload.get('logicalCode'))  # type: DeviceDict
            self._group = self._device.group  # type: GroupDict
            self._dealer = self._device.owner  # type: Dealer

        elif self._payload.get('groupId', None):
            self._device = None  # type: Optional[DeviceDict]
            self._group = Group.get_group(self._payload.get('groupId'))  # type: GroupDict
            self._dealer = self._group.owner  # type: Dealer

        elif self._attachParas.get("orderNo"):
            order = get_consume_order(self._attachParas["orderNo"]) # type: ConsumeRecord
            self._device = order.device
            self._group = order.group
            self._dealer = order.group.owner

        else:
            raise ServiceException({'result': 0, 'description': u'参数错误，请刷新重试(1001)'})

        self.common_check()

        self._payGateway = None
        self._subject = None
        self._source = None

        self._money = None
        self._coins = None
        self._discountInfo = None
        self._monthlyPackage = None

        if self._payType == 'startDevice':
            self.handle_param_with_start_device()

        elif self._payType in ['charge', 'forceCharge']:
            self.handle_param_with_recharge()

        elif self._payType == "orderPay":
            self.handle_param_with_order()

        elif self._payType == "chargeCard":
            self.handle_param_with_card()

        else:
            logger.error(
                "error pay type, payload is <{}>, attachParas is <{}>".format(self._payload, self._attachParas)
            )
            raise ServiceException({'result': 0, 'description': u'设备投放地址不属于该平台，请选择其他地址。'})

        product_agent = get_user_manager_agent(self._dealer)
        if self._payer.productAgentId != str(product_agent.id):
            logger.debug('product of {} is {}. is not belong to {}'.format(repr(self._dealer), repr(product_agent), repr(self._payer)))
            raise ServiceException({'result': 0, 'description': u'参数错误，请刷新重试(1002)'})

        self._product_agent = product_agent  # type: Agent

        # 获取支付网关
        self.load_pay_gateway()

    @property
    def UA(self):
        return self._ua

    @property
    def clientName(self):
        return self._clientName

    @property
    def _ruleId(self):
        return self._payload.get('ruleId', None) or self._attachParas.get('ruleId', None)

    @staticmethod
    def _fix_attach_paras(attachParas):
        # type: (dict)->dict

        return fix_dict(attachParas, ['chargeIndex'])

    def common_check(self):
        """
        支付前的公共参数校验 通用的校验都放在这个里面
        目前校验的
        1. 是否是拉黑用户 拉黑用户一律不允许充值
        2. 如果用户是个人中心的充值行为 校验是否是该平台下的用户
        :return:
        """

        # 经销商状态异常
        if not self._dealer.normal:
            raise ServiceException({"result": 0, "description": u"设备经销商账号异常，暂时不能支付。"})

        # 对于用户拉黑的处理
        if check_black_user(dealerId = str(self._dealer.id), openId = self._payer.openId):
            raise ServiceException({"result": 0, "description": u"暂不支持支付，请联系设备经销商解决。"})

        if not self._group:
            raise ServiceException({'result': 0, 'description': u'参数错误，请刷新重试(1002)'})

        # 校验组owner是否一致
        if self._group.ownerId != str(self._dealer.id):
            raise ServiceException({"result": 0, "description": u"设备参数错误，无法支付，请联系设备经销商解决(1001)。"})

        # 校验设备owner是否一致
        if self._device and self._device.ownerId != str(self._dealer.id):
            raise ServiceException({"result": 0, "description": u"设备参数错误，无法支付，请联系设备经销商解决(1002)。"})

        if not self._payType:
            raise ServiceException({'result': 0, 'description': u'参数错误，请刷新重试(1002)'})

    def call_check(self):
        """
        拉起支付检查. 支付作为唯一检测点
        :return:
        """
        if self._dealer.supports("support_collect_room_info"):
            myUserDetail = MyUserDetail.objects(openId = str(self._payer.openId),
                                                dealerId = str(self._dealer.id)).first()
            if not (myUserDetail and
                    myUserDetail.userName and
                    myUserDetail.userPhone and
                    myUserDetail.userUnit and
                    myUserDetail.userFloor and
                    myUserDetail.userRoom):
                raise InterceptException(redirect = before_frag_add_query(
                    concat_front_end_url(uri = '/user/index.html#/user/roomVerify'),
                    added_query = {
                        'ownerId': str(self._dealer.id),
                        'userName': myUserDetail and myUserDetail.userName or '',
                        'userPhone': myUserDetail and myUserDetail.userPhone or '',
                        'userUnit': myUserDetail and myUserDetail.userUnit or '',
                        'userFloor': myUserDetail and myUserDetail.userFloor or '',
                        'userRoom': myUserDetail and myUserDetail.userRoom or '',
                    }))

    @staticmethod
    def _get_client_env(request):
        if detect_wechat_client(request):
            return "wechat"
        elif detect_alipay_client(request):
            return "alipay"
        elif detect_jdpay_client(request) or detect_jdjr_client(request):
            return "jd"
        else:
            raise ServiceException({"result": 0, "description": u"不支持的客户端"})

    def _check_big_package(self, package):
        if RMB(package['price']) > self._dealer.maxPackagePrice:
            raise ServiceException({'result': 0, 'description': u'套餐支付金额超限'})

    def _check_big_charge(self, money):
        agent = Agent.objects.get(id = self._dealer.agentId)  # type: Agent
        max_pay_limit = int(agent.maxPayLimit)
        if money > RMB(max_pay_limit):
            raise ServiceException({'result': 0, 'description': u'支付金额超限(%d)' % ErrorCode.TOO_BIG_RECHARGE})

    def handle_param_with_recharge(self):
        """
        用户直接充值余额的参数处理
        对于用户的充值
        :return:
        """

        self._recordBuilderKey = "RECHARGE"

        ruleId = self._ruleId

        if not self._group.rule_is_accepted(ruleId):
            raise ServiceException({'result': 0, 'description': u'组内未找到所提供ruleId'})

        money = RMB(ruleId)
        coins = VirtualCoin(self._group['ruleDict'][ruleId])

        self._check_big_charge(money)

        if coins <= VirtualCoin(0):
            raise ServiceException({'result': 0, 'description': u'充值金币数额必须大于0金币'})

        if money <= RMB(0):
            raise ServiceException({'result': 0, 'description': u'支付金额必须大于0元'})

        self._money = money
        self._coins = coins

        self._subject = gen_recharge_purchase_subject(
            major_type=self._device.majorDeviceType[0:8],
            logicalCode=self._device.logicalCode
        )

        if self._payType == 'charge' and 'startKey' in self._attachParas:
            try:
                actionBox = ActionDeviceBuilder.create_action_device(self._device)
                actionBox.check_dev_status(self._attachParas)
            except ServiceException as e:
                logger.info('device(devNo=%s)(via %s)recharge failure. response==%s' % (
                    self._device.devNo, self._payGateway.gateway_type, e.result['description'].encode('utf-8'),))
                raise ServiceException({'result': 103, 'description': e.result['description'].encode('utf-8')})

    def handle_param_with_order(self):
        """
        订单的后支付流程 这个地方其实可以和start_device统一
        :return:
        """
        consumeRecordId = self._attachParas.get("consumeRecordId", "")

        consumeRecord = ConsumeRecord.objects.filter(id=consumeRecordId).first()
        if not consumeRecord:
            raise ServiceException({"result": 0, "description": u"查询消费记录失败，请刷新页面后再尝试支付"})

        if consumeRecord.status != consumeRecord.Status.END:
            raise ServiceException({"result": 0, "description": u"当前订单状态不允许支付"})

        if self._payer.openId != consumeRecord.openId:
            raise ServiceException({'result': 0, 'description': u'不是您消费的订单，无需为此支付费用'})

        if self._group.groupId != consumeRecord.groupId:
            raise ServiceException({'result': 0, 'description': u'支付失败，请联系经销商或客服'})

        self._consumeRecord = consumeRecord
        # 将运行结束的订单 切换为 等待支付的状态

        ConsumeOrderStateEngine(consumeRecord).to_wait_pay()

        self._recordBuilderKey = "RECHARGE_ORDER"

        self._subject = gen_quick_pay_purchase_subject(
            major_type = self._device.majorDeviceType[0:8],
            logicalCode = self._device.logicalCode,
            port = self.selected_port)

    def handle_param_with_start_device(self):
        self._recordBuilderKey = "START_DEVICE"
        orderNo = self.attachParas.get("orderNo")
        order = get_consume_order(orderNo)  # type: ConsumeRecord

        if not order:
            raise ServiceException({'result': 0, 'description': u'消费订单查询失败'})

        if order.status != order.Status.WAIT_CONF:
            raise ServiceException({"result": 2, "description": u"订单状态异常，请前往个人中心查看订单"})

        self._order = order
        self._check_big_charge(order.price)

        if self._order.price <= RMB(0):
            raise ServiceException({'result': 0, 'description': u'支付金额必须大于0元'})

        self._subject = gen_recharge_purchase_subject(
            major_type=order.device.majorDeviceType[0:8],
            logicalCode=order.logicalCode
        )

    def handle_param_with_card(self):
        self._recordBuilderKey = "RECHARGE_CARD"
        self._money = RMB(self._attachParas["price"])
        self._coins = VirtualCoin(self._attachParas["coins"])

        cardId = self._attachParas.get("cardId")
        if not cardId:
            raise ServiceException({"result": 0, "description": u"该卡不存在，请联系平台客服处理(1000)"})

        card = Card.objects.filter(id=str(cardId)).first()
        if not card:
            logger.error('card<id={}> not find'.format(cardId))
            raise ServiceException({'result': 0, 'description': u'该卡不存在，请联系平台客服处理(1001)'})

        if not card.dealerId or not card.groupId:
            logger.error('card<id={}> not bind dealer or group'.format(cardId))
            raise ServiceException({
                'result': ErrorCode.CARD_NEED_BIND_GROUP,
                'description': u'该卡未绑定开卡地址',
                'payload': {
                    'cardId': str(card.id),
                    'cardName': card.cardName,
                    'phone': card.phone,
                    'cardNo': card.cardNo
                }})

        if self._group.ownerId != card.dealerId:
            raise ServiceException({'result': 0, 'description': u'该卡不存在，请联系平台客服(1002)'})

        self._card = card

        self._subject = cn(u"实体卡充值 {}".format(card.cardNo))

    def load_pay_gateway(self):
        """
        加载支付网关 目前不支持商户的模式
        """
        source = self._product_agent
        visitor = AgentCustomizedBrandVisitor

        self._source = source

        funName = "get_{}_env_pay_gateway".format(self._clientName)

        get_env_pay_gateway_func = import_string("apps.web.helpers.{}".format(funName))

        payGateway = get_env_pay_gateway_func(source, role = ROLE.myuser, vistor = visitor)

        self._payGateway = payGateway

    def to_dict(self):
        return {
            "user": self._payer,
            "consumeRecord": self._consumeRecord,
            "vCard": self._vCard,
            "card": self._card,
            "device": self._device,
            "group": self._group,
            "dealer": self._dealer,
            "agent": self._product_agent,
            "gateWay": self._payGateway
        }

    def __str__(self):
        return "pay info is <{}>".format(self.to_dict())

    @property
    def payGateway(self):
        assert self._payGateway.pay_app_type in PayAppType.choices(), 'invalid pay app type'
        return self._payGateway

    @property
    def recordBuilderKey(self):
        assert self._recordBuilderKey in BUILDER_MAP.keys(), 'invalid build key'
        return self._recordBuilderKey

    @property
    def curUser(self):
        return self._payer  # type: MyUser

    @property
    def subject(self):
        return self._subject or ""

    @property
    def payload(self):
        return self._payload

    @property
    def attachParas(self):
        return self._attachParas

    @property
    def isQuickPay(self):
        return True if self._payload.get("quickPay") else False

    @property
    def source(self):
        return self._source

    @property
    def goodsInfo(self):
        info = {}

        info.update({
            "goodsName": cn(self._subject),
            "payPrice": str(self._money),
            "goodsPrice": str(self._money),
            "discountInfo": ""
        })

        return info

    @staticmethod
    def _parse_payload(request):
        """
        解析支付的参数
        历史遗留原因 之前的支付参数使用的是query传参 参数键为params
        现在的预下单接口 使用的是body-json传参
        """
        if request.method == GET:
            return json.loads(request.GET.get("params", '{}'))
        else:
            return json.loads(request.body)

    @property
    def showAd(self):
        return self._dealer.ad_show

    @property
    def selected_port(self):
        if not self._attachParas:
            return None

        if 'chargeIndex' in self._attachParas and \
                self._attachParas['chargeIndex'] and \
                self.attachParas['chargeIndex'] not in ['None', 'null', -1, '-1']:
            return str(self._attachParas['chargeIndex'])
        else:
            return None


class RedpackBuilder(object):
    @staticmethod
    def redpack_to_ledger(order):
        # type:(ConsumeRecord) -> None

        pay_app_type = order.user.gateway
        payGateway = get_platform_promotion_pay_gateway(pay_app_type = pay_app_type)

        # 红包订单建立 并分账
        redpackId = order.attachParas.get('redpackId')

        redpack = Redpack.get_one(redpackId)
        if not redpack:
            logger.error("redpack is null, is not valid record.")
            return

        redpack_attachParas = order.attachParas
        redpack_attachParas.update({'masterId': order.rechargeRcdId, 'startKey': order.startKey})

        dev = Device.get_dev(order.devNo)  # type: DeviceDict

        subject = gen_quick_pay_purchase_subject(
            major_type = dev.majorDeviceType[0:8], logicalCode = order.logicalCode, port = order.used_port)

        context = OrderBuilderContext(user = order.user, device = dev, group = dev.group, pay_gateway = payGateway)

        redpack_recharge_record = RechargeRecordBuilder._new_recharge_record(
            context = context,
            out_trade_no = OrderNoMaker.make_order_no_32(
                identifier = order.logicalCode,
                main_type = OrderMainType.PAY,
                sub_type = UserPaySubType.REDPACK
            ),
            via = USER_RECHARGE_TYPE.RECHARGE_REDPACK,
            money = RMB(redpack['redpackMoney']),
            coins = VirtualCoin(redpack['redpackCoins']),
            subject = subject,
            attachParas = redpack_attachParas,
            **{
                'isQuickPay': True,
                'selectedQuickPayPackageId': order.attachParas.get('packageId'),
                'result': RechargeRecord.PayResult.SUCCESS,
                'finishedTime': datetime.datetime.now(),
                'description': '平台红包',
            })

        ledger = Ledger(USER_RECHARGE_TYPE.RECHARGE_REDPACK, redpack_recharge_record)
        ledger.execute(journal = False, stats = True, check = False)

    @staticmethod
    def user_pay_coin_with_redpack(order):
        if Redpack.use_redpack(order.attachParas['redpackId'], str(order.id), order.package):
            redpack = Redpack.get_one(order.attachParas['redpackId'])
            deduct_coins = VirtualCoin(redpack.get('redpackCoins', 0))
            pay_count = round(VirtualCoin(order.package['coins']) - deduct_coins, 2)

            if pay_count > 0:
                user_pay_coin(order.openId, order.devNo, order.groupId, order.ownerId, pay_count)

            try:
                RedpackBuilder.redpack_to_ledger(order)
            except:
                import traceback
                logger.error(traceback.format_exc())


    @staticmethod
    def bt_user_pay_coin_with_redpack(order):
        if Redpack.use_redpack(order.attachParas['redpackId'], str(order.id), order.package):
            redpack = Redpack.get_one(order.attachParas['redpackId'])
            deduct_coins = VirtualCoin(redpack.get('redpackCoins', 0))
            pay_count = VirtualCoin(order.package['coins']) - deduct_coins

            if pay_count > VirtualCoin(0):
                device = Device.get_dev_by_l(order.logicalCode)
                errCode, errMsg = order.user.deduct_fee_for_bt(device, pay_count)
                if errCode != 1:
                    raise ServiceException({'result': errCode, 'description': errMsg})
            try:
                RedpackBuilder.redpack_to_ledger(order)
            except:
                import traceback
                logger.error(traceback.format_exc())

    @staticmethod
    def get_alipay_cpa_by_ruhui(openId, logicalCode, urlId='', showType='', **kw):

        if not urlId:
            urlId = ConsumeRecord.make_no()

        kw.update({
            'delayPay': 'true',
            'urlId': urlId,
            'logicalCode': logicalCode
        })

        dev = Device.get_dev_by_l(logicalCode)

        from apps.thirdparties.aliyun import AliRuHui
        RH = AliRuHui()

        extra = RedpackBuilder._connection_string(kw)

        params = {
            'urlId': urlId,
            # 'channelId': settings.ALIPAY_RUHUI_CHANNEL_ID,
            'alipayOpenId': openId,
            'outerCode': logicalCode,
            'extra': extra,
            'optionType': '1'
        }

        popUpQueryRequest = RH.PopUpQueryRequest(params)  # Type: Dict

        if popUpQueryRequest.get('Status') == True:
            money = RedpackBuilder.calc_by_amount(RMB(popUpQueryRequest.get('UnionAmount', 0)))
            if money == RMB(0):
                return {}

            else:
                import urlparse
                taskId = dict(urlparse.parse_qsl(popUpQueryRequest.get('Url'))).get('taskId')
                redpack = Redpack.create_redpack_by_ruhui(
                    taskId=taskId,
                    openId=openId,
                    urlId=urlId,
                    money=money,
                    leastPayMoney=RMB(0),
                    gateway='alipay',
                    logicalCode=logicalCode,
                    devNo=dev.devNo,
                    extra={'ApiPopUpQueryRequest': popUpQueryRequest},
                    showType=showType)

            return {'url': popUpQueryRequest.get('Url'), 'money': redpack.money.mongo_amount,
                    'redpackId': str(redpack.id), 'showType': showType, }
        else:
            return {}


    @staticmethod
    def get_alipay_cpa_by_ruhui_v3(openId, logicalCode, showType='', **kw):

        from apps.thirdparties.aliyun import AlipayYunMaV3
        RH = AlipayYunMaV3()

        dev = Device.get_dev_by_logicalCode(logicalCode)

        result = RH.get_cpa_ruhui_body(openId, logicalCode)
        logger.info(result)

        if result.body.success == True and len(result.body.result.seatbid[0].bid[0].ads):
            seatb = result.body.result.seatbid[0]
            urlId = result.body.result.id
            money = RMB.fen_to_yuan(seatb.bid[0].ads[0].price)
            money = RedpackBuilder.calc_by_amount(money)
            if money == RMB(0):
                return {}

            else:
                import urlparse
                url = seatb.bid[0].ads[0].crurl
                taskId = seatb.bid[0].ads[0].id
                redpack = Redpack.create_redpack_by_ruhui(
                    taskId=taskId,
                    openId=openId,
                    urlId=urlId,
                    money=money,
                    leastPayMoney=RMB(0),
                    gateway='alipay',
                    logicalCode=logicalCode,
                    devNo=dev.devNo,
                    extra={'ApiRequest': json.dumps(result.body.result.to_map(), ensure_ascii=False)},
                    showType=showType)

            return {'url': url, 'money': redpack.money.mongo_amount,
                    'redpackId': str(redpack.id), 'showType': showType, 'urlId': urlId}

        else:
            return {}

    @staticmethod
    def _connection_string(kw):
        # type: (dict) -> unicode
        """
            拼接字符串
        :param kw:
        :return:
        """
        return "&".join("{}={}".format(*_) for _ in kw.items())

    @classmethod
    def calc_by_amount(cls, unionAmount):
        # type: (RMB) -> Optional[RMB, bool]
        """
            随机金额
        """

        random_list = [0.1, 0.2, 0.2, 0.3, 0.3, 0.3, 0.4, 0.4, 0.5]
        import random

        radio = Ratio(random.choice(random_list))

        return unionAmount * radio

    @classmethod
    def get_alipay_cpa_by_laxin(cls, openId, channelId=None):

        TASKMAPNAME={
          '1': '关注天猫店铺领红包',
          '2': '关注天猫店铺领红包',
          '3': '关注淘宝店铺领红包',
          '4': '关注淘宝店铺领红包',
          '5': '浏览商品任务领红包',
          '6': '浏览商品任务领红包',
          '7': '看直播领红包',
          '8': '看直播领红包',
        }

        from apps.thirdparties.aliyun import AliLaXin
        ali = AliLaXin()

        resp = ali.QueryUnionPromotionRequest({'alipayOpenId': openId, 'channelId': channelId})

        code = resp.get('ErrorCode')
        dataList = []
        if code == 0:
            dataList = resp.get('Result', [])

            for item in dataList:
                item['alipayOpenId'] = openId
                item['channel'] = channelId or settings.ALIPAY_LAXIN_CHANNEL_ID
                item['taskName'] = TASKMAPNAME.get(item.get('taskType', ''), '')

        return dataList

    @classmethod
    def query_cpa_laxin_task_status(cls, taskId, openId):
        from apps.thirdparties.aliyun import AliLaXin
        ali = AliLaXin()
        resp = ali.GetUnionTaskStatusRequest({'taskId': taskId, 'alipayOpenId': openId})
        code = resp.get('ErrorCode')
        result = resp.get('Result')
        success = resp.get('Success')
        if code == 0 and result == True and success == True:
            return True
        else:
            return False

    @classmethod
    def create_cpa_laxin_redpack(cls, dev, taskId, openId, taskType):
        effectTime = datetime.datetime.now()
        expiredTime = datetime.datetime.now() + datetime.timedelta(days=30 * 3)

        return Redpack.create_redpack_by_laxin(factoryCode=taskId, openId=openId,
                                                  money=RMB(0.01), leastPayMoney=RMB(0),
                                                  effectTime=effectTime, expiredTime=expiredTime, gateway='alipay',
                                                  logicalCode=dev.logicalCode, devNo=dev.devNo, extra={'taskType':taskType})

    @staticmethod
    def _set_alipay_key(openId, taskId, urlId, money, showType):
        cache.set('alipayAd{}'.format(openId), {'taskId': taskId, 'urlId': urlId, 'money': money, 'showType': showType})


    @staticmethod
    def _pop_alipay_key(openId):
        result = cache.get('alipayAd{}'.format(openId))
        if result:
            cache.delete('alipayAd{}'.format(openId))
            return result


def get_consume_order(orderNo):     # type: (str) -> Optional[ConsumeRecord, None]
    return ConsumeRecord.objects.filter(Q(orderNo=orderNo) | Q(sequenceNo=orderNo)).first()