mygpo/maintenance/merge.py

   1 from itertools import chain, imap as map
   2 import logging
   3 from functools import partial
   4
   5 import restkit
   6
   7 from mygpo import utils
   8 from mygpo.decorators import repeat_on_conflict
   9 from mygpo.db.couchdb.podcast import delete_podcast
  10 from mygpo.db.couchdb.episode import episodes_for_podcast
  11 from mygpo.db.couchdb.podcast_state import all_podcast_states, \
  12     delete_podcast_state
  13 from mygpo.db.couchdb.episode_state import all_episode_states
  14
  15
  16 class IncorrectMergeException(Exception):
  17     pass
  18
  19
  20 class PodcastMerger(object):
  21     """ Merges podcasts and their related objects """
  22
  23     def __init__(self, podcasts, actions, groups):
  24         """ Prepares to merge podcasts[1:] into podcasts[0]  """
  25
  26         for n, podcast1 in enumerate(podcasts):
  27             for m, podcast2 in enumerate(podcasts):
  28                 if podcast1 == podcast2 and n != m:
  29                     raise IncorrectMergeException(
  30                         "can't merge podcast into itself")
  31
  32         self.podcasts = podcasts
  33         self.actions = actions
  34         self.groups = groups
  35
  36     def merge(self):
  37         """ Carries out the actual merging """
  38
  39         podcast1 = self.podcasts.pop(0)
  40
  41         for podcast2 in self.podcasts:
  42             self._merge_objs(podcast1=podcast1, podcast2=podcast2)
  43             self.merge_states(podcast1, podcast2)
  44             self.merge_episodes()
  45             self.reassign_episodes(podcast1, podcast2)
  46             delete_podcast(podcast2)
  47             self.actions['merge-podcast'] += 1
  48
  49         self.merge_episodes()
  50
  51     def merge_episodes(self):
  52         """ Merges the episodes according to the groups """
  53
  54         for n, episodes in self.groups:
  55
  56             if not episodes:
  57                 continue
  58
  59             episode = episodes.pop(0)
  60
  61             for ep in episodes:
  62                 em = EpisodeMerger(episode, ep, self.actions)
  63                 em.merge()
  64
  65     @repeat_on_conflict(['podcast1', 'podcast2'])
  66     def _merge_objs(self, podcast1, podcast2):
  67
  68         podcast1.merged_ids = set_filter(podcast1.get_id(),
  69                                          podcast1.merged_ids,
  70                                          [podcast2.get_id()],
  71                                          podcast2.merged_ids)
  72
  73         podcast1.merged_slugs = set_filter(podcast1.slug,
  74                                            podcast1.merged_slugs,
  75                                            [podcast2.slug],
  76                                            podcast2.merged_slugs)
  77
  78         podcast1.merged_oldids = set_filter(podcast1.oldid,
  79                                             podcast1.merged_oldids,
  80                                             [podcast2.oldid],
  81                                             podcast2.merged_oldids)
  82
  83         # the first URL in the list represents the podcast main URL
  84         main_url = podcast1.url
  85         podcast1.urls = set_filter(None, podcast1.urls, podcast2.urls)
  86         # so we insert it as the first again
  87         podcast1.urls.remove(main_url)
  88         podcast1.urls.insert(0, main_url)
  89
  90         podcast1.content_types = set_filter(None, podcast1.content_types,
  91                                             podcast2.content_types)
  92
  93         podcast1.save()
  94
  95     @repeat_on_conflict(['s'])
  96     def _save_state(self, s, podcast1):
  97         s.podcast = podcast1.get_id()
  98         s.save()
  99
 100     @repeat_on_conflict(['e'])
 101     def _save_episode(self, e, podcast1):
 102         e.podcast = podcast1.get_id()
 103         e.save()
 104
 105     def reassign_episodes(self, podcast1, podcast2):
 106         # re-assign episodes to new podcast
 107         # if necessary, they will be merged later anyway
 108         for e in episodes_for_podcast(podcast2):
 109             self.actions['reassign-episode'] += 1
 110
 111             for s in all_episode_states(e):
 112                 self.actions['reassign-episode-state'] += 1
 113
 114                 self._save_state(s=s, podcast1=podcast1)
 115
 116             self._save_episode(e=e, podcast1=podcast1)
 117
 118     def merge_states(self, podcast1, podcast2):
 119         """Merges the Podcast states that are associated with the two Podcasts.
 120
 121         This should be done after two podcasts are merged
 122         """
 123
 124         key = lambda x: x.user
 125         states1 = sorted(all_podcast_states(podcast1), key=key)
 126         states2 = sorted(all_podcast_states(podcast2), key=key)
 127
 128         for state, state2 in utils.iterate_together([states1, states2], key):
 129
 130             if state == state2:
 131                 continue
 132
 133             if state is None:
 134                 self.actions['move-podcast-state'] += 1
 135                 self._move_state(state2=state2, new_id=podcast1.get_id(),
 136                                  new_url=podcast1.url)
 137
 138             elif state2 is None:
 139                 continue
 140
 141             else:
 142                 psm = PodcastStateMerger(state, state2, self.actions)
 143                 psm.merge()
 144
 145     @repeat_on_conflict(['state2'])
 146     def _move_state(self, state2, new_id, new_url):
 147         state2.ref_url = new_url
 148         state2.podcast = new_id
 149         state2.save()
 150
 151
 152 class EpisodeMerger(object):
 153
 154     def __init__(self, episode1, episode2, actions):
 155         if episode1 == episode2:
 156             raise IncorrectMergeException("can't merge episode into itself")
 157
 158         self.episode1 = episode1
 159         self.episode2 = episode2
 160         self.actions = actions
 161
 162     def merge(self):
 163         self._merge_objs(episode1=self.episode1, episode2=self.episode2)
 164         self.merge_states(self.episode1, self.episode2)
 165         self._delete(e=self.episode2)
 166         self.actions['merge-episode'] += 1
 167
 168     @repeat_on_conflict(['episode1'])
 169     def _merge_objs(self, episode1, episode2):
 170
 171         episode1.urls = set_filter(None, episode1.urls, episode2.urls)
 172
 173         episode1.merged_ids = set_filter(episode1._id, episode1.merged_ids,
 174                                          [episode2._id], episode2.merged_ids)
 175
 176         episode1.merged_slugs = set_filter(episode1.slug,
 177                                            episode1.merged_slugs,
 178                                            [episode2.slug],
 179                                            episode2.merged_slugs)
 180
 181         episode1.save()
 182
 183     @repeat_on_conflict(['e'])
 184     def _delete(self, e):
 185         e.delete()
 186
 187     def merge_states(self, episode, episode2):
 188
 189         key = lambda x: x.user
 190         states1 = sorted(all_episode_states(self.episode1), key=key)
 191         states2 = sorted(all_episode_states(self.episode2), key=key)
 192
 193         for state, state2 in utils.iterate_together([states1, states2], key):
 194
 195             if state == state2:
 196                 continue
 197
 198             if state is None:
 199                 self.actions['move-episode-state'] += 1
 200                 self._move(state2=state2, podcast_id=self.episode1.podcast,
 201                            episode_id=self.episode1._id)
 202
 203             elif state2 is None:
 204                 continue
 205
 206             else:
 207                 esm = EpisodeStateMerger(state, state2, self.actions)
 208                 esm.merge()
 209
 210     @repeat_on_conflict(['state2'])
 211     def _move(self, state2, podcast_id, episode_id):
 212         state2.podcast = podcast_id
 213         state2.episode = episode_id
 214         state2.save()
 215
 216
 217 class PodcastStateMerger(object):
 218     """Merges the two given podcast states"""
 219
 220     def __init__(self, state, state2, actions):
 221
 222         if state._id == state2._id:
 223             raise IncorrectMergeException(
 224                 "can't merge podcast state into itself")
 225
 226         if state.user != state2.user:
 227             raise IncorrectMergeException(
 228                 "states don't belong to the same user")
 229
 230         self.state = state
 231         self.state2 = state2
 232         self.actions = actions
 233
 234     def merge(self):
 235         self._do_merge(state=self.state, state2=self.state2)
 236         self._add_actions(state=self.state, actions=self.state2.actions)
 237         self._delete(state2=self.state2)
 238         self.actions['merged-podcast-state'] += 1
 239
 240     @repeat_on_conflict(['state'])
 241     def _do_merge(self, state, state2):
 242
 243         # overwrite settings in state2 with state's settings
 244         settings = state2.settings
 245         settings.update(state.settings)
 246         state.settings = settings
 247
 248         state.disabled_devices = set_filter(None, state.disabled_devices,
 249                                             state2.disabled_devices)
 250
 251         state.merged_ids = set_filter(state._id, state.merged_ids,
 252                                       [state2._id], state2.merged_ids)
 253
 254         state.tags = set_filter(None, state.tags, state2.tags)
 255
 256         state.save()
 257
 258     @repeat_on_conflict(['state'])
 259     def _add_actions(self, state, actions):
 260         try:
 261             state.add_actions(actions)
 262             state.save()
 263         except restkit.Unauthorized:
 264             # the merge could result in an invalid list of
 265             # subscribe/unsubscribe actions -- we ignore it and
 266             # just use the actions from state
 267             return
 268
 269     @repeat_on_conflict(['state2'])
 270     def _delete(self, state2):
 271         state2.delete()
 272
 273
 274 class EpisodeStateMerger(object):
 275     """ Merges state2 in state """
 276
 277     def __init__(self, state, state2, actions):
 278
 279         if state._id == state2._id:
 280             raise IncorrectMergeException(
 281                 "can't merge episode state into itself")
 282
 283         if state.user != state2.user:
 284             raise IncorrectMergeException(
 285                 "states don't belong to the same user")
 286
 287         self.state = state
 288         self.state2 = state2
 289         self.actions = actions
 290
 291     def merge(self):
 292         self._merge_obj(state=self.state, state2=self.state2)
 293         delete_podcast_state(self.state2)
 294         self.actions['merge-episode-state'] += 1
 295
 296     @repeat_on_conflict(['state'])
 297     def _merge_obj(self, state, state2):
 298         state.add_actions(state2.actions)
 299
 300         # overwrite settings in state2 with state's settings
 301         settings = state2.settings
 302         settings.update(state.settings)
 303         state.settings = settings
 304
 305         merged_ids = set(state.merged_ids + [state2._id] + state2.merged_ids)
 306         state.merged_ids = filter(None, merged_ids)
 307
 308         state.chapters = list(set(state.chapters + state2.chapters))
 309
 310         state.save()
 311
 312
 313 def set_filter(orig, *args):
 314     """ chain args, and remove falsy values and orig """
 315     s = set(chain.from_iterable(args))
 316     s = s - set([orig])
 317     s = filter(None, s)
 318     return s