from django.core.rss import FeedConfiguration, register_feed from django.views.rss.rss import feed from django.models.auth import users from django.models.tags import tags, destinations, posts import queries class SimplerFeedConfiguration(FeedConfiguration): """Normal `FeedConfiguration` objects are easy to deal with unless your feed needs parameters, in which case things can get a little complicated. `SimplerFeedConfiguration` doesn't add or subtract power, but does rearrange and rename things to make them easier to understand. Limitation: doesn't handle enclosures yet.""" default_generator_parameters = {} slug = None # that'll break nicely def __init__(self): FeedConfiguration.__init__( self, slug = self.slug, title_cb = self.title, link_cb = self.link, description_cb = self.description, get_list_func_cb = self.generator_chooser, get_list_kwargs = self.default_generator_parameters, get_list_kwargs_cb = self.generator_parameters, param_func = self.feed_victim, param_kwargs_cb = self.feed_parameters) def item_generator(self, **kwargs): """This is the default item generator function, which you should either a) over-ride to return a list of items to insert into your feed, or b) bypass by over-riding `generator_chooser` below. `kwargs` -- `default_generator_parameters` updated with the result result of `generator_parameters`.""" return [] def title(self, feed_victim): """Return the feed title.""" return "Title" def description(self, feed_victim): """Return the feed descrition.""" return "Description" def link(self, feed_victim): """Return the feed link.""" return "http://djangoproject.com/" def feed_parameters(self, param): """Convert the feed parameter string into a dictionary of parameters.""" return {} def feed_victim(self, **feed_parameters): """Find the feed victim according to the feed parameters.""" return None def generator_chooser(self, feed_victim): """Choose which item generator function to use based on the result of `feed_victim` below. If you don't over-ride this method, we'll just use `item_generator` above.""" return self.item_generator def generator_parameters(self, feed_victim): """Return a dictionary of keyword arguments for the item generator based on the feed_victim.""" return {} def register(feedclass): """Class method to register this class as a feed configuration. Returns a viewer method you can aim a urlconf at.""" feed = feedclass() register_feed(feed) return feed.view register = classmethod(register) def view(self, request, param=None): """Method to render this feed.""" return feed(request, self.slug, param) class UserFeed(SimplerFeedConfiguration): """A feed for users' postings unqualified by tag.""" slug = 'tags_user' default_generator_parameters = { 'limit': 10 } def feed_parameters(self, param): try: user = users.get_object(username__exact=param) except users.UserDoesNotExist: raise Http404 return { 'username': param } def feed_victim(self, username=None): try: user = users.get_object(username__exact=username) except users.UserDoesNotExist: raise Http404 return user def generator_parameters(self, victim): return { 'id': victim.id } def item_generator(self, limit=None, id=None): all = posts.get_list(user_id__exact=id, order_by=['-posted']) return all[:limit] def description(self, victim): return "The latest postings by %s" % victim.username def title(self, victim): return "tags/%s" % victim.username def link(self, victim): return "/tags/%s" % victim.username user_feed = UserFeed.register() # So if the urlconf points to user_feed, it'll all work nicely.