manyi/apps/web/user/models.py

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

"""
    web.user.models
    ~~~~~~~~~
"""
import copy
import datetime
import logging
import random
import string
import threading
import time
import uuid
from collections import Counter, defaultdict

from arrow import Arrow
from bson.objectid import ObjectId
from dateutil import relativedelta
from django.conf import settings
from django.utils.functional import cached_property
from mongoengine import Q
from mongoengine.document import EmbeddedDocument
from mongoengine.errors import NotUniqueError, DoesNotExist
from mongoengine.fields import (BooleanField, StringField, IntField, EmbeddedDocumentListField,
                                DateTimeField, PointField, DictField, ObjectIdField, ListField, EmbeddedDocumentField,
                                MapField, GenericLazyReferenceField, LazyReferenceField)
from pymongo.errors import DuplicateKeyError
from pymongo.results import UpdateResult
from typing import Union, Dict, AnyStr, Optional, TYPE_CHECKING, List, Tuple

from apilib.monetary import RMB, VirtualCoin, Ratio, Percent, Money
from apilib.quantity import Quantity
from apilib.systypes import IterConstant
from apilib.utils import flatten
from apilib.utils_datetime import generate_timestamp_ex, today_format_str, to_datetime, get_tomorrow_zero_time
from apilib.utils_mongo import BulkHandlerEx, dict_field_with_money
from apilib.utils_string import get_random_str
from apps import serviceCache
from apps.web.agent.models import Agent, MoniApp
from apps.web.common.models import OrderRecordBase, RefundOrderBase

from apps.web.common.transaction import OrderNoMaker, OrderMainType, UserPaySubType, UserConsumeSubType, RefundSubType
from apps.web.common.validation import CARD_NO_RE
from apps.web.constant import (Const,
                               DEALER_CONSUMPTION_AGG_KIND, GLOSSARY_TRANSLATION,
                               USER_RECHARGE_TYPE,
                               RECHARGE_CARD_TYPE,
                               AppPlatformType, APP_PLATFORM_TYPE_TRANSLATION,
                               RechargeRecordVia, RECHARGE_RECORD_VIA_TRANSLATION, ErrorCode,
                               DEVICE_INCOME_STRATEGY, support_policy_device, support_policy_weifule,
                               PARTITION_ROLE)
from apps.web.core import PayAppType, ROLE
from apps.web.core.bridge import WechatClientProxy
from apps.web.core.db import Searchable, MonetaryField, VirtualCoinField, RoleBaseDocument, BooleanIntField
from apps.web.core.exceptions import InsufficientFundsError, ServiceException, ImproperlyOperatedBalance
from apps.web.core.models import BoundOpenInfo
from apps.web.core.models import WechatAuthApp
from apps.web.dealer.models import Dealer, VirtualCard, DealerDict
from apps.web.device.models import Group, Device, DeviceType
from apps.web.exceptions import UserServerException, PostPayOrderError
from apps.web.report.ledger import AgentLedgerFirst, PartnerLedgerFirst
from apps.web.report.utils import record_consumption_stats
from apps.web.user.conf import REFUND_NOTIFY_URL
from apps.web.user.constant2 import StartDeviceType, PackageCategory, CONSUME_ORDER_PAY_TIMEOUT, ConsumeOrderServiceItem, UserBalanceChangeCategory
from apps.web.utils import concat_front_end_url, concat_user_login_entry_url, concat_user_center_entry_url, set_or_incr_cache, concat_count_down_page_url
from library.idgen import IDGenService
from apps.web.core.payment import PaymentGateway


logger = logging.getLogger(__name__)


if TYPE_CHECKING:
    from apps.web.device.models import FeedBack
    from apps.web.device.models import DeviceDict, GroupDict
    from apps.web.common.models import CapitalUser
    from apps.web.dealer.models import MonthlyPackageTemp
    from mongoengine.queryset import QuerySet
    from apps.web.dealer.models import DealerRechargeRecord
    from apps.web.user.utils2 import StartParamContext, check_consume_order_timeout


class MyUserAuthBackend(object):
    """
    部分接口需要用户鉴权，由于目前用户体系尚未完整建立，在这里首先实现MVP
    """

    # noinspection PyUnusedLocal
    def authenticate(self, **kwargs):
        return True

    def get_user(self, user_id):
        return self.user_document.objects.with_id(user_id)

    @property
    def user_document(self):
        self._user_doc = MyUser
        return self._user_doc


class EndUserLocation(EmbeddedDocument):
    logicalCode = StringField(verbose_name = '')
    # point :: { "type" : "Point" , "coordinates" : [longitude, latitude]}
    point = PointField(default = None, verbose_name = u'用户的经纬度')
    type = StringField(verbose_name = u'经纬度类型')
    createdTime = DateTimeField(default = datetime.datetime.now)

    @property
    def coordinates(self):
        if not self.point:
            return ()
        else:
            return tuple(self.point['coordinates'])

    def __repr__(self):
        return '<EndUserLocation (logicalCode=%s, point=(lng=%s, lat=%s), type=%s)>' \
               % (self.logicalCode,
                  self.point['coordinates'][0],
                  self.point['coordinates'][1],
                  self.type)


class UserMoney(EmbeddedDocument):
    settled = MonetaryField(verbose_name = "已经分账给经销商的金额", default = RMB('0.00'))  # type: RMB
    unsettled = MonetaryField(verbose_name = "未分账给经销商的金额", default = RMB('0.00'))  # type: RMB
    total_recharged = MonetaryField(default = RMB('0.00'))  # type: RMB
    total_consumed = MonetaryField(default = RMB('0.00'))  # type: RMB

    def __repr__(self):
        return '<UserMoney settled=%s, unsettled=%s, total_recharged=%s, total_consumed=%s>' \
               % (self.settled, self.unsettled, self.total_recharged, self.total_consumed)

    def to_dict(self):
        return {
            'settled': self.settled,
            'unsettled': self.unsettled,
            'total_recharged': self.total_recharged,
            'total_consumed': self.total_consumed
        }


class UserCoin(EmbeddedDocument):
    balance = VirtualCoinField(default = VirtualCoin('0.00'))
    total_recharged = VirtualCoinField(default = VirtualCoin('0.00'))
    total_consumed = VirtualCoinField(default = VirtualCoin('0.00'))

    def __repr__(self):
        return '<UserCoin balance=%s total_recharged=%s total_consumed=%s>' \
               % (self.balance, self.total_recharged, self.total_consumed)

    def to_dict(self):
        return {
            'balance': self.balance,
            'total_recharged': self.total_recharged,
            'total_consumed': self.total_consumed
        }


class UniqueUser(Searchable):
    openId = StringField(verbose_name='第三方用户ID(微信的OPENID,支付宝的UID)', null=False, unique=True)
    userId = StringField(verbose_name='用户平台UID')
    phone = StringField(verbose_name='电话号码', default="")

    meta = {
        'collection': 'unique_user',
        'db_alias': 'default',
        'indexes': [
            {'fields': ['userId'], 'unique': True, 'sparse': True}
        ]
    }

    @classmethod
    def get_or_create(cls, openId):  # type:(str) -> UniqueUser
        """
        创建或者是获取用户
        """
        user = cls.objects(openId = openId).first()
        if user:
            return user

        try:
            return cls(openId = openId).save()
        except DuplicateKeyError:
            return cls.objects(openId = openId).first()

    def update_phone(self, phone):      # type:(str) -> bool
        """
        更新电话号码
        """
        return bool(self.update(phone=phone))


class MyUser(RoleBaseDocument):
    """
    `EndUser`
    终端用户模型
    """
    sex = IntField(verbose_name=u"性别", default=Const.USER_SEX.UNKNOWN)
    phoneOS = StringField(verbose_name=u"终端操作系统", default="")
    city = StringField(verbose_name=u"城市", default="")
    province = StringField(verbose_name=u"省份", default="")
    country = StringField(verbose_name=u"国家", default="")

    avatar = StringField(verbose_name=u"头像地址", default="")
    nickname = StringField(verbose_name=u"名称", max_length=255, default="")
    groupId = StringField(verbose_name=u"地址编号", default="")
    gateway = StringField(verbose_name=u"来自支付宝或微信", default='wechat')

    chargeBalance = MonetaryField(verbose_name=u"余额", default=RMB('0'))
    bestowBalance = MonetaryField(verbose_name=u"赠送余额", default=RMB('0'))

    total_recharged = MonetaryField(verbose_name="累计充值", default=RMB('0'))
    total_bestow = MonetaryField(verbose_name=u"累计赠送", default=RMB('0'))
    total_consumed = VirtualCoinField(verbose_name="累计消费", default=RMB('0'))

    phoneNumber = StringField(verbose_name=u"用户手机号码", default="")

    authAppId = StringField(verbose_name=u"鉴权appid", default="")
    openId = StringField(verbose_name=u"openID|支付宝buyerID", default="")

    unionId = StringField(verbose_name=u"统一用户ID", default="")

    managerialAppId = StringField(verbose_name=u"管理公众号AppId", default="")
    managerialOpenId = StringField(verbose_name=u"管理openId", default="")

    payAppId = StringField(verbose_name=u"最近登录微信授权appid", default="")
    payOpenId = StringField(verbose_name=u"openId", default="")

    payOpenIdMap = MapField(EmbeddedDocumentField(BoundOpenInfo))

    extra = DictField(verbose_name=u"多余字段", default={})

    dateTimeAdded = DateTimeField(default=datetime.datetime.now, verbose_name=u'添加进来的时间')
    last_login = DateTimeField(default=datetime.datetime.now, verbose_name=u'最近登录时间')
    lastLoginUserAgent = StringField(verbose_name=u"最后一次登录的userAgent", default="")

    locations = EmbeddedDocumentListField(document_type=EndUserLocation)

    agentId = StringField(verbose_name=u'当前用户绑定的直接上级代理商', default='')
    productAgentId = StringField(verbose_name=u'当前用户绑定的平台代理商', default='')

    promo = DictField(verbose_name=u'活动相关信息', default={})
    favoriteDeviceList = ListField(verbose_name=u'收藏的宝贝', default=[])
    smsVendor = StringField(verbose_name=u'sms提供商', default='')
    ongoingList = ListField(field=DictField(), verbose=u'冻结的金额')
    blacklistConfig = DictField(verbose_name=u'黑名单相关设置', default={})

    meta = {
        "collection": "MyUser2",
        "db_alias": "default",
        "indexes": [{
            'fields': ['$openId', '$nickname'],
            'weights': {'openId': 10, 'nickname': 2}
        },
            'openId',
            'nickname',
            'dateTimeAdded',
            # 'groupId'
        ],
        # "shard_key": ('openId',)
    }

    search_fields = ('openId', 'nickname')

    _AGENT_GROUP_ID_PREFIX = 'agent_'

    __mgr_cache = serviceCache

    def __str__(self):
        return '{}<id={} openId={} groupId={}>'.format(self.__class__.__name__, str(self.id), self.openId, self.groupId)

    @property
    def balance(self):
        return self.chargeBalance + self.bestowBalance

    def pay(self, payment):     # type:(PaymentInfo) -> PaymentInfo
        if not payment:
            return
        if not payment.deduct_list:
            return

        # 虽然是循环扣除 但是一般情况下只会扣除1次
        bulker = BulkHandlerEx(self.__class__.get_collection())  # type: BulkHandlerEx
        chargeBalanceField = self.__class__.chargeBalance.name
        bestowBalanceField = self.__class__.bestowBalance.name
        for deduct in payment.deduct_list:
            query = {
                '_id': ObjectId(deduct['id']),
            }
            update = {
                '$inc': {
                    chargeBalanceField: (-RMB(deduct[chargeBalanceField])).mongo_amount,
                    bestowBalanceField: (-RMB(deduct[bestowBalanceField])).mongo_amount
                }
            }
            bulker.update(query, update)

        result = bulker.execute()
        if result['success'] == 0 or len(result['info']['writeErrors']) != 0:
            logger.error("[user pay] pay error, result = {}".format(result))
        else:
            # 添加支付时间并返回
            payment.time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        return payment

    def account_consume(self, order):   # type:(ConsumeRecord) -> None
        payment = order.payment
        # 获取支付的钱
        consumeAmount = payment.actualAmount
        consumeBestowAmount = payment.totalAmount - consumeAmount

        # 获取平台余额
        charge, bestow, _, __ = self.filter_my_balance()

        UserBalanceLog.consume(
            order.user,
            afterAmount=charge,
            afterBestowAmount=bestow,
            consumeAmount=consumeAmount,
            consumeBestowAmount=consumeBestowAmount,
            order=order
        )

    def account_refund(self, order):    # type:(ConsumeRecord) -> None
        refund = order.refund
        # 获取支付的钱
        refundAmount = refund.actualAmount
        refundBestowAmount = refund.totalAmount - refundAmount

        # 获取平台余额
        charge, bestow, _, __ = self.filter_my_balance()

        UserBalanceLog.refund(
            order.user,
            afterAmount=charge,
            afterBestowAmount=bestow,
            refundAmount=refundAmount,
            refundBestowAmount=refundBestowAmount,
            order=order
        )

    def account_recharge(self, order):  # type:(RechargeRecord) -> None
        # 获取支付的钱
        chargeAmount = order.chargeAmount
        bestowAmount = order.bestowAmount

        # 获取平台余额
        charge, bestow, _, __ = self.filter_my_balance()

        UserBalanceLog.recharge(
            order.user,
            afterAmount=charge,
            afterBestowAmount=bestow,
            chargeAmount=chargeAmount,
            chargeBestowAmount=bestowAmount,
            order=order
        )

    def is_authenticated(self):
        if not self.authAppId:
            return False

        return True

    def get_promo_info(self, key):
        return self.promo.get(key)

    def set_promo_info(self, key, value):
        promo = self.promo
        promo[key] = value
        return self.update(promo = promo)

    @property
    def inhouse_promo_openId(self):
        return self.get_promo_info("inhouse_openId")

    def set_inhouse_promo_openId(self, openId):
        return self.set_promo_info(key = "inhouse_openId", value = openId)

    @property
    def feature_keys(self):
        return ['phoneOS', 'sex', 'gateway']

    @property
    def feature_map(self):
        return {'phoneOS': self.phoneOS, 'sex': self.sex_in_en, 'gateway': self.gateway}

    @property
    def sex_in_en(self):
        if self.is_female:
            return 'female'
        elif self.is_male:
            return 'male'
        else:
            return ''

    @property
    def is_female(self):
        return self.sex == Const.USER_SEX.FEMALE

    @property
    def is_male(self):
        return self.sex == Const.USER_SEX.MALE

    def get_bound_pay_openid(self, key):
        # type: (str)->str
        if self.gateway == AppPlatformType.ALIPAY:
            return self.openId
        else:
            pay_openid_map = self.payOpenIdMap  # type: dict
            bound = pay_openid_map.get(key, BoundOpenInfo(openId = ''))  # type: BoundOpenInfo
            return bound.openId

    def set_bound_pay_openid(self, key, **payload):
        # type: (str, Dict)->None
        self.payOpenIdMap[key] = BoundOpenInfo(**payload)

    @classmethod
    def _product_group_id(cls, agent_id):
        # type:(str)->str
        return '{}{}'.format(cls._AGENT_GROUP_ID_PREFIX, agent_id)

    @classmethod
    def _is_product_group_id(cls, group_id):
        # type: (str)->bool
        return group_id.startswith(cls._AGENT_GROUP_ID_PREFIX)

    def is_product_user(self):
        return not self.groupId or self.groupId.startswith(self._AGENT_GROUP_ID_PREFIX)

    @classmethod
    def get_product_users(cls, agent_id):   # type: (str) -> QuerySet
        productGroupId = cls._product_group_id(agent_id)
        return cls.objects.filter(groupId=productGroupId)

    @classmethod
    def get_or_create(cls, app_platform_type, open_id, group_id=groupId.default, **kwargs):
        # type: (str, str, str, Dict)->MyUser
        logger.info('get_or_create cls = {}, app_platform_type = {}, open_id = {}, groupId = {}, kwargs = {}'.format(
            cls, app_platform_type, open_id, group_id, str(kwargs)))

        if app_platform_type in [AppPlatformType.ALIPAY]:
            kwargs.pop('payOpenIdMap', None)

        if group_id == cls.groupId.default:  # 平台个人中心登录
            format_group_id = cls._product_group_id(kwargs.get('productAgentId'))
        else:
            format_group_id = group_id

        user = cls.objects(openId = open_id, groupId = format_group_id).first()  # type: MyUser

        if user is not None:
            need_update = False

            if 'payOpenIdMap' in kwargs:
                for key, value in kwargs['payOpenIdMap'].iteritems():
                    if key in user.payOpenIdMap:
                        continue

                    user.set_bound_pay_openid(key = key, **(value.to_dict()))
                    need_update = True

            if 'authAppId' in kwargs and kwargs['authAppId'] != user.authAppId:
                user.authAppId = kwargs['authAppId']
                need_update = True

            if 'agentId' in kwargs and kwargs['agentId'] != user.agentId:
                user.agentId = kwargs['agentId']
                need_update = True

            if 'productAgentId' in kwargs and kwargs['productAgentId'] != user.productAgentId:
                user.productAgentId = kwargs['productAgentId']
                need_update = True

            if 'avatar' in kwargs and kwargs['avatar'] != user.avatar:
                user.avatar = kwargs['avatar']
                need_update = True

            if need_update:
                user.save()

            return user
        else:
            kwargs.update({'gateway': app_platform_type})

            user = cls(openId = open_id, groupId = format_group_id, **kwargs)

            try:
                return user.save()
            except NotUniqueError:
                return cls.objects(openId = open_id, groupId = format_group_id).first()

    def group_pay(self, amount):
        # type: (VirtualCoin)->None
        """
        :param amount:
        :return:
        """
        #: 检查是否宇宙里未分配的余额和是否小于要付的钱
        valid_to_pay = bool(self.get_collection().count_documents(
            filter = {
                '_id': ObjectId(self.id),
                '$expr':
                    {'$lt': [amount.mongo_amount, {'$sum': ["$universe.money.unsettled"]}]}
            }
        ))

        if valid_to_pay:
            raise NotImplementedError()

    def refund(self, payCount):
        try:
            self.update(inc__balance = payCount.amount, inc__total_consumed = -payCount.amount)
        except Exception as e:
            logger.exception(
                'refund error = %s, openId = %s, money = %s' % (e, self.openId, payCount))
            return 0, u'退金币失败'

        return 1, ''

    def update_total_recharge(self, money):
        # type: (RMB)->int
        assert isinstance(money, RMB), 'money has to be RMB'
        updated = self.update(inc__total_recharged = money.amount)
        return updated

    def incr_balance(self, coins):
        # type: (VirtualCoin)->int
        assert isinstance(coins, VirtualCoin), 'coins had to be VirtualCoin'
        updated = self.update(inc__balance = coins.amount)
        return updated

    def recharge(self, money, bestowMoney): # type: (RMB, RMB)->MyUser
        """
        给用户充值，同时记录累计充值数额
        :param money: 币额
        :param bestowMoney: 金额
        :return:
        """
        assert isinstance(money, RMB), 'coins had to be VirtualCoin'
        assert isinstance(bestowMoney, RMB), 'money has to be RMB'

        updated = self.update(
            inc__chargeBalance=money,
            inc__total_recharged=money,
            inc__bestowBalance=bestowMoney,
            inc__total_bestow=bestowMoney
        )

        if not updated:
            raise PostPayOrderError(u'余额和累计充值更新失败')

        return self.reload()

    @classmethod
    def deduct_balance(cls, deduct_list):
        # type:(dict)->None

        """
        按照订单的扣款列表直接扣除用户相应balance
        :param deduct_list:
        :return:
        """

        bulker = BulkHandlerEx(cls.get_collection())  # type: BulkHandlerEx

        for deduct in deduct_list:
            query = {
                '_id': ObjectId(deduct['id'])
            }

            update = {
                '$inc': {
                    'balance': (-VirtualCoin(deduct['coins'])).mongo_amount
                }
            }
            bulker.update(query, update)

        result = bulker.execute()

        logger.debug(result['info'])

        if result['success'] == 0:
            raise ServiceException({'result': 0, 'description': u"扣款失败(1001)"})
        else:
            if len(result['info']['writeErrors']) != 0:
                raise ServiceException({'result': 0, 'description': u"扣款失败(1002)"})

    @classmethod
    def freeze_balance(cls, transaction_id, payment):   # type:(str, PaymentInfo) -> bool

        """
        按照扣款列表冻结用户相应的金额
        :param transaction_id:
        :param payment:
        :return:
        """

        bulker = BulkHandlerEx(cls.get_collection())  # type: BulkHandlerEx
        chargeBalanceField = cls.chargeBalance.name
        bestowBalanceField = cls.bestowBalance.name

        for deduct in payment.deduct_list:
            query = {
                '_id': ObjectId(deduct['id']),
                'ongoingList.transaction_id': {
                    '$ne': transaction_id
                }
            }

            update = {
                '$inc': {
                    chargeBalanceField: (-RMB(deduct[chargeBalanceField])).mongo_amount,
                    bestowBalanceField: (-RMB(deduct[bestowBalanceField])).mongo_amount
                },
                '$addToSet': {
                    'ongoingList': {
                        'transaction_id': transaction_id,
                        chargeBalanceField: deduct[chargeBalanceField],
                        bestowBalanceField: deduct[bestowBalanceField]
                    }
                }
            }
            bulker.update(query, update)

        result = bulker.execute()

        logger.debug(result['info'])

        if result['success'] == 0:
            raise ServiceException({'result': 0, 'description': u"扣款失败(1001)"})
        else:
            if len(result['info']['writeErrors']) != 0:
                raise ServiceException({'result': 0, 'description': u"扣款失败(1002)"})
            else:
                return True

    @classmethod
    def clear_frozen_balance(cls, transaction_id, payment, refund): # type:(str, PaymentInfo, PaymentInfo)->bool
        """
        清除冻结金额 实际上就是相当于退费
        如果没有退费 也需要调用一次 目的是清理掉transactionId
        """

        try:
            bulker = BulkHandlerEx(cls.get_collection())  # type: BulkHandlerEx
            chargeBalanceField = cls.chargeBalance.name
            bestowBalanceField = cls.bestowBalance.name

            # 将总消费情况 更新到第一个地址里面去
            first = True
            totalDeduct = payment.totalAmount
            totalRefund = refund.totalAmount

            for deduct in refund.deduct_list:
                query = {
                    '_id': ObjectId(deduct['id']),
                    'ongoingList': {
                        '$elemMatch': {
                            'transaction_id': transaction_id
                        }
                    }
                }

                if first:
                    update = {
                        '$inc': {
                            chargeBalanceField: deduct[chargeBalanceField],
                            bestowBalanceField: deduct[bestowBalanceField],
                            cls.total_consumed.name: (totalDeduct - totalRefund).mongo_amount
                        },
                        '$pull': {
                            'ongoingList': {
                                'transaction_id': transaction_id
                            }
                        }
                    }
                else:
                    update = {
                        '$inc': {
                            chargeBalanceField: deduct[chargeBalanceField],
                            bestowBalanceField: deduct[bestowBalanceField],
                        },
                        '$pull': {
                            'ongoingList': {
                                'transaction_id': transaction_id
                            }
                        }
                    }

                first = False
                bulker.update(query, update)

            result = bulker.execute()

            logger.debug(result['info'])

            if result['success'] == 0:
                return False
            else:
                if len(result['info']['writeErrors']) != 0:
                    return False
                else:
                    return True
        except Exception as e:
            logger.exception(e)
            return False

    @classmethod
    def recover_frozen_balance(cls, transaction_id, deduct_list):
        # type:(str, list)->bool

        """
        回滚冻结的余额
        """

        bulker = BulkHandlerEx(cls.get_collection())  # type: BulkHandlerEx

        for deduct in deduct_list:
            query = {
                '_id': ObjectId(deduct['id']),
                'ongoingList': {
                    '$elemMatch': {'transaction_id': transaction_id}}}

            update = {
                '$inc': {
                    'balance': deduct['coins']
                },
                '$pull': {
                    'ongoingList': {
                        'transaction_id': transaction_id, 'frozenCoins': deduct['coins']
                    }}
            }
            bulker.update(query, update)

        result = bulker.execute()
        if result['success'] == 0:
            logger.error(result['info'])
            return False
        else:
            if len(result['info']['writeErrors']) != 0:
                logger.error(result['info'])
                return False
            else:
                return True

    def to_dict(self, default_avatar = settings.DEFAULT_AVATAR_URL):

        avatar = self.avatar or default_avatar or Agent.get_agent(self.agentId).get("productLogo")

        return {
            'avatar': avatar,
            'nickname': self.nickname,
            'openId': self.openId,
            'groupId': self.groupId,
            'sex': self.sex,
            'balance': self.balance,
            'total_recharged': self.total_recharged,
            'total_consumed': self.total_consumed,
        }

    @property
    def product_users(self):
        return MyUser.objects.filter(
            __raw__ = {
                'openId': self.openId,
                '$or': [
                    {
                        'agentId': self.agentId
                    },
                    {
                        'productAgentId': self.productAgentId
                    }
                ]
            })

    @property
    def total_balance(self):
        """
        个人中心获取balance. 需要按照agentId过滤
        :return:
        """
        totalCharge, totalBestow, total, dataList = self.filter_my_balance()
        return totalCharge + totalBestow

    def filter_my_balance(self, currentGroup=None):
        """
        个人中心获取balance列表. 需要按照agentId过滤
        """
        dataList = []
        total = 0
        totalCharge = RMB(0)
        totalBestow = RMB(0)

        chargeBalanceField = self.__class__.chargeBalance.name
        bestowBalanceField = self.__class__.bestowBalance.name

        # dealer_partition = defaultdict(lambda: {
        #     chargeBalanceField: RMB(0),
        #     bestowBalanceField: RMB(0)
        # })

        users = self.product_users

        for user in users:      # type: MyUser
            groupId = user.groupId

            if user.is_product_user():
                logger.debug('groupId <{}> is agent group id.'.format(groupId))
                continue

            group = Group.get_group(groupId)  # type: GroupDict
            if not group:
                logger.error('no group. id = %s' % groupId)
                continue

            dealer = Dealer.get_dealer(group['ownerId'])  # type: DealerDict
            if dealer is None:
                logger.error('no dealer. id = %s' % group['ownerId'])
                continue

            # dealer_partition[dealer['id']][chargeBalanceField] += user.chargeBalance
            # dealer_partition[dealer['id']][bestowBalanceField] += user.bestowBalance

            # 过滤掉为0的情况
            if user.balance == RMB(0):
                continue
            else:
                total += 1
                totalCharge += user.chargeBalance
                totalBestow += user.bestowBalance

                address = group.address

                rv = {
                    'address': address,
                    'groupId': groupId,
                    'groupName': group.groupName,
                    'dealerId': group.ownerId,
                    'balance': {
                        chargeBalanceField: user.chargeBalance,
                        bestowBalanceField: user.bestowBalance
                    },
                    'currency': False
                }

                if currentGroup and dealer.is_currency(currentGroup, group):
                    rv['currency'] = True

                dataList.append(rv)

        return totalCharge, totalBestow, total, dataList

    def get_balance_in_dealer(self, dealer, group):     # type: (Dealer, GroupDict)->Tuple[RMB, RMB, RMB]

        if self.groupId != group.groupId:
            payload = self.cloneable_user_info
            payload['agentId'] = dealer.agentId
            user = MyUser.get_or_create(
                app_platform_type = self.gateway, open_id = self.openId, group_id = group.groupId, **payload)
        else:
            user = self

        users = user.product_users

        overall, dealer_balance, currency_balance = RMB(0), RMB(0), RMB(0)

        dealer_group_ids = Group.get_group_ids_of_dealer(str(dealer.id))  # type: List[GroupDict]

        groups = Group.get_groups_by_group_ids(dealer_group_ids).values()

        share_group_ids = dealer.get_currency_group_ids(group, groups)
        share_group_ids.append(group.groupId)

        for user in users:
            overall += user.balance

            if user.groupId in dealer_group_ids:
                dealer_balance += user.balance

            if user.groupId in share_group_ids:
                currency_balance += user.balance

        return overall, dealer_balance, currency_balance

    @classmethod
    def get_new_user_count(cls, groupIds, start, end):
        # type: (list, datetime.datetime, datetime.datetime)->int

        result = cls.get_collection().aggregate(
            [
                {
                    '$match': {
                        "groupId": {"$in": groupIds},
                        "dateTimeAdded": {"$gte": start, "$lte": end}
                    }
                },
                {
                    '$group': {
                        '_id': '$openId'
                    }
                },
                {'$count': 'count'},
            ]
        )
        return next(result, {}).get("count", 0)

    @classmethod
    def get_user_count_by_filter(cls, groupIds, filterDict = {}):
        # type: (list)->int
        filter = {"groupId": {"$in": groupIds}}
        filter.update(filterDict)

        result = cls.get_collection().aggregate(
            [
                {
                    '$match': filter
                },
                {
                    '$group': {
                        '_id': '$openId'
                    }
                },
                {'$count': 'count'},
            ]
        )
        return next(result, {}).get("count", 0)

    def get_extra_info(self, key):
        return self.extra.get(key)

    def set_extra_info(self, key, value):
        extra = self.extra
        extra[key] = value
        return self.update(extra = extra)

    @staticmethod
    def get_active_info(openId, **kwargs):
        """
        获取用户的激活状态 安骑换电用户的激活状态在一个经销商下只会有一个激活状态
        """
        users = MyUser.objects(openId = openId, **kwargs)

        for user in users:
            if user.get_extra_info("active"):
                curUser = user
                break
        else:
            return dict()  # 没找到用户的激活信息

        return curUser.get_extra_info("active")

    @staticmethod
    def del_active_info(openId, **kwargs):
        users = MyUser.objects(openId = openId, **kwargs)

        for user in users:
            if user.get_extra_info("active"):
                user.set_extra_info("active", {})
                user.phoneNumber = ""
                user.save()
                break

    @staticmethod
    def set_active_info(setInfo, openId, **kwargs):
        users = MyUser.objects(openId = openId, **kwargs)

        for user in users:
            if user.get_extra_info("active"):
                curUser = user
                break
        else:  # 用户第一次注册
            curUser = user

        active = curUser.get_extra_info("active")
        if not active:
            active = dict()
        active.update(setInfo)
        curUser.set_extra_info("active", active)
        if setInfo.get("isMember"):  # 被经销商激活的同时，为用户添加phoneNumber字段
            curUser.phoneNumber = active.get("phoneNumber")

        curUser.save()
        return

    @property
    def cloneable_user_info(self):
        """
        对于微信, 必须是相同的平台, 用户信息才能一致;
        对于京东和支付宝, 用户信息都是一致的
        :return:
        """
        return {
            'authAppId': self.authAppId,

            'avatar': self.avatar,
            'nickname': self.nickname,

            'managerialAppId': self.managerialAppId,
            'managerialOpenId': self.managerialOpenId,

            'payOpenIdMap': self.payOpenIdMap,

            'gateway': self.gateway,

            'productAgentId': self.productAgentId
        }

    @property
    def my_product_user(self):
        payload = self.cloneable_user_info
        payload['agentId'] = self.productAgentId
        return MyUser.get_or_create(self.gateway, self.openId, **payload)

    @property
    def collectedDeviceList(self):
        """
        用户收藏的设备
        :return:
        """
        return self.my_product_user.favoriteDeviceList

    @collectedDeviceList.setter
    def collectedDeviceList(self, value):
        cur_user = self.my_product_user
        cur_user.favoriteDeviceList = value
        cur_user.save()

    @property
    def phone(self):
        """
        用户的电话号码
        之前是存储在productUser上面 现在需要做一次转换适配
        """
        uniqueUser = UniqueUser.get_or_create(self.openId)
        # 唯一用户存储了电话的情况下 直接返回唯一用户
        if uniqueUser.phone:
            return uniqueUser.phone

        # 从以前的存储电话号码的地方找出存储的电话 如有 转移到uniquerUser上面
        phoneNumber = self.my_product_user.phoneNumber
        if phoneNumber:
            uniqueUser.update_phone(phoneNumber)
            return phoneNumber
        else:
            return phoneNumber

    @phone.setter
    def phone(self, value):
        """
        保存用户的电话号码 将直接保存到uniqueUser上面去
        """
        uniqueUser = UniqueUser.get_or_create(self.openId)
        uniqueUser.update_phone(value)

    @property
    def user_id(self):
        """
        用户系统分配ID
        """
        if settings.ID_SERVICE_IP:
            uniqueUser = UniqueUser.get_or_create(self.openId)

            if not uniqueUser.userId:
                try:
                    user_id = IDGenService(server_ip = settings.ID_SERVICE_IP).get_id()
                    uniqueUser.userId = user_id
                    uniqueUser.save()
                except Exception as e:
                    logger.error('update user id failure.')
                    logger.exception(e)

            return uniqueUser.userId
        else:
            return None

    def record_and_check_access_day(self, name, limit):
        dayTime = datetime.datetime.now().strftime(Const.DATE_FMT)
        key = '%s-%s-%s' % (self.openId, name, dayTime)
        value = serviceCache.get(key, 0)
        if value >= limit:
            return False
        value += 1
        serviceCache.set(key, value, 24 * 60 * 60)
        return True

    @property
    def cards_num(self):
        """
        统计该用户的该平台下的实体卡数量
        :return:
        """
        filters = {"openId": self.openId, "agentId": self.productAgentId}
        return Card.objects.filter(**filters).count()

    @property
    def many_cards(self):
        """
        是否允许 该用户拥有多张实体卡
        :return:
        """
        if "manyCards" in self.extra and self.get_extra_info("manyCards"):
            return True
        return False

    @classmethod
    def get_dealer_ids(cls, openId, productAgentId):
        users = cls.objects(openId = openId, productAgentId = productAgentId)
        group_ids = []
        for user in users:
            if not user.is_product_user():
                group_ids.append(user.groupId)

        groups = Group.get_groups_by_group_ids(group_ids)
        dealers = set()

        for group in groups.values():
            dealers.add(group.ownerId)

        return list(dealers)

    def calc_currency_balance(self, dealer, group, groups = None):
        # type:(Dealer, GroupDict, List[GroupDict])->RMB

        share_group_ids = dealer.get_currency_group_ids(group, groups)
        share_group_ids.append(group.groupId)

        users = MyUser.objects(openId =self.openId, groupId__in=share_group_ids)
        return sum((u.balance for u in users), RMB(0))

    def calc_currency_total_recharge(self, dealer, group):
        # type:(Dealer, GroupDict)->RMB

        share_group_ids = dealer.get_currency_group_ids(group)
        share_group_ids.append(group.groupId)
        users = MyUser.objects(openId = self.openId, groupId__in = share_group_ids)
        if users.count() == 0:
            return RMB(0)
        else:
            return RMB(users.sum('total_recharged'))

    @property
    def group(self):
        if self.is_product_user():
            return None

        if hasattr(self, '__group__'):
            return getattr(self, '__group__')

        group = Group.get_group(self.groupId)  # type: GroupDict
        if group:
            setattr(self, '__group__', group)

        return group

    @property
    def username(self):
        return self.nickname

    @property
    def request_limit_key(self):
        return self.openId

    @classmethod
    def get_day_used_cache(cls, openId):
        """获取用户的每日使用次数信息"""
        key = '{}_day_used'.format(openId)
        result = cls.__mgr_cache.get(key, 0)

        return result

    @classmethod
    def update_day_used_cache(cls, openId):
        """
        更新设备的每日使用次数信息
        :param openId:
        :return:
        """
        try:
            key = '{}_day_used'.format(openId)
            set_or_incr_cache(cls.__mgr_cache, key, 1, 24 * 60 * 60)
        except Exception:
            pass

    @classmethod
    def clear_day_used_cache(cls, openId):
        """清除用户的每日使用次数信息"""
        key = '{}_day_used'.format(openId)
        cls.__mgr_cache.set(key, 0)

    @classmethod
    def get_today_can_use(cls, openId):
        usedCount = MyUser.get_day_used_cache(openId)
        if usedCount > serviceCache.get('{}_day_used_limit'.format(openId), 10):
            return False

        return True

    def prepare_refund_cash(self, refund_order, minus_total_consume):   # type:(RefundMoneyRecord, VirtualCoin)->bool

        query = {
            '_id': self.id,
            'ongoingList.transaction_id': {
                '$ne': 'r_{}'.format(str(refund_order.id))
            }
        }

        update = {
            '$inc': {
                'chargeBalance': (-refund_order.coins).mongo_amount,
                'total_recharged': (-refund_order.money).mongo_amount,
            },
            '$addToSet': {
                'ongoingList': {
                    'transaction_id': 'r_{}'.format(str(refund_order.id)),
                    'chargeBalance': refund_order.money.mongo_amount,
                    'minus_total_consume': minus_total_consume.mongo_amount
                }
            }
        }

        result = self.get_collection().update_one(query, update, upsert = False)  # type: UpdateResult
        return bool(result.modified_count == 1)

    def commit_refund_cash(self, refund_order):
        # type:(RefundMoneyRecord)->bool

        query = {
            '_id': self.id,
            'ongoingList': {
                '$elemMatch': {
                    'transaction_id': 'r_{}'.format(str(refund_order.id))
                }
            }
        }

        update = {
            '$pull': {
                'ongoingList': {'transaction_id': 'r_{}'.format(str(refund_order.id))}
            }
        }

        result = self.get_collection().update_one(query, update, upsert = False)  # type: UpdateResult
        return bool(result.modified_count == 1)

    def revoke_refund_cash(self, refund_order):
        # type:(RefundMoneyRecord)->bool

        sync_key = 'r_{}'.format(str(refund_order.id))

        ongoingItem = None
        for item in self.ongoingList:
            if item['transaction_id'] == sync_key:
                ongoingItem = item
                break

        if not ongoingItem:
            return False

        query = {
            '_id': self.id,
            'ongoingList': {
                '$elemMatch': {
                    'transaction_id': sync_key
                }
            }
        }

        update = {
            '$inc': {
                'balance': VirtualCoin(ongoingItem['coins']).mongo_amount,
                'total_recharged': refund_order.money.mongo_amount,
            },

            '$pull': {
                'ongoingList': {'transaction_id': 'r_{}'.format(str(refund_order.id))}
            }
        }

        result = self.get_collection().update_one(query, update, upsert = False)  # type: UpdateResult
        return bool(result.modified_count == 1)

    @property
    def isNormal(self):
        return True


