コード例 #1
0
    def open_season_info(self, prev_window=None, tvshow_id=None,
                         season=None, tvshow=None, dbid=None):
        """
        open season info, deal with window stack
        needs *season AND (*tvshow_id OR *tvshow)
        """
        xbmc.executebuiltin("ActivateWindow(busydialog)")
        from dialogs import DialogSeasonInfo
        dbid = int(dbid) if dbid and int(dbid) > 0 else None
        if not tvshow_id:
            params = {"query": tvshow,
                      "language": SETTING("language")}
            response = TheMovieDB.get_data(url="search/tv",
                                           params=params,
                                           cache_days=30)
            if response["results"]:
                tvshow_id = str(response['results'][0]['id'])
            else:
                params = {"query": re.sub('\(.*?\)', '', tvshow),
                          "language": SETTING("language")}
                response = TheMovieDB.get_data(url="search/tv",
                                               params=params,
                                               cache_days=30)
                if response["results"]:
                    tvshow_id = str(response['results'][0]['id'])

        season_class = DialogSeasonInfo.get_window(self.window_type)
        dialog = season_class(INFO_DIALOG_FILE,
                              ADDON_PATH,
                              id=tvshow_id,
                              season=season,
                              dbid=dbid)
        xbmc.executebuiltin("Dialog.Close(busydialog)")
        self.open_dialog(dialog, prev_window)
コード例 #2
0
    def open_season_info(self, prev_window=None, tvshow_id=None,
                         season=None, tvshow=None, dbid=None):
        """
        open season info, deal with window stack
        needs *season AND (*tvshow_id OR *tvshow)
        """
        self.show_busy()
        from dialogs import DialogSeasonInfo
        dbid = int(dbid) if dbid and int(dbid) > 0 else None
        if not tvshow_id:
            params = {"query": tvshow,
                      "language": addon.setting("language")}
            response = TheMovieDB.get_data(url="search/tv",
                                           params=params,
                                           cache_days=30)
            if response["results"]:
                tvshow_id = str(response['results'][0]['id'])
            else:
                params = {"query": re.sub('\(.*?\)', '', tvshow),
                          "language": addon.setting("language")}
                response = TheMovieDB.get_data(url="search/tv",
                                               params=params,
                                               cache_days=30)
                if response["results"]:
                    tvshow_id = str(response['results'][0]['id'])

        season_class = DialogSeasonInfo.get_window(windows.DialogXML)
        dialog = season_class(INFO_XML,
                              addon.PATH,
                              id=tvshow_id,
                              season=season,
                              dbid=dbid)
        self.hide_busy()
        self.open_dialog(dialog, prev_window)
コード例 #3
0
 def open_tvshow_info(self,
                      tmdb_id=None,
                      dbid=None,
                      tvdb_id=None,
                      imdb_id=None,
                      name=None):
     """
     open tvshow info, deal with window stack
     """
     busy.show_busy()
     dbid = int(dbid) if dbid and int(dbid) > 0 else None
     from dialogs.DialogTVShowInfo import DialogTVShowInfo
     if tmdb_id:
         pass
     elif tvdb_id:
         tmdb_id = tmdb.get_show_tmdb_id(tvdb_id)
     elif imdb_id:
         tmdb_id = tmdb.get_show_tmdb_id(tvdb_id=imdb_id, source="imdb_id")
     elif dbid:
         tvdb_id = local_db.get_imdb_id(media_type="tvshow", dbid=dbid)
         if tvdb_id:
             tmdb_id = tmdb.get_show_tmdb_id(tvdb_id)
     elif name:
         tmdb_id = tmdb.search_media(media_name=name,
                                     year="",
                                     media_type="tv")
     dialog = DialogTVShowInfo(INFO_XML,
                               addon.PATH,
                               tmdb_id=tmdb_id,
                               dbid=dbid)
     busy.hide_busy()
     self.open_infodialog(dialog)
コード例 #4
0
 def open_tvshow_info(self, prev_window=None, tmdb_id=None, dbid=None,
                      tvdb_id=None, imdb_id=None, name=None):
     """
     open tvshow info, deal with window stack
     """
     xbmc.executebuiltin("ActivateWindow(busydialog)")
     dbid = int(dbid) if dbid and int(dbid) > 0 else None
     from dialogs import DialogTVShowInfo
     if tmdb_id:
         pass
     elif tvdb_id:
         tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id)
     elif imdb_id:
         tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id=imdb_id,
                                               source="imdb_id")
     elif dbid:
         tvdb_id = local_db.get_imdb_id(media_type="tvshow",
                                        dbid=dbid)
         if tvdb_id:
             tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id)
     elif name:
         tmdb_id = TheMovieDB.search_media(media_name=name,
                                           year="",
                                           media_type="tv")
     tvshow_class = DialogTVShowInfo.get_window(self.window_type)
     dialog = tvshow_class(INFO_DIALOG_FILE,
                           ADDON_PATH,
                           tmdb_id=tmdb_id,
                           dbid=dbid)
     xbmc.executebuiltin("Dialog.Close(busydialog)")
     self.open_dialog(dialog, prev_window)
コード例 #5
0
ファイル: default.py プロジェクト: kens13/Kens13_Repo
def get_media_meta_movie_id():
    global _year_, _media_type_
    if _title_ == "":
        return ""
    params = {"query": _title_, "language": "ru", "include_adult": True}
    if _year_ != "":
        params["year"] = int(_year_)
    try:
        response = tmdb.get_data(url="search/%s" % (get_media_category()),
                                 params=params,
                                 cache_days=1)
    except:
        try:
            params = {k: encode_(v) for k, v in params.iteritems() if v}
            xbmc.log("url=" +
                     ("search/%s?%s&" %
                      (get_media_category(), urllib.urlencode(params))))
            response = tmdb.get_tmdb_data(
                url="search/%s?%s&" %
                (get_media_category(), urllib.urlencode(params)),
                cache_days=1)
        except:
            return None
    if response and (not (response == "Empty")):
        if len(response['results']) > 0:
            return select_media(response["results"])
        else:
            return None
    else:
        return None
コード例 #6
0
    def open_season_info(self, tvshow_id=None, season=None, tvshow=None, dbid=None):
        """
        open season info, deal with window stack
        needs *season AND (*tvshow_id OR *tvshow)
        """
        busy.show_busy()
        from dialogs.DialogSeasonInfo import DialogSeasonInfo
        if not tvshow_id:
            params = {"query": tvshow,
                      "language": addon.setting("language")}
            response = tmdb.get_data(url="search/tv",
                                     params=params,
                                     cache_days=30)
            if response["results"]:
                tvshow_id = str(response['results'][0]['id'])
            else:
                params = {"query": re.sub('\(.*?\)', '', tvshow),
                          "language": addon.setting("language")}
                response = tmdb.get_data(url="search/tv",
                                         params=params,
                                         cache_days=30)
                if response["results"]:
                    tvshow_id = str(response['results'][0]['id'])

        dialog = DialogSeasonInfo(INFO_XML,
                                  addon.PATH,
                                  id=tvshow_id,
                                  season=max(0, season),
                                  dbid=int(dbid) if dbid and int(dbid) > 0 else None)
        busy.hide_busy()
        self.open_infodialog(dialog)
コード例 #7
0
 def open_tvshow_info(self,
                      prev_window=None,
                      tmdb_id=None,
                      dbid=None,
                      tvdb_id=None,
                      imdb_id=None,
                      name=None):
     """
     open tvshow info, deal with window stack
     """
     xbmc.executebuiltin("ActivateWindow(busydialog)")
     from dialogs import DialogTVShowInfo
     if tmdb_id:
         pass
     elif tvdb_id:
         tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id)
     elif imdb_id:
         tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id=imdb_id,
                                               source="imdb_id")
     elif dbid and (int(dbid) > 0):
         tvdb_id = local_db.get_imdb_id(media_type="tvshow", dbid=dbid)
         if tvdb_id:
             tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id)
     elif name:
         tmdb_id = TheMovieDB.search_media(media_name=name,
                                           year="",
                                           media_type="tv")
     tvshow_class = DialogTVShowInfo.get_window(self.window_type)
     dialog = tvshow_class(INFO_DIALOG_FILE,
                           ADDON_PATH,
                           tmdb_id=tmdb_id,
                           dbid=dbid)
     xbmc.executebuiltin("Dialog.Close(busydialog)")
     self.open_dialog(dialog, prev_window)
コード例 #8
0
 def open_tvshow_info(self, tmdb_id=None, dbid=None, tvdb_id=None, imdb_id=None, name=None):
     """
     open tvshow info, deal with window stack
     """
     busy.show_busy()
     dbid = int(dbid) if dbid and int(dbid) > 0 else None
     from dialogs.DialogTVShowInfo import DialogTVShowInfo
     if tmdb_id:
         pass
     elif tvdb_id:
         tmdb_id = tmdb.get_show_tmdb_id(tvdb_id)
     elif imdb_id:
         tmdb_id = tmdb.get_show_tmdb_id(tvdb_id=imdb_id,
                                         source="imdb_id")
     elif dbid:
         tvdb_id = local_db.get_imdb_id(media_type="tvshow",
                                        dbid=dbid)
         if tvdb_id:
             tmdb_id = tmdb.get_show_tmdb_id(tvdb_id)
     elif name:
         tmdb_id = tmdb.search_media(media_name=name,
                                     year="",
                                     media_type="tv")
     dialog = DialogTVShowInfo(INFO_XML,
                               addon.PATH,
                               tmdb_id=tmdb_id,
                               dbid=dbid)
     busy.hide_busy()
     self.open_infodialog(dialog)
コード例 #9
0
 def open_tvshow_info(self, prev_window=None, tmdb_id=None, dbid=None,
                      tvdb_id=None, imdb_id=None, name=None):
     """
     open tvshow info, deal with window stack
     """
     self.show_busy()
     dbid = int(dbid) if dbid and int(dbid) > 0 else None
     from dialogs import DialogTVShowInfo
     if tmdb_id:
         pass
     elif tvdb_id:
         tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id)
     elif imdb_id:
         tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id=imdb_id,
                                               source="imdb_id")
     elif dbid:
         tvdb_id = local_db.get_imdb_id(media_type="tvshow",
                                        dbid=dbid)
         if tvdb_id:
             tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id)
     elif name:
         tmdb_id = TheMovieDB.search_media(media_name=name,
                                           year="",
                                           media_type="tv")
     tvshow_class = DialogTVShowInfo.get_window(windows.DialogXML)
     dialog = tvshow_class(INFO_XML,
                           addon.PATH,
                           tmdb_id=tmdb_id,
                           dbid=dbid)
     self.hide_busy()
     self.open_dialog(dialog, prev_window)
コード例 #10
0
 def open_tvshow_info(self,
                      prev_window=None,
                      tmdb_id=None,
                      dbid=None,
                      tvdb_id=None,
                      imdb_id=None,
                      name=None):
     """
     open tvshow info, deal with window stack
     """
     self.show_busy()
     dbid = int(dbid) if dbid and int(dbid) > 0 else None
     from dialogs import DialogTVShowInfo
     if tmdb_id:
         pass
     elif tvdb_id:
         tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id)
     elif imdb_id:
         tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id=imdb_id,
                                               source="imdb_id")
     elif dbid:
         tvdb_id = local_db.get_imdb_id(media_type="tvshow", dbid=dbid)
         if tvdb_id:
             tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id)
     elif name:
         tmdb_id = TheMovieDB.search_media(media_name=name,
                                           year="",
                                           media_type="tv")
     tvshow_class = DialogTVShowInfo.get_window(windows.DialogXML)
     dialog = tvshow_class(INFO_XML, addon.PATH, tmdb_id=tmdb_id, dbid=dbid)
     self.hide_busy()
     self.open_dialog(dialog, prev_window)
コード例 #11
0
def handle_movies(results):
    movies = ItemList(content_type="movies")
    path = 'extendedinfo&&id=%s' if addon.bool_setting(
        "infodialog_onclick") else "playtrailer&&id=%s"
    for i in results:
        item = i["movie"] if "movie" in i else i
        trailer = "%syoutubevideo&&id=%s" % (
            PLUGIN_BASE, utils.extract_youtube_id(item["trailer"]))
        movie = VideoItem(label=item["title"],
                          path=PLUGIN_BASE + path % item["ids"]["tmdb"])
        movie.set_infos({
            'title':
            item["title"],
            'duration':
            item["runtime"] * 60 if item["runtime"] else "",
            'tagline':
            item["tagline"],
            'mediatype':
            "movie",
            'trailer':
            trailer,
            'year':
            item["year"],
            'mpaa':
            item["certification"],
            'plot':
            item["overview"],
            'imdbnumber':
            item["ids"]["imdb"],
            'premiered':
            item["released"],
            'rating':
            round(item["rating"], 1),
            'votes':
            item["votes"],
            'genre':
            " / ".join(item["genres"])
        })
        movie.set_properties({
            'id': item["ids"]["tmdb"],
            'imdb_id': item["ids"]["imdb"],
            'trakt_id': item["ids"]["trakt"],
            'watchers': item.get("watchers"),
            'language': item.get("language"),
            'homepage': item.get("homepage")
        })
        art_info = tmdb.get_movie(item["ids"]["tmdb"], light=True)
        movie.set_artwork(
            tmdb.get_image_urls(poster=art_info.get("poster_path"),
                                fanart=art_info.get("backdrop_path")))
        movies.append(movie)
    movies = local_db.merge_with_local(media_type="movie",
                                       items=movies,
                                       library_first=False)
    movies.set_sorts(["mpaa", "duration"])
    return movies
コード例 #12
0
def get_episodes(content):
    shows = ItemList(content_type="episodes")
    url = ""
    if content == "shows":
        url = 'calendars/shows/%s/14' % datetime.date.today()
    elif content == "premieres":
        url = 'calendars/shows/premieres/%s/14' % datetime.date.today()
    results = get_data(url=url,
                       params={"extended": "full"},
                       cache_days=0.3)
    count = 1
    if not results:
        return None
    for day in results.iteritems():
        for episode in day[1]:
            ep = episode["episode"]
            tv = episode["show"]
            title = ep["title"] if ep["title"] else ""
            label = u"{0} - {1}x{2}. {3}".format(tv["title"],
                                                 ep["season"],
                                                 ep["number"],
                                                 title)
            show = VideoItem(label=label,
                             path=PLUGIN_BASE + 'extendedtvinfo&&tvdb_id=%s' % tv["ids"]["tvdb"])
            show.set_infos({'title': title,
                            'aired': ep["first_aired"],
                            'season': ep["season"],
                            'episode': ep["number"],
                            'tvshowtitle': tv["title"],
                            'mediatype': "episode",
                            'year': tv.get("year"),
                            'duration': tv["runtime"] * 60 if tv["runtime"] else "",
                            'studio': tv["network"],
                            'plot': tv["overview"],
                            'country': tv["country"],
                            'status': tv["status"],
                            'trailer': tv["trailer"],
                            'imdbnumber': ep["ids"]["imdb"],
                            'rating': tv["rating"],
                            'genre': " / ".join(tv["genres"]),
                            'mpaa': tv["certification"]})
            show.set_properties({'tvdb_id': ep["ids"]["tvdb"],
                                 'id': ep["ids"]["tvdb"],
                                 'imdb_id': ep["ids"]["imdb"],
                                 'homepage': tv["homepage"]})
            if tv["ids"].get("tmdb"):
                art_info = tmdb.get_tvshow(tv["ids"]["tmdb"], light=True)
                show.set_artwork(tmdb.get_image_urls(poster=art_info.get("poster_path"),
                                                     fanart=art_info.get("backdrop_path")))
            shows.append(show)
            count += 1
            if count > 20:
                break
    return shows
コード例 #13
0
 def open_actor_info(self, prev_window=None, actor_id=None, name=None):
     """
     open actor info, deal with window stack
     """
     from dialogs import DialogActorInfo
     if not actor_id:
         name = name.split(" " + addon.LANG(20347) + " ")
         names = name[0].strip().split(" / ")
         if len(names) > 1:
             ret = xbmcgui.Dialog().select(heading=addon.LANG(32027),
                                           list=names)
             if ret == -1:
                 return None
             name = names[ret]
         else:
             name = names[0]
         self.show_busy()
         actor_info = TheMovieDB.get_person_info(name)
         if actor_info:
             actor_id = actor_info["id"]
         else:
             return None
     else:
         self.show_busy()
     actor_class = DialogActorInfo.get_window(windows.DialogXML)
     dialog = actor_class(ACTOR_XML, addon.PATH, id=actor_id)
     self.hide_busy()
     self.open_dialog(dialog, prev_window)
