################################################################################################# # WriteKodiDB ################################################################################################# import xbmc import xbmcgui import xbmcaddon import xbmcvfs import json import urllib import sqlite3 import os from decimal import Decimal from DownloadUtils import DownloadUtils from PlayUtils import PlayUtils from ReadKodiDB import ReadKodiDB from ReadEmbyDB import ReadEmbyDB from API import API import Utils as utils sleepVal = 20 class WriteKodiDB(): def updatePlayCountFromKodi(self, id, type, playcount=0): #when user marks item watched from kodi interface update this in MB3 xbmc.sleep(sleepVal) utils.logMsg("Emby", "updatePlayCountFromKodi Called") mb3Id = ReadKodiDB().getEmbyIdByKodiId(id, type) if(mb3Id != None): addon = xbmcaddon.Addon(id='plugin.video.emby') WINDOW = xbmcgui.Window(10000) username = WINDOW.getProperty('currUser') userid = WINDOW.getProperty('userId%s' % username) server = WINDOW.getProperty('server%s' % username) downloadUtils = DownloadUtils() watchedurl = "%s/mediabrowser/Users/%s/PlayedItems/%s" % (server, userid, mb3Id) utils.logMsg("Emby","watchedurl -->" + watchedurl) if playcount != 0: downloadUtils.downloadUrl(watchedurl, postBody="", type="POST") else: downloadUtils.downloadUrl(watchedurl, type="DELETE") def updateMovieToKodiLibrary_Batched(self, MBitem, KodiItem,connection, cursor): addon = xbmcaddon.Addon(id='plugin.video.emby') WINDOW = xbmcgui.Window(10000) username = WINDOW.getProperty('currUser') userid = WINDOW.getProperty('userId%s' % username) server = WINDOW.getProperty('server%s' % username) 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") params = list() self.getArtworkParam_Batched(KodiItem, MBitem, params) #set Filename playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem) self.setKodiFilename(KodiItem["movieid"], KodiItem["file"], playurl, "movie", MBitem["Id"], connection, cursor) #update common properties if KodiItem["runtime"] == 0: self.getPropertyParam_Batched(KodiItem, "runtime", (int(timeInfo.get('Duration'))*60), params) self.getPropertyParam_Batched(KodiItem, "year", MBitem.get("ProductionYear"), params) self.getPropertyParam_Batched(KodiItem, "mpaa", MBitem.get("OfficialRating"), params) self.getPropertyParam_Batched(KodiItem, "lastplayed", userData.get("LastPlayedDate"), params) self.getPropertyParamArray_Batched(KodiItem, "tag", MBitem.get("Tag"), params) if MBitem.get("CommunityRating") != None: self.getPropertyParam_Batched(KodiItem, "rating", Decimal(format(MBitem.get("CommunityRating"),'.1f')), params) self.getPropertyParam_Batched(KodiItem, "plot", MBitem.get("Overview"), 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 = "%s/mediabrowser/Users/%s/Items/%s/LocalTrailers?format=json" % (server, userid, MBitem.get("Id")) jsonData = downloadUtils.downloadUrl(itemTrailerUrl, suppress=False, popup=0 ) if(jsonData != ""): trailerItem = json.loads(jsonData) if trailerItem[0].get("LocationType") == "FileSystem": trailerUrl = PlayUtils().getPlayUrl(server, trailerItem[0].get("Id"), trailerItem[0]) trailerUrl = utils.convertEncoding(trailerUrl) self.getPropertyParam_Batched(KodiItem, "trailer", trailerUrl, 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.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) utils.logMsg("executeJSONRPC : ", jsoncommand, level = 2) xbmc.sleep(sleepVal) result = xbmc.executeJSONRPC(jsoncommand.encode("utf-8")) #add actors changes |= self.AddActorsToMedia(KodiItem,MBitem.get("People"), "movie", connection, cursor) if(changes): utils.logMsg("Updated item to Kodi Library", MBitem["Id"] + " - " + MBitem["Name"], level=0) return changes def updateMusicVideoToKodiLibrary_Batched(self, MBitem, KodiItem): addon = xbmcaddon.Addon(id='plugin.video.emby') 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) #update common properties if KodiItem["runtime"] == None: self.getPropertyParam_Batched(KodiItem, "runtime", (int(timeInfo.get('Duration'))*60), 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) self.getPropertyParam_Batched(KodiItem, "lastplayed", userData.get("LastPlayedDate"), params) 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.encode("utf-8")) if(changes): utils.logMsg("Updated musicvideo to Kodi Library", MBitem["Id"] + " - " + MBitem["Name"], level=0) def updateTVShowToKodiLibrary( self, MBitem, KodiItem,connection, cursor ): addon = xbmcaddon.Addon(id='plugin.video.emby') 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 #set Filename playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem) #make sure that the path always ends with a slash playurl = playurl + "/" self.setKodiFilename(KodiItem["tvshowid"], KodiItem["file"], playurl, "tvshow", MBitem["Id"], connection, cursor) #update/check all artwork changes |= self.updateArtWork(KodiItem,MBitem) #update common properties if MBitem.get("PremiereDate") != None: premieredatelist = (MBitem.get("PremiereDate")).split("T") premieredate = premieredatelist[0] changes |= self.updateProperty(KodiItem,"premiered",premieredate,"tvshow") changes |= self.updatePropertyArray(KodiItem,"tag",MBitem.get("Tag"),"tvshow") changes |= self.updateProperty(KodiItem,"mpaa",MBitem.get("OfficialRating"),"tvshow") changes |= self.updateProperty(KodiItem,"lastplayed",MBitem.get("LastPlayedDate"),"tvshow") if MBitem.get("CommunityRating") != None: changes |= self.updateProperty(KodiItem,"rating",Decimal(format(MBitem.get("CommunityRating"),'.1f')),"tvshow") changes |= self.updateProperty(KodiItem,"sorttitle",utils.convertEncoding(MBitem["SortName"]),"tvshow") changes |= self.updateProperty(KodiItem,"title",utils.convertEncoding(MBitem["Name"]),"tvshow") changes |= self.updateProperty(KodiItem,"plot",utils.convertEncoding(API().getOverview(MBitem)),"tvshow") # we use this to store the Emby ID so make sure we use that changes |= self.updateProperty(KodiItem, "imdbnumber", MBitem.get("Id"), "tvshow") changes |= self.updatePropertyArray(KodiItem,"genre",MBitem.get("Genres"),"tvshow") if(studios != None): for x in range(0, len(studios)): studios[x] = studios[x].replace("/", "&") changes |= self.updatePropertyArray(KodiItem,"studio",studios,"tvshow") # FIXME --> ProductionLocations not returned by MB3 server !? changes |= self.updatePropertyArray(KodiItem, "country", MBitem.get("ProductionLocations"), "tvshow") #add actors changes |= self.AddActorsToMedia(KodiItem,MBitem.get("People"),"tvshow", connection, cursor) #update season details self.updateSeasons(MBitem, KodiItem,connection, cursor) if changes: utils.logMsg("Updated item to Kodi Library", MBitem["Id"] + " - " + MBitem["Name"]) return changes def updateEpisodeToKodiLibrary( self, MBitem, KodiItem, connection, cursor ): addon = xbmcaddon.Addon(id='plugin.video.emby') port = addon.getSetting('port') host = addon.getSetting('ipaddress') server = host + ":" + port timeInfo = API().getTimeInfo(MBitem) people = API().getPeople(MBitem) genre = API().getGenre(MBitem) studios = API().getStudios(MBitem) mediaStreams=API().getMediaStreams(MBitem) userData=API().getUserData(MBitem) changes = False #update/check all artwork changes |= self.updateArtWork(KodiItem,MBitem) #set Filename (will update the filename in db if changed) playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem) changes |= self.setKodiFilename(KodiItem["episodeid"], KodiItem["file"], playurl, "episode", MBitem["Id"], connection, cursor) #update common properties if KodiItem["runtime"] == 0: changes |= self.updateProperty(KodiItem,"runtime",(int(timeInfo.get('Duration'))*60),"episode") changes |= self.updateProperty(KodiItem,"lastplayed",userData.get("LastPlayedDate"),"episode") 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: changes |= self.updateProperty(KodiItem,"firstaired",firstaired,"episode") if MBitem.get("CommunityRating") != None: changes |= self.updateProperty(KodiItem,"rating",Decimal(format(MBitem.get("CommunityRating"),'.1f')),"episode") if MBitem.get("ParentIndexNumber") != None: season = int(MBitem.get("ParentIndexNumber")) changes |= self.updateProperty(KodiItem,"season",season,"episode") # removed for now as setting c15 and c16 to -1 just shows specials in the special folder only #if(season == 0): # changes |= self.setSpecialAirsDetails(MBitem, KodiItem, connection, cursor) if MBitem.get("IndexNumber") != None: episode = int(MBitem.get("IndexNumber")) changes |= self.updateProperty(KodiItem,"episode",episode,"episode") #plot = utils.convertEncoding(API().getOverview(MBitem)) plot = MBitem.get("Overview") if(plot != None): changes |= self.updateProperty(KodiItem,"plot",plot,"episode") title = utils.convertEncoding(MBitem["Name"]) changes |= self.updateProperty(KodiItem,"title",title,"episode") changes |= self.updatePropertyArray(KodiItem,"writer",people.get("Writer"),"episode") changes |= self.updatePropertyArray(KodiItem,"director",people.get("Director"),"episode") #add actors changes |= self.AddActorsToMedia(KodiItem,MBitem.get("People"),"episode", connection, cursor) if changes: utils.logMsg("Updated item to Kodi Library", MBitem["Id"] + " - " + MBitem["Name"]) return changes 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") if(item_type != "Episode"): 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 # adds or updates artwork to the given Kodi file in database def updateArtWork(self,KodiItem,MBitem): 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": id = KodiItem['episodeid'] jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetEpisodeDetails", "params": { "episodeid": %i, "art": %s}, "id": 1 }' 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["thumb"] = API().getArtwork(MBitem, "Primary") if(item_type != "Episode"): 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"]) result = xbmc.executeJSONRPC(jsoncommand %(id, json_array)) return changes 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("Emby","updating property..." + str(propertyName)) utils.logMsg("Emby","kodi value:" + str(KodiItem[propertyName]) + " MB value: " + str(propertyValue)) params.append("\"" + propertyName + "\": " + str(propertyValue)) #xbmc.executeJSONRPC(jsoncommand_i %(id, propertyName, propertyValue)) changes = True elif type(propertyValue) is Decimal: #extra compare decimals as int (rounded) if int(propertyValue) != int(KodiItem[propertyName]): utils.logMsg("Emby","updating property..." + str(propertyName)) utils.logMsg("Emby","kodi value:" + str(KodiItem[propertyName]) + " MB value: " + str(propertyValue)) params.append("\"" + propertyName + "\": " + str(propertyValue)) changes = True else: #xbmc.sleep(sleepVal) propValue = json.dumps(propertyValue) utils.logMsg("Emby","updating property..." + str(propertyName)) utils.logMsg("Emby","kodi value:" + KodiItem[propertyName] + " MB value: " + propValue) params.append("\"" + propertyName + "\": " + propValue) #xbmc.executeJSONRPC(jsoncommand_s %(id, propertyName, propertyValue.encode('utf-8'))) changes = True return changes # adds or updates the given property on the videofile in Kodi database def updateProperty(self,KodiItem,propertyName,propertyValue,fileType,forced=False): 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 }' changes = False if ((propertyValue != KodiItem[propertyName]) or forced): if propertyValue != None: if type(propertyValue) is int: xbmc.sleep(sleepVal) utils.logMsg("Emby","updating property..." + str(propertyName)) utils.logMsg("Emby","kodi value:" + str(KodiItem[propertyName]) + " MB value: " + str(propertyValue)) xbmc.executeJSONRPC(jsoncommand %(id, propertyName, propertyValue)) changes = True elif type(propertyValue) is Decimal: #extra compare decimals as int (rounded) if int(propertyValue) != int(KodiItem[propertyName]): xbmc.sleep(sleepVal) utils.logMsg("Emby","updating property..." + str(propertyName)) utils.logMsg("Emby","kodi value:" + str(KodiItem[propertyName]) + " MB value: " + str(propertyValue)) xbmc.executeJSONRPC(jsoncommand %(id, propertyName, propertyValue)) changes = True else: xbmc.sleep(sleepVal) propValue = json.dumps(propertyValue) utils.logMsg("Emby","updating property..." + str(propertyName)) utils.logMsg("Emby","kodi value:" + KodiItem[propertyName] + " MB value: " + propValue) xbmc.executeJSONRPC(jsoncommand %(id, propertyName, propValue)) changes = True return changes 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("Emby","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 # 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 }' pendingChanges = False if (propertyCollection != None and KodiItem.get(propertyName) != 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("Emby","updating propertyarray... Name:" + str(propertyName) + " Current:" + str(currentvalues) + " New:" + str(json_array)) xbmc.executeJSONRPC(jsoncommand %(id,propertyName,json_array)) return pendingChanges def addMovieToKodiLibrary( self, MBitem ,connection, cursor): #adds a movie to Kodi by directly inserting it to the DB while there is no addmovie available on the json API #TODO: PR at Kodi team for a addMovie endpoint on their API addon = xbmcaddon.Addon(id='plugin.video.emby') WINDOW = xbmcgui.Window(10000) username = WINDOW.getProperty('currUser') userid = WINDOW.getProperty('userId%s' % username) server = WINDOW.getProperty('server%s' % username) downloadUtils = DownloadUtils() timeInfo = API().getTimeInfo(MBitem) userData=API().getUserData(MBitem) playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem) playurl = utils.convertEncoding(playurl) if MBitem.get("DateCreated") != None: dateadded = MBitem["DateCreated"].replace("T"," ") dateadded = dateadded.replace(".0000000Z","") else: dateadded = None # we need to store both the path and the filename seperately in the kodi db so we split them up if "\\" in playurl: filename = playurl.rsplit("\\",1)[-1] path = playurl.replace(filename,"") elif "/" in playurl: filename = playurl.rsplit("/",1)[-1] path = playurl.replace(filename,"") #create the path cursor.execute("SELECT idPath as pathid FROM path WHERE strPath = ?",(path,)) result = cursor.fetchone() if result != None: pathid = result[0] else: cursor.execute("select coalesce(max(idPath),0) as pathid from path") pathid = cursor.fetchone()[0] pathid = pathid + 1 pathsql = "insert into path(idPath, strPath, strContent, strScraper, noUpdate) values(?, ?, ?, ?, ?)" cursor.execute(pathsql, (pathid,path,"movies","metadata.local",1)) playcount = None if userData.get("PlayCount") == "1": playcount = 1 #create the file if not exists cursor.execute("SELECT idFile as fileid FROM files WHERE strFilename = ? and idPath = ?",(filename,pathid,)) result = cursor.fetchone() if result != None: fileid = result[0] if result == None: cursor.execute("select coalesce(max(idFile),0) as fileid from files") fileid = cursor.fetchone()[0] fileid = fileid + 1 pathsql="insert into files(idFile, idPath, strFilename, playCount, lastPlayed, dateAdded) values(?, ?, ?, ?, ?, ?)" cursor.execute(pathsql, (fileid,pathid,filename,playcount,userData.get("LastPlayedDate"),dateadded)) runtime = int(timeInfo.get('Duration'))*60 plot = utils.convertEncoding(API().getOverview(MBitem)) title = utils.convertEncoding(MBitem["Name"]) sorttitle = utils.convertEncoding(MBitem["SortName"]) year = MBitem.get("ProductionYear") rating = MBitem.get("CommunityRating") if MBitem.get("ShortOverview") != None: shortplot = utils.convertEncoding(MBitem.get("ShortOverview")) else: shortplot = None trailerUrl = None if MBitem.get("LocalTrailerCount") != None and MBitem.get("LocalTrailerCount") > 0: itemTrailerUrl = "%s/mediabrowser/Users/%s/Items/%s/LocalTrailers?format=json" % (server, userid, MBitem.get("Id")) jsonData = downloadUtils.downloadUrl(itemTrailerUrl, suppress=False, popup=0 ) if(jsonData != ""): trailerItem = json.loads(jsonData) if trailerItem[0].get("LocationType") == "FileSystem": trailerUrl = PlayUtils().getPlayUrl(server, trailerItem[0].get("Id"), trailerItem[0]) trailerUrl = utils.convertEncoding(trailerUrl) #create the movie cursor.execute("select coalesce(max(idMovie),0) as movieid from movie") movieid = cursor.fetchone()[0] movieid = movieid + 1 pathsql="insert into movie(idMovie, idFile, c00, c01, c02, c05, c07, c09, c10, c11, c16, c19) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" cursor.execute(pathsql, (movieid, fileid, title, plot, shortplot, rating, year, MBitem["Id"], sorttitle, runtime, title, trailerUrl)) actionPerformed = False try: connection.commit() utils.logMsg("Emby","Added movie to Kodi Library",MBitem["Id"] + " - " + MBitem["Name"]) actionPerformed = True except: utils.logMsg("Emby","Error adding movie to Kodi Library",MBitem["Id"] + " - " + MBitem["Name"]) actionPerformed = False return actionPerformed def addMusicVideoToKodiLibrary( self, MBitem, connection, cursor ): #adds a musicvideo to Kodi by directly inserting it to connectionthe DB while there is no addMusicVideo available on the json API #TODO: PR at Kodi team for a addMusicVideo endpoint on their API addon = xbmcaddon.Addon(id='plugin.video.emby') port = addon.getSetting('port') host = addon.getSetting('ipaddress') server = host + ":" + port timeInfo = API().getTimeInfo(MBitem) userData=API().getUserData(MBitem) playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem) playurl = utils.convertEncoding(playurl) if MBitem.get("DateCreated") != None: dateadded = MBitem["DateCreated"].replace("T"," ") dateadded = dateadded.replace(".0000000Z","") else: dateadded = None # we need to store both the path and the filename seperately in the kodi db so we split them up if "\\" in playurl: filename = playurl.rsplit("\\",1)[-1] path = playurl.replace(filename,"") elif "/" in playurl: filename = playurl.rsplit("/",1)[-1] path = playurl.replace(filename,"") #create the path cursor.execute("SELECT idPath as pathid FROM path WHERE strPath = ?",(path,)) result = cursor.fetchone() if result != None: pathid = result[0] else: cursor.execute("select coalesce(max(idPath),0) as pathid from path") pathid = cursor.fetchone()[0] pathid = pathid + 1 pathsql = "insert into path(idPath, strPath, strContent, strScraper, noUpdate) values(?, ?, ?, ?, ?)" cursor.execute(pathsql, (pathid,path,"movies","metadata.local",1)) playcount = None if userData.get("PlayCount") == "1": playcount = 1 #create the file if not exists cursor.execute("SELECT idFile as fileid FROM files WHERE strFilename = ?",(filename,)) result = cursor.fetchone() if result != None: fileid = result[0] if result == None: cursor.execute("select coalesce(max(idFile),0) as fileid from files") fileid = cursor.fetchone()[0] fileid = fileid + 1 pathsql="insert into files(idFile, idPath, strFilename, playCount, lastPlayed, dateAdded) values(?, ?, ?, ?, ?, ?)" cursor.execute(pathsql, (fileid,pathid,filename,playcount,userData.get("LastPlayedDate"),dateadded)) runtime = int(timeInfo.get('Duration'))*60 plot = utils.convertEncoding(API().getOverview(MBitem)) title = utils.convertEncoding(MBitem["Name"]) #create the musicvideo cursor.execute("select coalesce(max(idMVideo),0) as musicvideoid from musicvideo") musicvideoid = cursor.fetchone()[0] musicvideoid = musicvideoid + 1 pathsql="insert into musicvideo(idMVideo, idFile, c00, c04, c08, c23) values(?, ?, ?, ?, ?, ?)" cursor.execute(pathsql, (musicvideoid, fileid, title, runtime, plot, MBitem["Id"])) actionPerformed = False try: connection.commit() utils.logMsg("Emby","Added musicvideo to Kodi Library",MBitem["Id"] + " - " + MBitem["Name"]) actionPerformed = True except: utils.logMsg("Emby","Error adding musicvideo to Kodi Library",MBitem["Id"] + " - " + MBitem["Name"]) return actionPerformed def addEpisodeToKodiLibrary(self, MBitem, connection, cursor): #adds a Episode to Kodi by directly inserting it to the DB while there is no addEpisode available on the json API #TODO: PR at Kodi team for a addEpisode endpoint on their API # check season season = 0 if MBitem.get("ParentIndexNumber") != None: season = int(MBitem.get("ParentIndexNumber")) else: utils.logMsg("Emby","Error adding episode to Kodi Library, no ParentIndexNumber - ID: " + MBitem["Id"] + " - " + MBitem["Name"]) return False # first check the episode is not already in the DB using the Emby ID which is stored in c20 cursor.execute("SELECT idEpisode FROM episode WHERE c20 = ?",(MBitem["Id"],)) result = cursor.fetchone() if result != None: utils.logMsg("Emby", "Episode already exists in DB : " + MBitem["Id"] + " - " + MBitem["Name"], 2) return False # get the showid cursor.execute("SELECT idShow as showid FROM tvshow WHERE c12 = ?",(MBitem["SeriesId"],)) result = cursor.fetchone() showid = -1 if(result == None): utils.logMsg("Emby","Error adding episode to Kodi Library, couldn't find show - ID: " + MBitem["Id"] + " - " + MBitem["Name"]) return False else: showid = result[0] # check season cursor.execute("SELECT idSeason FROM seasons WHERE idShow = ? and season = ?",(showid, season)) result = cursor.fetchone() if(result == None): utils.logMsg("Emby","Error adding episode to Kodi Library, season does not exist - ShowId: " + str(showid) + " SeasonNo: " + str(season) + " EmbyId: " + MBitem["Id"] + " Name: " + MBitem["Name"]) return False # do add addon = xbmcaddon.Addon(id='plugin.video.emby') port = addon.getSetting('port') host = addon.getSetting('ipaddress') server = host + ":" + port timeInfo = API().getTimeInfo(MBitem) userData=API().getUserData(MBitem) playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem) playurl = utils.convertEncoding(playurl) if MBitem.get("DateCreated") != None: dateadded = MBitem["DateCreated"].replace("T"," ") dateadded = dateadded.split(".")[0] else: dateadded = None if userData.get("LastPlayedDate") != None: lastplayed = userData.get("LastPlayedDate") else: lastplayed = None # we need to store both the path and the filename seperately in the kodi db so we split them up if "\\" in playurl: filename = playurl.rsplit("\\",1)[-1] path = playurl.replace(filename,"") elif "/" in playurl: filename = playurl.rsplit("/",1)[-1] path = playurl.replace(filename,"") #create the new path - return id if already exists 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, strContent, strScraper, noUpdate) values(?, ?, ?, ?, ?)" cursor.execute(pathsql, (pathid,path,None,None,1)) playcount = None if userData.get("PlayCount") == "1": playcount = 1 #create the file if not exists cursor.execute("SELECT idFile as fileid FROM files WHERE strFilename = ? and idPath = ?",(filename,pathid,)) result = cursor.fetchone() if result != None: fileid = result[0] if result == None: cursor.execute("select coalesce(max(idFile),0) as fileid from files") fileid = cursor.fetchone()[0] fileid = fileid + 1 sql="INSERT OR REPLACE into files(idFile, idPath, strFilename, playCount, lastPlayed, dateAdded) values(?, ?, ?, ?, ?, ?)" cursor.execute(sql, (fileid,pathid,filename,playcount,lastplayed,dateadded)) # build info episode = 0 if MBitem.get("IndexNumber") != None: episode = int(MBitem.get("IndexNumber")) runtime = int(timeInfo.get('Duration'))*60 plot = utils.convertEncoding(API().getOverview(MBitem)) title = utils.convertEncoding(MBitem["Name"]) rating = MBitem.get("CommunityRating") if MBitem.get("PremiereDate") != None: premieredatelist = (MBitem.get("PremiereDate")).split("T") premieredate = premieredatelist[0] else: premieredate = None #create the episode cursor.execute("select coalesce(max(idEpisode),0) as episodeid from episode") episodeid = cursor.fetchone()[0] episodeid = episodeid + 1 pathsql = "INSERT into episode(idEpisode, idFile, c00, c01, c03, c05, c09, c20, c12, c13, c14, idShow, c15, c16) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" cursor.execute(pathsql, (episodeid, fileid, title, plot, rating, premieredate, runtime, MBitem["Id"], season, episode, title, showid, "-1", "-1")) actionPerformed = False try: connection.commit() utils.logMsg("Emby","Added episode to Kodi Library - ID: " + MBitem["Id"] + " - " + MBitem["Name"]) actionPerformed = True except: utils.logMsg("Emby","Error adding episode to Kodi Library - ID: " + MBitem["Id"] + " - " + MBitem["Name"]) return actionPerformed 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"])) 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"])) def deleteEpisodeFromKodiLibrary(self, episodeid, tvshowid ): utils.logMsg("deleting episode from Kodi library",episodeid) episode = ReadKodiDB().getKodiEpisodeByMbItem(episodeid, tvshowid) if episode != None: WINDOW = xbmcgui.Window( 10000 ) xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.RemoveEpisode", "params": { "episodeid": %i}, "id": 1 }' %(episode["episodeid"])) utils.logMsg("episode deleted succesfully!",episodeid) else: utils.logMsg("episode not found in kodi DB",episodeid) def deleteEpisodeFromKodiLibraryByMbId(self, id ): utils.logMsg("deleting episode from Kodi library", id) kodiItem = ReadKodiDB().getKodiEpisodeByMbItemEx(id) if kodiItem != None: xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.RemoveEpisode", "params": { "episodeid": %i}, "id": 1 }' %(kodiItem["episodeid"])) utils.logMsg("episode deleted succesfully!", id) else: utils.logMsg("episode not found in kodi DB", id) def addTVShowToKodiLibrary( self, MBitem, connection, cursor ): #adds a Tvshow to Kodi by directly inserting it to the DB while there is no addTvShow available on the json API #TODO: PR at Kodi team for a addTvShow endpoint on their API addon = xbmcaddon.Addon(id='plugin.video.emby') port = addon.getSetting('port') host = addon.getSetting('ipaddress') server = host + ":" + port timeInfo = API().getTimeInfo(MBitem) userData=API().getUserData(MBitem) thumbPath = API().getArtwork(MBitem, "Primary") playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem) #make sure that the path always ends with a slash path = utils.convertEncoding(playurl + "/") if MBitem.get("DateCreated") != None: dateadded = MBitem["DateCreated"].replace("T"," ") dateadded = dateadded.replace(".0000000Z","") else: dateadded = None #create the tv show 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, strContent, strScraper, noUpdate) values(?, ?, ?, ?, ?)" cursor.execute(pathsql, (pathid,path,None,None,1)) #create toplevel path as monitored source - needed for things like actors and stuff to work (no clue why) if "\\" in path: toplevelpathstr = path.rsplit("\\",2)[1] toplevelpath = path.replace(toplevelpathstr + "\\","") elif "/" in path: toplevelpathstr = path.rsplit("/",2)[1] toplevelpath = path.replace(toplevelpathstr + "/","") cursor.execute("SELECT idPath as tlpathid FROM path WHERE strPath = ?",(toplevelpath,)) result = cursor.fetchone() if result == None: cursor.execute("select coalesce(max(idPath),0) as tlpathid from path") tlpathid = cursor.fetchone()[0] tlpathid = pathid + 1 pathsql="insert into path(idPath, strPath, strContent, strScraper, noUpdate) values(?, ?, ?, ?, ?)" cursor.execute(pathsql, (tlpathid,toplevelpath,"tvshows","metadata.local",1)) runtime = int(timeInfo.get('Duration'))*60 plot = utils.convertEncoding(API().getOverview(MBitem)) title = utils.convertEncoding(MBitem["Name"]) sorttitle = utils.convertEncoding(MBitem["SortName"]) rating = MBitem.get("CommunityRating") #create the tvshow cursor.execute("select coalesce(max(idShow),0) as showid from tvshow") showid = cursor.fetchone()[0] showid = pathid + 1 pathsql="insert into tvshow(idShow, c00, c01, c04, c09, c12, c15) values(?, ?, ?, ?, ?, ?, ?)" cursor.execute(pathsql, (showid, title, plot, rating, title, MBitem["Id"], sorttitle)) #link the path pathsql="insert into tvshowlinkpath(idShow,idPath) values(?, ?)" cursor.execute(pathsql, (showid,pathid)) actionPerformed = False try: connection.commit() utils.logMsg("Emby","Added TV Show to Kodi Library: " + MBitem["Id"] + " - " + MBitem["Name"]) actionPerformed = True except: utils.logMsg("Emby","Error adding tvshow to Kodi Library: " + MBitem["Id"] + " - " + MBitem["Name"]) return actionPerformed def deleteTVShowFromKodiLibrary(self, id): xbmc.sleep(sleepVal) kodiItem = ReadKodiDB().getKodiTVShow(id) utils.logMsg("deleting tvshow from Kodi library ", "Emby ID : " + id) if kodiItem != None: utils.logMsg("deleting tvshow from Kodi library ", str(kodiItem)) kodiId = kodiItem["tvshowid"] utils.logMsg("deleting tvshow from Kodi library ", "Kodi ID : " + str(kodiId)) xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.RemoveTVShow", "params": { "tvshowid": %i}, "id": 1 }' %(kodiId)) def updateSeasons(self,MBitem, KodiItem, connection, cursor): #use sqlite to set the season details because no method in API available for this tvshowid = KodiItem["tvshowid"] #connection = utils.KodiSQL() #cursor = connection.cursor() seasonData = ReadEmbyDB().getTVShowSeasons(MBitem["Id"]) if seasonData != None: for season in seasonData: seasonNum = season.get("IndexNumber") if seasonNum != None and seasonNum >= 0 and seasonNum <= 1000: cursor.execute("SELECT idSeason as seasonid FROM seasons WHERE idShow = ? and season = ?",(tvshowid, seasonNum)) result = cursor.fetchone() if result == None: #create the season cursor.execute("select coalesce(max(idSeason),0) as seasonid from seasons") seasonid = cursor.fetchone()[0] seasonid = seasonid + 1 cursor.execute("INSERT into seasons(idSeason, idShow, season) values(?, ?, ?)", (seasonid, tvshowid, seasonNum)) else: seasonid = result[0] #update artwork imageUrl = API().getArtwork(season, "Thumb") self.updateSeasonArt(imageUrl, seasonid, "landscape", cursor) imageUrl = API().getArtwork(season, "Primary") self.updateSeasonArt(imageUrl, seasonid, "poster", cursor) imageUrl = API().getArtwork(season, "Banner") self.updateSeasonArt(imageUrl, seasonid, "banner", cursor) connection.commit() def updateSeasonArt(self, imageUrl, seasonid, imageType, cursor): updateDone = False if imageUrl != "": cursor.execute("SELECT url FROM art WHERE media_id = ? AND media_type = ? AND type = ?", (seasonid, "season", imageType)) result = cursor.fetchone() if(result == None): utils.logMsg("SeasonArt", "Adding Art Link for SeasonId: " + str(seasonid) + " (" + imageUrl + ")") cursor.execute("INSERT INTO art(media_id, media_type, type, url) values(?, ?, ?, ?)", (seasonid, "season", imageType, imageUrl)) updateDone = True else: url = result[0]; if(url != imageUrl): utils.logMsg("SeasonArt", "Updating Art Link for SeasonId: " + str(seasonid) + " (" + url + ") -> (" + imageUrl + ")") cursor.execute("UPDATE art set url = ? WHERE media_id = ? AND media_type = ? AND type = ?", (imageUrl, seasonid, "season", imageType)) updateDone = True return updateDone 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("Emby","setting resume point in kodi db..." + fileType + ": " + str(id)) xbmc.sleep(sleepVal) connection = utils.KodiSQL() 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() ''' # removed for now as setting c15 and c16 to -1 looks like it just shows specials in the special folder only def setSpecialAirsDetails(self, MBitem, KodiItem, connection, cursor): changes = False cursor.execute("SELECT c15, c16 FROM episode WHERE idEpisode = ?",(KodiItem["episodeid"],)) result = cursor.fetchone() if(result != None): c15 = -1 c16 = -1 if(result[0] != None and result[0] != "" and result[0] != "None"): c15 = int(result[0]) if(result[1] != None and result[1] != "" and result[1] != "None"): c16 = int(result[1]) airsBeforeSeasonNumber = MBitem.get("AirsBeforeSeasonNumber") airsBeforeEpisodeNumber = MBitem.get("AirsBeforeEpisodeNumber") #AirsAfterSeasonNumber if(airsBeforeSeasonNumber == None): airsBeforeSeasonNumber = 0 if(airsBeforeEpisodeNumber == None): airsBeforeEpisodeNumber = 0 if(airsBeforeSeasonNumber != None and airsBeforeEpisodeNumber != None): if(airsBeforeSeasonNumber != c15 or airsBeforeEpisodeNumber != c16): utils.logMsg("Emby","Special_Airs_Info Kodi: " + str(c15) + " " + str(c16)) utils.logMsg("Emby","Special_Airs_Info Emby : " + str(airsBeforeSeasonNumber) + " " + str(airsBeforeEpisodeNumber)) sql = "UPDATE episode set c15 = ?, c16 = ? WHERE idEpisode = ?" cursor.execute(sql, (airsBeforeSeasonNumber, airsBeforeEpisodeNumber, KodiItem["episodeid"])) connection.commit() changes = True return changes ''' def setKodiFilename(self, id, oldFileName, newFileName, fileType, mbId, connection, cursor): #use sqlite to set the filename in DB -- needed to avoid problems with resumepoints etc #return True if any action is performed, False if no action is performed #todo --> submit PR to kodi team to get this added to the jsonrpc api #todo --> extend support for musicvideos actionPerformed = False oldFileName = utils.convertEncoding(oldFileName) newFileName = utils.convertEncoding(newFileName) # this is required to make sure the paths match oldFileName = oldFileName.replace("\\", "/") # only perform changes if the path actually differs if oldFileName != newFileName: # xbmc.sleep(sleepVal) #connection = utils.KodiSQL() #cursor = connection.cursor() utils.logMsg("Emby","setting filename in kodi db..." + fileType + ": " + str(id)) utils.logMsg("Emby","old filename -->" + oldFileName) utils.logMsg("Emby","new filename -->" + newFileName) ######### PROCESS TV SHOW ############ if fileType == "tvshow": if newFileName.startswith("http"): newFileName = "plugin://plugin.video.emby/" #for tvshows we only store the path in DB cursor.execute("SELECT idPath as pathid FROM tvshowlinkpath WHERE idShow = ?",(id,)) result = cursor.fetchone() pathid = result[0] cursor.execute("UPDATE path SET strPath = ?, noUpdate = ?, idParentPath = ? WHERE idPath = ?", (newFileName,1,None,pathid)) else: # we need to store both the path and the filename seperately in the kodi db so we split them up if newFileName.startswith("http"): #transcoding or play from stream path = "plugin://plugin.video.emby/" filename = "plugin://plugin.video.emby/?id=" + mbId + "&mode=play" else: # direct play if "\\" in newFileName: filename = newFileName.rsplit("\\",1)[-1] path = newFileName.replace(filename,"") elif "/" in newFileName: filename = newFileName.rsplit("/",1)[-1] path = newFileName.replace(filename,"") ######### PROCESS EPISODE ############ if fileType == "episode": #get the file and the current path id cursor.execute("SELECT idFile as fileid FROM episode WHERE idEpisode = ?",(id,)) result = cursor.fetchone() fileid = result[0] #create the new path - return id if already exists 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, strContent, strScraper, noUpdate) values(?, ?, ?, ?, ?)" cursor.execute(pathsql, (pathid,path,None,None,1)) #set the new path and filename to the episode cursor.execute("UPDATE files SET idPath = ?, strFilename = ? WHERE idFile = ?", (pathid,filename,fileid)) ######### PROCESS MOVIE ############ if fileType == "movie": cursor.execute("SELECT idFile as fileid FROM movie WHERE idMovie = ?",(id,)) result = cursor.fetchone() fileid = result[0] #write the new filename to the DB cursor.execute("UPDATE files SET strFilename = ? WHERE idFile = ?", (filename,fileid)) #set the new path cursor.execute("SELECT idPath as pathid FROM files WHERE idFile = ?",(fileid,)) result = cursor.fetchone() pathid = result[0] cursor.execute("UPDATE path SET strPath = ?, strContent = ?, strScraper = ?, noUpdate = ?, idParentPath = ? WHERE idPath = ?", (path, "movies", "metadata.local", 1, None, pathid)) try: connection.commit() actionPerformed = True except: utils.logMsg("Emby","Error setting filename in kodi db for: " + fileType + ": " + str(id)) actionPerformed = False return actionPerformed def AddActorsToMedia(self, KodiItem, people, mediatype, connection, cursor): #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 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"]) needsUpdate = False if(people != None): for person in people: if(person.get("Type") == "Actor"): if person.get("Name") not in currentcast: needsUpdate = True break if(needsUpdate == False): return False utils.logMsg("AddActorsToMedia", "List needs updating") kodiVersion = 14 if xbmc.getInfoLabel("System.BuildVersion").startswith("15"): kodiVersion = 15 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")) Name = person.get("Name") Role = person.get("Role") actorid = None Thumb = downloadUtils.imageUrl(person.get("Id"), "Primary", 0, 400, 400) if kodiVersion == 15: # Kodi Isengard database # if Thumb != None: Thumb = "" + Thumb + "" cursor.execute("SELECT actor_id as actorid FROM actor WHERE name = ?",(Name,)) else: # Kodi Gotham or Helix database # cursor.execute("SELECT idActor as actorid FROM actors WHERE strActor = ?",(Name,)) result = cursor.fetchone() if result != None: actorid = result[0] if actorid == None: if kodiVersion == 15: # Kodi Isengard database # cursor.execute("select coalesce(max(actor_id),0) as actorid from actor") actorid = cursor.fetchone()[0] actorid = actorid + 1 peoplesql="insert into actor(actor_id, name, art_urls) values(?, ?, ?)" else: # Kodi Gotham or Helix database # 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 kodiVersion == 15: # Kodi Isengard database # peoplesql="INSERT OR REPLACE into actor_link(actor_id, media_id, media_type, role, cast_order) values(?, ?, ?, ?, ?)" cursor.execute(peoplesql, (actorid, id, mediatype, Role, None)) else: # Kodi Gotham or Helix database # 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() return True def addBoxsetToKodiLibrary(self, boxset, connection, cursor): #use sqlite to set add the set #connection = utils.KodiSQL() #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") art_types = ['poster','fanart','landscape','clearlogo','clearart','banner','discart'] 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"]) if kodiMovie != None: WriteKodiDB().updateProperty(kodiMovie,"set",strSet,"movie",True)