class MyUserDetail(Searchable):
    openId = StringField(verbose_name="Myuser中的id", default="")
    dealerId = StringField(verbose_name="经销商Id", default="")
    userName = StringField(verbose_name="用户姓名", default="")
    userPhone = StringField(verbose_name="用户电话", default="")
    userUnit = StringField(verbose_name="用户地址单元", default="")
    userFloor = StringField(verbose_name="用户地址楼层", default="")
    userRoom = StringField(verbose_name="用户地址房间", default="")

    meta = {
        "collection": "MyUserDetail",
        "db_alias": "logdata"}

    @classmethod
    def get_collection(cls):
        # type: ()->Collection
        return cls._get_collection()


class RechargeRecordDict(dict):
    def __repr__(self):
        return '<RechargeRecordDict id=%s>' % (self.get('id'),)

    @property
    def v(self):
        return dict(self)

    @property
    def ownerId(self):
        return self.get('ownerId')

    @property
    def groupId(self):
        return self.get('groupId')

    @property
    def money(self):
        return RMB(self['money'])

    @property
    def coins(self):
        return VirtualCoin(self['coins'])

    @property
    def attachParas(self):
        return self.get('attachParas')

    @property
    def extraInfo(self):
        return self.get('extraInfo')

    @property
    def group(self):
        # type:()->GroupDict

        _attr_name = '__my_group__'

        if hasattr(self, _attr_name):
            return getattr(self, _attr_name)
        else:
            group = Group.get_group(self.groupId)
            setattr(self, _attr_name, group)
            return group

    @property
    def owner(self):
        _attr_name = '__my_owner__'

        if hasattr(self, _attr_name):
            return getattr(self, _attr_name)
        else:
            dealer = Dealer.objects(id = self.ownerId).first()
            setattr(self, _attr_name, dealer)
            return dealer

    @property
    def my_gateway(self):
        return self.get('gateway')

    @property
    def pay_app_type(self):
        return self.get('payAppType')

    @property
    def pay_gateway_key(self):
        return self.get('payGatewayKey')

    @property
    def withdraw_source_key(self):
        return self.get('withdrawSourceKey')

    @property
    def dev_type_name(self):
        if 'devTypeName' in self:
            return self.get('devTypeName')
        elif 'devType' in self:
            return self.get('devType')
        else:
            return u'其他'

    @property
    def logicalCode(self):
        return self.get('logicalCode')

    @property
    def address(self):
        return self.get('address')

    @property
    def via(self):
        return self.get('via')

    @property
    def partition_map(self):
        """
        新订单模型下, 创建订单就会生成partitionMap. 所以直接取
        :return:
        """
        return self.extraInfo.get('partitionMap', None)

    def calc_income_partitions(self, partition_map):
        totalMoney = self.money

        leftMoney = totalMoney

        agent_partitions = partition_map.get(PARTITION_ROLE.AGENT, list())
        if agent_partitions:
            for agentShare in agent_partitions:
                shareMoney = totalMoney * Percent(agentShare['share']).as_ratio

                if shareMoney > leftMoney:
                    shareMoney = leftMoney

                leftMoney = leftMoney - shareMoney

                agentShare['money'] = shareMoney.mongo_amount

        partner_partitions = partition_map.get(PARTITION_ROLE.PARTNER, list())
        if partner_partitions:
            for partnerShare in partner_partitions:
                shareMoney = totalMoney * Percent(partnerShare['share']).as_ratio

                if shareMoney > leftMoney:
                    shareMoney = leftMoney

                leftMoney = leftMoney - shareMoney

                partnerShare['money'] = shareMoney.mongo_amount

        owner_partitions = partition_map.get(PARTITION_ROLE.OWNER, list())

        assert len(owner_partitions) == 1, u'经销商只能有一个'

        ownerShare = owner_partitions[0]

        ownerShare['money'] = leftMoney.mongo_amount

        return partition_map

    def calc_refund_partitions(self, pay_split_map):
        totalMoney = self.money

        leftMoney = totalMoney

        share_key = lambda _role, _id: '{}_{}'.format(_role, _id)
        old_shares_map = {}

        partition_map = {
            PARTITION_ROLE.AGENT: [],
            PARTITION_ROLE.PARTNER: [],
            PARTITION_ROLE.OWNER: []
        }

        agent_partitions = pay_split_map.get(PARTITION_ROLE.AGENT, list())
        if agent_partitions:
            for agentShare in agent_partitions:
                old_shares_map[share_key(agentShare['role'], agentShare['id'])] = RMB(agentShare['money'])

                newAgentShare = copy.deepcopy(agentShare)

                shareMoney = totalMoney * Percent(agentShare['share']).as_ratio

                if abs(shareMoney) > abs(leftMoney):
                    shareMoney = leftMoney

                leftMoney = leftMoney - shareMoney

                newAgentShare['money'] = shareMoney.mongo_amount

                partition_map[PARTITION_ROLE.AGENT].append(newAgentShare)

        partner_partitions = pay_split_map.get(PARTITION_ROLE.PARTNER, list())
        if partner_partitions:
            for partnerShare in partner_partitions:
                old_shares_map[share_key(partnerShare['role'], partnerShare['id'])] = RMB(partnerShare['money'])

                newPartnerShare = copy.deepcopy(partnerShare)

                shareMoney = totalMoney * Percent(partnerShare['share']).as_ratio

                if abs(shareMoney) > abs(leftMoney):
                    shareMoney = leftMoney

                leftMoney = leftMoney - shareMoney

                newPartnerShare['money'] = shareMoney.mongo_amount

                partition_map[PARTITION_ROLE.PARTNER].append(newPartnerShare)

        owner_partitions = pay_split_map.get(PARTITION_ROLE.OWNER, list())

        assert len(owner_partitions) == 1, u'经销商只能有一个'

        ownerShare = owner_partitions[0]

        newOwnerShare = copy.deepcopy(ownerShare)

        old_share_money = RMB(ownerShare['money'])

        if abs(leftMoney) <= old_share_money:
            newOwnerShare['money'] = leftMoney.mongo_amount
        else:
            diff = abs(leftMoney) - old_share_money

            shares = list(flatten(partition_map.values()))
            shares.sort(key = lambda x: Percent(x['share']), reverse = True)

            for share in shares:
                if RMB(share['money']) - RMB('0.01') + RMB(
                        old_shares_map[share_key(share['role'], share['id'])]) >= RMB(0):
                    share['money'] = (RMB(share['money']) - RMB('0.01')).mongo_amount

                    diff -= RMB('0.01')
                    leftMoney += RMB('0.01')

                    if diff <= RMB(0):
                        break

            assert diff == RMB(0), u'分账金额错误'

            newOwnerShare['money'] = leftMoney.mongo_amount

        partition_map[PARTITION_ROLE.OWNER] = [newOwnerShare]

        for role, items in partition_map.iteritems():
            for item in items:
                if RMB(item['money']) == RMB(0):
                    item['money'] = RMB(0).mongo_amount

        return partition_map