コード例 #14
0
 def open_episode_info(self,
                       prev_window=None,
                       tvshow_id=None,
                       season=None,
                       episode=None,
                       tvshow=None,
                       dbid=None):
     """
     open season info, deal with window stack
     needs (*tvshow_id OR *tvshow) AND *season AND *episode
     """
     from dialogs import DialogEpisodeInfo
     dbid = int(dbid) if dbid and int(dbid) > 0 else None
     ep_class = DialogEpisodeInfo.get_window(windows.DialogXML)
     if not tvshow_id and tvshow:
         tvshow_id = TheMovieDB.search_media(media_name=tvshow,
                                             media_type="tv",
                                             cache_days=7)
     dialog = ep_class(INFO_XML,
                       addon.PATH,
                       tvshow_id=tvshow_id,
                       season=season,
                       episode=episode,
                       dbid=dbid)
     self.open_dialog(dialog, prev_window)
コード例 #15
0
 def open_actor_info(self, prev_window=None, actor_id=None, name=None):
     """
     open actor info, deal with window stack
     """
     from dialogs import DialogActorInfo
     if not actor_id:
         name = name.split(" " + LANG(20347) + " ")
         names = name[0].strip().split(" / ")
         if len(names) > 1:
             ret = xbmcgui.Dialog().select(heading=LANG(32027),
                                           list=names)
             if ret == -1:
                 return None
             name = names[ret]
         else:
             name = names[0]
         xbmc.executebuiltin("ActivateWindow(busydialog)")
         actor_info = TheMovieDB.get_person_info(name)
         if actor_info:
             actor_id = actor_info["id"]
         else:
             return None
     else:
         xbmc.executebuiltin("ActivateWindow(busydialog)")
     actor_class = DialogActorInfo.get_window(self.window_type)
     dialog = actor_class(ACTOR_DIALOG_FILE,
                          ADDON_PATH,
                          id=actor_id)
     xbmc.executebuiltin("Dialog.Close(busydialog)")
     self.open_dialog(dialog, prev_window)
コード例 #16
0
 def open_actor_info(self, prev_window=None, actor_id=None, name=None):
     """
     open actor info, deal with window stack
     """
     from dialogs import DialogActorInfo
     if not actor_id:
         name = name.split(" " + addon.LANG(20347) + " ")
         names = name[0].strip().split(" / ")
         if len(names) > 1:
             ret = xbmcgui.Dialog().select(heading=addon.LANG(32027),
                                           list=names)
             if ret == -1:
                 return None
             name = names[ret]
         else:
             name = names[0]
         self.show_busy()
         actor_info = TheMovieDB.get_person_info(name)
         if actor_info:
             actor_id = actor_info["id"]
         else:
             return None
     else:
         self.show_busy()
     actor_class = DialogActorInfo.get_window(windows.DialogXML)
     dialog = actor_class(ACTOR_XML,
                          addon.PATH,
                          id=actor_id)
     self.hide_busy()
     self.open_dialog(dialog, prev_window)
コード例 #17
0
 def open_actor_info(self, actor_id=None, name=None):
     """
     open actor info, deal with window stack
     """
     from dialogs.DialogActorInfo import DialogActorInfo
     if not actor_id:
         name = name.split(" %s " % addon.LANG(20347))
         names = name[0].strip().split(" / ")
         if len(names) > 1:
             ret = xbmcgui.Dialog().select(heading=addon.LANG(32027),
                                           list=names)
             if ret == -1:
                 return None
             name = names[ret]
         else:
             name = names[0]
         busy.show_busy()
         actor_info = tmdb.get_person_info(name)
         if not actor_info:
             return None
         actor_id = actor_info["id"]
     else:
         busy.show_busy()
     dialog = DialogActorInfo(ACTOR_XML,
                              addon.PATH,
                              id=actor_id)
     busy.hide_busy()
     self.open_infodialog(dialog)
コード例 #18
0
 def open_episode_info(self,
                       prev_window=None,
                       tvshow_id=None,
                       season=None,
                       episode=None,
                       tvshow=None,
                       dbid=None):
     """
     open season info, deal with window stack
     needs (*tvshow_id OR *tvshow) AND *season AND *episode
     """
     from dialogs import DialogEpisodeInfo
     ep_class = DialogEpisodeInfo.get_window(self.window_type)
     if not tvshow_id and tvshow:
         params = {"query": tvshow, "language": SETTING("language")}
         response = TheMovieDB.get_data(url="search/tv",
                                        params=params,
                                        cache_days=30)
         if response["results"]:
             tvshow_id = str(response['results'][0]['id'])
     dialog = ep_class(INFO_DIALOG_FILE,
                       ADDON_PATH,
                       show_id=tvshow_id,
                       season=season,
                       episode=episode,
                       dbid=dbid)
     self.open_dialog(dialog, prev_window)
コード例 #19
0
 def open_actor_info(self, actor_id=None, name=None):
     """
     open actor info, deal with window stack
     """
     from dialogs.DialogActorInfo import DialogActorInfo
     if not actor_id:
         name = name.split(" %s " % addon.LANG(20347))
         names = name[0].strip().split(" / ")
         if len(names) > 1:
             ret = xbmcgui.Dialog().select(heading=addon.LANG(32027),
                                           list=names)
             if ret == -1:
                 return None
             name = names[ret]
         else:
             name = names[0]
         busy.show_busy()
         actor_info = tmdb.get_person_info(name)
         if not actor_info:
             return None
         actor_id = actor_info["id"]
     else:
         busy.show_busy()
     dialog = DialogActorInfo(ACTOR_XML, addon.PATH, id=actor_id)
     busy.hide_busy()
     self.open_infodialog(dialog)
コード例 #20
0
 def open_actor_info(self, prev_window=None, actor_id=None, name=None):
     """
     open actor info, deal with window stack
     """
     from dialogs import DialogActorInfo
     if not actor_id:
         name = name.decode("utf-8").split(" " + LANG(20347) + " ")
         names = name[0].strip().split(" / ")
         if len(names) > 1:
             ret = xbmcgui.Dialog().select(heading=LANG(32027), list=names)
             if ret == -1:
                 return None
             name = names[ret]
         else:
             name = names[0]
         xbmc.executebuiltin("ActivateWindow(busydialog)")
         actor_info = TheMovieDB.get_person_info(name)
         if actor_info:
             actor_id = actor_info["id"]
         else:
             return None
     else:
         xbmc.executebuiltin("ActivateWindow(busydialog)")
     actor_class = DialogActorInfo.get_window(self.window_type)
     dialog = actor_class(ACTOR_DIALOG_FILE, ADDON_PATH, id=actor_id)
     xbmc.executebuiltin("Dialog.Close(busydialog)")
     self.open_dialog(dialog, prev_window)
コード例 #21
0
def get_trakt_calendar_shows(content):
    cachedays = 99999
    shows = []
    url = ""
    if content == "shows":
        url = 'calendars/shows/%s/1?extended=full,images' % str(date.today() - timedelta(days=2))
    elif content == "premieres":
        url = 'calendars/shows/premieres/%s/1?extended=full,images' % str(date.today() - timedelta(days=8))
    try:
        results = get_JSON_response(url=BASE_URL + url,
                                    cache_days=0.5,
                                    folder="Trakt",
                                    headers=HEADERS)
    except:
        log("Error when fetching Trakt data from net")
        log("Json Query: " + url)
        results = None
    count = 1
    if not results:
        return None
    for day in results.iteritems():
        for episode in day[1]:
            if episode["show"]["ids"]["tvdb"] or episode["show"]["ids"]["tmdb"] or episode["show"]["ids"]["imdb"] or episode["show"]["ids"]["tvrage"]:
                images = tmdb.item_images("tv", tmdb_id=episode["show"]["ids"]["tmdb"], tvdb_id=episode["show"]["ids"]["tvdb"], imdb_id=episode["show"]["ids"]["imdb"], cache_time=cachedays)
                id = images[0]
                poster = images[1]
                fanart = images[2]
                show = {'title': "%s - %dx%d - %s" % (episode["show"]["title"], episode["episode"]["season"], episode["episode"]["number"], episode["episode"]["title"]),
                        'TVShowTitle': episode["show"]["title"],
                        'tvdb_id': episode["show"]["ids"]["tvdb"],
                        'id': episode["show"]["ids"]["tvdb"],
                        'imdb_id': episode["show"]["ids"]["imdb"],
                        'tmdb_id': episode["show"]["ids"]["tmdb"],
                        'trakt_id': episode["show"]["ids"]["trakt"],
                        'season': episode["episode"]["season"],
                        'episode': episode["episode"]["number"],
                        'path': 'plugin://script.vodextende/?info=extendedtvinfo&tvdb_id=%s' % episode["show"]["ids"]["tvdb"],
                        'Runtime': episode["show"]["runtime"] * 60,
                        'duration': episode["show"]["runtime"] * 60,
                        'duration(h)': format_time(episode["show"]["runtime"], "h"),
                        'duration(m)': format_time(episode["show"]["runtime"], "m"),
                        'year': fetch(episode["show"], "year"),
                        'Certification': episode["show"]["certification"],
                        'Studio': episode["show"]["network"],
                        'Plot': episode["show"]["overview"],
                        'genre': " / ".join(episode["show"]["genres"]),
                        'poster': poster,
                        'thumb': poster,
                        'fanart_small': fanart,
                        'fanart': fanart}
                shows.append(show)
                count += 1
                if count > 50:
                    break
        return shows
コード例 #22
0
def handle_tvshows(results):
    shows = ItemList(content_type="tvshows")
    for i in results:
        item = i["show"] if "show" in i else i
        airs = item.get("airs", {})
        show = VideoItem(label=item["title"],
                         path='%sextendedtvinfo&&tvdb_id=%s' % (PLUGIN_BASE, item['ids']["tvdb"]))
        show.set_infos({'mediatype': "tvshow",
                        'title': item["title"],
                        'duration': item["runtime"] * 60 if item["runtime"] else "",
                        'year': item["year"],
                        'premiered': item["first_aired"][:10],
                        'country': item["country"],
                        'rating': round(item["rating"], 1),
                        'votes': item["votes"],
                        'imdbnumber': item['ids']["imdb"],
                        'mpaa': item["certification"],
                        'trailer': item["trailer"],
                        'status': item.get("status"),
                        'studio': item["network"],
                        'genre': " / ".join(item["genres"]),
                        'plot': item["overview"]})
        show.set_properties({'id': item['ids']["tmdb"],
                             'tvdb_id': item['ids']["tvdb"],
                             'imdb_id': item['ids']["imdb"],
                             'trakt_id': item['ids']["trakt"],
                             'language': item["language"],
                             'aired_episodes': item["aired_episodes"],
                             'homepage': item["homepage"],
                             'airday': airs.get("day"),
                             'airshorttime': airs.get("time"),
                             'watchers': item.get("watchers")})
        art_info = tmdb.get_tvshow(item["ids"]["tmdb"], light=True)
        show.set_artwork(tmdb.get_image_urls(poster=art_info.get("poster_path"),
                                             fanart=art_info.get("backdrop_path")))
        shows.append(show)
    shows = local_db.merge_with_local(media_type="tvshow",
                                      items=shows,
                                      library_first=False)
    shows.set_sorts(["mpaa", "duration"])
    return shows
コード例 #23
0
 def onSettingsChanged(self):
     addon.reload_addon()
     username = addon.setting("tmdb_username")
     password = addon.setting("tmdb_password")
     if username and password:
         TheMovieDB.Login = TheMovieDB.LoginProvider(username=username,
                                                     password=password)
     if wm.active_dialog:
         wm.active_dialog.close()
         wm.active_dialog.logged_in = TheMovieDB.Login.check_login(
             cache_days=0)
         wm.active_dialog.doModal()
コード例 #24
0
    def open_season_info(self,
                         prev_window=None,
                         tvshow_id=None,
                         season=None,
                         tvshow=None,
                         dbid=None):
        """
        open season info, deal with window stack
        needs *season AND (*tvshow_id OR *tvshow)
        """
        self.show_busy()
        from dialogs import DialogSeasonInfo
        dbid = int(dbid) if dbid and int(dbid) > 0 else None
        if not tvshow_id:
            params = {"query": tvshow, "language": addon.setting("language")}
            response = TheMovieDB.get_data(url="search/tv",
                                           params=params,
                                           cache_days=30)
            if response["results"]:
                tvshow_id = str(response['results'][0]['id'])
            else:
                params = {
                    "query": re.sub('\(.*?\)', '', tvshow),
                    "language": addon.setting("language")
                }
                response = TheMovieDB.get_data(url="search/tv",
                                               params=params,
                                               cache_days=30)
                if response["results"]:
                    tvshow_id = str(response['results'][0]['id'])

        season_class = DialogSeasonInfo.get_window(windows.DialogXML)
        dialog = season_class(INFO_XML,
                              addon.PATH,
                              id=tvshow_id,
                              season=season,
                              dbid=dbid)
        self.hide_busy()
        self.open_dialog(dialog, prev_window)
コード例 #25
0
    def open_season_info(self,
                         prev_window=None,
                         tvshow_id=None,
                         season=None,
                         tvshow=None,
                         dbid=None):
        """
        open season info, deal with window stack
        needs *season AND (*tvshow_id OR *tvshow)
        """
        xbmc.executebuiltin("ActivateWindow(busydialog)")
        from dialogs import DialogSeasonInfo
        dbid = int(dbid) if dbid and int(dbid) > 0 else None
        if not tvshow_id:
            params = {"query": tvshow, "language": SETTING("language")}
            response = TheMovieDB.get_data(url="search/tv",
                                           params=params,
                                           cache_days=30)
            if response["results"]:
                tvshow_id = str(response['results'][0]['id'])
            else:
                params = {
                    "query": re.sub('\(.*?\)', '', tvshow),
                    "language": SETTING("language")
                }
                response = TheMovieDB.get_data(url="search/tv",
                                               params=params,
                                               cache_days=30)
                if response["results"]:
                    tvshow_id = str(response['results'][0]['id'])

        season_class = DialogSeasonInfo.get_window(self.window_type)
        dialog = season_class(INFO_DIALOG_FILE,
                              ADDON_PATH,
                              id=tvshow_id,
                              season=season,
                              dbid=dbid)
        xbmc.executebuiltin("Dialog.Close(busydialog)")
        self.open_dialog(dialog, prev_window)
コード例 #26
0
    def open_season_info(self,
                         tvshow_id=None,
                         season=None,
                         tvshow=None,
                         dbid=None):
        """
        open season info, deal with window stack
        needs *season AND (*tvshow_id OR *tvshow)
        """
        busy.show_busy()
        from dialogs.DialogSeasonInfo import DialogSeasonInfo
        if not tvshow_id:
            params = {"query": tvshow, "language": addon.setting("language")}
            response = tmdb.get_data(url="search/tv",
                                     params=params,
                                     cache_days=30)
            if response["results"]:
                tvshow_id = str(response['results'][0]['id'])
            else:
                params = {
                    "query": re.sub('\(.*?\)', '', tvshow),
                    "language": addon.setting("language")
                }
                response = tmdb.get_data(url="search/tv",
                                         params=params,
                                         cache_days=30)
                if response["results"]:
                    tvshow_id = str(response['results'][0]['id'])

        dialog = DialogSeasonInfo(
            INFO_XML,
            addon.PATH,
            id=tvshow_id,
            season=max(0, season),
            dbid=int(dbid) if dbid and int(dbid) > 0 else None)
        busy.hide_busy()
        self.open_infodialog(dialog)
