contrib/penfield/models.py

   1 from django.db import models
   2 from django.conf import settings
   3 from philo.models import Tag, Titled, Entity, MultiView, Page, register_value_model
   4 from django.conf.urls.defaults import url, patterns
   5 from django.http import Http404, HttpResponse
   6 from datetime import datetime
   7 from philo.contrib.penfield.utils import paginate
   8 from philo.contrib.penfield.validators import validate_pagination_count
   9
  10
  11 class Blog(Entity, Titled):
  12         @property
  13         def entry_tags(self):
  14                 """ Returns a QuerySet of Tags that are used on any entries in this blog. """
  15                 return Tag.objects.filter(blogentries__blog=self)
  16
  17
  18 class BlogEntry(Entity, Titled):
  19         blog = models.ForeignKey(Blog, related_name='entries')
  20         author = models.ForeignKey(getattr(settings, 'PHILO_PERSON_MODULE', 'auth.User'), related_name='blogentries')
  21         date = models.DateTimeField(default=datetime.now)
  22         content = models.TextField()
  23         excerpt = models.TextField()
  24         tags = models.ManyToManyField(Tag, related_name='blogentries')
  25
  26         class Meta:
  27                 ordering = ['-date']
  28                 verbose_name_plural = "blog entries"
  29
  30
  31 register_value_model(BlogEntry)
  32
  33
  34 class BlogView(MultiView):
  35         ENTRY_PERMALINK_STYLE_CHOICES = (
  36                 ('D', 'Year, month, and day'),
  37                 ('M', 'Year and month'),
  38                 ('Y', 'Year'),
  39                 ('B', 'Custom base'),
  40                 ('N', 'No base')
  41         )
  42
  43         blog = models.ForeignKey(Blog, related_name='blogviews')
  44
  45         index_page = models.ForeignKey(Page, related_name='blog_index_related')
  46         entry_page = models.ForeignKey(Page, related_name='blog_entry_related')
  47         entry_archive_page = models.ForeignKey(Page, related_name='blog_entry_archive_related', null=True, blank=True)
  48         tag_page = models.ForeignKey(Page, related_name='blog_tag_related')
  49         tag_archive_page = models.ForeignKey(Page, related_name='blog_tag_archive_related', null=True, blank=True)
  50         entries_per_page = models.IntegerField(blank=True, validators=[validate_pagination_count])
  51
  52         entry_permalink_style = models.CharField(max_length=1, choices=ENTRY_PERMALINK_STYLE_CHOICES)
  53         entry_permalink_base = models.CharField(max_length=255, blank=False, default='entries')
  54         tag_permalink_base = models.CharField(max_length=255, blank=False, default='tags')
  55
  56         def __unicode__(self):
  57                 return u'BlogView for %s' % self.blog.title
  58
  59         @property
  60         def urlpatterns(self):
  61                 base_patterns = patterns('',
  62                         url(r'^$', self.index_view),
  63                         url((r'^(?:%s)/?$' % self.tag_permalink_base), self.tag_archive_view),
  64                         url((r'^(?:%s)/(?P<tag>[-\w]+)/?$' % self.tag_permalink_base), self.tag_view)
  65                 )
  66                 if self.entry_permalink_style == 'D':
  67                         entry_patterns = patterns('',
  68                                 url(r'^(?P<year>\d{4})/?$', self.entry_archive_view),
  69                                 url(r'^(?P<year>\d{4})/(?P<month>\d{2})/?$', self.entry_archive_view),
  70                                 url(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d{2})/?$', self.entry_archive_view),
  71                                 url(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d{2})/(?P<slug>[-\w]+)/?$', self.entry_view)
  72                         )
  73                 elif self.entry_permalink_style == 'M':
  74                         entry_patterns = patterns('',
  75                                 url(r'^(?P<year>\d{4})/?$', self.entry_archive_view),
  76                                 url(r'^(?P<year>\d{4})/(?P<month>\d{2})/?$', self.entry_archive_view),
  77                                 url(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<slug>[-\w]+)/?$', self.entry_view)
  78                         )
  79                 elif self.entry_permalink_style == 'Y':
  80                         entry_patterns = patterns('',
  81                                 url(r'^(?P<year>\d{4})/?$', self.entry_archive_view),
  82                                 url(r'^(?P<year>\d{4})/(?P<slug>[-\w]+)/?$', self.entry_view)
  83                         )
  84                 elif self.entry_permalink_style == 'B':
  85                         entry_patterns = patterns('',
  86                                 url((r'^(?:%s)/?$' % self.entry_permalink_base), self.entry_archive_view),
  87                                 url((r'^(?:%s)/(?P<slug>[-\w]+)/?$' % self.entry_permalink_base), self.entry_view)
  88                         )
  89                 else:
  90                         entry_patterns = patterns('',
  91                                 url(r'^(?P<slug>[-\w]+)/?$', self.entry_view)
  92                         )
  93                 return base_patterns + entry_patterns
  94
  95         def index_view(self, request, node=None, extra_context=None):
  96                 entries = self.blog.entries.all()
  97                 if self.entries_per_page:
  98                         paginated_page = paginate(request, entries, self.entries_per_page)
  99                         entries = paginated_page.object_list
 100                 else:
 101                         paginated_page = None
 102                 context = {}
 103                 context.update(extra_context or {})
 104                 context.update({'blog': self.blog, 'entries': entries, 'paginated_page': paginated_page})
 105                 return self.index_page.render_to_response(node, request, extra_context=context)
 106
 107         def entry_view(self, request, slug, year=None, month=None, day=None, node=None, extra_context=None):
 108                 entries = self.blog.entries.all()
 109                 if year:
 110                         entries = entries.filter(date__year=year)
 111                 if month:
 112                         entries = entries.filter(date__month=month)
 113                 if day:
 114                         entries = entries.filter(date__day=day)
 115                 try:
 116                         entry = entries.get(slug=slug)
 117                 except:
 118                         raise Http404
 119                 context = {}
 120                 context.update(extra_context or {})
 121                 context.update({'blog': self.blog, 'entry': entry})
 122                 return self.entry_page.render_to_response(node, request, extra_context=context)
 123
 124         def entry_archive_view(self, request, year=None, month=None, day=None, node=None, extra_context=None):
 125                 if not self.entry_archive_page:
 126                         raise Http404
 127                 entries = self.blog.entries.all()
 128                 if year:
 129                         entries = entries.filter(date__year=year)
 130                 if month:
 131                         entries = entries.filter(date__month=month)
 132                 if day:
 133                         entries = entries.filter(date__day=day)
 134                 if self.entries_per_page:
 135                         paginated_page = paginate(request, entries, self.entries_per_page)
 136                         entries = paginated_page.object_list
 137                 else:
 138                         paginated_page = None
 139                 context = {}
 140                 context.update(extra_context or {})
 141                 context.update({'blog': self.blog, 'year': year, 'month': month, 'day': day, 'entries': entries, 'paginated_page': paginated_page})
 142                 return self.entry_archive_page.render_to_response(node, request, extra_context=context)
 143
 144         def tag_view(self, request, tag, node=None, extra_context=None):
 145                 try:
 146                         tag = self.blog.entry_tags.filter(slug=tag)
 147                 except:
 148                         raise Http404
 149                 entries = self.blog.entries.filter(tags=tag)
 150                 if self.entries_per_page:
 151                         paginated_page = paginate(request, entries, self.entries_per_page)
 152                         entries = paginated_page.object_list
 153                 else:
 154                         paginated_page = None
 155                 context = {}
 156                 context.update(extra_context or {})
 157                 context.update({'blog': self.blog, 'tag': tag, 'entries': entries, 'paginated_page': paginated_page})
 158                 return self.tag_page.render_to_response(node, request, extra_context=context)
 159
 160         def tag_archive_view(self, request, node=None, extra_context=None):
 161                 if not self.tag_archive_page:
 162                         raise Http404
 163                 context = {}
 164                 context.update(extra_context or {})
 165                 context.update({'blog': self.blog})
 166                 return self.tag_archive_page.render_to_response(node, request, extra_context=context)
 167
 168
 169 class Newsletter(Entity, Titled):
 170         pass
 171
 172
 173 class NewsletterArticle(Entity, Titled):
 174         newsletter = models.ForeignKey(Newsletter, related_name='articles')
 175         authors = models.ManyToManyField(getattr(settings, 'PHILO_PERSON_MODULE', 'auth.User'), related_name='newsletterarticles')
 176         date = models.DateTimeField(default=datetime.now)
 177         lede = models.TextField(null=True, blank=True)
 178         full_text = models.TextField()
 179
 180         class Meta:
 181                 ordering = ['-date']
 182                 unique_together = (('newsletter', 'slug'),)
 183
 184
 185 register_value_model(NewsletterArticle)
 186
 187
 188 class NewsletterIssue(Entity, Titled):
 189         newsletter = models.ForeignKey(Newsletter, related_name='issues')
 190         number = models.PositiveIntegerField()
 191         articles = models.ManyToManyField(NewsletterArticle)
 192
 193         class Meta:
 194                 ordering = ['-number']
 195                 unique_together = (('newsletter', 'number'),)
 196
 197
 198 class NewsletterView(MultiView):
 199         ARTICLE_PERMALINK_STYLE_CHOICES = (
 200                 ('D', 'Year, month, and day'),
 201                 ('M', 'Year and month'),
 202                 ('Y', 'Year'),
 203                 ('S', 'Slug only')
 204         )
 205
 206         newsletter = models.ForeignKey(Newsletter, related_name='newsletterviews')
 207
 208         index_page = models.ForeignKey(Page, related_name='newsletter_index_related')
 209         article_page = models.ForeignKey(Page, related_name='newsletter_article_related')
 210         article_archive_page = models.ForeignKey(Page, related_name='newsletter_article_archive_related', null=True, blank=True)
 211         issue_page = models.ForeignKey(Page, related_name='newsletter_issue_related')
 212         issue_archive_page = models.ForeignKey(Page, related_name='newsletter_issue_archive_related', null=True, blank=True)
 213
 214         article_permalink_style = models.CharField(max_length=1, choices=ARTICLE_PERMALINK_STYLE_CHOICES)
 215         article_permalink_base = models.CharField(max_length=255, blank=False, default='articles')
 216         issue_permalink_base = models.CharField(max_length=255, blank=False, default='issues')
 217
 218         @property
 219         def urlpatterns(self):
 220                 base_patterns = patterns('',
 221                         url(r'^$', self.index_view),
 222                         url((r'^(?:%s)/?$' % self.issue_permalink_base), self.issue_archive_view),
 223                         url((r'^(?:%s)/(?P<number>\d+)/?$' % self.issue_permalink_base), self.issue_view)
 224                 )
 225                 article_patterns = patterns('',
 226                         url((r'^(?:%s)/?$' % self.article_permalink_base), self.article_archive_view)
 227                 )
 228                 if self.article_permalink_style in 'DMY':
 229                         article_patterns += patterns('',
 230                                 url((r'^(?:%s)/(?P<year>\d{4})/?$' % self.article_permalink_base), self.article_archive_view)
 231                         )
 232                         if self.article_permalink_style in 'DM':
 233                                 article_patterns += patterns('',
 234                                         url((r'^(?:%s)/(?P<year>\d{4})/(?P<month>\d{2})/?$' % self.article_permalink_base), self.article_archive_view)
 235                                 )
 236                                 if self.article_permalink_style == 'D':
 237                                         article_patterns += patterns('',
 238                                                 url((r'^(?:%s)/(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d{2})/?$' % self.article_permalink_base), self.article_archive_view),
 239                                                 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)
 240                                         )
 241                                 else:
 242                                         article_patterns += patterns('',
 243                                                 url((r'^(?:%s)/(?P<year>\d{4})/(?P<month>\d{2})/(?P<slug>[-\w]+)/?$' % self.article_permalink_base), self.article_view)
 244                                         )
 245                         else:
 246                                 article_patterns += patterns('',
 247                                         url((r'^(?:%s)/(?P<year>\d{4})/(?P<slug>[-\w]+)/?$' % self.article_permalink_base), self.article_view)
 248                                 )
 249                 else:
 250                         article_patterns += patterns('',
 251                                 url((r'^(?:%s)/(?P<slug>[-\w]+)/?$' % self.article_permalink_base), self.article_view)
 252                         )
 253                 return base_patterns + article_patterns
 254
 255         def index_view(self, request, node=None, extra_context=None):
 256                 context = {}
 257                 context.update(extra_context or {})
 258                 context.update({'newsletter': self.newsletter})
 259                 return self.index_page.render_to_response(node, request, extra_context=context)
 260
 261         def article_view(self, request, slug, year=None, month=None, day=None, node=None, extra_context=None):
 262                 articles = self.newsletter.articles.all()
 263                 if year:
 264                         articles = articles.filter(date__year=year)
 265                 if month:
 266                         articles = articles.filter(date__month=month)
 267                 if day:
 268                         articles = articles.filter(date__day=day)
 269                 try:
 270                         article = articles.get(slug=slug)
 271                 except:
 272                         raise Http404
 273                 context = {}
 274                 context.update(extra_context or {})
 275                 context.update({'newsletter': self.newsletter, 'article': article})
 276                 return self.article_page.render_to_response(node, request, extra_context=context)
 277
 278         def article_archive_view(self, request, year=None, month=None, day=None, node=None, extra_context=None):
 279                 if not self.article_archive_page:
 280                         raise Http404
 281                 articles = self.newsletter.articles.all()
 282                 if year:
 283                         articles = articles.filter(date__year=year)
 284                 if month:
 285                         articles = articles.filter(date__month=month)
 286                 if day:
 287                         articles = articles.filter(date__day=day)
 288                 context = {}
 289                 context.update(extra_context or {})
 290                 context.update({'newsletter': self.newsletter, 'year': year, 'month': month, 'day': day, 'articles': articles})
 291                 return self.article_archive_page.render_to_response(node, request, extra_context=context)
 292
 293         def issue_view(self, request, number, node=None, extra_context=None):
 294                 try:
 295                         issue = self.newsletter.issues.get(number=number)
 296                 except:
 297                         raise Http404
 298                 context = {}
 299                 context.update(extra_context or {})
 300                 context.update({'newsletter': self.newsletter, 'issue': issue})
 301                 return self.issue_page.render_to_response(node, request, extra_context=context)
 302
 303         def issue_archive_view(self, request, node=None, extra_context=None):
 304                 if not self.issue_archive_page:
 305                         raise Http404
 306                 context = {}
 307                 context.update(extra_context or {})
 308                 context.update({'newsletter': self.newsletter})
 309                 return self.issue_archive_page.render_to_response(node, request, extra_context=context)