git.ithinksw.org / philo.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fixed File unicode method and added pagination to the BlogNode's index template....
[philo.git] / contrib / penfield / models.py
diff --git a/contrib/penfield/models.py b/contrib/penfield/models.py
index 374fb49..1117336 100644 (file)
--- a/contrib/penfield/models.py
+++ b/contrib/penfield/models.py
@@ -1,24 +1,53 @@
 from django.db import models
 from django.db import models
-from philo.models import Entity, Collection, MultiNode, Template, register_value_model
+from philo.models import Entity, MultiNode, Template, register_value_model
+from django.core.paginator import Paginator, InvalidPage, EmptyPage
 from django.contrib.auth.models import User
 from django.conf.urls.defaults import url, patterns
 from django.http import Http404, HttpResponse
 from django.contrib.auth.models import User
 from django.conf.urls.defaults import url, patterns
 from django.http import Http404, HttpResponse
+from django.template import RequestContext
+from datetime import datetime
 
 
 
 
-class Entry(Entity):
-       author = models.ForeignKey(User, related_name='blogpost_author')
-       pub_date = models.DateTimeField(auto_now_add=True)
-       mod_date = models.DateTimeField(auto_now=True)
+class Tag(models.Model):
+       name = models.CharField(max_length=250)
+       slug = models.SlugField()
+       
+       def __unicode__(self):
+               return self.name
+
+
+class Titled(models.Model):
        title = models.CharField(max_length=255)
        slug = models.SlugField()
        title = models.CharField(max_length=255)
        slug = models.SlugField()
+       
+       def __unicode__(self):
+               return self.title
+       
+       class Meta:
+               abstract = True
+
+
+class Blog(Entity, Titled):
+       pass
+
+
+class BlogEntry(Entity, Titled):
+       blog = models.ForeignKey(Blog, related_name='entries')
+       author = models.ForeignKey(User, related_name='blogentries')
+       date = models.DateTimeField(default=datetime.now)
        content = models.TextField()
        excerpt = models.TextField()
        content = models.TextField()
        excerpt = models.TextField()
+       tags = models.ManyToManyField(Tag)
+       
+       class Meta:
+               ordering = ['-date']
+               verbose_name_plural = "Blog Entries"
 
 
 
 
-register_value_model(Entry)
+register_value_model(BlogEntry)
 
 
 
 
-class Blog(MultiNode):
+class BlogNode(MultiNode):
        PERMALINK_STYLE_CHOICES = (
                ('D', 'Year, month, and day'),
                ('M', 'Year and month'),
        PERMALINK_STYLE_CHOICES = (
                ('D', 'Year, month, and day'),
                ('M', 'Year and month'),
@@ -27,65 +56,115 @@ class Blog(MultiNode):
                ('N', 'No base')
        )
        
                ('N', 'No base')
        )
        
-       posts = models.ForeignKey(Collection, related_name='blogs')
+       blog = models.ForeignKey(Blog, related_name='nodes')
+       
        index_template = models.ForeignKey(Template, related_name='blog_index_related')
        index_template = models.ForeignKey(Template, related_name='blog_index_related')
+       index_pages = models.IntegerField(help_text="Please enter a number between 0 and 9999.")
        archive_template = models.ForeignKey(Template, related_name='blog_archive_related')
        archive_template = models.ForeignKey(Template, related_name='blog_archive_related')
+       archive_pages = models.IntegerField(help_text="Please enter a number between 0 and 9999.")
        tag_template = models.ForeignKey(Template, related_name='blog_tag_related')
        tag_template = models.ForeignKey(Template, related_name='blog_tag_related')
-       post_template = models.ForeignKey(Template, related_name='blog_post_related')
+       tag_pages = models.IntegerField(help_text="Please enter a number between 0 and 9999.")
+       entry_template = models.ForeignKey(Template, related_name='blog_entry_related')
        
        
-       post_permalink_style = models.CharField(max_length=1, choices=PERMALINK_STYLE_CHOICES)
-       post_permalink_base = models.CharField(max_length=255, blank=False, default='posts')
+       entry_permalink_style = models.CharField(max_length=1, choices=PERMALINK_STYLE_CHOICES)
+       entry_permalink_base = models.CharField(max_length=255, blank=False, default='entries')
        tag_permalink_base = models.CharField(max_length=255, blank=False, default='tags')
        
        tag_permalink_base = models.CharField(max_length=255, blank=False, default='tags')
        
-       @property
-       def post_queryset(self):
-               # this won't be ordered according to the collection member indexes
-               return self.posts.members.with_model(Entry)
-       
        @property
        def urlpatterns(self):
                base_patterns = patterns('',
                        url(r'^$', self.index_view),
                        url((r'^(?:%s)/?' % self.tag_permalink_base), self.tag_view),
        @property
        def urlpatterns(self):
                base_patterns = patterns('',
                        url(r'^$', self.index_view),
                        url((r'^(?:%s)/?' % self.tag_permalink_base), self.tag_view),
-                       url((r'^(?:%s)/(?P<tag>\w+)/?' % self.tag_permalink_base), self.tag_view)
+                       url((r'^(?:%s)/(?P<tag>>[-\w]+)/?' % self.tag_permalink_base), self.tag_view)
                )
                )
-               if self.post_permalink_style == 'D':
-                       post_patterns = patterns('',
+               if self.entry_permalink_style == 'D':
+                       entry_patterns = patterns('',
                                url(r'^(?P<year>\d{4})/?$', self.archive_view),
                                url(r'^(?P<year>\d{4})/(?P<month>\d{2})/?$', self.archive_view),
                                url(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d+)/?$', self.archive_view),
                                url(r'^(?P<year>\d{4})/?$', self.archive_view),
                                url(r'^(?P<year>\d{4})/(?P<month>\d{2})/?$', self.archive_view),
                                url(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d+)/?$', self.archive_view),
-                               url(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d+)/(?P<slug>\w+)/?', self.archive_view)
+                               url(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d+)/(?P<slug>[-\w]+)/?', self.entry_view)
                        )
                        )