コード例 #27
0
def handle_movies(results):
    movies = ItemList(content_type="movies")
    path = 'extendedinfo&&id=%s' if addon.bool_setting("infodialog_onclick") else "playtrailer&&id=%s"
    for i in results:
        item = i["movie"] if "movie" in i else i
        trailer = "%syoutubevideo&&id=%s" % (PLUGIN_BASE, utils.extract_youtube_id(item["trailer"]))
        movie = VideoItem(label=item["title"],
                          path=PLUGIN_BASE + path % item["ids"]["tmdb"])
        movie.set_infos({'title': item["title"],
                         'duration': item["runtime"] * 60 if item["runtime"] else "",
                         'tagline': item["tagline"],
                         'mediatype': "movie",
                         'trailer': trailer,
                         'year': item["year"],
                         'mpaa': item["certification"],
                         'plot': item["overview"],
                         'imdbnumber': item["ids"]["imdb"],
                         'premiered': item["released"],
                         'rating': round(item["rating"], 1),
                         'votes': item["votes"],
                         'genre': " / ".join(item["genres"])})
        movie.set_properties({'id': item["ids"]["tmdb"],
                              'imdb_id': item["ids"]["imdb"],
                              'trakt_id': item["ids"]["trakt"],
                              'watchers': item.get("watchers"),
                              'language': item.get("language"),
                              'homepage': item.get("homepage")})
        art_info = tmdb.get_movie(item["ids"]["tmdb"], light=True)
        movie.set_artwork(tmdb.get_image_urls(poster=art_info.get("poster_path"),
                                              fanart=art_info.get("backdrop_path")))
        movies.append(movie)
    movies = local_db.merge_with_local(media_type="movie",
                                       items=movies,
                                       library_first=False)
    movies.set_sorts(["mpaa", "duration"])
    return movies
コード例 #28
0
 def open_episode_info(self, tvshow_id=None, season=None, episode=None, tvshow=None, dbid=None):
     """
     open season info, deal with window stack
     needs (*tvshow_id OR *tvshow) AND *season AND *episode
     """
     from dialogs.DialogEpisodeInfo import DialogEpisodeInfo
     if not tvshow_id and tvshow:
         tvshow_id = tmdb.search_media(media_name=tvshow,
                                       media_type="tv",
                                       cache_days=7)
     dialog = DialogEpisodeInfo(INFO_XML,
                                addon.PATH,
                                tvshow_id=tvshow_id,
                                season=max(0, season),
                                episode=episode,
                                dbid=int(dbid) if dbid and int(dbid) > 0 else None)
     self.open_infodialog(dialog)
コード例 #29
0
 def open_movie_info(self, movie_id=None, dbid=None, name=None, imdb_id=None):
     """
     open movie info, deal with window stack
     """
     busy.show_busy()
     from dialogs.DialogMovieInfo import DialogMovieInfo
     dbid = int(dbid) if dbid and int(dbid) > 0 else None
     if not movie_id:
         movie_id = tmdb.get_movie_tmdb_id(imdb_id=imdb_id,
                                           dbid=dbid,
                                           name=name)
     dialog = DialogMovieInfo(INFO_XML,
                              addon.PATH,
                              id=movie_id,
                              dbid=dbid)
     busy.hide_busy()
     self.open_infodialog(dialog)
コード例 #30
0
 def open_movie_info(self,
                     movie_id=None,
                     dbid=None,
                     name=None,
                     imdb_id=None):
     """
     open movie info, deal with window stack
     """
     busy.show_busy()
     from dialogs.DialogMovieInfo import DialogMovieInfo
     dbid = int(dbid) if dbid and int(dbid) > 0 else None
     if not movie_id:
         movie_id = tmdb.get_movie_tmdb_id(imdb_id=imdb_id,
                                           dbid=dbid,
                                           name=name)
     dialog = DialogMovieInfo(INFO_XML, addon.PATH, id=movie_id, dbid=dbid)
     busy.hide_busy()
     self.open_infodialog(dialog)
コード例 #31
0
 def open_movie_info(self, prev_window=None, movie_id=None, dbid=None,
                     name=None, imdb_id=None):
     """
     open movie info, deal with window stack
     """
     xbmc.executebuiltin("ActivateWindow(busydialog)")
     from dialogs import DialogMovieInfo
     if not movie_id:
         movie_id = TheMovieDB.get_movie_tmdb_id(imdb_id=imdb_id,
                                                 dbid=dbid,
                                                 name=name)
     movie_class = DialogMovieInfo.get_window(self.window_type)
     dialog = movie_class(INFO_DIALOG_FILE,
                          ADDON_PATH,
                          id=movie_id,
                          dbid=dbid)
     xbmc.executebuiltin("Dialog.Close(busydialog)")
     self.open_dialog(dialog, prev_window)
コード例 #32
0
def handle_trakt_tvshows(results):
    shows = []
    for tvshow in results:
        airs = fetch(tvshow['show'], "airs")
        images = tmdb.item_images("tv", tmdb_id=tvshow['show']['ids']["tmdb"], tvdb_id=tvshow['show']['ids']["tvdb"], imdb_id=tvshow['show']['ids']["imdb"])
        id = images[0]
        poster = images[1]
        fanart = images[2]
        show = {'title': tvshow['show']["title"],
                'Label': tvshow['show']["title"],
                'TVShowTitle': tvshow['show']["title"],
                'Runtime': tvshow['show']["runtime"] * 60,
                'duration': tvshow['show']["runtime"] * 60,
                'duration(h)': format_time(tvshow['show']["runtime"], "h"),
                'duration(m)': format_time(tvshow['show']["runtime"], "m"),
                'Trailer': 'plugin://script.vodextende/?info=playtvtrailer&id=%s' % str(tvshow['show']['ids']["tmdb"]),
                'year': tvshow['show']["year"],
                'Status': fetch(tvshow['show'], "status"),
                'mpaa': tvshow['show']["certification"],
                'Studio': tvshow['show']["network"],
                'Plot': tvshow['show']["overview"],
                'id': id,
                'tvdb_id': tvshow['show']['ids']["tvdb"],
                'imdb_id': tvshow['show']['ids']["imdb"],
                'tmdb_id': tvshow['show']['ids']["tmdb"],
                'trakt_id': tvshow['show']['ids']["trakt"],
                'slug': tvshow['show']['ids']["slug"],
                'path': 'plugin://script.vodextende/?info=extendedtvinfo&id=%s' % str(tvshow['show']['ids']["tmdb"]),
                'AirDay': fetch(airs, "day"),
                'AirShortTime': fetch(airs, "time"),
                'Premiered': tvshow['show']["first_aired"][:10],
                'Country': tvshow['show']["country"],
                'Rating': round(tvshow['show']["rating"], 1),
                'Votes': tvshow['show']["votes"],
                'Watchers': fetch(tvshow, "watchers"),
                'genre': " / ".join(tvshow['show']["genres"]),
                'poster': poster,
                'thumb': poster,
                'fanart': fanart,
                'fanart_small': fanart}
        shows.append(show)
    shows = merge_with_local_tvshow_info(online_list=shows,
                                         library_first=False)
    return shows
コード例 #33
0
 def open_episode_info(self, prev_window=None, tvshow_id=None, season=None,
                       episode=None, tvshow=None, dbid=None):
     """
     open season info, deal with window stack
     needs (*tvshow_id OR *tvshow) AND *season AND *episode
     """
     from dialogs import DialogEpisodeInfo
     ep_class = DialogEpisodeInfo.get_window(self.window_type)
     if not tvshow_id and tvshow:
         tvshow_id = TheMovieDB.search_media(media_name=tvshow,
                                             media_type="tv",
                                             cache_days=7)
     dialog = ep_class(INFO_DIALOG_FILE,
                       ADDON_PATH,
                       show_id=tvshow_id,
                       season=season,
                       episode=episode,
                       dbid=dbid)
     self.open_dialog(dialog, prev_window)
コード例 #34
0
 def open_movie_info(self, prev_window=None, movie_id=None, dbid=None,
                     name=None, imdb_id=None):
     """
     open movie info, deal with window stack
     """
     self.show_busy()
     from dialogs import DialogMovieInfo
     dbid = int(dbid) if dbid and int(dbid) > 0 else None
     if not movie_id:
         movie_id = TheMovieDB.get_movie_tmdb_id(imdb_id=imdb_id,
                                                 dbid=dbid,
                                                 name=name)
     movie_class = DialogMovieInfo.get_window(windows.DialogXML)
     dialog = movie_class(INFO_XML,
                          addon.PATH,
                          id=movie_id,
                          dbid=dbid)
     self.hide_busy()
     self.open_dialog(dialog, prev_window)
コード例 #35
0
 def open_episode_info(self, prev_window=None, tvshow_id=None, season=None,
                       episode=None, tvshow=None, dbid=None):
     """
     open season info, deal with window stack
     needs (*tvshow_id OR *tvshow) AND *season AND *episode
     """
     from dialogs import DialogEpisodeInfo
     dbid = int(dbid) if dbid and int(dbid) > 0 else None
     ep_class = DialogEpisodeInfo.get_window(windows.DialogXML)
     if not tvshow_id and tvshow:
         tvshow_id = TheMovieDB.search_media(media_name=tvshow,
                                             media_type="tv",
                                             cache_days=7)
     dialog = ep_class(INFO_XML,
                       addon.PATH,
                       tvshow_id=tvshow_id,
                       season=season,
                       episode=episode,
                       dbid=dbid)
     self.open_dialog(dialog, prev_window)
コード例 #36
0
 def open_movie_info(self,
                     prev_window=None,
                     movie_id=None,
                     dbid=None,
                     name=None,
                     imdb_id=None):
     """
     open movie info, deal with window stack
     """
     self.show_busy()
     from dialogs import DialogMovieInfo
     dbid = int(dbid) if dbid and int(dbid) > 0 else None
     if not movie_id:
         movie_id = TheMovieDB.get_movie_tmdb_id(imdb_id=imdb_id,
                                                 dbid=dbid,
                                                 name=name)
     movie_class = DialogMovieInfo.get_window(windows.DialogXML)
     dialog = movie_class(INFO_XML, addon.PATH, id=movie_id, dbid=dbid)
     self.hide_busy()
     self.open_dialog(dialog, prev_window)
コード例 #37
0
 def open_movie_info(self,
                     prev_window=None,
                     movie_id=None,
                     dbid=None,
                     name=None,
                     imdb_id=None):
     """
     open movie info, deal with window stack
     """
     xbmc.executebuiltin("ActivateWindow(busydialog)")
     from dialogs import DialogMovieInfo
     if not movie_id:
         movie_id = TheMovieDB.get_movie_tmdb_id(imdb_id=imdb_id,
                                                 dbid=dbid,
                                                 name=name)
     movie_class = DialogMovieInfo.get_window(self.window_type)
     dialog = movie_class(INFO_DIALOG_FILE,
                          ADDON_PATH,
                          id=movie_id,
                          dbid=dbid)
     xbmc.executebuiltin("Dialog.Close(busydialog)")
     self.open_dialog(dialog, prev_window)
コード例 #38
0
def handle_trakt_movies(results):
    movies = []
    for movie in results:
        images = tmdb.item_images("movie", tmdb_id=movie["movie"]["ids"]["tmdb"], imdb_id=movie["movie"]["ids"]["tmdb"])
        id = images[0]
        poster = images[1]
        fanart = images[2]
        if "watchers" in movie:
            watchers = movie["watchers"]
        else: watchers = ""
        movie = {'title': movie["movie"]["title"],
                 'Runtime': movie["movie"]["runtime"] * 60,
                 'duration': movie["movie"]["runtime"] * 60,
                 'duration(h)': format_time(movie["movie"]["runtime"], "h"),
                 'duration(m)': format_time(movie["movie"]["runtime"], "m"),
                 'Tagline': movie["movie"]["tagline"],
                 'Trailer': 'plugin://script.vodextende/?info=playtrailer&id=%s' % str(movie["movie"]["ids"]["tmdb"]),
                 'year': movie["movie"]["year"],
                 'id': id,
                 'imdb_id': movie["movie"]["ids"]["imdb"],
                 'trakt_id': movie["movie"]["ids"]["trakt"],
                 'slug': movie["movie"]["ids"]["slug"],
                 'path': 'plugin://script.vodextende/?info=extendedinfo&id=%s' % str(movie["movie"]["ids"]["tmdb"]), 
                 'mpaa': movie["movie"]["certification"],
                 'Plot': movie["movie"]["overview"],
                 'Premiered': movie["movie"]["released"],
                 'Rating': round(movie["movie"]["rating"], 1),
                 'Votes': movie["movie"]["votes"],
                 'Watchers': watchers,
                 'genre': " / ".join(movie["movie"]["genres"]),
                 'poster': poster,
                 'thumb': poster,
                 'fanart': fanart,
                 'fanart_small': fanart}
        movies.append(movie)
    movies = merge_with_local_movie_info(online_list=movies,
                                         library_first=False)
    return movies
コード例 #39
0
 def open_episode_info(self,
                       tvshow_id=None,
                       season=None,
                       episode=None,
                       tvshow=None,
                       dbid=None):
     """
     open season info, deal with window stack
     needs (*tvshow_id OR *tvshow) AND *season AND *episode
     """
     from dialogs.DialogEpisodeInfo import DialogEpisodeInfo
     if not tvshow_id and tvshow:
         tvshow_id = tmdb.search_media(media_name=tvshow,
                                       media_type="tv",
                                       cache_days=7)
     dialog = DialogEpisodeInfo(
         INFO_XML,
         addon.PATH,
         tvshow_id=tvshow_id,
         season=max(0, season),
         episode=episode,
         dbid=int(dbid) if dbid and int(dbid) > 0 else None)
     self.open_infodialog(dialog)
コード例 #40
0
 def open_episode_info(self, prev_window=None, tvshow_id=None, season=None,
                       episode=None, tvshow=None, dbid=None):
     """
     open season info, deal with window stack
     needs (*tvshow_id OR *tvshow) AND *season AND *episode
     """
     from dialogs import DialogEpisodeInfo
     ep_class = DialogEpisodeInfo.get_window(self.window_type)
     if not tvshow_id and tvshow:
         params = {"query": tvshow,
                   "language": SETTING("language")}
         response = TheMovieDB.get_data(url="search/tv",
                                        params=params,
                                        cache_days=30)
         if response["results"]:
             tvshow_id = str(response['results'][0]['id'])
     dialog = ep_class(INFO_DIALOG_FILE,
                       ADDON_PATH,
                       show_id=tvshow_id,
                       season=season,
                       episode=episode,
                       dbid=dbid)
     self.open_dialog(dialog, prev_window)
コード例 #41
0
 def open_episode_info(self,
                       prev_window=None,
                       tvshow_id=None,
                       season=None,
                       episode=None,
                       tvshow=None,
                       dbid=None):
     """
     open season info, deal with window stack
     needs (*tvshow_id OR *tvshow) AND *season AND *episode
     """
     from dialogs import DialogEpisodeInfo
     ep_class = DialogEpisodeInfo.get_window(self.window_type)
     if not tvshow_id and tvshow:
         tvshow_id = TheMovieDB.search_media(media_name=tvshow,
                                             media_type="tv",
                                             cache_days=7)
     dialog = ep_class(INFO_DIALOG_FILE,
                       ADDON_PATH,
                       show_id=tvshow_id,
                       season=season,
                       episode=episode,
                       dbid=dbid)
     self.open_dialog(dialog, prev_window)
コード例 #42
0
def start_info_actions(info, params):
    if "artistname" in params:
        params["artistname"] = params.get("artistname", "").split(" feat. ")[0].strip()
        params["artist_mbid"] = utils.fetch_musicbrainz_id(params["artistname"])
    utils.log(info)
    utils.pp(params)
    if "prefix" in params and not params["prefix"].endswith('.'):
        params["prefix"] = params["prefix"] + '.'

    # Audio
    if info == 'discography':
        discography = AudioDB.get_artist_discography(params["artistname"])
        if not discography:
            discography = LastFM.get_artist_albums(params.get("artist_mbid"))
        return discography
    elif info == 'mostlovedtracks':
        return AudioDB.get_most_loved_tracks(params["artistname"])
    elif info == 'trackdetails':
        return AudioDB.get_track_details(params.get("id", ""))
    elif info == 'topartists':
        return LastFM.get_top_artists()
