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 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, })