Jellyfin/jellyfin-kodi
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin-kodi.git synced 2024-11-14 14:16:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
jellyfin-kodi/resources/lib/WriteKodiDB.py

1066 lines
50 KiB
Python
Raw Normal View History

Refactor 4/4
2015-03-17 19:02:42 +00:00
#################################################################################################
# WriteKodiDB
#################################################################################################
import xbmc
import xbmcgui
import xbmcaddon
import xbmcvfs
import json
import urllib
import sqlite3
import os
from DownloadUtils import DownloadUtils
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
from PlayUtils import PlayUtils
Refactor 4/4
2015-03-17 19:02:42 +00:00
from CreateFiles import CreateFiles
Refactor fix
2015-03-17 20:18:27 +00:00
from ReadKodiDB import ReadKodiDB
fixed season artwork
2015-03-20 15:58:46 +00:00
from ReadEmbyDB import ReadEmbyDB
Refactor 4/4
2015-03-17 19:02:42 +00:00
from API import API
import Utils as utils
refactor to plugin.video.emby
2015-03-25 17:37:21 +00:00
addon = xbmcaddon.Addon(id='plugin.video.emby')
Refactor 4/4
2015-03-17 19:02:42 +00:00
addondir = xbmc.translatePath(addon.getAddonInfo('profile'))
dataPath = os.path.join(addondir,"library")
movieLibrary = os.path.join(dataPath,'movies')
tvLibrary = os.path.join(dataPath,'tvshows')
added musicvideos support
2015-03-21 13:31:30 +00:00
musicvideoLibrary = os.path.join(dataPath,'musicvideos')
speed improvement moved all sleeps to the kodi api calls only
2015-03-19 10:13:49 +00:00
sleepVal = 20
Refactor 4/4
2015-03-17 19:02:42 +00:00
add episode watched push to MBS from Kodi
2015-03-18 02:45:15 +00:00
class WriteKodiDB():
def updatePlayCountFromKodi(self, id, type, playcount=0):
#when user marks item watched from kodi interface update this in MB3
speed improvement moved all sleeps to the kodi api calls only
2015-03-19 10:13:49 +00:00
xbmc.sleep(sleepVal)
add episode watched push to MBS from Kodi
2015-03-18 02:45:15 +00:00
xbmc.log("WriteKodiDB -> updatePlayCountFromKodi Called")
Refactor 4/4
2015-03-17 19:02:42 +00:00
add episode watched push to MBS from Kodi
2015-03-18 02:45:15 +00:00
mb3Id = None
if(type == "movie"):
mb3Id = None
json_response = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovieDetails", "params": { "movieid": ' + str(id) + ', "properties" : ["playcount", "file"] }, "id": "1"}')
if json_response != None:
jsonobject = json.loads(json_response.decode('utf-8','replace'))
if(jsonobject.has_key('result')):
result = jsonobject['result']
if(result.has_key('moviedetails')):
moviedetails = result['moviedetails']
filename = moviedetails.get("file").rpartition('\\')[2]
mb3Id = filename.replace(".strm","")
Refactor 4/4
2015-03-17 19:02:42 +00:00
add episode watched push to MBS from Kodi
2015-03-18 02:45:15 +00:00
elif(type == "episode"):
mb3Id = None
json_response = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodeDetails", "params": { "episodeid": ' + str(id) + ', "properties" : ["playcount", "file"] }, "id": "1"}')
if json_response != None:
jsonobject = json.loads(json_response.decode('utf-8','replace'))
if(jsonobject.has_key('result')):
result = jsonobject['result']
if(result.has_key('episodedetails')):
episodedetails = result['episodedetails']
filename = episodedetails.get("file").rpartition('\\')[2]
mb3Id = filename[-38:-6]
Refactor 4/4
2015-03-17 19:02:42 +00:00
add episode watched push to MBS from Kodi
2015-03-18 02:45:15 +00:00
if(mb3Id != None):
refactor to plugin.video.emby
2015-03-25 17:37:21 +00:00
addon = xbmcaddon.Addon(id='plugin.video.emby')
add episode watched push to MBS from Kodi
2015-03-18 02:45:15 +00:00
port = addon.getSetting('port')
host = addon.getSetting('ipaddress')
server = host + ":" + port
downloadUtils = DownloadUtils()
userid = downloadUtils.getUserId()
watchedurl = 'http://' + server + '/mediabrowser/Users/' + userid + '/PlayedItems/' + mb3Id
utils.logMsg("MB3 Sync","watchedurl -->" + watchedurl)
if playcount != 0:
downloadUtils.downloadUrl(watchedurl, postBody="", type="POST")
else:
downloadUtils.downloadUrl(watchedurl, type="DELETE")
Refactor 4/4
2015-03-17 19:02:42 +00:00
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
def updateMovieToKodiLibrary_Batched(self, MBitem, KodiItem):
refactor to plugin.video.emby
2015-03-25 17:37:21 +00:00
addon = xbmcaddon.Addon(id='plugin.video.emby')
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
port = addon.getSetting('port')
host = addon.getSetting('ipaddress')
server = host + ":" + port
downloadUtils = DownloadUtils()
userid = downloadUtils.getUserId()
timeInfo = API().getTimeInfo(MBitem)
userData=API().getUserData(MBitem)
people = API().getPeople(MBitem)
genre = API().getGenre(MBitem)
studios = API().getStudios(MBitem)
mediaStreams=API().getMediaStreams(MBitem)
thumbPath = API().getArtwork(MBitem, "Primary")
params = list()
self.getArtworkParam_Batched(KodiItem, MBitem, params)
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
#set Filename
playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem)
one more fix for transcoding
2015-03-28 18:11:38 +00:00
if not playurl.startswith("http"):
if playurl != KodiItem["file"]:
self.setKodiFilename(KodiItem["movieid"], playurl, "movie")
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
#update common properties
duration = (int(timeInfo.get('Duration'))*60)
self.getPropertyParam_Batched(KodiItem, "runtime", duration, params)
self.getPropertyParam_Batched(KodiItem, "year", MBitem.get("ProductionYear"), params)
self.getPropertyParam_Batched(KodiItem, "mpaa", MBitem.get("OfficialRating"), params)
added lastplayed field to sync
2015-03-24 20:03:07 +00:00
self.getPropertyParam_Batched(KodiItem, "lastplayed", userData.get("LastPlayedDate"), params)
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
self.getPropertyParamArray_Batched(KodiItem, "tag", MBitem.get("Tag"), params)
if MBitem.get("CriticRating") != None:
self.getPropertyParam_Batched(KodiItem, "rating", int(MBitem.get("CriticRating"))/10, params)
self.getPropertyParam_Batched(KodiItem, "plotoutline", MBitem.get("ShortOverview"), params)
self.getPropertyParam_Batched(KodiItem, "set", MBitem.get("TmdbCollectionName"), params)
self.getPropertyParam_Batched(KodiItem, "sorttitle", MBitem.get("SortName"), params)
if MBitem.get("ProviderIds") != None:
if MBitem.get("ProviderIds").get("Imdb") != None:
self.getPropertyParam_Batched(KodiItem, "imdbnumber", MBitem.get("ProviderIds").get("Imdb"), params)
# FIXME --> Taglines not returned by MB3 server !?
if MBitem.get("TagLines") != None:
self.getPropertyParam_Batched(KodiItem, "tagline", MBitem.get("TagLines")[0], params)
self.getPropertyParamArray_Batched(KodiItem, "writer", people.get("Writer"), params)
self.getPropertyParamArray_Batched(KodiItem, "director", people.get("Director"), params)
self.getPropertyParamArray_Batched(KodiItem, "genre", MBitem.get("Genres"), params)
if(studios != None):
for x in range(0, len(studios)):
studios[x] = studios[x].replace("/", "&")
self.getPropertyParamArray_Batched(KodiItem, "studio", studios, params)
# FIXME --> ProductionLocations not returned by MB3 server !?
self.getPropertyParamArray_Batched(KodiItem, "country", MBitem.get("ProductionLocations"), params)
#trailer link
trailerUrl = None
if MBitem.get("LocalTrailerCount") != None and MBitem.get("LocalTrailerCount") > 0:
itemTrailerUrl = "http://" + server + "/mediabrowser/Users/" + userid + "/Items/" + MBitem.get("Id") + "/LocalTrailers?format=json"
Change suppress to False unless really needed This is how it really was before yesterday's commit to re-enable the optionality
2015-03-25 12:48:29 +00:00
jsonData = downloadUtils.downloadUrl(itemTrailerUrl, suppress=False, popup=0 )
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
if(jsonData != ""):
trailerItem = json.loads(jsonData)
only add real local trailers
2015-03-22 14:51:03 +00:00
if trailerItem[0].get("LocationType") == "FileSystem":
refactor to plugin.video.emby
2015-03-25 17:37:21 +00:00
trailerUrl = "plugin://plugin.video.emby/?id=" + trailerItem[0].get("Id") + '&mode=play'
only add real local trailers
2015-03-22 14:51:03 +00:00
self.getPropertyParam_Batched(KodiItem, "trailer", trailerUrl, params)
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
changes = False
# if there were movies changes then send the update via JSONRPC
if(len(params) > 0):
changes |= True
small changes to progress dialog and working of restart message
2015-03-21 03:15:34 +00:00
utils.logMsg("UpdateMovieParams", str(params), level = 2)
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": { "movieid": %i, %s}, "id": 1 }'
paramString = ""
paramLen = len(params)
for x in range(0, paramLen):
param = params[x]
paramString += param
if(x < paramLen-1):
paramString += ", "
jsoncommand = jsoncommand %(KodiItem['movieid'], paramString)
small changes to progress dialog and working of restart message
2015-03-21 03:15:34 +00:00
utils.logMsg("executeJSONRPC : ", jsoncommand, level = 2)
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
xbmc.sleep(sleepVal)
result = xbmc.executeJSONRPC(jsoncommand)
#add actors
changes |= self.AddActorsToMedia(KodiItem,MBitem.get("People"), "movie")
CreateFiles().createSTRM(MBitem)
CreateFiles().createNFO(MBitem)
Move theme music sync to update and make it an option
2015-03-25 09:59:23 +00:00
#add theme music
if addon.getSetting("syncThemeMusic") == "true":
CreateFiles().copyThemeMusic(MBitem)
added extra fanart sync
2015-03-25 14:00:08 +00:00
#add extra fanart
if addon.getSetting("syncExtraFanart") == "true":
CreateFiles().copyExtraFanart(MBitem)
Move theme music sync to update and make it an option
2015-03-25 09:59:23 +00:00
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
if(changes):
utils.logMsg("Updated item to Kodi Library", MBitem["Id"] + " - " + MBitem["Name"], level=0)
add Notification as an UI indication option for syns actions
2015-03-23 03:54:07 +00:00
return changes
added musicvideos support
2015-03-21 13:31:30 +00:00
def updateMusicVideoToKodiLibrary_Batched(self, MBitem, KodiItem):
refactor to plugin.video.emby
2015-03-25 17:37:21 +00:00
addon = xbmcaddon.Addon(id='plugin.video.emby')
added musicvideos support
2015-03-21 13:31:30 +00:00
port = addon.getSetting('port')
host = addon.getSetting('ipaddress')
server = host + ":" + port
downloadUtils = DownloadUtils()
userid = downloadUtils.getUserId()
timeInfo = API().getTimeInfo(MBitem)
userData=API().getUserData(MBitem)
people = API().getPeople(MBitem)
genre = API().getGenre(MBitem)
studios = API().getStudios(MBitem)
mediaStreams=API().getMediaStreams(MBitem)
thumbPath = API().getArtwork(MBitem, "Primary")
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
added musicvideos support
2015-03-21 13:31:30 +00:00
params = list()
self.getArtworkParam_Batched(KodiItem, MBitem, params)
#update common properties
duration = (int(timeInfo.get('Duration'))*60)
self.getPropertyParam_Batched(KodiItem, "runtime", duration, params)
self.getPropertyParam_Batched(KodiItem, "year", MBitem.get("ProductionYear"), params)
self.getPropertyParamArray_Batched(KodiItem, "director", people.get("Director"), params)
self.getPropertyParamArray_Batched(KodiItem, "genre", MBitem.get("Genres"), params)
self.getPropertyParamArray_Batched(KodiItem, "artist", MBitem.get("Artist"), params)
self.getPropertyParamArray_Batched(KodiItem, "album", MBitem.get("Album"), params)
added lastplayed field to sync
2015-03-24 20:03:07 +00:00
self.getPropertyParam_Batched(KodiItem, "lastplayed", userData.get("LastPlayedDate"), params)
added musicvideos support
2015-03-21 13:31:30 +00:00
if(studios != None):
for x in range(0, len(studios)):
studios[x] = studios[x].replace("/", "&")
self.getPropertyParamArray_Batched(KodiItem, "studio", studios, params)
changes = False
# if there were movies changes then send the update via JSONRPC
if(len(params) > 0):
changes |= True
utils.logMsg("UpdateMovieParams", str(params), level = 2)
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMusicVideoDetails", "params": { "musicvideoid": %i, %s}, "id": 1 }'
paramString = ""
paramLen = len(params)
for x in range(0, paramLen):
param = params[x]
paramString += param
if(x < paramLen-1):
paramString += ", "
jsoncommand = jsoncommand %(KodiItem['musicvideoid'], paramString)
utils.logMsg("executeJSONRPC : ", jsoncommand, level = 2)
xbmc.sleep(sleepVal)
result = xbmc.executeJSONRPC(jsoncommand)
CreateFiles().createSTRM(MBitem)
CreateFiles().createNFO(MBitem)
if(changes):
utils.logMsg("Updated musicvideo to Kodi Library", MBitem["Id"] + " - " + MBitem["Name"], level=0)
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
def updateMovieToKodiLibrary(self, MBitem, KodiItem):
Refactor 4/4
2015-03-17 19:02:42 +00:00
refactor to plugin.video.emby
2015-03-25 17:37:21 +00:00
addon = xbmcaddon.Addon(id='plugin.video.emby')
Refactor 4/4
2015-03-17 19:02:42 +00:00
port = addon.getSetting('port')
host = addon.getSetting('ipaddress')
server = host + ":" + port
downloadUtils = DownloadUtils()
userid = downloadUtils.getUserId()
timeInfo = API().getTimeInfo(MBitem)
userData=API().getUserData(MBitem)
people = API().getPeople(MBitem)
genre = API().getGenre(MBitem)
studios = API().getStudios(MBitem)
mediaStreams=API().getMediaStreams(MBitem)
thumbPath = API().getArtwork(MBitem, "Primary")
changes = False
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
#update/check all artwork
changes |= self.updateArtWork(KodiItem,MBitem)
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
Refactor 4/4
2015-03-17 19:02:42 +00:00
#update common properties
duration = (int(timeInfo.get('Duration'))*60)
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= self.updateProperty(KodiItem,"runtime",duration,"movie")
changes |= self.updateProperty(KodiItem,"year",MBitem.get("ProductionYear"),"movie")
changes |= self.updateProperty(KodiItem,"mpaa",MBitem.get("OfficialRating"),"movie")
added lastplayed field to sync
2015-03-24 20:03:07 +00:00
changes |= self.updateProperty(KodiItem,"lastplayed",MBitem.get("LastPlayedDate"),"movie")
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= self.updatePropertyArray(KodiItem,"tag",MBitem.get("Tag"),"movie")
Refactor 4/4
2015-03-17 19:02:42 +00:00
if MBitem.get("CriticRating") != None:
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= self.updateProperty(KodiItem,"rating",int(MBitem.get("CriticRating"))/10,"movie")
changes |= self.updateProperty(KodiItem,"plotoutline",MBitem.get("ShortOverview"),"movie")
changes |= self.updateProperty(KodiItem,"set",MBitem.get("TmdbCollectionName"),"movie")
changes |= self.updateProperty(KodiItem,"sorttitle",MBitem.get("SortName"),"movie")
Refactor 4/4
2015-03-17 19:02:42 +00:00
if MBitem.get("ProviderIds") != None:
if MBitem.get("ProviderIds").get("Imdb") != None:
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= self.updateProperty(KodiItem,"imdbnumber",MBitem.get("ProviderIds").get("Imdb"),"movie")
Refactor 4/4
2015-03-17 19:02:42 +00:00
# FIXME --> Taglines not returned by MB3 server !?
if MBitem.get("TagLines") != None:
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= self.updateProperty(KodiItem,"tagline",MBitem.get("TagLines")[0],"movie")
replace / with & in studio strings
2015-03-18 05:05:21 +00:00
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= self.updatePropertyArray(KodiItem,"writer",people.get("Writer"),"movie")
changes |= self.updatePropertyArray(KodiItem,"director",people.get("Director"),"movie")
changes |= self.updatePropertyArray(KodiItem,"genre",MBitem.get("Genres"),"movie")
replace / with & in studio strings
2015-03-18 05:05:21 +00:00
if(studios != None):
for x in range(0, len(studios)):
studios[x] = studios[x].replace("/", "&")
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= self.updatePropertyArray(KodiItem,"studio",studios,"movie")
replace / with & in studio strings
2015-03-18 05:05:21 +00:00
Refactor 4/4
2015-03-17 19:02:42 +00:00
# FIXME --> ProductionLocations not returned by MB3 server !?
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= self.updatePropertyArray(KodiItem,"country",MBitem.get("ProductionLocations"),"movie")
Refactor 4/4
2015-03-17 19:02:42 +00:00
#trailer link
trailerUrl = None
if MBitem.get("LocalTrailerCount") != None and MBitem.get("LocalTrailerCount") > 0:
itemTrailerUrl = "http://" + server + "/mediabrowser/Users/" + userid + "/Items/" + MBitem.get("Id") + "/LocalTrailers?format=json"
Change suppress to False unless really needed This is how it really was before yesterday's commit to re-enable the optionality
2015-03-25 12:48:29 +00:00
jsonData = downloadUtils.downloadUrl(itemTrailerUrl, suppress=False, popup=0 )
Refactor 4/4
2015-03-17 19:02:42 +00:00
if(jsonData != ""):
trailerItem = json.loads(jsonData)
refactor to plugin.video.emby
2015-03-25 17:37:21 +00:00
trailerUrl = "plugin://plugin.video.emby/?id=" + trailerItem[0].get("Id") + '&mode=play'
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= self.updateProperty(KodiItem,"trailer",trailerUrl,"movie")
Refactor 4/4
2015-03-17 19:02:42 +00:00
#add actors
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= self.AddActorsToMedia(KodiItem,MBitem.get("People"),"movie")
Refactor 4/4
2015-03-17 19:02:42 +00:00
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
#set Filename
playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem)
self.setKodiFilename(KodiItem["movieid"], playurl, "movie")
Refactor 4/4
2015-03-17 19:02:42 +00:00
CreateFiles().createSTRM(MBitem)
CreateFiles().createNFO(MBitem)
Move theme music sync to update and make it an option
2015-03-25 09:59:23 +00:00
#add theme music
if addon.getSetting("syncThemeMusic") == "true":
CreateFiles().copyThemeMusic(MBitem)
added extra fanart sync
2015-03-25 14:00:08 +00:00
#add extra fanart
if addon.getSetting("syncExtraFanart") == "true":
CreateFiles().copyExtraFanart(MBitem)
Move theme music sync to update and make it an option
2015-03-25 09:59:23 +00:00
Refactor 4/4
2015-03-17 19:02:42 +00:00
if changes:
utils.logMsg("Updated item to Kodi Library", MBitem["Id"] + " - " + MBitem["Name"])
def updateTVShowToKodiLibrary( self, MBitem, KodiItem ):
refactor to plugin.video.emby
2015-03-25 17:37:21 +00:00
addon = xbmcaddon.Addon(id='plugin.video.emby')
Refactor 4/4
2015-03-17 19:02:42 +00:00
port = addon.getSetting('port')
host = addon.getSetting('ipaddress')
server = host + ":" + port
downloadUtils = DownloadUtils()
timeInfo = API().getTimeInfo(MBitem)
userData=API().getUserData(MBitem)
people = API().getPeople(MBitem)
genre = API().getGenre(MBitem)
studios = API().getStudios(MBitem)
mediaStreams=API().getMediaStreams(MBitem)
thumbPath = API().getArtwork(MBitem, "Primary")
changes = False
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
#update/check all artwork
changes |= self.updateArtWork(KodiItem,MBitem)
Refactor 4/4
2015-03-17 19:02:42 +00:00
#update common properties
if MBitem.get("PremiereDate") != None:
premieredatelist = (MBitem.get("PremiereDate")).split("T")
premieredate = premieredatelist[0]
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.updateProperty(KodiItem,"premiered",premieredate,"tvshow")
Refactor 4/4
2015-03-17 19:02:42 +00:00
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.updateProperty(KodiItem,"mpaa",MBitem.get("OfficialRating"),"tvshow")
added lastplayed field to sync
2015-03-24 20:03:07 +00:00
changes |= self.updateProperty(KodiItem,"lastplayed",MBitem.get("LastPlayedDate"),"tvshow")
Refactor 4/4
2015-03-17 19:02:42 +00:00
if MBitem.get("CriticRating") != None:
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.updateProperty(KodiItem,"rating",int(MBitem.get("CriticRating"))/10,"tvshow")
Refactor 4/4
2015-03-17 19:02:42 +00:00
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.updateProperty(KodiItem,"sorttitle",MBitem.get("SortName"),"tvshow")
Refactor 4/4
2015-03-17 19:02:42 +00:00
if MBitem.get("ProviderIds") != None:
if MBitem.get("ProviderIds").get("Imdb") != None:
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.updateProperty(KodiItem,"imdbnumber",MBitem.get("ProviderIds").get("Imdb"),"tvshow")
Refactor 4/4
2015-03-17 19:02:42 +00:00
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.updatePropertyArray(KodiItem,"genre",MBitem.get("Genres"),"tvshow")
replace / with & in studio strings
2015-03-18 05:05:21 +00:00
if(studios != None):
for x in range(0, len(studios)):
studios[x] = studios[x].replace("/", "&")
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.updatePropertyArray(KodiItem,"studio",studios,"tvshow")
Refactor 4/4
2015-03-17 19:02:42 +00:00
# FIXME --> ProductionLocations not returned by MB3 server !?
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.updatePropertyArray(KodiItem,"country",MBitem.get("ProductionLocations"),"tvshow")
Refactor 4/4
2015-03-17 19:02:42 +00:00
#add actors
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.AddActorsToMedia(KodiItem,MBitem.get("People"),"tvshow")
Refactor 4/4
2015-03-17 19:02:42 +00:00
fixed season artwork
2015-03-20 15:58:46 +00:00
#update season artwork
self.updateSeasonArtwork(MBitem, KodiItem)
Refactor 4/4
2015-03-17 19:02:42 +00:00
CreateFiles().createNFO(MBitem)
Move theme music sync to update and make it an option
2015-03-25 09:59:23 +00:00
#add theme music
if addon.getSetting("syncThemeMusic") == "true":
CreateFiles().copyThemeMusic(MBitem)
added extra fanart sync
2015-03-25 14:00:08 +00:00
#add extra fanart
if addon.getSetting("syncExtraFanart") == "true":
CreateFiles().copyExtraFanart(MBitem)
Refactor 4/4
2015-03-17 19:02:42 +00:00
if changes:
utils.logMsg("Updated item to Kodi Library", MBitem["Id"] + " - " + MBitem["Name"])
add Notification as an UI indication option for syns actions
2015-03-23 03:54:07 +00:00
return changes
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
fixed incremental sync for tvshows
2015-03-19 08:44:25 +00:00
def updateEpisodeToKodiLibrary( self, MBitem, KodiItem ):
Refactor 4/4
2015-03-17 19:02:42 +00:00
refactor to plugin.video.emby
2015-03-25 17:37:21 +00:00
addon = xbmcaddon.Addon(id='plugin.video.emby')
Refactor 4/4
2015-03-17 19:02:42 +00:00
port = addon.getSetting('port')
host = addon.getSetting('ipaddress')
server = host + ":" + port
downloadUtils = DownloadUtils()
userid = downloadUtils.getUserId()
timeInfo = API().getTimeInfo(MBitem)
people = API().getPeople(MBitem)
genre = API().getGenre(MBitem)
studios = API().getStudios(MBitem)
mediaStreams=API().getMediaStreams(MBitem)
userData=API().getUserData(MBitem)
thumbPath = API().getArtwork(MBitem, "Primary")
changes = False
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
#update/check all artwork
changes |= self.updateArtWork(KodiItem,MBitem)
Refactor 4/4
2015-03-17 19:02:42 +00:00
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
#set Filename
playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem)
one more fix for transcoding
2015-03-28 18:11:38 +00:00
if not playurl.startswith("http"):
if playurl != KodiItem["file"]:
self.setKodiFilename(KodiItem["episodeid"], playurl, "episode")
Refactor 4/4
2015-03-17 19:02:42 +00:00
#update common properties
duration = (int(timeInfo.get('Duration'))*60)
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.updateProperty(KodiItem,"runtime",duration,"episode")
added lastplayed field to sync
2015-03-24 20:03:07 +00:00
changes |= self.updateProperty(KodiItem,"lastplayed",userData.get("LastPlayedDate"),"episode")
Refactor 4/4
2015-03-17 19:02:42 +00:00
if MBitem.get("PremiereDate") != None:
premieredatelist = (MBitem.get("PremiereDate")).split("T")
premieredate = premieredatelist[0]
premieretime = premieredatelist[1].split(".")[0]
firstaired = premieredate + " " + premieretime
# for Helix we use the whole time string, for kodi 15 we have to change to only the datestring
# see: http://forum.kodi.tv/showthread.php?tid=218743
if KodiItem["firstaired"] != premieredate:
self.updateProperty(KodiItem,"firstaired",firstaired,"episode")
if MBitem.get("CriticRating") != None:
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.updateProperty(KodiItem,"rating",int(MBitem.get("CriticRating"))/10,"episode")
Refactor 4/4
2015-03-17 19:02:42 +00:00
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.updatePropertyArray(KodiItem,"writer",people.get("Writer"),"episode")
Refactor 4/4
2015-03-17 19:02:42 +00:00
#add actors
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
changes |= self.AddActorsToMedia(KodiItem,MBitem.get("People"),"episode")
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
fixed incremental sync for tvshows
2015-03-19 08:44:25 +00:00
CreateFiles().createNFO(MBitem)
CreateFiles().createSTRM(MBitem)
Refactor 4/4
2015-03-17 19:02:42 +00:00
if changes:
utils.logMsg("Updated item to Kodi Library", MBitem["Id"] + " - " + MBitem["Name"])
add Notification as an UI indication option for syns actions
2015-03-23 03:54:07 +00:00
return changes
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
def getArtworkParam_Batched(self, KodiItem, MBitem, params):
'''
item_type=str(MBitem.get("Type"))
if item_type == "Series":
id = KodiItem['tvshowid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetTVShowDetails", "params": { "tvshowid": %i, "art": %s}, "id": 1 }'
elif item_type == "Episode":
# episodes don't have any artwork - they derrive this from the tv show
return False
elif item_type == "MusicVideo":
id = KodiItem['musicvideoid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMusicVideoDetails", "params": { musicvideoid": %i, "art": %s}, "id": 1 }'
elif item_type == "Movie":
id = KodiItem['movieid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": { "movieid": %i, "art": %s}, "id": 1 }'
'''
#update artwork
changes = False
artwork = {}
artwork["poster"] = API().getArtwork(MBitem, "Primary")
artwork["banner"] = API().getArtwork(MBitem, "Banner")
artwork["clearlogo"] = API().getArtwork(MBitem, "Logo")
artwork["clearart"] = API().getArtwork(MBitem, "Art")
artwork["landscape"] = API().getArtwork(MBitem, "Thumb")
artwork["discart"] = API().getArtwork(MBitem, "Disc")
artwork["fanart"] = API().getArtwork(MBitem, "Backdrop")
for art in artwork:
if artwork.get(art) != "":
if KodiItem["art"].has_key(art):
curValue = urllib.unquote(KodiItem['art'][art]).decode('utf8')
if not artwork.get(art) in curValue:
KodiItem["art"][art] = artwork.get(art)
changes = True
else:
KodiItem["art"][art] = artwork.get(art)
changes = True
if len(KodiItem["art"]) == 0:
changes = False
if changes:
json_array = json.dumps(KodiItem["art"])
params.append("\"art\": " + json_array)
#result = xbmc.executeJSONRPC(jsoncommand %(id, json_array))
return changes
Refactor 4/4
2015-03-17 19:02:42 +00:00
# adds or updates artwork to the given Kodi file in database
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
def updateArtWork(self,KodiItem,MBitem):
item_type=str(MBitem.get("Type"))
if item_type == "Series":
Refactor 4/4
2015-03-17 19:02:42 +00:00
id = KodiItem['tvshowid']
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetTVShowDetails", "params": { "tvshowid": %i, "art": %s}, "id": 1 }'
elif item_type == "Episode":
some more optimizations - episodes dont need their artwork set
2015-03-20 13:37:34 +00:00
# episodes don't have any artwork - they derrive this from the tv show
return False
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
elif item_type == "MusicVideo":
Refactor 4/4
2015-03-17 19:02:42 +00:00
id = KodiItem['musicvideoid']
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMusicVideoDetails", "params": { musicvideoid": %i, "art": %s}, "id": 1 }'
elif item_type == "Movie":
Refactor 4/4
2015-03-17 19:02:42 +00:00
id = KodiItem['movieid']
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": { "movieid": %i, "art": %s}, "id": 1 }'
optimize getArt method --> small fixes and removed extra logging
2015-03-20 11:53:02 +00:00
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
#update artwork
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes = False
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
artwork = {}
artwork["poster"] = API().getArtwork(MBitem, "Primary")
fixes for season artwork
2015-03-20 15:16:39 +00:00
artwork["banner"] = API().getArtwork(MBitem, "Banner")
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
artwork["clearlogo"] = API().getArtwork(MBitem, "Logo")
artwork["clearart"] = API().getArtwork(MBitem, "Art")
artwork["landscape"] = API().getArtwork(MBitem, "Thumb")
artwork["discart"] = API().getArtwork(MBitem, "Disc")
artwork["fanart"] = API().getArtwork(MBitem, "Backdrop")
for art in artwork:
optimize getArt method --> small fixes and removed extra logging
2015-03-20 11:53:02 +00:00
if artwork.get(art) != "":
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
if KodiItem["art"].has_key(art):
optimize getArt method --> small fixes and removed extra logging
2015-03-20 11:53:02 +00:00
curValue = urllib.unquote(KodiItem['art'][art]).decode('utf8')
if not artwork.get(art) in curValue:
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
KodiItem["art"][art] = artwork.get(art)
changes = True
else:
KodiItem["art"][art] = artwork.get(art)
changes = True
if len(KodiItem["art"]) == 0:
changes = False
if changes:
json_array = json.dumps(KodiItem["art"])
result = xbmc.executeJSONRPC(jsoncommand %(id, json_array))
Refactor 4/4
2015-03-17 19:02:42 +00:00
return changes
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
def getPropertyParam_Batched(self,KodiItem, propertyName, propertyValue, params, forced = False):
'''
if fileType == "tvshow":
id = KodiItem['tvshowid']
jsoncommand_i = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetTVShowDetails", "params": { "tvshowid": %i, "%s": %i}, "id": 1 }'
jsoncommand_s = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetTVShowDetails", "params": { "tvshowid": %i, "%s": "%s"}, "id": 1 }'
elif fileType == "episode":
id = KodiItem['episodeid']
jsoncommand_i = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetEpisodeDetails", "params": { "episodeid": %i, "%s": %i}, "id": 1 }'
jsoncommand_s = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetEpisodeDetails", "params": { "episodeid": %i, "%s": "%s"}, "id": 1 }'
elif fileType == "musicvideo":
id = KodiItem['musicvideoid']
jsoncommand_i = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMusicVideoDetails", "params": { "musicvideoid": %i, "%s": %i}, "id": 1 }'
jsoncommand_s = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMusicVideoDetails", "params": { "musicvideoid": %i, "%s": "%s"}, "id": 1 }'
elif fileType == "movie":
id = KodiItem['movieid']
jsoncommand_i = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": { "movieid": %i, "%s": %i}, "id": 1 }'
jsoncommand_s = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": { "movieid": %i, "%s": "%s"}, "id": 1 }'
'''
changes = False
if ((propertyValue != KodiItem[propertyName]) or forced):
if propertyValue != None:
if type(propertyValue) is int:
#xbmc.sleep(sleepVal)
utils.logMsg("MB3 Sync","updating property..." + str(propertyName))
utils.logMsg("MB3 Sync","kodi value:" + str(KodiItem[propertyName]) + " MB value: " + str(propertyValue))
params.append("\"" + propertyName + "\": " + str(propertyValue))
#xbmc.executeJSONRPC(jsoncommand_i %(id, propertyName, propertyValue))
changes = True
else:
#xbmc.sleep(sleepVal)
utils.logMsg("MB3 Sync","updating property..." + str(propertyName))
utils.logMsg("MB3 Sync","kodi value:" + KodiItem[propertyName] + " MB value: " + propertyValue)
params.append("\"" + propertyName + "\": \"" + str(propertyValue) + "\"")
#xbmc.executeJSONRPC(jsoncommand_s %(id, propertyName, propertyValue.encode('utf-8')))
changes = True
return changes
Refactor 4/4
2015-03-17 19:02:42 +00:00
# adds or updates the given property on the videofile in Kodi database
fixed artwork on Playback fixed playcount reporting on Movies improved playcount reporting after playback (refresh the listing)
2015-03-19 23:24:29 +00:00
def updateProperty(self,KodiItem,propertyName,propertyValue,fileType,forced=False):
Refactor 4/4
2015-03-17 19:02:42 +00:00
if fileType == "tvshow":
id = KodiItem['tvshowid']
jsoncommand_i = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetTVShowDetails", "params": { "tvshowid": %i, "%s": %i}, "id": 1 }'
jsoncommand_s = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetTVShowDetails", "params": { "tvshowid": %i, "%s": "%s"}, "id": 1 }'
elif fileType == "episode":
id = KodiItem['episodeid']
jsoncommand_i = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetEpisodeDetails", "params": { "episodeid": %i, "%s": %i}, "id": 1 }'
jsoncommand_s = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetEpisodeDetails", "params": { "episodeid": %i, "%s": "%s"}, "id": 1 }'
elif fileType == "musicvideo":
id = KodiItem['musicvideoid']
jsoncommand_i = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMusicVideoDetails", "params": { "musicvideoid": %i, "%s": %i}, "id": 1 }'
jsoncommand_s = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMusicVideoDetails", "params": { "musicvideoid": %i, "%s": "%s"}, "id": 1 }'
elif fileType == "movie":
id = KodiItem['movieid']
jsoncommand_i = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": { "movieid": %i, "%s": %i}, "id": 1 }'
jsoncommand_s = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": { "movieid": %i, "%s": "%s"}, "id": 1 }'
changes = False
fixed artwork on Playback fixed playcount reporting on Movies improved playcount reporting after playback (refresh the listing)
2015-03-19 23:24:29 +00:00
if ((propertyValue != KodiItem[propertyName]) or forced):
Refactor 4/4
2015-03-17 19:02:42 +00:00
if propertyValue != None:
if type(propertyValue) is int:
xbmc.sleep(sleepVal)
utils.logMsg("MB3 Sync","updating property..." + str(propertyName))
utils.logMsg("MB3 Sync","kodi value:" + str(KodiItem[propertyName]) + " MB value: " + str(propertyValue))
xbmc.executeJSONRPC(jsoncommand_i %(id, propertyName, propertyValue))
changes = True
else:
xbmc.sleep(sleepVal)
utils.logMsg("MB3 Sync","updating property..." + str(propertyName))
utils.logMsg("MB3 Sync","kodi value:" + KodiItem[propertyName] + " MB value: " + propertyValue)
xbmc.executeJSONRPC(jsoncommand_s %(id, propertyName, propertyValue.encode('utf-8')))
changes = True
return changes
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
def getPropertyParamArray_Batched(self, KodiItem, propertyName, propertyCollection, params):
'''
if fileType == "tvshow":
id = KodiItem['tvshowid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetTVShowDetails", "params": { "tvshowid": %i, "%s": %s}, "id": 1 }'
elif fileType == "episode":
id = KodiItem['episodeid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetEpisodeDetails", "params": { "episodeid": %i, "%s": %s}, "id": 1 }'
elif fileType == "musicvideo":
id = KodiItem['musicvideoid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMusicVideoDetails", "params": { "musicvideoid": %i, "%s": %s}, "id": 1 }'
elif fileType == "movie":
id = KodiItem['movieid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": { "movieid": %i, "%s": %s}, "id": 1 }'
'''
pendingChanges = False
if propertyCollection != None:
currentvalues = set(KodiItem[propertyName])
for item in propertyCollection:
if not item in currentvalues:
pendingChanges = True
json_array = json.dumps(propertyCollection)
if pendingChanges:
#xbmc.sleep(sleepVal)
utils.logMsg("MB3 Sync","updating propertyarray... Name:" + str(propertyName) + " Current:" + str(currentvalues) + " New:" + str(json_array))
params.append("\"" + propertyName + "\": " + json_array)
#xbmc.executeJSONRPC(jsoncommand %(id,propertyName,json_array))
return pendingChanges
Refactor 4/4
2015-03-17 19:02:42 +00:00
# adds or updates the property-array on the videofile in Kodi database
def updatePropertyArray(self,KodiItem,propertyName,propertyCollection,fileType):
if fileType == "tvshow":
id = KodiItem['tvshowid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetTVShowDetails", "params": { "tvshowid": %i, "%s": %s}, "id": 1 }'
elif fileType == "episode":
id = KodiItem['episodeid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetEpisodeDetails", "params": { "episodeid": %i, "%s": %s}, "id": 1 }'
elif fileType == "musicvideo":
id = KodiItem['musicvideoid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMusicVideoDetails", "params": { "musicvideoid": %i, "%s": %s}, "id": 1 }'
elif fileType == "movie":
id = KodiItem['movieid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": { "movieid": %i, "%s": %s}, "id": 1 }'
replace / with & in studio strings
2015-03-18 05:05:21 +00:00
Refactor 4/4
2015-03-17 19:02:42 +00:00
pendingChanges = False
replace / with & in studio strings
2015-03-18 05:05:21 +00:00
if propertyCollection != None:
Refactor 4/4
2015-03-17 19:02:42 +00:00
currentvalues = set(KodiItem[propertyName])
for item in propertyCollection:
if not item in currentvalues:
pendingChanges = True
json_array = json.dumps(propertyCollection)
if pendingChanges:
xbmc.sleep(sleepVal)
utils.logMsg("MB3 Sync","updating propertyarray... Name:" + str(propertyName) + " Current:" + str(currentvalues) + " New:" + str(json_array))
xbmc.executeJSONRPC(jsoncommand %(id,propertyName,json_array))
return pendingChanges
def addMovieToKodiLibrary( self, item ):
itemPath = os.path.join(movieLibrary,item["Id"])
strmFile = os.path.join(itemPath,item["Id"] + ".strm")
changes = False
#create path if not exists
if not xbmcvfs.exists(itemPath + os.sep):
xbmcvfs.mkdir(itemPath)
#create nfo file
changes = CreateFiles().createNFO(item)
# create strm file
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= CreateFiles().createSTRM(item)
Refactor 4/4
2015-03-17 19:02:42 +00:00
if changes:
utils.logMsg("MB3 Sync","Added movie to Kodi Library",item["Id"] + " - " + item["Name"])
added musicvideos support
2015-03-21 13:31:30 +00:00
def addMusicVideoToKodiLibrary( self, item ):
itemPath = os.path.join(musicvideoLibrary,item["Id"])
strmFile = os.path.join(itemPath,item["Id"] + ".strm")
changes = False
#create path if not exists
if not xbmcvfs.exists(itemPath + os.sep):
xbmcvfs.mkdir(itemPath)
#create nfo file
changes = CreateFiles().createNFO(item)
# create strm file
changes |= CreateFiles().createSTRM(item)
if changes:
utils.logMsg("MB3 Sync","Added musicvideo to Kodi Library",item["Id"] + " - " + item["Name"])
fixed incremental sync for tvshows
2015-03-19 08:44:25 +00:00
def addEpisodeToKodiLibrary(self, item):
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes = False
#create nfo file
fixed incremental sync for tvshows
2015-03-19 08:44:25 +00:00
changes = CreateFiles().createNFO(item)
Refactor 4/4
2015-03-17 19:02:42 +00:00
# create strm file
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
changes |= CreateFiles().createSTRM(item)
Refactor 4/4
2015-03-17 19:02:42 +00:00
if changes:
utils.logMsg("MB3 Sync","Added episode to Kodi Library",item["Id"] + " - " + item["Name"])
def deleteMovieFromKodiLibrary(self, id ):
kodiItem = ReadKodiDB().getKodiMovie(id)
utils.logMsg("deleting movie from Kodi library",id)
if kodiItem != None:
xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.RemoveMovie", "params": { "movieid": %i}, "id": 1 }' %(kodiItem["movieid"]))
path = os.path.join(movieLibrary,id)
fixed tv show deletions
2015-03-21 10:32:21 +00:00
allDirs, allFiles = xbmcvfs.listdir(path)
for dir in allDirs:
finished episode deletions
2015-03-21 11:33:59 +00:00
xbmcvfs.rmdir(os.path.join(path,dir))
fixed tv show deletions
2015-03-21 10:32:21 +00:00
for file in allFiles:
finished episode deletions
2015-03-21 11:33:59 +00:00
xbmcvfs.delete(os.path.join(path,file))
fixed tv show deletions
2015-03-21 10:32:21 +00:00
xbmcvfs.rmdir(path)
added musicvideos support
2015-03-21 13:31:30 +00:00
def deleteMusicVideoFromKodiLibrary(self, id ):
utils.logMsg("deleting musicvideo from Kodi library",id)
kodiItem = ReadKodiDB().getKodiMusicVideo(id)
if kodiItem != None:
xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.RemoveMusicVideo", "params": { "musicvideoid": %i}, "id": 1 }' %(kodiItem["musicvideoid"]))
fixed tv show deletions
2015-03-21 10:32:21 +00:00
added musicvideos support
2015-03-21 13:31:30 +00:00
path = os.path.join(musicvideoLibrary,id)
allDirs, allFiles = xbmcvfs.listdir(path)
for dir in allDirs:
xbmcvfs.rmdir(os.path.join(path,dir))
for file in allFiles:
xbmcvfs.delete(os.path.join(path,file))
xbmcvfs.rmdir(path)
finished episode deletions
2015-03-21 11:33:59 +00:00
def deleteEpisodeFromKodiLibrary(self, episodeid, tvshowid ):
still error in remove-episode
2015-03-20 19:29:50 +00:00
utils.logMsg("deleting episode from Kodi library",episodeid)
finished episode deletions
2015-03-21 11:33:59 +00:00
episode = ReadKodiDB().getKodiEpisodeByMbItem(episodeid, tvshowid)
if episode != None:
strmfile = episode["file"]
nfofile = strmfile.replace(".strm",".nfo")
Fix episode deletes
2015-03-28 16:14:52 +00:00
WINDOW = xbmcgui.Window( 10000 )
WINDOW.setProperty("suspendDeletes", "True")
finished episode deletions
2015-03-21 11:33:59 +00:00
xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.RemoveEpisode", "params": { "episodeid": %i}, "id": 1 }' %(episode["episodeid"]))
xbmcvfs.delete(strmfile)
xbmcvfs.delete(nfofile)
Fix episode deletes
2015-03-28 16:14:52 +00:00
while WINDOW.getProperty("suspendDeletes") == "True":
xbmc.sleep(100)
support for episode deletions
2015-03-20 19:26:37 +00:00
Refactor 4/4
2015-03-17 19:02:42 +00:00
def addTVShowToKodiLibrary( self, item ):
itemPath = os.path.join(tvLibrary,item["Id"])
changes = False
#create path if not exists
if not xbmcvfs.exists(itemPath + os.sep):
xbmcvfs.mkdir(itemPath)
#create nfo file
changes = CreateFiles().createNFO(item)
if changes:
utils.logMsg("Added TV Show to Kodi Library ",item["Id"] + " - " + item["Name"])
def deleteTVShowFromKodiLibrary(self, id ):
speed improvement moved all sleeps to the kodi api calls only
2015-03-19 10:13:49 +00:00
xbmc.sleep(sleepVal)
Refactor 4/4
2015-03-17 19:02:42 +00:00
kodiItem = ReadKodiDB().getKodiTVShow(id)
utils.logMsg("deleting tvshow from Kodi library",id)
fixed tv show deletions
2015-03-21 10:32:21 +00:00
Refactor 4/4
2015-03-17 19:02:42 +00:00
if kodiItem != None:
xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.RemoveTVShow", "params": { "tvshowid": %i}, "id": 1 }' %(kodiItem["tvshowid"]))
fixed tv show deletions
2015-03-21 10:32:21 +00:00
Refactor 4/4
2015-03-17 19:02:42 +00:00
path = os.path.join(tvLibrary,id)
fixed tv show deletions
2015-03-21 10:32:21 +00:00
allDirs, allFiles = xbmcvfs.listdir(path)
for dir in allDirs:
xbmcvfs.rmdir(os.path.join(path,dir))
for file in allFiles:
xbmcvfs.delete(os.path.join(path,file))
finished episode deletions
2015-03-21 11:33:59 +00:00
succes = xbmcvfs.rmdir(path)
if not succes:
utils.logMsg("Error deleting TV show with ID ",id)
fixes for season artwork
2015-03-20 15:16:39 +00:00
fixed season artwork
2015-03-20 15:58:46 +00:00
def updateSeasonArtwork(self,MBitem, KodiItem):
#use sqlite to set the season artwork because no method in API available for this
#season poster and banner are set by the nfo. landscape image is filled by this method
#if wanted this feature can be extended to also update the other artwork
tvshowid = KodiItem["tvshowid"]
support for isengard sqlite and **experimental** mysql support
2015-03-26 21:35:11 +00:00
connection = utils.KodiSQL()
fixed season artwork
2015-03-20 15:58:46 +00:00
cursor = connection.cursor( )
fixes for season artwork
2015-03-20 15:16:39 +00:00
fixed season artwork
2015-03-20 15:58:46 +00:00
seasonData = ReadEmbyDB().getTVShowSeasons(MBitem["Id"])
if seasonData != None:
for season in seasonData:
if season.has_key("IndexNumber"):
MB3landscape = API().getArtwork(season, "Thumb")
if MB3landscape != "":
cursor.execute("SELECT idSeason as seasonid FROM seasons WHERE idShow = ? and season = ?",(tvshowid,season["IndexNumber"]))
result = cursor.fetchone()
if result != None:
seasonid = result[0]
cursor.execute("SELECT art_id as art_id FROM art WHERE media_id = ? and media_type = ? and type = ?",(seasonid,"season","landscape"))
result = cursor.fetchone()
if result == None:
sql="INSERT into art(media_id, media_type, type, url) values(?, ?, ?, ?)"
cursor.execute(sql, (seasonid,"season","landscape",MB3landscape))
connection.commit()
added musicvideos support
2015-03-21 13:31:30 +00:00
cursor.close()
fixes for season artwork
2015-03-20 15:16:39 +00:00
Refactor 4/4
2015-03-17 19:02:42 +00:00
def setKodiResumePoint(self, id, resume_seconds, total_seconds, fileType):
#use sqlite to set the resume point while json api doesn't support this yet
#todo --> submit PR to kodi team to get this added to the jsonrpc api
utils.logMsg("MB3 Sync","setting resume point in kodi db..." + fileType + ": " + str(id))
speed improvement moved all sleeps to the kodi api calls only
2015-03-19 10:13:49 +00:00
xbmc.sleep(sleepVal)
support for isengard sqlite and **experimental** mysql support
2015-03-26 21:35:11 +00:00
connection = utils.KodiSQL()
Refactor 4/4
2015-03-17 19:02:42 +00:00
cursor = connection.cursor( )
if fileType == "episode":
cursor.execute("SELECT idFile as fileidid FROM episode WHERE idEpisode = ?",(id,))
result = cursor.fetchone()
fileid = result[0]
if fileType == "movie":
cursor.execute("SELECT idFile as fileidid FROM movie WHERE idMovie = ?",(id,))
result = cursor.fetchone()
fileid = result[0]
cursor.execute("delete FROM bookmark WHERE idFile = ?", (fileid,))
cursor.execute("select coalesce(max(idBookmark),0) as bookmarkId from bookmark")
bookmarkId = cursor.fetchone()[0]
bookmarkId = bookmarkId + 1
bookmarksql="insert into bookmark(idBookmark, idFile, timeInSeconds, totalTimeInSeconds, thumbNailImage, player, playerState, type) values(?, ?, ?, ?, ?, ?, ?, ?)"
cursor.execute(bookmarksql, (bookmarkId,fileid,resume_seconds,total_seconds,None,"DVDPlayer",None,1))
connection.commit()
cursor.close()
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
def setKodiFilename(self, id, filenameAndPath, fileType):
#use sqlite to set the filename in DB -- needed to avoid problems with resumepoints etc
#todo --> submit PR to kodi team to get this added to the jsonrpc api
use the plugin method for playback when transcoding, use native kodi playback for direct access
2015-03-28 18:04:32 +00:00
#todo --> extend support for musicvideos
fix for directplay
2015-03-28 17:36:14 +00:00
filenameAndPath = utils.convertEncoding(filenameAndPath)
use the plugin method for playback when transcoding, use native kodi playback for direct access
2015-03-28 18:04:32 +00:00
if "\\" in filenameAndPath:
filename = filenameAndPath.rsplit("\\",1)[-1]
path = filenameAndPath.replace(filename,"")
elif "/" in filenameAndPath:
filename = filenameAndPath.rsplit("/",1)[-1]
path = filenameAndPath.replace(filename,"")
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
utils.logMsg("MB3 Sync","setting filename in kodi db..." + fileType + ": " + str(id))
xbmc.sleep(sleepVal)
connection = utils.KodiSQL()
cursor = connection.cursor( )
fix for directplay
2015-03-28 17:36:14 +00:00
cursor.execute("SELECT idPath as pathid FROM path WHERE strPath = ?",(path,))
result = cursor.fetchone()
if result != None:
pathid = result[0]
if result == None:
cursor.execute("select coalesce(max(idPath),0) as pathid from path")
pathid = cursor.fetchone()[0]
pathid = pathid + 1
pathsql="insert into path(idPath, strPath) values(?, ?)"
cursor.execute(pathsql, (pathid,path))
cursor.execute("select coalesce(max(idPath),0) as pathid from path")
pathid = cursor.fetchone()[0]
pathid = pathid + 1
pathsql="insert into path(idPath, strPath) values(?, ?)"
cursor.execute(pathsql, (pathid,path))
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
if fileType == "episode":
cursor.execute("SELECT idFile as fileidid FROM episode WHERE idEpisode = ?",(id,))
result = cursor.fetchone()
fileid = result[0]
if fileType == "movie":
cursor.execute("SELECT idFile as fileidid FROM movie WHERE idMovie = ?",(id,))
result = cursor.fetchone()
fileid = result[0]
cursor.execute("UPDATE files SET strFilename = ? WHERE idFile = ?", (filename,fileid))
cursor.execute("UPDATE files SET idPath = ? WHERE idFile = ?", (pathid,fileid))
connection.commit()
cursor.close()
Refactor 4/4
2015-03-17 19:02:42 +00:00
def AddActorsToMedia(self, KodiItem, people, mediatype):
#use sqlite to set add the actors while json api doesn't support this yet
#todo --> submit PR to kodi team to get this added to the jsonrpc api
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
Refactor 4/4
2015-03-17 19:02:42 +00:00
downloadUtils = DownloadUtils()
if mediatype == "movie":
id = KodiItem["movieid"]
if mediatype == "tvshow":
id = KodiItem["tvshowid"]
if mediatype == "episode":
id = KodiItem["episodeid"]
currentcast = list()
if KodiItem["cast"] != None:
for cast in KodiItem["cast"]:
currentcast.append(cast["name"])
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
needsUpdate = False
Refactor 4/4
2015-03-17 19:02:42 +00:00
if(people != None):
for person in people:
if(person.get("Type") == "Actor"):
if person.get("Name") not in currentcast:
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
needsUpdate = True
break
if(needsUpdate == False):
return False
utils.logMsg("AddActorsToMedia", "List needs updating")
xbmc.sleep(sleepVal)
support for isengard sqlite and **experimental** mysql support
2015-03-26 21:35:11 +00:00
connection = utils.KodiSQL()
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
cursor = connection.cursor()
if(people != None):
for person in people:
if(person.get("Type") == "Actor"):
if person.get("Name") not in currentcast:
utils.logMsg("AddActorsToMedia", "Processing : " + person.get("Name"))
Refactor 4/4
2015-03-17 19:02:42 +00:00
Name = person.get("Name")
Role = person.get("Role")
actorid = None
Thumb = downloadUtils.imageUrl(person.get("Id"), "Primary", 0, 400, 400)
cursor.execute("SELECT idActor as actorid FROM actors WHERE strActor = ?",(Name,))
result = cursor.fetchone()
if result != None:
actorid = result[0]
if actorid == None:
cursor.execute("select coalesce(max(idActor),0) as actorid from actors")
actorid = cursor.fetchone()[0]
actorid = actorid + 1
peoplesql="insert into actors(idActor, strActor, strThumb) values(?, ?, ?)"
cursor.execute(peoplesql, (actorid,Name,Thumb))
if mediatype == "movie":
peoplesql="INSERT OR REPLACE into actorlinkmovie(idActor, idMovie, strRole, iOrder) values(?, ?, ?, ?)"
if mediatype == "tvshow":
peoplesql="INSERT OR REPLACE into actorlinktvshow(idActor, idShow, strRole, iOrder) values(?, ?, ?, ?)"
if mediatype == "episode":
peoplesql="INSERT OR REPLACE into actorlinkepisode(idActor, idEpisode, strRole, iOrder) values(?, ?, ?, ?)"
cursor.execute(peoplesql, (actorid,id,Role,None))
connection.commit()
cursor.close()
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
return True
add support for box sets
2015-03-24 16:47:26 +00:00
def addBoxsetToKodiLibrary(self, boxset):
#use sqlite to set add the set
support for isengard sqlite and **experimental** mysql support
2015-03-26 21:35:11 +00:00
connection = utils.KodiSQL()
add support for box sets
2015-03-24 16:47:26 +00:00
cursor = connection.cursor()
strSet = boxset["Name"]
# check if exists
cursor.execute("SELECT idSet FROM sets WHERE strSet = ?", (strSet,))
result = cursor.fetchone()
setid = None
if result != None:
setid = result[0]
currentsetartsql = "SELECT type, url FROM art where media_type = ? and media_id = ? and url != ''"
cursor.execute(currentsetartsql, ("set", setid))
existing_type_map = {}
rows = cursor.fetchall()
for row in rows:
existing_type_map[row[0] ] = row[1]
artwork = {}
artwork["poster"] = API().getArtwork(boxset, "Primary")
artwork["banner"] = API().getArtwork(boxset, "Banner")
artwork["clearlogo"] = API().getArtwork(boxset, "Logo")
artwork["clearart"] = API().getArtwork(boxset, "Art")
artwork["landscape"] = API().getArtwork(boxset, "Thumb")
artwork["discart"] = API().getArtwork(boxset, "Disc")
artwork["fanart"] = API().getArtwork(boxset, "Backdrop")
change art_types to a set
2015-03-24 18:58:13 +00:00
art_types = ['poster','fanart','landscape','clearlogo','clearart','banner','discart']
add support for box sets
2015-03-24 16:47:26 +00:00
for update_type in art_types:
if ( update_type in existing_type_map ):
if ( existing_type_map[update_type] != artwork[update_type] ) and artwork[update_type] != '':
setupdateartsql = "UPDATE art SET url = ? where media_type = ? and media_id = ? and type = ?"
cursor.execute(setupdateartsql,(artwork[update_type],"set",setid,update_type))
elif artwork[update_type] != '':
setartsql = "INSERT INTO art(media_id, media_type, type, url) VALUES(?,?,?,?)"
cursor.execute(setartsql,(setid,"set",update_type,artwork[update_type]))
if setid == None:
# insert not exists
setssql="INSERT INTO sets (idSet, strSet) values(?, ?)"
cursor.execute(setssql, (None,strSet))
#if OK:
result = cursor.fetchone()
if result != None:
setid = result[0]
connection.commit()
cursor.close()
return True
def updateBoxsetToKodiLibrary(self, boxsetmovie, boxset):
strSet = boxset["Name"]
kodiMovie = ReadKodiDB().getKodiMovie(boxsetmovie["Id"])
added copying theme music - plus workaround for reported boxset issues
2015-03-24 22:39:19 +00:00
if kodiMovie != None:
WriteKodiDB().updateProperty(kodiMovie,"set",strSet,"movie",True)
Reference in a new issue Copy permalink