#  RottenTomatoesMovies
    elif info == 'intheatermovies':
        return RottenTomatoes.get_movies("movies/in_theaters")
    elif info == 'boxofficemovies':
        return RottenTomatoes.get_movies("movies/box_office")
    elif info == 'openingmovies':
        return RottenTomatoes.get_movies("movies/opening")
    elif info == 'comingsoonmovies':
        return RottenTomatoes.get_movies("movies/upcoming")
    elif info == 'toprentalmovies':
        return RottenTomatoes.get_movies("dvds/top_rentals")
    elif info == 'currentdvdmovies':
        return RottenTomatoes.get_movies("dvds/current_releases")
    elif info == 'newdvdmovies':
        return RottenTomatoes.get_movies("dvds/new_releases")
    elif info == 'upcomingdvdmovies':
        return RottenTomatoes.get_movies("dvds/upcoming")
    #  The MovieDB
    elif info == 'incinemamovies':
        return tmdb.get_tmdb_movies("now_playing")
    elif info == 'upcomingmovies':
        return tmdb.get_tmdb_movies("upcoming")
    elif info == 'topratedmovies':
        return tmdb.get_tmdb_movies("top_rated")
    elif info == 'popularmovies':
        return tmdb.get_tmdb_movies("popular")
    elif info == 'ratedmovies':
        return tmdb.get_rated_media_items("movies")
    elif info == 'starredmovies':
        return tmdb.get_fav_items("movies")
    elif info == 'accountlists':
        account_lists = tmdb.handle_misc(tmdb.get_account_lists())
        for item in account_lists:
            item["directory"] = True
        return account_lists
    elif info == 'listmovies':
        return tmdb.get_movies_from_list(params["id"])
    elif info == 'airingtodaytvshows':
        return tmdb.get_tmdb_shows("airing_today")
    elif info == 'onairtvshows':
        return tmdb.get_tmdb_shows("on_the_air")
    elif info == 'topratedtvshows':
        return tmdb.get_tmdb_shows("top_rated")
    elif info == 'populartvshows':
        return tmdb.get_tmdb_shows("popular")
    elif info == 'ratedtvshows':
        return tmdb.get_rated_media_items("tv")
    elif info == 'ratedepisodes':
        return tmdb.get_rated_media_items("tv/episodes")
    elif info == 'starredtvshows':
        return tmdb.get_fav_items("tv")
    elif info == 'similarmovies':
        movie_id = params.get("id")
        if not movie_id:
            movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                              dbid=params.get("dbid"))
        if movie_id:
            return tmdb.get_similar_movies(movie_id)
    elif info == 'similartvshows':
        tvshow_id = None
        dbid = params.get("dbid")
        name = params.get("name")
        tmdb_id = params.get("tmdb_id")
        tvdb_id = params.get("tvdb_id")
        imdb_id = params.get("imdb_id")
        if tmdb_id:
            tvshow_id = tmdb_id
        elif dbid and int(dbid) > 0:
            tvdb_id = local_db.get_imdb_id("tvshow", dbid)
            if tvdb_id:
                tvshow_id = tmdb.get_show_tmdb_id(tvdb_id)
        elif tvdb_id:
            tvshow_id = tmdb.get_show_tmdb_id(tvdb_id)
        elif imdb_id:
            tvshow_id = tmdb.get_show_tmdb_id(imdb_id, "imdb_id")
        elif name:
            tvshow_id = tmdb.search_media(media_name=name,
                                          year="",
                                          media_type="tv")
        if tvshow_id:
            return tmdb.get_similar_tvshows(tvshow_id)
    elif info == 'studio':
        if params.get("id"):
            return tmdb.get_company_data(params["id"])
        elif params.get("studio"):
            company_data = tmdb.search_company(params["studio"])
            if company_data:
                return tmdb.get_company_data(company_data[0]["id"])
    elif info == 'set':
        if params.get("dbid"):
            name = local_db.get_set_name(params["dbid"])
            if name:
                params["setid"] = tmdb.get_set_id(name)
        if params.get("setid"):
            set_data, _ = tmdb.get_set_movies(params["setid"])
            return set_data
    elif info == 'movielists':
        movie_id = params.get("id")
        if not movie_id:
            movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                              dbid=params.get("dbid"))
        if movie_id:
            return tmdb.get_movie_lists(movie_id)
    elif info == 'keywords':
        movie_id = params.get("id")
        if not movie_id:
            movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                              dbid=params.get("dbid"))
        if movie_id:
            return tmdb.get_keywords(movie_id)
    elif info == 'popularpeople':
        return tmdb.get_popular_actors()
    elif info == 'personmovies':
        person = tmdb.get_person_info(person_label=params.get("person"),
                                      skip_dialog=True)
        if person and person.get("id"):
            movies = tmdb.get_person_movies(person["id"])
            for item in movies:
                del item["credit_id"]
            return utils.reduce_list(movies, key="department")
    elif info == 'traktsimilarmovies':
        if params.get("id") or params.get("dbid"):
            if params.get("dbid"):
                movie_id = local_db.get_imdb_id("movie", params["dbid"])
            else:
                movie_id = params["id"]
            return Trakt.get_similar("movie", movie_id)
    elif info == 'traktsimilartvshows':
        if params.get("id") or params.get("dbid"):
            if params.get("dbid"):
                if params.get("type") == "episode":
                    tvshow_id = local_db.get_tvshow_id_by_episode(params["dbid"])
                else:
                    tvshow_id = local_db.get_imdb_id(media_type="tvshow",
                                                     dbid=params["dbid"])
            else:
                tvshow_id = params["id"]
            return Trakt.get_similar("show", tvshow_id)
    elif info == 'airingepisodes':
        return Trakt.get_episodes("shows")
    elif info == 'premiereepisodes':
        return Trakt.get_episodes("premieres")
    elif info == 'trendingshows':
        return Trakt.get_shows("trending")
    elif info == 'popularshows':
        return Trakt.get_shows("popular")
    elif info == 'anticipatedshows':
        return Trakt.get_shows("anticipated")
    elif info == 'mostcollectedshows':
        return Trakt.get_shows_from_time("collected")
    elif info == 'mostplayedshows':
        return Trakt.get_shows_from_time("played")
    elif info == 'mostwatchedshows':
        return Trakt.get_shows_from_time("watched")
    elif info == 'trendingmovies':
        return Trakt.get_movies("trending")
    elif info == 'traktpopularmovies':
        return Trakt.get_movies("popular")
    elif info == 'mostplayedmovies':
        return Trakt.get_movies_from_time("played")
    elif info == 'mostwatchedmovies':
        return Trakt.get_movies_from_time("watched")
    elif info == 'mostcollectedmovies':
        return Trakt.get_movies_from_time("collected")
    elif info == 'mostanticipatedmovies':
        return Trakt.get_movies("anticipated")
    elif info == 'traktboxofficemovies':
        return Trakt.get_movies("boxoffice")
    elif info == 'similarartistsinlibrary':
        return local_db.get_similar_artists(params.get("artist_mbid"))
    elif info == 'trackinfo':
        addon.clear_global('%sSummary' % params.get("prefix", ""))
        if params["artistname"] and params["trackname"]:
            track_info = LastFM.get_track_info(artist_name=params["artistname"],
                                               track=params["trackname"])
            addon.set_global('%sSummary' % params.get("prefix", ""), track_info["summary"])
    elif info == 'topartistsnearevents':
        artists = local_db.get_artists()
        import BandsInTown
        return BandsInTown.get_near_events(artists[0:49])
    elif info == 'youtubesearchvideos':
        addon.set_global('%sSearchValue' % params.get("prefix", ""), params.get("id", ""))
        if params.get("id"):
            listitems = YouTube.search(search_str=params.get("id", ""),
                                       hd=params.get("hd"),
                                       orderby=params.get("orderby", "relevance"))
            return listitems.get("listitems", [])
    elif info == 'youtubeplaylistvideos':
        return YouTube.get_playlist_videos(params.get("id", ""))
    elif info == 'youtubeusersearchvideos':
        user_name = params.get("id")
        if user_name:
            playlists = YouTube.get_user_playlists(user_name)
            return YouTube.get_playlist_videos(playlists["uploads"])
    elif info == 'favourites':
        if params.get("id"):
            items = favs.get_favs_by_type(params["id"])
        else:
            items = favs.get_favs()
            addon.set_global('favourite.count', str(len(items)))
            if items:
                addon.set_global('favourite.1.name', items[-1]["label"])
        return items
    elif info == 'similarlocalmovies' and "dbid" in params:
        return local_db.get_similar_movies(params["dbid"])
    elif info == 'iconpanel':
        return favs.get_icon_panel(int(params["id"])), "IconPanel" + str(params["id"])
    # ACTIONS
    if params.get("handle"):
        xbmcplugin.setResolvedUrl(handle=int(params.get("handle")),
                                  succeeded=False,
                                  listitem=xbmcgui.ListItem())
    if info in ['playmovie', 'playepisode', 'playmusicvideo', 'playalbum', 'playsong']:
        kodijson.play_media(media_type=info.replace("play", ""),
                            dbid=params.get("dbid"),
                            resume=params.get("resume", "true"))
    elif info == "openinfodialog":
        if xbmc.getCondVisibility("System.HasModalDialog"):
            container_id = ""
        else:
            container_id = "Container(%s)" % utils.get_infolabel("System.CurrentControlId")
        dbid = utils.get_infolabel("%sListItem.DBID" % container_id)
        db_type = utils.get_infolabel("%sListItem.DBType" % container_id)
        if db_type == "movie":
            params = {"dbid": dbid,
                      "id": utils.get_infolabel("%sListItem.Property(id)" % container_id),
                      "name": utils.get_infolabel("%sListItem.Title" % container_id)}
            start_info_actions("extendedinfo", params)
        elif db_type == "tvshow":
            params = {"dbid": dbid,
                      "tvdb_id": utils.get_infolabel("%sListItem.Property(tvdb_id)" % container_id),
                      "id": utils.get_infolabel("%sListItem.Property(id)" % container_id),
                      "name": utils.get_infolabel("%sListItem.Title" % container_id)}
            start_info_actions("extendedtvinfo", params)
        elif db_type == "season":
            params = {"tvshow": utils.get_infolabel("%sListItem.TVShowTitle" % container_id),
                      "season": utils.get_infolabel("%sListItem.Season" % container_id)}
            start_info_actions("seasoninfo", params)
        elif db_type == "episode":
            params = {"tvshow": utils.get_infolabel("%sListItem.TVShowTitle" % container_id),
                      "season": utils.get_infolabel("%sListItem.Season" % container_id),
                      "episode": utils.get_infolabel("%sListItem.Episode" % container_id)}
            start_info_actions("extendedepisodeinfo", params)
        elif db_type in ["actor", "director"]:
            params = {"name": utils.get_infolabel("%sListItem.Label" % container_id)}
            start_info_actions("extendedactorinfo", params)
        else:
            utils.notify("Error", "Could not find valid content type")
    elif info == "ratedialog":
        if xbmc.getCondVisibility("System.HasModalDialog"):
            container_id = ""
        else:
            container_id = "Container(%s)" % utils.get_infolabel("System.CurrentControlId")
        dbid = utils.get_infolabel("%sListItem.DBID" % container_id)
        db_type = utils.get_infolabel("%sListItem.DBType" % container_id)
        if db_type == "movie":
            params = {"dbid": dbid,
                      "id": utils.get_infolabel("%sListItem.Property(id)" % container_id),
                      "type": "movie"}
            start_info_actions("ratemedia", params)
        elif db_type == "tvshow":
            params = {"dbid": dbid,
                      "id": utils.get_infolabel("%sListItem.Property(id)" % container_id),
                      "type": "tv"}
            start_info_actions("ratemedia", params)
        if db_type == "episode":
            params = {"tvshow": utils.get_infolabel("%sListItem.TVShowTitle" % container_id),
                      "season": utils.get_infolabel("%sListItem.Season" % container_id),
                      "type": "episode"}
            start_info_actions("ratemedia", params)
    elif info == 'youtubebrowser':
        wm.open_youtube_list(search_str=params.get("id", ""))
    elif info == 'moviedbbrowser':
        if addon.get_global('infodialogs.active'):
            return None
        addon.set_global('infodialogs.active', "true")
        search_str = params.get("id", "")
        if not search_str and params.get("search"):
            result = xbmcgui.Dialog().input(heading=addon.LANG(16017),
                                            type=xbmcgui.INPUT_ALPHANUM)
            if result and result > -1:
                search_str = result
            else:
                return None
        wm.open_video_list(search_str=search_str,
                           mode="search")
        addon.clear_global('infodialogs.active')
    elif info == 'extendedinfo':
        if addon.get_global('infodialogs.active'):
            return None
        addon.set_global('infodialogs.active', "true")
        wm.open_movie_info(movie_id=params.get("id"),
                           dbid=params.get("dbid"),
                           imdb_id=params.get("imdb_id"),
                           name=params.get("name"))
        addon.clear_global('infodialogs.active')
    elif info == 'extendedactorinfo':
        if addon.get_global('infodialogs.active'):
            return None
        addon.set_global('infodialogs.active', "true")
        wm.open_actor_info(actor_id=params.get("id"),
                           name=params.get("name"))
        addon.clear_global('infodialogs.active')
    elif info == 'extendedtvinfo':
        if addon.get_global('infodialogs.active'):
            return None
        addon.set_global('infodialogs.active', "true")
        wm.open_tvshow_info(tmdb_id=params.get("id"),
                            tvdb_id=params.get("tvdb_id"),
                            dbid=params.get("dbid"),
                            imdb_id=params.get("imdb_id"),
                            name=params.get("name"))
        addon.clear_global('infodialogs.active')
    elif info == 'seasoninfo':
        if addon.get_global('infodialogs.active'):
            return None
        addon.set_global('infodialogs.active', "true")
        wm.open_season_info(tvshow=params.get("tvshow"),
                            dbid=params.get("dbid"),
                            season=params.get("season"))
        addon.clear_global('infodialogs.active')
    elif info == 'extendedepisodeinfo':
        if addon.get_global('infodialogs.active'):
            return None
        addon.set_global('infodialogs.active', "true")
        wm.open_episode_info(tvshow=params.get("tvshow"),
                             tvshow_id=params.get("tvshow_id"),
                             dbid=params.get("dbid"),
                             episode=params.get("episode"),
                             season=params.get("season"))
        addon.clear_global('infodialogs.active')
    elif info == 'albuminfo':
        if params.get("id"):
            album_details = AudioDB.get_album_details(params.get("id"))
            utils.dict_to_windowprops(album_details, params.get("prefix", ""))
    elif info == 'artistdetails':
        artist_details = AudioDB.get_artist_details(params["artistname"])
        utils.dict_to_windowprops(artist_details, params.get("prefix", ""))
    elif info == 'ratemedia':
        media_type = params.get("type")
        if not media_type:
            return None
        if params.get("id"):
            tmdb_id = params["id"]
        elif media_type == "movie":
            tmdb_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                             dbid=params.get("dbid"),
                                             name=params.get("name"))
        elif media_type == "tv" and params.get("dbid"):
            tvdb_id = local_db.get_imdb_id(media_type="tvshow",
                                           dbid=params["dbid"])
            tmdb_id = tmdb.get_show_tmdb_id(tvdb_id=tvdb_id)
        else:
            return False
        rating = utils.input_userrating()
        tmdb.set_rating(media_type=media_type,
                        media_id=tmdb_id,
                        rating=rating,
                        dbid=params.get("dbid"))
    elif info == 'action':
        for builtin in params.get("id", "").split("$$"):
            xbmc.executebuiltin(builtin)
    elif info == "youtubevideo":
        xbmc.executebuiltin("Dialog.Close(all,true)")
        wm.play_youtube_video(params.get("id", ""))
    elif info == 'playtrailer':
        wm.show_busy()
        if params.get("id"):
            movie_id = params["id"]
        elif int(params.get("dbid", -1)) > 0:
            movie_id = local_db.get_imdb_id(media_type="movie",
                                            dbid=params["dbid"])
        elif params.get("imdb_id"):
            movie_id = tmdb.get_movie_tmdb_id(params["imdb_id"])
        else:
            movie_id = ""
        if movie_id:
            trailer = tmdb.get_trailer(movie_id)
            wm.hide_busy()
            time.sleep(0.1)
            if trailer:
                wm.play_youtube_video(trailer)
            elif params.get("title"):
                wm.open_youtube_list(search_str=params["title"])
            else:
                wm.hide_busy()
    elif info == 'deletecache':
        addon.clear_globals()
        for rel_path in os.listdir(addon.DATA_PATH):
            path = os.path.join(addon.DATA_PATH, rel_path)
            try:
                if os.path.isdir(path):
                    shutil.rmtree(path)
            except Exception as e:
                utils.log(e)
        utils.notify("Cache deleted")
    elif info == 'syncwatchlist':
        pass