class RechargeRecord(OrderRecordBase):
    """
    三个作用：
    1、经销商收益记录（特殊情况包括平台的收益记录，例如1毛保险单情况下）
    2、充值订单，模型增加refundInfo信息
    3、商家派送(金币,红包等)订单
    """

    class PayResult(IterConstant):
        UNPAY = 'unPay'

        SUCCESS = 'success'
        FAILED = 'failed'

        CANCEL = 'cancel'

        REFUNDING = 'refunding'  # 退费处理中
        CLOSE = 'close'  # 退款订单用, 被退单

    orderNo = StringField(verbose_name = u"订单号", unique = True)
    wxOrderNo = StringField(verbose_name = u"渠道订单号. 聚合商户,是聚合平台商户订单号;直连商户则是微信或支付宝订单号。互联互通订单号也用这个")
    transactionId = StringField(verbose_name = u"微信或者支付宝订单号", default = None)

    ownerId = StringField(verbose_name = u"设备的owner", default = "")

    #: 充值的金钱数额 incr(user.balance)
    money = MonetaryField(verbose_name = u"充值", default = RMB('0.00'))
    #: 用户购得的金币,如果是卡，就是充值的钱
    coins = VirtualCoinField(verbose_name = u"金币数目", default = VirtualCoin('0.00'))

    subject = StringField(verbose_name = u"订单产品或者服务描述", default = "")

    result = StringField(verbose_name = u"充值或者服务结果", default = PayResult.UNPAY)

    extraInfo = DictField(verbose_name = u"支付订单模型信息", default = {})
    description = StringField(verbose_name = u"结果描述,一般为第三方错误码", default = None)

    # 以下字段为充值订单的模型字段, MODEL中不在体现
    #: 当用户余额为0，点击投币，生成充值订单，用户完成后直接自动投相应币数
    #: 此举为优化用户体验，大多数情况用户对充值并不优先选择，使其能够缩短支付使用流程，用完即走
    isQuickPay = BooleanField(verbose_name = u"是否直接支付使用，默认为否", default = False)
    selectedQuickPayPackageId = StringField(verbose_name = u"快捷支付所选的投币套餐", default = None)

    via = StringField(verbose_name = u"充值途径 =: (recharge|sendcoin|refund|chargeCard|swap)", default = 'recharge')

    finishedTime = DateTimeField(default = None, verbose_name = u"支付完成时间")

    # 派币需要记录信息
    operator = StringField(verbose_name = u"操作员", default = None)

    attachParas = DictField(verbose_name = u"消费订单信息", default = {})

    gateway = StringField(verbose_name = u'支付网关类型', default = '')

    payAppType = StringField(verbose_name = u'支付应用类型', default = None)
    payGatewayKey = StringField(verbose_name = u'支付网关key', default = None)

    withdrawSourceKey = StringField(verbose_name = u'提现商户平台标识,资金池模式下和代理商相同', default = None)
    isAllocatedCardMoney = BooleanField(verbose_name = u'是否分钱了', default = None)

    search_fields = ('orderNo', 'wxOrderNo')

    _shard_key = ('ownerId', 'dateTimeAdded')

    _origin_meta = {
        "collection": "RechargeRecord",
        "db_alias": "default"
    }

    meta = _origin_meta

    def __repr__(self):
        return '<RechargeRecord id=%s, orderNo=%s, wxOrderNo=%s, via=%s>' % (str(self.id), self.orderNo, self.wxOrderNo, self.via)

    @cached_property
    def payGateway(self):
        return PaymentGateway.clone_from_order(self)

    @cached_property
    def user(self):
        return MyUser.objects.filter(openId=self.openId, groupId=self.groupId).first()

    @cached_property
    def dealer(self):
        return Dealer.objects(id=self.ownerId).get()

    @property
    def goods(self):    # type:()->dict
        return {}

    @property
    def timeout(self):  # type:()-> bool
        """支付超时"""
        return (datetime.datetime.now() - self.dateTimeAdded).total_seconds() > 60 * 3

    @property
    def chargeAmount(self):
        return self.money

    @property
    def bestowAmount(self):
        return RMB(self.coins) - RMB(self.money)

    @property
    def my_gateway(self):
        return self.gateway

    @property
    def pay_app_type(self):
        return self.payAppType

    @property
    def pay_gateway_key(self):
        return self.payGatewayKey

    @property
    def owner(self):
        return self.dealer

    @property
    def payOrder(self):
        """
        用户的实际支付的订单 由于业务需要 可能被拆分为多笔
        # TODO 需要搞定历史数据库的问题
        """

        if self.isSubOrder:
            _id = self.attachParas.get("tradeOrderId", None) or self.extraInfo.get('tradeOrderId', None)
            return self.__class__.objects.get(id = _id)

        return self

    @property
    def isSubOrder(self):
        return "tradeOrderId" in self.extraInfo or "tradeOrderId" in self.attachParas

    @property
    def card_no(self):
        return self.attachParas.get('cardNo', None)

    @property
    def myuser(self):
        _attr_name = '__my_user__'

        if hasattr(self, _attr_name):
            return getattr(self, _attr_name)
        else:
            _myuser = MyUser.get_or_create(
                open_id = self.openId,
                group_id = self.groupId,
                app_platform_type = self.gateway)  # type: MyUser
            setattr(self, _attr_name, _myuser)
            return _myuser

    @property
    def my_subject(self):
        if self.subject:
            return self.subject
        else:
            return RECHARGE_RECORD_VIA_TRANSLATION.get(self.via)

    @property
    def my_description(self):
        if self.description:
            return self.description
        else:
            return getattr(self, 'desc', '')

    @property
    def my_via(self):
        """
        老的订单模型, 对于recharge, 根据是否快速支付做一个调整
        :return:
        """
        return self.via

    @property
    def withdraw_source_key(self):
        return self.withdrawSourceKey

    @property
    def partition_map(self):
        return self.to_dict_obj.partition_map

    @property
    def fen_total_fee(self):
        return int(self.money * 100)

    @property
    def amount(self):
        # type:()->RMB
        return self.money

    @property
    def my_amount(self):
        if self.via in [RechargeRecordVia.RefundCash,
                        RechargeRecordVia.Cash,
                        RechargeRecordVia.VirtualCard,
                        RechargeRecordVia.MonthlyPackage]:
            return '{}元'.format(abs(self.money))
        else:
            return self.coins

    @property
    def mongo_amount(self):
        return self.amount.mongo_amount

    @property
    def extra_detail_info(self):
        rv = {}

        # TODO: 需要根据RechargeRecord建立各VIA下的订单详细信息
        if self.via == 'chargeCard':
            cardId = str(self.attachParas.get('cardId'))
            card = Card.objects(id = cardId).first()
            if card:
                rv.update({'cardNo': card.cardNo, 'cardType': card.cardType})
        elif self.via == 'chargeVirtualCard':
            if 'type' not in self.attachParas:
                # 老模型在new的情况下, 是没有type字段的
                cardNo = self.attachParas.get('cardNo', None)
                if cardNo:
                    rv.update({'cardNo': cardNo})

                cardId = self.attachParas.get('cardId', None)
                if cardId:
                    cardTmpl = VirtualCard.objects(id = cardId).first()  # type: VirtualCard
                    if cardTmpl:
                        rv.update({'cardName': cardTmpl.cardName})
            else:
                if 'cardId' in self.attachParas:
                    virtualCard = UserVirtualCard.objects(
                        id = self.attachParas['cardId']).first()  # type: UserVirtualCard
                    rv.update({
                        'cardNo': virtualCard.cardNo, 'cardName': virtualCard.cardName
                    })

        return rv

    @property
    def summary_info(self):
        rv = {
            'id': str(self.id),
            'createdTime': self.to_datetime_str(self.dateTimeAdded),
            'money': self.money,
            'coins': self.coins,
            'groupName': self.groupName,
            'groupNumber': self.groupNumber,
            'address': self.address,
            'logicalCode': self.logicalCode,
            'devTypeName': self.dev_type_name,
            'devTypeCode': self.dev_type_code,
            'ownerId': self.ownerId,
            'via': self.via
        }

        if self.via == 'chargeVirtualCard':
            rv.pop('coins')

        return rv

    @property
    def created_date(self):
        return self.dateTimeAdded

    @property
    def finished_time(self):
        if self.result != self.PayResult.SUCCESS:
            return ''

        if self.finishedTime:
            return self.to_datetime_str(self.finishedTime)

        return self.to_datetime_str(self.dateTimeAdded)

    @property
    def ledger_enable(self):
        return self.result in [self.PayResult.SUCCESS, self.PayResult.REFUNDING]

    @property
    def is_ledgered(self):
        """
        判断该订单是否已经 分账获取了收益
        :return:
        """

        if self.result != self.PayResult.SUCCESS:
            # 失败订单肯定是没有分账的
            return False

        if self.isAllocatedCardMoney:
            return True

        # 没有该字段的订单  直接进行一次检查 看看有没有分账
        from apps.web.common.proxy import ClientDealerIncomeModelProxy
        try:
            ledgerRecord = ClientDealerIncomeModelProxy.get_one(ref_id = self.id)
        except Exception as e:
            logger.exception(e)
            return False

        return bool(ledgerRecord)

    @property
    def notLedgerDesc(self):
        """
        没有分账的描述值 12小时 72小时分界线
        :return:
        """
        # 未超过 12 小时的情况 可以当成是订单尚未结束
        if self.dateTimeAdded + datetime.timedelta(hours = 12) > datetime.datetime.now():
            desc = u"订单尚未获取收益，可能设备正在运行"
        # 超过 12 小时但是 没有到 72 小时的情况 告知订单可能可能出现了某种问题 等待系统监测自动结账
        elif self.dateTimeAdded + datetime.timedelta(hours = 72) > datetime.datetime.now():
            desc = u"订单尚未获取收益，可能由于网络原因造成订单未关闭，系统将于{}小时后强制分账，请勿担心！".format(
                72 - (datetime.datetime.now().hour - self.dateTimeAdded.hour))
        # 超过72小时还没有分账的 问题单
        else:
            desc = u"订单尚未获取收益，请联系平台运营人员进行处理"

        return desc

    @property
    def used_port(self):
        if self.attachParas and 'chargeIndex' in self.attachParas and self.attachParas['chargeIndex']:
            return str(self.attachParas['chargeIndex'])

        return ''

    @property
    def startKey(self):
        return self.attachParas.get('startKey', None)

    @property
    def refundOrders(self):
        return RefundMoneyRecord.objects.filter(rechargeObjId = self.id)

    @property
    def has_refund_order(self):
        if self.refundOrders:
            return True
        else:
            return False

    @property
    def is_temp_package(self):
        return 'isTempPackage' in self.attachParas and self.attachParas['isTempPackage'] is True

    @property
    def to_dict_obj(self):
        return RechargeRecordDict({
            'via': self.via,
            'money': self.money,
            'coins': self.coins,
            'attachParas': self.attachParas,
            'extraInfo': self.extraInfo,
            'gateway': self.my_gateway,
            'payAppType': self.pay_app_type,
            'payGatewayKey': self.pay_gateway_key
        })

    @classmethod
    def get_record(cls, order_no, dealer_id = None):
        # type: (str, str)->Optional[RechargeRecord]

        # TODO 数据库分片修改
        # record = RechargeRecord.objects(ownerId = dealer_id, orderNo = order_no).first()
        record = cls.objects(orderNo = order_no).first()
        return record

    @classmethod
    def calc_count(cls, filter, group = None, limit = None, sort = None, allowDiskUse = False):
        # type: (dict, dict, int, dict, bool)->int

        pipeline = []

        if filter:
            pipeline.append({
                '$match': filter
            })

        if group:
            pipeline.append({
                '$group': group
            })

        if limit:
            pipeline.append({
                '$limit': limit
            })

        if sort:
            pipeline.append({
                '$sort': sort
            })

        pipeline.append({'$count': 'count'})

        result = cls.get_collection().aggregate(pipeline, allowDiskUse = allowDiskUse)
        return next(result, {}).get('count', 0)

    @classmethod
    def get_recharged_records(cls, **kwargs):
        return cls.objects(via = 'recharge', result = cls.PayResult.SUCCESS, **kwargs).order_by('-dateTimeAdded')

    @classmethod
    def get_card_recharged_records(cls, **kwargs):
        return cls.objects(via = 'chargeCard', result = cls.PayResult.SUCCESS, **kwargs).order_by('-dateTimeAdded')

    @classmethod
    def issue_pay_order(cls, context, gateway, **payload):

        payload.update({
            "openId": context.user.openId,
            "nickname": context.user.nickname,
            'gateway': gateway.gateway_type,
            'payAppType': gateway.pay_app_type,
            'payGatewayKey': gateway.gateway_key,
            'withdrawSourceKey': gateway.withdraw_source_key()
        })

        if gateway.pay_app_type in [PayAppType.WECHAT, PayAppType.ALIPAY]:
            payload['extraInfo'].update({
                'payOpenId': context.user.get_bound_pay_openid(gateway.bound_openid_key)
            })

        if "result" not in payload:
            payload["result"] = cls.PayResult.UNPAY

        order = cls(payload)
        return order.save()

    @classmethod
    def issue_from_auto_sim_order(cls, owner, sim_recharge, device, group):
        # type:(Dealer, DealerRechargeRecord, Device, GroupDict)->RechargeRecord

        payload = {
            'openId': owner.username,
            'nickname': owner.nickname,

            'orderNo': sim_recharge.orderNo,
            'ownerId': sim_recharge.dealerId,
            'money': -RMB(sim_recharge.totalFee/100),
            'coins': VirtualCoin(0),
            'subject': sim_recharge.subject,
            'result': cls.PayResult.SUCCESS,
            'via': RechargeRecordVia.AutoSim,
            'finishedTime': sim_recharge.finishedTime,
            'gateway': sim_recharge.my_gateway,
            'payAppType': sim_recharge.pay_app_type,
            'payGatewayKey': sim_recharge.pay_gateway_key,
            'isAllocatedCardMoney': True,
            'devNo': device.devNo,
            'devType': device.devTypeName,
            'devTypeName': device.devTypeName,
            'devTypeCode': device.devTypeCode,
            'logicalCode': device.logicalCode,
            'groupId': device.groupId,
            'address': group.address,
            'groupNumber': device.groupNumber,
            'groupName': group.groupName
        }

        record = cls(**payload).save()
        record.group = group

        return record

    @classmethod
    def viaText(cls, via, quickPay):
        if via == RechargeRecordVia.Balance:
            if quickPay:
                return u'快捷支付'
            else:
                return u'优惠充值'
        else:
            return RECHARGE_RECORD_VIA_TRANSLATION[via]

    @classmethod
    def gatewayText(cls, gateway):
        return APP_PLATFORM_TYPE_TRANSLATION.get(gateway, u'未知')

    @classmethod
    def from_feedback(cls, feedback, refundCoins):
        # type: (FeedBack, VirtualCoin)->RechargeRecord
        return cls(
            orderNo = str(uuid.uuid4()),
            coins = refundCoins,
            money = RMB(0),
            openId = feedback.openId,
            groupId = feedback.groupId,
            devNo = feedback.devNo,
            ownerId = feedback.ownerId,
            groupName = feedback.groupName,
            groupNumber = feedback.groupNumber,
            address = feedback.address,
            wxOrderNo = u'老板退币',
            devTypeName = feedback.devTypeName,
            nickname = feedback.nickname,
            result = cls.PayResult.SUCCESS,
            via = 'refund')

    @classmethod
    def issue_pay_record(cls, context, **payload):
        # type: (OrderBuilderContext, Dict)->RechargeRecord

        user = context.user
        payment_gateway = context.pay_gateway  # type: PaymentGateway

        payload.update({
            'openId': user.openId,
            'nickname': user.nickname,
            'gateway': payment_gateway.gateway_type,
            'payAppType': payment_gateway.pay_app_type,
            'payGatewayKey': payment_gateway.gateway_key,
            'withdrawSourceKey': payment_gateway.withdraw_source_key()
        })

        if 'attachParas' not in payload:
            payload['attachParas'] = {}

        if 'extraInfo' not in payload:
            payload['extraInfo'] = {}

        if payment_gateway.pay_app_type in [PayAppType.WECHAT, PayAppType.ALIPAY]:
            payload['extraInfo'].update({
                'payOpenId': user.get_bound_pay_openid(payment_gateway.bound_openid_key)
            })

        if "result" not in payload:
            payload['result'] = cls.PayResult.UNPAY

        record = cls(**payload)  # type: RechargeRecord
        return record.save()

    def to_dict(self, json_safe=False):
        money = str(self.money) if json_safe else self.money

        return {
            'ownerId': self.ownerId,
            'nickname': self.nickname,
            'money': money,
            'gateway': self.my_gateway,
            'via': self.via,
        }

    def to_json_dict(self):
        return self.to_dict(json_safe = True)

    def succeed(self, **kwargs):
        payload = {
            'result': self.PayResult.SUCCESS
        }

        if kwargs:
            payload.update(kwargs)

        result = self.get_collection().update_one(
            filter = {'_id': ObjectId(self.id),
                      'result': {'$nin': [self.PayResult.SUCCESS, self.PayResult.CLOSE]}},
            update = {'$set': payload},
            upsert = False)

        return result.matched_count == 1


    def close(self, **kwargs):
        payload = {
            'result': self.PayResult.CLOSE
        }

        if kwargs:
            payload.update(kwargs)

        result = self.get_collection().update_one(
            filter = {'_id': ObjectId(self.id),
                      'result': {'$nin': [self.PayResult.SUCCESS, self.PayResult.CLOSE]}},
            update = {'$set': payload},
            upsert = False)

        return result.matched_count == 1

    def fail(self, **kwargs):
        self.update(result = self.PayResult.FAILED, **kwargs)
        return self.reload()

    def cancel(self):
        payload = {
            'result': self.PayResult.CANCEL,
            'finishedTime': datetime.datetime.now()
        }
        result = self.get_collection().update_one(
            filter = {'_id': ObjectId(self.id), 'result': self.PayResult.UNPAY},
            update = {'$set': payload},
            upsert = False)

        return result.matched_count == 1

    @property
    def is_success(self):
        return self.result == self.PayResult.SUCCESS

    @property
    def is_refunding(self):
        return self.result == self.PayResult.REFUNDING

    @property
    def is_fail(self):
        return self.result == self.PayResult.FAILED

    @property
    def is_cancel(self):
        return self.result == self.PayResult.CANCEL

    @property
    def is_close(self):
        return self.result == self.PayResult.CLOSE

    def to_detail(self):
        # type: ()->dict
        """
        :return:
        """
        return {
            'id': self.id,

            'rechargeTradeNo': self.orderNo,

            'payResult': self.result,

            'ownerId': self.ownerId,

            'gateway': self.my_gateway,

            'openId': self.openId,
            'groupId': self.groupId,

            'userNickname': self.nickname,

            'orderAmount': self.money,
            'coins': self.coins,

            'devNo': self.devNo,
            'logicalCode': self.logicalCode,
            'devTypeName': self.dev_type_name,
            'groupName': self.groupName,
            'groupNumber': self.groupNumber,
            'address': self.address,

            'createdTime': self.dateTimeAdded,
            'completionTime': self.finished_time,

            'via': self.via,
            'isQuickPay': self.isQuickPay,

            'startKey': self.attachParas.get('startKey', None),

            # 以下字段和以前做兼容
            'outTradeNo': self.orderNo,
            'finishedTime': self.finished_time,
            'gatewayTradeNo': self.wxOrderNo,
            'result': self.result
        }

    def to_dict_for_super_admin(self):
        from apps.web.common.proxy import ClientConsumeModelProxy

        orderResult = ''
        isNormalDesc = ''
        via = ''

        if self.result == 'unPay':
            orderResult = u'未付款'
        elif self.result == 'failed':
            orderResult = u'充值失败'
        elif self.result == 'success':
            orderResult = u'充值成功'

        if self.via == '':
            via = u'充值金币'
        elif self.via == '':
            via = u'充值卡'

        if 'consumeRecordId' in self.attachParas:
            # 部分后支付的设备类型, 在支付的时候会塞入消费单的id
            consumeRcd = ClientConsumeModelProxy.get_one(
                shard_filter = {'ownerId': self.ownerId},
                id = self.attachParas.get("consumeRecordId"))  # type: ConsumeRecord
        elif 'startKey' in self.attachParas and self.attachParas['startKey']:
            consumeRcd = ClientConsumeModelProxy.get_one(
                shard_filter = {'ownerId': self.ownerId},
                foreign_id = str(self.id),
                startKey = self.attachParas['startKey'])  # type: ConsumeRecord
        else:
            consumeRcd = None

        if consumeRcd is not None:
            if consumeRcd.isNormal is True:
                isNormalDesc = u'消费成功'
            else:
                isNormalDesc = u'消费失败'

        return {
            'wxOrderNo': self.wxOrderNo,
            'orderNo': self.orderNo,
            'orderResult': orderResult,
            'rechargeUser': self.nickname + '  ' + self.openId,
            'rechargeType': via,
            'money': str(self.money),
            'coins': str(self.coins),
            'orderDetail': self.attachParas,
            'orderCreateTime': self.dateTimeAdded.strftime('%Y-%m-%d %H:%M:%S'),
            'logicalCode': self.logicalCode,
            'devNo': self.devNo,
            'devTypeCode': self.dev_type_code,
            'consumeOrderNo': consumeRcd.orderNo if consumeRcd else '',
            'consumeUser': consumeRcd.nickname + '  ' + consumeRcd.openId if consumeRcd else '',
            'consumeCoins': str(consumeRcd.coin) if consumeRcd else '',
            'consumeResult': isNormalDesc if consumeRcd else '',
            'failedReason': consumeRcd.errorDesc if consumeRcd else '',
            'consumeOrderCreateTime': consumeRcd.dateTimeAdded.strftime('%Y-%m-%d %H:%M:%S') if consumeRcd else '',
            'consumeDetail': consumeRcd.attachParas if consumeRcd else {},
            'consumeDict': consumeRcd.servicedInfo if consumeRcd else {}
        }

    def set_ledgered(self):
        try:
            modified = self.update(isAllocatedCardMoney = True)
            if not modified:
                logger.error('failed to update isAllocatedCardMoney for record=%r' % (self,))
        except Exception as e:
            logger.exception(e)

    def new_refund_cash_order(self, refund_order): # type: (RefundMoneyRecord)->RechargeRecord
        payload = {}

        for field in self.__class__._fields_ordered:
            if field in ['id', 'orderNo', 'wxOrderNo', 'transactionId', 'dateTimeAdded', 'ledgerStatus',
                         'finishedTime', 'notifiedTime', 'operator', 'devTypeName', 'money', 'coins',
                         'selectedQuickPayPackageId', 'devType', 'attachParas', 'isAllocatedCardMoney', 'subject']:
                continue

            payload.update({
                field: getattr(self.payOrder, field)
            })

        payload.update({
            'orderNo': refund_order.orderNo,
            'money': -refund_order.money,
            'coins': -refund_order.coins,
            'devTypeName': self.dev_type_name,
            'via': RechargeRecordVia.RefundCash,

            'isAllocatedCardMoney': False,

            'gateway': self.my_gateway,
            'payGatewayKey': self.pay_gateway_key,
            'payAppType': self.pay_app_type,
            'withdrawSourceKey': self.withdraw_source_key,

            'result': self.PayResult.REFUNDING,

            'extraInfo': {
                'refPay': {'objId': str(self.id)}
            },

            'subject': '{} {}'.format(self.subject, u'退费')
        })
        refund_order_record = self.__class__(**payload).save()  # type: RechargeRecord

        refund_order.refund_order_record = refund_order_record

        self.update(push__extraInfo__refRefund = {
            'objId': str(refund_order_record.id),
            'money': refund_order.money.mongo_amount,
            'coins': refund_order.coins.mongo_amount
        })

        return refund_order_record

    def is_refund_available(self, customer):  # type:(CapitalUser) -> bool
        if customer.role == ROLE.dealer:
            if self.ownerId != str(customer.id):
                logger.warning('is not my order. {} != {}'.format(self.ownerId, str(customer.id)))
                return False

            if self.via not in [USER_RECHARGE_TYPE.RECHARGE, USER_RECHARGE_TYPE.RECHARGE_CASH]:
                return False

            return True

        return False


class Dispute(EmbeddedDocument):
    feedback_id = ObjectIdField()


class CardRechargeOrder(Searchable):
    """
    卡充值订单
    """
    orderNo = StringField(verbose_name=u"订单号", default="")

    cardId = StringField(verbose_name=u"实体卡ID", default="")
    cardNo = StringField(verbose_name=u"实体卡NO", default="")

    # 卡绑定的发行地址
    groupId = StringField(verbose_name=u"设备地址编号", default="")
    address = StringField(verbose_name=u"设备地址", default="")
    groupName = StringField(verbose_name=u"交易场地", default="")

    openId = StringField(verbose_name=u"openId", default="")

    money = MonetaryField(verbose_name=u"付款金额", default=RMB('0.00'))
    coins = MonetaryField(verbose_name=u"充值金额", default=RMB('0.00'))

    remarks = StringField(verbose_name=u"备注", default="")
    dateTimeAdded = DateTimeField(default=datetime.datetime.now, verbose_name=u'生成时间')
    sequanceNo = StringField(verbose_name=u"交易流水号", default="")
    status = StringField(verbose_name=u"状态", default="")
    rechargeType = StringField(verbose_name=u"充值类型，一般分网络充值、线下设备充值", default="")  # netpay/device

    dealerId = StringField(verbose_name=u'订单ownerId, 集群需要', default=None)
    rechargeNo = ObjectIdField(verbose_name=u"订单ID")

    operationLog = ListField(verbose_name=u'历史处理结果', default=[])
    processingLog = DictField(verbose_name=u'')

    meta = {
        "collection": "cardRechargeOrder",
        "db_alias": "default",
    }

    def __repr__(self):
        return '<CardRechargeOrder(id=%s, orderNo=%s, cardNo=%s)>' % (str(self.id), self.orderNo, self.cardNo)

    @cached_property
    def rechargeOrder(self):
        return RechargeRecord.objects.filter(id=self.rechargeNo).first()

    @property
    def chargeAmount(self):
        return self.money

    @property
    def bestowAmount(self):
        return RMB(self.coins) - RMB(self.money)

    # 获取卡的订单，但是没有支付的
    @staticmethod
    def get_last_to_do_one(cardId):
        obj = CardRechargeOrder.objects(
            cardId=cardId, status='finishedPay',
            rechargeType__in=["netpay", "sendCoin"]
        ).order_by('-dateTimeAdded').first()
        return obj

    # 获取卡的订单，但是没有支付的
    @staticmethod
    def get_to_do_list(cardId):
        objs = CardRechargeOrder.objects.filter(
            cardId=cardId, status='finishedPay',
            rechargeType__in=['netpay', "sendCoin"]
        )
        money, coins = RMB(0), RMB(0)
        orderNos = []
        cardOrderNos = []
        for obj in objs:
            money += obj.money
            coins += obj.coins
            orderNos.append(obj.rechargeNo)
            cardOrderNos.append(obj.orderNo)
        return money, coins, orderNos, cardOrderNos

    # 更新卡的为到账订单，更新为已经支付
    @staticmethod
    def update_card_order_has_finished(cardId):
        CardRechargeOrder.get_collection().update(
            {'cardId': cardId, 'status': 'finishedPay', 'rechargeType': {"$in": ["netpay", "sendCoin"]}},
            {'$set': {'status': 'finished'}},
            multi = True
        )

    def init_processing_log(self, device, sendMoney, preBalance):
        # type: (DeviceDict, RMB, RMB)->CardRechargeOrder

        self.processingLog = {
            'devNo': device.devNo,
            'logicalCode': device.logicalCode,
            'sendMoney': sendMoney.mongo_amount,
            'preBalance': preBalance.mongo_amount,
            'code': device.get('devType', {}).get('code', ''),
            'time': datetime.datetime.now()
        }
        # return self.save()

    def update_after_recharge_ic_card(self, device, sendMoney, preBalance,
                                      result = ErrorCode.SUCCESS, description = '', syncBalance = None):
        # type: (DeviceDict, RMB, RMB, int, basestring, Optional[RMB])->CardRechargeOrder

        log = {
            'devNo': device.devNo,
            'logicalCode': device.logicalCode,
            'sendMoney': sendMoney.mongo_amount,
            'preBalance': preBalance.mongo_amount,
            'code': device.get('devType', {}).get('code', ''),
            'result': result,
            'description': description,
            'time': datetime.datetime.now()
        }

        if syncBalance:
            log['syncBalance'] = syncBalance.mongo_amount

        self.operationLog.append(log)

        if result == ErrorCode.SUCCESS:
            self.status = 'finished'

        return self.save()

    def update_after_recharge_id_card(self, device, balance, preBalance):
        # type: (Optional[DeviceDict], RMB, RMB)->CardRechargeOrder

        if device:
            log = {
                'devNo': device.devNo,
                'logicalCode': device.logicalCode,
                'balance': balance.mongo_amount,
                'preBalance': preBalance.mongo_amount,
                'code': device.get('devType', {}).get('code', ''),
                'time': datetime.datetime.now()
            }
        else:
            log = {
                'balance': balance.mongo_amount,
                'preBalance': preBalance.mongo_amount,
                'time': datetime.datetime.now()
            }

        self.operationLog.append(log)

        self.status = 'finished'

        return self.save()

    @staticmethod
    def new_one(openId, cardId, cardNo, money, coins, group, rechargeId, rechargeType = 'netpay'):
        # type:(str, str, str, RMB, RMB, GroupDict, ObjectId, str)->CardRechargeOrder

        newRcd = CardRechargeOrder(
            orderNo = OrderNoMaker.make_order_no_32(identifier = cardNo,
                                                    main_type = OrderMainType.PAY,
                                                    sub_type = UserPaySubType.CARD_RECHARGE_RECORD),
            cardId = str(cardId),
            cardNo = cardNo,
            openId = openId,
            money = money,
            coins = RMB(coins.amount),
            status = 'finishedPay',
            rechargeType = rechargeType,
            dealerId = group.ownerId,
            groupId = group.groupId,
            address = group.address,
            groupName = group.groupName,
            rechargeNo = rechargeId
        )

        logger.info('make card recharge order = %s' % repr(newRcd))

        try:
            return newRcd.save()
        except Exception as e:
            logger.exception('save cardId = %s; cardNo = %s; recharge error = %s' % (cardId, cardNo, e))

        return None

    def to_detail(self):
        # type: ()->dict
        """

        :return:
        """
        return {
            'orderNo': self.orderNo,
            'cardNo': self.cardNo,

            'openId': self.openId,
            'groupId': self.groupId,

            'amount': self.money,

            'devNo': '',
            'logicalCode': '',
            'devType': '',
            'groupNumber': '',

            'groupName': self.groupName,
            'address': self.address
        }

    @classmethod
    def get_by_rechargeRecord(cls, record):
        # type:(RechargeRecord)->CardRechargeOrder

        return cls.objects(rechargeNo = record.id).first()


class CardRechargeRecord(Searchable):
    orderNo = StringField(verbose_name = "关联订单号", default = "")  # 关联订单处理卡退费
    cardId = StringField(verbose_name = "实体卡ID", default = "")
    cardNo = StringField(verbose_name = "实体卡号", default = "")
    openId = StringField(verbose_name = "openId", default = "")
    ownerId = ObjectIdField(verbose_name = "dealerId")
    money = MonetaryField(verbose_name = "付款金额", default = RMB('0.00'))
    coins = MonetaryField(verbose_name = "充值金额", default = VirtualCoin('0.00'))

    chargeBalance = MonetaryField(verbose_name="充值余额", default=RMB(0))
    bestowBalance = MonetaryField(verbose_name="赠送余额", default=RMB(0))
    preChargeBalance = MonetaryField(verbose_name="之前充值余额", default=RMB(0))
    preBestowBalance = MonetaryField(verbose_name="之前赠送余额", default=RMB(0))

    devNo = StringField(verbose_name = "设备ID", default = "")
    devTypeCode = StringField(verbose_name = "设备类型编码", default = "")
    logicalCode = StringField(verbose_name = "设备逻辑编码", default = "")

    groupId = StringField(verbose_name = "设备地址编号", default="")
    address = StringField(verbose_name = "设备地址", default = "")
    groupNumber = StringField(verbose_name = "设备", default = "")
    groupName = StringField(verbose_name = "交易场地", default = "")
    #: 在部分场合，设备会失败启动，但这时应该添加该字段为False方便追溯
    remarks = StringField(verbose_name="备注", default="")
    dateTimeAdded = DateTimeField(default=datetime.datetime.now, verbose_name='生成时间')
    sequanceNo = StringField(verbose_name="交易流水号,有些刷卡的会上报", default="")
    status = StringField(verbose_name="状态", default="")
    rechargeType = StringField(verbose_name="充值类型，一般分网络充值、线下设备充值", default="")

    meta = {
        "collection": "cardRechargeRecord",
        "db_alias": "default",
        # "shard_key":('cardId',),
    }

    @property
    def amount(self):
        return self.money

    @property
    def balance(self):
        return self.chargeBalance + self.bestowBalance

    @property
    def preBalance(self):
        return self.preChargeBalance + self.preBestowBalance

    @property
    def dealer(self):
        return Dealer.objects(id=self.ownerId).get()

    @staticmethod
    def make_no():
        timestamp = generate_timestamp_ex()
        random_int = random.randint(1, 1000)
        return "%d%03d" % (timestamp, random_int)

    @classmethod
    def add_self_card_record(cls, cardId, group, money, device):
        newRcd = CardRechargeRecord(
            cardId = cardId,
            ownerId = ObjectId(group.ownerId),
            money = money,
            coins = money,

            groupId = group.groupId,
            address = group.address,
            groupName = group.groupName,

            status = 'success',
            rechargeType = 'dealer_oper',

            devNo = device.devNo,
            devTypeCode = device.get('devType', {}).get('code', ''),
            logicalCode = device.logicalCode,
            groupNumber = device.groupNumber
        )

        try:
            return newRcd.save()
        except Exception as e:
            logger.exception('save card consume rcd error=%s' % e)

    @staticmethod
    def add_record(card, group, order, device=None):
        # type:(Card, GroupDict, CardRechargeOrder, Optional[DeviceDict])->CardRechargeRecord
        newRcd = CardRechargeRecord(
            cardId=str(card.id),
            cardNo=card.cardNo,
            openId=card.openId,
            ownerId=ObjectId(group.ownerId),
            money=order.money,
            coins=order.coins,
            chargeBalance=order.chargeAmount + card.chargeBalance,
            bestowBalance=order.bestowAmount + card.bestowBalance,
            preChargeBalance=card.chargeBalance,
            preBestowBalance=card.bestowBalance,

            groupId=group.groupId,
            address=group.address,
            groupName=group.groupName,

            status='success',
            rechargeType=order.rechargeType
        )

        if device:
            newRcd.devNo = device.devNo
            newRcd.logicalCode = device.logicalCode
            newRcd.devTypeCode = device.devTypeCode
            newRcd.groupNumber = device.groupNumber

        try:
            return newRcd.save()
        except Exception as e:
            logger.exception('save card consume rcd error=%s' % e)


