def _get_obj_fun(self, action):
url, op = action
podcast = self.podcasts.get(url,
podcast_for_url(url, create=True))
state = podcast_state_for_user_podcast(self.user, podcast)
fun = self.operations[op]
return (state, fun)
def remove_tag(request, podcast):
podcast_state = podcast_state_for_user_podcast(request.user, podcast)
tag_str = request.GET.get('tag', '')
if not tag_str:
return HttpResponseBadRequest()
remove_podcast_tags(podcast_state, tag_str)
if request.GET.get('next', '') == 'mytags':
return HttpResponseRedirect('/tags/')
return HttpResponseRedirect(get_podcast_link_target(podcast))
def history(request, podcast):
""" shows the subscription history of the user """
user = request.user
state = podcast_state_for_user_podcast(user, podcast)
history = list(state.actions)
def _set_objects(h):
dev = user.get_device(h.device)
return proxy_object(h, device=dev)
history = map(_set_objects, history)
return render(request, 'podcast-history.html', {
'history': history,
'podcast': podcast,
})
def unsubscribe(self, user, device):
""" unsubscribes user from the current podcast on one or more devices """
from mygpo.db.couchdb.podcast_state import unsubscribe_on_device, \
podcast_state_for_user_podcast
state = podcast_state_for_user_podcast(user, self)
# accept devices, and also lists and tuples of devices
devices = device if isinstance(device, (list, tuple)) else [device]
for device in devices:
try:
unsubscribe_on_device(state, device)
subscription_changed.send(sender=self, user=user, device=device,
subscribed=False)
except Unauthorized as ex:
raise SubscriptionException(ex)
def unsubscribe_all(request, podcast):
""" unsubscribe all of the user's devices from the podcast """
user = request.user
state = podcast_state_for_user_podcast(user, podcast)
dev_ids = state.get_subscribed_device_ids()
devs = user.get_devices(dev_ids)
# ungroup groups
devs = [dev[0] if isinstance(dev, list) else dev for dev in devs]
try:
podcast.unsubscribe(user, devs)
except (SubscriptionException, DeviceDoesNotExist, ValueError) as e:
messages.error(request, str(e))
return HttpResponseRedirect(get_podcast_link_target(podcast))
def flattr_podcast(request, podcast):
""" Flattrs a podcast, records an event and redirects to the podcast """
user = request.user
site = RequestSite(request)
# do flattring via the tasks queue, but wait for the result
task = flattr_thing.delay(user, podcast.get_id(), site.domain,
request.is_secure(), 'Podcast')
success, msg = task.get()
if success:
action = SubscriptionAction()
action.action = 'flattr'
state = podcast_state_for_user_podcast(request.user, podcast)
add_subscription_action(state, action)
messages.success(request, _("Flattr\'d"))
else:
messages.error(request, msg)
return HttpResponseRedirect(get_podcast_link_target(podcast))
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 post(self, request, podcast_id):
podcast = podcast_by_id(podcast_id)
state = podcast_state_for_user_podcast(request.user, podcast)
set_podcast_privacy_settings(state, self.public)
return HttpResponseRedirect(reverse('privacy'))
def test_merge(self):
p1 = Podcast()
p1.urls = ['http://example.com/podcast1.rss']
p1.save()
p2 = Podcast()
p2.urls = ['http://example.com/podcast2.rss']
p2.save()
e1 = Episode()
e1.title = 'Episode 1'
e1.podcast = p1.get_id()
e1.urls = ['http://example.com/podcast1/e1.mp3']
e1.save()
e2 = Episode()
e2.title = 'Episode 2'
e2.podcast = p1.get_id()
e2.urls = ['http://example.com/podcast1/e2.mp3']
e2.save()
e3 = Episode()
e3.title = 'Episode 3'
e3.podcast = p2.get_id()
e3.urls = ['http://example.com/podcast2/e2.mp3']
e3.save()
e4 = Episode()
e4.title = 'Episode 4'
e4.podcast = p2.get_id()
e4.urls = ['http://example.com/podcast2/e3.mp3']
e4.save()
user = User()
user.username = '******'
user.email = '*****@*****.**'
user.set_password('secret')
device1 = Device()
device1.uid = 'dev1'
device2 = Device()
device2.uid = 'dev2'
user.devices.append(device1)
user.devices.append(device2)
user.save()
p1.subscribe(user, device1)
time.sleep(1)
p1.unsubscribe(user, device1)
time.sleep(1)
p1.subscribe(user, device1)
p2.subscribe(user, device2)
s1 = episode_state_for_user_episode(user, e1)
add_episode_actions(s1, [EpisodeAction(action='play',
upload_timestamp=get_timestamp(datetime.utcnow()))])
s3 = episode_state_for_user_episode(user, e3)
add_episode_actions(s3, [EpisodeAction(action='play',
upload_timestamp=get_timestamp(datetime.utcnow()))])
# we need that for later
e3_id = e3._id
actions = Counter()
# decide which episodes to merge
groups = [(0, [e1]), (1, [e2, e3]), (2, [e4])]
# carry out the merge
pm = PodcastMerger([p1, p2], actions, groups)
pm.merge()
e1 = episode_by_id(e1._id)
es1 = episode_state_for_user_episode(user, e1)
self.assertEqual(len(es1.actions), 1)
# check if merged episode's id can still be accessed
e3 = episode_by_id(e3_id)
es3 = episode_state_for_user_episode(user, e3)
self.assertEqual(len(es3.actions), 1)
p1 = podcast_by_id(p1.get_id())
ps1 = podcast_state_for_user_podcast(user, p1)
self.assertEqual(len(ps1.get_subscribed_device_ids()), 2)
self.assertEqual(len(list(episodes_for_podcast(p1))), 3)
def show(request, podcast):
""" Shows a podcast detail page """
podcast = check_restrictions(podcast)
current_site = RequestSite(request)
num_episodes = 20
episodes = episode_list(podcast, request.user, limit=num_episodes)
user = request.user
max_listeners = max([e.listeners for e in episodes] + [0])
episode = None
if episodes:
episode = episodes[0]
episodes = episodes[1:]
if podcast.group:
group = PodcastGroup.get(podcast.group)
rel_podcasts = filter(lambda x: x != podcast, group.podcasts)
else:
rel_podcasts = []
tags, has_tagged = get_tags(podcast, user)
if user.is_authenticated():
state = podcast_state_for_user_podcast(user, podcast)
subscribed_devices = state.get_subscribed_device_ids()
subscribed_devices = user.get_devices(subscribed_devices)
subscribe_targets = podcast.subscribe_targets(user)
has_history = bool(state.actions)
is_public = state.settings.get('public_subscription', True)
can_flattr = request.user.get_wksetting(FLATTR_TOKEN) and podcast.flattr_url
else:
has_history = False
is_public = False
subscribed_devices = []
subscribe_targets = []
can_flattr = False
is_publisher = check_publisher_permission(user, podcast)
episodes_total = podcast.episode_count or 0
num_pages = episodes_total / num_episodes
page_list = get_page_list(1, num_pages, 1, 15)
return render(request, 'podcast.html', {
'tags': tags,
'has_tagged': has_tagged,
'url': current_site,
'has_history': has_history,
'podcast': podcast,
'is_public': is_public,
'devices': subscribed_devices,
'related_podcasts': rel_podcasts,
'can_subscribe': len(subscribe_targets) > 0,
'subscribe_targets': subscribe_targets,
'episode': episode,
'episodes': episodes,
'max_listeners': max_listeners,
'can_flattr': can_flattr,
'is_publisher': is_publisher,
'page_list': page_list,
'current_page': 1,
})
def set_public(request, podcast, public):
state = podcast_state_for_user_podcast(request.user, podcast)
set_podcast_privacy_settings(state, public)
return HttpResponseRedirect(get_podcast_link_target(podcast))
