Jellyfin/jellyfin-kodi
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin-kodi.git synced 2024-11-10 04:06:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
jellyfin-kodi/jellyfin_kodi/entrypoint/default.py

1328 lines
40 KiB
Python
Raw Blame History

# -*- coding: utf-8 -*-
from __future__ import division, absolute_import, print_function, unicode_literals
#################################################################################################
import json
import sys
import os
from urllib.parse import parse_qsl, urlencode
from kodi_six import xbmc, xbmcvfs, xbmcgui, xbmcplugin, xbmcaddon
from .. import client
from ..database import reset, get_sync, Database, jellyfin_db, get_credentials
from ..objects import Objects, Actions
from ..helper import (
translate,
event,
settings,
window,
dialog,
api,
JSONRPC,
LazyLogger,
)
from ..helper.utils import JsonDebugPrinter, translate_path, kodi_version
from ..jellyfin import Jellyfin
#################################################################################################
LOG = LazyLogger(__name__)
ADDON_BASE_URL = sys.argv[0]
try:
PROCESS_HANDLE = int(sys.argv[1])
QUERY_STRING = sys.argv[2]
except IndexError:
pass
#################################################################################################
class Events(object):
def __init__(self):
"""Parse the parameters. Reroute to our service.py
where user is fully identified already.
"""
base_url = ADDON_BASE_URL
path = QUERY_STRING
try:
params = dict(parse_qsl(path[1:]))
except Exception:
params = {}
mode = params.get("mode")
server = params.get("server")
if server == "None":
server = None
jellyfin_client = Jellyfin(server).get_client()
api_client = jellyfin_client.jellyfin
addon_data = translate_path(
"special://profile/addon_data/plugin.video.jellyfin/data.json"
)
try:
with open(addon_data, "rb") as infile:
data = json.load(infile)
server_data = data["Servers"][0]
api_client.config.data["auth.server"] = server_data.get("address")
api_client.config.data["auth.server-name"] = server_data.get("Name")
api_client.config.data["auth.user_id"] = server_data.get("UserId")
api_client.config.data["auth.token"] = server_data.get("AccessToken")
except Exception as e:
LOG.warning("Addon appears to not be configured yet: {}".format(e))
LOG.info("path: %s params: %s", path, JsonDebugPrinter(params))
if "/extrafanart" in base_url:
jellyfin_path = path[1:]
jellyfin_id = params.get("id")
get_fanart(jellyfin_id, jellyfin_path, server, api_client)
elif "/Extras" in base_url or "/VideoFiles" in base_url:
jellyfin_path = path[1:]
jellyfin_id = params.get("id")
get_video_extras(jellyfin_id, jellyfin_path, server, api_client)
elif mode == "play":
item = api_client.get_item(params["id"])
item["resumePlayback"] = sys.argv[3].split(":")[1] == "true"
Actions(server, api_client).play(
item,
params.get("dbid"),
params.get("transcode") == "true",
playlist=params.get("playlist") == "true",
)
elif mode == "playlist":
api_client.post_session(
api_client.config.data["app.session"],
"Playing",
{
"PlayCommand": "PlayNow",
"ItemIds": params["id"],
"StartPositionTicks": 0,
},
)
elif mode == "deviceid":
client.reset_device_id()
elif mode == "reset":
reset()
elif mode == "delete":
delete_item()
elif mode == "refreshboxsets":
event("SyncLibrary", {"Id": "Boxsets:Refresh"})
elif mode == "nextepisodes":
get_next_episodes(params["id"], params["limit"])
elif mode == "browse":
browse(
params.get("type"),
params.get("id"),
params.get("folder"),
server,
api_client,
)
elif mode == "synclib":
event("SyncLibrary", {"Id": params.get("id")})
elif mode == "updatelib":
event("SyncLibrary", {"Id": params.get("id"), "Update": True})
elif mode == "repairlib":
event("RepairLibrary", {"Id": params.get("id")})
elif mode == "removelib":
event("RemoveLibrary", {"Id": params.get("id")})
elif mode == "repairlibs":
event("RepairLibrarySelection")
elif mode == "updatelibs":
event("SyncLibrarySelection")
elif mode == "removelibs":
event("RemoveLibrarySelection")
elif mode == "addlibs":
event("AddLibrarySelection")
elif mode == "addserver":
event("AddServer")
elif mode == "login":
event("ServerConnect", {"Id": server})
elif mode == "removeserver":
event("RemoveServer", {"Id": server})
elif mode == "settings":
xbmc.executebuiltin("Addon.OpenSettings(plugin.video.jellyfin)")
elif mode == "adduser":
add_user(api_client)
elif mode == "updatepassword":
event("UpdatePassword")
elif mode == "thememedia":
get_themes(api_client)
elif mode == "managelibs":
manage_libraries()
elif mode == "backup":
backup()
elif mode == "restartservice":
window("jellyfin.restart.bool", True)
elif (
mode is None
and not params
and base_url != "plugin://plugin.video.jellyfin/"
):
# Used when selecting "Browse" from a context menu, see #548
item_id = base_url.strip("/").split("/")[-1]
browse("", item_id, None, server, api_client)
else:
listing()
def listing():
"""Display all jellyfin nodes and dynamic entries when appropriate."""
total = int(window("Jellyfin.nodes.total") or 0)
sync = get_sync()
whitelist = [x.replace("Mixed:", "") for x in sync["Whitelist"]]
servers = get_credentials()["Servers"][1:]
for i in range(total):
window_prop = "Jellyfin.nodes.%s" % i
path = window("%s.index" % window_prop)
if not path:
path = window("%s.content" % window_prop) or window("%s.path" % window_prop)
label = window("%s.title" % window_prop)
node = window("%s.type" % window_prop)
artwork = window("%s.artwork" % window_prop)
view_id = window("%s.id" % window_prop)
context = []
if (
view_id
and node in ("movies", "tvshows", "musicvideos", "music", "mixed")
and view_id not in whitelist
):
label = "%s %s" % (label, translate(33166))
context.append(
(
translate(33123),
"RunPlugin(plugin://plugin.video.jellyfin/?mode=synclib&id=%s)"
% view_id,
)
)
if (
view_id
and node in ("movies", "tvshows", "musicvideos", "music")
and view_id in whitelist
):
context.append(
(
translate(33136),
"RunPlugin(plugin://plugin.video.jellyfin/?mode=updatelib&id=%s)"
% view_id,
)
)
context.append(
(
translate(33132),
"RunPlugin(plugin://plugin.video.jellyfin/?mode=repairlib&id=%s)"
% view_id,
)
)
context.append(
(
translate(33133),
"RunPlugin(plugin://plugin.video.jellyfin/?mode=removelib&id=%s)"
% view_id,
)
)
LOG.debug("--[ listing/%s/%s ] %s", node, label, path)
if path:
directory(label, path, artwork=artwork, context=context)
for server in servers:
context = []
if server.get("ManualAddress"):
context.append(
(
translate(33141),
"RunPlugin(plugin://plugin.video.jellyfin/?mode=removeserver&server=%s)"
% server["Id"],
)
)
if "AccessToken" not in server:
directory(
"%s (%s)" % (server["Name"], translate(30539)),
"plugin://plugin.video.jellyfin/?mode=login&server=%s" % server["Id"],
False,
context=context,
)
else:
directory(
server["Name"],
"plugin://plugin.video.jellyfin/?mode=browse&server=%s" % server["Id"],
context=context,
)
directory(translate(33194), "plugin://plugin.video.jellyfin/?mode=managelibs", True)
directory(translate(33134), "plugin://plugin.video.jellyfin/?mode=addserver", False)
directory(translate(33054), "plugin://plugin.video.jellyfin/?mode=adduser", False)
directory(translate(5), "plugin://plugin.video.jellyfin/?mode=settings", False)
directory(
translate(33161), "plugin://plugin.video.jellyfin/?mode=updatepassword", False
)
directory(translate(33058), "plugin://plugin.video.jellyfin/?mode=reset", False)
directory(
translate(33180), "plugin://plugin.video.jellyfin/?mode=restartservice", False
)
if settings("backupPath"):
directory(
translate(33092), "plugin://plugin.video.jellyfin/?mode=backup", False
)
xbmcplugin.setContent(PROCESS_HANDLE, "files")
xbmcplugin.endOfDirectory(PROCESS_HANDLE)
def directory(label, path, folder=True, artwork=None, fanart=None, context=None):
"""Add directory listitem. context should be a list of tuples [(label, action)*]"""
li = dir_listitem(label, path, artwork, fanart)
if context:
li.addContextMenuItems(context)
xbmcplugin.addDirectoryItem(PROCESS_HANDLE, path, li, folder)
return li
def dir_listitem(label, path, artwork=None, fanart=None):
"""Gets the icon paths for default node listings"""
li = xbmcgui.ListItem(label, path=path)
li.setArt(
{
"thumb": artwork
or "special://home/addons/plugin.video.jellyfin/resources/icon.png",
"fanart": fanart
or "special://home/addons/plugin.video.jellyfin/resources/fanart.png",
"landscape": artwork
or fanart
or "special://home/addons/plugin.video.jellyfin/resources/fanart.png",
}
)
return li
def manage_libraries():
directory(
translate(33098), "plugin://plugin.video.jellyfin/?mode=refreshboxsets", False
)
directory(translate(33154), "plugin://plugin.video.jellyfin/?mode=addlibs", False)
directory(
translate(33139), "plugin://plugin.video.jellyfin/?mode=updatelibs", False
)
directory(
translate(33140), "plugin://plugin.video.jellyfin/?mode=repairlibs", False
)
directory(
translate(33184), "plugin://plugin.video.jellyfin/?mode=removelibs", False
)
directory(
translate(33060), "plugin://plugin.video.jellyfin/?mode=thememedia", False
)
xbmcplugin.setContent(PROCESS_HANDLE, "files")
xbmcplugin.endOfDirectory(PROCESS_HANDLE)
def browse(media, view_id=None, folder=None, server_id=None, api_client=None):
"""Browse content dynamically."""
LOG.info("--[ v:%s/%s ] %s", view_id, media, folder)
if not window("jellyfin_online.bool") and server_id is None:
monitor = xbmc.Monitor()
for _i in range(300):
if window("jellyfin_online.bool"):
break
elif monitor.waitForAbort(0.1):
return
else:
LOG.error("Default server is not online.")
return
folder = folder.lower() if folder else None
if folder is None and media in ("homevideos", "movies", "books", "audiobooks"):
return browse_subfolders(media, view_id, server_id)
if folder and folder == "firstletter":
return browse_letters(media, view_id, server_id)
if view_id:
view = api_client.get_item(view_id)
xbmcplugin.setPluginCategory(PROCESS_HANDLE, view["Name"])
content_type = "files"
if media in (
"tvshows",
"seasons",
"episodes",
"movies",
"musicvideos",
"songs",
"albums",
):
content_type = media
elif media in ("homevideos", "photos"):
content_type = "images"
elif media in ("books", "audiobooks"):
content_type = "videos"
elif media == "music":
content_type = "artists"
if folder == "recentlyadded":
listing = api_client.get_recently_added(None, view_id, None)
elif folder == "genres":
listing = api_client.get_genres(view_id)
elif media == "livetv":
listing = api_client.get_channels()
elif folder == "unwatched":
listing = get_filtered_section(
view_id,
None,
None,
None,
None,
None,
["IsUnplayed"],
None,
server_id,
api_client,
)
elif folder == "favorite":
listing = get_filtered_section(
view_id,
None,
None,
None,
None,
None,
["IsFavorite"],
None,
server_id,
api_client,
)
elif folder == "inprogress":
listing = get_filtered_section(
view_id,
None,
None,
None,
None,
None,
["IsResumable"],
None,
server_id,
api_client,
)
elif folder == "boxsets":
listing = get_filtered_section(
view_id,
get_media_type("boxsets"),
None,
True,
None,
None,
None,
None,
server_id,
api_client,
)
elif folder == "random":
listing = get_filtered_section(
view_id,
get_media_type(content_type),
25,
True,
"Random",
None,
None,
None,
server_id,
api_client,
)
elif (folder or "").startswith("firstletter-"):
listing = get_filtered_section(
view_id,
get_media_type(content_type),
None,
None,
None,
None,
None,
{"NameStartsWith": folder.split("-")[1]},
server_id,
api_client,
)
elif (folder or "").startswith("genres-"):
listing = get_filtered_section(
view_id,
get_media_type(content_type),
None,
None,
None,
None,
None,
{"GenreIds": folder.split("-")[1]},
server_id,
api_client,
)
elif folder == "favepisodes":
listing = get_filtered_section(
None,
get_media_type(content_type),
25,
None,
None,
None,
["IsFavorite"],
None,
server_id,
api_client,
)
elif folder and media == "playlists":
listing = get_filtered_section(
folder,
get_media_type(content_type),
None,
False,
"None",
None,
None,
None,
server_id,
api_client,
)
elif media == "homevideos":
listing = get_filtered_section(
folder or view_id,
get_media_type(content_type),
None,
False,
None,
None,
None,
None,
server_id,
api_client,
)
elif media in ["movies", "episodes"]:
listing = get_filtered_section(
folder or view_id,
get_media_type(content_type),
None,
True,
None,
None,
None,
None,
server_id,
api_client,
)
elif media in ("boxset", "library"):
listing = get_filtered_section(
folder or view_id,
None,
None,
True,
None,
None,
None,
None,
server_id,
api_client,
)
elif media == "boxsets":
listing = get_filtered_section(
folder or view_id,
None,
None,
False,
None,
None,
["Boxsets"],
None,
server_id,
api_client,
)
elif media == "tvshows":
listing = get_filtered_section(
folder or view_id,
get_media_type(content_type),
None,
True,
None,
None,
None,
None,
server_id,
api_client,
)
elif media == "seasons":
listing = api_client.get_seasons(folder)
elif media != "files":
listing = get_filtered_section(
folder or view_id,
get_media_type(content_type),
None,
False,
None,
None,
None,
None,
server_id,
api_client,
)
else:
listing = get_filtered_section(
folder or view_id,
None,
None,
False,
None,
None,
None,
None,
server_id,
api_client,
)
if listing:
actions = Actions(server_id, api_client)
list_li = []
listing = listing if isinstance(listing, list) else listing.get("Items", [])
for item in listing:
li = xbmcgui.ListItem()
li.setProperty("jellyfinid", item["Id"])
li.setProperty("jellyfinserver", server_id)
actions.set_listitem(item, li)
if item.get("IsFolder"):
params = {
"id": view_id or item["Id"],
"mode": "browse",
"type": get_folder_type(item, media) or media,
"folder": item["Id"],
"server": server_id,
}
path = "%s?%s" % ("plugin://plugin.video.jellyfin/", urlencode(params))
context = []
if item["Type"] in ("Series", "Season", "Playlist"):
context.append(
(
"Play",
"RunPlugin(plugin://plugin.video.jellyfin/?mode=playlist&id=%s&server=%s)"
% (item["Id"], server_id),
)
)
if item["UserData"]["Played"]:
context.append(
(
translate(16104),
"RunPlugin(plugin://plugin.video.jellyfin/?mode=unwatched&id=%s&server=%s)"
% (item["Id"], server_id),
)
)
else:
context.append(
(
translate(16103),
"RunPlugin(plugin://plugin.video.jellyfin/?mode=watched&id=%s&server=%s)"
% (item["Id"], server_id),
)
)
li.addContextMenuItems(context)
list_li.append((path, li, True))
elif item["Type"] == "Genre":
params = {
"id": view_id or item["Id"],
"mode": "browse",
"type": get_folder_type(item, media) or media,
"folder": "genres-%s" % item["Id"],
"server": server_id,
}
path = "%s?%s" % ("plugin://plugin.video.jellyfin/", urlencode(params))
list_li.append((path, li, True))
else:
if item["Type"] not in ("Photo", "PhotoAlbum"):
params = {"id": item["Id"], "mode": "play", "server": server_id}
path = "%s?%s" % (
"plugin://plugin.video.jellyfin/",
urlencode(params),
)
li.setProperty("path", path)
context = [
(
translate(13412),
"RunPlugin(plugin://plugin.video.jellyfin/?mode=playlist&id=%s&server=%s)"
% (item["Id"], server_id),
)
]
if item["UserData"]["Played"]:
context.append(
(
translate(16104),
"RunPlugin(plugin://plugin.video.jellyfin/?mode=unwatched&id=%s&server=%s)"
% (item["Id"], server_id),
)
)
else:
context.append(
(
translate(16103),
"RunPlugin(plugin://plugin.video.jellyfin/?mode=watched&id=%s&server=%s)"
% (item["Id"], server_id),
)
)
li.addContextMenuItems(context)
list_li.append((li.getProperty("path"), li, False))
xbmcplugin.addDirectoryItems(PROCESS_HANDLE, list_li, len(list_li))
if content_type == "images":
xbmcplugin.addSortMethod(PROCESS_HANDLE, xbmcplugin.SORT_METHOD_VIDEO_TITLE)
xbmcplugin.addSortMethod(PROCESS_HANDLE, xbmcplugin.SORT_METHOD_DATE)
xbmcplugin.addSortMethod(PROCESS_HANDLE, xbmcplugin.SORT_METHOD_VIDEO_RATING)
xbmcplugin.addSortMethod(PROCESS_HANDLE, xbmcplugin.SORT_METHOD_VIDEO_RUNTIME)
xbmcplugin.setContent(PROCESS_HANDLE, content_type)
xbmcplugin.endOfDirectory(PROCESS_HANDLE)
def browse_subfolders(media, view_id, server_id=None):
"""Display submenus for jellyfin views."""
from ..views import DYNNODES
view = Jellyfin(server_id).get_client().jellyfin.get_item(view_id)
xbmcplugin.setPluginCategory(PROCESS_HANDLE, view["Name"])
nodes = DYNNODES[media]
for node in nodes:
params = {
"id": view_id,
"mode": "browse",
"type": media,
"folder": view_id if node[0] == "all" else node[0],
"server": server_id,
}
path = "%s?%s" % ("plugin://plugin.video.jellyfin/", urlencode(params))
directory(node[1] or view["Name"], path)
xbmcplugin.setContent(PROCESS_HANDLE, "files")
xbmcplugin.endOfDirectory(PROCESS_HANDLE)
def browse_letters(media, view_id, server_id=None):
"""Display letters as options."""
letters = "#ABCDEFGHIJKLMNOPQRSTUVWXYZ"
view = Jellyfin(server_id).get_client().jellyfin.get_item(view_id)
xbmcplugin.setPluginCategory(PROCESS_HANDLE, view["Name"])
for node in letters:
params = {
"id": view_id,
"mode": "browse",
"type": media,
"folder": "firstletter-%s" % node,
"server": server_id,
}
path = "%s?%s" % ("plugin://plugin.video.jellyfin/", urlencode(params))
directory(node, path)
xbmcplugin.setContent(PROCESS_HANDLE, "files")
xbmcplugin.endOfDirectory(PROCESS_HANDLE)
def get_folder_type(item, content_type=None):
media = item["Type"]
if media == "Series":
return "seasons"
elif media == "Season":
return "episodes"
elif media == "BoxSet":
return "boxset"
elif media == "MusicArtist":
return "albums"
elif media == "MusicAlbum":
return "songs"
elif media == "CollectionFolder":
return item.get("CollectionType", "library")
elif media == "Folder" and content_type == "music":
return "albums"
def get_media_type(media):
if media == "movies":
return "Movie,BoxSet"
elif media == "homevideos":
return "Video,Folder,PhotoAlbum,Photo"
elif media == "episodes":
return "Episode"
elif media == "boxsets":
return "BoxSet"
elif media == "tvshows":
return "Series"
elif media == "music":
return "MusicArtist,MusicAlbum,Audio"
def get_fanart(item_id, path, server_id=None, api_client=None):
"""Get extra fanart for listitems. This is called by skinhelper.
Images are stored locally, due to the Kodi caching system.
"""
if not item_id and "plugin.video.jellyfin" in path:
item_id = path.split("/")[-2]
if not item_id:
return
LOG.info("[ extra fanart ] %s", item_id)
objects = Objects()
list_li = []
directory = translate_path("special://thumbnails/jellyfin/%s/" % item_id)
if not xbmcvfs.exists(directory):
xbmcvfs.mkdirs(directory)
item = api_client.get_item(item_id)
obj = objects.map(item, "Artwork")
backdrops = api.API(item).get_all_artwork(obj)
tags = obj["BackdropTags"]
for index, backdrop in enumerate(backdrops):
tag = tags[index]
fanart = os.path.join(directory, "fanart%s.jpg" % tag)
li = xbmcgui.ListItem(tag, path=fanart)
xbmcvfs.copy(backdrop, fanart)
list_li.append((fanart, li, False))
else:
LOG.debug("cached backdrop found")
dirs, files = xbmcvfs.listdir(directory)
for file in files:
fanart = os.path.join(directory, file)
li = xbmcgui.ListItem(file, path=fanart)
list_li.append((fanart, li, False))
xbmcplugin.addDirectoryItems(PROCESS_HANDLE, list_li, len(list_li))
xbmcplugin.endOfDirectory(PROCESS_HANDLE)
def get_video_extras(item_id, path, server_id=None, api_client=None):
"""Returns the video files for the item as plugin listing, can be used
to browse actual files or video extras, etc.
"""
if not item_id and "plugin.video.jellyfin" in path:
item_id = path.split("/")[-2]
if not item_id:
return
# TODO implement????
# Jellyfin(server_id).get_client().jellyfin.get_item(item_id)
"""
def getVideoFiles(jellyfinId,jellyfinPath):
#returns the video files for the item as plugin listing, can be used for browsing the actual files or videoextras etc.
jellyfin = jellyfinserver.Read_JellyfinServer()
if not jellyfinId:
if "plugin.video.jellyfin" in jellyfinPath:
jellyfinId = jellyfinPath.split("/")[-2]
if jellyfinId:
item = jellyfin.getItem(jellyfinId)
putils = playutils.PlayUtils(item)
if putils.isDirectPlay():
#only proceed if we can access the files directly. TODO: copy local on the fly if accessed outside
filelocation = putils.directPlay()
if not filelocation.endswith("/"):
filelocation = filelocation.rpartition("/")[0]
dirs, files = xbmcvfs.listdir(filelocation)
for file in files:
file = filelocation + file
li = xbmcgui.ListItem(file, path=file)
xbmcplugin.addDirectoryItem(handle=PROCESS_HANDLE, url=file, listitem=li)
for dir in dirs:
dir = filelocation + dir
li = xbmcgui.ListItem(dir, path=dir)
xbmcplugin.addDirectoryItem(handle=PROCESS_HANDLE, url=dir, listitem=li, isFolder=True)
#xbmcplugin.endOfDirectory(PROCESS_HANDLE)
"""
def get_next_episodes(item_id, limit):
"""Only for synced content."""
with Database("jellyfin") as jellyfindb:
db = jellyfin_db.JellyfinDatabase(jellyfindb.cursor)
library = db.get_view_name(item_id)
if not library:
return
result = JSONRPC("VideoLibrary.GetTVShows").execute(
{
"sort": {"order": "descending", "method": "lastplayed"},
"filter": {
"and": [
{"operator": "true", "field": "inprogress", "value": ""},
{"operator": "is", "field": "tag", "value": "%s" % library},
]
},
"properties": ["title", "studio", "mpaa", "file", "art"],
}
)
try:
items = result["result"]["tvshows"]
except (KeyError, TypeError):
return
list_li = []
for item in items:
if settings("ignoreSpecialsNextEpisodes.bool"):
params = {
"tvshowid": item["tvshowid"],
"sort": {"method": "episode"},
"filter": {
"and": [
{"operator": "lessthan", "field": "playcount", "value": "1"},
{"operator": "greaterthan", "field": "season", "value": "0"},
]
},
"properties": [
"title",
"playcount",
"season",
"episode",
"showtitle",
"plot",
"file",
"rating",
"resume",
"tvshowid",
"art",
"streamdetails",
"firstaired",
"runtime",
"writer",
"dateadded",
"lastplayed",
],
"limits": {"end": 1},
}
else:
params = {
"tvshowid": item["tvshowid"],
"sort": {"method": "episode"},
"filter": {"operator": "lessthan", "field": "playcount", "value": "1"},
"properties": [
"title",
"playcount",
"season",
"episode",
"showtitle",
"plot",
"file",
"rating",
"resume",
"tvshowid",
"art",
"streamdetails",
"firstaired",
"runtime",
"writer",
"dateadded",
"lastplayed",
],
"limits": {"end": 1},
}
result = JSONRPC("VideoLibrary.GetEpisodes").execute(params)
try:
episodes = result["result"]["episodes"]
except (KeyError, TypeError):
pass
else:
for episode in episodes:
li = create_listitem(episode)
list_li.append((episode["file"], li))
if len(list_li) == limit:
break
xbmcplugin.addDirectoryItems(PROCESS_HANDLE, list_li, len(list_li))
xbmcplugin.setContent(PROCESS_HANDLE, "episodes")
xbmcplugin.endOfDirectory(PROCESS_HANDLE)
def create_listitem(item):
"""Listitem based on jsonrpc items."""
title = item["title"]
label2 = ""
li = xbmcgui.ListItem(title)
li.setProperty("IsPlayable", "true")
metadata = {
"Title": title,
"duration": str(item["runtime"] / 60),
"Plot": item["plot"],
"Playcount": item["playcount"],
}
if "showtitle" in item:
metadata["TVshowTitle"] = item["showtitle"]
label2 = item["showtitle"]
if "episodeid" in item:
# Listitem of episode
metadata["mediatype"] = "episode"
metadata["dbid"] = item["episodeid"]
# TODO: Review once Krypton is RC - probably no longer needed if there's dbid
if "episode" in item:
episode = item["episode"]
metadata["Episode"] = episode
if "season" in item:
season = item["season"]
metadata["Season"] = season
if season and episode:
episodeno = "s%.2de%.2d" % (season, episode)
li.setProperty("episodeno", episodeno)
label2 = "%s - %s" % (label2, episodeno) if label2 else episodeno
if "firstaired" in item:
metadata["Premiered"] = item["firstaired"]
if "rating" in item:
metadata["Rating"] = str(round(float(item["rating"]), 1))
if "director" in item:
metadata["Director"] = " / ".join(item["director"])
if "writer" in item:
metadata["Writer"] = " / ".join(item["writer"])
if "cast" in item:
cast = []
castandrole = []
for person in item["cast"]:
name = person["name"]
cast.append(name)
castandrole.append((name, person["role"]))
metadata["Cast"] = cast
metadata["CastAndRole"] = castandrole
li.setLabel2(label2)
li.setInfo(type="Video", infoLabels=metadata)
li.setProperty("resumetime", str(item["resume"]["position"]))
li.setProperty("totaltime", str(item["resume"]["total"]))
li.setArt(item["art"])
li.setProperty("dbid", str(item["episodeid"]))
li.setProperty("fanart_image", item["art"].get("tvshow.fanart", ""))
for key, value in item["streamdetails"].items():
for stream in value:
li.addStreamInfo(key, stream)
return li
def add_user(api_client):
"""Add or remove users from the default server session."""
if not window("jellyfin_online.bool"):
return
session = api_client.get_device(client.get_device_id())
users = api_client.get_users()
current = session[0]["AdditionalUsers"]
result = dialog(
"select",
translate(33061),
[translate(33062), translate(33063)] if current else [translate(33062)],
)
if result < 0:
return
if not result: # Add user
eligible = [
x
for x in users
if x["Id"] not in [current_user["UserId"] for current_user in current]
]
resp = dialog("select", translate(33064), [x["Name"] for x in eligible])
if resp < 0:
return
user = eligible[resp]
event("AddUser", {"Id": user["Id"], "Add": True})
else: # Remove user
resp = dialog("select", translate(33064), [x["UserName"] for x in current])
if resp < 0:
return
user = current[resp]
event("AddUser", {"Id": user["UserId"], "Add": False})
def get_themes(api_client):
"""Add theme media locally, via strm. This is only for tv tunes.
If another script is used, adjust this code.
"""
from ..helper.utils import normalize_string
from ..helper.playutils import PlayUtils
from ..helper.xmls import tvtunes_nfo
library = translate_path(
"special://profile/addon_data/plugin.video.jellyfin/library"
)
play = settings("useDirectPaths") == "1"
if not xbmcvfs.exists(library + "/"):
xbmcvfs.mkdir(library)
if xbmc.getCondVisibility("System.HasAddon(script.tvtunes)"):
tvtunes = xbmcaddon.Addon(id="script.tvtunes")
tvtunes.setSetting("custom_path_enable", "true")
tvtunes.setSetting("custom_path", library)
LOG.info("TV Tunes custom path is enabled and set.")
else:
dialog("ok", "{jellyfin}", translate(33152))
return
with Database("jellyfin") as jellyfindb:
all_views = jellyfin_db.JellyfinDatabase(jellyfindb.cursor).get_views()
views = [
x.view_id
for x in all_views
if x.media_type in ("movies", "tvshows", "mixed")
]
items = {}
server = api_client.config.data["auth.server"]
for view in views:
result = api_client.get_items_theme_video(view)
for item in result["Items"]:
folder = normalize_string(item["Name"])
items[item["Id"]] = folder
result = api_client.get_items_theme_song(view)
for item in result["Items"]:
folder = normalize_string(item["Name"])
items[item["Id"]] = folder
for item in items:
nfo_path = os.path.join(library, items[item])
nfo_file = os.path.join(nfo_path, "tvtunes.nfo")
if not xbmcvfs.exists(nfo_path):
xbmcvfs.mkdir(nfo_path)
themes = api_client.get_themes(item)
paths = []
for theme in (
themes["ThemeVideosResult"]["Items"] + themes["ThemeSongsResult"]["Items"]
):
putils = PlayUtils(theme, False, None, server, api_client)
if play:
paths.append(putils.direct_play(theme["MediaSources"][0]))
else:
paths.append(putils.direct_url(theme["MediaSources"][0]))
tvtunes_nfo(nfo_file, paths)
dialog(
"notification",
heading="{jellyfin}",
message=translate(33153),
icon="{jellyfin}",
time=1000,
sound=False,
)
def delete_item():
"""Delete keymap action."""
from . import context
context.Context(delete=True)
def backup():
"""Jellyfin backup."""
from ..helper.utils import delete_folder, copytree
path = settings("backupPath")
folder_name = "Kodi%s.%s" % (
kodi_version(),
xbmc.getInfoLabel("System.Date(dd-mm-yy)"),
)
folder_name = dialog("input", heading=translate(33089), defaultt=folder_name)
if not folder_name:
return
backup = os.path.join(path, folder_name)
if xbmcvfs.exists(backup + "/"):
if not dialog("yesno", "{jellyfin}", translate(33090)):
return backup()
delete_folder(backup)
addon_data = translate_path("special://profile/addon_data/plugin.video.jellyfin")
destination_data = os.path.join(backup, "addon_data", "plugin.video.jellyfin")
destination_databases = os.path.join(backup, "Database")
if not xbmcvfs.mkdirs(path) or not xbmcvfs.mkdirs(destination_databases):
LOG.info("Unable to create all directories")
dialog(
"notification",
heading="{jellyfin}",
icon="{jellyfin}",
message=translate(33165),
sound=False,
)
return
copytree(addon_data, destination_data)
databases = Objects().objects
db = translate_path(databases["jellyfin"])
xbmcvfs.copy(db, os.path.join(destination_databases, db.rsplit("\\", 1)[1]))
LOG.info("copied jellyfin.db")
db = translate_path(databases["video"])
filename = db.rsplit("\\", 1)[1]
xbmcvfs.copy(db, os.path.join(destination_databases, filename))
LOG.info("copied %s", filename)
if settings("enableMusic.bool"):
db = translate_path(databases["music"])
filename = db.rsplit("\\", 1)[1]
xbmcvfs.copy(db, os.path.join(destination_databases, filename))
LOG.info("copied %s", filename)
LOG.info("backup completed")
dialog("ok", "{jellyfin}", "%s %s" % (translate(33091), backup))
def get_filtered_section(
parent_id=None,
media=None,
limit=None,
recursive=None,
sort=None,
sort_order=None,
filters=None,
extra=None,
server_id=None,
api_client=None,
):
"""Get dynamic listings."""
params = {
"ParentId": parent_id,
"IncludeItemTypes": media,
"IsMissing": False,
"Recursive": recursive if recursive is not None else True,
"Limit": limit,
"SortBy": sort or "SortName",
"SortOrder": sort_order or "Ascending",
"ImageTypeLimit": 1,
"IsVirtualUnaired": False,
"Fields": browse_info(),
}
if filters:
if "Boxsets" in filters:
filters.remove("Boxsets")
params["CollapseBoxSetItems"] = settings("groupedSets.bool")
params["Filters"] = ",".join(filters)
if settings("getCast.bool"):
params["Fields"] += ",People"
if media and "Photo" in media:
params["Fields"] += ",Width,Height"
if extra is not None:
params.update(extra)
return api_client._get("Users/{UserId}/Items", params)
def browse_info():
return (
"DateCreated,EpisodeCount,SeasonCount,Path,Genres,Studios,Taglines,MediaStreams,Overview,Etag,"
"ProductionLocations,Width,Height,RecursiveItemCount,ChildCount"
)
Reference in a new issue View git blame Copy permalink