class CardConsumeRecord(Searchable):
    orderNo = StringField(verbose_name = "订单号", default = "")
    openId = StringField(verbose_name = "微信ID", default = "")
    cardId = StringField(verbose_name = "实体卡ID", default = "")
    money = MonetaryField(verbose_name = "消耗的钱(硬币)", default = RMB('0.00'))
    balance = MonetaryField(verbose_name = "当前余额(硬币)", default = RMB('0.00'))
    devNo = StringField(verbose_name = "设备ID", default = "")
    devType = StringField(verbose_name = "设备类型", default = "")
    logicalCode = StringField(verbose_name = "设备逻辑编码", default = "")
    groupId = StringField(verbose_name = "设备地址编号", default = "")
    address = StringField(verbose_name = "设备地址", default = "")
    groupNumber = StringField(verbose_name = "设备", default = "")
    groupName = StringField(verbose_name = "交易场地", default = "")
    result = StringField(verbose_name = "消费结果", default = "")
    remarks = StringField(verbose_name = "备注", default = "")
    desc = StringField(verbose_name = "描述", default = "")

    dateTimeAdded = DateTimeField(verbose_name = '生成时间', default = datetime.datetime.now)

    finishedTime = DateTimeField(verbose_name = '结束时间', default = datetime.datetime.now)
    servicedInfo = DictField(verbose_name = '服务内容', default = {})
    sid = StringField(verbose_name = "从设备上获取的流水号", default = "")

    linkedConsumeRcdOrderNo = StringField(verbose_name = u'关联的消费订单号.发布后去掉, 两者一致', default = '')

    meta = {
        "collection": "CardConsumeRecord",
        "db_alias": "default",
        # "shard_key":('orderNo',),
    }

    @staticmethod
    def make_no():
        timestamp = generate_timestamp_ex()
        random_int = random.randint(1, 1000)
        return "%d%03d" % (timestamp, random_int)


class ServiceProgress(Searchable):
    open_id = StringField(verbose_name = 'open id', default = '')
    device_imei = StringField(verbose_name = 'device imei', default = '')
    port = IntField(verbose_name = 'port', default = 0)
    isFinished = BooleanField(verbose_name = 'isFinished', default = False)

    devTypeCode = StringField(verbose_name = 'devTypeCode', default = '')
    cardId = StringField(verbose_name = 'cardNo', default = '')

    attachParas = DictField(verbose_name = 'attachParas', default = {})

    consumeOrder = DictField(verbose_name = 'consumeOrder', default = {})
    finished_time = IntField(verbose_name = 'finished time', default = 0)
    start_time = IntField(verbose_name = 'start_time', default = 0)

    consumes = ListField(verbose_name = "对应的所有消费记录单号", default = [])

    # 应该用一个状态表示服务的执行情况，包括等待服务、服务正在进行、服务结束。只有我们才需要此字段
    # 但是只有我们自己的主板支持每个订单的执行情况反馈以及查询，所以没有办法，以前都是裹在一起，现在分开逻辑更清晰。
    status = StringField(verbose_name = u'执行状态', default = 'running')  # waiting/working/finished/failed

    weifuleOrderNo = StringField(verbose_name = u'微付乐订单编号，设备也会产生订单', default = '')
    runningTime = DateTimeField(verbose_name = u'开始运行的时间')

    datetimeAdded = DateTimeField(verbose_name = "时间", default = datetime.datetime.now)

    expireAt = DateTimeField(verbose_name = u"TTL到期时间", default = None)

    meta = {
        'collection': 'service_progress',
        'db_alias': 'logdata'
    }

    @property
    def used_port(self):
        """
        兼容性属性. 以前是整形, 后面全部为字符串型
        :return:
        """
        return str(self.port)

    @property
    def order_no(self):
        return self.attachParas.get('orderNo', None)

    # 更新progress，以及关联的消费日志记录。这个函数一般是服务结束的时候调用，以刷新progress，有时候，结束时
    # 才扣费的场景，扣费的时候会直接把使用后的消耗，记录到消费日志中，就不需要刷新消费日志
    @staticmethod
    def update_progress_and_consume_rcd(ownerId, queryDict, consumeDict, updateConsume = True, progressDict = None):
        progressDict = {
            'isFinished': True, 'finished_time': int(time.time())
        } if progressDict is None else progressDict

        if 'isFinished' in progressDict and progressDict['isFinished']:
            progressDict.update({'expireAt': datetime.datetime.now()})

        rcds = ServiceProgress.get_collection().find(queryDict).sort('start_time')
        if rcds.count() == 0:
            logger.error('can not find the progress info')
            return

        orderIdList, orderNoList, cardOrderNoList = [], [], []
        for rcd in rcds:  # type: Dict
            consumeOrder = rcd.get('consumeOrder', {})

            if 'consumeRecordId' in consumeOrder and consumeOrder['consumeRecordId']:
                orderIdList.append(consumeOrder['consumeRecordId'])
            elif 'orderNo' in consumeOrder and consumeOrder['orderNo']:
                orderNoList.append(consumeOrder['orderNo'])

            if 'cardOrderNo' in consumeOrder:
                cardOrderNoList.append(consumeOrder['cardOrderNo'])

        # 更新进程的数据
        try:
            ServiceProgress.get_collection().update(queryDict, {'$set': progressDict}, multi = True)
        except Exception, e:
            logger.exception('update service progress e=%s' % e)

        if not updateConsume:  # 不需要更新就直接返回
            return

        # 更新订单中的时间以及服务信息。如果是卡的信息，因为找不到order，会直接pass
        # 如果是多条消费单，但是最终只有一条结束事件的场景，统计以及消费信息只记录到第一单上
        isFinished = progressDict and progressDict.get('isFinished', False)

        consume_orders = []
        for orderNo in orderNoList:
            rcd = ConsumeRecord.objects(ownerId = ownerId, orderNo = orderNo).first()  # type: ConsumeRecord
            consume_orders.append(rcd)

        for orderId in orderIdList:
            rcd = ConsumeRecord.objects(ownerId = ownerId, id = orderId).first()  # type: ConsumeRecord
            consume_orders.append(rcd)

        count = 0

        uart_data = consumeDict.pop('uartData', None)

        for rcd in consume_orders:  # type: ConsumeRecord
            try:
                count += 1

                pre_aggInfo = rcd.aggInfo

                # 如果是结束更新，相应的信息只需要更新到第一条中。非结束的，全部都刷新。
                if not isFinished:
                    updated = rcd.update(
                        finishedTime = datetime.datetime.now(),
                        servicedInfo = consumeDict,
                        status = ConsumeRecord.Status.FINISHED)
                elif count == 1:
                    if uart_data:
                        updated = rcd.update(
                            finishedTime = datetime.datetime.now(),
                            servicedInfo = consumeDict,
                            status = ConsumeRecord.Status.FINISHED,
                            attachParas__uartData = uart_data)
                    else:
                        updated = rcd.update(
                            finishedTime = datetime.datetime.now(),
                            servicedInfo = consumeDict,
                            status = ConsumeRecord.Status.FINISHED)
                else:
                    continue

                if not updated:
                    logger.error('%r updated failed' % (rcd,))

                if isFinished and count == 1:  # 只需要汇总一次使用的数据即可
                    try:
                        valueDict = {}
                        for kind, value in consumeDict.items():
                            if kind in DEALER_CONSUMPTION_AGG_KIND.choices():
                                if kind in pre_aggInfo:
                                    #: 会在发起service阶段更新一次报表
                                    #: 此处为结束时更新, 应该更新新数据 - 初始更新的数据
                                    valueDict[kind] = float(str(value)) - float(str(pre_aggInfo[kind]))
                                else:
                                    valueDict[kind] = value

                        status = rcd.update_agg_info(valueDict)
                        if status:
                            record_consumption_stats(rcd)
                        else:
                            logger.error(
                                '[update_progress_and_consume_rcd] failed to update_agg_info record=%r' % (rcd,))

                    except Exception, e:
                        logger.exception('update agg info error=%s' % e)

            except Exception as e:
                logger.exception('update consume rcd e=%s' % e)
                continue

        for orderNo in cardOrderNoList:
            if orderNo == '':
                continue
            try:
                CardConsumeRecord.get_collection().update_one({'orderNo': orderNo}, {
                    '$set': {'finished_time': int(time.time()), 'servicedInfo': consumeDict}})
            except Exception, e:
                logger.exception('update consume rcd e=%s' % e)
                continue

    @staticmethod
    def register_card_service(dev, port, card, consumeOrder = None, finishedTime = None):
        # type:(DeviceDict, int, Card, dict, int)->None

        consumeOrder = {} if consumeOrder is None else consumeOrder
        finishedTime = int(time.time()) + 24 * 60 * 60 if finishedTime is None else finishedTime

        ServiceProgress.get_collection().insert({
            'device_imei': dev.devNo,
            'devTypeCode': dev.devTypeCode,
            'cardId': str(card.id),
            'port': port,
            'finished_time': finishedTime,
            'start_time': int(time.time()),
            'open_id': card.openId,
            'consumeOrder': consumeOrder,
            'isFinished': False,
            'attachParas': {},
            'expireAt': datetime.datetime.now() + datetime.timedelta(days = 91)
        })

    @staticmethod
    def register_card_service_for_weifule(dev, port, card, consumeOrder):
        ServiceProgress.get_collection().insert({
            'device_imei': dev['devNo'],
            'devTypeCode': dev['devType']['code'],
            'cardId': str(card.id),
            'port': port,
            'finished_time': int(time.time()) + 24 * 60 * 60,
            'start_time': int(time.time()),
            'open_id': card.openId,
            'consumeOrder': consumeOrder,
            'isFinished': False,
            'attachParas': {},
            'status': 'waiting',
            'weifuleOrderNo': consumeOrder['orderNo'],
            'expireAt': datetime.datetime.now() + datetime.timedelta(days = 91)
        })

    @classmethod
    def new_progress_for_order(cls, order, device, cache_info):
        # type:(ConsumeRecord, DeviceDict, dict)->None

        try:
            consumeOrder = {
                'consumeRecordId': str(order.id),
                'orderNo': order.orderNo,
                'coin': VirtualCoin(cache_info['coins']).mongo_amount,
                'consumeType': cache_info.get('consumeType') or (
                    'mobile_vcard' if u'虚拟卡' in order.remarks else 'mobile')
            }

            if 'money' in cache_info:
                consumeOrder.update({'money': RMB(cache_info['money']).mongo_amount})

            if 'unit' in cache_info:
                consumeOrder.update({'unit': cache_info['unit']})

            if 'subOrderNos' in cache_info:
                consumeOrder.update({'subOrderNos': cache_info['subOrderNos']})

            if 'needKind' in cache_info and 'needValue' in cache_info:
                consumeOrder.update({
                    cache_info['needKind']: cache_info['needValue']
                })

            if 'cardId' in cache_info:
                consumeOrder.update({'cardId': cache_info['cardId']})

            update_dict = {
                'open_id': cache_info['openId'],
                'device_imei': device.devNo,
                'devTypeCode': device['devType']['code'],
                'port': order.used_port,
                'attachParas': order.attachParas,
                'start_time': int(
                    Arrow.fromdatetime(order.startTime, tzinfo = settings.TIME_ZONE).timestamp),
                'finished_time': int(cache_info['estimatedTs']),
                'consumeOrder': consumeOrder,
                'isFinished': False,
                'expireAt': datetime.datetime.now() + datetime.timedelta(days = 91)
            }

            cls.objects(open_id = order.openId,
                        device_imei = device.devNo,
                        port = order.used_port).update_one(upsert = True, **update_dict)
        except Exception as e:
            logger.exception(e)

    @classmethod
    def finish_progress_for_order(cls, order, device):
        # type:(ConsumeRecord, DeviceDict)->None

        cls.get_collection().update_one(filter = {
            'open_id': order.openId,
            'device_imei': device.devNo,
            'port': int(order.used_port),
            'consumeOrder.consumeRecordId': str(order.id)
        }, update = {
            '$set': {
                'isFinished': True,
                'finished_time': Arrow.fromdatetime(order.finishedTime,
                                                    tzinfo = settings.TIME_ZONE).timestamp,
                'expireAt': datetime.datetime.now()
            }
        }, upsert = False)


class Card(Searchable):
    cardNo = StringField(verbose_name="卡号", default="")
    cardType = StringField(verbose_name="卡类型", default="")
    openId = StringField(verbose_name="绑定的微信", default="")
    nickName = StringField(verbose_name="用户昵称", default="")
    productAgentId = StringField(verbose_name="当前用户绑定的平台代理商", default = "")

    cardName = StringField(verbose_name="持卡人姓名", default="")
    phone = StringField(verbose_name="手机号码", default="")

    # 绑定的管理APP信息
    managerialAppId = StringField(verbose_name="管理公众号AppId", default="")
    managerialOpenId = StringField(verbose_name="管理openId", default="")

    dealerId = StringField(verbose_name="经销商ID", default="")
    groupId = StringField(verbose_name="设备组ID", default="")
    agentId = StringField(verbose_name="代理商ID", default="")

    # 以下信息为卡固有信息
    remarks = StringField(verbose_name="备注", default="")
    chargeBalance = MonetaryField(verbose_name="充值余额", default=RMB(0))
    bestowBalance = MonetaryField(verbose_name=u"赠送余额", default=RMB(0))

    isHaveBalance = BooleanField(verbose_name="是否能够获取到卡的余额数据", default=True)
    lastMaxBalance = MonetaryField(verbose_name="最后一次充卡金额", default=RMB('0.00'))

    boundVirtualCardId = ObjectIdField(verbose_name=u"绑定的虚拟卡券ID")
    showBalance = MonetaryField(verbose_name=u"显示到设备上的卡余额，只有微付乐才会用此字段", default=RMB('0.00'))

    # 最近一次刷卡的设备
    devNo = StringField(verbose_name="设备IMEI", default="")
    devTypeCode = StringField(verbose_name="设备类型代码", default="")
    frozen = BooleanField(verbose_name="卡挂失状态", default=False)
    status = StringField(verbose_name="卡状态", default='active')
    dateTimeAdded = DateTimeField(verbose_name=u"添加卡的时间", default=datetime.datetime.now)
    attachParas = DictField(verbose_name='附加参数', default={})

    ongoingList = ListField(field=DictField(), verbose=u'冻结的金额')
    search_fields = ('cardNo', 'cardName', 'phone')

    meta = {
        "collection": "recharge_card",
        "db_alias": "default",
    }

    def __repr__(self):
        return '<Card(id={}, cardNo={})>'.format(str(self.id), self.cardNo)

    @cached_property
    def group(self):
        if not self.groupId:
            return None
        return Group.get_group(self.groupId)

    @cached_property
    def user(self):
        if not self.isBinded:
            return None

        return MyUser.objects.filter(openId=self.openId, groupId=self.groupId).first()

    @property
    def balance(self):
        return self.chargeBalance + self.bestowBalance

    @property
    def nickname(self):
        return self.nickName

    @property
    def is_id_card(self):
        # type: ()->bool
        return self.cardType == RECHARGE_CARD_TYPE.ID

    @property
    def is_ic_card(self):
        # type: ()->bool
        return self.cardType == RECHARGE_CARD_TYPE.IC

    @property
    def isBinded(self):
        """
        用户的绑定状态
        """
        return True if self.openId and self.openId != Const.DEFAULT_CARD_OPENID else False

    def recharge(self, money, bestowMoney):
        assert isinstance(money, RMB), 'coins had to be VirtualCoin'
        assert isinstance(bestowMoney, RMB), 'money has to be RMB'

        updated = self.update(
            inc__chargeBalance=money,
            inc__bestowBalance=bestowMoney,
        )

        if not updated:
            raise PostPayOrderError(u'余额和累计充值更新失败')

        return self.reload()

    def account_consume(self, order):   # type:(ConsumeRecord) -> None
        self.reload()
        payment = order.payment
        # 获取支付的钱
        consumeAmount = payment.actualAmount
        consumeBestowAmount = payment.totalAmount - consumeAmount

        # 获取当前的余额

        CardBalanceLog.consume(
            self,
            afterAmount=self.chargeBalance,
            afterBestowAmount=self.bestowBalance,
            consumeAmount=consumeAmount,
            consumeBestowAmount=consumeBestowAmount,
            order=order
        )

    def account_refund(self, order):    # type:(ConsumeRecord) -> None
        self.reload()
        refund = order.refund
        # 获取支付的钱
        refundAmount = refund.actualAmount
        refundBestowAmount = refund.totalAmount - refundAmount

        CardBalanceLog.refund(
            self,
            afterAmount=self.chargeBalance,
            afterBestowAmount=self.bestowBalance,
            refundAmount=refundAmount,
            refundBestowAmount=refundBestowAmount,
            order=order
        )

    def account_recharge(self, order):  # type:(RechargeRecord) -> None
        # 获取支付的钱
        chargeAmount = order.chargeAmount
        bestowAmount = order.bestowAmount

        CardBalanceLog.recharge(
            self,
            afterAmount=self.chargeBalance,
            afterBestowAmount=self.bestowBalance,
            chargeAmount=chargeAmount,
            chargeBestowAmount=bestowAmount,
            order=order
        )



    @classmethod
    def fake_one(cls, groupId, cardId='fake_id', cardNo='fake'):
        return cls(id=cardId, cardNo=cardNo, openId='', productAgentId='', groupId=groupId)

    @staticmethod
    def get_card_status(cardId):
        status = serviceCache.get(cardId, 'idle')
        return status

    @staticmethod
    def set_card_status(cardId, status):
        serviceCache.set(cardId, status, 10)

    @staticmethod
    def get_dev_cur_card(devNo):
        return serviceCache.get('%s_cardId' % devNo, None)

    @staticmethod
    def set_dev_cur_card(devNo, cardInfo):
        serviceCache.set('%s_cardId' % devNo, cardInfo, 90)

    @property
    def bound_virtual_card(self):
        # type: ()->Optional[UserVirtualCard]

        if self.boundVirtualCardId:
            now = datetime.datetime.now()
            virtual_card = UserVirtualCard.objects(id = self.boundVirtualCardId,
                                                   expiredTime__gte = now,
                                                   startTime__lte = now).first()
            return virtual_card
        else:
            return None

    def bind_virtual_card(self, card):
        # type:(UserVirtualCard)->None
        return self.update(boundVirtualCardId = card.id)

    def unbind_virtual_card(self, card):
        # type:(UserVirtualCard)->None
        """
        以后也许会支持多张卡
        :param card:
        :return:
        """
        return self.update(boundVirtualCardId = None)

    # 这个那种有余额的卡，才会调用
    @staticmethod
    def update_balance(cardId, balance):
        card = Card.objects(id=cardId).get()
        result = card.update(balance = balance)
        if not result:
            logger.error('update error, cardId=%s, balance=%s' % (cardId, balance))
        return result

    @staticmethod
    def check_card_no(cardNo):
        """
        检查实体卡卡号的合法性
        :param cardNo:
        :return:
        """
        if CARD_NO_RE.match(cardNo):
            return True
        return False

    @classmethod
    def check_swap_card_no(cls, cardNo, dealerId, agentId):
        try:
            card = cls.objects.get(cardNo=cardNo, agentId=agentId)
        except DoesNotExist:
            return True, ""

        if card.dealerId and card.dealerId != dealerId:
            return False, u"该卡已经被其他经销商绑定，请确认卡号无误"

        if card.openId:
            return False, u"该卡号已经被其他用户绑定，请确认卡号无误"

        if CardConsumeRecord.objects.filter(cardId=str(card.id)):
            return False, u"该卡号存在用户使用记录, 请确认卡号无误"

        card.delete()
        return True, ""

    @staticmethod
    def record_dev_card_no(devNo, cardNo):
        serviceCache.set('%s-cardno' % devNo, cardNo, 2 * 60)

    @staticmethod
    def get_dev_card_no(devNo):
        return serviceCache.get('%s-cardno' % devNo, None)

    @staticmethod
    def clear_dev_card_no(devNo):
        serviceCache.delete('%s-cardno' % devNo)

    def to_dict(self):
        data = {
            "cardId": str(self.id),
            "cardNo": self.cardNo,
            "cardName": self.cardName,
            "phone": self.phone,
            "cardType": self.cardType,
            "remarks": self.remarks,
            "frozen": self.frozen,
            "balance": self.balance,
            "lastMaxBalance": self.lastMaxBalance,
            "bindStatus": self.isBinded,
        }

        return data

    def freeze_transaction_id(self, freezeType):
        return '{}_{}'.format(freezeType, str(self.id))


    @classmethod
    def freeze_balance(cls, transaction_id, payment):
        bulker = BulkHandlerEx(cls.get_collection())  # type: BulkHandlerEx
        chargeBalanceField = cls.chargeBalance.name
        bestowBalanceField = cls.bestowBalance.name

        for deduct in payment.deduct_list:
            query = {
                '_id': ObjectId(deduct['id']),
                'ongoingList.transaction_id': {
                    '$ne': transaction_id
                }
            }

            update = {
                '$inc': {
                    chargeBalanceField: (-RMB(deduct[chargeBalanceField])).mongo_amount,
                    bestowBalanceField: (-RMB(deduct[bestowBalanceField])).mongo_amount
                },
                '$addToSet': {
                    'ongoingList': {
                        'transaction_id': transaction_id,
                        chargeBalanceField: deduct[chargeBalanceField],
                        bestowBalanceField: deduct[bestowBalanceField]
                    }
                }
            }
            bulker.update(query, update)

        result = bulker.execute()

        logger.debug(result['info'])

        if result['success'] == 0:
            raise ServiceException({'result': 0, 'description': u"扣款失败(1001)"})
        else:
            if len(result['info']['writeErrors']) != 0:
                raise ServiceException({'result': 0, 'description': u"扣款失败(1002)"})
            else:
                return True

    @classmethod
    def clear_frozen_balance(cls, transaction_id, refund):
        try:
            bulker = BulkHandlerEx(cls.get_collection())  # type: BulkHandlerEx
            chargeBalanceField = cls.chargeBalance.name
            bestowBalanceField = cls.bestowBalance.name

            for deduct in refund.deduct_list:
                query = {
                    '_id': ObjectId(deduct['id']),
                    'ongoingList': {
                        '$elemMatch': {
                            'transaction_id': transaction_id
                        }
                    }
                }

                update = {
                    '$inc': {
                        chargeBalanceField: deduct[chargeBalanceField],
                        bestowBalanceField: deduct[bestowBalanceField],
                    },
                    '$pull': {
                        'ongoingList': {
                            'transaction_id': transaction_id
                        }
                    }
                }
                bulker.update(query, update)

            result = bulker.execute()

            logger.debug(result['info'])

            if result['success'] == 0:
                return False
            else:
                if len(result['info']['writeErrors']) != 0:
                    return False
                else:
                    return True
        except Exception as e:
            logger.exception(e)
            return False

    @classmethod
    def recover_frozen_balance(cls, transaction_id, deduct_list):
        bulker = BulkHandlerEx(cls.get_collection())  # type: BulkHandlerEx

        for deduct in deduct_list:
            query = {
                '_id': ObjectId(deduct['id']),
                'ongoingList': {
                    '$elemMatch': {'transaction_id': transaction_id}}}

            update = {
                '$inc': {
                    'balance': deduct['coins']
                },
                '$pull': {
                    'ongoingList': {
                        'transaction_id': transaction_id, 'frozenCoins': deduct['coins']
                    }}
            }
            bulker.update(query, update)

        result = bulker.execute()
        if result['success'] == 0:
            logger.error(result['info'])
            return False
        else:
            if len(result['info']['writeErrors']) != 0:
                logger.error(result['info'])
                return False
            else:
                return True


    def clear_card(self):
        return self.update(
            cardType = '',
            openId = '',
            nickName = '',
            productAgentId = '',
            cardName = '',
            phone = '',
            managerialAppId = '',
            managerialOpenId = '',
            dealerId = '',
            groupId = '',
            remarks = '',
            isHaveBalance = True,
            lastMaxBalance = RMB('0.0'),
            devNo = '',
            devTypeCode = '',
            frozen = False,
            status = 'active',
            boundVirtualCardId = None,
            attachParas = {}
        )


class RefundMoneyRecord(RefundOrderBase):
    """
    用户退款记录
    """

    refIncomeOrder = ObjectIdField(verbose_name = u'对应收益单', default = None)
    coins = MonetaryField(verbose_name = u"清理用户金币数", default = None)

    meta = {
        "collection": "RefundMoneyRecord",
        "db_alias": "default",
    }

    @classmethod
    def issue(cls, order, refundCash, **extraInfo):
        # type:(RechargeRecord, RMB, dict)->RefundMoneyRecord

        extraInfo.update({'v': 2})

        if order.via in [USER_RECHARGE_TYPE.RECHARGE_CARD, USER_RECHARGE_TYPE.RECHARGE_VIRTUAL_CARD]:
            identifier = order.attachParas['cardNo']
        elif order.via in [USER_RECHARGE_TYPE.RECHARGE_MONTHLY_PACKAGE]:
            identifier = order.attachParas.get('cardId')
        else:
            identifier = order.logicalCode

        refund_order_no = OrderNoMaker.make_order_no_32(
            identifier = identifier,
            main_type = OrderMainType.REFUND,
            sub_type = RefundSubType.REFUND)

        return cls(
            rechargeObjId = order.id,
            # refundSeq=next_seq,
            orderNo = refund_order_no,
            money = refundCash,
            status = cls.Status.PROCESSING,
            datetimeAdded = datetime.datetime.now(),
            extraInfo = dict_field_with_money(extraInfo),
            payAppType = order.pay_app_type
        ).save()

    @property
    def pay_sub_order(self):
        # type: ()->RechargeRecord

        if not hasattr(self, '__pay_sub_order__'):
            from apps.web.common.proxy import ClientRechargeModelProxy
            pay_order = ClientRechargeModelProxy.get_one(id = str(self.rechargeObjId))  # type: RechargeRecord
            setattr(self, '__pay_sub_order__', pay_order)

        return getattr(self, '__pay_sub_order__')

    @pay_sub_order.setter
    def pay_sub_order(self, order):
        setattr(self, '__pay_sub_order__', order)

    @property
    def pay_app_type(self):
        if self.payAppType:
            return self.payAppType
        else:
            return self.pay_sub_order.pay_app_type

    @property
    def refund_income_order(self):
        if not hasattr(self, '__refund_income_order__'):
            if self.refIncomeOrder:
                order = RechargeRecord.objects(
                    id = self.refIncomeOrder).first()
            else:
                # 对老的方式的兼容
                order = RechargeRecord.objects(
                    id = self.pay_sub_order.extraInfo['refRefund'][0]['objId']).first()

            setattr(self, '__refund_income_order__', order)

        return getattr(self, '__refund_income_order__')

    @refund_income_order.setter
    def refund_income_order(self, obj):
        setattr(self, '__refund_income_order__', obj)

    @property
    def user(self):
        # type: ()->MyUser
        return self.pay_sub_order.user

    @property
    def notify_url(self):
        if self.pay_app_type in [PayAppType.WECHAT]:
            return REFUND_NOTIFY_URL.WECHAT_REFUND_BACK
        else:
            return None

    @property
    def checkWallet(self):
        return self.extraInfo.get('checkWallet', False)

    @property
    def operatorId(self):
        return self.extraInfo.get('operatorId', None)

    @property
    def is_new_version(self):
        return self.extraInfo.get('v', 1) > 1

    @property
    def deductCoins(self):
        """
        兼容以前数据.退现金同时被扣费的钱包余额。后续需要建模为被扣的描述(钱包就是被扣金额, 月卡等有自己的描述)
        :return:
        """
        if self.is_new_version:
            return VirtualCoin(self.extraInfo.get('deductCoins', 0))
        else:
            return self.coins

    @property
    def frozenCoins(self):
        """
        不退现金情况下应该退的钱包余额
        :return:
        """
        if self.is_new_version:
            return VirtualCoin(self.extraInfo.get('frozenCoins', 0))
        else:
            return self.coins


