mygpo/web/views/podcast.py

   1 from functools import wraps, partial
   2
   3 from django.core.urlresolvers import reverse
   4 from django.http import HttpResponseBadRequest, HttpResponseRedirect, Http404
   5 from django.shortcuts import render
   6 from django.contrib.auth.decorators import login_required
   7 from django.contrib.sites.models import RequestSite
   8 from django.utils.translation import ugettext as _
   9 from django.contrib import messages
  10 from django.views.decorators.vary import vary_on_cookie
  11 from django.views.decorators.cache import never_cache, cache_control
  12
  13 from mygpo.core.models import PodcastGroup, SubscriptionException
  14 from mygpo.core.proxy import proxy_object
  15 from mygpo.core.tasks import flattr_thing
  16 from mygpo.utils import normalize_feed_url
  17 from mygpo.users.settings import PUBLIC_SUB_PODCAST, FLATTR_TOKEN
  18 from mygpo.users.models import HistoryEntry, DeviceDoesNotExist, SubscriptionAction
  19 from mygpo.web.forms import SyncForm
  20 from mygpo.decorators import allowed_methods, repeat_on_conflict
  21 from mygpo.web.utils import get_podcast_link_target, get_page_list
  22 from mygpo.db.couchdb.episode import episodes_for_podcast
  23 from mygpo.db.couchdb.podcast import podcast_for_slug, podcast_for_slug_id, \
  24          podcast_for_oldid, podcast_for_url
  25 from mygpo.db.couchdb.podcast_state import podcast_state_for_user_podcast, \
  26          add_subscription_action
  27 from mygpo.db.couchdb.episode_state import get_podcasts_episode_states, \
  28          episode_listener_counts
  29 from mygpo.db.couchdb.directory import tags_for_user, tags_for_podcast
  30
  31 import logging
  32 logger = logging.getLogger(__name__)
  33
  34
  35 MAX_TAGS_ON_PAGE=50
  36
  37
  38 @repeat_on_conflict(['state'])
  39 def update_podcast_settings(state, is_public):
  40     state.settings[PUBLIC_SUB_PODCAST.name] = is_public
  41     state.save()
  42
  43
  44 @vary_on_cookie
  45 @cache_control(private=True)
  46 @allowed_methods(['GET'])
  47 def show_slug(request, slug):
  48     podcast = podcast_for_slug(slug)
  49
  50     if slug != podcast.slug:
  51         target = reverse('podcast_slug', args=[podcast.slug])
  52         return HttpResponseRedirect(target)
  53
  54     return show(request, podcast.oldid)
  55
  56
  57 @vary_on_cookie
  58 @cache_control(private=True)
  59 @allowed_methods(['GET'])
  60 def show(request, podcast):
  61     """ Shows a podcast detail page """
  62
  63     current_site = RequestSite(request)
  64     episodes = episode_list(podcast, request.user, limit=20)
  65     user = request.user
  66
  67     max_listeners = max([e.listeners for e in episodes] + [0])
  68
  69     episode = None
  70
  71     if episodes:
  72         episode = episodes[0]
  73         episodes = episodes[1:]
  74
  75     if podcast.group:
  76         group = PodcastGroup.get(podcast.group)
  77         rel_podcasts = filter(lambda x: x != podcast, group.podcasts)
  78     else:
  79         rel_podcasts = []
  80
  81     tags = get_tags(podcast, user)
  82
  83     if user.is_authenticated():
  84         state = podcast_state_for_user_podcast(user, podcast)
  85         subscribed_devices = state.get_subscribed_device_ids()
  86         subscribed_devices = [user.get_device(x) for x in subscribed_devices]
  87
  88         subscribe_targets = podcast.subscribe_targets(user)
  89
  90         history = list(state.actions)
  91         is_public = state.settings.get('public_subscription', True)
  92         can_flattr = request.user.get_wksetting(FLATTR_TOKEN) and podcast.flattr_url
  93
  94     else:
  95         history = []
  96         is_public = False
  97         subscribed_devices = []
  98         subscribe_targets = []
  99         can_flattr = False
 100
 101     def _set_objects(h):
 102         dev = user.get_device(h.device)
 103         return proxy_object(h, device=dev)
 104     history = map(_set_objects, history)
 105
 106     return render(request, 'podcast.html', {
 107         'tags': tags,
 108         'url': current_site,
 109         'history': history,
 110         'podcast': podcast,
 111         'is_public': is_public,
 112         'devices': subscribed_devices,
 113         'related_podcasts': rel_podcasts,
 114         'can_subscribe': len(subscribe_targets) > 0,
 115         'subscribe_targets': subscribe_targets,
 116         'episode': episode,
 117         'episodes': episodes,
 118         'max_listeners': max_listeners,
 119         'can_flattr': can_flattr,
 120     })
 121
 122
 123 def get_tags(podcast, user):
 124     tags = {}
 125     for t in tags_for_podcast(podcast):
 126         tag_str = t.lower()
 127         tags[tag_str] = False
 128
 129     if not user.is_anonymous():
 130         users_tags = tags_for_user(user, podcast.get_id())
 131         for t in users_tags.get(podcast.get_id(), []):
 132             tag_str = t.lower()
 133             tags[tag_str] = True
 134
 135     tag_list = [{'tag': key, 'is_own': value} for key, value in tags.iteritems()]
 136     tag_list.sort(key=lambda x: x['tag'])
 137
 138     if len(tag_list) > MAX_TAGS_ON_PAGE:
 139         tag_list = filter(lambda x: x['is_own'], tag_list)
 140         tag_list.append({'tag': '...', 'is_own': False})
 141
 142     return tag_list
 143
 144
 145 def episode_list(podcast, user, offset=0, limit=None):
 146     """
 147     Returns a list of episodes, with their action-attribute set to the latest
 148     action. The attribute is unsert if there is no episode-action for
 149     the episode.
 150     """
 151
 152     listeners = dict(episode_listener_counts(podcast))
 153     episodes = episodes_for_podcast(podcast, descending=True, skip=offset, limit=limit)
 154
 155     if user.is_authenticated():
 156
 157         # prepare pre-populated data for HistoryEntry.fetch_data
 158         podcasts_dict = dict( (p_id, podcast) for p_id in podcast.get_ids())
 159         episodes_dict = dict( (episode._id, episode) for episode in episodes)
 160
 161         actions = get_podcasts_episode_states(podcast, user._id)
 162         actions = map(HistoryEntry.from_action_dict, actions)
 163
 164         HistoryEntry.fetch_data(user, actions,
 165                 podcasts=podcasts_dict, episodes=episodes_dict)
 166
 167         episode_actions = dict( (action.episode_id, action) for action in actions)
 168     else:
 169         episode_actions = {}
 170
 171     annotate_episode = partial(_annotate_episode, listeners, episode_actions)
 172     return map(annotate_episode, episodes)
 173
 174
 175
 176 def all_episodes(request, podcast, page_size=20):
 177
 178     # Make sure page request is an int. If not, deliver first page.
 179     try:
 180         page = int(request.GET.get('page', '1'))
 181     except ValueError:
 182         page = 1
 183
 184     episodes = episode_list(podcast, request.user, (page-1) * page_size,
 185             page_size)
 186     episodes_total = podcast.episode_count or 0
 187     num_pages = episodes_total / page_size
 188     page_list = get_page_list(1, num_pages, page, 15)
 189
 190     max_listeners = max([e.listeners for e in episodes] + [0])
 191
 192     return render(request, 'episodes.html', {
 193         'podcast': podcast,
 194         'episodes': episodes,
 195         'max_listeners': max_listeners,
 196         'page_list': page_list,
 197         'current_page': page,
 198     })
 199
 200
 201
 202 def _annotate_episode(listeners, episode_actions, episode):
 203     listener_count = listeners.pop(episode._id, None)
 204     action         = episode_actions.pop(episode._id, None)
 205     return proxy_object(episode, listeners=listener_count, action=action)
 206
 207
 208
 209 @never_cache
 210 @login_required
 211 def add_tag(request, podcast):
 212     podcast_state = podcast_state_for_user_podcast(request.user, podcast)
 213
 214     tag_str = request.GET.get('tag', '')
 215     if not tag_str:
 216         return HttpResponseBadRequest()
 217
 218     tags = tag_str.split(',')
 219
 220     @repeat_on_conflict(['state'])
 221     def update(state):
 222         state.add_tags(tags)
 223         state.save()
 224
 225     update(state=podcast_state)
 226
 227     if request.GET.get('next', '') == 'mytags':
 228         return HttpResponseRedirect('/tags/')
 229
 230     return HttpResponseRedirect(get_podcast_link_target(podcast))
 231
 232
 233 @never_cache
 234 @login_required
 235 def remove_tag(request, podcast):
 236     podcast_state = podcast_state_for_user_podcast(request.user, podcast)
 237
 238     tag_str = request.GET.get('tag', '')
 239     if not tag_str:
 240         return HttpResponseBadRequest()
 241
 242     @repeat_on_conflict(['state'])
 243     def update(state):
 244         tags = list(state.tags)
 245         if tag_str in tags:
 246             state.tags.remove(tag_str)
 247             state.save()
 248
 249     update(state=podcast_state)
 250
 251     if request.GET.get('next', '') == 'mytags':
 252         return HttpResponseRedirect('/tags/')
 253
 254     return HttpResponseRedirect(get_podcast_link_target(podcast))
 255
 256
 257 @never_cache
 258 @login_required
 259 @allowed_methods(['GET', 'POST'])
 260 def subscribe(request, podcast):
 261
 262     if request.method == 'POST':
 263
 264         # multiple UIDs from the /podcast/<slug>/subscribe
 265         device_uids = [k for (k,v) in request.POST.items() if k==v]
 266
 267         # single UID from /podcast/<slug>
 268         if 'targets' in request.POST:
 269             device_uids.append(request.POST.get('targets'))
 270
 271         for uid in device_uids:
 272             try:
 273                 device = request.user.get_device_by_uid(uid)
 274                 podcast.subscribe(request.user, device)
 275
 276             except (SubscriptionException, DeviceDoesNotExist, ValueError) as e:
 277                 messages.error(request, str(e))
 278
 279         return HttpResponseRedirect(get_podcast_link_target(podcast))
 280
 281     targets = podcast.subscribe_targets(request.user)
 282
 283     return render(request, 'subscribe.html', {
 284         'targets': targets,
 285         'podcast': podcast,
 286     })
 287
 288
 289 @never_cache
 290 @login_required
 291 def unsubscribe(request, podcast, device_uid):
 292
 293     return_to = request.GET.get('return_to', None)
 294
 295     if not return_to:
 296         raise Http404('Wrong URL')
 297
 298     try:
 299         device = request.user.get_device_by_uid(device_uid)
 300
 301     except DeviceDoesNotExist as e:
 302         messages.error(request, str(e))
 303         return HttpResponseRedirect(return_to)
 304
 305     try:
 306         podcast.unsubscribe(request.user, device)
 307     except SubscriptionException as e:
 308         logger.exception('Web: %(username)s: could not unsubscribe from podcast %(podcast_url)s on device %(device_id)s' %
 309             {'username': request.user.username, 'podcast_url': podcast.url, 'device_id': device.id})
 310
 311     return HttpResponseRedirect(return_to)
 312
 313
 314 @never_cache
 315 @login_required
 316 def subscribe_url(request):
 317     url = request.GET.get('url', None)
 318
 319     if not url:
 320         raise Http404('http://my.gpodder.org/subscribe?url=http://www.example.com/podcast.xml')
 321
 322     url = normalize_feed_url(url)
 323
 324     if not url:
 325         raise Http404('Please specify a valid url')
 326
 327     podcast = podcast_for_url(url, create=True)
 328
 329     return HttpResponseRedirect(get_podcast_link_target(podcast, 'subscribe'))
 330
 331
 332 @never_cache
 333 @allowed_methods(['POST'])
 334 def set_public(request, podcast, public):
 335     state = podcast_state_for_user_podcast(request.user, podcast)
 336     update_podcast_settings(state=state, is_public=public)
 337     return HttpResponseRedirect(get_podcast_link_target(podcast))
 338
 339
 340 @never_cache
 341 @login_required
 342 def flattr_podcast(request, podcast):
 343     """ Flattrs a podcast, records an event and redirects to the podcast """
 344
 345     user = request.user
 346     site = RequestSite(request)
 347
 348     # do flattring via the tasks queue, but wait for the result
 349     task = flattr_thing.delay(user, podcast.get_id(), site.domain,
 350             request.is_secure(), 'Podcast')
 351     success, msg = task.get()
 352
 353     if success:
 354         action = SubscriptionAction()
 355         action.action = 'flattr'
 356         state = podcast_state_for_user_podcast(request.user, podcast)
 357         add_subscription_action(state, action)
 358         messages.success(request, _("Flattr\'d"))
 359
 360     else:
 361         messages.error(request, msg)
 362
 363     return HttpResponseRedirect(get_podcast_link_target(podcast))
 364
 365
 366 # To make all view accessible via either CouchDB-ID or Slugs
 367 # a decorator queries the podcast and passes the Id on to the
 368 # regular views
 369
 370 def slug_id_decorator(f):
 371     @wraps(f)
 372     def _decorator(request, slug_id, *args, **kwargs):
 373         podcast = podcast_for_slug_id(slug_id)
 374
 375         if podcast is None:
 376             raise Http404
 377
 378         # redirect when Id or a merged (non-cannonical) slug is used
 379         if podcast.slug and slug_id != podcast.slug:
 380             return HttpResponseRedirect(get_podcast_link_target(podcast))
 381
 382         return f(request, podcast, *args, **kwargs)
 383
 384     return _decorator
 385
 386
 387 def oldid_decorator(f):
 388     @wraps(f)
 389     def _decorator(request, pid, *args, **kwargs):
 390         try:
 391             pid = int(pid)
 392         except (TypeError, ValueError):
 393             raise Http404
 394
 395         podcast = podcast_for_oldid(pid)
 396
 397         if not podcast:
 398             raise Http404
 399
 400         # redirect to Id or slug URL
 401         return HttpResponseRedirect(get_podcast_link_target(podcast))
 402
 403     return _decorator
 404
 405
 406 show_slug_id        = slug_id_decorator(show)
 407 subscribe_slug_id   = slug_id_decorator(subscribe)
 408 unsubscribe_slug_id = slug_id_decorator(unsubscribe)
 409 add_tag_slug_id     = slug_id_decorator(add_tag)
 410 remove_tag_slug_id  = slug_id_decorator(remove_tag)
 411 set_public_slug_id  = slug_id_decorator(set_public)
 412 all_episodes_slug_id= slug_id_decorator(all_episodes)
 413 flattr_podcast_slug_id=slug_id_decorator(flattr_podcast)
 414
 415
 416 show_oldid          = oldid_decorator(show)
 417 subscribe_oldid     = oldid_decorator(subscribe)
 418 unsubscribe_oldid   = oldid_decorator(unsubscribe)
 419 add_tag_oldid       = oldid_decorator(add_tag)
 420 remove_tag_oldid    = oldid_decorator(remove_tag)
 421 set_public_oldid    = oldid_decorator(set_public)
 422 all_episodes_oldid  = oldid_decorator(all_episodes)
 423 flattr_podcast_oldid= oldid_decorator(flattr_podcast)