序列化第三张表的数据

import logging
import re
import json
import datetime
# from cryptography.utils import cached_property
from django.utils.functional import cached_property

from django.db.models import Q, Sum, Count
from rest_framework import serializers
from rest_framework import exceptions
from xqcircle.models import CircleUser, CityOfCircle, Circle, Circle2CircleUser, Dynamic, GroupBuy, Conversation, \
    Message, Config, GroupBuyForm, RecommRules, Like, CutKnife, GrouopOwner, Recommend, RealUserInformation, \
    AcademicCertificateRecord, Crowdordering, Order, Matchmaker, IdentifyingCode, MatchmakerAreaConfig, \
    IncomeAndExpenditure
from xqcircle import constants
from xqcircle import utils
from django.conf import settings
from xqcircle import tasks as ts

logger = logging.getLogger()


class CircleUserListSerializer(serializers.ListSerializer):
    @property
    def data(self):
        ret = super(CircleUserListSerializer, self).data
        for _ in ret:
            photos_str = ''.join(_['photos']).strip(',')
            if not photos_str:
                _['photos'] = []
            else:
                _['photos'] = photos_str.split(',')
        return ret


class CircleUserSerializer(serializers.ModelSerializer):
    class Meta:
        model = CircleUser
        list_serializer_class = CircleUserListSerializer
        # fields = "__all__"
        exclude = ['app_id', 'session_key', 'visible_quantity', 'user_status', 'open_id', 'open_gid',
                   'member_expire_time', 'last_login_time', 'last_city', 'create_time']

    # phone = serializers.CharField(max_length=11, required=True, error_messages={
    #     'max_length': 'Phone number length exceeds 11',
    #     'required': "Phone value can not be empty"
    # })
    # career = serializers.CharField(max_length=128, required=True, error_messages={
    #     'max_length': "Career value length exceeds 128",
    #     'required': "Career value can not be empty"
    # })
    # child_introduction = serializers.CharField(max_length=140, required=True,
    #                                            error_messages={
    #                                                'max_length': "Child_introduction value length exceeds 140",
    #                                                'required': "Child_introduction value can not be empty"
    #                                            })
    marriage = serializers.SerializerMethodField()
    spouse_description = serializers.CharField(max_length=140, required=False, allow_blank=True,
                                               error_messages={
                                                   'max_length': "Spouse_description value length exceeds 140",
                                               })

    # photos = serializers.ListField(required=True, error_messages={
    #     'required': "Photos value can not be empty"
    # })

    def get_marriage(self, obj):
        return constants.MARITAL_STATUS[obj.marriage]

    # def validate_phone(self, attrs):
    #     r = re.compile(r"^1((3[0-9])|(4[5,7])|(5[0-3,5-9])|(7[0,3,5-8])|(8[0-9])|66|98|99|47)\d{8}")
    #     if not isinstance(attrs, str):
    #         raise exceptions.ValidationError("Phone number type error")
    #     if not r.match(attrs):
    #         raise exceptions.ValidationError("Phone number is error")
    #     return attrs
    #
    # def validate_career(self, attrs):
    #     if not isinstance(attrs, str):
    #         raise exceptions.ValidationError("Career value type error")
    #     return attrs
    #
    # def validate_child_introduction(self, attrs):
    #     if not isinstance(attrs, str):
    #         raise exceptions.ValidationError("Child_introduction value type error")
    #     return attrs

    # def validate_photos(self, attrs):
    #     if not isinstance(attrs, list):
    #         raise exceptions.ValidationError("Photos value type error")
    #     if not attrs:
    #         raise exceptions.ValidationError("Photos value can not be empty")
    #     url_complie = re.compile(r'(http|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?')
    #     for _ in attrs:
    #         if not url_complie.match(_):
    #             raise exceptions.ValidationError("Photo url is error")
    #     return attrs

    @property
    def data(self):
        ret = super(CircleUserSerializer, self).data
        if isinstance(ret, dict):
            photos_str = ''.join(ret['photos']).strip(',')
            if not photos_str:
                ret['photos'] = []
            else:
                ret['photos'] = photos_str.split(',')
        return ret


class CircleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Circle
        fields = ('id', 'circle_name', 'member_number', 'heat', 'dynamic_number', 'dynamics', 'advertising',
                  'circle_info', 'single_buy_by_android', 'joined', 'members', 'slogan', 'link_path')

    members = serializers.SerializerMethodField()
    dynamics = serializers.SerializerMethodField()
    advertising = serializers.SerializerMethodField()
    circle_info = serializers.SerializerMethodField()
    joined = serializers.SerializerMethodField()
    slogan = serializers.SerializerMethodField()
    link_path = serializers.SerializerMethodField()

    def get_members(self, obj):
        res = []
        host = Circle2CircleUser.objects.filter(circle_id=obj.id, user_type=0).values('user__career',
                                                                                      'user__avatar').first()
        if host:
            res.append(host)
        members = Circle2CircleUser.objects.filter(circle_id=obj.pk, user_type=1, user__card=True).values(
            'user__career',
            'user__avatar').order_by('-create_time')[:3]
        res.extend(members)
        return res

    def get_dynamics(self, obj):
        try:
            dynamics = Dynamic.objects.filter(circle_id=obj.id).order_by(
                '-weight_h')[:10]
            serializer = DynamicsSerializer(dynamics, many=True)
        except Dynamic.DoesNotExist:
            return []
        return serializer.data

    def get_advertising(self, obj):
        group_config = Config.objects.filter(itype='wechat_advertising', ikey='circle_{}'.format(obj.pk),
                                             ienable=1).values("ival")[0:2]

        try:
            return [json.loads(group['ival']) for group in group_config]
        except:
            logger.info("群广告配置错误")
            return []

    def get_circle_info(self, obj):
        """
        圈子介绍语，口号，标签信息
        """
        ikey = "circle_{}".format(obj.id)
        circle_config = Config.objects.filter(itype='group_advertising', ikey=ikey, ienable=1).order_by('-id').values(
            "ival").first()
        if not circle_config:
            logger.info('圈子 {} 缺少标签，介绍语等信息')
            return {}
        else:
            try:
                return json.loads(circle_config['ival'])
            except:
                logger.info("{} 圈子标签配置信息json解析错误".format(obj.id))
                return {}

    def get_joined(self, obj):
        joined = Circle2CircleUser.objects.filter(circle_id=obj.id, user__card=True).values('user_id',
                                                                                            'user__career',
                                                                                            'user__avatar')[:20]
        return joined

        # place_of_residence = user.place_of_residence
        # logger.info('{} {}'.format(user.pk, place_of_residence))
        # if place_of_residence:
        #     try:
        #         provice, city = place_of_residence.split('-')
        #     except:
        #         logger.info('{} 格式错误'.format(place_of_residence))
        #         provice = city = '上海'
        # else:
        #     provice = city = '上海'
        # ikey = provice if provice in constants.MUNICIPALITY else city
        # banner_config = Config.objects.filter(itype='circle_banner', ikey=ikey)[0:3]
        # if not banner_config:
        #     logger.info('{} 缺少该城市的banner配置')
        #     banner_config = Config.objects.filter(itype='circle_banner', ikey='上海')[0:3]
        #
        # try:
        #     return [json.loads(item.ival) for item in banner_config]
        # except:
        #     logger.info('{} banner解析出错'.format(banner_config))
        #     return []

    def get_slogan(self, obj):
        """
        圈子介绍语，口号，标签信息
        """
        ikey = "circle_{}".format(obj.id)
        circle_config = Config.objects.filter(itype='group_advertising', ikey=ikey, ienable=1).order_by('-id').values(
            "ival").first()
        if not circle_config:
            logger.info('圈子 {} 缺少标签，介绍语等信息')
            return 0
        else:
            try:
                return json.loads(circle_config['ival'])['slogan']
            except:
                logger.info("{} 圈子标签配置信息json解析错误".format(obj.id))
                return 0

    def get_link_path(self, obj):
        group_config = utils.get_circle_group_config(obj.pk)
        if group_config:
            return group_config['link_path']
        else:
            return ''


class CirclesSerializer(serializers.ModelSerializer):
    intro = serializers.SerializerMethodField()  # 圈子介绍
    is_in = serializers.SerializerMethodField()  # 用户是否在圈内

    class Meta:
        model = Circle
        fields = (
            'id', 'circle_name', 'intro', 'circle_description', 'member_number', 'heat', 'dynamic_number', 'image',
            'is_in')

    def get_intro(self, obj):
        ikey = "circle_%d" % obj.id
        circle_config = Config.objects.filter(itype='group_advertising', ikey=ikey, ienable=1).order_by('-id').first()

        if circle_config:
            try:
                return json.loads(circle_config.ival)['intro']
            except:
                logger.info('{} 圈子解析配置出错')
                return ''
        else:
            logger.info('{} 圈子缺少相关标签配置'.format(obj.id))
            return ''

    def get_is_in(self, obj):
        return Circle2CircleUser.objects.filter(circle_id=obj.pk, user=self.context['request'].user).exists()


