1218 lines
39 KiB
Python
1218 lines
39 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
###############################################################################
|
|
from logging import getLogger
|
|
from ntpath import dirname
|
|
|
|
import artwork
|
|
from utils import kodi_sql, try_decode
|
|
import variables as v
|
|
|
|
###############################################################################
|
|
|
|
LOG = getLogger("PLEX." + __name__)
|
|
|
|
###############################################################################
|
|
|
|
|
|
class GetKodiDB(object):
|
|
"""
|
|
Usage: with GetKodiDB(db_type) as kodi_db:
|
|
do stuff with kodi_db
|
|
|
|
Parameters:
|
|
db_type: DB to open: 'video', 'music', 'plex', 'texture'
|
|
|
|
On exiting "with" (no matter what), commits get automatically committed
|
|
and the db gets closed
|
|
"""
|
|
def __init__(self, db_type):
|
|
self.kodiconn = None
|
|
self.db_type = db_type
|
|
|
|
def __enter__(self):
|
|
self.kodiconn = kodi_sql(self.db_type)
|
|
kodi_db = KodiDBMethods(self.kodiconn.cursor())
|
|
return kodi_db
|
|
|
|
def __exit__(self, typus, value, traceback):
|
|
self.kodiconn.commit()
|
|
self.kodiconn.close()
|
|
|
|
|
|
class KodiDBMethods(object):
|
|
"""
|
|
Best used indirectly with another Class GetKodiDB:
|
|
with GetKodiDB(db_type) as kodi_db:
|
|
kodi_db.method()
|
|
"""
|
|
def __init__(self, cursor):
|
|
self.cursor = cursor
|
|
self.artwork = artwork.Artwork()
|
|
|
|
def setup_path_table(self):
|
|
"""
|
|
Use with Kodi video DB
|
|
|
|
Sets strContent to e.g. 'movies' and strScraper to metadata.local
|
|
|
|
For some reason, Kodi ignores this if done via itemtypes while e.g.
|
|
adding or updating items. (addPath method does NOT work)
|
|
"""
|
|
path_id = self.getPath('plugin://%s.movies/' % v.ADDON_ID)
|
|
if path_id is None:
|
|
self.cursor.execute("select coalesce(max(idPath),0) from path")
|
|
path_id = self.cursor.fetchone()[0] + 1
|
|
query = '''
|
|
INSERT INTO path(idPath,
|
|
strPath,
|
|
strContent,
|
|
strScraper,
|
|
noUpdate,
|
|
exclude)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
'''
|
|
self.cursor.execute(query, (path_id,
|
|
'plugin://%s.movies/' % v.ADDON_ID,
|
|
'movies',
|
|
'metadata.local',
|
|
1,
|
|
0))
|
|
# And TV shows
|
|
path_id = self.getPath('plugin://%s.tvshows/' % v.ADDON_ID)
|
|
if path_id is None:
|
|
self.cursor.execute("select coalesce(max(idPath),0) from path")
|
|
path_id = self.cursor.fetchone()[0] + 1
|
|
query = '''
|
|
INSERT INTO path(idPath,
|
|
strPath,
|
|
strContent,
|
|
strScraper,
|
|
noUpdate,
|
|
exclude)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
'''
|
|
self.cursor.execute(query, (path_id,
|
|
'plugin://%s.tvshows/' % v.ADDON_ID,
|
|
'tvshows',
|
|
'metadata.local',
|
|
1,
|
|
0))
|
|
|
|
def getParentPathId(self, path):
|
|
"""
|
|
Video DB: Adds all subdirectories to SQL path while setting a "trail"
|
|
of parentPathId
|
|
"""
|
|
if "\\" in path:
|
|
# Local path
|
|
parentpath = "%s\\" % dirname(dirname(path))
|
|
else:
|
|
# Network path
|
|
parentpath = "%s/" % dirname(dirname(path))
|
|
pathid = self.getPath(parentpath)
|
|
if pathid is None:
|
|
self.cursor.execute("select coalesce(max(idPath),0) from path")
|
|
pathid = self.cursor.fetchone()[0] + 1
|
|
query = ' '.join((
|
|
"INSERT INTO path(idPath, strPath)",
|
|
"VALUES (?, ?)"
|
|
))
|
|
self.cursor.execute(query, (pathid, parentpath))
|
|
parentPathid = self.getParentPathId(parentpath)
|
|
query = ' '.join((
|
|
"UPDATE path",
|
|
"SET idParentPath = ?",
|
|
"WHERE idPath = ?"
|
|
))
|
|
self.cursor.execute(query, (parentPathid, pathid))
|
|
return pathid
|
|
|
|
def addPath(self, path, strHash=None):
|
|
# SQL won't return existing paths otherwise
|
|
if path is None:
|
|
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
|
|
if strHash is None:
|
|
query = (
|
|
'''
|
|
INSERT INTO path(
|
|
idPath, strPath)
|
|
|
|
VALUES (?, ?)
|
|
'''
|
|
)
|
|
self.cursor.execute(query, (pathid, path))
|
|
else:
|
|
query = (
|
|
'''
|
|
INSERT INTO path(
|
|
idPath, strPath, strHash)
|
|
|
|
VALUES (?, ?, ?)
|
|
'''
|
|
)
|
|
self.cursor.execute(query, (pathid, path, strHash))
|
|
|
|
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):
|
|
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))
|
|
|
|
def _getactorid(self, name):
|
|
"""
|
|
Crucial für sync speed!
|
|
"""
|
|
query = ' '.join((
|
|
"SELECT actor_id",
|
|
"FROM actor",
|
|
"WHERE name = ?",
|
|
"LIMIT 1"
|
|
))
|
|
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))
|
|
return actorid
|
|
|
|
def _addPerson(self, role, person_type, actorid, kodiid, mediatype,
|
|
castorder):
|
|
if "Actor" == person_type:
|
|
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" == 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 == "Writer":
|
|
query = '''
|
|
INSERT OR REPLACE INTO writer_link(
|
|
actor_id, media_id, media_type)
|
|
VALUES (?, ?, ?)
|
|
'''
|
|
self.cursor.execute(query, (actorid, kodiid, mediatype))
|
|
elif "Artist" == person_type:
|
|
query = '''
|
|
INSERT OR REPLACE INTO actor_link(
|
|
actor_id, media_id, media_type)
|
|
VALUES (?, ?, ?)
|
|
'''
|
|
self.cursor.execute(query, (actorid, kodiid, mediatype))
|
|
return castorder
|
|
|
|
def addPeople(self, kodiid, people, mediatype):
|
|
castorder = 0
|
|
for person in people:
|
|
actorid = self._getactorid(person['Name'])
|
|
# Link person to content
|
|
castorder = self._addPerson(person.get('Role'),
|
|
person['Type'],
|
|
actorid,
|
|
kodiid,
|
|
mediatype,
|
|
castorder)
|
|
# Add person image to art table
|
|
if person['imageurl']:
|
|
self.artwork.addOrUpdateArt(person['imageurl'], actorid,
|
|
person['Type'].lower(), "thumb",
|
|
self.cursor)
|
|
|
|
def existingArt(self, kodiId, mediaType, refresh=False):
|
|
"""
|
|
For kodiId, returns an artwork dict with already existing art from
|
|
the Kodi db
|
|
"""
|
|
# Only get EITHER poster OR thumb (should have same URL)
|
|
kodiToPKC = {
|
|
'banner': 'Banner',
|
|
'clearart': 'Art',
|
|
'clearlogo': 'Logo',
|
|
'discart': 'Disc',
|
|
'landscape': 'Thumb',
|
|
'thumb': 'Primary'
|
|
}
|
|
# BoxRear yet unused
|
|
result = {'BoxRear': ''}
|
|
for art in kodiToPKC:
|
|
query = ' '.join((
|
|
"SELECT url",
|
|
"FROM art",
|
|
"WHERE media_id = ?",
|
|
"AND media_type = ?",
|
|
"AND type = ?"
|
|
))
|
|
self.cursor.execute(query, (kodiId, mediaType, art,))
|
|
try:
|
|
url = self.cursor.fetchone()[0]
|
|
except TypeError:
|
|
url = ""
|
|
result[kodiToPKC[art]] = url
|
|
# There may be several fanart URLs saved
|
|
query = ' '.join((
|
|
"SELECT url",
|
|
"FROM art",
|
|
"WHERE media_id = ?",
|
|
"AND media_type = ?",
|
|
"AND type LIKE ?"
|
|
))
|
|
data = self.cursor.execute(query, (kodiId, mediaType, "fanart%",))
|
|
result['Backdrop'] = [d[0] for d in data]
|
|
return result
|
|
|
|
def addGenres(self, kodiid, genres, mediatype):
|
|
# 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))
|
|
|
|
def addStudios(self, kodiid, studios, mediatype):
|
|
for studio in studios:
|
|
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))
|
|
|
|
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 resume_points(self):
|
|
"""
|
|
VIDEOS
|
|
|
|
Returns all Kodi idFile that have a resume point set (not unwatched
|
|
ones or items that have already been completely watched)
|
|
"""
|
|
query = '''
|
|
SELECT idFile
|
|
FROM bookmark
|
|
'''
|
|
rows = self.cursor.execute(query)
|
|
ids = []
|
|
for row in rows:
|
|
ids.append(row[0])
|
|
return ids
|
|
|
|
def getUnplayedMusicItems(self):
|
|
"""
|
|
MUSIC
|
|
|
|
Returns all Kodi Item idFile that have not yet been completely played
|
|
"""
|
|
query = ' '.join((
|
|
"SELECT idSong",
|
|
"FROM song",
|
|
"WHERE iTimesPlayed = ?"
|
|
))
|
|
try:
|
|
rows = self.cursor.execute(query, (0, ))
|
|
except:
|
|
return []
|
|
ids = []
|
|
for row in rows:
|
|
ids.append(row[0])
|
|
return ids
|
|
|
|
def video_id_from_filename(self, filename, path):
|
|
"""
|
|
Returns the tuple (itemId, type) where
|
|
itemId: Kodi DB unique Id for either movie or episode
|
|
type: either 'movie' or 'episode'
|
|
|
|
Returns None if not found OR if too many entries were found
|
|
"""
|
|
query = ' '.join((
|
|
"SELECT idFile, idPath",
|
|
"FROM files",
|
|
"WHERE strFilename = ?"
|
|
))
|
|
self.cursor.execute(query, (filename,))
|
|
files = self.cursor.fetchall()
|
|
if len(files) == 0:
|
|
LOG.info('Did not find any file, abort')
|
|
return
|
|
query = ' '.join((
|
|
"SELECT strPath",
|
|
"FROM path",
|
|
"WHERE idPath = ?"
|
|
))
|
|
# result will contain a list of all idFile with matching filename and
|
|
# matching path
|
|
result = []
|
|
for file in files:
|
|
# Use idPath to get path as a string
|
|
self.cursor.execute(query, (file[1],))
|
|
try:
|
|
strPath = self.cursor.fetchone()[0]
|
|
except TypeError:
|
|
# idPath not found; skip
|
|
continue
|
|
# For whatever reason, double might have become triple
|
|
strPath = strPath.replace('///', '//')
|
|
strPath = strPath.replace('\\\\\\', '\\\\')
|
|
if strPath == path:
|
|
result.append(file[0])
|
|
if len(result) == 0:
|
|
LOG.info('Did not find matching paths, abort')
|
|
return
|
|
# Kodi seems to make ONE temporary entry; we only want the earlier,
|
|
# permanent one
|
|
if len(result) > 2:
|
|
LOG.warn('We found too many items with matching filenames and '
|
|
' paths, aborting')
|
|
return
|
|
idFile = result[0]
|
|
|
|
# Try movies first
|
|
query = ' '.join((
|
|
"SELECT idMovie",
|
|
"FROM movie",
|
|
"WHERE idFile = ?"
|
|
))
|
|
self.cursor.execute(query, (idFile,))
|
|
try:
|
|
itemId = self.cursor.fetchone()[0]
|
|
typus = v.KODI_TYPE_MOVIE
|
|
except TypeError:
|
|
# Try tv shows next
|
|
query = ' '.join((
|
|
"SELECT idEpisode",
|
|
"FROM episode",
|
|
"WHERE idFile = ?"
|
|
))
|
|
self.cursor.execute(query, (idFile,))
|
|
try:
|
|
itemId = self.cursor.fetchone()[0]
|
|
typus = v.KODI_TYPE_EPISODE
|
|
except TypeError:
|
|
LOG.warn('Unexpectantly did not find a match!')
|
|
return
|
|
return itemId, typus
|
|
|
|
def music_id_from_filename(self, filename, path):
|
|
"""
|
|
Returns the Kodi song_id from the Kodi music database or None if not
|
|
found OR something went wrong.
|
|
"""
|
|
query = '''
|
|
SELECT idPath
|
|
FROM path
|
|
WHERE strPath = ?
|
|
'''
|
|
self.cursor.execute(query, (path,))
|
|
path_id = self.cursor.fetchall()
|
|
if len(path_id) != 1:
|
|
LOG.error('Found wrong number of path ids: %s for path %s, abort',
|
|
path_id, path)
|
|
return
|
|
query = '''
|
|
SELECT idSong
|
|
FROM song
|
|
WHERE strFileName = ? AND idPath = ?
|
|
'''
|
|
self.cursor.execute(query, (filename, path_id[0]))
|
|
song_id = self.cursor.fetchall()
|
|
if len(song_id) != 1:
|
|
LOG.info('Found wrong number of songs %s, abort', song_id)
|
|
return
|
|
return song_id[0]
|
|
|
|
def getUnplayedItems(self):
|
|
"""
|
|
VIDEOS
|
|
|
|
Returns all Kodi Item idFile that have not yet been completely played
|
|
"""
|
|
query = ' '.join((
|
|
"SELECT idFile",
|
|
"FROM files",
|
|
"WHERE playCount IS NULL OR playCount = ''"
|
|
))
|
|
try:
|
|
rows = self.cursor.execute(query)
|
|
except:
|
|
return []
|
|
ids = []
|
|
for row in rows:
|
|
ids.append(row[0])
|
|
return ids
|
|
|
|
def getVideoRuntime(self, kodiid, mediatype):
|
|
if mediatype == v.KODI_TYPE_MOVIE:
|
|
query = ' '.join((
|
|
"SELECT c11",
|
|
"FROM movie",
|
|
"WHERE idMovie = ?",
|
|
))
|
|
elif mediatype == v.KODI_TYPE_EPISODE:
|
|
query = ' '.join((
|
|
"SELECT c09",
|
|
"FROM episode",
|
|
"WHERE idEpisode = ?",
|
|
))
|
|
self.cursor.execute(query, (kodiid,))
|
|
try:
|
|
runtime = self.cursor.fetchone()[0]
|
|
except TypeError:
|
|
return None
|
|
return int(runtime)
|
|
|
|
def get_resume(self, file_id):
|
|
"""
|
|
Returns the first resume point in seconds (int) if found, else None for
|
|
the Kodi file_id provided
|
|
"""
|
|
query = '''
|
|
SELECT timeInSeconds
|
|
FROM bookmark
|
|
WHERE idFile = ?
|
|
'''
|
|
self.cursor.execute(query, (file_id,))
|
|
resume = self.cursor.fetchone()
|
|
try:
|
|
resume = resume[0]
|
|
except TypeError:
|
|
resume = None
|
|
return resume
|
|
|
|
def delete_all_playstates(self):
|
|
"""
|
|
Entirely resets the table bookmark and thus all resume points
|
|
"""
|
|
self.cursor.execute("DELETE FROM bookmark")
|
|
|
|
def addPlaystate(self, fileid, resume_seconds, total_seconds, playcount,
|
|
dateplayed):
|
|
# Delete existing resume point
|
|
query = '''
|
|
DELETE FROM bookmark
|
|
WHERE idFile = ?
|
|
'''
|
|
self.cursor.execute(query, (fileid,))
|
|
# Set watched count
|
|
query = '''
|
|
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')
|
|
bookmark_id = self.cursor.fetchone()[0] + 1
|
|
query = '''
|
|
INSERT INTO bookmark(
|
|
idBookmark, idFile, timeInSeconds, totalTimeInSeconds,
|
|
thumbNailImage, player, playerState, type)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
|
'''
|
|
self.cursor.execute(query, (bookmark_id,
|
|
fileid,
|
|
resume_seconds,
|
|
total_seconds,
|
|
'',
|
|
"VideoPlayer",
|
|
'',
|
|
1))
|
|
|
|
def addTags(self, kodiid, tags, mediatype):
|
|
# First, delete any existing tags associated to the id
|
|
query = ' '.join((
|
|
|
|
"DELETE FROM tag_link",
|
|
"WHERE media_id = ?",
|
|
"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):
|
|
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))
|
|
|
|
def createTag(self, name):
|
|
# This will create and return the tag_id
|
|
query = ' '.join((
|
|
|
|
"SELECT tag_id",
|
|
"FROM tag",
|
|
"WHERE name = ?",
|
|
"COLLATE NOCASE"
|
|
))
|
|
self.cursor.execute(query, (name,))
|
|
try:
|
|
tag_id = self.cursor.fetchone()[0]
|
|
|
|
except TypeError:
|
|
self.cursor.execute("select coalesce(max(tag_id),0) from tag")
|
|
tag_id = self.cursor.fetchone()[0] + 1
|
|
|
|
query = "INSERT INTO tag(tag_id, name) values(?, ?)"
|
|
self.cursor.execute(query, (tag_id, name))
|
|
LOG.debug("Create tag_id: %s name: %s", tag_id, name)
|
|
return tag_id
|
|
|
|
def updateTag(self, oldtag, newtag, kodiid, mediatype):
|
|
try:
|
|
query = ' '.join((
|
|
|
|
"UPDATE tag_link",
|
|
"SET tag_id = ?",
|
|
"WHERE media_id = ?",
|
|
"AND media_type = ?",
|
|
"AND tag_id = ?"
|
|
))
|
|
self.cursor.execute(query, (newtag, kodiid, mediatype, oldtag,))
|
|
except Exception as e:
|
|
# The new tag we are going to apply already exists for this item
|
|
# delete current tag instead
|
|
query = ' '.join((
|
|
|
|
"DELETE FROM tag_link",
|
|
"WHERE media_id = ?",
|
|
"AND media_type = ?",
|
|
"AND tag_id = ?"
|
|
))
|
|
self.cursor.execute(query, (kodiid, mediatype, oldtag,))
|
|
|
|
def removeTag(self, kodiid, tagname, mediatype):
|
|
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,))
|
|
|
|
def addSets(self, movieid, collections, kodicursor):
|
|
for setname in collections:
|
|
setid = self.createBoxset(setname)
|
|
self.assignBoxset(setid, movieid)
|
|
|
|
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):
|
|
|
|
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))
|
|
|
|
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:
|
|
# Krypton has a dummy first entry idArtist: 1 strArtist:
|
|
# [Missing Tag] strMusicBrainzArtistID: Artist Tag Missing
|
|
if v.KODIVERSION >= 17:
|
|
self.cursor.execute(
|
|
"select coalesce(max(idArtist),1) from artist")
|
|
else:
|
|
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
|
|
query = (
|
|
'''
|
|
INSERT INTO album(idAlbum, strAlbum, strMusicBrainzAlbumID, strReleaseType)
|
|
|
|
VALUES (?, ?, ?, ?)
|
|
'''
|
|
)
|
|
self.cursor.execute(query, (albumid, name, musicbrainz, "album"))
|
|
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))
|
|
|
|
# Krypton only stuff ##############################
|
|
|
|
def update_userrating(self, kodi_id, kodi_type, userrating):
|
|
"""
|
|
Updates userrating for >=Krypton
|
|
"""
|
|
if kodi_type == v.KODI_TYPE_MOVIE:
|
|
ID = 'idMovie'
|
|
elif kodi_type == v.KODI_TYPE_EPISODE:
|
|
ID = 'idEpisode'
|
|
elif kodi_type == v.KODI_TYPE_SONG:
|
|
ID = 'idSong'
|
|
query = '''UPDATE %s SET userrating = ? WHERE ? = ?''' % kodi_type
|
|
self.cursor.execute(query, (userrating, ID, kodi_id))
|
|
|
|
def create_entry_uniqueid(self):
|
|
self.cursor.execute(
|
|
"select coalesce(max(uniqueid_id),0) from uniqueid")
|
|
return self.cursor.fetchone()[0] + 1
|
|
|
|
def add_uniqueid(self, *args):
|
|
"""
|
|
Feed with:
|
|
uniqueid_id: int
|
|
media_id: int
|
|
media_type: string
|
|
value: string
|
|
type: e.g. 'imdb' or 'tvdb'
|
|
"""
|
|
query = '''
|
|
INSERT INTO uniqueid(
|
|
uniqueid_id, media_id, media_type, value, type)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
'''
|
|
self.cursor.execute(query, (args))
|
|
|
|
def get_uniqueid(self, kodi_id, kodi_type):
|
|
query = '''
|
|
SELECT uniqueid_id FROM uniqueid
|
|
WHERE media_id = ? AND media_type = ?
|
|
'''
|
|
self.cursor.execute(query, (kodi_id, kodi_type))
|
|
try:
|
|
uniqueid = self.cursor.fetchone()[0]
|
|
except TypeError:
|
|
uniqueid = None
|
|
return uniqueid
|
|
|
|
def update_uniqueid(self, *args):
|
|
"""
|
|
Pass in media_id, media_type, value, type, uniqueid_id
|
|
"""
|
|
query = '''
|
|
UPDATE uniqueid
|
|
SET media_id = ?, media_type = ?, value = ?, type = ?
|
|
WHERE uniqueid_id = ?
|
|
'''
|
|
self.cursor.execute(query, (args))
|
|
|
|
def remove_uniqueid(self, kodi_id, kodi_type):
|
|
query = '''
|
|
DELETE FROM uniqueid
|
|
WHERE media_id = ? AND media_type = ?
|
|
'''
|
|
self.cursor.execute(query, (kodi_id, kodi_type))
|
|
|
|
def create_entry_rating(self):
|
|
self.cursor.execute("select coalesce(max(rating_id),0) from rating")
|
|
return self.cursor.fetchone()[0] + 1
|
|
|
|
def get_ratingid(self, kodi_id, kodi_type):
|
|
query = '''
|
|
SELECT rating_id FROM rating
|
|
WHERE media_id = ? AND media_type = ?
|
|
'''
|
|
self.cursor.execute(query, (kodi_id, kodi_type))
|
|
try:
|
|
ratingid = self.cursor.fetchone()[0]
|
|
except TypeError:
|
|
ratingid = None
|
|
return ratingid
|
|
|
|
def update_ratings(self, *args):
|
|
"""
|
|
Feed with media_id, media_type, rating_type, rating, votes, rating_id
|
|
"""
|
|
query = '''
|
|
UPDATE rating
|
|
SET media_id = ?,
|
|
media_type = ?,
|
|
rating_type = ?,
|
|
rating = ?,
|
|
votes = ?
|
|
WHERE rating_id = ?
|
|
'''
|
|
self.cursor.execute(query, (args))
|
|
|
|
def add_ratings(self, *args):
|
|
"""
|
|
feed with:
|
|
rating_id, media_id, media_type, rating_type, rating, votes
|
|
|
|
rating_type = 'default'
|
|
"""
|
|
query = '''
|
|
INSERT INTO rating(
|
|
rating_id, media_id, media_type, rating_type, rating, votes)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
'''
|
|
self.cursor.execute(query, (args))
|
|
|
|
def remove_ratings(self, kodi_id, kodi_type):
|
|
query = '''
|
|
DELETE FROM rating
|
|
WHERE media_id = ? AND media_type = ?
|
|
'''
|
|
self.cursor.execute(query, (kodi_id, kodi_type))
|
|
|
|
|
|
def kodiid_from_filename(path, kodi_type):
|
|
"""
|
|
Returns kodi_id if we have an item in the Kodi video or audio database with
|
|
said path. Feed with the Kodi itemtype, e.v. 'movie', 'song'
|
|
Returns None if not possible
|
|
"""
|
|
kodi_id = None
|
|
path = try_decode(path)
|
|
try:
|
|
filename = path.rsplit('/', 1)[1]
|
|
path = path.rsplit('/', 1)[0] + '/'
|
|
except IndexError:
|
|
filename = path.rsplit('\\', 1)[1]
|
|
path = path.rsplit('\\', 1)[0] + '\\'
|
|
if kodi_type == v.KODI_TYPE_SONG:
|
|
with GetKodiDB('music') as kodi_db:
|
|
try:
|
|
kodi_id, _ = kodi_db.music_id_from_filename(filename, path)
|
|
except TypeError:
|
|
LOG.debug('No Kodi audio db element found for path %s', path)
|
|
else:
|
|
with GetKodiDB('video') as kodi_db:
|
|
try:
|
|
kodi_id, _ = kodi_db.video_id_from_filename(filename, path)
|
|
except TypeError:
|
|
LOG.debug('No kodi video db element found for path %s', path)
|
|
return kodi_id
|