class VCardConsumeRecord(OrderRecordBase):
    orderNo = StringField(verbose_name = "订单号", default = "")
    cardId = StringField(verbose_name = "实体卡ID", default = "")
    dealerId = StringField(verbose_name = "经销商ID", default = "")

    # : 在部分场合，设备会失败启动，但这时应该添加该字段为False方便追溯
    remarks = StringField(verbose_name = "备注", default = "")
    desc = StringField(verbose_name = "描述", default = "")

    finishedTime = DateTimeField(verbose_name = '结束时间', default = datetime.datetime.now)
    servicedInfo = DictField(verbose_name = '服务内容', default = {})
    attachParas = DictField(verbose_name = '服务内容', default = {})

    # 本次消费消耗的额度
    consumeData = DictField(verbose_name = '消耗的额度', default = {})
    # 日限额消耗的额度
    consumeDayData = DictField(verbose_name = '消耗的额度', default = {})

    meta = {
        "collection": "VCardConsumeRecord",
        "db_alias": "default",
    }

    @staticmethod
    def make_no(identifier):
        # time:14;main_type:1;sub_type:1;identifier:15;extra:5
        return '{time}{main_type}{sub_type}{identifier}{reserved}'.format(
            time = datetime.datetime.now().strftime("%Y%m%d%H%M%S"),
            main_type = OrderMainType.CONSUME,
            sub_type = UserConsumeSubType.VIRTUAL_CARD,
            identifier = '{:0>15}'.format(identifier),
            reserved = get_random_str(5, string.digits + string.uppercase))

    @staticmethod
    def paginate(cardId, pageIndex, pageSize):
        records = VCardConsumeRecord.objects.filter(cardId = cardId) \
            .order_by('-dateTimeAdded').skip((pageIndex - 1) * pageSize).limit(pageSize)

        if not records:
            return 0, []

        dataList = []
        for record in records:
            newData = {
                'id': str(record.id),
                'createdTime': record.dateTimeAdded.strftime(Const.DATETIME_FMT),
                'address': record.address,
                'devNo': record.devNo,
                'openId': record.openId,
                'nickname': record.nickname,
                'logicalCode': record.logicalCode,
                'groupNumber': record.groupNumber,
                'groupName': record.groupName,
                'unit': record.consumeData.get("unit", ""),
                'devTypeCode': record.devTypeCode,
                'devTypeName': record.dev_type_name,
                'isNormal': True,
                'ownerId': record.dealerId
            }

            amount = record.consumeData.get("count", "")
            if amount:
                amount = Quantity(amount)

            newData.update({'amount': amount})

            if record.servicedInfo:
                newData.update(record.servicedInfo)

            dataList.append(newData)

        return len(dataList), dataList

    @property
    def amount(self):
        _amount = self.consumeData.get("count", None)
        if _amount is not None:
            return str(Quantity(_amount))
        else:
            return ""

    @property
    def unit(self):
        return self.consumeData.get("unit", "")

    @property
    def created_date(self):
        return self.dateTimeAdded

    @property
    def completion_date(self):
        return self.finishedTime

    @property
    def device_start_time(self):
        return self.dateTimeAdded

    @property
    def device_finished_time(self):
        return self.finishedTime

    def to_user_detail(self):
        """
        消费记录对于用户端显示的详细信息
        :return:
        """

        data = {
            'id': str(self.id),

            'orderNo': self.orderNo,

            'createdTime': self.dateTimeAdded.strftime(Const.DATETIME_FMT),

            'deviceStatTime': self.device_start_time,
            'address': self.address,
            'devNo': self.devNo,
            'logicalCode': self.logicalCode,
            'groupNumber': self.groupNumber,
            'groupName': self.groupName,
            'devTypeCode': self.devTypeCode,
            'devTypeName': self.dev_type_name,
            'isNormal': True,
            'amount': self.amount,
            'unit': self.unit,
            'ownerId': self.dealerId,
            'consumeType': 'mobile_vcard',
            'openId': self.openId,
            'userNickname': self.nickname
        }

        # 兼容之前的订单 凡是没有订单状态机的订单，一律视为 之前的订单
        if hasattr(self, "state") and self.state:
            data.update({"orderStatus": self.state})

        if self.servicedInfo:
            data.update(self.servicedInfo)

        return data

    @property
    def ownerId(self):
        return self.dealerId

    @property
    def owner(self):
        from apps.web.dealer.models import Dealer

        _attr_name = '__my_owner__'

        if hasattr(self, _attr_name):
            return getattr(self, _attr_name)
        else:
            if not self.dealerId:
                return None
            else:
                dealer = Dealer.objects(id = self.dealerId).first()
                setattr(self, _attr_name, dealer)
                return dealer

    @property
    def summary(self):
        return {
            'id': str(self.id),

            'consumeType': 'mobile_vcard',

            'ownerId': self.ownerId,

            'logicalCode': self.logicalCode,

            'groupName': self.groupName,
            'devTypeName': self.dev_type_name,

            'amount': self.amount,
            'unit': self.unit,

            'createdTime': self.dateTimeAdded.strftime(Const.DATETIME_FMT),
        }


VirtualCardQuotaList = List[Dict[str, Union[float, unicode]]]


class UserVirtualCard(Searchable):
    cardNo = StringField(verbose_name = "卡编号", default = "")
    cardTypeId = StringField(verbose_name = u'卡的类型ID', default = '')  # 如果卡停止销售了，这里就可以不允许续充
    openIds = ListField(verbose_name = "绑定的用户")  # 里面放的是MyUser的Id
    cardName = StringField(verbose_name = "卡名称", default = "")
    ownerOpenId = StringField(verbose_name = "卡的所有者", default = "")
    nickname = StringField(verbose_name = "昵称", default = "")
    logicalCode = StringField(verbose_name = u'发卡的时候记录的设备编码', default = '')
    groupId = StringField(verbose_name = u'发卡的时候记录的地址', default = '')

    dealerId = StringField(verbose_name = "卡的发布老板", default = "")
    groupIds = ListField(verbose_name = "可用使用卡的地址", default = [])  # 空表示没有地址，*表示所有地址下可用
    devTypeList = ListField(verbose_name = "设备类型清单", default = [])
    price = MonetaryField(verbose_name = "卡的售价", default = RMB('0.00'))
    periodDays = IntField(verbose_name = "卡的可用天数", default = 30)
    expiredTime = DateTimeField(verbose_name = "过期时间",
                                default = lambda: datetime.datetime.now() + datetime.timedelta(days = 365))

    userLimit = IntField(verbose_name = "用户数量限制", default = 10)
    userDesc = StringField(verbose_name = "描述", default = "")

    dayQuota = ListField(verbose_name = "日限额度", default = [])  # {'unit':u'次','count':2}
    quota = ListField(verbose_name = "总的额度", default = [])
    frozenQuota = ListField(verbose_name = u'冻结额度', default = [])

    startTime = DateTimeField(verbose_name = "买卡的时间", default = datetime.datetime.now)
    dayUsed = DictField(verbose_name = "日消耗情况", default = {})  # {'2018-12-26':[{'unit':'次','count':3}]}
    quotaUsed = ListField(verbose_name = "总的消耗情况", default = [])  # [{'unit':'次','count':3}]
    status = StringField(verbose_name = "卡状态", default = 'normal')
    # expired:过期,耗尽：exhausted, 未激活:nonactivated(经销商开虚拟卡),used(经销商开卡解绑了，并未过期)

    remark = StringField(verbose_name = "卡片备注", default = "")

    continueTime = DateTimeField(verbose_name="买卡的时间", default = None)  # 接续时间，用于续费后，下一次卡接续开始

    ongoingList = ListField(DictField(), verbose = u'冻结的配额')

    managerialAppId = StringField(verbose_name = "管理公众号AppId", default = None)
    managerialOpenId = StringField(verbose_name = "管理openId", default = None)

    # 坤元虚拟卡特有:功率
    power = IntField(verbose_name="包月卡功率限制", default=0)

    meta = {
        "collection": "UserVirtualCard",
        "db_alias": "default",
    }

    search_fields = ('nickname', 'cardNo', 'cardName')

    REVERSE_DAY = 3

    @property
    def payVia(self):
        return "virtualCard"

    @staticmethod
    def make_no():
        timestamp = generate_timestamp_ex()
        random_int = random.randint(1, 1000)
        return "%d%03d" % (timestamp, random_int)

    # --------------------------------------------------------------- 所有的虚拟卡的新方法 需要兼容以前 一定需要严格测试
    @staticmethod
    def find_match_unit(quotaList, package):
        """
        从额度列表中找到符合套餐单位的 返回index
        :param quotaList: [{"unit": "次"， "count": 15}, {"unit": "分钟", "count": 600}]
        :param package: {"unit": "分钟"， "time": 30}
        """
        # 只有一种额度的 走之前的流程 不要影响客户的使用
        if len(quotaList) == 1:
            return UserVirtualCard._find_match_unit(quotaList, package)

        # 多单位的情况下 不再对单位进行转换 如果单位不匹配 就直接跳过
        pCount, pUnit = package["time"], package["unit"]

        for _index, _quota in enumerate(quotaList):
            if _quota["unit"] != pUnit or float(_quota["count"]) < float(pCount):
                continue
            ii = _index
            break
        else:
            ii = -1

        return ii

    @staticmethod
    def calc_left_quota(quotaList, usedList):
        """
        计算剩余的额度
        :param quotaList: 总的额度列表
        :param usedList: 已经使用额度情况
        """
        # TODO 目前使用双循环解决，其实可以加一个单位排序，一次遍历搞定 时间复杂度将会降低一个量级

        leftQuotaList = list()

        for _quota in quotaList:

            _qCount, _qUnit = float(_quota["count"]), _quota["unit"]

            for _used in usedList:
                # 单位有匹配的 则直接计算额度
                if _used["unit"] == _qUnit:
                    _usedQuota = {"count": float(max(_qCount-_used["count"], 0)), "unit": _qUnit}
                    break
                else:
                    continue
            # 没有找到这种单位 说明这种额度没有使用过 则剩余额度为满值
            else:
                _usedQuota = {"count": float(_qCount), "unit": _qUnit}

            leftQuotaList.append(_usedQuota)

        return leftQuotaList

    def calc_left_total_quota(self):
        """
        计算剩余的总额度  将所有的冻结额度都算上使用的
        :return:
        """

        usedMap, frozenMap = dict(), dict()
        for _item in self.quotaUsed:
            if _item["unit"] in usedMap:
                usedMap[_item["unit"]] += float(_item["count"])
            else:
                usedMap[_item["unit"]] = float(_item["count"])

        for _on in self.ongoingList:
            if _on["quota"]["unit"] in frozenMap:
                frozenMap[_on["quota"]["unit"]] += float(_on["quota"]["count"])
            else:
                frozenMap[_on["quota"]["unit"]] = float(_on["quota"]["count"])

        quotaList = self.quota
        usedList = [{"count":  _v, "unit": _k} for _k, _v in dict(Counter(usedMap)+Counter(frozenMap)).items()]

        return self.calc_left_quota(quotaList, usedList)

    def calc_left_day_quota(self, dayKey):
        """
        计算当天剩下的总额度 注意key的匹配 将所有的当天的额度都算上使用的
        :param dayKey:
        :return:
        """
        usedMap, frozenMap = dict(), dict()
        for _item in self.dayUsed.get(dayKey, list()):
            if _item["unit"] in usedMap:
                usedMap[_item["unit"]] += _item["count"]
            else:
                usedMap[_item["unit"]] = _item["count"]

        for _on in self.ongoingList:

            if _on["dayKey"] != dayKey:
                continue

            if _on["dayQuota"]["unit"] in frozenMap:
                frozenMap[_on["dayQuota"]["unit"]] += _on["dayQuota"]["count"]
            else:
                frozenMap[_on["dayQuota"]["unit"]] = _on["dayQuota"]["count"]

        quotaList = self.dayQuota
        usedList = [{"count": _v, "unit": _k} for _k, _v in dict(Counter(usedMap) + Counter(frozenMap)).items()]

        return self.calc_left_quota(quotaList, usedList)

    # --------------------------------------------------------------- 新方法结束
    @staticmethod
    def _find_match_unit(quotaList, package):
        # type:(VirtualCardQuotaList, dict)->int

        match = False
        ii = 0

        for t1Dict in quotaList:
            unit = t1Dict['unit']
            count = t1Dict['count']
            if unit == u'次' and count >= 1:
                match = True
                break

            elif (unit in [u'分钟', u'小时', u'天']) and (package['unit'] in [u'分钟', u'小时', u'天']):
                if unit == u'小时':
                    t1Count = count * 60
                elif unit == u'天':
                    t1Count = count * 60 * 24
                else:
                    t1Count = count
                if package['unit'] == u'小时':
                    pCount = float(package['time']) * 60
                elif package['unit'] == u'天':
                    pCount = float(package['time']) * 60 * 24
                else:
                    pCount = float(package['time'])
                if t1Count >= pCount:
                    match = True
                    break

            elif (unit in [u'分钟', u'小时', u'天']) and package['unit'] == u'度':  # 直接按照12小时计算
                if unit == u'小时':
                    t1Count = count * 60
                elif unit == u'天':
                    t1Count = count * 60 * 24
                else:
                    t1Count = count

                if t1Count >= 6.0 * 60:  # 6小时打底
                    match = True
                    break

            elif unit == u'币' and count >= package['coins']:
                match = True
                break
            elif unit == u'度' and package['unit'] == u'度' and count >= package['time']:
                match = True
                break
            elif unit == u'度' and package['unit'] != u'度' and count >= 3.0:
                match = True
                break
            elif package['unit'] == u'次':
                if unit == u'分钟' and count >= 360.0:
                    match = True
                    break
                elif unit == u'小时' and count >= 6.0:
                    match = True
                    break
                elif unit == u'天' and count >= 0.25:
                    match = True
                    break
                elif unit == u'度' and count >= 3.0:  # 默认写死3度电，多退少补
                    match = True
                    break
                elif unit == u'币' and count >= package['coins']:
                    match = True
                    break

            ii += 1

        return ii if match else -1

    @staticmethod
    def find_match_unit_and_can_use_count(quotaList, package):
        """
        找出虚拟卡能否使用多少次  某些设备的特殊需求 例如和动
        """
        # 兼容之前的
        if len(quotaList) == 1:
            usage_count = 0
            for t1Dict in quotaList:
                unit = t1Dict['unit']
                count = t1Dict['count']
                if unit == u'次' and count >= 1:

                    usage_count = count
                    break

                elif (unit in [u'分钟', u'小时', u'天']) and (package['unit'] in [u'分钟', u'小时', u'天']):
                    if unit == u'小时':
                        t1Count = count * 60
                    elif unit == u'天':
                        t1Count = count * 60 * 24
                    else:
                        t1Count = count
                    if package['unit'] == u'小时':
                        pCount = float(package['time']) * 60
                    elif package['unit'] == u'天':
                        pCount = float(package['time']) * 60 * 24
                    else:
                        pCount = float(package['time'])
                    if t1Count >= pCount:
                        usage_count = t1Count // pCount
                        break

                elif (unit in [u'分钟', u'小时', u'天']) and package['unit'] == u'度':  # 直接按照12小时计算
                    if unit == u'小时':
                        t1Count = count * 60
                    elif unit == u'天':
                        t1Count = count * 60 * 24
                    else:
                        t1Count = count

                    if t1Count >= 6.0 * 60:  # 6小时打底

                        usage_count = t1Count // 6.0 * 60
                        break

                elif unit == u'币' and count >= package['coins']:

                    usage_count = count // float(package['coins'])
                    break

                elif unit == u'度' and package['unit'] == u'度' and count >= package['time']:

                    usage_count = count // float(package['time'])
                    break

                elif unit == u'度' and package['unit'] != u'度' and count >= 3.0:

                    usage_count = count // 3
                    break

                elif package['unit'] == u'次':
                    if unit == u'分钟' and count >= 360.0:

                        usage_count = count // 360.0
                        break

                    elif unit == u'小时' and count >= 6.0:

                        usage_count = count // 6
                        break

                    elif unit == u'天' and count >= 0.25:

                        usage_count = count // 0.25
                        break

                    elif unit == u'度' and count >= 3.0:  # 默认写死3度电，多退少补

                        usage_count = count // 3
                        break

                    elif unit == u'币' and count >= package['coins']:

                        usage_count = count // float(package['coins'])
                        break

            return int(usage_count)

        # 两种单位的
        else:
            pCount, pUnit = package["time"], package["unit"]

            for _index, _quota in enumerate(quotaList):
                # 单位不一致 或者数量不够的 直接跳过
                if _quota["unit"] != pUnit or float(_quota["count"]) < float(pCount):
                    continue

                # 然后求出count
                if pUnit == u"次":
                    return _quota["count"]

                # 时间的 由于单位一样 直接除法
                else:
                    return _quota["count"] // pCount

            else:
                return 0

    @staticmethod
    def count_by_unit(unit, package):
        # type:(unicode, dict)->Union[float, int]
        """
        根据单位，计算消耗量
        根据套餐计算以及单位，计算需要扣除的指标数量。比如单位是：币，那就直接看套餐多少币，就需要扣除多少币
        :param unit:
        :param package:
        :return:
        """

        if unit == u'次':
            return 1

        elif unit == u'币':
            return package['coins']

        elif unit == u'分钟':
            if package['unit'] == u'分钟':
                return float(package['time'])
            elif package['unit'] == u'小时':
                return float(package['time']) * 60.0
            elif package['unit'] == u'天':
                return float(package['time']) * 60 * 24.0
            else:
                return 6.0 * 60

        elif unit == u'小时':
            if package['unit'] == u'分钟':
                return float(package['time']) / 60.0
            elif package['unit'] == u'小时':
                return float(package['time'])
            elif package['unit'] == u'天':
                return float(package['time']) * 24.0
            else:
                return 6.0

        elif unit == u'天':
            if package['unit'] == u'分钟':
                return float(package['time']) / 360.0
            elif package['unit'] == u'小时':
                return float(package['time']) / 24.0
            elif package['unit'] == u'天':
                return float(package['time'])
            else:
                return 0.25

        elif unit == u'度':
            if package['unit'] == u'度':
                return float(package['time'])
            else:
                return 3.0

        else:
            raise ValueError(u'does not support unit %s' % (unit,))

    def can_use_today(self, package):
        # type:(dict)->bool
        """
        检查今天是否可以用卡
        :param package:
        :return:
        """
        if package.get("isTempPackage"):
            return False

        # 非正常状态的卡都不让用
        if self.status not in ["normal", "warning"]:
            return False

        # 先计算出总的剩余额度，以及每日的剩余额度
        leftQuota = self.calc_left_total_quota()

        dayKey = datetime.datetime.now().strftime("%Y-%m-%d")
        leftDayQuota = self.calc_left_day_quota(dayKey)

        # 剩余总额度以及剩余日限额度检查没有问题，就直接返回
        if UserVirtualCard.find_match_unit(leftQuota, package) >= 0 and UserVirtualCard.find_match_unit(leftDayQuota, package) >= 0:
            return True

        return False

    def freeze_quota(self, package, transaction_id):    # type:(dict, str) -> bool
        """
        消费一次，包括扣掉总额，增加消费记录
        :param package:
        :param transaction_id: 交易的ID
        :return:
        """
        try:
            # 找出额度单元，然后扣掉
            leftQuota = self.calc_left_total_quota()

            dayKey = today_format_str()
            leftDayQuota = self.calc_left_day_quota(dayKey)

            allIndex = UserVirtualCard.find_match_unit(leftQuota, package)
            dayIndex = UserVirtualCard.find_match_unit(leftDayQuota, package)

            if allIndex < 0 or dayIndex < 0:
                raise InsufficientFundsError(u'虚拟卡配额不足')

            # 先处理总额度
            unit = leftQuota[allIndex]['unit']
            consume = {'unit': unit, 'count': UserVirtualCard.count_by_unit(unit, package)}

            # 处理每日额度
            unit = leftDayQuota[dayIndex]['unit']
            day_consume = {'unit': unit, 'count': UserVirtualCard.count_by_unit(unit, package)}

            query = {'_id': self.id,
                     'ongoingList.transaction_id': {'$ne': transaction_id}}
            update = {
                '$addToSet': {'ongoingList': {
                    'transaction_id': transaction_id,
                    'quota': consume,
                    'dayQuota': day_consume,
                    'dayKey': dayKey
                }}}

            result = self.get_collection().update_one(filter=query, update=update, upsert = False)
            return bool(result.modified_count == 1)
        finally:
            try:
                day3Key = (datetime.datetime.now() - datetime.timedelta(days = self.REVERSE_DAY)).strftime('%Y-%m-%d')
                for dk in self.dayUsed.keys():
                    if dk <= day3Key:
                        self.dayUsed.pop(dk)

                self.save()
            except Exception as e:
                logger.exception('save user vcard e={}'.format(e))

    def clear_frozen_quota(self, transaction_id, usedTime, spendElec, backCoins):
        """
        清除冻结的额度，并按照一定的比例退还
        """
        def calc_left_by_unit(count, unit, ut, ue, uc):
            if unit in [u'分钟', u'小时', u'天']:
                if unit == u'分钟':
                    ut = int(ut)
                elif unit == u'小时':
                    ut = round(ut / 60.0, 2)
                else:
                    ut = round(ut / (60.0 * 24.0), 2)

                leftCount = count - ut

            elif unit in [u'度']:
                leftCount = count - ue

            elif unit in [u'次']:  # 如果没有用，比如没有插电，一样，不能扣除配额
                if int(ut) == 0 and int(ue) == 0:
                    leftCount = count
                else:
                    leftCount = 0

            elif unit in [u'币']:  # 注意，这个是已经算好的退币数额
                leftCount = uc

            else:
                leftCount = 0

            return max(leftCount, 0)

        frozen_item = None
        for item in self.ongoingList:
            if item['transaction_id'] == transaction_id:
                frozen_item = item
                break

        if not frozen_item:
            logger.debug('not find this frozen item. card = {}, consume id = {}'.format(repr(self), transaction_id))
            return False, None, None

        consumeTotal = frozen_item['quota']
        consumeTotalLeft = calc_left_by_unit(consumeTotal['count'], consumeTotal['unit'], usedTime, spendElec,
                                             backCoins)
        consumeTotal['count'] -= float(consumeTotalLeft)

        consumeDay = frozen_item['dayQuota']
        consumeDayLeft = calc_left_by_unit(consumeDay['count'], consumeDay['unit'],
                                           usedTime, spendElec, backCoins)
        consumeDay['count'] -= float(consumeDayLeft)

        day_key = frozen_item['dayKey']
        clean_day_key = (datetime.datetime.now() - datetime.timedelta(days = self.REVERSE_DAY)).strftime('%Y-%m-%d')
        if day_key <= clean_day_key:
            match_quota_used = None
            for item in self.quotaUsed:
                if item['unit'] == consumeTotal['unit']:
                    match_quota_used = item
                    break

            if not match_quota_used:
                self.quotaUsed.append({'unit': consumeTotal['unit'], 'count': 0})
                self.save()

            query = {
                '_id': self.id,
                'ongoingList': {'$elemMatch': {'transaction_id': transaction_id}},
                'quotaUsed.unit': consumeTotal['unit']
            }
            update = {
                '$inc': {
                    'quotaUsed.$.count': consumeTotal['count']
                },
                '$pull': {'ongoingList': {'transaction_id': transaction_id}},
            }

            result = self.get_collection().update_one(
                filter = query,
                update = update,
                upsert = False
            )

            modified = bool(result.modified_count == 1)

            return modified, consumeTotal, consumeDay
        else:
            match_quota_used = None
            for item in self.quotaUsed:
                if item['unit'] == consumeTotal['unit']:
                    match_quota_used = item
                    break

            if not match_quota_used:
                self.quotaUsed.append({'unit': consumeTotal['unit'], 'count': 0})

            if day_key not in self.dayUsed:
                self.dayUsed[day_key] = []

            match_day_used = None
            for item in self.dayUsed.get(day_key, []):
                if item['unit'] == consumeDay['unit']:
                    match_day_used = item
                    break

            if not match_day_used:
                self.dayUsed[day_key].append({'unit': consumeDay['unit'], 'count': 0})

            self.save()

            query = {
                '_id': self.id,
                'ongoingList': {'$elemMatch': {'transaction_id': transaction_id}},
                'quotaUsed.unit': consumeTotal['unit'],
                'dayUsed.{}.unit'.format(day_key): consumeDay['unit']
            }
            update = {
                '$inc': {
                    'quotaUsed.$.count': consumeTotal['count'],
                    'dayUsed.{}.$.count'.format(day_key): consumeDay['count']
                },

                '$pull': {'ongoingList': {'transaction_id': transaction_id}},
            }

            result = self.get_collection().update_one(
                filter = query,
                update = update,
                upsert = False)

            modified = bool(result.modified_count == 1)

            self.reload()

            return modified, consumeTotal, consumeDay

    def recover_frozen_quota(self, transaction_id):
        """
        清除虚拟卡的冻结额度 不退换
        """
        query = {'_id': self.id}
        update = {
            '$pull': {'ongoingList': {'transaction_id': transaction_id}},
        }

        result = self.get_collection().update_one(
            filter = query,
            update = update,
            upsert = False
        )

        return bool(result.modified_count == 1)

    def consume(self, openId, group, dev, package, attachParas, nickname='', orderNo=None):
        """
        消费一次，包括扣掉总额，增加消费记录
        :param openId:
        :param group:
        :param dev:
        :param package:
        :param attachParas:
        :param nickname:
        :param orderNo: 订单编号
        :return:
        """

        # 找出额度单元，然后扣掉
        leftQuota = self.calc_left_total_quota()

        dayKey = datetime.datetime.now().strftime("%Y-%m-%d")
        leftDayQuota = self.calc_left_day_quota(dayKey)

        allIndex = UserVirtualCard.find_match_unit(leftQuota, package)
        dayIndex = UserVirtualCard.find_match_unit(leftDayQuota, package)

        if allIndex < 0 or dayIndex < 0:
            return None

        # 先处理总额度
        unit = leftQuota[allIndex]['unit']
        consumeData = {'unit': unit, 'count': UserVirtualCard.count_by_unit(unit, package)}
        match = False
        for tDict in self.quotaUsed:
            if tDict['unit'] == unit:
                tDict['count'] = float(tDict['count']) + float(consumeData['count'])
                match = True
                break

        if not match:
            self.quotaUsed.append(consumeData)

        # 处理每日额度
        unit = leftDayQuota[dayIndex]['unit']
        consumeDayData = {'unit': unit, 'count': UserVirtualCard.count_by_unit(unit, package)}
        match = False
        for tDict in self.dayUsed.get(dayKey, []):
            if tDict['unit'] == unit:
                consumeDayData = {'unit': unit, 'count': UserVirtualCard.count_by_unit(unit, package)}
                tDict['count'] = float(tDict['count']) + float(consumeDayData['count'])
                match = True
                break

        if not match:
            self.dayUsed[dayKey] = [consumeDayData]

        # 清理掉3天以前的每日消费情况
        day3Key = (datetime.datetime.now() - datetime.timedelta(days=3)).strftime('%Y-%m-%d')
        for dk in self.dayUsed.keys():
            if dk <= day3Key:
                self.dayUsed.pop(dk)

        try:
            self.save()
        except Exception as e:
            logger.exception('[consume] save user vcard e={}'.format(e))
            return None

        # 增加一条消费记录
        newRcd = VCardConsumeRecord(
            orderNo = orderNo if orderNo is not None else VCardConsumeRecord.make_no(dev.logicalCode),
            openId = openId,
            nickname = nickname,
            cardId = str(self.id),
            dealerId = self.dealerId,
            devNo = dev['devNo'],
            devTypeCode = dev.devTypeCode,
            devTypeName = dev.devTypeName,
            logicalCode = dev['logicalCode'],
            groupId = group['groupId'],
            address = group['address'],
            groupNumber = dev['groupNumber'],
            groupName = group['groupName'],
            attachParas = attachParas,
            consumeData = consumeData,
            consumeDayData = consumeDayData
        )

        try:
            newRcd.save()
        except Exception as e:
            logger.error('[consume] save vcard consume e=%s' % e)
            return None

        return newRcd

    def new_consume_record(self, dev, user, consumeTotal, attachParas=None, orderNo=None):
        newRcd = VCardConsumeRecord(
            orderNo=orderNo if orderNo is not None else VCardConsumeRecord.make_no(dev.logicalCode),
            openId=user.openId,
            nickname=user.nickname,
            cardId=str(self.id),
            dealerId=dev.ownerId,
            devNo=dev.devNo,
            devTypeCode = dev.devTypeCode,
            devTypeName = dev.devTypeName,
            logicalCode=dev.logicalCode,
            groupId=dev.group.groupId,
            address=dev.group.address,
            groupNumber=dev.groupNumber,
            groupName=dev.group.groupName,
            attachParas=attachParas or dict(),
            consumeData=consumeTotal,
            consumeDayData=consumeTotal
        )

        try:
            newRcd.save()
        except Exception as e:
            logger.error('[consume] save vcard consume e=%s' % e)
            return None

        return newRcd

    def refund_quota(self, consumeRcd, usedTime, spendElec, backCoins):
        """
        将虚拟卡的额度返回  对应的使用方法是consume
        :param consumeRcd:
        :param usedTime:    单位一定是分钟
        :param spendElec:   单位一定是度
        :param backCoins:   单位一定是金币
        :return:
        """

        def calc_left_by_unit(count, unit, ut, ue, uc):
            if unit in [u'分钟', u'小时', u'天']:
                if unit == u'分钟':
                    ut = int(ut)
                elif unit == u'小时':
                    ut = round(ut / 60.0, 2)
                else:
                    ut = round(ut / (60.0 * 24.0), 2)

                leftCount = count - ut

            elif unit in [u'度']:
                leftCount = count - ue

            elif unit in [u'次']:  # 如果没有用，比如没有插电，一样，不能扣除配额
                if int(ut) == 0 and int(ue) == 0:
                    leftCount = count
                else:
                    leftCount = 0

            elif unit in [u'币']:  # 注意，这个是已经算好的退币数额
                leftCount = float(VirtualCoin(uc))

            else:
                leftCount = 0

            return leftCount

        # 当消费已经定下来的时候 则本次退换的单位实际上已经固定了
        consumeLeftTemp = calc_left_by_unit(
            consumeRcd.consumeData['count'],
            consumeRcd.consumeData['unit'],
            usedTime,
            spendElec,
            backCoins
        )
        consumeLeft = max(consumeLeftTemp,0)
        consumeRcd.consumeData['count'] -= float(consumeLeft)

        consumeDayLeft = calc_left_by_unit(
            consumeRcd.consumeDayData['count'],
            consumeRcd.consumeDayData['unit'],
            usedTime,
            spendElec,
            backCoins
        )
        consumeRcd.consumeDayData['count'] -= float(consumeDayLeft)

        # 刷新消费记录数据
        try:
            consumeRcd.save()
        except Exception as e:
            logger.exception('[refund_quota] save consume rcd error = %s' % e)
            return

        # 更新额度
        for tDict in self.quotaUsed:
            if tDict['unit'] != consumeRcd.consumeData['unit']:
                continue
            tDict['count'] -= consumeLeft

        dayKey = datetime.datetime.now().strftime("%Y-%m-%d")
        for tDict in self.dayUsed.get(dayKey, []):
            if tDict['unit'] != consumeRcd.consumeDayData['unit']:
                continue
            tDict['count'] -= float(consumeDayLeft)

        try:
            self.save()
        except Exception as e:
            logger.exception('[refund_quota] save quota error=%s' % e)
        
        # 返回本条记录余下的配套
        returnUsedTime,returnSpendElec,returnBackCoins = usedTime,spendElec,backCoins
        if consumeRcd.consumeData['unit'] in [u'分钟',u'小时',u'秒']:
            return consumeLeftTemp,returnSpendElec,returnBackCoins
        if consumeRcd.consumeData['unit'] in [u'度']:
            return returnUsedTime,consumeLeftTemp,returnBackCoins
        return returnUsedTime,returnSpendElec,returnBackCoins
    
    # 卡续费
    def continue_card(self):
        if not self.continueTime:
            return
        vCard = VirtualCard.objects.get(id = self.cardTypeId)
        # 以最新的属性作为 购买
        self.price = vCard.price
        self.dayQuota = vCard.dayQuota
        self.userLimit = vCard.userLimit
        self.cardName = vCard.cardName
        self.quota = vCard.quota
        self.userDesc = vCard.userDesc
        self.dayUsed = {}
        self.quotaUsed = []
        self.status = 'normal'
        self.expiredTime = self.continueTime + datetime.timedelta(seconds=vCard.periodDays * 24 * 3600)
        self.continueTime = None
        self.save()
        return self

    @staticmethod
    def get_user_cards(openId, groupId, ownerId):
        """
        获取用户所有的虚拟卡
        修改： 去掉continueTime的check判断 没意义
        """
        cardList = []
        vCards = UserVirtualCard.objects.filter(
            dealerId = ownerId, openIds = openId,
            groupIds__in = ['*', groupId]
        )
        nowTime = datetime.datetime.now()
        for obj in vCards:
            if obj.startTime <= nowTime <= obj.expiredTime:
                cardList.append(obj)
        return cardList

    def add_expired_time(self, days):
        self.expiredTime += datetime.timedelta(days = int(days))
        self.save()

    def support_dev_type(self, devTypeCode):
        devTypesCount = DeviceType.objects.filter(code = devTypeCode, id__in = self.devTypeList).count()
        if devTypesCount <= 0:
            return False
        return True

    @property
    def groupInfo(self):
        """
        获取虚拟卡的相应的 地址信息
        :return:
        """
        if '*' in self.groupIds:
            groups = [{'groupName': grp['groupName'], 'address': grp['address']} for grp in
                      Group.get_groups_by_group_ids(Group.get_group_ids_of_dealer(self.dealerId)).values()]
        else:
            groups = [{'groupName': grp['groupName'], 'address': grp['address']} for grp in
                      Group.get_groups_by_group_ids(self.groupIds).values()]

        return groups

    @property
    def membersInfo(self):
        """
        虚拟卡成员信息
        :return:
        """
        users = MyUser.objects.filter(openId__in = self.openIds).only("openId", "nickname")
        bindUsersList = list()
        repeatUsers = set()
        for user in users:
            if user.openId in repeatUsers:
                continue

            # openId 相同去重
            repeatUsers.add(user.openId)

            tempDict = {
                'userName': user.nickname,
                'userId': user.openId
            }
            user.openId == self.ownerOpenId and tempDict.update({"role": "owner"})

            bindUsersList.append(tempDict)

        return bindUsersList

    @property
    def quotaInfo(self):
        """
        获取和额度相关的信息
        :return:
        """
        dayUsedList = self.dayUsed.get(datetime.datetime.now().strftime("%Y-%m-%d"), list())
        dayUsed = 0
        if len(dayUsedList) > 0:
            dayUsed = dayUsedList[0]['count']

        return {
            'quota': self.quota[0]['count'],
            'quotaUnit': self.quota[0]['unit'],
            'quotaUsed': round(self.quotaUsed[0]['count'], 2) if len(self.quotaUsed) > 0 else 0,

            'dayQuota': self.dayQuota[0]['count'],
            'dayQuotaUnit': self.dayQuota[0]['unit'],
            'dayUsed': round(dayUsed, 2)
        }

    @property
    def devTypes(self):
        devs = DeviceType.objects.filter(id__in=self.devTypeList).only("majorDeviceType", "name")
        devTypes = list()

        for _dev in devs:   # type: DeviceType
            devTypes.append({"devTypeName": _dev.name, "majorDeviceType": _dev.majorDeviceType})

        return devTypes

    def isOwner(self, openId):
        """是不是卡的所有者"""
        return openId == self.ownerOpenId

    def to_dict(self):
        """
        序列化
        :return:
        """
        data = {
            'cardId': str(self.id),
            'cardNo': self.cardNo,
            'cardTypeId': self.cardTypeId,
            'cardName': self.cardName,
            'periodDays': self.periodDays,
            'createTime': self.startTime.strftime('%Y-%m-%d'),
            'expiredTime': self.expiredTime.strftime('%Y-%m-%d'),
            'userDesc': self.userDesc,
            'userLimit': self.userLimit,
            'userName': self.nickname,
            'logicalCode': self.logicalCode,
            'groupId': self.groupId,
            'remark': self.remark,
            'power': self.power
        }

        return data

    def to_detail(self):
        data = {
            'cardId': str(self.id),
            'cardNo': self.cardNo,
            'cardTypeId': self.cardTypeId,
            'cardName': self.cardName,
            'periodDays': self.periodDays,
            'createTime': self.startTime.strftime('%Y-%m-%d'),
            'expiredTime': self.expiredTime.strftime('%Y-%m-%d'),
            'userDesc': self.userDesc,
            'userLimit': self.userLimit,
            'userName': self.nickname,
            'logicalCode': self.logicalCode,
            'groupId': self.groupId,
            'remark': self.remark,

            "groups": self.groupInfo,
            "sharedMembers": self.membersInfo,
            "devTypes": self.devTypes,

            # 功率
            'power': self.power,

            # 额度
            'quota': {
                "day": self.dayQuota,
                "total": self.quota
            },
            # 剩余的额度
            'leftQuota': {
                "day": self.calc_left_day_quota(today_format_str()),
                "total": self.calc_left_total_quota()
            }
        }

        return data

    # 以下是霍坡的特殊业务 之前是不支持按次 现在支持了 考虑业务合并
    def can_use_hp_gate(self):
        """霍珀虚拟卡 对于道闸计费 只要卡没过期就可以使用"""
        # 尚未过期的虚拟卡可用于霍珀道闸
        # 要求变更 虚拟卡过期后还能在使用24小时
        if self.status not in ["normal", "warning"]:
            return False

        return self.expiredTime > datetime.datetime.now() - datetime.timedelta(hours = 24)

    def consume_hp_gate(self, openId, group, dev, package = None, attachParas={}, nickname=''):
        # type:(str, GroupDict, DeviceDict, dict, dict, str)->Optional[VCardConsumeRecord]
        """
        消费一次
        :param openId:
        :param group:
        :param dev:
        :param package:
        :param attachParas:
        :param nickname:
        :return:
        """
        # 增加一条消费记录
        newRcd = VCardConsumeRecord(
            orderNo = VCardConsumeRecord.make_no(dev.logicalCode),
            openId = openId,
            nickname = nickname,
            cardId = str(self.id),
            dealerId = self.dealerId,
            devNo = dev['devNo'],
            devTypeCode = dev.devTypeCode,
            devTypeName = dev.devTypeName,
            logicalCode = dev['logicalCode'],
            groupId = group['groupId'],
            address = group['address'],
            groupNumber = dev['groupNumber'],
            groupName = group['groupName'],
            attachParas = attachParas,
            remarks = u"道闸刷卡服务"
        )

        try:
            newRcd.save()
            self.record_gate_used_times()
        except Exception as e:
            logger.error('save vcard consume e=%s' % e)
            return None

        return newRcd

    def record_gate_used_times(self):
        """
        霍珀要求的 对于道闸次数进行监控，但是不能限制次数
        :return:
        """
        dayKey = datetime.datetime.now().strftime("%Y-%m-%d")
        cacheKey = "{}-{}".format(dayKey, self.cardNo)
        times = serviceCache.get(cacheKey, 0)
        times += 1
        serviceCache.set(cacheKey, times, timeout = 60 * 60 * 24)

        if times < 8:
            status = "normal"
        else:
            status = "warning"

        try:
            self.update(status = status)
        except Exception as e:
            logger.exception(e)

        return


