mygpo/admin/views.py

   1 import re
   2 from itertools import count
   3
   4 from django.shortcuts import render
   5 from django.contrib import messages
   6 from django.core.urlresolvers import reverse
   7 from django.http import HttpResponseRedirect
   8 from django.utils.translation import ugettext as _
   9 from django.views.generic import TemplateView
  10 from django.utils.decorators import method_decorator
  11
  12 from mygpo.admin.auth import require_staff
  13 from mygpo.admin.group import PodcastGrouper
  14 from mygpo.counter import Counter
  15 from mygpo.maintenance.merge import PodcastMerger, IncorrectMergeException
  16 from mygpo.users.models import User
  17 from mygpo.admin.clients import UserAgentStats, ClientStats
  18 from mygpo.api.httpresponse import JsonResponse
  19 from mygpo.db.couchdb.episode import episode_count
  20 from mygpo.db.couchdb.podcast import podcast_count, podcast_for_url
  21
  22
  23 class AdminView(TemplateView):
  24
  25     @method_decorator(require_staff)
  26     def dispatch(self, *args, **kwargs):
  27         return super(AdminView, self).dispatch(*args, **kwargs)
  28
  29
  30 class Overview(AdminView):
  31     template_name = 'admin/overview.html'
  32
  33
  34 class MergeSelect(AdminView):
  35     template_name = 'admin/merge-select.html'
  36
  37     def get(self, request):
  38         num = int(request.GET.get('podcasts', 2))
  39         urls = [''] * num
  40
  41         return self.render_to_response({
  42                 'urls': urls,
  43             })
  44
  45
  46 class MergeBase(AdminView):
  47
  48     def _get_podcasts(self, request):
  49         podcasts = []
  50         for n in count():
  51             podcast_url = request.POST.get('feed%d' % n, None)
  52             if podcast_url is None:
  53                 break
  54
  55             if not podcast_url:
  56                 continue
  57
  58             podcast = podcast_for_url(podcast_url)
  59
  60             if not podcast:
  61                 raise InvalidPodcast(podcast_url)
  62
  63             podcasts.append(podcast_for_url(podcast_url))
  64
  65         return podcasts
  66
  67
  68 class MergeVerify(MergeBase):
  69
  70     template_name = 'admin/merge-grouping.html'
  71
  72     def post(self, request):
  73
  74         try:
  75             podcasts = self._get_podcasts(request)
  76
  77         except InvalidPodcast as ip:
  78             messages.error(request,
  79                     _('No podcast with URL {url}').format(url=str(ip)))
  80
  81         grouper = PodcastGrouper(podcasts)
  82
  83         get_features = lambda (e_id, e): ((e.url, e.title), e_id)
  84
  85         num_groups = grouper.group(get_features)
  86
  87         return self.render_to_response({
  88                 'podcasts': podcasts,
  89                 'groups': num_groups,
  90             })
  91
  92
  93 class MergeProcess(MergeBase):
  94
  95     RE_EPISODE = re.compile(r'episode_([0-9a-fA-F]{32})')
  96
  97     def post(self, request):
  98
  99         try:
 100             podcasts = self._get_podcasts(request)
 101
 102         except InvalidPodcast as ip:
 103             messages.error(request,
 104                     _('No podcast with URL {url}').format(url=str(ip)))
 105
 106         grouper = PodcastGrouper(podcasts)
 107
 108         features = {}
 109         for key, feature in request.POST.items():
 110             m = self.RE_EPISODE.match(key)
 111             if m:
 112                 episode_id = m.group(1)
 113                 features[episode_id] = feature
 114
 115         get_features = lambda (e_id, e): (features[e_id], e_id)
 116
 117         num_groups = grouper.group(get_features)
 118
 119         if 'renew' in request.POST:
 120             return render(request, 'admin/merge-grouping.html', {
 121                     'podcasts': podcasts,
 122                     'groups': num_groups,
 123                 })
 124
 125
 126         elif 'merge' in request.POST:
 127
 128             actions = Counter()
 129
 130             try:
 131                 # merge podcast, reassign episodes
 132                 pm = PodcastMerger(podcasts, actions, num_groups)
 133                 pm.merge()
 134
 135             except IncorrectMergeException as ime:
 136                 messages.error(request, str(ime))
 137                 return HttpResponseRedirect(reverse('admin-merge'))
 138
 139             return render(request, 'admin/merge-finished.html', {
 140                     'actions': actions.items(),
 141                     'podcast': podcasts[0],
 142                 })
 143
 144
 145
 146 class UserAgentStatsView(AdminView):
 147     template_name = 'admin/useragents.html'
 148
 149     def get(self, request):
 150
 151         uas = UserAgentStats()
 152         useragents = uas.get_entries()
 153
 154         return self.render_to_response({
 155                 'useragents': useragents.most_common(),
 156                 'max_users': uas.max_users,
 157                 'total': uas.total_users,
 158             })
 159
 160
 161 class ClientStatsView(AdminView):
 162     template_name = 'admin/clients.html'
 163
 164     def get(self, request):
 165
 166         cs = ClientStats()
 167         clients = cs.get_entries()
 168
 169         return self.render_to_response({
 170                 'clients': clients.most_common(),
 171                 'max_users': cs.max_users,
 172                 'total': cs.total_users,
 173             })
 174
 175
 176 class ClientStatsJsonView(AdminView):
 177     def get(self, request):
 178
 179         cs = ClientStats()
 180         clients = cs.get_entries()
 181
 182         return JsonResponse(map(self.to_dict, clients.most_common()))
 183
 184     def to_dict(self, res):
 185         obj, count = res
 186
 187         if not isinstance(obj, tuple):
 188             return obj, count
 189
 190         return obj._asdict(), count
 191
 192
 193 class StatsView(AdminView):
 194     """ shows general stats as HTML page """
 195
 196     template_name = 'admin/stats.html'
 197
 198     def _get_stats(self):
 199         return {
 200             'podcasts': podcast_count(),
 201             'episodes': episode_count(),
 202             'users': User.count(),
 203         }
 204
 205     def get(self, request):
 206         stats = self._get_stats()
 207         return self.render_to_response({
 208             'stats': stats,
 209         })
 210
 211
 212 class StatsJsonView(StatsView):
 213     """ provides general stats as JSON """
 214
 215     def get(self, request):
 216         stats = self._get_stats()
 217         return JsonResponse(stats)