def apply_sync_actions(self, device, sync_actions):
""" Applies the sync-actions to the device """
add, rem = sync_actions
podcasts = podcasts_to_dict(add + rem)
for podcast_id in add:
podcast = podcasts.get(podcast_id, None)
if podcast is None:
continue
try:
podcast.subscribe(self, device)
except SubscriptionException as e:
logger.warn('Web: %(username)s: cannot sync device: %(error)s' %
dict(username=self.username, error=repr(e)))
for podcast_id in rem:
podcast = podcasts.get(podcast_id, None)
if not podcast:
continue
try:
podcast.unsubscribe(self, device)
except SubscriptionException as e:
logger.warn('Web: %(username)s: cannot sync device: %(error)s' %
dict(username=self.username, error=repr(e)))
def episode_toplist(request, num=100):
lang = process_lang_params(request)
toplist = EpisodeToplist(language=lang)
entries = list(map(proxy_object, toplist[:num]))
# load podcast objects
podcast_ids = [e.podcast for e in entries]
podcasts = podcasts_to_dict(podcast_ids, True)
for entry in entries:
entry.podcast = podcasts.get(entry.podcast, None)
current_site = RequestSite(request)
# Determine maximum listener amount (or 0 if no entries exist)
max_listeners = max([0]+[e.listeners for e in entries])
languages = get_podcast_languages()
all_langs = get_language_names(languages)
return render(request, 'episode_toplist.html', {
'entries': entries,
'max_listeners': max_listeners,
'url': current_site,
'language': lang,
'all_languages': all_langs,
})
def list_favorites(request):
user = request.user
site = RequestSite(request)
episodes = favorite_episodes_for_user(user)
recently_listened = get_latest_episodes(user)
podcast_ids = [episode.podcast for episode in episodes + recently_listened]
podcasts = podcasts_to_dict(podcast_ids)
recently_listened = fetch_episode_data(recently_listened, podcasts=podcasts)
episodes = fetch_episode_data(episodes, podcasts=podcasts)
favfeed = FavoriteFeed(user)
feed_url = favfeed.get_public_url(site.domain)
podcast = podcast_for_url(feed_url)
token = request.user.favorite_feeds_token
return render(request, 'favorites.html', {
'episodes': episodes,
'feed_token': token,
'site': site,
'podcast': podcast,
'recently_listened': recently_listened,
})
def podcasts_for_states(podcast_states):
""" returns the podcasts corresponding to the podcast states """
podcast_ids = [state.podcast for state in podcast_states]
podcasts = podcasts_to_dict(podcast_ids)
for state in podcast_states:
podcast = proxy_object(podcasts[state.podcast], url=state.ref_url)
podcasts[state.podcast] = podcast
return podcasts.values()
def fetch_episode_data(episodes, podcasts={}):
if not podcasts:
podcast_ids = [episode.podcast for episode in episodes]
podcasts = podcasts_to_dict(podcast_ids)
def set_podcast(episode):
episode = proxy_object(episode)
episode.podcast = podcasts.get(episode.podcast, None)
return episode
return map(set_podcast, episodes)
def privacy(request):
site = RequestSite(request)
subscriptions = subscriptions_by_user(request.user)
podcasts = podcasts_to_dict([x[1] for x in subscriptions])
subs = set((podcasts.get(x[1], None), not x[0]) for x in subscriptions)
subs = sorted(subs, key=lambda (p, _): PODCAST_SORT(p))
return render(request, 'privacy.html', {
'private_subscriptions': not request.user.get_wksetting(PUBLIC_SUB_USER),
'subscriptions': subs,
'domain': site.domain,
})
def get_subscribed_podcasts(self, public=None):
""" Returns all subscribed podcasts for the user
The attribute "url" contains the URL that was used when subscribing to
the podcast """
from mygpo.db.couchdb.podcast_state import get_subscribed_podcast_states_by_user
states = get_subscribed_podcast_states_by_user(self, public)
podcast_ids = [state.podcast for state in states]
podcasts = podcasts_to_dict(podcast_ids)
for state in states:
podcast = podcasts.get(state.podcast, None)
if podcast is None:
continue
podcast = proxy_object(podcast, url=state.ref_url)
podcasts[state.podcast] = podcast
return set(podcasts.values())
def fetch_data(cls, user, entries,
podcasts=None, episodes=None):
""" Efficiently loads additional data for a number of entries """
if podcasts is None:
# load podcast data
podcast_ids = [getattr(x, 'podcast_id', None) for x in entries]
podcast_ids = filter(None, podcast_ids)
podcasts = podcasts_to_dict(podcast_ids)
if episodes is None:
from mygpo.db.couchdb.episode import episodes_to_dict
# load episode data
episode_ids = [getattr(x, 'episode_id', None) for x in entries]
episode_ids = filter(None, episode_ids)
episodes = episodes_to_dict(episode_ids)
# load device data
# does not need pre-populated data because no db-access is required
device_ids = [getattr(x, 'device_id', None) for x in entries]
device_ids = filter(None, device_ids)
devices = dict([ (id, user.get_device(id)) for id in device_ids])
for entry in entries:
podcast_id = getattr(entry, 'podcast_id', None)
entry.podcast = podcasts.get(podcast_id, None)
episode_id = getattr(entry, 'episode_id', None)
entry.episode = episodes.get(episode_id, None)
if hasattr(entry, 'user'):
entry.user = user
device = devices.get(getattr(entry, 'device_id', None), None)
entry.device = device
return entries
def create_subscriptionlist(request):
user = request.user
subscriptions = subscriptions_by_user(user)
if not subscriptions:
return []
# Load all Podcasts and Devices first to ensure that they are
# only loaded once, not for each occurance in a subscription
public, podcast_ids, device_ids = unzip(subscriptions)
podcast_ids= list(set(podcast_ids))
device_ids = list(set(device_ids))
podcasts = podcasts_to_dict(podcast_ids)
devices = user.get_devices_by_id(device_ids)
subscription_list = {}
for public, podcast_id, device_id in subscriptions:
device = devices.get(device_id)
if not podcast_id in subscription_list:
podcast = podcasts.get(podcast_id, None)
if podcast is None:
continue
subscription_list[podcast_id] = {
'podcast': podcasts[podcast_id],
'devices': [device] if device else [],
'episodes': podcast.episode_count,
}
else:
if device:
subscription_list[podcast_id]['devices'].append(device)
subscriptions = subscription_list.values()
sort_key = lambda s: s['podcast'].latest_episode_timestamp or datetime.utcnow()
subscriptions = sorted(subscriptions, key=sort_key, reverse=True)
return subscriptions