class VirtualCardRechargeRecord(Searchable):
    orderNo = StringField(verbose_name = u'使用RechargeRecord的orderNo关联两张表', required = True)

    cardId = StringField(verbose_name = "虚拟卡ID", default = "")
    cardNo = StringField(verbose_name = "虚拟卡卡号", default = "")
    openId = StringField(verbose_name = "openId", default = "")
    gateway = StringField(verbose_name = 'gateway', default = "")
    groupId = StringField(verbose_name = "设备地址编号", default = "")
    ownerId = ObjectIdField(verbose_name = "dealerId")
    dateTimeAdded = DateTimeField(default = datetime.datetime.now, verbose_name = '生成时间')

    # 以下字段后续废弃, 只做兼容使用
    devNo = StringField(verbose_name = "设备ID", default = None)
    logicalCode = StringField(verbose_name = "设备逻辑编码", default = None)
    wxOrderNo = StringField(verbose_name = "orderNo", default = None)
    money = MonetaryField(verbose_name = "付款金额", default = None)
    coins = MonetaryField(verbose_name = "充值金额", default = None)
    devTypeCode = StringField(verbose_name = "设备类型编码", default = None)
    time = StringField(verbose_name = 'time', default = None)
    devType = StringField(verbose_name = "设备类型", default = None)
    address = StringField(verbose_name = "设备地址", default = None)
    groupNumber = StringField(verbose_name = "设备", default = None)
    groupName = StringField(verbose_name = "交易场地", default = None)
    remarks = StringField(verbose_name = "备注", default = None)
    status = StringField(verbose_name = "状态", default = None)

    meta = {
        "collection": "virtualCardRechargeRecord",
        "db_alias": "default",
    }

    @classmethod
    def get_link_orderNo_list(cls, cardId, startTime, endTime, openId = None):
        records = cls.objects(
            cardId = cardId, dateTimeAdded__gte = startTime, dateTimeAdded__lt = get_tomorrow_zero_time(endTime))
        if openId:
            records = records.filter(openId = openId)

        return [record.orderNo for record in records]

    @property
    def created_date(self):
        return self.dateTimeAdded

    def is_refund_available(self, customer):  # type:(CapitalUser) -> bool
        return False

    @property
    def has_refund_order(self):
        return False

    @property
    def isQuickPay(self):
        return False

    @classmethod
    def issue(cls, order):
        # type:(RechargeRecord)->VirtualCardRechargeRecord

        return cls(
            orderNo = order.orderNo,
            cardId = order.attachParas['cardId'],
            cardNo = order.attachParas['cardNo'],
            openId = order.openId,
            ownerId = order.ownerId,
            groupId = order.groupId,
            gateway = order.gateway,
            dateTimeAdded = order.dateTimeAdded).save()


# 监督号的用户，用于和实际系统的用户进行关联
class MoniUser(Searchable):
    moniAppId = StringField(verbose_name = 'moniAppId', default = '')
    moniOpenId = StringField(verbose_name = 'moniOpenId', default = '')
    openId = StringField(verbose_name = u'用户的主APPID', default = '')
    isSubscribe = BooleanField(verbose_name = u'是否订阅', default = False)
    checkTime = DateTimeField(verbose_name = u'检查时间')
    subTime = DateTimeField(verbose_name = u'关注时间')
    unsubTime = DateTimeField(verbose_name = u'取关时间')
    subLogicalCode = StringField(verbose_name = u'关注来源logicalCode', default = '')
    subDealerId = StringField(verbose_name = u'关注来源dealerId', default = '')
    subAgentId = StringField(verbose_name = u'关注来源agentId', default = '')
    subPoint = StringField(verbose_name = u'关注来源point', default = '')

    meta = {
        "collection": "moni_user",
        "db_alias": "logdata",
    }

    @classmethod
    def get_or_create(cls, moniOpenId, moniAppId, **kwargs):
        """
        创建一条用户的记录
        """
        obj = cls.objects.filter(moniOpenId=moniOpenId, moniAppId=moniAppId).order_by("-id").first() or cls(moniOpenId=moniOpenId, moniAppId=moniAppId)
        needUpdate = False

        for _field in cls._fields.keys():
            if _field in kwargs and kwargs[_field] != getattr(obj, _field, kwargs[_field]):
                setattr(obj, _field, kwargs[_field])
                needUpdate = True

        if needUpdate:
            obj = obj.save()

        return obj

    @classmethod
    def get_or_delete(cls, moniOpenId, moniAppId):
        cls.objects.filter(moniOpenId=moniOpenId, moniAppId=moniAppId).update(isSubscribe=False)


class AskStep(Searchable):
    operKey = StringField(verbose_name = 'oper key', default = '')
    answerText = StringField(verbose_name = 'answer text', default = '')
    answerPics = StringField(verbose_name = 'answer picture', default = '')  # '文件名称用,分割'
    answerFunc = StringField(verbose_name = 'answer func', default = '')

    @staticmethod
    def replyUseDevice(moniOpenId, appId, **kwargs):
        moniUser = MoniUser.objects.filter(moniOpenId = moniOpenId, moniAppId = appId).first()
        if moniUser:
            devLink = concat_user_login_entry_url(l=moniUser.subLogicalCode)
            return [{'msgType': 'text', 'value': u'\ue231<a href="%s">戳我使用设备</a>\ue230' % devLink}]
        return [{'msgType': 'text', 'value': u'您直接点击菜单栏的扫一扫，或者关闭当前页面重新扫码，即可使用'}]

    @staticmethod
    def replayQueryBalance(moniOpenId, appId, **kwargs):
        openId = kwargs.get('openId')
        agentId = kwargs.get('agentId')
        users = MyUser.objects.filter(openId = openId)
        balance = VirtualCoin(0.0)
        for user in users:
            balance += user.balance

        url = concat_user_center_entry_url(agentId=agentId,
                                           redirect=concat_front_end_url(uri='/user/index.html#/user/help'))

        return [{'msgType': 'text',
                 'value': u'您在系统总的余额是%s,如果界面上显示不对，请您先刷新页面，还是不行的话，<a href="%s">联系客服</a>' % (balance, url)}]

    @staticmethod
    def get_service_phone_from_rcd(consumeRcd):
        dealer = Dealer.objects(id=consumeRcd.ownerId).first()  # type: Dealer
        return dealer.service_phone

    @staticmethod
    def replyGetToushuUrl(moniOpenId, appId, **kwargs):
        agentId = kwargs.get('agentId')

        url = concat_user_center_entry_url(agentId=agentId,
                                           redirect=concat_front_end_url(uri='/user/index.html#/complaint/list'))

        return [{'msgType': 'text', 'value': u'<a href="%s">投诉点这里</a>' % url}]

    # 先检查用户的订单是否扣掉了钱。然后检查设备的连通性。
    # 调用此函数的时候，一般是用户付款了，设备没有响应。
    @staticmethod
    def replyQueryConsumeRcd(moniOpenId, appId, **kwargs):
        try:
            endTime = datetime.datetime.now()
            startTime = endTime - datetime.timedelta(days = 7)
            consumeRcd = ConsumeRecord.objects.filter(openId = kwargs['openId'], dateTimeAdded__gte = startTime,
                                                      dateTimeAdded__lte = endTime).order_by('-dateTimeAdded').first()
            agentId = kwargs.get('agentId')

            url = concat_user_center_entry_url(agentId=agentId,
                                               redirect=concat_front_end_url(uri='/user/index.html#/user/feedbackList'))

            if consumeRcd is None:
                return [
                    {'msgType': 'text',
                     'value': u'系统中没有查到您最近7天的使用记录/::-|，这种情况比较少见，建议您先创建一张<a href="%s">报告单</a>，然后拨打客服电话，让客服尽快处理' % url},
                    {'msgType': 'image', 'value': '1.png'},
                    {'msgType': 'image', 'value': '2.png'},
                    {'msgType': 'image', 'value': '3.png'},
                    {'msgType': 'image', 'value': '4.png'},
                ]
            rcdDesc = u'地址:%s,编号:%s,付款:%s,时间:%s' % (consumeRcd.address, consumeRcd.logicalCode, consumeRcd.coin,
                                                    consumeRcd.dateTimeAdded.strftime(Const.DATETIME_FMT))
            if consumeRcd.isNormal:
                return [
                    {'msgType': 'text', 'value': u'查到您最新的订单，信息如下：%s' % rcdDesc},
                    {'msgType': 'text',
                     'value': u'钱确实用出去了/:--b，设备如果没有正常响应或者故障，您先拍照留下证据。然后您在服务&投诉中，<a href="%s">报告老板</a>，申请上分或者退币。然后在常见问题菜单中，拨打客服电话，让客服尽快处理/::)。如果没有及时响应，您也可以先行自己补款，然后记得向设备老板申请退币/:rose' % url}
                ]
            else:
                return [
                    {'msgType': 'text', 'value': u'查到您最新的订单，信息如下：%s' % rcdDesc},
                    {'msgType': 'text', 'value': u'亲，刚查询到您确实有个消费订单，没有成功/:--b。系统已经自动给您退币了，您可以重新扫码尝试启动设备，或者换台别的设备试试吧/::)'}
                ]
        except Exception, e:
            return [{'msgType': 'text',
                     'value': u'我在系统中没有查到您最近的使用记录/::<，这种情况，建议您在服务&投诉中<a href="%s">报告老板</a>，申请上分或者退币。然后在常见问题中，拨打客服电话，让客服尽快处理/::P' % url}]

    @staticmethod
    def replyQueryServicedPhone(moniOpenId, appId, **kwargs):
        agentId = kwargs.get('agentId')
        endTime = datetime.datetime.now()
        startTime = endTime - datetime.timedelta(days = 7)
        consumeRcd = ConsumeRecord.objects.filter(openId = kwargs['openId'], dateTimeAdded__gte = startTime,
                                                  dateTimeAdded__lte = endTime).order_by('-dateTimeAdded').first()
        if consumeRcd:
            phone = AskStep.get_service_phone_from_rcd(consumeRcd)
            return [{'msgType': 'text', 'value': u'/::P这个是客服电话吧：%s' % phone}]
        else:
            url = concat_user_center_entry_url(agentId=agentId,
                                               redirect=concat_front_end_url(uri='/user/index.html#/user/help'))
            return [{'msgType': 'text', 'value': u'这个给您，<a href="%s">客服电话</a>' % url}]

    def reply(self, moniOpenId, appId, **kwargs):
        if self.answerFunc:
            return eval('AskStep.%s(moniOpenId,appId,**kwargs)' % self.answerFunc)
        elif self.answerText:
            return [{'msgType': 'text', 'value': self.answerText}]
        elif self.answerPics:
            return [{'msgType': 'image', 'value': pic} for pic in self.answerPics]
        else:
            return [{'msgType': 'text', 'value': ''}]


