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