[WIP] Recommended shows version 2

medusa/__main__.py

@@ -1172,9 +1172,9 @@ def initialize(self, console_logging=True):
 
             app.show_update_scheduler = scheduler.Scheduler(show_updater.ShowUpdater(),
                                                             cycleTime=datetime.timedelta(hours=1),
-                                                            threadName='SHOWUPDATER',
-                                                            start_time=datetime.time(hour=app.SHOWUPDATE_HOUR,
-                                                                                     minute=random.randint(0, 59)))
+                                                            threadName='SHOWUPDATER')#,
+                                                            # start_time=datetime.time(hour=app.SHOWUPDATE_HOUR,
+                                                            #                          minute=random.randint(0, 59)))
 
             # snatcher used for manual search, manual picked results
             app.manual_snatch_scheduler = scheduler.Scheduler(SnatchQueue(),

medusa/app.py

@@ -667,6 +667,12 @@ def __init__(self):
         self.FALLBACK_PLEX_API_URL = 'https://tvdb2.plex.tv'
         self.TVDB_API_KEY = '0629B785CE550C8D'
 
+        # show updater recommeded show caching
+        self.CACHE_RECOMMENDED_SHOWS = True
+        self.CACHE_RECOMMENDED_TRAKT = True
+        self.CACHE_RECOMMENDED_IMDB = False
+        self.CACHE_RECOMMENDED_ANIDB = True
+
 
 app = MedusaApp()
 for app_key, app_value in app.__dict__.items():

medusa/databases/cache_db.py

@@ -195,6 +195,30 @@ def inc_major_version(self):
         major_version, minor_version = self.connection.version
         major_version += 1
         self.connection.action('UPDATE db_version SET db_version = ?;', [major_version])
-        log.info('[CACHE-DB] Updated major version to: {}.{}', *self.connection.version)
+        return self.connection.version
 
         return self.connection.version
+
+
+class AddRecommendedTable(ClearProviderTables):
+    """Add table to cache the recommended shows."""
+
+    def test(self):
+        return self.hasTable('recommended')
+
+    def execute(self):
+        self.connection.action(
+            """CREATE TABLE "recommended" (
+                `recommended_id`	INTEGER PRIMARY KEY AUTOINCREMENT,
+                `source`	INTEGER NOT NULL,
+                `series_id`	INTEGER NOT NULL,
+                `mapped_indexer`	INTEGER,
+                `mapped_series_id`	INTEGER,
+                `title`	TEXT NOT NULL,
+                `rating`	NUMERIC,
+                `votes`	INTEGER,
+                `is_anime`	INTEGER DEFAULT 0,
+                `image_href`	TEXT,
+                `image_src`	TEXT
+            )"""
+        )

medusa/helpers/externals.py

@@ -9,7 +9,7 @@
 from medusa.indexers.indexer_api import indexerApi
 from medusa.indexers.indexer_config import indexerConfig
 from medusa.indexers.indexer_exceptions import IndexerException, IndexerShowAlreadyInLibrary, IndexerUnavailable
-from medusa.indexers.utils import mappings
+from medusa.indexers.utils import mappings, reverse_mappings
 from medusa.logger.adapters.style import BraceAdapter
 
 from requests.exceptions import RequestException
@@ -174,6 +174,26 @@ def check_existing_shows(indexed_show, indexer):
                                                           indexerApi(indexer).name))
 
 
