X-Git-Url: http://git.code-monkey.de/?p=plugin.video.netflix.git;a=blobdiff_plain;f=resources%2Flib%2FNavigation.py;h=db025988987ace9464430374689ba252d49421de;hp=c1e9397278dcd0fc97f22e8d839014c8ca281cb9;hb=69bafa3b4cb738c563f3cc8f7affe7b4fa8e91ea;hpb=85447a5fdfc7dff80e2272d77a5f94c0eddff1af

diff --git a/resources/lib/Navigation.py b/resources/lib/Navigation.py
index c1e9397..db02598 100644
--- a/resources/lib/Navigation.py
+++ b/resources/lib/Navigation.py
@@ -4,22 +4,19 @@
 # Created on: 13.01.2017
 
 import urllib
-import time
+import urllib2
+import json
 from urlparse import parse_qsl
-from utils import noop
-from utils import log
+from utils import noop, log
 
 class Navigation:
     """Routes to the correct subfolder, dispatches actions & acts as a controller for the Kodi view & the Netflix model"""
 
-    def __init__ (self, netflix_session, kodi_helper, library, base_url, log_fn=noop):
+    def __init__ (self, kodi_helper, library, base_url, log_fn=noop):
         """Takes the instances & configuration options needed to drive the plugin
 
         Parameters
         ----------
-        netflix_session : :obj:`NetflixSession`
-            instance of the NetflixSession class
-
         kodi_helper : :obj:`KodiHelper`
             instance of the KodiHelper class
 
@@ -32,12 +29,22 @@ class Navigation:
         log_fn : :obj:`fn`
              optional log function
         """
-        self.netflix_session = netflix_session
         self.kodi_helper = kodi_helper
         self.library = library
         self.base_url = base_url
         self.log = log_fn
 
+    def get_netflix_service_url (self):
+        return 'http://localhost:7005'
+
+    def call_netflix_service (self, params):
+        url_values = urllib.urlencode(params)
+        url = self.get_netflix_service_url()
+        full_url = url + '?' + url_values
+        data = urllib2.urlopen(full_url).read()
+        parsed_json = json.loads(data)
+        return parsed_json.get('result', None)
+
     @log
     def router (self, paramstring):
         """Route to the requested subfolder & dispatch actions along the way
@@ -51,13 +58,14 @@ class Navigation:
 
         # log out the user
         if 'action' in params.keys() and params['action'] == 'logout':
-            return self.netflix_session.logout()
+            return self.call_netflix_service({'method': 'logout'})
 
         # check login & try to relogin if necessary
         account = self.kodi_helper.get_credentials()
-        if self.netflix_session.is_logged_in(account=account) != True:
-            if self.establish_session(account=account) != True:
-                return self.kodi_helper.show_login_failed_notification()
+        if account['email'] != '' and account['password'] != '':
+            if self.call_netflix_service({'method': 'is_logged_in'}) != True:
+                if self.establish_session(account=account) != True:
+                    return self.kodi_helper.show_login_failed_notification()
 
         # check if we need to execute any actions before the actual routing
         # gives back a dict of options routes might need
@@ -68,7 +76,7 @@ class Navigation:
             return False
         if 'action' not in params.keys():
             # show the profiles
-            self.show_profiles()
+            return self.show_profiles()
         elif params['action'] == 'video_lists':
             # list lists that contain other lists (starting point with recommendations, search, etc.)
             return self.show_video_lists()
@@ -86,21 +94,24 @@ class Navigation:
             return self.rate_on_netflix(video_id=params['id'])
         elif params['action'] == 'remove_from_list':
             # removes a title from the users list on Netflix
+            self.kodi_helper.invalidate_memcache()
             return self.remove_from_list(video_id=params['id'])
         elif params['action'] == 'add_to_list':
             # adds a title to the users list on Netflix
+            self.kodi_helper.invalidate_memcache()
             return self.add_to_list(video_id=params['id'])
+        elif params['action'] == 'export':
+            # adds a title to the users list on Netflix
+            alt_title = self.kodi_helper.show_add_to_library_title_dialog(original_title=urllib.unquote(params['title']).decode('utf8'))
+            return self.export_to_library(video_id=params['id'], alt_title=alt_title)
+        elif params['action'] == 'remove':
+            # adds a title to the users list on Netflix
+            return self.remove_from_library(video_id=params['id'])
         elif params['action'] == 'user-items' and params['type'] != 'search':
             # display the lists (recommendations, genres, etc.)
             return self.show_user_list(type=params['type'])
         elif params['action'] == 'play_video':
-            # play a video, check for adult pin if needed
-            adult_pin = None
-            if self.check_for_adult_pin(params=params):
-                adult_pin = self.kodi_helper.show_adult_pin_dialog()
-                if self.netflix_session.send_adult_pin(adult_pin=adult_pin) != True:
-                    return self.kodi_helper.show_wrong_adult_pin_notification()
-            self.play_video(video_id=params['video_id'], start_offset=params['start_offset'])
+            self.play_video(video_id=params['video_id'], start_offset=params.get('start_offset', -1))
         elif params['action'] == 'user-items' and params['type'] == 'search':
             # if the user requested a search, ask for the term
             term = self.kodi_helper.show_search_term_dialog()
@@ -124,9 +135,10 @@ class Navigation:
             Offset to resume playback from (in seconds)
         """
         # widevine esn
