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     @repeat_on_conflict(['self'])
 505     def get_token(self, token_name):
 506         """ returns a token, and generate those that are still missing """
 507
 508         generated = False
 509
 510         if token_name not in TOKEN_NAMES:
 511             raise TokenException('Invalid token name %s' % token_name)
 512
 513         for tn in TOKEN_NAMES:
 514             if getattr(self, tn) is None:
 515                 self.create_new_token(tn)
 516                 generated = True
 517
 518         if generated:
 519             self.save()
 520
 521         return getattr(self, token_name)
 522
 523
 524
 525     @property
 526     def active_devices(self):
 527         not_deleted = lambda d: not d.deleted
 528         return filter(not_deleted, self.devices)
 529
 530
 531     @property
 532     def inactive_devices(self):
 533         deleted = lambda d: d.deleted
 534         return filter(deleted, self.devices)
 535
 536
 537     def get_devices_by_id(self):
 538         return dict( (device.id, device) for device in self.devices)
 539
 540
 541     def get_device(self, id):
 542
 543         if not hasattr(self, '__device_by_id'):
 544             self.__devices_by_id = dict( (d.id, d) for d in self.devices)
 545
 546         return self.__devices_by_id.get(id, None)
 547
 548
 549     def get_device_by_uid(self, uid, only_active=True):
 550
 551         if not hasattr(self, '__devices_by_uio'):
 552             self.__devices_by_uid = dict( (d.uid, d) for d in self.devices)
 553
 554         try:
 555             device = self.__devices_by_uid[uid]
 556
 557             if only_active and device.deleted:
 558                 raise DeviceDeletedException(
 559                         'Device with UID %s is deleted' % uid)
 560
 561             return device
 562
 563         except KeyError as e:
 564             raise DeviceDoesNotExist('There is no device with UID %s' % uid)
 565
 566
 567     @repeat_on_conflict(['self'])
 568     def update_device(self, device):
 569         """ Sets the device and saves the user """
 570         self.set_device(device)
 571         self.save()
 572
 573
 574     def set_device(self, device):
 575
 576         if not RE_DEVICE_UID.match(device.uid):
 577             raise DeviceUIDException(u"'{uid} is not a valid device ID".format(
 578                         uid=device.uid))
 579
 580         devices = list(self.devices)
 581         ids = [x.id for x in devices]
 582         if not device.id in ids:
 583             devices.append(device)
 584             self.devices = devices
 585             return
 586
 587         index = ids.index(device.id)
 588         devices.pop(index)
 589         devices.insert(index, device)
 590         self.devices = devices
 591
 592
 593     def remove_device(self, device):
 594         devices = list(self.devices)
 595         ids = [x.id for x in devices]
 596         if not device.id in ids:
 597             return
 598
 599         index = ids.index(device.id)
 600         devices.pop(index)
 601         self.devices = devices
 602
 603         if self.is_synced(device):
 604             self.unsync_device(device)
 605
 606
 607     def get_subscriptions_by_device(self, public=None):
 608         from mygpo.db.couchdb.podcast_state import subscriptions_by_user
 609         get_dev = itemgetter(2)
 610         groups = collections.defaultdict(list)
 611         subscriptions = subscriptions_by_user(self, public=public)
 612         subscriptions = sorted(subscriptions, key=get_dev)
 613
 614         for public, podcast_id, device_id in subscriptions:
 615             groups[device_id].append(podcast_id)
 616
 617         return groups
 618
 619
 620     def get_subscribed_podcast_states(self, public=None):
 621         """
 622         Returns the Ids of all subscribed podcasts
 623         """
 624
 625         r = PodcastUserState.view('subscriptions/by_user',
 626                 startkey     = [self._id, public, None, None],
 627                 endkey       = [self._id+'ZZZ', None, None, None],
 628                 reduce       = False,
 629                 include_docs = True
 630             )
 631
 632         return set(r)
 633
 634
 635     def get_subscribed_podcast_ids(self, public=None):
 636         states = self.get_subscribed_podcast_states(public=public)
 637         return [state.podcast for state in states]
 638
 639
 640
 641     def get_subscribed_podcasts(self, public=None):
 642         """ Returns all subscribed podcasts for the user
 643
 644         The attribute "url" contains the URL that was used when subscribing to
 645         the podcast """
 646
 647         states = self.get_subscribed_podcast_states(public=public)
 648         podcast_ids = [state.podcast for state in states]
 649         podcasts = podcasts_to_dict(podcast_ids)
 650
 651         for state in states:
 652             podcast = proxy_object(podcasts[state.podcast], url=state.ref_url)
 653             podcasts[state.podcast] = podcast
 654
 655         return podcasts.values()
 656
 657
 658
 659     def get_subscription_history(self, device_id=None, reverse=False, public=None):
 660         """ Returns chronologically ordered subscription history entries
 661
 662         Setting device_id restricts the actions to a certain device
 663         """
 664
 665         from mygpo.db.couchdb.podcast_state import podcast_states_for_user, \
 666             podcast_states_for_device
 667
 668         def action_iter(state):
 669             for action in sorted(state.actions, reverse=reverse):
 670                 if device_id is not None and device_id != action.device:
 671                     continue
 672
 673                 if public is not None and state.is_public() != public:
 674                     continue
 675
 676                 entry = HistoryEntry()
 677                 entry.timestamp = action.timestamp
 678                 entry.action = action.action
 679                 entry.podcast_id = state.podcast
 680                 entry.device_id = action.device
 681                 yield entry
 682
 683         if device_id is None:
 684             podcast_states = podcast_states_for_user(self)
 685         else:
 686             podcast_states = podcast_states_for_device(device_id)
 687
 688         # create an action_iter for each PodcastUserState
 689         subscription_action_lists = [action_iter(x) for x in podcast_states]
 690
 691         action_cmp_key = lambda x: x.timestamp
 692
 693         # Linearize their subscription-actions
 694         return linearize(action_cmp_key, subscription_action_lists, reverse)
 695
 696
 697     def get_global_subscription_history(self, public=None):
 698         """ Actions that added/removed podcasts from the subscription list
 699
 700         Returns an iterator of all subscription actions that either
 701          * added subscribed a podcast that hasn't been subscribed directly
 702            before the action (but could have been subscribed) earlier
 703          * removed a subscription of the podcast is not longer subscribed
 704            after the action
 705         """
 706
 707         subscriptions = collections.defaultdict(int)
 708
 709         for entry in self.get_subscription_history(public=public):
 710             if entry.action == 'subscribe':
 711                 subscriptions[entry.podcast_id] += 1
 712
 713                 # a new subscription has been added
 714                 if subscriptions[entry.podcast_id] == 1:
 715                     yield entry
 716
 717             elif entry.action == 'unsubscribe':
 718                 subscriptions[entry.podcast_id] -= 1
 719
 720                 # the last subscription has been removed
 721                 if subscriptions[entry.podcast_id] == 0:
 722                     yield entry
 723
 724
 725
 726     def get_newest_episodes(self, max_date, max_per_podcast=5):
 727         """ Returns the newest episodes of all subscribed podcasts
 728
 729         Only max_per_podcast episodes per podcast are loaded. Episodes with
 730         release dates above max_date are discarded.
 731
 732         This method returns a generator that produces the newest episodes.
 733
 734         The number of required DB queries is equal to the number of (distinct)
 735         podcasts of all consumed episodes (max: number of subscribed podcasts),
 736         plus a constant number of initial queries (when the first episode is
 737         consumed). """
 738
 739         cmp_key = lambda episode: episode.released or datetime(2000, 01, 01)
 740
 741         podcasts = list(self.get_subscribed_podcasts())
 742         podcasts = filter(lambda p: p.latest_episode_timestamp, podcasts)
 743         podcasts = sorted(podcasts, key=lambda p: p.latest_episode_timestamp,
 744                         reverse=True)
 745
 746         podcast_dict = dict((p.get_id(), p) for p in podcasts)
 747
 748         # contains the un-yielded episodes, newest first
 749         episodes = []
 750
 751         for podcast in podcasts:
 752
 753             yielded_episodes = 0
 754
 755             for episode in episodes:
 756                 # determine for which episodes there won't be a new episodes
 757                 # that is newer; those can be yielded
 758                 if episode.released > podcast.latest_episode_timestamp:
 759                     p = podcast_dict.get(episode.podcast, None)
 760                     yield proxy_object(episode, podcast=p)
 761                     yielded_episodes += 1
 762                 else:
 763                     break
 764
 765             # remove the episodes that have been yielded before
 766             episodes = episodes[yielded_episodes:]
 767
 768             # fetch and merge episodes for the next podcast
 769             from mygpo.db.couchdb.episode import episodes_for_podcast
 770             new_episodes = episodes_for_podcast(podcast, since=1,
 771                         until=max_date, descending=True, limit=max_per_podcast)
 772             episodes = sorted(episodes+new_episodes, key=cmp_key, reverse=True)
 773
 774
 775         # yield the remaining episodes
 776         for episode in episodes:
 777             podcast = podcast_dict.get(episode.podcast, None)
 778             yield proxy_object(episode, podcast=podcast)
 779
 780
 781
 782
 783     def save(self, *args, **kwargs):
 784
 785         from mygpo.db.couchdb.podcast_state import podcast_states_for_user
 786
 787         super(User, self).save(*args, **kwargs)
 788
 789         podcast_states = podcast_states_for_user(self)
 790         for state in podcast_states:
 791             @repeat_on_conflict(['state'])
 792             def _update_state(state):
 793                 old_devs = set(state.disabled_devices)
 794                 state.set_device_state(self.devices)
 795
 796                 if old_devs != set(state.disabled_devices):
 797                     state.save()
 798
 799             _update_state(state)
 800
 801
 802
 803
 804     def __eq__(self, other):
 805         if not other:
 806             return False
 807
 808         # ensure that other isn't AnonymousUser
 809         return other.is_authenticated() and self._id == other._id
 810
 811
 812     def __ne__(self, other):
 813         return not(self == other)
 814
 815
 816     def __repr__(self):
 817         return 'User %s' % self._id
 818
 819
 820 class History(object):
 821
 822     def __init__(self, user, device):
 823         self.user = user
 824         self.device = device
 825
 826
 827     def __getitem__(self, key):
 828
 829         if isinstance(key, slice):
 830             start = key.start or 0
 831             length = key.stop - start
 832         else:
 833             start = key
 834             length = 1
 835
 836         if self.device:
 837             return device_history(self.user, self.device, start, length)
 838
 839         else:
 840             return user_history(self.user, start, length)
 841
 842
 843
 844 class HistoryEntry(object):
 845     """ A class that can represent subscription and episode actions """
 846
 847
 848     @classmethod
 849     def from_action_dict(cls, action):
 850
 851         entry = HistoryEntry()
 852
 853         if 'timestamp' in action:
 854             ts = action.pop('timestamp')
 855             entry.timestamp = dateutil.parser.parse(ts)
 856
 857         for key, value in action.items():
 858             setattr(entry, key, value)
 859
 860         return entry
 861
 862
 863     @property
 864     def playmark(self):
 865         return getattr(self, 'position', None)
 866
 867
 868     @classmethod
 869     def fetch_data(cls, user, entries,
 870             podcasts=None, episodes=None):
 871         """ Efficiently loads additional data for a number of entries """
 872
 873         if podcasts is None:
 874             # load podcast data
 875             podcast_ids = [getattr(x, 'podcast_id', None) for x in entries]
 876             podcast_ids = filter(None, podcast_ids)
 877             podcasts = podcasts_to_dict(podcast_ids)
 878
 879         if episodes is None:
 880             from mygpo.db.couchdb.episode import episodes_to_dict
 881             # load episode data
 882             episode_ids = [getattr(x, 'episode_id', None) for x in entries]
 883             episode_ids = filter(None, episode_ids)
 884             episodes = episodes_to_dict(episode_ids)
 885
 886         # load device data
 887         # does not need pre-populated data because no db-access is required
 888         device_ids = [getattr(x, 'device_id', None) for x in entries]
 889         device_ids = filter(None, device_ids)
 890         devices = dict([ (id, user.get_device(id)) for id in device_ids])
 891
 892
 893         for entry in entries:
 894             podcast_id = getattr(entry, 'podcast_id', None)
 895             entry.podcast = podcasts.get(podcast_id, None)
 896
 897             episode_id = getattr(entry, 'episode_id', None)
 898             entry.episode = episodes.get(episode_id, None)
 899
 900             if hasattr(entry, 'user'):
 901                 entry.user = user
 902
 903             device = devices.get(getattr(entry, 'device_id', None), None)
 904             entry.device = device
 905
 906
 907         return entries