mygpo/administration/views.py

   1 import re
   2 import socket
   3 from itertools import count, chain
   4 from collections import Counter
   5 from datetime import datetime
   6
   7 import django
   8 from django.shortcuts import render
   9 from django.contrib import messages
  10 from django.core.urlresolvers import reverse
  11 from django.core.cache import cache
  12 from django.http import HttpResponseRedirect
  13 from django.template.loader import render_to_string
  14 from django.template import RequestContext
  15 from django.utils.translation import ugettext as _
  16 from django.contrib.sites.models import RequestSite
  17 from django.views.generic import TemplateView
  18 from django.utils.decorators import method_decorator
  19 from django.conf import settings
  20
  21 from mygpo.podcasts.models import Podcast, Episode
  22 from mygpo.administration.auth import require_staff
  23 from mygpo.administration.group import PodcastGrouper
  24 from mygpo.maintenance.merge import PodcastMerger, IncorrectMergeException
  25 from mygpo.users.models import User
  26 from mygpo.administration.clients import UserAgentStats, ClientStats
  27 from mygpo.administration.tasks import merge_podcasts
  28 from mygpo.utils import get_git_head
  29 from mygpo.api.httpresponse import JsonResponse
  30 from mygpo.celery import celery
  31 from mygpo.db.couchdb import get_userdata_database
  32 from mygpo.db.couchdb.user import activate_user, add_published_objs
  33
  34
  35 class InvalidPodcast(Exception):
  36     """ raised when we try to merge a podcast that doesn't exist """
  37
  38 class AdminView(TemplateView):
  39
  40     @method_decorator(require_staff)
  41     def dispatch(self, *args, **kwargs):
  42         return super(AdminView, self).dispatch(*args, **kwargs)
  43
  44
  45 class Overview(AdminView):
  46     template_name = 'admin/overview.html'
  47
  48
  49 class HostInfo(AdminView):
  50     """ shows host information for diagnosis """
  51
  52     template_name = 'admin/hostinfo.html'
  53
  54     def get(self, request):
  55         commit, msg = get_git_head()
  56         base_dir = settings.BASE_DIR
  57         hostname = socket.gethostname()
  58         django_version = django.VERSION
  59
  60         main_db = get_userdata_database()
  61
  62         db_tasks = main_db.server.active_tasks()
  63
  64         i = celery.control.inspect()
  65         scheduled = i.scheduled()
  66         if not scheduled:
  67             num_celery_tasks = None
  68         else:
  69             num_celery_tasks = sum(len(node) for node in scheduled.values())
  70
  71         feed_queue_status = self._get_feed_queue_status()
  72
  73         return self.render_to_response({
  74             'git_commit': commit,
  75             'git_msg': msg,
  76             'base_dir': base_dir,
  77             'hostname': hostname,
  78             'django_version': django_version,
  79             'main_db': main_db.uri,
  80             'db_tasks': db_tasks,
  81             'num_celery_tasks': num_celery_tasks,
  82             'feed_queue_status': feed_queue_status,
  83         })
  84
  85     def _get_feed_queue_status(self):
  86         now = datetime.utcnow()
  87         next_podcast = Podcast.objects.order_by_next_update().first()
  88
  89         delta = (next_podcast.next_update - now)
  90         delta_mins = delta.total_seconds() / 60
  91         return delta_mins
  92
  93
  94 class MergeSelect(AdminView):
  95     template_name = 'admin/merge-select.html'
  96
  97     def get(self, request):
  98         num = int(request.GET.get('podcasts', 2))
  99         urls = [''] * num
 100
 101         return self.render_to_response({
 102                 'urls': urls,
 103             })
 104
 105
 106 class MergeBase(AdminView):
 107
 108     def _get_podcasts(self, request):
 109         podcasts = []
 110         for n in count():
 111             podcast_url = request.POST.get('feed%d' % n, None)
 112             if podcast_url is None:
 113                 break
 114
 115             if not podcast_url:
 116                 continue
 117
 118             p = Podcast.objects.get(urls__url=podcast_url)
 119             podcasts.append(p)
 120
 121         return podcasts
 122
 123
 124 class MergeVerify(MergeBase):
 125
 126     template_name = 'admin/merge-grouping.html'
 127
 128     def post(self, request):
 129
 130         try:
 131             podcasts = self._get_podcasts(request)
 132
 133             grouper = PodcastGrouper(podcasts)
 134
 135             get_features = lambda (e_id, e): ((e.url, e.title), e_id)
 136
 137             num_groups = grouper.group(get_features)
 138
 139
 140         except InvalidPodcast as ip:
 141             messages.error(request,
 142                     _('No podcast with URL {url}').format(url=str(ip)))
 143
 144             podcasts = []
 145             num_groups = []
 146
 147         return self.render_to_response({
 148                 'podcasts': podcasts,
 149                 'groups': num_groups,
 150             })
 151
 152
 153 class MergeProcess(MergeBase):
 154
 155     RE_EPISODE = re.compile(r'episode_([0-9a-fA-F]{32})')
 156
 157     def post(self, request):
 158
 159         try:
 160             podcasts = self._get_podcasts(request)
 161
 162         except InvalidPodcast as ip:
 163             messages.error(request,
 164                     _('No podcast with URL {url}').format(url=str(ip)))
 165
 166         grouper = PodcastGrouper(podcasts)
 167
 168         features = {}
 169         for key, feature in request.POST.items():
 170             m = self.RE_EPISODE.match(key)
 171             if m:
 172                 episode_id = m.group(1)
 173                 features[episode_id] = feature
 174
 175         get_features = lambda (e_id, e): (features.get(e_id, e_id), e_id)
 176
 177         num_groups = grouper.group(get_features)
 178
 179         if 'renew' in request.POST:
 180             return render(request, 'admin/merge-grouping.html', {
 181                     'podcasts': podcasts,
 182                     'groups': num_groups,
 183                 })
 184
 185
 186         elif 'merge' in request.POST:
 187
 188             podcast_ids = [p.get_id() for p in podcasts]
 189             num_groups = list(num_groups)
 190
 191             res = merge_podcasts.delay(podcast_ids, num_groups)
 192
 193             return HttpResponseRedirect(reverse('admin-merge-status',
 194                         args=[res.task_id]))
 195
 196
 197 class MergeStatus(AdminView):
 198     """ Displays the status of the merge operation """
 199
 200     template_name = 'admin/task-status.html'
 201
 202     def get(self, request, task_id):
 203         result = merge_podcasts.AsyncResult(task_id)
 204
 205         if not result.ready():
 206             return self.render_to_response({
 207                 'ready': False,
 208             })
 209
 210         # clear cache to make merge result visible
 211         # TODO: what to do with multiple frontends?
 212         cache.clear()
 213
 214         try:
 215             actions, podcast = result.get()
 216
 217         except IncorrectMergeException as ime:
 218             messages.error(request, str(ime))
 219             return HttpResponseRedirect(reverse('admin-merge'))
 220
 221         return self.render_to_response({
 222                 'ready': True,
 223                 'actions': actions.items(),
 224                 'podcast': podcast,
 225             })
 226
 227
 228
 229 class UserAgentStatsView(AdminView):
 230     template_name = 'admin/useragents.html'
 231
 232     def get(self, request):
 233
 234         uas = UserAgentStats()
 235         useragents = uas.get_entries()
 236
 237         return self.render_to_response({
 238                 'useragents': useragents.most_common(),
 239                 'max_users': uas.max_users,
 240                 'total': uas.total_users,
 241             })
 242
 243
 244 class ClientStatsView(AdminView):
 245     template_name = 'admin/clients.html'
 246
 247     def get(self, request):
 248
 249         cs = ClientStats()
 250         clients = cs.get_entries()
 251
 252         return self.render_to_response({
 253                 'clients': clients.most_common(),
 254                 'max_users': cs.max_users,
 255                 'total': cs.total_users,
 256             })
 257
 258
 259 class ClientStatsJsonView(AdminView):
 260     def get(self, request):
 261
 262         cs = ClientStats()
 263         clients = cs.get_entries()
 264
 265         return JsonResponse(map(self.to_dict, clients.most_common()))
 266
 267     def to_dict(self, res):
 268         obj, count = res
 269
 270         if not isinstance(obj, tuple):
 271             return obj, count
 272
 273         return obj._asdict(), count
 274
 275
 276 class StatsView(AdminView):
 277     """ shows general stats as HTML page """
 278
 279     template_name = 'admin/stats.html'
 280
 281     def _get_stats(self):
 282         return {
 283             'podcasts': Podcast.objects.count_fast(),
 284             'episodes': Episode.objects.count_fast(),
 285             'users': User.count(),
 286         }
 287
 288     def get(self, request):
 289         stats = self._get_stats()
 290         return self.render_to_response({
 291             'stats': stats,
 292         })
 293
 294
 295 class StatsJsonView(StatsView):
 296     """ provides general stats as JSON """
 297
 298     def get(self, request):
 299         stats = self._get_stats()
 300         return JsonResponse(stats)
 301
 302
 303 class ActivateUserView(AdminView):
 304     """ Lets admins manually activate users """
 305
 306     template_name = 'admin/activate-user.html'
 307
 308     def get(self, request):
 309         return self.render_to_response({})
 310
 311     def post(self, request):
 312
 313         username = request.POST.get('username')
 314         email = request.POST.get('email')
 315
 316         if not (username or email):
 317             messages.error(request,
 318                            _('Provide either username or email address'))
 319             return HttpResponseRedirect(reverse('admin-activate-user'))
 320
 321         user = None
 322
 323         if username:
 324             user = User.get_user(username, is_active=None)
 325
 326         if email and not user:
 327             user = User.get_user_by_email(email, is_active=None)
 328
 329         if not user:
 330             messages.error(request, _('No user found'))
 331             return HttpResponseRedirect(reverse('admin-activate-user'))
 332
 333         activate_user(user)
 334         messages.success(request,
 335                          _('User {username} ({email}) activated'.format(
 336                             username=user.username, email=user.email)))
 337         return HttpResponseRedirect(reverse('admin-activate-user'))
 338
 339
 340
 341 class MakePublisherInput(AdminView):
 342     """ Get all information necessary for making someone publisher """
 343
 344     template_name = 'admin/make-publisher-input.html'
 345
 346
 347 class MakePublisher(AdminView):
 348     """ Assign publisher permissions """
 349
 350     template_name = 'admin/make-publisher-result.html'
 351
 352     def post(self, request):
 353         username = request.POST.get('username')
 354         user = User.get_user(username)
 355         if user is None:
 356             messages.error(request, 'User "{username}" not found'.format(username=username))
 357             return HttpResponseRedirect(reverse('admin-make-publisher-input'))
 358
 359         feeds = request.POST.get('feeds')
 360         feeds = feeds.split()
 361         podcasts = set()
 362
 363         for feed in feeds:
 364             try:
 365                 podcast = Podcast.objects.get(urls__url=feed)
 366             except Podcast.DoesNotExist:
 367                 messages.warning(request, 'Podcast with URL {feed} not found'.format(feed=feed))
 368                 continue
 369
 370             podcasts.add(podcast)
 371
 372         self.set_publisher(request, user, podcasts)
 373         self.send_mail(request, user, podcasts)
 374         return HttpResponseRedirect(reverse('admin-make-publisher-result'))
 375
 376     def set_publisher(self, request, user, podcasts):
 377         podcast_ids = set(p.get_id() for p in podcasts)
 378         add_published_objs(user, podcast_ids)
 379         messages.success(request, 'Set publisher permissions for {count} podcasts'.format(count=len(podcast_ids)))
 380
 381     def send_mail(self, request, user, podcasts):
 382         site = RequestSite(request)
 383         msg = render_to_string('admin/make-publisher-mail.txt', {
 384                 'user': user,
 385                 'podcasts': podcasts,
 386                 'support_url': settings.SUPPORT_URL,
 387                 'site': site,
 388             },
 389             context_instance=RequestContext(request))
 390         subj = get_email_subject(site, _('Publisher Permissions'))
 391
 392         user.email_user(subj, msg)
 393         messages.success(request, 'Sent email to user "{username}"'.format(username=user.username))
 394
 395
 396 class MakePublisherResult(AdminView):
 397     template_name = 'make-publisher-result.html'
 398
 399
 400 def get_email_subject(site, txt):
 401     return '[{domain}] {txt}'.format(domain=site.domain, txt=txt)