-               elif self.post_permalink_style == 'M':
-                       post_patterns = patterns('',
+               elif self.entry_permalink_style == 'M':
+                       entry_patterns = patterns('',
                                url(r'^(?P<year>\d{4})/?$', self.archive_view),
                                url(r'^(?P<year>\d{4})/(?P<month>\d{2})/?$', self.archive_view),
                                url(r'^(?P<year>\d{4})/?$', self.archive_view),
                                url(r'^(?P<year>\d{4})/(?P<month>\d{2})/?$', self.archive_view),
-                               url(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<slug>\w+)/?', self.archive_view)
+                               url(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<slug>>[-\w]+)/?', self.entry_view)
                        )
                        )
-               elif self.post_permalink_style == 'Y':
-                       post_patterns = patterns('',
+               elif self.entry_permalink_style == 'Y':
+                       entry_patterns = patterns('',
                                url(r'^(?P<year>\d{4})/?$', self.archive_view),
                                url(r'^(?P<year>\d{4})/?$', self.archive_view),
-                               url(r'^(?P<year>\d{4})/(?P<slug>\w+)/?', self.post_view)
+                               url(r'^(?P<year>\d{4})/(?P<slug>>[-\w]+)/?', self.entry_view)
                        )
                        )
-               elif self.post_permalink_style == 'B':
-                       post_patterns = patterns('',
-                               url((r'^(?:%s)/?' % self.post_permalink_base), self.archive_view),
-                               url((r'^(?:%s)/(?P<slug>\w+)/?' % self.post_permalink_base), self.post_view)
+               elif self.entry_permalink_style == 'B':
+                       entry_patterns = patterns('',
+                               url((r'^(?:%s)/?' % self.entry_permalink_base), self.archive_view),
+                               url((r'^(?:%s)/(?P<slug>>[-\w]+)/?' % self.entry_permalink_base), self.entry_view)
                        )
                else:
                        )
                else:
-                       post_patterns = patterns('',
-                               url(r'^(?P<slug>\w+)/?', self.post_view)
+                       entry_patterns = patterns('',
+                               url(r'^(?P<slug>>[-\w]+)/?', self.entry_view)
                        )
                        )
-               return base_patterns + post_patterns
+               return base_patterns + entry_patterns
        
        def index_view(self, request):
        
        def index_view(self, request):
-               raise Http404
+               entries = self.blog.entries.order_by('-date')
+               if self.index_pages != 0:
+                       paginator = Paginator(entries, self.index_pages)
+                       try:
+                               page = int(request.GET.get('page', '1'))
+                               entries = paginator.page(page).object_list
+                               page_number = paginator.page(page)
+                       except ValueError:
+                               page = 1
+                               entries = paginator.page(page).object_list
+                               page_number = paginator.page(page)
+                       try:
+                               entries = paginator.page(page).object_list
+                               page_number = paginator.page(page)
+                       except (EmptyPage, InvalidPage):
+                               entries = paginator.page(paginator.num_pages).object_list
+                               page_number = paginator.page(page)
+               return HttpResponse(self.index_template.django_template.render(RequestContext(request, {'blog': self.blog, 'entries': entries, 'page_number': page_number})), mimetype=self.index_template.mimetype)
        
        def archive_view(self, request, year=None, month=None, day=None):
        
        def archive_view(self, request, year=None, month=None, day=None):
-               raise Http404
+               entries = self.blog.entries.all()
+               if year:
+                       entries = entries.filter(date__year=year)
+               if month:
+                       entries = entries.filter(date__month=month)
+               if day:
+                       entries = entries.filter(date__day=day)
+               return HttpResponse(self.archive_template.django_template.render(RequestContext(request, {'blog': self.blog, 'year': year, 'month': month, 'day': day, 'entries': entries})), mimetype=self.archive_template.mimetype)
        
        def tag_view(self, request, tag=None):
        
        def tag_view(self, request, tag=None):
+               # return HttpResponse(self.tag_template.django_template.render(RequestContext(request, {'blog': self.blog, 'tag': tag, 'entries': None})), mimetype=self.tag_template.mimetype)
                raise Http404
        
                raise Http404
        
-       def post_view(self, request, year=None, month=None, day=None, slug=None):
-               raise Http404
+       def entry_view(self, request, slug, year=None, month=None, day=None):
+               entries = self.blog.entries.all()
+               if year:
+                       entries = entries.filter(date__year=year)
+               if month:
+                       entries = entries.filter(date__month=month)
+               if day:
+                       entries = entries.filter(date__day=day)
+               try:
+                       entry = entries.get(slug=slug)
+               except:
+                       raise Http404
+               return HttpResponse(self.entry_template.django_template.render(RequestContext(request, {'blog': self.blog, 'entry': entry})), mimetype=self.entry_template.mimetype)
+
+
+class Newsletter(Entity, Titled):
+       pass
+
+
+class NewsStory(Entity, Titled):
+       newsletter = models.ForeignKey(Newsletter, related_name='stories')
+       authors = models.ManyToManyField(User, related_name='newsstories')
+       date = models.DateTimeField(default=datetime.now)
+       lede = models.TextField(null=True, blank=True)
+       full_text = models.TextField()
+
+
+register_value_model(NewsStory)
\ No newline at end of file
Foundation for web content management systems using Django.