mirror of
https://github.com/jellyfin/jellyfin-kodi.git
synced 2024-12-25 10:16:11 +00:00
1378 lines
53 KiB
Python
1378 lines
53 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
#################################################################################################
|
|
|
|
import json
|
|
import logging
|
|
import os
|
|
import ntpath
|
|
import shutil
|
|
import sys
|
|
import urlparse
|
|
|
|
import xbmc
|
|
import xbmcaddon
|
|
import xbmcgui
|
|
import xbmcvfs
|
|
import xbmcplugin
|
|
|
|
import artwork
|
|
import utils
|
|
import clientinfo
|
|
import connectmanager
|
|
import database
|
|
import downloadutils
|
|
import librarysync
|
|
import read_embyserver as embyserver
|
|
import embydb_functions as embydb
|
|
import playlist
|
|
import playbackutils as pbutils
|
|
import playutils
|
|
import api
|
|
from views import Playlist, VideoNodes
|
|
from utils import window, settings, dialog, language as lang, urllib_path
|
|
|
|
#################################################################################################
|
|
|
|
log = logging.getLogger("EMBY."+__name__)
|
|
|
|
addon = xbmcaddon.Addon(id='plugin.video.emby')
|
|
XML_PATH = (addon.getAddonInfo('path'), "default", "1080i", True)
|
|
|
|
#################################################################################################
|
|
|
|
|
|
def doPlayback(itemId, dbId):
|
|
|
|
emby = embyserver.Read_EmbyServer()
|
|
item = emby.getItem(itemId)
|
|
pbutils.PlaybackUtils(item).play(itemId, dbId)
|
|
|
|
##### DO RESET AUTH #####
|
|
def resetAuth():
|
|
# User tried login and failed too many times
|
|
resp = xbmcgui.Dialog().yesno(
|
|
heading=lang(30132),
|
|
line1=lang(33050))
|
|
if resp:
|
|
log.info("Reset login attempts.")
|
|
window('emby_serverStatus', value="Auth")
|
|
else:
|
|
xbmc.executebuiltin('Addon.OpenSettings(plugin.video.emby)')
|
|
|
|
def addDirectoryItem(label, path, folder=True):
|
|
li = xbmcgui.ListItem(label, path=path)
|
|
li.setThumbnailImage("special://home/addons/plugin.video.emby/icon.png")
|
|
li.setArt({"fanart":"special://home/addons/plugin.video.emby/fanart.jpg"})
|
|
li.setArt({"landscape":"special://home/addons/plugin.video.emby/fanart.jpg"})
|
|
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=path, listitem=li, isFolder=folder)
|
|
|
|
def doMainListing():
|
|
|
|
xbmcplugin.setContent(int(sys.argv[1]), 'files')
|
|
# Get emby nodes from the window props
|
|
embyprops = window('Emby.nodes.total')
|
|
if embyprops:
|
|
totalnodes = int(embyprops)
|
|
for i in range(totalnodes):
|
|
path = window('Emby.nodes.%s.index' % i)
|
|
if not path:
|
|
path = window('Emby.nodes.%s.content' % i)
|
|
label = window('Emby.nodes.%s.title' % i)
|
|
node = window('Emby.nodes.%s.type' % i)
|
|
|
|
''' because we do not use seperate entrypoints for each content type,
|
|
we need to figure out which items to show in each listing.
|
|
for now we just only show picture nodes in the picture library
|
|
video nodes in the video library and all nodes in any other window
|
|
'''
|
|
|
|
if path:
|
|
if xbmc.getCondVisibility("Window.IsActive(Pictures)") and node in ("photos", "homevideos"):
|
|
addDirectoryItem(label, path)
|
|
elif xbmc.getCondVisibility("Window.IsActive(Videos)") and node != "photos":
|
|
addDirectoryItem(label, path)
|
|
elif not xbmc.getCondVisibility("Window.IsActive(Videos) | Window.IsActive(Pictures) | Window.IsActive(Music)"):
|
|
addDirectoryItem(label, path)
|
|
|
|
# experimental live tv nodes
|
|
'''
|
|
if not xbmc.getCondVisibility("Window.IsActive(Pictures)"):
|
|
addDirectoryItem(lang(33051),
|
|
"plugin://plugin.video.emby/?mode=browsecontent&type=tvchannels&folderid=root")
|
|
addDirectoryItem(lang(33052),
|
|
"plugin://plugin.video.emby/?mode=browsecontent&type=recordings&folderid=root")
|
|
'''
|
|
'''
|
|
TODO: Create plugin listing for servers
|
|
servers = window('emby_servers.json')
|
|
if servers:
|
|
for server in servers:
|
|
log.info(window('emby_server%s.name' % server))
|
|
addDirectoryItem(window('emby_server%s.name' % server), "plugin://plugin.video.emby/?mode=%s" % server)
|
|
'''
|
|
|
|
#addDirectoryItem("Manual login dialog", "plugin://plugin.video.emby/?mode=manuallogin")
|
|
#addDirectoryItem("Connect login dialog", "plugin://plugin.video.emby/?mode=connectlogin")
|
|
#addDirectoryItem("Manual server dialog", "plugin://plugin.video.emby/?mode=manualserver")
|
|
#addDirectoryItem("Connect servers dialog", "plugin://plugin.video.emby/?mode=connectservers")
|
|
#addDirectoryItem("Connect users dialog", "plugin://plugin.video.emby/?mode=connectusers")
|
|
|
|
addDirectoryItem(lang(30517), "plugin://plugin.video.emby/?mode=passwords")
|
|
addDirectoryItem(lang(33053), "plugin://plugin.video.emby/?mode=settings")
|
|
addDirectoryItem(lang(33054), "plugin://plugin.video.emby/?mode=adduser")
|
|
addDirectoryItem(lang(33055), "plugin://plugin.video.emby/?mode=refreshplaylist")
|
|
addDirectoryItem(lang(33098), "plugin://plugin.video.emby/?mode=refreshboxsets")
|
|
addDirectoryItem(lang(33056), "plugin://plugin.video.emby/?mode=manualsync")
|
|
addDirectoryItem(lang(33057), "plugin://plugin.video.emby/?mode=repair")
|
|
addDirectoryItem(lang(33058), "plugin://plugin.video.emby/?mode=reset")
|
|
addDirectoryItem(lang(33059), "plugin://plugin.video.emby/?mode=texturecache")
|
|
addDirectoryItem(lang(33060), "plugin://plugin.video.emby/?mode=thememedia")
|
|
|
|
if settings('backupPath'):
|
|
addDirectoryItem(lang(33092), "plugin://plugin.video.emby/?mode=backup")
|
|
|
|
xbmcplugin.endOfDirectory(int(sys.argv[1]))
|
|
|
|
def test_manual_login():
|
|
from dialogs import LoginManual
|
|
dialog = LoginManual("script-emby-connect-login-manual.xml", *XML_PATH)
|
|
dialog.set_server("Test server")
|
|
dialog.set_user("Test user")
|
|
dialog.doModal()
|
|
|
|
def test_connect_login():
|
|
from dialogs import LoginConnect
|
|
dialog = LoginConnect("script-emby-connect-login.xml", *XML_PATH)
|
|
dialog.doModal()
|
|
|
|
def test_manual_server():
|
|
from dialogs import ServerManual
|
|
dialog = ServerManual("script-emby-connect-server-manual.xml", *XML_PATH)
|
|
dialog.doModal()
|
|
|
|
def test_connect_servers():
|
|
from dialogs import ServerConnect
|
|
dialog = ServerConnect("script-emby-connect-server.xml", *XML_PATH)
|
|
test_servers = [
|
|
{
|
|
u'LastConnectionMode': 2,
|
|
u'Name': u'Server Name',
|
|
u'AccessToken': u'Token',
|
|
u'RemoteAddress': u'http://remote.address:8096',
|
|
u'UserId': u'd4000909883845059aadef13b7110375',
|
|
u'ManualAddress': u'http://manual.address:8096',
|
|
u'DateLastAccessed': '2018-01-01T02:36:58Z',
|
|
u'LocalAddress': u'http://local.address:8096',
|
|
u'Id': u'b1ef1940b1964e2188f00b73611d53fd',
|
|
u'Users': [
|
|
{
|
|
u'IsSignedInOffline': True,
|
|
u'Id': u'd4000909883845059aadef13b7110375'
|
|
}
|
|
]
|
|
}
|
|
]
|
|
kwargs = {
|
|
'username': "Test user",
|
|
'user_image': None,
|
|
'servers': test_servers,
|
|
'emby_connect': True
|
|
}
|
|
dialog.set_args(**kwargs)
|
|
dialog.doModal()
|
|
|
|
def test_connect_users():
|
|
from dialogs import UsersConnect
|
|
test_users = [{
|
|
u'Name': u'Guest',
|
|
u'HasConfiguredEasyPassword': False,
|
|
u'LastActivityDate': u'2018-01-01T04:10:15.4195197Z',
|
|
u'HasPassword': False,
|
|
u'LastLoginDate': u'2017-12-28T02:53:01.5770625Z',
|
|
u'Policy': {
|
|
u'EnabledDevices': [
|
|
|
|
],
|
|
u'EnableMediaPlayback': True,
|
|
u'EnableRemoteControlOfOtherUsers': False,
|
|
u'RemoteClientBitrateLimit': 0,
|
|
u'BlockUnratedItems': [
|
|
|
|
],
|
|
u'EnableAllDevices': True,
|
|
u'InvalidLoginAttemptCount': 0,
|
|
u'EnableUserPreferenceAccess': True,
|
|
u'EnableLiveTvManagement': False,
|
|
u'EnableLiveTvAccess': False,
|
|
u'IsAdministrator': False,
|
|
u'EnableContentDeletion': False,
|
|
u'EnabledChannels': [
|
|
|
|
],
|
|
u'IsDisabled': False,
|
|
u'EnableSyncTranscoding': False,
|
|
u'EnableAudioPlaybackTranscoding': True,
|
|
u'EnableSharedDeviceControl': False,
|
|
u'AccessSchedules': [
|
|
|
|
],
|
|
u'IsHidden': False,
|
|
u'EnableContentDeletionFromFolders': [
|
|
|
|
],
|
|
u'EnableContentDownloading': False,
|
|
u'EnableVideoPlaybackTranscoding': True,
|
|
u'EnabledFolders': [
|
|
u'0c41907140d802bb58430fed7e2cd79e',
|
|
u'a329cda1727467c08a8f1493195d32d3',
|
|
u'f137a2dd21bbc1b99aa5c0f6bf02a805',
|
|
u'4514ec850e5ad0c47b58444e17b6346c'
|
|
],
|
|
u'EnableAllChannels': False,
|
|
u'BlockedTags': [
|
|
|
|
],
|
|
u'EnableAllFolders': False,
|
|
u'EnablePublicSharing': False,
|
|
u'EnablePlaybackRemuxing': True
|
|
},
|
|
u'ServerId': u'Test',
|
|
u'Configuration': {
|
|
u'SubtitleMode': u'Default',
|
|
u'HidePlayedInLatest': True,
|
|
u'GroupedFolders': [
|
|
|
|
],
|
|
u'DisplayCollectionsView': False,
|
|
u'OrderedViews': [
|
|
|
|
],
|
|
u'SubtitleLanguagePreference': u'',
|
|
u'AudioLanguagePreference': u'',
|
|
u'LatestItemsExcludes': [
|
|
|
|
],
|
|
u'EnableLocalPassword': False,
|
|
u'RememberAudioSelections': True,
|
|
u'RememberSubtitleSelections': True,
|
|
u'DisplayMissingEpisodes': False,
|
|
u'PlayDefaultAudioTrack': True,
|
|
u'EnableNextEpisodeAutoPlay': True
|
|
},
|
|
u'Id': u'a9d56d37cb6b47a3bfd3453c55138ff1',
|
|
u'HasConfiguredPassword': False
|
|
}]
|
|
dialog = UsersConnect("script-emby-connect-users.xml", *XML_PATH)
|
|
dialog.set_server("Test server")
|
|
dialog.set_users(test_users)
|
|
dialog.doModal()
|
|
|
|
def emby_connect():
|
|
|
|
# Login user to emby connect
|
|
connect = connectmanager.ConnectManager()
|
|
try:
|
|
connectUser = connect.login_connect()
|
|
except RuntimeError:
|
|
return
|
|
else:
|
|
user = connectUser['User']
|
|
token = connectUser['AccessToken']
|
|
username = user['Name']
|
|
dialog(type_="notification",
|
|
heading="{emby}",
|
|
message="%s %s" % (lang(33000), username.decode('utf-8')),
|
|
icon=user.get('ImageUrl') or "{emby}",
|
|
time=2000,
|
|
sound=False)
|
|
|
|
settings('connectUsername', value=username)
|
|
|
|
def emby_backup():
|
|
# Create a backup at specified location
|
|
path = settings('backupPath')
|
|
|
|
# filename
|
|
default_value = "Kodi%s.%s" % (xbmc.getInfoLabel('System.BuildVersion')[:2],
|
|
xbmc.getInfoLabel('System.Date(dd-mm-yy)'))
|
|
folder_name = dialog(type_="input",
|
|
heading=lang(33089),
|
|
defaultt=default_value)
|
|
if not folder_name:
|
|
return
|
|
|
|
backup = os.path.join(path, folder_name)
|
|
log.info("Backup: %s", backup)
|
|
|
|
# Create directory
|
|
if xbmcvfs.exists(backup+"\\"):
|
|
log.info("Existing directory!")
|
|
if not dialog(type_="yesno",
|
|
heading="{emby}",
|
|
line1=lang(33090)):
|
|
return emby_backup()
|
|
shutil.rmtree(backup)
|
|
|
|
# Addon_data
|
|
addon_data = xbmc.translatePath("special://profile/addon_data/plugin.video.emby").decode('utf-8')
|
|
try:
|
|
shutil.copytree(src=addon_data,
|
|
dst=os.path.join(backup, "addon_data", "plugin.video.emby"))
|
|
except shutil.Error as error:
|
|
log.error(error)
|
|
|
|
# Database files
|
|
database_folder = os.path.join(backup, "Database")
|
|
if not xbmcvfs.mkdir(database_folder):
|
|
try:
|
|
os.makedirs(database_folder)
|
|
except OSError as error:
|
|
log.error(error)
|
|
dialog(type_="ok",
|
|
heading="{emby}",
|
|
line1="Failed to create backup")
|
|
return
|
|
|
|
# Emby database
|
|
emby_path = database.emby_database()
|
|
xbmcvfs.copy(emby_path, os.path.join(database_folder, ntpath.basename(emby_path)))
|
|
# Videos database
|
|
video_path = database.video_database()
|
|
xbmcvfs.copy(video_path, os.path.join(database_folder, ntpath.basename(video_path)))
|
|
# Music database
|
|
if settings('enableMusic') == "true":
|
|
music_path = database.music_database()
|
|
xbmcvfs.copy(music_path, os.path.join(database_folder, ntpath.basename(music_path)))
|
|
|
|
dialog(type_="ok",
|
|
heading="{emby}",
|
|
line1="%s: %s" % (lang(33091), backup))
|
|
|
|
##### Generate a new deviceId
|
|
def resetDeviceId():
|
|
|
|
dialog = xbmcgui.Dialog()
|
|
|
|
deviceId_old = window('emby_deviceId')
|
|
try:
|
|
window('emby_deviceId', clear=True)
|
|
deviceId = clientinfo.ClientInfo().get_device_id(reset=True)
|
|
except Exception as e:
|
|
log.error("Failed to generate a new device Id: %s" % e)
|
|
dialog.ok(
|
|
heading=lang(29999),
|
|
line1=lang(33032))
|
|
else:
|
|
log.info("Successfully removed old deviceId: %s New deviceId: %s" % (deviceId_old, deviceId))
|
|
dialog.ok(
|
|
heading=lang(29999),
|
|
line1=lang(33033))
|
|
xbmc.executebuiltin('RestartApp')
|
|
|
|
##### Delete Item
|
|
def deleteItem():
|
|
|
|
# Serves as a keymap action
|
|
if xbmc.getInfoLabel('ListItem.Property(embyid)'): # If we already have the embyid
|
|
itemId = xbmc.getInfoLabel('ListItem.Property(embyid)')
|
|
else:
|
|
dbId = xbmc.getInfoLabel('ListItem.DBID')
|
|
itemType = xbmc.getInfoLabel('ListItem.DBTYPE')
|
|
|
|
if not itemType:
|
|
|
|
if xbmc.getCondVisibility('Container.Content(albums)'):
|
|
itemType = "album"
|
|
elif xbmc.getCondVisibility('Container.Content(artists)'):
|
|
itemType = "artist"
|
|
elif xbmc.getCondVisibility('Container.Content(songs)'):
|
|
itemType = "song"
|
|
elif xbmc.getCondVisibility('Container.Content(pictures)'):
|
|
itemType = "picture"
|
|
else:
|
|
log.info("Unknown type, unable to proceed.")
|
|
return
|
|
|
|
with database.DatabaseConn('emby') as cursor:
|
|
emby_db = embydb.Embydb_Functions(cursor)
|
|
item = emby_db.getItem_byKodiId(dbId, itemType)
|
|
|
|
try:
|
|
itemId = item[0]
|
|
except TypeError:
|
|
log.error("Unknown itemId, unable to proceed.")
|
|
return
|
|
|
|
if settings('skipContextMenu') != "true":
|
|
resp = xbmcgui.Dialog().yesno(
|
|
heading=lang(29999),
|
|
line1=lang(33041))
|
|
if not resp:
|
|
log.info("User skipped deletion for: %s." % itemId)
|
|
return
|
|
|
|
embyserver.Read_EmbyServer().deleteItem(itemId)
|
|
|
|
##### ADD ADDITIONAL USERS #####
|
|
def addUser():
|
|
|
|
if window('emby_online') != "true":
|
|
log.info("server is offline")
|
|
return
|
|
|
|
doUtils = downloadutils.DownloadUtils()
|
|
art = artwork.Artwork()
|
|
clientInfo = clientinfo.ClientInfo()
|
|
deviceId = clientInfo.get_device_id()
|
|
deviceName = clientInfo.get_device_name()
|
|
userid = window('emby_currUser')
|
|
dialog = xbmcgui.Dialog()
|
|
|
|
# Get session
|
|
url = "{server}/emby/Sessions?DeviceId=%s&format=json" % deviceId
|
|
|
|
try:
|
|
result = doUtils.downloadUrl(url)
|
|
sessionId = result[0]['Id']
|
|
additionalUsers = result[0]['AdditionalUsers']
|
|
# Add user to session
|
|
userlist = {}
|
|
users = []
|
|
url = "{server}/emby/Users?IsDisabled=false&IsHidden=false&format=json"
|
|
result = doUtils.downloadUrl(url)
|
|
|
|
# pull the list of users
|
|
for user in result:
|
|
name = user['Name']
|
|
userId = user['Id']
|
|
if userid != userId:
|
|
userlist[name] = userId
|
|
users.append(name)
|
|
|
|
# Display dialog if there's additional users
|
|
if additionalUsers:
|
|
|
|
option = dialog.select(lang(33061), [lang(33062), lang(33063)])
|
|
# Users currently in the session
|
|
additionalUserlist = {}
|
|
additionalUsername = []
|
|
# Users currently in the session
|
|
for user in additionalUsers:
|
|
name = user['UserName']
|
|
userId = user['UserId']
|
|
additionalUserlist[name] = userId
|
|
additionalUsername.append(name)
|
|
|
|
if option == 1:
|
|
# User selected Remove user
|
|
resp = dialog.select(lang(33064), additionalUsername)
|
|
if resp > -1:
|
|
selected = additionalUsername[resp]
|
|
selected_userId = additionalUserlist[selected]
|
|
url = "{server}/emby/Sessions/%s/Users/%s" % (sessionId, selected_userId)
|
|
doUtils.downloadUrl(url, postBody={}, action_type="DELETE")
|
|
dialog.notification(
|
|
heading=lang(29999),
|
|
message="%s %s" % (lang(33066), selected),
|
|
icon="special://home/addons/plugin.video.emby/icon.png",
|
|
time=1000)
|
|
|
|
# clear picture
|
|
position = window('EmbyAdditionalUserPosition.%s' % selected_userId)
|
|
window('EmbyAdditionalUserImage.%s' % position, clear=True)
|
|
return
|
|
else:
|
|
return
|
|
|
|
elif option == 0:
|
|
# User selected Add user
|
|
for adduser in additionalUsername:
|
|
try: # Remove from selected already added users. It is possible they are hidden.
|
|
users.remove(adduser)
|
|
except: pass
|
|
|
|
elif option < 0:
|
|
# User cancelled
|
|
return
|
|
|
|
# Subtract any additional users
|
|
log.info("Displaying list of users: %s" % users)
|
|
resp = dialog.select("Add user to the session", users)
|
|
# post additional user
|
|
if resp > -1:
|
|
selected = users[resp]
|
|
selected_userId = userlist[selected]
|
|
url = "{server}/emby/Sessions/%s/Users/%s" % (sessionId, selected_userId)
|
|
doUtils.downloadUrl(url, postBody={}, action_type="POST")
|
|
dialog.notification(
|
|
heading=lang(29999),
|
|
message="%s %s" % (lang(33067), selected),
|
|
icon="special://home/addons/plugin.video.emby/icon.png",
|
|
time=1000)
|
|
|
|
except Exception as error:
|
|
log.error("Failed to add user to session: " + str(error))
|
|
dialog.notification(
|
|
heading=lang(29999),
|
|
message=lang(33068),
|
|
icon=xbmcgui.NOTIFICATION_ERROR)
|
|
|
|
# Add additional user images
|
|
# always clear the individual items first
|
|
totalNodes = 10
|
|
for i in range(totalNodes):
|
|
if not window('EmbyAdditionalUserImage.%s' % i):
|
|
break
|
|
window('EmbyAdditionalUserImage.%s' % i, clear=True)
|
|
|
|
url = "{server}/emby/Sessions?DeviceId=%s&format=json" % deviceId
|
|
|
|
try:
|
|
result = doUtils.downloadUrl(url)
|
|
additionalUsers = result[0]['AdditionalUsers']
|
|
except Exception as error:
|
|
log.error(error)
|
|
additionalUsers = []
|
|
|
|
count = 0
|
|
for additionaluser in additionalUsers:
|
|
userid = additionaluser['UserId']
|
|
url = "{server}/emby/Users/%s?format=json" % userid
|
|
result = doUtils.downloadUrl(url)
|
|
window('EmbyAdditionalUserImage.%s' % count,
|
|
value=art.get_user_artwork(result['Id'], 'Primary'))
|
|
window('EmbyAdditionalUserPosition.%s' % userid, value=str(count))
|
|
count +=1
|
|
|
|
##### THEME MUSIC/VIDEOS #####
|
|
def getThemeMedia():
|
|
|
|
doUtils = downloadutils.DownloadUtils()
|
|
dialog = xbmcgui.Dialog()
|
|
dummy_listitem = xbmcgui.ListItem()
|
|
playback = None
|
|
|
|
# Choose playback method
|
|
resp = dialog.select(lang(33072), [lang(30165), lang(33071)])
|
|
if resp == 0:
|
|
playback = "DirectPlay"
|
|
elif resp == 1:
|
|
playback = "DirectStream"
|
|
else:
|
|
return
|
|
|
|
library = xbmc.translatePath(
|
|
"special://profile/addon_data/plugin.video.emby/library/").decode('utf-8')
|
|
# Create library directory
|
|
if not xbmcvfs.exists(library):
|
|
xbmcvfs.mkdir(library)
|
|
|
|
# Set custom path for user
|
|
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:
|
|
# if it does not exist this will not work so warn user
|
|
# often they need to edit the settings first for it to be created.
|
|
dialog.ok(heading=lang(29999), line1=lang(33073))
|
|
xbmc.executebuiltin('Addon.OpenSettings(script.tvtunes)')
|
|
return
|
|
|
|
# Get every user view Id
|
|
with database.DatabaseConn('emby') as cursor:
|
|
emby_db = embydb.Embydb_Functions(cursor)
|
|
viewids = emby_db.getViews()
|
|
|
|
# Get Ids with Theme Videos
|
|
itemIds = {}
|
|
for view in viewids:
|
|
url = "{server}/emby/Users/{UserId}/Items?HasThemeVideo=True&ParentId=%s&format=json" % view
|
|
result = doUtils.downloadUrl(url)
|
|
if result['TotalRecordCount'] != 0:
|
|
for item in result['Items']:
|
|
itemId = item['Id']
|
|
folderName = item['Name']
|
|
folderName = utils.normalize_string(folderName.encode('utf-8'))
|
|
itemIds[itemId] = folderName
|
|
|
|
# Get paths for theme videos
|
|
for itemId in itemIds:
|
|
nfo_path = xbmc.translatePath(
|
|
"special://profile/addon_data/plugin.video.emby/library/%s/" % itemIds[itemId])
|
|
# Create folders for each content
|
|
if not xbmcvfs.exists(nfo_path):
|
|
xbmcvfs.mkdir(nfo_path)
|
|
# Where to put the nfos
|
|
nfo_path = "%s%s" % (nfo_path, "tvtunes.nfo")
|
|
|
|
url = "{server}/emby/Items/%s/ThemeVideos?format=json" % itemId
|
|
result = doUtils.downloadUrl(url)
|
|
|
|
# Create nfo and write themes to it
|
|
nfo_file = xbmcvfs.File(nfo_path, 'w')
|
|
pathstowrite = ""
|
|
# May be more than one theme
|
|
for theme in result['Items']:
|
|
putils = playutils.PlayUtils(theme, dummy_listitem)
|
|
if playback == "DirectPlay":
|
|
playurl = api.API(theme).get_file_path()
|
|
else:
|
|
playurl = putils.get_direct_url(theme['MediaSources'][0])
|
|
pathstowrite += ('<file>%s</file>' % playurl.encode('utf-8'))
|
|
|
|
# Check if the item has theme songs and add them
|
|
url = "{server}/emby/Items/%s/ThemeSongs?format=json" % itemId
|
|
result = doUtils.downloadUrl(url)
|
|
|
|
# May be more than one theme
|
|
for theme in result['Items']:
|
|
if playback == "DirectPlay":
|
|
playurl = api.API(theme).get_file_path()
|
|
else:
|
|
playurl = playutils.PlayUtils(theme, dummy_listitem).get_direct_url(theme['MediaSources'][0])
|
|
pathstowrite += ('<file>%s</file>' % playurl.encode('utf-8'))
|
|
|
|
nfo_file.write(
|
|
'<tvtunes>%s</tvtunes>' % pathstowrite
|
|
)
|
|
# Close nfo file
|
|
nfo_file.close()
|
|
|
|
# Get Ids with Theme songs
|
|
musicitemIds = {}
|
|
for view in viewids:
|
|
url = "{server}/emby/Users/{UserId}/Items?HasThemeSong=True&ParentId=%s&format=json" % view
|
|
result = doUtils.downloadUrl(url)
|
|
if result['TotalRecordCount'] != 0:
|
|
for item in result['Items']:
|
|
itemId = item['Id']
|
|
folderName = item['Name']
|
|
folderName = utils.normalize_string(folderName.encode('utf-8'))
|
|
musicitemIds[itemId] = folderName
|
|
|
|
# Get paths
|
|
for itemId in musicitemIds:
|
|
|
|
# if the item was already processed with video themes back out
|
|
if itemId in itemIds:
|
|
continue
|
|
|
|
nfo_path = xbmc.translatePath(
|
|
"special://profile/addon_data/plugin.video.emby/library/%s/" % musicitemIds[itemId])
|
|
# Create folders for each content
|
|
if not xbmcvfs.exists(nfo_path):
|
|
xbmcvfs.mkdir(nfo_path)
|
|
# Where to put the nfos
|
|
nfo_path = "%s%s" % (nfo_path, "tvtunes.nfo")
|
|
|
|
url = "{server}/emby/Items/%s/ThemeSongs?format=json" % itemId
|
|
result = doUtils.downloadUrl(url)
|
|
|
|
# Create nfo and write themes to it
|
|
nfo_file = xbmcvfs.File(nfo_path, 'w')
|
|
pathstowrite = ""
|
|
# May be more than one theme
|
|
for theme in result['Items']:
|
|
if playback == "DirectPlay":
|
|
playurl = api.API(theme).get_file_path()
|
|
else:
|
|
playurl = playutils.PlayUtils(theme, dummy_listitem).get_direct_url(theme['MediaSources'][0])
|
|
pathstowrite += ('<file>%s</file>' % playurl.encode('utf-8'))
|
|
|
|
nfo_file.write(
|
|
'<tvtunes>%s</tvtunes>' % pathstowrite
|
|
)
|
|
# Close nfo file
|
|
nfo_file.close()
|
|
|
|
dialog.notification(
|
|
heading=lang(29999),
|
|
message=lang(33069),
|
|
icon="special://home/addons/plugin.video.emby/icon.png",
|
|
time=1000,
|
|
sound=False)
|
|
|
|
##### REFRESH EMBY PLAYLISTS #####
|
|
def refreshPlaylist():
|
|
|
|
if window('emby_online') != "true":
|
|
log.info("server is offline")
|
|
return
|
|
|
|
lib = librarysync.LibrarySync()
|
|
dialog = xbmcgui.Dialog()
|
|
try:
|
|
# First remove playlists
|
|
Playlist().delete_playlists()
|
|
# Remove video nodes
|
|
VideoNodes().deleteNodes()
|
|
# Refresh views
|
|
lib.refreshViews()
|
|
dialog.notification(
|
|
heading=lang(29999),
|
|
message=lang(33069),
|
|
icon="special://home/addons/plugin.video.emby/icon.png",
|
|
time=1000,
|
|
sound=False)
|
|
|
|
except Exception as e:
|
|
log.exception("Refresh playlists/nodes failed: %s" % e)
|
|
dialog.notification(
|
|
heading=lang(29999),
|
|
message=lang(33070),
|
|
icon=xbmcgui.NOTIFICATION_ERROR,
|
|
time=1000,
|
|
sound=False)
|
|
|
|
#### SHOW SUBFOLDERS FOR NODE #####
|
|
def GetSubFolders(nodeindex):
|
|
nodetypes = ["",".recent",".recentepisodes",".inprogress",".inprogressepisodes",".unwatched",".nextepisodes",".sets",".genres",".random",".recommended"]
|
|
for node in nodetypes:
|
|
title = window('Emby.nodes.%s%s.title' %(nodeindex,node))
|
|
if title:
|
|
path = window('Emby.nodes.%s%s.content' %(nodeindex,node))
|
|
addDirectoryItem(title, path)
|
|
xbmcplugin.endOfDirectory(int(sys.argv[1]))
|
|
|
|
##### BROWSE EMBY NODES DIRECTLY #####
|
|
def BrowseContent(viewname, browse_type="", folderid=""):
|
|
|
|
emby = embyserver.Read_EmbyServer()
|
|
art = artwork.Artwork()
|
|
doUtils = downloadutils.DownloadUtils()
|
|
|
|
#folderid used as filter ?
|
|
if folderid in ["recent","recentepisodes","inprogress","inprogressepisodes","unwatched","nextepisodes","sets","genres","random","recommended"]:
|
|
filter_type = folderid
|
|
folderid = ""
|
|
else:
|
|
filter_type = ""
|
|
|
|
xbmcplugin.setPluginCategory(int(sys.argv[1]), viewname)
|
|
#get views for root level
|
|
if not folderid:
|
|
views = emby.getViews(browse_type)
|
|
for view in views:
|
|
if view.get("name") == viewname.decode('utf-8'):
|
|
folderid = view.get("id")
|
|
break
|
|
|
|
if viewname is not None:
|
|
log.info("viewname: %s - type: %s - folderid: %s - filter: %s" %(viewname.decode('utf-8'), browse_type.decode('utf-8'), folderid.decode('utf-8'), filter_type.decode('utf-8')))
|
|
#set the correct params for the content type
|
|
#only proceed if we have a folderid
|
|
if folderid:
|
|
if browse_type == "homevideos":
|
|
#xbmcplugin.setContent(int(sys.argv[1]), 'files')
|
|
itemtype = "Video,Folder,PhotoAlbum,Photo"
|
|
else:
|
|
itemtype = ""
|
|
|
|
#get the actual listing
|
|
if browse_type == "recordings":
|
|
listing = emby.getTvRecordings(folderid)
|
|
elif browse_type == "tvchannels":
|
|
listing = emby.getTvChannels()
|
|
elif filter_type == "recent":
|
|
listing = emby.getFilteredSection(folderid, itemtype=itemtype.split(",")[0], sortby="DateCreated", recursive=True, limit=25, sortorder="Descending")
|
|
elif filter_type == "random":
|
|
listing = emby.getFilteredSection(folderid, itemtype=itemtype.split(",")[0], sortby="Random", recursive=True, limit=150, sortorder="Descending")
|
|
elif filter_type == "recommended":
|
|
listing = emby.getFilteredSection(folderid, itemtype=itemtype.split(",")[0], sortby="SortName", recursive=True, limit=25, sortorder="Ascending", filter_type="IsFavorite")
|
|
elif folderid == "favepisodes":
|
|
#xbmcplugin.setContent(int(sys.argv[1]), 'episodes')
|
|
listing = emby.getFilteredSection(None, itemtype="Episode", sortby="SortName", recursive=True, limit=25, sortorder="Ascending", filter_type="IsFavorite")
|
|
elif filter_type == "sets":
|
|
listing = emby.getFilteredSection(folderid, itemtype=itemtype.split(",")[1], sortby="SortName", recursive=True, limit=25, sortorder="Ascending", filter_type="IsFavorite")
|
|
else:
|
|
listing = emby.getFilteredSection(folderid, itemtype=itemtype, recursive=False)
|
|
|
|
#process the listing
|
|
if listing:
|
|
for item in listing.get("Items"):
|
|
li = createListItemFromEmbyItem(item,art,doUtils)
|
|
if item.get("IsFolder") == True:
|
|
#for folders we add an additional browse request, passing the folderId
|
|
params = {
|
|
|
|
'id': viewname.encode('utf-8'),
|
|
'mode': "browsecontent",
|
|
'type': browse_type,
|
|
'folderid': item['Id']
|
|
}
|
|
path = urllib_path("plugin://plugin.video.emby/", params)
|
|
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=path, listitem=li, isFolder=True)
|
|
else: #playable item, set plugin path and mediastreams
|
|
xbmcplugin.setContent(int(sys.argv[1]), 'episodes' if folderid else 'files')
|
|
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=li.getProperty("path"), listitem=li)
|
|
|
|
|
|
if filter_type == "recent":
|
|
xbmcplugin.addSortMethod(int(sys.argv[1]), xbmcplugin.SORT_METHOD_DATE)
|
|
else:
|
|
xbmcplugin.addSortMethod(int(sys.argv[1]), xbmcplugin.SORT_METHOD_VIDEO_TITLE)
|
|
xbmcplugin.addSortMethod(int(sys.argv[1]), xbmcplugin.SORT_METHOD_DATE)
|
|
xbmcplugin.addSortMethod(int(sys.argv[1]), xbmcplugin.SORT_METHOD_VIDEO_RATING)
|
|
xbmcplugin.addSortMethod(int(sys.argv[1]), xbmcplugin.SORT_METHOD_VIDEO_RUNTIME)
|
|
|
|
xbmcplugin.endOfDirectory(handle=int(sys.argv[1]))
|
|
|
|
##### CREATE LISTITEM FROM EMBY METADATA #####
|
|
def createListItemFromEmbyItem(item,art=artwork.Artwork(),doUtils=downloadutils.DownloadUtils()):
|
|
API = api.API(item)
|
|
itemid = item['Id']
|
|
|
|
title = item.get('Name')
|
|
li = xbmcgui.ListItem(title)
|
|
|
|
premieredate = item.get('PremiereDate',"")
|
|
if not premieredate: premieredate = item.get('DateCreated',"")
|
|
if premieredate:
|
|
premieredatelst = premieredate.split('T')[0].split("-")
|
|
premieredate = "%s.%s.%s" %(premieredatelst[2],premieredatelst[1],premieredatelst[0])
|
|
|
|
li.setProperty("embyid",itemid)
|
|
|
|
allart = art.get_all_artwork(item)
|
|
|
|
if item["Type"] == "Photo":
|
|
#listitem setup for pictures...
|
|
img_path = allart.get('Primary')
|
|
li.setProperty("path",img_path)
|
|
try:
|
|
picture = doUtils.downloadUrl("{server}/Items/%s/Images" %itemid)
|
|
except Exception as error:
|
|
lof.info("Error getting images from server: " + str(error))
|
|
picture = None
|
|
|
|
if picture is not None:
|
|
picture = picture[0]
|
|
if picture.get("Width") > picture.get("Height"):
|
|
li.setArt( {"fanart": img_path}) #add image as fanart for use with skinhelper auto thumb/backgrund creation
|
|
li.setInfo('pictures', infoLabels={ "picturepath": img_path, "date": premieredate, "size": picture.get("Size"), "exif:width": str(picture.get("Width")), "exif:height": str(picture.get("Height")), "title": title})
|
|
li.setThumbnailImage(img_path)
|
|
li.setProperty("plot",API.get_overview())
|
|
li.setIconImage('DefaultPicture.png')
|
|
|
|
elif item['Type'] == "PhotoAlbum":
|
|
img_path = allart.get('Primary')
|
|
li.setProperty("path", img_path)
|
|
li.setThumbnailImage(img_path)
|
|
li.setIconImage('DefaultPicture.png')
|
|
backdrop = allart.get('Backdrop')
|
|
if backdrop:
|
|
li.setArt({ 'fanart': backdrop[0] })
|
|
else:
|
|
#normal video items
|
|
li.setProperty('IsPlayable', 'true')
|
|
path = "%s?id=%s&mode=play" % (sys.argv[0], item.get("Id"))
|
|
li.setProperty("path",path)
|
|
genre = API.get_genres()
|
|
overlay = 0
|
|
userdata = API.get_userdata()
|
|
runtime = item.get("RunTimeTicks",0)/ 10000000.0
|
|
seektime = userdata['Resume']
|
|
if seektime:
|
|
li.setProperty("resumetime", str(seektime))
|
|
li.setProperty("totaltime", str(runtime))
|
|
|
|
played = userdata['Played']
|
|
if played: overlay = 7
|
|
else: overlay = 6
|
|
playcount = userdata['PlayCount']
|
|
if playcount is None:
|
|
playcount = 0
|
|
|
|
rating = item.get('CommunityRating')
|
|
if not rating: rating = 0
|
|
|
|
# Populate the extradata list and artwork
|
|
extradata = {
|
|
'id': itemid,
|
|
'rating': rating,
|
|
'year': item.get('ProductionYear'),
|
|
'genre': genre,
|
|
'playcount': str(playcount),
|
|
'title': title,
|
|
'plot': API.get_overview(),
|
|
'Overlay': str(overlay),
|
|
'duration': runtime
|
|
}
|
|
if premieredate:
|
|
extradata["premieredate"] = premieredate
|
|
extradata["date"] = premieredate
|
|
li.setInfo('video', infoLabels=extradata)
|
|
if allart.get('Primary'):
|
|
li.setThumbnailImage(allart.get('Primary'))
|
|
else: li.setThumbnailImage('DefaultTVShows.png')
|
|
li.setIconImage('DefaultTVShows.png')
|
|
if not allart.get('Background'): #add image as fanart for use with skinhelper auto thumb/backgrund creation
|
|
li.setArt( {"fanart": allart.get('Primary') } )
|
|
else:
|
|
pbutils.PlaybackUtils(item).setArtwork(li)
|
|
|
|
mediastreams = API.get_media_streams()
|
|
videostreamFound = False
|
|
if mediastreams:
|
|
for key, value in mediastreams.iteritems():
|
|
if key == "video" and value: videostreamFound = True
|
|
if value: li.addStreamInfo(key, value[0])
|
|
if not videostreamFound:
|
|
#just set empty streamdetails to prevent errors in the logs
|
|
li.addStreamInfo("video", {'duration': runtime})
|
|
|
|
return li
|
|
|
|
##### BROWSE EMBY CHANNELS #####
|
|
def BrowseChannels(itemid, folderid=None):
|
|
|
|
_addon_id = int(sys.argv[1])
|
|
_addon_url = sys.argv[0]
|
|
doUtils = downloadutils.DownloadUtils()
|
|
art = artwork.Artwork()
|
|
|
|
xbmcplugin.setContent(int(sys.argv[1]), 'files')
|
|
if folderid:
|
|
url = (
|
|
"{server}/emby/Channels/%s/Items?userid={UserId}&folderid=%s&format=json"
|
|
% (itemid, folderid))
|
|
elif itemid == "0":
|
|
# id 0 is the root channels folder
|
|
url = "{server}/emby/Channels?{UserId}&format=json"
|
|
else:
|
|
url = "{server}/emby/Channels/%s/Items?UserId={UserId}&format=json" % itemid
|
|
|
|
try:
|
|
result = doUtils.downloadUrl(url)
|
|
except Exception as error:
|
|
log.info("Error getting channel: " + str(error))
|
|
result = None
|
|
|
|
if result is not None and result.get("Items"):
|
|
for item in result.get("Items"):
|
|
itemid = item['Id']
|
|
itemtype = item['Type']
|
|
li = createListItemFromEmbyItem(item,art,doUtils)
|
|
|
|
isFolder = item.get('IsFolder', False)
|
|
|
|
channelId = item.get('ChannelId', "")
|
|
channelName = item.get('ChannelName', "")
|
|
if itemtype == "Channel":
|
|
path = "%s?id=%s&mode=channels" % (_addon_url, itemid)
|
|
xbmcplugin.addDirectoryItem(handle=_addon_id, url=path, listitem=li, isFolder=True)
|
|
elif isFolder:
|
|
path = "%s?id=%s&mode=channelsfolder&folderid=%s" % (_addon_url, channelId, itemid)
|
|
xbmcplugin.addDirectoryItem(handle=_addon_id, url=path, listitem=li, isFolder=True)
|
|
else:
|
|
path = "%s?id=%s&mode=play" % (_addon_url, itemid)
|
|
li.setProperty('IsPlayable', 'true')
|
|
xbmcplugin.addDirectoryItem(handle=_addon_id, url=path, listitem=li)
|
|
|
|
xbmcplugin.endOfDirectory(handle=int(sys.argv[1]))
|
|
|
|
##### LISTITEM SETUP FOR VIDEONODES #####
|
|
def createListItem(item):
|
|
|
|
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.setThumbnailImage(item['art'].get('thumb',''))
|
|
li.setIconImage('DefaultTVShows.png')
|
|
li.setProperty('dbid', str(item['episodeid']))
|
|
li.setProperty('fanart_image', item['art'].get('tvshow.fanart',''))
|
|
for key, value in item['streamdetails'].iteritems():
|
|
for stream in value:
|
|
li.addStreamInfo(key, stream)
|
|
|
|
return li
|
|
|
|
##### GET NEXTUP EPISODES FOR TAGNAME #####
|
|
def getNextUpEpisodes(tagname, limit):
|
|
|
|
count = 0
|
|
# if the addon is called with nextup parameter,
|
|
# we return the nextepisodes list of the given tagname
|
|
xbmcplugin.setContent(int(sys.argv[1]), 'episodes')
|
|
# First we get a list of all the TV shows - filtered by tag
|
|
query = {
|
|
|
|
'jsonrpc': "2.0",
|
|
'id': "libTvShows",
|
|
'method': "VideoLibrary.GetTVShows",
|
|
'params': {
|
|
|
|
'sort': {'order': "descending", 'method': "lastplayed"},
|
|
'filter': {
|
|
'and': [
|
|
{'operator': "true", 'field': "inprogress", 'value': ""},
|
|
{'operator': "is", 'field': "tag", 'value': "%s" % tagname}
|
|
]},
|
|
'properties': ['title', 'studio', 'mpaa', 'file', 'art']
|
|
}
|
|
}
|
|
result = xbmc.executeJSONRPC(json.dumps(query))
|
|
result = json.loads(result)
|
|
# If we found any, find the oldest unwatched show for each one.
|
|
try:
|
|
items = result['result']['tvshows']
|
|
except (KeyError, TypeError):
|
|
pass
|
|
else:
|
|
for item in items:
|
|
if settings('ignoreSpecialsNextEpisodes') == "true":
|
|
query = {
|
|
|
|
'jsonrpc': "2.0",
|
|
'id': 1,
|
|
'method': "VideoLibrary.GetEpisodes",
|
|
'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:
|
|
query = {
|
|
|
|
'jsonrpc': "2.0",
|
|
'id': 1,
|
|
'method': "VideoLibrary.GetEpisodes",
|
|
'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 = xbmc.executeJSONRPC(json.dumps(query))
|
|
result = json.loads(result)
|
|
try:
|
|
episodes = result['result']['episodes']
|
|
except (KeyError, TypeError):
|
|
pass
|
|
else:
|
|
for episode in episodes:
|
|
li = createListItem(episode)
|
|
xbmcplugin.addDirectoryItem(
|
|
handle=int(sys.argv[1]),
|
|
url=episode['file'],
|
|
listitem=li)
|
|
count += 1
|
|
|
|
if count == limit:
|
|
break
|
|
|
|
xbmcplugin.endOfDirectory(handle=int(sys.argv[1]))
|
|
|
|
##### GET INPROGRESS EPISODES FOR TAGNAME #####
|
|
def getInProgressEpisodes(tagname, limit):
|
|
|
|
count = 0
|
|
# if the addon is called with inprogressepisodes parameter,
|
|
# we return the inprogressepisodes list of the given tagname
|
|
xbmcplugin.setContent(int(sys.argv[1]), 'episodes')
|
|
# First we get a list of all the in-progress TV shows - filtered by tag
|
|
query = {
|
|
|
|
'jsonrpc': "2.0",
|
|
'id': "libTvShows",
|
|
'method': "VideoLibrary.GetTVShows",
|
|
'params': {
|
|
|
|
'sort': {'order': "descending", 'method': "lastplayed"},
|
|
'filter': {
|
|
'and': [
|
|
{'operator': "true", 'field': "inprogress", 'value': ""},
|
|
{'operator': "is", 'field': "tag", 'value': "%s" % tagname}
|
|
]},
|
|
'properties': ['title', 'studio', 'mpaa', 'file', 'art']
|
|
}
|
|
}
|
|
result = xbmc.executeJSONRPC(json.dumps(query))
|
|
result = json.loads(result)
|
|
# If we found any, find the oldest unwatched show for each one.
|
|
try:
|
|
items = result['result']['tvshows']
|
|
except (KeyError, TypeError):
|
|
pass
|
|
else:
|
|
for item in items:
|
|
query = {
|
|
|
|
'jsonrpc': "2.0",
|
|
'id': 1,
|
|
'method': "VideoLibrary.GetEpisodes",
|
|
'params': {
|
|
|
|
'tvshowid': item['tvshowid'],
|
|
'sort': {'method': "episode"},
|
|
'filter': {'operator': "true", 'field': "inprogress", 'value': ""},
|
|
'properties': [
|
|
"title", "playcount", "season", "episode", "showtitle", "plot",
|
|
"file", "rating", "resume", "tvshowid", "art", "cast",
|
|
"streamdetails", "firstaired", "runtime", "writer",
|
|
"dateadded", "lastplayed"
|
|
]
|
|
}
|
|
}
|
|
result = xbmc.executeJSONRPC(json.dumps(query))
|
|
result = json.loads(result)
|
|
try:
|
|
episodes = result['result']['episodes']
|
|
except (KeyError, TypeError):
|
|
pass
|
|
else:
|
|
for episode in episodes:
|
|
li = createListItem(episode)
|
|
xbmcplugin.addDirectoryItem(
|
|
handle=int(sys.argv[1]),
|
|
url=episode['file'],
|
|
listitem=li)
|
|
count += 1
|
|
|
|
if count == limit:
|
|
break
|
|
|
|
xbmcplugin.endOfDirectory(handle=int(sys.argv[1]))
|
|
|
|
##### GET RECENT EPISODES FOR TAGNAME #####
|
|
def getRecentEpisodes(tagname, limit, filters=""):
|
|
|
|
count = 0
|
|
filters = filters.split(',') if filters else []
|
|
# if the addon is called with recentepisodes parameter,
|
|
# we return the recentepisodes list of the given tagname
|
|
xbmcplugin.setContent(int(sys.argv[1]), 'episodes')
|
|
# First we get a list of all the TV shows - filtered by tag
|
|
query = {
|
|
|
|
'jsonrpc': "2.0",
|
|
'id': "libTvShows",
|
|
'method': "VideoLibrary.GetTVShows",
|
|
'params': {
|
|
|
|
'sort': {'order': "descending", 'method': "dateadded"},
|
|
'filter': {'operator': "is", 'field': "tag", 'value': "%s" % tagname},
|
|
'properties': ["title", "sorttitle"]
|
|
}
|
|
}
|
|
result = xbmc.executeJSONRPC(json.dumps(query))
|
|
result = json.loads(result)
|
|
# If we found any, find the oldest unwatched show for each one.
|
|
try:
|
|
items = result['result']['tvshows']
|
|
except (KeyError, TypeError):
|
|
pass
|
|
else:
|
|
allshowsIds = set(item['tvshowid'] for item in items)
|
|
|
|
query = {
|
|
|
|
'jsonrpc': "2.0",
|
|
'id': 1,
|
|
'method': "VideoLibrary.GetEpisodes",
|
|
'params': {
|
|
|
|
'sort': {'order': "descending", 'method': "dateadded"},
|
|
'properties': [
|
|
"title", "playcount", "season", "episode", "showtitle", "plot",
|
|
"file", "rating", "resume", "tvshowid", "art", "streamdetails",
|
|
"firstaired", "runtime", "cast", "writer", "dateadded", "lastplayed"
|
|
],
|
|
"limits": {"end": limit*5}
|
|
}
|
|
}
|
|
if 'playcount' not in filters:
|
|
query['params']['filter'] = {'operator': "lessthan", 'field': "playcount", 'value': "1"}
|
|
|
|
result = xbmc.executeJSONRPC(json.dumps(query))
|
|
result = json.loads(result)
|
|
try:
|
|
episodes = result['result']['episodes']
|
|
except (KeyError, TypeError):
|
|
pass
|
|
else:
|
|
for episode in episodes:
|
|
if episode['tvshowid'] in allshowsIds:
|
|
li = createListItem(episode)
|
|
xbmcplugin.addDirectoryItem(
|
|
handle=int(sys.argv[1]),
|
|
url=episode['file'],
|
|
listitem=li)
|
|
count += 1
|
|
|
|
if count == limit:
|
|
break
|
|
|
|
xbmcplugin.endOfDirectory(handle=int(sys.argv[1]))
|
|
|
|
##### GET VIDEO EXTRAS FOR LISTITEM #####
|
|
def getVideoFiles(embyId,embyPath):
|
|
#returns the video files for the item as plugin listing, can be used for browsing the actual files or videoextras etc.
|
|
emby = embyserver.Read_EmbyServer()
|
|
if not embyId:
|
|
if "plugin.video.emby" in embyPath:
|
|
embyId = embyPath.split("/")[-2]
|
|
if embyId:
|
|
item = emby.getItem(embyId)
|
|
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=int(sys.argv[1]), url=file, listitem=li)
|
|
for dir in dirs:
|
|
dir = filelocation + dir
|
|
li = xbmcgui.ListItem(dir, path=dir)
|
|
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=dir, listitem=li, isFolder=True)
|
|
xbmcplugin.endOfDirectory(int(sys.argv[1]))
|
|
|
|
##### GET EXTRAFANART FOR LISTITEM #####
|
|
def getExtraFanArt(embyId,embyPath):
|
|
|
|
emby = embyserver.Read_EmbyServer()
|
|
art = artwork.Artwork()
|
|
|
|
# Get extrafanart for listitem
|
|
# will be called by skinhelper script to get the extrafanart
|
|
try:
|
|
# for tvshows we get the embyid just from the path
|
|
if not embyId:
|
|
if "plugin.video.emby" in embyPath:
|
|
embyId = embyPath.split("/")[-2]
|
|
|
|
if embyId:
|
|
#only proceed if we actually have a emby id
|
|
log.info("Requesting extrafanart for Id: %s" % embyId)
|
|
|
|
# We need to store the images locally for this to work
|
|
# because of the caching system in xbmc
|
|
fanartDir = xbmc.translatePath("special://thumbnails/emby/%s/" % embyId).decode('utf-8')
|
|
|
|
if not xbmcvfs.exists(fanartDir):
|
|
# Download the images to the cache directory
|
|
xbmcvfs.mkdirs(fanartDir)
|
|
item = emby.getItem(embyId)
|
|
if item:
|
|
backdrops = art.get_all_artwork(item)['Backdrop']
|
|
tags = item['BackdropImageTags']
|
|
count = 0
|
|
for backdrop in backdrops:
|
|
# Same ordering as in artwork
|
|
tag = tags[count]
|
|
if os.path.supports_unicode_filenames:
|
|
fanartFile = os.path.join(fanartDir, "fanart%s.jpg" % tag)
|
|
else:
|
|
fanartFile = os.path.join(fanartDir.encode("utf-8"), "fanart%s.jpg" % tag.encode("utf-8"))
|
|
li = xbmcgui.ListItem(tag, path=fanartFile)
|
|
xbmcplugin.addDirectoryItem(
|
|
handle=int(sys.argv[1]),
|
|
url=fanartFile,
|
|
listitem=li)
|
|
xbmcvfs.copy(backdrop, fanartFile)
|
|
count += 1
|
|
else:
|
|
log.debug("Found cached backdrop.")
|
|
# Use existing cached images
|
|
dirs, files = xbmcvfs.listdir(fanartDir)
|
|
for file in files:
|
|
fanartFile = os.path.join(fanartDir, file.decode('utf-8'))
|
|
li = xbmcgui.ListItem(file, path=fanartFile)
|
|
xbmcplugin.addDirectoryItem(
|
|
handle=int(sys.argv[1]),
|
|
url=fanartFile,
|
|
listitem=li)
|
|
except Exception as e:
|
|
log.error("Error getting extrafanart: %s" % e)
|
|
|
|
# Always do endofdirectory to prevent errors in the logs
|
|
xbmcplugin.endOfDirectory(int(sys.argv[1]))
|