mygpo/publisher/views.py

   1 from django.shortcuts import render_to_response, get_object_or_404
   2 from django.template import RequestContext
   3 from django.http import HttpResponse, HttpResponseRedirect, HttpResponseForbidden
   4 from mygpo.api.models import Podcast, Episode, PodcastGroup
   5 from mygpo.publisher.models import PodcastPublisher
   6 from mygpo.publisher.auth import require_publisher, is_publisher
   7 from mygpo.publisher.forms import SearchPodcastForm, EpisodeForm, PodcastForm
   8 from mygpo.publisher.utils import listener_data, episode_listener_data, check_publisher_permission, subscriber_data, device_stats, episode_heatmap
   9 from django.contrib.sites.models import Site
  10 from mygpo.data.feeddownloader import update_podcasts
  11 from mygpo.decorators import requires_token, allowed_methods
  12 from mygpo.web.models import SecurityToken
  13 from django.contrib.auth.models import User
  14
  15
  16 def home(request):
  17     if is_publisher(request.user):
  18         podcasts = [x.podcast for x in PodcastPublisher.objects.filter(user=request.user)]
  19         form = SearchPodcastForm()
  20         return render_to_response('publisher/home.html', {
  21             'podcasts': podcasts,
  22             'form': form
  23             }, context_instance=RequestContext(request))
  24
  25     else:
  26         site = Site.objects.get_current()
  27         return render_to_response('publisher/info.html', {
  28             'site': site
  29             }, context_instance=RequestContext(request))
  30
  31
  32 @require_publisher
  33 def search_podcast(request):
  34     form = SearchPodcastForm(request.POST)
  35     if form.is_valid():
  36         url = form.cleaned_data['url']
  37         p = get_object_or_404(Podcast, url=url)
  38
  39         return HttpResponseRedirect('/publisher/podcast/%d' % p.id)
  40
  41     else:
  42         return HttpResponseRedirect('/publisher/')
  43
  44 @require_publisher
  45 @allowed_methods(['GET', 'POST'])
  46 def podcast(request, id):
  47     p = get_object_or_404(Podcast, pk=id)
  48
  49     if not check_publisher_permission(request.user, p):
  50         return HttpResponseForbidden()
  51
  52     timeline_data = listener_data([p])
  53     subscription_data = subscriber_data([p])
  54     device_data = device_stats([p])
  55
  56     if request.method == 'POST':
  57         form = PodcastForm(request.POST, instance=p)
  58         if form.is_valid():
  59             form.save()
  60
  61     elif request.method == 'GET':
  62         form = PodcastForm(instance=p)
  63
  64     update_token, c = SecurityToken.objects.get_or_create(user=request.user, object='published_feeds', action='update')
  65
  66     if 'new_token' in request.GET:
  67         update_token.random_token()
  68         update_token.save()
  69
  70     site = Site.objects.get_current()
  71
  72     return render_to_response('publisher/podcast.html', {
  73         'site': site,
  74         'podcast': p,
  75         'form': form,
  76         'timeline_data': timeline_data,
  77         'subscriber_data': subscription_data,
  78         'device_data': device_data,
  79         'update_token': update_token,
  80         }, context_instance=RequestContext(request))
  81
  82
  83 @require_publisher
  84 def group(request, group_id):
  85     g = get_object_or_404(PodcastGroup, id=group_id)
  86
  87     # users need to have publisher access for at least one of the group's podcasts
  88     if not any([check_publisher_permission(request.user, p) for p in g.podcasts()]):
  89         return HttpResponseForbidden()
  90
  91
  92     timeline_data = listener_data(g.podcasts())
  93     subscription_data = subscriber_data(g.podcasts())
  94     device_data = device_stats(g.podcasts())
  95
  96     return render_to_response('publisher/group.html', {
  97         'group': g,
  98         'timeline_data': timeline_data,
  99         'subscriber_data': subscription_data,
 100         'device_data': device_data,
 101         }, context_instance=RequestContext(request))
 102
 103
 104 @require_publisher
 105 def update_podcast(request, id):
 106     p = get_object_or_404(Podcast, pk=id)
 107
 108     if not check_publisher_permission(request.user, p):
 109         return HttpResponseForbidden()
 110
 111     update_podcasts( [p] )
 112
 113     return HttpResponseRedirect('/publisher/podcast/%s' % id)
 114
 115
 116 @requires_token(object='published_feeds', action='update')
 117 def update_published_podcasts(request, username):
 118     user = get_object_or_404(User, username=username)
 119
 120     published_podcasts = [p.podcast for p in PodcastPublisher.objects.filter(user=user)]
 121     update_podcasts(published_podcasts)
 122
 123     return HttpResponse('Updated:\n' + '\n'.join([p.url for p in published_podcasts]), mimetype='text/plain')
 124
 125
 126 @require_publisher
 127 def episodes(request, id):
 128     p = get_object_or_404(Podcast, pk=id)
 129
 130     if not check_publisher_permission(request.user, p):
 131         return HttpResponseForbidden()
 132
 133     episodes = p.get_episodes()
 134     max_listeners = max([x.listener_count() for x in episodes]) if len(episodes) else 0
 135
 136     return render_to_response('publisher/episodes.html', {
 137         'podcast': p,
 138         'episodes': episodes,
 139         'max_listeners': max_listeners
 140         }, context_instance=RequestContext(request))
 141
 142
 143 @require_publisher
 144 @allowed_methods(['GET', 'POST'])
 145 def episode(request, id):
 146     e = get_object_or_404(Episode, pk=id)
 147
 148     if not check_publisher_permission(request.user, e.podcast):
 149         return HttpResponseForbidden()
 150
 151     if request.method == 'POST':
 152         form = EpisodeForm(request.POST, instance=e)
 153         if form.is_valid():
 154             form.save()
 155
 156     elif request.method == 'GET':
 157         form = EpisodeForm(instance=e)
 158
 159     timeline_data = episode_listener_data(e)
 160     heatmap_data, part_length = episode_heatmap(e)
 161
 162     return render_to_response('publisher/episode.html', {
 163         'episode': e,
 164         'form': form,
 165         'timeline_data': timeline_data,
 166         'heatmap_data': heatmap_data if any([x > 0 for x in heatmap_data]) else None,
 167         'heatmap_part_length': part_length,
 168         }, context_instance=RequestContext(request))
 169
 170
 171 def link(request):
 172     current_site = Site.objects.get_current()
 173     return render_to_response('link.html', {
 174         'url': current_site
 175         }, context_instance=RequestContext(request))
 176
 177
 178 def advertise(request):
 179     site = Site.objects.get_current()
 180     return render_to_response('publisher/advertise.html', {
 181         'site': site
 182     }, context_instance=RequestContext(request))
 183