348 lines
11 KiB
Python
348 lines
11 KiB
Python
from dataclasses import dataclass
|
|
import logging
|
|
from typing import Optional
|
|
from uuid import uuid4
|
|
|
|
import requests
|
|
from django.conf import settings
|
|
from django.core.files.base import ContentFile
|
|
from django.db import models
|
|
from django.urls import reverse
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django_extensions.db.models import TimeStampedModel
|
|
from imagekit.models import ImageSpecField
|
|
from imagekit.processors import ResizeToFit
|
|
from music.constants import JELLYFIN_POST_KEYS
|
|
from scrobbles.mixins import (
|
|
ObjectWithGenres,
|
|
ScrobblableConstants,
|
|
ScrobblableMixin,
|
|
)
|
|
from taggit.managers import TaggableManager
|
|
from videos.metadata import VideoMetadata
|
|
from videos.sources.imdb import lookup_video_from_imdb
|
|
from videos.sources.tmdb import lookup_video_from_tmdb
|
|
from videos.sources.youtube import lookup_video_from_youtube
|
|
from vrobbler.apps.scrobbles.dataclasses import BaseLogData, WithPeopleLogData
|
|
|
|
YOUTUBE_VIDEO_URL = "https://www.youtube.com/watch?v="
|
|
YOUTUBE_CHANNEL_URL = "https://www.youtube.com/channel/"
|
|
IMDB_VIDEO_URL = "https://www.imdb.com/title/tt"
|
|
|
|
logger = logging.getLogger(__name__)
|
|
BNULL = {"blank": True, "null": True}
|
|
|
|
|
|
@dataclass
|
|
class VideoLogData(BaseLogData, WithPeopleLogData):
|
|
rating: Optional[int] = None
|
|
|
|
|
|
class Channel(TimeStampedModel):
|
|
uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
|
|
name = models.CharField(max_length=255)
|
|
cover_image = models.ImageField(upload_to="videos/channels/", **BNULL)
|
|
cover_small = ImageSpecField(
|
|
source="cover_image",
|
|
processors=[ResizeToFit(100, 100)],
|
|
format="JPEG",
|
|
options={"quality": 60},
|
|
)
|
|
cover_medium = ImageSpecField(
|
|
source="cover_image",
|
|
processors=[ResizeToFit(300, 300)],
|
|
format="JPEG",
|
|
options={"quality": 75},
|
|
)
|
|
youtube_id = models.CharField(max_length=255, **BNULL)
|
|
genre = TaggableManager(through=ObjectWithGenres)
|
|
|
|
def __str__(self) -> str:
|
|
return self.name
|
|
|
|
def get_absolute_url(self):
|
|
return reverse("videos:channel_detail", kwargs={"slug": self.uuid})
|
|
|
|
@property
|
|
def youtube_url(self):
|
|
return YOUTUBE_CHANNEL_URL + self.youtube_id
|
|
|
|
@property
|
|
def primary_image_url(self) -> str:
|
|
url = ""
|
|
if self.cover_image:
|
|
url = self.cover_image_medium.url
|
|
return url
|
|
|
|
def scrobbles_for_user(self, user_id: int, include_playing=False):
|
|
from scrobbles.models import Scrobble
|
|
|
|
played_query = models.Q(played_to_completion=True)
|
|
if include_playing:
|
|
played_query = models.Q()
|
|
return Scrobble.objects.filter(
|
|
played_query,
|
|
video__channel=self,
|
|
user=user_id,
|
|
).order_by("-timestamp")
|
|
|
|
def fix_metadata(self, force: bool = False):
|
|
# TODO Scrape channel info from Youtube
|
|
logger.warning("Not implemented yet")
|
|
return
|
|
|
|
|
|
class Series(TimeStampedModel):
|
|
uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
|
|
name = models.CharField(max_length=255)
|
|
plot = models.TextField(**BNULL)
|
|
imdb_id = models.CharField(max_length=20, **BNULL)
|
|
imdb_rating = models.FloatField(**BNULL)
|
|
cover_image = models.ImageField(upload_to="videos/series/", **BNULL)
|
|
cover_small = ImageSpecField(
|
|
source="cover_image",
|
|
processors=[ResizeToFit(100, 100)],
|
|
format="JPEG",
|
|
options={"quality": 60},
|
|
)
|
|
cover_medium = ImageSpecField(
|
|
source="cover_image",
|
|
processors=[ResizeToFit(300, 300)],
|
|
format="JPEG",
|
|
options={"quality": 75},
|
|
)
|
|
preferred_source = models.CharField(max_length=100, **BNULL)
|
|
|
|
genre = TaggableManager(through=ObjectWithGenres)
|
|
|
|
class Meta:
|
|
verbose_name_plural = "series"
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
def get_absolute_url(self):
|
|
return reverse("videos:series_detail", kwargs={"slug": self.uuid})
|
|
|
|
def imdb_link(self) -> str:
|
|
if self.imdb_id:
|
|
return IMDB_VIDEO_URL + self.imdb_id
|
|
return ""
|
|
|
|
@property
|
|
def primary_image_url(self) -> str:
|
|
url = ""
|
|
if self.cover_image:
|
|
url = self.cover_image_medium.url
|
|
return url
|
|
|
|
def scrobbles_for_user(self, user_id: int, include_playing=False):
|
|
from scrobbles.models import Scrobble
|
|
|
|
played_query = models.Q(played_to_completion=True)
|
|
if include_playing:
|
|
played_query = models.Q()
|
|
return Scrobble.objects.filter(
|
|
played_query,
|
|
video__tv_series=self,
|
|
user=user_id,
|
|
).order_by("-timestamp")
|
|
|
|
def last_scrobbled_episode(self, user_id: int) -> Optional["Video"]:
|
|
episode = None
|
|
last_scrobble = self.scrobbles_for_user(
|
|
user_id, include_playing=True
|
|
).first()
|
|
if last_scrobble:
|
|
episode = last_scrobble.media_obj
|
|
return episode
|
|
|
|
def is_episode_playing(self, user_id: int) -> bool:
|
|
last_scrobble = self.scrobbles_for_user(
|
|
user_id, include_playing=True
|
|
).first()
|
|
return not last_scrobble.played_to_completion
|
|
|
|
def fix_metadata(self, force_update=False):
|
|
name_or_id = self.name
|
|
if self.imdb_id:
|
|
name_or_id = self.imdb_id
|
|
video_metadata: VideoMetadata = lookup_video_from_imdb(name_or_id)
|
|
|
|
if not video_metadata.title:
|
|
logger.warning(f"No imdb data for {self}")
|
|
return
|
|
|
|
cover_url = imdb_dict.get("cover_url")
|
|
|
|
if (not self.cover_image or force_update) and cover_url:
|
|
r = requests.get(cover_url)
|
|
if r.status_code == 200:
|
|
fname = f"{self.name}_{self.uuid}.jpg"
|
|
self.cover_image.save(fname, ContentFile(r.content), save=True)
|
|
|
|
if genres := imdb_dict.get("genres"):
|
|
self.genre.add(*genres)
|
|
|
|
|
|
class Video(ScrobblableMixin):
|
|
COMPLETION_PERCENT = getattr(settings, "VIDEO_COMPLETION_PERCENT", 90)
|
|
SECONDS_TO_STALE = getattr(settings, "VIDEO_SECONDS_TO_STALE", 14400)
|
|
METADATA_CLASS = VideoMetadata
|
|
|
|
class VideoType(models.TextChoices):
|
|
UNKNOWN = "U", _("Unknown")
|
|
TV_EPISODE = "E", _("TV Episode")
|
|
MOVIE = "M", _("Movie")
|
|
SKATE_VIDEO = "S", _("Skate Video")
|
|
YOUTUBE = "Y", _("YouTube Video")
|
|
|
|
video_type = models.CharField(
|
|
max_length=1,
|
|
choices=VideoType.choices,
|
|
default=VideoType.UNKNOWN,
|
|
)
|
|
overview = models.TextField(**BNULL)
|
|
tagline = models.TextField(**BNULL)
|
|
year = models.IntegerField(**BNULL)
|
|
|
|
# TV show specific fields
|
|
tv_series = models.ForeignKey(Series, on_delete=models.DO_NOTHING, **BNULL)
|
|
channel = models.ForeignKey(Channel, on_delete=models.DO_NOTHING, **BNULL)
|
|
season_number = models.IntegerField(**BNULL)
|
|
episode_number = models.IntegerField(**BNULL)
|
|
next_imdb_id = models.CharField(max_length=20, **BNULL)
|
|
imdb_id = models.CharField(max_length=20, **BNULL)
|
|
imdb_rating = models.FloatField(**BNULL)
|
|
tmdb_rating = models.FloatField(**BNULL)
|
|
cover_image = models.ImageField(upload_to="videos/video/", **BNULL)
|
|
cover_image_small = ImageSpecField(
|
|
source="cover_image",
|
|
processors=[ResizeToFit(100, 100)],
|
|
format="JPEG",
|
|
options={"quality": 60},
|
|
)
|
|
cover_image_medium = ImageSpecField(
|
|
source="cover_image",
|
|
processors=[ResizeToFit(300, 300)],
|
|
format="JPEG",
|
|
options={"quality": 75},
|
|
)
|
|
tvrage_id = models.CharField(max_length=20, **BNULL)
|
|
tvdb_id = models.CharField(max_length=20, **BNULL)
|
|
tmdb_id = models.CharField(max_length=20, **BNULL)
|
|
youtube_id = models.CharField(max_length=255, **BNULL)
|
|
plot = models.TextField(**BNULL)
|
|
upload_date = models.DateField(**BNULL)
|
|
|
|
class Meta:
|
|
unique_together = [["title", "imdb_id"]]
|
|
|
|
def __str__(self):
|
|
if not self.title:
|
|
return self.youtube_id or self.imdb_id
|
|
if self.video_type == self.VideoType.TV_EPISODE:
|
|
return f"{self.title} / [S{self.season_number}E{self.episode_number}] {self.tv_series}"
|
|
if self.video_type == self.VideoType.YOUTUBE:
|
|
return f"{self.title} / {self.channel}"
|
|
return self.title
|
|
|
|
def get_absolute_url(self):
|
|
return reverse("videos:video_detail", kwargs={"slug": self.uuid})
|
|
|
|
@property
|
|
def logdata_cls(self):
|
|
return VideoLogData
|
|
|
|
@property
|
|
def subtitle(self):
|
|
if self.tv_series:
|
|
return self.tv_series
|
|
return ""
|
|
|
|
@property
|
|
def imdb_link(self):
|
|
return f"https://www.imdb.com/title/tt{self.imdb_id}"
|
|
|
|
@property
|
|
def info_link(self):
|
|
return self.imdb_link
|
|
|
|
@property
|
|
def link(self) -> str:
|
|
return self.imdb_link
|
|
|
|
@property
|
|
def youtube_link(self) -> str:
|
|
if self.youtube_id:
|
|
return f"https://www.youtube.com/watch?v={self.youtube_id}"
|
|
return ""
|
|
|
|
@property
|
|
def primary_image_url(self) -> str:
|
|
url = ""
|
|
if self.cover_image:
|
|
url = self.cover_image_medium.url
|
|
return url
|
|
|
|
@property
|
|
def strings(self) -> ScrobblableConstants:
|
|
return ScrobblableConstants(verb="Watching", tags="movie_camera")
|
|
|
|
def save_image_from_url(self, url: str, force_update: bool = False):
|
|
if not self.cover_image or (force_update and url):
|
|
r = requests.get(url)
|
|
if r.status_code == 200:
|
|
fname = f"{self.title}_{self.uuid}.jpg"
|
|
self.cover_image.save(fname, ContentFile(r.content), save=True)
|
|
|
|
@classmethod
|
|
def get_from_youtube_id(
|
|
cls, youtube_id: str, overwrite: bool = False
|
|
) -> "Video":
|
|
video, created = cls.objects.get_or_create(youtube_id=youtube_id)
|
|
if not created and not overwrite:
|
|
return video
|
|
|
|
vdict, cover, genres = lookup_video_from_youtube(
|
|
youtube_id
|
|
).as_dict_with_cover_and_genres()
|
|
if created or overwrite:
|
|
for k, v in vdict.items():
|
|
setattr(video, k, v)
|
|
video.save()
|
|
|
|
video.save_image_from_url(cover)
|
|
video.genre.add(*genres)
|
|
return video
|
|
|
|
@classmethod
|
|
def get_from_imdb_id(
|
|
cls, imdb_id: str, overwrite: bool = False
|
|
) -> "Video":
|
|
if "tt" in imdb_id:
|
|
imdb_id = imdb_id[2:]
|
|
video, created = cls.objects.get_or_create(imdb_id=imdb_id)
|
|
if not created and not overwrite:
|
|
return video
|
|
|
|
vdict, cover, genres = lookup_video_from_tmdb(
|
|
imdb_id
|
|
).as_dict_with_cover_and_genres()
|
|
if created or overwrite:
|
|
for k, v in vdict.items():
|
|
setattr(video, k, v)
|
|
video.save()
|
|
|
|
video.save_image_from_url(cover)
|
|
video.genre.add(*genres)
|
|
return video
|
|
|
|
@classmethod
|
|
def find_or_create(
|
|
cls, data_dict: dict, post_keys: dict = JELLYFIN_POST_KEYS
|
|
) -> Optional["Video"]:
|
|
"""Thes smallest of wrappers around our actual get or create utility."""
|
|
imdb_key = post_keys.get("IMDB_ID", "").replace("tt", "")
|
|
return cls.get_from_imdb_id(data_dict.get(imdb_key))
|