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

1379 lines
67 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 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
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)
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby", "updatePlayCountFromKodi Called")
Refactor 4/4
2015-03-17 19:02:42 +00:00
Fix updatePlayCountFromKodi to use getEmbyIdByKodiId and done do a playcount sync if one is already running
2015-03-29 02:34:59 +00:00
mb3Id = ReadKodiDB().getEmbyIdByKodiId(id, type)
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
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","watchedurl -->" + watchedurl)
add episode watched push to MBS from Kodi
2015-03-18 02:45:15 +00:00
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
speed improvements
2015-04-04 17:20:48 +00:00
def updateMovieToKodiLibrary_Batched(self, MBitem, KodiItem,connection, cursor):
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)
speed improvements
2015-04-04 17:20:48 +00:00
self.setKodiFilename(KodiItem["movieid"], KodiItem["file"], playurl, "movie", MBitem["Id"], connection, cursor)
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
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
if KodiItem["runtime"] == 0:
self.getPropertyParam_Batched(KodiItem, "runtime", (int(timeInfo.get('Duration'))*60), 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.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)
set a few more props on update
2015-04-06 09:13:42 +00:00
self.getPropertyParam_Batched(KodiItem, "plot", MBitem.get("Overview"), 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.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":
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
trailerUrl = PlayUtils().getPlayUrl(server, trailerItem[0].get("Id"), trailerItem[0])
assure trailer url is encoded
2015-04-02 10:47:29 +00:00
trailerUrl = utils.convertEncoding(trailerUrl)
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)
fix string encoding for json command data
2015-04-01 03:17:46 +00:00
result = xbmc.executeJSONRPC(jsoncommand.encode("utf-8"))
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
#add actors
speed improvements
2015-04-04 17:20:48 +00:00
changes |= self.AddActorsToMedia(KodiItem,MBitem.get("People"), "movie", connection, cursor)
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
remove some redundant code calls and do a shouldstop call in the add loop
2015-04-04 23:59:15 +00:00
#downloadUtils = DownloadUtils()
#userid = downloadUtils.getUserId()
added musicvideos support
2015-03-21 13:31:30 +00:00
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
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
if KodiItem["runtime"] == None:
self.getPropertyParam_Batched(KodiItem, "runtime", (int(timeInfo.get('Duration'))*60), params)
added musicvideos support
2015-03-21 13:31:30 +00:00
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)
fix string encoding for json command data
2015-04-01 03:17:46 +00:00
result = xbmc.executeJSONRPC(jsoncommand.encode("utf-8"))
added musicvideos support
2015-03-21 13:31:30 +00:00
if(changes):
utils.logMsg("Updated musicvideo to Kodi Library", MBitem["Id"] + " - " + MBitem["Name"], level=0)
speed improvements
2015-04-04 17:20:48 +00:00
def updateMovieToKodiLibrary(self, MBitem, KodiItem, connection, cursor):
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
acumulate change values with |= and dont set art if it is ""
2015-03-19 23:48:59 +00:00
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)
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
trailerUrl = PlayUtils().getPlayUrl(server, trailerItem[0].get("Id"), MBitem)
assure trailer url is encoded
2015-04-02 10:47:29 +00:00
trailerUrl = utils.convertEncoding(trailerUrl)
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
speed improvements
2015-04-04 17:20:48 +00:00
changes |= self.AddActorsToMedia(KodiItem,MBitem.get("People"),"movie", connection, cursor)
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)
speed improvements
2015-04-04 17:20:48 +00:00
self.setKodiFilename(KodiItem["movieid"], KodiItem["file"], playurl, "movie", connection, cursor)
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +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"])
speed improvements
2015-04-04 17:20:48 +00:00
def updateTVShowToKodiLibrary( self, MBitem, KodiItem,connection, cursor ):
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()
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
fixed actors in tvshows
2015-04-01 21:28:19 +00:00
Refactor 4/4
2015-03-17 19:02:42 +00:00
fixes for the path sync actions not working yet --> episodes updates are skipped ?
2015-03-29 16:20:02 +00:00
#set Filename
playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem)
#make sure that the path always ends with a slash
playurl = playurl + "/"
speed improvements
2015-04-04 17:20:48 +00:00
self.setKodiFilename(KodiItem["tvshowid"], KodiItem["file"], playurl, "tvshow", MBitem["Id"], connection, cursor)
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
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")
Added tags for TV collections
2015-04-04 21:48:02 +00:00
changes |= self.updatePropertyArray(KodiItem,"tag",MBitem.get("Tag"),"tvshow")
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
set a few more props on update
2015-04-06 09:13:42 +00:00
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")
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
speed improvements
2015-04-04 17:20:48 +00:00
changes |= self.AddActorsToMedia(KodiItem,MBitem.get("People"),"tvshow", connection, cursor)
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
#update season details
speed improvements
2015-04-04 17:20:48 +00:00
self.updateSeasons(MBitem, KodiItem,connection, cursor)
added extra fanart sync
2015-03-25 14:00:08 +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"])
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
speed improvements
2015-04-04 17:20:48 +00:00
def updateEpisodeToKodiLibrary( self, MBitem, KodiItem, connection, cursor ):
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
remove some redundant code calls and do a shouldstop call in the add loop
2015-04-04 23:59:15 +00:00
#downloadUtils = DownloadUtils()
#userid = downloadUtils.getUserId()
Refactor 4/4
2015-03-17 19:02:42 +00:00
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
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
#set Filename (will update the filename in db if changed)
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem)
speed improvements
2015-04-04 17:20:48 +00:00
docleanup = self.setKodiFilename(KodiItem["episodeid"], KodiItem["file"], playurl, "episode", MBitem["Id"], connection, cursor)
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
Refactor 4/4
2015-03-17 19:02:42 +00:00
#update common properties
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
if KodiItem["runtime"] == 0:
changes |= self.updateProperty(KodiItem,"runtime",(int(timeInfo.get('Duration'))*60),"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:
add poster artwork to episodes
2015-04-05 23:11:39 +00:00
changes |= self.updateProperty(KodiItem,"firstaired",firstaired,"episode")
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,"episode")
set a few more props on update
2015-04-06 09:13:42 +00:00
if MBitem.get("ParentIndexNumber") != None:
season = int(MBitem.get("ParentIndexNumber"))
changes |= self.updateProperty(KodiItem,"season",season,"episode")
if MBitem.get("IndexNumber") != None:
episode = int(MBitem.get("IndexNumber"))
typo
2015-04-06 11:20:18 +00:00
changes |= self.updateProperty(KodiItem,"episode",episode,"episode")
set a few more props on update
2015-04-06 09:13:42 +00:00
plot = utils.convertEncoding(API().getOverview(MBitem))
changes |= self.updateProperty(KodiItem,"plot",plot,"episode")
title = utils.convertEncoding(MBitem["Name"])
another copy/paste issue
2015-04-06 11:38:49 +00:00
changes |= self.updateProperty(KodiItem,"title",title,"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
speed improvements
2015-04-04 17:20:48 +00:00
changes |= self.AddActorsToMedia(KodiItem,MBitem.get("People"),"episode", connection, cursor)
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):
add poster artwork to episodes
2015-04-05 23:11:39 +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
item_type=str(MBitem.get("Type"))
add poster artwork to episodes
2015-04-05 23:11:39 +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 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")
add poster artwork to episodes
2015-04-05 23:11:39 +00:00
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")
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
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":
add poster artwork to episodes
2015-04-05 23:11:39 +00:00
id = KodiItem['episodeid']
jsoncommand = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetEpisodeDetails", "params": { "episodeid": %i, "art": %s}, "id": 1 }'
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")
add poster artwork to episodes
2015-04-05 23:11:39 +00:00
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")
optimization in setartwork --> now sets all artwork at once
2015-03-20 11:39:26 +00:00
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)
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","updating property..." + str(propertyName))
utils.logMsg("Emby","kodi value:" + str(KodiItem[propertyName]) + " MB value: " + str(propertyValue))
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
params.append("\"" + propertyName + "\": " + str(propertyValue))
#xbmc.executeJSONRPC(jsoncommand_i %(id, propertyName, propertyValue))
changes = True
else:
#xbmc.sleep(sleepVal)
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","updating property..." + str(propertyName))
utils.logMsg("Emby","kodi value:" + KodiItem[propertyName] + " MB value: " + propertyValue)
fix string encoding for json command data
2015-04-01 03:17:46 +00:00
params.append("\"" + propertyName + "\": \"" + propertyValue + "\"")
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.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)
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","updating property..." + str(propertyName))
utils.logMsg("Emby","kodi value:" + str(KodiItem[propertyName]) + " MB value: " + str(propertyValue))
Refactor 4/4
2015-03-17 19:02:42 +00:00
xbmc.executeJSONRPC(jsoncommand_i %(id, propertyName, propertyValue))
changes = True
else:
xbmc.sleep(sleepVal)
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","updating property..." + str(propertyName))
utils.logMsg("Emby","kodi value:" + KodiItem[propertyName] + " MB value: " + propertyValue)
Refactor 4/4
2015-03-17 19:02:42 +00:00
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)
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","updating propertyarray... Name:" + str(propertyName) + " Current:" + str(currentvalues) + " New:" + str(json_array))
Batch up all the params needed to update a movie and send them all at once
2015-03-20 23:33:04 +00:00
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)
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","updating propertyarray... Name:" + str(propertyName) + " Current:" + str(currentvalues) + " New:" + str(json_array))
Refactor 4/4
2015-03-17 19:02:42 +00:00
xbmc.executeJSONRPC(jsoncommand %(id,propertyName,json_array))
return pendingChanges
speed improvements
2015-04-04 17:20:48 +00:00
def addMovieToKodiLibrary( self, MBitem ,connection, cursor):
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
#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
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
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)
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
thumbPath = API().getArtwork(MBitem, "Primary")
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem)
playurl = utils.convertEncoding(playurl)
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
if MBitem.get("DateCreated") != None:
dateadded = MBitem["DateCreated"].replace("T"," ")
dateadded = dateadded.replace(".0000000Z","")
else:
dateadded = None
Refactor 4/4
2015-03-17 19:02:42 +00:00
speed improvements
2015-04-04 17:20:48 +00:00
#connection = utils.KodiSQL()
#cursor = connection.cursor()
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
# 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
use existing file only if the path was the same as well
2015-04-01 23:48:04 +00:00
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))
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
playcount = None
if userData.get("PlayCount") == "1":
playcount = 1
#create the file if not exists
use existing file only if the path was the same as well
2015-04-01 23:48:04 +00:00
cursor.execute("SELECT idFile as fileid FROM files WHERE strFilename = ? and idPath = ?",(filename,pathid,))
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
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))
thumb = "<thumb>" + API().getArtwork(MBitem, "Primary") + "</thumb>"
fanart = "<fanart>" + API().getArtwork(MBitem, "Backdrop") + "</fanart>"
title = utils.convertEncoding(MBitem["Name"])
sorttitle = utils.convertEncoding(MBitem["SortName"])
year = MBitem.get("ProductionYear")
if MBitem.get("CriticRating") != None:
rating = int(MBitem.get("CriticRating"))/10
else:
rating = None
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 = "http://" + server + "/mediabrowser/Users/" + userid + "/Items/" + MBitem.get("Id") + "/LocalTrailers?format=json"
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])
assure trailer url is encoded
2015-04-02 10:47:29 +00:00
trailerUrl = utils.convertEncoding(trailerUrl)
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
#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, c04, c07, c08, c09, c10, c11, c16, c19, c20) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
assure trailer url is encoded
2015-04-02 10:47:29 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
cursor.execute(pathsql, (movieid, fileid, title, plot, shortplot, rating, year, thumb, MBitem["Id"], sorttitle, runtime, title, trailerUrl, fanart))
try:
connection.commit()
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","Added movie to Kodi Library",MBitem["Id"] + " - " + MBitem["Name"])
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
except:
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","Error adding movie to Kodi Library",MBitem["Id"] + " - " + MBitem["Name"])
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
actionPerformed = False
Refactor 4/4
2015-03-17 19:02:42 +00:00
speed improvements
2015-04-04 17:20:48 +00:00
def addMusicVideoToKodiLibrary( self, MBitem, connection, cursor ):
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
speed improvements
2015-04-04 17:20:48 +00:00
#adds a musicvideo to Kodi by directly inserting it to connectionthe DB while there is no addMusicVideo available on the json API
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
#TODO: PR at Kodi team for a addMusicVideo endpoint on their API
added musicvideos support
2015-03-21 13:31:30 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
addon = xbmcaddon.Addon(id='plugin.video.emby')
port = addon.getSetting('port')
host = addon.getSetting('ipaddress')
server = host + ":" + port
remove some redundant code calls and do a shouldstop call in the add loop
2015-04-04 23:59:15 +00:00
#downloadUtils = DownloadUtils()
#userid = downloadUtils.getUserId()
added musicvideos support
2015-03-21 13:31:30 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
timeInfo = API().getTimeInfo(MBitem)
userData=API().getUserData(MBitem)
people = API().getPeople(MBitem)
genre = API().getGenre(MBitem)
studios = API().getStudios(MBitem)
mediaStreams=API().getMediaStreams(MBitem)
added musicvideos support
2015-03-21 13:31:30 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
thumbPath = API().getArtwork(MBitem, "Primary")
added musicvideos support
2015-03-21 13:31:30 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem)
playurl = utils.convertEncoding(playurl)
added musicvideos support
2015-03-21 13:31:30 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
if MBitem.get("DateCreated") != None:
dateadded = MBitem["DateCreated"].replace("T"," ")
dateadded = dateadded.replace(".0000000Z","")
else:
dateadded = None
speed improvements
2015-04-04 17:20:48 +00:00
#connection = utils.KodiSQL()
#cursor = connection.cursor()
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
# 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
use existing file only if the path was the same as well
2015-04-01 23:48:04 +00:00
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))
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
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))
thumb = "<thumb>" + API().getArtwork(MBitem, "Primary") + "</thumb>"
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, c01, c04, c08, c23) values(?, ?, ?, ?, ?, ?, ?)"
cursor.execute(pathsql, (musicvideoid, fileid, title, thumb, runtime, plot, MBitem["Id"]))
try:
connection.commit()
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","Added musicvideo to Kodi Library",MBitem["Id"] + " - " + MBitem["Name"])
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
except:
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","Error adding musicvideo to Kodi Library",MBitem["Id"] + " - " + MBitem["Name"])
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
actionPerformed = False
added musicvideos support
2015-03-21 13:31:30 +00:00
speed improvements
2015-04-04 17:20:48 +00:00
def addEpisodeToKodiLibrary(self, MBitem, connection, cursor):
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
#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
Refactor 4/4
2015-03-17 19:02:42 +00:00
use uniqueid to check of en episode is already in the DB
2015-04-04 23:32:42 +00:00
# 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:
increase connection time out
2015-04-05 07:47:47 +00:00
utils.logMsg("Emby", "TV Show already exists in DB : " + MBitem["Id"] + " - " + MBitem["Name"], 2)
use uniqueid to check of en episode is already in the DB
2015-04-04 23:32:42 +00:00
return
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
addon = xbmcaddon.Addon(id='plugin.video.emby')
port = addon.getSetting('port')
host = addon.getSetting('ipaddress')
server = host + ":" + port
use uniqueid to check of en episode is already in the DB
2015-04-04 23:32:42 +00:00
#downloadUtils = DownloadUtils()
#userid = downloadUtils.getUserId()
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
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")
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
speed improvements
2015-04-04 17:20:48 +00:00
#connection = utils.KodiSQL()
#cursor = connection.cursor()
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
# 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
use existing file only if the path was the same as well
2015-04-01 23:48:04 +00:00
cursor.execute("SELECT idFile as fileid FROM files WHERE strFilename = ? and idPath = ?",(filename,pathid,))
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
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))
#get the showid
cursor.execute("SELECT idShow as showid FROM tvshow WHERE c12 = ?",(MBitem["SeriesId"],))
showid = cursor.fetchone()[0]
season = 0
if MBitem.get("ParentIndexNumber") != None:
season = int(MBitem.get("ParentIndexNumber"))
episode = 0
if MBitem.get("IndexNumber") != None:
episode = int(MBitem.get("IndexNumber"))
runtime = int(timeInfo.get('Duration'))*60
plot = utils.convertEncoding(API().getOverview(MBitem))
thumb = "<thumb>" + API().getArtwork(MBitem, "Primary") + "</thumb>"
title = utils.convertEncoding(MBitem["Name"])
if MBitem.get("CriticRating") != None:
rating = int(MBitem.get("CriticRating"))/10
else:
rating = 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, c06, c09, c20, c12, c13, c14, idShow) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
cursor.execute(pathsql, (episodeid, fileid, title, plot, rating, thumb, runtime, MBitem["Id"], season, episode, title, showid))
try:
connection.commit()
use uniqueid to check of en episode is already in the DB
2015-04-04 23:32:42 +00:00
utils.logMsg("Emby","Added TV Show to Kodi Library" + MBitem["Id"] + " - " + MBitem["Name"])
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
except:
use uniqueid to check of en episode is already in the DB
2015-04-04 23:32:42 +00:00
utils.logMsg("Emby","Error adding tvshow to Kodi Library" + MBitem["Id"] + " - " + MBitem["Name"])
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
actionPerformed = False
Refactor 4/4
2015-03-17 19:02:42 +00:00
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"]))
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
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"]))
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:
Fix episode deletes
2015-03-28 16:14:52 +00:00
WINDOW = xbmcgui.Window( 10000 )
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"]))
fix episode deletions cleanup
2015-03-29 21:37:02 +00:00
fixed empty results in getKodiTvshow and GetKodiMovie filter in kodi api call doesn't accept all fields as searchparameter so walk through the results instead
2015-03-29 20:13:11 +00:00
utils.logMsg("episode deleted succesfully!",episodeid)
else:
FINAL fix for the doubled episodes. Yeah for real now :-)
2015-03-29 22:43:53 +00:00
utils.logMsg("episode not found in kodi DB",episodeid)
fixed empty results in getKodiTvshow and GetKodiMovie filter in kodi api call doesn't accept all fields as searchparameter so walk through the results instead
2015-03-29 20:13:11 +00:00
speed improvements
2015-04-04 17:20:48 +00:00
def addTVShowToKodiLibrary( self, MBitem, connection, cursor ):
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
#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
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
addon = xbmcaddon.Addon(id='plugin.video.emby')
port = addon.getSetting('port')
host = addon.getSetting('ipaddress')
server = host + ":" + port
remove some redundant code calls and do a shouldstop call in the add loop
2015-04-04 23:59:15 +00:00
#downloadUtils = DownloadUtils()
#userid = downloadUtils.getUserId()
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
timeInfo = API().getTimeInfo(MBitem)
userData=API().getUserData(MBitem)
people = API().getPeople(MBitem)
genre = API().getGenre(MBitem)
studios = API().getStudios(MBitem)
mediaStreams=API().getMediaStreams(MBitem)
Refactor 4/4
2015-03-17 19:02:42 +00:00
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
thumbPath = API().getArtwork(MBitem, "Primary")
playurl = PlayUtils().getPlayUrl(server, MBitem["Id"], MBitem)
#make sure that the path always ends with a slash
solve encoding issue with playurl
2015-04-03 21:39:18 +00:00
path = utils.convertEncoding(playurl + "/")
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
if MBitem.get("DateCreated") != None:
dateadded = MBitem["DateCreated"].replace("T"," ")
dateadded = dateadded.replace(".0000000Z","")
else:
dateadded = None
speed improvements
2015-04-04 17:20:48 +00:00
#connection = utils.KodiSQL()
#cursor = connection.cursor()
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
fixed actors in tvshows
2015-04-01 21:28:19 +00:00
#create the tv show path
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
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))
fixed actors in tvshows
2015-04-01 21:28:19 +00:00
#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))
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
runtime = int(timeInfo.get('Duration'))*60
plot = utils.convertEncoding(API().getOverview(MBitem))
thumb = "<thumb>" + API().getArtwork(MBitem, "Primary") + "</thumb>"
fanart = "<fanart>" + API().getArtwork(MBitem, "Backdrop") + "</fanart>"
title = utils.convertEncoding(MBitem["Name"])
sorttitle = utils.convertEncoding(MBitem["SortName"])
if MBitem.get("CriticRating") != None:
rating = int(MBitem.get("CriticRating"))/10
else:
rating = None
#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, c06, c09, c11, c12, c15) values(?, ?, ?, ?, ?, ?, ?, ?, ?)"
cursor.execute(pathsql, (showid, title, plot, rating, thumb, title, fanart, MBitem["Id"], sorttitle))
#link the path
pathsql="insert into tvshowlinkpath(idShow,idPath) values(?, ?)"
cursor.execute(pathsql, (showid,pathid))
try:
connection.commit()
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","Added TV Show to Kodi Library",MBitem["Id"] + " - " + MBitem["Name"])
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
except:
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","Error adding tvshow to Kodi Library",MBitem["Id"] + " - " + MBitem["Name"])
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
actionPerformed = False
Refactor 4/4
2015-03-17 19:02:42 +00:00
fix delete TV Show
2015-04-02 08:00:58 +00:00
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)
fix delete TV Show
2015-04-02 08:00:58 +00:00
utils.logMsg("deleting tvshow from Kodi library ", "Emby ID : " + 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:
fix delete TV Show
2015-04-02 08:00:58 +00:00
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))
fixes for season artwork
2015-03-20 15:16:39 +00:00
speed improvements
2015-04-04 17:20:48 +00:00
def updateSeasons(self,MBitem, KodiItem, connection, cursor):
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
#use sqlite to set the season details because no method in API available for this
fixed season artwork
2015-03-20 15:58:46 +00:00
tvshowid = KodiItem["tvshowid"]
support for isengard sqlite and **experimental** mysql support
2015-03-26 21:35:11 +00:00
speed improvements
2015-04-04 17:20:48 +00:00
#connection = utils.KodiSQL()
#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"):
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
cursor.execute("SELECT idSeason as seasonid FROM seasons WHERE idShow = ? and season = ?",(tvshowid,season["IndexNumber"]))
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, season["IndexNumber"]))
#insert artwork
if API().getArtwork(season, "Thumb") != "":
cursor.execute("INSERT into art(media_id, media_type, type, url) values(?, ?, ?, ?)", (seasonid,"season","landscape",API().getArtwork(season, "Thumb")))
if API().getArtwork(season, "Primary") != "":
cursor.execute("INSERT into art(media_id, media_type, type, url) values(?, ?, ?, ?)", (seasonid,"season","poster",API().getArtwork(season, "Primary")))
if API().getArtwork(season, "Banner") != "":
cursor.execute("INSERT into art(media_id, media_type, type, url) values(?, ?, ?, ?)", (seasonid,"season","banner",API().getArtwork(season, "Banner")))
fixed season artwork
2015-03-20 15:58:46 +00:00
connection.commit()
use uniqueid to check of en episode is already in the DB
2015-04-04 23:32:42 +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
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","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()
speed improvements
2015-04-04 17:20:48 +00:00
def setKodiFilename(self, id, oldFileName, newFileName, fileType, mbId, connection, cursor):
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
#use sqlite to set the filename in DB -- needed to avoid problems with resumepoints etc
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
#return True if any action is performed, False if no action is performed
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
#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
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
actionPerformed = False
fixes for the path sync actions not working yet --> episodes updates are skipped ?
2015-03-29 16:20:02 +00:00
oldFileName = utils.convertEncoding(oldFileName)
newFileName = utils.convertEncoding(newFileName)
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
fixes for the path sync actions not working yet --> episodes updates are skipped ?
2015-03-29 16:20:02 +00:00
# only perform changes if the path actually differs
if oldFileName != newFileName:
remove sleep actions from actors and write filename to db
2015-04-04 13:39:27 +00:00
# xbmc.sleep(sleepVal)
speed improvements
2015-04-04 17:20:48 +00:00
#connection = utils.KodiSQL()
#cursor = connection.cursor()
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","setting filename in kodi db..." + fileType + ": " + str(id))
utils.logMsg("Emby","old filename -->" + oldFileName)
utils.logMsg("Emby","new filename -->" + newFileName)
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
one more fix for tvshow paths
2015-04-01 07:28:22 +00:00
######### PROCESS TV SHOW ############
fix for transcoding
2015-04-01 19:32:25 +00:00
if fileType == "tvshow":
if newFileName.startswith("http"):
newFileName = "plugin://plugin.video.emby/"
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
#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
fixes for the path sync actions not working yet --> episodes updates are skipped ?
2015-03-29 16:20:02 +00:00
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
if newFileName.startswith("http"):
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
#transcoding or play from stream
path = "plugin://plugin.video.emby/"
fix for transcoding
2015-04-01 19:32:25 +00:00
filename = "plugin://plugin.video.emby/?id=" + mbId + "&mode=play"
changes to use native kodi db for inserts
2015-04-01 19:07:29 +00:00
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,"")
fixes for the path sync actions not working yet --> episodes updates are skipped ?
2015-03-29 16:20:02 +00:00
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
######### PROCESS EPISODE ############
if fileType == "episode":
fixes for the path sync actions not working yet --> episodes updates are skipped ?
2015-03-29 16:20:02 +00:00
one more fix for tvshow paths
2015-04-01 07:28:22 +00:00
#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
fixes for the path sync actions not working yet --> episodes updates are skipped ?
2015-03-29 16:20:02 +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, strContent, strScraper, noUpdate) values(?, ?, ?, ?, ?)"
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
cursor.execute(pathsql, (pathid,path,None,None,1))
one more fix for tvshow paths
2015-04-01 07:28:22 +00:00
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
#set the new path and filename to the episode
cursor.execute("UPDATE files SET idPath = ?, strFilename = ? WHERE idFile = ?", (pathid,filename,fileid))
fixes for the path sync actions not working yet --> episodes updates are skipped ?
2015-03-29 16:20:02 +00:00
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
######### 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
fixes for the path sync actions not working yet --> episodes updates are skipped ?
2015-03-29 16:20:02 +00:00
cursor.execute("UPDATE files SET strFilename = ? WHERE idFile = ?", (filename,fileid))
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
#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))
FINAL fix for the doubled episodes. Yeah for real now :-)
2015-03-29 22:43:53 +00:00
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
try:
connection.commit()
actionPerformed = True
except:
changed log statements to remove MB Sync
2015-04-02 18:34:47 +00:00
utils.logMsg("Emby","Error setting filename in kodi db for: " + fileType + ": " + str(id))
changes to prevent doubled paths and support for transcoding
2015-03-31 21:21:51 +00:00
actionPerformed = False
return actionPerformed
use native kodi playback instead of setresolvedurl workaround
2015-03-28 16:42:38 +00:00
speed improvements
2015-04-04 17:20:48 +00:00
def AddActorsToMedia(self, KodiItem, people, mediatype, connection, cursor):
Refactor 4/4
2015-03-17 19:02:42 +00:00
#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")
remove sleep actions from actors and write filename to db
2015-04-04 13:39:27 +00:00
# xbmc.sleep(sleepVal)
speed improvements
2015-04-04 17:20:48 +00:00
#connection = utils.KodiSQL()
#cursor = connection.cursor()
dont try to do any DB access if it is not needed in Update Actors
2015-03-20 00:21:43 +00:00
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
fix actor images: don't need the thumb prefix after all
2015-04-02 17:19:29 +00:00
Thumb = downloadUtils.imageUrl(person.get("Id"), "Primary", 0, 400, 400)
Refactor 4/4
2015-03-17 19:02:42 +00:00
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()
use uniqueid to check of en episode is already in the DB
2015-04-04 23:32:42 +00:00
#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
speed improvements
2015-04-04 17:20:48 +00:00
def addBoxsetToKodiLibrary(self, boxset, connection, cursor):
add support for box sets
2015-03-24 16:47:26 +00:00
#use sqlite to set add the set
speed improvements
2015-04-04 17:20:48 +00:00
#connection = utils.KodiSQL()
#cursor = connection.cursor()
add support for box sets
2015-03-24 16:47:26 +00:00
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()
speed improvements
2015-04-04 17:20:48 +00:00
#cursor.close()
add support for box sets
2015-03-24 16:47:26 +00:00
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:
remove some redundant code calls and do a shouldstop call in the add loop
2015-04-04 23:59:15 +00:00
WriteKodiDB().updateProperty(kodiMovie,"set",strSet,"movie",True)
Reference in a new issue Copy permalink