src/archive/models.py

   1 import io
   2 import json
   3 import os.path
   4
   5 from django.db import models
   6 from time import sleep
   7 from django.utils.functional import cached_property
   8 from django.utils.timezone import now
   9 from django.utils.translation import gettext_lazy as _
  10 from django_pglocks import advisory_lock
  11 import requests
  12 from archive.constants import status
  13 from archive.settings import FILES_SAVE_PATH, ADVERT, ORGANIZATION, PROJECT
  14 from archive.utils import OverwriteStorage, sha1_file
  15
  16
  17 class License(models.Model):
  18     uri = models.CharField(max_length=255, unique=True)
  19     name = models.CharField(max_length=255)
  20
  21     def __str__(self):
  22         return self.name
  23
  24
  25 class Project(models.Model):
  26     """ an audiobook project, needed for specyfing sponsors """
  27
  28     name = models.CharField(max_length=128, unique=True, db_index=True, verbose_name="Nazwa")
  29     sponsors = models.TextField(blank=True, null=True, verbose_name="Sponsorzy")
  30     description = models.TextField(blank=True, verbose_name="Opis")
  31     youtube = models.ForeignKey('youtube.YouTube', models.PROTECT)
  32     icon = models.FileField(upload_to='archive/project', blank=True, null=True)
  33
  34     class Meta:
  35         verbose_name = _("project")
  36         verbose_name_plural = _("projects")
  37         ordering = ("name",)
  38
  39     def __str__(self):
  40         return self.name
  41
  42     def get_description(self):
  43         if self.description:
  44             return self.description
  45         return "Audiobook nagrany w ramach projektu %s%s." % (
  46             self.name,
  47             " finansowanego przez %s" % self.sponsors if self.sponsors else "",
  48         )
  49
  50
  51 def source_upload_to(intance, filename):
  52     return os.path.join(FILES_SAVE_PATH, filename) # FIXME: what about really long file names?
  53
  54
  55 class Audiobook(models.Model):
  56     source_file = models.FileField(upload_to=source_upload_to, max_length=255,
  57             verbose_name=_('source file'), editable=False)
  58     source_sha1 = models.CharField(max_length=40, editable=False)
  59     duration = models.FloatField(null=True, editable=False)
  60
  61     title = models.CharField(max_length=255, verbose_name=_('title'))
  62     part_name = models.CharField(max_length=255, verbose_name=_('part name'), help_text=_('eg. chapter in a novel'),
  63                                  default='', blank=True)
  64     index = models.IntegerField(verbose_name=_('index'), default=0, help_text=_('Ordering of parts of a book.'))
  65     youtube_volume = models.CharField(
  66         _("Volume name for YouTube"),
  67         max_length=100,
  68         blank=True,
  69         help_text=_(
  70             "If set, audiobooks with the save value will be published as single YouTube video."
  71         ),
  72     )
  73     artist = models.CharField(max_length=255, verbose_name=_('artist'))
  74     conductor = models.CharField(max_length=255, verbose_name=_('conductor'))
  75     encoded_by = models.CharField(max_length=255, verbose_name=_('encoded by'))
  76     date = models.CharField(max_length=255, verbose_name=_('date'))
  77     project = models.ForeignKey(Project, models.PROTECT, verbose_name=_('project'))
  78     slug = models.SlugField(max_length=120, blank=True, help_text=_('WL catalogue slug of the book.'))
  79     translator = models.CharField(max_length=255, null=True, blank=True, verbose_name=_('translator'))
  80     modified = models.DateTimeField(null=True, editable=False)
  81     license = models.ForeignKey(License, models.PROTECT, null=True, blank=True, verbose_name=_('license'))
  82
  83     # publishing process
  84     mp3_status = models.SmallIntegerField(null=True, editable=False, choices=status.choices)
  85     mp3_task = models.CharField(max_length=64, null=True, editable=False)
  86     mp3_tags = models.TextField(null=True, editable=False)
  87     mp3_file = models.FileField(null=True, upload_to='archive/final', storage=OverwriteStorage(), editable=False)
  88     mp3_published_tags = models.TextField(null=True, editable=False)
  89     mp3_published = models.DateTimeField(null=True, editable=False)
  90
  91     ogg_status = models.SmallIntegerField(null=True, editable=False, choices=status.choices)
  92     ogg_task = models.CharField(max_length=64, null=True, editable=False)
  93     ogg_tags = models.TextField(null=True, editable=False)
  94     ogg_file = models.FileField(null=True, upload_to='archive/final', storage=OverwriteStorage(), editable=False)
  95     ogg_published_tags = models.TextField(null=True, editable=False)
  96     ogg_published = models.DateTimeField(null=True, editable=False)
  97
  98     youtube_status = models.SmallIntegerField(null=True, editable=False, choices=status.choices)
  99     youtube_task = models.CharField(max_length=64, null=True, editable=False)
 100     youtube_tags = models.TextField(null=True, editable=False)
 101     youtube_published_tags = models.TextField(null=True, editable=False)
 102     youtube_published = models.DateTimeField(null=True, editable=False)
 103     youtube_id = models.CharField(max_length=255, blank=True, default='')
 104     youtube_queued = models.DateTimeField(null=True, blank=True)
 105
 106     class Meta:
 107         verbose_name = _("audiobook")
 108         verbose_name_plural = _("audiobooks")
 109         ordering = ("title",)
 110
 111     def __str__(self):
 112         return self.title
 113
 114     @property
 115     def url(self):
 116         return f'https://wolnelektury.pl/katalog/lektura/{self.slug}/'
 117
 118     @property
 119     def parts_count(self):
 120         return type(self).objects.filter(slug=self.slug).count()
 121
 122     @property
 123     def youtube_volume_count(self):
 124         total = 0
 125         prev_volume = None
 126         for a in type(self).objects.filter(slug=self.slug).order_by("index"):
 127             if not a.youtube_volume or a.youtube_volume != prev_volume:
 128                 total += 1
 129             prev_volume = a.youtube_volume
 130         return total
 131
 132     @property
 133     def youtube_volume_index(self):
 134         index = 0
 135         prev_volume = None
 136         for a in type(self).objects.filter(slug=self.slug, index__lte=self.index).order_by("index"):
 137             if not a.youtube_volume or a.youtube_volume != prev_volume:
 138                 index += 1
 139             prev_volume = a.youtube_volume
 140         return index
 141
 142     @property
 143     def is_youtube_publishable(self):
 144         return (
 145             not self.youtube_volume
 146             or not type(self)
 147             .objects.filter(youtube_volume=self.youtube_volume, index__lt=self.index)
 148             .exists()
 149         )
 150
 151     def youtube_publish(self):
 152         if not self.is_youtube_publishable:
 153             return False
 154         self.youtube_status = status.QUEUED
 155         self.youtube_queued = now()
 156         self.save(update_fields=['youtube_status', 'youtube_queued'])
 157
 158     def get_mp3_tags(self): return json.loads(self.mp3_tags) if self.mp3_tags else None
 159     def get_ogg_tags(self): return json.loads(self.ogg_tags) if self.ogg_tags else None
 160     def get_mp3_published_tags(self): return json.loads(self.mp3_published_tags) if self.mp3_published_tags else None
 161     def get_ogg_published_tags_tags(self): return json.loads(self.ogg_published_tags) if self.ogg_published_tags else None
 162     def set_mp3_tags(self, tags): self.mp3_tags = json.dumps(tags)
 163     def set_ogg_tags(self, tags): self.ogg_tags = json.dumps(tags)
 164
 165     def published(self):
 166         return self.mp3_published and self.ogg_published
 167
 168     def get_source_sha1(self):
 169         assert self.pk or self.source_sha1
 170         if not self.source_sha1:
 171             with advisory_lock(f'get_source_sha1_{self.pk}'):
 172                 with open(self.source_file.path, 'rb') as f:
 173                     self.source_sha1 = sha1_file(f)
 174                 self.save(update_fields=['source_sha1'])
 175         return self.source_sha1
 176
 177     def new_publish_tags(self):
 178         title = self.title
 179         if self.translator:
 180             title += ' (tłum. %s)' % self.translator
 181
 182         copyright = "%s %s." % (
 183                 self.date, ORGANIZATION)
 184         if self.license:
 185             copyright += " Licensed to the public under %s verify at %s" % (
 186                 self.license.uri, self.url)
 187
 188         comment = "\n".join((
 189             self.project.get_description(),
 190             ADVERT
 191         ))
 192
 193         tags = {
 194             'album': PROJECT,
 195             'albumartist': ORGANIZATION,
 196             'artist': self.artist,
 197             'comment': comment,
 198             'conductor': self.conductor,
 199             'contact': self.url,
 200             'copyright': copyright,
 201             'date': self.date,
 202             'genre': 'Speech',
 203             'language': 'pol',
 204             'organization': ORGANIZATION,
 205             'title': title,
 206             'project': self.project.name,
 207         }
 208         if self.license:
 209             tags['license'] = self.license.uri
 210         if self.project.sponsors:
 211             tags['funded_by'] = self.project.sponsors
 212
 213         if self.source_sha1:
 214             tags['flac_sha1'] = self.source_sha1
 215         return tags
 216
 217     @cached_property
 218     def book(self):
 219         if self.slug:
 220             apidata = requests.get(f'https://wolnelektury.pl/api/books/{self.slug}/').json()
 221         else:
 222             return {}
 223         return apidata
 224
 225     @property
 226     def document(self):
 227         from librarian.document import WLDocument, parser
 228         from lxml import etree
 229
 230         xml_url = self.book.get('xml', None)
 231         if xml_url is None:
 232             return None
 233
 234         return WLDocument(
 235                 etree.parse(
 236                     io.BytesIO(
 237                         requests.get(xml_url).content
 238                     )
 239                     ,parser = parser
 240                 )
 241             )