def all_tags(): """ Returns all tags Some tags might be returned twice """ db = get_main_database() res = multi_request_view(db, 'podcasts/by_tag', wrap = False, reduce = True, group = True, group_level = 1 ) for r in res: yield r['key'][0] udb = get_userdata_database() res = multi_request_view(udb, 'usertags/podcasts', wrap = False, reduce = True, group = True, group_level = 1 ) for r in res: yield r['key'][0]
def podcasts_for_tag(tag): """ Returns the podcasts with the current tag. Some podcasts might be returned twice """ if not tag: raise QueryParameterMissing('tag') res = multi_request_view(Podcast, 'podcasts/by_tag', wrap = False, startkey = [tag, None], endkey = [tag, {}], reduce = True, group = True, group_level = 2 ) for r in res: yield (r['key'][1], r['value']) udb = get_userdata_database() res = multi_request_view(udb, 'usertags/podcasts', wrap = False, startkey = [tag, None], endkey = [tag, {}], reduce = True, group = True, group_level = 2 ) for r in res: yield (r['key'][1], r['value'])
def episode_states_count(): udb = get_userdata_database() r = udb.view('episode_states/by_user_episode', limit = 0, stale = 'update_after', ) return r.total_rows
def _wrap_chapter(res): from mygpo.users.models import Chapter user = res['key'][1] chapter = Chapter.wrap(res['value']) udb = get_userdata_database() chapter.set_db(udb) return (user, chapter)
def tags_for_podcast(podcast): """ all tags for the podcast, in decreasing order of importance """ if not podcast: raise QueryParameterMissing('podcast') db = get_main_database() res = db.view('tags/by_podcast', startkey = [podcast.get_id(), None], endkey = [podcast.get_id(), {}], reduce = True, group = True, group_level = 2, stale = 'update_after', ) tags = Counter(dict((x['key'][1], x['value']) for x in res)) udb = get_userdata_database() res = udb.view('usertags/by_podcast', startkey = [podcast.get_id(), None], endkey = [podcast.get_id(), {}], reduce = True, group = True, group_level = 2, ) tags.update(Counter(dict( (x['key'][1], x['value']) for x in res))) get_tag = itemgetter(0) return map(get_tag, tags.most_common())
def update_device_state(state, devices): old_devs = set(state.disabled_devices) state.set_device_state(devices) if old_devs != set(state.disabled_devices): udb = get_userdata_database() udb.save_doc(state)
def podcast_state_for_user_podcast(user, podcast): if not user: raise QueryParameterMissing('user') if not podcast: raise QueryParameterMissing('podcast') udb = get_userdata_database() p = get_single_result(udb, 'podcast_states/by_podcast', key = [podcast.get_id(), user._id], limit = 1, include_docs = True, schema = PodcastUserState, ) if not p: p = PodcastUserState() p.podcast = podcast.get_id() p.user = user._id p.ref_url = podcast.url p.settings[PUBLIC_SUB_PODCAST.name]=user.get_wksetting(PUBLIC_SUB_USER) p.set_device_state(user.devices) return p
def podcast_state_count(): udb = get_userdata_database() r = udb.view('podcast_states/by_user', limit = 0, stale = 'update_after', ) return r.total_rows
def execute(self): """ Executes all added actions in bulk """ obj_funs = map(self._get_obj_fun, self.actions) udb = get_userdata_database() bulk_save_retry(obj_funs, udb) # prepare for another run self.actions = []
def update_episode_state_object(state, podcast_id, episode_id=None): state.podcast = podcast_id if episode_id is not None: state.episode = episode_id udb = get_userdata_database() udb.save_doc(state)
def main(request, username, scope): db = get_main_database() udb = get_userdata_database() def user_settings(user): return user, user, db def device_settings(user, uid): device = user.get_device_by_uid(uid) # get it from the user directly so that changes # to settings_obj are reflected in user (bug 1344) settings_obj = user.get_device_by_uid(uid) return user, settings_obj, db def podcast_settings(user, url): podcast = podcast_for_url(url) if not podcast: raise Http404 obj = podcast_state_for_user_podcast(user, podcast) return obj, obj, udb def episode_settings(user, url, podcast_url): episode = episode_for_podcast_url(podcast_url, url) if episode is None: raise Http404 episode_state = episode_state_for_user_episode(user, episode) return episode_state, episode_state, udb models = dict( account = lambda: user_settings(request.user), device = lambda: device_settings(request.user, request.GET.get('device', '')), podcast = lambda: podcast_settings(request.user, request.GET.get('podcast', '')), episode = lambda: episode_settings(request.user, request.GET.get('episode', ''), request.GET.get('podcast', '')) ) if scope not in models.keys(): return HttpResponseBadRequest('undefined scope %s' % scope) try: base_obj, settings_obj, db = models[scope]() except DeviceDoesNotExist as e: return HttpResponseNotFound(str(e)) if request.method == 'GET': return JsonResponse( settings_obj.settings ) elif request.method == 'POST': actions = parse_request_body(request) ret = update_settings(settings_obj, actions) db.save_doc(base_obj) return JsonResponse(ret)
def get_nth_episode_state(n): udb = get_userdata_database() state = get_single_result(udb, 'episode_states/by_user_episode', skip = n, include_docs = True, limit = 1, schema = EpisodeUserState, ) return state
def favorite_episode_ids_for_user(user): if not user: raise QueryParameterMissing('user') udb = get_userdata_database() favorites = udb.view('favorites/episodes_by_user', key = user._id, ) return set(x['value']['_id'] for x in favorites)
def subscribed_podcast_ids_by_device(device): if not device: raise QueryParameterMissing('device') udb = get_userdata_database() r = udb.view('subscriptions/by_device', startkey = [device.id, None], endkey = [device.id, {}] ) return [res['key'][1] for res in r]
def chapters_for_episode(episode_id): if not episode_id: raise QueryParameterMissing('episode_id') udb = get_userdata_database() r = udb.view('chapters/by_episode', startkey = [episode_id, None], endkey = [episode_id, {}], ) return map(_wrap_chapter, r)
def subscribed_podcast_ids_by_user_id(user_id): if not user_id: raise QueryParameterMissing('user_id') udb = get_userdata_database() subscribed = udb.view('subscriptions/by_user', startkey = [user_id, True, None, None], endkey = [user_id, True, {}, {}], group = True, group_level = 3, stale = 'update_after', ) return set(r['key'][2] for r in subscribed)
def get_subscribed_podcast_states_by_device(device): udb = get_userdata_database() r = udb.view('subscriptions/by_device', startkey = [device.id, None], endkey = [device.id, {}], include_docs = True, schema = PodcastUserState, ) states = list(r) for state in states: state.set_db(udb) return states
def get_num_listened_episodes(user): if not user: raise QueryParameterMissing('user') udb = get_userdata_database() r = udb.view('listeners/by_user_podcast', startkey = [user._id, None], endkey = [user._id, {}], reduce = True, group_level = 2, stale = 'update_after', ) return map(_wrap_num_listened, r)
def merge_episode_states(state, state2): state.add_actions(state2.actions) # overwrite settings in state2 with state's settings settings = state2.settings settings.update(state.settings) state.settings = settings merged_ids = set(state.merged_ids + [state2._id] + state2.merged_ids) state.merged_ids = filter(None, merged_ids) state.chapters = list(set(state.chapters + state2.chapters)) udb = get_userdata_database() udb.save_doc(state)
def episode_listener_count(episode, start=None, end={}): """ returns the number of users that have listened to this episode """ if not episode: raise QueryParameterMissing('episode') udb = get_userdata_database() r = get_single_result(udb, 'listeners/by_episode', startkey = [episode._id, start], endkey = [episode._id, end], group = True, group_level = 2, reduce = True, stale = 'update_after', ) return r['value'] if r else 0
def podcast_listener_count(episode): """ returns the number of users that have listened to this podcast """ if not episode: raise QueryParameterMissing('episode') udb = get_userdata_database() r = get_single_result(udb, 'listeners/by_podcast', startkey = [episode.get_id(), None], endkey = [episode.get_id(), {}], group = True, group_level = 1, reduce = True, stale = 'update_after', ) return r['value'] if r else 0
def get_podcasts_episode_states(podcast, user_id): """ Returns the latest episode actions for the podcast's episodes """ if not podcast: raise QueryParameterMissing('podcast') if not user_id: raise QueryParameterMissing('user_id') udb = get_userdata_database() res = udb.view('episode_states/by_user_podcast', startkey = [user_id, podcast.get_id(), None], endkey = [user_id, podcast.get_id(), {}], ) return map(lambda r: r['value'], res)
def subscribed_users(podcast): if not podcast: raise QueryParameterMissing('podcast') udb = get_userdata_database() res = udb.view('subscriptions/by_podcast', startkey = [podcast.get_id(), None, None], endkey = [podcast.get_id(), {}, {}], group = True, group_level = 2, stale = 'update_after', ) users = (r['key'][1] for r in res) return users
def tags_for_user(user, podcast_id=None): """ mapping of all podcasts tagged by the user with a list of tags """ if not user: raise QueryParameterMissing('user') udb = get_userdata_database() res = udb.view('usertags/by_user', startkey = [user._id, podcast_id], endkey = [user._id, podcast_id or {}] ) tags = defaultdict(list) for r in res: tags[r['key'][1]].append(r['value']) return tags
def episode_listener_counts(episode): """ (Episode-Id, listener-count) tuples for episodes w/ listeners """ if not episode: raise QueryParameterMissing('episode') udb = get_userdata_database() r = udb.view('listeners/by_podcast_episode', startkey = [episode.get_id(), None, None], endkey = [episode.get_id(), {}, {}], group = True, group_level = 2, reduce = True, stale = 'update_after', ) return map(_wrap_listeners, r)
def user_history(user, start, length): if not user: raise QueryParameterMissing('user') if length <= 0: return [] udb = get_userdata_database() res = udb.view('history/by_user', descending = True, startkey = [user._id, {}], endkey = [user._id, None], limit = length, skip = start, ) return map(_wrap_historyentry, res)
def subscriptions_by_user(user, public=None): """ Returns a list of (podcast-id, device-id) tuples for all of the users subscriptions """ if not user: raise QueryParameterMissing('user') udb = get_userdata_database() r = udb.view('subscriptions/by_user', startkey = [user._id, public, None, None], endkey = [user._id+'ZZZ', None, None, None], reduce = False, schema = PodcastUserState, ) return [res['key'][1:] for res in r]
def update_episodes(user, actions, now, ua_string): update_urls = [] grouped_actions = defaultdict(list) # group all actions by their episode for action in actions: podcast_url = action['podcast'] podcast_url = sanitize_append(podcast_url, update_urls) if podcast_url == '': continue episode_url = action['episode'] episode_url = sanitize_append(episode_url, update_urls) if episode_url == '': continue act = parse_episode_action(action, user, update_urls, now, ua_string) grouped_actions[ (podcast_url, episode_url) ].append(act) auto_flattr_episodes = [] # Prepare the updates for each episode state obj_funs = [] for (p_url, e_url), action_list in grouped_actions.iteritems(): episode_state = episode_state_for_ref_urls(user, p_url, e_url) if any(a['action'] == 'play' for a in actions): auto_flattr_episodes.append(episode_state.episode) fun = partial(update_episode_actions, action_list=action_list) obj_funs.append( (episode_state, fun) ) udb = get_userdata_database() bulk_save_retry(obj_funs, udb) if user.get_wksetting(FLATTR_AUTO): for episode_id in auto_flattr_episodes: auto_flattr_episode.delay(user, episode_id) return update_urls
def all_podcast_episode_states(podcast): if not podcast: raise QueryParameterMissing('podcast') udb = get_userdata_database() r = udb.view('episode_states/by_podcast_episode', startkey = [podcast.get_id(), None, None], endkey = [podcast.get_id(), {}, {}], include_docs = True, schema = EpisodeUserState, ) states = list(r) for state in states: state.set_db(udb) return states
def podcast_states_for_user(user): if not user: raise QueryParameterMissing('user') udb = get_userdata_database() r = udb.view('podcast_states/by_user', startkey = [user._id, None], endkey = [user._id, 'ZZZZ'], include_docs = True, schema = PodcastUserState, ) states = list(r) for state in states: state.set_db(udb) return states