+def save_externals_to_db(indexer, series_id, externals):
+    """Save the indexers external id's to the db."""
+    sql_l = []
+
+    for external in externals:
+        if external in reverse_mappings and externals[external]:
+            sql_l.append(['INSERT OR IGNORE '
+                          'INTO indexer_mapping (indexer_id, indexer, mindexer_id, mindexer) '
+                          'VALUES (?,?,?,?)',
+                          [series_id,
+                           indexer,
+                           externals[external],
+                           int(reverse_mappings[external])
+                           ]])
+
+    if sql_l:
+        main_db_con = db.DBConnection()
+        main_db_con.mass_action(sql_l)
+
+
 def load_externals_from_db(indexer=None, indexer_id=None):
     """Load and recreate the indexers external id's.
 

medusa/server/api/v2/recommended.py

@@ -0,0 +1,59 @@
+# coding=utf-8
+"""Request handler for series and episodes."""
+from __future__ import unicode_literals
+
+import logging
+
+
+from medusa.indexers.indexer_config import EXTERNAL_IMDB, EXTERNAL_ANIDB, EXTERNAL_TRAKT
+from medusa.logger.adapters.style import BraceAdapter
+from medusa.server.api.v2.base import (
+    BaseRequestHandler,
+    BooleanField,
+    IntegerField,
+    ListField,
+    StringField,
+    iter_nested_items,
+    set_nested_value
+)
+from medusa.show.recommendations.recommended import get_recommended_shows
+from medusa.show.recommendations.anidb import AnidbPopular
+from medusa.show.recommendations.imdb import ImdbPopular
+from medusa.show.recommendations.trakt import TraktPopular
+from simpleanidb import REQUEST_HOT
+from medusa.tv.series import Series, SeriesIdentifier
+
+from six import itervalues, viewitems
+
+from tornado.escape import json_decode
+
+log = BraceAdapter(logging.getLogger(__name__))
+log.logger.addHandler(logging.NullHandler())
+
+
+class RecommendedHandler(BaseRequestHandler):
+    """Series request handler."""
+
+    #: resource name
+    name = 'recommended'
+
+    identifier = ('identifier', r'\w+')
+    #: path param
+    path_param = ('path_param', r'\w+')
+    allowed_methods = ('GET',)
+
+    def http_get(self, identifier, path_param=None):
+        """Query available recommended show lists."""
+
+        if identifier and identifier not in ('anidb', 'trakt', 'imdb'):
+            return self._bad_request("Invalid recommended list identifier '{0}'".format(identifier))
+
+        data = {}
+
+        recommended_mappings = {'imdb': EXTERNAL_IMDB, 'anidb': EXTERNAL_ANIDB, 'trakt': EXTERNAL_TRAKT}
+        shows = get_recommended_shows(source=recommended_mappings.get(identifier))
+
+        if shows:
+            data = [show.to_json() for show in shows]
+
+        return self._ok(data)

medusa/server/core.py

@@ -25,11 +25,13 @@
 from medusa.server.api.v2.episodes import EpisodeHandler
 from medusa.server.api.v2.internal import InternalHandler
 from medusa.server.api.v2.log import LogHandler
+from medusa.server.api.v2.recommended import RecommendedHandler
 from medusa.server.api.v2.series import SeriesHandler
 from medusa.server.api.v2.series_asset import SeriesAssetHandler
 from medusa.server.api.v2.series_legacy import SeriesLegacyHandler
 from medusa.server.api.v2.series_operation import SeriesOperationHandler
 from medusa.server.api.v2.stats import StatsHandler
+
 from medusa.server.web import (
     CalendarHandler,
     KeyHandler,
@@ -109,6 +111,9 @@ def get_apiv2_handlers(base):
         # /api/v2/authenticate
         AuthHandler.create_app_handler(base),
 
+        # /api/v2/recommeded
+        RecommendedHandler.create_app_handler(base),
+
         # Always keep this last!
         NotFoundHandler.create_app_handler(base)
     ]

medusa/server/web/home/add_shows.py

@@ -212,7 +212,7 @@ def popularAnime(self, list_type=REQUEST_HOT):
         """
         Fetches list recommeded shows from anidb.info.
         """
-        t = PageTemplate(rh=self, filename='addShows_recommended.mako')
+        t = PageTemplate(rh=self, filename='addShows_recommended_vue.mako')
         e = None
 
         try:
@@ -226,6 +226,15 @@ def popularAnime(self, list_type=REQUEST_HOT):
                         enable_anime_options=True, blacklist=[], whitelist=[],
                         controller='addShows', action='recommendedShows', realpage='popularAnime')
 
+    def recommended(self):
+        """
+        Serve Vue page addShows_recommeded_vue.mako
+        """
+        t = PageTemplate(rh=self, filename='addShows_recommended_vue.mako')
+
+        return t.render(title='Recommended shows', header='Recommended shows',
+                        controller='addShows', action='recommendedShows', realpage='recommended')
+
     def addShowToBlacklist(self, seriesid):
         # URL parameters
         data = {'shows': [{'ids': {'tvdb': seriesid}}]}

medusa/show/recommendations/anidb.py

@@ -9,11 +9,11 @@
 
 from medusa import app
 from medusa.cache import recommended_series_cache
-from medusa.indexers.indexer_config import INDEXER_TVDBV2
+from medusa.indexers.indexer_config import INDEXER_TVDBV2, EXTERNAL_ANIDB
 from medusa.logger.adapters.style import BraceAdapter
 from medusa.session.core import MedusaSession
 from medusa.show.recommendations.recommended import (
-    MissingTvdbMapping, RecommendedShow, cached_aid_to_tvdb, create_key_from_series,
+    BasePopular, MissingTvdbMapping, RecommendedShow, cached_aid_to_tvdb, create_key_from_series,
     update_recommended_series_cache_index
 )
 
@@ -27,17 +27,22 @@
 log.logger.addHandler(logging.NullHandler())
 
 
-class AnidbPopular(object):  # pylint: disable=too-few-public-methods
+class AnidbPopular(BasePopular):  # pylint: disable=too-few-public-methods
+
+    BASE_URL = 'https://anidb.net/perl-bin/animedb.pl?show=anime&aid={aid}'
+    TITLE = 'Anidb Popular'
+    CACHE_SUBFOLDER = __name__.split('.')[-1] if '.' in __name__ else __name__
+
     def __init__(self):
         """Class retrieves a specified recommended show list from Trakt.
 
         List of returned shows is mapped to a RecommendedShow object
         """
-        self.cache_subfolder = __name__.split('.')[-1] if '.' in __name__ else __name__
-        self.session = MedusaSession()
-        self.recommender = 'Anidb Popular'
-        self.base_url = 'https://anidb.net/perl-bin/animedb.pl?show=anime&aid={aid}'
-        self.default_img_src = 'poster.png'
+        super(AnidbPopular, self).__init__()
+        self.cache_subfolder = AnidbPopular.CACHE_SUBFOLDER
+        self.recommender = AnidbPopular.TITLE
+        self.source = EXTERNAL_ANIDB
+        self.base_url = AnidbPopular.BASE_URL
 
     @recommended_series_cache.cache_on_arguments(namespace='anidb', function_key_generator=create_key_from_series)
     def _create_recommended_show(self, series, storage_key=None):
@@ -55,25 +60,24 @@ def _create_recommended_show(self, series, storage_key=None):
         rec_show = RecommendedShow(
             self,
             series.aid,
-            series.title,
+            unicode(series.title),
             INDEXER_TVDBV2,
             tvdb_id,
             **{'rating': series.rating_permanent,
                 'votes': series.count_permanent,
                 'image_href': self.base_url.format(aid=series.aid),
-                'ids': {'tvdb': tvdb_id,
-                        'aid': series.aid
-                        }
-               }
+                'ids': {
+                    'tvdb_id': tvdb_id,
+                    'anidb_id': series.aid
+                },
+               'is_anime': True
+            }
         )
 
         # Check cache or get and save image
         use_default = self.default_img_src if not series.picture.url else None
         rec_show.cache_image(series.picture.url, default=use_default)
 
-        # By default pre-configure the show option anime = True
-        rec_show.is_anime = True
-
         return rec_show
 
     def fetch_popular_shows(self, list_type=REQUEST_HOT):
@@ -90,6 +94,7 @@ def fetch_popular_shows(self, list_type=REQUEST_HOT):
             try:
                 recommended_show = self._create_recommended_show(show, storage_key='anidb_{0}'.format(show.aid))
                 if recommended_show:
+                    recommended_show.save_to_db()
                     result.append(recommended_show)
             except MissingTvdbMapping:
                 log.info('Could not parse AniDB show {0}, missing tvdb mapping', show.title)