コード例 #43
0
ファイル: process.py プロジェクト: PandoraClub/WizaTV
def start_info_actions(info, params):
    if "artistname" in params:
        params["artistname"] = params.get("artistname",
                                          "").split(" feat. ")[0].strip()
        params["artist_mbid"] = fetch_musicbrainz_id(params["artistname"])
    log(info)
    prettyprint(params)
    if "prefix" in params and not params["prefix"].endswith('.'):
        params["prefix"] = params["prefix"] + '.'

    # Audio
    if info == 'discography':
        discography = AudioDB.get_artist_discography(params["artistname"])
        if not discography:
            discography = LastFM.get_artist_albums(params.get("artist_mbid"))
        return discography
    elif info == 'mostlovedtracks':
        return AudioDB.get_most_loved_tracks(params["artistname"])
    elif info == 'trackdetails':
        return AudioDB.get_track_details(params.get("id", ""))
    elif info == 'topartists':
        return LastFM.get_top_artists()
    elif info == 'latestdbmovies':
        return LocalDB.local_db.get_movies(
            '"sort": {"order": "descending", "method": "dateadded"}',
            params.get("limit", 10))
    elif info == 'randomdbmovies':
        return LocalDB.local_db.get_movies('"sort": {"method": "random"}',
                                           params.get("limit", 10))
    elif info == 'inprogressdbmovies':
        method = '"sort": {"order": "descending", "method": "lastplayed"}, "filter": {"field": "inprogress", "operator": "true", "value": ""}'
        return LocalDB.local_db.get_movies(method, params.get("limit", 10))


#  RottenTomatoesMovies
    elif info == 'intheatermovies':
        return RottenTomatoes.get_movies("movies/in_theaters")
    elif info == 'boxofficemovies':
        return RottenTomatoes.get_movies("movies/box_office")
    elif info == 'openingmovies':
        return RottenTomatoes.get_movies("movies/opening")
    elif info == 'comingsoonmovies':
        return RottenTomatoes.get_movies("movies/upcoming")
    elif info == 'toprentalmovies':
        return RottenTomatoes.get_movies("dvds/top_rentals")
    elif info == 'currentdvdmovies':
        return RottenTomatoes.get_movies("dvds/current_releases")
    elif info == 'newdvdmovies':
        return RottenTomatoes.get_movies("dvds/new_releases")
    elif info == 'upcomingdvdmovies':
        return RottenTomatoes.get_movies("dvds/upcoming")
    #  The MovieDB
    elif info == 'incinemamovies':
        return tmdb.get_tmdb_movies("now_playing")
    elif info == 'upcomingmovies':
        return tmdb.get_tmdb_movies("upcoming")
    elif info == 'topratedmovies':
        return tmdb.get_tmdb_movies("top_rated")
    elif info == 'popularmovies':
        return tmdb.get_tmdb_movies("popular")
    elif info == 'ratedmovies':
        return tmdb.get_rated_media_items("movies")
    elif info == 'starredmovies':
        return tmdb.get_fav_items("movies")
    elif info == 'accountlists':
        account_lists = tmdb.handle_misc(tmdb.get_account_lists())
        for item in account_lists:
            item["directory"] = True
        return account_lists
    elif info == 'listmovies':
        return tmdb.get_movies_from_list(params["id"])
    elif info == 'airingtodaytvshows':
        return tmdb.get_tmdb_shows("airing_today")
    elif info == 'onairtvshows':
        return tmdb.get_tmdb_shows("on_the_air")
    elif info == 'topratedtvshows':
        return tmdb.get_tmdb_shows("top_rated")
    elif info == 'populartvshows':
        return tmdb.get_tmdb_shows("popular")
    elif info == 'ratedtvshows':
        return tmdb.get_rated_media_items("tv")
    elif info == 'starredtvshows':
        return tmdb.get_fav_items("tv")
    elif info == 'similarmovies':
        movie_id = params.get("id")
        if not movie_id:
            movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                              dbid=params.get("dbid"))
        if movie_id:
            return tmdb.get_similar_movies(movie_id)
    elif info == 'similartvshows':
        tvshow_id = None
        dbid = params.get("dbid")
        name = params.get("name")
        tmdb_id = params.get("tmdb_id")
        tvdb_id = params.get("tvdb_id")
        imdb_id = params.get("imdb_id")
        if tmdb_id:
            tvshow_id = tmdb_id
        elif dbid and int(dbid) > 0:
            tvdb_id = LocalDB.local_db.get_imdb_id("tvshow", dbid)
            if tvdb_id:
                tvshow_id = tmdb.get_show_tmdb_id(tvdb_id)
        elif tvdb_id:
            tvshow_id = tmdb.get_show_tmdb_id(tvdb_id)
        elif imdb_id:
            tvshow_id = tmdb.get_show_tmdb_id(imdb_id, "imdb_id")
        elif name:
            tvshow_id = tmdb.search_media(media_name=name,
                                          year="",
                                          media_type="tv")
        if tvshow_id:
            return tmdb.get_similar_tvshows(tvshow_id)
    elif info == 'studio':
        if params.get("id"):
            return tmdb.get_company_data(params["id"])
        elif params.get("studio"):
            company_data = tmdb.search_company(params["studio"])
            if company_data:
                return tmdb.get_company_data(company_data[0]["id"])
    elif info == 'set':
        if params.get("dbid") and "show" not in params.get("type", ""):
            name = LocalDB.local_db.get_set_name(params["dbid"])
            if name:
                params["setid"] = tmdb.get_set_id(name)
        if params.get("setid"):
            set_data, _ = tmdb.get_set_movies(params["setid"])
            return set_data
    elif info == 'movielists':
        movie_id = params.get("id")
        if not movie_id:
            movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                              dbid=params.get("dbid"))
        if movie_id:
            return tmdb.get_movie_lists(movie_id)
    elif info == 'keywords':
        movie_id = params.get("id")
        if not movie_id:
            movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                              dbid=params.get("dbid"))
        if movie_id:
            return tmdb.get_keywords(movie_id)
    elif info == 'popularpeople':
        return tmdb.get_popular_actors()
    elif info == 'directormovies':
        director_info = tmdb.get_person_info(
            person_label=params.get("director"), skip_dialog=True)
        if director_info and director_info.get("id"):
            movies = tmdb.get_person_movies(director_info["id"])
            for item in movies:
                del item["credit_id"]
            return merge_dict_lists(movies, key="department")
    elif info == 'writermovies':
        writer = params.get("writer")
        if writer and not writer.split(" / ")[0] == params.get(
                "director", "").split(" / ")[0]:
            writer_info = tmdb.get_person_info(person_label=writer,
                                               skip_dialog=True)
            if writer_info and writer_info.get("id"):
                movies = tmdb.get_person_movies(writer_info["id"])
                for item in movies:
                    del item["credit_id"]
                return merge_dict_lists(movies, key="department")
    elif info == 'traktsimilarmovies':
        if params.get("id") or params.get("dbid"):
            if params.get("dbid"):
                movie_id = LocalDB.local_db.get_imdb_id(
                    "movie", params["dbid"])
            else:
                movie_id = params["id"]
            return Trakt.get_similar("movie", movie_id)
    elif info == 'traktsimilartvshows':
        if params.get("id") or params.get("dbid"):
            if params.get("dbid"):
                if params.get("type") == "episode":
                    tvshow_id = LocalDB.local_db.get_tvshow_id_by_episode(
                        params["dbid"])
                else:
                    tvshow_id = LocalDB.local_db.get_imdb_id(
                        media_type="tvshow", dbid=params["dbid"])
            else:
                tvshow_id = params["id"]
            return Trakt.get_similar("show", tvshow_id)
    elif info == 'airingepisodes':
        return Trakt.get_calendar_shows("shows")
    elif info == 'premiereepisodes':
        return Trakt.get_calendar_shows("premieres")
    elif info == 'trendingshows':
        return Trakt.get_trending_shows()
    elif info == 'trendingmovies':
        return Trakt.get_trending_movies()
    elif info == 'similarartistsinlibrary':
        return LocalDB.local_db.get_similar_artists(params.get("artist_mbid"))
    elif info == 'trackinfo':
        HOME.clearProperty('%sSummary' % params.get("prefix", ""))
        if params["artistname"] and params["trackname"]:
            track_info = LastFM.get_track_info(
                artist_name=params["artistname"], track=params["trackname"])
            HOME.setProperty('%sSummary' % params.get("prefix", ""),
                             track_info["summary"])
    elif info == 'topartistsnearevents':
        artists = LocalDB.local_db.get_artists()
        import BandsInTown
        return BandsInTown.get_near_events(artists[0:49])
    elif info == 'youtubesearch':
        HOME.setProperty('%sSearchValue' % params.get("prefix", ""),
                         params.get("id", ""))
        if params.get("id"):
            listitems = YouTube.search(search_str=params.get("id", ""),
                                       hd=params.get("hd", ""),
                                       orderby=params.get(
                                           "orderby", "relevance"))
            return listitems.get("listitems", [])
    elif info == 'youtubeplaylist':
        return YouTube.get_playlist_videos(params.get("id", ""))
    elif info == 'youtubeusersearch':
        user_name = params.get("id")
        if user_name:
            playlists = YouTube.get_user_playlists(user_name)
            return YouTube.get_playlist_videos(playlists["uploads"])
    elif info == 'favourites':
        if params.get("id"):
            favs = get_favs_by_type(params["id"])
        else:
            favs = get_favs()
            HOME.setProperty('favourite.count', str(len(favs)))
            if favs:
                HOME.setProperty('favourite.1.name', favs[-1]["Label"])
        return favs
    elif info == 'similarlocalmovies' and "dbid" in params:
        return LocalDB.local_db.get_similar_movies(params["dbid"])
    elif info == 'iconpanel':
        return get_icon_panel(int(
            params["id"])), "IconPanel" + str(params["id"])
    elif info == 'weather':
        return get_weather_images()
    elif info == "sortletters":
        return get_sort_letters(params["path"], params.get("id", ""))

    # ACTIONS
    resolve_url(params.get("handle"))
    if info == 't9input':
        import T9Search
        dialog = T9Search.T9Search(call=None, start_value="")
        KodiJson.send_text(text=dialog.search_str)
    elif info in [
            'playmovie', 'playepisode', 'playmusicvideo', 'playalbum',
            'playsong'
    ]:
        KodiJson.play_media(media_type=info.replace("play", ""),
                            dbid=params.get("dbid"),
                            resume=params.get("resume", "true"))
    elif info == "openinfodialog":
        if xbmc.getCondVisibility("System.HasModalDialog"):
            container_id = ""
        else:
            container_id = "Container(%s)" % get_infolabel(
                "System.CurrentControlId")
        dbid = get_infolabel("%sListItem.DBID" % container_id)
        db_type = get_infolabel("%sListItem.DBType" % container_id)
        if not dbid:
            dbid = get_infolabel("%sListItem.Property(dbid)" % container_id)
        if db_type == "movie":
            params = {
                "dbid": dbid,
                "id": get_infolabel("%sListItem.Property(id)" % container_id),
                "name": get_infolabel("%sListItem.Title" % container_id)
            }
            start_info_actions("extendedinfo", params)
        elif db_type == "tvshow":
            params = {
                "dbid":
                dbid,
                "tvdb_id":
                get_infolabel("%sListItem.Property(tvdb_id)" % container_id),
                "id":
                get_infolabel("%sListItem.Property(id)" % container_id),
                "name":
                get_infolabel("%sListItem.Title" % container_id)
            }
            start_info_actions("extendedtvinfo", params)
        elif db_type == "season":
            params = {
                "tvshow":
                get_infolabel("%sListItem.TVShowTitle" % container_id),
                "season": get_infolabel("%sListItem.Season" % container_id)
            }
            start_info_actions("seasoninfo", params)
        elif db_type == "episode":
            params = {
                "tvshow":
                get_infolabel("%sListItem.TVShowTitle" % container_id),
                "season": get_infolabel("%sListItem.Season" % container_id),
                "episode": get_infolabel("%sListItem.Episode" % container_id)
            }
            start_info_actions("extendedepisodeinfo", params)
        elif db_type in ["actor", "director"]:
            params = {"name": get_infolabel("%sListItem.Label" % container_id)}
            start_info_actions("extendedactorinfo", params)
        else:
            notify("Error", "Could not find valid content type")
    elif info == "ratedialog":
        if xbmc.getCondVisibility("System.HasModalDialog"):
            container_id = ""
        else:
            container_id = "Container(%s)" % get_infolabel(
                "System.CurrentControlId")
        dbid = get_infolabel("%sListItem.DBID" % container_id)
        db_type = get_infolabel("%sListItem.DBType" % container_id)
        if not dbid:
            dbid = get_infolabel("%sListItem.Property(dbid)" % container_id)
        if db_type == "movie":
            params = {
                "dbid": dbid,
                "id": get_infolabel("%sListItem.Property(id)" % container_id),
                "type": "movie"
            }
            start_info_actions("ratemedia", params)
        elif db_type == "tvshow":
            params = {
                "dbid": dbid,
                "id": get_infolabel("%sListItem.Property(id)" % container_id),
                "type": "tv"
            }
            start_info_actions("ratemedia", params)
        if db_type == "episode":
            params = {
                "tvshow":
                get_infolabel("%sListItem.TVShowTitle" % container_id),
                "season": get_infolabel("%sListItem.Season" % container_id),
                "type": "episode"
            }
            start_info_actions("ratemedia", params)
    elif info == 'youtubebrowser':
        wm.open_youtube_list(search_str=params.get("id", ""))
    elif info == 'moviedbbrowser':
        search_str = params.get("id", "")
        if not search_str and params.get("search"):
            result = xbmcgui.Dialog().input(heading=LANG(16017),
                                            type=xbmcgui.INPUT_ALPHANUM)
            if result and result > -1:
                search_str = result
            else:
                return None
        wm.open_video_list(search_str=search_str, mode="search")
    elif info == 'extendedinfo':
        HOME.setProperty('infodialogs.active', "true")
        wm.open_movie_info(movie_id=params.get("id"),
                           dbid=params.get("dbid"),
                           imdb_id=params.get("imdb_id"),
                           name=params.get("name"))
        HOME.clearProperty('infodialogs.active')
    elif info == 'extendedactorinfo':
        HOME.setProperty('infodialogs.active', "true")
        wm.open_actor_info(actor_id=params.get("id"), name=params.get("name"))
        HOME.clearProperty('infodialogs.active')
    elif info == 'extendedtvinfo':
        HOME.setProperty('infodialogs.active', "true")
        wm.open_tvshow_info(tmdb_id=params.get("id"),
                            tvdb_id=params.get("tvdb_id"),
                            dbid=params.get("dbid"),
                            imdb_id=params.get("imdb_id"),
                            name=params.get("name"))
        HOME.clearProperty('infodialogs.active')
    elif info == 'seasoninfo':
        HOME.setProperty('infodialogs.active', "true")
        wm.open_season_info(tvshow=params.get("tvshow"),
                            dbid=params.get("dbid"),
                            season=params.get("season"))
        HOME.clearProperty('infodialogs.active')
    elif info == 'extendedepisodeinfo':
        HOME.setProperty('infodialogs.active', "true")
        wm.open_episode_info(tvshow=params.get("tvshow"),
                             tvshow_id=params.get("tvshow_id"),
                             dbid=params.get("dbid"),
                             episode=params.get("episode"),
                             season=params.get("season"))
        HOME.clearProperty('infodialogs.active')
    elif info == 'albuminfo':
        if params.get("id"):
            album_details = AudioDB.get_album_details(params.get("id"))
            pass_dict_to_skin(album_details, params.get("prefix", ""))
    elif info == 'artistdetails':
        artist_details = AudioDB.get_artist_details(params["artistname"])
        pass_dict_to_skin(artist_details, params.get("prefix", ""))
    elif info == 'ratemedia':
        media_type = params.get("type")
        if media_type:
            if params.get("id"):
                tmdb_id = params["id"]
            elif media_type == "movie":
                tmdb_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                                 dbid=params.get("dbid"),
                                                 name=params.get("name"))
            elif media_type == "tv" and params.get("dbid"):
                tvdb_id = LocalDB.local_db.get_imdb_id(media_type="tvshow",
                                                       dbid=params["dbid"])
                tmdb_id = tmdb.get_show_tmdb_id(tvdb_id=tvdb_id)
            else:
                return False
            tmdb.set_rating_prompt(media_type=media_type,
                                   media_id=tmdb_id,
                                   dbid=params.get("dbid"))
    elif info == 'playliststats':
        get_playlist_stats(params.get("id", ""))
    elif info == 'slideshow':
        window_id = xbmcgui.getCurrentwindow_id()
        window = xbmcgui.Window(window_id)
        # focusid = Window.getFocusId()
        num_items = window.getFocus().getSelectedPosition()
        for i in range(0, num_items):
            notify(item.getProperty("Image"))
    elif info == 'action':
        for builtin in params.get("id", "").split("$$"):
            xbmc.executebuiltin(builtin)
    elif info == "youtubevideo":
        xbmc.executebuiltin("Dialog.Close(all,true)")
        VideoPlayer.PLAYER.play_youtube_video(params.get("id", ""))
    elif info == 'playtrailer':
        xbmc.executebuiltin("ActivateWindow(busydialog)")
        if params.get("id"):
            movie_id = params["id"]
        elif int(params.get("dbid", -1)) > 0:
            movie_id = LocalDB.local_db.get_imdb_id(media_type="movie",
                                                    dbid=params["dbid"])
        elif params.get("imdb_id"):
            movie_id = tmdb.get_movie_tmdb_id(params["imdb_id"])
        else:
            movie_id = ""
        if movie_id:
            trailer = tmdb.get_trailer(movie_id)
            xbmc.executebuiltin("Dialog.Close(busydialog)")
            time.sleep(0.1)
            if trailer:
                VideoPlayer.PLAYER.play_youtube_video(trailer)
            elif params.get("title"):
                wm.open_youtube_list(search_str=params["title"])
            else:
                xbmc.executebuiltin("Dialog.Close(busydialog)")
    elif info == 'deletecache':
        HOME.clearProperties()
        import shutil
        for rel_path in os.listdir(ADDON_DATA_PATH):
            path = os.path.join(ADDON_DATA_PATH, rel_path)
            try:
                if os.path.isdir(path):
                    shutil.rmtree(path)
            except Exception as e:
                log(e)
        notify("Cache deleted")
    elif info == 'syncwatchlist':
        pass
    elif info == "widgetdialog":
        widget_selectdialog()
