class CompanySerializer(serializers.ModelSerializer):
phone = PhoneNumberField()
tel = PhoneNumberField()
class Meta:
model = Company
fields = '__all__'
class TestAttendeeRegisterSerializer(AbstractRegistrationSerializer):
email = serializers.EmailField(required=False)
phone_number = PhoneNumberField(max_length=20, required=True)
def custom_signup(self, request, user):
super().custom_signup(request, user)
def get_cleaned_data(self):
cleaned_data = super().get_cleaned_data()
# case where phone is not required we need to auto generate phone number unique and save
cleaned_data.update({
'email':
self.validated_data.get('email', generate_dummy_email()),
'phone_number':
self.validated_data.get('phone_number')
})
return cleaned_data
def save(self, request):
adapter = get_adapter()
user = adapter.new_user(request)
self.cleaned_data = self.get_cleaned_data()
adapter.save_user(request, user, self)
self.custom_signup(request, user)
setup_user_email(request, user, [])
return user
class CustomRegisterSerializer(RegisterSerializer):
first_name = serializers.CharField(required=True, write_only=True)
last_name = serializers.CharField(required=True, write_only=True)
birth_date = serializers.CharField(required=True, write_only=True)
phone_number = PhoneNumberField(
required=True,
write_only=True,
validators=[
UniqueValidator(
queryset=Profile.objects.all(),
message=_(
"A user is already registered with this phone number."),
)
],
)
def get_cleaned_data_profile(self):
return {
"first_name": self.validated_data.get("first_name", ""),
"last_name": self.validated_data.get("last_name", ""),
"birth_date": self.validated_data.get("birth_date", ""),
"phone_number": self.validated_data.get("phone_number", ""),
}
def create_profile(self, user, validated_data):
user.first_name = self.validated_data.get("first_name")
user.last_name = self.validated_data.get("last_name")
user.save()
user.profile.birth_date = self.validated_data.get("birth_date")
user.profile.phone_number = self.validated_data.get("phone_number")
user.profile.save()
def custom_signup(self, request, user):
self.create_profile(user, self.get_cleaned_data_profile())
class ChangePhoneNumberSerializer(
ErrorDictMixin, AllowedMobilePrefixMixin, serializers.Serializer
):
phone_number = PhoneNumberField()
@property
def user(self):
return self.context['request'].user
def validate_phone_number(self, phone_number):
if self.user.phone_number == phone_number:
raise serializers.ValidationError(
_('The new phone number must be different than the old one.')
)
org = self.context['view'].organization
mobile_prefixes = org.radius_settings.allowed_mobile_prefixes_list
if not self.is_prefix_allowed(phone_number, mobile_prefixes):
raise serializers.ValidationError(
_('This international mobile prefix is not allowed.')
)
return phone_number
def save(self):
# we do not update the phone number of the user
# yet, tha will be done by the phone token validation view
# once the phone number has been validated
# at this point we flag the user as unverified again
self.user.registered_user.is_verified = False
self.user.registered_user.save()
class LoginSerializer(serializers.ModelSerializer):
password = serializers.CharField(style={'input_type': 'password'})
phone_number = PhoneNumberField(required=True)
class Meta:
model = Account
fields = ('phone_number', 'password')
class UserSerializer(serializers.ModelSerializer):
phone_number = PhoneNumberField(required=True)
new_password = serializers.CharField(write_only=True)
confirm_new_password = serializers.CharField(write_only=True)
class Meta:
model = User
fields = (
'id',
'display_name',
'phone_number',
'email',
'is_active',
'is_staff',
'is_superuser',
'new_password',
'confirm_new_password',
)
def validate(self, attrs):
if self.context['request'].method == "POST":
if attrs.get('new_password') != attrs.get('confirm_new_password'):
raise serializers.ValidationError({
"new_password":
_("Passwords are not equal."),
"confirm_new_password":
_("Passwords are not equal."),
})
attrs.pop('confirm_new_password')
attrs['password'] = attrs.pop('new_password')
return attrs
def create(self, validated_data):
return User.objects.create_user(**validated_data)
class UserSerializer(serializers.ModelSerializer):
"""Serializer for the user objects"""
location = serializers.PrimaryKeyRelatedField(
required=False,
queryset=Location.objects.all(),
allow_null=True
)
picture = serializers.ImageField(
max_length=None, use_url=True
)
phone = PhoneNumberField(required=False)
class Meta:
model = get_user_model()
fields = (
'id', 'email', 'name',
'phone', 'location', 'picture',
'date_created'
)
extra_kwargs = {
'id': {'read_only': True},
'email': {'read_only': True},
'name': {'read_only': True},
'date_created': {'read_only': True}
}
class PhoneVerificationSerializer(serializers.Serializer):
phone_number = PhoneNumberField()
session_token = serializers.CharField(required=True)
security_code = serializers.CharField(required=True)
def validate(self, attrs):
attrs = super().validate(attrs)
phone_number = attrs.get("phone_number", None)
security_code = attrs.get("security_code", None)
session_token = attrs.get("session_token", None)
phone_verification_service = PhoneVerificationService()
verification = phone_verification_service.validate_security_code(
security_code, phone_number, session_token)
if verification == phone_verification_service.SECURITY_CODE_INVALID:
raise CustomAPIException('Security code is not valid')
elif verification == phone_verification_service.SESSION_TOKEN_INVALID:
raise CustomAPIException('Session token is not valid')
elif verification == phone_verification_service.SECURITY_CODE_EXPIRED:
raise CustomAPIException('Security code has expired')
elif verification == phone_verification_service.SECURITY_CODE_VERIFIED:
raise CustomAPIException('Security code is already verified')
return attrs
class PhoneSerializer(serializers.ModelSerializer):
number = PhoneNumberField(required=True)
verification_code = serializers.CharField(required=False)
class Meta:
model = Phone
fields = (
'id',
'customer',
'number',
'verification_code',
'generated_at',
'confirmed',
)
read_only_fields = ('id', 'customer', 'generated_at', 'confirmed')
def validate(self, attrs):
if (verification_code := attrs.pop('verification_code',
None)) is not None:
if verification_code != self.instance.verification_code:
raise serializers.ValidationError(
{"verification_code": "Пин-код введен неверно"})
else:
attrs['confirmed'] = True
return attrs
class PhoneVerificationCodeSerializer(serializers.ModelSerializer):
"""
Base serializer for phone verification.
"""
phone_number = PhoneNumberField(
write_only=True,
error_messages={
'invalid':
_('Phone number must starts with + and contain only numbers.')
})
class Meta:
model = PhoneVerificationCode
def validate_phone_number(self, value):
"""
Check if phone exists and not verified.
"""
try:
self.phone = Phone.objects.only(
'user__id', 'phone_number',
'is_verified').select_related('user').get(phone_number=value)
if self.phone.is_verified:
raise serializers.ValidationError(
_('This phone number is already verified.'),
code=status.HTTP_400_BAD_REQUEST)
except Phone.DoesNotExist:
raise serializers.ValidationError(
_('This phone number is not in the database.'),
code=status.HTTP_404_NOT_FOUND)
return value
class PhoneDetailSerializer(serializers.ModelSerializer):
"""
Serializer for phone model.
"""
phone_number = PhoneNumberField(
validators=[
UniqueValidator(
queryset=Phone.objects.all(),
message=_('Someone is already using this phone number.'))
],
error_messages={
'invalid':
_('Phone number must starts with + and contain only numbers.')
})
class Meta:
model = Phone
fields = ('phone_number', )
def update(self, instance, validated_data):
"""
Set phone number as unverified on at update.
"""
instance.phone_number = validated_data.get('phone_number')
instance.is_verified = False
instance.save()
return instance
class PhoneListSerializer(serializers.ModelSerializer):
"""
Serializer for Phone model.
"""
phone_number = PhoneNumberField(
validators=[
UniqueValidator(
queryset=Phone.objects.all(),
message=_('Someone is already using this phone number.'))
],
error_messages={
'invalid':
_('Phone number must starts with + and contain only numbers.')
})
class Meta:
model = Phone
fields = '__all__'
extra_kwargs = {
'user': {
'read_only': True,
'default': serializers.CurrentUserDefault()
},
'is_verified': {
'read_only': True
}
}
class ReminderRequestSerializer(TrackingSerializer, ActionSerializer):
phone = PhoneNumberField(required=False)
zipcode = serializers.CharField(validators=[zip_validator])
state = serializers.ChoiceField(
choices=STATES, required=True, validators=[state_code_validator]
)
class Meta:
model = ReminderRequest
minimum_necessary_fields = [
"first_name",
"last_name",
"address1",
"city",
"state",
"zipcode",
"date_of_birth",
"email",
]
optional_fields = [
"address2",
"phone",
"sms_opt_in",
"sms_opt_in_subscriber",
"utm_campaign",
"utm_source",
"utm_medium",
"utm_term",
"utm_content",
"source",
"embed_url",
"session_id",
"email_referrer",
"mobile_referrer",
]
class DriverSerializer(serializers.ModelSerializer):
phone = PhoneNumberField()
class Meta:
model = Driver
fields = ('id', 'email', 'name', 'phone', 'password', 'user_type',
'photo', 'seller_id', 'status')
extra_kwargs = {
'password': {
'write_only': True
},
'first_name': {
'required': False
},
'last_name': {
'required': False
},
'terms_of_use': {
'required': False
},
'photo': {
'required': False
},
}
class UserFullSerializer(serializers.ModelSerializer):
phone = PhoneNumberField(required=False,
validators=[UniqueValidator(User.objects.all())])
email = serializers.EmailField(
required=False, validators=[UniqueValidator(User.objects.all())])
full_name = serializers.SerializerMethodField()
change_password = serializers.SerializerMethodField()
def get_full_name(self, obj):
return obj.get_full_name()
def get_change_password(self, obj):
return obj.get_change_password()
class Meta:
model = User
fields = (
'id',
'username',
'full_name',
'first_name',
'middle_name',
'last_name',
'gender',
'phone',
'email',
'photo',
'change_password',
'birthday',
'last_login',
'date_joined',
)
read_only_fields = ('id', 'full_name', 'photo', 'last_login',
'date_joined')
class UserSerializer(serializers.ModelSerializer):
password = serializers.CharField(write_only=True)
token = serializers.SerializerMethodField(read_only=True)
phone_number = PhoneNumberField(required=False)
avatar = serializers.ImageField(required=False, write_only=True)
avatar_url = serializers.SerializerMethodField(read_only=True)
class Meta:
model = CustomUser
fields = (
"name",
"email",
"password",
"phone_number",
"token",
"avatar",
"avatar_url",
)
def get_token(self, obj=None):
return str(obj.auth_token)
def get_avatar_url(self, user):
request = self.context.get("request")
if user.avatar:
avatar_url = user.avatar.url
return request.build_absolute_uri(avatar_url)
return None
class UserSerializer(serializers.ModelSerializer):
""" User serializer """
has_plan = PrimaryKeyRelatedField(queryset=Plan.objects.all())
contact_number = PhoneNumberField(style={'placeholder': 'Contact Number', 'hide_label': True})
first_name = serializers.CharField(
style={'placeholder': 'First Name', 'hide_label': True})
last_name = serializers.CharField(
style={'placeholder': 'Last Name', 'hide_label': True})
email = serializers.CharField(
style={'placeholder': 'Email Address', 'hide_label': True})
gender = serializers.ChoiceField(
choices=UserModel.GENDER_CHOICE,
style={'placeholder': 'Select Gender', 'hide_label': True})
password = serializers.CharField(
max_length=190,
style={'input_type': 'password', 'placeholder': 'Password', 'hide_label': True})
profile_image = Base64ImageField(
required=False,
style={'class': 'form-control clearablefileinput', 'placeholder': 'Profile Image'})
def update(self, instance, validated_data):
if 'password' in validated_data:
validated_data['password'] = set_password_hash(validated_data["password"])
return super(UserSerializer, self).update(instance, validated_data)
def create(self, validated_data):
validated_data['password'] = set_password_hash(validated_data["password"])
return super(UserSerializer, self).create(validated_data)
class Meta:
model = User
fields = ['url', 'id', 'contact_number', 'first_name', 'last_name', 'gender', 'profile_image', 'email',
'password', 'role', 'registration_date', 'has_plan']
read_only_fields = ['has_plan']
write_only_fields = ('password', )
class SellerSerializer(serializers.ModelSerializer):
phone = PhoneNumberField()
class Meta:
model = Seller
fields = ('id', 'email', 'store', 'describtion', 'phone', 'photo',
'password', 'terms_of_use', 'user_type', 'credit_card',
'cash', 'k_net', 'deivery_method')
extra_kwargs = {
'password': {
'write_only': True
},
'terms_of_use': {
'required': True
},
'phone': {
'required': True
},
}
def validate(self, data):
context = dict()
if not data["credit_card"] and not data["cash"] and not data["k_net"]:
context['error'] = _("You must choose your payment methods")
raise serializers.ValidationError(context)
return data
class ChangePhoneNumberSerializer(ErrorDictMixin, serializers.Serializer):
phone_number = PhoneNumberField()
@property
def user(self):
return self.context['request'].user
def validate_phone_number(self, phone_number):
if self.user.phone_number == phone_number:
raise serializers.ValidationError(
_('The new phone number must be '
'different than the old one.'))
return phone_number
def validate(self, data):
self.user.phone_number = data['phone_number']
try:
self.user.full_clean()
except ValidationError as e:
raise serializers.ValidationError(self._get_error_dict(e))
return data
def save(self):
self.user.is_active = False
self.user.save()
class UpdateSellerProfileSerializer(serializers.ModelSerializer):
phone = PhoneNumberField()
class Meta:
model = Seller
fields = ('describtion', 'cash', 'credit_card', 'k_net', 'email',
'phone', 'photo', 'cover', 'store')
class ProductItemsSerializer(serializers.Serializer):
products = serializers.ListField(child=ProductItemSerializer())
name = serializers.CharField(max_length=250)
phone = PhoneNumberField()
email = serializers.EmailField()
address = serializers.CharField()
class Meta:
list_serializer_class = ProductItemSerializer
def create(self, validated_data):
products = validated_data.get('products')
print('product', products)
order = Order.objects.create(
status='pending',
order_date=datetime.datetime.now(),
email=validated_data['email'],
phone=validated_data['phone'],
name=validated_data['name'],
address=validated_data['address'],
)
total = 0
for selected_product in products:
print('selected_product.get(id)', selected_product.get('id'))
print('selected_product.get(quantity)',
selected_product.get('quantity'))
product = Product.objects.get(id=selected_product.get('id'))
print('product', product.price)
OrderItem.objects.bulk_create([
OrderItem(
order=order,
cost=product.price,
quantity=selected_product.get('quantity'),
product=product,
)
])
total = total + (product.price * selected_product.get('quantity'))
invoice = Invoice.objects.create(
status='pending',
period_start_date=datetime.date.today(),
period_end_date=datetime.date.today() + datetime.timedelta(days=7),
invoice_date=datetime.datetime.now(),
)
invoiceorder = InvoiceOrder.objects.create(
invoice=invoice,
order=order,
)
order.total = total
order.save()
return {
'products': products,
'name': order.id,
'address': invoice.invoice_no,
'phone': validated_data.get('phone'),
'email': validated_data.get('email'),
}
class AccountSerializer(CustomerSerializer):
id = serializers.IntegerField(source='pk')
username = serializers.CharField(source='get_username')
phone_number = PhoneNumberField()
shipping_addresses = serializers.SerializerMethodField()
billing_addresses = serializers.SerializerMethodField()
class Meta:
model = Customer
fields = [
'id', 'username', 'salutation', 'first_name', 'last_name', 'email',
'phone_number', 'extra', 'shipping_addresses', 'billing_addresses'
]
def get_shipping_addresses(self, obj):
addresses = obj.shippingaddress_set.all()
if addresses:
return ShippingAddressSerializer(addresses,
context=self.context,
many=True).data
def get_billing_addresses(self, obj):
addresses = obj.billingaddress_set.all()
if addresses:
return BillingAddressSerializer(addresses,
context=self.context,
many=True).data
class StaffRegisterSerializer(AbstractRegistrationSerializer):
email = serializers.EmailField(required=STAFF_EMAIL_IS_REQUIRED,
allow_blank=not STAFF_EMAIL_IS_REQUIRED)
phone_number = PhoneNumberField(max_length=20,
required=STAFF_PHONE_IS_REQUIRED,
allow_blank=not STAFF_PHONE_IS_REQUIRED)
def get_cleaned_data(self):
cleaned_data = super().get_cleaned_data()
# case where phone is not required we need to auto generate phone number unique and save
cleaned_data.update({
'email':
self.validated_data.get('email', generate_dummy_email()),
'phone_number':
self.validated_data.get('phone_number',
generate_dummy_phone_number())
})
return cleaned_data
def save(self, request):
adapter = get_adapter()
user = adapter.new_user(request)
self.cleaned_data = self.get_cleaned_data()
adapter.save_user(request, user, self)
self.custom_signup(request, user)
setup_user_email(request, user, [])
return user
class LookupSerializer(ActionSerializer):
phone = PhoneNumberField(required=False)
zipcode = serializers.CharField(validators=[zip_validator])
state = serializers.ChoiceField(choices=STATES,
required=True,
validators=[state_code_validator])
class Meta:
model = Lookup
minimum_necessary_fields = [
"first_name",
"last_name",
"address1",
"city",
"state",
"zipcode",
"date_of_birth",
"email",
]
optional_fields = [
"address2",
"age",
"phone",
"sms_opt_in",
"response",
"utm_campaign",
"utm_source",
"utm_medium",
"source",
]
class SMSVerificationSerializer(serializers.Serializer):
phone_number = PhoneNumberField(required=True)
session_token = serializers.CharField(required=True)
security_code = serializers.CharField(required=True)
def validate(self, attrs):
attrs = super().validate(attrs)
phone_number = attrs.get("phone_number", None)
security_code, session_token = (
attrs.get("security_code", None),
attrs.get("session_token", None),
)
backend = get_sms_backend(phone_number=phone_number)
verification, token_validatation = backend.validate_security_code(
security_code=security_code,
phone_number=phone_number,
session_token=session_token,
)
if verification is None:
raise serializers.ValidationError(_("Security code is not valid"))
elif token_validatation == backend.SESSION_TOKEN_INVALID:
raise serializers.ValidationError(_("Session Token mis-match"))
elif token_validatation == backend.SECURITY_CODE_EXPIRED:
raise serializers.ValidationError(_("Security code has expired"))
elif token_validatation == backend.SECURITY_CODE_VERIFIED:
raise serializers.ValidationError(
_("Security code is already verified"))
return attrs
class BloggerActionSerializer(ModelActionSerializer):
country = CountryField(source='profile.country', required=False)
blogs_num = serializers.IntegerField(source='profile.blogs_num',
required=False)
birth_date = serializers.DateField(source='profile.birth_date',
required=False)
phone_number = PhoneNumberField(source='profile.phone_number',
required=False)
bio = serializers.CharField(source='profile.bio', required=False)
class Meta:
model = User
fields = (
'id',
'username',
'blogs_num',
'birth_date',
'phone_number',
'country',
'bio',
)
action_fields = {
"list": {
"fields": (
'id',
'username',
'blogs_num',
)
},
# "retrieve": {"fields": ('id', 'username', 'blogs_num',)},
}
class ChangePhoneNumberSerializer(ErrorDictMixin, AllowedMobilePrefixMixin,
serializers.Serializer):
phone_number = PhoneNumberField()
@property
def user(self):
return self.context['request'].user
def validate_phone_number(self, phone_number):
if self.user.phone_number == phone_number:
raise serializers.ValidationError(
_('The new phone number must be different than the old one.'))
org = self.context['view'].organization
mobile_prefixes = org.radius_settings.allowed_mobile_prefixes_list
if not self.is_prefix_allowed(phone_number, mobile_prefixes):
raise serializers.ValidationError(
_('This international mobile prefix is not allowed.'))
return phone_number
def validate(self, data):
self.user.phone_number = data['phone_number']
try:
self.user.full_clean()
except ValidationError as e:
raise serializers.ValidationError(self._get_error_dict(e))
return data
def save(self):
self.user.is_active = False
self.user.save()
class AddressSerializer(serializers.Serializer):
contact_name = serializers.CharField(max_length=255)
contact_phone = PhoneNumberField()
city = serializers.CharField(max_length=255)
street = serializers.CharField(max_length=255)
house = serializers.CharField(max_length=255)
zip = serializers.CharField(max_length=255)
class PatientSearchSerializer(serializers.ModelSerializer):
gender = ChoiceField(choices=GENDER_CHOICES)
phone_number = PhoneNumberField()
class Meta:
model = PatientSearch
fields = "__all__"
def to_phone_number_field(phone_number):
try:
return PhoneNumberField().to_internal_value(phone_number)
except ValidationError:
parsed = phonenumbers.parse(phone_number, region="IN")
return phonenumbers.format_number(parsed,
phonenumbers.PhoneNumberFormat.E164)
