def do_register(self, request):
"""Handle registration with association"""
# Ensure that Twitter signin details are present in the session
profile = request.session.get(self.session_profile, None)
if not profile: return HttpResponse(status=400)
RegistrationForm = self.get_registration_form_class(request)
success_url = get_default_redirect(request, REDIRECT_FIELD_NAME)
if request.method != "POST":
# Pre-fill form with suggested info based in Twitter signin
form = RegistrationForm(initial = self.initial_from_profile(profile))
else:
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save(request=request)
assoc = self.create_association(request, user, profile)
self.log_in_user(request, user)
return HttpResponseRedirect(success_url)
return self.render(request, 'register.html', {
'form': form,
'auth_label': self.auth_label,
'signin_url': reverse(self.urlname_pattern % 'signin'),
"action": request.path,
})
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 facebook_callback(request, access, token):
if not request.user.is_authenticated():
user_data = access.make_api_call("json", "https://graph.facebook.com/me", token)
user = access.lookup_user(identifier=user_data["id"])
if user is None:
request.session["oauth_signup_data"] = {
"token": token,
"user_data": user_data,
}
return redirect(
reverse(
"oauth_access_finish_signup", kwargs={
"service": access.service
}
)
)
else:
user.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user)
else:
user = request.user
redirect_to = get_default_redirect(request)
access.persist(user, token)
return redirect(redirect_to)
def twitter_callback(request, access, token):
if not request.user.is_authenticated():
url = "https://twitter.com/account/verify_credentials.json"
user_data = access.make_api_call("json", url, token)
user = access.lookup_user(identifier=user_data["screen_name"])
if user is None:
request.session["oauth_signup_data"] = {
"token": token,
"user_data": user_data,
}
return redirect(
reverse(
"oauth_access_finish_signup", kwargs={
"service": access.service
}
)
)
else:
user.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user)
else:
user = request.user
redirect_to = get_default_redirect(request)
access.persist(user, token)
return redirect(redirect_to)
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 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, **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 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 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 get_success_url(self, request, allowSignup = True):
# @@@ honor custom redirect more fully (this is used primarily for
# the default fallback)
if allowSignup and 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
return get_default_redirect(request, fallback_url, self.redirect_field_name)
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 do_callback(self, request):
"""Handle response from OAuth permit/deny"""
# TODO: Handle OAuth denial!
mode = request.session.get('socialconnect_mode', None)
profile = self.get_profile_from_callback(request)
if not profile: return HttpResponse(status=400)
request.session[self.session_profile] = profile
success_url = get_default_redirect(request, REDIRECT_FIELD_NAME)
if not success_url or 'None' == success_url:
success_url = '/'
try:
# Try looking for an association to perform a login.
assoc = UserOauthAssociation.objects.filter(
auth_type=self.auth_type,
profile_id=profile['id'],
username=profile['username']
).get()
if 'connect' == mode:
messages.add_message(request, messages.ERROR,
ugettext("""This service is already connected to another
account!""")
)
return HttpResponseRedirect(reverse(
ManagementView().urlname_pattern % 'associations'))
else:
self.log_in_user(request, assoc.user)
return HttpResponseRedirect(success_url)
except UserOauthAssociation.DoesNotExist:
# No association found, so...
if not request.user.is_authenticated():
# If no login session, bounce to registration
return HttpResponseRedirect(reverse(
self.urlname_pattern % 'register'))
else:
# If there's a login session, create an association to the
# currently logged in user.
assoc = self.create_association(request, request.user, profile)
del request.session[self.session_profile]
if 'connect' == mode:
return HttpResponseRedirect(reverse(
ManagementView().urlname_pattern % 'associations'))
else:
return HttpResponseRedirect(success_url)
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 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 twitter_callback(request, access, token):
if not request.user.is_authenticated():
url = "https://twitter.com/account/verify_credentials.json"
user_data = access.make_api_call("json", url, token)
user = access.lookup_user(identifier=user_data["screen_name"])
if user is None:
request.session["oauth_signup_data"] = {
"token": token,
"user_data": user_data,
}
return redirect(
reverse("oauth_access_finish_signup",
kwargs={"service": access.service}))
else:
user.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user)
else:
user = request.user
redirect_to = get_default_redirect(request)
access.persist(user, token)
return redirect(redirect_to)
def facebook_callback(request, access, token):
if not request.user.is_authenticated():
user_data = access.make_api_call("json",
"https://graph.facebook.com/me",
token)
user = access.lookup_user(identifier=user_data["id"])
if user is None:
request.session["oauth_signup_data"] = {
"token": token,
"user_data": user_data,
}
return redirect(
reverse("oauth_access_finish_signup",
kwargs={"service": access.service}))
else:
user.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user)
else:
user = request.user
redirect_to = get_default_redirect(request)
access.persist(user, token)
return redirect(redirect_to)
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 redirect_url(self, request):
# if "send_healing_facebook" in request.session:
# del request.session["send_healing_facebook"]
# return reverse("send_healing")
return request.session.pop('oauth_callback_redirect', get_default_redirect(request, '/'))
def on_registration_complete(self, request):
return HttpResponseRedirect(get_default_redirect(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 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 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 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 show_i_have_logged_you_in(self, request):
return HttpResponseRedirect(get_default_redirect(request))
