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
  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 @never_cache
 150 @require_publisher
 151 def new_update_token(request, username):
 152     request.user.create_new_token('publisher_update_token')
 153     request.user.save()
 154     messages.success(request, _('Publisher token updated'))
 155     return HttpResponseRedirect(reverse('publisher'))
 156
 157
 158 @never_cache
 159 @requires_token(token_name='publisher_update_token')
 160 def update_published_podcasts(request, username):
 161     user = User.get_user(username)
 162     if not user:
 163         raise Http404
 164
 165     published_podcasts = podcasts_by_id(user.published_objects)
 166     updater = PodcastUpdater(published_podcasts)
 167     updater.update()
 168
 169     return HttpResponse('Updated:\n' + '\n'.join([p.url for p in published_podcasts]), mimetype='text/plain')
 170
 171
 172 @vary_on_cookie
 173 @cache_control(private=True)
 174 @require_publisher
 175 def episodes(request, podcast):
 176
 177     if not check_publisher_permission(request.user, podcast):
 178         return HttpResponseForbidden()
 179
 180     episodes = episodes_for_podcast(podcast, descending=True)
 181     listeners = dict(episode_listener_counts(podcast))
 182
 183     max_listeners = max(listeners.values() + [0])
 184
 185     def annotate_episode(episode):
 186         listener_count = listeners.get(episode._id, None)
 187         return proxy_object(episode, listeners=listener_count)
 188
 189     episodes = map(annotate_episode, episodes)
 190
 191     return render(request, 'publisher/episodes.html', {
 192         'podcast': podcast,
 193         'episodes': episodes,
 194         'max_listeners': max_listeners
 195         })
 196
 197
 198 @require_publisher
 199 @vary_on_cookie
 200 @cache_control(private=True)
 201 @allowed_methods(['GET', 'POST'])
 202 def episode(request, episode):
 203
 204     podcast = podcast_by_id(episode.podcast)
 205
 206     if not check_publisher_permission(request.user, podcast):
 207         return HttpResponseForbidden()
 208
 209     if request.method == 'POST':
 210         form = None #EpisodeForm(request.POST, instance=e)
 211         #if form.is_valid():
 212         #    form.save()
 213
 214     elif request.method == 'GET':
 215         form = None #EpisodeForm(instance=e)
 216
 217     timeline_data = list(episode_listener_data(episode))
 218
 219     heatmap = EpisodeHeatmap(episode.podcast, episode._id,
 220               duration=episode.duration)
 221
 222     return render(request, 'publisher/episode.html', {
 223         'episode': episode,
 224         'podcast': podcast,
 225         'form': form,
 226         'timeline_data': timeline_data,
 227         'heatmap': heatmap,
 228         })
 229
 230
 231 @vary_on_cookie
 232 @cache_control(private=True)
 233 def link(request):
 234     current_site = RequestSite(request)
 235     return render(request, 'link.html', {
 236         'url': current_site
 237         })
 238
 239
 240 @vary_on_cookie
 241 @cache_control(private=True)
 242 def advertise(request):
 243     site = RequestSite(request)
 244     return render(request, 'publisher/advertise.html', {
 245         'site': site
 246     })
 247
 248
 249 def group_slug_id_decorator(f):
 250     @wraps(f)
 251     def _decorator(request, slug_id, *args, **kwargs):
 252         group = podcastgroup_for_slug_id(slug_id)
 253
 254         if podcast is None:
 255             raise Http404
 256
 257         return f(request, group, *args, **kwargs)
 258
 259     return _decorator
 260
 261
 262 def group_oldid_decorator(f):
 263     @wraps(f)
 264     def _decorator(request, pid, *args, **kwargs):
 265         try:
 266             pid = int(pid)
 267         except (TypeError, ValueError):
 268             raise Http404
 269
 270         group = podcastgroup_for_oldid(pid)
 271
 272         if not podcast:
 273             raise Http404
 274
 275         return f(request, group, *args, **kwargs)
 276
 277     return _decorator
 278
 279
 280
 281 episode_oldid        = oldid_decorator(episode)
 282 podcast_oldid        = podcast_oldid_decorator(podcast)
 283 update_podcast_oldid = podcast_oldid_decorator(update_podcast)
 284 episodes_oldid       = podcast_oldid_decorator(episodes)
 285 group_oldid          = group_oldid_decorator(group)
 286
 287 episode_slug_id        = slug_id_decorator(episode)
 288 podcast_slug_id        = podcast_slug_id_decorator(podcast)
 289 episodes_slug_id       = podcast_slug_id_decorator(episodes)
 290 update_podcast_slug_id = podcast_slug_id_decorator(update_podcast)
 291 group_slug_id          = group_slug_id_decorator(group)