-        esn = self.netflix_session.esn
+        esn = self.call_netflix_service({'method': 'get_esn'})
         return self.kodi_helper.play_item(esn=esn, video_id=video_id, start_offset=start_offset)
 
+    @log
     def show_search_results (self, term):
         """Display a list of search results
 
@@ -140,30 +152,10 @@ class Navigation:
         bool
             If no results are available
         """
-        has_search_results = False
-        search_results_raw = self.netflix_session.fetch_search_results(term=term)
-        # check for any errors
-        if self._is_dirty_response(response=search_results_raw):
-            return False
-
-        # determine if we found something
-        if 'search' in search_results_raw['value']:
-            for key in search_results_raw['value']['search'].keys():
-                if self.netflix_session._is_size_key(key=key) == False:
-                    has_search_results = search_results_raw['value']['search'][key]['titles']['length'] > 0
-
-        # display that we haven't found a thing
-        if has_search_results == False:
-            return self.kodi_helper.build_no_search_results_available(build_url=self.build_url, action='search')
-
-        # list the search results
-        search_results = self.netflix_session.parse_search_results(response_data=search_results_raw)
-        # add more menaingful data to the search results
-        raw_search_contents = self.netflix_session.fetch_video_list_information(video_ids=search_results.keys())
+        search_contents = self.call_netflix_service({'method': 'search', 'term': term})
         # check for any errors
-        if self._is_dirty_response(response=raw_search_contents):
+        if self._is_dirty_response(response=search_contents):
             return False
-        search_contents = self.netflix_session.parse_video_list(response_data=raw_search_contents)
         actions = {'movie': 'play_video', 'show': 'season_list'}
         return self.kodi_helper.build_search_result_listing(video_list=search_contents, actions=actions, build_url=self.build_url)
 
@@ -175,11 +167,10 @@ class Navigation:
         user_list_id : :obj:`str`
             Type of list to display
         """
-        video_list_ids_raw = self.netflix_session.fetch_video_list_ids()
+        video_list_ids = self.call_netflix_service({'method': 'fetch_video_list_ids', 'type': type})
         # check for any errors
-        if self._is_dirty_response(response=video_list_ids_raw):
+        if self._is_dirty_response(response=video_list_ids):
             return False
-        video_list_ids = self.netflix_session.parse_video_list_ids(response_data=video_list_ids_raw)
         return self.kodi_helper.build_user_sub_listing(video_list_ids=video_list_ids[type], type=type, action='video_list', build_url=self.build_url)
 
     def show_episode_list (self, season_id):
@@ -190,12 +181,16 @@ class Navigation:
         season_id : :obj:`str`
             ID of the season episodes should be displayed for
         """
