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
   5 from mygpo.api.constants import DEVICE_TYPES
   6 from django.contrib.auth.decorators import login_required
   7 from mygpo.publisher.models import PodcastPublisher
   8 from mygpo.publisher.auth import require_publisher, is_publisher
   9 from mygpo.publisher.forms import SearchPodcastForm, EpisodeForm, PodcastForm
  10 from mygpo.publisher.utils import listener_data, episode_listener_data, check_publisher_permission, episode_list, subscriber_data
  11 from django.contrib.sites.models import Site
  12 from mygpo.data.feeddownloader import update_podcasts
  13 from mygpo.decorators import requires_token
  14 from mygpo.web.models import SecurityToken
  15 from django.contrib.auth.models import User
  16
  17
  18 def home(request):
  19     if is_publisher(request.user):
  20         podcasts = [x.podcast for x in PodcastPublisher.objects.filter(user=request.user)]
  21         form = SearchPodcastForm()
  22         return render_to_response('publisher/home.html', {
  23             'podcasts': podcasts,
  24             'form': form
  25             }, context_instance=RequestContext(request))
  26
  27     else:
  28         site = Site.objects.get_current()
  29         return render_to_response('publisher/info.html', {
  30             'site': site
  31             }, context_instance=RequestContext(request))
  32
  33
  34 @require_publisher
  35 def search_podcast(request):
  36     form = SearchPodcastForm(request.POST)
  37     if form.is_valid():
  38         url = form.cleaned_data['url']
  39         p = get_object_or_404(Podcast, url=url)
  40
  41         return HttpResponseRedirect('/publisher/podcast/%d' % p.id)
  42
  43     else:
  44         return HttpResponseRedirect('/publisher/')
  45
  46 @require_publisher
  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 update_podcast(request, id):
  86     p = get_object_or_404(Podcast, pk=id)
  87
  88     if not check_publisher_permission(request.user, p):
  89         return HttpResponseForbidden()
  90
  91     update_podcasts( [p] )
  92
  93     return HttpResponseRedirect('/publisher/podcast/%s' % id)
  94
  95
  96 @requires_token(object='published_feeds', action='update')
  97 def update_published_podcasts(request, username):
  98     user = get_object_or_404(User, username=username)
  99
 100     published_podcasts = [p.podcast for p in PodcastPublisher.objects.filter(user=user)]
 101     update_podcasts(published_podcasts)
 102
 103     return HttpResponse('Updated:\n' + '\n'.join([p.url for p in published_podcasts]), mimetype='text/plain')
 104
 105
 106 @require_publisher
 107 def episodes(request, id):
 108     p = get_object_or_404(Podcast, pk=id)
 109
 110     if not check_publisher_permission(request.user, p):
 111         return HttpResponseForbidden()
 112
 113     episodes = episode_list(p)
 114     max_listeners = max([x.listeners for x in episodes]) if len(episodes) else 0
 115
 116     return render_to_response('publisher/episodes.html', {
 117         'podcast': p,
 118         'episodes': episodes,
 119         'max_listeners': max_listeners
 120         }, context_instance=RequestContext(request))
 121
 122
 123 @require_publisher
 124 def episode(request, id):
 125     e = get_object_or_404(Episode, pk=id)
 126
 127     if not check_publisher_permission(request.user, e.podcast):
 128         return HttpResponseForbidden()
 129
 130     if request.method == 'POST':
 131         form = EpisodeForm(request.POST, instance=e)
 132         if form.is_valid():
 133             form.save()
 134
 135     elif request.method == 'GET':
 136         form = EpisodeForm(instance=e)
 137
 138     timeline_data = episode_listener_data(e)
 139
 140     return render_to_response('publisher/episode.html', {
 141         'episode': e,
 142         'form': form,
 143         'timeline_data': timeline_data,
 144         }, context_instance=RequestContext(request))
 145
 146
 147 def device_stats(podcast):
 148     res = {}
 149     for type in DEVICE_TYPES:
 150         c = EpisodeAction.objects.filter(episode__podcast=podcast, device__type=type[0]).values('user_id').distinct().count()
 151         if c > 0:
 152             res[type[1]] = c
 153
 154     return res
 155
 156
 157 def link(request):
 158     current_site = Site.objects.get_current()
 159     return render_to_response('link.html', {
 160         'url': current_site
 161         }, context_instance=RequestContext(request))
 162