def join_welcome_photo(request): next = "/welcome/2" redirect_to = request.REQUEST.get("redirect_to", "/") # Welcome pages have a 'Continue' button that should always lead # to the next page. success = "/welcome/1" if "continue" in request.POST: success = next rv = common_views.common_photo_upload(request, util.qsa(success, {"redirect_to": redirect_to})) if rv: return rv # If avatar wasn't changed, just go to next page, if 'Continue' was clicked. if "continue" in request.POST: return http.HttpResponseRedirect(util.qsa(next, {"redirect_to": redirect_to})) avatars = display.DEFAULT_AVATARS view = request.user page = "photo" area = "welcome" c = template.RequestContext(request, locals()) t = loader.get_template("welcome_%s.html" % page) return http.HttpResponse(t.render(c))
def build_auth_url(request, request_token, url, callback=None, parameters=None): if not callback: callback = util.here(request) parameters = parameters and parameters or {} parameters.update({'oauth_token': request_token.key, 'oauth_callback': callback}) auth_url = util.qsa(url, parameters) return auth_url
def build_url(self, request): # TODO(termie) rearrange these in the future to prevent circular imports from jaikucommon import util base_url = self.base_url if self.redirect: redirect_to = self.build_redirect(request) base_url = util.qsa(base_url, {'redirect_to': redirect_to}) return base_url
def build_url(self, request): # TODO(termie) rearrange these in the future to prevent circular imports from jaikucommon import util redirect_url = self.build_redirect(request) nonce = util.create_nonce(request.user, self.message + redirect_url) return util.qsa(self.base_url, {'message': self.message, '_nonce': nonce, 'redirect_to': redirect_url})
def login_login(request): redirect_to = request.REQUEST.get("redirect_to", "/") redirect_to = clean.redirect_to(redirect_to) if request.POST: try: login = request.POST.get("log", None) password = request.POST.get("pwd", None) rememberme = request.POST.get("rememberme", None) # TODO validate current_user = user.lookup_user_by_login(login, password) if current_user: if redirect_to == "/": redirect_to = current_user.url("/overview") # Attempt to do some cleanup on the user if necessary api.user_cleanup(api.ROOT, current_user.nick) # if we aren't hosted or aren't ssl just set the cookie and go home if not settings.HOSTED_DOMAIN_ENABLED or not settings.SSL_LOGIN_ENABLED: response = http.HttpResponseRedirect(redirect_to) response = user.set_user_cookie(response, current_user, rememberme) return response # otherwise, we're going to have to redirect to set the cookie on # the proper domain sso_token = util.generate_uuid() cache.set("sso/%s" % sso_token, (current_user.nick, rememberme), timeout=10) sso_url = "http://%s/login/noreally" % (settings.DOMAIN) sso_url = util.qsa(sso_url, {"redirect_to": redirect_to, "sso_token": sso_token}) return http.HttpResponseRedirect(sso_url) else: raise exception.ValidationError("Invalid username or password") except: exception.handle_exception(request) if request.user: if redirect_to == "/": redirect_to = request.user.url("/overview") return http.HttpResponseRedirect(redirect_to) c = template.RequestContext(request, locals()) t = loader.get_template("login.html") return http.HttpResponse(t.render(c))
def join_join(request): if request.user: raise exception.AlreadyLoggedInException() redirect_to = request.REQUEST.get("redirect_to", "/") # get the submitted vars nick = request.REQUEST.get("nick", "") first_name = request.REQUEST.get("first_name", "") last_name = request.REQUEST.get("last_name", "") email = request.REQUEST.get("email", "") password = request.REQUEST.get("password", "") confirm = request.REQUEST.get("confirm", "") hide = request.REQUEST.get("hide", "") if request.POST: try: # TODO validate params = util.query_dict_to_keywords(request.POST) if hide: params["privacy"] = 2 validate.email(email) if not mail.is_allowed_to_send_email_to(email): raise exception.ValidationError("Cannot send email to that address") # TODO start transaction if api.actor_lookup_email(api.ROOT, email): raise exception.ValidationError("That email address is already associated with a member.") actor_ref = api.user_create(api.ROOT, **params) actor_ref.access_level = "delete" api.post(actor_ref, nick=actor_ref.nick, message="Joined %s!" % (settings.SITE_NAME), icon="jaiku-new-user") # send off email confirmation api.activation_request_email(actor_ref, actor_ref.nick, email) # TODO end transaction welcome_url = util.qsa("/welcome", {"redirect_to": redirect_to}) # NOTE: does not provide a flash message response = http.HttpResponseRedirect(welcome_url) user.set_user_cookie(response, actor_ref) return response except: exception.handle_exception(request) # for legal section legal_component = component.include("legal", "dummy_legal") legal_html = legal_component.embed_join() # for sidebar sidebar_green_top = True area = "join" c = template.RequestContext(request, locals()) t = loader.get_template("join.html") return http.HttpResponse(t.render(c))
def join_welcome_contacts(request): """ if we have an access token for this user attempt to fetch the contacts else if we have a request token attempt to get an access token if we have neither if we are trying to authorize, grab a request token and redirect to authorize page else show the page """ redirect_to = request.REQUEST.get("redirect_to", "/") next = "/welcome/done" # these are for the find more contacts bits start_index = int(request.REQUEST.get("index", 1)) max = 100 token = request.REQUEST.get("token") contacts_more = int(request.REQUEST.get("contacts_more", 0)) # this won't be seen unless contacts_more is positive, # so no worries about the possible negative value contacts_so_far = contacts_more - 1 try: if not settings.GOOGLE_CONTACTS_IMPORT_ENABLED: raise exception.FeatureDisabledError("Google Contacts import is currently disabled") if "lookup_remote_contacts" in request.POST: validate.nonce(request, "lookup_remote_contacts") next_url = util.qsa( util.here(request), { "redirect_to": redirect_to, "upgrade_auth_token": "", "_nonce": util.create_nonce(request.user, "upgrade_auth_token"), }, ) auth_url = google_contacts.auth_sub_url(next_url) return http.HttpResponseRedirect(auth_url) elif "actor_add_contacts" in request.POST: validate.nonce(request, "actor_add_contacts") targets = request.POST.getlist("targets") owner = request.POST.get("owner", "") rv = api.actor_add_contacts(request.user, owner, targets) next_url = util.qsa( util.here(request), {"redirect_to": redirect_to, "contacts_more": contacts_more, "index": start_index, "token": token}, ) return util.RedirectFlash(next_url, "Contacts added.") elif "upgrade_auth_token" in request.GET: validate.nonce(request, "upgrade_auth_token") auth_token = google_contacts.auth_sub_token_from_request(request) session_token = google_contacts.upgrade_to_session_token(auth_token) next_url = util.qsa( util.here(request), { "redirect_to": redirect_to, "fetch_contacts": "", "token": session_token.get_token_string(), "_nonce": util.create_nonce(request.user, "fetch_contacts"), }, ) return http.HttpResponseRedirect(next_url) elif "fetch_contacts" in request.REQUEST: validate.nonce(request, "fetch_contacts") # start_index and max are gathered above session_token = google_contacts.auth_sub_token_from_request(request) # check for the "My Contacts" group, otherwise, fetch it my_contacts = memcache.client.get("%s/my_contacts" % token) if not my_contacts: my_contacts = google_contacts.get_system_group(session_token, "Contacts") memcache.client.set("%s/my_contacts" % token, my_contacts) rv, more = google_contacts.get_contacts_emails(session_token, group=my_contacts, index=start_index, max=max) contacts = [] for name, email in rv: logging.info('looking up "%s" %s', name, email) contacts.append(api.actor_lookup_email(request.user, email)) contacts = [x for x in contacts if x] # for the template contacts_found = True contacts_more = more contacts_so_far = contacts_more - 1 token = session_token.get_token_string() contacts_emails = rv # if no contacts were found and more are available, try some more if not contacts and contacts_more: next_url = util.qsa( util.here(request), { "fetch_contacts": "", "contacts_more": contacts_more, "index": contacts_more, "token": token, "_nonce": util.create_nonce(request.user, "fetch_contacts"), "redirect_to": redirect_to, }, ) # TODO(termie): this can take a really long time, probably not really # viable until we can do it with javascript # return util.MetaRefresh(next_url, message='Still working...', second=1) # return http.HttpResponseRedirect(next_url) except: exception.handle_exception(request) # set the progress welcome_photo = True welcome_mobile = True view = request.user page = "contacts" area = "welcome" c = template.RequestContext(request, locals()) t = loader.get_template("welcome_%s.html" % page) return http.HttpResponse(t.render(c))