399 lines
14 KiB
Python
399 lines
14 KiB
Python
import re
|
|
from django.utils import timezone
|
|
from django.contrib.auth.hashers import make_password
|
|
from rest_framework import serializers
|
|
|
|
from accounts.models import (
|
|
AppVersion,
|
|
IAmPrincipal,
|
|
IAmPrincipalExtendedData,
|
|
IAmPrincipalType,
|
|
# IAmPrincipalKYCDetails,
|
|
)
|
|
|
|
from manage_events.models import EventInteractionType, EventPrincipalInteraction, FreeUsageFeatureLimit, PrincipalPreference
|
|
from manage_referrals.models import (
|
|
ReferralCode,
|
|
ReferralRecord,
|
|
)
|
|
from goodtimes import constants, date_utils
|
|
from manage_subscriptions.models import PrincipalSubscription, SubscriptionStatus
|
|
|
|
|
|
def clean_phone(number: str):
|
|
"""Validates number starts with +91 or 0, then 10 digits"""
|
|
number_pattern = re.compile(r"^(?:\+91|0)\d{10}$")
|
|
result = number_pattern.match(number)
|
|
if not result:
|
|
raise serializers.ValidationError({"phone_no": constants.PHONE_NUMBER_INVALID})
|
|
if number.startswith("0"):
|
|
return "+91" + number[1:]
|
|
return number
|
|
|
|
|
|
# class PhoneSerializer(serializers.Serializer):
|
|
# phone_no = serializers.CharField(max_length=15, required=True)
|
|
|
|
# def validate(self, attrs):
|
|
# phone_no = attrs.get("phone_no")
|
|
# cleaned_number = clean_phone(phone_no)
|
|
# attrs["phone_no"] = cleaned_number
|
|
# return super().validate(attrs)
|
|
|
|
|
|
class EmailSerializer(serializers.Serializer):
|
|
email = serializers.EmailField(
|
|
required=True,
|
|
)
|
|
principal_type = serializers.CharField(required=True, write_only=True)
|
|
|
|
def validate_principal_type_name(self, value):
|
|
"""
|
|
Check that the principal_type_name corresponds to a valid IAmPrincipalType.
|
|
"""
|
|
if not IAmPrincipalType.objects.filter(name=value).exists():
|
|
raise serializers.ValidationError("Invalid principal type name.")
|
|
return value
|
|
|
|
|
|
class BasePasswordSerializer(serializers.Serializer):
|
|
confirm_password = serializers.CharField(max_length=20, write_only=True)
|
|
|
|
def validate(self, attrs):
|
|
password = attrs.get("password")
|
|
confirm_password = attrs.pop("confirm_password", None)
|
|
|
|
if password != confirm_password:
|
|
raise serializers.ValidationError(
|
|
{"confirm_password": "Password do not match"}
|
|
)
|
|
|
|
return super().validate(attrs)
|
|
|
|
def update(self, instance, validated_data):
|
|
new_password = validated_data.get("password")
|
|
if new_password:
|
|
instance.password = make_password(new_password)
|
|
# instance.set_password(new_password)
|
|
instance.save()
|
|
return instance
|
|
|
|
|
|
class RegistrationSerializer(BasePasswordSerializer, serializers.ModelSerializer):
|
|
# email = serializers.EmailField(
|
|
# required=True,
|
|
# )
|
|
class Meta:
|
|
model = IAmPrincipal
|
|
fields = ["first_name", "last_name", "email", "password", "confirm_password"]
|
|
extra_kwargs = {
|
|
"first_name": {"required": True},
|
|
"last_name": {"required": True},
|
|
"email": {"required": True},
|
|
}
|
|
|
|
# def validate(self, attrs):
|
|
# email = attrs.get("email")
|
|
|
|
# # Check if the email is already associated with any user
|
|
# user_with_email = IAmPrincipal.objects.filter(email=email).first()
|
|
|
|
# if user_with_email:
|
|
# raise serializers.ValidationError({"email": [constants.EMAIL_EXISTS]})
|
|
# # # Check if the user has a different phone number
|
|
# # if user_with_email.phone_no != phone_no:
|
|
# # raise serializers.ValidationError({"email": [constants.EMAIL_EXISTS]})
|
|
|
|
# return attrs
|
|
|
|
def update(self, instance, validated_data):
|
|
# update prinicpal instance fiedls based on the validation data
|
|
instance.first_name = validated_data.get("first_name", instance.first_name)
|
|
instance.last_name = validated_data.get("last_name", instance.last_name)
|
|
instance.email = validated_data.get("email", instance.email)
|
|
instance.username = validated_data.get("email", instance.email)
|
|
# Set the new password (if provided) correctly using set_password method
|
|
if "password" in validated_data:
|
|
new_password = validated_data["password"]
|
|
print("new_password serializers: ", new_password)
|
|
instance.set_password(
|
|
new_password
|
|
) # Correctly use set_password without assignment
|
|
|
|
instance.save()
|
|
return instance
|
|
|
|
|
|
class RegistrationPasswordSerializer(
|
|
BasePasswordSerializer, serializers.ModelSerializer
|
|
):
|
|
class Meta:
|
|
model = IAmPrincipal
|
|
fields = ["email", "password", "confirm_password"]
|
|
|
|
|
|
class PasswordResetSerializer(BasePasswordSerializer, serializers.ModelSerializer):
|
|
class Meta:
|
|
model = IAmPrincipal
|
|
fields = ["password", "confirm_password"]
|
|
|
|
|
|
from phonenumbers import parse, phonenumberutil, NumberParseException
|
|
|
|
|
|
class ProfileSerializer(serializers.ModelSerializer):
|
|
profile_photo = serializers.ImageField(required=False)
|
|
principal_type_name = serializers.SerializerMethodField(read_only=True)
|
|
email = serializers.CharField(read_only=True)
|
|
is_active = serializers.BooleanField(read_only=True)
|
|
phone_no = serializers.CharField(required=True)
|
|
|
|
class Meta:
|
|
model = IAmPrincipal
|
|
fields = [
|
|
"principal_type",
|
|
"principal_type_name",
|
|
"profile_photo",
|
|
"player_id",
|
|
"first_name",
|
|
"last_name",
|
|
'business_name',
|
|
"phone_no",
|
|
"email",
|
|
"linkedin_profile",
|
|
"youtube_profile",
|
|
"facebook_profile",
|
|
"instagram_profile",
|
|
"twitter_profile",
|
|
"website",
|
|
"is_active",
|
|
]
|
|
|
|
# def validate_phone_no(self, value):
|
|
# try:
|
|
# # Parse the phone number
|
|
# phone_number = parse(value)
|
|
# # Check for validity
|
|
# if not phonenumberutil.is_valid_number(phone_number):
|
|
# raise serializers.ValidationError('Please enter a valid phone number.')
|
|
# return value
|
|
# except NumberParseException:
|
|
# raise serializers.ValidationError('The phone number format is invalid.')
|
|
|
|
def update(self, instance, validated_data):
|
|
instance.profile_photo = validated_data.get(
|
|
"profile_photo", instance.profile_photo
|
|
)
|
|
instance.first_name = validated_data.get("first_name", instance.first_name)
|
|
instance.last_name = validated_data.get("last_name", instance.last_name)
|
|
return super().update(instance, validated_data)
|
|
|
|
def get_image_url(self, obj, field_name, request):
|
|
image_field = getattr(obj, field_name)
|
|
if image_field:
|
|
return request.build_absolute_uri(image_field.url)
|
|
return ""
|
|
|
|
def get_principal_type_name(self, obj):
|
|
return obj.principal_type.name if obj.principal_type else None
|
|
|
|
def to_representation(self, instance):
|
|
data = super().to_representation(instance)
|
|
request = self.context.get("request")
|
|
data["profile_photo"] = self.get_image_url(instance, "profile_photo", request)
|
|
return data
|
|
|
|
class ProfileExtendedDataSerializer(serializers.ModelSerializer):
|
|
invite_count = serializers.SerializerMethodField(read_only=True)
|
|
principal_type_name = serializers.SerializerMethodField(read_only=True)
|
|
has_active_subscription = serializers.SerializerMethodField(read_only=True)
|
|
preference = serializers.SerializerMethodField(read_only=True)
|
|
principal_preference_count = serializers.SerializerMethodField(read_only=True)
|
|
going_events_count = serializers.SerializerMethodField(read_only=True)
|
|
interested_events_count = serializers.SerializerMethodField(read_only=True)
|
|
feature_limit = serializers.SerializerMethodField(read_only=True)
|
|
|
|
class Meta:
|
|
model = IAmPrincipal
|
|
fields = [
|
|
"principal_type_name",
|
|
"invite_count",
|
|
"register_complete",
|
|
"has_active_subscription",
|
|
"preference",
|
|
"principal_preference_count",
|
|
"going_events_count",
|
|
"interested_events_count",
|
|
"feature_limit"
|
|
]
|
|
|
|
def get_going_events_count(self, obj):
|
|
return EventPrincipalInteraction.objects.filter(
|
|
principal=obj, status=EventInteractionType.GOING
|
|
).count()
|
|
|
|
def get_interested_events_count(self, obj):
|
|
return EventPrincipalInteraction.objects.filter(
|
|
principal=obj, status=EventInteractionType.INTERESTED
|
|
).count()
|
|
|
|
def get_invite_count(self, obj):
|
|
if obj:
|
|
return ReferralRecord.get_invite_count(obj)
|
|
return 0
|
|
|
|
def get_principal_type_name(self, obj):
|
|
return obj.principal_type.name if obj.principal_type else None
|
|
|
|
def get_preference(self, obj):
|
|
return PrincipalPreference.objects.filter(principal=obj).exists()
|
|
|
|
def get_principal_preference_count(self, obj):
|
|
principal_preference = PrincipalPreference.objects.filter(principal=obj).first()
|
|
if principal_preference:
|
|
categories = principal_preference.preferred_categories.all()
|
|
return categories.count()
|
|
return 0
|
|
|
|
def get_has_active_subscription(self, obj):
|
|
subscription_status = {
|
|
"has_active_subscription": False,
|
|
"in_grace_period": False,
|
|
"grace_period_end_date": None,
|
|
"subscription_id": None,
|
|
}
|
|
today = timezone.now().date()
|
|
|
|
# Attempt to find the active subscription with the furthest grace_period_end_date
|
|
latest_subscription = PrincipalSubscription.get_principal_subscription(obj)
|
|
|
|
print(f"subscrition record {latest_subscription}")
|
|
|
|
if latest_subscription:
|
|
subscription_status["subscription_id"] = (
|
|
latest_subscription.stripe_subscription_id
|
|
)
|
|
# Check if we're within the grace period
|
|
if today <= latest_subscription.grace_period_end_date:
|
|
subscription_status["has_active_subscription"] = (
|
|
today <= latest_subscription.end_date
|
|
)
|
|
subscription_status["in_grace_period"] = (
|
|
latest_subscription.end_date
|
|
< today
|
|
<= latest_subscription.grace_period_end_date
|
|
)
|
|
subscription_status["grace_period_end_date"] = (
|
|
latest_subscription.grace_period_end_date
|
|
)
|
|
|
|
return subscription_status
|
|
|
|
def get_feature_limit(self, obj):
|
|
from manage_events.api.serializers import FreeUsageFeatureLimitSerializer
|
|
obj = FreeUsageFeatureLimit.objects.first()
|
|
return FreeUsageFeatureLimitSerializer().to_representation(obj)
|
|
|
|
# class PrincipalKYCDetailsSerializer(serializers.ModelSerializer):
|
|
# aadhar_front_image = serializers.ImageField(required=False)
|
|
# aadhar_back_image = serializers.ImageField(required=False)
|
|
# pan_image = serializers.ImageField(required=False)
|
|
|
|
# class Meta:
|
|
# model = IAmPrincipalKYCDetails
|
|
# fields = [
|
|
# "aadhar_front_image",
|
|
# "aadhar_back_image",
|
|
# "aadhar_number",
|
|
# "is_aadhar_verified",
|
|
# "pan_image",
|
|
# "pan_number",
|
|
# "is_pan_verified",
|
|
# "account_no",
|
|
# "bank_name",
|
|
# "branch_name",
|
|
# "ifsc_code",
|
|
# ]
|
|
|
|
# def create(self, validated_data):
|
|
# # Extract and set the principal (user) from the request context
|
|
# validated_data["principal"] = self.context.get("request").user
|
|
|
|
# return super(PrincipalKYCDetailsSerializer, self).create(validated_data)
|
|
|
|
# def get_image_url(self, obj, field_name, request):
|
|
# image_field = getattr(obj, field_name)
|
|
# if image_field:
|
|
# return request.build_absolute_uri(image_field.url)
|
|
# return ""
|
|
|
|
# def to_representation(self, instance):
|
|
# data = super().to_representation(instance)
|
|
# request = self.context.get("request")
|
|
# if request:
|
|
# data["aadhar_front_image"] = self.get_image_url(
|
|
# instance, "aadhar_front_image", request
|
|
# )
|
|
# data["aadhar_back_image"] = self.get_image_url(
|
|
# instance, "aadhar_back_image", request
|
|
# )
|
|
# data["pan_image"] = self.get_image_url(instance, "pan_image", request)
|
|
# return data
|
|
|
|
|
|
class ReferralCodeSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = ReferralCode
|
|
fields = ["referral_code"]
|
|
|
|
|
|
class ReferralRecordSerializer(serializers.ModelSerializer):
|
|
name = serializers.SerializerMethodField()
|
|
join_at = serializers.SerializerMethodField()
|
|
|
|
class Meta:
|
|
model = ReferralRecord
|
|
fields = ["name", "join_at"]
|
|
|
|
def get_name(self, obj):
|
|
# Check if the referred_principal is set (not None) and get the full name
|
|
if obj.referred_principal:
|
|
return obj.referred_principal.get_full_name()
|
|
return None
|
|
|
|
def get_join_at(self, obj):
|
|
return date_utils.format_date_to_string(obj.created_on)
|
|
|
|
|
|
# added 's' to differentiate with Email Serializer
|
|
class EmailSerializers(serializers.Serializer):
|
|
email = serializers.EmailField(required=True)
|
|
# otp = serializers.CharField(required=True)
|
|
|
|
|
|
class ProfilePhotoSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = IAmPrincipal
|
|
fields = ("email", "profile_photo", "first_name")
|
|
|
|
|
|
class PlayerIDSerializer(serializers.Serializer):
|
|
player_id = serializers.CharField(max_length=255)
|
|
|
|
|
|
class AppVersionSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = AppVersion
|
|
fields = [
|
|
"app_type",
|
|
"version",
|
|
"force_upgrade",
|
|
"recommend_upgrade",
|
|
]
|
|
|
|
|
|
class IAmPrincipalExtendedDataSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = IAmPrincipalExtendedData
|
|
fields = "__all__"
|