def register(request):
# A boolean value for telling the template whether the registration was successful.
# Set to False initially. Code changes value to True when registration succeeds.
registered = False
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
# Attempt to grab information from the raw form information.
# Note that we make use of both UserForm and UserProfileForm.
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# If the the form is valid...
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Now we hash the password with the set_password method.
# Once hashed, we can update the user object.
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
# Update our variable to tell the template registration was successful.
registered = True
new_user = authenticate(
username=user_form.cleaned_data['username'],
password=user_form.cleaned_data['password'],
)
login(request, new_user)
return HttpResponseRedirect('/')
# Invalid form or forms - mistakes or something else?
# Print problems to the terminal.
# They'll also be shown to the user.
else:
print user_form.errors, profile_form.errors
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
else:
user_form = UserForm()
# Render the template depending on the context.
return render(request, 'registration/register.html', {})
def registration_view(request):
dict = {}
if request.POST:
form = UserForm(request.POST)
if form.is_valid():
form.save()
messages.add_message(
request, messages.INFO,
" You have successfully registered. You can sign in now.")
redirect('/')
else:
form = UserForm()
dict['form'] = form
return render_to_response('registration/signup.html',
dict,
context_instance=RequestContext(request))
def register(request):
registered = False
if request.method == "POST":
user_form = UserForm(data=request.POST)
profile_form = UserProfileInfoForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
name = user_form.cleaned_data['firstname']
subject = 'message from eshop'
comment = 'Hi! I am a new user'
message = '%s %s' % (comment, name)
emailFrom = user_form.cleaned_data['email']
emailTo = [settings.EMAIL_HOST_USER]
send_mail(
subject,
message,
emailFrom,
emailTo,
fail_silently=True,
)
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'profile_pic' in request.FILES:
profile.profile_pic = request.FILES['profile_pic']
profile.save()
registered = True
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileInfoForm()
return render(
request, 'registration/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def post(self, request):
organization_list = get_organizations_ordered_by_name()
if organization_list:
if request.method == 'POST':
user_form = UserForm(request.POST, prefix="usr")
administrator_form = AdministratorForm(
request.POST, prefix="admin")
if user_form.is_valid() and administrator_form.is_valid():
ad_country = request.POST.get('admin-country')
ad_phone = request.POST.get('admin-phone_number')
if (ad_country and ad_phone):
if not validate_phone(ad_country, ad_phone):
self.phone_error = True
return render(
request,
'registration/signup_administrator.html', {
'user_form': user_form,
'administrator_form': administrator_form,
'registered': self.registered,
'phone_error': self.phone_error,
'organization_list':
self.organization_list,
})
user = user_form.save()
user.set_password(user.password)
user.save()
administrator = administrator_form.save(commit=False)
administrator.user = user
# if organization isn't chosen from dropdown,
# the organization_id will be 0
organization_id = request.POST.get('organization_name')
organization = get_organization_by_id(organization_id)
if organization:
administrator.organization = organization
administrator.save()
registered = True
messages.success(request,
'You have successfully registered!')
return HttpResponseRedirect(reverse('home:index'))
else:
print(user_form.errors, administrator_form.errors)
return render(
request, 'registration/signup_administrator.html', {
'user_form': user_form,
'administrator_form': administrator_form,
'registered': self.registered,
'phone_error': self.phone_error,
'organization_list': self.organization_list,
})
else:
return render(request, 'home/home.html', {'error': True})
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
if user_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
registered = True
else:
print(user_form.errors)
else:
user_form = UserForm()
context_dict = {'user_form': user_form, 'registered': registered}
return render(request, 'registration/register.html', context_dict)
def register(request):
if request.method=='POST':
form = UserForm(request.POST, instance=User())
if form.is_valid():
user=form.save()
user.set_password(form.cleaned_data["password2"])
user.save()
#trying to authenticate user
auth_user = authenticate(username=user.username,
password=form.cleaned_data["password2"])
if auth_user:
login(request,auth_user)
return redirect("Mail_blacklist.views.home")
else:
form=UserForm(instance=User())
return render(request, 'registration/register.html', locals() )
def register(request):
registered = False #will be set true when the registration is successful
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
#grab information from the raw form information
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Now we hash the password with the set_password method then update the user object.
user.set_password(user.password)
user.save()
# Now sort out the UserProfile instance.
# Since we need to set the user attribute ourselves,
# we set commit=False. This delays saving the model until we're ready to avoid integrity problems.
profile = profile_form.save(commit=False)
profile.user = user
# If user provided a profile picture we need to get it from the input form
# and put it in the UserProfile model.
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
# Now we save the UserProfile model instance.
profile.save()
# Update our variable to indicate that registration was successful.
registered = True
else:
#if form is invalid
print(user_form.errors, profile_form.errors)
else: #Not a HTTP POST, so we render our blank form using two ModelForm instances
user_form = UserForm()
profile_form = UserProfileForm()
# Render the template depending on the context.
return render(
request, 'registration/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def register(request):
registered = False
flag = 1
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileInfoForm(data=request.POST)
User = get_user_model()
if user_form.is_valid() and profile_form.is_valid():
for User in User.objects.filter():
if user_form.cleaned_data['email'] == User.email:
flag = 0
user_form.cleaned_data['username'] = "******"
print("This mail address already exists!")
if flag == 1:
user = user_form.save()
print("user saved")
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'profile_pic' in request.FILES:
print('found it')
profile.profile_pic = request.FILES['profile_pic']
profile.save()
registered = True
else:
print("not-saved")
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileInfoForm()
return render(
request, 'registration/registration.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered,
'flag': flag
})
def get(self, request):
user_form = UserForm(prefix="usr")
volunteer_form = VolunteerForm(prefix="vol")
return render(
request, 'registration/signup_volunteer.html', {
'user_form': user_form,
'volunteer_form': volunteer_form,
'registered': self.registered,
'phone_error': self.phone_error,
'organization_list': self.organization_list,
})
def get(self, request):
user_form = UserForm(prefix="usr")
administrator_form = AdministratorForm(prefix="admin")
return render(
request, 'registration/signup_administrator.html', {
'user_form': user_form,
'administrator_form': administrator_form,
'registered': self.registered,
'phone_error': self.phone_error,
'organization_list': self.organization_list
})
def register(request):
if request.method == 'POST':
user_form = UserForm(request.POST, request.FILES)
profile_form = UserProfileForm(request.POST, request.FILES)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save(commit=False)
raw_password = user.password # this will be used in logging in user later...see below
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
# logging in user after completing registration
user = auth.authenticate(username=user.username,
password=raw_password)
auth.login(request, user)
return HttpResponseRedirect(reverse('index'))
else:
print(user_form.errors)
print(profile_form.errors)
# it is happening for validation errors
# and see we are not returning anything
# may be django handles it itself
# beacuse django retuns this form with telling error messages
# if we show the validation error messages to user in the template
# so that they may enter correct value
else:
user_form = UserForm()
profile_form = UserProfileForm()
context = {
'user_form': user_form,
'profile_form': profile_form,
}
return render(request, 'registration/register.html', context=context)
def UserSignUp(request):
if (request.method == "POST"):
form1 = UserForm(request.POST)
if (form1.is_valid()):
username = form1.cleaned_data['username']
email = form1.cleaned_data['email']
password = form1.cleaned_data['password']
retype_password = form1.cleaned_data['confirm_password']
User.objects.create_user(username=username,
email=email,
password=password,
first_name="job_seeker")
messages.success(request, 'user registration successful')
usr = authenticate(username=username, password=password)
login(request, usr)
user_instance = UserModel(user=usr, accountType="job_seeker")
user_instance.save()
# return HttpResponseRedirect(reverse(UserDashBoard))
return HttpResponseRedirect(reverse(HomePage))
else:
form1 = UserForm()
return render(request, 'user_signup.html', {'reg_form': form1})
def get(self, request):
organization_list = get_organizations_ordered_by_name()
user_form = UserForm(prefix="usr")
administrator_form = AdministratorForm(prefix="admin")
return render(
request, 'registration/signup_administrator.html', {
'user_form': user_form,
'administrator_form': administrator_form,
'registered': self.registered,
'phone_error': self.phone_error,
'match_error': self.match_error,
'organization_list': organization_list,
'country_list': self.country_list,
})
def test_user_form_password_error(self):
photo = SimpleUploadedFile(
content=(base64.b64decode(TEST_IMAGE)),
name='tempfile.png',
content_type='image/png',
)
form_data = dict(
password1='123qweASD',
password2='123qweASD1',
login='******',
email='*****@*****.**',
)
form = UserForm(data=form_data, files={'photo': photo})
self.assertFalse(form.is_valid())
def get(self, request):
if request.user.is_authenticated:
return render(request, 'pages/user_is_logged_in.html')
else:
user_form = UserForm(prefix="usr")
alumni_form = AlumniForm(prefix="alu")
return render(
request, 'registration/signup_alumni.html', {
'user_form': user_form,
'alumni_form': alumni_form,
'registered': self.registered,
'phone_error': self.phone_error,
'match_error': self.match_error,
'country_list': self.country_list,
'city_list': self.city_list,
'region_list': self.region_list,
})
def registerTeamMember(request, startupID='Default User'):
registered = False
startup = Startup.objects.get(uniqueID=startupID)
if request.method == 'POST':
# Get info from "both" forms
# It appears as one form to the user on the .html page
# user_form = UserForm(data=request.POST)
user_form = UserForm(request.POST, request.FILES)
profile_form = TeamMemberProfileInfoForm(data=request.POST)
# Check to see both forms are valid
if user_form.is_valid() and profile_form.is_valid():
# Save User Form to Database
user = user_form.save(commit=False)
# group = user_form.save()
# Hash the password
user.set_password(user.password)
user.is_Team_Leader = False
user.is_Team_Member = True
user.startupID = startup.uniqueID
user.name_of_the_startup = startup.name_of_the_startup
# group.password(group.password)
# Update with Hashed password
# Now we deal with the extra info!
# Can't commit yet because we still need to manipulate
profile = profile_form.save(commit=False)
# Set One to One relationship between
# UserForm and IndividualProfileInfoForm
profile.user = user
profile.startupID = startup.uniqueID
user.save()
# we are getting the group
group = Group.objects.get(name=user.name_of_the_startup)
startup.group = group
# we are adding the user to the group
user.groups.add(startup.group)
# Check if they provided a profile picture
if 'profile_pic' in request.FILES:
print('found it')
# If yes, then grab it from the POST form reply
user.profile_pic = request.FILES['profile_pic']
profile.save()
registered = True
# Registration Successful!
else:
# One of the forms was invalid if this else gets called.
print(
user_form.errors,
profile_form.errors,
)
else:
# Was not an HTTP post so we just render the forms as blank.
user_form = UserForm()
profile_form = TeamMemberProfileInfoForm()
# user_form = UserForm()
# This is the render and context dictionary to feed
# back to the registration.html file page.
return render(
request, 'registration/memberRegistration.html', {
'user_form': user_form,
'profile_form': profile_form,
'startupID': startupID,
'registered': registered
})
def registration(request):
"""
Функция регистрации профиля персоны
user_form - работает из админки и содержит поле username пользвоателя
sms_form - Нужна для обработки кода смс
"""
global counter,mes
user_form = UserForm()
sms_form = SmsForm()
disabled,disabled2 = "","disabled" # Параметры кнопок,которые передаются в html
if request.is_ajax():
# Ajax запрос для автоматического определения ошибок при ввода телефона пользователем
user_form = UserForm(request.POST)
if user_form.is_valid():
return JsonResponse({'s': True})
else:
return JsonResponse({'error': user_form.errors})
if request.method == "POST" and 'code' in request.POST or request.is_ajax():
user_form = UserForm (request.POST)
if user_form.is_valid():
# Отправка сообщения и валидация номера
smsc = SMSC()
phone = user_form.cleaned_data['username']
mes = my_random_string(4)
print(mes)
# mes = "5"
# counter = ['19', '1', '0.9', '194.4' ]
# d = [ '-1' ]
counter = smsc.send_sms(phones=phone, message=mes, sender="me") # Отправка смс с
# введёными данными пользователя
status_phone = smsc.get_status(phone=phone, id=counter[0])
print(status_phone)
if len(counter)<3 and status_phone[0] != "-1":
# Проверка статуса отправки сообщения сайтом
messages.error(request, "Такого номера не существует ")
else:
messages.success(request, "Код отправлен!")
disabled = "disabled"
disabled2 = ""
if request.method == "POST" and 'reg' in request.POST:
user_form = UserForm(request.POST)
sms_form = SmsForm(request.POST)
print(mes)#код отправки
if user_form.is_valid () and sms_form.is_valid ():
if mes == sms_form.cleaned_data['sms_mes']:# ПРоверка совпадает ли код пользователя и код отправленный ему
# создание и аутентификаци персоны по введёным данным пользователя
last_id = User.objects.latest('id').id # можно заменить на ваши модели
# last_i = Person.objects.latest('id').id # можно заменить на ваши модели
password = "******"
# сохранение новго пользователя и дальнейший его вход
User.objects.create_user (**user_form.cleaned_data, id=int(last_id)+1, password=password)
# create_person = Person(users_id = last_id+1, id = last_i+1)
# print(create_person)
# create_person.save()
user = authenticate(
username=user_form.cleaned_data[ 'username' ],
password=password
)
login(request, user)
messages.success (request, "Вы успешно зарегестрированы!")
# return redirect('edit_person', id=last_i+1)
else:
messages.error(request, "Вы ввели неверный код!")
disabled2 = ""
return render (request, 'sign_ip.html',
{"user_form": user_form,
"sms_form": sms_form,
"id": id,
"disabled": disabled,
"disabled2":disabled2})
def register(request):
registered = False
# Messy to include profile stuff here
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = ProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
unique_slugify(profile, user.username)
profile.save()
# Give user permission to view and edit own profile
assign_perm('profiles.view_profile', user, profile)
assign_perm('profiles.change_profile', user, profile)
registered = True
# Invitation stuff
if 'invitation' in request.session:
# Retrieve invitation object
invitation = Invitation.objects.get(
id=request.session['invitation'])
# Create membership of profile with group
m = Membership(profile=profile,
giftgroup=invitation.gift_group)
m.save()
# Delete the used invitation from the (database and) session
# invitation.delete()
del request.session['invitation']
else:
# If user was not invited
profile.save()
# Check if all invited people have registered
invites = Invitation.objects.all()
all_users = [u.username for u in User.objects.all()]
for invite in invites:
if invite.to_name in all_users:
pass
else:
break
# User no longer has admin property
# # Check if user is an admin
# if user.profile.admin:
# permission_invites = Permission.objects.get(
# codename='send_invites')
# permission_assign = Permission.objects.get(
# codename='assign_pairs')
# user.user_permissions.add(
# permission_invites,
# permission_assign
# )
# Log user in after registration
user = authenticate(username=request.POST['username'],
password=request.POST['password'])
login(request, user)
else:
print(user_form.errors, profile_form.errors)
else:
# TODO repetition checking for invite
if 'invitation' in request.session:
# Retrieve invitation object
invitation = Invitation.objects.get(
id=request.session['invitation'])
user_form = UserForm(initial={
'username': invitation.to_name,
'email': invitation.to_email
})
user_form.fields['username'].widget.attrs['readonly'] = True
user_form.fields['email'].widget.attrs['readonly'] = True
else:
user_form = UserForm()
profile_form = ProfileForm()
return render(
request, 'registration/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def test_user_form_login_label(self):
form = UserForm()
self.assertEqual(form.fields['username'].label, 'Имя пользователя')
def test_user_form_photo_label(self):
form = UserForm()
self.assertEqual(form.fields['photo'].label, 'Аватарка')
def test_user_form_email_label(self):
form = UserForm()
self.assertEqual(form.fields['email'].label, 'Адрес электронной почты')
def test_user_form_password2_label(self):
form = UserForm()
self.assertEqual(form.fields['password2'].label,
'Подтверждение пароля')
def test_user_form_password1_label(self):
form = UserForm()
self.assertEqual(form.fields['password1'].label, 'Пароль')
def signup_volunteer(request):
registered = False
organization_list = get_organizations_ordered_by_name()
if organization_list:
if request.method == 'POST':
#each form must have it's own namespace (prefix) if multiple forms are to be put inside one <form> tag
user_form = UserForm(request.POST, prefix="usr")
volunteer_form = VolunteerForm(request.POST,
request.FILES,
prefix="vol")
if user_form.is_valid() and volunteer_form.is_valid():
if 'resume_file' in request.FILES:
my_file = volunteer_form.cleaned_data['resume_file']
if not validate_file(my_file):
return render(
request, 'registration/signup_volunteer.html', {
'user_form': user_form,
'volunteer_form': volunteer_form,
'registered': registered,
'organization_list': organization_list,
})
user = user_form.save()
user.set_password(user.password)
user.save()
volunteer = volunteer_form.save(commit=False)
volunteer.user = user
#if an organization isn't chosen from the dropdown, then organization_id will be 0
organization_id = request.POST.get('organization_name')
organization = get_organization_by_id(organization_id)
if organization:
volunteer.organization = organization
volunteer.save()
registered = True
return HttpResponseRedirect(reverse('home:index'))
else:
print user_form.errors, volunteer_form.errors
return render(
request, 'registration/signup_volunteer.html', {
'user_form': user_form,
'volunteer_form': volunteer_form,
'registered': registered,
'organization_list': organization_list,
})
else:
user_form = UserForm(prefix="usr")
volunteer_form = VolunteerForm(prefix="vol")
return render(
request, 'registration/signup_volunteer.html', {
'user_form': user_form,
'volunteer_form': volunteer_form,
'registered': registered,
'organization_list': organization_list,
})
else:
return render(request, 'organization/add_organizations.html')
def signup_administrator(request):
"""
This method is responsible for diplaying the register user view
Register Admin or volunteer is judged on the basis of users
access rights.
Only if user is registered and logged in and registered as an
admin user, he/she is allowed to register others as an admin user
"""
registered = False
organization_list = get_organizations_ordered_by_name()
if organization_list:
#if request.user.username != '' and request.user.is_authenticated(
#) and checkAdmin(request.user):
if request.method == 'POST':
user_form = UserForm(request.POST, prefix="usr")
administrator_form = AdministratorForm(request.POST,
prefix="admin")
if user_form.is_valid() and administrator_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
administrator = administrator_form.save(commit=False)
administrator.user = user
#if organization isn't chosen from dropdown, the organization_id will be 0
organization_id = request.POST.get('organization_name')
organization = get_organization_by_id(organization_id)
if organization:
administrator.organization = organization
administrator.save()
registered = True
return HttpResponseRedirect(reverse('home:index'))
else:
print user_form.errors, administrator_form.errors
return render(
request, 'registration/signup_administrator.html', {
'user_form': user_form,
'administrator_form': administrator_form,
'registered': registered,
'organization_list': organization_list,
})
else:
user_form = UserForm(prefix="usr")
administrator_form = AdministratorForm(prefix="admin")
return render(
request, 'registration/signup_administrator.html', {
'user_form': user_form,
'administrator_form': administrator_form,
'registered': registered,
'organization_list': organization_list,
})
else:
return render(request, 'organization/add_organizations.html')
def post(self, request):
organization_list = get_organizations_ordered_by_name()
if organization_list:
if request.method == 'POST':
user_form = UserForm(request.POST, prefix="usr")
volunteer_form = VolunteerForm(request.POST,
request.FILES,
prefix="vol")
if user_form.is_valid() and volunteer_form.is_valid():
password1 = request.POST.get('usr-password')
password2 = request.POST.get('usr-confirm_password')
if not match_password(password1, password2):
self.match_error = True
return render(
request, 'registration/signup_volunteer.html', {
'user_form': user_form,
'volunteer_form': volunteer_form,
'registered': self.registered,
'phone_error': self.phone_error,
'match_error': self.match_error,
'organization_list': self.organization_list,
})
vol_country = request.POST.get('vol-country')
vol_phone = request.POST.get('vol-phone_number')
if (vol_country and vol_phone):
if not validate_phone(vol_country, vol_phone):
self.phone_error = True
return render(
request, 'registration/signup_volunteer.html',
{
'user_form': user_form,
'volunteer_form': volunteer_form,
'registered': self.registered,
'phone_error': self.phone_error,
'organization_list':
self.organization_list,
})
if 'resume_file' in request.FILES:
my_file = volunteer_form.cleaned_data['resume_file']
if not validate_file(my_file):
return render(
request, 'registration/signup_volunteer.html',
{
'user_form': user_form,
'volunteer_form': volunteer_form,
'registered': self.registered,
'phone_error': self.phone_error,
'organization_list':
self.organization_list,
})
user = user_form.save()
user.set_password(user.password)
user.save()
volunteer = volunteer_form.save(commit=False)
volunteer.user = user
# if an organization isn't chosen from the dropdown,
# then organization_id will be 0
organization_id = request.POST.get('organization_name')
organization = get_organization_by_id(organization_id)
if organization:
volunteer.organization = organization
else:
unlisted_org = request.POST.get(
'vol-unlisted_organization')
org = Organization.objects.create(
name=unlisted_org, approved_status=False)
org.save()
volunteer.organization = org
volunteer.reminder_days = 1
volunteer.save()
current_site = get_current_site(request)
mail_subject = 'Activate your account.'
message = render_to_string(
'registration/acc_active_email.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
to_email = volunteer_form.cleaned_data.get('email')
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
return render(request, 'home/email_ask_confirm.html')
else:
return render(
request, 'registration/signup_volunteer.html', {
'user_form': user_form,
'volunteer_form': volunteer_form,
'registered': self.registered,
'phone_error': self.phone_error,
'organization_list': self.organization_list,
})
else:
return render(request, 'home/home.html', {'error': True})
def post(self, request, *args, **kwargs):
form = UserForm(request.POST)
return super(UserCreate, self).form_valid(form)
def post(self, request, *args, **kwargs):
print("submitted form")
form = UserForm(request.POST)
return super(UserUpdate, self).form_valid(form)
def post(self, request):
if request.method == 'POST':
user_form = UserForm(request.POST, prefix="usr")
alumni_form = AlumniForm(request.POST, request.FILES, prefix="alu")
if user_form.is_valid() and alumni_form.is_valid():
password1 = request.POST.get('usr-password')
password2 = request.POST.get('usr-confirm_password')
if not match_password(password1, password2):
self.match_error = True
return render(
request, 'registration/signup_alumni.html', {
'user_form': user_form,
'alumni_form': alumni_form,
'registered': self.registered,
'phone_error': self.phone_error,
'match_error': self.match_error,
'country_list': self.country_list,
'city_list': self.city_list,
'region_list': self.region_list,
})
try:
alu_country_name = request.POST.get('current_country')
alu_country = Country.objects.get(name=alu_country_name)
except ObjectDoesNotExist:
alu_country = None
try:
alu_state_name = request.POST.get('current_state')
alu_state = Region.objects.get(name=alu_state_name)
except ObjectDoesNotExist:
alu_state = None
try:
alu_city_name = request.POST.get('current_city')
alu_city = City.objects.get(name=alu_city_name)
except ObjectDoesNotExist:
alu_city = None
alu_phone = request.POST.get('alu-phone_number')
if alu_country and alu_phone:
if not validate_phone(alu_country, alu_phone):
self.phone_error = True
return render(
request, 'registration/signup_alumni.html', {
'user_form': user_form,
'alumni_form': alumni_form,
'registered': self.registered,
'phone_error': self.phone_error,
'match_error': self.match_error,
'country_list': self.country_list,
'city_list': self.city_list,
'region_list': self.region_list,
})
user = user_form.save(commit=False)
user.set_password(user.password)
user.is_active = False
user.save()
alumni = alumni_form.save(commit=False)
alumni.user = user
alumni.country = alu_country
alumni.city = alu_city
alumni.state = alu_state
alumni.save()
print('nhi nhi yha pahooncha')
current_site = get_current_site(request)
mail_subject = 'Activate your account.'
message = render_to_string(
'registration/acc_active_email.html', {
'user':
user,
'domain':
current_site.domain,
'uid':
force_text(urlsafe_base64_encode(force_bytes(
user.pk))),
'token':
account_activation_token.make_token(user),
})
to_email = alumni_form.cleaned_data.get('email')
send_mail(mail_subject, message, settings.EMAIL_HOST_USER,
[to_email])
print('reached')
return render(request, 'HomePage/email_ask_confirm.html')
else:
print('yha pahooncha kya')
return render(
request, 'registration/signup_alumni.html', {
'user_form': user_form,
'alumni_form': alumni_form,
'registered': self.registered,
'phone_error': self.phone_error,
'match_error': self.match_error,
'country_list': self.country_list,
'city_list': self.city_list,
'region_list': self.region_list,
})
def register(request):
registered = False
if request.method == 'POST':
# Get info from "both" forms
# It appears as one form to the user on the .html page
user_form = UserForm(request.POST, request.FILES)
profile_form = IndividualProfileInfoForm(data=request.POST)
# Check to see both forms are valid
if user_form.is_valid() and profile_form.is_valid():
# Save User Form to Database
user = user_form.save()
# Hash the password
user.set_password(user.password)
user.is_Team_Leader = False
user.is_Individual = True
# Update with Hashed password
# Now we deal with the extra info!
# Can't commit yet because we still need to manipulate
profile = profile_form.save(commit=False)
# Set One to One relationship between
# UserForm and IndividualProfileInfoForm
profile.user = user
# Check if they provided a profile picture
if 'profile_pic' in request.FILES:
print('found it')
# If yes, then grab it from the POST form reply
user.profile_pic = request.FILES['profile_pic']
# Now save model
user.save()
profile.save()
# Registration Successful!
registered = True
else:
# One of the forms was invalid if this else gets called.
print(user_form.errors, profile_form.errors)
else:
# Was not an HTTP post so we just render the forms as blank.
user_form = UserForm()
profile_form = IndividualProfileInfoForm()
# This is the render and context dictionary to feed
# back to the registration.html file page.
return render(
request, 'registration/registration.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