class GroupBuySerializer(serializers.ModelSerializer):
    class Meta:
        model = GroupBuy
        fields = '__all__'


class DynamicsListSerializer(serializers.ListSerializer):
    @property
    def data(self):
        ret = super(DynamicsListSerializer, self).data
        for _ in ret:
            _['user_id'] = _['user']
            _['circle_id'] = _['circle']
            del _['user']
            del _['circle']
            photos_str = ''.join(_['photos']).strip(',')
            if not photos_str:
                _['photos'] = []
            else:
                _['photos'] = photos_str.split(',')
        return ret


class DynamicsSerializer(serializers.ModelSerializer):
    class Meta:
        model = Dynamic
        list_serializer_class = DynamicsListSerializer
        exclude = ["create_time", "weight_a", "weight_v", "weight_h"]

    circle = serializers.IntegerField(source='circle.pk', error_messages={
        'required': "Circle value can not be empty",
    })
    user = serializers.CharField(source='user.pk', error_messages={
        'required': "User value can not be empty",
    })
    detail = serializers.CharField(max_length=140, required=False, allow_blank=True, error_messages={
        'max_length': "Detail value length exceeds 140",
    })
    photos = serializers.ListField(required=False)
    career = serializers.SerializerMethodField()
    avatar = serializers.SerializerMethodField()
    age = serializers.SerializerMethodField()
    gender = serializers.SerializerMethodField()

    def validate_circle(self, attrs):
        try:
            attrs = Circle.objects.get(pk=attrs)
        except Circle.DoesNotExist:
            raise exceptions.ValidationError("Circle value is error")
        return attrs

    def validate_user(self, attrs):
        try:
            attrs = CircleUser.objects.get(pk=attrs)
        except CircleUser.DoesNotExist:
            raise exceptions.ValidationError("User value is error")
        return attrs

    def validate_photos(self, attrs):
        if not isinstance(attrs, list):
            raise exceptions.ValidationError("Photos value type error")
        url_complie = re.compile('(http|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?')
        for _ in attrs:
            if not url_complie.match(_):
                raise exceptions.ValidationError("Photo url is error")
        return ','.join(attrs)

    def validate(self, attrs):
        if not attrs['detail'] and not attrs['photos']:
            raise exceptions.ValidationError("Detail and Photos cannot be empty at the same time")
        return attrs

    def get_career(self, obj):
        return obj.user.career

    def get_avatar(self, obj):
        return obj.user.avatar

    def get_age(self, obj):
        return obj.user.age

    def get_gender(self, obj):
        return obj.user.gender

    @property
    def data(self):
        ret = super(DynamicsSerializer, self).data
        if isinstance(ret, dict):
            ret['user_id'] = ret['user']
            ret['circle_id'] = ret['circle']
            photos_str = ''.join(ret['photos']).strip(',')
            if not photos_str:
                ret['photos'] = []
            else:
                ret['photos'] = photos_str.split(',')
            del ret['user']
            del ret['circle']
        return ret

    def create(self, validated_data):
        validated_data['circle'] = validated_data['circle']['pk']
        validated_data['user'] = validated_data['user']['pk']
        return Dynamic.objects.create(**validated_data)


