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')