コード例 #44
0
def start_info_actions(infos, params):
    if "artistname" in params:
        params["artistname"] = params.get("artistname", "").split(" feat. ")[0].strip()
        params["artist_mbid"] = fetch_musicbrainz_id(params["artistname"])
    prettyprint(params)
    prettyprint(infos)
    if "prefix" in params and (not params["prefix"].endswith('.')) and (params["prefix"]):
        params["prefix"] = params["prefix"] + '.'
    for info in infos:
        data = [], ""
        #  Images
        if info == 'xkcd':
            from MiscScraper import get_xkcd_images
            data = get_xkcd_images(), "XKCD"
        elif info == 'cyanide':
            from MiscScraper import get_cyanide_images
            data = get_cyanide_images(), "CyanideHappiness"
        elif info == 'dailybabes':
            from MiscScraper import get_babe_images
            data = get_babe_images(), "DailyBabes"
        elif info == 'dailybabe':
            from MiscScraper import get_babe_images
            data = get_babe_images(single=True), "DailyBabe"
        # Audio
        elif info == 'discography':
            discography = AudioDB.get_artist_discography(params["artistname"])
            if not discography:
                discography = LastFM.get_artist_albums(params.get("artist_mbid"))
            data = discography, "discography"
        elif info == 'mostlovedtracks':
            data = AudioDB.get_most_loved_tracks(params["artistname"]), "MostLovedTracks"
        elif info == 'musicvideos':
            pass
            # if "audiodbid" in artist_details:
            #     data = get_musicvideos(artist_details["audiodbid"]), "MusicVideos"
        elif info == 'trackdetails':
            if params.get("id", ""):
                data = AudioDB.get_track_details(params.get("id", "")), "Trackinfo"
        elif info == 'albumshouts':
            if params["artistname"] and params["albumname"]:
                data = LastFM.get_album_shouts(params["artistname"], params["albumname"]), "Shout"
        elif info == 'artistshouts':
            if params["artistname"]:
                data = LastFM.get_artist_shouts(params["artistname"]), "Shout"
        elif info == 'topartists':
            data = LastFM.get_top_artists(), "TopArtists"
        elif info == 'hypedartists':
            data = LastFM.get_hyped_artists(), "HypedArtists"
        elif info == 'latestdbmovies':
            data = local_db.get_movies('"sort": {"order": "descending", "method": "dateadded"}', params.get("limit", 10)), "LatestMovies"
        elif info == 'randomdbmovies':
            data = local_db.get_movies('"sort": {"method": "random"}', params.get("limit", 10)), "RandomMovies"
        elif info == 'inprogressdbmovies':
            method = '"sort": {"order": "descending", "method": "lastplayed"}, "filter": {"field": "inprogress", "operator": "true", "value": ""}'
            data = local_db.get_movies(method, params.get("limit", 10)), "RecommendedMovies"
    #  RottenTomatoesMovies
        elif info == 'intheaters':
            data = RottenTomatoes.get_movies("movies/in_theaters"), "InTheatersMovies"
        elif info == 'boxoffice':
            data = RottenTomatoes.get_movies("movies/box_office"), "BoxOffice"
        elif info == 'opening':
            data = RottenTomatoes.get_movies("movies/opening"), "Opening"
        elif info == 'comingsoon':
            data = RottenTomatoes.get_movies("movies/upcoming"), "ComingSoonMovies"
        elif info == 'toprentals':
            data = RottenTomatoes.get_movies("dvds/top_rentals"), "TopRentals"
        elif info == 'currentdvdreleases':
            data = RottenTomatoes.get_movies("dvds/current_releases"), "CurrentDVDs"
        elif info == 'newdvdreleases':
            data = RottenTomatoes.get_movies("dvds/new_releases"), "NewDVDs"
        elif info == 'upcomingdvds':
            data = RottenTomatoes.get_movies("dvds/upcoming"), "UpcomingDVDs"
        #  The MovieDB
        elif info == 'incinemas':
            data = TheMovieDB.get_tmdb_movies("now_playing"), "InCinemasMovies"
        elif info == 'upcoming':
            data = TheMovieDB.get_tmdb_movies("upcoming"), "UpcomingMovies"
        elif info == 'topratedmovies':
            data = TheMovieDB.get_tmdb_movies("top_rated"), "TopRatedMovies"
        elif info == 'popularmovies':
            data = TheMovieDB.get_tmdb_movies("popular"), "PopularMovies"
        elif info == 'ratedmovies':
            data = TheMovieDB.get_rated_media_items("movies"), "RatedMovies"
        elif info == 'starredmovies':
            data = TheMovieDB.get_fav_items("movies"), "StarredMovies"
        elif info == 'accountlists':
            account_lists = TheMovieDB.handle_misc(TheMovieDB.get_account_lists())
            for item in account_lists:
                item["directory"] = True
            data = account_lists, "AccountLists"
        elif info == 'listmovies':
            movies = TheMovieDB.get_movies_from_list(params["id"])
            data = movies, "AccountLists"
        elif info == 'airingtodaytvshows':
            data = TheMovieDB.get_tmdb_shows("airing_today"), "AiringTodayTVShows"
        elif info == 'onairtvshows':
            data = TheMovieDB.get_tmdb_shows("on_the_air"), "OnAirTVShows"
        elif info == 'topratedtvshows':
            data = TheMovieDB.get_tmdb_shows("top_rated"), "TopRatedTVShows"
        elif info == 'populartvshows':
            data = TheMovieDB.get_tmdb_shows("popular"), "PopularTVShows"
        elif info == 'ratedtvshows':
            data = TheMovieDB.get_rated_media_items("tv"), "RatedTVShows"
        elif info == 'starredtvshows':
            data = TheMovieDB.get_fav_items("tv"), "StarredTVShows"
        elif info == 'similarmovies':
            movie_id = params.get("id", False)
            if not movie_id:
                movie_id = TheMovieDB.get_movie_tmdb_id(imdb_id=params.get("imdb_id", False),
                                                        dbid=params.get("dbid", False))
            if movie_id:
                data = TheMovieDB.get_similar_movies(movie_id), "SimilarMovies"
        elif info == 'similartvshows':
            tvshow_id = None
            dbid = params.get("dbid", False)
            name = params.get("name", False)
            tmdb_id = params.get("tmdb_id", False)
            tvdb_id = params.get("tvdb_id", False)
            imdb_id = params.get("imdb_id", False)
            if tmdb_id:
                tvshow_id = tmdb_id
            elif dbid and int(dbid) > 0:
                tvdb_id = local_db.get_imdb_id("tvshow", dbid)
                if tvdb_id:
                    tvshow_id = TheMovieDB.get_show_tmdb_id(tvdb_id)
            elif tvdb_id:
                tvshow_id = TheMovieDB.get_show_tmdb_id(tvdb_id)
            elif imdb_id:
                tvshow_id = TheMovieDB.get_show_tmdb_id(imdb_id, "imdb_id")
            elif name:
                tvshow_id = TheMovieDB.search_media(media_name=name,
                                                    year="",
                                                    media_type="tv")
            if tvshow_id:
                data = TheMovieDB.get_similar_tvshows(tvshow_id), "SimilarTVShows"
        elif info == 'studio':
            if "id" in params and params["id"]:
                data = TheMovieDB.get_company_data(params["id"]), "StudioInfo"
            elif "studio" in params and params["studio"]:
                company_data = TheMovieDB.search_company(params["studio"])
                if company_data:
                    data = TheMovieDB.get_company_data(company_data[0]["id"]), "StudioInfo"
        elif info == 'set':
            if params.get("dbid") and "show" not in str(params.get("type", "")):
                name = local_db.get_set_name(params["dbid"])
                if name:
                    params["setid"] = TheMovieDB.get_set_id(name)
            if params.get("setid"):
                set_data, _ = TheMovieDB.get_set_movies(params["setid"])
                if set_data:
                    data = set_data, "MovieSetItems"
        elif info == 'movielists':
            movie_id = params.get("id", False)
            if not movie_id:
                movie_id = TheMovieDB.get_movie_tmdb_id(imdb_id=params.get("imdb_id", False),
                                                        dbid=params.get("dbid", False))
            if movie_id:
                data = TheMovieDB.get_movie_lists(movie_id), "MovieLists"
        elif info == 'keywords':
            movie_id = params.get("id", False)
            if not movie_id:
                movie_id = TheMovieDB.get_movie_tmdb_id(imdb_id=params.get("imdb_id", False),
                                                        dbid=params.get("dbid", False))
            if movie_id:
                data = TheMovieDB.get_keywords(movie_id), "Keywords"
        elif info == 'popularpeople':
            data = TheMovieDB.get_popular_actors(), "PopularPeople"
        elif info == 'directormovies':
            if params.get("director"):
                director_info = TheMovieDB.get_person_info(person_label=params["director"],
                                                           skip_dialog=True)
                if director_info and director_info.get("id"):
                    movies = TheMovieDB.get_person_movies(director_info["id"])
                    for item in movies:
                        del item["credit_id"]
                    data = merge_dict_lists(movies, key="department"), "DirectorMovies"
        elif info == 'writermovies':
            if params.get("writer") and not params["writer"].split(" / ")[0] == params.get("director", "").split(" / ")[0]:
                writer_info = TheMovieDB.get_person_info(person_label=params["writer"],
                                                         skip_dialog=True)
                if writer_info and writer_info.get("id"):
                    movies = TheMovieDB.get_person_movies(writer_info["id"])
                    for item in movies:
                        del item["credit_id"]
                    data = merge_dict_lists(movies, key="department"), "WriterMovies"
        elif info == 'similarmoviestrakt':
            if params.get("id", False) or params.get("dbid"):
                if params.get("dbid"):
                    movie_id = local_db.get_imdb_id("movie", params["dbid"])
                else:
                    movie_id = params.get("id", "")
                data = Trakt.get_similar("movie", movie_id), "SimilarMovies"
        elif info == 'similartvshowstrakt':
            if (params.get("id", "") or params["dbid"]):
                if params.get("dbid"):
                    if params.get("type") == "episode":
                        tvshow_id = local_db.get_tvshow_id_by_episode(params["dbid"])
                    else:
                        tvshow_id = local_db.get_imdb_id(media_type="tvshow",
                                                         dbid=params["dbid"])
                else:
                    tvshow_id = params.get("id", "")
                data = Trakt.get_similar("show", tvshow_id), "SimilarTVShows"
        elif info == 'airingshows':
            data = Trakt.get_calendar_shows("shows"), "AiringShows"
        elif info == 'premiereshows':
            data = Trakt.get_calendar_shows("premieres"), "PremiereShows"
        elif info == 'trendingshows':
            data = Trakt.get_trending_shows(), "TrendingShows"
        elif info == 'trendingmovies':
            data = Trakt.get_trending_movies(), "TrendingMovies"
        elif info == 'similarartistsinlibrary':
            if params.get("artist_mbid"):
                data = local_db.get_similar_artists(params.get("artist_mbid")), "SimilarArtists"
        elif info == 'artistevents':
            if params.get("artist_mbid"):
                data = LastFM.get_events(params.get("artist_mbid")), "ArtistEvents"
        elif info == 'youtubesearch':
            HOME.setProperty('%sSearchValue' % params.get("prefix", ""), params.get("id", ""))  # set properties
            if params.get("id"):
                listitems = YouTube.search(search_str=params.get("id", ""),
                                           hd=params.get("hd", ""),
                                           orderby=params.get("orderby", "relevance"))
                data = listitems.get("listitems", []), "YoutubeSearch"
        elif info == 'youtubeplaylist':
            if params.get("id"):
                data = YouTube.get_playlist_videos(params.get("id", "")), "YoutubePlaylist"
        elif info == 'youtubeusersearch':
            user_name = params.get("id", "")
            if user_name:
                playlists = YouTube.get_user_playlists(user_name)
                data = YouTube.get_playlist_videos(playlists["uploads"]), "YoutubeUserSearch"
        elif info == 'nearevents':
            eventinfo = LastFM.get_near_events(tag=params.get("tag", ""),
                                               festivals_only=params.get("festivalsonly", ""),
                                               lat=params.get("lat", ""),
                                               lon=params.get("lon", ""),
                                               location=params.get("location", ""),
                                               distance=params.get("distance", ""))
            data = eventinfo, "NearEvents"
        elif info == 'trackinfo':
            HOME.setProperty('%sSummary' % params.get("prefix", ""), "")  # set properties
            if params["artistname"] and params["trackname"]:
                track_info = LastFM.get_track_info(artist=params["artistname"],
                                                   track=params["trackname"])
                HOME.setProperty('%sSummary' % params.get("prefix", ""), track_info["summary"])  # set properties
        elif info == 'venueevents':
            if params["location"]:
                params["id"] = LastFM.get_venue_id(params["location"])
            if params.get("id", ""):
                data = LastFM.get_venue_events(params.get("id", "")), "VenueEvents"
            else:
                notify("Error", "Could not find venue")
        elif info == 'topartistsnearevents':
            artists = local_db.get_artists()
            import BandsInTown
            data = BandsInTown.get_near_events(artists[0:49]), "TopArtistsNearEvents"
        elif info == 'favourites':
            if params.get("id", ""):
                favs = get_favs_by_type(params.get("id", ""))
            else:
                favs = get_favs()
                HOME.setProperty('favourite.count', str(len(favs)))
                if favs:
                    HOME.setProperty('favourite.1.name', favs[-1]["Label"])
            data = favs, "Favourites"
        elif info == 'similarlocal' and "dbid" in params:
            data = local_db.get_similar_movies(params["dbid"]), "SimilarLocalMovies"
        elif info == 'iconpanel':
            data = get_icon_panel(int(params["id"])), "IconPanel" + str(params["id"])
        elif info == 'autocomplete':
            data = get_autocomplete_items(params["id"]), "AutoComplete"
        elif info == 'weather':
            data = get_weather_images(), "WeatherImages"
        elif info == "sortletters":
            data = get_sort_letters(params["path"], params.get("id", "")), "SortLetters"

        # ACTIONS
        elif info == 't9input':
            resolve_url(params.get("handle"))
            from T9Search import T9Search
            dialog = T9Search(call=None,
                              start_value="")
            KodiJson.send_text(text=dialog.search_str)
        elif info in ['playmovie', 'playepisode', 'playmusicvideo', 'playalbum', 'playsong']:
            resolve_url(params.get("handle"))
            KodiJson.play_media(media_type=info.replace("play", ""),
                                dbid=params.get("dbid"),
                                resume=params.get("resume", "true"))
        elif info == "openinfodialog":
            resolve_url(params.get("handle"))
            dbid = xbmc.getInfoLabel("ListItem.DBID")
            if not dbid:
                dbid = xbmc.getInfoLabel("ListItem.Property(dbid)")
            if xbmc.getCondVisibility("Container.Content(movies)"):
                params = {"dbid": dbid,
                          "id": xbmc.getInfoLabel("ListItem.Property(id)"),
                          "name": xbmc.getInfoLabel("ListItem.Title")}
                start_info_actions(["extendedinfo"], params)
            elif xbmc.getCondVisibility("Container.Content(tvshows)"):
                params = {"dbid": dbid,
                          "id": xbmc.getInfoLabel("ListItem.Property(id)"),
                          "name": xbmc.getInfoLabel("ListItem.Title")}
                start_info_actions(["extendedtvinfo"], params)
            elif xbmc.getCondVisibility("Container.Content(seasons)"):
                params = {"tvshow": xbmc.getInfoLabel("ListItem.TVShowTitle"),
                          "season": xbmc.getInfoLabel("ListItem.Season")}
                start_info_actions(["seasoninfo"], params)
            elif xbmc.getCondVisibility("Container.Content(episodes)"):
                params = {"tvshow": xbmc.getInfoLabel("ListItem.TVShowTitle"),
                          "season": xbmc.getInfoLabel("ListItem.Season"),
                          "episode": xbmc.getInfoLabel("ListItem.Episode")}
                start_info_actions(["extendedepisodeinfo"], params)
            elif xbmc.getCondVisibility("Container.Content(actors) | Container.Content(directors)"):
                params = {"name": xbmc.getInfoLabel("ListItem.Label")}
                start_info_actions(["extendedactorinfo"], params)
            else:
                notify("Error", "Could not find valid content type")
        elif info == "ratedialog":
            resolve_url(params.get("handle"))
            if xbmc.getCondVisibility("Container.Content(movies)"):
                params = {"dbid": xbmc.getInfoLabel("ListItem.DBID"),
                          "id": xbmc.getInfoLabel("ListItem.Property(id)"),
                          "type": "movie"}
                start_info_actions(["ratemedia"], params)
            elif xbmc.getCondVisibility("Container.Content(tvshows)"):
                params = {"dbid": xbmc.getInfoLabel("ListItem.DBID"),
                          "id": xbmc.getInfoLabel("ListItem.Property(id)"),
                          "type": "tv"}
                start_info_actions(["ratemedia"], params)
            elif xbmc.getCondVisibility("Container.Content(episodes)"):
                params = {"tvshow": xbmc.getInfoLabel("ListItem.TVShowTitle"),
                          "season": xbmc.getInfoLabel("ListItem.Season"),
                          "type": "episode"}
                start_info_actions(["ratemedia"], params)
        elif info == 'youtubebrowser':
            resolve_url(params.get("handle"))
            wm.open_youtube_list(search_str=params.get("id", ""))
        elif info == 'moviedbbrowser':
            resolve_url(params.get("handle"))
            search_str = params.get("id", "")
            if not search_str and params.get("search", ""):
                result = xbmcgui.Dialog().input(heading=LANG(16017),
                                                type=xbmcgui.INPUT_ALPHANUM)
                if result and result > -1:
                    search_str = result
                else:
                    return None
            wm.open_video_list(search_str=search_str,
                               mode="search")
        elif info == 'extendedinfo':
            resolve_url(params.get("handle"))
            HOME.setProperty('infodialogs.active', "true")
            wm.open_movie_info(movie_id=params.get("id", ""),
                               dbid=params.get("dbid", None),
                               imdb_id=params.get("imdb_id", ""),
                               name=params.get("name", ""))
            HOME.clearProperty('infodialogs.active')
        elif info == 'extendedactorinfo':
            resolve_url(params.get("handle"))
            HOME.setProperty('infodialogs.active', "true")
            wm.open_actor_info(actor_id=params.get("id", ""),
                               name=params.get("name", ""))
            HOME.clearProperty('infodialogs.active')
        elif info == 'extendedtvinfo':
            resolve_url(params.get("handle"))
            HOME.setProperty('infodialogs.active', "true")
            wm.open_tvshow_info(tvshow_id=params.get("id", ""),
                                tvdb_id=params.get("tvdb_id", ""),
                                dbid=params.get("dbid", None),
                                imdb_id=params.get("imdb_id", ""),
                                name=params.get("name", ""))
            HOME.clearProperty('infodialogs.active')
        elif info == 'seasoninfo':
            resolve_url(params.get("handle"))
            HOME.setProperty('infodialogs.active', "true")
            wm.open_season_info(tvshow=params.get("tvshow"),
                                dbid=params.get("dbid"),
                                season=params.get("season"))
            HOME.clearProperty('infodialogs.active')
        elif info == 'extendedepisodeinfo':
            resolve_url(params.get("handle"))
            HOME.setProperty('infodialogs.active', "true")
            wm.open_episode_info(tvshow=params.get("tvshow"),
                                 tvshow_id=params.get("tvshow_id"),
                                 dbid=params.get("dbid"),
                                 episode=params.get("episode"),
                                 season=params.get("season"))
            HOME.clearProperty('infodialogs.active')
        elif info == 'albuminfo':
            resolve_url(params.get("handle"))
            if params.get("id", ""):
                album_details = AudioDB.get_album_details(params.get("id", ""))
                pass_dict_to_skin(album_details, params.get("prefix", ""))
        elif info == 'artistdetails':
            resolve_url(params.get("handle"))
            artist_details = AudioDB.get_artist_details(params["artistname"])
            pass_dict_to_skin(artist_details, params.get("prefix", ""))
        elif info == 'ratemedia':
            resolve_url(params.get("handle"))
            media_type = params.get("type", False)
            if media_type:
                if params.get("id") and params["id"]:
                    tmdb_id = params["id"]
                elif media_type == "movie":
                    tmdb_id = TheMovieDB.get_movie_tmdb_id(imdb_id=params.get("imdb_id", ""),
                                                           dbid=params.get("dbid", ""),
                                                           name=params.get("name", ""))
                elif media_type == "tv" and params["dbid"]:
                    tvdb_id = local_db.get_imdb_id(media_type="tvshow",
                                                   dbid=params["dbid"])
                    tmdb_id = TheMovieDB.get_show_tmdb_id(tvdb_id=tvdb_id)
                else:
                    return False
                TheMovieDB.set_rating_prompt(media_type=media_type,
                                             media_id=tmdb_id)
        elif info == 'setfocus':
            resolve_url(params.get("handle"))
            xbmc.executebuiltin("SetFocus(22222)")
        elif info == 'playliststats':
            resolve_url(params.get("handle"))
            get_playlist_stats(params.get("id", ""))
        elif info == 'slideshow':
            resolve_url(params.get("handle"))
            window_id = xbmcgui.getCurrentwindow_id()
            window = xbmcgui.Window(window_id)
            # focusid = Window.getFocusId()
            num_items = window.getFocus().getSelectedPosition()
            for i in range(0, num_items):
                notify(item.getProperty("Image"))
        elif info == 'action':
            resolve_url(params.get("handle"))
            for builtin in params.get("id", "").split("$$"):
                xbmc.executebuiltin(builtin)
            return None
        elif info == 'selectautocomplete':
            resolve_url(params.get("handle"))
            try:
                window_id = xbmcgui.getCurrentWindowDialogId()
                window = xbmcgui.Window(window_id)
            except:
                return None
            KodiJson.send_text(text=params.get("id"),
                               close_keyboard=False)
            # xbmc.executebuiltin("SendClick(103,32)")
            window.setFocusId(300)
        elif info == 'bounce':
            resolve_url(params.get("handle"))
            HOME.setProperty(params.get("name", ""), "True")
            xbmc.sleep(200)
            HOME.clearProperty(params.get("name", ""))
        elif info == "youtubevideo":
            resolve_url(params.get("handle"))
            xbmc.executebuiltin("Dialog.Close(all,true)")
            PLAYER.play_youtube_video(params.get("id", ""))
        elif info == 'playtrailer':
            resolve_url(params.get("handle"))
            xbmc.executebuiltin("ActivateWindow(busydialog)")
            if params.get("id", ""):
                movie_id = params.get("id", "")
            elif int(params.get("dbid", -1)) > 0:
                movie_id = local_db.get_imdb_id(media_type="movie",
                                                dbid=params["dbid"])
            elif params.get("imdb_id", ""):
                movie_id = get_movie_tmdb_id(params.get("imdb_id", ""))
            else:
                movie_id = ""
            if movie_id:
                trailer = TheMovieDB.get_trailer(movie_id)
                xbmc.executebuiltin("Dialog.Close(busydialog)")
                xbmc.sleep(100)
                if trailer:
                    PLAYER.play_youtube_video(trailer)
                elif params.get("title"):
                    wm.open_youtube_list(search_str=params.get("title", ""))
                else:
                    xbmc.executebuiltin("Dialog.Close(busydialog)")
        elif info == 'deletecache':
            resolve_url(params.get("handle"))
            HOME.clearProperties()
            import shutil
            for rel_path in os.listdir(ADDON_DATA_PATH):
                path = os.path.join(ADDON_DATA_PATH, rel_path)
                try:
                    if os.path.isdir(path):
                        shutil.rmtree(path)
                except Exception as e:
                    log(e)
            notify("Cache deleted")
        elif info == 'syncwatchlist':
            pass
        elif info == "widgetdialog":
            resolve_url(params.get("handle"))
            widget_selectdialog()
        listitems, prefix = data
        if params.get("handle"):
            xbmcplugin.addSortMethod(params.get("handle"), xbmcplugin.SORT_METHOD_TITLE)
            xbmcplugin.addSortMethod(params.get("handle"), xbmcplugin.SORT_METHOD_VIDEO_YEAR)
            xbmcplugin.addSortMethod(params.get("handle"), xbmcplugin.SORT_METHOD_DURATION)
            if info.endswith("shows"):
                xbmcplugin.setContent(params.get("handle"), 'tvshows')
            else:
                xbmcplugin.setContent(params.get("handle"), 'movies')
        pass_list_to_skin(name=prefix,
                          data=listitems,
                          prefix=params.get("prefix", ""),
                          handle=params.get("handle", ""),
                          limit=params.get("limit", 20))
