mygpo/core/models.py

   1 from __future__ import division
   2
   3 import hashlib
   4 import os.path
   5 import re
   6 from datetime import datetime
   7 from dateutil import parser
   8 from random import randint, random
   9
  10 from couchdbkit.ext.django.schema import *
  11 from restkit.errors import Unauthorized
  12
  13 from django.conf import settings
  14 from django.core.urlresolvers import reverse
  15
  16 from mygpo.decorators import repeat_on_conflict
  17 from mygpo import utils
  18 from mygpo.cache import cache_result
  19 from mygpo.couch import get_main_database
  20 from mygpo.core.proxy import DocumentABCMeta
  21 from mygpo.core.slugs import SlugMixin
  22 from mygpo.core.oldid import OldIdMixin
  23 from mygpo.web.logo import CoverArt
  24
  25
  26 class SubscriptionException(Exception):
  27     pass
  28
  29
  30 class MergedIdException(Exception):
  31     """ raised when an object is accessed through one of its merged_ids """
  32
  33     def __init__(self, obj, current_id):
  34         self.obj = obj
  35         self.current_id = current_id
  36
  37
  38 class Episode(Document, SlugMixin, OldIdMixin):
  39     """
  40     Represents an Episode. Can only be part of a Podcast
  41     """
  42
  43     __metaclass__ = DocumentABCMeta
  44
  45     title = StringProperty()
  46     description = StringProperty()
  47     link = StringProperty()
  48     released = DateTimeProperty()
  49     author = StringProperty()
  50     duration = IntegerProperty()
  51     filesize = IntegerProperty()
  52     language = StringProperty()
  53     last_update = DateTimeProperty()
  54     outdated = BooleanProperty(default=False)
  55     mimetypes = StringListProperty()
  56     merged_ids = StringListProperty()
  57     urls = StringListProperty()
  58     podcast = StringProperty(required=True)
  59     listeners = IntegerProperty()
  60     content_types = StringListProperty()
  61
  62
  63
  64     @property
  65     def url(self):
  66         return self.urls[0]
  67
  68     def __repr__(self):
  69         return 'Episode %s' % self._id
  70
  71
  72
  73     def get_short_title(self, common_title):
  74         if not self.title or not common_title:
  75             return None
  76
  77         title = self.title.replace(common_title, '').strip()
  78         title = re.sub(r'^[\W\d]+', '', title)
  79         return title
  80
  81
  82     def get_episode_number(self, common_title):
  83         if not self.title or not common_title:
  84             return None
  85
  86         title = self.title.replace(common_title, '').strip()
  87         match = re.search(r'^\W*(\d+)', title)
  88         if not match:
  89             return None
  90
  91         return int(match.group(1))
  92
  93
  94     def get_ids(self):
  95         return set([self._id] + self.merged_ids)
  96
  97
  98     @classmethod
  99     def all(cls):
 100         return utils.multi_request_view(cls, 'episodes/by_podcast',
 101                 reduce       = False,
 102                 include_docs = True,
 103                 stale        = 'update_after',
 104             )
 105
 106     def __eq__(self, other):
 107         if other == None:
 108             return False
 109         return self._id == other._id
 110
 111
 112     def __hash__(self):
 113         return hash(self._id)
 114
 115
 116     def __str__(self):
 117         return '<{cls} {title} ({id})>'.format(cls=self.__class__.__name__,
 118                 title=self.title, id=self._id)
 119
 120     __repr__ = __str__
 121
 122
 123 class SubscriberData(DocumentSchema):
 124     timestamp = DateTimeProperty()
 125     subscriber_count = IntegerProperty()
 126
 127     def __eq__(self, other):
 128         if not isinstance(other, SubscriberData):
 129             return False
 130
 131         return (self.timestamp == other.timestamp) and \
 132                (self.subscriber_count == other.subscriber_count)
 133
 134     def __hash__(self):
 135         return hash(frozenset([self.timestamp, self.subscriber_count]))
 136
 137
 138 class PodcastSubscriberData(Document):
 139     podcast = StringProperty()
 140     subscribers = SchemaListProperty(SubscriberData)
 141
 142     @classmethod
 143     def for_podcast(cls, id):
 144         r = cls.view('podcasts/subscriber_data', key=id, include_docs=True)
 145         if r:
 146             return r.first()
 147
 148         data = PodcastSubscriberData()
 149         data.podcast = id
 150         return data
 151
 152     def __repr__(self):
 153         return 'PodcastSubscriberData for Podcast %s (%s)' % (self.podcast, self._id)
 154
 155
 156 class Podcast(Document, SlugMixin, OldIdMixin):
 157
 158     __metaclass__ = DocumentABCMeta
 159
 160     id = StringProperty()
 161     title = StringProperty()
 162     urls = StringListProperty()
 163     description = StringProperty()
 164     link = StringProperty()
 165     last_update = DateTimeProperty()
 166     logo_url = StringProperty()
 167     author = StringProperty()
 168     merged_ids = StringListProperty()
 169     group = StringProperty()
 170     group_member_name = StringProperty()
 171     related_podcasts = StringListProperty()
 172     subscribers = SchemaListProperty(SubscriberData)
 173     language = StringProperty()
 174     content_types = StringListProperty()
 175     tags = DictProperty()
 176     restrictions = StringListProperty()
 177     common_episode_title = StringProperty()
 178     new_location = StringProperty()
 179     latest_episode_timestamp = DateTimeProperty()
 180     episode_count = IntegerProperty()
 181     random_key = FloatProperty(default=random)
 182
 183
 184
 185     def get_podcast_by_id(self, id, current_id=False):
 186         if current_id and id != self.get_id():
 187             raise MergedIdException(self, self.get_id())
 188
 189         return self
 190
 191
 192     get_podcast_by_oldid = get_podcast_by_id
 193     get_podcast_by_url = get_podcast_by_id
 194
 195
 196     def get_id(self):
 197         return self.id or self._id
 198
 199     def get_ids(self):
 200         return set([self.get_id()] + self.merged_ids)
 201
 202     @property
 203     def display_title(self):
 204         return self.title or self.url
 205
 206
 207     def group_with(self, other, grouptitle, myname, othername):
 208
 209         if self.group and (self.group == other.group):
 210             # they are already grouped
 211             return
 212
 213         group1 = PodcastGroup.get(self.group) if self.group else None
 214         group2 = PodcastGroup.get(other.group) if other.group else None
 215
 216         if group1 and group2:
 217             raise ValueError('both podcasts already are in different groups')
 218
 219         elif not (group1 or group2):
 220             group = PodcastGroup(title=grouptitle)
 221             group.save()
 222             group.add_podcast(self, myname)
 223             group.add_podcast(other, othername)
 224             return group
 225
 226         elif group1:
 227             group1.add_podcast(other, othername)
 228             return group1
 229
 230         else:
 231             group2.add_podcast(self, myname)
 232             return group2
 233
 234
 235
 236     def get_episode_count(self, since=None, until={}, **kwargs):
 237
 238         # use stored episode count for better performance
 239         if getattr(self, 'episode_count', None) is not None:
 240             return self.episode_count
 241
 242         from mygpo.db.couchdb import episode_count_for_podcast
 243         return episode_count_for_podcast(self, since, until, **kwargs)
 244
 245
 246     def get_common_episode_title(self, num_episodes=100):
 247
 248         if self.common_episode_title:
 249             return self.common_episode_title
 250
 251         from mygpo.db.couchdb.episode import episodes_for_podcast
 252         episodes = episodes_for_podcast(self, descending=True, limit=num_episodes)
 253
 254         # We take all non-empty titles
 255         titles = filter(None, (e.title for e in episodes))
 256         # get the longest common substring
 257         common_title = utils.longest_substr(titles)
 258
 259         # but consider only the part up to the first number. Otherwise we risk
 260         # removing part of the number (eg if a feed contains episodes 100-199)
 261         common_title = re.search(r'^\D*', common_title).group(0)
 262
 263         if len(common_title.strip()) < 2:
 264             return None
 265
 266         return common_title
 267
 268
 269     @cache_result(timeout=60*60)
 270     def get_latest_episode(self):
 271         # since = 1 ==> has a timestamp
 272
 273         from mygpo.db.couchdb.episode import episodes_for_podcast
 274         episodes = episodes_for_podcast(self, since=1, descending=True, limit=1)
 275         return next(iter(episodes), None)
 276
 277
 278     def get_episode_before(self, episode):
 279         if not episode.released:
 280             return None
 281
 282         from mygpo.db.couchdb.episode import episodes_for_podcast
 283         prevs = episodes_for_podcast(self, until=episode.released,
 284                 descending=True, limit=1)
 285
 286         return next(iter(prevs), None)
 287
 288
 289     def get_episode_after(self, episode):
 290         if not episode.released:
 291             return None
 292
 293         from mygpo.db.couchdb.episode import episodes_for_podcast
 294         nexts = episodes_for_podcast(self, since=episode.released, limit=1)
 295
 296         return next(iter(nexts), None)
 297
 298
 299     @property
 300     def url(self):
 301         return self.urls[0]
 302
 303
 304     def get_podcast(self):
 305         return self
 306
 307
 308     def get_logo_url(self, size):
 309         if self.logo_url:
 310             filename = hashlib.sha1(self.logo_url).hexdigest()
 311         else:
 312             filename = 'podcast-%d.png' % (hash(self.title) % 5, )
 313
 314         prefix = CoverArt.get_prefix(filename)
 315
 316         return reverse('logo', args=[size, prefix, filename])
 317
 318
 319     def subscriber_change(self):
 320         prev = self.prev_subscriber_count()
 321         if prev <= 0:
 322             return 0
 323
 324         return self.subscriber_count() / prev
 325
 326
 327     def subscriber_count(self):
 328         if not self.subscribers:
 329             return 0
 330         return self.subscribers[-1].subscriber_count
 331
 332
 333     def prev_subscriber_count(self):
 334         if len(self.subscribers) < 2:
 335             return 0
 336         return self.subscribers[-2].subscriber_count
 337
 338
 339     def get_all_subscriber_data(self):
 340         subdata = PodcastSubscriberData.for_podcast(self.get_id())
 341         return sorted(self.subscribers + subdata.subscribers,
 342                 key=lambda s: s.timestamp)
 343
 344
 345     @repeat_on_conflict()
 346     def subscribe(self, user, device):
 347         from mygpo.db.couchdb.podcast_state import podcast_state_for_user_podcast
 348         state = podcast_state_for_user_podcast(user, self)
 349         state.subscribe(device)
 350         try:
 351             state.save()
 352         except Unauthorized as ex:
 353             raise SubscriptionException(ex)
 354
 355
 356     @repeat_on_conflict()
 357     def unsubscribe(self, user, device):
 358         from mygpo.db.couchdb.podcast_state import podcast_state_for_user_podcast
 359         state = podcast_state_for_user_podcast(user, self)
 360         state.unsubscribe(device)
 361         try:
 362             state.save()
 363         except Unauthorized as ex:
 364             raise SubscriptionException(ex)
 365
 366
 367     def subscribe_targets(self, user):
 368         """
 369         returns all Devices and SyncGroups on which this podcast can be subsrbied. This excludes all
 370         devices/syncgroups on which the podcast is already subscribed
 371         """
 372         targets = []
 373
 374         subscriptions_by_devices = user.get_subscriptions_by_device()
 375
 376         for group in user.get_grouped_devices():
 377
 378             if group.is_synced:
 379
 380                 dev = group.devices[0]
 381
 382                 if not self.get_id() in subscriptions_by_devices[dev.id]:
 383                     targets.append(group.devices)
 384
 385             else:
 386                 for device in group.devices:
 387                     if not self.get_id() in subscriptions_by_devices[device.id]:
 388                         targets.append(device)
 389
 390         return targets
 391
 392
 393     def __hash__(self):
 394         return hash(self.get_id())
 395
 396
 397     def __repr__(self):
 398         if not self._id:
 399             return super(Podcast, self).__repr__()
 400         elif self.oldid:
 401             return '%s %s (%s)' % (self.__class__.__name__, self.get_id(), self.oldid)
 402         else:
 403             return '%s %s' % (self.__class__.__name__, self.get_id())
 404
 405
 406     def save(self):
 407         group = getattr(self, 'group', None)
 408         if group: #we are part of a PodcastGroup
 409             group = PodcastGroup.get(group)
 410             podcasts = list(group.podcasts)
 411
 412             if not self in podcasts:
 413                 # the podcast has not been added to the group correctly
 414                 group.add_podcast(self)
 415
 416             else:
 417                 i = podcasts.index(self)
 418                 podcasts[i] = self
 419                 group.podcasts = podcasts
 420                 group.save()
 421
 422             i = podcasts.index(self)
 423             podcasts[i] = self
 424             group.podcasts = podcasts
 425             group.save()
 426
 427         else:
 428             super(Podcast, self).save()
 429
 430
 431     def delete(self):
 432         group = getattr(self, 'group', None)
 433         if group:
 434             group = PodcastGroup.get(group)
 435             podcasts = list(group.podcasts)
 436
 437             if self in podcasts:
 438                 i = podcasts.index(self)
 439                 del podcasts[i]
 440                 group.podcasts = podcasts
 441                 group.save()
 442
 443         else:
 444             super(Podcast, self).delete()
 445
 446
 447     def __eq__(self, other):
 448         if not self.get_id():
 449             return self == other
 450
 451         if other == None:
 452             return False
 453
 454         return self.get_id() == other.get_id()
 455
 456
 457
 458 class PodcastGroup(Document, SlugMixin, OldIdMixin):
 459     title    = StringProperty()
 460     podcasts = SchemaListProperty(Podcast)
 461
 462     def get_id(self):
 463         return self._id
 464
 465
 466     @classmethod
 467     def for_slug_id(cls, slug_id):
 468         """ Returns the Podcast for either an CouchDB-ID for a Slug """
 469
 470         if utils.is_couchdb_id(slug_id):
 471             return cls.get(slug_id)
 472         else:
 473             #TODO: implement
 474             return cls.for_slug(slug_id)
 475
 476
 477     def get_podcast_by_id(self, id, current_id=False):
 478         for podcast in self.podcasts:
 479             if podcast.get_id() == id:
 480                 return podcast
 481
 482             if id in podcast.merged_ids:
 483                 if current_id:
 484                     raise MergedIdException(podcast, podcast.get_id())
 485
 486                 return podcast
 487
 488
 489     def get_podcast_by_oldid(self, oldid):
 490         for podcast in list(self.podcasts):
 491             if podcast.oldid == oldid:
 492                 return podcast
 493
 494
 495     def get_podcast_by_url(self, url):
 496         for podcast in self.podcasts:
 497             if url in list(podcast.urls):
 498                 return podcast
 499
 500
 501     def subscriber_change(self):
 502         prev = self.prev_subscriber_count()
 503         if not prev:
 504             return 0
 505
 506         return self.subscriber_count() / prev
 507
 508
 509     def subscriber_count(self):
 510         return sum([p.subscriber_count() for p in self.podcasts])
 511
 512
 513     def prev_subscriber_count(self):
 514         return sum([p.prev_subscriber_count() for p in self.podcasts])
 515
 516     @property
 517     def display_title(self):
 518         return self.title
 519
 520
 521     def get_podcast(self):
 522         # return podcast with most subscribers (bug 1390)
 523         return sorted(self.podcasts, key=Podcast.subscriber_count,
 524                 reverse=True)[0]
 525
 526
 527     @property
 528     def logo_url(self):
 529         return utils.first(p.logo_url for p in self.podcasts)
 530
 531
 532     def get_logo_url(self, size):
 533         if self.logo_url:
 534             filename = hashlib.sha1(self.logo_url).hexdigest()
 535         else:
 536             filename = 'podcast-%d.png' % (hash(self.title) % 5, )
 537
 538         prefix = CoverArt.get_prefix(filename)
 539
 540         return reverse('logo', args=[size, prefix, filename])
 541
 542
 543     def add_podcast(self, podcast, member_name):
 544
 545         if not self._id:
 546             raise ValueError('group has to have an _id first')
 547
 548         if not podcast._id:
 549             raise ValueError('podcast needs to have an _id first')
 550
 551         if not podcast.id:
 552             podcast.id = podcast._id
 553
 554         podcast.delete()
 555         podcast.group = self._id
 556         podcast.group_member_name = member_name
 557         self.podcasts = sorted(self.podcasts + [podcast],
 558                         key=Podcast.subscriber_count, reverse=True)
 559         self.save()
 560
 561
 562     def __repr__(self):
 563         if not self._id:
 564             return super(PodcastGroup, self).__repr__()
 565         elif self.oldid:
 566             return '%s %s (%s)' % (self.__class__.__name__, self._id[:10], self.oldid)
 567         else:
 568             return '%s %s' % (self.__class__.__name__, self._id[:10])
 569
 570
 571 class SanitizingRuleStub(object):
 572     pass
 573
 574 class SanitizingRule(Document):
 575     slug        = StringProperty()
 576     applies_to  = StringListProperty()
 577     search      = StringProperty()
 578     replace     = StringProperty()
 579     priority    = IntegerProperty()
 580     description = StringProperty()
 581
 582
 583     @classmethod
 584     def for_obj_type(cls, obj_type):
 585         r = cls.view('sanitizing_rules/by_target', include_docs=True,
 586             startkey=[obj_type, None], endkey=[obj_type, {}])
 587
 588         for rule in r:
 589             obj = SanitizingRuleStub()
 590             obj.slug = rule.slug
 591             obj.applies_to = list(rule.applies_to)
 592             obj.search = rule.search
 593             obj.replace = rule.replace
 594             obj.priority = rule.priority
 595             obj.description = rule.description
 596             yield obj
 597
 598
 599     @classmethod
 600     def for_slug(cls, slug):
 601         r = cls.view('sanitizing_rules/by_slug', include_docs=True,
 602             key=slug)
 603         return r.one() if r else None
 604
 605
 606     def __repr__(self):
 607         return 'SanitizingRule %s' % self._id