mygpo/directory/views.py

   1 from itertools import imap as map
   2 from math import ceil
   3
   4 from django.http import HttpResponseNotFound
   5 from django.shortcuts import render
   6 from django.contrib.sites.models import RequestSite
   7 from django.views.decorators.cache import cache_control
   8 from django.views.decorators.vary import vary_on_cookie
   9 from django.utils.decorators import method_decorator
  10 from django.views.generic.base import View
  11
  12 from mygpo.core.proxy import proxy_object
  13 from mygpo.directory.toplist import PodcastToplist, EpisodeToplist, \
  14          TrendingPodcasts
  15 from mygpo.directory.search import search_podcasts
  16 from mygpo.web.utils import process_lang_params, get_language_names, \
  17          get_page_list
  18 from mygpo.directory.tags import Topics
  19 from mygpo.users.models import User
  20 from mygpo.db.couchdb.podcast import get_podcast_languages, podcasts_by_id, \
  21          random_podcasts, podcasts_to_dict
  22 from mygpo.db.couchdb.directory import category_for_tag
  23 from mygpo.db.couchdb.podcastlist import random_podcastlists, \
  24          podcastlist_count, podcastlists_by_rating
  25
  26
  27 @vary_on_cookie
  28 @cache_control(private=True)
  29 def toplist(request, num=100, lang=None):
  30
  31     lang = process_lang_params(request)
  32
  33     toplist = PodcastToplist(lang)
  34     entries = toplist[:num]
  35
  36     max_subscribers = max([p.subscriber_count() for (oldp, p) in entries]) if entries else 0
  37     current_site = RequestSite(request)
  38
  39     languages = get_podcast_languages()
  40     all_langs = get_language_names(languages)
  41
  42     return render(request, 'toplist.html', {
  43         'entries': entries,
  44         'max_subscribers': max_subscribers,
  45         'url': current_site,
  46         'language': lang,
  47         'all_languages': all_langs,
  48     })
  49
  50
  51 class Carousel(View):
  52     """ A carousel demo """
  53
  54     @method_decorator(cache_control(private=True))
  55     @method_decorator(vary_on_cookie)
  56     def get(self, request):
  57
  58         return render(request, 'carousel.html', {
  59             # evaluated lazyly, cached by template
  60             'topics': Topics(),
  61             })
  62
  63
  64 class Directory(View):
  65     """ The main directory page """
  66
  67     @method_decorator(cache_control(private=True))
  68     @method_decorator(vary_on_cookie)
  69     def get(self, request):
  70
  71         return render(request, 'directory.html', {
  72
  73             # evaluated lazyly, cached by template
  74             'topics': Topics(),
  75             'trending_podcasts': TrendingPodcasts(''),
  76             'podcastlists': self.get_random_list(),
  77             'random_podcasts': self.get_random_podcast(),
  78             })
  79
  80
  81     def get_random_list(self, podcasts_per_list=5):
  82         random_list = next(random_podcastlists(), None)
  83         list_owner = None
  84         if random_list:
  85             random_list = proxy_object(random_list)
  86             random_list.more_podcasts = max(0, len(random_list.podcasts) - podcasts_per_list)
  87             random_list.podcasts = podcasts_by_id(random_list.podcasts[:podcasts_per_list])
  88             random_list.user = User.get(random_list.user)
  89
  90         yield random_list
  91
  92     def get_random_podcast(self):
  93         random_podcast = next(random_podcasts(), None)
  94         if random_podcast:
  95             yield random_podcast.get_podcast()
  96
  97
  98 @cache_control(private=True)
  99 @vary_on_cookie
 100 def category(request, category, page_size=20):
 101     category = category_for_tag(category)
 102     if not category:
 103         return HttpResponseNotFound()
 104
 105     # Make sure page request is an int. If not, deliver first page.
 106     try:
 107         page = int(request.GET.get('page', '1'))
 108     except ValueError:
 109         page = 1
 110
 111     entries = category.get_podcasts( (page-1) * page_size, page*page_size )
 112     podcasts = filter(None, entries)
 113     num_pages = len(category.podcasts) / page_size
 114
 115     page_list = get_page_list(1, num_pages, page, 15)
 116
 117     return render(request, 'category.html', {
 118         'entries': podcasts,
 119         'category': category.label,
 120         'page_list': page_list,
 121         })
 122
 123
 124
 125 RESULTS_PER_PAGE=20
 126
 127 @cache_control(private=True)
 128 @vary_on_cookie
 129 def search(request, template='search.html', args={}):
 130
 131     if 'q' in request.GET:
 132         q = request.GET.get('q', '').encode('utf-8')
 133
 134         try:
 135             page = int(request.GET.get('page', 1))
 136         except ValueError:
 137             page = 1
 138
 139         results, total = search_podcasts(q=q, skip=RESULTS_PER_PAGE*(page-1))
 140         num_pages = total / RESULTS_PER_PAGE
 141
 142         page_list = get_page_list(1, num_pages, page, 15)
 143
 144     else:
 145         results = []
 146         q = None
 147         page_list = []
 148
 149     max_subscribers = max([p.subscriber_count() for p in results] + [0])
 150     current_site = RequestSite(request)
 151
 152     return render(request, template, dict(
 153             q= q,
 154             results= results,
 155             page_list= page_list,
 156             max_subscribers= max_subscribers,
 157             domain= current_site.domain,
 158             **args
 159             ))
 160
 161
 162 @cache_control(private=True)
 163 @vary_on_cookie
 164 def episode_toplist(request, num=100):
 165     lang = process_lang_params(request)
 166
 167     toplist = EpisodeToplist(language=lang)
 168     entries = list(map(proxy_object, toplist[:num]))
 169
 170     # load podcast objects
 171     podcast_ids = [e.podcast for e in entries]
 172     podcasts = podcasts_to_dict(podcast_ids, True)
 173     for entry in entries:
 174         entry.podcast = podcasts.get(entry.podcast, None)
 175
 176     current_site = RequestSite(request)
 177
 178     # Determine maximum listener amount (or 0 if no entries exist)
 179     max_listeners = max([0]+[e.listeners for e in entries])
 180
 181     languages = get_podcast_languages()
 182     all_langs = get_language_names(languages)
 183
 184     return render(request, 'episode_toplist.html', {
 185         'entries': entries,
 186         'max_listeners': max_listeners,
 187         'url': current_site,
 188         'language': lang,
 189         'all_languages': all_langs,
 190     })
 191
 192
 193 @cache_control(private=True)
 194 @vary_on_cookie
 195 def podcast_lists(request, page_size=20):
 196
 197     # Make sure page request is an int. If not, deliver first page.
 198     try:
 199         page = int(request.GET.get('page', '1'))
 200     except ValueError:
 201         page = 1
 202
 203     lists = podcastlists_by_rating(skip=(page-1) * page_size, limit=page_size)
 204
 205
 206     def _prepare_list(l):
 207         user = User.get(l.user)
 208         l = proxy_object(l)
 209         l.username = user.username
 210         return l
 211
 212     lists = map(_prepare_list, lists)
 213
 214     num_pages = int(ceil(podcastlist_count() / float(page_size)))
 215
 216     page_list = get_page_list(1, num_pages, page, 15)
 217
 218     return render(request, 'podcast_lists.html', {
 219         'lists': lists,
 220         'page_list': page_list,
 221         })