class ConversationSerializer(serializers.ModelSerializer):
    class Meta:
        model = Conversation
        # list_serializer_class = DynamicsListSerializer
        fields = '__all__'

    user_1_info = serializers.SerializerMethodField()
    user_2_info = serializers.SerializerMethodField()
    last_message = serializers.SerializerMethodField()
    unread_count = serializers.SerializerMethodField()
    circle_id = serializers.SerializerMethodField()
    circle_name = serializers.SerializerMethodField()
    fake_uid = serializers.SerializerMethodField()

    def get_user_1_info(self, obj):
        try:
            res = CircleUser.objects.filter(user_id=obj.user_1_id).values('avatar', 'age', 'career').first()
        except CircleUser.DoesNotExist:
            return {}
        return res

    def get_user_2_info(self, obj):
        try:
            res = CircleUser.objects.filter(user_id=obj.user_2_id).values('avatar', 'age', 'career').first()
        except CircleUser.DoesNotExist:
            return {}
        return res

    def get_last_message(self, obj):
        if self.context['request'].user.pk == obj.user_1_id:
            return obj.last_message or ''
        else:
            return obj.last_message_2 or ''

    def get_unread_count(self, obj):
        if self.context['request'].user.pk == obj.user_1_id:
            send_user_id = obj.user_2_id
            receive_user_id = obj.user_1_id
        else:
            send_user_id = obj.user_1_id
            receive_user_id = obj.user_2_id

        cur_time = datetime.datetime.now()
        s_time = cur_time - datetime.timedelta(days=7)
        count = Message.objects.filter(send_user_id=send_user_id, receive_user_id=receive_user_id, is_effective=True,
                                       state=False).filter(create_time__range=(s_time, cur_time)).count()
        return min(99, count) or ''

    def get_circle_id(self, obj):
        if self.context['request'].user.pk == obj.user_1_id:
            user_id = obj.user_2_id
        else:
            user_id = obj.user_1_id

        circle = utils.get_most_expensive_circle_belong(user_id)
        if circle:
            return circle.pk
        else:
            return -1

    def get_circle_name(self, obj):
        if self.context['request'].user.pk == obj.user_1_id:
            user_id = obj.user_2_id
        else:
            user_id = obj.user_1_id

        circle = utils.get_most_expensive_circle_belong(user_id)
        if circle:
            return circle.circle_name
        else:
            return ''

    def get_fake_uid(self, obj):
        if self.context['request'].user.pk == obj.user_1_id:
            user_id = obj.user_2_id
        else:
            user_id = obj.user_1_id
        return utils.encrypt_uid(user_id)


class MessageSerializer(serializers.ModelSerializer):
    class Meta:
        model = Message
        # list_serializer_class = DynamicsListSerializer
        fields = '__all__'


class CityOfCircleSerializer(serializers.ModelSerializer):
    class Meta:
        model = CityOfCircle
        # list_serializer_class = DynamicsListSerializer
        # fields = '__all__'
        fields = ('city_name', 'id', 'parent_id')


class ConfigsSerializer(serializers.ModelSerializer):
    class Meta:
        model = Config
        # list_serializer_class = DynamicsListSerializer
        fields = '__all__'


class GroupBuyFormSerializer(serializers.ModelSerializer):
    class Meta:
        model = GroupBuyForm
        # list_serializer_class = DynamicsListSerializer
        fields = '__all__'


class RecommStandardSerializer(serializers.ModelSerializer):
    class Meta:
        model = RecommRules
        fields = '__all__'


class UserLikeSerializer(serializers.ModelSerializer):
    conversation_id = serializers.SerializerMethodField()

    def get_conversation_id(self, obj):
        conversation = Conversation.objects.filter(
            Q(user_1_id=obj.from_user_id, user_2_id=obj.to_user_id) | Q(user_1_id=obj.from_user_id,
                                                                        user_2_id=obj.to_user_id)).first()
        if conversation and obj.is_like:
            return conversation.pk
        return -1

    class Meta:
        model = Like
        fields = ('to_user_id', 'is_like', 'conversation_id')


class LikeMeUserSerizlizer(serializers.ModelSerializer):
    age = serializers.SerializerMethodField()

    class Meta:
        model = CircleUser
        fields = ('user_id', 'open_id', 'create_time', 'gender', 'age', 'place_of_residence', 'education', 'avatar',
                  'career', 'card')

    def get_age(self, obj):
        return obj.age[0:4]


class MembersSerializer(serializers.ModelSerializer):
    class Meta:
        model = CircleUser
        fields = ('user_id', 'open_id', 'gender', 'age', 'place_of_residence', 'education', 'avatar', 'career', 'card')


