def register_user_view(request):
logger.debug("register_user_view called by user %s" % request.user)
if request.method == 'POST':
form = RegistrationForm(request.POST)
logger.debug("Request type POST contains form valid: %s" % form.is_valid())
if form.is_valid():
if not User.objects.filter(username=form.cleaned_data['username']).exists():
user = User.objects.create_user(form.cleaned_data['username'],
form.cleaned_data['email'], form.cleaned_data['password'])
user.save()
logger.info("Created new user %s" % user)
return HttpResponseRedirect("/dashboard/")
else:
logger.error("Unable to register new user: username %s already exists." % form.cleaned_data['username'])
return render_to_response('public/register.html', {'form': form, 'error': True}
, context_instance=RequestContext(request))
else:
logger.debug("Registration form invalid. Returning for user %s to make corrections." % request.user)
else:
logger.debug("Returning blank registration form.")
form = RegistrationForm()
return render_to_response('public/register.html', {'form': form}, context_instance=RequestContext(request))
def register(request):
"""
Register a new user.
"""
# User info is being submitted
if request.method == "POST":
form = RegistrationForm(request.POST)
params = {"form": form}
if form.is_valid():
# Create user
user = User.objects.create_user(form.cleaned_data["username"],
form.cleaned_data["email"],
form.cleaned_data["password"])
user.is_active = False
user.save()
# Send activation email
email_manager = EmailManager(user)
activation_email = email_manager.generate_activation_email()
activation_email.send()
return render_to_response("account/registration_complete.html",
{},
context_instance=RequestContext(request))
# If there is no POST data, send blank registration form.
else:
params = {"form": RegistrationForm()}
return render_to_response("account/register.html",
params,
context_instance=RequestContext(request))
def register(request):
context = {"nem_base_url" : "http://" + settings.SITE_URL + "/static/nem/",
"site_url" : "http://" + settings.SITE_URL + "/",}
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 passes
# Process the data in form.cleaned_data
amount_bool = form.cleaned_data['amount']
email = form.cleaned_data['email']
name = form.cleaned_data['name']
branch = form.cleaned_data['branch']
batch = form.cleaned_data['batch']
pt = Registration.objects.create(amount=amount_bool, email=email,
name=name, branch=branch, batch=batch,
status=LIMBO)
transaction_id = pt.id
notes=""
if settings.ENV == "dev":
transaction_id = "dev-nem" + str(pt.id)
else:
transaction_id = "nem" + str(pt.id)
callback_url = "http://" + settings.SITE_URL + "/nem/payment-return"
amount = 1500 if int(amount_bool) == ALUMNI else 500
context = {"payment_dict" : get_post_object(callback_url, amount, email, transaction_id, notes)}
return render_to_response("nem/registration_payment_redirect.html",
RequestContext(request, context))
else:
form = RegistrationForm() # An unbound form
context['form'] = form
return render(request, "nem/register.html", context)
def register(request):
# if this is a POST request we need to process the form data
if request.method == 'POST':
reg_form = RegistrationForm(request.POST)
if reg_form.is_valid():
in_first_name = reg_form.cleaned_data['first_name']
in_last_name = reg_form.cleaned_data['last_name']
in_username = reg_form.cleaned_data['username']
in_email = reg_form.cleaned_data['email']
in_password = reg_form.cleaned_data['password']
# Create the user object
user = User.objects.create_user(first_name = in_first_name,
last_name = in_last_name,
username = in_username,
password = in_password,
email = in_email)
# Save the user in the db
# todo: add try catch here
user.save()
# todo: Success redirection :
return render(request, 'mafia/index.html')
# if a GET (or any other method) we'll create a blank form
else:
reg_form = RegistrationForm()
return render(request, 'mafia/register.html', {'form': reg_form})
def registration(request):
"""Registration view"""
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
name = form.cleaned_data['name']
surname = form.cleaned_data['surname']
email = form.cleaned_data['email']
password = form.cleaned_data['repeat_password']
ssh_public_key = form.cleaned_data['ssh_public_key']
studies_year = form.cleaned_data['studies_year']
if not username:
username = strip_polish_letters(name[0] + surname).lower()
user = TemporaryUser(username=username,
name=name,
surname=surname,
email=email,
password=password,
ssh_public_key=ssh_public_key,
studies_year=studies_year,
confirmed=False,
confirmation_link=generate_confirmation_link())
user.save()
send_confirmation_mail(user)
form = LogInForm()
return render_to_response('invitation.html', {'confirmed': 4, 'form': form}, context_instance=RequestContext(request))
else:
form = RegistrationForm()
return render_to_response('registration.html', {'form': form,}, context_instance=RequestContext(request))
def register(request):
state = " Se dispone a realizar un nuevo registro.Recuerde que todos los campos son obligatorios"
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
name_user = form.cleaned_data['username']
email_user = form.cleaned_data['email']
pass_user = form.cleaned_data['password1']
create_user = User.objects.create_user(username= name_user, email= email_user,password=pass_user)
create_user.save()
pseudo="@"+name_user
extend=ExtendUser(user=create_user,pseudo=pseudo)
extend.save()
return redirect('/login')
else:
state=" Error en el registro"
return render_to_response('nuevo.html', {'title':'Registro', 'formulario': form,'state':state}, context_instance=RequestContext(request))
else:
form = RegistrationForm()
return render_to_response('nuevo.html', {'title':'Registro', 'formulario': form,'state':state}, context_instance=RequestContext(request))
def view_raid(request, raid_id):
raid = get_object_or_404(Raid, id=raid_id)
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
registration = Registration(player=request.user,
raid=raid,
role=form.cleaned_data['role'])
if 'standby' in form.cleaned_data:
registration.standby = form.cleaned_data['standby']
registration.save()
else:
form = RegistrationForm()
dps = Registration.objects.filter(raid=raid,role="dps").order_by("-won", "-number")
tanks = Registration.objects.filter(raid=raid,role="tank").order_by("-won", "-number")
healers = Registration.objects.filter(raid=raid,role="healer").order_by("-won", "-number")
registered = { 'DPS': dps,
'Tanks': tanks,
'Healers': healers
}
return render_to_response('raid/view.djhtml',
{'raid': raid,
'registered': registered,
'registration_form': form,
'is_registered': raid.is_registered(request.user)
},
context_instance=RequestContext(request))
def doregister(request):
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
print 'yes'
mailkey = uuid.uuid1().hex[0:29]
u = User()
userlogin = request.POST ['login']
u.username = mailkey
u.last_name = request.POST ['lastname']
u.first_name = request.POST ['firstname']
u.email = request.POST ['email']
u.set_password (request.POST['password'])
u.is_superuser = 0
u.is_active = 0
u.is_staff = 0
u.save()
send_mail('Yellers email verification',
'To verify your email please follow the link below: http://5.19.200.78/Yellers/mailverify/'+userlogin+'/'+mailkey+
'\nyour login is: ' + userlogin + '\nyour password is ' + request.POST['password'],
'*****@*****.**', [request.POST['email']], fail_silently=False)
return HttpResponseRedirect("/Yellers/")
else:
print 'no'
form = RegistrationForm
return HttpResponseRedirect("/Yellers/registration/")
def register(request):
if request.method == 'POST' and not request.user.is_authenticated():
form = RegistrationForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
username, password, name = cd['email'], cd['password'], cd['name']
try:
UserProfile.objects.get(username=username)
return redirect('/already_registered/')
except:
verify_hash = _random_MD5()
u = UserProfile.objects.create(username=username,
email=username,
first_name=name,
verified=False,
verify_hash=verify_hash)
u.set_password(password)
msgstr = settings.VERIFICATION_MAIL_BODY_TEMPLATE.render(
Context({
"username": name,
"verification_link":
request.build_absolute_uri('/')
+ 'verify/?'
+ urllib.urlencode((
("username", username),
("verify", verify_hash),
))
})
)
EmailMessage('Welcome to cloud.js', msgstr, to=[username]).send()
return redirect("/registered/")
return HttpResponse("Form invalid")
return HttpResponse("hmmmm " + request.method + " " + str(request.user.is_authenticated()))
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 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 registerBanda(request):
registered = False
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
banda_form = BandaForm(data = request.POST)
if form.is_valid() and banda_form.is_valid:
user = User.objects.create_user(form.cleaned_data['username'], form.cleaned_data['email'], form.cleaned_data['password1'])
user.save()
banda = banda_form.save()
banda.save()
usuario = auth.authenticate(username=request.POST['username'], password=request.POST['password1'])
login(request,usuario)
return HttpResponseRedirect('/')
else:
print form.errors, banda_form.errors
else:
form = RegistrationForm()
banda_form = BandaForm()
return render(request, 'registroBanda1.html', {'user':form, 'banda_form':banda_form, 'registered':registered})
def view_raid(request, raid_id):
raid = get_object_or_404(Raid, id=raid_id)
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
registration = Registration(player=request.user, raid=raid, role=form.cleaned_data["role"])
if "standby" in form.cleaned_data:
registration.standby = form.cleaned_data["standby"]
registration.save()
else:
form = RegistrationForm()
dps = Registration.objects.filter(raid=raid, role="dps").order_by("-won", "-number")
tanks = Registration.objects.filter(raid=raid, role="tank").order_by("-won", "-number")
healers = Registration.objects.filter(raid=raid, role="healer").order_by("-won", "-number")
registered = {"DPS": dps, "Tanks": tanks, "Healers": healers}
return render_to_response(
"raid/view.djhtml",
{
"raid": raid,
"registered": registered,
"registration_form": form,
"is_registered": raid.is_registered(request.user),
},
context_instance=RequestContext(request),
)
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 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 signup(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('forms_set'))
if request.method == 'POST':
post_form = RegistrationForm(request.POST)
if post_form.is_valid():
try:
with transaction.commit_on_success():
data = post_form.cleaned_data
user = User.objects.create_user( data['mail'].lower(), data['mail'], data['password1'] )
user.save()
# TODO need text email, need params for smpt
# email sending
# send_mail(u"Title",
# u"Text message"
# % (data['username'], data['password1']), "Email of service", [data['mail']],
# fail_silently=True)
if user.is_active:
new_user = authenticate( username = data['mail'].lower(), password = data['password1'] )
django_login(request, new_user)
return HttpResponseRedirect(reverse('forms_set'))
except Exception, e:
pass
#todo log
#logger.error("Controller:signup error:" + e.message)
return render_to_response('client_data_core/signup.html',
{'form' : post_form, },
context_instance = RequestContext(request),)
def registration(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(form.cleaned_data['username'], form.cleaned_data['email'], form.cleaned_data['password1'])
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.save()
profile = Profile(user_id=user.id, phone=form.cleaned_data['phone'])
profile.save()
messages.info(request, 'Registrácia prebehla úspešne')
return HttpResponseRedirect('/')
else:
form = RegistrationForm()
page_info = {}
page_info['title'] = 'Registrácia nového uživateľa'
page_info['page'] = 1
page_info['form_name'] = 'registration'
page_info['form_action'] = '/registracia/'
return render_to_response('registracia.html', {'form': form, 'countInfo': countInfo, 'recentNews': recentNews,
'page_info': page_info},
context_instance=RequestContext(request))
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 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_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 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 register(request):
searchform = SearchForm(request.POST)
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(form.cleaned_data['username'],
form.cleaned_data['email'],
form.cleaned_data['password'])
user.save()
return render_to_response('index.html',
{'form': form,
'searchform': searchform,
'msg' : "Registered Successfully"}
)
else:
return render_to_response('index.html',
{'form': form,
'searchform':searchform}
)
else:
form = RegistrationForm()
args = {}
args.update(csrf(request))
args['form'] = form
args['searchform'] = searchform
return render_to_response('index.html', args)
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 registration(request):
c = {}
c.update(csrf(request))
reg_form = RegistrationForm()
c['reg_form'] = reg_form
invalid = False
if request.method == 'POST':
reg_form = RegistrationForm(request.POST)
if reg_form.is_valid():
name = request.POST['name']
email = request.POST['email']
password = request.POST['password']
address = request.POST['address']
phone = request.POST['phone']
user = FoodUser.objects.filter(name=name)
if len(user) == 0:
user = User.objects.create_user(username=name,
email=email,
password=password)
user.save()
user = FoodUser(name=name, address=address, phone=phone)
user.save()
return HttpResponseRedirect('/')
return HttpResponseRedirect('../registration')
else:
invalid = True
if not request.user.is_authenticated():
c['auth'] = 0
c['attempt'] = invalid
return render_to_response("registration.html", c)
c['auth'] = 1
return render_to_response("registration.html", c)
def func(request):
# If the request method is POST, it means that the form has been submitted
# and we need to validate it.
if request.method == 'POST':
# Create a RegistrationForm instance with the submitted data
form = RegistrationForm(request.POST)
# is_valid validates a form and returns True if it is valid and
# False if it is invalid.
if form.is_valid():
# The form is valid and you could save it to a database
# by creating a model object and populating the
# data from the form object, but here we are just
# rendering a success template page.
return render(request, "registration/registration_complete.html")
# This means that the request is a GET request. So we need to
# create an instance of the RegistrationForm class and render it in
# the template
else:
form = RegistrationForm()
# Render the registration form template with a RegistrationForm instance. If the
# form was submitted and the data found to be invalid, the template will
# be rendered with the entered data and error messages. Otherwise an empty
# form will be rendered. Check the comments in the registration_form.html template
# to understand how this is done.
return render(request, "registration/registration_form.html",
{"form": form })
def registration(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
is_active=False,
)
user.set_password(form.cleaned_data['password'])
user.save()
hash = md5_constructor(str(user.id) + form.cleaned_data['username']).hexdigest()
confirm = RegConfirm(hash=hash, user_id=user.id)
confirm.save()
current_site = Site.objects.get(id=1)
message = u'Поздравляем! Вы зарегистрировались на %s . Пожалуйста, пройдите по адресу %s для активации учетной записи.' % \
(current_site.domain, "http://" + current_site.domain + "/accounts/confirm/" + hash, )
send_mail(u'Активация аккаунта ' + current_site.domain, message, 'system@'+current_site.domain,
[form.cleaned_data['email']])
return render(request, 'accounts/frontend/registration_done.html')
else:
form = RegistrationForm()
return render(request, 'accounts/frontend/registration.html', {
'form':form
})
def registration(request):
return redirect("accounts:frontend:login")
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
user = User(
username=form.cleaned_data["username"],
email=form.cleaned_data["email"],
first_name=form.cleaned_data["first_name"],
last_name=form.cleaned_data["last_name"],
is_active=True,
)
user.set_password(form.cleaned_data["password"])
user.save()
group = Group.objects.get(name="users")
user.groups.add(group)
# hash = md5_constructor(str(user.id) + form.cleaned_data['username']).hexdigest()
# confirm = RegConfirm(hash=hash, user_id=user.id)
# confirm.save()
# current_site = Site.objects.get(id=1)
# message = u'Поздравляем! Вы зарегистрировались на %s . Пожалуйста, пройдите по адресу %s для активации учетной записи.' % \
# (current_site.domain, "http://" + current_site.domain + "/accounts/confirm/" + hash, )
#
#
# send_mail(u'Активация учетной записи ' + current_site.domain, message, 'system@'+current_site.domain,
# [form.cleaned_data['email']])
return render(request, "accounts/frontend/registration_done.html")
else:
form = RegistrationForm()
return render(request, "accounts/frontend/registration.html", {"form": form})
def register(request, success_url='/accounts/register/complete/'):
"""
Allows a new user to register an account.
On successful registration, an email will be sent to the new user
with an activation link to click to make the account active. This
view will then redirect to ``success_url``, which defaults to
'/accounts/register/complete/'. This application has a URL pattern
for that URL and routes it to the ``direct_to_template`` generic
view to display a short message telling the user to check their
email for the account activation link.
Context::
form
The registration form
Template::
registration/registration_form.html
"""
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = RegistrationProfile.objects.create_inactive_user(username=form.clean_data['username'],
password=form.clean_data['password1'],
email=form.clean_data['email'])
return HttpResponseRedirect(success_url)
else:
form = RegistrationForm()
return render_to_response('registration/registration_form.html',
{ 'form': form },
context_instance=RequestContext(request))
def signup(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']
)
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password1'])
profile = Profile(
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'], user=user)
profile.save()
login(request, user)
msg = ("Thanks for registering! You are now logged in and ready to "
"go questing.")
messages.info(request, msg)
return HttpResponseRedirect(reverse('quest_maker_app:homepage'))
else:
form = RegistrationForm()
variables = RequestContext(request, {'form': form})
return render_to_response('registration/signup.html', variables)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST, request.FILES)
if form.is_valid():
cleaned_data = form.clean()
first_name = cleaned_data['first_name'].strip()
last_name = cleaned_data['last_name'].strip()
email = cleaned_data['emailAddress']
password = cleaned_data['password']
confirmPassword = cleaned_data['confirmPassword']
username = "******".join([first_name.lower(), last_name.lower()])
if passwordsMatch(password, confirmPassword) and uniquename(username):
dorm = cleaned_data['dorm']
pic = request.FILES.get('pic','')
user = User.objects.create_user(username=username, email=email, password=password)
user.first_name = first_name
user.last_name = last_name
userdata = UserData.objects.create(user=user,score=0,dorm=dorm, pic=pic)
userdata.pic = pic
user.save()
userdata.save()
user = auth.authenticate(username=username, password=password)
auth.login(request, user)
return HttpResponseRedirect('/')
else:
form = RegistrationForm()
render(request, 'registration.html', {'form':form})
else:
form = RegistrationForm()
return render(request, 'registration.html', {'form':form})
def register(request):
if request.method == 'POST':
user_form = RegistrationForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
new_user = user_form.save()
p = Profile.objects.get(user=new_user)
profile_form = ProfileForm(request.POST, instance=p)
profile_form.save()
users_page = 'http://' + request.META['HTTP_HOST'] + reverse('user_list')
approve_page = 'http://' + request.META['HTTP_HOST'] + reverse('user_edit', args=[new_user.username])
message = "New user registration!\n\n%s\n%s, %s\nActivate user: %s\nView all users: %s" % (
new_user.username, new_user.first_name, new_user.last_name, approve_page, users_page,
)
try:
try:
g = Group.objects.get(name="Account Admins")
emails = [u.email for u in g.user_set.all()]
except:
# email to single email for now
# https://github.com/MAPC/myschoolcommute/issues/49
emails = ['*****@*****.**']
send_mail(
'myschoolcommute.com new user '+new_user.username,
message,
settings.SERVER_EMAIL,
emails
)
except:
#Problem finding group or emailing
mail_admins('myschoolcommute.com new user '+new_user.username, message)
return HttpResponseRedirect("/accounts/register/success/")
else:
profile_form = ProfileForm()
user_form = RegistrationForm()
profile_form.helper.add_input(Submit('submit', 'Create the account'))
return render_to_response("accounts/register.html", {
'user_form' : user_form, 'profile_form': profile_form
}, context_instance=RequestContext(request))
def register_view(request):
logout(request)
message = None
if request.method == "POST":
user = None
form = RegistrationForm(request.POST, request.FILES)
try:
if form.is_valid():
cd = form.cleaned_data
# for optional value
age = cd['age'] or None
sex = cd['sex'] or None
user = User.objects.create_user(form.cleaned_username(),
form.cleaned_email(),
form.cleaned_password2())
userProfile = UserProfile(
type=cd['type'],
location=cd['location'],
profile_image=cd['profile_image'],
user=user,
age=age, # optional value
sex=sex, # optional value
)
userProfile.save()
return HttpResponseRedirect("/")
else:
message = str(form.errors)
except:
if user:
user.delete()
message = str(sys.exc_info()[1])
form = RegistrationForm()
return render_to_response(
register_path,
RequestContext(request, {
"message": message,
"form": form
}))
def signup(request):
register_form = RegistrationForm()
next = request.REQUEST.get('next')
if request.method == 'POST':
register_form = RegistrationForm(request.POST)
if register_form.is_valid():
username = register_form.save()
request.session['username'] = username
if next:
return HttpResponseRedirect(next)
return HttpResponseRedirect('/')
context = {
'register_form': register_form,
'next': next,
}
return render_to_response('signup.html',
context,
context_instance=RequestContext(request))
def landingpage(request):
stats = StatDB.objects.latest()
if request.user.is_authenticated():
url = reverse('logbook', args=[request.user.username])
return HttpResponseRedirect(url)
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
p = form.register()
password = form.cleaned_data['password']
user = authenticate(username=p.user.username, password=password)
login(request, user)
url = reverse('logbook', args=[request.user.username])
return HttpResponseRedirect(url)
else:
form = RegistrationForm()
return TemplateResponse(request, 'landingpage.html', locals())
def register(request):
context = {
"nem_base_url": "http://" + settings.SITE_URL + "/static/nem/",
"site_url": "http://" + settings.SITE_URL + "/",
}
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 passes
# Process the data in form.cleaned_data
amount_bool = form.cleaned_data['amount']
email = form.cleaned_data['email']
name = form.cleaned_data['name']
branch = form.cleaned_data['branch']
batch = form.cleaned_data['batch']
pt = Registration.objects.create(amount=amount_bool,
email=email,
name=name,
branch=branch,
batch=batch,
status=LIMBO)
transaction_id = pt.id
notes = ""
if settings.ENV == "dev":
transaction_id = "dev-nem" + str(pt.id)
else:
transaction_id = "nem" + str(pt.id)
callback_url = "http://" + settings.SITE_URL + "/nem/payment-return"
amount = 1500 if int(amount_bool) == ALUMNI else 500
context = {
"payment_dict":
get_post_object(callback_url, amount, email, transaction_id,
notes)
}
return render_to_response("nem/registration_payment_redirect.html",
RequestContext(request, context))
else:
form = RegistrationForm() # An unbound form
context['form'] = form
return render(request, "nem/register.html", context)
def register_user(request):
user_exist = False
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
name = request.POST['username']
current_site = get_current_site(request)
print current_site
try:
user_exist = User.objects.get(username=name)
print "USER EXIST ---------", user_exist
except ObjectDoesNotExist:
password = request.POST['password1']
user = User.objects.create_user(name,
name,
password,
is_active=False)
key = ''.join(
random.choice(string.digits + string.letters)
for _ in range(10))
app_user = AppUser(user=user,
key_expires=timezone.now() +
datetime.timedelta(minutes=3),
activation_key=key)
app_user.save()
# activation_key = key, to = ['*****@*****.**'])
Thread(target=mail.registration_mail,
kwargs={
'host': current_site.domain,
'activation_key': key,
'to': ['*****@*****.**']
}).start()
# mail.registration_mail(activation_key=key, to=['*****@*****.**'])
print 'mail sent success --------'
return HttpResponseRedirect(reverse('login'))
else:
form = RegistrationForm()
return render(request, 'login/register.html', {
'form': form,
'user_exist': user_exist
})
def register(request):
if request.method == 'GET':
form = RegistrationForm()
elif request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = get_user_model()
user = user()
user.username = form.cleaned_data.get('username')
user.email = form.cleaned_data.get('email')
user.password = make_password(form.cleaned_data.get('password'))
user.is_active = False
user.reset_activation_token()
user.generate_verification_token()
user.save()
return redirect("%s?message=%s" %
(reverse('message'), REG_SUCCESSFUL))
else:
return HttpResponseNotAllowed(permitted_methods=['POST', 'GET'])
return render(request, 'registration/register.html', {'form': form})
def register(request):
logging.debug("IN AUTH_REGISTER")
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(
username=form.cleaned_data['username'],
password=form.cleaned_data['password'],
email=form.cleaned_data['email'])
return HttpResponseRedirect('/register/success/')
else:
form = RegistrationForm()
variables = RequestContext(request, {'form': form})
return render_to_response(
'accounts/registration_form.html',
variables,
)
else:
logging.debug("Rendering registration form")
return render(request, 'accounts/registration_form.html')
logging.debug("Not using post method")
def user_registration(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/')
args = {}
args.update(csrf(request))
if request.method == "POST":
form1 = RegistrationForm(request.POST)
form2 = UserProfileForm(request.POST)
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('/register_success')
args["form"] = RegistrationForm()
args["form2"] = UserProfileForm()
args["form_title"] = "Register"
return render(request, 'register.html', args, RequestContext(request))
def register(request):
"""
Registers a user from supplied username and password. If successful, logs
the user in and redirects him to the cardstories client, with the proper
cookie set.
"""
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
username = form.cleaned_data['username']
password = form.cleaned_data['password1']
# Store username both as username and email, since username = email
# for now.
u = User.objects.create_user(username, username, password)
u.first_name = name
u.save()
# Always call authenticate() before login().
auth_user = authenticate(username=username, password=password)
auth_login(request, auth_user)
GravatarAvatar(auth_user).update()
# The user was just created.
request.session['create'] = True
# Redirect maintaining game_id, if set.
url = '%s%s' % (reverse(welcome), get_gameid_query(request))
return redirect(url);
else:
form = RegistrationForm()
context = {'registration_form': form,
'login_form': LoginForm()}
return render_to_response('cardstories/welcome.html', context,
context_instance=RequestContext(request,
processors=[common_variables]))
def register(request):
latest_news = NewsItem.objects.all()[0]
if request.method == 'POST': #User is attempting submit registration form
form = RegistrationForm(request.POST)
if form.is_valid():
#Create the user objects, w fake username hashed from email address
user = User(username=str(hash(form.cleaned_data['email'])),
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
email=form.cleaned_data['email'])
user.set_password(form.cleaned_data['password'])
user.save()
#Now create associated ambassador instance
ambassador = Ambassador(
user=user,
code=form.cleaned_data['code'],
target=form.cleaned_data['target'],
phone=form.cleaned_data['phone'],
nickname=form.cleaned_data['ambassador_nickname'])
ambassador.save()
send_mail(
'Summer Saturnalia | Ambassador registration confirmation',
'''Congratulations! You are now registered as a Summer Saturnalia ambassador.
Log in using your email address and password at the 'login' link at the top of www.summersaturnalia.com.
If you have any questions that the FAQ doesn't answer then don't hesitate to get in touch.
Love from Team Summer Saturnalia :)''',
'*****@*****.**', [form.cleaned_data['email']],
fail_silently=False)
return redirect('/ambassador/registration_successful')
else: #User would like to see registration form
form = RegistrationForm()
return render_to_response('register.html', {
'registration_form': form,
'latest_news': latest_news
},
context_instance=RequestContext(request))
def index(request):
bound_form = RegistrationForm(request.POST)
if request.method == "POST":
if bound_form.is_valid():
new_user = bound_form.save(commit=False)
new_user.password = bcrypt.hashpw(
bound_form.cleaned_data['password'].encode(), bcrypt.gensalt())
new_user.save()
return HttpResponse("Your form is valid")
else:
print bound_form.errors.as_data()
context = {
'myregistrationform': RegistrationForm(),
'errors': bound_form.errors
}
return render(request, 'testform/index.html', context)
else:
context = {
# Form is the variable name referencing the instance of our RegistrationForm class
'myregistrationform': RegistrationForm()
}
return render(request, 'testform/index.html', context)
def register(request, template_name="registration/register.html"):
if request.method == 'POST':
postdata = request.POST.copy()
form = RegistrationForm(postdata)
if form.is_valid():
user = form.save(commit=False)
user.email = postdata.get('email', '')
user.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:
form = RegistrationForm()
page_title = 'User Registration'
return render_to_response(template_name,
locals(),
context_instance=RequestContext(request))
def register(request):
"""
API endpoint to register a new user.
"""
try:
payload = json.loads(request.body)
except ValueError:
return JsonResponse({"error": "Unable to parse request body"},
status=400)
form = RegistrationForm(payload)
if form.is_valid():
user = User.objects.create_user(form.cleaned_data["username"],
form.cleaned_data["email"],
form.cleaned_data["password"])
user.save()
return JsonResponse({"success": "User registered."}, status=201)
return HttpResponse(form.errors.as_json(),
status=400,
content_type="application/json")
def register(request):
form = RegistrationForm()
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['password1']
)
log_user_in(request, user)
# Check for any GameMemberships they might have and convert to User references
memberships = GameMembership.objects.filter(email=user.email)
if memberships:
for membership in memberships:
membership.user = user
membership.email = None
membership.save()
return redirect('dashboard:home')
return render(request, "authentication/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_form(request):
entity = request.user.entities_set
regtypes = request.user.userregistrationaccess.registrations.filter(
manual=True)
if request.POST:
r = Registration(entity=entity, date=datetime.datetime.now())
form = RegistrationForm(regtypes, request.POST, instance=r)
if form.is_valid():
object = form.save()
form = RegistrationForm(regtypes)
return render_to_response("livestats/registration_form.html", {
'form': form,
'success': True,
'object': object,
'entity': entity
},
context_instance=RequestContext(request))
else:
form = RegistrationForm(regtypes)
return render_to_response("livestats/registration_form.html", {
'form': form,
'entity': entity
},
context_instance=RequestContext(request))
def get_player_id(request, username):
"""
Returns a user's id based on supplied username, optionally creating the
user, if so requested. Username will be validated according to
registration form rules.
If user is not found, a status of 404 will be returned.
If user is not found, creation is requested, but the supplied username is
invalid, a status of 400 will be returned.
"""
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
if request.GET.get('create', '') == 'yes':
# Validates the username according to the registration form.
name = "Cardstories Player"
password = "******"
data = {"name": name,
"username": username,
"password1": password,
"password2": password}
form = RegistrationForm(data)
if not form.is_valid():
return HttpResponseBadRequest()
# Create the user with an unusable password. The user will need
# to click on "forgot password" to obtain a new one.
user = User.objects.create_user(username, username)
user.save()
else:
return HttpResponseNotFound()
response = HttpResponse(user.id, mimetype="text/plain")
return response
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'])
#send_mail(subject,message,from_email,to_list,fail_silently=True)
subject = 'Hello from QUIZZY'
message = 'Hi there, ' + request.POST[
'username'] + '\nThanks for registering with us. Please visit our site to take a test now (quizzy.pythonanywhere.com)'
from_email = settings.EMAIL_HOST_USER
to_list = [request.POST['email']]
send_mail(subject,
message,
from_email,
to_list,
fail_silently=True)
return render(request, 'login/success.html', {'user': user})
else:
form = RegistrationForm()
variables = RequestContext(request, {'form': form})
return render_to_response('login/register.html', variables)
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 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():
obj = get_object_or_404(User, username=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 register(request):
"""
This view handles user registration
"""
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
# Process the data in form.cleaned_data
# Create user and send activation mail
# Create user
user = User.objects.create_user(form.cleaned_data.get('username'),
form.cleaned_data.get('email'),
form.cleaned_data.get('password'))
user.is_staff = False
user.is_active = False
user.save()
# Fill profile
profile = Profile.objects.get(user=user)
# Generate activation key
email_key = user.username + uuid.uuid4().hex
profile.activation_key = email_key
profile.key_expires = datetime.datetime.now() + datetime.timedelta(
days=2)
# Save Profile
profile.save()
# Send activation mail
text = get_template('mail/activation.txt')
html = get_template('mail/activation.haml')
mail_context = Context({
'username':
form.cleaned_data.get('username'),
'activation_key':
email_key
})
text_content = text.render(mail_context)
html_content = html.render(mail_context)
message = EmailMultiAlternatives('Welcome to Element43!',
text_content,
settings.DEFAULT_FROM_EMAIL,
[form.cleaned_data.get('email')])
message.attach_alternative(html_content, "text/html")
message.send()
# Add success message
messages.success(
request,
"""Your account has been created and an e-mail message containing your activation
key has been sent to the address you specified. You have to activate your
account within the next 48 hours.""")
# Redirect home
return HttpResponseRedirect(reverse('home'))
else:
form = RegistrationForm() # An unbound form
rcontext = RequestContext(request, {})
return render_to_response('register.haml', {'form': form}, rcontext)
def register(request):
if request.method == "POST":
bound_form = RegistrationForm(request.POST)
print bound_form.is_valid()
return redirect('/')
