philo/contrib/penfield/models.py

   1 from datetime import date, datetime
   2
   3 from django.conf import settings
   4 from django.conf.urls.defaults import url, patterns, include
   5 from django.db import models
   6 from django.http import Http404, HttpResponse
   7 from taggit.managers import TaggableManager
   8
   9 from philo.contrib.winer.models import FeedView
  10 from philo.exceptions import ViewCanNotProvideSubpath
  11 from philo.models import Entity, Page, register_value_model
  12 from philo.models.fields import TemplateField
  13 from philo.utils import paginate
  14
  15
  16 class Blog(Entity):
  17         """Represents a blog which can be posted to."""
  18         #: The name of the :class:`Blog`, currently called 'title' for historical reasons.
  19         title = models.CharField(max_length=255)
  20
  21         #: A slug used to identify the :class:`Blog`.
  22         slug = models.SlugField(max_length=255)
  23
  24         def __unicode__(self):
  25                 return self.title
  26
  27         @property
  28         def entry_tags(self):
  29                 """Returns a :class:`QuerySet` of :class:`.Tag`\ s that are used on any entries in this blog."""
  30                 return Tag.objects.filter(blogentries__blog=self).distinct()
  31
  32         @property
  33         def entry_dates(self):
  34                 """Returns a dictionary of date :class:`QuerySet`\ s for years, months, and days for which there are entries."""
  35                 dates = {'year': self.entries.dates('date', 'year', order='DESC'), 'month': self.entries.dates('date', 'month', order='DESC'), 'day': self.entries.dates('date', 'day', order='DESC')}
  36                 return dates
  37
  38
  39 register_value_model(Blog)
  40
  41
  42 class BlogEntry(Entity):
  43         """Represents an entry in a :class:`Blog`."""
  44         #: The title of the :class:`BlogEntry`.
  45         title = models.CharField(max_length=255)
  46
  47         #: A slug which identifies the :class:`BlogEntry`.
  48         slug = models.SlugField(max_length=255)
  49
  50         #: The :class:`Blog` which this entry has been posted to. Can be left blank to represent a "draft" status.
  51         blog = models.ForeignKey(Blog, related_name='entries', blank=True, null=True)
  52
  53         #: A :class:`ForeignKey` to the author. The model is either :setting:`PHILO_PERSON_MODULE` or :class:`auth.User`.
  54         author = models.ForeignKey(getattr(settings, 'PHILO_PERSON_MODULE', 'auth.User'), related_name='blogentries')
  55
  56         #: The date and time which the :class:`BlogEntry` is considered posted at.
  57         date = models.DateTimeField(default=None)
  58
  59         #: The content of the :class:`BlogEntry`.
  60         content = models.TextField()
  61
  62         #: An optional brief excerpt from the :class:`BlogEntry`.
  63         excerpt = models.TextField(blank=True, null=True)
  64
  65         #: A ``django-taggit`` :class:`TaggableManager`.
  66         tags = TaggableManager()
  67
  68         def save(self, *args, **kwargs):
  69                 if self.date is None:
  70                         self.date = datetime.now()
  71                 super(BlogEntry, self).save(*args, **kwargs)
  72
  73         def __unicode__(self):
  74                 return self.title
  75
  76         class Meta:
  77                 ordering = ['-date']
  78                 verbose_name_plural = "blog entries"
  79                 get_latest_by = "date"
  80
  81
  82 register_value_model(BlogEntry)
  83
  84
  85 class BlogView(FeedView):
  86         """
  87         A subclass of :class:`.FeedView` which handles patterns and feeds for a :class:`Blog` and its related :class:`entries <BlogEntry>`.
  88
  89         """
  90         ENTRY_PERMALINK_STYLE_CHOICES = (
  91                 ('D', 'Year, month, and day'),
  92                 ('M', 'Year and month'),
  93                 ('Y', 'Year'),
  94                 ('B', 'Custom base'),
  95                 ('N', 'No base')
  96         )
  97
  98         #: The :class:`Blog` whose entries should be managed by this :class:`BlogView`
  99         blog = models.ForeignKey(Blog, related_name='blogviews')
 100
 101         #: The main page of the :class:`Blog` will be rendered with this :class:`.Page`.
 102         index_page = models.ForeignKey(Page, related_name='blog_index_related')
 103         #: The detail view of a :class:`BlogEntry` will be rendered with this :class:`Page`.
 104         entry_page = models.ForeignKey(Page, related_name='blog_entry_related')
 105         # TODO: entry_archive is misleading. Rename to ymd_page or timespan_page.
 106         #: Views of :class:`BlogEntry` archives will be rendered with this :class:`Page` (optional).
 107         entry_archive_page = models.ForeignKey(Page, related_name='blog_entry_archive_related', null=True, blank=True)
 108         #: Views of :class:`BlogEntry` archives according to their :class:`.Tag`\ s will be rendered with this :class:`Page`.
 109         tag_page = models.ForeignKey(Page, related_name='blog_tag_related')
 110         #: The archive of all available tags will be rendered with this :class:`Page` (optional).
 111         tag_archive_page = models.ForeignKey(Page, related_name='blog_tag_archive_related', null=True, blank=True)
 112         #: This number will be passed directly into pagination for :class:`BlogEntry` list pages. Pagination will be disabled if this is left blank.
 113         entries_per_page = models.IntegerField(blank=True, null=True)
 114
 115         #: Depending on the needs of the site, different permalink styles may be appropriate. Example subpaths are provided for a :class:`BlogEntry` posted on May 2nd, 2011 with a slug of "hello". The choices are:
 116         #:
 117         #:      * Year, month, and day - ``2011/05/02/hello``
 118         #:      * Year and month - ``2011/05/hello``
 119         #:      * Year - ``2011/hello``
 120         #:      * Custom base - :attr:`entry_permalink_base`\ ``/hello``
 121         #:      * No base - ``hello``
 122         entry_permalink_style = models.CharField(max_length=1, choices=ENTRY_PERMALINK_STYLE_CHOICES)
 123         #: If the :attr:`entry_permalink_style` is set to "Custom base" then the value of this field will be used as the base subpath for year/month/day entry archive pages and entry detail pages. Default: "entries"
 124         entry_permalink_base = models.CharField(max_length=255, blank=False, default='entries')
 125         #: This will be used as the base for the views of :attr:`tag_page` and :attr:`tag_archive_page`. Default: "tags"
 126         tag_permalink_base = models.CharField(max_length=255, blank=False, default='tags')
 127
 128         item_context_var = 'entries'
 129         object_attr = 'blog'
 130
 131         def __unicode__(self):
 132                 return u'BlogView for %s' % self.blog.title
 133
 134         def get_reverse_params(self, obj):
 135                 if isinstance(obj, BlogEntry):
 136                         if obj.blog_id == self.blog_id:
 137                                 kwargs = {'slug': obj.slug}
 138                                 if self.entry_permalink_style in 'DMY':
 139                                         kwargs.update({'year': str(obj.date.year).zfill(4)})
 140                                         if self.entry_permalink_style in 'DM':
 141                                                 kwargs.update({'month': str(obj.date.month).zfill(2)})
 142                                                 if self.entry_permalink_style == 'D':
 143                                                         kwargs.update({'day': str(obj.date.day).zfill(2)})
 144                                 return self.entry_view, [], kwargs
 145                 elif isinstance(obj, Tag) or (isinstance(obj, models.query.QuerySet) and obj.model == Tag and obj):
 146                         if isinstance(obj, Tag):
 147                                 obj = [obj]
 148                         slugs = [tag.slug for tag in obj if tag in self.get_tag_queryset(self.blog)]
 149                         if slugs:
 150                                 return 'entries_by_tag', [], {'tag_slugs': "/".join(slugs)}
 151                 elif isinstance(obj, (date, datetime)):
 152                         kwargs = {
 153                                 'year': str(obj.year).zfill(4),
 154                                 'month': str(obj.month).zfill(2),
 155                                 'day': str(obj.day).zfill(2)
 156                         }
 157                         return 'entries_by_day', [], kwargs
 158                 raise ViewCanNotProvideSubpath
 159
 160         @property
 161         def urlpatterns(self):
 162                 urlpatterns = self.feed_patterns(r'^', 'get_all_entries', 'index_page', 'index') +\
 163                         self.feed_patterns(r'^%s/(?P<tag_slugs>[-\w]+[-+/\w]*)' % self.tag_permalink_base, 'get_entries_by_tag', 'tag_page', 'entries_by_tag')
 164
 165                 if self.tag_archive_page_id:
 166                         urlpatterns += patterns('',
 167                                 url((r'^%s$' % self.tag_permalink_base), self.tag_archive_view, name='tag_archive')
 168                         )
 169
 170                 if self.entry_archive_page_id:
 171                         if self.entry_permalink_style in 'DMY':
 172                                 urlpatterns += self.feed_patterns(r'^(?P<year>\d{4})', 'get_entries_by_ymd', 'entry_archive_page', 'entries_by_year')
 173                                 if self.entry_permalink_style in 'DM':
 174                                         urlpatterns += self.feed_patterns(r'^(?P<year>\d{4})/(?P<month>\d{2})', 'get_entries_by_ymd', 'entry_archive_page', 'entries_by_month')
 175                                         if self.entry_permalink_style == 'D':
 176                                                 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')
 177
 178                 if self.entry_permalink_style == 'D':
 179                         urlpatterns += patterns('',
 180                                 url(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d{2})/(?P<slug>[-\w]+)$', self.entry_view)
 181                         )
 182                 elif self.entry_permalink_style == 'M':
 183                         urlpatterns += patterns('',
 184                                 url(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<slug>[-\w]+)$', self.entry_view)
 185                         )
 186                 elif self.entry_permalink_style == 'Y':
 187                         urlpatterns += patterns('',
 188                                 url(r'^(?P<year>\d{4})/(?P<slug>[-\w]+)$', self.entry_view)
 189                         )
 190                 elif self.entry_permalink_style == 'B':
 191                         urlpatterns += patterns('',
 192                                 url((r'^%s/(?P<slug>[-\w]+)$' % self.entry_permalink_base), self.entry_view)
 193                         )
 194                 else:
 195                         urlpatterns += patterns('',
 196                                 url(r'^(?P<slug>[-\w]+)$', self.entry_view)
 197                         )
 198                 return urlpatterns
 199
 200         def get_context(self):
 201                 return {'blog': self.blog}
 202
 203         def get_entry_queryset(self, obj):
 204                 """Returns the default :class:`QuerySet` of :class:`BlogEntry` instances for the :class:`BlogView` - all entries that are considered posted in the past. This allows for scheduled posting of entries."""
 205                 return obj.entries.filter(date__lte=datetime.now())
 206
 207         def get_tag_queryset(self, obj):
 208                 """Returns the default :class:`QuerySet` of :class:`.Tag`\ s for the :class:`BlogView`'s :meth:`get_entries_by_tag` and :meth:`tag_archive_view`."""
 209                 return obj.entry_tags
 210
 211         def get_all_entries(self, obj, request, extra_context=None):
 212                 """Used to generate :meth:`~.FeedView.feed_patterns` for all entries."""
 213                 return self.get_entry_queryset(obj), extra_context
 214
 215         def get_entries_by_ymd(self, obj, request, year=None, month=None, day=None, extra_context=None):
 216                 """Used to generate :meth:`~.FeedView.feed_patterns` for entries with a specific year, month, and day."""
 217                 if not self.entry_archive_page:
 218                         raise Http404
 219                 entries = self.get_entry_queryset(obj)
 220                 if year:
 221                         entries = entries.filter(date__year=year)
 222                 if month:
 223                         entries = entries.filter(date__month=month)
 224                 if day:
 225                         entries = entries.filter(date__day=day)
 226
 227                 context = extra_context or {}
 228                 context.update({'year': year, 'month': month, 'day': day})
 229                 return entries, context
 230
 231         def get_entries_by_tag(self, obj, request, tag_slugs, extra_context=None):
 232                 """Used to generate :meth:`~.FeedView.feed_patterns` for entries with all of the given tags."""
 233                 tag_slugs = tag_slugs.replace('+', '/').split('/')
 234                 tags = self.get_tag_queryset(obj).filter(slug__in=tag_slugs)
 235
 236                 if not tags:
 237                         raise Http404
 238
 239                 # Raise a 404 on an incorrect slug.
 240                 found_slugs = [tag.slug for tag in tags]
 241                 for slug in tag_slugs:
 242                         if slug and slug not in found_slugs:
 243                                 raise Http404
 244
 245                 entries = self.get_entry_queryset(obj)
 246                 for tag in tags:
 247                         entries = entries.filter(tags=tag)
 248
 249                 context = extra_context or {}
 250                 context.update({'tags': tags})
 251
 252                 return entries, context
 253
 254         def entry_view(self, request, slug, year=None, month=None, day=None, extra_context=None):
 255                 """Renders :attr:`entry_page` with the entry specified by the given parameters."""
 256                 entries = self.get_entry_queryset(self.blog)
 257                 if year:
 258                         entries = entries.filter(date__year=year)
 259                 if month:
 260                         entries = entries.filter(date__month=month)
 261                 if day:
 262                         entries = entries.filter(date__day=day)
 263                 try:
 264                         entry = entries.get(slug=slug)
 265                 except:
 266                         raise Http404
 267                 context = self.get_context()
 268                 context.update(extra_context or {})
 269                 context.update({'entry': entry})
 270                 return self.entry_page.render_to_response(request, extra_context=context)
 271
 272         def tag_archive_view(self, request, extra_context=None):
 273                 """Renders :attr:`tag_archive_page` with the result of :meth:`get_tag_queryset` added to the context."""
 274                 if not self.tag_archive_page:
 275                         raise Http404
 276                 context = self.get_context()
 277                 context.update(extra_context or {})
 278                 context.update({
 279                         'tags': self.get_tag_queryset(self.blog)
 280                 })
 281                 return self.tag_archive_page.render_to_response(request, extra_context=context)
 282
 283         def feed_view(self, get_items_attr, reverse_name, feed_type=None):
 284                 """Overrides :meth:`.FeedView.feed_view` to add :class:`.Tag`\ s to the feed as categories."""
 285                 get_items = callable(get_items_attr) and get_items_attr or getattr(self, get_items_attr)
 286
 287                 def inner(request, extra_context=None, *args, **kwargs):
 288                         obj = self.get_object(request, *args, **kwargs)
 289                         feed = self.get_feed(obj, request, reverse_name, feed_type, *args, **kwargs)
 290                         items, extra_context = get_items(request, extra_context=extra_context, *args, **kwargs)
 291                         self.populate_feed(feed, items, request)
 292
 293                         if 'tags' in extra_context:
 294                                 tags = extra_context['tags']
 295                                 feed.feed['link'] = request.node.construct_url(self.reverse(obj=tags), with_domain=True, request=request, secure=request.is_secure())
 296                         else:
 297                                 tags = obj.entry_tags
 298
 299                         feed.feed['categories'] = [tag.name for tag in tags]
 300
 301                         response = HttpResponse(mimetype=feed.mime_type)
 302                         feed.write(response, 'utf-8')
 303                         return response
 304
 305                 return inner
 306
 307         def process_page_items(self, request, items):
 308                 """Overrides :meth:`.FeedView.process_page_items` to add pagination."""
 309                 if self.entries_per_page:
 310                         page_num = request.GET.get('page', 1)
 311                         paginator, paginated_page, items = paginate(items, self.entries_per_page, page_num)
 312                         item_context = {
 313                                 'paginator': paginator,
 314                                 'paginated_page': paginated_page,
 315                                 self.item_context_var: items
 316                         }
 317                 else:
 318                         item_context = {
 319                                 self.item_context_var: items
 320                         }
 321                 return items, item_context
 322
 323         def title(self, obj):
 324                 return obj.title
 325
 326         def item_title(self, item):
 327                 return item.title
 328
 329         def item_description(self, item):
 330                 return item.content
 331
 332         def item_author_name(self, item):
 333                 return item.author.get_full_name()
 334
 335         def item_pubdate(self, item):
 336                 return item.date
 337
 338         def item_categories(self, item):
 339                 return [tag.name for tag in item.tags.all()]
 340
 341
 342 class Newsletter(Entity):
 343         """Represents a newsletter which will contain :class:`articles <NewsletterArticle>` organized into :class:`issues <NewsletterIssue>`."""
 344         #: The name of the :class:`Newsletter`, currently callse 'title' for historical reasons.
 345         title = models.CharField(max_length=255)
 346         #: A slug used to identify the :class:`Newsletter`.
 347         slug = models.SlugField(max_length=255)
 348
 349         def __unicode__(self):
 350                 return self.title
 351
 352
 353 register_value_model(Newsletter)
 354
 355
 356 class NewsletterArticle(Entity):
 357         """Represents an article in a :class:`Newsletter`"""
 358         #: The title of the :class:`NewsletterArticle`.
 359         title = models.CharField(max_length=255)
 360         #: A slug which identifies the :class:`NewsletterArticle`.
 361         slug = models.SlugField(max_length=255)
 362         #: A :class:`ForeignKey` to :class:`Newsletter` representing the newsletter which this article was written for.
 363         newsletter = models.ForeignKey(Newsletter, related_name='articles')
 364         #: A :class:`ManyToManyField` to the author(s) of the :class:`NewsletterArticle`. The model is either :setting:`PHILO_PERSON_MODULE` or :class:`auth.User`.
 365         authors = models.ManyToManyField(getattr(settings, 'PHILO_PERSON_MODULE', 'auth.User'), related_name='newsletterarticles')
 366         #: The date and time which the :class:`NewsletterArticle` is considered published at.
 367         date = models.DateTimeField(default=None)
 368         #: A :class:`.TemplateField` containing an optional short summary of the article, meant to grab a reader's attention and draw them in.
 369         lede = TemplateField(null=True, blank=True, verbose_name='Summary')
 370         #: A :class:`.TemplateField` containing the full text of the article.
 371         full_text = TemplateField(db_index=True)
 372         #: A ``django-taggit`` :class:`TaggableManager`.
 373         tags = TaggableManager()
 374
 375         def save(self, *args, **kwargs):
 376                 if self.date is None:
 377                         self.date = datetime.now()
 378                 super(NewsletterArticle, self).save(*args, **kwargs)
 379
 380         def __unicode__(self):
 381                 return self.title
 382
 383         class Meta:
 384                 get_latest_by = 'date'
 385                 ordering = ['-date']
 386                 unique_together = (('newsletter', 'slug'),)
 387
 388
 389 register_value_model(NewsletterArticle)
 390
 391
 392 class NewsletterIssue(Entity):
 393         """Represents an issue of the newsletter."""
 394         #: The title of the :class:`NewsletterIssue`.
 395         title = models.CharField(max_length=255)
 396         #: A slug which identifies the :class:`NewsletterIssue`.
 397         slug = models.SlugField(max_length=255)
 398         #: A :class:`ForeignKey` to the :class:`Newsletter` which this issue belongs to.
 399         newsletter = models.ForeignKey(Newsletter, related_name='issues')
 400         #: The numbering of the issue - for example, 04.02 for volume 4, issue 2. This is an instance of :class:`CharField` to allow any arbitrary numbering system.
 401         numbering = models.CharField(max_length=50, help_text='For example, 04.02 for volume 4, issue 2.')
 402         #: A :class:`ManyToManyField` to articles belonging to this issue.
 403         articles = models.ManyToManyField(NewsletterArticle, related_name='issues')
 404
 405         def __unicode__(self):
 406                 return self.title
 407
 408         class Meta:
 409                 ordering = ['-numbering']
 410                 unique_together = (('newsletter', 'numbering'),)
 411
 412
 413 register_value_model(NewsletterIssue)
 414
 415
 416 class NewsletterView(FeedView):
 417         """A subclass of :class:`.FeedView` which handles patterns and feeds for a :class:`Newsletter` and its related :class:`articles <NewsletterArticle>`."""
 418         ARTICLE_PERMALINK_STYLE_CHOICES = (
 419                 ('D', 'Year, month, and day'),
 420                 ('M', 'Year and month'),
 421                 ('Y', 'Year'),
 422                 ('S', 'Slug only')
 423         )
 424
 425         #: A :class:`ForeignKey` to the :class:`Newsletter` managed by this :class:`NewsletterView`.
 426         newsletter = models.ForeignKey(Newsletter, related_name='newsletterviews')
 427
 428         #: A :class:`ForeignKey` to the :class:`Page` used to render the main page of this :class:`NewsletterView`.
 429         index_page = models.ForeignKey(Page, related_name='newsletter_index_related')
 430         #: A :class:`ForeignKey` to the :class:`Page` used to render the detail view of a :class:`NewsletterArticle` for this :class:`NewsletterView`.
 431         article_page = models.ForeignKey(Page, related_name='newsletter_article_related')
 432         #: A :class:`ForeignKey` to the :class:`Page` used to render the :class:`NewsletterArticle` archive pages for this :class:`NewsletterView`.
 433         article_archive_page = models.ForeignKey(Page, related_name='newsletter_article_archive_related', null=True, blank=True)
 434         #: A :class:`ForeignKey` to the :class:`Page` used to render the detail view of a :class:`NewsletterIssue` for this :class:`NewsletterView`.
 435         issue_page = models.ForeignKey(Page, related_name='newsletter_issue_related')
 436         #: A :class:`ForeignKey` to the :class:`Page` used to render the :class:`NewsletterIssue` archive pages for this :class:`NewsletterView`.
 437         issue_archive_page = models.ForeignKey(Page, related_name='newsletter_issue_archive_related', null=True, blank=True)
 438
 439         #: Depending on the needs of the site, different permalink styles may be appropriate. Example subpaths are provided for a :class:`NewsletterArticle` posted on May 2nd, 2011 with a slug of "hello". The choices are:
 440         #:
 441         #:      * Year, month, and day - :attr:`article_permalink_base`\ ``/2011/05/02/hello``
 442         #:      * Year and month - :attr:`article_permalink_base`\ ``/2011/05/hello``
 443         #:      * Year - :attr:`article_permalink_base`\ ``/2011/hello``
 444         #:      * Slug only - :attr:`article_permalink_base`\ ``/hello``
 445         article_permalink_style = models.CharField(max_length=1, choices=ARTICLE_PERMALINK_STYLE_CHOICES)
 446         #: This will be used as the base subpath for year/month/day article archive pages and article detail pages. Default: "articles"
 447         article_permalink_base = models.CharField(max_length=255, blank=False, default='articles')
 448         #: This will be used as the base subpath for issue detail pages and the issue archive page.
 449         issue_permalink_base = models.CharField(max_length=255, blank=False, default='issues')
 450
 451         item_context_var = 'articles'
 452         object_attr = 'newsletter'
 453
 454         def __unicode__(self):
 455                 return "NewsletterView for %s" % self.newsletter.__unicode__()
 456
 457         def get_reverse_params(self, obj):
 458                 if isinstance(obj, NewsletterArticle):
 459                         if obj.newsletter_id == self.newsletter_id:
 460                                 kwargs = {'slug': obj.slug}
 461                                 if self.article_permalink_style in 'DMY':
 462                                         kwargs.update({'year': str(obj.date.year).zfill(4)})
 463                                         if self.article_permalink_style in 'DM':
 464                                                 kwargs.update({'month': str(obj.date.month).zfill(2)})
 465                                                 if self.article_permalink_style == 'D':
 466                                                         kwargs.update({'day': str(obj.date.day).zfill(2)})
 467                                 return self.article_view, [], kwargs
 468                 elif isinstance(obj, NewsletterIssue):
 469                         if obj.newsletter_id == self.newsletter_id:
 470                                 return 'issue', [], {'numbering': obj.numbering}
 471                 elif isinstance(obj, (date, datetime)):
 472                         kwargs = {
 473                                 'year': str(obj.year).zfill(4),
 474                                 'month': str(obj.month).zfill(2),
 475                                 'day': str(obj.day).zfill(2)
 476                         }
 477                         return 'articles_by_day', [], kwargs
 478                 raise ViewCanNotProvideSubpath
 479
 480         @property
 481         def urlpatterns(self):
 482                 urlpatterns = self.feed_patterns(r'^', 'get_all_articles', 'index_page', 'index') + patterns('',
 483                         url(r'^%s/(?P<numbering>.+)$' % self.issue_permalink_base, self.page_view('get_articles_by_issue', 'issue_page'), name='issue')
 484                 )
 485                 if self.issue_archive_page_id:
 486                         urlpatterns += patterns('',
 487                                 url(r'^%s$' % self.issue_permalink_base, self.issue_archive_view, 'issue_archive')
 488                         )
 489                 if self.article_archive_page_id:
 490                         urlpatterns += self.feed_patterns(r'^%s' % self.article_permalink_base, 'get_all_articles', 'article_archive_page', 'articles')
 491                         if self.article_permalink_style in 'DMY':
 492                                 urlpatterns += self.feed_patterns(r'^%s/(?P<year>\d{4})' % self.article_permalink_base, 'get_articles_by_ymd', 'article_archive_page', 'articles_by_year')
 493                                 if self.article_permalink_style in 'DM':
 494                                         urlpatterns += self.feed_patterns(r'^%s/(?P<year>\d{4})/(?P<month>\d{2})' % self.article_permalink_base, 'get_articles_by_ymd', 'article_archive_page', 'articles_by_month')
 495                                         if self.article_permalink_style == 'D':
 496                                                 urlpatterns += self.feed_patterns(r'^%s/(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d{2})' % self.article_permalink_base, 'get_articles_by_ymd', 'article_archive_page', 'articles_by_day')
 497
 498                 if self.article_permalink_style == 'Y':
 499                         urlpatterns += patterns('',
 500                                 url(r'^%s/(?P<year>\d{4})/(?P<slug>[\w-]+)$' % self.article_permalink_base, self.article_view)
 501                         )
 502                 elif self.article_permalink_style == 'M':
 503                         urlpatterns += patterns('',
 504                                 url(r'^%s/(?P<year>\d{4})/(?P<month>\d{2})/(?P<slug>[\w-]+)$' % self.article_permalink_base, self.article_view)
 505                         )
 506                 elif self.article_permalink_style == 'D':
 507                         urlpatterns += patterns('',
 508                                 url(r'^%s/(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d{2})/(?P<slug>[\w-]+)$' % self.article_permalink_base, self.article_view)
 509                         )
 510                 else:
 511                         urlpatterns += patterns('',
 512                                 url(r'^%s/(?P<slug>[-\w]+)$' % self.article_permalink_base, self.article_view)
 513                         )
 514
 515                 return urlpatterns
 516
 517         def get_context(self):
 518                 return {'newsletter': self.newsletter}
 519
 520         def get_article_queryset(self, obj):
 521                 """Returns the default :class:`QuerySet` of :class:`NewsletterArticle` instances for the :class:`NewsletterView` - all articles that are considered posted in the past. This allows for scheduled posting of articles."""
 522                 return obj.articles.filter(date__lte=datetime.now())
 523
 524         def get_issue_queryset(self, obj):
 525                 """Returns the default :class:`QuerySet` of :class:`NewsletterIssue` instances for the :class:`NewsletterView`."""
 526                 return obj.issues.all()
 527
 528         def get_all_articles(self, obj, request, extra_context=None):
 529                 """Used to generate :meth:`~.FeedView.feed_patterns` for all entries."""
 530                 return self.get_article_queryset(obj), extra_context
 531
 532         def get_articles_by_ymd(self, obj, request, year, month=None, day=None, extra_context=None):
 533                 """Used to generate :meth:`~.FeedView.feed_patterns` for a specific year, month, and day."""
 534                 articles = self.get_article_queryset(obj).filter(date__year=year)
 535                 if month:
 536                         articles = articles.filter(date__month=month)
 537                 if day:
 538                         articles = articles.filter(date__day=day)
 539                 return articles, extra_context
 540
 541         def get_articles_by_issue(self, obj, request, numbering, extra_context=None):
 542                 """Used to generate :meth:`~.FeedView.feed_patterns` for articles from a certain issue."""
 543                 try:
 544                         issue = self.get_issue_queryset(obj).get(numbering=numbering)
 545                 except NewsletterIssue.DoesNotExist:
 546                         raise Http404
 547                 context = extra_context or {}
 548                 context.update({'issue': issue})
 549                 return self.get_article_queryset(obj).filter(issues=issue), context
 550
 551         def article_view(self, request, slug, year=None, month=None, day=None, extra_context=None):
 552                 """Renders :attr:`article_page` with the article specified by the given parameters."""
 553                 articles = self.get_article_queryset(self.newsletter)
 554                 if year:
 555                         articles = articles.filter(date__year=year)
 556                 if month:
 557                         articles = articles.filter(date__month=month)
 558                 if day:
 559                         articles = articles.filter(date__day=day)
 560                 try:
 561                         article = articles.get(slug=slug)
 562                 except NewsletterArticle.DoesNotExist:
 563                         raise Http404
 564                 context = self.get_context()
 565                 context.update(extra_context or {})
 566                 context.update({'article': article})
 567                 return self.article_page.render_to_response(request, extra_context=context)
 568
 569         def issue_archive_view(self, request, extra_context):
 570                 """Renders :attr:`issue_archive_page` with the result of :meth:`get_issue_queryset` added to the context."""
 571                 if not self.issue_archive_page:
 572                         raise Http404
 573                 context = self.get_context()
 574                 context.update(extra_context or {})
 575                 context.update({
 576                         'issues': self.get_issue_queryset(self.newsletter)
 577                 })
 578                 return self.issue_archive_page.render_to_response(request, extra_context=context)
 579
 580         def title(self, obj):
 581                 return obj.title
 582
 583         def item_title(self, item):
 584                 return item.title
 585
 586         def item_description(self, item):
 587                 return item.full_text
 588
 589         def item_author_name(self, item):
 590                 authors = list(item.authors.all())
 591                 if len(authors) > 1:
 592                         return "%s and %s" % (", ".join([author.get_full_name() for author in authors[:-1]]), authors[-1].get_full_name())
 593                 elif authors:
 594                         return authors[0].get_full_name()
 595                 else:
 596                         return ''
 597
 598         def item_pubdate(self, item):
 599                 return item.date
 600
 601         def item_categories(self, item):
 602                 return [tag.name for tag in item.tags.all()]