diff --git a/resources/lib/api.py b/resources/lib/api.py
index d0ad8594..cc639408 100644
--- a/resources/lib/api.py
+++ b/resources/lib/api.py
@@ -37,15 +37,6 @@ class API(object):
else:
favorite = userdata['IsFavorite']
likes = userdata.get('Likes')
- # Userrating is based on likes and favourite
- if favorite:
- user_rating = 5
- elif likes:
- user_rating = 3
- elif likes is False:
- user_rating = 0
- else:
- user_rating = 1
last_played = userdata.get('LastPlayedDate')
if last_played:
@@ -72,8 +63,7 @@ class API(object):
'PlayCount': playcount,
'Played': played,
'LastPlayedDate': last_played,
- 'Resume': resume,
- 'UserRating': user_rating
+ 'Resume': resume
}
def get_people(self):
diff --git a/resources/lib/entrypoint.py b/resources/lib/entrypoint.py
index 4ecaa1f3..90877379 100644
--- a/resources/lib/entrypoint.py
+++ b/resources/lib/entrypoint.py
@@ -548,7 +548,7 @@ def refreshPlaylist():
sound=False)
except Exception as e:
- log.error("Refresh playlists/nodes failed: %s" % e)
+ log.exception("Refresh playlists/nodes failed: %s" % e)
dialog.notification(
heading=lang(29999),
message=lang(33070),
@@ -698,7 +698,7 @@ def createListItemFromEmbyItem(item,art=artwork.Artwork(),doUtils=downloadutils.
playcount = 0
rating = item.get('CommunityRating')
- if not rating: rating = userdata['UserRating']
+ if not rating: rating = 0
# Populate the extradata list and artwork
extradata = {
diff --git a/resources/lib/kodidb_functions.py b/resources/lib/kodidb_functions.py
index fe76b5e2..fc6cdb12 100644
--- a/resources/lib/kodidb_functions.py
+++ b/resources/lib/kodidb_functions.py
@@ -25,769 +25,6 @@ class Kodidb_Functions():
self.cursor = cursor
self.artwork = artwork.Artwork()
-
-
- def addPath(self, path):
-
- query = ' '.join((
-
- "SELECT idPath",
- "FROM path",
- "WHERE strPath = ?"
- ))
- self.cursor.execute(query, (path,))
- try:
- pathid = self.cursor.fetchone()[0]
- except TypeError:
- self.cursor.execute("select coalesce(max(idPath),0) from path")
- pathid = self.cursor.fetchone()[0] + 1
- query = (
- '''
- INSERT INTO path(
- idPath, strPath)
-
- VALUES (?, ?)
- '''
- )
- self.cursor.execute(query, (pathid, path))
-
- return pathid
-
- def getPath(self, path):
-
- query = ' '.join((
-
- "SELECT idPath",
- "FROM path",
- "WHERE strPath = ?"
- ))
- self.cursor.execute(query, (path,))
- try:
- pathid = self.cursor.fetchone()[0]
- except TypeError:
- pathid = None
-
- return pathid
-
- def addFile(self, filename, pathid):
-
- query = ' '.join((
-
- "SELECT idFile",
- "FROM files",
- "WHERE strFilename = ?",
- "AND idPath = ?"
- ))
- self.cursor.execute(query, (filename, pathid,))
- try:
- fileid = self.cursor.fetchone()[0]
- except TypeError:
- self.cursor.execute("select coalesce(max(idFile),0) from files")
- fileid = self.cursor.fetchone()[0] + 1
- query = (
- '''
- INSERT INTO files(
- idFile, strFilename)
-
- VALUES (?, ?)
- '''
- )
- self.cursor.execute(query, (fileid, filename))
-
- return fileid
-
- def getFile(self, fileid):
-
- query = ' '.join((
-
- "SELECT strFilename",
- "FROM files",
- "WHERE idFile = ?"
- ))
- self.cursor.execute(query, (fileid,))
- try:
- filename = self.cursor.fetchone()[0]
- except TypeError:
- filename = ""
-
- return filename
-
- def removeFile(self, path, filename):
-
- pathid = self.getPath(path)
-
- if pathid is not None:
- query = ' '.join((
-
- "DELETE FROM files",
- "WHERE idPath = ?",
- "AND strFilename = ?"
- ))
- self.cursor.execute(query, (pathid, filename,))
-
- def addCountries(self, kodiid, countries, mediatype):
-
- if self.kodiversion in (15, 16, 17):
- # Kodi Isengard, Jarvis, Krypton
- for country in countries:
- query = ' '.join((
-
- "SELECT country_id",
- "FROM country",
- "WHERE name = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (country,))
-
- try:
- country_id = self.cursor.fetchone()[0]
-
- except TypeError:
- # Country entry does not exists
- self.cursor.execute("select coalesce(max(country_id),0) from country")
- country_id = self.cursor.fetchone()[0] + 1
-
- query = "INSERT INTO country(country_id, name) values(?, ?)"
- self.cursor.execute(query, (country_id, country))
- log.debug("Add country to media, processing: %s" % country)
-
- finally: # Assign country to content
- query = (
- '''
- INSERT OR REPLACE INTO country_link(
- country_id, media_id, media_type)
-
- VALUES (?, ?, ?)
- '''
- )
- self.cursor.execute(query, (country_id, kodiid, mediatype))
- else:
- # Kodi Helix
- for country in countries:
- query = ' '.join((
-
- "SELECT idCountry",
- "FROM country",
- "WHERE strCountry = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (country,))
-
- try:
- idCountry = self.cursor.fetchone()[0]
-
- except TypeError:
- # Country entry does not exists
- self.cursor.execute("select coalesce(max(idCountry),0) from country")
- idCountry = self.cursor.fetchone()[0] + 1
-
- query = "INSERT INTO country(idCountry, strCountry) values(?, ?)"
- self.cursor.execute(query, (idCountry, country))
- log.debug("Add country to media, processing: %s" % country)
-
- finally:
- # Only movies have a country field
- if "movie" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO countrylinkmovie(
- idCountry, idMovie)
-
- VALUES (?, ?)
- '''
- )
- self.cursor.execute(query, (idCountry, kodiid))
-
- def addPeople(self, kodiid, people, mediatype):
-
- castorder = 1
- for person in people:
-
- name = person['Name']
- person_type = person['Type']
- thumb = person['imageurl']
-
- # Kodi Isengard, Jarvis, Krypton
- if self.kodiversion in (15, 16, 17):
- query = ' '.join((
-
- "SELECT actor_id",
- "FROM actor",
- "WHERE name = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (name,))
-
- try:
- actorid = self.cursor.fetchone()[0]
-
- except TypeError:
- # Cast entry does not exists
- self.cursor.execute("select coalesce(max(actor_id),0) from actor")
- actorid = self.cursor.fetchone()[0] + 1
-
- query = "INSERT INTO actor(actor_id, name) values(?, ?)"
- self.cursor.execute(query, (actorid, name))
- log.debug("Add people to media, processing: %s" % name)
-
- finally:
- # Link person to content
- if "Actor" in person_type:
- role = person.get('Role')
- query = (
- '''
- INSERT OR REPLACE INTO actor_link(
- actor_id, media_id, media_type, role, cast_order)
-
- VALUES (?, ?, ?, ?, ?)
- '''
- )
- self.cursor.execute(query, (actorid, kodiid, mediatype, role, castorder))
- castorder += 1
-
- elif "Director" in person_type:
- query = (
- '''
- INSERT OR REPLACE INTO director_link(
- actor_id, media_id, media_type)
-
- VALUES (?, ?, ?)
- '''
- )
- self.cursor.execute(query, (actorid, kodiid, mediatype))
-
- elif person_type in ("Writing", "Writer"):
- query = (
- '''
- INSERT OR REPLACE INTO writer_link(
- actor_id, media_id, media_type)
-
- VALUES (?, ?, ?)
- '''
- )
- self.cursor.execute(query, (actorid, kodiid, mediatype))
-
- elif "Artist" in person_type:
- query = (
- '''
- INSERT OR REPLACE INTO actor_link(
- actor_id, media_id, media_type)
-
- VALUES (?, ?, ?)
- '''
- )
- self.cursor.execute(query, (actorid, kodiid, mediatype))
- # Kodi Helix
- else:
- query = ' '.join((
-
- "SELECT idActor",
- "FROM actors",
- "WHERE strActor = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (name,))
-
- try:
- actorid = self.cursor.fetchone()[0]
-
- except TypeError:
- # Cast entry does not exists
- self.cursor.execute("select coalesce(max(idActor),0) from actors")
- actorid = self.cursor.fetchone()[0] + 1
-
- query = "INSERT INTO actors(idActor, strActor) values(?, ?)"
- self.cursor.execute(query, (actorid, name))
- log.debug("Add people to media, processing: %s" % name)
-
- finally:
- # Link person to content
- if "Actor" in person_type:
- role = person.get('Role')
-
- if "movie" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO actorlinkmovie(
- idActor, idMovie, strRole, iOrder)
-
- VALUES (?, ?, ?, ?)
- '''
- )
- elif "tvshow" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO actorlinktvshow(
- idActor, idShow, strRole, iOrder)
-
- VALUES (?, ?, ?, ?)
- '''
- )
- elif "episode" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO actorlinkepisode(
- idActor, idEpisode, strRole, iOrder)
-
- VALUES (?, ?, ?, ?)
- '''
- )
- else: return # Item is invalid
-
- self.cursor.execute(query, (actorid, kodiid, role, castorder))
- castorder += 1
-
- elif "Director" in person_type:
- if "movie" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO directorlinkmovie(
- idDirector, idMovie)
-
- VALUES (?, ?)
- '''
- )
- elif "tvshow" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO directorlinktvshow(
- idDirector, idShow)
-
- VALUES (?, ?)
- '''
- )
- elif "musicvideo" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO directorlinkmusicvideo(
- idDirector, idMVideo)
-
- VALUES (?, ?)
- '''
- )
-
- elif "episode" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO directorlinkepisode(
- idDirector, idEpisode)
-
- VALUES (?, ?)
- '''
- )
- else: return # Item is invalid
-
- self.cursor.execute(query, (actorid, kodiid))
-
- elif person_type in ("Writing", "Writer"):
- if "movie" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO writerlinkmovie(
- idWriter, idMovie)
-
- VALUES (?, ?)
- '''
- )
- elif "episode" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO writerlinkepisode(
- idWriter, idEpisode)
-
- VALUES (?, ?)
- '''
- )
- else: return # Item is invalid
-
- self.cursor.execute(query, (actorid, kodiid))
-
- elif "Artist" in person_type:
- query = (
- '''
- INSERT OR REPLACE INTO artistlinkmusicvideo(
- idArtist, idMVideo)
-
- VALUES (?, ?)
- '''
- )
- self.cursor.execute(query, (actorid, kodiid))
-
- # Add person image to art table
- if thumb:
- arttype = person_type.lower()
-
- if "writing" in arttype:
- arttype = "writer"
-
- self.artwork.add_update_art(thumb, actorid, arttype, "thumb", self.cursor)
-
- def addGenres(self, kodiid, genres, mediatype):
-
-
- # Kodi Isengard, Jarvis, Krypton
- if self.kodiversion in (15, 16, 17):
- # Delete current genres for clean slate
- query = ' '.join((
-
- "DELETE FROM genre_link",
- "WHERE media_id = ?",
- "AND media_type = ?"
- ))
- self.cursor.execute(query, (kodiid, mediatype,))
-
- # Add genres
- for genre in genres:
-
- query = ' '.join((
-
- "SELECT genre_id",
- "FROM genre",
- "WHERE name = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (genre,))
-
- try:
- genre_id = self.cursor.fetchone()[0]
-
- except TypeError:
- # Create genre in database
- self.cursor.execute("select coalesce(max(genre_id),0) from genre")
- genre_id = self.cursor.fetchone()[0] + 1
-
- query = "INSERT INTO genre(genre_id, name) values(?, ?)"
- self.cursor.execute(query, (genre_id, genre))
- log.debug("Add Genres to media, processing: %s" % genre)
-
- finally:
- # Assign genre to item
- query = (
- '''
- INSERT OR REPLACE INTO genre_link(
- genre_id, media_id, media_type)
-
- VALUES (?, ?, ?)
- '''
- )
- self.cursor.execute(query, (genre_id, kodiid, mediatype))
- else:
- # Kodi Helix
- # Delete current genres for clean slate
- if "movie" in mediatype:
- self.cursor.execute("DELETE FROM genrelinkmovie WHERE idMovie = ?", (kodiid,))
- elif "tvshow" in mediatype:
- self.cursor.execute("DELETE FROM genrelinktvshow WHERE idShow = ?", (kodiid,))
- elif "musicvideo" in mediatype:
- self.cursor.execute("DELETE FROM genrelinkmusicvideo WHERE idMVideo = ?", (kodiid,))
-
- # Add genres
- for genre in genres:
-
- query = ' '.join((
-
- "SELECT idGenre",
- "FROM genre",
- "WHERE strGenre = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (genre,))
-
- try:
- idGenre = self.cursor.fetchone()[0]
-
- except TypeError:
- # Create genre in database
- self.cursor.execute("select coalesce(max(idGenre),0) from genre")
- idGenre = self.cursor.fetchone()[0] + 1
-
- query = "INSERT INTO genre(idGenre, strGenre) values(?, ?)"
- self.cursor.execute(query, (idGenre, genre))
- log.debug("Add Genres to media, processing: %s" % genre)
-
- finally:
- # Assign genre to item
- if "movie" in mediatype:
- query = (
- '''
- INSERT OR REPLACE into genrelinkmovie(
- idGenre, idMovie)
-
- VALUES (?, ?)
- '''
- )
- elif "tvshow" in mediatype:
- query = (
- '''
- INSERT OR REPLACE into genrelinktvshow(
- idGenre, idShow)
-
- VALUES (?, ?)
- '''
- )
- elif "musicvideo" in mediatype:
- query = (
- '''
- INSERT OR REPLACE into genrelinkmusicvideo(
- idGenre, idMVideo)
-
- VALUES (?, ?)
- '''
- )
- else: return # Item is invalid
-
- self.cursor.execute(query, (idGenre, kodiid))
-
- def addStudios(self, kodiid, studios, mediatype):
-
- for studio in studios:
-
- if self.kodiversion in (15, 16, 17):
- # Kodi Isengard, Jarvis, Krypton
- query = ' '.join((
-
- "SELECT studio_id",
- "FROM studio",
- "WHERE name = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (studio,))
- try:
- studioid = self.cursor.fetchone()[0]
-
- except TypeError:
- # Studio does not exists.
- self.cursor.execute("select coalesce(max(studio_id),0) from studio")
- studioid = self.cursor.fetchone()[0] + 1
-
- query = "INSERT INTO studio(studio_id, name) values(?, ?)"
- self.cursor.execute(query, (studioid, studio))
- log.debug("Add Studios to media, processing: %s" % studio)
-
- finally: # Assign studio to item
- query = (
- '''
- INSERT OR REPLACE INTO studio_link(
- studio_id, media_id, media_type)
-
- VALUES (?, ?, ?)
- ''')
- self.cursor.execute(query, (studioid, kodiid, mediatype))
- else:
- # Kodi Helix
- query = ' '.join((
-
- "SELECT idstudio",
- "FROM studio",
- "WHERE strstudio = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (studio,))
- try:
- studioid = self.cursor.fetchone()[0]
-
- except TypeError:
- # Studio does not exists.
- self.cursor.execute("select coalesce(max(idstudio),0) from studio")
- studioid = self.cursor.fetchone()[0] + 1
-
- query = "INSERT INTO studio(idstudio, strstudio) values(?, ?)"
- self.cursor.execute(query, (studioid, studio))
- log.debug("Add Studios to media, processing: %s" % studio)
-
- finally: # Assign studio to item
- if "movie" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO studiolinkmovie(idstudio, idMovie)
- VALUES (?, ?)
- ''')
- elif "musicvideo" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO studiolinkmusicvideo(idstudio, idMVideo)
- VALUES (?, ?)
- ''')
- elif "tvshow" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO studiolinktvshow(idstudio, idShow)
- VALUES (?, ?)
- ''')
- elif "episode" in mediatype:
- query = (
- '''
- INSERT OR REPLACE INTO studiolinkepisode(idstudio, idEpisode)
- VALUES (?, ?)
- ''')
- self.cursor.execute(query, (studioid, kodiid))
-
- def addStreams(self, fileid, streamdetails, runtime):
-
- # First remove any existing entries
- self.cursor.execute("DELETE FROM streamdetails WHERE idFile = ?", (fileid,))
- if streamdetails:
- # Video details
- for videotrack in streamdetails['video']:
- query = (
- '''
- INSERT INTO streamdetails(
- idFile, iStreamType, strVideoCodec, fVideoAspect,
- iVideoWidth, iVideoHeight, iVideoDuration ,strStereoMode)
-
- VALUES (?, ?, ?, ?, ?, ?, ?, ?)
- '''
- )
- self.cursor.execute(query, (fileid, 0, videotrack['codec'],
- videotrack['aspect'], videotrack['width'], videotrack['height'],
- runtime ,videotrack['video3DFormat']))
-
- # Audio details
- for audiotrack in streamdetails['audio']:
- query = (
- '''
- INSERT INTO streamdetails(
- idFile, iStreamType, strAudioCodec, iAudioChannels, strAudioLanguage)
-
- VALUES (?, ?, ?, ?, ?)
- '''
- )
- self.cursor.execute(query, (fileid, 1, audiotrack['codec'],
- audiotrack['channels'], audiotrack['language']))
-
- # Subtitles details
- for subtitletrack in streamdetails['subtitle']:
- query = (
- '''
- INSERT INTO streamdetails(
- idFile, iStreamType, strSubtitleLanguage)
-
- VALUES (?, ?, ?)
- '''
- )
- self.cursor.execute(query, (fileid, 2, subtitletrack))
-
- def addPlaystate(self, fileid, resume_seconds, total_seconds, playcount, dateplayed):
-
- # Delete existing resume point
- query = ' '.join((
-
- "DELETE FROM bookmark",
- "WHERE idFile = ?"
- ))
- self.cursor.execute(query, (fileid,))
-
- # Set watched count
- query = ' '.join((
-
- "UPDATE files",
- "SET playCount = ?, lastPlayed = ?",
- "WHERE idFile = ?"
- ))
- self.cursor.execute(query, (playcount, dateplayed, fileid))
-
- # Set the resume bookmark
- if resume_seconds:
- self.cursor.execute("select coalesce(max(idBookmark),0) from bookmark")
- bookmarkId = self.cursor.fetchone()[0] + 1
- query = (
- '''
- INSERT INTO bookmark(
- idBookmark, idFile, timeInSeconds, totalTimeInSeconds, player, type)
-
- VALUES (?, ?, ?, ?, ?, ?)
- '''
- )
- self.cursor.execute(query, (bookmarkId, fileid, resume_seconds, total_seconds,
- "DVDPlayer", 1))
-
- def addTags(self, kodiid, tags, mediatype):
-
- # First, delete any existing tags associated to the id
- if self.kodiversion in (15, 16, 17):
- # Kodi Isengard, Jarvis, Krypton
- query = ' '.join((
-
- "DELETE FROM tag_link",
- "WHERE media_id = ?",
- "AND media_type = ?"
- ))
- self.cursor.execute(query, (kodiid, mediatype))
- else:
- # Kodi Helix
- query = ' '.join((
-
- "DELETE FROM taglinks",
- "WHERE idMedia = ?",
- "AND media_type = ?"
- ))
- self.cursor.execute(query, (kodiid, mediatype))
-
- # Add tags
- log.debug("Adding Tags: %s" % tags)
- for tag in tags:
- self.addTag(kodiid, tag, mediatype)
-
- def addTag(self, kodiid, tag, mediatype):
-
- if self.kodiversion in (15, 16, 17):
- # Kodi Isengard, Jarvis, Krypton
- query = ' '.join((
-
- "SELECT tag_id",
- "FROM tag",
- "WHERE name = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (tag,))
- try:
- tag_id = self.cursor.fetchone()[0]
-
- except TypeError:
- # Create the tag, because it does not exist
- tag_id = self.createTag(tag)
- log.debug("Adding tag: %s" % tag)
-
- finally:
- # Assign tag to item
- query = (
- '''
- INSERT OR REPLACE INTO tag_link(
- tag_id, media_id, media_type)
-
- VALUES (?, ?, ?)
- '''
- )
- self.cursor.execute(query, (tag_id, kodiid, mediatype))
- else:
- # Kodi Helix
- query = ' '.join((
-
- "SELECT idTag",
- "FROM tag",
- "WHERE strTag = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (tag,))
- try:
- tag_id = self.cursor.fetchone()[0]
-
- except TypeError:
- # Create the tag
- tag_id = self.createTag(tag)
- log.debug("Adding tag: %s" % tag)
-
- finally:
- # Assign tag to item
- query = (
- '''
- INSERT OR REPLACE INTO taglinks(
- idTag, idMedia, media_type)
-
- VALUES (?, ?, ?)
- '''
- )
- self.cursor.execute(query, (tag_id, kodiid, mediatype))
def createTag(self, name):
@@ -836,7 +73,7 @@ class Kodidb_Functions():
return tag_id
def updateTag(self, oldtag, newtag, kodiid, mediatype):
-
+ # TODO: Move to video nodes eventually
log.debug("Updating: %s with %s for %s: %s" % (oldtag, newtag, mediatype, kodiid))
if self.kodiversion in (15, 16, 17):
@@ -885,263 +122,3 @@ class Kodidb_Functions():
"AND idTag = ?"
))
self.cursor.execute(query, (kodiid, mediatype, oldtag,))
-
- def removeTag(self, kodiid, tagname, mediatype):
-
- if self.kodiversion in (15, 16, 17):
- # Kodi Isengard, Jarvis, Krypton
- query = ' '.join((
-
- "SELECT tag_id",
- "FROM tag",
- "WHERE name = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (tagname,))
- try:
- tag_id = self.cursor.fetchone()[0]
- except TypeError:
- return
- else:
- query = ' '.join((
-
- "DELETE FROM tag_link",
- "WHERE media_id = ?",
- "AND media_type = ?",
- "AND tag_id = ?"
- ))
- self.cursor.execute(query, (kodiid, mediatype, tag_id,))
- else:
- # Kodi Helix
- query = ' '.join((
-
- "SELECT idTag",
- "FROM tag",
- "WHERE strTag = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (tagname,))
- try:
- tag_id = self.cursor.fetchone()[0]
- except TypeError:
- return
- else:
- query = ' '.join((
-
- "DELETE FROM taglinks",
- "WHERE idMedia = ?",
- "AND media_type = ?",
- "AND idTag = ?"
- ))
- self.cursor.execute(query, (kodiid, mediatype, tag_id,))
-
- def createBoxset(self, boxsetname):
-
- log.debug("Adding boxset: %s" % boxsetname)
- query = ' '.join((
-
- "SELECT idSet",
- "FROM sets",
- "WHERE strSet = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (boxsetname,))
- try:
- setid = self.cursor.fetchone()[0]
-
- except TypeError:
- self.cursor.execute("select coalesce(max(idSet),0) from sets")
- setid = self.cursor.fetchone()[0] + 1
-
- query = "INSERT INTO sets(idSet, strSet) values(?, ?)"
- self.cursor.execute(query, (setid, boxsetname))
-
- return setid
-
- def assignBoxset(self, setid, movieid):
-
- query = ' '.join((
-
- "UPDATE movie",
- "SET idSet = ?",
- "WHERE idMovie = ?"
- ))
- self.cursor.execute(query, (setid, movieid,))
-
- def removefromBoxset(self, movieid):
-
- query = ' '.join((
-
- "UPDATE movie",
- "SET idSet = null",
- "WHERE idMovie = ?"
- ))
- self.cursor.execute(query, (movieid,))
-
- def addSeason(self, showid, seasonnumber, season_name=None):
-
- query = ' '.join((
-
- "SELECT idSeason",
- "FROM seasons",
- "WHERE idShow = ?",
- "AND season = ?"
- ))
- self.cursor.execute(query, (showid, seasonnumber,))
- try:
- seasonid = self.cursor.fetchone()[0]
- except TypeError:
- self.cursor.execute("select coalesce(max(idSeason),0) from seasons")
- seasonid = self.cursor.fetchone()[0] + 1
- query = "INSERT INTO seasons(idSeason, idShow, season) values(?, ?, ?)"
- self.cursor.execute(query, (seasonid, showid, seasonnumber))
-
- if self.kodiversion in (16,17) and season_name is not None:
- query = "UPDATE seasons SET name = ? WHERE idSeason = ?"
- self.cursor.execute(query, (season_name, seasonid))
-
- return seasonid
-
- def addArtist(self, name, musicbrainz):
-
- query = ' '.join((
-
- "SELECT idArtist, strArtist",
- "FROM artist",
- "WHERE strMusicBrainzArtistID = ?"
- ))
- self.cursor.execute(query, (musicbrainz,))
- try:
- result = self.cursor.fetchone()
- artistid = result[0]
- artistname = result[1]
-
- except TypeError:
-
- query = ' '.join((
-
- "SELECT idArtist",
- "FROM artist",
- "WHERE strArtist = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (name,))
- try:
- artistid = self.cursor.fetchone()[0]
- except TypeError:
- self.cursor.execute("select coalesce(max(idArtist),0) from artist")
- artistid = self.cursor.fetchone()[0] + 1
- query = (
- '''
- INSERT INTO artist(idArtist, strArtist, strMusicBrainzArtistID)
-
- VALUES (?, ?, ?)
- '''
- )
- self.cursor.execute(query, (artistid, name, musicbrainz))
- else:
- if artistname != name:
- query = "UPDATE artist SET strArtist = ? WHERE idArtist = ?"
- self.cursor.execute(query, (name, artistid,))
-
- return artistid
-
- def addAlbum(self, name, musicbrainz):
-
- query = ' '.join((
-
- "SELECT idAlbum",
- "FROM album",
- "WHERE strMusicBrainzAlbumID = ?"
- ))
- self.cursor.execute(query, (musicbrainz,))
- try:
- albumid = self.cursor.fetchone()[0]
- except TypeError:
- # Create the album
- self.cursor.execute("select coalesce(max(idAlbum),0) from album")
- albumid = self.cursor.fetchone()[0] + 1
- if self.kodiversion in (15, 16, 17):
- query = (
- '''
- INSERT INTO album(idAlbum, strAlbum, strMusicBrainzAlbumID, strReleaseType)
-
- VALUES (?, ?, ?, ?)
- '''
- )
- self.cursor.execute(query, (albumid, name, musicbrainz, "album"))
- else: # Helix
- query = (
- '''
- INSERT INTO album(idAlbum, strAlbum, strMusicBrainzAlbumID)
-
- VALUES (?, ?, ?)
- '''
- )
- self.cursor.execute(query, (albumid, name, musicbrainz))
-
- return albumid
-
- def addMusicGenres(self, kodiid, genres, mediatype):
-
- if mediatype == "album":
-
- # Delete current genres for clean slate
- query = ' '.join((
-
- "DELETE FROM album_genre",
- "WHERE idAlbum = ?"
- ))
- self.cursor.execute(query, (kodiid,))
-
- for genre in genres:
- query = ' '.join((
-
- "SELECT idGenre",
- "FROM genre",
- "WHERE strGenre = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (genre,))
- try:
- genreid = self.cursor.fetchone()[0]
- except TypeError:
- # Create the genre
- self.cursor.execute("select coalesce(max(idGenre),0) from genre")
- genreid = self.cursor.fetchone()[0] + 1
- query = "INSERT INTO genre(idGenre, strGenre) values(?, ?)"
- self.cursor.execute(query, (genreid, genre))
-
- query = "INSERT OR REPLACE INTO album_genre(idGenre, idAlbum) values(?, ?)"
- self.cursor.execute(query, (genreid, kodiid))
-
- elif mediatype == "song":
-
- # Delete current genres for clean slate
- query = ' '.join((
-
- "DELETE FROM song_genre",
- "WHERE idSong = ?"
- ))
- self.cursor.execute(query, (kodiid,))
-
- for genre in genres:
- query = ' '.join((
-
- "SELECT idGenre",
- "FROM genre",
- "WHERE strGenre = ?",
- "COLLATE NOCASE"
- ))
- self.cursor.execute(query, (genre,))
- try:
- genreid = self.cursor.fetchone()[0]
- except TypeError:
- # Create the genre
- self.cursor.execute("select coalesce(max(idGenre),0) from genre")
- genreid = self.cursor.fetchone()[0] + 1
- query = "INSERT INTO genre(idGenre, strGenre) values(?, ?)"
- self.cursor.execute(query, (genreid, genre))
-
- query = "INSERT OR REPLACE INTO song_genre(idGenre, idSong) values(?, ?)"
- self.cursor.execute(query, (genreid, kodiid))
\ No newline at end of file
diff --git a/resources/lib/objects/common.py b/resources/lib/objects/_common.py
similarity index 99%
rename from resources/lib/objects/common.py
rename to resources/lib/objects/_common.py
index 60070e01..f4b75d14 100644
--- a/resources/lib/objects/common.py
+++ b/resources/lib/objects/_common.py
@@ -27,7 +27,7 @@ class Items(object):
total = 0
- def __init__(self, **kwargs):
+ def __init__(self):
self.artwork = artwork.Artwork()
self.emby = embyserver.Read_EmbyServer()
diff --git a/resources/lib/objects/_kodi_common.py b/resources/lib/objects/_kodi_common.py
new file mode 100644
index 00000000..028a0a4f
--- /dev/null
+++ b/resources/lib/objects/_kodi_common.py
@@ -0,0 +1,822 @@
+# -*- coding: utf-8 -*-
+
+##################################################################################################
+
+import logging
+
+import xbmc
+
+import api
+import artwork
+
+##################################################################################################
+
+log = logging.getLogger("EMBY."+__name__)
+
+##################################################################################################
+
+
+class KodiItems(object):
+
+
+ def __init__(self):
+
+ self.artwork = artwork.Artwork()
+ self.kodi_version = int(xbmc.getInfoLabel('System.BuildVersion')[:2])
+
+ def create_entry_path(self):
+ self.cursor.execute("select coalesce(max(idPath),0) from path")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_file(self):
+ self.cursor.execute("select coalesce(max(idFile),0) from files")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_person(self):
+ self.cursor.execute("select coalesce(max(actor_id),0) from actor")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_genre(self):
+ self.cursor.execute("select coalesce(max(genre_id),0) from genre")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_studio(self):
+ self.cursor.execute("select coalesce(max(studio_id),0) from studio")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_bookmark(self):
+ self.cursor.execute("select coalesce(max(idBookmark),0) from bookmark")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_tag(self):
+ self.cursor.execute("select coalesce(max(tag_id),0) from tag")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def add_path(self, path):
+
+ path_id = self.get_path(path)
+ if path_id is None:
+ # Create a new entry
+ path_id = self.create_entry_path()
+ query = (
+ '''
+ INSERT INTO path(idPath, strPath)
+
+ VALUES (?, ?)
+ '''
+ )
+ self.cursor.execute(query, (path_id, path))
+
+ return path_id
+
+ def get_path(self, path):
+
+ query = ' '.join((
+
+ "SELECT idPath",
+ "FROM path",
+ "WHERE strPath = ?"
+ ))
+ self.cursor.execute(query, (path,))
+ try:
+ path_id = self.cursor.fetchone()[0]
+ except TypeError:
+ path_id = None
+
+ return path_id
+
+ def update_path(self, path_id, path, media_type, scraper):
+
+ query = ' '.join((
+
+ "UPDATE path",
+ "SET strPath = ?, strContent = ?, strScraper = ?, noUpdate = ?",
+ "WHERE idPath = ?"
+ ))
+ self.cursor.execute(query, (path, media_type, scraper, 1, path_id))
+
+ def remove_path(self, path_id):
+ kodicursor.execute("DELETE FROM path WHERE idPath = ?", (path_id,))
+
+ def add_file(self, filename, path_id):
+
+ query = ' '.join((
+
+ "SELECT idFile",
+ "FROM files",
+ "WHERE strFilename = ?",
+ "AND idPath = ?"
+ ))
+ self.cursor.execute(query, (filename, path_id,))
+ try:
+ file_id = self.cursor.fetchone()[0]
+ except TypeError:
+ # Create a new entry
+ file_id = self.create_entry_file()
+ query = (
+ '''
+ INSERT INTO files(idFile, idPath, strFilename)
+
+ VALUES (?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (file_id, path_id, filename))
+
+ return file_id
+
+ def update_file(self, file_id, filename, path_id, date_added):
+
+ query = ' '.join((
+
+ "UPDATE files",
+ "SET idPath = ?, strFilename = ?, dateAdded = ?",
+ "WHERE idFile = ?"
+ ))
+ self.cursor.execute(query, (path_id, filename, date_added, file_id))
+
+ def remove_file(self, path, filename):
+
+ path_id = self.get_path(path)
+ if path_id is not None:
+
+ query = ' '.join((
+
+ "DELETE FROM files",
+ "WHERE idPath = ?",
+ "AND strFilename = ?"
+ ))
+ self.cursor.execute(query, (path_id, filename,))
+
+ def get_filename(self, file_id):
+
+ query = ' '.join((
+
+ "SELECT strFilename",
+ "FROM files",
+ "WHERE idFile = ?"
+ ))
+ self.cursor.execute(query, (file_id,))
+ try:
+ filename = self.cursor.fetchone()[0]
+ except TypeError:
+ filename = ""
+
+ return filename
+
+ def add_people(self, kodi_id, people, media_type):
+
+ def add_thumbnail(person_id, person, type_):
+
+ thumbnail = person['imageurl']
+ if thumbnail:
+
+ art = type_.lower()
+ if "writing" in art:
+ art = "writer"
+
+ self.artwork.add_update_art(thumbnail, person_id, art, "thumb", self.cursor)
+
+ def add_link(link_type, person_id, kodi_id, media_type):
+
+ query = (
+ "INSERT OR REPLACE INTO " + link_type + "(actor_id, media_id, media_type)"
+ "VALUES (?, ?, ?)"
+ )
+ self.cursor.execute(query, (person_id, kodi_id, media_type))
+
+ cast_order = 1
+
+ if self.kodi_version > 14:
+
+ for person in people:
+
+ name = person['Name']
+ type_ = person['Type']
+ person_id = self._get_person(name)
+
+ # Link person to content
+ if type_ == "Actor":
+ role = person.get('Role')
+ query = (
+ '''
+ INSERT OR REPLACE INTO actor_link(
+ actor_id, media_id, media_type, role, cast_order)
+
+ VALUES (?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (person_id, kodi_id, media_type, role, cast_order))
+ cast_order += 1
+
+ elif type_ == "Director":
+ add_link("director_link", person_id, kodi_id, media_type)
+
+ elif type_ in ("Writing", "Writer"):
+ add_link("writer_link", person_id, kodi_id, media_type)
+
+ elif type_ == "Artist":
+ add_link("actor_link", person_id, kodi_id, media_type)
+
+ add_thumbnail(person_id, person, type_)
+ else:
+ # TODO: Remove Helix code when Krypton is RC
+ for person in people:
+ name = person['Name']
+ type_ = person['Type']
+
+ query = ' '.join((
+
+ "SELECT idActor",
+ "FROM actors",
+ "WHERE strActor = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (name,))
+
+ try:
+ person_id = self.cursor.fetchone()[0]
+
+ except TypeError:
+ # Cast entry does not exists
+ self.cursor.execute("select coalesce(max(idActor),0) from actors")
+ person_id = self.cursor.fetchone()[0] + 1
+
+ query = "INSERT INTO actors(idActor, strActor) values(?, ?)"
+ self.cursor.execute(query, (person_id, name))
+ log.debug("Add people to media, processing: %s", name)
+
+ finally:
+ # Link person to content
+ if type_ == "Actor":
+ role = person.get('Role')
+
+ if media_type == "movie":
+ query = (
+ '''
+ INSERT OR REPLACE INTO actorlinkmovie(
+ idActor, idMovie, strRole, iOrder)
+
+ VALUES (?, ?, ?, ?)
+ '''
+ )
+ elif media_type == "tvshow":
+ query = (
+ '''
+ INSERT OR REPLACE INTO actorlinktvshow(
+ idActor, idShow, strRole, iOrder)
+
+ VALUES (?, ?, ?, ?)
+ '''
+ )
+ elif media_type == "episode":
+ query = (
+ '''
+ INSERT OR REPLACE INTO actorlinkepisode(
+ idActor, idEpisode, strRole, iOrder)
+
+ VALUES (?, ?, ?, ?)
+ '''
+ )
+ else: return # Item is invalid
+
+ self.cursor.execute(query, (person_id, kodi_id, role, cast_order))
+ cast_order += 1
+
+ elif type_ == "Director":
+ if media_type == "movie":
+ query = (
+ '''
+ INSERT OR REPLACE INTO directorlinkmovie(idDirector, idMovie)
+ VALUES (?, ?)
+ '''
+ )
+ elif media_type == "tvshow":
+ query = (
+ '''
+ INSERT OR REPLACE INTO directorlinktvshow(idDirector, idShow)
+ VALUES (?, ?)
+ '''
+ )
+ elif media_type == "musicvideo":
+ query = (
+ '''
+ INSERT OR REPLACE INTO directorlinkmusicvideo(idDirector, idMVideo)
+ VALUES (?, ?)
+ '''
+ )
+ elif media_type == "episode":
+ query = (
+ '''
+ INSERT OR REPLACE INTO directorlinkepisode(idDirector, idEpisode)
+ VALUES (?, ?)
+ '''
+ )
+ else: return # Item is invalid
+
+ self.cursor.execute(query, (person_id, kodi_id))
+
+ elif type_ in ("Writing", "Writer"):
+ if media_type == "movie":
+ query = (
+ '''
+ INSERT OR REPLACE INTO writerlinkmovie(
+ idWriter, idMovie)
+
+ VALUES (?, ?)
+ '''
+ )
+ elif media_type == "episode":
+ query = (
+ '''
+ INSERT OR REPLACE INTO writerlinkepisode(
+ idWriter, idEpisode)
+
+ VALUES (?, ?)
+ '''
+ )
+ else: return # Item is invalid
+
+ self.cursor.execute(query, (person_id, kodi_id))
+
+ elif type_ == "Artist":
+ query = (
+ '''
+ INSERT OR REPLACE INTO artistlinkmusicvideo(
+ idArtist, idMVideo)
+
+ VALUES (?, ?)
+ '''
+ )
+ self.cursor.execute(query, (person_id, kodi_id))
+
+ add_thumbnail(person_id, person, type_)
+
+ def _add_person(self, name):
+
+ person_id = self.create_entry_person()
+ query = "INSERT INTO actor(actor_id, name) values(?, ?)"
+ self.cursor.execute(query, (person_id, name))
+ log.debug("Add people to media, processing: %s", name)
+
+ return person_id
+
+ def _get_person(self, name):
+
+ query = ' '.join((
+
+ "SELECT actor_id",
+ "FROM actor",
+ "WHERE name = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (name,))
+
+ try:
+ person_id = self.cursor.fetchone()[0]
+ except TypeError:
+ person_id = self._add_person(name)
+
+ return person_id
+
+ def add_genres(self, kodi_id, genres, media_type):
+
+ if self.kodi_version > 14:
+ # Delete current genres for clean slate
+ query = ' '.join((
+
+ "DELETE FROM genre_link",
+ "WHERE media_id = ?",
+ "AND media_type = ?"
+ ))
+ self.cursor.execute(query, (kodi_id, media_type,))
+
+ # Add genres
+ for genre in genres:
+
+ genre_id = self._get_genre(genre)
+ query = (
+ '''
+ INSERT OR REPLACE INTO genre_link(
+ genre_id, media_id, media_type)
+
+ VALUES (?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (genre_id, kodi_id, media_type))
+ else:
+ # TODO: Remove Helix code when Krypton is RC
+ # Delete current genres for clean slate
+ if media_type == "movie":
+ self.cursor.execute("DELETE FROM genrelinkmovie WHERE idMovie = ?", (kodi_id,))
+ elif media_type == "tvshow":
+ self.cursor.execute("DELETE FROM genrelinktvshow WHERE idShow = ?", (kodi_id,))
+ elif media_type == "musicvideo":
+ self.cursor.execute("DELETE FROM genrelinkmusicvideo WHERE idMVideo = ?", (kodi_id,))
+
+ # Add genres
+ for genre in genres:
+
+ query = ' '.join((
+
+ "SELECT idGenre",
+ "FROM genre",
+ "WHERE strGenre = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (genre,))
+
+ try:
+ genre_id = self.cursor.fetchone()[0]
+
+ except TypeError:
+ # Create genre in database
+ self.cursor.execute("select coalesce(max(idGenre),0) from genre")
+ genre_id = self.cursor.fetchone()[0] + 1
+
+ query = "INSERT INTO genre(idGenre, strGenre) values(?, ?)"
+ self.cursor.execute(query, (genre_id, genre))
+ log.debug("Add Genres to media, processing: %s", genre)
+
+ finally:
+ # Assign genre to item
+ if media_type == "movie":
+ query = (
+ '''
+ INSERT OR REPLACE into genrelinkmovie(idGenre, idMovie)
+ VALUES (?, ?)
+ '''
+ )
+ elif media_type == "tvshow":
+ query = (
+ '''
+ INSERT OR REPLACE into genrelinktvshow(idGenre, idShow)
+ VALUES (?, ?)
+ '''
+ )
+ elif media_type == "musicvideo":
+ query = (
+ '''
+ INSERT OR REPLACE into genrelinkmusicvideo(idGenre, idMVideo)
+ VALUES (?, ?)
+ '''
+ )
+ else: return # Item is invalid
+
+ self.cursor.execute(query, (genre_id, kodi_id))
+
+ def _add_genre(self, genre):
+
+ genre_id = self.create_entry_genre()
+ query = "INSERT INTO genre(genre_id, name) values(?, ?)"
+ self.cursor.execute(query, (genre_id, genre))
+ log.debug("Add Genres to media, processing: %s", genre)
+
+ return genre_id
+
+ def _get_genre(self, genre):
+
+ query = ' '.join((
+
+ "SELECT genre_id",
+ "FROM genre",
+ "WHERE name = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (genre,))
+
+ try:
+ genre_id = self.cursor.fetchone()[0]
+ except TypeError:
+ genre_id = self._add_genre(genre)
+
+ return genre_id
+
+ def add_studios(self, kodi_id, studios, media_type):
+
+ if self.kodi_version > 14:
+
+ for studio in studios:
+
+ studio_id = self._get_studio(studio)
+ query = (
+ '''
+ INSERT OR REPLACE INTO studio_link(
+ studio_id, media_id, media_type)
+
+ VALUES (?, ?, ?)
+ ''')
+ self.cursor.execute(query, (studio_id, kodi_id, media_type))
+ else:
+ # TODO: Remove Helix code when Krypton is RC
+ for studio in studios:
+
+ query = ' '.join((
+
+ "SELECT idstudio",
+ "FROM studio",
+ "WHERE strstudio = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (studio,))
+ try:
+ studio_id = self.cursor.fetchone()[0]
+
+ except TypeError:
+ # Studio does not exists.
+ self.cursor.execute("select coalesce(max(idstudio),0) from studio")
+ studio_id = self.cursor.fetchone()[0] + 1
+
+ query = "INSERT INTO studio(idstudio, strstudio) values(?, ?)"
+ self.cursor.execute(query, (studio_id, studio))
+ log.debug("Add Studios to media, processing: %s", studio)
+
+ finally: # Assign studio to item
+ if media_type == "movie":
+ query = (
+ '''
+ INSERT OR REPLACE INTO studiolinkmovie(idstudio, idMovie)
+ VALUES (?, ?)
+ ''')
+ elif media_type == "musicvideo":
+ query = (
+ '''
+ INSERT OR REPLACE INTO studiolinkmusicvideo(idstudio, idMVideo)
+ VALUES (?, ?)
+ ''')
+ elif media_type == "tvshow":
+ query = (
+ '''
+ INSERT OR REPLACE INTO studiolinktvshow(idstudio, idShow)
+ VALUES (?, ?)
+ ''')
+ elif media_type == "episode":
+ query = (
+ '''
+ INSERT OR REPLACE INTO studiolinkepisode(idstudio, idEpisode)
+ VALUES (?, ?)
+ ''')
+ self.cursor.execute(query, (studio_id, kodi_id))
+
+ def _add_studio(self, studio):
+
+ studio_id = self.create_entry_studio()
+ query = "INSERT INTO studio(studio_id, name) values(?, ?)"
+ self.cursor.execute(query, (studio_id, studio))
+ log.debug("Add Studios to media, processing: %s", studio)
+
+ return studio_id
+
+ def _get_studio(self, studio):
+
+ query = ' '.join((
+
+ "SELECT studio_id",
+ "FROM studio",
+ "WHERE name = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (studio,))
+ try:
+ studio_id = self.cursor.fetchone()[0]
+ except TypeError:
+ studio_id = self._add_studio(studio)
+
+ return studio_id
+
+ def add_streams(self, file_id, streams, runtime):
+ # First remove any existing entries
+ self.cursor.execute("DELETE FROM streamdetails WHERE idFile = ?", (file_id,))
+ if streams:
+ # Video details
+ for track in streams['video']:
+ query = (
+ '''
+ INSERT INTO streamdetails(
+ idFile, iStreamType, strVideoCodec, fVideoAspect,
+ iVideoWidth, iVideoHeight, iVideoDuration ,strStereoMode)
+
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (file_id, 0, track['codec'], track['aspect'],
+ track['width'], track['height'], runtime,
+ track['video3DFormat']))
+ # Audio details
+ for track in streams['audio']:
+ query = (
+ '''
+ INSERT INTO streamdetails(
+ idFile, iStreamType, strAudioCodec, iAudioChannels, strAudioLanguage)
+
+ VALUES (?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (file_id, 1, track['codec'], track['channels'],
+ track['language']))
+ # Subtitles details
+ for track in streams['subtitle']:
+ query = (
+ '''
+ INSERT INTO streamdetails(idFile, iStreamType, strSubtitleLanguage)
+ VALUES (?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (file_id, 2, track))
+
+ def add_playstate(self, file_id, resume, total, playcount, date_played):
+
+ # Delete existing resume point
+ self.cursor.execute("DELETE FROM bookmark WHERE idFile = ?", (file_id,))
+ # Set watched count
+ self.set_playcount(file_id, playcount, date_played)
+
+ if resume:
+ bookmark_id = self.create_entry_bookmark()
+ query = (
+ '''
+ INSERT INTO bookmark(
+ idBookmark, idFile, timeInSeconds, totalTimeInSeconds, player, type)
+
+ VALUES (?, ?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (bookmark_id, file_id, resume, total, "DVDPlayer", 1))
+
+ def set_playcount(self, file_id, playcount, date_played):
+
+ query = ' '.join((
+
+ "UPDATE files",
+ "SET playCount = ?, lastPlayed = ?",
+ "WHERE idFile = ?"
+ ))
+ self.cursor.execute(query, (playcount, date_played, file_id))
+
+ def add_tags(self, kodi_id, tags, media_type):
+
+ if self.kodi_version > 14:
+
+ query = ' '.join((
+
+ "DELETE FROM tag_link",
+ "WHERE media_id = ?",
+ "AND media_type = ?"
+ ))
+ self.cursor.execute(query, (kodi_id, media_type))
+
+ # Add tags
+ log.debug("Adding Tags: %s", tags)
+ for tag in tags:
+ tag_id = self.get_tag(kodi_id, tag, media_type)
+ else:
+ # TODO: Remove Helix code when Krypton is RC
+ query = ' '.join((
+
+ "DELETE FROM taglinks",
+ "WHERE idMedia = ?",
+ "AND media_type = ?"
+ ))
+ self.cursor.execute(query, (kodi_id, media_type))
+
+ # Add tags
+ log.debug("Adding Tags: %s", tags)
+ for tag in tags:
+ tag_id = self.get_tag_old(kodi_id, tag, media_type)
+
+ def _add_tag(self, tag):
+
+ tag_id = self.create_entry_tag()
+ query = "INSERT INTO tag(tag_id, name) values(?, ?)"
+ self.cursor.execute(query, (tag_id, tag))
+ log.debug("Create tag_id: %s name: %s", tag_id, tag)
+
+ return tag_id
+
+ def get_tag(self, kodi_id, tag, media_type):
+
+ if self.kodi_version > 14:
+
+ query = ' '.join((
+
+ "SELECT tag_id",
+ "FROM tag",
+ "WHERE name = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (tag,))
+ try:
+ tag_id = self.cursor.fetchone()[0]
+ except TypeError:
+ tag_id = self._add_tag(tag)
+
+ query = (
+ '''
+ INSERT OR REPLACE INTO tag_link(tag_id, media_id, media_type)
+ VALUES (?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (tag_id, kodi_id, media_type))
+ else:
+ # TODO: Remove Helix code when Krypton is RC
+ tag_id = self.get_tag_old(kodi_id, tag, media_type)
+
+ return tag_id
+
+ def get_tag_old(self, kodi_id, tag, media_type):
+ # TODO: Remove Helix code when Krypton is RC
+ query = ' '.join((
+
+ "SELECT idTag",
+ "FROM tag",
+ "WHERE strTag = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (tag,))
+ try:
+ tag_id = self.cursor.fetchone()[0]
+
+ except TypeError:
+ # Create the tag
+ self.cursor.execute("select coalesce(max(idTag),0) from tag")
+ tag_id = self.cursor.fetchone()[0] + 1
+
+ query = "INSERT INTO tag(idTag, strTag) values(?, ?)"
+ self.cursor.execute(query, (tag_id, name))
+ log.debug("Create idTag: %s name: %s", tag_id, name)
+
+ finally:
+ # Assign tag to item
+ query = (
+ '''
+ INSERT OR REPLACE INTO taglinks(
+ idTag, idMedia, media_type)
+
+ VALUES (?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (tag_id, kodi_id, media_type))
+
+ return tag_id
+
+ def remove_tag(self, kodi_id, tag, media_type):
+
+ if self.kodi_version > 14:
+
+ query = ' '.join((
+
+ "SELECT tag_id",
+ "FROM tag",
+ "WHERE name = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (tag,))
+ try:
+ tag_id = self.cursor.fetchone()[0]
+ except TypeError:
+ return
+ else:
+ query = ' '.join((
+
+ "DELETE FROM tag_link",
+ "WHERE media_id = ?",
+ "AND media_type = ?",
+ "AND tag_id = ?"
+ ))
+ self.cursor.execute(query, (kodi_id, media_type, tag_id,))
+ else:
+ # TODO: Remove Helix code when Krypton is RC
+ query = ' '.join((
+
+ "SELECT idTag",
+ "FROM tag",
+ "WHERE strTag = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (tag,))
+ try:
+ tag_id = self.cursor.fetchone()[0]
+ except TypeError:
+ return
+ else:
+ query = ' '.join((
+
+ "DELETE FROM taglinks",
+ "WHERE idMedia = ?",
+ "AND media_type = ?",
+ "AND idTag = ?"
+ ))
+ self.cursor.execute(query, (kodi_id, media_type, tag_id,))
diff --git a/resources/lib/objects/_kodi_movies.py b/resources/lib/objects/_kodi_movies.py
new file mode 100644
index 00000000..38b78922
--- /dev/null
+++ b/resources/lib/objects/_kodi_movies.py
@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+
+##################################################################################################
+
+import logging
+
+from _kodi_common import KodiItems
+
+##################################################################################################
+
+log = logging.getLogger("EMBY."+__name__)
+
+##################################################################################################
+
+
+class KodiMovies(KodiItems):
+
+
+ def __init__(self, cursor):
+ self.cursor = cursor
+
+ KodiItems.__init__(self)
+
+ def create_entry(self):
+ self.cursor.execute("select coalesce(max(idMovie),0) from movie")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_set(self):
+ self.cursor.execute("select coalesce(max(idSet),0) from sets")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_country(self):
+ self.cursor.execute("select coalesce(max(country_id),0) from country")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def get_movie(self, kodi_id):
+
+ query = "SELECT * FROM movie WHERE idMovie = ?"
+ self.cursor.execute(query, (kodi_id,))
+ try:
+ kodi_id = self.cursor.fetchone()[0]
+ except TypeError:
+ kodi_id = None
+
+ return kodi_id
+
+ def add_movie(self, *args):
+
+ query = (
+ '''
+ INSERT INTO movie(
+ idMovie, idFile, c00, c01, c02, c03, c04, c05, c06, c07,
+ c09, c10, c11, c12, c14, c15, c16, c18, c19, c21)
+
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (args))
+
+ def add_movie_17(self, *args):
+ # Create the movie entry
+ query = (
+ '''
+ INSERT INTO movie(
+ idMovie, idFile, c00, c01, c02, c03, c04, c05, c06, c07,
+ c09, c10, c11, c12, c14, c15, c16, c18, c19, c21, premiered)
+
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (args))
+
+ def update_movie(self, *args):
+
+ query = ' '.join((
+
+ "UPDATE movie",
+ "SET c00 = ?, c01 = ?, c02 = ?, c03 = ?, c04 = ?, c05 = ?, c06 = ?,",
+ "c07 = ?, c09 = ?, c10 = ?, c11 = ?, c12 = ?, c14 = ?, c15 = ?,",
+ "c16 = ?, c18 = ?, c19 = ?, c21 = ?",
+ "WHERE idMovie = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def update_movie_17(self, *args):
+
+ query = ' '.join((
+
+ "UPDATE movie",
+ "SET c00 = ?, c01 = ?, c02 = ?, c03 = ?, c04 = ?, c05 = ?, c06 = ?,",
+ "c07 = ?, c09 = ?, c10 = ?, c11 = ?, c12 = ?, c14 = ?, c15 = ?,",
+ "c16 = ?, c18 = ?, c19 = ?, c21 = ?, premiered = ?",
+ "WHERE idMovie = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def remove_movie(self, kodi_id, file_id):
+ self.cursor.execute("DELETE FROM movie WHERE idMovie = ?", (kodi_id,))
+ self.cursor.execute("DELETE FROM files WHERE idFile = ?", (file_id,))
+
+ def add_countries(self, kodi_id, countries):
+
+ if self.kodi_version > 14:
+
+ for country in countries:
+ country_id = self._get_country(country)
+
+ query = (
+ '''
+ INSERT OR REPLACE INTO country_link(country_id, media_id, media_type)
+ VALUES (?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (country_id, kodi_id, "movie"))
+ else:
+ # TODO: Remove Helix code when Krypton is RC
+ for country in countries:
+ query = ' '.join((
+
+ "SELECT idCountry",
+ "FROM country",
+ "WHERE strCountry = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (country,))
+
+ try:
+ country_id = self.cursor.fetchone()[0]
+ except TypeError:
+ # Create a new entry
+ self.cursor.execute("select coalesce(max(idCountry),0) from country")
+ country_id = self.cursor.fetchone()[0] + 1
+
+ query = "INSERT INTO country(idCountry, strCountry) values(?, ?)"
+ self.cursor.execute(query, (country_id, country))
+ log.debug("Add country to media, processing: %s", country)
+
+ query = (
+ '''
+ INSERT OR REPLACE INTO countrylinkmovie(idCountry, idMovie)
+ VALUES (?, ?)
+ '''
+ )
+ self.cursor.execute(query, (country_id, kodi_id))
+
+ def _add_country(self, country):
+
+ country_id = self.create_entry_country()
+ query = "INSERT INTO country(country_id, name) values(?, ?)"
+ self.cursor.execute(query, (country_id, country))
+ log.debug("Add country to media, processing: %s", country)
+
+ return country_id
+
+ def _get_country(self, country):
+
+ query = ' '.join((
+
+ "SELECT country_id",
+ "FROM country",
+ "WHERE name = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (country,))
+ try:
+ country_id = self.cursor.fetchone()[0]
+ except TypeError:
+ country_id = self._add_country(country)
+
+ return country_id
+
+ def add_boxset(self, boxset):
+
+ query = ' '.join((
+
+ "SELECT idSet",
+ "FROM sets",
+ "WHERE strSet = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (boxset,))
+ try:
+ set_id = self.cursor.fetchone()[0]
+ except TypeError:
+ set_id = self._add_boxset(boxset)
+
+ return set_id
+
+ def _add_boxset(self, boxset):
+
+ set_id = self.create_entry_set()
+ query = "INSERT INTO sets(idSet, strSet) values(?, ?)"
+ self.cursor.execute(query, (set_id, boxset))
+ log.debug("Adding boxset: %s", boxset)
+
+ return set_id
+
+ def set_boxset(self, set_id, movie_id):
+
+ query = ' '.join((
+
+ "UPDATE movie",
+ "SET idSet = ?",
+ "WHERE idMovie = ?"
+ ))
+ self.cursor.execute(query, (set_id, movie_id,))
+
+ def remove_from_boxset(self, movie_id):
+
+ query = ' '.join((
+
+ "UPDATE movie",
+ "SET idSet = null",
+ "WHERE idMovie = ?"
+ ))
+ self.cursor.execute(query, (movie_id,))
+
+ def remove_boxset(self, set_id):
+ self.cursor.execute("DELETE FROM sets WHERE idSet = ?", (kodi_id,))
diff --git a/resources/lib/objects/_kodi_music.py b/resources/lib/objects/_kodi_music.py
new file mode 100644
index 00000000..88210355
--- /dev/null
+++ b/resources/lib/objects/_kodi_music.py
@@ -0,0 +1,406 @@
+# -*- coding: utf-8 -*-
+
+##################################################################################################
+
+import logging
+
+from _kodi_common import KodiItems
+
+##################################################################################################
+
+log = logging.getLogger("EMBY."+__name__)
+
+##################################################################################################
+
+
+class KodiMusic(KodiItems):
+
+
+ def __init__(self, cursor):
+ self.cursor = cursor
+
+ KodiItems.__init__(self)
+
+ def create_entry(self):
+ self.cursor.execute("select coalesce(max(idArtist),0) from artist")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_album(self):
+ self.cursor.execute("select coalesce(max(idAlbum),0) from album")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_song(self):
+ self.cursor.execute("select coalesce(max(idSong),0) from song")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_genre(self):
+ self.cursor.execute("select coalesce(max(idGenre),0) from genre")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def update_path(self, path_id, path):
+
+ query = "UPDATE path SET strPath = ? WHERE idPath = ?"
+ self.cursor.execute(query, (path, path_id))
+
+ def add_role(self):
+ query = (
+ '''
+ INSERT OR REPLACE INTO role(idRole, strRole)
+ VALUES (?, ?)
+ '''
+ )
+ self.cursor.execute(query, (1, 'Composer'))
+
+ def get_artist(self, name, musicbrainz):
+
+ query = ' '.join((
+
+ "SELECT idArtist, strArtist",
+ "FROM artist",
+ "WHERE strMusicBrainzArtistID = ?"
+ ))
+ self.cursor.execute(query, (musicbrainz,))
+ try:
+ result = self.cursor.fetchone()
+ artist_id = result[0]
+ artist_name = result[1]
+ except TypeError:
+ artist_id = self._add_artist(name, musicbrainz)
+ else:
+ if artist_name != name:
+ self.update_artist_name(artist_id, name)
+
+ return artist_id
+
+ def _add_artist(self, name, musicbrainz):
+
+ query = ' '.join((
+ # Safety check, when musicbrainz does not exist
+ "SELECT idArtist",
+ "FROM artist",
+ "WHERE strArtist = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (name,))
+ try:
+ artist_id = self.cursor.fetchone()[0]
+ except TypeError:
+ artist_id = self.create_entry()
+ query = (
+ '''
+ INSERT INTO artist(idArtist, strArtist, strMusicBrainzArtistID)
+ VALUES (?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (artist_id, name, musicbrainz))
+
+ return artist_id
+
+ def update_artist_name(self, kodi_id, name):
+
+ query = "UPDATE artist SET strArtist = ? WHERE idArtist = ?"
+ self.cursor.execute(query, (name, kodi_id,))
+
+ def update_artist_16(self, *args):
+ query = ' '.join((
+
+ "UPDATE artist",
+ "SET strGenres = ?, strBiography = ?, strImage = ?, strFanart = ?,",
+ "lastScraped = ?",
+ "WHERE idArtist = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def update_artist(self, *args):
+ query = ' '.join((
+
+ "UPDATE artist",
+ "SET strGenres = ?, strBiography = ?, strImage = ?, strFanart = ?,",
+ "lastScraped = ?, dateAdded = ?",
+ "WHERE idArtist = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def link_artist(self, kodi_id, album_id, name):
+ query = (
+ '''
+ INSERT OR REPLACE INTO album_artist(idArtist, idAlbum, strArtist)
+ VALUES (?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (kodi_id, album_id, name))
+
+ def add_discography(self, kodi_id, album, year):
+ query = (
+ '''
+ INSERT OR REPLACE INTO discography(idArtist, strAlbum, strYear)
+ VALUES (?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (kodi_id, album, year))
+
+ def get_album(self, name, musicbrainz):
+
+ query = ' '.join((
+
+ "SELECT idAlbum",
+ "FROM album",
+ "WHERE strMusicBrainzAlbumID = ?"
+ ))
+ self.cursor.execute(query, (musicbrainz,))
+ try:
+ album_id = self.cursor.fetchone()[0]
+ except TypeError:
+ album_id = self._add_album(name, musicbrainz)
+
+ return album_id
+
+ def _add_album(self, name, musicbrainz):
+
+ album_id = self.create_entry_album()
+ if self.kodi_version > 14:
+ query = (
+ '''
+ INSERT INTO album(idAlbum, strAlbum, strMusicBrainzAlbumID, strReleaseType)
+ VALUES (?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (album_id, name, musicbrainz, "album"))
+ else:
+ # TODO: Remove Helix code when Krypton is RC
+ query = (
+ '''
+ INSERT INTO album(idAlbum, strAlbum, strMusicBrainzAlbumID)
+ VALUES (?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (album_id, name, musicbrainz))
+
+ return album_id
+
+ def update_album(self, *args):
+ query = ' '.join((
+
+ "UPDATE album",
+ "SET strArtists = ?, iYear = ?, strGenres = ?, strReview = ?, strImage = ?,",
+ "iRating = ?, lastScraped = ?, strReleaseType = ?",
+ "WHERE idAlbum = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def update_album_17(self, *args):
+ query = ' '.join((
+
+ "UPDATE album",
+ "SET strArtists = ?, iYear = ?, strGenres = ?, strReview = ?, strImage = ?,",
+ "iUserrating = ?, lastScraped = ?, strReleaseType = ?",
+ "WHERE idAlbum = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def update_album_15(self, *args):
+ query = ' '.join((
+
+ "UPDATE album",
+ "SET strArtists = ?, iYear = ?, strGenres = ?, strReview = ?, strImage = ?,",
+ "iRating = ?, lastScraped = ?, dateAdded = ?, strReleaseType = ?",
+ "WHERE idAlbum = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def update_album_14(self, *args):
+ # TODO: Remove Helix code when Krypton is RC
+ query = ' '.join((
+
+ "UPDATE album",
+ "SET strArtists = ?, iYear = ?, strGenres = ?, strReview = ?, strImage = ?,",
+ "iRating = ?, lastScraped = ?, dateAdded = ?",
+ "WHERE idAlbum = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def get_album_artist(self, album_id, artists):
+
+ query = ' '.join((
+
+ "SELECT strArtists",
+ "FROM album",
+ "WHERE idAlbum = ?"
+ ))
+ self.cursor.execute(query, (album_id,))
+ try:
+ curr_artists = self.cursor.fetchone()[0]
+ except TypeError:
+ return
+
+ if curr_artists != artists:
+ self._update_album_artist(album_id, artists)
+
+ def _update_album_artist(self, album_id, artists):
+
+ query = "UPDATE album SET strArtists = ? WHERE idAlbum = ?"
+ self.cursor.execute(query, (artists, album_id))
+
+ def add_single(self, *args):
+ query = (
+ '''
+ INSERT INTO album(idAlbum, strGenres, iYear, strReleaseType)
+
+ VALUES (?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (args))
+
+ def add_single_15(self, *args):
+ query = (
+ '''
+ INSERT INTO album(idAlbum, strGenres, iYear, dateAdded, strReleaseType)
+
+ VALUES (?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (albumid, args))
+
+ def add_single_14(self, *args):
+ # TODO: Remove Helix code when Krypton is RC
+ query = (
+ '''
+ INSERT INTO album(idAlbum, strGenres, iYear, dateAdded)
+
+ VALUES (?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (albumid, genre, year, dateadded))
+
+ def add_song(self, *args):
+ query = (
+ '''
+ INSERT INTO song(
+ idSong, idAlbum, idPath, strArtists, strGenres, strTitle, iTrack,
+ iDuration, iYear, strFileName, strMusicBrainzTrackID, iTimesPlayed, lastplayed,
+ rating)
+
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (args))
+
+ def update_song(self, *args):
+ query = ' '.join((
+
+ "UPDATE song",
+ "SET idAlbum = ?, strArtists = ?, strGenres = ?, strTitle = ?, iTrack = ?,",
+ "iDuration = ?, iYear = ?, strFilename = ?, iTimesPlayed = ?, lastplayed = ?,",
+ "rating = ?, comment = ?",
+ "WHERE idSong = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def link_song_artist(self, kodi_id, song_id, index, artist):
+
+ if self.kodi_version > 16:
+ query = (
+ '''
+ INSERT OR REPLACE INTO song_artist(idArtist, idSong, idRole, iOrder, strArtist)
+ VALUES (?, ?, ?, ?, ?)
+ '''
+ )
+ kodicursor.execute(query, (kodi_id, song_id, 1, index, artist))
+ else:
+ query = (
+ '''
+ INSERT OR REPLACE INTO song_artist(idArtist, idSong, iOrder, strArtist)
+ VALUES (?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (kodi_id, song_id, index, artist))
+
+ def link_song_album(self, song_id, album_id, track, title, duration):
+ query = (
+ '''
+ INSERT OR REPLACE INTO albuminfosong(
+ idAlbumInfoSong, idAlbumInfo, iTrack, strTitle, iDuration)
+
+ VALUES (?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (song_id, album_id, track, title, duration))
+
+ def rate_song(self, kodi_id, playcount, rating, date_played):
+
+ query = "UPDATE song SET iTimesPlayed = ?, lastplayed = ?, rating = ? WHERE idSong = ?"
+ self.cursor.execute(query, (playcount, date_played, rating, kodi_id))
+
+ def add_genres(self, kodi_id, genres, media_type):
+
+ if media_type == "album":
+ # Delete current genres for clean slate
+ query = ' '.join((
+
+ "DELETE FROM album_genre",
+ "WHERE idAlbum = ?"
+ ))
+ self.cursor.execute(query, (kodi_id,))
+
+ for genre in genres:
+
+ genre_id = self.get_genre(genre)
+ query = "INSERT OR REPLACE INTO album_genre(idGenre, idAlbum) values(?, ?)"
+ self.cursor.execute(query, (genre_id, kodi_id))
+
+ elif media_type == "song":
+ # Delete current genres for clean slate
+ query = ' '.join((
+
+ "DELETE FROM song_genre",
+ "WHERE idSong = ?"
+ ))
+ self.cursor.execute(query, (kodi_id,))
+
+ for genre in genres:
+
+ genre_id = self.get_genre(genre)
+ query = "INSERT OR REPLACE INTO song_genre(idGenre, idSong) values(?, ?)"
+ self.cursor.execute(query, (genre_id, kodi_id))
+
+ def get_genre(self, genre):
+
+ query = ' '.join((
+
+ "SELECT idGenre",
+ "FROM genre",
+ "WHERE strGenre = ?",
+ "COLLATE NOCASE"
+ ))
+ self.cursor.execute(query, (genre,))
+ try:
+ genre_id = self.cursor.fetchone()[0]
+ except TypeError:
+ genre_id = self._add_genre(genre)
+
+ return genre_id
+
+ def _add_genre(self, genre):
+
+ genre_id = self.create_entry_genre()
+ query = "INSERT INTO genre(idGenre, strGenre) values(?, ?)"
+ self.cursor.execute(query, (genre_id, genre))
+
+ return genre_id
+
+ def remove_artist(self, kodi_id):
+ self.cursor.execute("DELETE FROM artist WHERE idArtist = ?", (kodi_id,))
+
+ def remove_album(self, kodi_id):
+ self.cursor.execute("DELETE FROM album WHERE idAlbum = ?", (kodi_id,))
+
+ def remove_song(self, kodi_id):
+ self.cursor.execute("DELETE FROM song WHERE idSong = ?", (kodi_id,))
diff --git a/resources/lib/objects/_kodi_musicvideos.py b/resources/lib/objects/_kodi_musicvideos.py
new file mode 100644
index 00000000..729a27fa
--- /dev/null
+++ b/resources/lib/objects/_kodi_musicvideos.py
@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+
+##################################################################################################
+
+import logging
+
+from _kodi_common import KodiItems
+
+##################################################################################################
+
+log = logging.getLogger("EMBY."+__name__)
+
+##################################################################################################
+
+
+class KodiMusicVideos(KodiItems):
+
+
+ def __init__(self, cursor):
+ self.cursor = cursor
+
+ KodiItems.__init__(self)
+
+ def create_entry(self):
+ self.cursor.execute("select coalesce(max(idMVideo),0) from musicvideo")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def get_musicvideo(self, kodi_id):
+
+ query = "SELECT * FROM musicvideo WHERE idMVideo = ?"
+ self.cursor.execute(query, (kodi_id,))
+ try:
+ kodi_id = self.cursor.fetchone()[0]
+ except TypeError:
+ kodi_id = None
+
+ return kodi_id
+
+ def add_musicvideo(self, *args):
+
+ query = (
+ '''
+ INSERT INTO musicvideo(
+ idMVideo, idFile, c00, c04, c05, c06, c07, c08, c09, c10, c11, c12)
+
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (args))
+
+ def update_musicvideo(self, *args):
+
+ query = ' '.join((
+
+ "UPDATE musicvideo",
+ "SET c00 = ?, c04 = ?, c05 = ?, c06 = ?, c07 = ?, c08 = ?, c09 = ?, c10 = ?,",
+ "c11 = ?, c12 = ?"
+ "WHERE idMVideo = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def remove_musicvideo(self, kodi_id, file_id):
+ self.cursor.execute("DELETE FROM musicvideo WHERE idMVideo = ?", (kodi_id,))
+ self.cursor.execute("DELETE FROM files WHERE idFile = ?", (file_id,))
diff --git a/resources/lib/objects/_kodi_tvshows.py b/resources/lib/objects/_kodi_tvshows.py
new file mode 100644
index 00000000..8fe7ad53
--- /dev/null
+++ b/resources/lib/objects/_kodi_tvshows.py
@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+
+##################################################################################################
+
+import logging
+
+from _kodi_common import KodiItems
+
+##################################################################################################
+
+log = logging.getLogger("EMBY."+__name__)
+
+##################################################################################################
+
+
+class KodiTVShows(KodiItems):
+
+
+ def __init__(self, cursor):
+ self.cursor = cursor
+
+ KodiItems.__init__(self)
+
+ def create_entry(self):
+ self.cursor.execute("select coalesce(max(idShow),0) from tvshow")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_season(self):
+ self.cursor.execute("select coalesce(max(idSeason),0) from seasons")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def create_entry_episode(self):
+ self.cursor.execute("select coalesce(max(idEpisode),0) from episode")
+ kodi_id = self.cursor.fetchone()[0] + 1
+
+ return kodi_id
+
+ def get_tvshow(self, kodi_id):
+
+ query = "SELECT * FROM tvshow WHERE idShow = ?"
+ self.cursor.execute(query, (kodi_id,))
+ try:
+ kodi_id = self.cursor.fetchone()[0]
+ except TypeError:
+ kodi_id = None
+
+ return kodi_id
+
+ def get_episode(self, kodi_id):
+
+ query = "SELECT * FROM episode WHERE idEpisode = ?"
+ self.cursor.execute(query, (kodi_id,))
+ try:
+ kodi_id = self.cursor.fetchone()[0]
+ except TypeError:
+ kodi_id = None
+
+ return kodi_id
+
+ def add_tvshow(self, *args):
+
+ query = (
+ '''
+ INSERT INTO tvshow(idShow, c00, c01, c04, c05, c08, c09, c12, c13, c14, c15)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (args))
+
+ def update_tvshow(self, *args):
+
+ query = ' '.join((
+
+ "UPDATE tvshow",
+ "SET c00 = ?, c01 = ?, c04 = ?, c05 = ?, c08 = ?, c09 = ?,",
+ "c12 = ?, c13 = ?, c14 = ?, c15 = ?",
+ "WHERE idShow = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def link_tvshow(self, show_id, path_id):
+ query = "INSERT OR REPLACE INTO tvshowlinkpath(idShow, idPath) values(?, ?)"
+ self.cursor.execute(query, (show_id, path_id))
+
+ def get_season(self, show_id, number, name=None):
+
+ query = ' '.join((
+
+ "SELECT idSeason",
+ "FROM seasons",
+ "WHERE idShow = ?",
+ "AND season = ?"
+ ))
+ self.cursor.execute(query, (show_id, number,))
+ try:
+ season_id = self.cursor.fetchone()[0]
+ except TypeError:
+ season_id = self._add_season(show_id, number)
+
+ if self.kodi_version > 15 and name is not None:
+ query = "UPDATE seasons SET name = ? WHERE idSeason = ?"
+ self.cursor.execute(query, (name, season_id))
+
+ return season_id
+
+ def _add_season(self, show_id, number):
+
+ season_id = self.create_entry_season()
+ query = "INSERT INTO seasons(idSeason, idShow, season) values(?, ?, ?)"
+ self.cursor.execute(query, (season_id, show_id, number))
+
+ return season_id
+
+ def add_episode(self, *args):
+ query = (
+ '''
+ INSERT INTO episode(
+ idEpisode, idFile, c00, c01, c03, c04, c05, c09, c10, c12, c13, c14,
+ idShow, c15, c16)
+
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (args))
+
+ def add_episode_16(self, *args):
+ query = (
+ '''
+ INSERT INTO episode(
+ idEpisode, idFile, c00, c01, c03, c04, c05, c09, c10, c12, c13, c14,
+ idShow, c15, c16, idSeason)
+
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ '''
+ )
+ self.cursor.execute(query, (args))
+
+ def update_episode(self, *args):
+ query = ' '.join((
+
+ "UPDATE episode",
+ "SET c00 = ?, c01 = ?, c03 = ?, c04 = ?, c05 = ?, c09 = ?, c10 = ?,",
+ "c12 = ?, c13 = ?, c14 = ?, c15 = ?, c16 = ?, idShow = ?",
+ "WHERE idEpisode = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def update_episode_16(self, *args):
+ query = ' '.join((
+
+ "UPDATE episode",
+ "SET c00 = ?, c01 = ?, c03 = ?, c04 = ?, c05 = ?, c09 = ?, c10 = ?,",
+ "c12 = ?, c13 = ?, c14 = ?, c15 = ?, c16 = ?, idSeason = ?, idShow = ?",
+ "WHERE idEpisode = ?"
+ ))
+ self.cursor.execute(query, (args))
+
+ def remove_tvshow(self, kodi_id):
+ self.cursor.execute("DELETE FROM tvshow WHERE idShow = ?", (kodi_id,))
+
+ def remove_season(self, kodi_id):
+ self.cursor.execute("DELETE FROM seasons WHERE idSeason = ?", (kodi_id,))
+
+ def remove_episode(self, kodi_id, file_id):
+ self.cursor.execute("DELETE FROM episode WHERE idEpisode = ?", (kodi_id,))
+ self.cursor.execute("DELETE FROM files WHERE idFile = ?", (file_id,))
diff --git a/resources/lib/objects/movies.py b/resources/lib/objects/movies.py
index fdc0f9ee..63540000 100644
--- a/resources/lib/objects/movies.py
+++ b/resources/lib/objects/movies.py
@@ -6,9 +6,9 @@ import logging
import urllib
import api
-import common
import embydb_functions as embydb
-import kodidb_functions as kodidb
+import _kodi_movies
+from _common import Items
from utils import window, settings, language as lang, catch_except
##################################################################################################
@@ -18,7 +18,7 @@ log = logging.getLogger("EMBY."+__name__)
##################################################################################################
-class Movies(common.Items):
+class Movies(Items):
def __init__(self, embycursor, kodicursor, pdialog=None):
@@ -26,12 +26,12 @@ class Movies(common.Items):
self.embycursor = embycursor
self.emby_db = embydb.Embydb_Functions(self.embycursor)
self.kodicursor = kodicursor
- self.kodi_db = kodidb.Kodidb_Functions(self.kodicursor)
+ self.kodi_db = _kodi_movies.KodiMovies(self.kodicursor)
self.pdialog = pdialog
self.new_time = int(settings('newvideotime'))*1000
- common.Items.__init__(self)
+ Items.__init__(self)
def _get_func(self, item_type, action):
@@ -176,7 +176,6 @@ class Movies(common.Items):
@catch_except()
def add_update(self, item, view=None):
# Process single movie
- kodicursor = self.kodicursor
emby_db = self.emby_db
artwork = self.artwork
API = api.API(item)
@@ -196,16 +195,10 @@ class Movies(common.Items):
update_item = False
log.debug("movieid: %s not found", itemid)
# movieid
- kodicursor.execute("select coalesce(max(idMovie),0) from movie")
- movieid = kodicursor.fetchone()[0] + 1
+ movieid = self.kodi_db.create_entry()
else:
- # Verification the item is still in Kodi
- query = "SELECT * FROM movie WHERE idMovie = ?"
- kodicursor.execute(query, (movieid,))
- try:
- kodicursor.fetchone()[0]
- except TypeError:
+ if self.kodi_db.get_movie(movieid) is None:
# item is not found, let's recreate it.
update_item = False
log.info("movieid: %s missing from Kodi, repairing the entry", movieid)
@@ -312,30 +305,15 @@ class Movies(common.Items):
# Update the movie entry
if self.kodi_version > 16:
- query = ' '.join((
-
- "UPDATE movie",
- "SET c00 = ?, c01 = ?, c02 = ?, c03 = ?, c04 = ?, c05 = ?, c06 = ?,",
- "c07 = ?, c09 = ?, c10 = ?, c11 = ?, c12 = ?, c14 = ?, c15 = ?,",
- "c16 = ?, c18 = ?, c19 = ?, c21 = ?, premiered = ?",
- "WHERE idMovie = ?"
- ))
- kodicursor.execute(query, (title, plot, shortplot, tagline, votecount, rating,
- writer, year, imdb, sorttitle, runtime, mpaa, genre,
- director, title, studio, trailer, country, year,
- movieid))
+ self.kodi_db.update_movie_17(title, plot, shortplot, tagline, votecount, rating,
+ writer, year, imdb, sorttitle, runtime, mpaa, genre,
+ director, title, studio, trailer, country, year,
+ movieid)
else:
- query = ' '.join((
+ self.kodi_db.update_movie(title, plot, shortplot, tagline, votecount, rating,
+ writer, year, imdb, sorttitle, runtime, mpaa, genre,
+ director, title, studio, trailer, country, movieid)
- "UPDATE movie",
- "SET c00 = ?, c01 = ?, c02 = ?, c03 = ?, c04 = ?, c05 = ?, c06 = ?,",
- "c07 = ?, c09 = ?, c10 = ?, c11 = ?, c12 = ?, c14 = ?, c15 = ?,",
- "c16 = ?, c18 = ?, c19 = ?, c21 = ?",
- "WHERE idMovie = ?"
- ))
- kodicursor.execute(query, (title, plot, shortplot, tagline, votecount, rating,
- writer, year, imdb, sorttitle, runtime, mpaa, genre,
- director, title, studio, trailer, country, movieid))
# Update the checksum in emby table
emby_db.updateReference(itemid, checksum)
@@ -344,87 +322,57 @@ class Movies(common.Items):
log.info("ADD movie itemid: %s - Title: %s", itemid, title)
# Add path
- pathid = self.kodi_db.addPath(path)
+ pathid = self.kodi_db.add_path(path)
# Add the file
- fileid = self.kodi_db.addFile(filename, pathid)
+ fileid = self.kodi_db.add_file(filename, pathid)
# Create the movie entry
if self.kodi_version > 16:
- query = (
- '''
- INSERT INTO movie(
- idMovie, idFile, c00, c01, c02, c03, c04, c05, c06, c07,
- c09, c10, c11, c12, c14, c15, c16, c18, c19, c21, premiered)
-
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (movieid, fileid, title, plot, shortplot, tagline,
- votecount, rating, writer, year, imdb, sorttitle,
- runtime, mpaa, genre, director, title, studio, trailer,
- country, year))
+ self.kodi_db.add_movie_17(movieid, fileid, title, plot, shortplot, tagline,
+ votecount, rating, writer, year, imdb, sorttitle,
+ runtime, mpaa, genre, director, title, studio, trailer,
+ country, year)
else:
- query = (
- '''
- INSERT INTO movie(
- idMovie, idFile, c00, c01, c02, c03, c04, c05, c06, c07,
- c09, c10, c11, c12, c14, c15, c16, c18, c19, c21)
+ self.kodi_db.add_movie(movieid, fileid, title, plot, shortplot, tagline,
+ votecount, rating, writer, year, imdb, sorttitle,
+ runtime, mpaa, genre, director, title, studio, trailer,
+ country)
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (movieid, fileid, title, plot, shortplot, tagline,
- votecount, rating, writer, year, imdb, sorttitle,
- runtime, mpaa, genre, director, title, studio, trailer,
- country))
# Create the reference in emby table
emby_db.addReference(itemid, movieid, "Movie", "movie", fileid, pathid, None,
checksum, viewid)
# Update the path
- query = ' '.join((
-
- "UPDATE path",
- "SET strPath = ?, strContent = ?, strScraper = ?, noUpdate = ?",
- "WHERE idPath = ?"
- ))
- kodicursor.execute(query, (path, "movies", "metadata.local", 1, pathid))
-
+ self.kodi_db.update_path(pathid, path, "movies", "metadata.local")
# Update the file
- query = ' '.join((
-
- "UPDATE files",
- "SET idPath = ?, strFilename = ?, dateAdded = ?",
- "WHERE idFile = ?"
- ))
- kodicursor.execute(query, (pathid, filename, dateadded, fileid))
+ self.kodi_db.update_file(fileid, filename, pathid, dateadded)
# Process countries
if 'ProductionLocations' in item:
- self.kodi_db.addCountries(movieid, item['ProductionLocations'], "movie")
+ self.kodi_db.add_countries(movieid, item['ProductionLocations'])
# Process cast
people = artwork.get_people_artwork(item['People'])
- self.kodi_db.addPeople(movieid, people, "movie")
+ self.kodi_db.add_people(movieid, people, "movie")
# Process genres
- self.kodi_db.addGenres(movieid, genres, "movie")
+ self.kodi_db.add_genres(movieid, genres, "movie")
# Process artwork
- artwork.add_artwork(artwork.get_all_artwork(item), movieid, "movie", kodicursor)
+ artwork.add_artwork(artwork.get_all_artwork(item), movieid, "movie", self.kodicursor)
# Process stream details
streams = API.get_media_streams()
- self.kodi_db.addStreams(fileid, streams, runtime)
+ self.kodi_db.add_streams(fileid, streams, runtime)
# Process studios
- self.kodi_db.addStudios(movieid, studios, "movie")
+ self.kodi_db.add_studios(movieid, studios, "movie")
# Process tags: view, emby tags
tags = [viewtag]
tags.extend(item['Tags'])
if userdata['Favorite']:
tags.append("Favorite movies")
log.info("Applied tags: %s", tags)
- self.kodi_db.addTags(movieid, tags, "movie")
+ self.kodi_db.add_tags(movieid, tags, "movie")
# Process playstates
resume = API.adjust_resume(userdata['Resume'])
total = round(float(runtime), 6)
- self.kodi_db.addPlaystate(fileid, resume, total, playcount, dateplayed)
+ self.kodi_db.add_playstate(fileid, resume, total, playcount, dateplayed)
return True
@@ -442,7 +390,7 @@ class Movies(common.Items):
setid = emby_dbitem[0]
except TypeError:
- setid = self.kodi_db.createBoxset(title)
+ setid = self.kodi_db.add_boxset(title)
# Process artwork
artwork.add_artwork(artwork.get_all_artwork(boxset), setid, "set", self.kodicursor)
@@ -475,7 +423,7 @@ class Movies(common.Items):
continue
log.info("New addition to boxset %s: %s", title, movie['Name'])
- self.kodi_db.assignBoxset(setid, movieid)
+ self.kodi_db.set_boxset(setid, movieid)
# Update emby reference
emby_db.updateParentId(itemid, setid)
else:
@@ -486,7 +434,7 @@ class Movies(common.Items):
for movie in process:
movieid = current[movie]
log.info("Remove from boxset %s: %s", title, movieid)
- self.kodi_db.removefromBoxset(movieid)
+ self.kodi_db.remove_from_boxset(movieid)
# Update emby reference
emby_db.updateParentId(movie, None)
@@ -516,9 +464,9 @@ class Movies(common.Items):
# Process favorite tags
if userdata['Favorite']:
- self.kodi_db.addTag(movieid, "Favorite movies", "movie")
+ self.kodi_db.get_tag(movieid, "Favorite movies", "movie")
else:
- self.kodi_db.removeTag(movieid, "Favorite movies", "movie")
+ self.kodi_db.remove_tag(movieid, "Favorite movies", "movie")
# Process playstates
playcount = userdata['PlayCount']
@@ -528,13 +476,12 @@ class Movies(common.Items):
log.debug("%s New resume point: %s", itemid, resume)
- self.kodi_db.addPlaystate(fileid, resume, total, playcount, dateplayed)
+ self.kodi_db.add_playstate(fileid, resume, total, playcount, dateplayed)
emby_db.updateReference(itemid, checksum)
def remove(self, itemid):
# Remove movieid, fileid, emby reference
emby_db = self.emby_db
- kodicursor = self.kodicursor
artwork = self.artwork
emby_dbitem = emby_db.getItem_byId(itemid)
@@ -549,12 +496,10 @@ class Movies(common.Items):
# Remove the emby reference
emby_db.removeItem(itemid)
# Remove artwork
- artwork.delete_artwork(kodiid, mediatype, kodicursor)
+ artwork.delete_artwork(kodiid, mediatype, self.kodicursor)
if mediatype == "movie":
- # Delete kodi movie and file
- kodicursor.execute("DELETE FROM movie WHERE idMovie = ?", (kodiid,))
- kodicursor.execute("DELETE FROM files WHERE idFile = ?", (fileid,))
+ self.kodi_db.remove_movie(kodiid, fileid)
elif mediatype == "set":
# Delete kodi boxset
@@ -562,10 +507,10 @@ class Movies(common.Items):
for movie in boxset_movies:
embyid = movie[0]
movieid = movie[1]
- self.kodi_db.removefromBoxset(movieid)
+ self.kodi_db.remove_from_boxset(movieid)
# Update emby reference
emby_db.updateParentId(embyid, None)
- kodicursor.execute("DELETE FROM sets WHERE idSet = ?", (kodiid,))
+ self.kodi_db.remove_boxset(kodiid)
log.info("Deleted %s %s from kodi database", mediatype, itemid)
diff --git a/resources/lib/objects/music.py b/resources/lib/objects/music.py
index ee64eca9..ab81d3d8 100644
--- a/resources/lib/objects/music.py
+++ b/resources/lib/objects/music.py
@@ -6,10 +6,10 @@ import logging
from datetime import datetime
import api
-import common
import embydb_functions as embydb
-import kodidb_functions as kodidb
import musicutils
+import _kodi_music
+from _common import Items
from utils import window, settings, language as lang, catch_except
##################################################################################################
@@ -19,7 +19,7 @@ log = logging.getLogger("EMBY."+__name__)
##################################################################################################
-class Music(common.Items):
+class Music(Items):
def __init__(self, embycursor, kodicursor, pdialog=None):
@@ -27,7 +27,7 @@ class Music(common.Items):
self.embycursor = embycursor
self.emby_db = embydb.Embydb_Functions(self.embycursor)
self.kodicursor = kodicursor
- self.kodi_db = kodidb.Kodidb_Functions(self.kodicursor)
+ self.kodi_db = _kodi_music.KodiMusic(self.kodicursor)
self.pdialog = pdialog
self.new_time = int(settings('newmusictime'))*1000
@@ -38,7 +38,7 @@ class Music(common.Items):
self.userid = window('emby_currUser')
self.server = window('emby_server%s' % self.userid)
- common.Items.__init__(self)
+ Items.__init__(self)
def _get_func(self, item_type, action):
@@ -218,6 +218,8 @@ class Music(common.Items):
except TypeError:
update_item = False
log.debug("artistid: %s not found", itemid)
+ else:
+ pass
##### The artist details #####
lastScraped = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
@@ -253,30 +255,15 @@ class Music(common.Items):
log.info("ADD artist itemid: %s - Name: %s", itemid, name)
# safety checks: It looks like Emby supports the same artist multiple times.
# Kodi doesn't allow that. In case that happens we just merge the artist entries.
- artistid = self.kodi_db.addArtist(name, musicBrainzId)
+ artistid = self.kodi_db.get_artist(name, musicBrainzId)
# Create the reference in emby table
emby_db.addReference(itemid, artistid, artisttype, "artist", checksum=checksum)
# Process the artist
- if self.kodi_version in (16, 17):
- query = ' '.join((
-
- "UPDATE artist",
- "SET strGenres = ?, strBiography = ?, strImage = ?, strFanart = ?,",
- "lastScraped = ?",
- "WHERE idArtist = ?"
- ))
- kodicursor.execute(query, (genres, bio, thumb, fanart, lastScraped, artistid))
+ if self.kodi_version > 15:
+ self.kodi_db.update_artist_16(genres, bio, thumb, fanart, lastScraped, artistid)
else:
- query = ' '.join((
-
- "UPDATE artist",
- "SET strGenres = ?, strBiography = ?, strImage = ?, strFanart = ?,",
- "lastScraped = ?, dateAdded = ?",
- "WHERE idArtist = ?"
- ))
- kodicursor.execute(query, (genres, bio, thumb, fanart, lastScraped,
- dateadded, artistid))
+ self.kodi_db.update_artist(genres, bio, thumb, fanart, lastScraped, dateadded, artistid)
# Update artwork
artwork.add_artwork(artworks, artistid, "artist", kodicursor)
@@ -313,7 +300,7 @@ class Music(common.Items):
genres = item.get('Genres')
genre = " / ".join(genres)
bio = API.get_overview()
- rating = userdata['UserRating']
+ rating = 0
artists = item['AlbumArtists']
artistname = []
for artist in artists:
@@ -337,56 +324,27 @@ class Music(common.Items):
log.info("ADD album itemid: %s - Name: %s", itemid, name)
# safety checks: It looks like Emby supports the same artist multiple times.
# Kodi doesn't allow that. In case that happens we just merge the artist entries.
- albumid = self.kodi_db.addAlbum(name, musicBrainzId)
+ albumid = self.kodi_db.get_album(name, musicBrainzId)
# Create the reference in emby table
emby_db.addReference(itemid, albumid, "MusicAlbum", "album", checksum=checksum)
-
# Process the album info
if self.kodi_version == 17:
# Kodi Krypton
- query = ' '.join((
-
- "UPDATE album",
- "SET strArtists = ?, iYear = ?, strGenres = ?, strReview = ?, strImage = ?,",
- "iUserrating = ?, lastScraped = ?, strReleaseType = ?",
- "WHERE idAlbum = ?"
- ))
- kodicursor.execute(query, (artistname, year, genre, bio, thumb, rating, lastScraped,
- "album", albumid))
+ self.kodi_db.update_album_17(artistname, year, genre, bio, thumb, rating, lastScraped,
+ "album", albumid)
elif self.kodi_version == 16:
# Kodi Jarvis
- query = ' '.join((
-
- "UPDATE album",
- "SET strArtists = ?, iYear = ?, strGenres = ?, strReview = ?, strImage = ?,",
- "iRating = ?, lastScraped = ?, strReleaseType = ?",
- "WHERE idAlbum = ?"
- ))
- kodicursor.execute(query, (artistname, year, genre, bio, thumb, rating, lastScraped,
- "album", albumid))
+ self.kodi_db.update_album(artistname, year, genre, bio, thumb, rating, lastScraped,
+ "album", albumid)
elif self.kodi_version == 15:
# Kodi Isengard
- query = ' '.join((
-
- "UPDATE album",
- "SET strArtists = ?, iYear = ?, strGenres = ?, strReview = ?, strImage = ?,",
- "iRating = ?, lastScraped = ?, dateAdded = ?, strReleaseType = ?",
- "WHERE idAlbum = ?"
- ))
- kodicursor.execute(query, (artistname, year, genre, bio, thumb, rating, lastScraped,
- dateadded, "album", albumid))
+ self.kodi_db.update_album_15(artistname, year, genre, bio, thumb, rating, lastScraped,
+ dateadded, "album", albumid)
else:
- # Kodi Helix
- query = ' '.join((
-
- "UPDATE album",
- "SET strArtists = ?, iYear = ?, strGenres = ?, strReview = ?, strImage = ?,",
- "iRating = ?, lastScraped = ?, dateAdded = ?",
- "WHERE idAlbum = ?"
- ))
- kodicursor.execute(query, (artistname, year, genre, bio, thumb, rating, lastScraped,
- dateadded, albumid))
+ # TODO: Remove Helix code when Krypton is RC
+ self.kodi_db.update_album_14(artistname, year, genre, bio, thumb, rating, lastScraped,
+ dateadded, albumid)
# Assign main artists to album
for artist in item['AlbumArtists']:
@@ -403,18 +361,10 @@ class Music(common.Items):
artistid = emby_dbartist[0]
else:
# Best take this name over anything else.
- query = "UPDATE artist SET strArtist = ? WHERE idArtist = ?"
- kodicursor.execute(query, (artistname, artistid,))
+ self.kodi_db.update_artist_name(artistid, artistname)
# Add artist to album
- query = (
- '''
- INSERT OR REPLACE INTO album_artist(idArtist, idAlbum, strArtist)
-
- VALUES (?, ?, ?)
- '''
- )
- kodicursor.execute(query, (artistid, albumid, artistname))
+ self.kodi_db.link_artist(artistid, albumid, artistname)
# Update emby reference with parentid
emby_db.updateParentId(artistId, albumid)
@@ -427,17 +377,10 @@ class Music(common.Items):
pass
else:
# Update discography
- query = (
- '''
- INSERT OR REPLACE INTO discography(idArtist, strAlbum, strYear)
-
- VALUES (?, ?, ?)
- '''
- )
- kodicursor.execute(query, (artistid, name, year))
+ self.kodi_db.add_discography(artistid, name, year)
# Add genres
- self.kodi_db.addMusicGenres(albumid, genres, "album")
+ self.kodi_db.add_genres(albumid, genres, "album")
# Update artwork
artwork.add_artwork(artworks, albumid, "album", kodicursor)
@@ -462,6 +405,7 @@ class Music(common.Items):
except TypeError:
update_item = False
log.debug("songid: %s not found", itemid)
+ songid = self.kodi_db.create_entry_song()
##### The song details #####
checksum = API.get_checksum()
@@ -484,7 +428,7 @@ class Music(common.Items):
track = disc*2**16 + tracknumber
year = item.get('ProductionYear')
duration = API.get_runtime()
- rating = userdata['UserRating']
+ rating = 0
#if enabled, try to get the rating from file and/or emby
if not self.directstream:
@@ -524,20 +468,11 @@ class Music(common.Items):
log.info("UPDATE song itemid: %s - Title: %s", itemid, title)
# Update path
- query = "UPDATE path SET strPath = ? WHERE idPath = ?"
- kodicursor.execute(query, (path, pathid))
+ self.kodi_db.update_path(pathid, path)
# Update the song entry
- query = ' '.join((
-
- "UPDATE song",
- "SET idAlbum = ?, strArtists = ?, strGenres = ?, strTitle = ?, iTrack = ?,",
- "iDuration = ?, iYear = ?, strFilename = ?, iTimesPlayed = ?, lastplayed = ?,",
- "rating = ?, comment = ?",
- "WHERE idSong = ?"
- ))
- kodicursor.execute(query, (albumid, artists, genre, title, track, duration, year,
- filename, playcount, dateplayed, rating, comment, songid))
+ self.kodi_db.update_song(albumid, artists, genre, title, track, duration, year,
+ filename, playcount, dateplayed, rating, comment, songid)
# Update the checksum in emby table
emby_db.updateReference(itemid, checksum)
@@ -547,7 +482,7 @@ class Music(common.Items):
log.info("ADD song itemid: %s - Title: %s", itemid, title)
# Add path
- pathid = self.kodi_db.addPath(path)
+ pathid = self.kodi_db.add_path(path)
try:
# Get the album
@@ -558,7 +493,7 @@ class Music(common.Items):
album_name = item.get('Album')
if album_name:
log.info("Creating virtual music album for song: %s", itemid)
- albumid = self.kodi_db.addAlbum(album_name, API.get_provider('MusicBrainzAlbum'))
+ albumid = self.kodi_db.get_album(album_name, API.get_provider('MusicBrainzAlbum'))
emby_db.addReference("%salbum%s" % (itemid, albumid), albumid, "MusicAlbum_", "album")
else:
# No album Id associated to the song.
@@ -578,70 +513,30 @@ class Music(common.Items):
except TypeError:
# No album found, create a single's album
log.info("Failed to add album. Creating singles.")
- kodicursor.execute("select coalesce(max(idAlbum),0) from album")
- albumid = kodicursor.fetchone()[0] + 1
+ album_id = self.kodi_db.create_entry_album()
if self.kodi_version == 16:
- # Kodi Jarvis
- query = (
- '''
- INSERT INTO album(idAlbum, strGenres, iYear, strReleaseType)
+ self.kodi_db.add_single(albumid, genre, year, "single")
- VALUES (?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (albumid, genre, year, "single"))
elif self.kodi_version == 15:
- # Kodi Isengard
- query = (
- '''
- INSERT INTO album(idAlbum, strGenres, iYear, dateAdded, strReleaseType)
+ self.kodi_db.add_single_15(albumid, genre, year, dateadded, "single")
- VALUES (?, ?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (albumid, genre, year, dateadded, "single"))
else:
- # Kodi Helix
- query = (
- '''
- INSERT INTO album(idAlbum, strGenres, iYear, dateAdded)
-
- VALUES (?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (albumid, genre, year, dateadded))
+ # TODO: Remove Helix code when Krypton is RC
+ self.kodi_db.add_single_14(albumid, genre, year, dateadded)
# Create the song entry
- kodicursor.execute("select coalesce(max(idSong),0) from song")
- songid = kodicursor.fetchone()[0] + 1
- query = (
- '''
- INSERT INTO song(
- idSong, idAlbum, idPath, strArtists, strGenres, strTitle, iTrack,
- iDuration, iYear, strFileName, strMusicBrainzTrackID, iTimesPlayed, lastplayed,
- rating)
-
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (songid, albumid, pathid, artists, genre, title, track,
- duration, year, filename, musicBrainzId, playcount,
- dateplayed, rating))
+ self.kodi_db.add_song(songid, albumid, pathid, artists, genre, title, track, duration,
+ year, filename, musicBrainzId, playcount, dateplayed, rating)
# Create the reference in emby table
emby_db.addReference(itemid, songid, "Audio", "song", pathid=pathid, parentid=albumid,
checksum=checksum)
# Link song to album
- query = (
- '''
- INSERT OR REPLACE INTO albuminfosong(
- idAlbumInfoSong, idAlbumInfo, iTrack, strTitle, iDuration)
-
- VALUES (?, ?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (songid, albumid, track, title, duration))
+ self.kodi_db.link_song_album(songid, albumid, track, title, duration)
+ # Create default role
+ if self.kodi_version > 16:
+ self.kodi_db.add_role()
# Link song to artists
for index, artist in enumerate(item['ArtistItems']):
@@ -658,35 +553,8 @@ class Music(common.Items):
artist_edb = emby_db.getItem_byId(artist_eid)
artistid = artist_edb[0]
finally:
- if self.kodi_version >= 17:
- # Kodi Krypton
- query = (
- '''
- INSERT OR REPLACE INTO song_artist(idArtist, idSong, idRole, iOrder, strArtist)
-
- VALUES (?, ?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (artistid, songid, 1, index, artist_name))
-
- # May want to look into only doing this once?
- query = (
- '''
- INSERT OR REPLACE INTO role(idRole, strRole)
-
- VALUES (?, ?)
- '''
- )
- kodicursor.execute(query, (1, 'Composer'))
- else:
- query = (
- '''
- INSERT OR REPLACE INTO song_artist(idArtist, idSong, iOrder, strArtist)
-
- VALUES (?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (artistid, songid, index, artist_name))
+ # Link song to artist
+ self.kodi_db.link_song_artist(artistid, songid, index, artist_name)
# Verify if album artist exists
album_artists = []
@@ -705,51 +573,18 @@ class Music(common.Items):
artist_edb = emby_db.getItem_byId(artist_eid)
artistid = artist_edb[0]
finally:
- query = (
- '''
- INSERT OR REPLACE INTO album_artist(idArtist, idAlbum, strArtist)
-
- VALUES (?, ?, ?)
- '''
- )
- kodicursor.execute(query, (artistid, albumid, artist_name))
+ # Link artist to album
+ self.kodi_db.link_artist(artistid, albumid, artist_name)
# Update discography
if item.get('Album'):
- query = (
- '''
- INSERT OR REPLACE INTO discography(idArtist, strAlbum, strYear)
-
- VALUES (?, ?, ?)
- '''
- )
- kodicursor.execute(query, (artistid, item['Album'], 0))
+ self.kodi_db.add_discography(artistid, item['Album'], 0)
+ # Artist names
album_artists = " / ".join(album_artists)
- query = ' '.join((
-
- "SELECT strArtists",
- "FROM album",
- "WHERE idAlbum = ?"
- ))
- kodicursor.execute(query, (albumid,))
- result = kodicursor.fetchone()
- if result and result[0] != album_artists:
- # Field is empty
- if self.kodi_version in (16, 17):
- # Kodi Jarvis, Krypton
- query = "UPDATE album SET strArtists = ? WHERE idAlbum = ?"
- kodicursor.execute(query, (album_artists, albumid))
- elif self.kodi_version == 15:
- # Kodi Isengard
- query = "UPDATE album SET strArtists = ? WHERE idAlbum = ?"
- kodicursor.execute(query, (album_artists, albumid))
- else:
- # Kodi Helix
- query = "UPDATE album SET strArtists = ? WHERE idAlbum = ?"
- kodicursor.execute(query, (album_artists, albumid))
+ self.kodi_db.get_album_artist(albumid, album_artists)
# Add genres
- self.kodi_db.addMusicGenres(songid, genres, "song")
+ self.kodi_db.add_genres(songid, genres, "song")
# Update artwork
allart = artwork.get_all_artwork(item, parent_info=True)
@@ -774,7 +609,7 @@ class Music(common.Items):
itemid = item['Id']
checksum = API.get_checksum()
userdata = API.get_userdata()
- rating = userdata['UserRating']
+ rating = 0
# Get Kodi information
emby_dbitem = emby_db.getItem_byId(itemid)
@@ -799,17 +634,7 @@ class Music(common.Items):
#process item ratings
rating, comment, hasEmbeddedCover = musicutils.getAdditionalSongTags(itemid, rating, API, kodicursor, emby_db, self.enableimportsongrating, self.enableexportsongrating, self.enableupdatesongrating)
-
- query = "UPDATE song SET iTimesPlayed = ?, lastplayed = ?, rating = ? WHERE idSong = ?"
- kodicursor.execute(query, (playcount, dateplayed, rating, kodiid))
-
- elif mediatype == "album":
- # Process playstates
- if self.kodi_version >= 17:
- query = "UPDATE album SET fRating = ? WHERE idAlbum = ?"
- else:
- query = "UPDATE album SET iRating = ? WHERE idAlbum = ?"
- kodicursor.execute(query, (rating, kodiid))
+ self.kodi_db.rate_song(playcount, dateplayed, rating, kodiid)
emby_db.updateReference(itemid, checksum)
@@ -889,21 +714,19 @@ class Music(common.Items):
# Remove artist
self.removeArtist(kodiid)
- log.info("Deleted %s: %s from kodi database" % (mediatype, itemid))
+ log.info("Deleted %s: %s from kodi database", mediatype, itemid)
- def removeSong(self, kodiId):
+ def removeSong(self, kodi_id):
- kodicursor = self.kodicursor
+ self.artwork.delete_artwork(kodi_id, "song", self.kodicursor)
+ self.kodi_db.remove_song(kodi_id)
- self.artwork.delete_artwork(kodiId, "song", self.kodicursor)
- self.kodicursor.execute("DELETE FROM song WHERE idSong = ?", (kodiId,))
+ def removeAlbum(self, kodi_id):
- def removeAlbum(self, kodiId):
+ self.artwork.delete_artwork(kodi_id, "album", self.kodicursor)
+ self.kodi_db.remove_album(kodi_id)
- self.artwork.delete_artwork(kodiId, "album", self.kodicursor)
- self.kodicursor.execute("DELETE FROM album WHERE idAlbum = ?", (kodiId,))
+ def removeArtist(self, kodi_id):
- def removeArtist(self, kodiId):
-
- self.artwork.delete_artwork(kodiId, "artist", self.kodicursor)
- self.kodicursor.execute("DELETE FROM artist WHERE idArtist = ?", (kodiId,))
+ self.artwork.delete_artwork(kodi_id, "artist", self.kodicursor)
+ self.kodi_db.remove_artist(kodi_id)
diff --git a/resources/lib/objects/musicvideos.py b/resources/lib/objects/musicvideos.py
index 16db704a..118c36ee 100644
--- a/resources/lib/objects/musicvideos.py
+++ b/resources/lib/objects/musicvideos.py
@@ -6,9 +6,9 @@ import logging
import urllib
import api
-import common
import embydb_functions as embydb
-import kodidb_functions as kodidb
+import _kodi_musicvideos
+from _common import Items
from utils import window, language as lang, catch_except
##################################################################################################
@@ -18,7 +18,7 @@ log = logging.getLogger("EMBY."+__name__)
##################################################################################################
-class MusicVideos(common.Items):
+class MusicVideos(Items):
def __init__(self, embycursor, kodicursor, pdialog=None):
@@ -26,10 +26,10 @@ class MusicVideos(common.Items):
self.embycursor = embycursor
self.emby_db = embydb.Embydb_Functions(self.embycursor)
self.kodicursor = kodicursor
- self.kodi_db = kodidb.Kodidb_Functions(self.kodicursor)
+ self.kodi_db = _kodi_musicvideos.KodiMusicVideos(self.kodicursor)
self.pdialog = pdialog
- common.Items.__init__(self)
+ Items.__init__(self)
def _get_func(self, item_type, action):
@@ -119,7 +119,7 @@ class MusicVideos(common.Items):
def added(self, items, total=None, view=None):
- for item in super(MusicVideos, self).added(items, total, True):
+ for item in super(MusicVideos, self).added(items, total):
if self.add_update(item, view):
self.content_pop(item.get('Name', "unknown"))
@@ -146,16 +146,10 @@ class MusicVideos(common.Items):
update_item = False
log.debug("mvideoid: %s not found", itemid)
# mvideoid
- kodicursor.execute("select coalesce(max(idMVideo),0) from musicvideo")
- mvideoid = kodicursor.fetchone()[0] + 1
+ mvideoid = self.kodi_db.create_entry()
else:
- # Verification the item is still in Kodi
- query = "SELECT * FROM musicvideo WHERE idMVideo = ?"
- kodicursor.execute(query, (mvideoid,))
- try:
- kodicursor.fetchone()[0]
- except TypeError:
+ if self.kodi_db.get_musicvideo(mvideoid) is None:
# item is not found, let's recreate it.
update_item = False
log.info("mvideoid: %s missing from Kodi, repairing the entry.", mvideoid)
@@ -224,24 +218,10 @@ class MusicVideos(common.Items):
if update_item:
log.info("UPDATE mvideo itemid: %s - Title: %s", itemid, title)
- # Update path
- query = "UPDATE path SET strPath = ? WHERE idPath = ?"
- kodicursor.execute(query, (path, pathid))
-
- # Update the filename
- query = "UPDATE files SET strFilename = ?, dateAdded = ? WHERE idFile = ?"
- kodicursor.execute(query, (filename, dateadded, fileid))
-
# Update the music video entry
- query = ' '.join((
+ self.kodi_db.update_musicvideo(title, runtime, director, studio, year, plot, album,
+ artist, genre, track, mvideoid)
- "UPDATE musicvideo",
- "SET c00 = ?, c04 = ?, c05 = ?, c06 = ?, c07 = ?, c08 = ?, c09 = ?, c10 = ?,",
- "c11 = ?, c12 = ?"
- "WHERE idMVideo = ?"
- ))
- kodicursor.execute(query, (title, runtime, director, studio, year, plot, album,
- artist, genre, track, mvideoid))
# Update the checksum in emby table
emby_db.updateReference(itemid, checksum)
@@ -250,57 +230,23 @@ class MusicVideos(common.Items):
log.info("ADD mvideo itemid: %s - Title: %s", itemid, title)
# Add path
- query = ' '.join((
-
- "SELECT idPath",
- "FROM path",
- "WHERE strPath = ?"
- ))
- kodicursor.execute(query, (path,))
- try:
- pathid = kodicursor.fetchone()[0]
- except TypeError:
- kodicursor.execute("select coalesce(max(idPath),0) from path")
- pathid = kodicursor.fetchone()[0] + 1
- query = (
- '''
- INSERT OR REPLACE INTO path(
- idPath, strPath, strContent, strScraper, noUpdate)
-
- VALUES (?, ?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (pathid, path, "musicvideos", "metadata.local", 1))
-
+ pathid = self.kodi_db.add_path(path)
# Add the file
- kodicursor.execute("select coalesce(max(idFile),0) from files")
- fileid = kodicursor.fetchone()[0] + 1
- query = (
- '''
- INSERT INTO files(
- idFile, idPath, strFilename, dateAdded)
-
- VALUES (?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (fileid, pathid, filename, dateadded))
+ fileid = self.kodi_db.add_file(filename, pathid)
# Create the musicvideo entry
- query = (
- '''
- INSERT INTO musicvideo(
- idMVideo, idFile, c00, c04, c05, c06, c07, c08, c09, c10, c11, c12)
-
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (mvideoid, fileid, title, runtime, director, studio,
- year, plot, album, artist, genre, track))
+ self.kodi_db.add_musicvideo(mvideoid, fileid, title, runtime, director, studio,
+ year, plot, album, artist, genre, track)
# Create the reference in emby table
emby_db.addReference(itemid, mvideoid, "MusicVideo", "musicvideo", fileid, pathid,
checksum=checksum, mediafolderid=viewid)
+ # Update the path
+ self.kodi_db.update_path(pathid, path, "musicvideos", "metadata.local")
+ # Update the file
+ self.kodi_db.update_file(fileid, filename, pathid, dateadded)
+
# Process cast
people = item['People']
artists = item['ArtistItems']
@@ -308,26 +254,26 @@ class MusicVideos(common.Items):
artist['Type'] = "Artist"
people.extend(artists)
people = artwork.get_people_artwork(people)
- self.kodi_db.addPeople(mvideoid, people, "musicvideo")
+ self.kodi_db.add_people(mvideoid, people, "musicvideo")
# Process genres
- self.kodi_db.addGenres(mvideoid, genres, "musicvideo")
+ self.kodi_db.add_genres(mvideoid, genres, "musicvideo")
# Process artwork
artwork.add_artwork(artwork.get_all_artwork(item), mvideoid, "musicvideo", kodicursor)
# Process stream details
streams = API.get_media_streams()
- self.kodi_db.addStreams(fileid, streams, runtime)
+ self.kodi_db.add_streams(fileid, streams, runtime)
# Process studios
- self.kodi_db.addStudios(mvideoid, studios, "musicvideo")
+ self.kodi_db.add_studios(mvideoid, studios, "musicvideo")
# Process tags: view, emby tags
tags = [viewtag]
tags.extend(item['Tags'])
if userdata['Favorite']:
tags.append("Favorite musicvideos")
- self.kodi_db.addTags(mvideoid, tags, "musicvideo")
+ self.kodi_db.add_tags(mvideoid, tags, "musicvideo")
# Process playstates
resume = API.adjust_resume(userdata['Resume'])
total = round(float(runtime), 6)
- self.kodi_db.addPlaystate(fileid, resume, total, playcount, dateplayed)
+ self.kodi_db.add_playstate(fileid, resume, total, playcount, dateplayed)
return True
@@ -354,9 +300,9 @@ class MusicVideos(common.Items):
# Process favorite tags
if userdata['Favorite']:
- self.kodi_db.addTag(mvideoid, "Favorite musicvideos", "musicvideo")
+ self.kodi_db.get_tag(mvideoid, "Favorite musicvideos", "musicvideo")
else:
- self.kodi_db.removeTag(mvideoid, "Favorite musicvideos", "musicvideo")
+ self.kodi_db.remove_tag(mvideoid, "Favorite musicvideos", "musicvideo")
# Process playstates
playcount = userdata['PlayCount']
@@ -364,7 +310,7 @@ class MusicVideos(common.Items):
resume = API.adjust_resume(userdata['Resume'])
total = round(float(runtime), 6)
- self.kodi_db.addPlaystate(fileid, resume, total, playcount, dateplayed)
+ self.kodi_db.add_playstate(fileid, resume, total, playcount, dateplayed)
emby_db.updateReference(itemid, checksum)
def remove(self, itemid):
@@ -382,26 +328,13 @@ class MusicVideos(common.Items):
except TypeError:
return
+ # Remove the emby reference
+ emby_db.removeItem(itemid)
# Remove artwork
- query = ' '.join((
+ artwork.delete_artwork(mvideoid, "musicvideo", self.kodicursor)
- "SELECT url, type",
- "FROM art",
- "WHERE media_id = ?",
- "AND media_type = 'musicvideo'"
- ))
- kodicursor.execute(query, (mvideoid,))
- for row in kodicursor.fetchall():
-
- url = row[0]
- imagetype = row[1]
- if imagetype in ("poster", "fanart"):
- artwork.delete_cached_artwork(url)
-
- kodicursor.execute("DELETE FROM musicvideo WHERE idMVideo = ?", (mvideoid,))
- kodicursor.execute("DELETE FROM files WHERE idFile = ?", (fileid,))
+ self.kodi_db.remove_musicvideo(mvideoid, fileid)
if self.direct_path:
- kodicursor.execute("DELETE FROM path WHERE idPath = ?", (pathid,))
- self.embycursor.execute("DELETE FROM emby WHERE emby_id = ?", (itemid,))
+ self.kodi_db.remove_path(pathid)
log.info("Deleted musicvideo %s from kodi database", itemid)
diff --git a/resources/lib/objects/tvshows.py b/resources/lib/objects/tvshows.py
index c44ca75b..afb96312 100644
--- a/resources/lib/objects/tvshows.py
+++ b/resources/lib/objects/tvshows.py
@@ -7,9 +7,10 @@ import urllib
from ntpath import dirname
import api
-import common
import embydb_functions as embydb
import kodidb_functions as kodidb
+import _kodi_tvshows
+from _common import Items
from utils import window, settings, language as lang, catch_except
##################################################################################################
@@ -19,7 +20,7 @@ log = logging.getLogger("EMBY."+__name__)
##################################################################################################
-class TVShows(common.Items):
+class TVShows(Items):
def __init__(self, embycursor, kodicursor, pdialog=None):
@@ -27,12 +28,12 @@ class TVShows(common.Items):
self.embycursor = embycursor
self.emby_db = embydb.Embydb_Functions(self.embycursor)
self.kodicursor = kodicursor
- self.kodi_db = kodidb.Kodidb_Functions(self.kodicursor)
+ self.kodi_db = _kodi_tvshows.KodiTVShows(self.kodicursor)
self.pdialog = pdialog
self.new_time = int(settings('newvideotime'))*1000
- common.Items.__init__(self)
+ Items.__init__(self)
def _get_func(self, item_type, action):
@@ -252,16 +253,11 @@ class TVShows(common.Items):
except TypeError:
update_item = False
log.debug("showid: %s not found", itemid)
- kodicursor.execute("select coalesce(max(idShow),0) from tvshow")
- showid = kodicursor.fetchone()[0] + 1
+ showid = self.kodi_db.create_entry()
else:
# Verification the item is still in Kodi
- query = "SELECT * FROM tvshow WHERE idShow = ?"
- kodicursor.execute(query, (showid,))
- try:
- kodicursor.fetchone()[0]
- except TypeError:
+ if self.kodi_db.get_tvshow(showid) is None:
# item is not found, let's recreate it.
update_item = False
log.info("showid: %s missing from Kodi, repairing the entry", showid)
@@ -345,15 +341,8 @@ class TVShows(common.Items):
log.info("UPDATE tvshow itemid: %s - Title: %s", itemid, title)
# Update the tvshow entry
- query = ' '.join((
-
- "UPDATE tvshow",
- "SET c00 = ?, c01 = ?, c04 = ?, c05 = ?, c08 = ?, c09 = ?,",
- "c12 = ?, c13 = ?, c14 = ?, c15 = ?",
- "WHERE idShow = ?"
- ))
- kodicursor.execute(query, (title, plot, rating, premieredate, genre, title,
- tvdb, mpaa, studio, sorttitle, showid))
+ self.kodi_db.update_tvshow(title, plot, rating, premieredate, genre, title,
+ tvdb, mpaa, studio, sorttitle, showid)
# Update the checksum in emby table
emby_db.updateReference(itemid, checksum)
@@ -363,68 +352,49 @@ class TVShows(common.Items):
log.info("ADD tvshow itemid: %s - Title: %s", itemid, title)
# Add top path
- toppathid = self.kodi_db.addPath(toplevelpath)
- query = ' '.join((
-
- "UPDATE path",
- "SET strPath = ?, strContent = ?, strScraper = ?, noUpdate = ?",
- "WHERE idPath = ?"
- ))
- kodicursor.execute(query, (toplevelpath, "tvshows", "metadata.local", 1, toppathid))
+ toppathid = self.kodi_db.add_path(toplevelpath)
+ self.kodi_db.update_path(toppathid, toplevelpath, "tvshows", "metadata.local")
# Add path
- pathid = self.kodi_db.addPath(path)
+ pathid = self.kodi_db.add_path(path)
# Create the tvshow entry
- query = (
- '''
- INSERT INTO tvshow(idShow, c00, c01, c04, c05, c08, c09, c12, c13, c14, c15)
-
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (showid, title, plot, rating, premieredate, genre,
- title, tvdb, mpaa, studio, sorttitle))
-
- # Link the path
- query = "INSERT INTO tvshowlinkpath(idShow, idPath) values(?, ?)"
- kodicursor.execute(query, (showid, pathid))
+ self.kodi_db.add_tvshow(showid, title, plot, rating, premieredate, genre,
+ title, tvdb, mpaa, studio, sorttitle)
# Create the reference in emby table
emby_db.addReference(itemid, showid, "Series", "tvshow", pathid=pathid,
checksum=checksum, mediafolderid=viewid)
- # Update the path
- query = ' '.join((
- "UPDATE path",
- "SET strPath = ?, strContent = ?, strScraper = ?, noUpdate = ?",
- "WHERE idPath = ?"
- ))
- kodicursor.execute(query, (path, None, None, 1, pathid))
+ # Link the path
+ self.kodi_db.link_tvshow(showid, pathid)
+
+ # Update the path
+ self.kodi_db.update_path(pathid, path, None, None)
# Process cast
people = artwork.get_people_artwork(item['People'])
- self.kodi_db.addPeople(showid, people, "tvshow")
+ self.kodi_db.add_people(showid, people, "tvshow")
# Process genres
- self.kodi_db.addGenres(showid, genres, "tvshow")
+ self.kodi_db.add_genres(showid, genres, "tvshow")
# Process artwork
artwork.add_artwork(artwork.get_all_artwork(item), showid, "tvshow", kodicursor)
# Process studios
- self.kodi_db.addStudios(showid, studios, "tvshow")
+ self.kodi_db.add_studios(showid, studios, "tvshow")
# Process tags: view, emby tags
tags = [viewtag]
tags.extend(item['Tags'])
if userdata['Favorite']:
tags.append("Favorite tvshows")
- self.kodi_db.addTags(showid, tags, "tvshow")
+ self.kodi_db.add_tags(showid, tags, "tvshow")
# Process seasons
all_seasons = emby.getSeasons(itemid)
for season in all_seasons['Items']:
self.add_updateSeason(season, showid=showid)
else:
# Finally, refresh the all season entry
- seasonid = self.kodi_db.addSeason(showid, -1)
+ seasonid = self.kodi_db.get_season(showid, -1)
# Process artwork
artwork.add_artwork(artwork.get_all_artwork(item), seasonid, "season", kodicursor)
@@ -456,7 +426,7 @@ class TVShows(common.Items):
self.add_update(show)
return
- seasonid = self.kodi_db.addSeason(showid, seasonnum, item['Name'])
+ seasonid = self.kodi_db.get_season(showid, seasonnum, item['Name'])
if item['LocationType'] != "Virtual":
# Create the reference in emby table
@@ -494,16 +464,11 @@ class TVShows(common.Items):
update_item = False
log.debug("episodeid: %s not found", itemid)
# episodeid
- kodicursor.execute("select coalesce(max(idEpisode),0) from episode")
- episodeid = kodicursor.fetchone()[0] + 1
+ episodeid = self.kodi_db.create_entry_episode()
else:
# Verification the item is still in Kodi
- query = "SELECT * FROM episode WHERE idEpisode = ?"
- kodicursor.execute(query, (episodeid,))
- try:
- kodicursor.fetchone()[0]
- except TypeError:
+ if self.kodi_db.get_episode(episodeid) is None:
# item is not found, let's recreate it.
update_item = False
log.info("episodeid: %s missing from Kodi, repairing the entry", episodeid)
@@ -571,7 +536,7 @@ class TVShows(common.Items):
log.error("Skipping: %s. Unable to add series: %s", itemid, seriesId)
return False
- seasonid = self.kodi_db.addSeason(showid, season)
+ seasonid = self.kodi_db.get_season(showid, season)
##### GET THE FILE AND PATH #####
@@ -610,27 +575,14 @@ class TVShows(common.Items):
# Update the movie entry
if self.kodi_version in (16, 17):
# Kodi Jarvis, Krypton
- query = ' '.join((
-
- "UPDATE episode",
- "SET c00 = ?, c01 = ?, c03 = ?, c04 = ?, c05 = ?, c09 = ?, c10 = ?,",
- "c12 = ?, c13 = ?, c14 = ?, c15 = ?, c16 = ?, idSeason = ?, idShow = ?",
- "WHERE idEpisode = ?"
- ))
- kodicursor.execute(query, (title, plot, rating, writer, premieredate, runtime,
- director, season, episode, title, airsBeforeSeason,
- airsBeforeEpisode, seasonid, showid, episodeid))
+ self.kodi_db.update_episode_16(title, plot, rating, writer, premieredate, runtime,
+ director, season, episode, title, airsBeforeSeason,
+ airsBeforeEpisode, seasonid, showid, episodeid)
else:
- query = ' '.join((
+ self.kodi_db.update_episode(title, plot, rating, writer, premieredate, runtime,
+ director, season, episode, title, airsBeforeSeason,
+ airsBeforeEpisode, showid, episodeid)
- "UPDATE episode",
- "SET c00 = ?, c01 = ?, c03 = ?, c04 = ?, c05 = ?, c09 = ?, c10 = ?,",
- "c12 = ?, c13 = ?, c14 = ?, c15 = ?, c16 = ?, idShow = ?",
- "WHERE idEpisode = ?"
- ))
- kodicursor.execute(query, (title, plot, rating, writer, premieredate, runtime,
- director, season, episode, title, airsBeforeSeason,
- airsBeforeEpisode, showid, episodeid))
# Update the checksum in emby table
emby_db.updateReference(itemid, checksum)
# Update parentid reference
@@ -641,86 +593,49 @@ class TVShows(common.Items):
log.info("ADD episode itemid: %s - Title: %s", itemid, title)
# Add path
- pathid = self.kodi_db.addPath(path)
+ pathid = self.kodi_db.add_path(path)
# Add the file
- fileid = self.kodi_db.addFile(filename, pathid)
+ fileid = self.kodi_db.add_file(filename, pathid)
# Create the episode entry
if self.kodi_version in (16, 17):
# Kodi Jarvis, Krypton
- query = (
- '''
- INSERT INTO episode(
- idEpisode, idFile, c00, c01, c03, c04, c05, c09, c10, c12, c13, c14,
- idShow, c15, c16, idSeason)
-
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (episodeid, fileid, title, plot, rating, writer,
- premieredate, runtime, director, season, episode, title,
- showid, airsBeforeSeason, airsBeforeEpisode, seasonid))
+ self.kodi_db.add_episode_16(episodeid, fileid, title, plot, rating, writer,
+ premieredate, runtime, director, season, episode, title,
+ showid, airsBeforeSeason, airsBeforeEpisode, seasonid)
else:
- query = (
- '''
- INSERT INTO episode(
- idEpisode, idFile, c00, c01, c03, c04, c05, c09, c10, c12, c13, c14,
- idShow, c15, c16)
-
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
- '''
- )
- kodicursor.execute(query, (episodeid, fileid, title, plot, rating, writer,
- premieredate, runtime, director, season, episode, title,
- showid, airsBeforeSeason, airsBeforeEpisode))
+ self.kodi_db.add_episode(episodeid, fileid, title, plot, rating, writer,
+ premieredate, runtime, director, season, episode, title,
+ showid, airsBeforeSeason, airsBeforeEpisode)
# Create the reference in emby table
emby_db.addReference(itemid, episodeid, "Episode", "episode", fileid, pathid,
seasonid, checksum)
# Update the path
- query = ' '.join((
-
- "UPDATE path",
- "SET strPath = ?, strContent = ?, strScraper = ?, noUpdate = ?",
- "WHERE idPath = ?"
- ))
- kodicursor.execute(query, (path, None, None, 1, pathid))
-
+ self.kodi_db.update_path(pathid, path, None, None)
# Update the file
- query = ' '.join((
-
- "UPDATE files",
- "SET idPath = ?, strFilename = ?, dateAdded = ?",
- "WHERE idFile = ?"
- ))
- kodicursor.execute(query, (pathid, filename, dateadded, fileid))
+ self.kodi_db.update_file(fileid, filename, pathid, dateadded)
# Process cast
people = artwork.get_people_artwork(item['People'])
- self.kodi_db.addPeople(episodeid, people, "episode")
+ self.kodi_db.add_people(episodeid, people, "episode")
# Process artwork
artworks = artwork.get_all_artwork(item)
artwork.add_update_art(artworks['Primary'], episodeid, "episode", "thumb", kodicursor)
# Process stream details
streams = API.get_media_streams()
- self.kodi_db.addStreams(fileid, streams, runtime)
+ self.kodi_db.add_streams(fileid, streams, runtime)
# Process playstates
resume = API.adjust_resume(userdata['Resume'])
total = round(float(runtime), 6)
- self.kodi_db.addPlaystate(fileid, resume, total, playcount, dateplayed)
+ self.kodi_db.add_playstate(fileid, resume, total, playcount, dateplayed)
if not self.direct_path and resume:
# Create additional entry for widgets. This is only required for plugin/episode.
- temppathid = self.kodi_db.getPath("plugin://plugin.video.emby.tvshows/")
- tempfileid = self.kodi_db.addFile(filename, temppathid)
- query = ' '.join((
-
- "UPDATE files",
- "SET idPath = ?, strFilename = ?, dateAdded = ?",
- "WHERE idFile = ?"
- ))
- kodicursor.execute(query, (temppathid, filename, dateadded, tempfileid))
- self.kodi_db.addPlaystate(tempfileid, resume, total, playcount, dateplayed)
+ temppathid = self.kodi_db.get_path("plugin://plugin.video.emby.tvshows/")
+ tempfileid = self.kodi_db.add_file(filename, temppathid)
+ self.kodi_db.update_file(tempfileid, filename, temppathid, dateadded)
+ self.kodi_db.add_playstate(tempfileid, resume, total, playcount, dateplayed)
return True
@@ -750,9 +665,9 @@ class TVShows(common.Items):
# Process favorite tags
if mediatype == "tvshow":
if userdata['Favorite']:
- self.kodi_db.addTag(kodiid, "Favorite tvshows", "tvshow")
+ self.kodi_db.get_tag(kodiid, "Favorite tvshows", "tvshow")
else:
- self.kodi_db.removeTag(kodiid, "Favorite tvshows", "tvshow")
+ self.kodi_db.remove_tag(kodiid, "Favorite tvshows", "tvshow")
elif mediatype == "episode":
# Process playstates
playcount = userdata['PlayCount']
@@ -762,25 +677,19 @@ class TVShows(common.Items):
log.debug("%s New resume point: %s", itemid, resume)
- self.kodi_db.addPlaystate(fileid, resume, total, playcount, dateplayed)
+ self.kodi_db.add_playstate(fileid, resume, total, playcount, dateplayed)
if not self.direct_path and not resume:
# Make sure there's no other bookmarks created by widget.
- filename = self.kodi_db.getFile(fileid)
- self.kodi_db.removeFile("plugin://plugin.video.emby.tvshows/", filename)
+ filename = self.kodi_db.get_filename(fileid)
+ self.kodi_db.remove_file("plugin://plugin.video.emby.tvshows/", filename)
if not self.direct_path and resume:
# Create additional entry for widgets. This is only required for plugin/episode.
- filename = self.kodi_db.getFile(fileid)
- temppathid = self.kodi_db.getPath("plugin://plugin.video.emby.tvshows/")
- tempfileid = self.kodi_db.addFile(filename, temppathid)
- query = ' '.join((
-
- "UPDATE files",
- "SET idPath = ?, strFilename = ?, dateAdded = ?",
- "WHERE idFile = ?"
- ))
- self.kodicursor.execute(query, (temppathid, filename, dateadded, tempfileid))
- self.kodi_db.addPlaystate(tempfileid, resume, total, playcount, dateplayed)
+ filename = self.kodi_db.get_filename(fileid)
+ temppathid = self.kodi_db.get_path("plugin://plugin.video.emby.tvshows/")
+ tempfileid = self.kodi_db.add_file(filename, temppathid)
+ self.kodi_db.update_file(tempfileid, filename, temppathid, dateadded)
+ self.kodi_db.add_playstate(tempfileid, resume, total, playcount, dateplayed)
emby_db.updateReference(itemid, checksum)
@@ -890,7 +799,7 @@ class TVShows(common.Items):
kodicursor = self.kodicursor
self.artwork.delete_artwork(kodiid, "tvshow", kodicursor)
- kodicursor.execute("DELETE FROM tvshow WHERE idShow = ?", (kodiid,))
+ self.kodi_db.remove_tvshow(kodiid)
log.debug("Removed tvshow: %s", kodiid)
def removeSeason(self, kodiid):
@@ -898,7 +807,7 @@ class TVShows(common.Items):
kodicursor = self.kodicursor
self.artwork.delete_artwork(kodiid, "season", kodicursor)
- kodicursor.execute("DELETE FROM seasons WHERE idSeason = ?", (kodiid,))
+ self.kodi_db.remove_season(kodiid)
log.debug("Removed season: %s", kodiid)
def removeEpisode(self, kodiid, fileid):
@@ -906,6 +815,5 @@ class TVShows(common.Items):
kodicursor = self.kodicursor
self.artwork.delete_artwork(kodiid, "episode", kodicursor)
- kodicursor.execute("DELETE FROM episode WHERE idEpisode = ?", (kodiid,))
- kodicursor.execute("DELETE FROM files WHERE idFile = ?", (fileid,))
+ self.kodi_db.remove_episode(kodiid, fileid)
log.debug("Removed episode: %s", kodiid)
diff --git a/resources/lib/videonodes.py b/resources/lib/videonodes.py
index f8475d79..5a140e88 100644
--- a/resources/lib/videonodes.py
+++ b/resources/lib/videonodes.py
@@ -67,18 +67,17 @@ class VideoNodes(object):
dst=xbmc.translatePath("special://profile/library/video").decode('utf-8'))
xbmcvfs.exists(path)
+ if delete:
+ dirs, files = xbmcvfs.listdir(nodepath)
+ for file in files:
+ xbmcvfs.delete(nodepath + file)
+
+ log.info("Sucessfully removed videonode: %s." % tagname)
+ return
# Create the node directory
if not xbmcvfs.exists(nodepath) and not mediatype == "photos":
# We need to copy over the default items
xbmcvfs.mkdirs(nodepath)
- else:
- if delete:
- dirs, files = xbmcvfs.listdir(nodepath)
- for file in files:
- xbmcvfs.delete(nodepath + file)
-
- log.info("Sucessfully removed videonode: %s." % tagname)
- return
# Create index entry
nodeXML = "%sindex.xml" % nodepath