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
