src/archive/views.py

   1 from datetime import datetime
   2 import os
   3 import os.path
   4 from urllib.parse import quote
   5
   6 from archive import settings
   7 from django.contrib.auth.decorators import permission_required
   8 from django.contrib.postgres.search import SearchVector
   9 from django.urls import reverse
  10 from django.db.models import Q, Max
  11 from django.http import Http404, HttpResponse
  12 from django.shortcuts import render, redirect, get_object_or_404
  13 from django.utils.translation import gettext as _
  14 from django.views.decorators.http import require_POST
  15 from django.views.generic import ListView
  16
  17 import mutagen
  18
  19 from archive.constants import status
  20 from archive import models
  21 from archive.forms import AudiobookForm
  22 from archive import tasks
  23 from archive.utils import all_files
  24
  25
  26 def list_new(request):
  27     path = settings.NEW_PATH
  28     objects = sorted(all_files(path))
  29     return render(request, "archive/list_new.html", locals())
  30
  31
  32 @permission_required('archive.change_audiobook')
  33 def file_new(request, filename):
  34     filepath = filename
  35     root_filepath = os.path.join(settings.NEW_PATH, filename)
  36     if request.POST:
  37         form = AudiobookForm(request.POST)
  38         if form.is_valid():
  39             try:
  40                 form.save(path=filepath)
  41             except IOError:
  42                 raise Http404
  43             return redirect(list_new)
  44
  45     try:
  46         tags = mutagen.File(root_filepath)
  47     except IOError:
  48         raise Http404
  49     d = {}
  50     if tags:
  51         for tag in tags:
  52             value = tags[tag]
  53             if isinstance(value, list):
  54                 d[tag] = value[0]
  55             else:
  56                 d[tag] = value
  57             if tag == 'project':
  58                 try:
  59                     d[tag] = models.Project.objects.get(name=d[tag]).pk
  60                 except models.Project.DoesNotExist:
  61                     d[tag] = None
  62
  63     if not request.POST:
  64         form = AudiobookForm(initial=d)
  65     return render(request, "archive/file_new.html", locals())
  66
  67
  68 @require_POST
  69 @permission_required('archive.change_audiobook')
  70 def move_to_archive(request, filename):
  71     """ move a new file to the unmanaged files dir """
  72
  73     filename_str = filename.encode('utf-8')
  74     old_path = os.path.join(settings.NEW_PATH, filename_str)
  75     new_path = os.path.join(settings.UNMANAGED_PATH, filename_str)
  76     new_dir = os.path.split(new_path)[0]
  77     if not os.path.isdir(new_dir):
  78         os.makedirs(new_dir)
  79
  80     if not os.path.isfile(old_path):
  81         raise Http404
  82
  83     try:
  84         os.link(old_path, new_path)
  85         os.unlink(old_path)
  86     except OSError:
  87         # destination file exists, don't overwrite it
  88         # TODO: this should probably be more informative
  89         return redirect(file_new, filename)
  90
  91     return redirect(list_new)
  92
  93
  94 @require_POST
  95 @permission_required('archive.change_audiobook')
  96 def remove_to_archive(request, aid):
  97     """ move a managed file to the unmanaged files dir """
  98
  99     audiobook = get_object_or_404(models.Audiobook, id=aid)
 100     old_path = audiobook.source_file.path
 101     new_path = os.path.join(settings.UNMANAGED_PATH,
 102         str(audiobook.source_file)[len(settings.FILES_SAVE_PATH):].lstrip('/'))
 103     new_dir = os.path.split(new_path)[0]
 104     if not os.path.isdir(new_dir):
 105         os.makedirs(new_dir)
 106
 107     if not os.path.isfile(old_path):
 108         raise Http404
 109
 110     success = False
 111     try_new_path = new_path
 112     try_number = 0
 113     while not success:
 114         try:
 115             os.link(old_path, try_new_path)
 116         except OSError:
 117             # destination file exists, don't overwrite it
 118             try_number += 1
 119             parts = new_path.rsplit('.', 1)
 120             parts[0] += '_%d' % try_number
 121             try_new_path = ".".join(parts)
 122         else:
 123             os.unlink(old_path)
 124             audiobook.delete()
 125             success = True
 126
 127     return redirect(list_unmanaged)
 128
 129 @require_POST
 130 @permission_required('archive.change_audiobook')
 131 def move_to_new(request, filename):
 132     """ move a unmanaged file to new files dir """
 133
 134     filename_str = filename.encode('utf-8')
 135     old_path = os.path.join(settings.UNMANAGED_PATH, filename_str)
 136     new_path = os.path.join(settings.NEW_PATH, filename_str)
 137     new_dir = os.path.split(new_path)[0]
 138     if not os.path.isdir(new_dir):
 139         os.makedirs(new_dir)
 140
 141     if not os.path.isfile(old_path):
 142         raise Http404
 143
 144     try:
 145         os.link(old_path, new_path)
 146         os.unlink(old_path)
 147     except OSError:
 148         # destination file exists, don't overwrite it
 149         # TODO: this should probably be more informative
 150         return redirect(reverse(file_unmanaged, args=[filename]) + "?exists=1")
 151
 152     return redirect(list_unmanaged)
 153
 154
 155 @require_POST
 156 @permission_required('archive.change_audiobook')
 157 def publish(request, aid, publish=True):
 158     """ mark file for publishing """
 159     audiobook = get_object_or_404(models.Audiobook, id=aid)
 160     tags = {
 161         'name': audiobook.title,
 162         'url': audiobook.url,
 163         'tags': audiobook.new_publish_tags(),
 164         }
 165     audiobook.set_mp3_tags(tags)
 166     audiobook.set_ogg_tags(tags)
 167     audiobook.mp3_status = audiobook.ogg_status = status.WAITING
 168     audiobook.save()
 169     # isn't there a race here?
 170     audiobook.mp3_task = tasks.Mp3Task.delay(request.user.id, aid, publish).task_id
 171     audiobook.ogg_task = tasks.OggTask.delay(request.user.id, aid, publish).task_id
 172     audiobook.save()
 173
 174     return redirect(file_managed, aid)
 175
 176
 177 @require_POST
 178 @permission_required('archive.change_audiobook')
 179 def cancel_publishing(request, aid):
 180     """ cancel scheduled publishing """
 181     audiobook = get_object_or_404(models.Audiobook, id=aid)
 182     # TODO: cancel tasks
 183     audiobook.mp3_status = None
 184     audiobook.ogg_status = None
 185     audiobook.youtube_status = None
 186     audiobook.youtube_queued = None
 187     audiobook.save()
 188     return redirect(file_managed, aid)
 189
 190
 191 def download(request, aid, which="source"):
 192     if which not in ("source", "mp3", "ogg", 'mkv'):
 193         raise Http404
 194     audiobook = get_object_or_404(models.Audiobook, id=aid)
 195     field = which
 196     if which == 'mkv':
 197         field = 'youtube'
 198     file_ = getattr(audiobook, "%s_file" % field)
 199     if not file_:
 200         raise Http404
 201     ext = file_.path.rsplit('.', 1)[-1]
 202     response = HttpResponse(content_type='application/force-download')
 203
 204     response['Content-Disposition'] = "attachment; filename*=UTF-8''%s.%s" % (
 205         quote(audiobook.title.encode('utf-8'), safe=''), ext)
 206     with open(file_.path, 'rb') as f:
 207         response.write(f.read())
 208     #response['X-Sendfile'] = file_.path.encode('utf-8')
 209     return response
 210
 211
 212 def list_publishing(request):
 213     objects = models.Audiobook.objects.exclude(
 214         mp3_status=None, ogg_status=None, youtube_status=None
 215     ).order_by("youtube_queued", "title")
 216     objects_by_status = {}
 217     for o in objects:
 218         statuses = set()
 219         if o.mp3_status:
 220             statuses.add((o.mp3_status, o.get_mp3_status_display()))
 221         if o.ogg_status:
 222             statuses.add((o.ogg_status, o.get_ogg_status_display()))
 223         if o.youtube_status:
 224             statuses.add((o.youtube_status, o.get_youtube_status_display()))
 225         for status in statuses:
 226             objects_by_status.setdefault(status, []).append(o)
 227     status_objects = sorted(objects_by_status.items(), reverse=True)
 228
 229     return render(request, "archive/list_publishing.html", locals())
 230
 231
 232 class AudiobookList(ListView):
 233     def get_queryset(self):
 234         qs = models.Audiobook.objects.all()
 235         if 's' in self.request.GET:
 236             qs = qs.annotate(s=SearchVector('title', 'slug')).filter(s=self.request.GET['s'])
 237         return qs
 238
 239
 240 @permission_required('archive.change_audiobook')
 241 def file_managed(request, id):
 242     audiobook = get_object_or_404(models.Audiobook, id=id)
 243
 244     if request.POST:
 245         form = AudiobookForm(request.POST, instance=audiobook)
 246         if form.is_valid():
 247             try:
 248                 form.save()
 249             except IOError:
 250                 raise Http404
 251
 252     tags = {}
 253     if audiobook.source_file:
 254         path = audiobook.source_file.path[len(settings.FILES_PATH):].lstrip('/')
 255
 256         # for tags update
 257         tags = mutagen.File(audiobook.source_file.path.encode('utf-8'))
 258         if not tags:
 259             tags = {}
 260     form = AudiobookForm(instance=audiobook)
 261
 262     user_can_publish = (
 263         request.user.is_authenticated and
 264         request.user.oauthconnection_set.filter(access=True).exists())
 265
 266     alerts = []
 267     parts_count = audiobook.parts_count
 268     if parts_count > 1:
 269         series = models.Audiobook.objects.filter(slug=audiobook.slug)
 270         if not audiobook.index:
 271             alerts.append(_('There is more than one part, but index is not set.'))
 272         if set(series.values_list('index', flat=True)) != set(range(1, parts_count + 1)):
 273             alerts.append(_('Part indexes are not 1..%(parts_count)d.') % {"parts_count": parts_count})
 274
 275     from youtube.models import YouTube
 276     youtube = YouTube.objects.first()
 277     youtube_title = youtube.get_title(audiobook)
 278     youtube_description = youtube.get_description(audiobook)
 279
 280
 281     return render(request, "archive/file_managed.html", locals())
 282
 283
 284 def list_unmanaged(request):
 285     objects = sorted(all_files(settings.UNMANAGED_PATH))
 286     return render(request, "archive/list_unmanaged.html", locals())
 287
 288
 289 def file_unmanaged(request, filename):
 290     tags = mutagen.File(os.path.join(settings.UNMANAGED_PATH, filename.encode('utf-8')))
 291     if not tags:
 292         tags = {}
 293
 294     err_exists = request.GET.get('exists')
 295     return render(request, "archive/file_unmanaged.html", locals())
 296
 297
 298 class BookView(ListView):
 299     template_name = 'archive/book.html'
 300
 301     def get_queryset(self):
 302         qs = models.Audiobook.objects.filter(slug=self.kwargs["slug"]).order_by(
 303             "index"
 304         )
 305         last_vol = None
 306         for b in qs:
 307             if last_vol is None or last_vol.youtube_volume != b.youtube_volume:
 308                 last_vol = b
 309                 b.total = 0
 310             last_vol.total += b.duration
 311         return list(qs)
 312
 313
 314 @permission_required('archive.change_audiobook')
 315 def book_youtube_volume(request, aid):
 316     audiobook = get_object_or_404(models.Audiobook, id=aid)
 317     slug = audiobook.slug
 318     cur_vol = audiobook.youtube_volume
 319     new_vol = request.POST.get('volume', '')
 320
 321     audiobook.youtube_volume = new_vol
 322     audiobook.save()
 323
 324     for a in models.Audiobook.objects.filter(youtube_volume=cur_vol, index__gt=audiobook.index).order_by('index'):
 325         if a.youtube_volume != cur_vol:
 326             break
 327         a.youtube_volume = new_vol
 328         a.save()
 329
 330     return redirect('book', audiobook.slug)
 331