mygpo/users/models.py

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