Feature/vueify home

medusa/__main__.py

@@ -2134,6 +2134,7 @@ def load_shows_from_db():
         for sql_show in sql_results:
             try:
                 cur_show = Series(sql_show['indexer'], sql_show['indexer_id'])
+                cur_show.prev_episode()
                 cur_show.next_episode()
                 app.showList.append(cur_show)
             except Exception as error:

medusa/server/api/v2/config.py

@@ -80,7 +80,6 @@ class ConfigHandler(BaseRequestHandler):
     #: patch mapping
     patches = {
         # Main
-        'selectedRootIndex': IntegerField(app, 'SELECTED_ROOT'),
         'rootDirs': ListField(app, 'ROOT_DIRS'),
 
         'showDefaults.status': EnumField(app, 'STATUS_DEFAULT', (SKIPPED, WANTED, IGNORED), int),
@@ -474,6 +473,7 @@ class ConfigHandler(BaseRequestHandler):
         'layout.backlogOverview.status': StringField(app, 'BACKLOG_STATUS'),
         'layout.timeStyle': StringField(app, 'TIME_PRESET_W_SECONDS'),
         'layout.dateStyle': StringField(app, 'DATE_PRESET'),
+        'layout.selectedRootIndex': IntegerField(app, 'SELECTED_ROOT'),
     }
 
     def get(self, identifier, path_param=None):
@@ -615,8 +615,6 @@ def data_main():
         section_data['logs']['subliminalLog'] = bool(app.SUBLIMINAL_LOG)
         section_data['logs']['privacyLevel'] = app.PRIVACY_LEVEL
 
-        section_data['selectedRootIndex'] = int_default(app.SELECTED_ROOT, -1)  # All paths
-
         # Added for config - main, needs refactoring in the structure.
         section_data['launchBrowser'] = bool(app.LAUNCH_BROWSER)
         section_data['defaultPage'] = app.DEFAULT_PAGE
@@ -1174,7 +1172,7 @@ def data_layout():
 
         section_data['wide'] = bool(app.LAYOUT_WIDE)
 
-        section_data['posterSortdir'] = int(app.POSTER_SORTDIR)
+        section_data['posterSortdir'] = int(app.POSTER_SORTDIR or 0)
         section_data['themeName'] = app.THEME_NAME
         section_data['animeSplitHomeInTabs'] = bool(app.ANIME_SPLIT_HOME_IN_TABS)
         section_data['animeSplitHome'] = bool(app.ANIME_SPLIT_HOME)
@@ -1192,11 +1190,13 @@ def data_layout():
         section_data['comingEps'] = {}
         section_data['comingEps']['displayPaused'] = bool(app.COMING_EPS_DISPLAY_PAUSED)
         section_data['comingEps']['sort'] = app.COMING_EPS_SORT
-        section_data['comingEps']['missedRange'] = int(app.COMING_EPS_MISSED_RANGE)
+        section_data['comingEps']['missedRange'] = int(app.COMING_EPS_MISSED_RANGE or 0)
         section_data['comingEps']['layout'] = app.COMING_EPS_LAYOUT
 
         section_data['backlogOverview'] = {}
         section_data['backlogOverview']['status'] = app.BACKLOG_STATUS
         section_data['backlogOverview']['period'] = app.BACKLOG_PERIOD
 
+        section_data['selectedRootIndex'] = int_default(app.SELECTED_ROOT, -1)  # All paths
+
         return section_data

medusa/server/api/v2/series.py

@@ -55,6 +55,7 @@ def filter_series(current):
                 s.to_json(detailed=detailed, episodes=episodes)
                 for s in Series.find_series(predicate=filter_series)
             ]
+
             return self._paginate(data, sort='title')
 
         identifier = SeriesIdentifier.from_slug(series_slug)

medusa/server/api/v2/stats.py

@@ -17,6 +17,7 @@
     UNAIRED,
     WANTED
 )
+from medusa.network_timezones import parse_date_time
 from medusa.server.api.v2.base import BaseRequestHandler
 from medusa.show.show import Show
 
