def signup(request, **kwargs):
from django_ext.forms.utils import format_errors
import json
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 = urlresolvers.reverse(settings.SIGNUP_REDIRECT_URLNAME)
else:
if hasattr(settings, "LOGIN_REDIRECT_URLNAME"):
fallback_url = urlresolvers.reverse(settings.LOGIN_REDIRECT_URLNAME)
else:
fallback_url = settings.LOGIN_REDIRECT_URL
success_url = get_default_redirect(request, fallback_url, redirect_field_name)
form = form_class(request.POST or None, group=group)
if request.method == "POST":
if request.is_ajax() and request.POST.get('__validate__'):
return HttpResponse(
json.dumps(format_errors(
form,
fields=request.POST.getlist('__fields__[]')
)), mimetype="application/json")
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)
elif request.is_ajax():
return HttpResponse(json.dumps(format_errors(form)),
mimetype="application/json")
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, **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, redirect_field_name)
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 render(self, context):
user = self.user_var.resolve(context)
display = user_display(user)
if self.as_var:
context[self.as_var] = display
return ""
return display
def render(self, context):
user = self.user_var.resolve(context)
display = user_display(user)
if self.as_var:
context[self.as_var] = display
return ""
return conditional_escape(display)
def show_i_have_logged_you_in(self, request):
messages.add_message(request, messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") % {
"user": user_display(request.user)
}
)
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 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:
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.REQUEST.get(redirect_field_name),
})
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)
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)
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:
confirmation_key = request.GET.get("code")
initial = {}
if confirmation_key:
initial["confirmation_key"] = confirmation_key
form = form_class(group=group, initial=initial)
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")
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")
if request.POST["success_url"]:
success_url = request.POST["success_url"]
else:
success_url = kwargs.pop("success_url", None)
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.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.REQUEST.get(redirect_field_name),
})
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)
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.REQUEST.get(redirect_field_name),
})
return render_to_response(template_name, RequestContext(request, ctx))
def finish_signup(request, service):
access = OAuthAccess(service)
data = request.session.get("oauth_signup_data", None)
ctx = {}
if data["token"]:
if request.method == "POST":
form = SignupForm(request.POST)
# @@@ pulled from Pinax (a class based view would be awesome here
# to reduce duplication)
if form.is_valid():
success_url = get_default_redirect(request)
user = form.save(request=request)
if service == "twitter":
identifier = data["user_data"]["screen_name"]
elif service == "facebook":
identifier = data["user_data"]["id"]
access.persist(user, data["token"], identifier=identifier)
# del request.session["oauth_signup_data"]
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(request, user)
messages.add_message(
request, messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") %
{"user": user_display(user)})
return redirect(success_url)
else:
initial = {}
if service == "twitter":
username = data["user_data"]["screen_name"]
if not User.objects.filter(username=username).exists():
initial["username"] = data["user_data"]["screen_name"]
else:
ctx["username_taken"] = username
form = SignupForm(initial=initial)
ctx.update({
"service": service,
"form": form,
})
ctx = RequestContext(request, ctx)
return render_to_response("oauth_access/finish_signup.html", ctx)
else:
return HttpResponse("no token!")
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:
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 finish_signup(request, service):
access = OAuthAccess(service)
data = request.session.get("oauth_signup_data", None)
ctx = {}
if data["token"]:
if request.method == "POST":
form = SignupForm(request.POST)
# @@@ pulled from Pinax (a class based view would be awesome here
# to reduce duplication)
if form.is_valid():
success_url = get_default_redirect(request)
user = form.save(request=request)
if service == "twitter":
identifier = data["user_data"]["screen_name"]
elif service == "facebook":
identifier = data["user_data"]["id"]
access.persist(user, data["token"], identifier=identifier)
# del request.session["oauth_signup_data"]
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(request, user)
messages.add_message(request, messages.SUCCESS,
ugettext("Successfully logged in as %(user)s.") % {
"user": user_display(user)
}
)
return redirect(success_url)
else:
initial = {}
if service == "twitter":
username = data["user_data"]["screen_name"]
if not User.objects.filter(username=username).exists():
initial["username"] = data["user_data"]["screen_name"]
else:
ctx["username_taken"] = username
form = SignupForm(initial=initial)
ctx.update({
"service": service,
"form": form,
})
ctx = RequestContext(request, ctx)
return render_to_response("oauth_access/finish_signup.html", ctx)
else:
return HttpResponse("no token!")
def signup(request, **kwargs):
authenticated_redirect = getattr(settings, "ACCOUNT_AUTHENTICATED_REDIRECT", None)
if request.user.is_authenticated() and authenticated_redirect:
return redirect(authenticated_redirect)
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:
success_url = get_default_redirect(request, 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.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)
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 = urlresolvers.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)
messages.add_message(request, messages.SUCCESS,
ugettext("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.REQUEST.get(redirect_field_name),
})
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)
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)
signup_record = MobileSignupRecord(user=user)
signup_record.save()
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.REQUEST.get(redirect_field_name),
})
return render_to_response(template_name, RequestContext(request, ctx))
def create_association(self, request, user, profile):
"""Create an association between this user and the given profile"""
assoc = UserOauthAssociation(
user=user,
auth_type=self.auth_type,
profile_id=profile['id'],
username=profile['username'],
access_token=profile['access_token']
)
assoc.save()
messages.add_message(request, messages.SUCCESS,
ugettext("""
Successfully associated %(user)s with %(auth_label)s
screen name %(username)s.
""") % {
"user": user_display(request.user),
"auth_label": self.auth_label,
"username": profile['username']
}
)
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 mark_delete(request):
"""Mark user deleted"""
obj = get_object_or_404(User, pk=request.user.pk)
username = obj.username
email = obj.email
user_displayed = user_display(obj)
if request.method == "POST" and request.POST["action"] == "delete":
logout(request)
count = 0
while True:
username_prefixed = '__{0}_{1}'.format(count, username)
if not User.objects.filter(username=username_prefixed).exists():
break
count += 1
count = 0
while True:
email_prefixed = '__{0}_{1}'.format(count, email)
if not User.objects.filter(email=email_prefixed).exists():
break
count += 1
User.objects.filter(pk=obj.pk).update(
is_active=False,
username=username_prefixed,
email=email_prefixed
)
messages.add_message(request, messages.SUCCESS,
_("Successfully deleted user '%s'") % user_displayed
)
return HttpResponseRedirect(urlresolvers.reverse("home"))
return HttpResponseRedirect(obj.get_absolute_url())
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")
# @@@ honor custom redirect more fully (this is used primarily for
# the default fallback)
success_url = get_default_redirect(request, self.redirect_field_name)
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)})
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 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"
)
# @@@ honor custom redirect more fully (this is used primarily for
# the default fallback)
success_url = get_default_redirect(request, self.redirect_field_name)
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)
}
)
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,
})
