mygpo/podcasts/models.py

   1 from __future__ import unicode_literals
   2
   3 from django.db import models
   4 from django.contrib.contenttypes.models import ContentType
   5 from django.contrib.contenttypes.fields import GenericRelation
   6 from django.contrib.contenttypes import generic
   7
   8 from uuidfield import UUIDField
   9
  10
  11 class UUIDModel(models.Model):
  12     """ Models that have an UUID as primary key """
  13
  14     id = UUIDField(primary_key=True)
  15
  16     class Meta:
  17         abstract = True
  18
  19
  20 class TitleModel(models.Model):
  21     """ Model that has a title """
  22
  23     title = models.CharField(max_length=1000, null=False, blank=True,
  24                              db_index=True)
  25     subtitle = models.CharField(max_length=1000, null=False, blank=True)
  26
  27     class Meta:
  28         abstract = True
  29
  30
  31 class DescriptionModel(models.Model):
  32     """ Model that has a description """
  33
  34     description = models.TextField(null=False, blank=True)
  35
  36     class Meta:
  37         abstract = True
  38
  39
  40 class LinkModel(models.Model):
  41     """ Model that has a link """
  42
  43     link = models.URLField(null=True, max_length=1000)
  44
  45     class Meta:
  46         abstract = True
  47
  48
  49 class LanguageModel(models.Model):
  50     """ Model that has a language """
  51
  52     language = models.CharField(max_length=10, null=True, blank=False,
  53                                 db_index=True)
  54
  55     class Meta:
  56         abstract = True
  57
  58
  59 class LastUpdateModel(models.Model):
  60     """ Model with timestamp of last update from its source """
  61
  62     # date and time at which the model has last been updated from its source
  63     # (eg a podcast feed). None means that the object has been created as a
  64     # stub, without information from the source.
  65     last_update = models.DateTimeField(null=True)
  66
  67     class Meta:
  68         abstract = True
  69
  70
  71 class UpdateInfoModel(models.Model):
  72
  73     # this does not use "auto_now_add=True" so that data
  74     # can be migrated with its creation timestamp intact; it can be
  75     # switched on after the migration is complete
  76     created = models.DateTimeField()
  77     modified = models.DateTimeField(auto_now=True)
  78
  79     class Meta:
  80         abstract = True
  81
  82
  83 class LicenseModel(models.Model):
  84     # URL to a license (usually Creative Commons)
  85     license = models.CharField(max_length=100, null=True, blank=False,
  86                                db_index=True)
  87
  88     class Meta:
  89         abstract = True
  90
  91
  92 class FlattrModel(models.Model):
  93     # A Flattr payment URL
  94     flattr_url = models.URLField(null=True, blank=False, max_length=1000,
  95                                  db_index=True)
  96
  97     class Meta:
  98         abstract = True
  99
 100
 101 class ContentTypesModel(models.Model):
 102     # contains a comma-separated values of content types, eg 'audio,video'
 103     content_types = models.CharField(max_length=20, null=False, blank=True)
 104
 105     class Meta:
 106         abstract = True
 107
 108
 109 class MergedIdsModel(models.Model):
 110
 111     class Meta:
 112         abstract = True
 113
 114
 115 class OutdatedModel(models.Model):
 116     outdated = models.BooleanField(default=False, db_index=True)
 117
 118     class Meta:
 119         abstract = True
 120
 121
 122 class AuthorModel(models.Model):
 123     author = models.CharField(max_length=150, null=True, blank=True)
 124
 125     class Meta:
 126         abstract = True
 127
 128
 129 class UrlsMixin(models.Model):
 130     """ Methods for working with URL objects """
 131
 132     urls = GenericRelation('URL', related_query_name='urls')
 133
 134     class Meta:
 135         abstract = True
 136
 137
 138 class SlugsMixin(models.Model):
 139     """ Methods for working with Slug objects """
 140
 141     slugs = GenericRelation('Slug', related_query_name='slugs')
 142
 143     class Meta:
 144         abstract = True
 145
 146     @property
 147     def slug(self):
 148         """ The main slug of the podcast
 149
 150         TODO: should be retrieved from a (materialized) view """
 151         slug = self.slugs.first()
 152         if slug is None:
 153             return None
 154         return slug.slug
 155
 156
 157 class MergedUUIDsMixin(models.Model):
 158     """ Methods for working with MergedUUID objects """
 159
 160     merged_uuids = GenericRelation('MergedUUID',
 161                                    related_query_name='merged_uuids')
 162
 163     class Meta:
 164         abstract = True
 165
 166 class TagsMixin(models.Model):
 167     """ Methods for working with Tag objects """
 168
 169     tags = GenericRelation('Tag', related_query_name='tags')
 170
 171     class Meta:
 172         abstract = True
 173
 174
 175 class OrderedModel(models.Model):
 176     """ A model that can be ordered
 177
 178     The implementing Model must make sure that 'order' is sufficiently unique
 179     """
 180
 181     order = models.PositiveSmallIntegerField()
 182
 183     class Meta:
 184         abstract = True
 185         ordering = ['order']
 186
 187
 188 class PodcastGroup(UUIDModel, TitleModel):
 189     """ Groups multiple podcasts together """
 190
 191
 192 class PodcastQuerySet(models.QuerySet):
 193     """ Custom queries for Podcasts """
 194
 195     def random(self):
 196         """ Random podcasts
 197
 198         Excludes podcasts with missing title to guarantee some
 199         minimum quality of the results """
 200         return self.exclude(title='').order_by('?')
 201
 202     def flattr(self):
 203         """ Podcasts providing Flattr information """
 204         return self.exclude(flattr_url__isnull=True)
 205
 206     def license(self, license_url=None):
 207         """ Podcasts with any / the given license """
 208         if license_url:
 209             return self.filter(license=license_url)
 210         else:
 211             return self.exclude(license__isnull=True)
 212
 213
 214
 215 class Podcast(UUIDModel, TitleModel, DescriptionModel, LinkModel,
 216         LanguageModel, LastUpdateModel, UpdateInfoModel, LicenseModel,
 217         FlattrModel, ContentTypesModel, MergedIdsModel, OutdatedModel,
 218         AuthorModel, UrlsMixin, SlugsMixin, TagsMixin, MergedUUIDsMixin):
 219     """ A Podcast """
 220
 221     logo_url = models.URLField(null=True, max_length=1000)
 222     group = models.ForeignKey(PodcastGroup, null=True)
 223     group_member_name = models.CharField(max_length=30, null=True, blank=False)
 224
 225     # if p1 is related to p2, p2 is also related to p1
 226     related_podcasts = models.ManyToManyField('self', symmetrical=True)
 227
 228     #subscribers = SchemaListProperty(SubscriberData)
 229     restrictions = models.CharField(max_length=20, null=True, blank=True)
 230     common_episode_title = models.CharField(max_length=50, null=False, blank=True)
 231     new_location = models.URLField(max_length=1000, null=True, blank=False)
 232     latest_episode_timestamp = models.DateTimeField(null=True)
 233     episode_count = models.PositiveIntegerField(default=0)
 234     hub = models.URLField(null=True)
 235     twitter = models.CharField(max_length=15, null=True, blank=False)
 236
 237     objects = PodcastQuerySet.as_manager()
 238
 239     def subscriber_count(self):
 240         # TODO: implement
 241         return 0
 242
 243     def __str__(self):
 244         return self.title.encode('ascii', errors='replace')
 245
 246     def __unicode(self):
 247         return self.title
 248
 249
 250 class Episode(UUIDModel, TitleModel, DescriptionModel, LinkModel,
 251         LanguageModel, LastUpdateModel, UpdateInfoModel, LicenseModel,
 252         FlattrModel, ContentTypesModel, MergedIdsModel, OutdatedModel,
 253         AuthorModel, UrlsMixin, SlugsMixin, MergedUUIDsMixin):
 254     """ An episode """
 255
 256     guid = models.CharField(max_length=200, null=True)
 257     content = models.TextField()
 258     released = models.DateTimeField(null=True)
 259     duration = models.PositiveIntegerField(null=True)
 260     filesize = models.BigIntegerField(null=True)
 261     mimetypes = models.CharField(max_length=50)
 262     podcast = models.ForeignKey(Podcast)
 263     listeners = models.PositiveIntegerField(null=True)
 264
 265     class Meta:
 266         ordering = ['-released']
 267
 268     def __str__(self):
 269         return self.title.encode('ascii', errors='replace')
 270
 271     def __unicode__(self):
 272         return self.title
 273
 274
 275 class ScopedModel(models.Model):
 276
 277     # A slug / URL is unique within a scope; no two podcasts can have the same
 278     # URL (scope None), and no two episdoes of the same podcast (scope =
 279     # podcast-ID) can have the same URL
 280     scope = UUIDField(null=True, db_index=True)
 281
 282     class Meta:
 283         abstract = True
 284
 285
 286 class URL(OrderedModel, ScopedModel):
 287     """ Podcasts and Episodes can have multiple URLs
 288
 289     URLs are ordered, and the first slug is considered the canonical one """
 290
 291     url = models.URLField(max_length=2048)
 292
 293     # see https://docs.djangoproject.com/en/1.6/ref/contrib/contenttypes/#generic-relations
 294     content_type = models.ForeignKey(ContentType)
 295     object_id = UUIDField()
 296     content_object = generic.GenericForeignKey('content_type', 'object_id')
 297
 298     class Meta:
 299         unique_together = (
 300             # a URL is unique per scope
 301             ('url', 'scope'),
 302
 303             # URLs of an object must be ordered, so that no two slugs of one
 304             # object have the same order key
 305             ('content_type', 'object_id', 'order'),
 306         )
 307
 308         verbose_name = 'URL'
 309         verbose_name_plural = 'URLs'
 310
 311
 312 class Tag(models.Model):
 313     """ Tags any kind of Model
 314
 315     See also :class:`TagsMixin`
 316     """
 317
 318     FEED = 1
 319     DELICIOUS = 2
 320     USER = 4
 321
 322     SOURCE_CHOICES = (
 323         (FEED, 'Feed'),
 324         (DELICIOUS, 'delicious'),
 325         (USER, 'User'),
 326     )
 327
 328     tag = models.SlugField()
 329     source = models.PositiveSmallIntegerField(choices=SOURCE_CHOICES)
 330     #user = models.ForeignKey(null=True)
 331
 332     # see https://docs.djangoproject.com/en/1.6/ref/contrib/contenttypes/#generic-relations
 333     content_type = models.ForeignKey(ContentType)
 334     object_id = UUIDField()
 335     content_object = generic.GenericForeignKey('content_type', 'object_id')
 336
 337     class Meta:
 338         unique_together = (
 339             # a tag can only be assigned once from one source to one item
 340             # TODO: add user to tuple
 341             ('tag', 'source', 'content_type', 'object_id'),
 342         )
 343
 344
 345 class Slug(OrderedModel, ScopedModel):
 346     """ Slug for any kind of Model
 347
 348     Slugs are ordered, and the first slug is considered the canonical one.
 349     See also :class:`SlugsMixin`
 350     """
 351
 352     slug = models.SlugField(max_length=150, db_index=True)
 353
 354     # see https://docs.djangoproject.com/en/1.6/ref/contrib/contenttypes/#generic-relations
 355     content_type = models.ForeignKey(ContentType)
 356     object_id = UUIDField()
 357     content_object = generic.GenericForeignKey('content_type', 'object_id')
 358
 359     class Meta:
 360         unique_together = (
 361             # a slug is unique per type; eg a podcast can have the same slug
 362             # as an episode, but no two podcasts can have the same slug
 363             ('slug', 'scope'),
 364
 365             # slugs of an object must be ordered, so that no two slugs of one
 366             # object have the same order key
 367             ('content_type', 'object_id', 'order'),
 368         )
 369
 370     def __repr__(self):
 371         return '{cls}(slug={slug}, order={order}, content_object={obj}'.format(
 372             cls=self.__class__.__name__,
 373             slug=self.slug,
 374             order=self.order,
 375             obj=self.content_object
 376         )
 377
 378
 379 class MergedUUID(models.Model):
 380     """ If objects are merged their UUIDs are stored for later reference
 381
 382     see also :class:`MergedUUIDsMixin`
 383     """
 384
 385     uuid = UUIDField(unique=True)
 386
 387     # see https://docs.djangoproject.com/en/1.6/ref/contrib/contenttypes/#generic-relations
 388     content_type = models.ForeignKey(ContentType)
 389     object_id = UUIDField()
 390     content_object = generic.GenericForeignKey('content_type', 'object_id')
 391
 392     class Meta:
 393         verbose_name = 'Merged UUID'
 394         verbose_name_plural = 'Merged UUIDs'