def actor_invite(request, nick, format='html'): nick = clean.nick(nick) view = api.actor_get(request.user, nick) if not view: raise exception.UserDoesNotExistError(nick, request.user) if not request.user or view.nick != request.user.nick: # Bounce the user to their own page (avoids any confusion for the wrong # nick in the url). Perhaps unnecessary. return http.HttpResponseRedirect( '%s/invite' % request.user.url()) handled = common_views.handle_view_action( request, { 'invite_request_email': request.path, }) if handled: return handled if request.user and request.user.nick == view.nick: whose = 'Your' else: whose = "%s's" % view.display_nick() c = template.RequestContext(request, locals()) if format == 'html': t = loader.get_template('invite.html') return http.HttpResponse(t.render(c))
def test_login(self): log = 'popular' pwd = self.passwords[clean.nick(log)] r = self.client.post('/login', {'log': log, 'pwd': pwd}) r = self.assertRedirectsPrefix(r, '/user/popular/overview') self.assertTemplateUsed(r, 'overview.html') self.assertTemplateUsed(r, 'flash.html')
def actor_settings_redirect(request): if not request.user: return http.HttpResponseRedirect( '/login?redirect_to=%s' % request.get_full_path()) nick = clean.nick(request.user.nick) view = api.actor_lookup_nick(request.user, nick) return http.HttpResponseRedirect(view.url() + request.get_full_path())
def test_settings_change_avatar(self): nick = 'obligated' self.login(nick) nick = clean.nick(nick) old_avatar = api.actor_get(api.ROOT, nick).extra.get('icon', 'avatar_default') # TODO(teemu): add more tests for different file types (gif and jpg). # Alternatively, test those against api.avatar_upload. r = self.client.post('/user/obligated/settings/photo', { 'avatar': 'default/animal_9', '_nonce' : util.create_nonce('obligated', 'change_photo'), }) r = self.assertRedirectsPrefix(r, '/user/obligated/settings/photo') new_avatar = api.actor_get(api.ROOT, nick).extra.get('icon', 'avatar_default') self.assertNotEquals(old_avatar, new_avatar) self.assertContains(r, 'Avatar changed') self.assertTemplateUsed(r, 'settings_photo.html') self.assertTemplateUsed(r, 'flash.html')
def test_login_with_confirmed_email(self): log = 'hotness' pwd = self.passwords[clean.nick(log)] confirmed_email = '*****@*****.**' r = self.client.post('/login', {'log': confirmed_email, 'pwd': pwd}) r = self.assertRedirectsPrefix(r, '/user/hotness/overview') self.assertTemplateUsed(r, 'overview.html') self.assertTemplateUsed(r, 'flash.html')
def actor_followers(request, nick=None, format='html'): nick = clean.nick(nick) view = api.actor_lookup_nick(request.user, nick) if not view: raise exception.UserDoesNotExistError(nick, request.user) handled = common_views.handle_view_action( request, { 'actor_add_contact': request.path, 'actor_remove_contact': request.path, }) if handled: return handled per_page = CONTACTS_PER_PAGE offset, prev = util.page_offset_nick(request) follower_nicks = api.actor_get_followers(request.user, view.nick, limit=(per_page + 1), offset=offset) actor_nicks = follower_nicks actors = api.actor_get_actors(request.user, actor_nicks) # clear deleted actors actors = dict([(k, v) for k, v in actors.iteritems() if v]) per_page = per_page - (len(follower_nicks) - len(actors)) # TODO(termie): incorporate this into paging so we only fetch the range # on this page # add some extra info so we can let the user do contextual actions # on these homeboys if request.user and request.user.nick == view.nick: for actor in actors: if api.actor_is_contact(request.user, view.nick, actor): actors[actor].my_contact = True whose = 'Your' else: whose = "%s's" % view.display_nick() # here comes lots of munging data into shape actor_tiles = [actors[x] for x in follower_nicks if x in actors] actor_tiles_count = view.extra.get('follower_count', 0) actor_tiles, actor_tiles_more = util.page_actors(request, actor_tiles, per_page) area = 'people' c = template.RequestContext(request, locals()) if format == 'html': t = loader.get_template('followers.html') return http.HttpResponse(t.render(c))
def test_login_deleted(self): log = 'popular' pwd = self.passwords[clean.nick(log)] r = self.client.post('/login', {'log': log, 'pwd': pwd}) r = self.assertRedirectsPrefix(r, '/user/popular/overview') self.assertTemplateUsed(r, 'overview.html') self.assertTemplateUsed(r, 'flash.html') api.actor_remove(api.ROOT, 'popular') r = self.client.post('/login', {'log': log, 'pwd': pwd}) self.assert_error_contains(r, 'Invalid username') self.assertTemplateUsed(r, 'login.html')
def actor_add_contact(self, sender, nick): sender_ref = api.actor_lookup_mobile(api.ROOT, sender) if not sender_ref: raise exception.ValidationError(HELP_SIGN_IN) clean_nick = clean.nick(nick) try: api.actor_add_contact(sender_ref, sender_ref.nick, clean_nick) self.send_message((sender,), "%s followed %s" % (sender_ref.display_nick(), nick)) except: self.send_message((sender,), "Failed to follow %s" % nick)
def actor_remove_contact(self, from_jid, nick): jid_ref = api.actor_lookup_im(api.ROOT, from_jid.base()) if not jid_ref: raise exception.ValidationError( "You must be signed in to post, please SIGN IN") nick = clean.nick(nick) try: api.actor_remove_contact(jid_ref, jid_ref.nick, nick) self.send_message((from_jid,), "%s stopped following %s" % (jid_ref.nick, nick)) except: self.send_message((from_jid,), "Leave FAILED: %s" % nick)
def create_nonce(user, action, offset=0): if not user: nick = "" else: try: nick = user.nick except AttributeError: if settings.MANAGE_PY: # extra case to make testing easier nick = clean.nick(user) else: raise i = math.ceil(time.time() / 43200) i += offset nonce = hash_generic(str(i) + action + nick) return nonce[-12:-2]
def test_login_sso(self): o = util.override( DOMAIN=self.domain, GAE_DOMAIN=self.gae_domain, HOSTED_DOMAIN_ENABLED=True, HOSTED_DOMAIN=self.hosted_domain, SUBDOMAINS_ENABLED=True, SSL_LOGIN_ENABLED=True, ) r = self.post_with_host( "/login", {"log": "popular", "pwd": self.passwords[clean.nick("popular")]}, self.gae_domain, ssl=True ) check_redirect = "http://%s/login/noreally" % self.domain r = self.assertRedirectsPrefix(r, check_redirect, status_code=302, target_status_code=302) r = self.assertRedirectsPrefix(r, "/user/popular/overview", status_code=302, target_status_code=200) o.reset()
def add_comment(self, sender, nick, message): sender_ref = api.actor_lookup_mobile(api.ROOT, sender) if not sender_ref: raise exception.ValidationError(HELP_SIGN_IN) logging.debug("comment: %s %s %s", nick, sender_ref.nick, message) nick = clean.nick(nick) stream_entry = api.reply_get_cache(sender=nick, target=sender_ref.nick, service='sms') if not stream_entry: # Well, or memcache timed it out... Or we crashed... Or... Or... raise exception.ValidationError( 'The message to which you tried to respond doesn\'t exist') api.entry_add_comment(sender_ref, entry=stream_entry.keyname(), content=message, nick=sender_ref.nick, stream=stream_entry.stream)
def add_comment(self, from_jid, nick, message): jid_ref = api.actor_lookup_im(api.ROOT, from_jid.base()) if not jid_ref: raise exception.ValidationError( "You must be signed in to post, please SIGN IN") logging.debug("comment: %s %s %s", nick, jid_ref.nick, message) nick = clean.nick(nick) stream_entry = api.reply_get_cache(sender=nick, target=jid_ref.nick, service='im') if not stream_entry: # Well, or memcache timed it out... Or we crashed... Or... Or... raise exception.ValidationError( 'The message to which you tried to respond doesn\'t exist') api.entry_add_comment(jid_ref, entry=stream_entry.keyname(), content=message, nick=jid_ref.nick, stream=stream_entry.stream)
def test_settings_upload_avatar(self): nick = 'obligated' self.login(nick) nick = clean.nick(nick) old_contact_avatars = api.actor_get_contacts_avatars_since(api.ROOT, nick) contacts = api.actor_get_contacts(api.ROOT, nick) self.assertEquals(len(old_contact_avatars), len(contacts) + 1) old_avatar = api.actor_get(api.ROOT, nick).extra.get('icon', 'avatar_default') start_time = api.utcnow() no_contact_avatars = api.actor_get_contacts_avatars_since(api.ROOT, nick, since_time=start_time) self.assertEquals(len(no_contact_avatars), 0) # TODO(teemu): add more tests for different file types (gif and jpg). # Alternatively, test those against api.avatar_upload. f = open('testdata/test_avatar.jpg') r = self.client.post('/user/obligated/settings/photo', { 'imgfile': f, '_nonce' : util.create_nonce('obligated', 'change_photo'), }) r = self.assertRedirectsPrefix(r, '/user/obligated/settings/photo') actor_ref = api.actor_get(api.ROOT, nick) new_avatar = actor_ref.extra.get('icon', 'avatar_default') self.assertNotEquals(old_avatar, new_avatar) self.assertTrue(actor_ref.avatar_updated_at >= start_time) new_contact_avatars = api.actor_get_contacts_avatars_since(api.ROOT, nick, since_time=start_time) self.assertEquals(len(new_contact_avatars), 1) self.assertEquals(new_contact_avatars.pop().nick, nick) self.assertContains(r, 'Avatar uploaded') self.assertTemplateUsed(r, 'settings_photo.html') self.assertTemplateUsed(r, 'flash.html')
def test_photo_upload(self): nick = 'popular' nick = clean.nick(nick) old_avatar = api.actor_get(api.ROOT, nick).extra.get('icon', 'avatar_default') self.login(nick) f = open('testdata/test_avatar.jpg') r = self.client.post('/welcome/1', { 'imgfile': f, '_nonce' : util.create_nonce('popular', 'change_photo'), }) r = self.assertRedirectsPrefix(r, '/welcome/1?') new_avatar = api.actor_get(api.ROOT, nick).extra.get('icon', 'avatar_default') self.assertNotEquals(old_avatar, new_avatar) self.assertContains(r, 'Avatar uploaded') self.assertTemplateUsed(r, 'welcome_photo.html') self.assertTemplateUsed(r, 'flash.html')
def test_login_user_cleanup(self): log = 'broken' pwd = self.passwords[clean.nick(log)] actor_ref_pre = api.actor_get(api.ROOT, log) self.assert_(not actor_ref_pre.normalized_nick) self.assertRaises(exception.ApiException, api.stream_get_presence, api.ROOT, log) self.assertRaises(exception.ApiException, api.stream_get_comment, api.ROOT, log) r = self.client.post('/login', {'log': log, 'pwd': pwd}) r = self.assertRedirectsPrefix(r, '/user/broken/overview') actor_ref_post = api.actor_get(api.ROOT, log) self.assert_(actor_ref_post.normalized_nick) self.assert_(api.stream_get_presence(api.ROOT, log)) self.assert_(api.stream_get_comment(api.ROOT, log))
def actor_overview(request, nick, format='html'): nick = clean.nick(nick) view = api.actor_lookup_nick(request.user, nick) if not view: raise exception.UserDoesNotExistError(nick, request.user) if not request.user or view.nick != request.user.nick: # Instead of displaying the overview, redirect to the public-facing page return http.HttpResponseRedirect(view.url()) handled = common_views.handle_view_action( request, { 'entry_remove': request.path, 'entry_remove_comment': request.path, 'entry_mark_as_spam': request.path, 'presence_set': request.path, 'settings_hide_comments': request.path, 'post': request.path, } ) if handled: return handled per_page = ENTRIES_PER_PAGE offset, prev = util.page_offset(request) inbox = api.inbox_get_actor_overview(request.user, view.nick, limit=(per_page + 1), offset=offset) # START inbox generation chaos # TODO(termie): refacccttttooorrrrr entries = api.entry_get_entries(request.user, inbox) if view.extra.get('comments_hide', 0): # TODO(tyler): This is certainly not the most eloquent way to filter # through entries to remove comments. entries = [x for x in entries if not x.stream.endswith('comments')] per_page = per_page - (len(inbox) - len(entries)) entries, more = util.page_entries(request, entries, per_page) stream_keys = [e.stream for e in entries] actor_streams = api.stream_get_actor(request.user, view.nick) stream_keys += [s.key().name() for s in actor_streams] streams = api.stream_get_streams(request.user, stream_keys) contact_nicks = api.actor_get_contacts(request.user, view.nick, limit=CONTACTS_PER_PAGE) actor_nicks = (contact_nicks + [view.nick] + [s.owner for s in streams.values()] + [e.owner for e in entries] + [e.actor for e in entries]) actors = api.actor_get_actors(request.user, actor_nicks) # here comes lots of munging data into shape # clear deleted contacts contacts = [actors[x] for x in contact_nicks if actors[x]] streams = display.prep_stream_dict(streams, actors) entries = display.prep_entry_list(entries, streams, actors) # END inbox generation chaos # Check for unconfirmed emails unconfirmeds = api.activation_get_actor_email(request.user, view.nick) if unconfirmeds: unconfirmed_email = unconfirmeds[0].content # If not logged in, cannot write is_owner = False try: is_owner = view.nick == request.user.nick except: pass presence = api.presence_get(request.user, view.nick) # for sidebar streams view_streams = dict([(x.key().name(), streams[x.key().name()]) for x in actor_streams]) # for sidebar_contacts contacts_count = view.extra.get('contact_count', 0) contacts_more = contacts_count > CONTACTS_PER_PAGE # Config for the template green_top = True sidebar_green_top = True selectable_icons = display.SELECTABLE_ICONS area = 'home' # TODO(tyler/termie): This conflicts with the global settings import. # Also, this seems fishy. Do none of the settings.* items work in templates? import settings c = template.RequestContext(request, locals()) if format == 'html': t = loader.get_template('overview.html') return http.HttpResponse(t.render(c)) elif format == 'json': t = loader.get_template('overview.json') r = util.HttpJsonResponse(t.render(c), request) return r elif format == 'atom': t = loader.get_template('overview.atom') r = util.HttpAtomResponse(t.render(c), request) return r elif format == 'rss': t = loader.get_template('overview.rss') r = util.HttpRssResponse(t.render(c), request) return r
def sign_in(self, from_jid, nick, password=None): if not password: password = self.passwords[clean.nick(nick)] message = 'SIGN IN %s %s' % (nick, password) return self.send(from_jid, message)
def actor_item(request, nick=None, item=None, format='html'): # The nick passed in the url looks ugly with the escaped @ in it and is # generally just shorter if we only use the lead part of the nick # however the entire system expects full nicks so we should expand this # as soon as possible nick = clean.nick(nick) # Most pages have the concept of a viewer and an actor being viewed, # in all cases the viewer is `request.user` and the actor being viewed # should be named `view` view = api.actor_lookup_nick(request.user, nick) if not view: raise exception.UserDoesNotExistError(nick, request.user) # With very few exceptions, whenever we are referring to a an # instance that is an entity from the datastore we append `_ref` # to the variable name to distinguish it from the variable that # is simply a string identifier. # In the code below `stream_ref` and `entry_ref` are both entity # references, while `entry` is simply the string key_name of an entry stream_ref = api.stream_get_presence(request.user, view.nick) if not stream_ref: raise http.Http404() if item == 'last': entry_ref = api.entry_get_last(request.user, stream_ref.keyname()) return http.HttpResponseRedirect(entry_ref.url()) else: entry = '%s/%s' % (stream_ref.key().name(), item) entry_ref = api.entry_get_safe(request.user, entry) # Most api calls will return None if the entity being looked up does # not exist so we usually want to verify the return values if not entry_ref: raise http.Http404() # When handling user actions the following pattern more or less applies # if 'parameter_unique_to_action' in request.(POST|GET|REQUEST): # try: # validate.nonce(request, 'nonce_action') # validate.anything_else_that_is_related_to_ui_rather_than_call() # # local_variable = request.(POST|GET|REQUEST).get('request_arg') # # or # params = util.query_dict_to_keywords(request.(POST|GET|REQUEST)) # # # Our goal is to have most of the logic for any action translate # # directly into an api call on behalf of the requesting user # # such that the api call is responsible for validating all input # # and raising any applicable errors # result = api.some_api_method(request.user, # method_variable=local_variable, # ...) # # or # result = api.some_api_method(request.user, **params) # # # All actions should issue a redirect with a success message # return util.RedirectFlash('some_url', 'some success message') # except: # exception.handle_exception(request) # # When an exception occurs we expect the rest of the page to be able # to be processed normally as if no action had been taken, the error # handling section of the template should display the errors caught # by the exception.handle_exception() call handled = common_views.handle_view_action( request, {'entry_add_comment': entry_ref.url(), 'entry_remove': view.url(), 'entry_remove_comment': entry_ref.url(), 'entry_mark_as_spam': entry_ref.url() } ) if handled: return handled comments = api.entry_get_comments(request.user, entry_ref.key().name()) # To minimize the number of lookups to the datastore once we know # all the data we will be displaying on a page we attempt to make # a list of all the actors associated with that data so that we can # fetch them all at once actor_nicks = [entry_ref.owner, entry_ref.actor] + [c.actor for c in comments] actors = api.actor_get_actors(request.user, actor_nicks) # Due to restrictions on Django's templating language most of the time # we will have to take an additional step of preparing all of our data # for display, this usually translates to attaching references to # actor or stream entities. # Functions that handle this preparation should be added to the # common.display module entry = display.prep_entry(entry_ref, {stream_ref.key().name(): stream_ref}, actors) comments = display.prep_comment_list(comments, actors) # Additionally, to minimize more logic in the templates some variables # can be defined to configure the output, these are usually template specific # though some are common variables for anything that inherits from the # base templates green_top = True sidebar_green_top = True # The quickest way to make sure we are getting all of the things we care # about passed to the template without the temptation of making last minute # changes is just to pass `locals()` to the template context c = template.RequestContext(request, locals()) # Ideally this is all that should be necessary to add additional output # formats, in practice it is yet to be seen whether additional data # preparation will be necessary before outputting in JSON or ATOM formats if format == 'html': # We always use the full path to the template to prevent naming conflicts # and difficult searches. t = loader.get_template('item.html') return http.HttpResponse(t.render(c)) elif format == 'json': t = loader.get_template('item.json') r = http.HttpResponse(t.render(c)) r['Content-type'] = 'text/javascript' return r
def actor_history(request, nick=None, format='html'): nick = clean.nick(nick) view = api.actor_lookup_nick(request.user, nick) if not view: raise exception.UserDoesNotExistError(nick, request.user) called_subscribe, sub_ref = common_views.call_api_from_request( request, 'subscription_request') if called_subscribe: if sub_ref.state == 'subscribed': message = 'Subscribed.' else: message = 'Subscription requested.' return util.RedirectFlash(view.url(), message) handled = common_views.handle_view_action( request, { 'entry_remove': request.path, 'entry_remove_comment': request.path, 'entry_mark_as_spam': request.path, 'subscription_remove': view.url(), 'actor_add_contact': request.path, 'actor_remove_contact': request.path, 'post': request.path, 'presence_set': request.path, } ) if handled: return handled privacy = 'public' if request.user: if view.nick == request.user.nick: privacy = 'private' # ROOT because we care whether or not request.user is a contact of # the view user's, not whether the request.user can see the contacts elif api.actor_has_contact(api.ROOT, view.nick, request.user.nick): privacy = 'contacts' # we're going to hide a bunch of stuff if this user is private and we # aren't allowed to see user_is_private = False if view.privacy < models.PRIVACY_PUBLIC and privacy == 'public': user_is_private = True per_page = ENTRIES_PER_PAGE offset, prev = util.page_offset(request) if privacy == 'public': if user_is_private: inbox = [] else: inbox = api.inbox_get_actor_public(request.user, view.nick, limit=(per_page + 1), offset=offset) elif privacy == 'contacts': inbox = api.inbox_get_actor_contacts(request.user, view.nick, limit=(per_page + 1), offset=offset) elif privacy == 'private': inbox = api.inbox_get_actor_private(request.user, view.nick, limit=(per_page + 1), offset=offset) # START inbox generation chaos # TODO(termie): refacccttttooorrrrr entries = api.entry_get_entries(request.user, inbox) per_page = per_page - (len(inbox) - len(entries)) entries, more = util.page_entries(request, entries, per_page) stream_keys = [e.stream for e in entries] try: actor_streams = api.stream_get_actor(request.user, view.nick) except exception.ApiException: actor_streams = [] stream_keys += [s.key().name() for s in actor_streams] streams = api.stream_get_streams(request.user, stream_keys) try: contact_nicks = api.actor_get_contacts(request.user, view.nick, limit=CONTACTS_PER_PAGE) except exception.ApiException: contact_nicks = [] actor_nicks = (contact_nicks + [view.nick] + [s.owner for s in streams.values()] + [e.owner for e in entries] + [e.actor for e in entries]) actors = api.actor_get_actors(request.user, actor_nicks) # here comes lots of munging data into shape contacts = [actors[x] for x in contact_nicks if actors[x]] streams = display.prep_stream_dict(streams, actors) entries = display.prep_entry_list(entries, streams, actors) # END inbox generation chaos # If not logged in, cannot write is_owner = request.user and view.nick == request.user.nick try: presence = api.presence_get(request.user, view.nick) presence_stream = api.stream_get_presence(request.user, view.nick) last_entry = api.entry_get_last(request.user, presence_stream.keyname()) view.last_entry = last_entry except exception.ApiException: pass # for add/remove contact if request.user: user_is_contact = api.actor_has_contact(request.user, request.user.nick, view.nick) view.my_contact = user_is_contact else: user_is_contact = False # for sidebar streams view_streams = dict([(x.key().name(), streams[x.key().name()]) for x in actor_streams]) if request.user: # un/subscribe buttons are possible only, when logged in # TODO(termie): what if there are quite a lot of streams? for stream in view_streams.values(): stream.subscribed = api.subscription_exists( request.user, stream.key().name(), 'inbox/%s/overview' % request.user.nick ) # for sidebar_contacts contacts_count = view.extra.get('contact_count', 0) contacts_more = contacts_count > CONTACTS_PER_PAGE # Config for the template green_top = True sidebar_green_top = True selectable_icons = display.SELECTABLE_ICONS area = 'user' c = template.RequestContext(request, locals()) if format == 'html': t = loader.get_template('history.html') return http.HttpResponse(t.render(c)) elif format == 'json': t = loader.get_template('history.json') r = util.HttpJsonResponse(t.render(c), request) return r elif format == 'atom': t = loader.get_template('history.atom') r = util.HttpAtomResponse(t.render(c), request) return r elif format == 'rss': t = loader.get_template('history.rss') r = util.HttpRssResponse(t.render(c), request) return r
def actor_settings(request, nick, page='index'): """ just a static page that links to the rest""" nick = clean.nick(nick) view = api.actor_lookup_nick(api.ROOT, nick) handled = common_views.handle_view_action( request, { 'activation_activate_mobile': view.url('/settings/mobile'), 'activation_request_email': view.url('/settings/email'), 'activation_request_mobile': view.url('/settings/mobile'), 'settings_change_notify': view.url('/settings/notifications'), 'settings_change_privacy': request.path, 'settings_update_account': view.url('/settings/profile'), 'actor_remove': '/logout', #'oauth_remove_consumer': request.path, #'oauth_remove_access_token': request.path } ) if handled: return handled # TODO(tyler/termie): This conflicts with the global settings import. # Also, this seems fishy. Do none of the settings.* items work in templates? import settings # TODO(tyler): Merge this into handle_view_action, if possible if 'password' in request.POST: try: validate.nonce(request, 'change_password') password = request.POST.get('password', '') confirm = request.POST.get('confirm', '') validate.password_and_confirm(password, confirm, field = 'password') api.settings_change_password(request.user, nick, password) response = util.RedirectFlash(view.url() + '/settings/password', 'password updated') request.user.password = password # TODO(mikie): change when cookie-auth is changed user.set_user_cookie(response, request.user) return response except: exception.handle_exception(request) if page == 'feeds': try: if not settings.FEEDS_ENABLED: raise exception.DisabledFeatureError('Feeds are currently disabled') except: exception.handle_exception(request) if page == 'photo': redirect_to = view.url() + '/settings/photo' handled = common_views.common_photo_upload(request, redirect_to) if handled: return handled area = 'settings' full_page = page.capitalize() if page == 'mobile': full_page = 'Mobile Number' mobile = api.mobile_get_actor(request.user, request.user.nick) sms_notify = view.extra.get('sms_notify', False) elif page == 'im': full_page = 'IM Address' im_address = api.im_get_actor(request.user, view.nick) im_notify = view.extra.get('im_notify', False) elif page == 'index': email = api.email_get_actor(request.user, view.nick) email_notify = view.extra.get('email_notify', False) im_address = api.im_get_actor(request.user, view.nick) im_notify = view.extra.get('im_notify', False) elif page == 'feeds': full_page = 'Web Feeds' elif page == 'email': full_page = 'Email Address' email_notify = view.extra.get('email_notify', False) # check if we already have an email email = api.email_get_actor(request.user, view.nick) # otherwise look for an unconfirmed one if not email: unconfirmeds = api.activation_get_actor_email(api.ROOT, view.nick) if unconfirmeds: unconfirmed_email = unconfirmeds[0].content elif page == 'design': handled = common_views.common_design_update(request, nick) if handled: return handled full_page = 'Look and Feel' elif page == 'notifications': email = api.email_get_actor(request.user, view.nick) email_notify = view.extra.get('email_notify', False) im_address = api.im_get_actor(request.user, view.nick) im_notify = view.extra.get('im_notify', False) mobile = api.mobile_get_actor(request.user, request.user.nick) sms_notify = view.extra.get('sms_notify', False) sms_confirm = sms_notify and not view.extra.get('sms_confirmed', False) # TODO(termie): remove this once we can actually receive sms sms_confirm = False elif page == 'profile': # check if we already have an email email = api.email_get_actor(request.user, view.nick) # otherwise look for an unconfirmed one if not email: unconfirmeds = api.activation_get_actor_email(api.ROOT, view.nick) if unconfirmeds: unconfirmed_email = unconfirmeds[0].content elif page == 'photo': avatars = display.DEFAULT_AVATARS small_photos = api.image_get_all_keys(request.user, view.nick, size='f') # TODO(tyler): Fix this avatar nonsense! own_photos = [{ 'path' : small_photo.key().name(), 'name' : small_photo.key().name()[len('image/'):-len('_f.jpg')], } for small_photo in small_photos ] elif page == 'privacy': PRIVACY_PUBLIC = api.PRIVACY_PUBLIC PRIVACY_CONTACTS = api.PRIVACY_CONTACTS elif page == 'jsbadge': full_page = 'Javascript Badges' elif page == 'badge': badges = [{'id': 'badge-stream', 'width': '200', 'height': '300', 'src': '%sglobal/themes/%s/badge.swf' % (settings.MEDIA_URL, settings.DEFAULT_THEME), 'title': 'Stream', }, {'id': 'badge-map', 'width': '200', 'height': '255', 'src': '%sglobal/themes/%s/badge-map.swf' % (settings.MEDIA_URL, settings.DEFAULT_THEME), 'title': 'Map', }, {'id': 'badge-simple', 'width': '200', 'height': '200', 'src': '%sglobal/themes/%s/badge-simple.swf' % (settings.MEDIA_URL, settings.DEFAULT_THEME), 'title': 'Simple', }, ] elif page in ['password', 'delete']: # Catch for remaining pages before we generate a 404. pass else: return common_views.common_404(request) # rendering c = template.RequestContext(request, locals()) t = loader.get_template('settings_%s.html' % page) return http.HttpResponse(t.render(c))
def sign_in(self, nick, sender=None): password = self.passwords[clean.nick(nick)] r = self.receive("SIGN IN %s %s" % (nick, password), sender=sender) return r
def test_sign_in(self): nick = "popular" password = self.passwords[clean.nick(nick)] r = self.receive("SIGN IN %s %s" % (nick, password)) self.assertOutboxContains(r, "Welcome to %s SMS %s" % (settings.SITE_NAME, nick))