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