-        raw_episode_list = self.netflix_session.fetch_episodes_by_season(season_id=season_id)
-        # check for any errors
-        if self._is_dirty_response(response=raw_episode_list):
-            return False
-        # parse the raw Netflix data
-        episode_list = self.netflix_session.parse_episodes_by_season(response_data=raw_episode_list)
+        cache_id = 'episodes_' + season_id
+        if self.kodi_helper.has_cached_item(cache_id=cache_id):
+            episode_list = self.kodi_helper.get_cached_item(cache_id=cache_id)
+        else:
+            episode_list = self.call_netflix_service({'method': 'fetch_episodes_by_season', 'season_id': season_id})
+            # check for any errors
+            if self._is_dirty_response(response=episode_list):
+                return False
+            # parse the raw Netflix data
+            self.kodi_helper.add_cached_item(cache_id=cache_id, contents=episode_list)
 
         # sort seasons by number (they´re coming back unsorted from the api)
         episodes_sorted = []
@@ -219,19 +214,23 @@ class Navigation:
         bool
             If no seasons are available
         """
-        season_list_raw = self.netflix_session.fetch_seasons_for_show(id=show_id);
-        # check for any errors
-        if self._is_dirty_response(response=season_list_raw):
-            return False
-        # check if we have sesons, announced shows that are not available yet have none
-        if 'seasons' not in season_list_raw['value']:
-            return self.kodi_helper.build_no_seasons_available()
-        # parse the seasons raw response from Netflix
-        season_list = self.netflix_session.parse_seasons(id=show_id, response_data=season_list_raw)
+        cache_id = 'season_' + show_id
+        if self.kodi_helper.has_cached_item(cache_id=cache_id):
+            season_list = self.kodi_helper.get_cached_item(cache_id=cache_id)
+        else:
+            season_list = self.call_netflix_service({'method': 'fetch_seasons_for_show', 'show_id': show_id})
+            # check for any errors
+            if self._is_dirty_response(response=season_list):
+                return False
+            # check if we have sesons, announced shows that are not available yet have none
+            if len(season_list) == 0:
+                return self.kodi_helper.build_no_seasons_available()
+            # parse the seasons raw response from Netflix
+            self.kodi_helper.add_cached_item(cache_id=cache_id, contents=season_list)
         # sort seasons by index by default (they´re coming back unsorted from the api)
         seasons_sorted = []
         for season_id in season_list:
-            seasons_sorted.append(int(season_list[season_id]['shortName'].split(' ')[1]))
+            seasons_sorted.append(int(season_list[season_id]['idx']))
             seasons_sorted.sort()
         return self.kodi_helper.build_season_listing(seasons_sorted=seasons_sorted, season_list=season_list, build_url=self.build_url)
 
@@ -246,34 +245,42 @@ class Navigation:
         type : :obj:`str`
             None or 'queue' f.e. when it´s a special video lists
         """
-        raw_video_list = self.netflix_session.fetch_video_list(list_id=video_list_id)
-        # check for any errors
-        if self._is_dirty_response(response=raw_video_list):
-            return False
-        # parse the video list ids
-        video_list = self.netflix_session.parse_video_list(response_data=raw_video_list)
+        if self.kodi_helper.has_cached_item(cache_id=video_list_id):
+            video_list = self.kodi_helper.get_cached_item(cache_id=video_list_id)
+        else:
+            video_list = self.call_netflix_service({'method': 'fetch_video_list', 'list_id': video_list_id})
+            # check for any errors
+            if self._is_dirty_response(response=video_list):
+                return False
+            # parse the video list ids
+            if len(video_list) > 0:
+                self.kodi_helper.add_cached_item(cache_id=video_list_id, contents=video_list)
         actions = {'movie': 'play_video', 'show': 'season_list'}
         return self.kodi_helper.build_video_listing(video_list=video_list, actions=actions, type=type, build_url=self.build_url)
 
     def show_video_lists (self):
         """List the users video lists (recommendations, my list, etc.)"""
