Ticket #329: SimplerFeedConfiguration.txt

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.