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