コード例 #45
0
ファイル: process.py プロジェクト: metate/script.extendedinfo
def start_info_actions(info, params):
    if "artistname" in params:
        params["artistname"] = params.get("artistname", "").split(" feat. ")[0].strip()
        params["artist_mbid"] = fetch_musicbrainz_id(params["artistname"])
    log(info)
    prettyprint(params)
    if "prefix" in params and not params["prefix"].endswith('.'):
        params["prefix"] = params["prefix"] + '.'

    # Audio
    if info == 'discography':
        discography = AudioDB.get_artist_discography(params["artistname"])
        if not discography:
            discography = LastFM.get_artist_albums(params.get("artist_mbid"))
        return discography
    elif info == 'mostlovedtracks':
        return AudioDB.get_most_loved_tracks(params["artistname"])
    elif info == 'trackdetails':
        return AudioDB.get_track_details(params.get("id", ""))
    elif info == 'topartists':
        return LastFM.get_top_artists()
    elif info == 'latestdbmovies':
        return LocalDB.local_db.get_movies('"sort": {"order": "descending", "method": "dateadded"}',
                                           params.get("limit", 10))
    elif info == 'randomdbmovies':
        return LocalDB.local_db.get_movies('"sort": {"method": "random"}', params.get("limit", 10))
    elif info == 'inprogressdbmovies':
        method = '"sort": {"order": "descending", "method": "lastplayed"}, "filter": {"field": "inprogress", "operator": "true", "value": ""}'
        return LocalDB.local_db.get_movies(method, params.get("limit", 10))
