mygpo/publisher/views.py

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