mygpo/directory/views.py

   1 from __future__ import division
   2
   3 from itertools import imap as map
   4 from math import ceil
   5
   6 from django.http import HttpResponseNotFound, Http404, HttpResponseRedirect
   7 from django.core.urlresolvers import reverse
   8 from django.shortcuts import render
   9 from django.contrib.sites.models import RequestSite
  10 from django.views.decorators.cache import cache_control
  11 from django.views.decorators.vary import vary_on_cookie
  12 from django.utils.decorators import method_decorator
  13 from django.views.generic.base import View
  14 from django.contrib.auth.decorators import login_required
  15 from django.contrib import messages
  16 from django.utils.translation import ugettext as _
  17
  18 from feedservice.parse.models import ParserException
  19 from feedservice.parse import FetchFeedException
  20
  21 from mygpo.core.proxy import proxy_object
  22 from mygpo.directory.toplist import PodcastToplist, EpisodeToplist, \
  23          TrendingPodcasts
  24 from mygpo.directory.search import search_podcasts
  25 from mygpo.web.utils import process_lang_params, get_language_names, \
  26          get_page_list, get_podcast_link_target
  27 from mygpo.directory.tags import Topics
  28 from mygpo.users.models import User
  29 from mygpo.users.settings import FLATTR_TOKEN
  30 from mygpo.data.feeddownloader import PodcastUpdater, NoEpisodesException
  31 from mygpo.db.couchdb.podcast import get_podcast_languages, podcasts_by_id, \
  32          random_podcasts, podcasts_to_dict, podcast_for_url, \
  33          get_flattr_podcasts, get_flattr_podcast_count
  34 from mygpo.db.couchdb.directory import category_for_tag
  35 from mygpo.db.couchdb.podcastlist import random_podcastlists, \
  36          podcastlist_count, podcastlists_by_rating
  37
  38
  39 @vary_on_cookie
  40 @cache_control(private=True)
  41 def toplist(request, num=100, lang=None):
  42
  43     lang = process_lang_params(request)
  44
  45     toplist = PodcastToplist(lang)
  46     entries = toplist[:num]
  47
  48     max_subscribers = max([p.subscriber_count() for (oldp, p) in entries]) if entries else 0
  49     current_site = RequestSite(request)
  50
  51     languages = get_podcast_languages()
  52     all_langs = get_language_names(languages)
  53
  54     return render(request, 'toplist.html', {
  55         'entries': entries,
  56         'max_subscribers': max_subscribers,
  57         'url': current_site,
  58         'language': lang,
  59         'all_languages': all_langs,
  60     })
  61
  62
  63 class Carousel(View):
  64     """ A carousel demo """
  65
  66     @method_decorator(cache_control(private=True))
  67     @method_decorator(vary_on_cookie)
  68     def get(self, request):
  69
  70         return render(request, 'carousel.html', {
  71             # evaluated lazyly, cached by template
  72             'topics': Topics(),
  73             })
  74
  75
  76 class Directory(View):
  77     """ The main directory page """
  78
  79     @method_decorator(cache_control(private=True))
  80     @method_decorator(vary_on_cookie)
  81     def get(self, request):
  82
  83         return render(request, 'directory.html', {
  84
  85             # evaluated lazyly, cached by template
  86             'topics': Topics(),
  87             'trending_podcasts': TrendingPodcasts(''),
  88             'podcastlists': self.get_random_list(),
  89             'random_podcasts': self.get_random_podcast(),
  90             })
  91
  92
  93     def get_random_list(self, podcasts_per_list=5):
  94         random_list = next(random_podcastlists(), None)
  95         list_owner = None
  96         if random_list:
  97             random_list = proxy_object(random_list)
  98             random_list.more_podcasts = max(0, len(random_list.podcasts) - podcasts_per_list)
  99             random_list.podcasts = podcasts_by_id(random_list.podcasts[:podcasts_per_list])
 100             random_list.user = User.get(random_list.user)
 101
 102         yield random_list
 103
 104     def get_random_podcast(self):
 105         random_podcast = next(random_podcasts(), None)
 106         if random_podcast:
 107             yield random_podcast.get_podcast()
 108
 109
 110 @cache_control(private=True)
 111 @vary_on_cookie
 112 def category(request, category, page_size=20):
 113     category = category_for_tag(category)
 114     if not category:
 115         return HttpResponseNotFound()
 116
 117     # Make sure page request is an int. If not, deliver first page.
 118     try:
 119         page = int(request.GET.get('page', '1'))
 120     except ValueError:
 121         page = 1
 122
 123     entries = category.get_podcasts( (page-1) * page_size, page*page_size )
 124     podcasts = filter(None, entries)
 125     num_pages = ceil(len(category.podcasts) / page_size)
 126
 127     page_list = get_page_list(1, num_pages, page, 15)
 128
 129     return render(request, 'category.html', {
 130         'entries': podcasts,
 131         'category': category.label,
 132         'page_list': page_list,
 133         })
 134
 135
 136
 137 RESULTS_PER_PAGE=20
 138
 139 @cache_control(private=True)
 140 @vary_on_cookie
 141 def search(request, template='search.html', args={}):
 142
 143     if 'q' in request.GET:
 144         q = request.GET.get('q', '').encode('utf-8')
 145
 146         try:
 147             page = int(request.GET.get('page', 1))
 148         except ValueError:
 149             page = 1
 150
 151         results, total = search_podcasts(q=q, skip=RESULTS_PER_PAGE*(page-1))
 152         num_pages = ceil(total / RESULTS_PER_PAGE)
 153
 154         page_list = get_page_list(1, num_pages, page, 15)
 155
 156     else:
 157         results = []
 158         q = None
 159         page_list = []
 160
 161     max_subscribers = max([p.subscriber_count() for p in results] + [0])
 162     current_site = RequestSite(request)
 163
 164     return render(request, template, dict(
 165             q= q,
 166             results= results,
 167             page_list= page_list,
 168             max_subscribers= max_subscribers,
 169             domain= current_site.domain,
 170             **args
 171             ))
 172
 173
 174 @cache_control(private=True)
 175 @vary_on_cookie
 176 def episode_toplist(request, num=100):
 177     lang = process_lang_params(request)
 178
 179     toplist = EpisodeToplist(language=lang)
 180     entries = list(map(proxy_object, toplist[:num]))
 181
 182     # load podcast objects
 183     podcast_ids = [e.podcast for e in entries]
 184     podcasts = podcasts_to_dict(podcast_ids, True)
 185     for entry in entries:
 186         entry.podcast = podcasts.get(entry.podcast, None)
 187
 188     current_site = RequestSite(request)
 189
 190     # Determine maximum listener amount (or 0 if no entries exist)
 191     max_listeners = max([0]+[e.listeners for e in entries])
 192
 193     languages = get_podcast_languages()
 194     all_langs = get_language_names(languages)
 195
 196     return render(request, 'episode_toplist.html', {
 197         'entries': entries,
 198         'max_listeners': max_listeners,
 199         'url': current_site,
 200         'language': lang,
 201         'all_languages': all_langs,
 202     })
 203
 204
 205 @cache_control(private=True)
 206 @vary_on_cookie
 207 def podcast_lists(request, page_size=20):
 208
 209     # Make sure page request is an int. If not, deliver first page.
 210     try:
 211         page = int(request.GET.get('page', '1'))
 212     except ValueError:
 213         page = 1
 214
 215     lists = podcastlists_by_rating(skip=(page-1) * page_size, limit=page_size)
 216
 217
 218     def _prepare_list(l):
 219         user = User.get(l.user)
 220         l = proxy_object(l)
 221         l.username = user.username
 222         return l
 223
 224     lists = map(_prepare_list, lists)
 225
 226     num_pages = int(ceil(podcastlist_count() / float(page_size)))
 227
 228     page_list = get_page_list(1, num_pages, page, 15)
 229
 230     return render(request, 'podcast_lists.html', {
 231         'lists': lists,
 232         'page_list': page_list,
 233         })
 234
 235
 236
 237 class MissingPodcast(View):
 238     """ Check if a podcast is missing """
 239
 240     @method_decorator(login_required)
 241     def get(self, request):
 242
 243         site = RequestSite(request)
 244
 245         # check if we're doing a query
 246         url = request.GET.get('q', None)
 247
 248         if not url:
 249             podcast = None
 250             can_add = False
 251
 252         else:
 253             podcast = podcast_for_url(url)
 254
 255             # if the podcast does already exist, there's nothing more to do
 256             if podcast:
 257                 can_add = False
 258
 259             # check if we could add a podcast for the given URL
 260             else:
 261                 podcast = False
 262                 updater = PodcastUpdater()
 263
 264                 try:
 265                     can_add = updater.verify_podcast_url(url)
 266
 267                 except (ParserException, FetchFeedException,
 268                         NoEpisodesException) as ex:
 269                     can_add = False
 270                     messages.error(request, str(ex))
 271
 272         return render(request, 'missing.html', {
 273                 'site': site,
 274                 'q': url,
 275                 'podcast': podcast,
 276                 'can_add': can_add,
 277             })
 278
 279
 280 class AddPodcast(View):
 281     """ Add a missing podcast"""
 282
 283     @method_decorator(login_required)
 284     @method_decorator(cache_control(private=True))
 285     @method_decorator(vary_on_cookie)
 286     def post(self, request):
 287
 288         url = request.POST.get('url', None)
 289
 290         if not url:
 291             raise Http404
 292
 293         updater = PodcastUpdater()
 294
 295         try:
 296             podcast = updater.update(url)
 297
 298             messages.success(request, _('The podcast has been added'))
 299
 300             return HttpResponseRedirect(get_podcast_link_target(podcast))
 301
 302         except (ParserException, FetchFeedException,
 303                 NoEpisodesException) as ex:
 304             messages.error(request, str(ex))
 305
 306             add_page = '%s?q=%s' % (reverse('missing-podcast'), url)
 307             return HttpResponseRedirect(add_page)
 308
 309
 310
 311 class FlattrPodcastList(View):
 312     """ Lists podcasts that have Flattr payment URLs """
 313
 314     @method_decorator(cache_control(private=True))
 315     @method_decorator(vary_on_cookie)
 316     def get(self, request, page_size=20):
 317
 318         # Make sure page request is an int. If not, deliver first page.
 319         try:
 320             page = int(request.GET.get('page', '1'))
 321         except ValueError:
 322             page = 1
 323
 324         podcasts = get_flattr_podcasts( (page-1) * page_size, page_size)
 325         podcast_count = get_flattr_podcast_count()
 326         num_pages = ceil(podcast_count / page_size)
 327         page_list = get_page_list(1, num_pages, page, 15)
 328
 329         max_subscribers = max([p.subscriber_count() for p in podcasts] + [0])
 330
 331         user = request.user
 332         flattr_auth = user.is_authenticated() and bool(user.get_wksetting(FLATTR_TOKEN))
 333
 334         return render(request, 'flattr-podcasts.html', {
 335             'podcasts': podcasts,
 336             'page_list': page_list,
 337             'current_page': page,
 338             'flattr_auth': flattr_auth,
 339             'max_subscribers': max_subscribers,
 340             })