def episode_count(): db = get_main_database() r = get_single_result(db, 'episodes/by_podcast', reduce = True, stale = 'update_after', ) return r['value'] if r else 0
def episode_count_for_podcast(podcast, since=None, until={}, **kwargs): if not podcast: raise QueryParameterMissing('podcast') if kwargs.get('descending', False): since, until = until, since if isinstance(since, datetime): since = since.isoformat() if isinstance(until, datetime): until = until.isoformat() db = get_main_database() res = get_single_result(db, 'episodes/by_podcast', startkey = [podcast.get_id(), since], endkey = [podcast.get_id(), until], reduce = True, group_level = 1, **kwargs ) return res['value'] if res else 0
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 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 get_license_podcast_count(license_url=None): """ returns the number of podcasts that contain license information """ kwargs = {} if license_url: kwargs['key'] = license_url db = get_main_database() r = get_single_result(db, 'podcasts/license', **kwargs) return r['value'] if r else 0
def subscription_for_topic(topic): """ return the subscription for the given topic, one None """ db = get_pubsub_database() sub = get_single_result(db, 'subscriptions/by_topic', key = topic, include_docs = True, reduce = False, schema = Subscription ) return sub
def category_for_tag_uncached(tag): if not tag: raise QueryParameterMissing('tag') db = get_categories_database() cat = get_single_result(db, 'categories/by_tags', key = tag, include_docs = True, stale = 'update_after', schema = Category ) return cat
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 podcastlist_for_user_slug(user_id, slug): if not user_id: raise QueryParameterMissing('user_id') if not slug: raise QueryParameterMissing('slug') db = get_main_database() l = get_single_result(db, 'podcastlists/by_user_slug', key = [user_id, slug], include_docs = True, schema = PodcastList, ) return l
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 subscriberdata_for_podcast(podcast_id): if not podcast_id: raise QueryParameterMissing('podcast_id') db = get_main_database() data = get_single_result(db, 'podcasts/subscriber_data', key = podcast_id, include_docs = True, schema = PodcastSubscriberData, ) if not data: data = PodcastSubscriberData() data.podcast = podcast_id return data
def suggestions_for_user(user): if not user: raise QueryParameterMissing('user') from mygpo.users.models import Suggestions db = get_main_database() s = get_single_result(db, 'suggestions/by_user', key = user._id, include_docs = True, schema = Suggestions, ) if not s: s = Suggestions() s.user = user._id return s
def podcastgroup_for_oldid(oldid): if not oldid: raise QueryParameterMissing('oldid') db = get_main_database() pg = get_single_result(db, 'podcasts/groups_by_oldid', key = long(oldid), include_docs = True, schema = PodcastGroup, ) if not pg: return None if pg.needs_update: incomplete_obj.send_robust(sender=pg) return pg
def podcast_for_oldid(oldid): if oldid is None: raise QueryParameterMissing('oldid') db = get_main_database() podcast = get_single_result(db, 'podcasts/by_oldid', key = long(oldid), include_docs = True, wrapper = _wrap_podcast_group_key1, ) if not podcast: return None if podcast.needs_update: incomplete_obj.send_robust(sender=podcast) return podcast
def episode_for_podcast_id_url(podcast_id, episode_url, create=False): if not podcast_id: raise QueryParameterMissing('podcast_id') if not episode_url: raise QueryParameterMissing('episode_url') key = u'episode-podcastid-%s-url-%s' % ( sha1(podcast_id.encode('utf-8')).hexdigest(), sha1(episode_url.encode('utf-8')).hexdigest()) # Disabled as cache invalidation is not working properly # episode = cache.get(key) # if episode: # return episode db = get_main_database() episode = get_single_result(db, 'episodes/by_podcast_url', key = [podcast_id, episode_url], include_docs = True, reduce = False, schema = Episode, ) if episode: if episode.needs_update: incomplete_obj.send_robust(sender=episode) else: cache.set(key, episode) return episode if create: episode = Episode() episode.created_timestamp = get_timestamp(datetime.utcnow()) episode.podcast = podcast_id episode.urls = [episode_url] episode.save() incomplete_obj.send_robust(sender=episode) return episode return None
def podcast_by_id_uncached(podcast_id, current_id=False): if not podcast_id: raise QueryParameterMissing('podcast_id') db = get_main_database() podcast = get_single_result(db, 'podcasts/by_id', key = podcast_id, include_docs = True, wrapper = _wrap_podcast_group, ) if not podcast: return None if podcast.needs_update: incomplete_obj.send_robust(sender=podcast) return podcast
def podcast_for_slug(slug): if not slug: raise QueryParameterMissing('slug') db = get_main_database() obj = get_single_result(db, 'podcasts/by_slug', startkey = [slug, None], endkey = [slug, {}], include_docs = True, wrapper = _wrap_podcast_group_key1, ) if not obj: return None if obj.needs_update: incomplete_obj.send_robust(sender=obj) return obj
def podcast_subscriber_count(podcast): if not podcast: raise QueryParameterMissing('podcast') udb = get_userdata_database() subscriber_sum = 0 for podcast_id in podcast.get_ids(): x = get_single_result(udb, 'subscribers/by_podcast', startkey = [podcast_id, None], endkey = [podcast_id, {}], reduce = True, group = True, group_level = 1, ) subscriber_sum += x['value'] if x else 0 return subscriber_sum
def episode_state_for_user_episode(user, episode): if not user: raise QueryParameterMissing('user') if not episode: raise QueryParameterMissing('episode') key = 'episode-state-userid-%s-episodeid-%s' % (sha1(user._id).hexdigest(), sha1(episode._id).hexdigest()) # Disabled as cache invalidation does not work properly # state = cache.get(key) # if state: # return state udb = get_userdata_database() state = get_single_result(udb, 'episode_states/by_user_episode', key = [user._id, episode._id], include_docs = True, limit = 1, schema = EpisodeUserState, ) if state: cache.set(key, state) return state else: podcast = podcast_by_id(episode.podcast) state = EpisodeUserState() state.episode = episode._id state.podcast = episode.podcast state.user = user._id state.ref_url = episode.url state.podcast_ref_url = podcast.url # don't cache here, because the state is saved by the calling function return state
def episode_for_oldid(oldid): if not oldid: raise QueryParameterMissing('oldid') oldid = int(oldid) db = get_main_database() episode = get_single_result(db, 'episodes/by_oldid', key = oldid, limit = 1, include_docs = True, schema = Episode, ) if not episode: return None if episode.needs_update: incomplete_obj.send_robust(sender=episode) return episode
def get_num_played_episodes(user, since=None, until={}): """ Number of played episodes in interval """ if not user: raise QueryParameterMissing('user') since_str = since.strftime('%Y-%m-%d') if since else None until_str = until.strftime('%Y-%m-%d') if until else {} startkey = [user._id, since_str] endkey = [user._id, until_str] udb = get_userdata_database() val = get_single_result(udb, 'listeners/by_user', startkey = startkey, endkey = endkey, reduce = True, stale = 'update_after', ) return val['value'] if val else 0
def episode_for_slug(podcast_id, episode_slug): if not podcast_id: raise QueryParameterMissing('podcast_id') if not episode_slug: raise QueryParameterMissing('episode_slug') db = get_main_database() episode = get_single_result(db, 'episodes/by_slug', key = [podcast_id, episode_slug], include_docs = True, schema = Episode, ) if not episode: return None if episode.needs_update: incomplete_obj.send_robust(sender=episode) return episode
def episode_state_for_ref_urls(user, podcast_url, episode_url): if not user: raise QueryParameterMissing('user') if not podcast_url: raise QueryParameterMissing('podcast_url') if not episode_url: raise QueryParameterMissing('episode_url') cache_key = 'episode-state-%s-%s-%s' % (user._id, sha1(podcast_url).hexdigest(), sha1(episode_url).hexdigest()) state = cache.get(cache_key) if state: return state udb = get_userdata_database() state = get_single_result(udb, 'episode_states/by_ref_urls', key = [user._id, podcast_url, episode_url], limit = 1, include_docs=True, schema = EpisodeUserState, ) if state: state.ref_url = episode_url state.podcast_ref_url = podcast_url cache.set(cache_key, state, 60*60) return state else: podcast = podcast_for_url(podcast_url, create=True) episode = episode_for_podcast_id_url(podcast.get_id(), episode_url, create=True) return episode_state_for_user_episode(user, episode)
def get_seconds_played(user, since=None, until={}): """ Returns the number of seconds that the user has listened Can be selected by timespan, podcast and episode """ if not user: raise QueryParameterMissing('user') since_str = since.strftime('%Y-%m-%dT%H:%M:%S') if since else None until_str = until.strftime('%Y-%m-%dT%H:%M:%S') if until else {} startkey = [user._id, since_str] endkey = [user._id, until_str] udb = get_userdata_database() val = get_single_result(udb, 'listeners/times_played_by_user', startkey = startkey, endkey = endkey, reduce = True, stale = 'update_after', ) return val['value'] if val else 0
def episode_by_id(episode_id, current_id=False): if not episode_id: raise QueryParameterMissing('episode_id') db = get_main_database() episode = get_single_result(db, 'episodes/by_id', key = episode_id, include_docs = True, schema = Episode, ) if not episode: return None if current_id and episode._id != episode_id: raise MergedIdException(episode, episode._id) if episode.needs_update: incomplete_obj.send_robust(sender=episode) return episode
def podcast_for_url(url, create=False): if not url: raise QueryParameterMissing('url') key = 'podcast-by-url-%s' % sha1(url.encode('utf-8')).hexdigest() podcast = cache.get(key) if podcast: return podcast db = get_main_database() podcast_group = get_single_result(db, 'podcasts/by_url', key = url, include_docs = True, wrapper = _wrap_pg, ) if podcast_group: podcast = podcast_group.get_podcast_by_url(url) if podcast.needs_update: incomplete_obj.send_robust(sender=podcast) else: cache.set(key, podcast) return podcast if create: podcast = Podcast() podcast.created_timestamp = get_timestamp(datetime.utcnow()) podcast.urls = [url] podcast.save() incomplete_obj.send_robust(sender=podcast) return podcast return None
def get_flattr_podcast_count(): """ returns the number of podcasts that contain Flattr payment URLs """ db = get_main_database() r = get_single_result(db, 'podcasts/flattr') return r['value']