class UserSignupSerializer(RegisterSerializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED)
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
gender = serializers.CharField(max_length=10)
birthdate = serializers.DateTimeField()
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
("A user is already registered with this e-mail address."))
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(
("The two password fields didn't match."))
return data
def custom_signup(self, request, user):
pass
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', ''),
'gender': self.validated_data.get('gender', ''),
'birthdate': self.validated_data.get('birthdate', '')
}
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)
#Assign gender and birthdate to the new user
userProfile = UserProfile(user=user,
gender=self.validated_data.get('gender', ''),
birthdate=self.validated_data.get(
'birthdate', ''))
userProfile.save()
self.custom_signup(request, user)
setup_user_email(request, user, [])
return user
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
if app_settings.AUTHENTICATION_METHOD == AuthenticationMethod.EMAIL:
login_widget = forms.TextInput(
attrs={
'type': 'email',
'placeholder': _('E-mail address'),
'autofocus': 'autofocus'
})
login_field = forms.EmailField(label=_("E-mail"),
widget=login_widget)
elif app_settings.AUTHENTICATION_METHOD \
== AuthenticationMethod.USERNAME:
login_widget = forms.TextInput(attrs={
'placeholder': _('Username'),
'autofocus': 'autofocus'
})
login_field = forms.CharField(label=_("Username"),
widget=login_widget,
max_length=get_username_max_length())
else:
assert app_settings.AUTHENTICATION_METHOD \
== AuthenticationMethod.USERNAME_EMAIL
login_widget = forms.TextInput(
attrs={
'placeholder': _('Username or e-mail'),
'autofocus': 'autofocus'
})
login_field = forms.CharField(label=pgettext(
"field label", "Login"),
widget=login_widget)
self.fields["login"] = login_field
set_form_field_order(self, ["login", "password", "remember"])
if app_settings.SESSION_REMEMBER is not None:
del self.fields['remember']
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
if app_settings.AUTHENTICATION_METHOD == AuthenticationMethod.EMAIL:
login_widget = forms.TextInput(attrs={'type': 'email',
'placeholder':
_('E-mail address'),
'autofocus': 'autofocus'})
login_field = forms.EmailField(label=_("E-mail"),
widget=login_widget)
elif app_settings.AUTHENTICATION_METHOD \
== AuthenticationMethod.USERNAME:
login_widget = forms.TextInput(attrs={'placeholder':
_('Username'),
'autofocus': 'autofocus'})
login_field = forms.CharField(
label=_("Username"),
widget=login_widget,
max_length=get_username_max_length())
else:
assert app_settings.AUTHENTICATION_METHOD \
== AuthenticationMethod.USERNAME_EMAIL
login_widget = forms.TextInput(attrs={'placeholder':
_('Username or e-mail'),
'autofocus': 'autofocus'})
login_field = forms.CharField(label=pgettext("field label",
"Login"),
widget=login_widget)
self.fields["login"] = login_field
set_form_field_order(self, ["login", "password", "remember"])
if app_settings.SESSION_REMEMBER is not None:
del self.fields['remember']
class MyRegisterSerializer(RegisterSerializer):
first_name = serializers.CharField(required=True, write_only=True)
last_name = serializers.CharField(required=True, write_only=True)
avatar = serializers.CharField(required=True, write_only=True)
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED
)
def get_cleaned_data(self):
return {
'first_name': self.validated_data.get('first_name', ''),
'username': self.validated_data.get('username', ''),
'last_name': self.validated_data.get('last_name', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', ''),
'avatar': self.validated_data.get('avatar', ''),
}
def custom_signup(self, request, user):
user.username = self.validated_data.get('username', '')
user.first_name = self.validated_data.get('first_name', '')
user.last_name = self.validated_data.get('last_name', '')
user.avatar = self.validated_data.get('avatar', '')
user.save(update_fields=['first_name', 'last_name', 'avatar'])
class CustomRegistrationSerializer(RegisterSerializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=True
)
email = serializers.EmailField(required=True, write_only=True)
phone = serializers.CharField(write_only=True, required=True)
password1 = serializers.CharField(write_only=True, required=True)
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', ''),
'phone': self.validated_data.get('phone', ''),
}
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)
setup_user_email(request, user, [])
user.phone = self.validated_data.get('phone', '')
user.save()
return user
class RegisterSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED
)
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
name = serializers.CharField(max_length=128)
phone = serializers.CharField(max_length=32)
vaccination_info = serializers.ChoiceField(choices=VACCINATION_CHOICES)
is_store_owner = serializers.BooleanField(default=False)
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
("A user is already registered with this e-mail address."))
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(("The two password fields didn't match."))
return data
def custom_signup(self, request, user, data):
user.name = data['name']
user.phone = data['phone']
user.is_store_owner = data['is_store_owner']
user.save()
def get_cleaned_data(self):
print(self.validated_data)
return {
'username': self.validated_data.get('username', ''),
'name': self.validated_data.get('name', ''),
'phone': self.validated_data.get('phone', ''),
'is_store_owner': self.validated_data.get('is_store_owner', False),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', '')
}
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, self.cleaned_data)
setup_user_email(request, user, [])
return user
class RegisterSerializerCustom(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED
)
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
usn = serializers.CharField(required=True)
user_t = serializers.IntegerField(write_only=True)
#user_type = PrimaryKeyRelatedField()
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address."))
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
'''if data['password'] != data['password'] :
raise serializers.ValidationError(_("The two password fields didn't match."))\
#checking here for user type
if data['ut_type'] == 0:
raise serializers.ValidationError(_("You cannot register as superuser"))'''
return data
def custom_signup(self, request, user):
pass
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'password': self.validated_data.get('password', ''),
'email': self.validated_data.get('email', ''),
}
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 RegisterSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED)
firstName = serializers.CharField(max_length=255)
lastName = serializers.CharField(max_length=255)
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address.")
)
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate_firstName(self, firstName):
return firstName
def validate_lastName(self, lastName):
return lastName
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(
_("The two password fields didn't match."))
return data
def custom_signup(self, request, user):
pass
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'first_name': self.validated_data.get('firstName', ''),
'last_name': self.validated_data.get('lastName', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', '')
}
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
def __init__(self, *args, **kwargs):
email_required = kwargs.pop('email_required',
app_settings.EMAIL_REQUIRED)
self.username_required = kwargs.pop('username_required',
app_settings.USERNAME_REQUIRED)
super(BaseSignupForm, self).__init__(*args, **kwargs)
username_field = self.fields['username']
username_field.max_length = get_username_max_length()
username_field.validators.append(
validators.MaxLengthValidator(username_field.max_length))
username_field.widget.attrs['maxlength'] = str(
username_field.max_length)
default_field_order = [
'email',
'email2', # ignored when not present
'username',
'first_name',
'last_name',
'description',
'image',
'password1',
'password2' # ignored when not present
]
if app_settings.SIGNUP_EMAIL_ENTER_TWICE:
self.fields["email2"] = forms.EmailField(
label=_("E-mail (again)"),
widget=forms.TextInput(
attrs={
'type': 'email',
'placeholder': _('E-mail address confirmation')
}))
if email_required:
self.fields['email'].label = ugettext("E-mail")
self.fields['email'].required = True
else:
self.fields['email'].label = ugettext("E-mail (optional)")
self.fields['email'].required = False
self.fields['email'].widget.is_required = False
if self.username_required:
default_field_order = [
'email',
'email2', # ignored when not present
'username',
'first_name',
'last_name',
'description',
'image',
'password1',
'password2'
]
if not self.username_required:
del self.fields["username"]
set_form_field_order(
self,
getattr(self, 'field_order', None) or default_field_order)
class RegisterSerializer(serializers.Serializer):
"""
验证用户输入的数据，创建新用户
"""
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=app_settings.USERNAME_MIN_LENGTH,
required=app_settings.USERNAME_REQUIRED
)
email = serializers.EmailField(required=app_settings.EMAIL_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
cleaned_data = {}
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if app_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
msg = {"email_error": "This email address has been registered!"}
raise serializers.ValidationError(msg)
return email
def validate_password1(self, password):
password = get_adapter().clean_password(password)
return password
def validate_password_equal(self, data):
if data['password1'] != data['password2']:
msg = {"password_error": "The password entered twice is inconsistent!"}
raise serializers.ValidationError(msg)
return data
def get_cleaned_data(self):
result = {
'username': self.validated_data.get('username', ''),
'email': self.validated_data.get('email', ''),
'password1': self.validated_data.get('password1', '')
}
return result
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)
setup_user_email(request, user, [])
return user
class RegisterSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED)
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
name = serializers.CharField(max_length=100, min_length=5, required=True)
def validate_name(self, name):
pattern = '^[a-zA-ZàáâäãåąčćęèéêëėįìíîïłńòóôöõøùúûüųūÿýżźñçčšžÀÁÂÄÃÅĄĆČĖĘÈÉÊËÌÍÎÏĮŁŃÒÓÔÖÕØÙÚÛÜŲŪŸÝŻŹÑßÇŒÆČŠŽ∂ðء-ي]+ [a-zA-ZàáâäãåąčćęèéêëėįìíîïłńòóôöõøùúûüųūÿýżźñçčšžÀÁÂÄÃÅĄĆČĖĘÈÉÊËÌÍÎÏĮŁŃÒÓÔÖÕØÙÚÛÜŲŪŸÝŻŹÑßÇŒÆČŠŽ∂ðء-ي]+[a-zA-ZàáâäãåąčćęèéêëėįìíîïłńòóôöõøùúûüųūÿýżźñçčšžÀÁÂÄÃÅĄĆČĖĘÈÉÊËÌÍÎÏĮŁŃÒÓÔÖÕØÙÚÛÜŲŪŸÝŻŹÑßÇŒÆČŠŽ∂ðء-ي ]*$'
compiler = re.compile(pattern)
if not compiler.match(name):
raise serializers.ValidationError(
_("تأكد أن الإسم الكامل لا يحتوي الا على حروف و مسافات."))
return name
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address.")
)
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(
_("The two password fields didn't match."))
return data
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', ''),
'first_name': self.validated_data.get('name', '')
}
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)
setup_user_email(request, user, [])
discourse_sync_sso.delay(user.id)
return user
class MyRegisterSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED
)
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
department = serializers.CharField(required=True,write_only=True)
date_of_birth = serializers.IntegerField(required=True,write_only=True)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(("The two password fields didn't match."))
return data
def custom_signup(self, request, user):
pass
def get_cleaned_data(self):
print('validated_data ' , self.validated_data.get('username'))
return {
'username': self.validated_data.get('username', ''),
'password1': self.validated_data.get('password1', ''),
'department': self.validated_data.get('department', ''),
'date_of_birth': self.validated_data.get('date_of_birth', ''),
'email': self.validated_data.get('email', '')
}
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, [])
profile = Profile()
profile.user = user
profile.department = self.cleaned_data.get('department')
profile.date_of_birth = self.cleaned_data.get('date_of_birth')
profile.save()
print('Profile saved: ', profile)
return user
def test_username_maxlength(self):
data = {
"username": "******",
"email": "*****@*****.**",
}
form = BaseSignupForm(data, email_required=True)
max_length = get_username_max_length()
field = form.fields["username"]
self.assertEqual(field.max_length, max_length)
widget = field.widget
self.assertEqual(widget.attrs.get("maxlength"), str(max_length))
def test_username_maxlength(self):
data = {
'username': '******',
'email': '*****@*****.**',
}
form = BaseSignupForm(data, email_required=True)
max_length = get_username_max_length()
field = form.fields['username']
self.assertEqual(field.max_length, max_length)
widget = field.widget
self.assertEqual(widget.attrs.get('maxlength'), str(max_length))
def test_username_maxlength(self):
data = {
'username': '******',
'email': '*****@*****.**',
}
form = BaseSignupForm(data, email_required=True)
max_length = get_username_max_length()
field = form.fields['username']
self.assertEqual(field.max_length, max_length)
widget = field.widget
self.assertEqual(widget.attrs.get('maxlength'), str(max_length))
def gen_username(email):
mailbox, domain = email.rsplit("@", maxsplit=1)
username = mailbox
n = 1
while User.objects.filter(username=username).count():
username = "******" % (mailbox, n)
n += 1
max_length = get_username_max_length()
if max_length and len(username) > max_length:
# I give up.
return os.urandom(max_length // 2).hex()
return username
class AccountUserSerializer(serializers.ModelSerializer):
username = serializers.CharField(
label='Username',
required=True,
min_length=app_settings.USERNAME_MIN_LENGTH,
max_length=get_username_max_length(),
validators=username_validators,
help_text=
'Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.',
style={'template': 'vadetisweb/parts/input/text_input.html'})
first_name = serializers.CharField(
label='First Name',
required=False,
validators=[alphabetic_validator],
style={'template': 'vadetisweb/parts/input/text_input.html'})
last_name = serializers.CharField(
label='Last Name',
required=False,
validators=[alphabetic_validator],
style={'template': 'vadetisweb/parts/input/text_input.html'})
email = serializers.EmailField(
label='E-Mail Address',
required=True,
validators=email_validators,
style={'template': 'vadetisweb/parts/input/text_input.html'})
def validate_email(self, value):
value = get_account_adapter().clean_email(value)
errors = {
"different_account":
"This e-mail address is already associated with another account.",
}
users = filter_users_by_email(value)
on_diff_account = [u for u in users if u.pk != self.instance.pk]
if on_diff_account and app_settings.UNIQUE_EMAIL:
raise serializers.ValidationError(errors["different_account"])
return value
class Meta:
model = User
fields = (
'username',
'first_name',
'last_name',
'email',
)
def gen_username(email):
mailbox, domain = email.rsplit('@', maxsplit=1)
username = mailbox
n = 1
while User.objects.filter(username=username).count():
username = '******' % (mailbox, n)
n += 1
max_length = get_username_max_length()
if max_length and len(username) > max_length:
# I give up.
return os.urandom(max_length // 2).hex()
return username
class RegisterSerializer(serializers.Serializer):
username = serializers.CharField(max_length=get_username_max_length(),
min_length=6,
required=True)
email = serializers.EmailField(required=False)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
city = serializers.CharField(max_length=25, default='New York City')
country = serializers.CharField(max_length=30,
default='United States of America')
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
("A user is already registered with this e-mail address."))
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(
("The two password fields didn't match."))
return data
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', ''),
'city': self.validated_data.get('city', ''),
'country': self.validated_data.get('country', '')
}
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)
setup_user_email(request, user, [])
return user
def __init__(self, *args, **kwargs):
email_required = kwargs.pop('email_required',
app_settings.EMAIL_REQUIRED)
self.username_required = kwargs.pop('username_required',
app_settings.USERNAME_REQUIRED)
super(BaseSignupForm, self).__init__(*args, **kwargs)
username_field = self.fields['username']
username_field.max_length = get_username_max_length()
username_field.validators.append(
validators.MaxLengthValidator(username_field.max_length))
username_field.widget.attrs['maxlength'] = str(
username_field.max_length)
# field order may contain additional fields from our base class,
# so take proper care when reordering...
field_order = ['email', 'username']
if app_settings.SIGNUP_EMAIL_ENTER_TWICE:
self.fields["email2"] = forms.EmailField(
label=_("E-mail (again)"),
widget=forms.TextInput(
attrs={
'type': 'email',
'placeholder': _('E-mail address confirmation')
}))
field_order = ['email', 'email2', 'username']
merged_field_order = list(self.fields.keys())
if email_required:
self.fields['email'].label = ugettext("E-mail")
self.fields['email'].required = True
else:
self.fields['email'].label = ugettext("E-mail (optional)")
self.fields['email'].required = False
self.fields['email'].widget.is_required = False
if self.username_required:
field_order = ['username', 'email']
if app_settings.SIGNUP_EMAIL_ENTER_TWICE:
field_order.append('email2')
# Merge our email and username fields in if they are not
# currently in the order. This is to allow others to
# re-arrange email and username if they desire. Go in reverse
# so that we make sure the inserted items are always
# prepended.
for field in reversed(field_order):
if field not in merged_field_order:
merged_field_order.insert(0, field)
set_form_field_order(self, merged_field_order)
if not self.username_required:
del self.fields["username"]
class SignupSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED)
email = serializers.EmailField(
required=allauth_settings.EMAIL_REQUIRED,
style={'input_type': 'email'},
)
password = serializers.CharField(write_only=True,
style={'input_type': 'password'})
def validate_username(self, username):
try:
return get_account_adapter().clean_username(username)
except DjangoValidationError:
raise serializers.ValidationError(
_("A user is already registered with this username."))
def validate_email(self, email):
email = get_account_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address.")
)
return email
def validate_password(self, password):
return get_account_adapter().clean_password(password)
def validate(self, attrs):
attrs['password1'] = attrs['password'] # Needed by save_user()
return attrs
def save(self, request):
self.cleaned_data = self.validated_data # Needed by new_user()
user = get_account_adapter().new_user(request)
original_request = request._request
get_account_adapter().save_user(request, user, self)
setup_user_email(request, user, [])
complete_signup(original_request, user,
allauth_settings.EMAIL_VERIFICATION, None)
return user
class CustomRegisterSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
name = serializers.CharField(write_only=True)
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(
_("The two password fields didn't match."))
return data
def custom_signup(self, request, user):
pass
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'password1': self.validated_data.get('password1', ''),
# 'email': self.validated_data.get('email', '')
}
def save(self, request):
adapter = get_adapter()
user = adapter.new_user(request)
if 'name' in request.POST:
user.name = request.POST['name']
# user.name = user.name.encode('utf-8')
self.cleaned_data = self.get_cleaned_data()
adapter.save_user(request, user, self)
self.custom_signup(request, user)
user.email = request.data['username']
user.save()
# setup_user_email(request, user, )
return user
class UserRegistrationSerializer(serializers.Serializer):
phone = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED)
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
def validate_phone(self, phone):
phone = get_adapter().clean_username(phone)
return phone
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
"Пользователь с таким e-mail уже существует.")
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError("Введенные пароли не совпадают.")
return data
def get_cleaned_data(self):
return {
'phone': self.validated_data.get('phone', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', '')
}
def save(self, request):
self.cleaned_data = self.get_cleaned_data()
user = UserModel.objects.create_user(
phone=self.cleaned_data.get('phone'),
password=self.cleaned_data.get('password1'),
email=self.cleaned_data.get('email'))
user.save()
setup_user_email(request, user, [])
return user
class RegisterSerializer(serializers.Serializer):
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED)
# first_name = serializers.CharField(required=False, write_only=True)
# last_name = serializers.CharField(required=False, write_only=True)
password1 = serializers.CharField(required=True, write_only=True)
password2 = serializers.CharField(required=True, write_only=True)
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(("このメールアドレスは既に登録されています。"))
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(("確認用パスワードが間違っています。"))
return data
def get_cleaned_data(self):
return {
'first_name': self.validated_data.get('first_name', ''),
'last_name': self.validated_data.get('last_name', ''),
'password1': self.validated_data.get('password1', ''),
'password2': self.validated_data.get('password2', ''),
'email': self.validated_data.get('email', ''),
}
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)
setup_user_email(request, user, [])
user.save()
return user
class RegisterSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
# email = serializers.EmailField(required=False)
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(
_("The two password fields din't match."))
return data
def custom_signup(self, request, user):
pass
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'password1': self.validated_data.get('password1', ''),
}
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)
return user
def __init__(self, *args, **kwargs):
self.request = kwargs.pop('request', None)
super(LoginForm, self).__init__(*args, **kwargs)
if settings.ACCOUNT_AUTHENTICATION_METHOD == 'email':
login_widget = forms.TextInput(
attrs={
'type': 'email',
'placeholder': _('E-mail address'),
'autofocus': 'autofocus',
'style': 'color:white',
})
login_field = forms.EmailField(label=_("E-mail"),
widget=login_widget)
elif settings.ACCOUNT_AUTHENTICATION_METHOD \
== 'username':
login_widget = forms.TextInput(
attrs={
'placeholder': _('Username'),
'autofocus': 'autofocus',
'style': 'color:white'
})
login_field = forms.CharField(label=_("Username"),
widget=login_widget,
max_length=get_username_max_length())
else:
assert settings.ACCOUNT_AUTHENTICATION_METHOD \
== 'username_email'
login_widget = forms.TextInput(
attrs={
'placeholder': _('Username or e-mail'),
'autofocus': 'autofocus',
'style': 'color:white'
})
login_field = forms.CharField(label=pgettext(
"field label", "Login"),
widget=login_widget)
self.fields["login"] = login_field
set_form_field_order(self, ["login", "password", "remember"])
class SignupWithEmailSerializer(serializers.ModelSerializer):
class Meta:
model = User
fields = ('id', 'username', 'first_name', 'last_name', 'email',
'phone_number', 'password')
extra_kwargs = {
'password': {
'write_only': True,
'style': {
'input_type': 'password'
}
},
'username': {
'required': True
},
'email': {
'required': True,
'allow_blank': False,
}
}
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=True)
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address.")
)
return email
class SignUpWithPhoneSerializer(serializers.ModelSerializer):
class Meta:
model = User
fields = ('id', 'username', 'first_name', 'last_name', 'email',
'phone_number', 'password')
extra_kwargs = {
'password': {
'write_only': True,
'style': {
'input_type': 'password'
}
},
'username': {
'required': True
},
'phone_number': {
'required': True,
'allow_blank': False,
}
}
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=True)
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_phone_number(self, phone_number):
try:
user = User.objects.get(phone_number=phone_number)
except User.DoesNotExist:
return phone_number
raise serializers.ValidationError(
_("A user is already registered with this phone number."))
class RegisterSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED)
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
group_name = serializers.ChoiceField(choices=list(
Group.objects.all().values_list('name', flat=True)),
write_only=True,
required=True)
user_details = UserExtraDetailsSerializer(required=False)
def __init__(self, *args, **kwargs):
self.fields['group_name'].choices = list(
Group.objects.all().values_list('name', flat=True))
super(RegisterSerializer, self).__init__(*args, **kwargs)
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address.")
)
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate_group_name(self, group_name):
try:
Group.objects.get(name=group_name)
except Group.DoesNotExist:
raise serializers.ValidationError(
_("You have to create group before creating user"))
return group_name
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(
_("The two password fields didn't match."))
return data
def custom_signup(self, request, user):
pass
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', ''),
'group_name': self.validated_data.get('group_name', ''),
'user_details': self.validated_data.get('user_details', '')
}
def save(self, request):
adapter = get_adapter()
self.cleaned_data = self.get_cleaned_data()
try:
group = Group.objects.get(name=self.cleaned_data['group_name'])
except Group.DoesNotExist:
raise serializers.ValidationError(_("Group is not Available"))
try:
user_details = dict(self.cleaned_data['user_details'])
user_details = UserDetails.objects.create(**user_details)
except Exception as E:
raise serializers.ValidationError(
_("Problem while creating user details " + str(E)))
user = adapter.new_user(request)
adapter.save_user(request, user, self)
self.custom_signup(request, user)
setup_user_email(request, user, [])
user.groups.add(group)
user.user_details = user_details
user.save()
return user
class NewRegisterSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED
)
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
usn = serializers.CharField(required=True)
dept = serializers.IntegerField(required=True)
ut_id = serializers.IntegerField(required=True)
phone_number = serializers.CharField(required=True)
# user_t = serializers.IntegerField(write_only=True)
#user_type = PrimaryKeyRelatedField()
# email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
# first_name = serializers.CharField(required=True, write_only=True)
#last_name = serializers.CharField(required=True, write_only=True)
#address = serializers.CharField(required=True, write_only=True)
#password1 = serializers.CharField(required=True, write_only=True)
#password2 = serializers.CharField(required=True, write_only=True)
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address."))
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(
_("The two password fields didn't match."))
return data
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
#'last_name': self.validated_data.get('last_name', ''),
#'address': self.validated_data.get('address', ''),
#'user_type': self.validated_data.get('user_type', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', ''),
'usn': self.validated_data.get('usn', ''),
'phone_number': self.validated_data.get('phone_number', ''),
'ut_id': self.validated_data.get('ut_id', ''),
}
def save(self, request):
adapter = get_adapter()
user = adapter.new_user(request)
user.is_active = False
self.cleaned_data = self.get_cleaned_data()
adapter.save_user(request, user, self)
setup_user_email(request, user, [])
#user.address = self.cleaned_data.get('usn')
#user.user_type = self.cleaned_data.get('user_type')
user.save()
return user
class UserSafeSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED)
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
address = serializers.CharField(max_length=100, default='Innopolis')
phone = serializers.DecimalField(max_digits=11, decimal_places=0)
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
first_name = serializers.CharField(write_only=True)
last_name = serializers.CharField(write_only=True)
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
"A user is already registered with this e-mail address.")
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate_phone(self, phone):
existing_user = User.objects.filter(phone=phone)
if existing_user and existing_user.exists():
raise serializers.ValidationError(
"A user is already registered with this phone number.")
return phone
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(
"The two password fields didn't match.")
return data
def custom_signup(self, request, user):
pass
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', ''),
'address': self.validated_data.get('address', ''),
'first_name': self.validated_data.get('first_name', ''),
'last_name': self.validated_data.get('last_name', ''),
'phone': self.validated_data.get('phone', ''),
'role': 0
}
def save(self, request):
adapter = get_adapter()
user = adapter.new_user(request)
self.cleaned_data = self.get_cleaned_data()
user.set_data(self.cleaned_data)
adapter.save_user(request, user, self)
self.custom_signup(request, user)
setup_user_email(request, user, [])
return user
class RegisterSerializer(serializers.Serializer):
username = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=allauth_settings.USERNAME_REQUIRED)
# email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
email = serializers.EmailField(required=True)
first_name = serializers.CharField(required=False)
last_name = serializers.CharField(required=False)
password = serializers.CharField(required=True, write_only=True)
is_driver = serializers.NullBooleanField(required=False)
# password2 = serializers.CharField(required=True, write_only=True)
def validate_username(self, username):
username = get_adapter().clean_username(username)
return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
# raise serializers.ValidationError( _("A user is already registered with this e-mail address."))
raise serializers.ValidationError(
"A user is already registered with this e-mail address.")
return email
def validate_password(self, password):
return get_adapter().clean_password(password)
# def validate(self, data):
# if data['password1'] != data['password2']:
# # raise serializers.ValidationError(_("The two password fields didn't match."))
# raise serializers.ValidationError("The two password fields didn't match.")
# return data
# def custom_signup(self, request, user):
# user.first_name = self.validated_data.get('first_name', '')
# user.last_name = self.validated_data.get('last_name', '')
# user.password = self.validated_data.get('password', '')
# user.save(update_fields=['first_name', 'last_name','password'])
def get_cleaned_data(self):
return {
'username': self.validated_data.get('username', ''),
'first_name': self.validated_data.get('first_name', ''),
'last_name': self.validated_data.get('last_name', ''),
'password1': self.validated_data.get('password', ''),
'email': self.validated_data.get('email', ''),
}
def save(self, request):
adapter = get_adapter()
user = adapter.new_user(request)
# data = request.DATA
# breakpoint()
self.cleaned_data = self.get_cleaned_data()
adapter.save_user(request, user, self)
setup_user_email(request, user, [])
# user.profile.save()
if self.data['is_driver']:
group = Group.objects.get(name='Delivery Person')
else:
group = Group.objects.get(name='Customer')
user.groups.add(group)
user.save()
profile = UserProfileInfo.objects.create(user=user)
user.profile = profile
return user
class CustomRegisterSerializer(serializers.Serializer):
first_name = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=True,
help_text='Your firstname',
)
last_name = serializers.CharField(
max_length=get_username_max_length(),
min_length=allauth_settings.USERNAME_MIN_LENGTH,
required=True,
help_text='Your lastname',
)
gender = serializers.ChoiceField(choices=GENDER_CHOICE, required=True)
phone = serializers.CharField(
# max_length=14,
# min_length=14,
required=True,
help_text='Your phone number',
)
email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED,
help_text='Email must be a unique')
password1 = serializers.CharField(write_only=True,
required=True,
help_text='password',
style={
'input_type': 'password',
})
password2 = serializers.CharField(write_only=True,
required=True,
help_text='confirm password',
style={
'input_type': 'password',
})
# def validate_username(self, username):
# username = get_adapter().clean_username(username)
# return username
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address.")
)
return email
def validate_password1(self, password):
return get_adapter().clean_password(password)
def validate(self, data):
if data['password1'] != data['password2']:
raise serializers.ValidationError(
_("The two password fields didn't match."))
return data
def custom_signup(self, request, user):
pass
def get_cleaned_data(self):
print('----------', self.validated_data)
return {
# 'username': self.validated_data.get('username', ''),
'first_name': self.validated_data.get('first_name', ''),
'last_name': self.validated_data.get('last_name', ''),
'gender': self.validated_data.get('gender', ''),
'password1': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', '')
}
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
