philo/contrib/winer/models.py

   1 from django.conf import settings
   2 from django.conf.urls.defaults import url, patterns, include
   3 from django.contrib.sites.models import Site, RequestSite
   4 from django.contrib.syndication.views import add_domain
   5 from django.db import models
   6 from django.http import HttpResponse
   7 from django.template import RequestContext, Template as DjangoTemplate
   8 from django.utils import feedgenerator, tzinfo
   9 from django.utils.encoding import smart_unicode, force_unicode
  10 from django.utils.html import escape
  11
  12 from philo.contrib.winer.exceptions import HttpNotAcceptable
  13 from philo.contrib.winer.feeds import registry, DEFAULT_FEED
  14 from philo.contrib.winer.middleware import http_not_acceptable
  15 from philo.models import Page, Template, MultiView
  16
  17 try:
  18         import mimeparse
  19 except:
  20         mimeparse = None
  21
  22
  23 class FeedView(MultiView):
  24         """
  25         :class:`FeedView` is an abstract model which handles a number of pages and related feeds for a single object such as a blog or newsletter. In addition to all other methods and attributes, :class:`FeedView` supports the same generic API as `django.contrib.syndication.views.Feed <http://docs.djangoproject.com/en/dev/ref/contrib/syndication/#django.contrib.syndication.django.contrib.syndication.views.Feed>`_.
  26
  27         """
  28         #: The type of feed which should be served by the :class:`FeedView`.
  29         feed_type = models.CharField(max_length=50, choices=registry.choices, default=registry.get_slug(DEFAULT_FEED))
  30         #: The suffix which will be appended to a page URL for a :attr:`feed_type` feed of its items. Default: "feed". Note that RSS and Atom feeds will always be available at ``<page_url>/rss`` and ``<page_url>/atom`` regardless of the value of this setting.
  31         #:
  32         #: .. seealso:: :meth:`get_feed_type`, :meth:`feed_patterns`
  33         feed_suffix = models.CharField(max_length=255, blank=False, default="feed")
  34         #: A :class:`BooleanField` - whether or not feeds are enabled.
  35         feeds_enabled = models.BooleanField(default=True)
  36         #: A :class:`PositiveIntegerField` - the maximum number of items to return for this feed. All items will be returned if this field is blank. Default: 15.
  37         feed_length = models.PositiveIntegerField(blank=True, null=True, default=15, help_text="The maximum number of items to return for this feed. All items will be returned if this field is blank.")
  38
  39         #: A :class:`ForeignKey` to a :class:`.Template` which will be used to render the title of each item in the feed if provided.
  40         item_title_template = models.ForeignKey(Template, blank=True, null=True, related_name="%(app_label)s_%(class)s_title_related")
  41         #: A :class:`ForeignKey` to a :class:`.Template` which will be used to render the description of each item in the feed if provided.
  42         item_description_template = models.ForeignKey(Template, blank=True, null=True, related_name="%(app_label)s_%(class)s_description_related")
  43
  44         #: An attribute holding the name of the context variable to be populated with the items managed by the :class:`FeedView`. Default: "items"
  45         item_context_var = 'items'
  46         #: An attribute holding the name of the attribute on a subclass of :class:`FeedView` which will contain the main object of a feed (such as a :class:`~philo.contrib.penfield.models.Blog`.) Default: "object"
  47         #:
  48         #: Example::
  49         #:
  50         #:     class BlogView(FeedView):
  51         #:         blog = models.ForeignKey(Blog)
  52         #:
  53         #:         object_attr = 'blog'
  54         #:         item_context_var = 'entries'
  55         object_attr = 'object'
  56
  57         #: An attribute holding a description of the feeds served by the :class:`FeedView`. This is a required part of the :class:`django.contrib.syndication.view.Feed` API.
  58         description = ""
  59
  60         def feed_patterns(self, base, get_items_attr, page_attr, reverse_name):
  61                 """
  62                 Given the name to be used to reverse this view and the names of the attributes for the function that fetches the objects, returns patterns suitable for inclusion in urlpatterns. In addition to ``base`` (which will serve the page at ``page_attr``) and ``base`` + :attr:`feed_suffix` (which will serve a :attr:`feed_type` feed), patterns will be provided for each registered feed type as ``base`` + ``slug``.
  63
  64                 :param base: The base of the returned patterns - that is, the subpath pattern which will reference the page for the items. The :attr:`feed_suffix` will be appended to this subpath.
  65                 :param get_items_attr: A callable or the name of a callable on the :class:`FeedView` which will return an (``items``, ``extra_context``) tuple. This will be passed directly to :meth:`feed_view` and :meth:`page_view`.
  66                 :param page_attr: A :class:`.Page` instance or the name of an attribute on the :class:`FeedView` which contains a :class:`.Page` instance. This will be passed directly to :meth:`page_view` and will be rendered with the items from ``get_items_attr``.
  67                 :param reverse_name: The string which is considered the "name" of the view function returned by :meth:`page_view` for the given parameters.
  68                 :returns: Patterns suitable for use in urlpatterns.
  69
  70                 Example::
  71
  72                         class BlogView(FeedView):
  73                             blog = models.ForeignKey(Blog)
  74                             entry_archive_page = models.ForeignKey(Page)
  75
  76                             @property
  77                             def urlpatterns(self):
  78                                 urlpatterns = self.feed_patterns(r'^', 'get_all_entries', 'index_page', 'index')
  79                                 urlpatterns += self.feed_patterns(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d{2})', 'get_entries_by_ymd', 'entry_archive_page', 'entries_by_day')
  80                                 return urlpatterns
  81
  82                             def get_entries_by_ymd(request, year, month, day, extra_context=None):
  83                                 entries = Blog.entries.all()
  84                                 # filter entries based on the year, month, and day.
  85                                 return entries, extra_context
  86
  87                 .. seealso:: :meth:`get_feed_type`
  88
  89                 """
  90                 feed_patterns = ()
  91                 if self.feeds_enabled:
  92                         suffixes = [(self.feed_suffix, None)] + [(slug, slug) for slug in registry]
  93                         for suffix, feed_type in suffixes:
  94                                 feed_view = http_not_acceptable(self.feed_view(get_items_attr, reverse_name, feed_type))
  95                                 feed_pattern = r'%s%s%s$' % (base, "/" if base and base[-1] != "^" else "", suffix)
  96                                 feed_patterns += (url(feed_pattern, feed_view, name="%s_%s" % (reverse_name, suffix)),)
  97                 feed_patterns += (url(r"%s$" % base, self.page_view(get_items_attr, page_attr), name=reverse_name),)
  98                 return patterns('', *feed_patterns)
  99
 100         def get_object(self, request, **kwargs):
 101                 """By default, returns the object stored in the attribute named by :attr:`object_attr`. This can be overridden for subclasses that publish different data for different URL parameters. It is part of the :class:`django.contrib.syndication.views.Feed` API."""
 102                 return getattr(self, self.object_attr)
 103
 104         def feed_view(self, get_items_attr, reverse_name, feed_type=None):
 105                 """
 106                 Returns a view function that renders a list of items as a feed.
 107
 108                 :param get_items_attr: A callable or the name of a callable on the :class:`FeedView` that will return a (items, extra_context) tuple when called with view arguments.
 109                 :param reverse_name: The name which can be used reverse the page for this feed using the :class:`FeedView` as the urlconf.
 110                 :param feed_type: The slug used to render the feed class which will be used by the returned view function.
 111
 112                 :returns: A view function that renders a list of items as a feed.
 113
 114                 """
 115                 get_items = get_items_attr if callable(get_items_attr) else getattr(self, get_items_attr)
 116
 117                 def inner(request, extra_context=None, *args, **kwargs):
 118                         obj = self.get_object(request, *args, **kwargs)
 119                         feed = self.get_feed(obj, request, reverse_name, feed_type, *args, **kwargs)
 120                         items, xxx = get_items(request, extra_context=extra_context, *args, **kwargs)
 121                         self.populate_feed(feed, items, request)
 122
 123                         response = HttpResponse(mimetype=feed.mime_type)
 124                         feed.write(response, 'utf-8')
 125                         return response
 126
 127                 return inner
 128
 129         def page_view(self, get_items_attr, page_attr):
 130                 """
 131                 :param get_items_attr: A callable or the name of a callable on the :class:`FeedView` that will return a (items, extra_context) tuple when called with view arguments.
 132                 :param page_attr: A :class:`.Page` instance or the name of an attribute on the :class:`FeedView` which contains a :class:`.Page` instance. This will be rendered with the items from ``get_items_attr``.
 133
 134                 :returns: A view function that renders a list of items as an :class:`HttpResponse`.
 135
 136                 """
 137                 get_items = get_items_attr if callable(get_items_attr) else getattr(self, get_items_attr)
 138                 page = page_attr if isinstance(page_attr, Page) else getattr(self, page_attr)
 139
 140                 def inner(request, extra_context=None, *args, **kwargs):
 141                         items, extra_context = get_items(request, extra_context=extra_context, *args, **kwargs)
 142                         items, item_context = self.process_page_items(request, items)
 143
 144                         context = self.get_context()
 145                         context.update(extra_context or {})
 146                         context.update(item_context or {})
 147
 148                         return page.render_to_response(request, extra_context=context)
 149                 return inner
 150
 151         def process_page_items(self, request, items):
 152                 """
 153                 Hook for handling any extra processing of ``items`` based on an :class:`HttpRequest`, such as pagination or searching. This method is expected to return a list of items and a dictionary to be added to the page context.
 154
 155                 """
 156                 item_context = {
 157                         self.item_context_var: items
 158                 }
 159                 return items, item_context
 160
 161         def get_feed_type(self, request, feed_type=None):
 162                 """
 163                 If ``feed_type`` is not ``None``, returns the corresponding class from the registry or raises :exc:`.HttpNotAcceptable`.
 164
 165                 Otherwise, intelligently chooses a feed type for a given request. Tries to return :attr:`feed_type`, but if the Accept header does not include that mimetype, tries to return the best match from the feed types that are offered by the :class:`FeedView`. If none of the offered feed types are accepted by the :class:`HttpRequest`, raises :exc:`.HttpNotAcceptable`.
 166
 167                 If `mimeparse <http://code.google.com/p/mimeparse/>`_ is installed, it will be used to select the best matching accepted format; otherwise, the first available format that is accepted will be selected.
 168
 169                 """
 170                 if feed_type is not None:
 171                         feed_type = registry[feed_type]
 172                         loose = False
 173                 else:
 174                         feed_type = registry.get(self.feed_type, DEFAULT_FEED)
 175                         loose = True
 176                 mt = feed_type.mime_type
 177                 accept = request.META.get('HTTP_ACCEPT')
 178                 if accept and mt not in accept and "*/*" not in accept and "%s/*" % mt.split("/")[0] not in accept:
 179                         # Wups! They aren't accepting the chosen format.
 180                         feed_type = None
 181                         if loose:
 182                                 # Is there another format we can use?
 183                                 accepted_mts = dict([(obj.mime_type, obj) for obj in registry.values()])
 184                                 if mimeparse:
 185                                         mt = mimeparse.best_match(accepted_mts.keys(), accept)
 186                                         if mt:
 187                                                 feed_type = accepted_mts[mt]
 188                                 else:
 189                                         for mt in accepted_mts:
 190                                                 if mt in accept or "%s/*" % mt.split("/")[0] in accept:
 191                                                         feed_type = accepted_mts[mt]
 192                                                         break
 193                         if not feed_type:
 194                                 raise HttpNotAcceptable
 195                 return feed_type
 196
 197         def get_feed(self, obj, request, reverse_name, feed_type=None, *args, **kwargs):
 198                 """
 199                 Returns an unpopulated :class:`django.utils.feedgenerator.DefaultFeed` object for this object.
 200
 201                 :param obj: The object for which the feed should be generated.
 202                 :param request: The current request.
 203                 :param reverse_name: The name which can be used to reverse the URL of the page corresponding to this feed.
 204                 :param feed_type: The slug used to register the feed class that will be instantiated and returned.
 205
 206                 :returns: An instance of the feed class registered as ``feed_type``, falling back to :attr:`feed_type` if ``feed_type`` is ``None``.
 207
 208                 """
 209                 try:
 210                         current_site = Site.objects.get_current()
 211                 except Site.DoesNotExist:
 212                         current_site = RequestSite(request)
 213
 214                 feed_type = self.get_feed_type(request, feed_type)
 215                 node = request.node
 216                 link = node.construct_url(self.reverse(reverse_name, args=args, kwargs=kwargs), with_domain=True, request=request, secure=request.is_secure())
 217
 218                 feed = feed_type(
 219                         title = self.__get_dynamic_attr('title', obj),
 220                         subtitle = self.__get_dynamic_attr('subtitle', obj),
 221                         link = link,
 222                         description = self.__get_dynamic_attr('description', obj),
 223                         language = settings.LANGUAGE_CODE.decode(),
 224                         feed_url = add_domain(
 225                                 current_site.domain,
 226                                 self.__get_dynamic_attr('feed_url', obj) or node.construct_url(self.reverse("%s_%s" % (reverse_name, registry.get_slug(feed_type)), args=args, kwargs=kwargs), with_domain=True, request=request, secure=request.is_secure()),
 227                                 request.is_secure()
 228                         ),
 229                         author_name = self.__get_dynamic_attr('author_name', obj),
 230                         author_link = self.__get_dynamic_attr('author_link', obj),
 231                         author_email = self.__get_dynamic_attr('author_email', obj),
 232                         categories = self.__get_dynamic_attr('categories', obj),
 233                         feed_copyright = self.__get_dynamic_attr('feed_copyright', obj),
 234                         feed_guid = self.__get_dynamic_attr('feed_guid', obj),
 235                         ttl = self.__get_dynamic_attr('ttl', obj),
 236                         **self.feed_extra_kwargs(obj)
 237                 )
 238                 return feed
 239
 240         def populate_feed(self, feed, items, request):
 241                 """Populates a :class:`django.utils.feedgenerator.DefaultFeed` instance as is returned by :meth:`get_feed` with the passed-in ``items``."""
 242                 if self.item_title_template:
 243                         title_template = DjangoTemplate(self.item_title_template.code)
 244                 else:
 245                         title_template = None
 246                 if self.item_description_template:
 247                         description_template = DjangoTemplate(self.item_description_template.code)
 248                 else:
 249                         description_template = None
 250
 251                 node = request.node
 252                 try:
 253                         current_site = Site.objects.get_current()
 254                 except Site.DoesNotExist:
 255                         current_site = RequestSite(request)
 256
 257                 if self.feed_length is not None:
 258                         items = items[:self.feed_length]
 259
 260                 for item in items:
 261                         if title_template is not None:
 262                                 title = title_template.render(RequestContext(request, {'obj': item}))
 263                         else:
 264                                 title = self.__get_dynamic_attr('item_title', item)
 265                         if description_template is not None:
 266                                 description = description_template.render(RequestContext(request, {'obj': item}))
 267                         else:
 268                                 description = self.__get_dynamic_attr('item_description', item)
 269
 270                         link = node.construct_url(self.reverse(obj=item), with_domain=True, request=request, secure=request.is_secure())
 271
 272                         enc = None
 273                         enc_url = self.__get_dynamic_attr('item_enclosure_url', item)
 274                         if enc_url:
 275                                 enc = feedgenerator.Enclosure(
 276                                         url = smart_unicode(add_domain(
 277                                                         current_site.domain,
 278                                                         enc_url,
 279                                                         request.is_secure()
 280                                         )),
 281                                         length = smart_unicode(self.__get_dynamic_attr('item_enclosure_length', item)),
 282                                         mime_type = smart_unicode(self.__get_dynamic_attr('item_enclosure_mime_type', item))
 283                                 )
 284                         author_name = self.__get_dynamic_attr('item_author_name', item)
 285                         if author_name is not None:
 286                                 author_email = self.__get_dynamic_attr('item_author_email', item)
 287                                 author_link = self.__get_dynamic_attr('item_author_link', item)
 288                         else:
 289                                 author_email = author_link = None
 290
 291                         pubdate = self.__get_dynamic_attr('item_pubdate', item)
 292                         if pubdate and not pubdate.tzinfo:
 293                                 ltz = tzinfo.LocalTimezone(pubdate)
 294                                 pubdate = pubdate.replace(tzinfo=ltz)
 295
 296                         feed.add_item(
 297                                 title = title,
 298                                 link = link,
 299                                 description = description,
 300                                 unique_id = self.__get_dynamic_attr('item_guid', item, link),
 301                                 enclosure = enc,
 302                                 pubdate = pubdate,
 303                                 author_name = author_name,
 304                                 author_email = author_email,
 305                                 author_link = author_link,
 306                                 categories = self.__get_dynamic_attr('item_categories', item),
 307                                 item_copyright = self.__get_dynamic_attr('item_copyright', item),
 308                                 **self.item_extra_kwargs(item)
 309                         )
 310
 311         def __get_dynamic_attr(self, attname, obj, default=None):
 312                 try:
 313                         attr = getattr(self, attname)
 314                 except AttributeError:
 315                         return default
 316                 if callable(attr):
 317                         # Check func_code.co_argcount rather than try/excepting the
 318                         # function and catching the TypeError, because something inside
 319                         # the function may raise the TypeError. This technique is more
 320                         # accurate.
 321                         if hasattr(attr, 'func_code'):
 322                                 argcount = attr.func_code.co_argcount
 323                         else:
 324                                 argcount = attr.__call__.func_code.co_argcount
 325                         if argcount == 2: # one argument is 'self'
 326                                 return attr(obj)
 327                         else:
 328                                 return attr()
 329                 return attr
 330
 331         def feed_extra_kwargs(self, obj):
 332                 """Returns an extra keyword arguments dictionary that is used when initializing the feed generator."""
 333                 return {}
 334
 335         def item_extra_kwargs(self, item):
 336                 """Returns an extra keyword arguments dictionary that is used with the `add_item` call of the feed generator."""
 337                 return {}
 338
 339         def item_title(self, item):
 340                 return escape(force_unicode(item))
 341
 342         def item_description(self, item):
 343                 return force_unicode(item)
 344
 345         class Meta:
 346                 abstract=True