def signup(request,
key,
form_class=SignupForm,
template_name="account/signup.html",
success_url=None):
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST":
print "received post"
form = form_class(request.POST)
print form
if form.is_valid():
username, password = form.save()
user = authenticate(username=username, password=password)
auth_login(request, user)
request.user.message_set.create(
message=_("Successfully logged in as %(username)s.") %
{'username': user.username})
return HttpResponseRedirect(success_url)
else:
print "invalid form"
else:
form = form_class()
return render_to_response(template_name, {
"form": form,
},
context_instance=RequestContext(request))
def forgot_password(request, form_class=ForgotPasswordForm,
template_name="account/forgot_password.html", success_url=None):
sent_email = None
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
subject = _("Tintz - Nova Senha")
message = render_to_string(u"account/password_reset_message.txt", {
"user": form.user,
"new_password": form.new_password,
})
email_password = EmailHtml(subject, message, settings.DEFAULT_FROM_EMAIL, [form.email_address.email])
email_password.start()
sent_email = u"Nova senha enviada para o email informado"
else:
form = form_class()
return render_to_response(template_name, {
"form": form,
"sent_email": sent_email,
}, context_instance=RequestContext(request))
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", settings.TEMPLATE_SIGNUP)
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(kwargs)
ctx = group_context(group, bridge)
if success_url is None:
if hasattr(settings, "SIGNUP_REDIRECT_URLNAME"):
fallback_url = reverse(settings.SIGNUP_REDIRECT_URLNAME)
else:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(request, fallback_url, redirect_field_name)
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
user, emailAddress = form.save(request=request)
if settings.ACCOUNT_EMAIL_VERIFICATION:
user.is_active = False
user.save()
EmailConfirmation.objects.send_confirmation(emailAddress)
ctx.update({"email": form.cleaned_data["email"], "success_url": success_url})
ctx = RequestContext(request, ctx)
return render_to_response(settings.TEMPLATE_VERIFICATION_SENT, ctx)
else:
form.login(request, user)
return render_to_response(
"account/signup_success.html",
RequestContext(request, {"email": user.email, "nickname": user.get_profile().name}),
)
else:
soup = BeautifulSoup(str(form.errors))
utils.addMsg(request, messages.ERROR, soup.ul.li.ul.li.contents[0])
# utils.addMsg(request, messages.ERROR, form.errors)
else:
form = form_class(group=group)
motto = Motto.objects.get(id=random.randint(1, Motto.objects.getCount()))
ctx.update(
{
"form": form,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.REQUEST.get(redirect_field_name),
"motto": motto,
}
)
return render_to_response(template_name, RequestContext(request, ctx))
def signup(request, form_class=EmailSignupForm,
template_name="account/signup.html", success_url=None,
chapter_slug=None):
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST":
form = form_class(request.POST,
chapter=chapter_slug)
if form.is_valid():
username, password = form.save()
if settings.ACCOUNT_EMAIL_VERIFICATION:
return render_to_response("account/verification_sent.html", {
"email": form.cleaned_data["email"],
}, context_instance=RequestContext(request))
else:
user = authenticate(username=username, password=password)
auth_login(request, user)
login_message=ugettext(u"Welcome back, %(name)s") % {
'name': user.visible_name
}
request.user.message_set.create(message=login_message)
return HttpResponseRedirect(success_url)
else:
form = form_class(chapter=chapter_slug)
return render_to_response(template_name, {
"form": form,
}, context_instance=RequestContext(request))
def signup(request, form_class=SignupForm,
template_name="account/signup.html", success_url=None):
if success_url is None:
success_url = get_default_redirect(request)
if not request.user.is_authenticated():
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
username, password = form.save()
if settings.ACCOUNT_EMAIL_VERIFICATION:
return render_to_response("account/verification_sent.html", {
"email": form.cleaned_data["email"],
}, context_instance=RequestContext(request))
else:
user = authenticate(username=username, password=password)
auth_login(request, user)
request.user.message_set.create(
message=_("%(username)s seja bem vindo!") % {
'username': user.email
})
return HttpResponseRedirect(success_url)
else:
form = form_class()
return render_to_response(template_name,
context_instance=RequestContext(
request,
{ "form": form,
}
)
)
else:
return HttpResponseRedirect(success_url)
def login(request,
form_class=LoginForm,
template_name="account/login.html",
success_url=None,
associate_openid=False,
openid_success_url=None,
url_required=False,
extra_context=None):
if extra_context is None:
extra_context = {}
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST" and not url_required:
form = form_class(request.POST)
if form.login(request):
if associate_openid and association_model is not None:
for openid in request.session.get('openids', []):
assoc, created = UserOpenidAssociation.objects.get_or_create(
user=form.user, openid=openid.openid)
success_url = openid_success_url or success_url
return HttpResponseRedirect(success_url)
else:
form = form_class()
ctx = {
"form": form,
"url_required": url_required,
}
ctx.update(extra_context)
return render_to_response(template_name,
ctx,
context_instance=RequestContext(request))
def confirm_email(request, confirmation_key, **kwargs):
"""
Confirms the email as normal, but then also logs the user in if succesful
"""
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
email_address = None
user = authenticate(confirmation_key=confirmation_key)
if user:
auth_login(request, user)
try:
email_confirmation = EmailConfirmation.objects.get(confirmation_key=confirmation_key)
email_address = email_confirmation.email_address
# now delete the confirmation
email_confirmation.delete()
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
messages.add_message(
request,
messages.SUCCESS,
ugettext(u"You have confirmed that %(email)s is an email address for user '%(user)s'.")
% {"user": user_display(email_address.user), "email": email_address.email},
)
return HttpResponseRedirect(success_url)
except:
pass
return render_to_response(
"emailconfirmation/confirm_email.html",
{"email_address": email_address},
context_instance=RequestContext(request),
)
def on_registration_complete(self, request):
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
return HttpResponseRedirect(get_default_redirect(
request, fallback_url))
def signup(request,
form_class=SignupForm,
template_name="account/signup.html",
success_url=None):
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
username, password = form.save()
if settings.ACCOUNT_EMAIL_VERIFICATION:
return render_to_response(
"account/verification_sent.html", {
"email": form.cleaned_data["email"],
},
context_instance=RequestContext(request))
else:
user = authenticate(username=username, password=password)
auth_login(request, user)
request.user.message_set.create(
message=_("Successfully logged in as %(username)s.") %
{'username': user.username})
return HttpResponseRedirect(success_url)
else:
form = form_class()
return render_to_response(template_name, {
"form": form,
},
context_instance=RequestContext(request))
def login(request,
form_class=LoginForm,
template_name="account/login.html",
success_url=None,
associate_openid=False,
openid_success_url=None,
url_required=False):
if success_url is None:
success_url = get_default_redirect(request)
message = ""
if request.method == "POST" and not url_required:
form = form_class(request.POST)
if form.login(request):
if associate_openid and association_model is not None:
for openid in request.session.get('openids', []):
assoc, created = UserOpenidAssociation.objects.get_or_create(
user=form.user, openid=openid.openid)
success_url = openid_success_url or success_url
return HttpResponseRedirect(success_url)
else:
message = _(
'The username or password you provided does not match our records.'
)
form = form_class()
return render_to_response(template_name, {
"form": form,
"url_required": url_required,
"message": message,
},
context_instance=RequestContext(request))
def signup(request, form_class=SignupForm,
template_name="account/signup.html", success_url=None):
if success_url is None:
success_url = get_default_redirect(request)
if request.user.is_authenticated():
return HttpResponseRedirect(success_url)
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
username, password, email = form.save()
user = User.objects.get(username=username) # authenticate(username=username, password=password)
send_email_confirmation(user, email)
return HttpResponseRedirect('/about/confirm_email')
else:
form = form_class()
return render_to_response(template_name, {
"form": form,
}, context_instance=RequestContext(request))
def show_i_have_logged_you_in(self, request):
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
return HttpResponseRedirect(get_default_redirect(
request, fallback_url))
def signup(request, key, form_class=SignupForm,
template_name="account/signup.html", success_url=None):
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST":
print "received post"
form = form_class(request.POST)
print form
if form.is_valid():
username, password = form.save()
user = authenticate(username=username, password=password)
auth_login(request, user)
request.user.message_set.create(
message=_("Successfully logged in as %(username)s.") % {
'username': user.username
})
return HttpResponseRedirect(success_url)
else :
print "invalid form"
else:
form = form_class()
return render_to_response(template_name, {
"form": form,
}, context_instance=RequestContext(request))
def login(
request,
form_class=LoginForm,
template_name="account/login.html",
success_url=None,
associate_openid=False,
openid_success_url=None,
url_required=False,
):
if success_url is None:
success_url = get_default_redirect(request)
message = ""
if request.method == "POST" and not url_required:
form = form_class(request.POST)
if form.login(request):
if associate_openid and association_model is not None:
for openid in request.session.get("openids", []):
assoc, created = UserOpenidAssociation.objects.get_or_create(user=form.user, openid=openid.openid)
success_url = openid_success_url or success_url
return HttpResponseRedirect(success_url)
else:
message = _("The username or password you provided does not match our records.")
form = form_class()
return render_to_response(
template_name,
{"form": form, "url_required": url_required, "message": message},
context_instance=RequestContext(request),
)
def login(request, form_class=LoginForm, template_name="account/login.html",
success_url=None, associate_openid=False, openid_success_url=None,
url_required=False, extra_context=None, redirect_field_name="next"):
if extra_context is None:
extra_context = {}
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
if request.method == "POST" and not url_required:
form = form_class(request.POST)
if form.login(request):
if associate_openid and association_model is not None:
for openid in request.session.get('openids', []):
assoc, created = UserOpenidAssociation.objects.get_or_create(
user=form.user, openid=openid.openid
)
success_url = openid_success_url or success_url
return HttpResponseRedirect(success_url)
else:
form = form_class()
ctx = {
"form": form,
"url_required": url_required,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.GET.get(redirect_field_name),
}
ctx.update(extra_context)
return render_to_response(template_name, ctx,
context_instance = RequestContext(request)
)
def login(request, **kwargs):
form_class = kwargs.pop("form_class", LoginForm)
template_name = kwargs.pop("template_name", "account/login.html")
success_url = (request.GET.get("success_url")
or request.POST.get("success_url")
or kwargs.pop("success_url", None))
associate_openid = kwargs.pop("associate_openid", False)
openid_success_url = kwargs.pop("openid_success_url", None)
url_required = kwargs.pop("url_required", False)
extra_context = kwargs.pop("extra_context", {})
redirect_field_name = kwargs.pop("redirect_field_name", "next")
group, bridge = group_and_bridge(kwargs)
if extra_context is None:
extra_context = {}
if success_url is None:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(request, fallback_url,
redirect_field_name)
if request.method == "POST" and not url_required:
form = form_class(request.POST, group=group)
if form.is_valid():
form.login(request)
if associate_openid and association_model is not None:
for openid in request.session.get("openids", []):
assoc, created = UserOpenidAssociation.objects.get_or_create(
user=form.user, openid=openid.openid)
success_url = openid_success_url or success_url
messages.add_message(
request, messages.SUCCESS,
ugettext(u"Successfully logged in as %(user)s.") %
{"user": user_display(form.user)})
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update({
"form":
form,
"url_required":
url_required,
"redirect_field_name":
redirect_field_name,
"redirect_field_value":
request.GET.get(redirect_field_name,
request.POST.get(redirect_field_name)),
"success_url":
success_url,
})
ctx.update(extra_context)
return render_to_response(template_name, RequestContext(request, ctx))
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/signup.html")
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(kwargs)
ctx = group_context(group, bridge)
ctx['invite_parameters'] = get_invite_parameters(request)
if success_url is None:
if hasattr(settings, "SIGNUP_REDIRECT_URLNAME"):
fallback_url = reverse(settings.SIGNUP_REDIRECT_URLNAME)
else:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(request, fallback_url,
redirect_field_name)
if request.method == "POST":
form = form_class(request.POST, request.FILES, group=group)
if form.is_valid():
user = form.save(request=request)
accept_invite(request, user)
if settings.ACCOUNT_EMAIL_VERIFICATION:
ctx.update({
"email": form.cleaned_data["email"],
"success_url": success_url,
})
ctx = RequestContext(request, ctx)
return render_to_response("account/verification_sent.html",
ctx)
else:
form.login(request, user)
messages.add_message(
request, messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") %
{"user": user_display(user)})
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group,
initial={
'username': ugettext('Username'),
'email': ugettext('Email address')
})
ctx.update({
"form":
form,
"redirect_field_name":
redirect_field_name,
"redirect_field_value":
request.REQUEST.get(redirect_field_name),
})
return render_to_response(template_name, RequestContext(request, ctx))
def login(request, form_class=LoginForm, template_name="account/login.html",
success_url=None, associate_openid=False, openid_success_url=None,
url_required=False, extra_context=None):
redirect_to = request.REQUEST.get('next', '')
#print "redirect to: " , redirect_to
if extra_context is None:
extra_context = {}
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST" and not url_required:
form = form_class(request.POST)
#print ">>>>>>>>>>>> GET HERE FIRST??"
if form.is_valid():
## HACK For now. Dont know why form.login(request) returns false!!
## TODO HACK For now. Dont know why form.login(request) returns false!!
# if form.login(request):
form.login(request)
try:
s = request.user.shoppleyuser
#s = ShoppleyUser.objects.get(user__id=request.user.id)
s.verified=True
s.save()
except ShoppleyUser.DoesNotExist:
# user wasnt registered yet.
pass
if associate_openid and association_model is not None:
for openid in request.session.get('openids', []):
assoc, created = UserOpenidAssociation.objects.get_or_create(
user=form.user, openid=openid.openid
)
success_url = openid_success_url or success_url
# print ">>>>>>>>>>>>>>>>>landing here??"
#return render_to_response("shoppleyuser/customer_landing_page.html", context_instance=RequestContext(request))
if not redirect_to:
redirect_to= reverse("home")
#print "redirect=", redirect_to
return HttpResponseRedirect(redirect_to)
#return HttpResponseRedirect(success_url)
#return HttpResponseRedirect(reverse('home'))
else:
form = form_class()
# print "request" , request.method, url_required, form.is_valid(), form.login(request), request
# print ">>>>>>> landing there?"
ctx = {
"form": form,
"url_required": url_required,
"redirect_to": redirect_to,
}
ctx.update(extra_context)
return render_to_response(template_name, ctx,
context_instance = RequestContext(request)
)
def login(request, **kwargs):
form_class = kwargs.pop("form_class", LoginForm)
template_name = kwargs.pop("template_name", "account/login.html")
success_url = (request.GET.get("success_url")
or request.POST.get("success_url")
or kwargs.pop("success_url", None))
associate_openid = kwargs.pop("associate_openid", False)
openid_success_url = kwargs.pop("openid_success_url", None)
url_required = kwargs.pop("url_required", False)
extra_context = kwargs.pop("extra_context", {})
redirect_field_name = kwargs.pop("redirect_field_name", "next")
group, bridge = group_and_bridge(kwargs)
if extra_context is None:
extra_context = {}
if success_url is None:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(
request, fallback_url, redirect_field_name)
if request.method == "POST" and not url_required:
form = form_class(request.POST, group=group)
if form.is_valid():
form.login(request)
if associate_openid and association_model is not None:
for openid in request.session.get("openids", []):
assoc, created = UserOpenidAssociation.objects.get_or_create(
user=form.user, openid=openid.openid
)
success_url = openid_success_url or success_url
messages.add_message(
request, messages.SUCCESS,
ugettext(u"Successfully logged in as %(user)s.") % {
"user": user_display(form.user)
})
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update({
"form": form,
"url_required": url_required,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.GET.get(
redirect_field_name,
request.POST.get(redirect_field_name)
),
"success_url": success_url,
})
ctx.update(extra_context)
return render_to_response(template_name, RequestContext(request, ctx))
def login(request, form_class=LoginForm, template_name="account/login.html"):
success_url = get_default_redirect(request)
if not request.user.is_authenticated():
success_url = get_default_redirect(request)
if request.method == "POST":
form = form_class(request.POST)
if form.login(request):
return HttpResponseRedirect(success_url)
else:
form = form_class()
ctx = {
"form": form,
}
return render_to_response(template_name, ctx,
context_instance = RequestContext(request)
)
else:
return HttpResponseRedirect(success_url)
def proxied_invited_signup(
request, invite, form_class=SignupForm, template_name="account/accepted_signup.html", success_url=None
):
# request.user is the user who has invited / authorized the signup
if success_url is None:
success_url = get_default_redirect(request)
display_name = "Visitor"
sponsor = request.user # the actual user who authorized this acceptance
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
username = form.cleaned_data["username"]
password = form.cleaned_data["password1"]
invite.invited.become_member(username, accepted_by=sponsor, password=password)
user = authenticate(username=username, password=password)
auth_login(request, user)
user.message_set.create(
message=ugettext("Successfully logged in as %(username)s.") % {"username": user.username}
)
# Now, what happens if this invite came with a group?
if invite.group:
group = secure_wrap(invite.group, sponsor)
group.add_member(user)
return HttpResponseRedirect(success_url)
else:
form = form_class()
applicant = invite.invited
if applicant:
form.data["email_address"] = applicant.email_address
form.data["first_name"] = ""
form.data["last_name"] = ""
form.data["username"] = ""
display_name = ""
else:
form.email_address = ""
form.username = ""
request.user = request.old_user
return render_to_response(
template_name,
{"form": form, "submit_url": request.build_absolute_uri(), "display_name": display_name},
context_instance=RequestContext(request),
)
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/signup.html")
template_name_failure = kwargs.pop("template_name_failure", "signup_codes/failure.html")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(request)
ctx = group_context(group, bridge)
if success_url is None:
if hasattr(settings, "SIGNUP_REDIRECT_URLNAME"):
fallback_url = reverse(settings.SIGNUP_REDIRECT_URLNAME)
else:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(request, fallback_url)
code = request.GET.get("code")
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
user = form.save(request=request)
signup_code = form.cleaned_data["signup_code"]
if signup_code:
signup_code.use(user)
form.login(request, user)
messages.add_message(
request,
messages.SUCCESS,
ugettext("Successfully logged in as %(username)s.") % {"username": user_display(user)},
)
return HttpResponseRedirect(success_url)
else:
signup_code = SignupCode.check(code)
if signup_code:
initial = {"signup_code": code, "email": signup_code.email}
form = form_class(initial=initial, group=group)
else:
if not settings.ACCOUNT_OPEN_SIGNUP:
ctx.update({"code": code})
ctx = RequestContext(request, ctx)
# if account signup is not open we want to fail when there is
# no sign up code or what was provided failed.
return render_to_response(template_name_failure, ctx)
else:
form = form_class(group=group)
ctx.update({"code": code, "form": form})
return render_to_response(template_name, RequestContext(request, ctx))
def login(request, **kwargs):
form_class = kwargs.pop("form_class", LoginForm)
template_name = settings.TEMPLATE_LOGIN
# 如果是ajax弹出框登录，重置模板
if request.is_ajax():
template_name = settings.TEMPLATE_AJAX_LOGIN
success_url = kwargs.pop("success_url", None)
url_required = kwargs.pop("url_required", False)
extra_context = kwargs.pop("extra_context", {})
redirect_field_name = kwargs.pop("redirect_field_name", "next")
group, bridge = group_and_bridge(kwargs)
if extra_context is None:
extra_context = {}
if success_url is None:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(request, fallback_url, redirect_field_name)
if request.method == "POST" and not url_required:
form = form_class(request.POST, group=group)
if form.is_valid():
form.login(request)
request.session["failedLoginCount"] = 0
return after_login(request, success_url)
else:
soup = BeautifulSoup(str(form.errors))
utils.addMsg(request, messages.ERROR, soup.ul.li.ul.li.contents[0])
# utils.addMsg(request, messages.ERROR, form.errors)
request.session["failedLoginCount"] = request.session.get("failedLoginCount", 0) + 1
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
motto = Motto.objects.get(id=random.randint(1, Motto.objects.getCount()))
ctx.update(
{
"form": form,
"url_required": url_required,
"redirect_field_name": redirect_field_name,
"next": request.REQUEST.get("next", success_url),
"redirect_field_value": request.REQUEST.get(redirect_field_name),
"motto": motto,
}
)
ctx.update(extra_context)
return render_to_response(template_name, RequestContext(request, ctx))
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/account_signup.html")
template_name_failure = kwargs.pop("template_name_failure",
"signup_codes/failure.html")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(request)
ctx = group_context(group, bridge)
if success_url is None:
success_url = get_default_redirect(request)
code = request.GET.get("code")
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
user = form.save(request=request)
signup_code = form.cleaned_data["signup_code"]
signup_code.use(user)
form.login(request, user)
messages.add_message(
request, messages.SUCCESS,
ugettext("Successfully logged in as %(username)s.") % {
"username": user_display(user),
})
return HttpResponseRedirect(success_url)
else:
signup_code = check_signup_code(code)
if signup_code:
form = form_class(initial={"signup_code": code}, group=group)
else:
if not settings.ACCOUNT_OPEN_SIGNUP:
ctx.update({
"code": code,
})
ctx = RequestContext(request, ctx)
# if account signup is not open we want to fail when there is
# no sign up code or what was provided failed.
return render_to_response(template_name_failure, ctx)
else:
form = form_class(group=group)
ctx.update({
"code": code,
"form": form,
})
return render_to_response(template_name, RequestContext(request, ctx))
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/signup.html")
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(kwargs)
ctx = group_context(group, bridge)
if success_url is None:
if hasattr(settings, "SIGNUP_REDIRECT_URLNAME"):
fallback_url = reverse(settings.SIGNUP_REDIRECT_URLNAME)
else:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(
request, fallback_url, redirect_field_name)
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
user = form.save(request=request)
if settings.ACCOUNT_EMAIL_VERIFICATION:
ctx.update({
"email": form.cleaned_data["email"],
"success_url": success_url,
})
ctx = RequestContext(request, ctx)
return render_to_response("account/verification_sent.html",
ctx)
else:
form.login(request, user)
messages.add_message(
request, messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") % {
"user": user_display(user)
})
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group)
ctx.update({
"form": form,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.GET.get(
redirect_field_name,
request.POST.get(redirect_field_name)),
})
return render_to_response(template_name, RequestContext(request, ctx))
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/signup.html")
template_name_failure = kwargs.pop("template_name_failure", "signup_codes/failure.html")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(kwargs)
ctx = group_context(group, bridge)
if success_url is None:
success_url = get_default_redirect(request)
code = request.GET.get("code")
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
username, password = form.save()
user = authenticate(username=username, password=password)
signup_code = form.cleaned_data["signup_code"]
signup_code.use(user)
auth_login(request, user)
messages.add_message(request, messages.SUCCESS,
ugettext("Successfully logged in as %(username)s.") % {
"username": user_display(user),
}
)
return HttpResponseRedirect(success_url)
else:
signup_code = check_signup_code(code)
if signup_code:
form = form_class(initial={"signup_code": code}, group=group)
else:
if not settings.ACCOUNT_OPEN_SIGNUP:
ctx.update({
"code": code,
})
ctx = RequestContext(request, ctx)
# if account signup is not open we want to fail when there is
# no sign up code or what was provided failed.
return render_to_response(template_name_failure, ctx)
else:
form = form_class(group=group)
ctx.update({
"code": code,
"form": form,
})
return render_to_response(template_name, RequestContext(request, ctx))
def login(request, msg=None, **kwargs):
form_class = kwargs.pop("form_class", LoginForm)
template_name = kwargs.pop("template_name", "account/login.html")
success_url = kwargs.pop("success_url", None)
url_required = kwargs.pop("url_required", False)
extra_context = kwargs.pop("extra_context", {})
redirect_field_name = kwargs.pop("redirect_field_name", "next")
group, bridge = group_and_bridge(kwargs)
message = None
if "message" in request.session:
message = request.session["message"]
del request.session["message"]
if msg is not None:
if msg == '1':
message = "Already Registered"
if extra_context is None:
extra_context = {}
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
if request.method == "POST" and not url_required:
form = form_class(request.POST, group=group)
if form.is_valid():
form.login(request)
if len(request.user.get_profile().display_children) < 1:
return HttpResponseRedirect(reverse("signup_add_children"))
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update({
"message":
message,
"form":
form,
"url_required":
url_required,
"redirect_field_name":
redirect_field_name,
"redirect_field_value":
request.REQUEST.get(redirect_field_name),
})
ctx.update(extra_context)
return render_to_response(template_name, RequestContext(request, ctx))
def beta(request, msg=None, **kwargs):
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = get_default_redirect(request, redirect_field_name)
if request.method == "POST" and "beta" in request.POST:
beta_code = request.POST["beta"]
if beta_code == "play":
request.session["beta_ok"] = 1
return HttpResponseRedirect(success_url)
ctx = {"redirect_field_name": redirect_field_name, "redirect_field_value": request.REQUEST.get(redirect_field_name)}
return render_to_response("account/beta.html", RequestContext(request, ctx))
def login(request, **kwargs):
form_class = kwargs.pop("form_class", LoginForm)
template_name = kwargs.pop("template_name", "account/login.html")
success_url = kwargs.pop("success_url", None)
associate_openid = kwargs.pop("associate_openid", False)
openid_success_url = kwargs.pop("openid_success_url", None)
url_required = kwargs.pop("url_required", False)
extra_context = kwargs.pop("extra_context", {})
redirect_field_name = kwargs.pop("redirect_field_name", "next")
group, bridge = group_and_bridge(kwargs)
if extra_context is None:
extra_context = {}
if request.method == "POST" and not url_required:
form = form_class(request.POST, group=group)
if form.login(request):
if associate_openid and association_model is not None:
for openid in request.session.get("openids", []):
assoc, created = UserOpenidAssociation.objects.get_or_create(user=form.user, openid=openid.openid)
success_url = openid_success_url or success_url
message = ugettext(u"Successfully logged in as %(user)s.") % {"user": user_display(form.user)}
messages.add_message(request, messages.SUCCESS, message)
extra_context["message"] = message
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
if request.is_ajax():
extra_context["TEMPLATE"] = ""
return extra_context
return HttpResponseRedirect(success_url)
else:
extra_context["message"] = "Login failed"
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update(
{
"form": form,
"url_required": url_required,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.GET.get(redirect_field_name),
"TEMPLATE": template_name,
}
)
ctx.update(extra_context)
return ctx
def signup(request, form_class=SignupForm,
template_name="account/signup.html", success_url=None):
if success_url is None:
success_url = get_default_redirect(request)
code = request.GET.get("code")
badge = request.GET.get("badge")
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
username, password = form.save()
user = authenticate(username=username, password=password)
signup_code = form.cleaned_data["signup_code"]
badge_code = form.data.get("signup_badge")
signup_code.use(user)
auth_login(request, user)
request.user.message_set.create(
message=ugettext("Successfully logged in as %(username)s.") % {
'username': user.username
})
post_acc = Account.objects.get(user=User.objects.get(username=user.username))
print post_acc
post_acc.badge = badge_code
post_acc.save()
return HttpResponseRedirect(success_url)
else:
signup_code = check_signup_code(code,badge)
if signup_code:
form = form_class(initial={"signup_code": code, "signup_badge" : badge})
else:
if not settings.ACCOUNT_OPEN_SIGNUP:
# if account signup is not open we want to fail when there is
# no sign up code or what was provided failed.
return render_to_response("signup_codes/failure.html", {
"code": code,
"badge": badge,
}, context_instance=RequestContext(request))
else:
form = form_class()
return render_to_response(template_name, {
"code": code,
"badge": badge,
"form": form,
}, context_instance=RequestContext(request))
def post(request, success_url=None) :
if success_url is None:
success_url = get_default_redirect(request)
if request.POST :
form = TweetForm(request.user, request.POST)
if form.is_valid():
form.save()
else :
# what to do here? We weren't planning to show the form again ... :-(
request.user.message_set.create(message=u'%s'%_("We are sorry, but we cannot update your status at the moment"))
return HttpResponseRedirect(success_url)
def login(request, msg=None, **kwargs):
form_class = kwargs.pop("form_class", LoginForm)
template_name = kwargs.pop("template_name", "account/login.html")
success_url = kwargs.pop("success_url", None)
url_required = kwargs.pop("url_required", False)
extra_context = kwargs.pop("extra_context", {})
redirect_field_name = kwargs.pop("redirect_field_name", "next")
group, bridge = group_and_bridge(kwargs)
message = None
if "message" in request.session:
message = request.session["message"]
del request.session["message"]
if msg is not None:
if msg == "1":
message = "Already Registered"
if extra_context is None:
extra_context = {}
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
if request.method == "POST" and not url_required:
form = form_class(request.POST, group=group)
if form.is_valid():
form.login(request)
if len(request.user.get_profile().display_children) < 1:
return HttpResponseRedirect(reverse("signup_add_children"))
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update(
{
"message": message,
"form": form,
"url_required": url_required,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.REQUEST.get(redirect_field_name),
}
)
ctx.update(extra_context)
return render_to_response(template_name, RequestContext(request, ctx))
def beta(request, msg=None, **kwargs):
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = get_default_redirect(request, redirect_field_name)
if request.method == "POST" and "beta" in request.POST:
beta_code = request.POST["beta"]
if beta_code == 'play':
request.session["beta_ok"] = 1
return HttpResponseRedirect(success_url)
ctx = {
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.REQUEST.get(redirect_field_name),
}
return render_to_response("account/beta.html",
RequestContext(request, ctx))
def signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/signup.html")
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
group, bridge = group_and_bridge(kwargs)
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
if request.method == "POST":
form = form_class(request.POST, group=group)
if form.is_valid():
credentials = form.save(request=request)
if settings.ACCOUNT_EMAIL_VERIFICATION:
return render_to_response(
"account/verification_sent.html",
{"email": form.cleaned_data["email"]},
context_instance=RequestContext(request),
)
else:
user = authenticate(**credentials)
auth_login(request, user)
messages.add_message(
request,
messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") % {"user": user_display(user)},
)
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update(
{
"form": form,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.GET.get(redirect_field_name),
}
)
return render_to_response(template_name, RequestContext(request, ctx))
def signup(request, confirmation_key=None, **kwargs):
template_name = kwargs.pop("template_name", "account/account_signup.html")
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
ctx = {}
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
user = form.save(request=request)
request.session["new_user"] = True
form.login(request, user)
request.session["event"] = 'Registered using non-Facebook form'
return HttpResponseRedirect(reverse("signup_connect_fb"))
else:
form = SignupForm()
if confirmation_key is not None:
try:
join_invitation = JoinInvitationEmail.objects.get(
confirmation_key=confirmation_key.lower())
ctx.update({
"email": join_invitation.contact.email,
"confirmation_key": join_invitation.confirmation_key
})
request.session["source"] = 'email_invite'
except JoinInvitationEmail.DoesNotExist:
pass
ctx.update({
"form":
form,
"redirect_field_name":
redirect_field_name,
"redirect_field_value":
request.REQUEST.get(redirect_field_name),
})
return render_to_response(template_name, RequestContext(request, ctx))
def signup(request,
form_class=SignupForm,
template_name="account/signup.html",
success_url=None):
if success_url is None:
success_url = get_default_redirect(request)
code = request.GET.get("code")
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
username, password = form.save()
user = authenticate(username=username, password=password)
signup_code = form.cleaned_data["signup_code"]
signup_code.use(user)
auth_login(request, user)
request.user.message_set.create(
message=ugettext("Successfully logged in as %(username)s.") %
{'username': user.username})
return HttpResponseRedirect(success_url)
else:
signup_code = check_signup_code(code)
if signup_code:
form = form_class(initial={"signup_code": code})
else:
if not settings.ACCOUNT_OPEN_SIGNUP:
# if account signup is not open we want to fail when there is
# no sign up code or what was provided failed.
return render_to_response(
"signup_codes/failure.html", {
"code": code,
},
context_instance=RequestContext(request))
else:
form = form_class()
return render_to_response(template_name, {
"code": code,
"form": form,
},
context_instance=RequestContext(request))
def signup_complete(request, form_class=SignupCompleteForm,
template_name="account/signup_complete.html", success_url=None):
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
username, password, email = form.save(request)
user = User.objects.get(username=username)
authenticate(username=username, password=password)
return HttpResponseRedirect(success_url)
else:
form = form_class()
return render_to_response(template_name, {
"form": form,
"username": request.user.username,
}, context_instance=RequestContext(request))
def customer_signup(request, form_class=CustomerSignupForm,
template_name="shoppleyuser/customer_signup.html", success_url=None):
#success_url = "shoopleyuser/customer_landing_page.html"
success_url = "/shoppleyuser/customer/signup-success"
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
username, password = form.save()
#from shoppleyuser.utils import parse_phone_number,sms_notify
#signup_msg = _("Welcome to Shoppley! Txt \"#help\" for all commands. Enjoy!")
#sms_notify(parse_phone_number(form.cleaned_data["phone"]),signup_msg)
if settings.ACCOUNT_EMAIL_VERIFICATION:
return render_to_response("account/verification_sent.html", {
"email": form.cleaned_data["email"],
}, context_instance=RequestContext(request))
else:
user = authenticate(username=username, password=password)
auth_login(request, user)
request.user.message_set.create(
message=_("Successfully logged in as %(username)s.") % {
'username': user.username
})
from shoppleyuser.utils import parse_phone_number,sms_notify
signup_msg =unicode(_("Welcome to Shoppley! Txt \"#help\" for all commands. Enjoy!"))
#print signup_msg
try :
sms_notify(parse_phone_number(form.cleaned_data["phone"]),signup_msg)
except ValidationError:
pass
return HttpResponseRedirect(success_url)
else:
form = form_class()
return render_to_response(template_name, {
"form": form,
}, context_instance=RequestContext(request))
def signup(request, confirmation_key=None, **kwargs):
template_name = kwargs.pop("template_name", "account/account_signup.html")
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
ctx = {}
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
user = form.save(request=request)
request.session["new_user"] = True
form.login(request, user)
request.session["event"] = "Registered using non-Facebook form"
return HttpResponseRedirect(reverse("signup_connect_fb"))
else:
form = SignupForm()
if confirmation_key is not None:
try:
join_invitation = JoinInvitationEmail.objects.get(confirmation_key=confirmation_key.lower())
ctx.update(
{"email": join_invitation.contact.email, "confirmation_key": join_invitation.confirmation_key}
)
request.session["source"] = "email_invite"
except JoinInvitationEmail.DoesNotExist:
pass
ctx.update(
{
"form": form,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.REQUEST.get(redirect_field_name),
}
)
return render_to_response(template_name, RequestContext(request, ctx))
def login(request, **kwargs):
form_class = kwargs.pop("form_class", LoginForm)
template_name = kwargs.pop("template_name", "account/login.html")
success_url = kwargs.pop("success_url", None)
associate_openid = kwargs.pop("associate_openid", False)
openid_success_url = kwargs.pop("openid_success_url", None)
url_required = kwargs.pop("url_required", False)
extra_context = kwargs.pop("extra_context", {})
redirect_field_name = kwargs.pop("redirect_field_name", "next")
group, bridge = group_and_bridge(kwargs)
if extra_context is None:
extra_context = {}
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
if request.method == "POST" and not url_required:
form = form_class(request.POST, group=group)
if form.login(request):
if associate_openid and association_model is not None:
for openid in request.session.get("openids", []):
assoc, created = UserOpenidAssociation.objects.get_or_create(
user=form.user, openid=openid.openid
)
success_url = openid_success_url or success_url
return HttpResponseRedirect(success_url)
else:
form = form_class(group=group)
ctx = group_context(group, bridge)
ctx.update({
"form": form,
"url_required": url_required,
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.GET.get(redirect_field_name),
})
ctx.update(extra_context)
return render_to_response(template_name, RequestContext(request, ctx))
def resend_confirmation(request, form_class=ResendConfirmationForm,
template_name="account/resend_confirmation.html", success_url=None):
sent_email = None
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
if form.user and form.email_address:
send_email_confirmation(form.user, form.email_address)
sent_email = u"Nova confirmação enviada para o email informado"
else:
form = form_class()
return render_to_response(template_name, {
"form": form,
"sent_email": sent_email,
}, context_instance=RequestContext(request))
def login(request, form_class=LoginForm,
template_name="account/login.html", success_url=None,
associate_openid=False, openid_success_url=None, url_required=False):
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST" and not url_required:
form = form_class(request.POST)
if form.login(request):
if associate_openid and association_model is not None:
for openid in request.session.get('openids', []):
assoc, created = UserOpenidAssociation.objects.get_or_create(
user=form.user, openid=openid.openid
)
success_url = openid_success_url or success_url
return HttpResponseRedirect(iri_to_uri(success_url))
else:
form = form_class()
return render_to_response(template_name, {
"form": form,
"url_required": url_required,
}, context_instance=RequestContext(request))
def login(request, form_class=LoginForm, template_name="account/login.html",
success_url=None, associate_openid=False, openid_success_url=None,
url_required=False, extra_context=None):
if extra_context is None:
extra_context = {}
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST" and not url_required:
form = form_class(request.POST)
if form.login(request):
return HttpResponseRedirect(success_url)
else:
form = form_class()
ctx = {
"form": form,
"url_required": url_required,
}
ctx.update(extra_context)
return render_to_response(template_name, ctx,
context_instance = RequestContext(request)
)
def login(request,
form_class=LoginForm,
template_name="login.html",
success_url=None):
if success_url is None:
success_url = get_default_redirect(request)
if not request.user.is_authenticated():
if request.method == "POST":
form = form_class(request.POST)
if form.login(request):
return HttpResponseRedirect(success_url)
else:
form = form_class()
ctx = {
"form": form,
}
return render_to_response(template_name,
ctx,
context_instance=RequestContext(request))
else:
return HttpResponseRedirect(success_url)
def mit_bu_signup(request,
form_class=SignupForm,
template="egghead/mit_bu_signup.html",
success_url=None):
if success_url is None:
success_url = get_default_redirect(request)
form_checking_errors = []
form_checking_passed = True
if request.method == "POST":
form = form_class(request.POST)
if request.POST["email"].lower().find("@bu.edu") < 0\
and request.POST["email"].lower().find("@mit.edu") < 0\
and request.POST["email"].lower().find("@tulane.edu") < 0:
form_checking_passed = False
form_checking_errors.append(
_("You must use an email address from accepted universities"))
if form.is_valid() and form_checking_passed:
username, password = form.save()
user = User.objects.get(username=username)
if settings.ACCOUNT_EMAIL_VERIFICATION:
return render_to_response(
"account/verification_sent.html", {
"email": form.cleaned_data["email"],
},
context_instance=RequestContext(request))
else:
user = authenticate(username=username, password=password)
auth_login(request, user)
request.user.message_set.create(
message=_("Successfully logged in as %(username)s.") %
{'username': user.username})
return HttpResponseRedirect(success_url)
else:
form = form_class()
return render_to_response(template, {
"form": form,
"form_errors": form_checking_errors,
},
context_instance=RequestContext(request))
def login(request, form_class=LoginForm, template_name="account/login.html",
success_url=None, associate_openid=False, openid_success_url=None,
url_required=False, extra_context=None):
if extra_context is None:
extra_context = {}
if success_url is None:
success_url = get_default_redirect(request)
if request.method == "POST" and not url_required:
form = form_class(request.POST)
if form.login(request):
if associate_openid and association_model is not None:
for openid in request.session.get('openids', []):
assoc, created = UserOpenidAssociation.objects.get_or_create(
user=form.user, openid=openid.openid
)
success_url = openid_success_url or success_url
# Redirect to http or https based on account
if personal_ssl_access.increaseAllowed(user=form.user):
success_url = "%s%s" % (settings.SSL_BASE_URL, success_url)
logger.debug("Subscriber %s" % success_url)
else:
success_url = "%s%s" % (settings.BASE_URL, success_url)
logger.debug("NonSubscriber %s" % success_url)
return HttpResponseRedirect(success_url)
else:
form = form_class()
ctx = {
"form": form,
"url_required": url_required,
"success_url": success_url
}
ctx.update(extra_context)
return render_to_response(template_name, ctx,
context_instance = RequestContext(request)
)
def do_register(self, request, message=None):
"""
do_register implementation is copied from django-openid so we can
ensure Pinax functionality in OpenID registration. django-openid
didn't quite give enough hooks.
This implementation modifies the POST case and will not run
create_user, confirm_email_step or on_registration_complete hooks.
"""
# Show a registration / signup form, provided the user is not
# already logged in
if not request.user.is_anonymous():
return self.show_already_signed_in(request)
openid_url = request.POST.get("openid_url")
openids = request.session.get("openids")
if not openid_url and not openids:
return account_login(request,
url_required=True,
extra_context={
"openid_login": True,
})
# perform OpenID login if openid_url is defined. we do this before the
# check to ACCOUNT_OPEN_SIGNUP to allow users who have existing OpenID
# association to login even when ACCOUNT_OPEN_SIGNUP is turned off.
if openid_url:
return self.start_openid_process(
request,
user_url=openid_url,
on_complete_url=urlparse.urljoin(request.path,
"../register_complete/"),
trust_root=urlparse.urljoin(request.path, ".."))
if not settings.ACCOUNT_OPEN_SIGNUP:
return render_to_response("django_openid/registration_closed.html",
{},
context_instance=RequestContext(request))
RegistrationForm = self.get_registration_form_class(request)
try:
openid = request.openid and request.openid.openid or None
except AttributeError:
return self.show_error(
request, "Add CookieConsumer or similar to your middleware")
if request.method == "POST":
# TODO: The user might have entered an OpenID as a starting point,
# or they might have decided to sign up normally
form = RegistrationForm(
request.POST,
openid=openid,
reserved_usernames=self.reserved_usernames,
no_duplicate_emails=self.no_duplicate_emails)
if form.is_valid():
# Pinax modification
user = form.save(request=request)
if openid:
user.openids.create(openid=openid)
if settings.ACCOUNT_EMAIL_VERIFICATION:
return render_to_response(
"account/verification_sent.html", {
"email": form.cleaned_data["email"],
},
context_instance=RequestContext(request))
else:
# form.login is the same implementation used in normal
# signup. hopefully this doesn't bite us later.
self.log_in_user(request, user)
messages.add_message(
request, messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") %
{"user": user_display(user)})
# @@@ honor custom redirect more fully (this is used primarily for
# the default fallback)
if hasattr(settings, "SIGNUP_REDIRECT_URLNAME"):
fallback_url = reverse(
settings.SIGNUP_REDIRECT_URLNAME)
else:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = reverse(
settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(
request, fallback_url, self.redirect_field_name)
return HttpResponseRedirect(success_url)
else:
form = RegistrationForm(
initial=request.openid
and self.initial_from_sreg(request.openid.sreg) or {},
openid=openid,
reserved_usernames=self.reserved_usernames,
no_duplicate_emails=self.no_duplicate_emails)
return self.render(
request, self.register_template, {
"form":
form,
"message":
message,
"openid":
request.openid,
"logo":
self.logo_path or (urlparse.urljoin(request.path, "../logo/")),
"no_thanks":
self.sign_next(request.path),
"action":
request.path,
})
def proxied_signup(request,
application,
form_class=SignupForm,
template_name="account/accepted_signup.html",
success_url=None):
# request.user is the user who has invited / authorized the signup
if success_url is None:
success_url = get_default_redirect(request)
# because this is a signup request that has an application object, we expect the application
display_name = "Visitor"
sponsor = request.user # the actual user who authorized this acceptance
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password1']
application.applicant.become_member(username,
accepted_by=sponsor,
password=password)
user = authenticate(username=username, password=password)
auth_login(request, user)
user.message_set.create(
message=ugettext("Successfully logged in as %(username)s.") %
{'username': user.username})
# Now, what happens if this application or invite came with a group?
if application.group:
group = secure_wrap(application.group, sponsor)
group.add_member(user)
#application.delete()
return HttpResponseRedirect(success_url)
else:
form = form_class()
applicant = application.get_inner().applicant
if applicant:
form.data['email_address'] = applicant.email_address
form.data['first_name'] = applicant.first_name
form.data['last_name'] = applicant.last_name
form.data['username'] = applicant.first_name.lower().strip(
) + '.' + applicant.last_name.lower().strip()
#normalize and uniquify
display_name = form.data['first_name'] + ' ' + form.data[
'last_name']
else:
form.email_address = ''
form.username = ''
# the outstanding issue is how to make sure that the form we're rendering comes back here
# ie. with the hmac, let's pass it down as a "submit_url"
# we must now switch back to the original user (probably Anon) back ... otherwise it thinks we're
# logged in as the proxy, which circumvents showing the signup form
request.user = request.old_user
return render_to_response(template_name, {
"form": form,
"submit_url": request.build_absolute_uri(),
"display_name": display_name
},
context_instance=RequestContext(request))
def proxied_invited_signup(request,
invite,
form_class=SignupForm,
template_name="account/accepted_signup.html",
success_url=None):
# request.user is the user who has invited / authorized the signup
if success_url is None:
success_url = get_default_redirect(request)
display_name = "Visitor"
sponsor = request.user # the actual user who authorized this acceptance
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password1']
invite.invited.become_member(username,
accepted_by=sponsor,
password=password)
user = authenticate(username=username, password=password)
auth_login(request, user)
user.message_set.create(
message=ugettext("Successfully logged in as %(username)s.") %
{'username': user.username})
# Now, what happens if this invite came with a group?
if invite.group:
group = secure_wrap(invite.group, sponsor)
group.add_member(user)
return HttpResponseRedirect(success_url)
else:
form = form_class()
applicant = invite.invited
if applicant:
form.data['email_address'] = applicant.email_address
form.data['first_name'] = ''
form.data['last_name'] = ''
form.data['username'] = ''
display_name = ''
else:
form.email_address = ''
form.username = ''
request.user = request.old_user
return render_to_response(template_name, {
"form": form,
"submit_url": request.build_absolute_uri(),
"display_name": display_name
},
context_instance=RequestContext(request))
def show_i_have_logged_you_in(self, request):
return HttpResponseRedirect(get_default_redirect(request))
def on_registration_complete(self, request):
return HttpResponseRedirect(get_default_redirect(request))
def bu2010spring(request,
form_class=SignupForm,
template="egghead/bu2010spring.html",
success_url=None):
if success_url is None:
success_url = get_default_redirect(request)
form_checking_errors = []
form_checking_passed = True
if request.method == "POST":
form = form_class(request.POST)
course = request.POST["course"]
cohort = request.POST["cohort"]
if course == "None":
form_checking_passed = False
form_checking_errors.append("You must choose a course number")
if cohort == "None":
form_checking_passed = False
form_checking_errors.append("You must select a cohort (A~D)")
if request.POST["email"].find("@bu.edu") < 0\
and request.POST["email"].find("mit.edu") < 0:
form_checking_passed = False
form_checking_errors.append("You must use a BU email address")
if form.is_valid() and form_checking_passed:
username, password = form.save()
user = User.objects.get(username=username)
descp = "Students who register with the course " + course + \
" at Boston University, offered by Prof. Marshall Van Alstyne"
marshall, created = User.objects.get_or_create(username="******")
course_tribe, created = Tribe.objects.get_or_create(
slug=course,
defaults={
"name": course,
"creator": marshall,
"created": datetime.now(),
"description": descp,
})
course_tribe.members.add(user)
descp = "Students in " + course + " , Cohort " + cohort
cohort_tribe, created = Tribe.objects.get_or_create(
slug=course + "_" + cohort,
defaults={
"name": course + " Corhort " + cohort,
"creator": marshall,
"created": datetime.now(),
"description": descp,
})
cohort_tribe.members.add(user)
if settings.ACCOUNT_EMAIL_VERIFICATION:
return render_to_response(
"account/verification_sent.html", {
"email": form.cleaned_data["email"],
},
context_instance=RequestContext(request))
else:
user = authenticate(username=username, password=password)
auth_login(request, user)
request.user.message_set.create(
message=_("Successfully logged in as %(username)s.") %
{'username': user.username})
return HttpResponseRedirect(success_url)
else:
form = form_class()
return render_to_response(template, {
"form": form,
"form_errors": form_checking_errors,
},
context_instance=RequestContext(request))
