def register(request,
disallowed_url='registration_disallowed',
template_name='registration/registration.html'):
"""用户注册
"""
# 是否允许用户进行注册
allow_register = getattr(settings, 'REGISTRATION_OPEN', False)
if not allow_register:
return redirect(disallowed_url)
if request.method == 'POST':
form = RegistrationForm(request.POST)
# 数据验证
if form.is_valid():
username = form.cleaned_data['username']
email = form.cleaned_data['email']
password = form.cleaned_data['password1']
# 创建一个未激活的用户和默认的扩展属性
act_key = TeamProfile.objects.create_inactive_user(username, email, password)
# 直接将激活码作为链接发给用户
to, args, kwargs = ('registration_activate',(), {'activation_key':act_key})
return redirect(to, *args, **kwargs)
else:
form = RegistrationForm()
context = RequestContext(request)
return render_to_response(template_name,
{'form': form},
context_instance=context)
def register(request, template_name='registration/register.html'):
profile_url = settings.USER_PROFILE_URL % 'username'
if request.method == 'GET':
form = RegistrationForm()
else: # POST
form = RegistrationForm(data=request.POST)
if form.is_valid():
hn_username = form.cleaned_data['hn_username']
# user_data is a dict containing the users HN account creation
# date, karma at query time, and HN profile
user_data = retrieve_hn_user_data(hn_username)
# form validation checks that hn_username matches what's provided
# and that the "key" (a url) is in the profile
temp_password = ''.join(random.sample(string.letters, 16))
new_user = User.objects.create_user(username=hn_username,
email='',
password=temp_password)
user = authenticate(username=new_user.username,
password=temp_password)
if user is not None:
login(request, user)
messages.success(request,
'That worked. Please provide a password.')
return HttpResponseRedirect(reverse('set_password'))
return render_to_response(template_name,
locals(),
context_instance=RequestContext(request))
def register(request):
if request.user.is_authenticated():
return redirect('current_profile')
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password1']
#new_user = RegistrationProfile.objects.create_inactive_user(username, email, password)
#return redirect('registration_complete')
user = User.objects.create_user(username, form.cleaned_data['email'], password)
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.save()
user = auth.authenticate(username=username, password=password)
assert user and user.is_authenticated()
auth.login(request, user)
# TODO: redirect to a message with confirmation
return redirect(user.get_absolute_url())
else:
form = RegistrationForm()
return render_to_response('users/register.html',
context_instance=RequestContext(request, {'form': form}))
def create_account(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(
form.cleaned_data['email'],
form.cleaned_data['email'],
form.cleaned_data['password'],
)
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.save()
# Log in the new user. Note that Django requires that we call
# authenticate() despite its apparent redundancy in this case
user = authenticate(username=user.username,
password=form.cleaned_data['password'])
login(request, user)
return redirect(reverse('registration.views.create_account_done'))
else:
form = RegistrationForm()
return render_to_response('registration/create_account.html',
RequestContext(request, {
'form': form,
}))
def handle_post(self, request):
"""
Registers a user if it was a request to register a user
and the registration form was correctly completed.
"""
# Confirm that the requst is a post, and that this form is
# the intended recipient of the posted data.
if not request.POST or self.submit_btn_name() not in request.POST:
return None
form = RegistrationForm(request.POST, auto_id=False)
if form.is_valid():
# Create a user, log them in, and redirect based on the
# success_url rules.
user, created = User.objects.create_user(request=request,
send_email=True,
**form.cleaned_data)
user_cache = authenticate(
username=form.cleaned_data['email'],
password=form.cleaned_data['password1'])
expire_login(request, user_cache)
response = HttpResponseRedirect(success_url(request))
response.set_cookie('myguid', user.user_guid, expires=365*24*60*60,
domain='.my.jobs')
return response
return None
def register(request, extra_context=None):
if not getattr(settings, 'REGISTRATION_OPEN', True):
return redirect('registration_disallowed')
if request.method == 'POST':
form = RegistrationForm(data=request.POST, files=request.FILES)
if form.is_valid():
username, email, password = form.cleaned_data['username'], form.cleaned_data['email'], form.cleaned_data['password1']
site = Site.objects.get_current() if Site._meta.installed else RequestSite(request)
new_user = RegistrationProfile.objects.create_inactive_user(username, email, password, site)
signals.user_registered.send(sender=None, user=new_user, request=request)
profile = UserProfile.objects.get(user=new_user)
seller_type = form.cleaned_data['seller_type']
phone = form.cleaned_data['phone']
profile.seller_type = seller_type
profile.phone = phone
profile.save()
gravatar_task.delay(new_user, new_user.pk)
success_url = request.GET.get('next','')
if success_url:
return redirect(success_url)
else:
return redirect('registration_complete')
else:
form = RegistrationForm()
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return render_to_response('static_pages/index.html', {'register_form': form}, context_instance=context)
def register(request, template_name='registration/register.html'):
profile_url = settings.USER_PROFILE_URL % 'username'
if request.method == 'GET':
form = RegistrationForm()
else: # POST
form = RegistrationForm(data=request.POST)
if form.is_valid():
hn_username = form.cleaned_data['hn_username']
# user_data is a dict containing the users HN account creation
# date, karma at query time, and HN profile
user_data = retrieve_hn_user_data(hn_username)
# form validation checks that hn_username matches what's provided
# and that the "key" (a url) is in the profile
temp_password = ''.join(random.sample(string.letters, 16))
new_user = User.objects.create_user(username=hn_username,
email='',
password=temp_password)
user = authenticate(username=new_user.username,
password=temp_password)
if user is not None:
login(request, user)
messages.success(request, 'That worked. Please provide a password.')
return HttpResponseRedirect(reverse('set_password'))
return render_to_response(template_name, locals(),
context_instance=RequestContext(request))
def register(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/profile/')
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(username=form.cleaned_data['username'], email = form.cleaned_data['email'], password=form.cleaned_data['password'])
user.save()
registration = UserProfile(user=user, name = form.cleaned_data['name'], address = form.cleaned_data['address'],
contact = form.cleaned_data['contact'], stream = form.cleaned_data['stream'], age = form.cleaned_data['age'],
gender = form.cleaned_data['gender'], register_as = form.cleaned_data['register_as']
)
if form.cleaned_data['register_as']=='FY':
facstat = FacultyStatus(username = form.cleaned_data['username'], name = form.cleaned_data['name'])
facstat.save()
if 'picture' in request.FILES:
registration.picture = request.FILES['picture']
registration.save()
return HttpResponseRedirect('/profile')
else:
return render_to_response('registration/register.html',{'form':form, 're':"active"}, context_instance=RequestContext(request))
else:
form = RegistrationForm()
context = {'form': form, 're':"active"}
return render_to_response('registration/register.html', context, context_instance=RequestContext(request))
def register(request):
if not request.user.is_anonymous():
return redirect('/home/')
if request.method == 'POST':
title = "Update Profile"
form = RegistrationForm(request.POST)
if form.is_valid():
email = form.cleaned_data['email']
password = form.cleaned_data['password1']
user = User.objects.create(username=email_to_username(email),
email=email)
user.set_password(password)
user.save()
account = Account.objects.create(
user=user,
first_name=form.cleaned_data['first_name'],
middle_name=form.cleaned_data['middle_name'],
last_name=form.cleaned_data['last_name'],
mobile_no=form.cleaned_data['phone_number'],
email=form.cleaned_data['email']
)
return redirect('/register/success/')
else:
title = "Create New Profile"
form = RegistrationForm()
return render(
request,
'registration/register.html',
{'form': form, 'title': title}
)
def create_account(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(
form.cleaned_data['email'],
form.cleaned_data['email'],
form.cleaned_data['password'],
)
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.save()
# Log in the new user. Note that Django requires that we call
# authenticate() despite its apparent redundancy in this case
user = authenticate(username=user.username, password=form.cleaned_data['password'])
login(request, user)
return redirect(reverse('registration.views.create_account_done'))
else:
form = RegistrationForm()
return render_to_response('registration/create_account.html', RequestContext(request, {
'form': form,
}))
def edit(request):
curr_user = request.user
if request.method == 'POST':
form = RegistrationForm(request.POST, user=curr_user)
if form.is_valid():
try:
curr_user.account.first_name = form.cleaned_data['first_name']
curr_user.account.middle_name = form.cleaned_data['middle_name']
curr_user.account.last_name = form.cleaned_data['last_name']
curr_user.account.mobile_no = form.cleaned_data['phone_number']
#curr_user.account.email = form.cleaned_data['email']
curr_user.account.save()
except Account.DoesNotExist:
return HttpResponse('The Account object does not exist for this user')
return redirect('/register/success/')
else:
form = RegistrationForm(user=curr_user)
return render(
request,
'registration/register.html',
{'form': form, 'title': 'Update Profile'}
)
def handle_post(self, request):
"""
Registers a user if it was a request to register a user
and the registration form was correctly completed.
"""
# Confirm that the requst is a post, and that this form is
# the intended recipient of the posted data.
if not request.POST or self.submit_btn_name() not in request.POST:
return None
form = RegistrationForm(request.POST, auto_id=False)
if form.is_valid():
# Create a user, log them in, and redirect based on the
# success_url rules.
user, created = User.objects.create_user(request=request,
send_email=True,
**form.cleaned_data)
user_cache = authenticate(username=form.cleaned_data['email'],
password=form.cleaned_data['password1'])
expire_login(request, user_cache)
response = HttpResponseRedirect(success_url(request))
response.set_cookie('myguid',
user.user_guid,
expires=365 * 24 * 60 * 60,
domain='.my.jobs')
return response
return None
def user_profile_post(request, **kwargs):
user=request.user
form=RegistrationForm(request.POST)
added_context={'registration_form': form}
if not form.is_valid(user=user):
form.reformat_errors()
# log.debug('user %r not valid, aborting' % user.contributor)
return render(request, 'registration/user_profile.html', added_context)
user.first_name=form.cleaned_data['first_name']
user.last_name=form.cleaned_data['last_name']
user.email=form.cleaned_data['email']
user.password=make_password(form.cleaned_data['password1'])
user.contributor.lab.name=form.cleaned_data['lab']
user.contributor.lab.url=form.cleaned_data['lab_url']
try:
# log.debug('about to save user: %r' % user.contributor)
user.save()
added_context['msgs']='Profile successfully updated'
except Exception as e:
msgs='Unable to save user information: %s' % e
added_context['msgs']=msgs
# log.debug(msgs)
return render(request, 'registration/user_profile.html', added_context)
def login(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
return HttpResponseRedirect('')
else:
return render(request, 'registration/login.html')
def __init__(self, *args, **kwargs):
user_profile_instance = kwargs.pop('user_profile_instance', None)
captcha_answer = kwargs.pop('captcha_answer', None)
RegistrationForm.__init__(self, captcha_answer=captcha_answer, *args, **kwargs)
ArtistProfileUpdateForm.__init__(self, user_profile_instance=user_profile_instance, *args, **kwargs)
# Move CAPTCHA and EULA fields to the end
self.fields.keyOrder.remove('captcha')
self.fields.keyOrder.remove('over13')
self.fields.keyOrder.remove('accept_eula')
self.fields.keyOrder.extend(['captcha', 'over13', 'accept_eula'])
def createUser(request):
if request.method == 'POST': # If the form has been submitted...
form = RegistrationForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
try:
form.save()
except ValidationError, err:
error = unicode(err)
return render(request, 'createuser.html', {'form': form, 'error': error})
return HttpResponseRedirect('/thanks/') # Redirect after POST
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save()
return redirect('registration_completed')
else:
form = RegistrationForm()
return TemplateResponse(request, 'registration/register.html', {'form': form})
def login_register(request):
form = None
next_url = None
if request.method == 'POST':
action = request.POST.get('action')
next_url = request.GET.get('next') or reverse('login')
if action == 'login':
username = request.POST.get('username', '')
password = request.POST.get('password1', '')
if username and password:
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
return redirect(next_url)
# Could not authenticate
form = {
'username': {
'errors': 'Your username and password did not match.',
}
}
else:
form = {
'password1': {
'errors': 'Please enter a username and password.',
},
}
elif action == 'register':
form = RegistrationForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
email = form.cleaned_data['email']
password = form.cleaned_data['password1']
User.objects.create_user(username, email, password)
user = authenticate(username=username, password=password)
login(request, user)
return redirect(next_url)
else:
# The action is not set. Malicious submission?
pass
context = {
'next_url': next_url,
'form': form,
}
return render(request, 'login.djhtml', context)
def _register_all(trial_run, email_func):
if trial_run:
def trial_email(subject, body, from_, addresses, fail_silently):
print "-" * 60
print "Would send this mail:"
print "To: %s" % ", ".join(addresses)
print "From: %s" % from_
print "Subject: %s" % subject
print
print body
print '-' * 60
email_func = trial_email
anon_racks = Rack.objects.filter(user=u'')
addrs = set([rack.email.strip() for rack in anon_racks])
names_seen = set()
current_site = Site.objects.get(id=settings.SITE_ID)
for email in addrs:
name = email.split('@', 1)[0]
import re
name = re.sub(r'[^!A-Za-z0-9_-]', '_', name)
if name in names_seen:
raise ValueError("Oh crap, already saw name %r" % name)
names_seen.add(name)
password = randpass() # Just so we always have a non-empty password.
data = {'username': name, 'email': email,
'password1': password, 'password2': password,}
template_args = {'name': name, 'email': email, 'domain': current_site.domain,
'password': password,
'activation_days': settings.ACCOUNT_ACTIVATION_DAYS,
}
form = RegistrationForm(data=data)
if form.is_valid():
# Register an inactive account and get the key.
template = register_email_txt
user = form.save()
reg_profile = RegistrationProfile.objects.filter(user=user)[0]
template_args['key'] = reg_profile.activation_key
# We also need to provide a way to set your password.
template_args['password_reset_token'] = default_token_generator.make_token(user)
template_args['uidb36'] = int_to_base36(user.id)
if trial_run:
user.delete(); reg_profile.delete()
else:
if form.errors.get('username', [''])[0].count(u'already taken'):
# Send an email without the link to the predetermined username.
template = register_email_name_taken_txt
else:
print "Problem with address %s:" % email
import pprint
pprint.pprint(form.errors)
continue
send_email(template, trial_run, email_func=email_func, **template_args)
def login(request):
#grab the redirect URL if set
if request.POST.get('next'):
redirect = request.POST.get('next')
elif request.POST.get('redirect'):
redirect = request.POST.get('redirect')
elif request.GET.get('next'):
redirect = request.GET.get('next')
else:
redirect = request.META.get('HTTP_REFERER', '/')
if redirect.endswith("login"):
redirect = "/myaccount"
login_form = AuthenticationForm()
registration_form = RegistrationForm()
if request.POST:
login_form = AuthenticationForm(request.POST)
registration_form = RegistrationForm(request.POST)
username = request.POST.get('username', None)
password = request.POST.get('password', None)
user = auth.authenticate(username=username, password=password)
if user is not None:
if user.is_active:
auth.login(request, user)
return HttpResponseRedirect(redirect)
if registration_form.is_valid():
u = User(username=request.POST['username'],
email=request.POST['email'],
)
u.set_password(request.POST['password1'])
u.is_active = True
u.save()
p = Profile(user=u)
p.save()
user = auth.authenticate(username=request.POST['username'], password=request.POST['password1'])
auth.login(request, user)
return HttpResponseRedirect(redirect)
return render_to_response('login.html',
{
'login_form': login_form,
'registration_form': registration_form,
'redirect' : redirect,
},
context_instance = RequestContext(request)
)
def createUser(request):
if request.method == 'POST': # If the form has been submitted...
form = RegistrationForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
try:
form.save()
except ValidationError, err:
error = unicode(err)
return render(request, 'createuser.html', {
'form': form,
'error': error
})
return HttpResponseRedirect('/thanks/') # Redirect after POST
def subscribe(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['password1'],
email=form.cleaned_data['email']
)
return HttpResponseRedirect('/')
else:
form = RegistrationForm()
return render(request, 'general/signup.html',{'form': RegistrationForm()})
def __init__(self, *args, **kwargs):
user_profile_instance = kwargs.pop('user_profile_instance', None)
captcha_answer = kwargs.pop('captcha_answer', None)
RegistrationForm.__init__(self,
captcha_answer=captcha_answer,
*args,
**kwargs)
ArtistProfileUpdateForm.__init__(
self, user_profile_instance=user_profile_instance, *args, **kwargs)
# Move CAPTCHA and EULA fields to the end
self.fields.keyOrder.remove('captcha')
self.fields.keyOrder.remove('over13')
self.fields.keyOrder.remove('accept_eula')
self.fields.keyOrder.extend(['captcha', 'over13', 'accept_eula'])
def cal(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
result = 0
if form.is_valid():
result = 1
Line = form.cleaned_data['LineCode']
Machine = form.cleaned_data['MachineCode']
Product = form.cleaned_data['ProductCode']
result = OEEcal(Line, Machine, Product)
return render(request, 'production/index.html', {
'result': result,
'te': 1
})
def register(request):
if request.POST:
# load up the form with data from the POST request
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(username=form.cleaned_data['email'], email=form.cleaned_data['email'],
password=form.cleaned_data['password'])
return render(request, 'register_result.html', {'email': user.username})
else:
print form.errors
else:
form = RegistrationForm()
return render(request, 'register.html', {'form': form})
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME):
"Displays the login form and handles the login action."
redirect_to = request.REQUEST.get(redirect_field_name, '')
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
if form.is_valid():
# Light security check -- make sure redirect_to isn't garbage.
if not redirect_to or '//' in redirect_to or ' ' in redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
from django.contrib.auth import login
login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
return HttpResponseRedirect(redirect_to)
else:
form = AuthenticationForm(request)
request.session.set_test_cookie()
if Site._meta.installed:
current_site = Site.objects.get_current()
else:
current_site = RequestSite(request)
return render_to_response(template_name, {
'form': form,
'reg_form': RegistrationForm(),
redirect_field_name: redirect_to,
'site_name': current_site.name,
}, context_instance=RequestContext(request))
def clean(self):
email_username, email_domain = parse_email(self.cleaned_data.get('email', ''))
if not email_username:
return self.cleaned_data
self.cleaned_data['username'] = email_username
self.cleaned_data['username'] = RegistrationForm.clean_username(self)
return self.cleaned_data
def save(self, commit=True):
user = RegistrationForm.save(self, commit=commit)
profile = user.get_profile()
artist_profile = ArtistProfileUpdateForm.save(self,
profile,
commit=commit)
return user
def register(request):
is_registered = False
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
if form.is_valid():
backend = DefaultBackend()
new_user = backend.register(request, **form.cleaned_data)
is_registered = True
else:
is_registered = False
else:
is_registered = False
result = {"Status": is_registered}
response = json.dumps(result)
return HttpResponse(response)
def register(self, form):
"""
Save all the fields not included in the standard `RegistrationForm`
into the JSON `data` field of an `ExtraUserDetail` object
"""
## ANTEA START
# if REGISTRATION_DEFAULT_FROM_EMAIL email is set, send validation account mail to this email
import os
new_user_email = form.instance.email
if os.environ.get('REGISTRATION_DEFAULT_FROM_EMAIL'):
form.instance.user_email = new_user_email
form.instance.email = os.environ.get(
'REGISTRATION_DEFAULT_FROM_EMAIL')
form.cleaned_data['email'] = os.environ.get(
'REGISTRATION_DEFAULT_FROM_EMAIL')
## ANTEA END
standard_fields = set(RegistrationForm().fields.keys())
extra_fields = set(form.fields.keys()).difference(standard_fields)
# Don't save the user unless we successfully store the extra data
with transaction.atomic():
new_user = super().register(form)
extra_data = {k: form.cleaned_data[k] for k in extra_fields}
new_user.extra_details.data.update(extra_data)
new_user.extra_details.save()
## ANTEA START
# and reset the email to the new user
new_user.email = new_user_email
new_user.save()
## ANTEA END
return new_user
def create_user(request, post_data, files):
"""Create new user from a distutil client request"""
form = RegistrationForm({"username": post_data["name"],
"email": post_data["email"],
"password1": post_data["password"],
"password2": post_data["password"]})
if not form.is_valid():
# Dist Utils requires error msg in HTTP status: "HTTP/1.1 400 msg"
# Which is HTTP/WSGI incompatible, so we're just returning a empty 400.
return HttpResponseBadRequest()
backend = get_backend("registration.backends.default.DefaultBackend")
if not backend.registration_allowed(request):
return HttpResponseBadRequest()
new_user = backend.register(request, **form.cleaned_data)
return HttpResponse("OK\n", status=200, mimetype='text/plain')
def get_context_data(self, **kwargs):
login_form = AuthenticationForm()
registration_form = RegistrationForm()
context = super(HomeView, self).get_context_data(**kwargs)
context['login_form'] = login_form
context['registration_form'] = registration_form
return context
def home_page(request):
context = {}
context.update(csrf(request))
context.update({'reg_form': RegistrationForm()})
context.update({'login_form': AuthenticationForm()})
return render(request, 'geodjango/index.html', context)
def register(request,
success_url='/accounts/register/complete/',
template_name='registration_form.html'):
"""
Allows a new user to register an account. A customised variation of the
view of the same name from django-registration.
Context::
form
The registration form
Template::
registration/registration_form.html (or template_name argument)
"""
if request.method == 'POST':
form = RegistrationFormOpenID(request.POST, request=request)
if form.is_valid():
RegistrationProfile.objects.create_inactive_user(
username=form.cleaned_data['username'],
password=form.cleaned_data['password1'],
email=form.cleaned_data['email'],
)
return HttpResponseRedirect(success_url)
else:
form = RegistrationForm()
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
def index(request):
if not request.user.is_authenticated():
if WEBSITE == 'murmur':
return render_to_response('home.html', {
'form': AuthenticationForm(),
'reg_form': RegistrationForm()
},
context_instance=RequestContext(request))
elif WEBSITE == 'squadbox':
return render_to_response('squadbox/home.html', {
'form': AuthenticationForm(),
'reg_form': RegistrationForm()
},
context_instance=RequestContext(request))
else:
return HttpResponseRedirect('/posts')
def home(request):
'''
if request.method == 'POST':
print "post"
registration_form = RegistrationForm(request.POST)
if registration_form.is_valid():
new_user = registration_form.save()
return HttpResponseRedirect('/profile/')
else:
print "not post"
'''
if request.user.is_authenticated():
return HttpResponseRedirect('/profile')
registration_form = RegistrationForm()
print "out"
t = get_template('index2.html')
context = {
'user': request.user,
# 'registration_form': registration_form,
# 'login_form': AuthenticationForm(),
}
context.update(csrf(request))
return render_to_response('index2.html', context)
def home(request, template_name="registration/register.html"):
"""Home view"""
# NOTE: Only using the actual 'django form' on the POST side b/c we could
# be running split tests on the actual form elements (some are shown and
# some aren't, etc.). So, it's just easier to render the form ourselves on
# the template side.
if request.method == 'POST':
form = RegistrationForm(request.POST)
if not form.is_valid():
return render(request, template_name,
{'test_choice': int(request.POST['choice']),
'form': form})
if form.cleaned_data['choice'] > 0:
choice = form.cleaned_data['choice']
try:
result = TestResult.objects.get(pk=choice)
except TestResult.DoesNotExist:
result = _create_result_object(choice)
if result is not None:
result.conversions += 1
result.save()
# NOTE: The data could easily be saved here into the standard django
# User model or a custom one. However, the point of this app is just
# to demonstrate A/B split testing, not saving user information.
return HttpResponseRedirect('/register/thanks')
else:
# See if there's a test running for this url
choice = _get_choice_for_split_test('registration.views.home')
if choice > 0:
try:
result = TestResult.objects.get(pk=choice)
except TestResult.DoesNotExist:
result = _create_result_object(choice)
if result is not None:
result.visitors += 1
result.save()
return render(request, template_name, {'test_choice': choice})
def register(request):
if request.POST:
# load up the form with data from the POST request
form = RegistrationForm(request.POST)
if form.is_valid():
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
user = create_fingr_user(form.cleaned_data['email'], form.cleaned_data['password'], first_name=first_name,
last_name=last_name)
verification(form.cleaned_data['email'], user, request)
return render(request, 'register_result.html', {'email': user.username})
else:
form = RegistrationForm()
return render(request, 'register.html', {'form': form})
def post(self, request, *args, **kwargs):
form = RegistrationForm(request.POST or None)
if form.is_valid():
new_user = form.save(commit=False)
username = form.cleaned_data['username']
password = form.cleaned_data['password']
new_user.set_password(password)
password_check = form.cleaned_data['password_check']
# phone = form.cleaned_data['phone']
email = form.cleaned_data['email']
new_user.save()
UserAccount.objects.create(
user=User.objects.get(username=new_user.username),
email=new_user.email)
return HttpResponseRedirect('/')
context = {'form': form}
return render(self.request, self.template, context)
def register(request):
"""
Registration form. Creates inactive user (which in turn sends an activation
email) and redirect to registration complete page.
"""
form = RegistrationForm()
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = User.objects.create_inactive_user(**form.cleaned_data)
username = form.cleaned_data['email']
password = form.cleaned_data['password1']
user = authenticate(username=username, password=password)
expire_login(request, user)
return HttpResponseRedirect('/accounts/register/complete/')
return HttpResponse(json.dumps({'errors': form.errors.items()}))
def register(request):
"""
Registration form. Creates inactive user (which in turn sends an activation
email) and redirect to registration complete page.
"""
form = RegistrationForm()
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = User.objects.create_inactive_user(**form.cleaned_data)
username = form.cleaned_data['email']
password = form.cleaned_data['password1']
user = authenticate(username=username, password=password)
expire_login(request, user)
return HttpResponseRedirect('/accounts/register/complete/')
return HttpResponse(json.dumps({'errors': form.errors.items()}))
def context(self, request, **kwargs):
querystring = "?%s" % request.META.get('QUERY_STRING')
if request.POST and self.submit_btn_name() in request.POST:
# If data is being posted to this specific block, give the form
# the opportunity to render any errors.
return {
'registration_action': querystring,
'query_string': querystring,
'registration_form': RegistrationForm(request.POST,
auto_id=False),
'registration_submit_btn_name': self.submit_btn_name(),
}
return {
'registration_action': querystring,
'registration_form': RegistrationForm(),
'registration_submit_btn_name': self.submit_btn_name(),
}
def index(request):
if request.user.is_authenticated():
return render(request, "dashboard.html")
else:
return render(
request, "index.html", {
"login_form": AuthenticationForm(),
"registration_form": RegistrationForm(),
})
def create_user(request, post_data, files, backend_name=DEFAULT_BACKEND):
"""Create new user from a distutil client request"""
form = RegistrationForm({
"username": post_data["name"],
"email": post_data["email"],
"password1": post_data["password"],
"password2": post_data["password"]
})
if not form.is_valid():
# Dist Utils requires error msg in HTTP status: "HTTP/1.1 400 msg"
# Which is HTTP/WSGI incompatible, so we're just returning a empty 400.
return HttpResponseBadRequest()
backend = get_backend(backend_name)
if not backend.registration_allowed(request):
return HttpResponseBadRequest()
new_user = backend.register(request, **form.cleaned_data)
return HttpResponse("OK\n", status=200, mimetype='text/plain')
def register(request, template_name='static_pages/splash.html'):
if request.method == 'POST':
form = RegistrationForm(data=request.POST, files=request.FILES)
if form.is_valid():
username = form.cleaned_data['email'].split('@')[0]
email = form.cleaned_data['email']
password = form.cleaned_data['password1']
if Site._meta.installed:
site = Site.objects.get_current()
else:
site = RequestSite(request)
new_user = RegistrationProfile.objects.create_inactive_user(username,
email,
password,
site)
signals.user_registered.send(sender=RegistrationProfile,
user=new_user,
request=request)
profile = UserProfile.objects.get(user=new_user)
profile.save()
# Check if the email matches a professor in the db
try:
professor = Professor.objects.get(email=email)
profile.professor_assoc = professor
profile.save()
except Professor.DoesNotExist:
# Not a professor in our db, but user came from
# professor registration page
if request.POST.get('is_professor', False):
# is_professor field is only for validation
return redirect('prof_reg_error')
# else drop down to normal registration
messages.add_message(request, messages.INFO,
"Thanks for signing up! Check your email for an activation link.")
success_url = request.GET.get('next')
if success_url:
return redirect(success_url)
else:
return redirect('index')
else:
form = RegistrationForm()
return TemplateResponse(request, template_name, {'form': form})
def school_info(request):
if request.method == 'POST':
# adminForm.clean()
try:
form = SchoolForm(request.POST, instance=request.session['school'])
except:
new = True
request.session['school'] = School()
form = SchoolForm(request.POST, instance=request.session['school'])
# sem.school=request.session['school']
if 'password1' in request.POST:
adminForm = RegistrationForm(request.POST)
else:
adminForm = None
if adminForm and adminForm.is_valid():
admin = User.objects.create_user(username=adminForm.cleaned_data['email'],
email=adminForm.cleaned_data['email'],
password=adminForm.cleaned_data[
'password1'])
role = Role(user=admin, is_admin=True)
role.save()
if form.is_valid():
request.session['school'].admin = admin
form.instance
form.save()
return HttpResponseRedirect('/')
else:
print 'form not valid', dir(form)
else: # GET
try:
form = SchoolForm(instance=request.session['school'])
except:
new = True
request.session['school'] = School()
form = SchoolForm(instance=request.session['school'])
if not request.session['school'].admin: # admin is in
adminForm = RegistrationForm()
return my_render_to_response(request, 'school_info.html', locals())
def register(request):
if request.user.is_authenticated():
return redirect('edit_profile')
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save()
#user = auth.authenticate(username=username, password=password)
#assert user and user.is_authenticated()
#auth.login(request, user)
return redirect('registration_completed')
else:
form = RegistrationForm()
return TemplateResponse(request, 'registration/register.html', {'form': form})
def register(request):
member_form = MemberForm(request.POST or None)
registration_form = RegistrationForm(request.POST or None)
if request.method == 'POST':
member_form = MemberForm(request.POST, request.FILES)
registration_form = RegistrationForm(request.POST)
if member_form.is_valid() and registration_form.is_valid():
member_form.save()
registration_form.save()
registration_form.new_person_form = member_form
registration_form.save()
else:
member_form = member_form
registration_form = registration_form
return render(request, 'registration/registration_form.html', {
'member_form': member_form,
'registration_form': registration_form,
})
def professor_register(request, template_name='cr_registration/professor_registration_form.html'):
# if request.user.is_authenticated():
# return redirect('index')
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
if form.is_valid():
try:
# professor = Professor.objects.get(email=form.cleaned_data['email'])
return register(request,
template_name='cr_registration/professor_registration_form.html')
except Professor.DoesNotExist:
return redirect('prof_reg_error')
else:
return TemplateResponse(request, template_name, {'form': form})
else:
form = RegistrationForm()
return TemplateResponse(request, template_name, {'form': form})
def _register_all():
anon_racks = Rack.objects.filter(user=u"")
addrs = set([rack.email.strip() for rack in anon_racks])
names_seen = set()
current_site = Site.objects.get(id=settings.SITE_ID)
for email in addrs:
name = email.split("@", 1)[0]
name = name.replace("+", "_") # XXX do more cleanup
if name in names_seen:
raise ValueError("Oh crap, already saw name %r" % name)
names_seen.add(name)
password = randpass() # Just so we always have a non-empty password.
data = {"username": name, "email": email, "password1": password, "password2": password}
template_args = {
"name": name,
"email": email,
"domain": current_site.domain,
"password": password,
"activation_days": settings.ACCOUNT_ACTIVATION_DAYS,
}
form = RegistrationForm(data=data)
if form.is_valid():
# Register an inactive account and get the key.
template = register_email_txt
user = form.save()
reg_profile = RegistrationProfile.objects.filter(user=user)[0]
template_args["key"] = reg_profile.activation_key
# We also need to provide a way to set your password.
template_args["password_reset_token"] = default_token_generator.make_token(user)
template_args["uidb36"] = int_to_base36(user.id)
# user.delete(); reg_profile.delete() #XXX remove this when everything works
else:
if form.errors.get("username", [""])[0].count(u"already taken"):
# Send an email without the link to the predetermined username.
template = register_email_name_taken_txt
else:
print "Problem with address %s:" % email
import pprint
pprint.pprint(form.errors)
continue
send_email(template, **template_args)
def index(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('registration/registered')
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'registration/index.html', args)
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['password1'],
email=form.cleaned_data['email'],
first_name=form.cleaned_data['firstname'],
last_name=form.cleaned_data['lastname'],
is_active=False,
)
return HttpResponseRedirect('success/')
else:
form = RegistrationForm()
variables = RequestContext(request, {'form': form})
return render_to_response(
'registration/register.html',
variables,
)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('pvm_forms:index')
else:
form = RegistrationForm()
return render(request, 'registration/register.html', {'form': form})
def signup(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
subject = 'Activate Your MySite Account'
message = render_to_string(
'prabhav/registration/account_activation_email.html',
{
'user': user,
'domain': current_site.domain,
# 'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'uid': urlsafe_base64_encode(force_bytes(
user.pk)).decode(),
'token': account_activation_token.make_token(user),
})
from_email = [settings.EMAIL_HOST_USER]
to_email = [user.email]
send_mail(subject=subject,
from_email=from_email,
recipient_list=to_email,
message=message,
fail_silently=False)
return redirect('account_activation_sent')
else:
form = RegistrationForm()
return render(request, 'prabhav/registration/signup.html', {'form': form})
def get(self, request, *args, **kwargs):
language = request.LANGUAGE_CODE
challenge = Challenge.get_unsolved_challenge(language=language)
challenge_id = challenge.id if challenge else None
order_id = Registration.generate_order_id()
context = {
'order_id': order_id,
'form': RegistrationForm(challenge=challenge),
'stripe_public_key': self.get_stripe_public_key(),
'challenge_id': challenge_id
}
print 'GET ====== '
return render(request, self.template_name, context)
def register(self, request, form, *args, **kwargs):
''' Save all the fields not included in the standard `RegistrationForm`
into the JSON `data` field of an `ExtraUserDetail` object '''
standard_fields = set(RegistrationForm().fields.keys())
extra_fields = set(form.fields.keys()).difference(standard_fields)
# Don't save the user unless we successfully store the extra data
with transaction.atomic():
new_user = super(ExtraDetailRegistrationView,
self).register(request, form, *args, **kwargs)
extra_data = {k: form.cleaned_data[k] for k in extra_fields}
new_user.extra_details.data.update(extra_data)
new_user.extra_details.save()
return new_user
def register(request,
disallowed_url='registration_disallowed',
template_name='registration/registration.html'):
"""用户注册
"""
# 是否允许用户进行注册
allow_register = getattr(settings, 'REGISTRATION_OPEN', False)
if not allow_register:
return redirect(disallowed_url)
if request.method == 'POST':
form = RegistrationForm(request.POST)
# 数据验证
if form.is_valid():
username = form.cleaned_data['username']
email = form.cleaned_data['email']
password = form.cleaned_data['password1']
# 创建一个未激活的用户和默认的扩展属性
act_key = TeamProfile.objects.create_inactive_user(
username, email, password)
# 直接将激活码作为链接发给用户
to, args, kwargs = ('registration_activate', (), {
'activation_key': act_key
})
return redirect(to, *args, **kwargs)
else:
form = RegistrationForm()
context = RequestContext(request)
return render_to_response(template_name, {'form': form},
context_instance=context)
