def test_reg_form_unique_email(self):
"""
Test that ``RegistrationForm`` validates uniqueness
of email addresses.
"""
# Create a user so we can verify that duplicate addresses aren't permitted.
User.objects.create_user('alice', '*****@*****.**', 'secret')
form = RegistrationForm(data={'username': '******',
'email': '*****@*****.**',
'password1': 'foo',
'password2': 'foo',
'tos': True})
self.failIf(form.is_valid())
self.assertEqual(form.errors['email'], [u"This email address is already in use. Please supply a different email address."])
form = RegistrationForm(data={'username': '******',
'email': '*****@*****.**',
'password1': 'foo',
'password2': 'foo',
'tos': True})
print form.is_valid()
print form.errors
self.failUnless(form.is_valid())
def RegistrationView(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
print("The form reached")
print(form.is_valid())
if form.is_valid():
print("the form is validated")
user = form.save() # this pretty much creates the user
user.first_name = request.POST.get("first_name")
user.last_name = request.POST.get("last_name")
user.save()
return redirect('/account') # this is /account
else:
form = RegistrationForm(request.POST)
args = {'form': form}
# this refers to the template, so accounts/reg_form.html
return render(request, 'accounts/signup.html', args)
# giving them the opportunity to get the form
# the else condition is working
else:
form = RegistrationForm()
args = {'form': form}
# this refers to the template, so accounts/reg_form.html
return render(request, 'accounts/signup.html', args)
def register(self, request, **kwargs):
"""
Create and immediately log in a new user.
"""
invitation_key = kwargs.get('invitation_key', None)
email = kwargs.get('email', None)
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.email = email # email was omitted from form - it's required to use the same email invitation was sent to
user.save() # default groups and all pending accesses are automatically assigned - signal
else:
return None
#username, email, password = kwargs['username'], kwargs['email'], kwargs['password1']
#User.objects.create_user(username, email, password)
# authenticate() always has to be called before login(), and
# will return the user we just created.
new_user = authenticate(username=user.username, password=form.cleaned_data['password1'])
login(request, new_user)
signals.user_registered.send(sender=self.__class__,
user=new_user,
invitation_key=invitation_key,
request=request)
return new_user
def test_non_matching_passwords(self):
form = RegistrationForm(self.non_matching_passwords)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
{'__all__': [u"Passwords don't match."]}
)
def register(request):
#create_superuser('*****@*****.**', 'password')
register_success = False
form = RegistrationForm()
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
# Check this, change it to email in html template
# in html, the input element has name as 'username', but we are showing label as email, so we will accept it as 'email'
email = request.POST.get('username')
password = request.POST.get('password1')
# There are errors, if the email gets repeated,
# check, some authentication, if UserValid only then fire a create_user, else, print some error in html
if not user_exists(email):
create_user(email, password)
else: # if user exists, then log him in
# If user created properly, then login
# This login is NOT WORKING, see y?
#import django.contrib.auth.views as v
#v.login(request)
pass
register_success = True
# return HttpResponseRedirect("/")
else:
form = RegistrationForm(request.POST)
d = { 'form': form, "register_success": register_success, }
#return render(request, "registration/register.html", { 'form': form, })
return render(request, 'registration/registration.html', d, context_instance=RequestContext(request))
def WeightloserRegistration(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/profile/')
if request.method=='POST':
form=RegistrationForm(request.POST)
if form.is_valid():
emailtemp=str(form.cleaned_data['emailId'])
name=emailtemp.split("@")[0]
user = User.objects.create_user(username=name, email = form.cleaned_data['emailId'], password = form.cleaned_data['password'])
user.save()
weightloser = WeightLoser(user=user, fname=form.cleaned_data['fname'],lname=form.cleaned_data['lname'], dob=form.cleaned_data['dob'],gender=form.cleaned_data['gender'],emailId=form.cleaned_data['emailId'],currentWeight=form.cleaned_data['currentWeight'])
weightloser.save()
userwloser = authenticate(username=name, password=form.cleaned_data['password'])
login(request, userwloser)
print "user is "+str(request.user.is_authenticated())
return HttpResponseRedirect('/profile/')
else: #display the form when not valid
return render_to_response('RegisterPage.html',{'form':form}, context_instance=RequestContext(request))
else: #Showing the form
'''user is not submitting the form, show them a blank registration form'''
form=RegistrationForm()
context={'form':form}
return render_to_response('RegisterPage.html',context, context_instance=RequestContext(request))
def register(request, template_name="registration/register.html"):
"""
view displaying customer registration form
"""
if request.method == 'POST':
post_data = request.POST.copy()
form = RegistrationForm(post_data)
if form.is_valid():
# form.save()
user = form.save(commit=False) # new
user.email = post_data.get('email', '') # new
user.save() # new
un = post_data.get('username', '')
pw = post_data.get('password1', '')
from django.contrib.auth import login, authenticate
new_user = authenticate(username=un, password=pw)
if new_user and new_user.is_active:
login(request, new_user)
url = urlresolvers.reverse('accounts:my_account')
return HttpResponseRedirect(url)
else:
form = RegistrationForm()
page_title = 'User Registration'
return render(request, template_name, locals())
def test_invalid_email(self):
form = RegistrationForm(self.invalid_email)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
{'email': [u'Enter a valid email address.']}
)
def test_non_matching_passwords(self):
form = RegistrationForm(self.non_matching_passwords)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
{'__all__': [u"Passwords don't match."]}
)
def register(request):
"""
用户注册
"""
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(
username=form.cleaned_data['username'],
password=form.cleaned_data['password2'],
email=form.cleaned_data['email'],
)
user.save()
#保存用户城市数据
users = Users(
user=user,
city=form.cleaned_data['citycode'],
)
users.save()
#注册成功
return render_to_response('warn.html',{'warning':'注册成功！',}, context_instance=RequestContext(request))
else:
form = RegistrationForm()
return render_to_response('account/register.html',{'form':form,},
context_instance=RequestContext(request))
def registration_view(request):
context = {}
redirect_to = request.GET.get('next', '')
if redirect_to != "" or redirect_to is not None:
context['redirect_to'] = redirect_to
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
customer_number = form.cleaned_data.get('mobile')
# print(customer_number)
# user_otp = form.cleaned_data.get('otp')
# print(user_otp)
# send_otp(customer_number,user_otp)
form.save()
email = form.cleaned_data.get('email')
raw_password = form.cleaned_data.get('password1')
account = authenticate(email=email, password=raw_password)
login(request, account)
return redirect('home')
else:
context['registration_form'] = form
else: #GET request
form = RegistrationForm()
context['registration_form'] = form
return render(request, 'accounts/register.html', context)
def post(self, request, *args, **kwargs):
form = RegistrationForm(request.POST)
if form.is_valid():
fname = form.cleaned_data.get('fname')
lname = form.cleaned_data.get('lname')
usrnm = form.cleaned_data.get('usrnm')
email = form.cleaned_data.get('email')
passw = form.cleaned_data.get('pass1')
user = User.objects.create_user(usrnm, email, passw)
user.first_name = fname
user.last_name = lname
user.save()
messages.info(request,
'''Your new account has been created.
You may now login using your username and password.''')
return redirect('account_login')
else:
return self.render_to_response({
'form': form
})
def register(request):
if request.user != None and request.user.is_authenticated():
return redirect('/')
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
#Create the user
email = form.cleaned_data.get('email')
passwd = form.cleaned_data.get('password1')
user = User(email=email)
user.set_password(passwd)
user.save()
user.username = user.pk
user.save()
user_profile = UserProfile(user=user)
user_profile.save()
user.backend='user_backends.email_username.EmailOrUsernameModelBackend'
#logs the new user
login(request,user)
return redirect('/')
else:
form = RegistrationForm()
return locals()
def register(request):
if request.method == 'POST':
form1 = RegistrationForm(request.POST)
form = customreg(request.POST)
if form1.is_valid():
if request.POST['Jobtitle'] != 'CEO':
form1_instance = form1.save()
form_instance = form.save(commit=False)
form_instance.user = form1_instance
form_instance.save()
return redirect('/accounts')
else:
return HttpResponse("CEO should register with company ")
else:
return HttpResponse("form 1 is invalid")
else:
form = customreg()
form1 = RegistrationForm()
args = {'form': form, 'form1': form1}
#print(args[])
return render(request, 'accounts/reg_form.html', args)
def login_page(request):
if request.method == 'POST':
registration_form = RegistrationForm(request.POST, prefix='register')
authentication_form = AuthenticationForm(request.POST,
prefix='authenticate')
if 'register-username' in request.POST:
if registration_form.is_valid():
user = registration_form.save()
UserProfile.objects.create(
user=user,
first_name=registration_form.cleaned_data['first_name'],
last_name=registration_form.cleaned_data['last_name'],
)
return redirect('/home')
elif 'authenticate-username' in request.POST:
username = request.POST['authenticate-username']
password = request.POST['authenticate-password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
return redirect('/account/profile')
else:
return redirect('/home')
else:
register_form = RegistrationForm(prefix='register')
authentication_form = AuthenticationForm(prefix='authenticate')
args = {
'register_form': register_form,
'authentication_form': authentication_form
}
return render(request, 'home/login-or-signup.html', args)
def create_user_from_weibo(request,
template_name='register/create_user_from_weibo.html'
):
oauth_access_token = request.session.get('oauth_access_token', None)
if request.user.is_authenticated() or oauth_access_token is None:
return HttpResponseRedirect(reverse('home.views.index'))
client = APIClient(app_key=APP_KEY,
app_secret=APP_SECRET,
redirect_uri=_get_weibo_callback_url(request))
client.set_access_token(oauth_access_token['access_token'],
oauth_access_token['expires_in'])
weibo_user = client.get.users__show(uid=oauth_access_token['uid'])
weibo_username = weibo_user.screen_name
template_var = {}
form = RegistrationForm(initial={'username': weibo_username})
if request.method == 'POST':
form = RegistrationForm(request.POST.copy())
if request.method == 'POST':
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.is_active = True
user.save()
profile = UserProfile()
profile.user = user
profile.song_ord_filed = 'post_datetime'
profile.save()
#weibo信息记录
w_user = WeiboUser()
w_user.user = user
w_user.weibo_user_id = oauth_access_token['uid']
w_user.weibo_username = weibo_username
w_user.oauth_access_token = oauth_access_token['access_token']
w_user.save()
#发微博提示
if request.POST.get('update_msg'):
msg = request.POST.get('bind_msg')[0:140]
client.post.statuses__update(status=msg)
user = authenticate(username=username, password=password)
auth_login(request, user)
return HttpResponseRedirect(reverse('songs.views.my_home'))
template_var['form'] = form
template_var['weibo_username'] = weibo_username
return render_to_response(template_name,
template_var,
context_instance=RequestContext(request))
def signup(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/profile/')
if request.method=="POST":
form = RegistrationForm(request.POST) #take the form and fill it with what has been POST'ed
if form.is_valid():
user = User.objects.create_user(form.cleaned_data['username'], form.cleaned_data['email'], form.cleaned_data['password'])
user.save()
#possibly might need these lines of code for edit profile
#uprofile = user.get_profile() #remember its set in settings
#uprofile.avatar = form.cleaned_data['avatar']
#uprofile.name = form.cleaned_data['name']
#uprofile.website = form.cleaned_data['website']
#uprofile.bio = form.cleaned_data['bio']
#uprofile.save() #save our UserProfile object, which contains our User extra data or subclass.
"""create UserProfile object manually. uncomment when done in editprofile view"""
# userprofile = UserProfile(user=user, avatar=form.cleaned_data['avatar'],name=form.cleaned_data['name'],)
# userprofile.save()
return HttpResponseRedirect('/a/profile/') # because we have to return HTTP response else error is thrown
else: #in case form isnt valid show the form again. this time possibly with errors and such
return render_to_response('accounts/register.html', {'form':form}, context_instance=RequestContext(request))
else:
form = RegistrationForm()
context = {'form':form}
return render_to_response('accounts/register.html', context, context_instance=RequestContext(request))
def post(self, request):
form = RegistrationForm(request.POST)
if form.is_valid():
#form.save()
#return redirect('/djangoproj')
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
mail_subject = 'Activate your account.'
message = render_to_string(
'accounts/confirm_email.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(
user.pk)).decode(),
'token': account_activation_token.make_token(user),
})
to_email = form.cleaned_data.get('email')
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
return render(request, 'accounts/confirm_email_page.html')
form = RegistrationForm(request.POST)
args = {'form': form}
return render(request, 'accounts/register.html', args)
def register(request, isdriver=False):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
email = form.cleaned_data['email']
username = form.cleaned_data['username']
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
password = form.cleaned_data['password2']
user = User.objects.create_user(username=username,
password=password,
email=email,
first_name=first_name,
last_name=last_name)
user_profile = UserInfo(user=user)
user_profile.vehicle_id = request.POST.get('vehicle_id', None)
vehicle_max_passenger = request.POST.get('vehicle_max_passenger',
None)
user_profile.vehicle_max_passenger = vehicle_max_passenger
user_profile.isDriver = True
user_profile.save()
auth.logout(request)
return HttpResponseRedirect('/accounts/')
else:
return render(request, 'accounts/reg_form.html', {'form': form})
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/reg_form.html', args)
def register(request):
context = {}
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = RegistrationForm(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
# Creamos la nueva cuenta de usuario
form.save()
email = form.cleaned_data.get('email')
raw_password = form.cleaned_data.get('password1')
account = authenticate(email=email, password=raw_password)
do_login(request, account)
return redirect('dashboard')
else:
context = {'form': form}
else:
form = RegistrationForm()
context = {'form': form}
# Si queremos borramos los campos de ayuda
#form.fields['username'].help_text = None
form.fields['email'].help_text = None
form.fields['password1'].help_text = None
form.fields['password2'].help_text = None
# Si llegamos al final renderizamos el formulario
return render(request, "register.html", context)
def registration(request):
"""
Registration method
"""
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
# register user
form.save()
new_user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password1'])
# send account creation confirmation email
subject = "Thanks for signing up, %s!" % new_user.first_name
from_email = '*****@*****.**'
to = new_user.email
html_content = render_to_string(
'email_welcome.html', {'user': new_user}
)
text_content = strip_tags(html_content)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()
# log user in
login(request, new_user)
return redirect('/sign-up/more-details/')
else:
form = RegistrationForm()
return render(request, 'auth_form.html', {'form': form})
def login(request):
login_form = LoginForm()
register_form = RegistrationForm()
next = request.REQUEST.get('next', settings.LOGIN_REDIRECT_URL)
# Special case next urls that will lead us into redirect loops
if next == settings.LOGIN_URL:
next = settings.LOGIN_REDIRECT_URL
if 'kind' in request.POST:
if request.POST['kind'] == 'register':
register_form = RegistrationForm(request.POST)
if register_form.is_valid():
_backend_hackend(request, register_form.save())
return HttpResponseRedirect(next)
elif request.POST['kind'] == 'login':
login_form = LoginForm(request.POST)
if login_form.is_valid() and login_form.user:
_backend_hackend(request, login_form.user)
return HttpResponseRedirect(next)
context = {
'login_form': login_form,
'register_form': register_form,
'next': next,
}
return render_to_response('accounts/login.html', context,
context_instance=RequestContext(request))
def register(request):
if request.user.is_authenticated():
return redirect('base:index')
if request.POST:
form = RegistrationForm(data=request.POST)
if form.is_valid():
new_user = form.save(commit=False)
password = form.cleaned_data['password']
new_user.set_password(password)
new_user.save()
# Add `new_user` to a group
if form.cleaned_data['is_developer']:
user_group = Group.objects.get(name='developer')
else:
user_group = Group.objects.get(name='player')
new_user.groups.add(user_group)
new_user.save()
base_url = request.build_absolute_uri(
reverse('accounts:registration-complete'))
verification_link = PendingRegistration.objects.create_new_pending(
user=new_user, base_url=base_url)
send_email(new_user, verification_link)
return redirect('accounts:registration-link-sent')
else:
form = RegistrationForm()
return render(request,
'accounts/registration-form.html',
context={'form': form})
def register(request):
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get("username")
email = form.cleaned_data.get("email")
password = form.cleaned_data.get("password1")
first = form.cleaned_data.get("first_name")
last = form.cleaned_data.get("last_name")
school = form.cleaned_data.get("school")
interests = form.cleaned_data.get("interest_input")
new_user = User.objects.create_user(username, email, password)
new_user.first_name = first
new_user.last_name = last
new_user.save()
ext_new = ExtUser.objects.create(school=school, user=new_user)
if interests:
parseInterests(ext_new, interests)
ext_new.save()
login(request, new_user)
return redirect('index')
else:
form = RegistrationForm()
return render(request, 'registration/register.html', {'form': form})
def addStudent(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
userr = form.save()
userrr = User.objects.get(username=userr)
userid = userrr.id
phone = request.POST.get("phone")
user = UserProfile.objects.get(user=request.user)
org = user.Organisation
profile = "S"
UserProfile.objects.create(user_id=userid,
phone=phone,
profile=profile,
Organisation=org)
return redirect(reverse('teacher:addStudent'))
else:
return HttpResponse("form invalid")
elif request.user.userprofile.profile == "T":
form1 = RegistrationForm()
form2 = UserProfileForm()
usr = UserProfile.objects.get(user=request.user)
org = usr.Organisation
usrp = UserProfile.objects.filter(Organisation=org)
args = {'form1': form1, 'form2': form2, 'usrp': usrp}
return render(request, 'panel1.html', args)
else:
return HttpResponse(
"<h1>You are not authorised to view this page</h1>")
def register(request):
code = ""
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
email = request.POST['email']
form = RegistrationForm(request.POST)
if form.is_valid():
salt = sha.new(str(random.random())).hexdigest()[:5]
activation_code = sha.new(salt+username).hexdigest()
key_expires = datetime.datetime.today() + datetime.timedelta(7)
user = User.objects.create_user(username=username, email=email, password=password)
user.is_active = False
user.save()
profile = form.save(commit=False)
profile.user = user
profile.activation_code = activation_code
profile.key_expires = key_expires
profile.save()
return render_to_response('accounts/register.html',
{'code':activation_code, 'profile':profile}, context_instance=RequestContext(request))
else:
salt = sha.new(str(random.random())).hexdigest()[:5]
activation_code = sha.new(salt+username).hexdigest()
return render_to_response('accounts/register.html',
{'form':form, 'code':activation_code}, context_instance=RequestContext(request))
else:
form = RegistrationForm()
return render_to_response('accounts/register.html',{'form':form, 'code':code})
def registration_view(request):
context = {}
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
email = form.cleaned_data.get('email')
raw_password = form.cleaned_data.get('password1')
username = form.cleaned_data.get('username')
employee = form.cleaned_data.get('employee')
account = authenticate(email=email,
password=raw_password,
username=username,
employee=employee)
login(request, account)
return redirect('/')
else:
context['registration_form'] = form
else:
form = RegistrationForm()
# context['registration_form'] = form
context = {'registration_form': form}
return render(request, 'accounts/user_register.html', context)
def registration_view(request):
context = {}
if request.POST: # for post request
form = RegistrationForm(request.POST)
customer_form = cust_form(request.POST)
if form.is_valid() and customer_form.is_valid(
): # if user entered proper format of info
register_form = form.save()
c_form = customer_form.save(False)
c_form.user = register_form
c_form.name = register_form.first_name
c_form.email = register_form.email
c_form.save()
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
phone_no = form.cleaned_data.get('phone_no')
email = form.cleaned_data.get('email')
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
account = authenticate(username=username, password=raw_password)
login(request, account)
return render(request, 'shop/home.html')
else:
context[
'registration_form'] = form # if form not valid, then too send that errenous form to the template
else: # for get request
form = RegistrationForm()
customer_form = cust_form()
context['registration_form'] = form
context['customer_form'] = customer_form
return render(request, 'accounts/signup.html', context)
def register(request):
if request.method =='POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
messages.success(request,
'Success!',
'alert alert-success alert-dismissible')
return redirect('website:index')
else:
messages.warning(request,
'Please fix the following errors: ' + str(form.errors),
'alert alert-warning alert-dismissible')
context = {
'form': form,
}
return render(request, 'registration/reg_form.html', context)
else:
form = RegistrationForm()
context = {
'form': form,
}
return render(request, 'registration/reg_form.html', context)
def registration_view(request):
if request.method == 'GET':
return render(request, 'accounts/registration.html',
{'form': RegistrationForm})
elif request.method == 'POST':
form = RegistrationForm(request.POST, request.FILES or None)
if not form.is_valid():
return render(request, 'accounts/registration.html',
{'form': form})
avatar = form.cleaned_data['avatar']
password = form.cleaned_data['password']
username = form.cleaned_data['username']
user = User.objects.create_user(
email=form.cleaned_data['email'],
password=password,
username=username,
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
avatar=avatar,
)
if user is not None:
user.save()
user = authenticate(request, username=username, password=password)
if user is not None:
login(request, user)
return redirect('articles:Cat In Hat')
else:
return render(request, 'accounts/registration.html', {
'form': form,
'error': 'Server error'
})
else:
return HttpResponse(status=405)
def registerate_user(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse("home"))
else:
form = RegistrationForm()
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
data = form.cleaned_data
password1 = data.get('password1')
password2 = data.get('password2')
if User.objects.filter(username=data.get("username")):
username_error = 'User with this username is already exists'
return render(request, 'registration.html', {
"form": form,
"username_error": username_error
})
else:
if password1 != password2:
pass_error = "Passwords don't match"
return render(request, 'registration.html', {
"form": form,
"pass_error": pass_error
})
else:
user = User.objects.create_user(
username=data.get("username"),
email=data.get("email"))
user.set_password(password1)
user.save()
return HttpResponseRedirect(reverse("login"))
return render(request, 'registration.html', {"form": form})
class RegisterView(TemplateView):
template_name = "register.html"
def __init__(self):
super(RegisterView, self).__init__()
self.form = RegistrationForm()
def get_context(self, request, *args, **kwargs):
context = {
'form': self.form
}
return context
def get(self, request, *args, **kwargs):
return self.render_to_response(self.get_context(request))
def post(self, request, *args, **kwargs):
self.form = RegistrationForm(request.POST)
if self.form.is_valid():
self.form.save()
user = auth.authenticate(username=self.form.user.email, password=self.form.str_password)
auth.login(request, user)
send([user], 'registration')
return HttpResponseRedirect("/accounts/personal-data-master/")
return self.render_to_response(self.get_context(request))
def registercompany(request):
if request.method == 'POST':
form1 = RegistrationForm(request.POST)
form = customregcompany(request.POST)
form2 = regcompany(request.POST)
if form1.is_valid() and form.is_valid() and form2.is_valid():
if request.POST['Jobtitle'] == 'CEO':
form2_instance = form2.save()
form1_instance = form1.save()
form_instance = form.save(commit=False)
form_instance.user = form1_instance
form_instance.company_name = form2_instance
form_instance.save()
return redirect('/accounts')
else:
return HttpResponse("only ceo can register ")
else:
return HttpResponse("form 1 is invalid")
else:
form = customregcompany()
form1 = RegistrationForm()
form2 = regcompany()
args = {'form': form, 'form1': form1, 'form2': form2}
#print(args[])
return render(request, 'accounts/reg_company.html', args)
def register(request):
context = {}
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save()
email = form.cleaned_data.get('email')
raw_password = form.cleaned_data.get('password1')
# accounts = authenticate(email=email, password=raw_password)
# login(request, accounts)
return redirect('/')
else:
context['registration_form'] = form
else:
form = RegistrationForm()
context['registration_form'] = form
return render(request, 'travels_app/register.html', context)
def register(request):
"""
A view allowing users to register and shows
messages if form is completed successfully or not
"""
if request.user.is_authenticated:
return redirect(reverse('index'))
if request.method == "POST":
registration_form = RegistrationForm(request.POST)
if registration_form.is_valid():
registration_form.save()
user = auth.authenticate(username=request.POST['username'],
password=request.POST['password1'])
if user:
auth.login(user=user, request=request)
messages.success(request,
"Great job! You've successfully registered")
else:
messages.error(request,
"We are unable to register your account")
else:
registration_form = RegistrationForm()
return render(request, 'registration.html',
{"registration_form": registration_form})
def registration(request):
# context = {}
# if request.POST:
# form = RegistrationForm(request.POST)
# if form.is_valid():
# form.save()
# email = form.cleaned_data.get('email')
# raw_password = form.cleaned_data.get('password1')
# accounts = authenticate(email=email, password= password1)
# login(request, accounts)
# return redirect('home')
# else:
# context['registration_form'] = form
# else: # GET request
# form = RegistrationForm()
# context = {"form": form}
form = RegistrationForm()
if request.method == "POST":
print('form valid ------')
form = RegistrationForm(request.POST)
try:
if form.is_valid():
form.save()
return redirect('home')
else:
print('form not valid 2------')
except ValueError:
print('form not valid ------')
return redirect('register')
context = {'form': form}
return render(request, 'accounts/register.html', context)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
if User.objects.filter(
email=form.cleaned_data.get('email')).exists():
args = {
'error': 'User already exists',
'erlink': '/account/register'
}
return render(request, 'accounts/regerror.html', args)
else:
form.save()
return redirect('/account')
else:
args = {
'error': 'Password not strong',
'erlink': '/account/register'
}
return render(request, 'accounts/regerror.html', args)
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/reg_form.html', args)
def Registration(request):
if request.method=="POST":
form=RegistrationForm(request.POST)
if form.is_valid():
user=form.save(commit=False)
user.is_active=False
user.save()
#============Emailing======
current_site=get_current_site(request)
mail_subject="Activate your blog account."
message=render_to_string('activation_email.html',{
'user':user,
'domain':current_site.domain,
'uid':urlsafe_base64_encode(force_bytes(user.pk)),
'token':account_activation_token.make_token(user),
})
to_mail=form.cleaned_data.get('email')
email=EmailMessage(
mail_subject,message,to=[to_mail]
)
email.send()
return HttpResponse('Please confirm your email address to complete the Registration')
else:
form=RegistrationForm()
context={
'form':form
}
return render(request,'accounts/register.html',context)
def test_invalid_email(self):
form = RegistrationForm(self.invalid_email)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
{'email': [u'Enter a valid email address.']}
)
def register(request):
if request.user != None and request.user.is_authenticated():
return redirect('/')
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
#Create the user
email = form.cleaned_data.get('email')
passwd = form.cleaned_data.get('password1')
user = User(email=email)
user.set_password(passwd)
user.save()
user.username = user.pk
user.save()
user_profile = UserProfile(user=user)
user_profile.save()
user.backend = 'user_backends.email_username.EmailOrUsernameModelBackend'
#logs the new user
login(request, user)
return redirect('/')
else:
form = RegistrationForm()
return locals()
def ragister_view(request):
form = RegistrationForm(request.POST)
if request.method == "POST":
if form.is_valid():
username = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
if email and User.objects.filter(email=email):
messages.error(request, "Email addresses must be unique.")
return render(request, 'accounts/login.html')
user = form.save()
username = form.cleaned_data.get('username')
print(username)
#login(request, user)
user.is_active = False
user.save()
current_site = get_current_site(request)
subject = 'Please Activate Your Account'
# load a template like get_template()
# and calls its render() method immediately.
message = render_to_string(
'accounts/activation_request.html',
{
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
# method will generate a hash value with user related data
'token': account_activation_token.make_token(user),
})
to_email = form.cleaned_data.get('email')
send_mail(subject, message, '*****@*****.**',
[to_email])
return redirect('activation_sent')
else:
messages.error(request, "username must be unique.")
return render(request, "accounts/login.html")
def registration_view(request):
context = {}
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
account = authenticate(username=username, password=raw_password)
login(request, account)
if form.cleaned_data.get(
'user_type') == 'Student' or form.cleaned_data.get(
'user_type') == 'student':
return redirect(reverse('profile_info:student-profile'))
elif form.cleaned_data.get(
'user_type') == 'Teacher' or form.cleaned_data.get(
'user_type') == 'teacher':
return redirect(reverse('profile_info:tutor-profile'))
else:
context['registration_form'] = form
else:
form = RegistrationForm()
context['registration_form'] = form
return render(request, 'accounts/register.html', context)
def register(request):
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
if form.is_valid():
user = form.save()
return redirect('/accounts/register_success')
else:
form = RegistrationForm()
return render(request,'accounts/register.html', {'form':form,})
def test_reg_form(self):
"""
Test that ``RegistrationForm`` enforces username constraints
and matching passwords.
"""
# Create a user so we can verify that duplicate usernames aren't permitted.
User.objects.create_user('alice', '*****@*****.**', 'secret')
invalid_data_dicts = [
# Non-alphanumeric username.
{'data': {'username': '******',
'email': '*****@*****.**',
'password1': 'foo',
'password2': 'foo',
'tos': True},
'error': ('username', [u"This value may contain only letters, numbers and @/./+/-/_ characters."])},
# Already-existing username.
{'data': {'username': '******',
'email': '*****@*****.**',
'password1': 'secret',
'password2': 'secret',
'tos': True},
'error': ('username', [u"A user with that username already exists."])},
# Mismatched passwords.
{'data': {'username': '******',
'email': '*****@*****.**',
'password1': 'foo',
'password2': 'bar',
'tos': True},
'error': ('__all__', [u"The two password fields didn't match."])},
]
for invalid_dict in invalid_data_dicts:
form = RegistrationForm(data=invalid_dict['data'])
self.failIf(form.is_valid())
self.assertEqual(form.errors[invalid_dict['error'][0]],
invalid_dict['error'][1])
form = RegistrationForm(data={'username': '******',
'email': '*****@*****.**',
'password1': 'foo',
'password2': 'foo',
'tos': True})
self.failUnless(form.is_valid())
def test_reg_form_tos(self):
"""
Test that ``RegistrationFormTermsOfService`` requires
agreement to the terms of service.
"""
form = RegistrationForm(data={'username': '******',
'email': '*****@*****.**',
'password1': 'foo',
'password2': 'foo'})
self.failIf(form.is_valid())
self.assertEqual(form.errors['tos'],
[u"You must agree to the terms to register"])
form = RegistrationForm(data={'username': '******',
'email': '*****@*****.**',
'password1': 'foo',
'password2': 'foo',
'tos': 'on'})
self.failUnless(form.is_valid())
def register(request,template_name='register/p_register.html'):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('views.home'))
template_var={}
form = RegistrationForm()
if request.method == 'POST':
form = RegistrationForm(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)
if accounts_settings.USER_ACTIVE_BY_EMAIL == True:
user.is_active = False
user.save()
if accounts_settings.USER_ACTIVE_BY_EMAIL == False:
#if it's unnecessary to active by email, login directly.
_login(request, email, password)
return HttpResponseRedirect(reverse('views.home'))
else:
"""
Generates a one-use only link for activation and sends to the user
"""
from django.core.mail import send_mail
email_template_name = 'register/activation_email.html'
current_site = get_current_site(request)
site_name = current_site.name
domain = current_site.domain
use_https = False
t = loader.get_template(email_template_name)
c = {
'email': user.email,
'domain': domain,
'site_name': site_name,
'uid': int_to_base36(user.id),
'user': user,
'token': default_token_generator.make_token(user),
'protocol': use_https and 'https' or 'http',
}
try:
send_mail(_(u'%s：激活账户') % site_name,
t.render(Context(c)), None, [user.email])
return HttpResponseRedirect(reverse('accounts.views.register_complete'))
except:
user.delete()
return TemplateView.as_view(template_name='register/register_fail.html')
template_var['form'] = form
return render_to_response(template_name, template_var, context_instance=RequestContext(request))
def create_user_from_weibo(request, template_name='register/create_user_from_weibo.html'):
oauth_access_token = request.session.get('oauth_access_token', None)
if request.user.is_authenticated() or oauth_access_token is None:
return HttpResponseRedirect(reverse('home.views.index'))
client = APIClient(app_key=APP_KEY, app_secret=APP_SECRET, redirect_uri=_get_weibo_callback_url(request))
client.set_access_token(oauth_access_token['access_token'], oauth_access_token['expires_in'])
weibo_user = client.get.users__show(uid=oauth_access_token['uid'])
weibo_username = weibo_user.screen_name
template_var = {}
form = RegistrationForm(initial={'username': weibo_username })
if request.method == 'POST':
form = RegistrationForm(request.POST.copy())
if request.method == 'POST':
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.is_active = True
user.save()
profile = UserProfile()
profile.user = user
profile.song_ord_filed = 'post_datetime'
profile.save()
#weibo信息记录
w_user = WeiboUser()
w_user.user = user
w_user.weibo_user_id = oauth_access_token['uid']
w_user.weibo_username = weibo_username
w_user.oauth_access_token = oauth_access_token['access_token']
w_user.save()
#发微博提示
if request.POST.get('update_msg'):
msg = request.POST.get('bind_msg')[0:140]
client.post.statuses__update(status=msg)
user = authenticate(username=username, password=password)
auth_login(request,user)
return HttpResponseRedirect(reverse('songs.views.my_home'))
template_var['form'] = form
template_var['weibo_username'] = weibo_username
return render_to_response(template_name, template_var, context_instance=RequestContext(request))
def register(request):
next_url = request.GET.get('next', None)
if request.method == 'GET':
form = RegistrationForm()
return render(request, 'registration/registration_page.html', {'registration_form': form})
if request.method == 'POST':
# create a form instance and populate it with data from the request
form = RegistrationForm(request.POST, )
if form.is_valid():
client = request.session['client']
new_user = form.save(commit=False)
try: # create a user on the API
data = client.create_user(new_user.email, request.POST['password1'],
new_user.first_name, new_user.last_name,
new_user.phone_number)
new_user.booker_id = data.get('CustomerID', None)
if not new_user.booker_id:
raise ValidationError(data['ErrorMessage'],
code=data['ErrorCode'])
new_user.save()
except ValidationError as error:
form.add_error(None, error)
return render(request, 'registration/registration_page.html',
{'registration_form': form})
# login to the api
client.login(new_user.email, request.POST['password1'])
# authenticate and login the user locally
new_user = authenticate(email=request.POST['email'].lower(),
password=request.POST['password1'])
auth_login(request, new_user)
try:
request.cart.replace(request.session.get('CART-ID'), new_user)
except CartDoesNotExist:
pass
# store the user password for the length of the session
client.user = new_user
messages.info(request, 'Thanks for registering. You are now logged in.')
# redirect user the profile page
if next_url:
return HttpResponseRedirect(next_url)
return HttpResponseRedirect(reverse('welcome'))
return render(request, 'registration/registration_page.html',
{'registration_form': form, 'next': next_url})
def register_user(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
obj = form.save()
return HttpResponse('<meta http-equiv="refresh" content="1;url=/"/>Registration was successfull')
args = {}
args.update(csrf(request))
args['form'] = RegistrationForm()
return render_to_response('register.html', args)
def registration(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('accounts-home'))
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save()
send_activation(user)
return render(request, 'accounts/registration_done.html')
else:
form = RegistrationForm()
return render(request, 'accounts/registration.html', {'form': form})
def register(request):
registration_form = RegistrationForm(request.POST or None, request=request)
if registration_form.is_valid():
user = registration_form.save()
_backend_hackend(request, user)
return HttpResponseRedirect(request.REQUEST.get('next', '/'))
context = {
'registration_form': registration_form,
'months': range(1, 13),
'years': range(2011, 2036),
}
return TemplateResponse(request, 'accounts/register.html', context)
def registration(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse("accounts-home"))
if request.method == "POST":
form = RegistrationForm(request, request.POST)
if form.is_valid():
user = form.save()
send_activation2(user)
return render_to_response('accounts/registration_done.html', locals(), context_instance=RequestContext(request))
else:
form = RegistrationForm(request)
return render_to_response('accounts/registration.html', locals(), context_instance=RequestContext(request))
def registration(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse("accounts-home"))
if request.method == "POST":
form = RegistrationForm(request, request.POST)
if form.is_valid():
user = form.save()
send_activation(user)
return render(request, "accounts/registration_done.html")
else:
form = RegistrationForm(request)
return render(request, "accounts/registration.html", {"form": form})
def post(self, request):
form = RegistrationForm(request.POST)
print 'In Register View --- Post'
if form.is_valid():
user = User.objects.create_user(
username = form.cleaned_data['username'],
password = form.cleaned_data['password1'],
email = form.cleaned_data['email'],
#role = form.cleaned_data['role'],
)
user.save()
return HttpResponseRedirect('/register/success/')
variables = RequestContext(request, {'form' : form })
return render_to_response('registration/register.html', variables,)
def create_user(request):
form = RegistrationForm(request.POST or None)
if request.method == "POST" and form.is_valid():
form.save()
user = authenticate(username=form.cleaned_data["username"],
password=form.cleaned_data["password1"])
login(request, user)
return redirect("accounts:profile")
return render(request, "accounts/create.html", {
"form": form,
})
def registration(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save()
password = new_user.password
new_user.set_password(password)
create_cloud_container ( new_user.username )
new_user.save()
user = authenticate(username=new_user.username, password=password)
login(request, user)
return HttpResponseRedirect('/%s' % user.username)
else:
form = RegistrationForm()
return render(request, 'registration.html', {'form': form}, context_instance=RequestContext(request))
def register(request):
if request.user.is_authenticated(): # Check if the user is logged in
messages.add_message(request, messages.INFO, "You're currently logged in to Comet. If you want to register another account please <a href='/logout'>logout</a> first.")
return redirect("frontpage") # User is logged in, return them to index
if request.POST: # Some data was posted
# Create a form instance and populate it with the Post data
form = RegistrationForm(request.POST)
# Check whether the form is valid.
if form.is_valid():
# Form data is valid, send a verification email.
data = form.cleaned_data
user_url = generate()
while User.objects.filter(user_url=user_url).exists():
user_url = generate()
# You need to call user.objects.create_user rather than accessing
# the user manager directly.
User.objects.create_user(
email=data["email"],
username=data["username"],
password=data["password"],
user_url=user_url,
)
# Authenticate
user = authenticate(
username=data["email"],
password=data["password"],
)
login_user(request, user) # Log the user in.
if "next" in request.GET:
return redirect(request.GET["next"])
return redirect("messages")
# Form data was invalid, render the page with error messages
next_dir = ""
if "next" in request.GET:
next_dir=request.GET["next"]
return renderRegister(request, next_dir=next_dir, form=form)
else: # No data was posted, render a regular page
next_dir = ""
if "next" in request.GET:
next_dir=request.GET["next"]
return renderRegister(request, next_dir=next_dir)
def register(request):
"""
User registration view.
"""
navbarlinks = list_navbarlinks(request, ["Registration", "Help page"])
navbarlinks.append({"url": "/help#helpsection_registrationpage", "title": "Help page", "icon": "question-sign"})
shortcutlinks = list_shortcutlinks(request, ["Registration"])
auth_email = request.session["auth_email"]
auth_firstname = request.session["auth_firstname"]
auth_surname = request.session["auth_surname"]
auth_data = {"auth_email": auth_email, "auth_firstname": auth_firstname, "auth_lastname": auth_surname}
if request.method == 'POST':
data = request.POST.copy()
data.update(auth_data)
form = RegistrationForm(data=data)
if form.is_valid():
try:
user = form.save()
request.session["registration_state"] = "done"
user = authenticate(email=auth_email, password="******")
if user.is_active:
django_login(request, user)
request.session["user"] = user.annotator_id.annotator_id
except IntegrityError:
# catch "UNIQUE constraint failed" error
# May catch other errors in which case the error message displayed in the UI would not be accurate
return render_to_response(
'accounts/register.html',
{'navbarlinks': navbarlinks, 'shortcutlinks': shortcutlinks, 'form': form, 'alreadytaken': True},
context_instance=RequestContext(request)
)
return redirect('/interface_main')
else:
print form.errors
else:
form = RegistrationForm(data=auth_data)
return render_to_response('accounts/register.html', {
'navbarlinks': navbarlinks,
'shortcutlinks': shortcutlinks,
'auth_email': auth_email,
'auth_firstname': auth_firstname,
'auth_lastname': auth_surname,
'form': form,}, context_instance=RequestContext(request))
def AccountRegistration(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/')
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
user.save()
return HttpResponseRedirect('/')
else:
return render_to_response('register.html', {'form': form}, context_instance = RequestContext(request))
else:
# user not submitted form show blank
form = RegistrationForm()
context = {'form': form}
return render_to_response('register.html', context, context_instance = RequestContext(request))