class ProfileSerializer(serializers.ModelSerializer):
    like_count = serializers.SerializerMethodField()  # 我喜欢的用户数量
    be_like_count = serializers.SerializerMethodField()  # 喜欢我的用户数量
    info_degree = serializers.SerializerMethodField()  # 个人资料完整度
    intro_degree = serializers.SerializerMethodField()  # 我的介绍完整度
    claim_id = serializers.SerializerMethodField()
    cut_group = serializers.SerializerMethodField()
    is_real = serializers.SerializerMethodField()  # 是否实名
    is_phone_auth = serializers.SerializerMethodField()  # 是否手机号认证
    is_full = serializers.SerializerMethodField()  # 必填资料是否全部填写
    is_union_id = serializers.SerializerMethodField()  # 是否获取 union_id
    user_type = serializers.SerializerMethodField()  # 用户类型
    fake_uid = serializers.SerializerMethodField()  # 虚拟用户ID
    is_education = serializers.SerializerMethodField()  # 是否学历认证
    user_group_type = serializers.SerializerMethodField()  # 是否是红娘

    class Meta:
        model = CircleUser
        fields = (
            'user_id', 'career', 'avatar', 'like_count', 'be_like_count', 'total_money', 'info_degree', 'intro_degree',
            'wechat_id', 'claim_id', 'cut_group', 'is_real', 'is_phone_auth', 'gender', 'age', 'place_of_residence',
            'is_full', 'is_wechat_visible', 'is_union_id', 'user_type', 'fake_uid', 'is_education', 'user_group_type')

    def get_like_count(self, obj):
        return Like.objects.filter(from_user_id=obj.user_id, is_like=True).count()

    def get_be_like_count(self, obj):
        user_type = utils.get_user_membership_type(obj)
        if user_type == 0:
            return Like.objects.filter(to_user_id=obj.user_id, is_like=True).count()
        elif utils.is_required_information(obj):
            # 如果未填写基本资料，则为0
            return constants.VISITOR_NUMBER
        else:
            return 0

    def get_info_degree(self, obj):
        """个人资料完整度
        基本信息：六项，每一项填写权重为10。
        性别、出生年月、学历、居住地、职业、身高。
        补充信息：五项，每一项填写权重为8。
        户籍、住房情况、月收入、婚姻状况、车辆状况。
        """
        options = (
            'gender', 'age', 'education', 'place_of_residence', 'career', 'height', 'residence', 'house',
            'monthly_salary', 'marriage', 'car')
        proportion = (10,) * 6 + (8,) * 5

        return sum(proportion[index] if getattr(obj, choice) else 0 for index, choice in enumerate(options))

    def get_intro_degree(self, obj):
        """我的介绍完整度
        文字描述：每一项填写权重为10。
        我的介绍、兴趣爱好、感情观、心仪的TA
        上传生活照：1张照片权重为20，最多累计权重为 60 。
        即用户上传3张照片或9张照片，总权重最多为60。
        """
        options = ('child_introduction', 'hobbies', 'emotional_view', 'spouse_description')
        proportion = (10,) * 4

        photos = obj.photos.split(',') if obj.photos else []

        # 生活照得分
        photos_degree = min(60, 20 * sum(1 for p in photos if p.strip()))

        return sum(
            proportion[index] if getattr(obj, choice) else 0 for index, choice in enumerate(options)) + photos_degree

    def get_claim_id(self, obj):
        group_owner = GrouopOwner.objects.filter(user_id=obj.user_id).first()

        return group_owner.pk if group_owner else ''

    def get_cut_group(self, obj):
        return CutKnife.objects.filter(user_id=obj.user_id, state=1, expire_time__gte=datetime.datetime.now()).values(
            'id', 'circle_id', 'circle_name', 'expire_time')

    def get_is_real(self, obj):
        # return all([obj.real_name, obj.id_card])
        return RealUserInformation.objects.filter(user_id=obj.pk).exists()

    def get_is_phone_auth(self, obj):
        return obj.phone != ''

    def get_is_full(self, obj):
        return all([obj.gender, obj.age, obj.education, obj.place_of_residence, obj.height, obj.career])

    def get_is_union_id(self, obj):
        return True if obj.union_id else False

    def get_user_type(self, obj):
        return utils.get_user_membership_type(obj)

    def get_fake_uid(self, obj):
        return utils.encrypt_uid(obj.pk)

    def get_is_education(self, obj):
        education_record = AcademicCertificateRecord.objects.filter(user_id=obj.pk)
        if education_record.filter(state=1).exists():
            return 1
        else:
            education = education_record.order_by('-created_time').first()
            if not education:
                return 3
            else:
                return education.state

    def get_user_group_type(self, obj):
        return 1 if Matchmaker.objects.filter(user_id=obj.pk, state=1).exists() else 0