-        # fetch video lists
-        raw_video_list_ids = self.netflix_session.fetch_video_list_ids()
-        # check for any errors
-        if self._is_dirty_response(response=raw_video_list_ids):
-            return False
-        # parse the video list ids
-        video_list_ids = self.netflix_session.parse_video_list_ids(response_data=raw_video_list_ids)
+        cache_id='main_menu'
+        if self.kodi_helper.has_cached_item(cache_id=cache_id):
+            video_list_ids = self.kodi_helper.get_cached_item(cache_id=cache_id)
+        else:
+            # fetch video lists
+            video_list_ids = self.call_netflix_service({'method': 'fetch_video_list_ids'})
+            # check for any errors
+            if self._is_dirty_response(response=video_list_ids):
+                return False
+            # parse the video list ids
+            self.kodi_helper.add_cached_item(cache_id=cache_id, contents=video_list_ids)
         # defines an order for the user list, as Netflix changes the order at every request
         user_list_order = ['queue', 'continueWatching', 'topTen', 'netflixOriginals', 'trendingNow', 'newRelease', 'popularTitles']
         # define where to route the user
         actions = {'recommendations': 'user-items', 'genres': 'user-items', 'search': 'user-items', 'default': 'video_list'}
         return self.kodi_helper.build_main_menu_listing(video_list_ids=video_list_ids, user_list_order=user_list_order, actions=actions, build_url=self.build_url)
 
+    @log
     def show_profiles (self):
         """List the profiles for the active account"""
-        self.netflix_session.refresh_session_data(account=self.kodi_helper.get_credentials())
-        profiles = self.netflix_session.profiles
+        profiles = self.call_netflix_service({'method': 'list_profiles'})
         return self.kodi_helper.build_profiles_listing(profiles=profiles, action='video_lists', build_url=self.build_url)
 
     @log
@@ -286,7 +293,7 @@ class Navigation:
             ID of the video list that should be displayed
         """
         rating = self.kodi_helper.show_rating_dialog()
-        return self.netflix_session.rate_video(video_id=video_id, rating=rating)
+        return self.call_netflix_service({'method': 'rate_video', 'video_id': video_id, 'rating': rating})
 
     @log
     def remove_from_list (self, video_id):
@@ -297,7 +304,7 @@ class Navigation:
         video_list_id : :obj:`str`
             ID of the video list that should be displayed
         """
-        self.netflix_session.remove_from_list(video_id=video_id)
+        self.call_netflix_service({'method': 'remove_from_list', 'video_id': video_id})
         return self.kodi_helper.refresh()
 
     @log
