mygpo/users/models.py

   1 import re
   2 import uuid
   3 import collections
   4 from datetime import datetime
   5 import dateutil.parser
   6 from itertools import imap
   7 from operator import itemgetter
   8 import random
   9 import string
  10
  11 from couchdbkit.ext.django.schema import *
  12
  13 from django.core.cache import cache
  14
  15 from django_couchdb_utils.registration.models import User as BaseUser
  16
  17 from mygpo.utils import linearize
  18 from mygpo.core.proxy import DocumentABCMeta, proxy_object
  19 from mygpo.decorators import repeat_on_conflict
  20 from mygpo.users.ratings import RatingMixin
  21 from mygpo.users.sync import SyncedDevicesMixin
  22 from mygpo.users.subscriptions import subscription_changes, podcasts_for_states
  23 from mygpo.users.settings import FAV_FLAG, PUBLIC_SUB_PODCAST, SettingsMixin
  24 from mygpo.db.couchdb.podcast import podcasts_by_id, podcasts_to_dict
  25 from mygpo.db.couchdb.user import user_history, device_history
  26
  27 # make sure this code is executed at startup
  28 from mygpo.users.signals import *
  29
  30
  31 RE_DEVICE_UID = re.compile(r'^[\w.-]+$')
  32
  33 # TODO: derive from ValidationException?
  34 class InvalidEpisodeActionAttributes(ValueError):
  35     """ raised when the attribues of an episode action fail validation """
  36
  37
  38 class DeviceUIDException(Exception):
  39     pass
  40
  41
  42 class DeviceDoesNotExist(Exception):
  43     pass
  44
  45
  46 class DeviceDeletedException(DeviceDoesNotExist):
  47     pass
  48
  49
  50 class Suggestions(Document, RatingMixin):
  51     user = StringProperty(required=True)
  52     user_oldid = IntegerProperty()
  53     podcasts = StringListProperty()
  54     blacklist = StringListProperty()
  55
  56
  57     def get_podcasts(self, count=None):
  58         user = User.get(self.user)
  59         subscriptions = user.get_subscribed_podcast_ids()
  60
  61         ids = filter(lambda x: not x in self.blacklist + subscriptions, self.podcasts)
  62         if count:
  63             ids = ids[:count]
  64         return filter(lambda x: x and x.title, podcasts_by_id(ids))
  65
  66
  67     def __repr__(self):
  68         if not self._id:
  69             return super(Suggestions, self).__repr__()
  70         else:
  71             return '%d Suggestions for %s (%s)' % \
  72                 (len(self.podcasts), self.user, self._id)
  73
  74
  75 class EpisodeAction(DocumentSchema):
  76     """
  77     One specific action to an episode. Must
  78     always be part of a EpisodeUserState
  79     """
  80
  81     action        = StringProperty(required=True)
  82
  83     # walltime of the event (assigned by the uploading client, defaults to now)
  84     timestamp     = DateTimeProperty(required=True, default=datetime.utcnow)
  85
  86     # upload time of the event
  87     upload_timestamp = IntegerProperty(required=True)
  88
  89     device_oldid  = IntegerProperty(required=False)
  90     device        = StringProperty()
  91     started       = IntegerProperty()
  92     playmark      = IntegerProperty()
  93     total         = IntegerProperty()
  94
  95     def __eq__(self, other):
  96         if not isinstance(other, EpisodeAction):
  97             return False
  98         vals = ('action', 'timestamp', 'device', 'started', 'playmark',
  99                 'total')
 100         return all([getattr(self, v, None) == getattr(other, v, None) for v in vals])
 101
 102
 103     def to_history_entry(self):
 104         entry = HistoryEntry()
 105         entry.action = self.action
 106         entry.timestamp = self.timestamp
 107         entry.device_id = self.device
 108         entry.started = self.started
 109         entry.position = self.playmark
 110         entry.total = self.total
 111         return entry
 112
 113
 114
 115     def validate_time_values(self):
 116         """ Validates allowed combinations of time-values """
 117
 118         PLAY_ACTION_KEYS = ('playmark', 'started', 'total')
 119
 120         # Key found, but must not be supplied (no play action!)
 121         if self.action != 'play':
 122             for key in PLAY_ACTION_KEYS:
 123                 if getattr(self, key, None) is not None:
 124                     raise InvalidEpisodeActionAttributes('%s only allowed in play actions' % key)
 125
 126         # Sanity check: If started or total are given, require playmark
 127         if ((self.started is not None) or (self.total is not None)) and \
 128                 self.playmark is None:
 129             raise InvalidEpisodeActionAttributes('started and total require position')
 130
 131         # Sanity check: total and playmark can only appear together
 132         if ((self.total is not None) or (self.started is not None)) and \
 133            ((self.total is None) or (self.started is None)):
 134             raise InvalidEpisodeActionAttributes('total and started can only appear together')
 135
 136
 137     def __repr__(self):
 138         return '%s-Action on %s at %s (in %s)' % \
 139             (self.action, self.device, self.timestamp, self._id)
 140
 141
 142     def __hash__(self):
 143         return hash(frozenset([self.action, self.timestamp, self.device,
 144                     self.started, self.playmark, self.total]))
 145
 146
 147 class Chapter(Document):
 148     """ A user-entered episode chapter """
 149
 150     device = StringProperty()
 151     created = DateTimeProperty()
 152     start = IntegerProperty(required=True)
 153     end = IntegerProperty(required=True)
 154     label = StringProperty()
 155     advertisement = BooleanProperty()
 156
 157
 158     def __repr__(self):
 159         return '<%s %s (%d-%d)>' % (self.__class__.__name__, self.label,
 160                 self.start, self.end)
 161
 162
 163 class EpisodeUserState(Document, SettingsMixin):
 164     """
 165     Contains everything a user has done with an Episode
 166     """
 167
 168     episode       = StringProperty(required=True)
 169     actions       = SchemaListProperty(EpisodeAction)
 170     user_oldid    = IntegerProperty()
 171     user          = StringProperty(required=True)
 172     ref_url       = StringProperty(required=True)
 173     podcast_ref_url = StringProperty(required=True)
 174     merged_ids    = StringListProperty()
 175     chapters      = SchemaListProperty(Chapter)
 176     podcast       = StringProperty(required=True)
 177
 178
 179
 180     def add_actions(self, actions):
 181         map(EpisodeAction.validate_time_values, actions)
 182         self.actions = list(self.actions) + actions
 183         self.actions = list(set(self.actions))
 184         self.actions = sorted(self.actions, key=lambda x: x.timestamp)
 185
 186
 187     def is_favorite(self):
 188         return self.get_wksetting(FAV_FLAG)
 189
 190
 191     def set_favorite(self, set_to=True):
 192         self.settings[FAV_FLAG.name] = set_to
 193
 194
 195     def update_chapters(self, add=[], rem=[]):
 196         """ Updates the Chapter list
 197
 198          * add contains the chapters to be added
 199
 200          * rem contains tuples of (start, end) times. Chapters that match
 201            both endpoints will be removed
 202         """
 203
 204         @repeat_on_conflict(['state'])
 205         def update(state):
 206             for chapter in add:
 207                 self.chapters = self.chapters + [chapter]
 208
 209             for start, end in rem:
 210                 keep = lambda c: c.start != start or c.end != end
 211                 self.chapters = filter(keep, self.chapters)
 212
 213             self.save()
 214
 215         update(state=self)
 216
 217
 218     def get_history_entries(self):
 219         return imap(EpisodeAction.to_history_entry, self.actions)
 220
 221
 222     def __repr__(self):
 223         return 'Episode-State %s (in %s)' % \
 224             (self.episode, self._id)
 225
 226     def __eq__(self, other):
 227         if not isinstance(other, EpisodeUserState):
 228             return False
 229
 230         return (self.episode == other.episode and
 231                 self.user == other.user)
 232
 233
 234
 235 class SubscriptionAction(Document):
 236     action    = StringProperty()
 237     timestamp = DateTimeProperty(default=datetime.utcnow)
 238     device    = StringProperty()
 239
 240
 241     __metaclass__ = DocumentABCMeta
 242
 243
 244     def __cmp__(self, other):
 245         return cmp(self.timestamp, other.timestamp)
 246
 247     def __eq__(self, other):
 248         return self.action == other.action and \
 249                self.timestamp == other.timestamp and \
 250                self.device == other.device
 251
 252     def __hash__(self):
 253         return hash(self.action) + hash(self.timestamp) + hash(self.device)
 254
 255     def __repr__(self):
 256         return '<SubscriptionAction %s on %s at %s>' % (
 257             self.action, self.device, self.timestamp)
 258
 259
 260 class PodcastUserState(Document, SettingsMixin):
 261     """
 262     Contains everything that a user has done
 263     with a specific podcast and all its episodes
 264     """
 265
 266     podcast       = StringProperty(required=True)
 267     user_oldid    = IntegerProperty()
 268     user          = StringProperty(required=True)
 269     actions       = SchemaListProperty(SubscriptionAction)
 270     tags          = StringListProperty()
 271     ref_url       = StringProperty(required=True)
 272     disabled_devices = StringListProperty()
 273     merged_ids    = StringListProperty()
 274
 275
 276     def remove_device(self, device):
 277         """
 278         Removes all actions from the podcast state that refer to the
 279         given device
 280         """
 281         self.actions = filter(lambda a: a.device != device.id, self.actions)
 282
 283
 284     def subscribe(self, device):
 285         action = SubscriptionAction()
 286         action.action = 'subscribe'
 287         action.device = device.id
 288         self.add_actions([action])
 289
 290
 291     def unsubscribe(self, device):
 292         action = SubscriptionAction()
 293         action.action = 'unsubscribe'
 294         action.device = device.id
 295         self.add_actions([action])
 296
 297
 298     def add_actions(self, actions):
 299         self.actions = list(set(self.actions + actions))
 300         self.actions = sorted(self.actions)
 301
 302
 303     def add_tags(self, tags):
 304         self.tags = list(set(self.tags + tags))
 305
 306
 307     def set_device_state(self, devices):
 308         disabled_devices = [device.id for device in devices if device.deleted]
 309         self.disabled_devices = disabled_devices
 310
 311
 312     def get_change_between(self, device_id, since, until):
 313         """
 314         Returns the change of the subscription status for the given device
 315         between the two timestamps.
 316
 317         The change is given as either 'subscribe' (the podcast has been
 318         subscribed), 'unsubscribed' (the podcast has been unsubscribed) or
 319         None (no change)
 320         """
 321
 322         device_actions = filter(lambda x: x.device == device_id, self.actions)
 323         before = filter(lambda x: x.timestamp <= since, device_actions)
 324         after  = filter(lambda x: x.timestamp <= until, device_actions)
 325
 326         # nothing happened, so there can be no change
 327         if not after:
 328             return None
 329
 330         then = before[-1] if before else None
 331         now  = after[-1]
 332
 333         if then is None:
 334             if now.action != 'unsubscribe':
 335                 return now.action
 336         elif then.action != now.action:
 337             return now.action
 338         return None
 339
 340
 341     def get_subscribed_device_ids(self):
 342         """ device Ids on which the user subscribed to the podcast """
 343         devices = set()
 344
 345         for action in self.actions:
 346             if action.action == "subscribe":
 347                 if not action.device in self.disabled_devices:
 348                     devices.add(action.device)
 349             else:
 350                 if action.device in devices:
 351                     devices.remove(action.device)
 352
 353         return devices
 354
 355
 356     def is_subscribed_on(self, device):
 357         """ checks if the podcast is subscribed on the given device """
 358
 359         for action in reversed(self.actions):
 360             if not action.device == device.id:
 361                 continue
 362
 363             # we only need to check the latest action for the device
 364             return (action.action == 'subscribe')
 365
 366         # we haven't found any matching action
 367         return False
 368
 369
 370     def is_public(self):
 371         return self.get_wksetting(PUBLIC_SUB_PODCAST)
 372
 373
 374     def __eq__(self, other):
 375         if other is None:
 376             return False
 377
 378         return self.podcast == other.podcast and \
 379                self.user == other.user
 380
 381     def __repr__(self):
 382         return 'Podcast %s for User %s (%s)' % \
 383             (self.podcast, self.user, self._id)
 384
 385
 386 class Device(Document, SettingsMixin):
 387     id       = StringProperty(default=lambda: uuid.uuid4().hex)
 388     oldid    = IntegerProperty(required=False)
 389     uid      = StringProperty(required=True)
 390     name     = StringProperty(required=True, default='New Device')
 391     type     = StringProperty(required=True, default='other')
 392     deleted  = BooleanProperty(default=False)
 393     user_agent = StringProperty()
 394
 395
 396     def get_subscription_changes(self, since, until):
 397         """
 398         Returns the subscription changes for the device as two lists.
 399         The first lists contains the Ids of the podcasts that have been
 400         subscribed to, the second list of those that have been unsubscribed
 401         from.
 402         """
 403
 404         from mygpo.db.couchdb.podcast_state import podcast_states_for_device
 405         podcast_states = podcast_states_for_device(self.id)
 406         return subscription_changes(self.id, podcast_states, since, until)
 407
 408
 409     def get_latest_changes(self):
 410
 411         from mygpo.db.couchdb.podcast_state import podcast_states_for_device
 412
 413         podcast_states = podcast_states_for_device(self.id)
 414         for p_state in podcast_states:
 415             actions = filter(lambda x: x.device == self.id, reversed(p_state.actions))
 416             if actions:
 417                 yield (p_state.podcast, actions[0])
 418
 419
 420     def get_subscribed_podcast_states(self):
 421         r = PodcastUserState.view('subscriptions/by_device',
 422                 startkey     = [self.id, None],
 423                 endkey       = [self.id, {}],
 424                 include_docs = True
 425             )
 426         return list(r)
 427
 428
 429     def get_subscribed_podcast_ids(self):
 430         states = self.get_subscribed_podcast_states()
 431         return [state.podcast for state in states]
 432
 433
 434     def get_subscribed_podcasts(self):
 435         """ Returns all subscribed podcasts for the device
 436
 437         The attribute "url" contains the URL that was used when subscribing to
 438         the podcast """
 439
 440         states = self.get_subscribed_podcast_states()
 441         return podcasts_for_states(states)
 442
 443
 444     def __hash__(self):
 445         return hash(frozenset([self.id, self.uid, self.name, self.type, self.deleted]))
 446
 447
 448     def __eq__(self, other):
 449         return self.id == other.id
 450
 451
 452     def __repr__(self):
 453         return '<{cls} {id}>'.format(cls=self.__class__.__name__, id=self.id)
 454
 455
 456     def __str__(self):
 457         return self.name
 458
 459     def __unicode__(self):
 460         return self.name
 461
 462
 463
 464 TOKEN_NAMES = ('subscriptions_token', 'favorite_feeds_token',
 465         'publisher_update_token', 'userpage_token')
 466
 467
 468 class TokenException(Exception):
 469     pass
 470
 471
 472 class User(BaseUser, SyncedDevicesMixin, SettingsMixin):
 473     oldid    = IntegerProperty()
 474     devices  = SchemaListProperty(Device)
 475     published_objects = StringListProperty()
 476     deleted  = BooleanProperty(default=False)
 477     suggestions_up_to_date = BooleanProperty(default=False)
 478     twitter = StringProperty()
 479     about   = StringProperty()
 480     google_email = StringProperty()
 481
 482     # token for accessing subscriptions of this use
 483     subscriptions_token    = StringProperty(default=None)
 484
 485     # token for accessing the favorite-episodes feed of this user
 486     favorite_feeds_token   = StringProperty(default=None)
 487
 488     # token for automatically updating feeds published by this user
 489     publisher_update_token = StringProperty(default=None)
 490
 491     # token for accessing the userpage of this user
 492     userpage_token         = StringProperty(default=None)
 493
 494     class Meta:
 495         app_label = 'users'
 496
 497
 498     def create_new_token(self, token_name, length=32):
 499         """ creates a new random token """
 500
 501         if token_name not in TOKEN_NAMES:
 502             raise TokenException('Invalid token name %s' % token_name)
 503
 504         token = "".join(random.sample(string.letters+string.digits, length))
 505         setattr(self, token_name, token)
 506
 507
 508
 509     @repeat_on_conflict(['self'])
 510     def get_token(self, token_name):
 511         """ returns a token, and generate those that are still missing """
 512
 513         generated = False
 514
 515         if token_name not in TOKEN_NAMES:
 516             raise TokenException('Invalid token name %s' % token_name)
 517
 518         for tn in TOKEN_NAMES:
 519             if getattr(self, tn) is None:
 520                 self.create_new_token(tn)
 521                 generated = True
 522
 523         if generated:
 524             self.save()
 525
 526         return getattr(self, token_name)
 527
 528
 529
 530     @property
 531     def active_devices(self):
 532         not_deleted = lambda d: not d.deleted
 533         return filter(not_deleted, self.devices)
 534
 535
 536     @property
 537     def inactive_devices(self):
 538         deleted = lambda d: d.deleted
 539         return filter(deleted, self.devices)
 540
 541
 542     def get_devices_by_id(self):
 543         return dict( (device.id, device) for device in self.devices)
 544
 545
 546     def get_device(self, id):
 547
 548         if not hasattr(self, '__device_by_id'):
 549             self.__devices_by_id = dict( (d.id, d) for d in self.devices)
 550
 551         return self.__devices_by_id.get(id, None)
 552
 553
 554     def get_device_by_uid(self, uid, only_active=True):
 555
 556         if not hasattr(self, '__devices_by_uio'):
 557             self.__devices_by_uid = dict( (d.uid, d) for d in self.devices)
 558
 559         try:
 560             device = self.__devices_by_uid[uid]
 561
 562             if only_active and device.deleted:
 563                 raise DeviceDeletedException(
 564                         'Device with UID %s is deleted' % uid)
 565
 566             return device
 567
 568         except KeyError as e:
 569             raise DeviceDoesNotExist('There is no device with UID %s' % uid)
 570
 571
 572     @repeat_on_conflict(['self'])
 573     def update_device(self, device):
 574         """ Sets the device and saves the user """
 575         self.set_device(device)
 576         self.save()
 577
 578
 579     def set_device(self, device):
 580
 581         if not RE_DEVICE_UID.match(device.uid):
 582             raise DeviceUIDException(u"'{uid} is not a valid device ID".format(
 583                         uid=device.uid))
 584
 585         devices = list(self.devices)
 586         ids = [x.id for x in devices]
 587         if not device.id in ids:
 588             devices.append(device)
 589             self.devices = devices
 590             return
 591
 592         index = ids.index(device.id)
 593         devices.pop(index)
 594         devices.insert(index, device)
 595         self.devices = devices
 596
 597
 598     def remove_device(self, device):
 599         devices = list(self.devices)
 600         ids = [x.id for x in devices]
 601         if not device.id in ids:
 602             return
 603
 604         index = ids.index(device.id)
 605         devices.pop(index)
 606         self.devices = devices
 607
 608         if self.is_synced(device):
 609             self.unsync_device(device)
 610
 611
 612     def get_subscriptions_by_device(self, public=None):
 613         from mygpo.db.couchdb.podcast_state import subscriptions_by_user
 614         get_dev = itemgetter(2)
 615         groups = collections.defaultdict(list)
 616         subscriptions = subscriptions_by_user(self, public=public)
 617         subscriptions = sorted(subscriptions, key=get_dev)
 618
 619         for public, podcast_id, device_id in subscriptions:
 620             groups[device_id].append(podcast_id)
 621
 622         return groups
 623
 624
 625     def get_subscribed_podcast_states(self, public=None):
 626         """
 627         Returns the Ids of all subscribed podcasts
 628         """
 629
 630         r = PodcastUserState.view('subscriptions/by_user',
 631                 startkey     = [self._id, public, None, None],
 632                 endkey       = [self._id+'ZZZ', None, None, None],
 633                 reduce       = False,
 634                 include_docs = True
 635             )
 636
 637         return set(r)
 638
 639
 640     def get_subscribed_podcast_ids(self, public=None):
 641         states = self.get_subscribed_podcast_states(public=public)
 642         return [state.podcast for state in states]
 643
 644
 645
 646     def get_subscribed_podcasts(self, public=None):
 647         """ Returns all subscribed podcasts for the user
 648
 649         The attribute "url" contains the URL that was used when subscribing to
 650         the podcast """
 651
 652         states = self.get_subscribed_podcast_states(public=public)
 653         podcast_ids = [state.podcast for state in states]
 654         podcasts = podcasts_to_dict(podcast_ids)
 655
 656         for state in states:
 657             podcast = proxy_object(podcasts[state.podcast], url=state.ref_url)
 658             podcasts[state.podcast] = podcast
 659
 660         return podcasts.values()
 661
 662
 663
 664     def get_subscription_history(self, device_id=None, reverse=False, public=None):
 665         """ Returns chronologically ordered subscription history entries
 666
 667         Setting device_id restricts the actions to a certain device
 668         """
 669
 670         from mygpo.db.couchdb.podcast_state import podcast_states_for_user, \
 671             podcast_states_for_device
 672
 673         def action_iter(state):
 674             for action in sorted(state.actions, reverse=reverse):
 675                 if device_id is not None and device_id != action.device:
 676                     continue
 677
 678                 if public is not None and state.is_public() != public:
 679                     continue
 680
 681                 entry = HistoryEntry()
 682                 entry.timestamp = action.timestamp
 683                 entry.action = action.action
 684                 entry.podcast_id = state.podcast
 685                 entry.device_id = action.device
 686                 yield entry
 687
 688         if device_id is None:
 689             podcast_states = podcast_states_for_user(self)
 690         else:
 691             podcast_states = podcast_states_for_device(device_id)
 692
 693         # create an action_iter for each PodcastUserState
 694         subscription_action_lists = [action_iter(x) for x in podcast_states]
 695
 696         action_cmp_key = lambda x: x.timestamp
 697
 698         # Linearize their subscription-actions
 699         return linearize(action_cmp_key, subscription_action_lists, reverse)
 700
 701
 702     def get_global_subscription_history(self, public=None):
 703         """ Actions that added/removed podcasts from the subscription list
 704
 705         Returns an iterator of all subscription actions that either
 706          * added subscribed a podcast that hasn't been subscribed directly
 707            before the action (but could have been subscribed) earlier
 708          * removed a subscription of the podcast is not longer subscribed
 709            after the action
 710         """
 711
 712         subscriptions = collections.defaultdict(int)
 713
 714         for entry in self.get_subscription_history(public=public):
 715             if entry.action == 'subscribe':
 716                 subscriptions[entry.podcast_id] += 1
 717
 718                 # a new subscription has been added
 719                 if subscriptions[entry.podcast_id] == 1:
 720                     yield entry
 721
 722             elif entry.action == 'unsubscribe':
 723                 subscriptions[entry.podcast_id] -= 1
 724
 725                 # the last subscription has been removed
 726                 if subscriptions[entry.podcast_id] == 0:
 727                     yield entry
 728
 729
 730
 731     def get_newest_episodes(self, max_date, max_per_podcast=5):
 732         """ Returns the newest episodes of all subscribed podcasts
 733
 734         Only max_per_podcast episodes per podcast are loaded. Episodes with
 735         release dates above max_date are discarded.
 736
 737         This method returns a generator that produces the newest episodes.
 738
 739         The number of required DB queries is equal to the number of (distinct)
 740         podcasts of all consumed episodes (max: number of subscribed podcasts),
 741         plus a constant number of initial queries (when the first episode is
 742         consumed). """
 743
 744         cmp_key = lambda episode: episode.released or datetime(2000, 01, 01)
 745
 746         podcasts = list(self.get_subscribed_podcasts())
 747         podcasts = filter(lambda p: p.latest_episode_timestamp, podcasts)
 748         podcasts = sorted(podcasts, key=lambda p: p.latest_episode_timestamp,
 749                         reverse=True)
 750
 751         podcast_dict = dict((p.get_id(), p) for p in podcasts)
 752
 753         # contains the un-yielded episodes, newest first
 754         episodes = []
 755
 756         for podcast in podcasts:
 757
 758             yielded_episodes = 0
 759
 760             for episode in episodes:
 761                 # determine for which episodes there won't be a new episodes
 762                 # that is newer; those can be yielded
 763                 if episode.released > podcast.latest_episode_timestamp:
 764                     p = podcast_dict.get(episode.podcast, None)
 765                     yield proxy_object(episode, podcast=p)
 766                     yielded_episodes += 1
 767                 else:
 768                     break
 769
 770             # remove the episodes that have been yielded before
 771             episodes = episodes[yielded_episodes:]
 772
 773             # fetch and merge episodes for the next podcast
 774             from mygpo.db.couchdb.episode import episodes_for_podcast
 775             new_episodes = episodes_for_podcast(podcast, since=1,
 776                         until=max_date, descending=True, limit=max_per_podcast)
 777             episodes = sorted(episodes+new_episodes, key=cmp_key, reverse=True)
 778
 779
 780         # yield the remaining episodes
 781         for episode in episodes:
 782             podcast = podcast_dict.get(episode.podcast, None)
 783             yield proxy_object(episode, podcast=podcast)
 784
 785
 786     def __eq__(self, other):
 787         if not other:
 788             return False
 789
 790         # ensure that other isn't AnonymousUser
 791         return other.is_authenticated() and self._id == other._id
 792
 793
 794     def __ne__(self, other):
 795         return not(self == other)
 796
 797
 798     def __repr__(self):
 799         return 'User %s' % self._id
 800
 801
 802 class History(object):
 803
 804     def __init__(self, user, device):
 805         self.user = user
 806         self.device = device
 807
 808
 809     def __getitem__(self, key):
 810
 811         if isinstance(key, slice):
 812             start = key.start or 0
 813             length = key.stop - start
 814         else:
 815             start = key
 816             length = 1
 817
 818         if self.device:
 819             return device_history(self.user, self.device, start, length)
 820
 821         else:
 822             return user_history(self.user, start, length)
 823
 824
 825
 826 class HistoryEntry(object):
 827     """ A class that can represent subscription and episode actions """
 828
 829
 830     @classmethod
 831     def from_action_dict(cls, action):
 832
 833         entry = HistoryEntry()
 834
 835         if 'timestamp' in action:
 836             ts = action.pop('timestamp')
 837             entry.timestamp = dateutil.parser.parse(ts)
 838
 839         for key, value in action.items():
 840             setattr(entry, key, value)
 841
 842         return entry
 843
 844
 845     @property
 846     def playmark(self):
 847         return getattr(self, 'position', None)
 848
 849
 850     @classmethod
 851     def fetch_data(cls, user, entries,
 852             podcasts=None, episodes=None):
 853         """ Efficiently loads additional data for a number of entries """
 854
 855         if podcasts is None:
 856             # load podcast data
 857             podcast_ids = [getattr(x, 'podcast_id', None) for x in entries]
 858             podcast_ids = filter(None, podcast_ids)
 859             podcasts = podcasts_to_dict(podcast_ids)
 860
 861         if episodes is None:
 862             from mygpo.db.couchdb.episode import episodes_to_dict
 863             # load episode data
 864             episode_ids = [getattr(x, 'episode_id', None) for x in entries]
 865             episode_ids = filter(None, episode_ids)
 866             episodes = episodes_to_dict(episode_ids)
 867
 868         # load device data
 869         # does not need pre-populated data because no db-access is required
 870         device_ids = [getattr(x, 'device_id', None) for x in entries]
 871         device_ids = filter(None, device_ids)
 872         devices = dict([ (id, user.get_device(id)) for id in device_ids])
 873
 874
 875         for entry in entries:
 876             podcast_id = getattr(entry, 'podcast_id', None)
 877             entry.podcast = podcasts.get(podcast_id, None)
 878
 879             episode_id = getattr(entry, 'episode_id', None)
 880             entry.episode = episodes.get(episode_id, None)
 881
 882             if hasattr(entry, 'user'):
 883                 entry.user = user
 884
 885             device = devices.get(getattr(entry, 'device_id', None), None)
 886             entry.device = device
 887
 888
 889         return entries