def post(self, request, *args, **kwargs):
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('login'))
else:
return render(request, 'protocol/registration.html', {'form':form})
def profile(request):
"""
Update a User profile using built in Django Users Model if the user is logged in
otherwise redirect them to registration version
"""
if request.user.is_authenticated():
print request.user
obj = UserProfile.objects.get(user=request.user)
form = RegistrationForm(request.POST or None,
instance=obj,
initial={'username': request.user})
if request.method == 'POST':
if form.is_valid():
form.save()
messages.error(request,
'Your profile has been updated.',
fail_silently=False)
return render(request, "registration/profile.html", {
'form': form,
'helper': RegistrationForm.helper
})
else:
return HttpResponseRedirect("/accounts/register")
def registration(request):
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('login'))
form = RegistrationForm()
return render(request, "registration.html", {"form": form.as_p()})
def registration(request):
form = RegistrationForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('index'))
return render(request, 'client/registration.html', {'form': form})
def registration(request):
form = RegistrationForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('index'))
return render(request, 'client/registration.html', {'form': form})
def on_post_call(self, request):
form = RegistrationForm(request.POST)
if form.is_valid():
form.instance.set_password(form.cleaned_data['password'])
form.save()
user = authenticate(username=form.instance.username, password=form.cleaned_data['password'])
login(request, user)
return HttpResponseRedirect(reverse('index'))
return request_response(request, 'answers/register.html', {'form': form})
def create(request):
form = RegistrationForm()
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('account:thankyou'))
return direct_to_template(request, 'account/create.html',
dict(form=form))
def register_user(request, template_name='login.html'):
args = {}
args.update(csrf(request))
link = request.REQUEST.get('link', False)
if link:
args['link'] = link
if request.method == 'POST':
userForm = RegistrationForm(request.POST)
if userForm.is_valid():
# #判断有没邀请码
# if request.REQUEST.get('inviteCode','')!='pinlove_fate':
# args['user_form']=userForm
# args['inviteCodeError']='输入正确的邀请码'
# return render(request, 'login.html', args)
userForm.save()
username = userForm.cleaned_data['username']
user = User.objects.get(username=username)
sex = userForm.cleaned_data['gender']
from pinloveweb.method import create_register_extra_user
create_register_extra_user(request,user.id,user.username,userForm.cleaned_data['password1'],sex,link,year_of_birth=userForm.cleaned_data['year_of_birth'],\
month_of_birth=userForm.cleaned_data['month_of_birth'],day_of_birth=userForm.cleaned_data['day_of_birth'])
authenticate = auth.authenticate(
username=username, password=userForm.cleaned_data['password1'])
auth.login(request, authenticate)
#登录奖励
from apps.user_score_app.method import get_score_by_invite_friend_login, get_score_by_user_login
get_score_by_user_login(request.user.id)
url = request.path
url = '%s%s' % (url[0:(url.find('/', 1))],
'/loggedin/?previous_page=register')
#手机端做引导页面
if url.find('/mobile/') != -1:
url = '/mobile/update_avtar/?guide=1'
else:
#检测推荐信息填写情况
from apps.recommend_app.recommend_util import recommend_info_status
recommendStatus = recommend_info_status(
request.user.id,
channel='mobile'
if request.path.find('/mobile/') != -1 else 'web')
if recommendStatus['result']:
request.session['recommendStatus'] = simplejson.dumps(
recommendStatus['data'])
return HttpResponseRedirect(url)
else:
args['user_form'] = userForm
args['error'] = True
if userForm.errors:
for item in userForm.errors.items():
key = '%s%s' % (item[0], '_error')
args[key] = item[1][0]
else:
args['user_form'] = RegistrationForm()
return render(request, template_name, args)
def signup(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('update_profile')
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/signup.html', {'form': form})
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('/apps/home.html')
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'apps/reg_form.html', args)
def register_user(request):
if request.method == 'GET':
form = RegistrationForm()
return render(request, 'register.html', {'form': form})
elif request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return render(request, 'register_success.html')
else:
return render(request, 'register_fail.html', {'form': form})
def register_user(request):
# False till someone fills in and sends
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect("/users/register_success")
else:
form = RegistrationForm()
return render_to_response('register.html', {'form': form}, context_instance=RequestContext(request))
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/register/complete')
else:
form = RegistrationForm()
token = {}
token.update(csrf(request))
token = {'form': form}
return render(request, 'registration/registration_form.html', token)
def register_user(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/register_success')
else:
return render_to_response('task/account/register.html', {'form': form})
args = {}
args.update(csrf(request))
args['form'] = RegistrationForm()
return render(request, 'task/account/register.html', args)
def register_user(request):
# False till someone fills in and sends
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('index'))
else:
form = RegistrationForm()
return render_to_response('register.html', {'form': form},
context_instance=RequestContext(request))
def register(request):
title = "Registration"
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect("/")
else:
form = RegistrationForm()
return render_to_response("registration/registration_form.html", locals())
"""
def create_user(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
user = authenticate(username = form.cleaned_data['username'],
password = form.cleaned_data['password1'])
login(request, user)
return HttpResponseRedirect('profile')
else:
form = RegistrationForm()
return render(request, 'create_user.html', { 'form': form, })
def register_user(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/register_success')
print form.errors
args = {}
args.update(csrf(request))
args['form'] = RegistrationForm()
return render_to_response('website/register.html', args)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('registration_complete')
else:
form = RegistrationForm()
token = {}
#token.update(csrf(request))
token['form'] = form
return render(request, 'registration/registration_form.html', token)
def register_user(request):
if request.method=='POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
username = request.POST.get('username','')
return HttpResponseRedirect(reverse('register_user_success',args=[username]))
else:
form = RegistrationForm()
context = {}
context.update(csrf(request))
context['reg_form'] = form
return render(request,'tools/register_user.html',context)
def register_user(request):
args = {}
args.update(csrf(request))
if request.method == 'POST':
form = RegistrationForm(request.POST)
args['form'] = form
if form.is_valid():
form.save()
return HttpResponseRedirect('/register_success/')
else:
args['form'] = RegistrationForm()
return render_to_response('SNP/registration/register.html', args, context_instance=RequestContext(request))
def signup(request):
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
if form.is_valid():
form.save()
return HttpResponse('true')
else:
errors_dict = {}
if form.errors:
for error in form.errors:
e = form.errors[error]
errors_dict[error] = unicode(e)
data = json.dumps(errors_dict, cls=JSONEncoder)
return HttpResponse(data, content_type="application/json")
def register(request):
args = {}
args.update(csrf(request))
if request.method == 'POST':
form = RegistrationForm(request.POST)
args['form'] = form
if form.is_valid():
form.save()
username = form.cleaned_data['username']
email = form.cleaned_data['email']
salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
activation_key = hashlib.sha1(salt + email).hexdigest()
key_expires = datetime.datetime.today() + datetime.timedelta(2)
user = User.objects.get(username=username)
new_profile = UserProfile(user=user,
activation_key=activation_key,
key_expires=key_expires)
new_profile.save()
# email starts here
template = get_template('law/email/confirmation.html')
context = Context({
'username': username,
'user_email': email,
'activation_key': activation_key
})
content = template.render(context)
subject = 'Confirm Registration'
message = "Hey %s, thanks for signing up. To activate your account, click this link within \
48hours http://127.0.0.1:8000/law/accounts/confirm/%s" % (
username, activation_key)
from_email = settings.EMAIL_HOST_USER
to_email = [settings.EMAIL_HOST_USER, email]
msg = EmailMessage(subject, content, from_email, to_email)
msg.content_subtype = 'html'
msg.send()
# send_mail(subject, msg, from_email, to_email, fail_silently=True)
return HttpResponseRedirect(reverse('law:register_success'))
else:
# return render(request, 'law/registration/auth.html')
args['form'] = RegistrationForm()
return render_to_response('law/registration/register.html', args)
def registration(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
group_visitor = Group.objects.get(name='visitor')
new_user = User.objects.get(username=request.POST.get('username'))
new_user.groups.add(group_visitor)
new_user.save()
#return HttpResponseRedirect("/blog/profile/")
return HttpResponseRedirect("/blog/")
else:
form = RegistrationForm()
return render_to_response("registration.html", {'form': form}, context_instance=RequestContext(request))
def register_user(request):
args = {}
args.update(csrf(request))
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
args['registered'] = True
return render_to_response('mainPage.html', args)
else:
args['form'] = form
return render_to_response('mainPage.html', args)
args['form'] = RegistrationForm()
return render(request, 'mainPage.html', args)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/register/complete')
else:
form = RegistrationForm()
token = {}
token.update(csrf(request))
token['form'] = form
return render_to_response('registration/registration_form.html', token)
def register_user(request):
args = {}
args.update(csrf(request))
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
args['registered'] = True
return render_to_response('mainPage.html', args)
else:
args['form'] = form
return render_to_response('mainPage.html', args)
args['form'] = RegistrationForm()
return render(request, 'mainPage.html', args)
def edituser(request):
if not request.user.is_authenticated():
#return HttpResponseRedirect('/login/?next=%s' %request.path)
return HttpResponseRedirect('/login/')
if request.method == 'POST':
form = RegistrationForm(request.POST, instance=request.user)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('Yaas_user_home') )
else:
form = RegistrationForm(instance=request.user)
return render_to_response('edituser.html', {'form' : form }, context_instance=RequestContext(request))
def post(self, request):
data = request.DATA
form = RegistrationForm(request.DATA)
if form.is_valid():
form.save()
return Response({
"success": True,
"message": "Success"
}, status.HTTP_200_OK)
else:
return Response(
{
"success": False,
"message": "Information Not Valid"
}, status.HTTP_400_BAD_REQUEST)
def register(request):
'''
This handles the request sent to registration. If the user
has sent a confirmation to their email before, simply send another
one.
This is to, hopefully, counteract the fact that people might
have expired invitations in their inbox, or they deleted the confirmation
email on accident.
'''
if request.user.is_authenticated():
return render(request, 'register.html', {'action': '/register/'})
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
'''
We need to go to the email-sent page (even though an email
isn't sent at the moment.
'''
user = form.save()
EmailConfirmation.objects.send_confirmation(user=user)
return render(request, 'email_sent.html', {'email': form.cleaned_data['email'] })
else:
form = RegistrationForm()
return render(request, 'register.html', {'form': form,
'action': '/register/'})
def signup_user(request):
"""
view untuk fungsionalitas pendaftaran user
"""
template = "accounts/signup.html"
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
nohp = form.cleaned_data["nohp"]
sec_question = form.cleaned_data['sec_question']
sec_answer = form.cleaned_data['sec_answer']
user = form.save()
profile = Profile()
profile.user = user
profile.nohp = nohp
profile.sec_question = sec_question
profile.sec_answer = sec_answer
profile.save()
request.session['signup_success'] = True
return HttpResponseRedirect(reverse('signup_success'))
else:
form = RegistrationForm()
return render_to_response(template,
{"form": form},
context_instance=RequestContext(request))
def register(request):
registration_form = RegistrationForm()
login_form = LoginForm()
if request.method == "POST":
registration_form = RegistrationForm(request.POST)
if registration_form.is_valid():
registration_form.save()
ctx = {
"registration_form" : registration_form,
"login_form" : login_form,
"color_choices" : COLOR_CHOICES,
}
return render_to_response("register.html", context_instance=RequestContext(request, ctx) )
def register_page(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save()
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password1'])
if user is not None:
if user.is_active:
login(request, user)
return HttpResponseRedirect('%s/' %
(request.META['SCRIPT_NAME']))
else:
# return a 'disabled account' error message.
return HttpResponseRedirect('%s/accounts/login/' %
(request.META['SCRIPT_NAME']))
else:
# return an 'invalid login' error message.
return HttpResponseRedirect('%s/accounts/login/' %
(request.META['SCRIPT_NAME']))
else:
form = RegistrationForm()
variables = RequestContext(request, {
'script_name': request.META['SCRIPT_NAME'],
'form': form
})
return render_to_response('accounts/register.html', variables)
def login_pilot_mode(request):
args = {}
args['mode'] = 'pilot_mode'
args.update(csrf(request))
if request.method == "POST":
data = copy.copy(request.POST)
password = '******'
data['password1'] = password
data['password2'] = password
form = RegistrationForm(data)
if form.is_valid():
user = form.save()
UserProfile(user=user,
name=form.cleaned_data['username'],
age=form.cleaned_data['age'],
gender=form.cleaned_data['gender'],
selection_mode='-').save()
username = data.get('username', '')
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
return HttpResponseRedirect('/welcome_pilot_mode/')
else:
args['form'] = form
return render_to_response('login.html', args)
args['form'] = RegistrationForm()
return render_to_response('login.html', args)
def register(request, type):
if type not in ['subject', 'tester']:
raise Exception('register: invalid type.')
if request.method == 'POST':
rform = RegistrationForm(request.POST)
pform = UserProfileForm(request.POST)
if rform.is_valid() and pform.is_valid():
user = rform.save()
if type == 'subject':
group = Group.objects.get(name='Subjects')
elif type == 'tester':
group = Group.objects.get(name='Testers')
user.groups.add(group)
profile = pform.save(commit=False)
profile.user = user
profile.save()
if type == 'tester':
create_log_entry(profile, 'joined', [])
return HttpResponseRedirect(reverse('home'))
else:
rform = RegistrationForm()
pform = UserProfileForm()
return render_to_response('testtool/registration/register.html', {
'rform': rform,
'pform': pform
},
context_instance=RequestContext(request))
def registration(request):
if request.method == 'POST':
regform = RegistrationForm(request.POST)
userform = LoginForm(request.POST)
username = request.POST['username']
password = request.POST['password']
if regform.is_valid() and userform.is_valid():
user = userform.save(commit=False)
user.set_password(user.password)
user.save()
profile = regform.save(request.POST)
profile.user = user
profile.save()
return redirect('profile', pk=user.pk)
else:
return HttpResponse('Please fill the form correctly')
else:
regform = RegistrationForm()
userform = LoginForm()
return render(request, 'registration/signup.html', {
'regform': regform,
'userform': userform
})
def register_user(request):
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/registration_success')
else:
print form.errors
data = {}
data.update(csrf(request))
data['form'] = RegistrationForm()
return render_to_response('register.html', data)
def register_view(request):
if request.method == 'POST':
login_form = LoginForm(request.POST)
register_form = RegistrationForm(request.POST)
if register_form.is_valid():
user = register_form.save()
salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
user.activation_key = hashlib.sha1(salt+user.email).hexdigest()
#user.key_expires = timezone.now() + timezone.timedelta(100)
user.save()
plaintext = get_template('email/register_email.txt')
htmly = get_template('email/register_email.html')
d = Context({'username': user.username})
subject, from_email, to = 'Account has been created', '*****@*****.**', user.email
text_content = plaintext.render(d)
html_content = htmly.render(d)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()
return HttpResponseRedirect(reverse('success_register'))
else:
register_form = RegistrationForm()
login_form = LoginForm()
context = {'register_form': register_form, 'login_form': login_form}
return render(request, "register.html", context)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
# Create a new user object but avoid saving it yet
new_user = form.save(commit=False)
# Set the chosen password
new_user.set_password(form.cleaned_data['password'])
# Save the User object
new_user.save()
try:
group = Group.objects.get(name="apply")
except ObjectDoesNotExist:
group = Group(name="apply")
group.save()
group.user_set.add(new_user)
profile = Profile(user=new_user)
profile.save()
return render(request, 'registration/register_done.html',
{'new_user': new_user})
else:
form = RegistrationForm()
school_pool = School.objects.filter(online=True)
return render(request, 'registration/register.html', {
'form': form,
'schools': school_pool
})
def registration(request):
cache.clear()
if request.user.is_authenticated():
return redirect('/')
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
try:
user_pk = form.save(request.FILES.get('avatar'))
admins = User.objects.filter(is_superuser=True)
msg = EmailMessage(
u'Новый пользователь %s' % request.POST['username'],
(u'<html>'
u'<meta http-equiv="Content-Type" content="text/html; '
u'charset=UTF-8"><body>'
u'Зарегистрировался новый пользователь '
u'<a href="http://%s/admin/auth/user/%i">%s</a>'
u'<br />'
u'Данные:<br /><ul>%s</ul>'
u'</body></html>') % (settings.HOSTNAME, user_pk,
request.POST['username'], form.as_ul()),
u'admin@%s' % settings.HOSTNAME,
[a.email for a in admins]
)
msg.content_subtype = "html"
msg.send()
return redirect(reverse('registration-thanks'))
except ValidationError:
pass
else:
form = RegistrationForm()
return render(request, 'registration/registration.html', {'form': form})
def otp_register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
account_sid = 'ACb78b2fd3a07bfb51bc243bbc8b1a08f5' # Found on Twilio Console Dashboard
auth_token = 'd3892a335ca6e3a1a1d6dc80dddb81b8' # Found on Twilio Console Dashboard
# Phone number you used to verify your Twilio account
TwilioNumber = '+13182257674' # Phone number given to you by Twilio
client = Client(account_sid, auth_token)
if form.is_valid():
user = form.save()
phone_number = form.cleaned_data.get('phone_number')
token_number = user.token_number
if user.id:
client.api.account.messages.create(
to=phone_number,
from_=TwilioNumber,
body='I sent a text message from Python!'+str(token_number))
# user.twiliosmsdevice_set.create(name='SMS',key=token_number, number=phone_number)
# device = user.twiliosmsdevice_set.get()
# device.generate_challenge()
return HttpResponseRedirect('/otp/verify/'+str(user.id))
else:
form = RegistrationForm()
context = {}
context.update(csrf(request))
context['form'] = form
return render_to_response('register.html', context)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
registration = form.save(commit=False)
registration.save()
for workshop in form.cleaned_data['workshops']:
registration.workshops.add(Workshop.objects.get(id=workshop))
current_site = Site.objects.get_current()
subject = render_to_string('workshops/confirmation_email_subject.txt',
{'site': current_site})
subject = ''.join(subject.splitlines())
message = render_to_string('workshops/confirmation_email.txt',
{'registration': registration})
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,
[registration.email])
return HttpResponseRedirect(reverse('workshop-registration-complete'))
else:
form = RegistrationForm()
return render_to_response('workshops/registration_form.html', {'form': form})
def register_user(request):
"""
Handle registration
:param request:
:return:
"""
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/login')
args = {}
args.update(csrf(request))
args['form'] = RegistrationForm() # Initialize a form
return render_to_response('quiz_user/register.html', args)
def registration_view(request):
"""
регистрация
форма регистрации короткая, только обязательные поля
пароль сохраняется в два этапа: сохранение пользователя, зтем установка пароля
при удаче переход на редактирование профиля
"""
if request.method == 'POST':
form = RegistrationForm(request.POST, request.FILES)
if form.is_valid():
f = form.save(commit=False)
f.save()
u = CustomUser.objects.get(pk = f.id)
u.set_password(request.POST.get('password'))
u.save()
else:
form = RegistrationForm(request.POST, request.FILES)
else:
form = RegistrationForm()
t = loader.get_template('accounts_registration.html')
c = RequestContext(request,{
# 'current_user' : user,
'form' : form,
}, processors=[custom_proc])
return HttpResponse(t.render(c))
def register(request, template_name = 'registration/register.html'):
if request.method == 'POST':
print("POST")
postdata = request.POST.copy()
#form = UserCreationForm(postdata)
form = RegistrationForm(postdata)
if form.is_valid():
print("valid user input")
user = form.save(commit = False)
user.email = postdata.get('email', '')
user.save()
#form.save()
un = postdata.get('username', '')
pw = postdata.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('my_account')
return HttpResponseRedirect(url)
else:
print("GET")
#form = UserCreationForm()
form = RegistrationForm()
page_title = 'User Registration'
return render_to_response(template_name, locals(), context_instance = RequestContext(request))
def register_view(request):
if request.method == 'POST':
login_form = LoginForm(request.POST)
register_form = RegistrationForm(request.POST)
if register_form.is_valid():
user = register_form.save()
salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
user.activation_key = hashlib.sha1(salt + user.email).hexdigest()
#user.key_expires = timezone.now() + timezone.timedelta(100)
user.save()
plaintext = get_template('email/register_email.txt')
htmly = get_template('email/register_email.html')
d = Context({'username': user.username})
subject, from_email, to = 'Account has been created', '*****@*****.**', user.email
text_content = plaintext.render(d)
html_content = htmly.render(d)
msg = EmailMultiAlternatives(subject, text_content, from_email,
[to])
msg.attach_alternative(html_content, "text/html")
msg.send()
return HttpResponseRedirect(reverse('success_register'))
else:
register_form = RegistrationForm()
login_form = LoginForm()
context = {'register_form': register_form, 'login_form': login_form}
return render(request, "register.html", context)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
c = form.cleaned_data
teamname = c['teamname']
instance = form.save(commit=False)
instance.save()
if c['division'] == u'P':
div = '<option value="Premier">Premier $350.00 USD</option>'
elif c['division'] == u'M':
div = '<option value="Club">Club $275.00 USD</option>'
elif c['division'] == u'O':
div = '<option value="Old Boys">Old Boys $250.00 USD</option>'
elif c['division'] == u'W':
div = '<option value="Women">Women $200.00 USD</option>'
else:
pass; # should not occur since division has been validated
name = '<input type="hidden" name="on1" value="Club Name"></td></tr><tr><td><input type="hidden" name="os1" maxlength="200" value="' + c['teamname'] + '">'
return render_to_response('paypal.html', {'teamname':str(teamname), 'div':div, 'name':name})
else:
return render_to_response('register.html', {'form':form}, context_instance=RequestContext(request))
else:
form = RegistrationForm()
return render_to_response('register.html', {'form':form}, context_instance=RequestContext(request))
def user_profile_edit(request):
instance1 = get_object_or_404(User, id=request.user.id)
instance2 = get_object_or_404(UserProfile, id=request.user.profile.id)
args = {}
args.update(csrf(request))
if request.method == "POST":
form1 = RegistrationForm(request.POST, instance=instance1)
form2 = UserProfileForm(request.POST,
request.FILES,
instance=instance2)
args["err"] = form1.errors
args["err2"] = form2.errors
if form1.is_valid() * form2.is_valid():
user = form1.save()
userprofile = form2.save(commit=False)
userprofile.user = user
userprofile.save()
return HttpResponseRedirect('/dashboard')
args["form"] = RegistrationForm(instance=instance1)
args["form2"] = UserProfileForm(instance=instance2)
args["form_title"] = "Edit Profile Info"
return render(request, 'register.html', args, RequestContext(request))
def register_user(request):
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save(commit=False)
if new_user.email:
salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
new_user.activation_key = hashlib.sha1(salt+new_user.email).hexdigest()
new_user.key_expires = datetime.datetime.today() + datetime.timedelta(2)
new_user.save()
# Send email with activation key
email_subject = u'Подтверждение '
email_body = u"Добро пожаловать в магазин, %s. Спасибо за регистрацию. Чтобы активировать аккаунт, перейди по ссылке \
%s/account/confirm/%s" % (new_user.username,settings.SITE_URL, new_user.activation_key)
send_mail(email_subject, email_body, '*****@*****.**',
[new_user.email], fail_silently=False)
return HttpResponseRedirect('/account/registersuccess')
elif new_user.phone:
new_user.save()
return HttpResponseRedirect('/account')
else:
return HttpResponseRedirect('/')
else:
print form.errors
else:
form = RegistrationForm()
return render(request, 'accounts/register.html', {'form': form})
def create_user(request):
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
if form.is_valid():
form.save()
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password1'])
login(request, user)
EmailValidation.objects.send(user=user)
next = request.POST.get('next', None)
return HttpResponseRedirect(next if next else reverse('edit-profile'))
else:
return render_to_response('user/create_user.html',
context_instance=RequestContext(request, {'form': form}))
form = RegistrationForm()
return render_to_response('user/create_user.html',
context_instance=RequestContext(request, {'form': form,
'next': request.GET.get('next','')}))
def registration(request):
form = RegistrationForm()
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
registered = form.save()
return redirect('login')
return render(request, 'registration.html', {'form': form})
def register(request, template='account.register.form.html'):
if request.method == 'POST':
f = RegistrationForm(request.POST)
if f.is_valid():
person = f.save()
return HttpResponseRedirect(person.get_absolute_url())
else:
f = RegistrationForm()
data = {'form': f}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def registration_view(request):
form = RegistrationForm(request.POST or None)
btn = 'Join'
if form.is_valid():
new_user = form.save(commit=False)
new_user.save()
return HttpResponseRedirect("/")
context = {
"form": form,
"submit_btn": btn,
}
return render(request, 'builder/simple_form.html', context)
def register(request):
registered = False
disabled = False
# is registration disabled?
if not (AuthenticationCode.objects.all()[0]).enable:
disabled = True
context = {
'title': 'Create an account' + SITE_SUF,
'navlight': 3,
'request': request,
'disabled': disabled,
}
return render(request, 'nest/register.html', context)
# registration is enabled
if request.method == 'POST':
reg_form = RegistrationForm(data=request.POST)
if reg_form.is_valid():
reg_form.save(request.POST
) # automatically creates new user & student objects
registered = True
else:
reg_form = RegistrationForm()
context = {
'title': 'Create an account' + SITE_SUF,
'navlight': 3,
'request': request,
'reg_form': reg_form,
'registered': registered,
'disabled': disabled,
}
return render(request, 'nest/register.html', context)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
# Create a new user object but avoid saving it yet
new_user = form.save(commit=False)
# Set the chosen password
new_user.set_password(form.cleaned_data['password'])
# Save the User object
new_user.save()
return render_to_response('registration/register_done.html',
{'new_user': new_user},
context_instance=RequestContext(request))
else:
form = RegistrationForm()
return render_to_response('registration/register.html', {'form': form},
context_instance=RequestContext(request))
def register_user(request):
# False till someone fills in and sends
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save(commit=False)
new_user.save()
#add extend user object
new = ExtendUser(user=new_user, )
new.save()
return HttpResponseRedirect(reverse('login_user'))
else:
form = RegistrationForm()
return render(request, 'register.html', {'form': form})
def register_handle_form(request, redirect=None):
"""
Handle all registration logic. This is broken out from "register" to allow easy overriding/hooks
such as a combined login/register page.
This method only presents a typical login or register form, not a full address form
(see register_handle_address_form for that one.)
Returns:
- Success flag
- HTTPResponseRedirect (success) or form (fail)
"""
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
contact = form.save(request, force_new=True)
# look for explicit "next"
next = request.POST.get('next', '')
if not next:
if redirect:
next = redirect
else:
next = urlresolvers.reverse('registration_complete')
return (True, HttpResponseRedirect(next))
else:
initial_data = {}
try:
contact = Contact.objects.from_request(request, create=False)
initial_data = {
'email': contact.email,
'first_name': contact.first_name,
'last_name': contact.last_name,
}
except Contact.DoesNotExist:
log.debug("No contact in request")
contact = None
initial_data['next'] = request.GET.get('next', '')
form = RegistrationForm(initial=initial_data)
return (False, form)
def sign_up(request):
if request.method == 'POST':
registration_form = RegistrationForm(request.POST)
profile_form = ProfileForm(request.POST)
if registration_form.is_valid() and profile_form.is_valid():
user = registration_form.save()
profile = profile_form.save(commit=False)
profile.user = user
user.save()
profile.save()
return HttpResponseRedirect(reverse('core:home'))
else:
registration_form = RegistrationForm()
profile_form = ProfileForm(request.POST)
return render(request, 'core/signup.html', {
'registration_form': registration_form,
'profile_form': profile_form
})
def register_user(request):
args = {}
args.update(csrf(request))
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save()
UserProfile(user=user,
name=form.cleaned_data['username'],
age=form.cleaned_data['age'],
gender=form.cleaned_data['gender']).save()
return HttpResponseRedirect('/accounts/register_success')
else:
args['form'] = form
return render_to_response('register.html', args)
args['form'] = RegistrationForm()
return render_to_response('register.html', args)