# 聊天模式匹配库。用于批量智能客服(不需要那么复杂的聊天，而且也贵；可以针对性进行数据库查询，更灵活)
class AskRobot(Searchable):
    ask = StringField(verbose_name = 'ask', default = '')  # 问题模式，是可以匹配的: 机器/洗衣机/设备/,不启动/没反应/不动/不转/没动静
    steps = ListField(verbose_name = 'answer steps', default = [])  # 支持
    priority = IntField(verbose_name = 'priority', default = 1)

    askList = []

    @staticmethod
    def load_in_mem_if_not_exist():
        #         if AskRobot.askList:#调试比较麻烦，直接查询所有吧，以后做了界面，再打开
        #             return
        objs = AskRobot.objects.all().order_by('-priority')
        for obj in objs:
            AskRobot.askList.append(obj)

    @staticmethod
    def match_sentence(ask, sentence, score):
        wordList = sentence.split('/')
        for word in wordList:
            if word in ask:
                logger.info('it is match,sentence=%s,ask=%s' % (sentence, ask))
                return score
        return 0.0

    # 根据图片文件名称找ID，文章标题找ID
    @staticmethod
    def find_material_id(proxy, mediaType, value):
        if mediaType == 'image':
            results = proxy.client.material.batchget(media_type = 'image', offset = 0,
                                                     count = 1000)  # 简单粗暴，目前看素材不会超过20个
            for item in results.get('item', []):
                if item['name'] == value:
                    return item['media_id']
            return None
        return None

    @staticmethod
    def reply(event, moniOpenId, ask, appId, secret, **kwargs):
        AskRobot.load_in_mem_if_not_exist()

        # 产生一个线程，让线程后台处理这个客服消息
        class replyer(threading.Thread):
            def __init__(self, event, moniOpenId, ask, appId, secret, **kwargs):
                super(replyer, self).__init__()
                self._event = event
                self._moniOpenId = moniOpenId
                self._ask = ask
                self._appId = appId
                self._secret = secret
                self._kwargs = kwargs

            def run(self):
                try:
                    replys = []

                    # 如果是关注事件，直接推送文章
                    if self._event == 'subscribe':
                        materialId = MoniApp.objects.get(appId = self._appId).welcomeArticleMaterialId
                        replys.append({'msgType': 'news', 'value': materialId})

                        moniUser = MoniUser.objects.filter(moniOpenId = self._moniOpenId,
                                                           moniAppId = self._appId).first()
                        if moniUser:
                            devLink = concat_user_login_entry_url(l=moniUser.subLogicalCode)
                            replys.append({'msgType': 'text',
                                           'value': u'/:rose亲，欢迎您关注自助设备服务平台！乐乐可以为您解决售后问题以及投诉事宜/:hug，———————   \ue231<a href="%s">戳我使用设备</a>\ue230' % devLink})
                    else:
                        # 找到所有问题的答案
                        for askConfig in AskRobot.askList:
                            sentenceList = askConfig.ask.split(',')
                            sentenceScore = 100.0 / len(sentenceList)
                            allScore = 0
                            for sentence in sentenceList:
                                allScore += AskRobot.match_sentence(self._ask, sentence, sentenceScore)

                            if allScore >= 90:
                                logger.info('find match answer key = %s' % ','.join(askConfig.steps))
                                replys = askConfig.answer(self._moniOpenId, self._appId, **self._kwargs)
                                break
                    logger.info('reply len %s' % len(replys))
                    # 把答案的文章、图片发给用户
                    app = WechatAuthApp(appid = self._appId, secret = self._secret)
                    proxy = WechatClientProxy(app)
                    for reply in replys:
                        if not reply:
                            continue
                        try:
                            if reply['msgType'] == 'text' and reply['value']:
                                proxy.client.message.send_text(moniOpenId, reply['value'])
                            elif reply['msgType'] == 'image' and reply['value']:
                                materialId = AskRobot.find_material_id(proxy, 'image', reply['value'])
                                proxy.client.message.send_image(moniOpenId, materialId)
                            elif reply['msgType'] == 'news' and reply['value']:
                                proxy.client.message.send_articles(moniOpenId, reply['value'])
                            time.sleep(1)
                        except Exception, e:
                            logger.exception('send msg to user failed = %s' % (e))
                            continue
                except Exception as e:
                    logger.info('replyer error,e=%s' % e)

        sender = replyer(event, moniOpenId, ask, appId, secret, **kwargs)
        sender.start()

    def answer(self, moniOpenId, appId, **kwargs):
        # 首先把当前回话的历史信息拉出来
        historyReplys = serviceCache.get(moniOpenId, '')
        replyList = []
        for stepKey in self.steps:
            step = AskStep.objects.get(operKey = stepKey)
            sameReplyCount = historyReplys.count(stepKey)
            if sameReplyCount == 0:
                reply = step.reply(moniOpenId, appId, **kwargs)
            elif sameReplyCount == 1:
                if 'xiangyin' not in stepKey:
                    reply = [{'msgType': 'text', 'value': u'建议您试试我给的建议哦/::P'}].extend(
                        step.reply(moniOpenId, appId, **kwargs))
                else:
                    reply = [{'msgType': 'text', 'value': u'嗯，您的问题是什么呢？/::P'}]
            elif sameReplyCount == 2:
                step = AskStep.objects.get(operKey = 'kefudianhua')
                reply = step.reply(moniOpenId, appId, **kwargs)
            else:
                reply = [{'msgType': 'text', 'value': ''}]

            if reply:
                historyReplys += '%s,' % stepKey
                serviceCache.set(moniOpenId, historyReplys, 600)
                replyList.extend(reply)

        return replyList


class WxAuthTransfer(Searchable):
    agentId = StringField(verbose_name = u'代理商ID', default = '')
    oldAppId = StringField(verbose_name = u'老的appid', default = '')
    oldOpenId = StringField(verbose_name = u'老的openid', default = '')
    newAppId = StringField(verbose_name = u'新的appid', default = '')
    newOpenId = StringField(verbose_name = u'新的openid', default = '')
    # subAgentList = ListField(verbose_name = '子agent列表', default = '')
    firstPhase = BooleanField(verbose_name = u'第1阶段任务完成', default = False)
    secondPhase = BooleanField(verbose_name = u'第2阶段任务完成', default = False)

    meta = {
        "collection": "wx_auth_transfer",
        "db_alias": "logdata"
    }

    def __repr__(self):
        return '{}<agent={}, old=({},{}), new=({},{})>'.format(
            self.__class__.__name__,
            str(self.agentId),
            self.oldAppId, self.oldOpenId,
            self.newAppId, self.newOpenId)


class ICChargeOperating(Searchable):
    """
    deprecated 该功能废弃, 保证脚本能正常进行
    """

    cardId = StringField(verbose_name = 'cardId', default = '')
    balance = MonetaryField(verbose_name = u"卡余额", default = RMB('0.00'))
    needChargeMoney = MonetaryField(verbose_name = u"需要充值的钱", default = RMB('0.00'))
    dateTimeAdded = DateTimeField(verbose_name = u'操作时间', default = datetime.datetime.now)

    meta = {
        "collection": "ic_charge_operating",
        "db_alias": "logdata"
    }


class BlackListUsers(Searchable):
    class Status(IterConstant):
        BLACK = "black"
        WHITE = 'white'

    openId = StringField(verbose_name = "被拉黑用户OpenId")
    dealerId = StringField(verbose_name = "经销商ID")
    agentId = StringField(verbose_name = "代理商ID")
    reason = StringField(verbose_name = "被拉黑的理由", default = "")
    operator = StringField(verbose_name = "操作人")
    status = StringField(verbose_name = "拉黑状态", choices = Status.choices(), default = Status.BLACK)

    dateTimeAdded = DateTimeField(verbose_name = "拉黑进去的时间", default = datetime.datetime.now)

    meta = {
        "db_alias": "default",
        'indexes': [
            'dealerId',
        ],
    }

    @classmethod
    def add_black_user(cls, openId, dealerId, operator, reason = ""):
        """
        拉黑用户
        :param openId:
        :param dealerId:
        :param operator:
        :param reason:
        :return:
        """
        try:
            record = cls.objects.get(dealerId = dealerId, openId = openId)
        except DoesNotExist:
            dealer = Dealer.get_dealer(dealerId) or dict()
            record = cls(
                openId = openId,
                dealerId = dealerId,
                agentId = dealer.get("agentId", ""),
                operator = operator,
                reason = reason
            ).save()

        record.update(status = cls.Status.BLACK)

    @classmethod
    def freed_black_user(cls, openId, dealerId):
        """
        解除用户的拉黑状态 这个地方不删除记录 防止之后要有需求对拉黑用户进行天数限制
        :param openId:
        :param dealerId:
        :return:
        """
        try:
            record = cls.objects.get(dealerId = dealerId, openId = openId)
        except DoesNotExist:
            return

        record.update(status = cls.Status.WHITE)

    @classmethod
    def check_black(cls, openId, dealerId):
        """
        检查该用户是否被拉黑
        :param openId:
        :param dealerId:
        :return:
        """

        record = cls.objects(openId=openId, dealerId__in=[dealerId, '*']).first()

        if not record:
            return False

        if record.status == cls.Status.WHITE:
            return False
        else:
            return True


# 此表用于解决复制卡的问题。每张卡都有一个变化的随机码，每次扣费后会新生成一个随机码。每次扣钱后，会上报上次的随机码
# 如果随机码出现一次重复，说明出现一次复制卡。随机码是刷卡器生成的时间标签，恰好重复的可能性微乎其微。
class WeifuleCardStamp(Searchable):
    cardNo = StringField(verbose_name = "卡号", default = "")
    dealerId = StringField(verbose_name = "经销商ID", default = "")

    dateTimeAdded = DateTimeField(verbose_name = '添加时间', default = datetime.datetime.now())
    stamp = StringField(verbose_name = 'stamp', default = "")

    meta = {
        "collection": "weifule_card_stamp",
        "db_alias": "default"
    }

    @staticmethod
    def is_copy_card(cardNo, dealerId, stamp):
        harfYear = datetime.datetime.now() - datetime.timedelta(days = 6 * 30)
        copyCount = WeifuleCardStamp.objects.filter(cardNo = cardNo, dealerId = dealerId, dateTimeAdded__gte = harfYear,
                                                    stamp = stamp).count()
        if copyCount:
            return True
        return False


class SwapCardRecord(Searchable):
    oldCardNo = StringField(verbose_name = u"旧卡卡号")
    newCardNo = StringField(verbose_name = u"新卡卡号")
    agentId = StringField(verbose_name = u"补卡的代理商ID")
    operator = StringField(verbose_name = u"操作人")
    dateTimeAdded = DateTimeField(verbose_name = u"补卡时间", default = datetime.datetime.now)

    meta = {'collection': 'SwapCardRecord', 'db_alias': 'logdata'}

    @classmethod
    def add_record(cls, oldCardNo, newCardNo, agentId, operator):
        """
        添加一条补卡记录
        :param oldCardNo: 旧卡卡号
        :param newCardNo: 新卡卡号
        :param agentId: 补卡代理商ID
        :param operator: 操作者ID
        :return:
        """

        record = cls(
            newCardNo = newCardNo,
            oldCardNo = oldCardNo,
            agentId = agentId,
            operator = operator
        )
        record.save()
        return record


class DuibijiOrderMap(Searchable):
    devOrderId = IntField(verbose_name = 'device order id', unique = True)
    consumeRcdId = StringField(verbose_name = 'consume rcd id', unique = True)
    rechargeRcdId = StringField(verbose_name = 'rechargeRcdId id', default = '')
    status = StringField(verbose_name = 'status', default = '')
    openId = StringField(verbose_name = 'openId', default = '')
    dateTimeAdded = DateTimeField(verbose_name = 'dateTimeAdded', default = datetime.datetime.now())


class MonthlyPackageUseInfo(EmbeddedDocument):
    orderNo = StringField(verbose_name = u"使用订单编号", required = True)
    orderTime = DateTimeField(verbose_name = u"使用的时间", required = True)

    def to_dict(self):
        return {"orderNo": self.orderNo, "orderTime": self.orderTime}


class MonthlyPackage(Searchable):
    # 用户相关信息
    name = StringField(verbose_name = u"包月套餐的名称", default = "")
    groupId = StringField(verbose_name = u"包月绑定的地址组", required = True)
    openId = StringField(verbose_name = u"用户的唯一ID", required = True)
    cardNo = StringField(verbose_name = u"刷卡能够使用的卡号", default = "")
    bothCardAndMobile = BooleanIntField(verbose_name = u"是否是通用的(扫码和刷卡通用)", default = False)

    # 包月相关信息
    startDateTime = DateTimeField(verbose_name = u"有效期起始时间", required = True)
    expireDateTime = DateTimeField(verbose_name = u"过期的时间", required = True)
    maxCountOfDay = IntField(verbose_name = u"每日的最大的次数", default = 0, min_value = 0)
    maxCount = IntField(verbose_name = u"可供使用的最大次数", default = 0, min_value = 0)
    maxTimeOfCount = IntField(verbose_name = u"每次最大的充电时间 单位分钟", default = 0, min_value = 0)
    maxElecOfCount = IntField(verbose_name = u"每次最大充电量 单位度", default = 0, min_value = 0)

    # 基本信息
    isDisable = BooleanIntField(verbose_name = u"是否已经失效", default = 0)
    usedTotal = IntField(verbose_name = u"使用的总次数", default = 0)
    usedDetail = MapField(verbose_name = u"用户使用情况",
                          field = EmbeddedDocumentListField(document_type = MonthlyPackageUseInfo))
    dateTimeAdded = DateTimeField(verbose_name = u"购买的时间 一般与起始时间开始", default = datetime.datetime.now)

    @property
    def payVia(self):
        return "monthlyPackage"

    @staticmethod
    def format_date(date):  # type: (datetime.date) -> str
        """
        :param date:
        :return:
        """
        return "T{}".format(date.strftime("%Y_%m_%d"))

    @classmethod
    def get_enable_one(cls, openId, groupId, cardNo = ""):
        """
        找包月的 openId groupId 一定需要对应上 并且 允许通用 或者不允许通用但是卡号不为空
        :return:
        """
        group = Group.get_group(groupId)  # type: GroupDict
        dealer = Dealer.objects.get(id = group.ownerId)
        groupIds = Dealer.get_currency_group_ids(dealer, group)
        groupIds.append(groupId)

        objs = cls.objects.filter(
            openId = openId, groupId__in = groupIds, isDisable = 0
        ).filter(
            Q(cardNo = cardNo) | Q(bothCardAndMobile = 1)
        ).order_by('dateTimeAdded')

        result = filter(
            lambda obj: obj.useable,
            map(lambda obj: obj.disable(), objs)
        )

        return result[0] if result else None

    @classmethod
    def get_user_all(cls, openId):
        """
        获取用户所有的包月套餐规则
        :param openId:
        :return:
        """
        return cls.objects.filter(openId = openId, isDisable = 0)

    @classmethod
    def create_by_template(cls, template, rechargeOrder):  # type:(MonthlyPackageTemp, RechargeRecord) -> MonthlyPackage

        subIndex = rechargeOrder.attachParas.get("subTempIndex")
        purchasedMonth = template.subTemplate[subIndex].numOfMonth

        data = {
            "name": template.subTemplate[subIndex].displayName,
            "groupId": rechargeOrder.groupId,
            "openId": rechargeOrder.openId,
            "cardNo": rechargeOrder.attachParas.get("cardNo", ""),
            "bothCardAndMobile": template.bothCardAndMobile,

            "startDateTime": rechargeOrder.dateTimeAdded,
            "expireDateTime": rechargeOrder.dateTimeAdded + relativedelta.relativedelta(months = purchasedMonth),
            "maxCountOfDay": template.maxCountOfDay,
            "maxCount": template.maxCountOfMonth * purchasedMonth,
            "maxTimeOfCount": template.maxTimeOfCount,
            "maxElecOfCount": template.maxElecOfCount,
        }

        obj = cls(**data)
        return obj.save()

    @property
    def useable(self):
        """
        :return:
        """
        if self.isDisable:
            return False

        # 总次数
        if len(self.usedDetail) >= self.maxCount:
            return False

        # 0 表示不限制
        if self.maxCountOfDay == 0:
            return True

        else:
            # 当日的次数超限
            dateStr = self.format_date(datetime.date.today())
            dateUseInfo = self.usedDetail.get(dateStr, list())
            if len(dateUseInfo) >= self.maxCountOfDay:
                return False

            return True

    def deduct(self, order):
        # type:(ConsumeRecord)->None

        """
        使用一次， 扣除一次额度， 根据订单进行扣除
        :return:
        """
        orderTime = order.dateTimeAdded  # type: datetime.datetime
        orderInfo = MonthlyPackageUseInfo(orderNo = order.orderNo, orderTime = orderTime)

        updateData = {
            "inc__usedTotal": 1,
            "add_to_set__usedDetail__{}".format(self.format_date(orderTime)): orderInfo
        }

        return self.update(**updateData)

    def rollback(self, order):
        """
            用于抵扣回退 目前存在与5分钟以内 需要全退的情况
        """
        orderTime = order.dateTimeAdded  # type: datetime.datetime
        orderInfo = MonthlyPackageUseInfo(orderNo=order.orderNo, orderTime=orderTime)

        updateData = {
            "dec__usedTotal": 1,
            "pull__usedDetail__{}".format(self.format_date(orderTime)): orderInfo
        }

        return self.update(**updateData)


    def disable(self):
        """
        检查将 过期的包月套餐直接清理掉
        :return:
        """
        if self.expireDateTime <= datetime.datetime.now():
            self.update(isDisable = 1)
            return self.reload()

        return self

    def is_suit_package(self, package):
        """
        判断当前的包月套餐是否试用用户选择的套餐
        时间和电量的 检验是否足够抵扣 单次的直接抵扣一次 其余的暂不支持
        :param package:
        :return:
        """
        if package.get("unit") == u"分钟":
            unit = "Time"
        elif package.get("unit") == u"度":
            unit = "Elec"
        elif package.get("unit") == u"次":
            return True
        else:
            return False

        # 这个地方默认的规则时 如果没有适配到合适的套餐 就直接判定为不能够使用
        count = getattr(self, "max{}OfCount".format(unit), 0)

        # 添加一种情况(当count为0时候) 不做限制,只用次数
        if count == 0:
            return True

        if count >= int(package.get("time", 0xFFFF)):
            return True

        return False

    def to_dict(self):
        dayUse = len(self.usedDetail.get(self.format_date(date = datetime.date.today()), list()))

        return {
            "id": self.id,
            "name": self.name,
            "expireDateTime": self.expireDateTime.strftime("%Y-%m-%d %H:%M:%S"),
            "dayLeft": self.maxCountOfDay - dayUse,
            "totalLeft": self.maxCount - self.usedTotal,
            "maxElecOfCount": self.maxElecOfCount,
            "maxTimeOfCount": self.maxTimeOfCount,
        }

    def get_used_detail(self):
        usedDetail = list()
        for _k, _v in self.usedDetail.items():
            usedDetail.extend([_m.to_dict() for _m in _v])
        usedDetail.sort(key = lambda x: x["orderTime"])

        return usedDetail

    @classmethod
    def get_user_ticket(cls, openId, groupId, cardNo = ""):
        group = Group.get_group(groupId)  # type: GroupDict
        dealer = Dealer.objects.get(id = group.ownerId)
        groupIds = Dealer.get_currency_group_ids(dealer, group)
        groupIds.append(groupId)

        objs = cls.objects.filter(
            openId = openId, groupId__in = groupIds, isDisable = 0
        ).filter(
            Q(cardNo = cardNo) | Q(bothCardAndMobile = 1)
        ).order_by('dateTimeAdded')

        return map(lambda obj: obj.disable(), objs)

    @staticmethod
    def get_can_use_one(all_tickets, package):
        # type: (List[MonthlyPackage], dict) -> (MonthlyPackage)
        for ticket in all_tickets:
            if ticket.useable and ticket.is_suit_package(package):
                return ticket
        return None


class Redpack(Searchable):
    # 红包信息
    # TODO 建立索引 factoryCode(索引), openId(索引)

    # 红包活动类型
    class RedpackType():
        LAXIN = 'laxin'
        RUHUI = 'ruhui'

    class Result(IterConstant):
        FINISHED = 'finished'
        PROCESSING = 'processing'

    openId = StringField(verbose_name='openId', default='')
    title = StringField(verbose_name='红包标题', default='')
    factoryCode = StringField(verbose_name='TaskId')
    redpackType = StringField(verbose_name='红包类型', default='')

    # 红包自身流程
    money = MonetaryField(verbose_name='红包金额', default=RMB('0.00'))
    leastPayMoney = MonetaryField(verbose_name='最小使用金额', default=RMB('0.00'))
    effectTime = DateTimeField(verbose_name='红包生效时间')
    expiredTime = DateTimeField(verbose_name='红包过期时间')
    usedStatus = BooleanField(verbose_name='是否使用', default=False)
    usedTime = DateTimeField(verbose_name='使用时间')
    consumeRecordId = StringField(verbose_name='关联消费订单')
    package = DictField(verbose_name='选中的套餐')

    # 来源信息
    gateway = StringField(verbose_name='平台', default='')
    logicalCode = StringField(verbose_name='设备号', default='')
    devNo = StringField(verbose_name='IMEI', default='')
    dateTimeAdded = DateTimeField(verbose_name='记录添加时间', default=datetime.datetime.now)
    extra = DictField(verbose_name='其他', default={})
    taskStatus = StringField(verbose_name="任务当前状态", default=Result.PROCESSING)
    showType = StringField(verbose_name="红包展示方式")

    meta = {
        "db_alias": "default"
    }

    # 红包业务流程
    @classmethod
    def pre_deducted_coins(cls, redpackId, package):
        # 预计抵扣的金额计算, 此函数目前只用于蓝牙流程
        redpack = cls.objects.filter(id=redpackId, usedStatus=False).first()
        if not redpack:
            return 0.0

        if redpack.money > RMB(package['price']):
            return round(RMB(package['coins']), 2)

        else:
            ratio = Ratio(float(package['coins']) / float(package['price']))
        return round(RMB(redpack.money) * ratio, 2)

    @property
    def to_deducted_coins(self):
        if not self.package:
            return 0.0

        if self.money > RMB(self.package['price']):
            return round(RMB(self.package['coins']), 2)

        else:
            ratio = Ratio(float(self.package['coins']) / float(self.package['price']))
        return round(RMB(self.money) * ratio, 2)

    @property
    def to_deducted_money(self):
        if not self.package:
            return self.money

        else:
            if self.money > RMB(self.package['price']):
                return round(RMB(self.package['price']), 2)

            else:
                return round(RMB(self.money), 2)

    @staticmethod
    def use_redpack(redPacketId, consumeRecordId, package):
        # type: (str, str, dict) -> int

        # 1  校验红包(过期, 状态)
        nowTime = datetime.datetime.now()

        return Redpack.objects.filter(id=redPacketId, usedStatus=False).update(usedStatus=True, usedTime=nowTime,
                                                                  consumeRecordId=consumeRecordId, package=package)

    @classmethod
    def get_redpack_list(cls, filtetr, rmb=None):
        """
            rmb 当前使用金额, 如果没有的话
            例: 红包 满2 - 0.2  最小使用金额必须
        """

        nowTime = datetime.datetime.now()

        if not rmb:
            rmb = RMB(0).mongo_amount

        exp_time = nowTime + datetime.timedelta(minutes=30) # 给30分钟时间给设备启动留用

        redPackets = cls.objects.filter(
            effectTime__lte=nowTime,
            expiredTime__gte=exp_time,
            leastPayMoney__lte=rmb,
            usedStatus=False,
            taskStatus=cls.Result.FINISHED,
            **filtetr
        ).order_by('expiredTime')

        if not redPackets:
            return []

        return list(map(lambda x: x.to_dict(), redPackets))

    def to_dict(self):
        return {
            'openId': self.openId,
            'title': self.title,
            'factoryCode': self.factoryCode,
            'money': RMB(self.money).mongo_amount,
            'leastPayMoney': RMB(self.leastPayMoney).mongo_amount,
            'effectTime': self.effectTime,
            'expiredTime': self.expiredTime,
            'usedStatus': self.usedStatus,
            'logicalCode': self.logicalCode,
            'consumeRecordId': self.consumeRecordId,
            'redpackCoins': self.to_deducted_coins,
            'redpackMoney': self.to_deducted_money,
            'id': str(self.id),
            'taskStatus': self.taskStatus,
            'showType': self.showType,
        }

    def rollback_redpack(self, redPacketId):
        redPacket = self.objects.filter(id=redPacketId).first()
        if not Redpack:
            return False

        return redPacket.update(usedStatus=False)

    @classmethod
    def can_use(cls, dealer, devTypeCode):
        # type: (Dealer, str)->bool

        dealer_features = map(lambda x: x['key'], filter(lambda x: x['value'] == True, dealer.feature_list))
        if 'disable_redpack' in dealer_features:
            return False
        else:
            if devTypeCode and devTypeCode in Redpack.list_of_devices_that_support_redpack():
                return True

        return False

    @classmethod
    def auto_suit_with_money(cls, query, rmb):
        """
            自动挑选合适的红包抵扣支付金额
             # 有两种判断:
                 1 红包金额大于支付金额, 优先选择与红包金额接近金额支付的红包使用
                 2 红包金额小于支付金额, 优先选择大的红包金额
        """
        try:
            redpacks = cls.get_redpack_list(query)

            if redpacks:
                # 第一种情况做筛选 红包金额大于支付金额, 优先选择与红包金额接近金额支付的红包使用
                _enough_list = filter(lambda _: RMB(_.get('money')) >= rmb, redpacks)

                if _enough_list:
                    return min(_enough_list, key=lambda _: RMB(_.get('money', 0)))

                # 第二种情况 没有足够支付的金额 选取最大的红包进行抵扣
                return max(redpacks, key=lambda _: RMB(_.get('money', 0)))
        except:
            import traceback
            logger.error(traceback.format_exc())
            return

    @classmethod
    def auto_suit_with_coins(cls, query, userBalance, package):
        """
            自动挑选合适的红包抵扣金币
             # 有三种判断:
                 1 红包足以 抵扣 挑选最小的红包
                 2 红包 + 金币 抵扣 挑选最小的红包
                 2 返回 都不足以抵扣 返回空
        """
        try:
            package_money = RMB(package.get('price', 0))
            if package_money == RMB(0):
                return

            package_coins = RMB(package.get('coins', 0))
            ratio = Ratio(float(package.get('coins', 0.0)) / float(package.get('price', 0.0)))

            redpacks = cls.get_redpack_list(query)
            if redpacks:
                #  第一种情况 红包足以 抵扣 挑选最小的红包
                _enough_list = filter(lambda _: RMB(_.get('money')) >= package_money, redpacks)

                if _enough_list:
                    return min(_enough_list, key=lambda _: RMB(_.get('money', 0)))

                # 第二种情况 红包 + 金币 抵扣 挑选最小的红包
                _mix_enough_list = filter(lambda _: RMB(_.get('money', 0)) * ratio + RMB(userBalance) >= package_coins, redpacks)
                if _mix_enough_list:
                    return min(_mix_enough_list, key=lambda _: RMB(_.get('money', 0)))
        except:
            import traceback
            logger.error(traceback.format_exc())
            return

    @classmethod
    def get_one(self, redpackId):
        redpack = Redpack.objects.filter(id=redpackId).first() # type: Redpack
        if not redpack:
            return {}

        else:
            return redpack.to_dict()

    @classmethod
    def show_redpack(cls, openId):
        nowTime = datetime.datetime.now()

        exp_time = nowTime - datetime.timedelta(days=3)

        # 筛选出过期时间超过三天或者 使用后时间超过三天的红包
        redPackets = cls.objects.filter(Q(expiredTime__gte=exp_time) | Q(usedTime__gte=exp_time),
                                        openId=openId, taskStatus=cls.Result.FINISHED).order_by('-expiredTime')

        if not redPackets:
            return []

        return list(map(lambda x: x.to_dict(), redPackets))

    @staticmethod
    def list_of_devices_that_support_redpack():
        from apps.web.core.models import SystemSettings
        support_redpack_list = SystemSettings.get_support_redpack_list()
        return support_redpack_list

    @staticmethod
    def add_device_to_support_redpack_list(devTypeCode):
        from apps.web.core.models import SystemSettings
        support_redpack_list = SystemSettings.get_support_redpack_list()
        support_redpack_list.append(devTypeCode)
        support_redpack_list = list(set(support_redpack_list))
        SystemSettings.set_support_redpack_list(support_redpack_list)
        logger.info('Current support redpck list：{}'.format(support_redpack_list))

    @staticmethod
    def remove_device_to_support_redpack_list(devTypeCode):
        from apps.web.core.models import SystemSettings
        support_redpack_list = SystemSettings.get_support_redpack_list()
        if devTypeCode in support_redpack_list:
            support_redpack_list.remove(devTypeCode)
        support_redpack_list = list(set(support_redpack_list))
        SystemSettings.set_support_redpack_list(support_redpack_list)
        logger.info('Current support redpck list：{}'.format(support_redpack_list))

    @staticmethod
    def renew_support_repack_list(devTypeCodeList):
        from apps.web.core.models import SystemSettings
        SystemSettings.set_support_redpack_list(devTypeCodeList)

    # 拉新创建红包*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
    @staticmethod
    def create_redpack_by_laxin(factoryCode, openId, money, leastPayMoney, effectTime, expiredTime, gateway,
                                logicalCode, devNo, extra):

        if Redpack.objects.filter(factoryCode=factoryCode, openId=openId).first():
            return

        else:
            red_packet = {
                'factoryCode': factoryCode,
                'title': '支付宝每日任务红包',
                'openId': openId,
                'money': money,
                'leastPayMoney': leastPayMoney,
                'effectTime': effectTime,
                'expiredTime': expiredTime,
                'gateway': gateway,
                'logicalCode': logicalCode,
                'devNo': devNo,
                'extra': extra,
                'taskStatus': Redpack.Result.FINISHED,
                'redpackType': Redpack.RedpackType.LAXIN
            }

        try:
            redpack = Redpack.objects.create(**red_packet)
        except:
            return None

        return redpack



    # 入会创建红包*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
    @staticmethod
    def create_redpack_by_ruhui(taskId, openId, urlId, money, leastPayMoney, gateway, logicalCode, devNo, extra, showType=''):

        redpack = Redpack.objects.filter(factoryCode=taskId, openId=openId, redpackType=Redpack.RedpackType.RUHUI,
                                         taskStatus__ne=Redpack.Result.FINISHED).first()
        if redpack:
            redpack.update(**{
                'logicalCode': logicalCode,
                'devNo': devNo,
                'extra': extra,
                'taskStatus': Redpack.Result.PROCESSING,
                'expiredTime': datetime.datetime.now() + datetime.timedelta(days=7),
                'urlId': urlId,
                'dateTimeAdded': datetime.datetime.now(),
                'showType':showType,
            })

        else:
            red_packet = {
                'factoryCode': taskId,
                'title': '支付宝每日任务红包.',
                'openId': openId,
                'money': money,
                'leastPayMoney': leastPayMoney,
                'gateway': gateway,
                'logicalCode': logicalCode,
                'devNo': devNo,
                'extra': extra,
                'taskStatus': Redpack.Result.PROCESSING,
                'expiredTime': datetime.datetime.now() + datetime.timedelta(days=7),
                'redpackType': Redpack.RedpackType.RUHUI,
                'urlId': urlId,
                'showType': showType,
            }

            try:
                redpack = Redpack.objects.create(**red_packet)
            except:
                return

        return redpack

    @staticmethod
    def take_effect(openId, urlId, **kw):
        try:
            obj = Redpack.objects.filter(openId=openId, urlId=urlId, redpackType=Redpack.RedpackType.RUHUI,
                                         taskStatus__ne=Redpack.Result.FINISHED).first()
            if not obj:
                return

            extra = obj.extra
            extra.update(kw)
            obj.update(
                extra=extra,
                taskStatus=Redpack.Result.FINISHED,
                effectTime=datetime.datetime.now(),
                expiredTime=datetime.datetime.now() + datetime.timedelta(days=15)
            )
            return obj.reload()
        except:
            import traceback
            logger.error(traceback.format_exc())


