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