@@ -66,46 +67,49 @@ def query_in(items):
         return '({0})'.format(','.join(map(str, items)))
 
     query = dedent("""\
-        SELECT indexer AS indexerId, showid AS seriesId,
+        SELECT tv_eps.indexer AS indexerId, tv_eps.showid AS seriesId,
             SUM(
                 season > 0 AND
                 episode > 0 AND
                 airdate > 1 AND
-                status IN {status_quality}
+                tv_eps.status IN {status_quality}
             ) AS epSnatched,
             SUM(
                 season > 0 AND
                 episode > 0 AND
                 airdate > 1 AND
-                status IN {status_download}
+                tv_eps.status IN {status_download}
             ) AS epDownloaded,
             SUM(
                 season > 0 AND
                 episode > 0 AND
                 airdate > 1 AND (
-                    (airdate <= {today} AND status IN {status_pre_today}) OR
-                    status IN {status_both}
+                    (airdate <= {today} AND tv_eps.status IN {status_pre_today}) OR
+                    tv_eps.status IN {status_both}
                 )
             ) AS epTotal,
             (SELECT airdate FROM tv_episodes
-            WHERE showid=tv_eps.showid AND
-                    indexer=tv_eps.indexer AND
+            WHERE tv_episodes.showid=tv_eps.showid AND
+                    tv_episodes.indexer=tv_eps.indexer AND
                     airdate >= {today} AND
-                    (status = {unaired} OR status = {wanted})
+                    (tv_eps.status = {unaired} OR tv_eps.status = {wanted})
             ORDER BY airdate ASC
             LIMIT 1
             ) AS epAirsNext,
             (SELECT airdate FROM tv_episodes
-            WHERE showid=tv_eps.showid AND
-                    indexer=tv_eps.indexer AND
-                    airdate > 1 AND
-                    status <> {unaired}
+            WHERE tv_episodes.showid=tv_eps.showid AND
+                    tv_episodes.indexer=tv_eps.indexer AND
+                    airdate > {today} AND
+                    tv_eps.status <> {unaired}
             ORDER BY airdate DESC
             LIMIT 1
             ) AS epAirsPrev,
-            SUM(file_size) AS seriesSize
-        FROM tv_episodes tv_eps
-        GROUP BY showid, indexer
+            SUM(file_size) AS seriesSize,
+            tv_shows.airs as airs,
+            tv_shows.network as network
+        FROM tv_episodes tv_eps, tv_shows
+        WHERE tv_eps.showid = tv_shows.indexer_id AND tv_eps.indexer = tv_shows.indexer
+        GROUP BY tv_eps.showid, tv_eps.indexer;
     """).format(
         status_quality=query_in(snatched),
         status_download=query_in(downloaded),
@@ -121,12 +125,16 @@ def query_in(items):
     sql_result = main_db_con.select(query)
 
     stats_data = {}
-    stats_data['seriesStat'] = []
+    stats_data['stats'] = []
     stats_data['maxDownloadCount'] = 1000
     for cur_result in sql_result:
-        stats_data['seriesStat'].append(cur_result)
+        stats_data['stats'].append(cur_result)
         if cur_result['epTotal'] > stats_data['maxDownloadCount']:
             stats_data['maxDownloadCount'] = cur_result['epTotal']
+        if cur_result['epAirsNext']:
+            cur_result['epAirsNext'] = parse_date_time(cur_result['epAirsNext'], cur_result['airs'], cur_result['network'])
+        if cur_result['epAirsPrev']:
+            cur_result['epAirsPrev'] = parse_date_time(cur_result['epAirsPrev'], cur_result['airs'], cur_result['network'])
 
     stats_data['maxDownloadCount'] *= 100
     return stats_data

medusa/server/web/home/handler.py

@@ -121,41 +121,13 @@ def _genericMessage(self, subject, message):
         return t.render(message=message, subject=subject, title='')
 
     def index(self):
-        t = PageTemplate(rh=self, filename='home.mako')
-        selected_root = int(app.SELECTED_ROOT)
-        shows_dir = None
-        if selected_root is not None and app.ROOT_DIRS:
-            backend_pieces = app.ROOT_DIRS
-            backend_dirs = backend_pieces[1:]
-            try:
-                shows_dir = backend_dirs[selected_root] if selected_root != -1 else None
-            except IndexError:
-                # If user have a root selected in /home and remove the root folder a IndexError is raised
-                shows_dir = None
-                app.SELECTED_ROOT = -1
-
-        series = []
-        if app.ANIME_SPLIT_HOME:
-            anime = []
-            for show in app.showList:
-                if shows_dir and not show._location.startswith(shows_dir):
-                    continue
-                if show.is_anime:
-                    anime.append(show)
-                else:
-                    series.append(show)
-
-            show_lists = [[order, {'Series': series, 'Anime': anime}[order]] for order in app.SHOW_LIST_ORDER]
-        else:
-            for show in app.showList:
-                if shows_dir and not show._location.startswith(shows_dir):
-                    continue
-                series.append(show)
-            show_lists = [['Series', series]]
+        """
+        Render the home page.
 
-        stats = self.show_statistics()
-        return t.render(show_lists=show_lists, show_stat=stats[0],
-                        max_download_count=stats[1], controller='home', action='index')
+        [Converted to VueRouter]
+        """
+        t = PageTemplate(rh=self, filename='index.mako')
+        return t.render()
 
     @staticmethod
     def show_statistics():

medusa/tv/series.py

@@ -235,6 +235,7 @@ def __init__(self, indexer, indexerid, lang='', quality=None,
         self.default_ep_status = SKIPPED
         self._location = ''
         self.episodes = {}
+        self.prev_aired = ''
         self.next_aired = ''
         self.release_groups = None
         self.exceptions = set()
@@ -555,9 +556,17 @@ def last_update_indexer(self):
         epoch_date = update_date - datetime.date.fromtimestamp(0)
         return int(epoch_date.total_seconds())
 
+    @property
+    def prev_airdate(self):
+        """Return last aired episode airdate."""
+        return (
+            sbdatetime.convert_to_setting(network_timezones.parse_date_time(self.prev_aired, self.airs, self.network))
+            if try_int(self.prev_aired, 1) > MILLIS_YEAR_1900 else None
+        )
+
     @property
     def next_airdate(self):
-        """Return next airdate."""
+        """Return next aired episode airdate."""
         return (
             sbdatetime.convert_to_setting(network_timezones.parse_date_time(self.next_aired, self.airs, self.network))
             if try_int(self.next_aired, 1) > MILLIS_YEAR_1900 else None
@@ -623,7 +632,7 @@ def aliases_to_json(self):
     @property
     def xem_numbering(self):
         """Return series episode xem numbering."""
-        return get_xem_numbering_for_show(self)
+        return get_xem_numbering_for_show(self, refresh_data=False)
 
     @property
     def xem_absolute_numbering(self):
@@ -1612,6 +1621,46 @@ def load_imdb_info(self):
         log.debug(u'{id}: Obtained info from IMDb: {imdb_info}',
                   {'id': self.series_id, 'imdb_info': self.imdb_info})
 
+    def prev_episode(self):
+        """Return the last aired episode air date.
+
+        :return:
+        :rtype: datetime.date
+        """
+        log.debug(u'{id}: Finding the episode which aired last', {'id': self.series_id})
+
+        main_db_con = db.DBConnection()
+        sql_results = main_db_con.select(
+            'SELECT '
+            '  airdate,'
+            '  season,'
+            '  episode '
+            'FROM '
+            '  tv_episodes '
+            'WHERE '
+            '  indexer = ?'
+            '  AND showid = ? '
+            '  AND airdate < ? '
+            '  AND status <> ? '
+            'ORDER BY'
+            '  airdate '
+            'DESC LIMIT 1',
+            [self.indexer, self.series_id, datetime.date.today().toordinal(), UNAIRED])
+
+        if sql_results is None or len(sql_results) == 0:
+            log.debug(u'{id}: Could not find a previous aired episode', {'id': self.series_id})
+            self.prev_aired = u''
+        else:
+            log.debug(
+                u'{id}: Found previous aired episode number {ep}', {
+                    'id': self.series_id,
+                    'ep': episode_num(sql_results[0]['season'], sql_results[0]['episode'])
+                }
+            )
+            self.prev_aired = sql_results[0]['airdate']
+
+        return self.prev_aired
+
     def next_episode(self):
         """Return the next episode air date.
 
@@ -1635,14 +1684,13 @@ def next_episode(self):
                 '  indexer = ?'
                 '  AND showid = ? '
                 '  AND airdate >= ? '
-                '  AND status IN (?,?) '
                 'ORDER BY'
                 '  airdate '
                 'ASC LIMIT 1',
-                [self.indexer, self.series_id, datetime.date.today().toordinal(), UNAIRED, WANTED])
+                [self.indexer, self.series_id, datetime.date.today().toordinal()])
 
             if sql_results is None or len(sql_results) == 0:
-                log.debug(u'{id}: No episode found... need to implement a show status',
+                log.debug(u'{id}: Could not find a next episode',
                           {'id': self.series_id})
                 self.next_aired = u''
             else:
@@ -2056,6 +2104,7 @@ def to_json(self, detailed=False, episodes=False):
         data['imdbInfo'] = {to_camel_case(k): v for k, v in viewitems(self.imdb_info)}
         data['year'] = {}
         data['year']['start'] = self.imdb_year or self.start_year
+        data['prevAirDate'] = self.prev_airdate.isoformat() if self.prev_airdate else None
         data['nextAirDate'] = self.next_airdate.isoformat() if self.next_airdate else None
         data['lastUpdate'] = datetime.date.fromordinal(self._last_update_indexer).isoformat()
         data['runtime'] = self.imdb_runtime or self.runtime
@@ -2097,6 +2146,9 @@ def to_json(self, detailed=False, episodes=False):
         data['config']['release']['requiredWordsExclude'] = bool(self.rls_require_exclude)
         data['config']['airdateOffset'] = self.airdate_offset
 
+        # Moved from detailed, as the home page, needs it to display the Xem icon.
+        data['xemNumbering'] = numbering_tuple_to_dict(self.xem_numbering)
+
         # These are for now considered anime-only options
         if self.is_anime:
             bw_list = self.release_groups or BlackAndWhiteList(self)
@@ -2112,7 +2164,6 @@ def to_json(self, detailed=False, episodes=False):
         if detailed:
             data['size'] = self.size
             data['showQueueStatus'] = self.show_queue_status
-            data['xemNumbering'] = numbering_tuple_to_dict(self.xem_numbering)
             data['sceneAbsoluteNumbering'] = dict_to_array(self.scene_absolute_numbering, key='absolute', value='sceneAbsolute')
             if self.is_scene:
                 data['xemAbsoluteNumbering'] = dict_to_array(self.xem_absolute_numbering, key='absolute', value='sceneAbsolute')

tests/apiv2/__init__.py

@@ -1,9 +1,23 @@
 # coding=utf-8
 """Api v2 tests."""
 from __future__ import unicode_literals
+
 import os
 import sys
 
+import six
+
+# Start event loop in python3
+if six.PY3:
+    import asyncio
+
+    # We need to set the WindowsSelectorEventLoop event loop on python 3 (3.8 and higher) running on windows
+    if sys.platform == 'win32':
+        try:
+            asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+        except AttributeError:  # Only available since Python 3.7.0
+            pass
+
 sys.path.insert(1, os.path.abspath(os.path.join(os.path.dirname(__file__), '../../lib')))
 sys.path.insert(1, os.path.abspath(os.path.join(os.path.dirname(__file__), '../../ext')))
 sys.path.insert(1, os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))