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