# -*- coding: utf-8 -*- # vi:si:et:sw=4:sts=4:ts=4 import re import os.path import random from datetime import datetime from django.db import models from django.db.models import Q from django.contrib.auth.models import User from django.core.files.base import ContentFile import oxlib from oxlib import stripTags from oxlib.normalize import canonicalTitle, canonicalName from django.utils import simplejson as json import utils import managers import fields import load class MovieImdb(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) imdbId = models.CharField(max_length=7, unique=True) title = models.CharField(max_length=1000) year = models.CharField(max_length=4) runtime = models.IntegerField(null=True, blank=True) release_date = models.DateField(null=True, blank=True) tagline = models.TextField(blank=True) plot = models.TextField(blank=True) plot_outline = models.TextField(blank=True) rating = models.FloatField(null=True, blank=True) votes = models.IntegerField(null=True, blank=True) budget = models.IntegerField(null=True, blank=True) gross = models.IntegerField(null=True, blank=True) profit = models.IntegerField(null=True, blank=True) series_imdb = models.CharField(max_length=7, default='') series_title = models.CharField(max_length=1000, blank=True, default='') episode_title = models.CharField(max_length=1000, blank=True, default='') season = models.IntegerField(default=-1) episode = models.IntegerField(default=-1) def __unicode__(self): return u"%s (%s)" % (self.title, self.imdbId) class MovieOxdb(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) title = models.CharField(max_length=1000) year = models.CharField(max_length=4) runtime = models.IntegerField(null=True, blank=True) release_date = models.DateField(null=True, blank=True) tagline = models.TextField(blank=True) plot = models.TextField(blank=True) plot_outline = models.TextField(blank=True) rating = models.FloatField(null=True, blank=True) votes = models.IntegerField(null=True, blank=True) budget = models.IntegerField(null=True, blank=True) gross = models.IntegerField(null=True, blank=True) profit = models.IntegerField(null=True, blank=True) series_imdb = models.CharField(max_length=7, default='') series_title = models.TextField(blank=True, default='') episode_title = models.TextField(blank=True, default='') season = models.IntegerField(default=-1) episode = models.IntegerField(default=-1) def __unicode__(self): return u"%s (%s)" % (self.title, self.year) class MovieExtra(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) title = models.CharField(max_length=1000) description = models.TextField(blank=True) contributor = models.CharField(max_length=1000) def getMovie(info): ''' info dict with: imdbId, title, director, episode_title, season, series ''' if 'imdbId' in info: try: movie = models.Movie.byImdbId(imdbId) except models.Movie.DoesNotExist: movie = load.loadIMDb(movieId==info['imdbId']) else: q = Movie.objects.filter(title=info['title'], year=info['director']) if q.count() > 1: movie = q[0] else: movie = newMovie(info['title'], info['director'], '') updated = False for key in ('episode_title', 'season', 'year'): if key in info: setattr(movie.oxdb, key, info[key]) updated = True if updated: movie.save() return movie def newMovie(title, director, year): movie = Movie() oxdb = MovieOxdb() oxdb.save() movie.oxdb = oxdb movie.oxdb.title = title movie.oxdb.year = str(year) movie.oxdb.save() movie.oxdbId = "__init__%s" % random.randint(0, 100000) movie.save() movie.oxdbId = movie.oxid() movie.save() return movie def movie_path(f, size): name = "%s.%s" % (size, 'ogv') url_hash = f.movieId return os.path.join('movie', url_hash[:2], url_hash[2:4], url_hash[4:6], name) class Movie(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) published = models.DateTimeField(default=datetime.now, editable=False) #only movies that have metadata from files are available, #this is indicated by setting available to True available = models.BooleanField(default=False, db_index=True) movieId = models.CharField(max_length=128, unique=True, blank=True) oxdbId = models.CharField(max_length=42, unique=True, blank=True) imdb = models.OneToOneField('MovieImdb', null=True, related_name='movie') oxdb = models.OneToOneField('MovieOxdb', null=True, related_name='movie') extra = models.OneToOneField('MovieExtra', null=True, related_name='movie') objects = managers.MovieManager() def get(self, key, default=None): if self.extra and getattr(self.extra, key): return getattr(self.extra, key) if self.oxdb and getattr(self.oxdb, key): return getattr(self.oxdb, key) if self.imdb: return getattr(self.imdb, key) return default def _manual(self, qs, f='manual'): if qs.filter(**{f:True}).count() > 0: return qs.exclude(**{f:False}) return qs.exclude(**{f:True}) def directors(self): qs = self.people.filter(cast__role='directors').order_by('cast__position') return self._manual(qs, 'cast__manual') def writers(self): qs = self.people.filter(cast__role='writers').order_by('cast__position') return self._manual(qs, 'cast__manual') def editors(self): qs = self.people.filter(cast__role='editors').order_by('cast__position') return self._manual(qs, 'cast__manual') def producers(self): qs = self.people.filter(cast__role='producers').order_by('cast__position') return self._manual(qs, 'cast__manual') def cinematographers(self): qs = self.people.filter(cast__role='cinematographers').order_by('cast__position') return self._manual(qs, 'cast__manual') def cast(self): cast = [] qs = Cast.objects.filter(movie=self, role='cast').order_by('position') qs = self._manual(qs) for c in qs: cast.append((c.person.name, c.character)) return tuple(cast) def alternative_titles(self): return self._manual(self.alternative_titles_all) def genres(self): return self._manual(self.genres_all) def keywords(self): return self._manual(self.keywords_all) def countries(self): return self._manual(self.countries_all, 'moviecountry__manual').order_by('moviecountry__position') def languages(self): return self._manual(self.languages_all, 'movielanguage__manual').order_by('movielanguage__position') def trivia(self): return self._manual(self.trivia_all) def locations(self): return self._manual(self.locations_all) def connections(self): return self._manual(self.connections_all) def connections_json(self): connections = {} for connection in self.connections(): if connection.relation not in connections: connections[connection.relation] = [] connections[connection.relation].append(connection.object.movieId) return connections def reviews(self): q = self.reviews_all.filter(manual=True) if q.count() > 0: return q whitelist = ReviewWhitelist.objects.all() q = Q(id=-1) for w in whitelist: q = q | Q(url__contains=w.url) return self.reviews_all.filter(q).filter(manual=False) rights_level = models.IntegerField(default=-1) ''' #these values get populated with imdb/oxdb values on save() #edits will be overwritten title = models.CharField(max_length=1000) year = models.CharField(max_length=4) runtime = models.IntegerField(null=True, blank=True) release_date = models.DateField(null=True, blank=True) tagline = models.TextField(blank=True) plot = models.TextField(blank=True) plot_outline = models.TextField(blank=True) rating = models.FloatField(null=True, blank=True) votes = models.IntegerField(null=True, blank=True) budget = models.IntegerField(null=True, blank=True) gross = models.IntegerField(null=True, blank=True) profit = models.IntegerField(null=True, blank=True) series_imdb = models.CharField(max_length=7, default='') series_title = models.TextField(blank=True, default='') episode_title = models.TextField(blank=True, default='') season = models.IntegerField(default=-1) episode = models.IntegerField(default=-1) ''' json = fields.DictField(default={}, editable=False) ''' directors = fields.TupleField(default=()) writers = fields.TupleField(default=()) editors = fields.TupleField(default=()) producers = fields.TupleField(default=()) cinematographers = fields.TupleField(default=()) cast = fields.TupleField(default=()) alternative_titles = fields.TupleField(default=()) genres = fields.TupleField(default=()) keywords = fields.TupleField(default=()) countries = fields.TupleField(default=()) languages = fields.TupleField(default=()) trivia = fields.TupleField(default=()) locations = fields.TupleField(default=()) connections = fields.DictField(default={}) reviews = fields.TupleField(default=()) ''' #FIXME: use data.0xdb.org ''' tpb_id = models.CharField(max_length=128, blank=True) kg_id = models.CharField(max_length=128, blank=True) open_subtitle_id = models.IntegerField(null=True, blank=True) wikipedia_url = models.TextField(blank=True) #FIXME: use data.0xdb.org/posters for that #what of this is still required? still_pos = models.IntegerField(null=True, blank=True) poster = models.TextField(blank=True) posters_disabled = models.TextField(blank=True) posters_available = models.TextField(blank=True) poster_height = models.IntegerField(null=True, blank=True) poster_width = models.IntegerField(null=True, blank=True) ''' #stream related fields ''' ''' stream128 = models.FileField(default=None, blank=True, upload_to=lambda f, x: movie_path(f, '128')) stream320 = models.FileField(default=None, blank=True, upload_to=lambda f, x: movie_path(f, '320')) stream640 = models.FileField(default=None, blank=True, upload_to=lambda f, x: movie_path(f, '640')) #FIXME: is this still required? should this not be aspect ratio? depends on stream??? scene_height = models.IntegerField(null=True, blank=True) def __unicode__(self): return u'%s (%s)' % (self.get('title'), self.get('year')) def save(self, *args, **kwargs): if not self.oxdb: oxdb = MovieOxdb() oxdb.save() self.oxdb = oxdb if self.imdb: mid = self.imdb.imdbId else: mid = self.oxdbId self.movieId = mid if self.id: self.json = self.get_json() ''' #populate auto values for faster results #FIXME: why is it not possible to use setattr to set List instead of db value? common_fields = [f.name for f in MovieImdb._meta.fields] only_relevant = lambda f: f not in ('id', 'created', 'modified', 'imdbId') common_fields = filter(only_relevant, common_fields) for f in common_fields: setattr(self, f, self.get(f)) for f in ('directors', 'writers', 'editors', 'producers', 'cinematographers', 'reviews', 'countries', 'languages', 'keywords', 'genres', 'trivia', 'alternative_titles'): value = getattr(self, 'get_' + f) setattr(self, f, tuple([v.json() for v in value()])) for f in ('cast', ): value = getattr(self, 'get_' + f) setattr(self, f, value()) self.connections = self.connections_json() ''' super(Movie, self).save(*args, **kwargs) self.updateFind() self.updateSort() _public_fields = { 'movieId': 'id', 'title': 'title', 'year': 'year', 'runtime': 'runtime', 'release_date': 'release_date', 'countries': 'country', 'directors': 'director', 'languages': 'language', 'genres': 'genre', 'keywords': 'keyword', 'cast': 'cast', 'series_title': 'series_title', 'episode_title': 'episode_title', 'season': 'season', 'episode': 'episode', 'reviews': 'reviews', 'trivia': 'trivia', 'rating': 'rating', 'votes': 'votes', 'alternative_titles': 'alternative_titles', 'connections_json': 'connections' } def get_json(self, fields=None): movie = {} for key in self._public_fields: pub_key = self._public_fields.get(key, key) if not fields or pub_key in fields: if hasattr(self, key): value = getattr(self, key) else: value = self.get(key) if key in ('directors', 'writers', 'editors', 'cinematographers', 'producers', 'reviews', 'countries', 'languages', 'keywords', 'genres', 'trivia', 'alternative_titles'): movie[pub_key] = tuple([v.json() for v in value()]) elif callable(value): movie[pub_key] = value() else: movie[pub_key] = value if fields: for f in fields: if f.endswith('.length') and f[:-7] in ('cast', 'genre', 'trivia'): movie[f] = getattr(self.sort.all()[0], f[:-7]) return movie def fields(self): fields = {} for f in self._meta.fields: if f.name in self._public_fields: fields[f.name] = {} fields[f.name]['order'] = 'desc' fields[f.name]['type'] = type(f) return fields fields = classmethod(fields) #Class functions to get Movies by ID, right now movieId, imdbId and oxdbId #FIXME: this should go into a manager def byMovieId(self, movieId): if len(movieId) == 7: return self.byImdbId(movieId) return self.byOxdbId(movieId) byMovieId = classmethod(byMovieId) def byImdbId(self, imdbId): return self.objects.get(imdb__imdbId=imdbId) byImdbId = classmethod(byImdbId) def byOxdbId(self, oxdbId): return self.objects.get(oxdbId=oxdbId) byOxdbId = classmethod(byOxdbId) def oxid(self): directors = ','.join([d.name for d in self.directors()]) return utils.oxid(self.get('title', ''), directors, self.get('year', ''), self.get('series_title', ''), self.get('episode_title', ''), self.get('season', ''), self.get('episode', '')) def updateFind(self): try: f = self.find except MovieFind.DoesNotExist: f = MovieFind(movie=self) f.title = self.get('title') + ' '.join([t.title for t in self.alternative_titles()]) f.director = ' '.join([i.name for i in self.directors()]) f.country = ' '.join([i.name for i in self.countries()]) f.year = self.get('year', '') f.language = ' '.join([i.name for i in self.languages()]) f.writer = ' '.join([i.name for i in self.writers()]) f.producer = ' '.join([i.name for i in self.producers()]) f.editor = ' '.join([i.name for i in self.editors()]) f.cinematographer = ' '.join([i.name for i in self.cinematographers()]) f.cast = ' '.join(['%s %s' % i for i in self.cast()]) f.genre = ' '.join([i.name for i in self.genres()]) f.keywords = ' '.join([i.name for i in self.keywords()]) f.summary = self.get('plot', '') + self.get('plot_outline', '') f.trivia = ' '.join([i.trivia for i in self.trivia()]) f.location = ' '.join([i.name for i in self.locations()]) #FIXME: collate filenames #f.filename = self.filename f.all = ' '.join(filter(None, [f.title, f.director, f.country, f.year, f.language, f.writer, f.producer, f.editor, f.cinematographer, f.cast, f.genre, f.keywords, f.summary, f.trivia, f.location, f.filename])) f.save() def updateSort(self): try: s = self.sort except MovieSort.DoesNotExist: s = MovieSort(movie=self) def sortName(value): sort_value = '~' if value: sort_value = stripTags(value).split(',') sort_value = '; '.join([canonicalName(name.strip()) for name in sort_value]) sort_value = sort_value.replace(u'\xc5k', 'A') if not sort_value: sort_value = '~' return sort_value #title title = canonicalTitle(self.get('title')) title = re.sub(u'[\'!¿¡,\.;\-"\:\*\[\]]', '', title) title = title.replace(u'Æ', 'Ae') #pad numbered titles numbers = re.compile('^(\d+)').findall(title) if numbers: padded = '%010d' % int(numbers[0]) title = re.sub('^(\d+)', padded, title) s.title = title.strip() directors = ','.join([i.name for i in self.directors()]) s.director = sortName(directors) s.country = ','.join([i.name for i in self.countries()]) s.year = self.get('year', '') names = ','.join([i.name for i in self.producers()]) s.producer = sortName(names) names = ','.join([i.name for i in self.writers()]) s.writer = sortName(names) names = ','.join([i.name for i in self.editors()]) s.editor = sortName(names) names = ','.join([i.name for i in self.cinematographers()]) s.cinematographer = sortName(names) s.language = ','.join([i.name for i in self.languages()]) s.country = ','.join([i.name for i in self.countries()]) s.runtime = self.get('runtime', 0) s.keywords = self.keywords().count() s.genre = self.genres().count() s.cast = len(self.cast()) s.summary = len(self.get('plot', '').split()) s.trivia = self.trivia().count() s.connections = self.connections().count() s.movieId = self.movieId s.rating = self.get('rating', -1) s.votes = self.get('votes', -1) # data from related subtitles s.scenes = 0 #FIXME s.words = 0 #FIXME s.wpm = 0 #FIXME s.risk = 0 #FIXME # data from related files s.duration = 0 #FIXME s.resolution = 0 #FIXME s.aspectratio = 0 #FIXME s.bitrate = 0 #FIXME s.pixels = 0 #FIXME s.filename = 0 #FIXME s.files = 0 #FIXME s.size = 0 #FIXME s.save() class MovieFind(models.Model): """ used to search movies, all search values are in here """ movie = models.OneToOneField('Movie', related_name='find', primary_key=True) all = models.TextField(blank=True) title = models.TextField(blank=True) director = models.TextField(blank=True, default='') country = models.TextField(blank=True, default='') year = models.CharField(max_length=4) language = models.TextField(blank=True, default='') writer = models.TextField(blank=True, default='') producer = models.TextField(blank=True, default='') editor = models.TextField(blank=True, default='') cinematographer = models.TextField(blank=True, default='') cast = models.TextField(blank=True, default='') #person genre = models.TextField(blank=True) keywords = models.TextField(blank=True) summary = models.TextField(blank=True) trivia = models.TextField(blank=True) locations = models.TextField(blank=True, default='') #only for own files or as admin? filename = models.TextField(blank=True, default='') _private_fields = ('id', 'movie') #return available find fields #FIXME: should return mapping name -> verbose_name def fields(self): fields = [] for f in self._meta.fields: if f.name not in self._private_fields: name = f.verbose_name name = name[0].capitalize() + name[1:] fields.append(name) return tuple(fields) fields = classmethod(fields) class MovieSort(models.Model): """ used to sort movies, all sort values are in here """ movie = models.OneToOneField('Movie', related_name='sort', primary_key=True) title = models.CharField(max_length=1000) director = models.TextField(blank=True) country = models.TextField(blank=True) year = models.CharField(max_length=4) producer = models.TextField(blank=True) writer = models.TextField(blank=True) editor = models.TextField(blank=True) cinematographer = models.TextField(blank=True) language = models.TextField(blank=True) runtime = models.IntegerField(blank=True, null=True) keywords = models.IntegerField(blank=True) genre = models.TextField(blank=True) cast = models.IntegerField(blank=True) summary = models.IntegerField(blank=True) trivia = models.IntegerField(blank=True) connections = models.IntegerField(blank=True) rating = models.FloatField(blank=True) votes = models.IntegerField(blank=True) scenes = models.IntegerField(blank=True) words = models.IntegerField(null=True, blank=True) wpm = models.IntegerField('Words per Minute', null=True, blank=True) risk = models.IntegerField(null=True, blank=True) movieId = models.CharField('ID', max_length=128, blank=True) duration = models.FloatField(default=-1) resolution = models.IntegerField(blank=True) aspectratio = models.IntegerField('Aspect Ratio', blank=True) bitrate = models.IntegerField(blank=True) pixels = models.IntegerField(blank=True) filename = models.IntegerField(blank=True) files = models.IntegerField(blank=True) size = models.IntegerField(blank=True) _private_fields = ('id', 'movie') #return available sort fields #FIXME: should return mapping name -> verbose_name def fields(self): fields = [] for f in self._meta.fields: if f.name not in self._private_fields: name = f.verbose_name name = name[0].capitalize() + name[1:] fields.append(name) return tuple(fields) fields = classmethod(fields) class AlternativeTitle(models.Model): movie = models.ForeignKey(Movie, related_name='alternative_titles_all') title = models.TextField() type = models.CharField(max_length=1000) manual = models.BooleanField(default=False) class Meta: ordering = ('title', ) def __unicode__(self): return self.title def json(self): return (self.title, self.type) def get_or_create(model, name): try: o = model.objects.get(name=name) except model.DoesNotExist: o = model.objects.create(name=name) o.save() return o class Person(models.Model): name = models.CharField(max_length=200) imdbId = models.CharField(max_length=7, blank=True) name_sort = models.CharField(max_length=200) movies = models.ManyToManyField(Movie, related_name='people', through='Cast') class Meta: ordering = ('name_sort', ) def __unicode__(self): return self.name def save(self, *args, **kwargs): if not self.name_sort: self.name_sort = oxlib.normalize.canonicalName(self.name) super(Person, self).save(*args, **kwargs) def get_or_create(model, name, imdbId=None): if imdbId: q = model.objects.filter(name=name, imdbId=imdbId) else: q = model.objects.all().filter(name=name) if q.count() > 0: o = q[0] else: o = model.objects.create(name=name) if imdbId: o.imdbId = imdbId o.save() return o get_or_create = classmethod(get_or_create) def json(self): return self.name class Cast(models.Model): movie = models.ForeignKey(Movie, related_name='cast_relation') person = models.ForeignKey(Person) role = models.CharField(max_length=200) character = models.CharField(max_length=1000, blank=True) position = models.IntegerField() manual = models.BooleanField(default=False) class Meta: ordering = ('position', 'person__name_sort') def __unicode__(self): return "%s <> %s" % (self.person, self.movie) def link(self, movie, person, role, character, position, manual=False): q = self.objects.filter(movie=movie, person=person, role=role, character=character) if q.count() > 0: link = q[0] link.position = position link.manual = manual link.save() else: link = self() link.movie=movie link.person=person link.role=role link.character=character link.position = position link.manual = manual link.save() return link link = classmethod(link) def json(self): return (self.person.json(), self.character) class Country(models.Model): name = models.CharField(max_length=200, unique=True) movies = models.ManyToManyField(Movie, related_name='countries_all', through='MovieCountry') class Meta: #!! adding this to ordering, breaks: # models.Country.objects.values("name").annotate(movies=Count('movies')) #'moviecountry__position', ordering = ('name', ) def __unicode__(self): return self.name get_or_create = classmethod(get_or_create) def json(self): return self.name class MovieCountry(models.Model): movie = models.ForeignKey(Movie) country = models.ForeignKey(Country) position = models.IntegerField() manual = models.BooleanField(default=False) class Meta: ordering = ('position', 'country') def __unicode__(self): return "%s <> %s" % (self.country, self.movie) def link(self, movie, country, position): q = self.objects.filter(movie=movie, country=country) if q.count() > 0: link = q[0] link.position = position link.save() else: link = self() link.movie=movie link.country=country link.position=position link.save() return link link = classmethod(link) class Language(models.Model): name = models.CharField(max_length=200, unique=True) movies = models.ManyToManyField(Movie, related_name='languages_all', through="MovieLanguage") class Meta: ordering = ('name', ) def __unicode__(self): return self.name get_or_create = classmethod(get_or_create) def json(self): return self.name class MovieLanguage(models.Model): movie = models.ForeignKey(Movie) language = models.ForeignKey(Language) position = models.IntegerField() manual = models.BooleanField(default=False) class Meta: ordering = ('position', 'language') def __unicode__(self): return self.language.name def link(self, movie, language, position): q = self.objects.filter(movie=movie, language=language) if q.count() > 0: link = q[0] link.position = position link.save() else: link = self() link.movie=movie link.language=language link.position=position link.save() return link link = classmethod(link) class Keyword(models.Model): name = models.CharField(max_length=200, unique=True) manual = models.BooleanField(default=False) movies = models.ManyToManyField(Movie, related_name='keywords_all') class Meta: ordering = ('name', ) def __unicode__(self): return self.name get_or_create = classmethod(get_or_create) def json(self): return self.name class Genre(models.Model): name = models.CharField(max_length=200, unique=True) manual = models.BooleanField(default=False) movies = models.ManyToManyField(Movie, related_name='genres_all') class Meta: ordering = ('name', ) def __unicode__(self): return self.name get_or_create = classmethod(get_or_create) def json(self): return self.name class Location(models.Model): name = models.CharField(max_length=200, unique=True) manual = models.BooleanField(default=False) movies = models.ManyToManyField(Movie, related_name='locations_all') #fixme: geo data lat_sw = models.FloatField(default=0) lng_sw = models.FloatField(default=0) lat_ne = models.FloatField(default=0) lng_ne = models.FloatField(default=0) lat_center = models.FloatField(default=0) lng_center = models.FloatField(default=0) area = models.FloatField(default=-1) class Meta: ordering = ('name', ) def __unicode__(self): return self.name get_or_create = classmethod(get_or_create) def json(self): return self.name class Trivia(models.Model): trivia = models.TextField() manual = models.BooleanField(default=False) position = models.IntegerField() movie = models.ForeignKey(Movie, related_name='trivia_all') class Meta: ordering = ('position', ) def __unicode__(self): return self.trivia def json(self): trivia = self.trivia trivia = oxlib.fixAmpersands(trivia) trivia = re.sub(' ', '', trivia) trivia = re.sub('(.*?)', '\\2', trivia) trivia = re.sub('(.*?)', '\\2', trivia) return trivia class Connection(models.Model): subject = models.ForeignKey(Movie, related_name='connections_all') relation = models.CharField(max_length=512) object = models.ForeignKey(Movie) manual = models.BooleanField(default=False) def get_or_create(model, subject, relation, object, reverse=True, manual=False): q = model.objects.filter(subject=subject, relation=relation, object=object) if q.count() > 0: o = q[0] else: o = model.objects.create(subject=subject, relation=relation, object=object, manual=manual) o.save() if reverse: _map = { 'Edited into': 'Edited from', 'Features': 'Featured in', 'Follows': 'Followed by', 'References': 'Referenced in', 'Remake of': 'Remade as', 'Spin off from': 'Spin off', 'Spoofs': 'Spoofed in', 'Version of': 'Version of', 'Alternate language version of': 'Alternate language version of', } if relation in _map.values(): for k in _map: if _map[k] == relation: reverse_relation = k else: reverse_relation = _map[relation] o2 = model.get_or_create(object, reverse_relation, subject, reverse=False) return o get_or_create = classmethod(get_or_create) def __unicode__(self): return '%s %s %s' % (self.subject, self.relation, self.object) class Review(models.Model): movie = models.ForeignKey('Movie', related_name='reviews_all') title = models.CharField(blank=True, max_length=2048) url = models.CharField(blank=True, max_length=2048) manual = models.BooleanField(default=False) def __unicode__(self): return self.title def get_or_create(self, movie, url): q = self.objects.filter(movie=movie, url=url) if q.count() > 0: o = q[0] else: o = self.objects.create(movie=movie, url=url) o.save() return o get_or_create = classmethod(get_or_create) def name(self): for w in ReviewWhitelist.objects.all(): if w.url in self.url: return w.name return self.title def json(self): return (self.name(), self.url) class ReviewWhitelist(models.Model): name = models.CharField(max_length=255, unique=True) url = models.CharField(max_length=255, unique=True) class List(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) user = models.ForeignKey(User) name = models.CharField(max_length=255, unique=True) public = models.BooleanField(default=False) movies = models.ManyToManyField(Movie, related_name='lists', through='ListItem') def add(self, movie): q = self.movies.filter(id=movie.id) if q.count() == 0: l = ListItem() l.list = self l.movie = movie l.save() def remove(self, movie): self.ListItem.objects.all().filter(movie=movie, list=self).delete() def __unicode__(self): return u'%s (%s)' % (self.title, unicode(self.user)) class ListItem(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) list = models.ForeignKey(List) movie = models.ForeignKey(Movie) def __unicode__(self): return u'%s in %s' % (unicode(self.movie), unicode(self.list)) def stream_path(f, size): name = "%s.%s" % (size, 'ogv') url_hash = f.oshash return os.path.join('stream', url_hash[:2], url_hash[2:4], url_hash[4:6], name) def still_path(f, still): name = "%s.%s" % (still, 'png') url_hash = f.oshash return os.path.join('still', url_hash[:2], url_hash[2:4], url_hash[4:6], name) FILE_TYPES = ( (0, 'unknown'), (1, 'video'), (2, 'audio'), (3, 'subtitle'), ) class File(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) published = models.DateTimeField(default=datetime.now, editable=False) verified = models.BooleanField(default=False) oshash = models.CharField(blank=True, unique=True, max_length=16) sha1 = models.CharField(blank=True, null=True, unique=True, max_length=40) md5 = models.CharField(blank=True, null=True, unique=True, max_length=32) movie = models.ForeignKey(Movie, related_name="files", default=None, null=True) type = models.IntegerField(default=0, choices=FILE_TYPES) info = fields.DictField(default={}) #FIMXE: why do i need those in the db? could jsut have them in info path = models.CharField(blank=True, max_length=2048) size = models.BigIntegerField(default=-1) duration = models.FloatField(default=-1) video_codec = models.CharField(blank=True, max_length=256) pixel_format = models.CharField(blank=True, max_length=256) width = models.IntegerField(default=-1) height = models.IntegerField(default=-1) pixel_aspect_ratio = models.CharField(blank=True, max_length=256) display_aspect_ratio = models.CharField(blank=True, max_length=256) framerate = models.CharField(blank=True, max_length=256) audio_codec = models.CharField(blank=True, max_length=256) samplerate = models.IntegerField(default=-1) channels = models.IntegerField(default=-1) #computed values bpp = models.FloatField(default=-1) pixels = models.BigIntegerField(default=0) part = models.IntegerField(default=0) needs_data = models.BooleanField(default=True) #stream related fields available = models.BooleanField(default=False) stream128 = models.FileField(default=None, upload_to=lambda f, x: stream_path(f, '128')) stream320 = models.FileField(default=None, upload_to=lambda f, x: stream_path(f, '320')) stream640 = models.FileField(default=None, upload_to=lambda f, x: stream_path(f, '640')) timeline = models.ImageField(default=None, null=True, upload_to=lambda f, x: still_path(f, '0')) def save_chunk(self, chunk, name='video.ogv'): if not self.available: #FIXME: this should use stream128 or stream640 depending on configuration video = getattr(self, 'stream128') if not video: video.save(name, ContentFile(chunk)) self.save() else: f = open(video.path, 'a') f.write(chunk) f.close() return True return False objects = managers.FileManager() def get_or_create(model, oshash): try: f = model.objects.get(oshash=oshash) except model.DoesNotExist: f = model.objects.create(oshash=oshash) f.save() return f get_or_create = classmethod(get_or_create) def __unicode__(self): return "%s (%s)" % (self.path, self.oshash) def update(self, data=None): """ only add, do not overwrite keys in file """ if data and not self.info: self.info = data _video_map = { 'codec': 'video_codec', } if 'video' in self.info and self.info['video']: for key in ('codec', 'pixel_format', 'width', 'height', 'pixel_aspect_ratio', 'display_aspect_ratio', 'framerate'): if key in self.info['video'][0]: setattr(self, _video_map.get(key, key), self.info['video'][0][key]) _audio_map = { 'codec': 'audio_codec', } if 'audio' in self.info and self.info['audio']: for key in ('codec', 'samplerate', 'channels'): if key in self.info['audio'][0]: setattr(self, _audio_map.get(key, key), self.info['audio'][0][key]) for key in ('duration', 'size', 'sha1', 'md5'): if key in self.info: setattr(self, key, self.info[key]) #detect and assign type based on extension or detected video track if os.path.splitext(self.info['path'])[-1] in ('.rar', '.sub', '.idx'): self.type = 0 elif 'video' in self.info: self.type = 1 elif os.path.splitext(self.info['path'])[-1] in ('.mp3', '.oga'): self.type = 2 elif os.path.splitext(self.info['path'])[-1] in ('.srt', ): self.type = 3 #FIXME: this should be computed and not submitted path self.path = self.info['path'] self.save() def findMovie(self): info = utils.parsePath(self.path) self.movie = getMovie(info) self.save() class Still(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) file = models.ForeignKey(File, related_name="stills") position = models.FloatField() still = models.ImageField(default=None, null=True, upload_to=lambda f, x: still_path(f, '0')) def __unicode__(self): return '%s at %s' % (self.file, self.position) class Subtitle(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) user = models.ForeignKey(User) file = models.ForeignKey(File, related_name="subtitles") language = models.CharField(max_length=16) srt = models.TextField(blank=True) def get_or_create(model, user, oshash, language): q = model.objects.filter(file__oshash=oshash, language=language, user=user) if q.count() > 0: s = q[0] else: f = models.File.get_or_create(oshash=oshash) s = model.objects.create(user=user, language=language, file=f) s.save() return s get_or_create = classmethod(get_or_create) def __unicode__(self): return '%s.%s.srt' % (os.path.splitext(self.movie_file.path)[0], self.language) class Layer(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) user = models.ForeignKey(User) movie = models.ForeignKey(Movie) #seconds time_in = models.FloatField(default=-1) time_out = models.FloatField(default=-1) type = models.CharField(blank=True, max_length=255) value = models.TextField() #location = models.ForeignKey('Location', default=None) class Archive(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) name = models.CharField(max_length=255, unique=True) public = models.BooleanField(default=False) users = models.ManyToManyField(User, related_name='archives') def __unicode__(self): return '%s' % (self.name) class ArchiveFile(models.Model): created = models.DateTimeField(auto_now_add=True) modified = models.DateTimeField(auto_now=True) archive = models.ForeignKey(Archive, related_name='files') file = models.ForeignKey(File) path = models.CharField(blank=True, max_length=2048) objects = managers.ArchiveFileManager() def update(self, data): """ only add, do not overwrite keys in file """ self.file.update(data) self.path = data.get('path', '') self.save() def get_or_create(model, archive, oshash): try: f = model.objects.by_oshash(oshash=oshash) except model.DoesNotExist: file = File.get_or_create(oshash) file.save() f = model.objects.create(archive=archive, file=file) f.save() return f get_or_create = classmethod(get_or_create) def __unicode__(self): return '%s (%s)' % (self.path, unicode(self.archive))