src/archive/models.py

   1 import io
   2 import json
   3 from os import unlink
   4 import os.path
   5 from urllib.parse import urljoin
   6
   7 from django.db import models
   8 from time import sleep
   9 from django.contrib.sites.models import Site
  10 from django.utils.functional import cached_property
  11 from django.utils.timezone import now
  12 from django.utils.translation import gettext_lazy as _
  13 from django_pglocks import advisory_lock
  14 import requests
  15 from archive.constants import status
  16 from archive.settings import FILES_SAVE_PATH, ADVERT, ORGANIZATION, PROJECT
  17 from archive.utils import OverwriteStorage, sha1_file
  18 from youtube.utils import concat_audio, standardize_audio
  19
  20
  21 class License(models.Model):
  22     uri = models.CharField(max_length=255, unique=True)
  23     name = models.CharField(max_length=255)
  24
  25     def __str__(self):
  26         return self.name
  27
  28
  29 class Project(models.Model):
  30     """ an audiobook project, needed for specyfing sponsors """
  31
  32     name = models.CharField(max_length=128, unique=True, db_index=True, verbose_name="Nazwa")
  33     sponsors = models.TextField(blank=True, null=True, verbose_name="Sponsorzy")
  34     description = models.TextField(blank=True, verbose_name="Opis")
  35     private_notes = models.TextField(blank=True, verbose_name="Prywatne notatki")
  36     config = models.ForeignKey('Config', models.PROTECT)
  37     can_sell = models.BooleanField(default=True, verbose_name="Do sprzedaży")
  38     required_license = models.ForeignKey('License', models.PROTECT, blank=True, null=True, verbose_name='Wymagana licencja')
  39     youtube = models.ForeignKey('youtube.YouTube', models.PROTECT)
  40     icon = models.FileField(upload_to='archive/project', blank=True, null=True)
  41     info_flac = models.FileField(upload_to='archive/info_flac', blank=True)
  42
  43     class Meta:
  44         verbose_name = _("project")
  45         verbose_name_plural = _("projects")
  46         ordering = ("name",)
  47
  48     def __str__(self):
  49         return self.name
  50
  51     def get_description(self):
  52         if self.description:
  53             return self.description
  54         return "Audiobook nagrany w ramach projektu %s%s." % (
  55             self.name,
  56             " finansowanego przez %s" % self.sponsors if self.sponsors else "",
  57         )
  58
  59     def get_icon_url(self):
  60         if not self.icon:
  61             return ''
  62         return urljoin(
  63             'https://' + Site.objects.get_current().domain,
  64             self.icon.url
  65         )
  66
  67
  68 class Config(models.Model):
  69     name = models.CharField(max_length=255)
  70     intro_flac = models.FileField(upload_to='config/intro_flac', blank=True)
  71     intro_min_seconds = models.IntegerField()
  72     outro_flac = models.FileField(upload_to='config/outro_flac', blank=True)
  73     outro_min_seconds = models.IntegerField()
  74
  75     class Meta:
  76         verbose_name = _("Configuration")
  77         verbose_name_plural = _("Configurations")
  78
  79     def __str__(self):
  80         return self.name
  81
  82     def prepare_audio(self, audiobook):
  83         total_duration = audiobook.total_duration
  84         files = []
  85         if self.intro_flac and total_duration > self.intro_min_seconds and audiobook.is_first:
  86             files.append(standardize_audio(self.intro_flac.path))
  87         files.append(standardize_audio(audiobook.source_file.path))
  88         if self.outro_flac and total_duration > self.outro_min_seconds and audiobook.is_last:
  89             files.append(standardize_audio(self.outro_flac.path))
  90         output = concat_audio(files)
  91         for d in files:
  92             unlink(d)
  93         return output
  94
  95
  96 def source_upload_to(intance, filename):
  97     return os.path.join(FILES_SAVE_PATH, filename) # FIXME: what about really long file names?
  98
  99
 100 class Audiobook(models.Model):
 101     source_file = models.FileField(upload_to=source_upload_to, max_length=255,
 102             verbose_name=_('source file'), editable=False)
 103     source_sha1 = models.CharField(max_length=40, editable=False)
 104     duration = models.FloatField(null=True, editable=False)
 105
 106     title = models.CharField(max_length=255, verbose_name=_('title'))
 107     part_name = models.CharField(max_length=255, verbose_name=_('part name'), help_text=_('eg. chapter in a novel'),
 108                                  default='', blank=True)
 109     index = models.IntegerField(verbose_name=_('index'), default=0, help_text=_('Ordering of parts of a book.'))
 110     youtube_volume = models.CharField(
 111         _("Volume name for YouTube"),
 112         max_length=100,
 113         blank=True,
 114         help_text=_(
 115             "If set, audiobooks with the save value will be published as single YouTube video."
 116         ),
 117     )
 118     artist = models.CharField(max_length=255, verbose_name=_('artist'))
 119     conductor = models.CharField(max_length=255, verbose_name=_('conductor'))
 120     encoded_by = models.CharField(max_length=255, verbose_name=_('encoded by'))
 121     date = models.CharField(max_length=255, verbose_name=_('date'))
 122     project = models.ForeignKey(Project, models.PROTECT, verbose_name=_('project'))
 123     slug = models.SlugField(max_length=120, blank=True, help_text=_('WL catalogue slug of the book.'))
 124     translator = models.CharField(max_length=255, null=True, blank=True, verbose_name=_('translator'))
 125     modified = models.DateTimeField(null=True, editable=False)
 126     license = models.ForeignKey(License, models.PROTECT, null=True, blank=True, verbose_name=_('license'))
 127     license_secondary = models.ForeignKey(License, models.PROTECT, null=True, blank=True, verbose_name=_('license'), related_name='secondary')
 128
 129     # publishing process
 130     mp3_status = models.SmallIntegerField(null=True, editable=False, choices=status.choices)
 131     mp3_file = models.FileField(null=True, upload_to='archive/final', storage=OverwriteStorage(), editable=False)
 132     mp3_published = models.DateTimeField(null=True, editable=False)
 133
 134     ogg_status = models.SmallIntegerField(null=True, editable=False, choices=status.choices)
 135     ogg_file = models.FileField(null=True, upload_to='archive/final', storage=OverwriteStorage(), editable=False)
 136     ogg_published = models.DateTimeField(null=True, editable=False)
 137
 138     youtube_status = models.SmallIntegerField(null=True, editable=False, choices=status.choices)
 139     youtube_published = models.DateTimeField(null=True, editable=False)
 140     youtube_id = models.CharField(max_length=255, blank=True, default='')
 141     youtube_queued = models.DateTimeField(null=True, blank=True)
 142
 143     class Meta:
 144         verbose_name = _("audiobook")
 145         verbose_name_plural = _("audiobooks")
 146         ordering = ("title",)
 147
 148     def __str__(self):
 149         return self.title
 150
 151     @property
 152     def url(self):
 153         return f'https://wolnelektury.pl/katalog/lektura/{self.slug}/'
 154
 155     @property
 156     def parts_count(self):
 157         return type(self).objects.filter(slug=self.slug).count()
 158
 159     @property
 160     def total_duration(self):
 161         return type(self).objects.filter(slug=self.slug).aggregate(s=models.Sum('duration'))['s']
 162
 163     @property
 164     def is_first(self):
 165         return not type(self).objects.filter(slug=self.slug, index__lte=self.index).exclude(pk=self.pk).exists()
 166
 167     @property
 168     def is_last(self):
 169         return not type(self).objects.filter(slug=self.slug, index__gte=self.index).exclude(pk=self.pk).exists()
 170
 171     @property
 172     def youtube_volume_count(self):
 173         total = 0
 174         prev_volume = None
 175         for a in type(self).objects.filter(slug=self.slug).order_by("index"):
 176             if not a.youtube_volume or a.youtube_volume != prev_volume:
 177                 total += 1
 178             prev_volume = a.youtube_volume
 179         return total
 180
 181     @property
 182     def youtube_volume_index(self):
 183         index = 0
 184         prev_volume = None
 185         for a in type(self).objects.filter(slug=self.slug, index__lte=self.index).order_by("index"):
 186             if not a.youtube_volume or a.youtube_volume != prev_volume:
 187                 index += 1
 188             prev_volume = a.youtube_volume
 189         return index
 190
 191     @property
 192     def is_youtube_publishable(self):
 193         return (
 194             not self.youtube_volume
 195             or not type(self)
 196             .objects.filter(slug=self.slug, youtube_volume=self.youtube_volume, index__lt=self.index)
 197             .exists()
 198         )
 199
 200     def youtube_publish(self):
 201         if not self.is_youtube_publishable:
 202             return False
 203         self.youtube_status = status.QUEUED
 204         self.youtube_queued = now()
 205         self.save(update_fields=['youtube_status', 'youtube_queued'])
 206
 207     def published(self):
 208         return self.mp3_published and self.ogg_published
 209
 210     def publish(self, user, publish=True):
 211         from . import tasks
 212         self.mp3_status = self.ogg_status = status.WAITING
 213         self.save(update_fields=['mp3_status', 'ogg_status'])
 214         tasks.Mp3Task.delay(user.id, self.pk, publish=publish).task_id
 215         tasks.OggTask.delay(user.id, self.pk, publish=publish).task_id
 216
 217     def get_source_sha1(self):
 218         assert self.pk or self.source_sha1
 219         if not self.source_sha1:
 220             with advisory_lock(f'get_source_sha1_{self.pk}'):
 221                 with open(self.source_file.path, 'rb') as f:
 222                     self.source_sha1 = sha1_file(f)
 223                 self.save(update_fields=['source_sha1'])
 224         return self.source_sha1
 225
 226     def new_publish_tags(self):
 227         title = self.title
 228         if self.translator:
 229             title += ' (tłum. %s)' % self.translator
 230
 231         copyright = "%s %s." % (
 232                 self.date, ORGANIZATION)
 233         if self.license:
 234             copyright += " Licensed to the public under %s verify at %s" % (
 235                 self.license.uri, self.url)
 236
 237         comment = "\n".join((
 238             self.project.get_description(),
 239             ADVERT
 240         ))
 241
 242         tags = {
 243             'album': PROJECT,
 244             'albumartist': ORGANIZATION,
 245             'artist': self.artist,
 246             'comment': comment,
 247             'conductor': self.conductor,
 248             'contact': self.url,
 249             'copyright': copyright,
 250             'date': self.date,
 251             'genre': 'Speech',
 252             'language': 'pol',
 253             'organization': ORGANIZATION,
 254             'title': title,
 255             'project': self.project.name,
 256         }
 257         if self.license:
 258             tags['license'] = self.license.uri
 259         if self.project.sponsors:
 260             tags['funded_by'] = self.project.sponsors
 261
 262         tags['flac_sha1'] = self.get_source_sha1()
 263
 264         return tags
 265
 266     def prepare_audio(self):
 267         return self.project.config.prepare_audio(self)
 268
 269     @cached_property
 270     def book(self):
 271         if self.slug:
 272             apidata = requests.get(f'https://wolnelektury.pl/api/books/{self.slug}/').json()
 273         else:
 274             return {}
 275         return apidata
 276
 277     @property
 278     def document(self):
 279         from librarian.document import WLDocument, parser
 280         from lxml import etree
 281
 282         xml_url = self.book.get('xml', None)
 283         if xml_url is None:
 284             return None
 285
 286         return WLDocument(url=xml_url)
 287
 288     @property
 289     def cover(self):
 290         from librarian.cover import LogoWLCover
 291         return LogoWLCover(self.document.meta).output_file.get_bytes()