class OneCardGateLog(Searchable):
    devNo = StringField(verbose_name=u"设备编号")
    logicalCode = StringField(verbose_name=u"逻辑编号")
    openId = StringField(verbose_name=u"用户信息")
    control = IntField(verbose_name=u"进出标记")
    result = BooleanField(verbose_name=u"操纵结果")
    dateTimeAdded = DateTimeField(verbose_name=u"添加时间")

    meta = {
        'collection': 'OneCardGateLog',
        'db_alias': 'logdata'
    }


# ------------------------------------ 以下为新增 ------------------------


class OrderPackage(dict):

    def belong_category(self, category):    # type: (str) -> bool
        return self.category == category

    @property
    def policyType(self):   # type: () -> Optional[str, None]
        return self.get("policyType") or self.get("category")

    @property
    def category(self):     # type: () -> str
        """
        套餐的种类 实际上也是相应的启动方式
        """
        if self.policyType:
            return self.policyType

        unit = self.get("unit")
        if unit in [u"度"]:
            return PackageCategory.ELEC
        if unit in [u"元"]:
            return PackageCategory.COIN
        if unit in [u"小时", u"分钟"]:
            return PackageCategory.TIME

        return "unknown"

    @property
    def isPostpaid(self):
        return self.get("isPostpaid", False)

    @property
    def autoRefund(self):
        return self.get("autoRefund", False)

    @property
    def autoStop(self):
        return self.get("autoStop", False)

    @property
    def minFee(self):
        return RMB(self.get("minFee", 0))

    @property
    def minAfterStartCoins(self):
        return RMB(self.get("minAfterStartCoins", 0))

    @property
    def isFree(self):
        return self.get("isFree", False)

    @property
    def price(self):
        """
        套餐的价格 后付费 即先用后付的情况 显示价格为0
        """
        if self.isFree or self.isPostpaid:
            return RMB(0)

        return RMB(self.get("price", 0))

    @property
    def time(self):     # type:()->int
        """
        套餐的时间单位 最终为 分钟
        注意区分是否已经初始化过了
        """
        value = self.get("m_time")
        if value:
            return value

        # 初始化过程
        value = self.get('time', 0) if self.belong_category(PackageCategory.TIME) else 0
        if self.get("unit") == u"小时":
            return int(float(value) * 60)

        if self.get("unit") == u"分钟":
            return int(value)
        return 0

    @property
    def elec(self):
        """
        套餐的电量单位 最终为 度
        """
        value = self.get("m_elec")
        if value:
            return value

        return float(self.get('time', 0) if self.belong_category(PackageCategory.ELEC) else 0)

    @property
    def coin(self):
        """
        注意 这个coin不是价格的意思 指的是直接是设备运行的硬币数 例如投币 或者某些直接以金额启动设备的套餐
        """
        value = self.get("m_coin")
        if value:
            return value
        return int(self.get('time', 0) if self.belong_category(PackageCategory.COIN) else 0)

    @property
    def name(self):
        return self.get("name", "")

    @property
    def desc(self):
        return self.get("desc", "")

    @property
    def rules(self):
        """
        即计费规则
        """
        return self.get("rules") or None

    @property
    def refundProtectTime(self):
        return self.get("refundProtectTime", 0)

    @property
    def dumpDict(self):
        """
        需要被订单固化的数据
        """
        return {
            "category": self.category,
            "name": self.name,
            "price": self.price.mongo_amount,
            "m_time": self.time,
            "m_elec": self.elec,
            "m_coin": self.coin,
            "minAfterStartCoins": self.minAfterStartCoins.mongo_amount,
            "minFee": self.minFee.mongo_amount,
            "autoRefund": self.autoRefund,
            "autoStop": self.autoStop,
            "rules": self.rules,
            "isFree": self.isFree,
            "isPostpaid": self.isPostpaid,
            "desc": self.desc,
            "refundProtectTime": self.refundProtectTime
        }

    @property
    def showDict(self):
        return {
            "category": self.category,
            "name": self.name,
            "time": self.time,
            "elec": self.elec,
            "coin": self.coin,
            "minAfterStartCoins": self.minAfterStartCoins.mongo_amount,
            "minFee": self.minFee.mongo_amount,
            "autoRefund": self.autoRefund,
            "autoStop": self.autoStop,
            "rules": self.rules,
            "isFree": self.isFree,
            "isPostpaid": self.isPostpaid,
            "desc": self.desc,
            "refundProtectTime": self.refundProtectTime
        }


class PaymentInfo(dict):

    @property
    def deduct_list(self):
        return self.get("deduct_list") or list()

    @property
    def time(self):
        return self.get("time")

    @time.setter
    def time(self, value):
        self.update({"time": value})

    @property
    def isPaid(self):
        return self.time is not None

    @property
    def via(self):
        return self.get("via")

    @property
    def totalAmount(self):
        s = RMB(0)
        for _item in self.deduct_list:
            s += RMB(_item.get("chargeBalance"))
            s += RMB(_item.get("bestowBalance"))
        return s

    @property
    def actualAmount(self):
        """
        排除赠送余额之后的支付金额
        """
        s = RMB(0)
        for _item in self.deduct_list:
            s += RMB(_item.get("chargeBalance"))

        return s

    @property
    def bestowAmount(self):
        s = RMB(0)
        for _item in self.deduct_list:
            s += RMB(_item.get("bestowBalance"))

        return s


class ServiceInfo(dict):
    """
    和设备运行的一切相关信息
    """
    @property
    def deviceStartTime(self):
        return self.get(ConsumeOrderServiceItem.START_TIME)

    @deviceStartTime.setter
    def deviceStartTime(self, value):
        if isinstance(value, datetime.datetime):
            value = value.strftime("%Y-%m-%d %H:%M:%S")
        self.update({ConsumeOrderServiceItem.START_TIME: value})

    @property
    def elec(self):
        return self.get(ConsumeOrderServiceItem.ELEC)

    @elec.setter
    def elec(self, value):
        self.update({ConsumeOrderServiceItem.ELEC: float(value)})

    @property
    def duration(self):
        return self.get(ConsumeOrderServiceItem.DURATION)

    @duration.setter
    def duration(self, value):
        self.update({ConsumeOrderServiceItem.DURATION: int(value)})

    @property
    def deviceEndTime(self):
        return self.get(ConsumeOrderServiceItem.END_TIME)

    @deviceEndTime.setter
    def deviceEndTime(self, value):
        if isinstance(value, datetime.datetime):
            value = value.strftime("%Y-%m-%d %H:%M:%S")
        self.update({ConsumeOrderServiceItem.END_TIME: value})

    @property
    def maxPower(self):
        return self.get(ConsumeOrderServiceItem.MAX_POWER)

    @maxPower.setter
    def maxPower(self, value):
        self.update({ConsumeOrderServiceItem.MAX_POWER: value})

    @property
    def reason(self):
        return self.get(ConsumeOrderServiceItem.REASON)

    @reason.setter
    def reason(self, value):
        self.update({ConsumeOrderServiceItem.REASON: value})

    @property
    def spendMoney(self):
        return RMB(self.get(ConsumeOrderServiceItem.SPEND, 0))

    @spendMoney.setter
    def spendMoney(self, value):
        self.update({ConsumeOrderServiceItem.SPEND: RMB(value)})


class ConsumeRecord(Searchable):
    """
    用户的消费订单记录
    """
    class Status(IterConstant):
        CREATED = 'created'     # 订单创建初始状态 刚刚下单
        WAIT_CONF = 'waitConf'  # 用户下完单之后【等待】用户进一步的动作确认
        FINISHED = 'finished'   # 订单的结束状态 表示相应信息已经被记录
        WAITING = 'waiting'     # 订单的执行等待状态 设备尚未执行该订单
        RUNNING = 'running'     # 订单执行运行状态 设备正在执行该订单
        END = "end"             # 订单运行结束状态 设备已经执行订单完毕 订单完结
        TIMEOUT = 'timeout'     # 订单启动超时状态 设备启动超时 有可能已经启动了
        FAILURE = 'failure'     # 订单执行失败状态 设备明确启动失败 订单已经完结
        UNKNOWN = 'unknown'     # 订单的未知状态 未知的订单状态
        WAIT_PAY = 'waitPay'    # 订单支付的中间状态

    orderNo = StringField(verbose_name=u"订单号", required=True, unique=True)
    sequenceNo = StringField(verbose_name=u"流水号", unique=True)
    logicalCode = StringField(verbose_name=u"设备编号", required=True)
    groupId = StringField(verbose_name=u"设备地址编号", default=None)
    price = MonetaryField(verbose_name=u"订单价格", default=RMB('0'))
    startType = IntField(verbose_name=u"启动方式", choices=StartDeviceType.choices())
    status = StringField(verbose_name=u"状态", default=Status.CREATED)
    ownerId = StringField(verbose_name=u"经销商", required=True)
    remarks = StringField(verbose_name=u"备注(系统、用户)", default='')
    description = StringField(verbose_name=u"订单描述（错误信息）")
    association = DictField(verbose_name=u'关联单', default={})
    serviceInfo = DictField(verbose_name=u"订单的服务信息", default={})
    isFree = BooleanField(verbose_name=u"是否订单免费", default=False)
    dateTimeAdded = DateTimeField(verbose_name=u"创建时间", default=datetime.datetime.now)
    finishedTime = DateTimeField(verbose_name=u"结束时间")

    cardId = StringField(verbose_name=u"卡ID")
    openId = StringField(verbose_name=u"用户", required=True)
    nickname = StringField(verbose_name=u'用户昵称', default='')

    # 以下信息属于订单快照 防止引用被修改
    devNo = StringField(verbose_name=u"设备ID", required=True)
    port = IntField(verbose_name=u"启动端口")
    devTypeName = StringField(verbose_name=u"设备类型名称", default=None)
    devTypeCode = StringField(verbose_name=u"设备类型编码", default=None)
    address = StringField(verbose_name=u"设备地址", default=None)
    groupNumber = StringField(verbose_name=u"设备", default=None)
    groupName = StringField(verbose_name=u"交易场地", default=None)

    # 退款状态应该是用户下单的时候即被锁定 和设备、支付、套餐有关系
    startPackage = DictField(verbose_name=u'启动套餐', required=True)
    paymentInfo = DictField(verbose_name=u'支付的相关信息', default={})
    refundInfo = DictField(verbose_name=u"退还的相关信息", default={})
    dailyStats = LazyReferenceField(verbose_name="统计关联单", document_type='DealerGroupStats')

    feedbackId = ObjectIdField(verbose_name=u'用户反馈ID')

    search_fields = ('openId', 'devNo', 'orderNo', 'remarks', 'logicalCode')
    _shard_key = ('ownerId', 'dateTimeAdded')
    _origin_meta = {
        "collection": "ConsumeRecord",
        "db_alias": "default"
    }
    meta = _origin_meta

    def __str__(self):
        return '{}<id={} orderNo={}>'.format(self.__class__.__name__, str(self.id), self.orderNo)

    @cached_property
    def owner(self):
        # 防止id报错
        if not self.ownerId:
            return None

        from apps.web.dealer.models import Dealer
        dealer = Dealer.objects(id=self.ownerId).first()
        return dealer

    @cached_property
    def user(self): # type:() -> MyUser
        return MyUser.objects.filter(openId=self.openId, groupId=self.groupId).first()

    @cached_property
    def card(self):
        return Card.objects.filter(id=self.cardId).first()

    @property
    def coin(self):
        return self.price

    @property
    def package(self):  # type: () -> OrderPackage
        return OrderPackage(self.startPackage)

    @property
    def device(self):   # type:()-> DeviceDict
        return Device.get_dev(self.devNo)

    @property
    def group(self):    # type:() -> GroupDict
        return Group.get_group(self.groupId)

    @property
    def startLockKey(self):
        return "{}-{}-start-device-lock".format(self.openId, self.orderNo)

    @property
    def isPayTimeOut(self):
        """
        订单到支付下单的一个过程
        """
        now = datetime.datetime.now()
        return (now - self.dateTimeAdded).total_seconds() > CONSUME_ORDER_PAY_TIMEOUT

    @property
    def isPostPaid(self):
        """
        True 后付费订单 使用完给钱
        False 预付费订单 先给钱再使用然后再决定是否退款
        """
        return self.package.isPostpaid

    @property
    def isStartNetPay(self):
        return self.startType == StartDeviceType.ON_LIEN

    @property
    def isStartCardPay(self):
        return self.startType == StartDeviceType.CARD

    @property
    def payer(self):
        if self.startType == StartDeviceType.ON_LIEN:
            return self.user
        else:
            return self.card

    @property
    def payment(self):  # type: () -> PaymentInfo
        return PaymentInfo(self.paymentInfo)

    @property
    def refund(self):   # type: () -> PaymentInfo
        return PaymentInfo(self.refundInfo)

    @property
    def service(self):  # type:() -> ServiceInfo
        return ServiceInfo(self.serviceInfo)

    @property
    def device_start_time(self):
        return self.service.deviceStartTime

    @property
    def device_end_time(self):
        return self.service.deviceEndTime

    @property
    def isPaid(self):
        if self.isFree:
            return True
        return self.payment.isPaid

    @property
    def actualAmount(self):
        """
        用户订单实际消费的金额
        """
        return self.payment.actualAmount - self.refund.actualAmount

    @property
    def detail_link(self):
        if self.device.deviceAdapter.support_count_down(self.openId, self.port):
            return concat_count_down_page_url(devNo=self.devNo, port=self.port)
        else:
            return concat_front_end_url(uri='/user/index.html#/user/consumeDetail?id={}'.format(str(self.id)))

    @property
    def receiptDesc(self):
        rv = {
            'orderNo': self.orderNo,
            'createdTime': self.dateTimeAdded,
            'payment': u'{} 元'.format(self.price)
        }

        if self.isFree:
            rv.update({"payment": u"本次免费"})

        if self.isPostPaid:
            rv.update({"payment": u"先用后付"})

        return rv

    @property
    def startKey(self):
        return self.orderNo

    @property
    def actualAmount(self):
        return self.payment.actualAmount - self.refund.actualAmount

    @property
    def bestowAmount(self):
        return self.payment.bestowAmount - self.refund.bestowAmount

    @property
    def isNormal(self):
        """
        是否为正常订单
        """
        if self.status in [self.Status.FAILURE, self.Status.UNKNOWN, self.Status.TIMEOUT]:
            return False

        if self.status in [self.Status.WAIT_CONF, self.Status.CREATED]:
            return False

        return True

    @property
    def device_identity_info(self):
        return {
            'logicalCode': self.logicalCode,
            'devTypeCode': self.devTypeCode,
            'devTypeName': self.devTypeName,
            'groupName': self.groupName,
            'groupNumber': self.groupNumber,
            'address': self.address,
            'groupId': self.groupId
        }

    @classmethod
    def make_no(cls, *args, **kwargs):
        """
        有可能会重复 需要保证唯一性
        """
        timestamp = generate_timestamp_ex()
        random_int = random.randint(1, 1000)
        return "%d%03d" % (timestamp, random_int)

    @classmethod
    def new_one(cls, orderNo, user, device, context):    # type:(str, MyUser, DeviceDict, StartParamContext) -> ConsumeRecord

        order = cls(
            orderNo=orderNo,
            sequenceNo=context.sequence,
            logicalCode=device.logicalCode,
            groupId=device.groupId,
            price=context.package.price,
            startType=context.startType,
            ownerId=device.ownerId,
            openId=user.openId,
            cardId=context.cardId,
            nickname=user.nickname,
            devNo=device.devNo,
            port=context.port,
            devTypeName=device.devTypeName,
            devTypeCode=device.devTypeCode,
            address=device.group.address,
            groupNumber=device.groupNumber,
            groupName=device.group.groupName,
            startPackage=context.package.dumpDict,
            isFree=context.package.isFree,
            autoRefund=context.package.autoRefund
        )

        return order.save()

    def update_payment(self, payment):  # type:(dict) -> bool
        """支付信息添加"""
        if self.isPaid:
            return False

        self.paymentInfo = payment
        return self.save()

    def frozen_payer_balance(self):
        """
        执行订单的支付过程 实际上是将用户的金额冻结
        """
        if not self.payment:
            return

        if self.isPaid:
            return

        payer, payment = self.payer, self.payment

        result = payer.__class__.freeze_balance(str(self.id), self.payment)
        if not result:
            return

        # 更新一次付款信息
        payment.time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        self.update_payment(payment)

        payer.account_consume(self)

    def clear_payer_frozen(self, refundMoney=RMB(0)):
        from apps.web.user.utils2 import generate_refund
        refundInfo = PaymentInfo(generate_refund(self, refundMoney))

        result = self.payer.__class__.clear_frozen_balance(
            str(self.id),
            self.payment,
            refundInfo
        )

        if not result:
            return

        if refundMoney == RMB(0):
            return

        refundInfo.time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        self.refundInfo = refundInfo
        self.save()

        self.payer.account_refund(self)

    def link_state(self, state):
        self.dailyStats = state
        self.finishedTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        self.save()

    def to_user_detail(self):
        data = {
            "id": str(self.id),
            "orderNo": self.orderNo,
            "ownerId": self.ownerId,
            "money": self.price,
            "createdTime": self.dateTimeAdded,
            "completionTime": self.finishedTime,
            "startResult": True if self.device_start_time else False,
            "errorDesc": self.description,
            "deviceStatTime": self.device_start_time,
            "deviceFinishedTime": self.device_end_time,
            "isRefund": True if self.refund.time else False,
            "orderStatus": self.status
        }
        if self.refund.time:
            data.update({
                "refundedMoney": self.refund.totalAmount
            })

        data.update(self.device_identity_info)
        return data

    def to_detail(self):
        data = {
            "id": str(self.id),
            'orderNo': self.orderNo,

            'createdTime': self.dateTimeAdded,
            'completionTime': self.finishedTime,

            'deviceStatTime': self.device_start_time,
            'deviceFinishedTime': self.device_end_time,

            'amount': self.price,

            'openId': self.openId,
            'groupId': self.groupId,
            'userNickname': u'用户' if not self.nickname else self.nickname,

            'ownerId': self.ownerId,

            'devNo': self.devNo,
            'logicalCode': self.logicalCode,
            'groupName': self.groupName,
            'address': self.address,
            'groupNumber': self.groupNumber,
            'devType': self.devTypeName,  # 兼容
            'devTypeName': self.devTypeName,

            'remarks': self.remarks,

            'startResult': 'success' if self.isNormal else 'failed',

            'errorDesc': self.description,

            'servicedInfo': [
                u'%s： %s'.encode('utf-8') % (GLOSSARY_TRANSLATION.get(k, k), v) for k, v in self.service.iteritems()
            ],

            # 以下字段和以前做兼容
            'finishedTime': self.device_end_time,
            'port': self.port
        }

        return data


class BalanceLog(Searchable):
    meta = {
        'abstract': True,
    }

    bAmount = MonetaryField(verbose_name=u"变动前充值余额", required=True)
    bBestowAmount = MonetaryField(verbose_name=u"变动前赠送余额", required=True)
    aAmount = MonetaryField(verbose_name=u"变动后充值余额", required=True)
    aBestowAmount = MonetaryField(verbose_name=u"变动后赠送金额", required=True)
    # 充值订单 1 退费订单 2 消费订单 3
    category = IntField(verbose_name=u"变动类型", choices=UserBalanceChangeCategory.choices())
    sourceObj = GenericLazyReferenceField(verbose_name=u'资金变动来源', required=True)
    dateTimeAdded = DateTimeField(verbose_name=u"变动时间", default=datetime.datetime.now)

    @cached_property
    def source(self):
        return self.sourceObj.fetch()

    @property
    def beforeBalance(self):
        return self.bAmount + self.bBestowAmount

    @property
    def afterBalance(self):
        return self.aBestowAmount + self.aAmount

    def to_dict(self):
        data = {
            "id": str(self.id),
            "category": self.category,
            "beforeBalance": self.beforeBalance,
            "afterBalance": self.afterBalance,
            "dateTimeAdded": self.dateTimeAdded.strftime("%Y-%m-%d %H:%M:%S"),
            "sourceId": str(self.sourceObj.id)
        }

        return data


class UserBalanceLog(BalanceLog):
    """
    用户账户余额变化记录
    """
    openId = StringField(verbose_name=u"资金主体标识", required=True)
    productAgentId = StringField(verbose_name=u"平台标识", required=True)

    @classmethod
    def consume(cls, user, afterAmount, afterBestowAmount, consumeAmount, consumeBestowAmount, order):    # type: (MyUser, RMB, RMB, RMB, RMB, ConsumeRecord) -> UserBalanceLog
        return cls(
            openId=user.openId,
            productAgentId=user.productAgentId,
            bAmount=afterAmount+consumeAmount,
            bBestowAmount=afterBestowAmount+consumeBestowAmount,
            aAmount=afterAmount,
            aBestowAmount=afterBestowAmount,
            sourceObj=order,
            category=UserBalanceChangeCategory.CONSUME
        ).save()

    @classmethod
    def recharge(cls, user, afterAmount, afterBestowAmount, chargeAmount, chargeBestowAmount, order):
        return cls(
            openId=user.openId,
            productAgentId=user.productAgentId,
            bAmount=afterAmount-chargeAmount,
            bBestowAmount=afterBestowAmount-chargeBestowAmount,
            aAmount=afterAmount,
            aBestowAmount=afterBestowAmount,
            sourceObj=order,
            category=UserBalanceChangeCategory.RECHARGE
        ).save()

    @classmethod
    def refund(cls, user, afterAmount, afterBestowAmount, refundAmount, refundBestowAmount, order):
        return cls(
            openId=user.openId,
            productAgentId=user.productAgentId,
            bAmount=afterAmount-refundAmount,
            bBestowAmount=afterBestowAmount-refundBestowAmount,
            aAmount=afterAmount,
            aBestowAmount=afterBestowAmount,
            sourceObj=order,
            category=UserBalanceChangeCategory.REFUND
        ).save()

    @classmethod
    def get_logs(cls, user, pageIndex, pageSize):   # type:(MyUser, int, int) -> QuerySet
        return cls.objects.filter(
            openId=user.openId,
            productAgentId=user.productAgentId
        ).skip((pageIndex-1)*pageSize).limit(pageSize)


class CardBalanceLog(BalanceLog):
    cardId = StringField(verbose_name=u"资金主体标识", required=True)
    openId = StringField(verbose_name=u"卡的持有人", required=True)

    @classmethod
    def consume(cls, card, afterAmount, afterBestowAmount, consumeAmount, consumeBestowAmount, order):  # type: (Card, RMB, RMB, RMB, RMB, ConsumeRecord) -> UserBalanceLog
        return cls(
            cardId=str(card.id),
            openId=card.openId,
            bAmount=afterAmount + consumeAmount,
            bBestowAmount=afterBestowAmount + consumeBestowAmount,
            aAmount=afterAmount,
            aBestowAmount=afterBestowAmount,
            sourceObj=order,
            category=UserBalanceChangeCategory.CONSUME
        ).save()

    @classmethod
    def recharge(cls, card, afterAmount, afterBestowAmount, chargeAmount, chargeBestowAmount, order):
        return cls(
            cardId=str(card.id),
            openId=card.openId,
            bAmount=afterAmount - chargeAmount,
            bBestowAmount=afterBestowAmount - chargeBestowAmount,
            aAmount=afterAmount,
            aBestowAmount=afterBestowAmount,
            sourceObj=order,
            category=UserBalanceChangeCategory.RECHARGE
        ).save()

    @classmethod
    def refund(cls, card, afterAmount, afterBestowAmount, refundAmount, refundBestowAmount, order):
        return cls(
            cardId=str(card.id),
            openId=card.openId,
            bAmount=afterAmount - refundAmount,
            bBestowAmount=afterBestowAmount - refundBestowAmount,
            aAmount=afterAmount,
            aBestowAmount=afterBestowAmount,
            sourceObj=order,
            category=UserBalanceChangeCategory.REFUND
        ).save()

    @classmethod
    def get_logs(cls, card, pageIndex, pageSize):
        return cls.objects.filter(
            cardId=str(card.id)
        ).skip((pageIndex - 1) * pageSize).limit(pageSize)