class RecommUserSerializer(serializers.ModelSerializer):
    photos = serializers.SerializerMethodField()
    is_like = serializers.SerializerMethodField()  # 用户是否喜欢当前嘉宾
    car = serializers.SerializerMethodField()
    house = serializers.SerializerMethodField()
    gender = serializers.SerializerMethodField()
    circle_id = serializers.SerializerMethodField()
    circle_name = serializers.SerializerMethodField()
    is_education = serializers.SerializerMethodField()

    class Meta:
        model = Recommend
        fields = (
            "recomm_user_id", "photos", "career", "age", "height", "gender", "place_of_residence", "education",
            "annual_salary", "car", "house", "is_like", "circle_id", "circle_name", "is_education")

    def get_photos(self, obj):
        if obj.photos:
            return obj.photos.split(',')

    def get_car(self, obj):
        return '有车' if obj.car > 0 else '没车'

    def get_house(self, obj):
        # return '有房' if obj.house > 0 else '没房'
        return constants.HOUSE_STATUS[obj.house]

    def get_is_like(self, obj):
        """
        判断用户是否喜欢当前用户
        """
        if Like.objects.filter(from_user_id=obj.user_id, to_user_id=obj.recomm_user_id, is_like=True).exists():
            return True
        return False

    def get_gender(self, obj):
        return '男' if obj.gender == 1 else '女'

    def get_circle_id(self, obj):
        circle = utils.get_most_expensive_circle_belong(obj.recomm_user_id)
        if circle:
            return circle.pk
        else:
            return -1

    def get_circle_name(self, obj):
        circle = utils.get_most_expensive_circle_belong(obj.recomm_user_id)
        if circle:
            return circle.circle_name
        else:
            return ''

    def get_is_education(self, obj):
        return AcademicCertificateRecord.objects.filter(user_id=obj.recomm_user_id, state=1).exists()


class CardSerializer(serializers.ModelSerializer):
    info = serializers.SerializerMethodField()
    my_circle = serializers.SerializerMethodField()
    photos = serializers.SerializerMethodField()
    is_like = serializers.SerializerMethodField()
    age = serializers.SerializerMethodField()
    is_real = serializers.SerializerMethodField()
    fake_uid = serializers.SerializerMethodField()  # 虚拟用户ID
    is_education = serializers.SerializerMethodField()  # 是否学历认证

    class Meta:
        model = CircleUser
        fields = (
            'photos', 'career', 'gender', 'user_id', 'place_of_residence', 'info', 'my_circle', 'child_introduction',
            'hobbies', 'emotional_view', 'spouse_description', 'is_like', 'age', 'education', 'is_real', 'fake_uid',
            'is_education')

    def get_info(self, obj):
        res = []
        marriage_choice = constants.MARITAL_STATUS
        if obj.marriage:
            res.append(marriage_choice[obj.marriage])

        age = obj.age[0:4]
        try:
            age = int(age)
        except:
            logger.info("{} 错误".format(obj.age))
            age = 0
        if age > 0:
            res.append('{}岁'.format(datetime.datetime.now().year - age))
        if obj.height > 0:
            res.append('{}cm'.format(obj.height))
        if obj.monthly_salary:
            res.append('月薪：{}'.format(obj.monthly_salary))
        if obj.car:
            res.append(obj.car)
        if obj.house:
            res.append(obj.house)
        if obj.career:
            res.append(obj.career)
        if obj.place_of_residence:
            res.append(obj.place_of_residence)
        return res

    def get_my_circle(self, obj):
        return Circle.objects.filter(C2Us__user_id=obj.pk).values('id', 'circle_name')

    def get_photos(self, obj):
        return obj.photos.split(',')

    def get_is_like(self, obj):
        """
        判断用户是否喜欢当前用户
        """
        host_id = self.context['request'].user.user_id
        if Like.objects.filter(from_user_id=host_id, to_user_id=obj.user_id, is_like=True).exists():
            return True
        return False

    def get_age(self, obj):
        return obj.age[0:4]

    def get_is_real(self, obj):
        # return all([obj.real_name, obj.id_card])
        return obj.user_status == 0 or RealUserInformation.objects.filter(user_id=obj.pk).exists()

    def get_fake_uid(self, obj):
        return utils.encrypt_uid(obj.pk)

    def get_is_education(self, obj):
        return AcademicCertificateRecord.objects.filter(user_id=obj.pk, state=1).exists()


