fix(http-service): Call HTTP service on 127.0.0.1 instead of localhost to get rid...
[plugin.video.netflix.git] / resources / lib / Navigation.py
1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3 # Module: Navigation
4 # Created on: 13.01.2017
5
6 import urllib
7 import urllib2
8 import json
9 from xbmcaddon import Addon
10 from urlparse import parse_qsl
11 from utils import noop, log
12
13 class Navigation:
14     """Routes to the correct subfolder, dispatches actions & acts as a controller for the Kodi view & the Netflix model"""
15
16     def __init__ (self, kodi_helper, library, base_url, log_fn=noop):
17         """Takes the instances & configuration options needed to drive the plugin
18
19         Parameters
20         ----------
21         kodi_helper : :obj:`KodiHelper`
22             instance of the KodiHelper class
23
24         library : :obj:`Library`
25             instance of the Library class
26
27         base_url : :obj:`str`
28             plugin base url
29
30         log_fn : :obj:`fn`
31              optional log function
32         """
33         self.kodi_helper = kodi_helper
34         self.library = library
35         self.base_url = base_url
36         self.log = log_fn
37
38     @log
39     def router (self, paramstring):
40         """Route to the requested subfolder & dispatch actions along the way
41
42         Parameters
43         ----------
44         paramstring : :obj:`str`
45             Url query params
46         """
47         params = self.parse_paramters(paramstring=paramstring)
48
49         # open foreign settings dialog
50         if 'mode' in params.keys() and params['mode'] == 'openSettings':
51             return self.open_settings(params['url'])
52
53         # log out the user
54         if 'action' in params.keys() and params['action'] == 'logout':
55             return self.call_netflix_service({'method': 'logout'})
56
57         # check login & try to relogin if necessary
58         account = self.kodi_helper.get_credentials()
59         if account['email'] != '' and account['password'] != '':
60             if self.call_netflix_service({'method': 'is_logged_in'}) != True:
61                 if self.establish_session(account=account) != True:
62                     return self.kodi_helper.show_login_failed_notification()
63
64         # check if we need to execute any actions before the actual routing
65         # gives back a dict of options routes might need
66         options = self.before_routing_action(params=params)
67
68         # check if one of the before routing options decided to killthe routing
69         if 'exit' in options:
70             return False
71         if 'action' not in params.keys():
72             # show the profiles
73             return self.show_profiles()
74         elif params['action'] == 'video_lists':
75             # list lists that contain other lists (starting point with recommendations, search, etc.)
76             return self.show_video_lists()
77         elif params['action'] == 'video_list':
78             # show a list of shows/movies
79             type = None if 'type' not in params.keys() else params['type']
80             return self.show_video_list(video_list_id=params['video_list_id'], type=type)
81         elif params['action'] == 'season_list':
82             # list of seasons for a show
83             return self.show_seasons(show_id=params['show_id'])
84         elif params['action'] == 'episode_list':
85             # list of episodes for a season
86             return self.show_episode_list(season_id=params['season_id'])
87         elif params['action'] == 'rating':
88             return self.rate_on_netflix(video_id=params['id'])
89         elif params['action'] == 'remove_from_list':
90             # removes a title from the users list on Netflix
91             self.kodi_helper.invalidate_memcache()
92             return self.remove_from_list(video_id=params['id'])
93         elif params['action'] == 'add_to_list':
94             # adds a title to the users list on Netflix
95             self.kodi_helper.invalidate_memcache()
96             return self.add_to_list(video_id=params['id'])
97         elif params['action'] == 'export':
98             # adds a title to the users list on Netflix
99             alt_title = self.kodi_helper.show_add_to_library_title_dialog(original_title=urllib.unquote(params['title']).decode('utf8'))
100             return self.export_to_library(video_id=params['id'], alt_title=alt_title)
101         elif params['action'] == 'remove':
102             # adds a title to the users list on Netflix
103             return self.remove_from_library(video_id=params['id'])
104         elif params['action'] == 'user-items' and params['type'] != 'search':
105             # display the lists (recommendations, genres, etc.)
106             return self.show_user_list(type=params['type'])
107         elif params['action'] == 'play_video':
108             self.play_video(video_id=params['video_id'], start_offset=params.get('start_offset', -1))
109         elif params['action'] == 'user-items' and params['type'] == 'search':
110             # if the user requested a search, ask for the term
111             term = self.kodi_helper.show_search_term_dialog()
112             return self.show_search_results(term=term)
113         else:
114             raise ValueError('Invalid paramstring: {0}!'.format(paramstring))
115         return True
116
117     @log
118     def play_video (self, video_id, start_offset):
119         """Starts video playback
120
121         Note: This is just a dummy, inputstream is needed to play the vids
122
123         Parameters
124         ----------
125         video_id : :obj:`str`
126             ID of the video that should be played
127
128         start_offset : :obj:`str`
129             Offset to resume playback from (in seconds)
130         """
131         esn = self.call_netflix_service({'method': 'get_esn'})
132         return self.kodi_helper.play_item(esn=esn, video_id=video_id, start_offset=start_offset)
133
134     @log
135     def show_search_results (self, term):
136         """Display a list of search results
137
138         Parameters
139         ----------
140         term : :obj:`str`
141             String to lookup
142
143         Returns
144         -------
145         bool
146             If no results are available
147         """
148         user_data = self.call_netflix_service({'method': 'get_user_data'})
149         search_contents = self.call_netflix_service({'method': 'search', 'term': term, 'guid': user_data['guid'], 'cache': True})
150         # check for any errors
151         if self._is_dirty_response(response=search_contents):
152             return False
153         actions = {'movie': 'play_video', 'show': 'season_list'}
154         return self.kodi_helper.build_search_result_listing(video_list=search_contents, actions=actions, build_url=self.build_url)
155
156     def show_user_list (self, type):
157         """List the users lists for shows/movies for recommendations/genres based on the given type
158
159         Parameters
160         ----------
161         user_list_id : :obj:`str`
162             Type of list to display
163         """
164         # determine if we´re in kids mode
165         user_data = self.call_netflix_service({'method': 'get_user_data'})
166         video_list_ids = self.call_netflix_service({'method': 'fetch_video_list_ids', 'guid': user_data['guid'], 'cache': True})
167         # check for any errors
168         if self._is_dirty_response(response=video_list_ids):
169             return False
170         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)
171
172     def show_episode_list (self, season_id):
173         """Lists all episodes for a given season
174
175         Parameters
176         ----------
177         season_id : :obj:`str`
178             ID of the season episodes should be displayed for
179         """
180         user_data = self.call_netflix_service({'method': 'get_user_data'})
181         episode_list = self.call_netflix_service({'method': 'fetch_episodes_by_season', 'season_id': season_id, 'guid': user_data['guid'], 'cache': True})
182         # check for any errors
183         if self._is_dirty_response(response=episode_list):
184             return False
185         # sort seasons by number (they´re coming back unsorted from the api)
186         episodes_sorted = []
187         for episode_id in episode_list:
188             episodes_sorted.append(int(episode_list[episode_id]['episode']))
189             episodes_sorted.sort()
190
191         # list the episodes
192         return self.kodi_helper.build_episode_listing(episodes_sorted=episodes_sorted, episode_list=episode_list, build_url=self.build_url)
193
194     def show_seasons (self, show_id):
195         """Lists all seasons for a given show
196
197         Parameters
198         ----------
199         show_id : :obj:`str`
200             ID of the show seasons should be displayed for
201
202         Returns
203         -------
204         bool
205             If no seasons are available
206         """
207         user_data = self.call_netflix_service({'method': 'get_user_data'})
208         season_list = self.call_netflix_service({'method': 'fetch_seasons_for_show', 'show_id': show_id, 'guid': user_data['guid'], 'cache': True})
209         # check for any errors
210         if self._is_dirty_response(response=season_list):
211             return False
212         # check if we have sesons, announced shows that are not available yet have none
213         if len(season_list) == 0:
214             return self.kodi_helper.build_no_seasons_available()
215         # sort seasons by index by default (they´re coming back unsorted from the api)
216         seasons_sorted = []
217         for season_id in season_list:
218             seasons_sorted.append(int(season_list[season_id]['idx']))
219             seasons_sorted.sort()
220         return self.kodi_helper.build_season_listing(seasons_sorted=seasons_sorted, season_list=season_list, build_url=self.build_url)
221
222     def show_video_list (self, video_list_id, type):
223         """List shows/movies based on the given video list id
224
225         Parameters
226         ----------
227         video_list_id : :obj:`str`
228             ID of the video list that should be displayed
229
230         type : :obj:`str`
231             None or 'queue' f.e. when it´s a special video lists
232         """
233         user_data = self.call_netflix_service({'method': 'get_user_data'})
234         video_list = self.call_netflix_service({'method': 'fetch_video_list', 'list_id': video_list_id, 'guid': user_data['guid'] ,'cache': True})
235         # check for any errors
236         if self._is_dirty_response(response=video_list):
237             return False
238         actions = {'movie': 'play_video', 'show': 'season_list'}
239         return self.kodi_helper.build_video_listing(video_list=video_list, actions=actions, type=type, build_url=self.build_url)
240
241     def show_video_lists (self):
242         """List the users video lists (recommendations, my list, etc.)"""
243         user_data = self.call_netflix_service({'method': 'get_user_data'})
244         video_list_ids = self.call_netflix_service({'method': 'fetch_video_list_ids', 'guid': user_data['guid'], 'cache': True})
245         # check for any errors
246         if self._is_dirty_response(response=video_list_ids):
247             return False
248         # defines an order for the user list, as Netflix changes the order at every request
249         user_list_order = ['queue', 'continueWatching', 'topTen', 'netflixOriginals', 'trendingNow', 'newRelease', 'popularTitles']
250         # define where to route the user
251         actions = {'recommendations': 'user-items', 'genres': 'user-items', 'search': 'user-items', 'default': 'video_list'}
252         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)
253
254     @log
255     def show_profiles (self):
256         """List the profiles for the active account"""
257         profiles = self.call_netflix_service({'method': 'list_profiles'})
258         if len(profiles) == 0:
259             return self.kodi_helper.show_login_failed_notification()
260         return self.kodi_helper.build_profiles_listing(profiles=profiles, action='video_lists', build_url=self.build_url)
261
262     @log
263     def rate_on_netflix (self, video_id):
264         """Rate a show/movie/season/episode on Netflix
265
266         Parameters
267         ----------
268         video_list_id : :obj:`str`
269             ID of the video list that should be displayed
270         """
271         rating = self.kodi_helper.show_rating_dialog()
272         return self.call_netflix_service({'method': 'rate_video', 'video_id': video_id, 'rating': rating})
273
274     @log
275     def remove_from_list (self, video_id):
276         """Remove an item from 'My List' & refresh the view
277
278         Parameters
279         ----------
280         video_list_id : :obj:`str`
281             ID of the video list that should be displayed
282         """
283         self.call_netflix_service({'method': 'remove_from_list', 'video_id': video_id})
284         return self.kodi_helper.refresh()
285
286     @log
287     def add_to_list (self, video_id):
288         """Add an item to 'My List' & refresh the view
289
290         Parameters
291         ----------
292         video_list_id : :obj:`str`
293             ID of the video list that should be displayed
294         """
295         self.call_netflix_service({'method': 'add_to_list', 'video_id': video_id})
296         return self.kodi_helper.refresh()
297
298     @log
299     def export_to_library (self, video_id, alt_title):
300         """Adds an item to the local library
301
302         Parameters
303         ----------
304         video_id : :obj:`str`
305             ID of the movie or show
306
307         alt_title : :obj:`str`
308             Alternative title (for the folder written to disc)
309         """
310         metadata = self.call_netflix_service({'method': 'fetch_metadata', 'video_id': video_id})
311         # check for any errors
312         if self._is_dirty_response(response=metadata):
313             return False
314         video = metadata['video']
315
316         if video['type'] == 'movie':
317             self.library.add_movie(title=video['title'], alt_title=alt_title, year=video['year'], video_id=video_id, build_url=self.build_url)
318         if video['type'] == 'show':
319             episodes = []
320             for season in video['seasons']:
321                 for episode in season['episodes']:
322                     episodes.append({'season': season['seq'], 'episode': episode['seq'], 'id': episode['id']})
323
324             self.library.add_show(title=video['title'], alt_title=alt_title, episodes=episodes, build_url=self.build_url)
325         return self.kodi_helper.refresh()
326
327     @log
328     def remove_from_library (self, video_id, season=None, episode=None):
329         """Removes an item from the local library
330
331         Parameters
332         ----------
333         video_id : :obj:`str`
334             ID of the movie or show
335         """
336         metadata = self.call_netflix_service({'method': 'fetch_metadata', 'video_id': video_id})
337         # check for any errors
338         if self._is_dirty_response(response=metadata):
339             return False
340         video = metadata['video']
341
342         if video['type'] == 'movie':
343             self.library.remove_movie(title=video['title'], year=video['year'])
344         if video['type'] == 'show':
345             self.library.remove_show(title=video['title'])
346         return self.kodi_helper.refresh()
347
348     @log
349     def establish_session(self, account):
350         """Checks if we have an cookie with an active sessions, otherwise tries to login the user
351
352         Parameters
353         ----------
354         account : :obj:`dict` of :obj:`str`
355             Dict containing an email & a password property
356
357         Returns
358         -------
359         bool
360             If we don't have an active session & the user couldn't be logged in
361         """
362         is_logged_in = self.call_netflix_service({'method': 'is_logged_in'})
363         return True if is_logged_in else self.call_netflix_service({'method': 'login', 'email': account['email'], 'password': account['password']})
364
365     @log
366     def before_routing_action (self, params):
367         """Executes actions before the actual routing takes place:
368
369             - Check if account data has been stored, if not, asks for it
370             - Check if the profile should be changed (and changes if so)
371             - Establishes a session if no action route is given
372
373         Parameters
374         ----------
375         params : :obj:`dict` of :obj:`str`
376             Url query params
377
378         Returns
379         -------
380         :obj:`dict` of :obj:`str`
381             Options that can be provided by this hook & used later in the routing process
382         """
383         options = {}
384         credentials = self.kodi_helper.get_credentials()
385         # check if we have user settings, if not, set em
386         if credentials['email'] == '':
387             email = self.kodi_helper.show_email_dialog()
388             self.kodi_helper.set_setting(key='email', value=email)
389             credentials['email'] = email
390         if credentials['password'] == '':
391             password = self.kodi_helper.show_password_dialog()
392             self.kodi_helper.set_setting(key='password', value=password)
393             credentials['password'] = password
394         # persist & load main menu selection
395         if 'type' in params:
396             self.kodi_helper.set_main_menu_selection(type=params['type'])
397         options['main_menu_selection'] = self.kodi_helper.get_main_menu_selection()
398         # check and switch the profile if needed
399         if self.check_for_designated_profile_change(params=params):
400             self.kodi_helper.invalidate_memcache()
401             profile_id = params.get('profile_id', None)
402             if profile_id == None:
403                 user_data = self.call_netflix_service({'method': 'get_user_data'})
404                 profile_id = user_data['guid']
405             self.call_netflix_service({'method': 'switch_profile', 'profile_id': profile_id})
406         # check login, in case of main menu
407         if 'action' not in params:
408             self.establish_session(account=credentials)
409         return options
410
411     def check_for_designated_profile_change (self, params):
412         """Checks if the profile needs to be switched
413
414         Parameters
415         ----------
416         params : :obj:`dict` of :obj:`str`
417             Url query params
418
419         Returns
420         -------
421         bool
422             Profile should be switched or not
423         """
424         # check if we need to switch the user
425         user_data = self.call_netflix_service({'method': 'get_user_data'})
426         profiles = self.call_netflix_service({'method': 'list_profiles'})
427         if 'guid' not in user_data:
428             return False
429         current_profile_id = user_data['guid']
430         if profiles.get(current_profile_id).get('isKids', False) == True:
431             return True
432         return 'profile_id' in params and current_profile_id != params['profile_id']
433
434     def parse_paramters (self, paramstring):
435         """Tiny helper to convert a url paramstring into a dictionary
436
437         Parameters
438         ----------
439         paramstring : :obj:`str`
440             Url query params (in url string notation)
441
442         Returns
443         -------
444         :obj:`dict` of :obj:`str`
445             Url query params (as a dictionary)
446         """
447         return dict(parse_qsl(paramstring))
448
449     def _is_expired_session (self, response):
450         """Checks if a response error is based on an invalid session
451
452         Parameters
453         ----------
454         response : :obj:`dict` of :obj:`str`
455             Error response object
456
457         Returns
458         -------
459         bool
460             Error is based on an invalid session
461         """
462         return 'error' in response and 'code' in response and str(response['code']) == '401'
463
464     def _is_dirty_response (self, response):
465         """Checks if a response contains an error & if the error is based on an invalid session, it tries a relogin
466
467         Parameters
468         ----------
469         response : :obj:`dict` of :obj:`str`
470             Success response object or Error response object
471
472         Returns
473         -------
474         bool
475             Response contains error or not
476         """
477         # check for any errors
478         if 'error' in response:
479             # check if we do not have a valid session, in case that happens: (re)login
480             if self._is_expired_session(response=response):
481                 if self.establish_session(account=self.kodi_helper.get_credentials()):
482                     return True
483             message = response['message'] if 'message' in response else ''
484             code = response['code'] if 'code' in response else ''
485             self.log(msg='[ERROR]: ' + message + '::' + str(code))
486             return True
487         return False
488
489     def build_url(self, query):
490         """Tiny helper to transform a dict into a url + querystring
491
492         Parameters
493         ----------
494         query : :obj:`dict` of  :obj:`str`
495             List of paramters to be url encoded
496
497         Returns
498         -------
499         str
500             Url + querystring based on the param
501         """
502         return self.base_url + '?' + urllib.urlencode(query)
503
504     def get_netflix_service_url (self):
505         """Returns URL & Port of the internal Netflix HTTP Proxy service
506
507         Returns
508         -------
509         str
510             Url + Port
511         """
512         return 'http://127.0.0.1:' + str(self.kodi_helper.addon.getSetting('netflix_service_port'))
513
514     def call_netflix_service (self, params):
515         """Makes a GET request to the internal Netflix HTTP proxy and returns the result
516
517         Parameters
518         ----------
519         params : :obj:`dict` of  :obj:`str`
520             List of paramters to be url encoded
521
522         Returns
523         -------
524         :obj:`dict`
525             Netflix Service RPC result
526         """
527         url_values = urllib.urlencode(params)
528         # check for cached items
529         if self.kodi_helper.has_cached_item(cache_id=url_values) and params.get('cache', False) == True:
530             self.log(msg='Fetching item from cache: (cache_id=' + url_values + ')')
531             return self.kodi_helper.get_cached_item(cache_id=url_values)
532         url = self.get_netflix_service_url()
533         full_url = url + '?' + url_values
534         data = urllib2.urlopen(full_url).read()
535         parsed_json = json.loads(data)
536         result = parsed_json.get('result', None)
537         if params.get('cache', False) == True:
538             self.log(msg='Adding item to cache: (cache_id=' + url_values + ')')
539             self.kodi_helper.add_cached_item(cache_id=url_values, contents=result)
540         return result
541
542     def open_settings(self, url):
543         """Opens a foreign settings dialog"""
544         is_addon = self.kodi_helper.get_inputstream_addon()
545         url = is_addon if url == 'is' else url
546         return Addon(url).openSettings()