#  RottenTomatoesMovies
    elif info == 'intheatermovies':
        return RottenTomatoes.get_movies("movies/in_theaters")
    elif info == 'boxofficemovies':
        return RottenTomatoes.get_movies("movies/box_office")
    elif info == 'openingmovies':
        return RottenTomatoes.get_movies("movies/opening")
    elif info == 'comingsoonmovies':
        return RottenTomatoes.get_movies("movies/upcoming")
    elif info == 'toprentalmovies':
        return RottenTomatoes.get_movies("dvds/top_rentals")
    elif info == 'currentdvdmovies':
        return RottenTomatoes.get_movies("dvds/current_releases")
    elif info == 'newdvdmovies':
        return RottenTomatoes.get_movies("dvds/new_releases")
    elif info == 'upcomingdvdmovies':
        return RottenTomatoes.get_movies("dvds/upcoming")
    #  The MovieDB
    elif info == 'incinemamovies':
        return tmdb.get_tmdb_movies("now_playing")
    elif info == 'upcomingmovies':
        return tmdb.get_tmdb_movies("upcoming")
    elif info == 'topratedmovies':
        return tmdb.get_tmdb_movies("top_rated")
    elif info == 'popularmovies':
        return tmdb.get_tmdb_movies("popular")
    elif info == 'ratedmovies':
        return tmdb.get_rated_media_items("movies")
    elif info == 'starredmovies':
        return tmdb.get_fav_items("movies")
    elif info == 'accountlists':
        account_lists = tmdb.handle_misc(tmdb.get_account_lists())
        for item in account_lists:
            item["directory"] = True
        return account_lists
    elif info == 'listmovies':
        return tmdb.get_movies_from_list(params["id"])
    elif info == 'airingtodaytvshows':
        return tmdb.get_tmdb_shows("airing_today")
    elif info == 'onairtvshows':
        return tmdb.get_tmdb_shows("on_the_air")
    elif info == 'topratedtvshows':
        return tmdb.get_tmdb_shows("top_rated")
    elif info == 'populartvshows':
        return tmdb.get_tmdb_shows("popular")
    elif info == 'ratedtvshows':
        return tmdb.get_rated_media_items("tv")
    elif info == 'starredtvshows':
        return tmdb.get_fav_items("tv")
    elif info == 'similarmovies':
        movie_id = params.get("id")
        if not movie_id:
            movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                              dbid=params.get("dbid"))
        if movie_id:
            return tmdb.get_similar_movies(movie_id)
    elif info == 'similartvshows':
        tvshow_id = None
        dbid = params.get("dbid")
        name = params.get("name")
        tmdb_id = params.get("tmdb_id")
        tvdb_id = params.get("tvdb_id")
        imdb_id = params.get("imdb_id")
        if tmdb_id:
            tvshow_id = tmdb_id
        elif dbid and int(dbid) > 0:
            tvdb_id = LocalDB.local_db.get_imdb_id("tvshow", dbid)
            if tvdb_id:
                tvshow_id = tmdb.get_show_tmdb_id(tvdb_id)
        elif tvdb_id:
            tvshow_id = tmdb.get_show_tmdb_id(tvdb_id)
        elif imdb_id:
            tvshow_id = tmdb.get_show_tmdb_id(imdb_id, "imdb_id")
        elif name:
            tvshow_id = tmdb.search_media(media_name=name,
                                          year="",
                                          media_type="tv")
        if tvshow_id:
            return tmdb.get_similar_tvshows(tvshow_id)
    elif info == 'studio':
        if params.get("id"):
            return tmdb.get_company_data(params["id"])
        elif params.get("studio"):
            company_data = tmdb.search_company(params["studio"])
            if company_data:
                return tmdb.get_company_data(company_data[0]["id"])
    elif info == 'set':
        if params.get("dbid") and "show" not in params.get("type", ""):
            name = LocalDB.local_db.get_set_name(params["dbid"])
            if name:
                params["setid"] = tmdb.get_set_id(name)
        if params.get("setid"):
            set_data, _ = tmdb.get_set_movies(params["setid"])
            return set_data
    elif info == 'movielists':
        movie_id = params.get("id")
        if not movie_id:
            movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                              dbid=params.get("dbid"))
        if movie_id:
            return tmdb.get_movie_lists(movie_id)
    elif info == 'keywords':
        movie_id = params.get("id")
        if not movie_id:
            movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                              dbid=params.get("dbid"))
        if movie_id:
            return tmdb.get_keywords(movie_id)
    elif info == 'popularpeople':
        return tmdb.get_popular_actors()
    elif info == 'directormovies':
        director_info = tmdb.get_person_info(person_label=params.get("director"),
                                             skip_dialog=True)
        if director_info and director_info.get("id"):
            movies = tmdb.get_person_movies(director_info["id"])
            for item in movies:
                del item["credit_id"]
            return merge_dict_lists(movies, key="department")
    elif info == 'writermovies':
        writer = params.get("writer")
        if writer and not writer.split(" / ")[0] == params.get("director", "").split(" / ")[0]:
            writer_info = tmdb.get_person_info(person_label=writer,
                                               skip_dialog=True)
            if writer_info and writer_info.get("id"):
                movies = tmdb.get_person_movies(writer_info["id"])
                for item in movies:
                    del item["credit_id"]
                return merge_dict_lists(movies, key="department")
    elif info == 'traktsimilarmovies':
        if params.get("id") or params.get("dbid"):
            if params.get("dbid"):
                movie_id = LocalDB.local_db.get_imdb_id("movie", params["dbid"])
            else:
                movie_id = params["id"]
            return Trakt.get_similar("movie", movie_id)
    elif info == 'traktsimilartvshows':
        if params.get("id") or params.get("dbid"):
            if params.get("dbid"):
                if params.get("type") == "episode":
                    tvshow_id = LocalDB.local_db.get_tvshow_id_by_episode(params["dbid"])
                else:
                    tvshow_id = LocalDB.local_db.get_imdb_id(media_type="tvshow",
                                                             dbid=params["dbid"])
            else:
                tvshow_id = params["id"]
            return Trakt.get_similar("show", tvshow_id)
    elif info == 'airingepisodes':
        return Trakt.get_calendar_shows("shows")
    elif info == 'premiereepisodes':
        return Trakt.get_calendar_shows("premieres")
    elif info == 'trendingshows':
        return Trakt.get_trending_shows()
    elif info == 'trendingmovies':
        return Trakt.get_trending_movies()
    elif info == 'similarartistsinlibrary':
        return LocalDB.local_db.get_similar_artists(params.get("artist_mbid"))
    elif info == 'trackinfo':
        HOME.clearProperty('%sSummary' % params.get("prefix", ""))
        if params["artistname"] and params["trackname"]:
            track_info = LastFM.get_track_info(artist_name=params["artistname"],
                                               track=params["trackname"])
            HOME.setProperty('%sSummary' % params.get("prefix", ""), track_info["summary"])
    elif info == 'topartistsnearevents':
        artists = LocalDB.local_db.get_artists()
        import BandsInTown
        return BandsInTown.get_near_events(artists[0:49])
    elif info == 'youtubesearch':
        HOME.setProperty('%sSearchValue' % params.get("prefix", ""), params.get("id", ""))
        if params.get("id"):
            listitems = YouTube.search(search_str=params.get("id", ""),
                                       hd=params.get("hd", ""),
                                       orderby=params.get("orderby", "relevance"))
            return listitems.get("listitems", [])
    elif info == 'youtubeplaylist':
        return YouTube.get_playlist_videos(params.get("id", ""))
    elif info == 'youtubeusersearch':
        user_name = params.get("id")
        if user_name:
            playlists = YouTube.get_user_playlists(user_name)
            return YouTube.get_playlist_videos(playlists["uploads"])
    elif info == 'favourites':
        if params.get("id"):
            favs = get_favs_by_type(params["id"])
        else:
            favs = get_favs()
            HOME.setProperty('favourite.count', str(len(favs)))
            if favs:
                HOME.setProperty('favourite.1.name', favs[-1]["Label"])
        return favs
    elif info == 'similarlocalmovies' and "dbid" in params:
        return LocalDB.local_db.get_similar_movies(params["dbid"])
    elif info == 'iconpanel':
        return get_icon_panel(int(params["id"])), "IconPanel" + str(params["id"])
    elif info == 'weather':
        return get_weather_images()
    # ACTIONS
    resolve_url(params.get("handle"))
    if info == 't9input':
        import T9Search
        dialog = T9Search.T9Search(call=None,
                                   start_value="")
        KodiJson.send_text(text=dialog.search_str)
    elif info in ['playmovie', 'playepisode', 'playmusicvideo', 'playalbum', 'playsong']:
        KodiJson.play_media(media_type=info.replace("play", ""),
                            dbid=params.get("dbid"),
                            resume=params.get("resume", "true"))
    elif info == "openinfodialog":
        if xbmc.getCondVisibility("System.HasModalDialog"):
            container_id = ""
        else:
            container_id = "Container(%s)" % get_infolabel("System.CurrentControlId")
        dbid = get_infolabel("%sListItem.DBID" % container_id)
        db_type = get_infolabel("%sListItem.DBType" % container_id)
        if not dbid:
            dbid = get_infolabel("%sListItem.Property(dbid)" % container_id)
        if db_type == "movie":
            params = {"dbid": dbid,
                      "id": get_infolabel("%sListItem.Property(id)" % container_id),
                      "name": get_infolabel("%sListItem.Title" % container_id)}
            start_info_actions("extendedinfo", params)
        elif db_type == "tvshow":
            params = {"dbid": dbid,
                      "tvdb_id": get_infolabel("%sListItem.Property(tvdb_id)" % container_id),
                      "id": get_infolabel("%sListItem.Property(id)" % container_id),
                      "name": get_infolabel("%sListItem.Title" % container_id)}
            start_info_actions("extendedtvinfo", params)
        elif db_type == "season":
            params = {"tvshow": get_infolabel("%sListItem.TVShowTitle" % container_id),
                      "season": get_infolabel("%sListItem.Season" % container_id)}
            start_info_actions("seasoninfo", params)
        elif db_type == "episode":
            params = {"tvshow": get_infolabel("%sListItem.TVShowTitle" % container_id),
                      "season": get_infolabel("%sListItem.Season" % container_id),
                      "episode": get_infolabel("%sListItem.Episode" % container_id)}
            start_info_actions("extendedepisodeinfo", params)
        elif db_type in ["actor", "director"]:
            params = {"name": get_infolabel("%sListItem.Label" % container_id)}
            start_info_actions("extendedactorinfo", params)
        else:
            notify("Error", "Could not find valid content type")
    elif info == "ratedialog":
        if xbmc.getCondVisibility("System.HasModalDialog"):
            container_id = ""
        else:
            container_id = "Container(%s)" % get_infolabel("System.CurrentControlId")
        dbid = get_infolabel("%sListItem.DBID" % container_id)
        db_type = get_infolabel("%sListItem.DBType" % container_id)
        if not dbid:
            dbid = get_infolabel("%sListItem.Property(dbid)" % container_id)
        if db_type == "movie":
            params = {"dbid": dbid,
                      "id": get_infolabel("%sListItem.Property(id)" % container_id),
                      "type": "movie"}
            start_info_actions("ratemedia", params)
        elif db_type == "tvshow":
            params = {"dbid": dbid,
                      "id": get_infolabel("%sListItem.Property(id)" % container_id),
                      "type": "tv"}
            start_info_actions("ratemedia", params)
        if db_type == "episode":
            params = {"tvshow": get_infolabel("%sListItem.TVShowTitle" % container_id),
                      "season": get_infolabel("%sListItem.Season" % container_id),
                      "type": "episode"}
            start_info_actions("ratemedia", params)
    elif info == 'youtubebrowser':
        wm.open_youtube_list(search_str=params.get("id", ""))
    elif info == 'moviedbbrowser':
        active = HOME.getProperty('infodialogs.active')
        if active:
            return None
        HOME.setProperty('infodialogs.active', "true")
        search_str = params.get("id", "")
        if not search_str and params.get("search"):
            result = xbmcgui.Dialog().input(heading=LANG(16017),
                                            type=xbmcgui.INPUT_ALPHANUM)
            if result and result > -1:
                search_str = result
            else:
                return None
        wm.open_video_list(search_str=search_str,
                           mode="search")
        HOME.clearProperty('infodialogs.active')
    elif info == 'extendedinfo':
        active = HOME.getProperty('infodialogs.active')
        if active:
            return None
        HOME.setProperty('infodialogs.active', "true")
        wm.open_movie_info(movie_id=params.get("id"),
                           dbid=params.get("dbid"),
                           imdb_id=params.get("imdb_id"),
                           name=params.get("name"))
        HOME.clearProperty('infodialogs.active')
    elif info == 'extendedactorinfo':
        active = HOME.getProperty('infodialogs.active')
        if active:
            return None
        HOME.setProperty('infodialogs.active', "true")
        wm.open_actor_info(actor_id=params.get("id"),
                           name=params.get("name"))
        HOME.clearProperty('infodialogs.active')
    elif info == 'extendedtvinfo':
        active = HOME.getProperty('infodialogs.active')
        if active:
            return None
        HOME.setProperty('infodialogs.active', "true")
        wm.open_tvshow_info(tmdb_id=params.get("id"),
                            tvdb_id=params.get("tvdb_id"),
                            dbid=params.get("dbid"),
                            imdb_id=params.get("imdb_id"),
                            name=params.get("name"))
        HOME.clearProperty('infodialogs.active')
    elif info == 'seasoninfo':
        active = HOME.getProperty('infodialogs.active')
        if active:
            return None
        HOME.setProperty('infodialogs.active', "true")
        wm.open_season_info(tvshow=params.get("tvshow"),
                            dbid=params.get("dbid"),
                            season=params.get("season"))
        HOME.clearProperty('infodialogs.active')
    elif info == 'extendedepisodeinfo':
        active = HOME.getProperty('infodialogs.active')
        if active:
            return None
        HOME.setProperty('infodialogs.active', "true")
        wm.open_episode_info(tvshow=params.get("tvshow"),
                             tvshow_id=params.get("tvshow_id"),
                             dbid=params.get("dbid"),
                             episode=params.get("episode"),
                             season=params.get("season"))
        HOME.clearProperty('infodialogs.active')
    elif info == 'albuminfo':
        if params.get("id"):
            album_details = AudioDB.get_album_details(params.get("id"))
            pass_dict_to_skin(album_details, params.get("prefix", ""))
    elif info == 'artistdetails':
        artist_details = AudioDB.get_artist_details(params["artistname"])
        pass_dict_to_skin(artist_details, params.get("prefix", ""))
    elif info == 'ratemedia':
        media_type = params.get("type")
        if media_type:
            if params.get("id"):
                tmdb_id = params["id"]
            elif media_type == "movie":
                tmdb_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
                                                 dbid=params.get("dbid"),
                                                 name=params.get("name"))
            elif media_type == "tv" and params.get("dbid"):
                tvdb_id = LocalDB.local_db.get_imdb_id(media_type="tvshow",
                                                       dbid=params["dbid"])
                tmdb_id = tmdb.get_show_tmdb_id(tvdb_id=tvdb_id)
            else:
                return False
            tmdb.set_rating_prompt(media_type=media_type,
                                   media_id=tmdb_id,
                                   dbid=params.get("dbid"))
    elif info == 'slideshow':
        window_id = xbmcgui.getCurrentwindow_id()
        window = xbmcgui.Window(window_id)
        # focusid = Window.getFocusId()
        num_items = window.getFocus().getSelectedPosition()
        for i in range(0, num_items):
            notify(item.getProperty("Image"))
    elif info == 'action':
        for builtin in params.get("id", "").split("$$"):
            xbmc.executebuiltin(builtin)
    elif info == "youtubevideo":
        xbmc.executebuiltin("Dialog.Close(all,true)")
        VideoPlayer.PLAYER.play_youtube_video(params.get("id", ""))
    elif info == 'playtrailer':
        xbmc.executebuiltin("ActivateWindow(busydialog)")
        if params.get("id"):
            movie_id = params["id"]
        elif int(params.get("dbid", -1)) > 0:
            movie_id = LocalDB.local_db.get_imdb_id(media_type="movie",
                                                    dbid=params["dbid"])
        elif params.get("imdb_id"):
            movie_id = tmdb.get_movie_tmdb_id(params["imdb_id"])
        else:
            movie_id = ""
        if movie_id:
            trailer = tmdb.get_trailer(movie_id)
            xbmc.executebuiltin("Dialog.Close(busydialog)")
            time.sleep(0.1)
            if trailer:
                VideoPlayer.PLAYER.play_youtube_video(trailer)
            elif params.get("title"):
                wm.open_youtube_list(search_str=params["title"])
            else:
                xbmc.executebuiltin("Dialog.Close(busydialog)")
    elif info == 'deletecache':
        HOME.clearProperties()
        import shutil
        for rel_path in os.listdir(ADDON_DATA_PATH):
            path = os.path.join(ADDON_DATA_PATH, rel_path)
            try:
                if os.path.isdir(path):
                    shutil.rmtree(path)
            except Exception as e:
                log(e)
        notify("Cache deleted")
    elif info == 'syncwatchlist':
        pass
コード例 #46
0
def get_episodes(content):
    shows = ItemList(content_type="episodes")
    url = ""
    if content == "shows":
        url = 'calendars/shows/%s/14' % datetime.date.today()
    elif content == "premieres":
        url = 'calendars/shows/premieres/%s/14' % datetime.date.today()
    results = get_data(url=url, params={"extended": "full"}, cache_days=0.3)
    count = 1
    if not results:
        return None
    for day in results.iteritems():
        for episode in day[1]:
            ep = episode["episode"]
            tv = episode["show"]
            title = ep["title"] if ep["title"] else ""
            label = u"{0} - {1}x{2}. {3}".format(tv["title"], ep["season"],
                                                 ep["number"], title)
            show = VideoItem(label=label,
                             path=PLUGIN_BASE +
                             'extendedtvinfo&&tvdb_id=%s' % tv["ids"]["tvdb"])
            show.set_infos({
                'title':
                title,
                'aired':
                ep["first_aired"],
                'season':
                ep["season"],
                'episode':
                ep["number"],
                'tvshowtitle':
                tv["title"],
                'mediatype':
                "episode",
                'year':
                tv.get("year"),
                'duration':
                tv["runtime"] * 60 if tv["runtime"] else "",
                'studio':
                tv["network"],
                'plot':
                tv["overview"],
                'country':
                tv["country"],
                'status':
                tv["status"],
                'trailer':
                tv["trailer"],
                'imdbnumber':
                ep["ids"]["imdb"],
                'rating':
                tv["rating"],
                'genre':
                " / ".join(tv["genres"]),
                'mpaa':
                tv["certification"]
            })
            show.set_properties({
                'tvdb_id': ep["ids"]["tvdb"],
                'id': ep["ids"]["tvdb"],
                'imdb_id': ep["ids"]["imdb"],
                'homepage': tv["homepage"]
            })
            if tv["ids"].get("tmdb"):
                art_info = tmdb.get_tvshow(tv["ids"]["tmdb"], light=True)
                show.set_artwork(
                    tmdb.get_image_urls(poster=art_info.get("poster_path"),
                                        fanart=art_info.get("backdrop_path")))
            shows.append(show)
            count += 1
            if count > 20:
                break
    return shows
コード例 #47
0
def handle_tvshows(results):
    shows = ItemList(content_type="tvshows")
    for i in results:
        item = i["show"] if "show" in i else i
        airs = item.get("airs", {})
        show = VideoItem(label=item["title"],
                         path='%sextendedtvinfo&&tvdb_id=%s' %
                         (PLUGIN_BASE, item['ids']["tvdb"]))
        show.set_infos({
            'mediatype':
            "tvshow",
            'title':
            item["title"],
            'duration':
            item["runtime"] * 60 if item["runtime"] else "",
            'year':
            item["year"],
            'premiered':
            item["first_aired"][:10],
            'country':
            item["country"],
            'rating':
            round(item["rating"], 1),
            'votes':
            item["votes"],
            'imdbnumber':
            item['ids']["imdb"],
            'mpaa':
            item["certification"],
            'trailer':
            item["trailer"],
            'status':
            item.get("status"),
            'studio':
            item["network"],
            'genre':
            " / ".join(item["genres"]),
            'plot':
            item["overview"]
        })
        show.set_properties({
            'id': item['ids']["tmdb"],
            'tvdb_id': item['ids']["tvdb"],
            'imdb_id': item['ids']["imdb"],
            'trakt_id': item['ids']["trakt"],
            'language': item["language"],
            'aired_episodes': item["aired_episodes"],
            'homepage': item["homepage"],
            'airday': airs.get("day"),
            'airshorttime': airs.get("time"),
            'watchers': item.get("watchers")
        })
        art_info = tmdb.get_tvshow(item["ids"]["tmdb"], light=True)
        show.set_artwork(
            tmdb.get_image_urls(poster=art_info.get("poster_path"),
                                fanart=art_info.get("backdrop_path")))
        shows.append(show)
    shows = local_db.merge_with_local(media_type="tvshow",
                                      items=shows,
                                      library_first=False)
    shows.set_sorts(["mpaa", "duration"])
    return shows