class PurchaseSerializer(serializers.ModelSerializer):
    slogan = serializers.SerializerMethodField()
    attraction = serializers.SerializerMethodField()
    discount = serializers.SerializerMethodField()  # 折扣

    class Meta:
        model = Circle
        fields = (
            'id', 'circle_name', 'slogan', 'single_buy_by_android', 'attraction', 'discount')

    def get_slogan(self, obj):
        """
        圈子介绍语，口号，标签信息
        """
        ikey = "circle_{}".format(obj.id)
        circle_config = Config.objects.filter(itype='group_advertising', ikey=ikey, ienable=1).order_by('-id').values(
            "ival").first()
        if not circle_config:
            logger.info('圈子 {} 缺少标签，介绍语等信息')
            return 32
        else:
            try:
                return json.loads(circle_config['ival'])['slogan']
            except:
                logger.info("{} 圈子标签配置信息json解析错误".format(obj.id))
                return 32

    def get_discount(self, obj):
        user = self.context['request'].user
        if obj.single_buy_by_android >= user.total_money:
            return user.total_money
        else:
            return obj.single_buy_by_android

    def get_intro(self, obj):
        ikey = "circle_%d" % obj.id
        circle_config = Config.objects.filter(itype='group_advertising', ikey=ikey, ienable=1).order_by('-id').first()

        if circle_config:
            try:
                return json.loads(circle_config.ival)['intro']
            except:
                logger.info('{} 圈子解析配置出错')
                return ''
        else:
            logger.info('{} 圈子缺少相关标签配置'.format(obj.id))
            return ''

    def get_attraction(self, obj):
        ikey = "circle_%d" % obj.id
        circle_config = Config.objects.filter(itype='group_advertising', ikey=ikey, ienable=1).order_by('-id').first()

        if circle_config:
            try:
                return json.loads(circle_config.ival)['attraction']
            except:
                logger.info('{} 圈子解析配置出错')
                return ''
        else:
            logger.info('{} 圈子缺少相关标签配置'.format(obj.id))
            return ''


class CutKnifeSerializer(serializers.ModelSerializer):
    class Meta:
        model = CutKnife
        fields = ('id', 'expire_time')


class GzhCirclesSerializer(serializers.ModelSerializer):
    class Meta:
        model = Circle
        fields = (
            "id", "circle_name", "circle_description", "member_number", "heat", "dynamic_number",
            "single_buy_by_android",)


class CrowdorderingSerializer(serializers.ModelSerializer):
    class Meta:
        model = Crowdordering
        fields = (
            "expire_time", "is_participate", "is_source", "group_id", "group_type", "is_finish",
            "gap_number", "avatar", "join_number", "circle_id", "circle_name", "circle_description", "short_desc",
            "created_time", "remind", "link_path", "is_join_circle_other_group")

    expire_time = serializers.SerializerMethodField()
    is_participate = serializers.SerializerMethodField()
    # is_join = serializers.SerializerMethodField()
    is_source = serializers.SerializerMethodField()
    is_finish = serializers.SerializerMethodField()
    gap_number = serializers.SerializerMethodField()
    avatar = serializers.SerializerMethodField()
    join_number = serializers.SerializerMethodField()
    circle_name = serializers.SerializerMethodField()
    circle_description = serializers.SerializerMethodField()
    short_desc = serializers.SerializerMethodField()
    remind = serializers.SerializerMethodField()
    link_path = serializers.SerializerMethodField()
    is_join_circle_other_group = serializers.SerializerMethodField()

    def get_expire_time(self, obj):
        self._obj = obj
        self._user = self.context['request'].user
        return obj.over_time

    @cached_property
    def cached_get_is_participate(self):
        return (self._obj.sponsor_user_id == self._user.pk) or Order.objects.filter(user_id=self._user.pk, state=1,
                                                                                    group_buy_id=self._obj.group_id).exists()

    def get_is_participate(self, obj):
        return self.cached_get_is_participate

    def get_is_source(self, obj):
        """
        是否是拼单发起者
        """
        return self._user.pk == self._obj.sponsor_user_id

    @cached_property
    def cached_get_is_finish(self):
        # 当前对改拼单是否完成
        return utils.is_user_group_success(self._user, self._obj)

    def get_is_finish(self, obj):
        """
        拼单是否完成
        """
        return self.cached_get_is_finish

    @cached_property
    def cached_get_gap_number(self):
        # 返回问号头像的个数
        if self.cached_get_is_finish:
            return 0
        elif self._obj.group_type == 0:
            return utils.get_group_gap_number(self._obj) - (self.cached_get_is_participate and (
                    self._user.pk != self._obj.sponsor_user_id))
        else:
            return max(0, utils.get_group_gap_number(self._obj) - self.cached_real_join_number)

    def get_gap_number(self, obj):
        return self.cached_get_gap_number

    @cached_property
    def cached_get_avatar(self):
        return utils.get_group_show_avatar(self._user, self._obj)

    def get_avatar(self, obj):
        """
        返回需要展示的头像 ( 加上问号头像 )
        """
        return self.cached_get_avatar + [constants.QUESTION_MARK_AVATAR] * self.cached_get_gap_number

    @cached_property
    def cached_real_join_number(self):
        # 获取拼单真实参与用户
        return len(utils.get_group_join_user(self._obj)) + self._obj.group_type

    def get_join_number(self, obj):
        # 用户前端显示的参与用户数 (与头像数保持一致)
        return len(self.cached_get_avatar)

    @cached_property
    def cached_get_circle(self):
        return Circle.objects.get(pk=self._obj.circle_id)

    def get_circle_name(self, obj):
        return self.cached_get_circle.circle_name

    def get_circle_description(self, obj):
        return self.cached_get_circle.circle_description

    def get_short_desc(self, obj):
        return self.cached_get_circle.short_desc

    def get_remind(self, obj):
        return "如果超过拼单时间未成功拼单，已支付拼单金额将退还至原支付账户"

    def get_link_path(self, obj):
        group_config = utils.get_circle_group_config(obj.circle_id, is_force=True)
        if group_config:
            return group_config['link_path']
        else:
            return ''

    def get_is_join_circle_other_group(self, obj):
        """
        用户是否参与该圈子的拼单 或 已经进圈
        :param obj:
        :return:
        """
        if Circle2CircleUser.objects.filter(user_id=self._user.pk, circle_id=obj.circle_id) or Order.objects.filter(
                user_id=self._user.pk, circle_id=obj.circle_id, state=1, is_group=True).exists():
            return True
        else:
            return False


