def register(request):
url='/register'
sub='Register'
if request.method == "POST":
form = RegisterForm(request.POST)
if form.is_valid():
nm = form.cleaned_data['name']
gender = form.cleaned_data['gender']
reg_no = form.cleaned_data['reg_no']
email = form.cleaned_data['email']
pwd = form.cleaned_data['password']
x = OjUser.objects.filter(username=email)
if x:
return HttpResponse('Email exists')
l = OjUser.objects.create(
username = reg_no,
first_name = nm,
email = email,
gender = gender,
reg_no = reg_no,
)
l.set_password(pwd)
l.save()
text="Registered Successfully"
return render(request,"index.html",{'text':text})
else:
return render(request,'register.html',{'form':form,'url':url,'sub':sub})
else:
form = RegisterForm()
return render(request,'register.html',{'form':form,'url':'/register','sub':'Register'})
def register_wholesale(request):
"""Регистрация оптового покупателя"""
if request.POST:
form = RegisterForm(request.POST)
company_form = CompanyForm(request.POST)
if form.is_valid() and company_form.is_valid():
instance = form.save(commit=False)
instance.set_password(form.cleaned_data["password"])
instance.status = User.STATUS_WHOLESALE
instance.save()
instance = authenticate(email=instance.email, password=form.cleaned_data["password"])
user_login(request, instance)
company = company_form.save(commit=False)
company.user = request.user
company.save()
return redirect(reverse("users.auth.register.completed"))
else:
form = RegisterForm()
company_form = CompanyForm()
context = {"form": form, "company_form": company_form}
return render(request, "users/auth/register_wholesale.html", context)
def register(request, **kwargs):
if request.user.is_authenticated():
messages.error(request, 'Ya estas registrado')
logging.error('Ya estas registrado: %s ' % request.user.username)
return redirect(reverse('error'))
form = RegisterForm()
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save()
messages.success(request, _("Bienvenido a %s" % current_site.name))
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password1'])
auth_login(request, user)
return redirect(reverse('home'))
context = {
'form': form
}
c = template.RequestContext(request, context)
return render_to_response('page.users.register.html', c)
def register():
form = RegisterForm(request.form)
if form.validate_on_submit():
# Create new User instance
user = User(
name=form.username.data,
email=form.email.data,
password=form.password.data,
)
try:
user.save()
except UniquenessViolation, err:
if err.column_name == "email":
form.email.errors.append("There is already an account registered with that email address.")
elif err.column_name == "name":
form.username.errors.append("There is already an account registered with that username.")
else:
login_user(user)
# Flash a message that gets displayed only once.
flash("Welcome to the herd.")
return redirect(url_for("users.profile"))
finally:
def handle_register(request, email_template=None, email_subject=None,
email_data=None):
"""Handle to help registration."""
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
form = try_send_email_with_form(
RegistrationProfile.objects.create_inactive_user,
form, 'email',
form.cleaned_data['username'],
form.cleaned_data['password'],
form.cleaned_data['email'],
locale=request.locale,
email_template=email_template,
email_subject=email_subject,
email_data=email_data)
if not form.is_valid():
# Delete user if form is not valid, i.e. email was not sent.
# This is in a POST request and so always pinned to master,
# so there is no race condition.
User.objects.filter(email=form.instance.email).delete()
else:
statsd.incr('user.register')
return form
return RegisterForm()
def create_user(request):
#If the user is trying to add info to the server,
if request.method == 'POST':
#Feed as arguments to RegisterForm the inputs from the user.
create_user_form = RegisterForm(request.POST)
#If username and password are of the right length and email is of the valid form,
#And password and confirm password identical,
if create_user_form.is_valid():
#Don't save the user in creation as a new user yet.
new_user = create_user_form.save()
pw = create_user_form.cleaned_data.get('password')
new_user.set_password( pw )
new_user.save()
#Then create UserProfile object from User object.
new_UserProfile = UserProfile(user=new_user)
#new_UserProfile.user = new_user
new_UserProfile.save() #Then save.
#Render a Welcome to GroupFit page if the input info is valid.
#No need to customize welcome page unless we want to just switch the name: Welcome, username!
return render(request, 'welcome.html')
#Send an email as well.
else:
#If the user didn't plug in anything, create_user_form will be an empty shell?
create_user_form = RegisterForm()
return render(request, 'register.html', {'create_user_form': create_user_form})
def sbregister(request):
errors_msg = []
if request.method=="POST":
form = RegisterForm(request.POST)
if form.is_valid():
username = request.POST['username']
password = request.POST['password']
rptpwd = request.POST['rptpwd']
sbid = request.POST['idnum']
name = request.POST['name']
teleph = request.POST['teleph']
address = request.POST['address']
user = User.objects.create_user(username=username, password=password)
user.save()
profile = SBProfile(user=user, sbid=sbid, name=name, teleph=teleph, address=address, flag=1)
profile.save()
#login the user in
user = authenticate(username=username, password=password)
login(request, user)
return redirect('users.views.home')
else:
errors_msg.append('Input invalid!')
else:
form = RegisterForm()
return render_to_response('users/register.html',
locals(),
context_instance=RequestContext(request)
)
def register_view(request):
"""
Register a new user
"""
# Check if the user is authenticated
if request.user.is_authenticated():
# User is already authenticated
return render(request, 'users/register/already_logged_in.html')
else:
register_form = RegisterForm(request.POST or None)
if request.method == 'POST': # Form data was submitted
if register_form.is_valid(): # Form data is valid
# Create the user
with transaction.atomic():
user = User.objects.create_user(register_form.cleaned_data['username'],
"N/A", # we don't deal with email addresses
register_form.cleaned_data['password'])
PastebinUser.create_user(user)
# TODO: Show a different message if the registration fails
return render(request, 'users/register/register_success.html')
# Show the registration page
return render(request, "users/register/register.html", { "form": register_form })
def register(request):
c = get_common_context(request)
auth_form = AuthenticationForm()
register_form = RegisterForm()
c['auth_form'] = auth_form
c['register_form'] = register_form
if request.method == "POST":
if request.POST['action'] == 'auth':
auth_form = AuthenticationForm(request.POST)
if auth_form.is_valid():
pass
username = request.POST.get('username', '')
password = request.POST.get('password', '')
user = auth.authenticate(username=username, password=password)
if user is not None:
if user.is_active:
auth.login(request, user)
if 'is_order' in request.session:
del request.session['is_order']
return HttpResponseRedirect('/order/2/')
return HttpResponseRedirect('/')
else:
c['auth_error'] = u'Ваш аккаунт не активирован.'
else:
c['auth_error'] = u'Неверный логин или пароль.'
c['auth_form'] = auth_form
elif request.POST['action'] == 'register':
from django.forms.util import ErrorList
register_form = RegisterForm(request.POST)
if register_form.is_valid():
p1 = register_form.data.get('password_1')
p2 = register_form.data.get('password_2')
error = False
if p1 != p2:
register_form._errors["password_2"] = ErrorList([u'Пароли не совпадают.'])
error = True
if len(User.objects.filter(username=register_form.data.get('email'))):
register_form._errors["email"] = ErrorList([u'Такой емейл уже зарегистрирован.'])
error = True
if not error:
u = User(username=register_form.data.get('email'), email=register_form.data.get('email'))
u.set_password(register_form.data.get('password_1'))
u.save()
p = u.get_profile()
p.fio = register_form.data.get('fio')
p.save()
user = auth.authenticate(username=register_form.data.get('email'), password=register_form.data.get('password_1'))
auth.login(request, user)
if 'is_order' in request.session:
del request.session['is_order']
return HttpResponseRedirect('/order/2/')
else:
return HttpResponseRedirect('/')
c['register_form'] = register_form
return render_to_response('register.html', c, context_instance=RequestContext(request))
def post(self, request):
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save()
return render_to_response('register_success.html', RequestContext(request))
#return HttpResponseRedirect('../../coins/')
else:
return self.registerPage(request, form)
def post(self, request, *args, **kwargs):
form = RegisterForm(request.POST, request.FILES)
if form.is_valid():
user = form.save()
# send_validation_code.apply_async(kwargs={'pk': user.id })
messages.info(request, _('You were successfully registered.'
'Validation link was sent to you'), extra_tags='register')
return HttpResponseRedirect(reverse('users:code_sent'))
return self.render_to_response({'form': form})
def testEmailAlreadyRegistered(self):
form_data = {
'username': self.CREATED_USER_USERNAME,
'email': self.USER_EMAIL,
'password': self.USER_PASSWORD,
'password_confirm': self.USER_PASSWORD,
}
form = RegisterForm(form_data)
self.assertFalse(form.is_valid())
self.assertIn('email', form.errors)
def handle_register(request):
"""Handle to help registration."""
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
RegistrationProfile.objects.create_inactive_user(
form.cleaned_data['username'], form.cleaned_data['password'],
form.cleaned_data['email'])
return form
return RegisterForm()
def register():
form = RegisterForm()
if form.validate_on_submit():
user = User(form.name.data, form.email.data, form.password.data)
db.session.add(user)
db.session.commit()
login_user(user)
flash('Thanks for registering')
return redirect(url_for('users.home'))
return render_template("register.html", form=form)
def test_can_save(self):
self.assertEqual(User.objects.count(), 0)
test_form = RegisterForm({'username': '******',
'email': '*****@*****.**',
'password1': 'asdf',
'password2': 'asdf'})
test_form.is_valid()
test_form.save()
self.assertEqual(User.objects.count(), 1)
def register(request):
form = RegisterForm()
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save()
mail_welcome(user)
authenticate(request, user)
util.add_success(request, "Welcome to %s" % ConfigData.get_configdata('SITE_NAME'))
return redirect(reverse('admin_dashboard'))
c = template.RequestContext(request, locals())
return render_to_response('users_register.html', c)
def register(request):
if (request.method=='POST'):
form = RegisterForm(data=request.POST)
if(form.is_valid()):
#check captcha first
session = UserSession.objects.get(session_key=request.session.session_key)
print("session captcha: "+session.captcha)
print("form captcha: "+form.cleaned_data["captcha"])
if(session.captcha != form.cleaned_data["captcha"]):
messages.add_message(request, messages.ERROR, _('The captcha was entered wrong.'))
else:
referer = request.META.get('HTTP_REFERER')
user = form.save()
user.groups.add(Group.objects.get(name='User'))
user.is_active = False
user.set_password(user.password)
user.save()
import uuid
lv_uuid = str(uuid.uuid1())[0:30]
message = """<html>
<body>
<h3>Registration at """+get_current_site(request).name+"""</h3><br/>
<p>
Please click the following link to end your registration.
</p>
<p>
<a href='https://"""+get_current_site(request).domain+""""/user/activate/"""+lv_uuid+"""/'>Activation Link</a>
</p>
</html>
"""
send_mail('Registration at '+get_current_site(request).name, 'Hello '+user.username+
'\n\nPlease click the following the link to end your registration.\n\n'+
'Activation Link: https://'+get_current_site(request).domain+'/user/activate/'+lv_uuid+'/', settings.SYSTEMMAIL,
[user.email], fail_silently=False,html_message=message)
profile = UserProfile()
profile.user = user
profile.posts = 0
profile.threads = 0
profile.activate = lv_uuid
profile.theme = Theme.objects.get(default=True)
profile.banned = False
profile.save()
messages.add_message(request, messages.INFO, _('User successful registrated.'))
#return redirect(urlresolvers.reverse('board.views.index'))
return redirect(referer)
else:
form = RegisterForm()
f_profile = ProfileForm()
return render_to_response('user/register.html',{'form':form},context_instance=RequestContext(request))
def testPasswordsDoNotMatch(self):
form_data = {
'username': self.CREATED_USER_USERNAME,
'email': self.CREATED_USER_EMAIL,
'password': self.USER_PASSWORD,
'password_confirm': "oops123",
}
form = RegisterForm(form_data)
self.assertFalse(form.is_valid())
self.assertIn('__all__', form.errors)
self.assertEquals(len(form.errors['__all__']), 1)
(error,) = form.errors['__all__']
self.assertIn('Password', error)
self.assertIn('not match', error)
def handle_register(request):
"""Handle to help registration."""
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
email = form.cleaned_data['email']
password = form.cleaned_data['password']
new_user = User.objects.create_user(username, email, password)
new_user.save()
Profile.objects.create(user=new_user)
return form
return RegisterForm()
def test_bad_username(self):
# Simple match.
form = RegisterForm({'username': '******',
'password': '******',
'password2': 'adssadfsadf',
'email': '*****@*****.**'})
assert not form.is_valid()
# Simple obfuscation.
form = RegisterForm({'username': '******',
'password': '******',
'password2': 'adssadfsadf',
'email': '*****@*****.**'})
assert not form.is_valid()
# Partial match.
form = RegisterForm({'username': '******',
'password': '******',
'password2': 'adssadfsadf',
'email': '*****@*****.**'})
assert not form.is_valid()
# No match.
form = RegisterForm({'username': '******',
'password': '******',
'password2': 'adssadfsadf',
'email': '*****@*****.**'})
assert form.is_valid()
def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
# Validate fields
if form.cleaned_data['password1'] == form.cleaned_data['password2']:
password = form.cleaned_data['password1']
else:
return render_to_response('users/register.html',
{'form':form,
'invalid':"Passwords mismatched"},
context_instance=RequestContext(request))
# Django User Data
username = form.cleaned_data['username']
email = form.cleaned_data['email']
# User Profile Data
birthday = form.cleaned_data['birthday']
nickname = form.cleaned_data['nickname']
gender = form.cleaned_data['gender']
interests = form.cleaned_data['interests']
# Save User to database
newuser = User(username=username,email=email)
newuser.set_password(password)
newuser.save()
# save user profile to database
user = User.objects.get(username=username)
newUserProfile = UserProfile.objects.create(user=user,
birthday=birthday,
nickname=nickname,
gender=gender,
interests=interests)
newUserProfile.save()
return HttpResponseRedirect('/login/')
else:
return render_to_response('users/register.html',
{'form':form,
'invalid':"Some required fields have not been filled"},
context_instance=RequestContext(request))
else:
form = RegisterForm()
return render_to_response('users/register.html',
context_instance=RequestContext(request))
def post(self, request):
if request.user.is_authenticated():
return redirect('index')
postData = request.POST
regForm = RegisterForm(postData)
if regForm.is_valid():
cleanedData = regForm.cleaned_data
username = cleanedData['username']
email = cleanedData['email']
password = cleanedData['password1']
firstName = cleanedData['first_name']
lastName = cleanedData['last_name']
timezone = cleanedData['timezone']
gender = cleanedData['gender']
with transaction.atomic():
newUser = User.objects.create_user(
username=username,
password=password,
email=email,
first_name=firstName,
last_name=lastName,
)
newProfile = UserProfile(
user=newUser,
timezone=timezone,
gender=gender,
)
newProfile.save()
user = authenticate(username=username, password=password)
login(request, user)
if 'next' in postData:
return redirect(postData['next'])
else:
return redirect('users_profile', username=username)
else:
context = {
'regForm' : regForm,
}
return render(request, self.template_name, context)
def register(request):
if request.method == "POST":
form = RegisterForm(request.POST)
if form.is_valid():
try:
form.save()
messages.add_message(request, messages.SUCCESS, "Your registration succed. We've sent a verification link to your email address.")
return redirect(reverse('login'))
except:
pass
else:
form = RegisterForm()
data = {'form': form}
return render(request, 'registration/register.html', data)
def register(request):
"""Register a new user."""
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
# TODO: Send registration email for confirmation.
user.is_active = True
user.set_password(form['password'].data)
user.save()
return login(request)
else: # request.method == 'GET'
form = RegisterForm()
return jingo.render(request, 'users/register.html',
{'form': form})
def make_validated_form(**kwargs):
valid = dict(
first_name='Admin',
last_name='Adminson',
email='*****@*****.**',
username='******',
facebook='https://www.facebook.com/adminadminson',
phone='99 9999-9999',
password1='123456',
password2='123456',
)
data = dict(valid, **kwargs)
form = RegisterForm(data)
form.is_valid()
return form
def test_not_valid_with_non_matching_passwords(self):
self.assertEqual(User.objects.count(), 0)
test_form = RegisterForm({'username': '******',
'email': '*****@*****.**',
'password1': 'asdf',
'password2': 'asdf2'})
test_form.is_valid()
def test_this():
test_form.save()
self.assertRaises(ValueError, test_this)
self.assertEqual(User.objects.count(), 0)
def register_user(request):
if request.method == "POST":
form = RegisterForm(request.POST)
if form.is_valid():
form.save()
data = form.cleaned_data
user = authenticate(username=data['username'], password=data['password'])
return HttpResponseRedirect('/registerSucces/')
else:
form = RegisterForm()
return render(request, 'register.html', {'form':form})
def register():
form = RegisterForm(request.form)
if form.validate_on_submit():
user = User.query.filter(User.username == form.username.data).first()
if user is not None:
flash('This username is already taken', 'error')
user = User.query.filter(User.email == form.email.data).first()
if user is not None:
flash('This email address is already taken', 'error')
return render_template('register.html', form=form)
user = User(form.username.data, form.email.data)
user.set_password(form.password.data)
db_session.add(user)
db_session.commit()
login_user(user)
return redirect(url_for('main.hello'))
return render_template('register.html', form=form)
def register(request):
"""
Register page.
"""
if request.user.is_authenticated():
return redirect('index')
form = RegisterForm(request.POST or None)
if form.is_valid():
try:
user = form.register(request)
except ValidationError as err:
form._errors['__all__'] = err.messages
else:
return redirect('index')
return {'form': form}
def register(request):
d = {}
d["url"] = "/register"
d["sub"] = "Register"
if request.method == "POST":
form = RegisterForm(request.POST)
if form.is_valid():
u = form.save(commit = False)
password = form.cleaned_data["password"]
u.set_password(password)
u.save()
return HttpResponseRedirect("/")
else:
d["form"] =form
return render(request,"register.html",d)
else:
d["form"] = RegisterForm()
return render(request,"register.html",d)
def user_auth(request, contributor=False, register_form=None, login_form=None):
"""Try to log the user in, or register a user.
POSTs from these forms do not come back to this view, but instead go to the
login and register views, which may redirect back to this in case of error.
"""
next_url = get_next_url(request) or reverse('home')
if login_form is None:
login_form = AuthenticationForm()
if register_form is None:
register_form = RegisterForm()
return render(
request, 'users/auth.html', {
'login_form': login_form,
'register_form': register_form,
'contributor': contributor,
'next_url': next_url
})
def home(request, register_form=None, login_form=None):
"""Display the home page."""
# Redirect logged-in users
if request.user.is_authenticated():
return redirect('badges.new.step1')
# en-US users see the BrowserID view instead
if get_language() in settings.BROWSERID_LOCALES:
return browserid_home(request)
if register_form is None:
register_form = RegisterForm()
if login_form is None:
login_form = LoginForm()
params = {
'register_form': register_form,
'login_form': login_form,
'share_url': absolutify('/', https=True),
'tweet_text': urlquote_plus(TWEET_TEXT)
}
return render(request, 'shared/home/normal.html', params)
def register(request):
redirect_to = request.POST.get('next', request.GET.get('next', ''))
form = RegisterForm()
if request.method == 'POST':
form = RegisterForm(request.POST, request.FILES)
if form.is_valid():
user = form.save()
messages.success(request, '注册成功,请登录')
if redirect_to:
login(request, user)
return redirect(redirect_to)
else:
return redirect(reverse('login'))
else:
return render(request, 'users/register.html', {
'form': form,
'next': redirect_to
})
def register(request):
# 先从 post 请求中获取 next 参数值,如果没有再从get请求中获取next
# get 请求中，next 通过 url 传递，即 /?next=value
# post 请求中，next 通过表单传递，即 <input type="hidden" name="next" value="{{ next }}"/>
redirect_url = request.POST.get('next', request.GET.get('next'))
if request.method == "POST":
# request.POST 是一个类字典数据结构，记录了用户提交的注册信息
# 这里提交的就是用户名（username）、密码（password）、邮箱（email）
form = RegisterForm(request.POST)
# 校验form表单的合法性
if form.is_valid():
# 保存到数据库
form.save()
# 重定向到登录页
return redirect('../login')
else:
form = RegisterForm()
return render(request, 'users/register.html', {
'form': form,
'next': redirect_url
})
def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
# email = form.cleaned_data.get('email')
# password1 = form.cleaned_data.get('password1')
# password2 = form.cleaned_data.get('password2')
# # form = RegisterForm(username=username,email=email,password=password,password2=password2)
messages.success(
request,
f'Your account has been created you are now able to login')
return redirect("users:login")
else:
form = RegisterForm()
return render(request, 'users/register.html ', {'form': form})
def register(request):
form = EmailSignupForm()
if request.method == 'POST':
reg_form = RegisterForm(request.POST)
if reg_form.is_valid():
user = reg_form.save()
profile = UserProfile(user=user, )
profile.save()
login(request, user)
username = reg_form.cleaned_data.get('username')
messages.success(request, f"Account created for {username}!")
return redirect('index')
else:
reg_form = RegisterForm()
context = {
'reg_form': reg_form,
'form': form,
}
return render(request, 'users/register.html', context)
def register(request):
#获取跳转地址
redirect_to = request.POST.get('next', request.GET.get('next', ''))
form = RegisterForm()
if request.method == 'POST':
#首先使用提交的数据生成form
form = RegisterForm(request.POST, request.FILES)
if form.is_valid():
user = form.save()
#返回登入，并提示注册成功，
messages.success(request, '注册成功，欢迎来到登入界面')
if redirect_to:
login(request, user)
return redirect(redirect_to)
else:
#重定向到login
return redirect(reverse('login'))
else:
return render(request, 'users/register.html', {
'form': form,
'next': redirect_to
})
pass
def post(self, request):
"""
Procesa el formulario de registro
:param request:
:return:
"""
user = User()
form = RegisterForm(request.POST, instance=user)
if form.is_valid():
# Guardar el anuncio
new_user = form.save()
# Limpiar el formulario
form = RegisterForm()
# Devolvemos un mensaje de OK
messages.success(request, 'Usuario registrado con éxito')
context = {'form': form,
'navbar': "register"}
return render(request, 'users/register.html', context)
def get(self, request):
register_form = RegisterForm()
return render(request, "forgot_password.html",
{"register_form": register_form})
def get(self, request):
register_form = RegisterForm()
return render(request, "register.html",
{"register_form": register_form})
def get(self, request):
register_form = RegisterForm()
return render(request, "user_register.html", {
'register_form': register_form,
'method': 'email'
})
def get(self, request):
if request.user.is_authenticated:
messages.add_message(request, messages.INFO, '用户已登录，请登出后再访问')
return redirect(reverse('index'))
register_form = RegisterForm()
return render(request, 'sign-up.html', {'register_form': register_form, 'title': '注册'})
def get(self, request):
# 显示验证码
register_form = RegisterForm()
return render(request, 'register.html', locals())
def get(self, request):
# 添加验证码:将forms中的类实例化并传送至前端;
register_form = RegisterForm()
return render(request, "register.html",
{'register_form': register_form})
def new_question(request, template=None):
"""Ask a new question."""
product_key = request.GET.get('product')
product = products.get(product_key)
if product_key and not product:
raise Http404
category_key = request.GET.get('category')
if product and category_key:
category = product['categories'].get(category_key)
if not category:
raise Http404
deadend = category.get('deadend', False)
html = category.get('html')
articles = category.get('articles')
else:
category = None
deadend = product.get('deadend', False) if product else False
html = product.get('html') if product else None
articles = None
login_t = ('questions/mobile/new_question_login.html'
if request.MOBILE else 'questions/new_question_login.html')
if request.method == 'GET':
search = request.GET.get('search', '')
if search:
try:
search_results = _search_suggestions(
search, locale_or_default(request.locale))
except SearchError:
# Just quietly advance the user to the next step.
search_results = []
tried_search = True
else:
search_results = []
tried_search = False
if request.GET.get('showform'):
# Before we show the form, make sure the user is auth'd:
if not request.user.is_authenticated():
login_form = AuthenticationForm()
register_form = RegisterForm()
return jingo.render(
request, login_t, {
'product': product,
'category': category,
'title': search,
'register_form': register_form,
'login_form': login_form
})
form = NewQuestionForm(product=product,
category=category,
initial={'title': search})
else:
form = None
return jingo.render(
request, template, {
'form': form,
'search_results': search_results,
'tried_search': tried_search,
'products': products,
'current_product': product,
'current_category': category,
'current_html': html,
'current_articles': articles,
'deadend': deadend,
'host': Site.objects.get_current().domain
})
# Handle the form post.
if not request.user.is_authenticated():
if request.POST.get('login'):
login_form = handle_login(request, only_active=False)
register_form = RegisterForm()
elif request.POST.get('register'):
login_form = AuthenticationForm()
email_template = 'questions/email/confirm_question.ltxt'
email_subject = _('Please confirm your Firefox Help question')
email_data = request.GET.get('search')
register_form = handle_register(request, email_template,
email_subject, email_data)
if register_form.is_valid(): # now try to log in
user = auth.authenticate(username=request.POST.get('username'),
password=request.POST.get('password'))
auth.login(request, user)
else:
# L10n: This shouldn't happen unless people tamper with POST data
message = _lazy('Request type not recognized.')
return jingo.render(request,
'handlers/400.html', {'message': message},
status=400)
if request.user.is_authenticated():
# Redirect to GET the current URL.
# This is required for the csrf middleware to set the auth'd tokens
# appropriately.
return HttpResponseRedirect(request.get_full_path())
else:
return jingo.render(
request, login_t, {
'product': product,
'category': category,
'title': request.POST.get('title'),
'register_form': register_form,
'login_form': login_form
})
form = NewQuestionForm(product=product,
category=category,
data=request.POST)
if form.is_valid():
question = Question(creator=request.user,
title=form.cleaned_data['title'],
content=form.cleaned_data['content'])
question.save()
question.add_metadata(**form.cleaned_metadata)
if product:
question.add_metadata(product=product['key'])
if category:
question.add_metadata(category=category['key'])
# The first time a question is saved, automatically apply some tags:
question.auto_tag()
# Submitting the question counts as a vote
question_vote(request, question.id)
if request.user.is_active:
messages.add_message(
request, messages.SUCCESS,
_('Thanks! Your question has been posted. See it below.'))
url = reverse('questions.answers',
kwargs={'question_id': question.id})
return HttpResponseRedirect(url)
auth.logout(request)
confirm_t = ('questions/mobile/confirm_email.html'
if request.MOBILE else 'questions/confirm_email.html')
return jingo.render(request, confirm_t, {'question': question})
return jingo.render(
request, template, {
'form': form,
'products': products,
'current_product': product,
'current_category': category,
'current_articles': articles
})
def test_bad_username(self):
# Simple match.
form = RegisterForm({'username': '******',
'password': '******',
'password2': 'adssadfsadf1',
'email': '*****@*****.**'})
assert not form.is_valid()
# Simple obfuscation.
form = RegisterForm({'username': '******',
'password': '******',
'password2': 'adssadfsadf1',
'email': '*****@*****.**'})
assert not form.is_valid()
# Partial match.
form = RegisterForm({'username': '******',
'password': '******',
'password2': 'adssadfsadf1',
'email': '*****@*****.**'})
assert not form.is_valid()
# No match.
form = RegisterForm({'username': '******',
'password': '******',
'password2': 'adssadfsadf1',
'email': '*****@*****.**'})
assert form.is_valid()
def test_strong_password(self):
form = RegisterForm({'username': '******',
'password': '******',
'password2': 'fksjvaj1',
'email': '*****@*****.**'})
assert form.is_valid()
def test_common_password(self):
form = RegisterForm({'username': '******',
'password': '******',
'password2': 'password',
'email': '*****@*****.**'})
assert not form.is_valid()
def get(self, request):
form = RegisterForm()
context = {"form": form}
return render(request, "users/register.html", context)
def get(self, request):
register_form = RegisterForm()
return render(request, 'register.html', {
'register_form': register_form,
'captcha': captcha()
})
def get(self, request):
context = {
'login_form': LoginForm(request),
'register_form': RegisterForm()
}
return render(request, 'registration/login.html', context)
def register(request):
"""
This function displays the registration form for the user to create a new account. If the user is already logged
in, it displays a message that the user is already logged in. When the user clicks the submit button, it will
process the form, validate it and send him back to the index page with logged in status as True.
:param request: The incoming request object from the user.
:return: A redirect to the index page or the registration form
"""
# The default url to return to is the same file, unless the form was correctly filled.
route_url = 'register.html'
# The default context is empty. Nothing should be sent if the user doesn't need the registration form.
context = {}
# Defaults for facebook image upload. image_request_url defines a default value for the facebook image a false
# until it is actually used. That is because the sign up, img and disconnect tags in the template check for its
# existence to be displayed or not.
image_request_url = False
# The facebook image used is a flag that is true or false whether the user is going to use the facebook image or
# not. If he will, the database doesn't store the selected file from the file chooser.
facebook_image_used = False
# If the user is not logged in.
if 'logged' not in request.session:
# If the request method is post, then this page was loaded because the user submitted the form,
# not just navigated to it.
if request.method == 'POST':
# If a facebook user was defined, then make sure that the profile picture is loaded by sending its link
# to the context to the view page to preview it. Note that if the user selected another file,
# it takes precedence over it.
if request.user and not request.user.is_anonymous():
facebook_id = UserSocialAuth.objects.get(
id=request.user.id).uid
image_request_url = 'http://graph.facebook.com/' + facebook_id + '/picture?type=large'
# If the user didn't choose a file from the for file chooser create a form with post data only.
if 'user_image' not in request.FILES:
# Create the registration form object with the received data only.
registration_form = RegisterForm(request.POST)
facebook_image_used = True
else:
# Create the registration form object with the received data and files.
registration_form = RegisterForm(request.POST, request.FILES)
# The is_valid() method validates the fields of the form and returns true if they are all validated
# correctly. It also passes the form parameters (fields) into a dictionary called cleaned_data, which you can
# use for additional validation.
if registration_form.is_valid():
# SUCCESSFUL LOGIN
# Create new user based on the received data and save that user to the database.
if facebook_image_used:
new_user = create_user(request.POST, image_request_url)
else:
new_user = create_user(request.POST, request.FILES)
# Set the logged session variable to true to indicate that the user is logged in.
request.session['logged'] = True
# Set the logged user name to the logged in username.
request.session['username'] = new_user.user_name
# Set the logged user profile picture path if available
if new_user.user_image_path:
request.session['user_image'] = str(
new_user.user_image_path)
# Set the admin flag based on whether the user is an admin or not.
if new_user.user_admin_status:
request.session['is_admin'] = True
# Format: subject,body,host to use,recipients,fail_silently
send_mail('Welcome to our website!',
'Welcome to our website ' + new_user.user_name +
'! We hope you enjoy it!',
settings.EMAIL_HOST_USER, [new_user.user_email],
fail_silently=False)
# The URL to go to.
route_url = '/article/index/'
# Go to the index page since you successfully logged in.
return redirect(route_url)
# The method was GET, that means the user just navigated to the register form page or the form was redirected
# from a facebook register request.
else:
# If a facebook user was defined
if request.user and not request.user.is_anonymous():
# Get the facebook user name, email and id from the database.
facebook_username = request.user.username
facebook_email = request.user.email
facebook_id = UserSocialAuth.objects.get(
id=request.user.id).uid
# Create a url GET request to get the profile picture of the user.
image_request_url = 'http://graph.facebook.com/' + facebook_id + '/picture?type=large'
register_initial_data = {
'user_name': facebook_username,
'user_email': facebook_email,
}
# Create new registration form with facebook info
registration_form = RegisterForm(register_initial_data)
else:
# Create new empty registration form.
registration_form = RegisterForm()
# The registration form data to the register page.
context = {
'register_form': registration_form,
'user_image': image_request_url
}
# This displays the register page again with the defined context.
return render(request, route_url, context)
def get(self):
form = RegisterForm()
return render_template("users/registration.html", form=form)
def new_question(request):
"""Ask a new question."""
product_key = request.GET.get('product')
product = products.get(product_key)
if product_key and not product:
raise Http404
category_key = request.GET.get('category')
if product and category_key:
category = product['categories'].get(category_key)
if not category:
raise Http404
deadend = category.get('deadend', False)
html = category.get('html')
articles = category.get('articles')
else:
category = None
deadend = product.get('deadend', False) if product else False
html = product.get('html') if product else None
articles = None
if request.method == 'GET':
search = request.GET.get('search', '')
if search:
try:
search_results = _search_suggestions(
search, locale_or_default(request.locale))
except SearchError:
# Just quietly advance the user to the next step.
search_results = []
tried_search = True
else:
search_results = []
tried_search = False
if request.GET.get('showform'):
# Before we show the form, make sure the user is auth'd:
if not request.user.is_authenticated():
login_form = AuthenticationForm()
register_form = RegisterForm()
return jingo.render(request,
'questions/new_question_login.html',
{'product': product, 'category': category,
'title': search,
'register_form': register_form,
'login_form': login_form})
form = NewQuestionForm(product=product,
category=category,
initial={'title': search})
else:
form = None
return jingo.render(request, 'questions/new_question.html',
{'form': form, 'search_results': search_results,
'tried_search': tried_search,
'products': products,
'current_product': product,
'current_category': category,
'current_html': html,
'current_articles': articles,
'deadend': deadend,
'host': Site.objects.get_current().domain})
# Handle the form post.
just_logged_in = False # Used below for whether to pre-load Question form.
if not request.user.is_authenticated():
type = request.POST.get('type')
if type not in ('login', 'register'):
# L10n: This shouldn't happen unless people tamper with POST data
message = _lazy('Request type not recognized.')
return jingo.render(request, 'handlers/400.html',
{'message': message}, status=400)
if type == 'login':
login_form = handle_login(request, only_active=False)
register_form = RegisterForm()
else: # must be 'register'
login_form = AuthenticationForm()
register_form = handle_register(request)
if register_form.is_valid(): # now try to log in
user = auth.authenticate(username=request.POST.get('username'),
password=request.POST.get('password'))
auth.login(request, user)
if not request.user.is_authenticated():
return jingo.render(request,
'questions/new_question_login.html',
{'product': product, 'category': category,
'title': request.POST.get('title'),
'register_form': register_form,
'login_form': login_form})
else:
just_logged_in = True
if just_logged_in:
form = NewQuestionForm(product=product,
category=category,
initial={'title': request.GET.get('search')})
else:
form = NewQuestionForm(product=product, category=category,
data=request.POST)
if form.is_valid():
question = Question(creator=request.user,
title=form.cleaned_data['title'],
content=form.cleaned_data['content'])
question.save()
question.add_metadata(**form.cleaned_metadata)
if product:
question.add_metadata(product=product['key'])
if category:
question.add_metadata(category=category['key'])
# The first time a question is saved, automatically apply some tags:
question.auto_tag()
# Submitting the question counts as a vote
question_vote(request, question.id)
if request.user.is_active:
url = reverse('questions.answers',
kwargs={'question_id': question.id})
return HttpResponseRedirect(urlparams(url, new=1))
auth.logout(request)
return jingo.render(request, 'questions/confirm_email.html',
{'question': question})
return jingo.render(request, 'questions/new_question.html',
{'form': form, 'products': products,
'current_product': product,
'current_category': category,
'current_articles': articles})
def get_context_data(self, **kwargs):
context = super(Register, self).get_context_data(**kwargs)
if 'form' not in context:
context['form'] = RegisterForm()
return context
def get(self, request):
register_form = RegisterForm() # 实例化register表单
return render(request, 'register.html',
{'register_form': register_form})
def get(self, request):
register_form = RegisterForm()
return render(request, 'user/logreg/register.html',
{'register_form': register_form})
def get(self, request):
register_form = RegisterForm()
return render(request, "usercenter/register.html",
{'register_form': register_form})
def get(self, request):
register_form = RegisterForm(request.POST)
return render(request, 'register.html',
{'register_form': register_form})
def get(request):
register_form = RegisterForm()
return render(request, 'register.html',
{'register_form': register_form})
