Esempio n. 1
0
    def make_content_node(self, path, kind):
        title = os.path.basename(path)
        try:
            node = ContentNode.objects.get(path=path)
        except ContentNode.DoesNotExist:
            node = ContentNode(path=path)
        node.title = title
        node.owner = self.owner
        node.kind = kind

        # Set the creation date to the file modification time.
        mtime = os.path.getmtime(path)
        node.created = datetime.datetime.fromtimestamp(mtime)

        # Get the file size or size of files contained within the directory.
        if os.path.isfile(path):
            size = os.path.getsize(path)
        elif os.path.isdir(path):
            # This could be inefficient if we end up repeatedly walking the same
            # directory subtree.
            size = 0
            for (root, dirs, files) in os.walk(path):
                size += sum(
                    os.path.getsize(os.path.join(root, f)) for f in files)
        node.size = size

        try:
            node.metadata
        except ContentMetadata.DoesNotExist:
            meta = ContentMetadata()
            meta.save()
            node.metadata = meta
        node.save()
        self.nodes.add(node)
        print 'created node: %r; path %r' % (node, node.path)
        return node
Esempio n. 2
0
    def make_content_node(self, path, kind):
        title = os.path.basename(path)
        try:
            node = ContentNode.objects.get(path=path)
        except ContentNode.DoesNotExist:
            node = ContentNode(path=path)
        node.title = title
        node.owner = self.owner
        node.kind = kind

        # Set the creation date to the file modification time.
        mtime = os.path.getmtime(path)
        node.created = datetime.datetime.fromtimestamp(mtime)

        # Get the file size or size of files contained within the directory.
        if os.path.isfile(path):
            size = os.path.getsize(path)
        elif os.path.isdir(path):
            # This could be inefficient if we end up repeatedly walking the same
            # directory subtree.
            size = 0
            for (root, dirs, files) in os.walk(path):
                size += sum(os.path.getsize(os.path.join(root, f))
                            for f in files)
        node.size = size

        try:
            node.metadata
        except ContentMetadata.DoesNotExist:
            meta = ContentMetadata()
            meta.save()
            node.metadata = meta
        node.save()
        self.nodes.add(node)
        print 'created node: %r; path %r' % (node, node.path)
        return node
