def register(request):
register_form = RegisterForm(request.POST)
if register_form.is_valid():
first_name = request.POST.get('first_name')
email = request.POST.get('email')
password = request.POST.get('password')
confirm_password = request.POST.get('confirm_password')
username = request.POST.get('username')
organization_name = request.POST.get('organization')
if password == confirm_password:
if Organization.objects.filter(name=organization_name):
pietrack_role = 'user'
organization_obj = Organization.objects.get(name=organization_name)
else:
pietrack_role = 'admin'
organization_obj = Organization.objects.create(name=organization_name, slug=organization_name)
json_data = {'error': False}
new_user = User.objects.create_user(username=username, email=email, password=password,
first_name=first_name, organization=organization_obj,
pietrack_role=pietrack_role)
else:
json_data = {'error': True, 'error_password': '******'}
return HttpResponse(json.dumps(json_data), content_type='application/json')
else:
json_data = {'error': True, 'response': register_form.errors}
return HttpResponse(json.dumps(json_data), content_type='application/json')
def test_passwords_dont_match(self): data = self.data data['password2'] = '123test' form = RegisterForm(data) self.assertFalse(form.is_valid()) self.assertEqual(form["password2"].errors, ["You must type the same password each time"])
def register(request, token):
# check token
try:
token_object = signing.loads(token, max_age=settings.REGISTER_MAX_AGE)
email = token_object['email']
register = token_object['register']
except:
messages.error(request, u'Link de ativação inválido.')
return redirect('accounts_register_confirm_email')
# check for registered user
if User.objects.filter(email=email):
messages.error(request, u'E-mail já cadastrado.')
return redirect('accounts_register_confirm_email')
# process form
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
# get new user
new_user = form.save(email=email)
# login new user
auth_login(request, new_user)
# make message
messages.success(request, u'Conta criada com sucesso.')
# redirect to index
return redirect('staticpages_index')
else:
form = RegisterForm()
return render(request, 'accounts/register.html', {'form': form})
def register(request):
if request.method == 'POST':
if 'recaptcha_challenge_field' in request.POST:
check_captcha = captcha.submit(request.POST['recaptcha_challenge_field'], request.POST['recaptcha_response_field'], settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR'])
if not check_captcha.is_valid:
messages.error(request, "Captcha was incorrect!") #% check_captcha.error_code)
return HttpResponseRedirect(reverse('register'))
form = RegisterForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
username,email,password = cd['username'], cd['email'], cd['password']
new_user = User.objects.create_user(username = username, email = email, password = password)
#TODO: fix this, weird postgres issue in django 1.3 see trac issue #15682
user = User.objects.get(username=new_user.username)
profile = UserProfile.objects.create(user=user)
messages.success(request, "Thanks for registering %s! Welcome to tehorng." % new_user)
authed_user = authenticate(username=username, password=password)
login(request, authed_user)
return HttpResponseRedirect(reverse('profile'))
else:
form = RegisterForm(initial=request.POST)
return render_to_response('registration/register.html', {
'form': form,
'captcha': mark_safe(captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY)),
}, context_instance=RequestContext(request))
def test_emails_dont_match(self): data = self.data data['email2'] = '*****@*****.**' form = RegisterForm(data) self.assertFalse(form.is_valid()) self.assertEqual(form["email2"].errors, ["You must type the same e-mail address each time"])
def register(request):
if request.user.is_authenticated():
return redirect(reverse('home'))
next_uri = request.REQUEST.get('next', reverse('home'))
# rescuing poor users from infinite redirection loop
if next_uri == get_config('LOGIN_URL', reverse('login')):
next_uri = reverse('home')
register_form = RegisterForm()
if request.method == 'POST':
register_form = RegisterForm(request.POST)
if register_form.is_valid():
register_form.save()
username = register_form.cleaned_data['username']
password = register_form.cleaned_data['password1']
user = authenticate(username=username, password=password)
if user is not None:
auth_login(request, user)
messages.success(request, "Welcome aboard, {0}.".format(user))
return redirect(next_uri)
return {
'register_form': register_form,
'next': next_uri,
}
def post(self, request):
registerform = RegisterForm(request.POST)
if registerform.is_valid():
username = registerform.cleaned_data['username']
email = registerform.cleaned_data['email']
password = registerform.cleaned_data['password']
password_conf = registerform.cleaned_data['password_repeat']
if password != password_conf:
messages.error(request, "De wachtwoorden kwamen niet overeen")
return self.get(request)
User.objects._create_user(username=username, password=password, email=email, is_staff=False,
is_superuser=False)
user = User.objects.get(username=username)
user.first_name = registerform.cleaned_data['first_name']
user.last_name = registerform.cleaned_data['last_name']
user.save()
if user.pk != None:
messages.success(request, "Account aangemaakt!")
else:
messages.error(request, "Account niet aangemaakt")
return redirect("events:index")
else:
context = {'registerform': registerform}
return render(request, "account/new.html", context)
def register(request):
form = RegisterForm(request.POST or None)
if form.is_valid():
username = form.cleaned_data['username']
email = form.cleaned_data['email']
password = form.cleaned_data['password2']
#MyUser.objects.create_user(username=username, email=email, password=password)
new_user = MyUser()
new_user.username = username
new_user.email = email
new_user.is_active = False
messages.success(request, "Enregistrement terminé. Votre compte est maintenant en attente d'activation")
#new_user.password = password #WRONG
new_user.set_password(password) #RIGHT
new_user.save()
action_url = reverse("register")
title = "Register"
submit_btn = "Create free account"
context = {
"form": form,
"action_url": action_url,
"title": title,
"submit_btn": submit_btn
}
return render(request, "registration/registration_form.html", context)
def register(request):
if request.method == "POST":
if "recaptcha_challenge_field" in request.POST:
check_captcha = captcha.submit(
request.POST["recaptcha_challenge_field"],
request.POST["recaptcha_response_field"],
settings.RECAPTCHA_PRIVATE_KEY,
request.META["REMOTE_ADDR"],
)
if not check_captcha.is_valid:
messages.error(request, "Captcha didn't pan out! '%s'" % check_captcha.error_code)
return HttpResponseRedirect(reverse("register"))
form = RegisterForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
username, email, password = cd["username"], cd["email"], cd["password"]
new_user = User.objects.create_user(username=username, email=email, password=password)
profile = UserProfile.objects.create(user=new_user)
messages.success(request, "Thanks for registering %s! Welcome to tehorng." % new_user)
authed_user = authenticate(username=username, password=password)
login(request, authed_user)
return HttpResponseRedirect(reverse("profile"))
else:
form = RegisterForm()
return render_to_response(
"registration/register.html",
{"form": form, "captcha": mark_safe(captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY))},
context_instance=RequestContext(request),
)
def test_empty(self):
form=RegisterForm({})
self.assertFalse(form.is_valid())
self.assertTrue(form['username'].errors)
self.assertTrue(form['email'].errors)
self.assertTrue(form['password'].errors)
self.assertTrue(form['re_password'].errors)
self.assertTrue(form.non_field_errors)
def test_form_valid(self):
"""
Check if the new user object is created
"""
view = RegisterView()
form = RegisterForm()
form.cleaned_data = {'username': '******', 'password': '******'}
view.form_valid(form)
self.assertTrue(User.objects.filter(username='******').exists())
def register(request, auth=None):
initial = {'auth_code': auth}
form = RegisterForm(request.POST or None, initial=initial)
if form.is_valid():
form.save()
messages.success(request, REGISTER_MESSAGE)
return redirect(reverse('accounts:login'))
context = {'form': form}
return render(request, 'accounts/register.html', context)
def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect("/accounts/login")
else:
form = RegisterForm()
context = RequestContext(request)
return render_to_response('accounts/register.html', {'form': form}, context_instance=context)
def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
new_user = form.save()
return HttpResponseRedirect('/')
else:
form = RegisterForm()
return render_to_response(
'registration/register.html',
{'form' : form,},
context_instance=RequestContext(request),
)
def register(request):
"""注册视图"""
template_var = {}
form = RegisterForm()
if request.method == "POST":
form = RegisterForm(request.POST.copy())
if form.is_valid():
form.save()
if _login(request, form.cleaned_data["username"], form.cleaned_data["password"], template_var):
return HttpResponseRedirect("/accounts/index")
template_var["form"] = form
return render(request, "accounts/register.html", template_var)
def test_clean(self):
"""
1. phone is already existed.
2. phone is new.
"""
form = RegisterForm()
# phone exists
user = UserFactory()
form.data = {'username': user.username}
self.assertRaises(forms.ValidationError, lambda: form.clean())
# new phone
form.data = {'username': '******'}
self.assertTrue('username' in form.clean())
def get(self, request, *args, **kwargs):
form = RegisterForm(request.POST or None)
if form.is_valid():
form.save()
user = authenticate(username=form.cleaned_data['email'], password=form.cleaned_data['password1'])
if user is not None:
auth_login(request, user)
return redirect('dashboard')
context = self.get_context_data(**kwargs)
context['form'] = form
return self.render_to_response(context)
def register(request):
'''注册视图'''
template_var={}
form = RegisterForm()
if request.method=="POST":
form=RegisterForm(request.POST.copy())
if form.is_valid():
username=form.cleaned_data["username"]
email=form.cleaned_data["email"]
password=form.cleaned_data["password"]
user=User.objects.create_user(username,email,password)
user.save()
_login(request,username,password)#注册完毕 直接登陆
return HttpResponseRedirect("/jizhang/first_login")
template_var["form"]=form
return render_to_response("accounts/register.html",template_var,context_instance=RequestContext(request))
def regist(request):
'''用户注册页'''
form = RegisterForm()
if request.method=="POST":
form=RegisterForm(request.POST.copy())
if form.is_valid():
username = form.cleaned_data["username"]
email = form.cleaned_data["email"]
password = form.cleaned_data["password"]
repassword = form.cleaned_data["repassword"]
print form
if password != repassword:
return HttpResponse('重复登录密码与登录密码不一致');
user = User.objects.create_user(username, email, password)
user.save()
validate_login(request, username, password)
return HttpResponseRedirect("/simpleblog/bloglist")
return render_to_response('accounts/register.html',{'form':form},context_instance=RequestContext(request));
def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
# get new user
new_user = form.save()
# login new user
auth_login(request, new_user)
# make message
messages.success(request, u'Conta criada com sucesso.')
# redirect to index
return redirect('shorturl_index')
else:
form = RegisterForm()
return render(request, 'accounts/register.html', {'form': form})
def register(request):
register_form = RegisterForm(request.POST, email=request.POST.get('email'))
errors = {}
if request.POST.get('organization'):
if User.objects.filter(organization__name__exact=request.POST.get('organization')).exists():
errors = {'organization': 'Please contact the admin to register for this organization'}
if register_form.is_valid() and not errors:
first_name = request.POST.get('first_name')
email = request.POST.get('email')
password = request.POST.get('password')
confirm_password = request.POST.get('confirm_password')
username = request.POST.get('username')
organization_name = request.POST.get('organization')
domain_name = request.POST.get('domain')
if password == confirm_password:
if Organization.objects.filter(name=organization_name):
pietrack_role = 'user'
organization_obj = Organization.objects.get(name=organization_name)
else:
pietrack_role = 'admin'
organization_obj = Organization.objects.create(
name=organization_name, slug=organization_name, domain=domain_name.lower())
json_data = {'error': False}
new_user = User.objects.create_user(username=username, email=email, password=password,
first_name=first_name, organization=organization_obj,
pietrack_role=pietrack_role)
user = auth.authenticate(username=email, password=password)
if user:
if user.is_active:
auth.login(request, user)
messages.success(request, 'You are successfully registered !')
else:
json_data = {'error': True, 'error_password': '******'}
return HttpResponse(json.dumps(json_data), content_type='application/json')
else:
response = dict(register_form.errors.items())
if errors:
response = merge_two_dicts(dict(register_form.errors.items()), errors)
json_data = {'error': True, 'response': response}
return HttpResponse(json.dumps(json_data), content_type='application/json')
def register(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/majors/')
if request.method == "POST":
form = RegisterForm(request.POST)
if form.is_valid():
# grab cleaned values from form
username = form.cleaned_data['username']
email = form.cleaned_data['username']
location = form.cleaned_data['location']
headline = form.cleaned_data['headline']
password = form.cleaned_data['password']
# create user
user = User.objects.create_user(username,email,password)
# user.save()
# create provile
user.profile.headline = headline
user.profile.location = location
user.profile.save()
# make sure using right backend
request.session['_auth_user_backend'] = 'django.contrib.auth.backends.ModelBackend'
# log user in
user = authenticate(username=username,password=password)
# make sure authentication worked
if user is not None:
auth_login(request,user)
# send to personalization
return HttpResponseRedirect('/majors/')
else:
form = RegisterForm()
return render_to_response('accounts/register.html',{'form':form},context_instance=RequestContext(request))
def register(request):
if '_auth_user_id' in request.session:
return HttpResponseRedirect('/')
if request.method =='POST':
form=RegisterForm(request.POST)
if form.is_valid():
user=User.objects.create_user(
username=form.cleaned_data['username'],
password=form.cleaned_data['password'],
email=form.cleaned_data['email'],
)
user_profile=user.get_profile()
user_profile.nickname=form.cleaned_data['nickname']
user_profile.save()
Cart.objects.create(user=user)
return HttpResponseRedirect('/accounts/register/success/')
else:
form=RegisterForm()
return render_to_response('reg_form.html', {
'form': form},
context_instance=RequestContext(request),
)
def register(request):
'''
register a new user (as a django.contrib.auth.models.User object)
* POST - validate form and save user info
* GET - render registration form
'''
if request.method == 'GET':
form = RegisterForm()
context = {'form': form}
return render(request, 'accounts/register.html', context)
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
new_user = form.save()
new_user = authenticate(username=request.POST['username'],
password=request.POST['password1'])
login(request, new_user)
return HttpResponseRedirect('/')
else:
context = {'form': form}
return render(request, 'accounts/register.html', context)
def register_view(request):
# Same email alone is checked against the Users table
def rand_from_name(f_name, l_name):
return l_name[:3]+f_name[:3]+'_' + \
''.join(random.choice('0123456789abcdefghijklmnopqrstuvwxyz') for _ in range(6))
# if this is a POST request we need to process the form data
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = RegisterForm(request.POST)
# check whether it's valid:
if form.is_valid():
# process the data in form.cleaned_data as required
# ...
# redirect to a new URL:
password = form.cleaned_data['password']
email = form.cleaned_data['email']
first_name = form.cleaned_data['firstName']
last_name = form.cleaned_data['lastName']
while True:
try:
username = rand_from_name(first_name.lower(), last_name.lower()) # generating username
user = User.objects.create_user(username, email=email, password=password)
break
except Exception:
pass
user.first_name = first_name
user.last_name = last_name
user.save()
UserExtended(user=user).save()
send_verification_email(user)
return render(request, "accounts/new_user_registered.html", {})
# if a GET (or any other method) we'll create a blank form
else:
form = RegisterForm()
return render(request, "accounts/register.html", {'registerForm': form})
def user_signup(request):
next = request.GET.get('next', '') or get_referer_view(request, '/')
form = RegisterForm()
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
email = form.cleaned_data['email']
devtype = form.cleaned_data['devtype']
com_tem_per = form.cleaned_data['com_tem_per']
contact = form.cleaned_data['contact']
mobile = form.cleaned_data['mobile']
user = User.objects.create_user(username=username, password=password, email=email)
profile = Profile.objects.create(user=user)
developer = Developer.objects.create(profile=profile, devtype=devtype, com_tem_per=com_tem_per, contact=contact, mobile=mobile)
user = authenticate(username=username, password=password)
if user and user.is_active:
login(request, user)
return redirect(reverse('developer:games'))
return render(request, 'accounts/signup.html', dict(form=form, next=next))
def register(request):
if hasattr(request, 'user'):
if request.user.is_authenticated():
return redirect('/')
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
id = form.cleaned_data['id']
name = form.cleaned_data['name']
password = form.cleaned_data['password']
type = form.cleaned_data['type']
new_user = User.objects.create_user(username=id, password=password)
if type == Student.user_type:
new_student = Student.objects.create(id = id, user=new_user, name=name)
new_user.user_permissions = STUDENT_PERMISSION
if type == Teacher.user_type:
title = form.cleaned_data['title']
new_teacher = Teacher.objects.create(id = id, user=new_user, name=name, title=title)
new_user.user_permissions = TEACHER_PERMISSION
if type == Manager.user_type:
new_manager = Manager.objects.create(id = id, user=new_user, name=name)
new_user.user_permissions = MANAGER_PERMISSION
user = authenticate(username=id, password=password)
auth_login(request, user)
return redirect('/')
else:
form = RegisterForm()
context = {
'form': form
}
return TemplateResponse(request, "accounts/register.html", context)
def register(request):
template_var={}
form=RegisterForm()
if request.method == "POST":
#使用表单时直接request.POST.copy()这样把POST数据copy一份给表单
form=RegisterForm(request.POST.copy())
#生成表单之后，调用is_valid检查它的正确性，把clean那些数据全部执行
#一遍，把error信息全部放在form里,放进区之后怎么表现出来？
#判断表单是否有效
if form.is_valid():
username=form.cleaned_data["username"]
email=form.cleaned_data["email"]
password=form.cleaned_data["password"]
#验证成功并且表单有效时，获得用户名、密码、email后用这三者为参数创建用户
user=User.objects.create_user(username,email,password)
#创建好用户之后要保存倒数据库中
user.save()
if _login(request,username,password,template_var):
#创建成功后进行重定向
return HttpResponseRedirect("/accounts/index")
#把form中的错误信息填到模板对应得变量中,就可以在模板templates/accounts/
#对应的html文件中展示出错误信息
template_var["form"]=form
return render(request,"accounts/register.html",template_var)
def register_view(request):
logined_redirect(request)
if request.method == "POST":
form = RegisterForm(request.POST)
if form.is_valid():
username = form.cleaned_data["username"]
password = form.cleaned_data["password"]
email = form.cleaned_data["email"]
user = User.objects.create(username = username, email = email)
user.set_password(password)
user.save()
user = authenticate(username = username, password = password)
if user is not None:
if user.is_active:
login(request, user)
return redirect("/")
else:
form = RegisterForm()
return render(request, "accounts/register.html", {
"form":form
})
def register(request):
if request.user.is_authenticated():
return redirect(reverse('home'))
_request = None
if request.method == 'POST':
_request = request.POST.copy()
else:
_request = request.GET.copy()
next_uri = _request.get('next',
get_config('FIRST_LOGIN_REDIRECT_URL', reverse('first_steps')))
# rescuing poor users from infinite redirection loop
if next_uri == get_config('LOGIN_URL', reverse('login')):
next_uri = get_config('FIRST_LOGIN_REDIRECT_URL',
reverse('first_steps'))
register_form = RegisterForm()
if request.method == 'POST':
register_form = RegisterForm(request.POST)
if register_form.is_valid():
register_form.save()
username = register_form.cleaned_data['username']
password = register_form.cleaned_data['password1']
user = authenticate(username=username, password=password)
if user is not None:
auth_login(request, user)
messages.success(request, "Welcome aboard, {0}.".format(user))
badges.possibly_award_badge("logged_in",
user=user)
return redirect(next_uri)
return {
'register_form': register_form,
'next': next_uri,
}
def test_register_form_no_data(self):
form = RegisterForm(data={})
self.assertFalse(form.is_valid())
self.assertEquals(len(form.errors), 4)
def test_user_already_exists(self):
form = RegisterForm(self.data)
self.assertFalse(form.is_valid())
self.assertEqual(form["username"].errors,
["Username is already taken"])
def post(self, request, *args, **kwargs):
form = RegisterForm(request.POST)
if form.is_valid():
email = form.cleaned_data['email']
password = form.cleaned_data['password']
account = Account.objects.create_user(
email=email,
password=password,
)
primary_profile = request.POST.get('primary_profile')
if primary_profile == "1":
# doctor profile
profile = account.create_doctor_profile()
account.user_settings = {
'primary_profile': {
'type': 'doctor',
'pk': profile.pk
},
}
next_url = reverse('doctor_profile_home')
elif primary_profile == "2":
# patient profile
next_url = reverse('base_profile_home_view')
elif primary_profile == "3":
next_url = reverse('receptionist_profile_home')
profile = account.create_receptionist_profile()
account.user_settings = {
'primary_profile': {
'type': 'receptionist',
'pk': profile.pk
}
}
account.save()
user = authenticate(email=account.email, password=password)
if user is not None:
login(request, user)
messages.success(
request,
"Account created! Please fill up your profile.",
extra_tags="success")
request.session['login_origin'] = 'internal'
return HttpResponseRedirect(
f"{reverse('profile_settings_basic_info_view')}?next={next_url}"
)
else:
messages.error(request,
"Unable to authenticate your account",
extra_tags="danger")
return HttpResponseRedirect(reverse('accounts_register'))
else:
errors = PrettyErrors(errors=form.errors)
messages.error(request, errors.as_html(), extra_tags="danger")
return HttpResponseRedirect(reverse('accounts_register'))
def test_form_has_field(self):
form = RegisterForm()
expected = ['username', 'email', 'first_name', 'last_name', 'password1', 'password2']
actual = list(form.fields)
self.assertSequenceEqual(expected, actual)
def test_correct(self):
form = RegisterForm(self.correct_data)
self.assertTrue(form.is_valid())
def test_register_form_is_not_valid_with_bad_user_data(self):
# Test if register form with bad user data is invalide
registerForm = RegisterForm(self.bad_user_data)
self.assertFalse(registerForm.is_valid())
def test_register_form_is_valid_with_good_user_data(self):
# Test if register form with bad user data is valide
registerForm = RegisterForm(self.good_user_data)
self.assertTrue(registerForm.is_valid())
