mygpo/publisher/views.py

   1 from functools import wraps
   2 import urllib
   3
   4 from django.shortcuts import render
   5 from django.http import HttpResponse, HttpResponseRedirect, \
   6         HttpResponseForbidden, Http404
   7 from django.views.decorators.cache import never_cache, cache_control
   8 from django.views.decorators.vary import vary_on_cookie
   9 from django.core.urlresolvers import reverse
  10 from django.utils.translation import ugettext as _
  11 from django.contrib import messages
  12
  13 from mygpo.core.proxy import proxy_object
  14 from mygpo.publisher.auth import require_publisher, is_publisher
  15 from mygpo.publisher.forms import SearchPodcastForm
  16 from mygpo.publisher.utils import listener_data, episode_listener_data, \
  17          check_publisher_permission, subscriber_data
  18 from mygpo.web.heatmap import EpisodeHeatmap
  19 from mygpo.web.views.episode import oldid_decorator, slug_id_decorator
  20 from mygpo.web.views.podcast import \
  21          slug_id_decorator as podcast_slug_id_decorator, \
  22          oldid_decorator as podcast_oldid_decorator
  23 from mygpo.web.utils import get_podcast_link_target
  24 from django.contrib.sites.models import RequestSite
  25 from mygpo.data.feeddownloader import PodcastUpdater
  26 from mygpo.decorators import requires_token, allowed_methods
  27 from mygpo.users.models import User
  28 from mygpo.db.couchdb.episode import episodes_for_podcast
  29 from mygpo.db.couchdb.podcast import podcast_by_id, podcasts_by_id, \
  30          podcast_for_url, podcastgroup_for_slug_id, podcastgroup_for_oldid, \
  31          podcastgroup_by_id, update_additional_data
  32 from mygpo.db.couchdb.episode_state import episode_listener_counts
  33
  34
  35 @vary_on_cookie
  36 @cache_control(private=True)
  37 def home(request):
  38     if is_publisher(request.user):
  39         podcasts = podcasts_by_id(request.user.published_objects)
  40         site = RequestSite(request)
  41         update_token = request.user.get_token('publisher_update_token')
  42         form = SearchPodcastForm()
  43         return render(request, 'publisher/home.html', {
  44             'update_token': update_token,
  45             'podcasts': podcasts,
  46             'form': form,
  47             'site': site,
  48             })
  49
  50     else:
  51         site = RequestSite(request)
  52         return render(request, 'publisher/info.html', {
  53             'site': site
  54             })
  55
  56
  57 @vary_on_cookie
  58 @cache_control(private=True)
  59 @require_publisher
  60 def search_podcast(request):
  61     form = SearchPodcastForm(request.POST)
  62     if form.is_valid():
  63         url = form.cleaned_data['url']
  64
  65         podcast = podcast_for_url(url)
  66         if not podcast:
  67             raise Http404
  68
  69         url = get_podcast_link_target(podcast, 'podcast-publisher-detail')
  70     else:
  71         url = reverse('publisher')
  72
  73     return HttpResponseRedirect(url)
  74
  75
  76 @vary_on_cookie
  77 @cache_control(private=True)
  78 @require_publisher
  79 @allowed_methods(['GET', 'POST'])
  80 def podcast(request, podcast):
  81
  82     if not check_publisher_permission(request.user, podcast):
  83         return HttpResponseForbidden()
  84
  85     timeline_data = listener_data([podcast])
  86     subscription_data = subscriber_data([podcast])[-20:]
  87
  88     if podcast.group:
  89         group = podcastgroup_by_id(podcast.group)
  90     else:
  91         group = None
  92
  93     update_token = request.user.publisher_update_token
  94
  95     heatmap = EpisodeHeatmap(podcast.get_id())
  96
  97     site = RequestSite(request)
  98     feedurl_quoted = urllib.quote(podcast.url)
  99
 100     return render(request, 'publisher/podcast.html', {
 101         'site': site,
 102         'podcast': podcast,
 103         'group': group,
 104         'form': None,
 105         'timeline_data': timeline_data,
 106         'subscriber_data': subscription_data,
 107         'update_token': update_token,
 108         'heatmap': heatmap,
 109         'feedurl_quoted': feedurl_quoted,
 110         })
 111
 112
 113 @vary_on_cookie
 114 @cache_control(private=True)
 115 @require_publisher
 116 def group(request, group):
 117
 118     podcasts = group.podcasts
 119
 120     # users need to have publisher access for at least one of the group's podcasts
 121     if not any([check_publisher_permission(request.user, p) for p in podcasts]):
 122         return HttpResponseForbidden()
 123
 124     timeline_data = listener_data(podcasts)
 125     subscription_data = list(subscriber_data(podcasts))[-20:]
 126
 127     return render(request, 'publisher/group.html', {
 128         'group': group,
 129         'timeline_data': timeline_data,
 130         'subscriber_data': subscription_data,
 131         })
 132
 133
 134 @vary_on_cookie
 135 @cache_control(private=True)
 136 @require_publisher
 137 def update_podcast(request, podcast):
 138
 139     if not check_publisher_permission(request.user, podcast):
 140         return HttpResponseForbidden()
 141
 142     updater = PodcastUpdater( [podcast] )
 143     updater.update()
 144
 145     url = get_podcast_link_target(podcast, 'podcast-publisher-detail')
 146     return HttpResponseRedirect(url)
 147
 148
 149 @vary_on_cookie
 150 @cache_control(private=True)
 151 @require_publisher
 152 def save_podcast(request, podcast):
 153     update_additional_data(podcast, request.POST.get('twitter', None))
 154     messages.success(request, _('Data updated'))
 155     url = get_podcast_link_target(podcast, 'podcast-publisher-detail')
 156     return HttpResponseRedirect(url)
 157
 158
 159
 160 @never_cache
 161 @require_publisher
 162 def new_update_token(request, username):
 163     request.user.create_new_token('publisher_update_token')
 164     request.user.save()
 165     messages.success(request, _('Publisher token updated'))
 166     return HttpResponseRedirect(reverse('publisher'))
 167
 168
 169 @never_cache
 170 @requires_token(token_name='publisher_update_token')
 171 def update_published_podcasts(request, username):
 172     user = User.get_user(username)
 173     if not user:
 174         raise Http404
 175
 176     published_podcasts = podcasts_by_id(user.published_objects)
 177     updater = PodcastUpdater(published_podcasts)
 178     updater.update()
 179
 180     return HttpResponse('Updated:\n' + '\n'.join([p.url for p in published_podcasts]), mimetype='text/plain')
 181
 182
 183 @vary_on_cookie
 184 @cache_control(private=True)
 185 @require_publisher
 186 def episodes(request, podcast):
 187
 188     if not check_publisher_permission(request.user, podcast):
 189         return HttpResponseForbidden()
 190
 191     episodes = episodes_for_podcast(podcast, descending=True)
 192     listeners = dict(episode_listener_counts(podcast))
 193
 194     max_listeners = max(listeners.values() + [0])
 195
 196     def annotate_episode(episode):
 197         listener_count = listeners.get(episode._id, None)
 198         return proxy_object(episode, listeners=listener_count)
 199
 200     episodes = map(annotate_episode, episodes)
 201
 202     return render(request, 'publisher/episodes.html', {
 203         'podcast': podcast,
 204         'episodes': episodes,
 205         'max_listeners': max_listeners
 206         })
 207
 208
 209 @require_publisher
 210 @vary_on_cookie
 211 @cache_control(private=True)
 212 @allowed_methods(['GET', 'POST'])
 213 def episode(request, episode):
 214
 215     podcast = podcast_by_id(episode.podcast)
 216
 217     if not check_publisher_permission(request.user, podcast):
 218         return HttpResponseForbidden()
 219
 220     if request.method == 'POST':
 221         form = None #EpisodeForm(request.POST, instance=e)
 222         #if form.is_valid():
 223         #    form.save()
 224
 225     elif request.method == 'GET':
 226         form = None #EpisodeForm(instance=e)
 227
 228     timeline_data = list(episode_listener_data(episode))
 229
 230     heatmap = EpisodeHeatmap(episode.podcast, episode._id,
 231               duration=episode.duration)
 232
 233     return render(request, 'publisher/episode.html', {
 234         'episode': episode,
 235         'podcast': podcast,
 236         'form': form,
 237         'timeline_data': timeline_data,
 238         'heatmap': heatmap,
 239         })
 240
 241
 242 @vary_on_cookie
 243 @cache_control(private=True)
 244 def link(request):
 245     current_site = RequestSite(request)
 246     return render(request, 'link.html', {
 247         'url': current_site
 248         })
 249
 250
 251 @vary_on_cookie
 252 @cache_control(private=True)
 253 def advertise(request):
 254     site = RequestSite(request)
 255     return render(request, 'publisher/advertise.html', {
 256         'site': site
 257     })
 258
 259
 260 def group_slug_id_decorator(f):
 261     @wraps(f)
 262     def _decorator(request, slug_id, *args, **kwargs):
 263         group = podcastgroup_for_slug_id(slug_id)
 264
 265         if podcast is None:
 266             raise Http404
 267
 268         return f(request, group, *args, **kwargs)
 269
 270     return _decorator
 271
 272
 273 def group_oldid_decorator(f):
 274     @wraps(f)
 275     def _decorator(request, pid, *args, **kwargs):
 276         try:
 277             pid = int(pid)
 278         except (TypeError, ValueError):
 279             raise Http404
 280
 281         group = podcastgroup_for_oldid(pid)
 282
 283         if not podcast:
 284             raise Http404
 285
 286         return f(request, group, *args, **kwargs)
 287
 288     return _decorator
 289
 290
 291
 292 episode_oldid        = oldid_decorator(episode)
 293 podcast_oldid        = podcast_oldid_decorator(podcast)
 294 update_podcast_oldid = podcast_oldid_decorator(update_podcast)
 295 save_podcast_oldid   = podcast_oldid_decorator(save_podcast)
 296 episodes_oldid       = podcast_oldid_decorator(episodes)
 297 group_oldid          = group_oldid_decorator(group)
 298
 299 episode_slug_id        = slug_id_decorator(episode)
 300 podcast_slug_id        = podcast_slug_id_decorator(podcast)
 301 episodes_slug_id       = podcast_slug_id_decorator(episodes)
 302 update_podcast_slug_id = podcast_slug_id_decorator(update_podcast)
 303 save_podcast_slug_id   = podcast_slug_id_decorator(save_podcast)
 304 group_slug_id          = group_slug_id_decorator(group)