mygpo/core/models.py

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