Esempio n. 3
0
def exhibit_content(request):
    content_nodes = ContentNode.with_metadata(
        ).filter(kind__in=[KIND_MOVIE, KIND_SERIES])
    kinds = {KIND_MOVIE: 'Movie',
             KIND_SERIES: 'TV Show',}
    items = []
    titleyearPattern = re.compile("^(.*) \((\d{4})\)$")

    # for i in range(15):
    #     items.append({'type': 'Season',
    #                   'label': ,
    #                   'Label': 'Season %d' % (i+1),
    #                   'href': '/tvseasons'})

    # select_related doesn't work for ManyToMany relationships, so we load all
    # genre, actor, and director names into memory.
    imdb_to_actors = _grouped_dict(Role, 'imdb', 'actor', order_by='bill_pos')
    imdb_to_directors = _grouped_dict(IMDBMetadata.directors.through,
                                      'imdbmetadata', 'director')
    imdb_to_genres = _grouped_dict(IMDBMetadata.genres.through,
                                   'imdbmetadata', 'genre')

    for node in content_nodes:
        name = node.simple_name()
        item = {'type': kinds.get(node.kind, 'Unknown'),
                'label': node.simple_name(),
                'DateAdded': str(node.created),
                'Title': node.simple_name(),
                'Year': '',
                }
        missing = []

        match = titleyearPattern.search(name)
        if match:
            item['Title'] = match.group(1)
            item['Year'] = match.group(2)


        is_tv_series = node.kind == KIND_SERIES
        is_movie = node.kind == KIND_MOVIE

        if is_tv_series:
            seasons = []

            for child in node.children.all():
                seasons.append({'type': 'Season',
                                'label': str(child.id),
                                'title': child.title,
                                'link': '<a href="%s">%s</a>' % ('/foolio',
                                                                 child.title),
                                'href': '/tvseasons/%d' % child.id})
            items.extend(seasons)

            item['Seasons'] = [str(child.id) for child in node.children.all()
                               if child.kind == KIND_SEASON]
            # item['Seasons'] = [{'type': 'Season',
            #                     'label': child.title,
            #                     'href': '/tvseasons'}
            #                    for child in node.children.all()
            #                    if child.kind == KIND_SEASON]

        item['DL'] = node.downloads

        metadata = node.metadata
        imdb = metadata.imdb if metadata else None
        rt = metadata.rotten_tomatoes if metadata else None
        mc = metadata.metacritic if metadata else None

        if metadata and metadata.nyt_review:
            item['NYTReviewURL'] = metadata.nyt_review
        else:
            missing.append('NYTReviewURL')

        if imdb:
            imdb = node.metadata.imdb
            item['IMDbURL'] = 'http://www.imdb.com/title/tt%s' % imdb.imdb_id

            if imdb.rating is not None:
                item['IMDbRating'] = imdb.rating
            else:
                missing.append('IMDbRating')

            if imdb.length is not None:
                item['IMDbRuntime'] = imdb.length
            else:
                missing.append('IMDbRuntime')

            if imdb.plot_outline is not None:
                item['IMDbPlotOutline'] = imdb.plot_outline
            else:
                missing.append('IMDbPlotOutline')

            item['IMDbGenres'] = imdb_to_genres.get(imdb.pk, [])
            item['IMDbDirectors'] = imdb_to_directors.get(imdb.pk, [])

            # Limit to top 4

            item['IMDbActors'] = imdb_to_actors.get(imdb.pk, [])[:4]

            # Don't provide it if we don't have any. It's easier to check after
            # the query.
            if len(item['IMDbActors']) == 0:
                del item['IMDbActors']

            if imdb.thumb_image:
                item['ThumbURL'] = imdb.thumb_image.url

            # if imdb.thumb_uri is not None:
            #     item['ThumbURL'] = imdb.thumb_uri
            #     item['ThumbWidth'] = imdb.thumb_width
            #     item['ThumbHeight'] = imdb.thumb_height
        else:
            missing.append('IMDbURL')

        if rt:
            item['RTURL'] = rt.rt_uri

            # Prefer IMDb (local) thumbnails.
            if rt.thumb_uri and 'ThumbURL' not in item:
                item['ThumbURL'] = rt.thumb_uri
                # item['ThumbWidth'] = rt.thumb_width
                # item['ThumbHeight'] = rt.thumb_height

            if rt.top_critics_percent:
                item['RTRating'] = rt.top_critics_percent


                if rt.top_critics_fresh is None:
                    item['RTST'] = 'n'
                elif rt.top_critics_fresh is True:
                    item['RTST'] = 'f'
                else:
                    item['RTST'] = 'r'
            elif rt.all_critics_percent:
                item['RTRating'] = rt.all_critics_percent
                if rt.all_critics_fresh is None:
                    item['RTST'] = 'n'
                elif rt.all_critics_fresh is True:
                    item['RTST'] = 'f'
                else:
                    item['RTST'] = 'r'
            else:
                item['RTST'] = 'n'
                missing.append('RTRating')
        else:
            missing.append('RTURL')

        if mc:
            item['MCURL'] = 'http://www.metacritic.com%s' % mc.mc_uri
            if mc.score:
                item['MCRating'] = mc.score
            else:
                missing.append('MCRating')
            if mc.status:
                if mc.status == 'tbd':
                    item['MCST'] = 'n'
                elif mc.status in ['terrible', 'unfavorable']:
                    item['MCST'] = 'u'
                elif mc.status in ['mixed']:
                    item['MCST'] = 'm'
                elif mc.status in ['favorable', 'outstanding']:
                    item['MCST'] = 'f'
            else:
                item['MCST'] = 'n'
        else:
            missing.append('MCURL')

        item['Missing'] = missing
        items.append(item)

    properties = {
        'Title': { 'valueType': 'text' },
        'Year': { 'valueType': 'number' },
        'Seasons': { 'valueType': 'item' },
        'ThumbURL': { 'valueType': 'url' },
        'ThumbWidth': { 'valueType': 'number' },
        'ThumbHeight': { 'valueType': 'number' },
        'IMDbRating': { 'valueType': 'number', 'label': 'IMDb User Rating' },
        'IMDbURL': { 'valueType': 'url', 'label': 'IMDb URL' },
        'IMDbGenres': { 'valueType': 'text', 'label': 'Genres' },
        'IMDbDirectors': { 'valueType': 'text', 'label': 'Directors' },
        'IMDbActors': { 'valueType': 'text', 'label': 'Actors' },
        'IMDbRuntime': { 'valueType': 'number', 'label': 'Runtime' },
        'IMDbReleaseDate': { 'valueType': 'date', 'label': 'Release Date' },
        'IMDbAKA': { 'valueType': 'text', 'label': 'Alternate Titles' },
        'IMDbProduction': { 'valueType': 'text', 'label': 'Production Companies' },
        'IMDbPlotOutline': { 'valueType': 'text', 'label': 'Plot Outline' },
        'RTRating': { 'valueType': 'number', 'label': 'RottenTomatoes Rating' },
        'RTURL': { 'valueType': 'url', 'label': 'RottenTomatoes URL' },
        'RTActors': { 'valueType': 'text', 'label': 'Actors' },
        'RTDirectors': { 'valueType': 'text', 'label': 'Directors' },
        'RTWriters': { 'valueType': 'text', 'label': 'Writers' },
        'RTST': { 'valueType': 'text', 'label': 'RottenTomatoes Status'},
        'RTBoxOffice': { 'valueType': 'number', 'label': 'Box Office' },
        'MCURL': { 'valueType': 'url', 'label':' MetaCritic URL' },
        'MCRating': { 'valueType': 'number', 'label': 'Metacritic Rating' },
        'MCST': { 'valueType': 'text', 'label': 'Metacritic Status' },
        'MCNA': { 'valueType': 'boolean', 'label': 'MC No Rating' },
        'NYTReviewURL': { 'valueType': 'url', 'label': 'NYT Review URL' },
        'DateAdded': { 'valueType': 'date', 'label': 'Date Added' },
        'DL': { 'valueType': 'number', 'label': 'Downloads' },
        'Random': { 'valueType': 'number', 'label': 'Random' },
        'Missing': { 'valueType': 'text', 'label': 'Missing Fields' },
        }

    types = {
        'Movie': { 'pluralLabel': 'Movies' },
        'TV Show': { 'pluralLabel': 'TV Shows' },
        'Season': { 'pluralLabel': 'Seasons' },
    }

    result = {'types': types,
              'properties': properties,
              'items': items }

    indent = None if not settings.DEBUG else 2
    return json_response(result, indent=indent)