from tagging.fields import TagField
from django_extensions.db.fields import CreationDateTimeField, ModificationDateTimeField
import datetime
class EventType(models.Model):
"""
A type or category of events.
"""
name = models.CharField(max_length=100)
slug = models.SlugField()
def __unicode__(self):
return self.name
gettag.register(EventType)
class Event(DynamicModelBase):
"""
A scheduled event.
"""
name = models.CharField(max_length=255)
slug = models.SlugField()
summary = models.TextField()
description = models.TextField()
event_type = models.ForeignKey(EventType, related_name="events")
tags = TagField()
#location when we make the location app
date = models.DateField()
ordering = ['user']
unique_together = ['first_name', 'last_name']
def __unicode__(self):
return "%s %s" % (self.first_name, self.last_name)
def save(self):
if self.user: #denormalization
self.first_name = self.user.first_name
self.last_name = self.user.last_name
super(Staffer, self).save()
@models.permalink
def get_absolute_url(self):
return('staffer_detailed', (), {'slug': self.slug})
gettag.register(Staffer)
class ContentByline(models.Model):
"""
Abstract base class that handles associating staffers with other types
of content.
"""
staffer = models.ForeignKey(Staffer)
position = models.CharField(max_length=100)
order = models.PositiveSmallIntegerField()
class Meta:
abstract = True
def __unicode__(self):
return "%s - %s" % (self.staffer, self.position)
article__published_at__lte=datetime.datetime.now()).order_by('order')]
@models.permalink
def get_absolute_url(self):
return('issue_archive', (), {
'year': self.published_at.year,
'month': '%02d' % self.published_at.month,
'day': '%02d' % self.published_at.day
})
def articles_by_section(self):
"""
Retrieve all articles for this issue grouped by their sections.
"""
return Article.objects.filter(issue=self).order_by('section')
gettag.register(Issue)
class IssueArticle(models.Model):
"""
Connects an article to an issue, including the slot/order in which
the article should be displayed among all of that issue's articles.
"""
issue = models.ForeignKey(Issue)
article = models.ForeignKey('Article')
order = models.PositiveIntegerField()
class Meta:
ordering = ['order']
def __unicode__(self):
return u'%s: %s: %s' % (self.issue, self.article.section, self.article.heading)
templates = []
for extension in request.extension:
for template in arguments[0]:
if template:
templates.append("".join([template, ".", extension]))
arguments[0] = templates
return render_to_response(*arguments, **kwargs)
# Make common_tags available everywhere
for library in settings.TEMPLATE_TAGS:
add_to_builtins(library)
# Add a .type method to every object, so you can ask it what type it is from templates
def add_type(sender, *args, **kwargs):
sender.add_to_class("type", lambda self: self._meta.verbose_name)
pre_init.connect(add_type)
# register Tag model with gettag, since Tag model can't be modified directly (svn:external)
gettag.register(
Tag, name_field="tag__name", with_func=Tag.objects.usage_for_queryset, in_func=TaggedItem.objects.get_by_model
)
# register ContentType with gettag
gettag.register(ContentType, name_field="model")
provider = models.ForeignKey(Provider, blank=True, null=True)
center_longitude = models.DecimalField(max_digits=11, decimal_places=8, null=True, blank=True)
center_latitude = models.DecimalField(max_digits=11, decimal_places=8, null=True, blank=True)
zoom = models.PositiveSmallIntegerField(null=True, blank=True)
map_type = models.CharField(max_length=10, choices=MAP_TYPE_CHOICES, null=True, blank=True)
locations = models.ManyToManyField('Location', related_name='maps', blank=True)
def __unicode__(self):
return u"Map: %s" % self.name
def thumbnail(self):
return "map_thumbnail.gif"
gettag.register(Map)
class Location(DynamicModelBase):
name = models.CharField(max_length=255)
slug = models.SlugField(unique=True)
parent = models.ForeignKey('self', blank=True, null=True, related_name='sublocations')
address = models.CharField(max_length=255, blank=True)
description = models.TextField()
longitude = models.DecimalField(max_digits=11, decimal_places=8, blank=True, )
latitude = models.DecimalField(max_digits=11, decimal_places=8, blank=True)
def __unicode__(self):
return self.name
return model.objects.get(id=self.id)
def admin_thumbnail(self):
"""
Returns an image for display in admin listings.
"""
if hasattr(self, 'thumbnail'):
try:
thumb = DjangoThumbnail(self.thumbnail(), (160,120), opts={'crop':True})
return '<img src="%s" width="160" height="120" />' % unicode(thumb)
except ThumbnailException:
return 'N/A'
return 'N/A'
admin_thumbnail.allow_tags = True
admin_thumbnail.short_description = 'Thumbnail'
gettag.register(MediaItem, plural_name='media')
class MediaByline(ContentByline):
"""
Associates a staffer with a media item, including their position and the
order to display this staffer among all staffers associated with the item.
"""
media_item = models.ForeignKey(MediaItem)
class ContentMedia(models.Model):
"""
Abstract base class for associating media with a content object, including
specifying an order in which all such associations should be displayed.
"""
media_item = models.ForeignKey(MediaItem)
order = models.PositiveSmallIntegerField()
name = models.CharField(max_length=50)
allow_anonymous = models.BooleanField(help_text="Allow anonymous users to post comments")
moderate_anonymous_only = models.BooleanField(help_text="If set, only anonymous users' comments will be moderated. Authenticated users comments will immediately become publicly visible")
moderate_after = models.PositiveSmallIntegerField(default=30,
help_text="# of days after which posts must be moderated. Set to zero (0) for all posts to be moderated")
close_after = models.PositiveSmallIntegerField(default=365, help_text="# of days after which commenting will be closed. Set to zero (0) to disable commenting")
class Meta:
verbose_name = "Comment Options"
verbose_name_plural = "Comments Options"
def __unicode__(self):
return self.name
class DefaultCommentOption(models.Model):
"""
Assigns a default CommentOptions instance for a given ContentType.
"""
content_type = models.ForeignKey(ContentType, unique=True)
options = models.ForeignKey(CommentOptions)
def __unicode__(self):
return self.content_type.name
def save(self, **kwargs):
super(DefaultCommentOption, self).save(**kwargs)
cache.delete('default_%s_comment_options' % self.content_type.model.lower())
gettag.register(Comment, name_field='body')