class IdentifyingCodeSerizliser(serializers.ModelSerializer):
    class Meta:
        model = IdentifyingCode
        fields = (
            'id',
            "user_id",
            'phone',
            'expired',
        )

    def create(self, validated_data):
        # logger.info('[create] validated_data=%s', validated_data)
        phone = validated_data['phone']

        r_code, r_expired = validated_data['code'], validated_data['expired']

        # 添加验证码白名单
        if phone in constants.PHONE_CODE_WHITELIST or settings.IS_DEV:
            r_code = '000000'
            r_expired = datetime.datetime(2099, 1, 1)

        record = IdentifyingCode.objects.create(user_id=self.context["request"].user.user_id, phone=phone,
                                                identifying_code=r_code,
                                                expired=r_expired)

        try:
            ts.send_message_async.delay(record.phone, record.identifying_code)
        except Exception as e:
            logger.info('[send_message_async] %s:%s %s', (phone, r_code, e))
        return record


class MatchmakerAreaConfigSerializer(serializers.ModelSerializer):
    class Meta:
        model = MatchmakerAreaConfig
        fields = (
            "id",
            "area",
            "money",
            "detail"
        )

    detail = serializers.SerializerMethodField()

    def get_detail(self, obj):
        try:
            detail = json.loads(obj.detail)
        except Exception:
            detail = {}
        return detail


class MatchmakerSerializer(serializers.ModelSerializer):
    class Meta:
        model = Matchmaker
        fields = (
            "user_id",
            "phone",
            "avatar",
            "place_of_residence",
            "crowdordering_royalty",
            "today_crowdordering_royalty",
            "inferior_num",
            "today_inferior_num"
        )

    crowdordering_royalty = serializers.SerializerMethodField()
    today_crowdordering_royalty = serializers.SerializerMethodField()
    inferior_num = serializers.SerializerMethodField()
    today_inferior_num = serializers.SerializerMethodField()

    def get_crowdordering_royalty(self, obj):
        money = IncomeAndExpenditure.objects.filter(user_id=obj.user_id, state=1, source=1).aggregate(
            total=Sum("operate_money"))
        return money["total"] if money and money["total"] else 0

    def get_today_crowdordering_royalty(self, obj):
        money = IncomeAndExpenditure.objects.filter(user_id=obj.user_id, state=1, source=1,
                                                    created_time__gte=datetime.date.today()).aggregate(
            total=Sum("operate_money"))
        return money["total"] if money and money["total"] else 0

    def get_inferior_num(self, obj):
        return IncomeAndExpenditure.objects.filter(user_id=obj.user_id, state=1, source=2).count()

    def get_today_inferior_num(self, obj):
        return IncomeAndExpenditure.objects.filter(user_id=obj.user_id, state=1, source=2,
                                                   created_time__gte=datetime.date.today()).count()

    @property
    def data(self):
        ret = super(MatchmakerSerializer, self).data
        result = {"errcode": 0, "detail": "success", "data": ret}
        return result