f218c88b41da99ef76e9055c319e6d774c8e7198
[audio.git] / 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()