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