@@ -309,7 +316,57 @@ class Navigation:
         video_list_id : :obj:`str`
             ID of the video list that should be displayed
         """
-        self.netflix_session.add_to_list(video_id=video_id)
+        self.call_netflix_service({'method': 'add_to_list', 'video_id': video_id})
+        return self.kodi_helper.refresh()
+
+    @log
+    def export_to_library (self, video_id, alt_title):
+        """Adds an item to the local library
+
+        Parameters
+        ----------
+        video_id : :obj:`str`
+            ID of the movie or show
+
+        alt_title : :obj:`str`
+            Alternative title (for the folder written to disc)
+        """
+        metadata = self.call_netflix_service({'method': 'fetch_metadata', 'video_id': video_id})
+        # check for any errors
+        if self._is_dirty_response(response=metadata):
+            return False
+        video = metadata['video']
+
+        if video['type'] == 'movie':
+            self.library.add_movie(title=video['title'], alt_title=alt_title, year=video['year'], video_id=video_id, build_url=self.build_url)
+        if video['type'] == 'show':
+            episodes = []
+            for season in video['seasons']:
+                for episode in season['episodes']:
+                    episodes.append({'season': season['seq'], 'episode': episode['seq'], 'id': episode['id']})
+
+            self.library.add_show(title=video['title'], alt_title=alt_title, episodes=episodes, build_url=self.build_url)
+        return self.kodi_helper.refresh()
+
+    @log
+    def remove_from_library (self, video_id, season=None, episode=None):
+        """Removes an item from the local library
+
+        Parameters
+        ----------
+        video_id : :obj:`str`
+            ID of the movie or show
+        """
+        metadata = self.call_netflix_service({'method': 'fetch_metadata', 'video_id': video_id})
+        # check for any errors
+        if self._is_dirty_response(response=metadata):
+            return False
+        video = metadata['video']
+
+        if video['type'] == 'movie':
+            self.library.remove_movie(title=video['title'], year=video['year'])
+        if video['type'] == 'show':
+            self.library.remove_show(title=video['title'])
         return self.kodi_helper.refresh()
 
     @log
@@ -326,10 +383,8 @@ class Navigation:
         bool
             If we don't have an active session & the user couldn't be logged in
         """
-        if self.netflix_session.is_logged_in(account=account):
-            return True
-        else:
-            return self.netflix_session.login(account=account)
+        is_logged_in = self.call_netflix_service({'method': 'is_logged_in'})
+        return True if is_logged_in else self.call_netflix_service({'method': 'login'})
 
     @log
     def before_routing_action (self, params):
@@ -355,16 +410,19 @@ class Navigation:
         if credentials['email'] == '':
             email = self.kodi_helper.show_email_dialog()
             self.kodi_helper.set_setting(key='email', value=email)
+            credentials['email'] = email
         if credentials['password'] == '':
             password = self.kodi_helper.show_password_dialog()
             self.kodi_helper.set_setting(key='password', value=password)
+            credentials['password'] = password
         # persist & load main menu selection
         if 'type' in params:
             self.kodi_helper.set_main_menu_selection(type=params['type'])
         options['main_menu_selection'] = self.kodi_helper.get_main_menu_selection()
         # check and switch the profile if needed
         if self.check_for_designated_profile_change(params=params):
-            self.netflix_session.switch_profile(profile_id=params['profile_id'], account=credentials)
+            self.kodi_helper.invalidate_memcache()
+            self.call_netflix_service({'method': 'switch_profile', 'profile_id': params['profile_id']})
         # check login, in case of main menu
         if 'action' not in params:
             self.establish_session(account=credentials)
@@ -384,26 +442,12 @@ class Navigation:
             Profile should be switched or not
         """
         # check if we need to switch the user
-        if 'guid' not in self.netflix_session.user_data:
+        user_data = self.call_netflix_service({'method': 'get_user_data'})
+        if 'guid' not in user_data:
             return False
-        current_profile_id = self.netflix_session.user_data['guid']
+        current_profile_id = user_data['guid']
         return 'profile_id' in params and current_profile_id != params['profile_id']
 
-    def check_for_adult_pin (self, params):
-        """Checks if an adult pin is given in the query params
-
-        Parameters
-        ----------
-        params : :obj:`dict` of :obj:`str`
-            Url query params
-
-        Returns
-        -------
-        bool
-            Adult pin parameter exists or not
-        """
-        return (True, False)[params['pin'] == 'True']
-
     def parse_paramters (self, paramstring):
         """Tiny helper to convert a url paramstring into a dictionary
 
@@ -453,7 +497,9 @@ class Navigation:
             if self._is_expired_session(response=response):
                 if self.establish_session(account=self.kodi_helper.get_credentials()):
                     return True
-            self.log(msg='[ERROR]: ' + response['message'] + '::' + str(response['code']))
+            message = response['message'] if 'message' in response else ''
+            code = response['code'] if 'code' in response else ''
+            self.log(msg='[ERROR]: ' + message + '::' + str(code))
             return True
         return False