def register_user(request):
if request.method == 'POST':
register = RegisterForm(request.POST, prefix='register')
usrprofile = ProfileForm(request.POST, prefix='profile')
print(register.is_valid(), register.errors)
print(usrprofile.is_valid())
if register.is_valid() * usrprofile.is_valid():
user = register.save()
usrprof = usrprofile.save(commit=False)
usrprof.user = user
usrprof.set_token()
usrprof.subscribed = '1'
usrprof.save()
return HttpResponseRedirect('/account/')
else:
messages.info(request, 'Password do not match!')
userform = RegisterForm(prefix='register')
userprofileform = ProfileForm(prefix='profile')
#return HttpResponse('errors')
return render(
request, 'accounts/register.html', {
'messages': messages.get_messages(request),
'userform': userform,
'userprofileform': userprofileform
})
else:
userform = RegisterForm(prefix='register')
userprofileform = ProfileForm(prefix='profile')
return render(request, 'accounts/register.html', {
'userform': userform,
'userprofileform': userprofileform
})
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 register_user(request):
if request.method == 'GET':
if request.user.is_authenticated:
return redirect('all quotes')
context = {
'user_form': RegisterForm(),
'profile_form': ProfileForm(),
}
return render(request, 'registration/register.html', context)
else:
user_form = RegisterForm(request.POST)
profile_form = ProfileForm(request.POST, request.FILES)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
login(request, user)
return redirect('all quotes')
context = {
'user_form': user_form,
'profile_form': profile_form,
}
return render(request, 'registration/register.html', context)
def signup_user(request):
if request.method == 'GET':
context = {
'form': RegisterForm(),
}
return render(request, 'accounts/signup.html', context)
else:
# &qy^a}ay4J\vpXeR
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save()
profile = Profile(
user=user,
phone=request.POST['phone']
)
profile.save()
login(request, user)
return redirect('index')
else:
context = {
'form': form,
}
return render(request, 'accounts/signup.html', context)
def register(request):
"""
Renders the registration page
"""
if request.user.is_authenticated:
return redirect(reverse("index"))
if request.method == "POST":
register_form = RegisterForm(request.POST)
if register_form.is_valid():
register_form.save()
user = auth.authenticate(username=request.POST["username"],
password=request.POST["password1"])
if user:
auth.login(user=user, request=request)
messages.success(
request, "Registration successful, you are now signed in!")
return redirect(reverse("index"))
else:
messages.error(
request,
"Account registration not availiable at this time.")
else:
register_form = RegisterForm()
return render(request, "register.html", {"register_form": register_form})
def register(request):
'''
注册视图
注意加"/"和不加"/"的区别
'''
template_var = {}
if request.method == "POST":
form = RegisterForm(data=request.POST.copy()) # 使用提交的数据构建表单
if form.is_valid(): # 表单字段验证正常
post_data = form.cleaned_data
username = post_data["username"]
password = post_data["password"]
email = post_data["email"]
user = User.objects.create_user(username, email, password) # 创建用户
in_json = json.dumps([True,]) # 创建成功，向前端返回True
return HttpResponse(in_json, content_type='application/json')
else:
in_json = json.dumps([False, form.errors]) # 创建失败
print(in_json)
return HttpResponse(in_json, content_type='application/json')
# 注册完毕 重定向到登录页面
#return HttpResponseRedirect("/accounts/index")
else:
form = RegisterForm()
template_var["form"] = form
return render(request, "accounts/register.html", template_var)
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 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.session.get('is_login'):
return HttpResponseRedirect(reverse('miunottingham:main_page'))
if request.method == "POST":
regform = RegisterForm(request.POST)
if regform.is_valid():
username = regform.cleaned_data['username']
password1 = regform.cleaned_data['password1']
password2 = regform.cleaned_data['password2']
email = regform.cleaned_data['email']
if User.objects.filter(username=username):
message = 'username already exists'
return render(request, 'accounts/register.html', locals())
else:
if User.objects.filter(email=email):
message = 'email address already exists'
return render(request, 'accounts/register.html', locals())
else:
if password1 != password2:
message = 'password does not match'
return render(request, 'accounts/register.html',
locals())
new_user = User()
new_user.username = username
# encrypt password
new_user.password = hash_code(password2)
new_user.email = email
new_user.has_confirmed = True
new_user.save()
return HttpResponseRedirect(reverse('accounts:login_test'))
regform = RegisterForm()
return render(request, 'accounts/register.html', locals())
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):
if request.method == 'POST':
form = RegisterForm(request.POST)
if (form.is_valid()):
user = form.save()
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password1')
# save user depending on if the user type
user = authenticate(username=username, password=password)
login(request, user)
# determine if user is a donator or a receiver
if (form.cleaned_data.get('user_type') == 0):
# donator
donator = Donator()
donator.description = form.cleaned_data.get('description')
donator.user = user
donator.save()
else:
# receiver
receiver = Receiver()
receiver.description = form.cleaned_data.get('description')
receiver.user = user
receiver.save()
return redirect('Accounts:user_dashboard')
else:
print("error")
print(form.errors)
else:
form = RegisterForm()
return render(request, 'register.html', {'form': form})
def business_signup(request):
if request.user.is_authenticated():
return redirect("home")
else:
form = RegisterForm(request.POST or None)
next_url = request.POST.get('next')
if form.is_valid():
username = form.cleaned_data['username']
email = form.cleaned_data['email']
password = form.cleaned_data['password2']
new_user = MyUser()
new_user.username = username
new_user.email = email
new_user.set_password(password)
new_user.save()
user = authenticate(username=username, password=password)
if user is not None:
new_advertiser, created = Advertiser.objects.get_or_create(
user=user)
new_advertiser.save()
login(request, user)
if next_url is not None:
return HttpResponseRedirect(next_url)
return HttpResponseRedirect(reverse("home"))
context = {
"form": form,
"action_url": reverse("contact:business_signup"),
}
return render(request, 'advertisers/business_signup.html', context)
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.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_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 user_register(request):
if request.method == 'POST':
form = RegisterForm(request=request, data=request.POST)
params = request.POST.get('params')
if form.is_valid():
user = form.register()
email = form.cleaned_data['email']
username = form.cleaned_data['username']
# password = form.cleaned_data['password']
# 正式处理发送邮件
# 加密用户的身份信息，生成激活token
serializer = TJSS(settings.SECRET_KEY, 900)
info = {'confirm': user.id}
token = serializer.dumps(info)
# 默认解码为utf8
token = token.decode()
# 使用celery发邮件
send_activate_email.delay(email, username, token)
rest = {'data': '注册成功！邮件正在发送，请前往邮箱激活账号'}
return JsonResponse(rest)
else:
if params in ['password', 'repassword']:
error = form.non_field_errors()
else:
error = form.errors.get(params)
rest = {'data': error}
return JsonResponse(rest)
form = RegisterForm(request)
return render(request, 'login/register.html', {'form': form})
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 post(self, request):
form = RegisterForm(request.POST)
if form.is_valid():
form.save()
return redirect('login')
else:
return redirect('login')
def test_for_blank_username(self):
form = RegisterForm(data={'username': ''})
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors['username'],
["This field is required."]
)
def register_user(request):
"""Register new users"""
# Get request origin to pass to the form
next = request.GET.get('next', '/')
accounts_form = RegisterForm()
# check if a form was submitted
if request.method == 'POST':
# Get request origin from form
next = request.POST.get('next', '/')
# Create form object with submitted data
accounts_form = RegisterForm(request.POST)
if accounts_form.is_valid():
# when valid save user to the database
user = accounts_form.save()
username = accounts_form.cleaned_data.get('username')
# Add user to the customer group
group = Group.objects.get(name='customer')
user.groups.add(group)
# Display success message
auth.login(user=user, request=request)
messages.success(
request, 'You are now registered and logged in as ' + username)
# Return to request origin
return redirect(next)
# Show the register page
return render(request, 'register.html',
{'accounts_form': accounts_form,
'next': next,
'title': 'Please register to use the webshop'})
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_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 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_page(request):
form = RegisterForm(request.POST or None)
context = {'form': form}
if form.is_valid():
form.save()
return redirect("/")
return render(request, 'register.html', context)
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 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_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 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()
else:
form = RegisterForm()
context = {'form': form}
return render(request, 'accounts/register.html', context)
def register(response):
if response.method == 'POST':
form = RegisterForm(response.POST)
if form.is_valid():
form.save()
return redirect("/")
else:
form = RegisterForm()
return render(response, 'registration/signup.html', {'form': form})
def signup(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
form.save()
else:
form = RegisterForm()
return render(request, 'accounts/Signup.html', {"form": form})
def signup(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save()
auth_login(request, user)
return redirect('index')
else:
form = RegisterForm()
return render(request, 'accounts/signup.html', {'form': form})
def signUpVIew(request):
if request.POST:
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save()
login(request, user)
return redirect("main page")
else:
form = RegisterForm()
return render(request, 'register.html', {'registeform': form})
def test_required_accept_button_false(self):
data = {
'username': self.user.username,
'password': self.user.password,
'password2': self.user.password,
'email': '*****@*****.**',
'accept': False
}
form = RegisterForm(data=data)
self.assertFalse(form.is_valid())
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 test_for_unique_username(self):
username = uuid.uuid4().hex[:8].upper()
password = uuid.uuid4().hex[:8].upper()
register_user_form = RegisterForm(data={'username': username, 'password': password})
register_user_form.save()
form = RegisterForm(data={'username': username})
self.assertFalse(form.is_valid())
self.assertTrue("A user with that username already exists" in str(form.errors['username']))
def register_view(response):
form = RegisterForm()
if response.method == 'POST':
form = RegisterForm(response.POST)
if form.is_valid():
form.save()
return redirect('keci_home')
context = {'form': form}
return render(response, 'registration/register.html', context=context)
def register(response):
if response.method == "POST":
form = RegisterForm(response.POST)
if form.is_valid():
form.save()
return redirect("/")
else:
form = RegisterForm()
return render(response, "register/register.html", {"form": form})
def test_register_form(self):
form = RegisterForm(
data={
"email": "*****@*****.**",
"username": "******",
"password1": "Justatest123",
"password2": "Justatest123",
})
self.assertTrue(form.is_valid())
def signup(response):
if response.method == "POST":
form = RegisterForm(response.POST)
if form.is_valid():
form.save()
# return redirect("/home")
else:
form = RegisterForm()
return render(response, "signup.html", {"form": form})
def register(request):
reg = RegisterForm(request.POST)
if request.POST and reg.is_valid():
reg.save()
return HttpResponseRedirect("/")
form = LoginForm()
args = {
'form': form,
'reg': reg,
}
return render(request, 'login.html', args)
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 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 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 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 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):
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 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 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 test_no_user_name(self):
""" do we fail appropriately if user did not submit a user name? """
form = RegisterForm({"password":"******", "user_name":""})
self.assertFalse(form.is_valid())
def test_register_form(self):
""" does our register form even function properly """
form = RegisterForm({"password":"******", "user_name":"Jared"})
self.assertTrue(form.is_valid())
