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 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 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 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():
form.save()
return redirect('pvm_forms:index')
else:
form = RegistrationForm()
return render(request, 'registration/register.html', {'form': form})
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST, request.FILES)
if form.is_valid():
user = form.save()
login(request, user)
user.verify_email()
return render(request, "reg/check_email.html")
else:
form = RegistrationForm()
return render(request, "reg/reg.html", context={"form": form})
def index(request):
success = False
if request.method == 'POST':
f = RegistrationForm(request.POST)
if f.is_valid():
success = True
f.instance.is_active = False
#print f.cleaned_data
f.save()
# присоединяем пользователя к группе зарегистрированных пользователей
g = Group.objects.get(pk=1)
f.instance.groups.add(g)
# отправляем письмо с данными учетной записи пользователю
mail_template = MailTemplate.objects.get(
code__exact='USERREGISTRATION')
body = mail_template.body.replace('###hostname###',
request.get_host())
body = body.replace('###username###', request.POST.get('username'))
body = body.replace('###password###', request.POST.get('password'))
body = body.replace(
'###activation_link###', 'http://' + request.get_host() +
'/registration/activate/{0}/'.format(
request.POST.get('username')))
email = EmailMessage(mail_template.subject,
body,
mail_template.from_email, [
request.POST.get('email').strip(),
],
mail_template.copy_emails.split(';'),
headers={
'Reply-To': mail_template.from_email,
'From': mail_template.from_name
})
email.content_subtype = "html"
email.send()
return redirect('registration_success')
else:
f = RegistrationForm()
context = {'form': f, 'success': success}
return render(request, 'registration/index.html', context)
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 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_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(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 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 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 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 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):
"""
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 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 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(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 index(request):
register_list = Registration.objects.all()
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
try:
form.save()
return redirect('/registration')
except:
pass
else:
form = RegistrationForm()
return render(request, 'registration/index.html', {
'form': form,
'register_list': register_list
})
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 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(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 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 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,
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 test_registration_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(**{
'email':'*****@*****.**', 'password1':'5UuYquA@'})
invalid_data_dicts = [
# Already-existing username.
{'data': {'email': '*****@*****.**',
'password1': '5UuYquA@',
'password2': '5UuYquA@'},
#__all__ refers to a form level error.
'error': [['__all__', [u"A user with that email already exists."]]]},
# Mismatched passwords.
{'data': {'email': '*****@*****.**',
'password1': '5UuYquA@',
'password2': 'bar'},
'error': [['password1', [u"The new password fields did not match."]],
['password2', [u"The new password fields did not 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][0]],
invalid_dict['error'][0][1])
form = RegistrationForm(data={'email': '*****@*****.**',
'password1': '5UuYquA@',
'password2': '5UuYquA@'})
self.failUnless(form.is_valid())
def home(request, template='index.html'):
form = RegistrationForm()
try:
content = PageContent.objects.filter(
page__page_name='home_page',
is_active=True).latest('page__pub_date')
except:
content = None
return shortcuts.render_to_response(
template,
dict(title=content.page.title if content else "Welcome",
content=content,
form=form),
context_instance=RequestContext(request))
