Jellyfin/jellyfin-kodi
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin-kodi.git synced 2025-05-20 16:25:08 +00:00
Code Issues Projects Releases Packages Wiki Activity

New hybrid method

Browse source
This commit is contained in:
angelblue05 2018-09-06 03:36:32 -05:00
parent 7f5084c62e
commit ace50b34dc
279 changed files with 39526 additions and 19994 deletions
Download patch file Download diff file Expand all files Collapse all files

284
resources/lib/database/__init__.py Normal file
View file

@ -0,0 +1,284 @@
# -*- coding: utf-8 -*-
#################################################################################################
import datetime
import logging
import json
import os
import sqlite3
import xbmc
import xbmcvfs
import emby_db
from helper import _, settings, window, dialog
from objects import obj
#################################################################################################
LOG = logging.getLogger("EMBY."+__name__)
#################################################################################################
class Database(object):
''' This should be called like a context.
i.e. with Database('emby') as db:
db.cursor
db.conn.commit()
'''
timeout = 120
def __init__(self, file=None, commit_close=True):
''' file: emby, texture, music, video, :memory: or path to file
'''
self.db_file = file or "video"
self.commit_close = commit_close
def __enter__(self):
''' Open the connection and return the Database class.
This is to allow for both the cursor and conn to be accessible.
at any time.
'''
self.conn = sqlite3.connect(self._sql(self.db_file), timeout=self.timeout)
self.cursor = self.conn.cursor()
if self.db_file in ('video', 'music', 'texture'):
self.conn.execute("PRAGMA journal_mode=WAL")
LOG.debug("--->[ database: %s ] %s", self.db_file, id(self.conn))
if self.db_file == 'emby':
emby_tables(self.cursor)
self.conn.commit()
return self
def _sql(self, file):
databases = obj.Objects().objects
return xbmc.translatePath(databases[file]).decode('utf-8') if file in databases else file
def __exit__(self, exc_type, exc_val, exc_tb):
''' Close the connection and cursor.
'''
changes = self.conn.total_changes
if exc_type is not None: # errors raised
LOG.error("type: %s value: %s", exc_type, exc_val)
if self.commit_close and changes:
LOG.info("[%s] %s rows updated.", self.db_file, changes)
self.conn.commit()
LOG.debug("---<[ database: %s ] %s", self.db_file, id(self.conn))
self.cursor.close()
self.conn.close()
def emby_tables(cursor):
''' Create the tables for the emby database.
emby, view, version
'''
cursor.execute(
"""CREATE TABLE IF NOT EXISTS emby(
emby_id TEXT UNIQUE, media_folder TEXT, emby_type TEXT, media_type TEXT,
kodi_id INTEGER, kodi_fileid INTEGER, kodi_pathid INTEGER, parent_id INTEGER,
checksum INTEGER)""")
cursor.execute(
"""CREATE TABLE IF NOT EXISTS view(
view_id TEXT UNIQUE, view_name TEXT, media_type TEXT)""")
cursor.execute("CREATE TABLE IF NOT EXISTS version(idVersion TEXT)")
def reset():
''' Reset both the emby database and the kodi database.
'''
from views import Views
views = Views()
if not dialog("yesno", heading="{emby}", line1=_(33074)):
return
window('emby_should_stop.bool', True)
count = 10
while window('emby_sync.bool'):
LOG.info("Sync is running...")
count -= 1
if not count:
dialog("ok", heading="{emby}", line1=_(33085))
return
if xbmc.Monitor().waitForAbort(1):
return
reset_kodi()
reset_emby()
views.delete_playlists()
views.delete_nodes()
if dialog("yesno", heading="{emby}", line1=_(33086)):
reset_artwork()
addon_data = xbmc.translatePath("special://profile/addon_data/plugin.video.emby/").decode('utf-8')
if dialog("yesno", heading="{emby}", line1=_(33087)):
xbmcvfs.delete(os.path.join(addon_data, "settings.xml"))
xbmcvfs.delete(os.path.join(addon_data, "data.json"))
LOG.info("[ reset settings ]")
if xbmcvfs.exists(os.path.join(addon_data, "sync.json")):
xbmcvfs.delete(os.path.join(addon_data, "sync.json"))
settings('MinimumSetup.bool', False)
settings('SyncInstallRunDone.bool', False)
dialog("ok", heading="{emby}", line1=_(33088))
xbmc.executebuiltin('RestartApp')
def reset_kodi():
with Database() as videodb:
videodb.cursor.execute("SELECT tbl_name FROM sqlite_master WHERE type='table'")
for table in videodb.cursor.fetchall():
name = table[0]
if name != 'version':
videodb.cursor.execute("DELETE FROM " + name)
if settings('enableMusic.bool'):
with Database('music') as musicdb:
musicdb.cursor.execute("SELECT tbl_name FROM sqlite_master WHERE type='table'")
for table in musicdb.cursor.fetchall():
name = table[0]
if name != 'version':
musicdb.cursor.execute("DELETE FROM " + name)
LOG.warn("[ reset kodi ]")
def reset_emby():
with Database('emby') as embydb:
embydb.cursor.execute("SELECT tbl_name FROM sqlite_master WHERE type='table'")
for table in embydb.cursor.fetchall():
name = table[0]
if name not in ('version', 'view'):
embydb.cursor.execute("DELETE FROM " + name)
embydb.cursor.execute("DROP table IF EXISTS emby")
embydb.cursor.execute("DROP table IF EXISTS view")
embydb.cursor.execute("DROP table IF EXISTS version")
LOG.warn("[ reset emby ]")
def reset_artwork():
''' Remove all existing texture.
'''
thumbnails = xbmc.translatePath('special://thumbnails/').decode('utf-8')
if xbmcvfs.exists(thumbnails):
dirs, ignore = xbmcvfs.listdir(thumbnails)
for directory in dirs:
ignore, thumbs = xbmcvfs.listdir(os.path.join(thumbnails, directory.decode('utf-8')))
for thumb in thumbs:
LOG.debug("DELETE thumbnail %s", thumb)
xbmcvfs.delete(os.path.join(thumbnails, directory.decode('utf-8'), thumb.decode('utf-8')))
with Database('texture') as texdb:
texdb.cursor.execute("SELECT tbl_name FROM sqlite_master WHERE type='table'")
for table in texdb.cursor.fetchall():
name = table[0]
if name != 'version':
texdb.cursor.execute("DELETE FROM " + name)
LOG.warn("[ reset artwork ]")
def get_sync():
path = xbmc.translatePath("special://profile/addon_data/plugin.video.emby/").decode('utf-8')
if not xbmcvfs.exists(path):
xbmcvfs.mkdirs(path)
try:
with open(os.path.join(path, 'sync.json')) as infile:
sync = json.load(infile)
except Exception:
sync = {'Libraries': [], 'RestorePoint': {}, 'Whitelist': []}
return sync
def save_sync(sync):
path = xbmc.translatePath("special://profile/addon_data/plugin.video.emby/").decode('utf-8')
if not xbmcvfs.exists(path):
xbmcvfs.mkdirs(path)
sync['Date'] = datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ')
with open(os.path.join(path, 'sync.json'), 'w') as outfile:
json.dump(sync, outfile, sort_keys=True, indent=4, ensure_ascii=False)
def get_credentials():
path = xbmc.translatePath("special://profile/addon_data/plugin.video.emby/").decode('utf-8')
if not xbmcvfs.exists(path):
xbmcvfs.mkdirs(path)
try:
with open(os.path.join(path, 'data.json')) as infile:
credentials = json.load(infile)
except Exception:
credentials = {'Servers': []}
return credentials
def save_credentials(credentials):
credentials = credentials or {}
path = xbmc.translatePath("special://profile/addon_data/plugin.video.emby/").decode('utf-8')
if not xbmcvfs.exists(path):
xbmcvfs.mkdirs(path)
with open(os.path.join(path, 'data.json'), 'w') as outfile:
json.dump(credentials, outfile, sort_keys=True, indent=4, ensure_ascii=False)
def get_item(kodi_id, media):
''' Get emby item based on kodi id and media.
'''
with Database('emby') as embydb:
item = emby_db.EmbyDatabase(embydb.cursor).get_full_item_by_kodi_id(kodi_id, media)
if not item:
LOG.debug("Not an emby item")
return
return item

417
resources/lib/database/emby_db.py Normal file
View file

@ -0,0 +1,417 @@
# -*- coding: utf-8 -*-
#################################################################################################
import logging
import queries as QU
##################################################################################################
LOG = logging.getLogger("EMBY."+__name__)
##################################################################################################
class EmbyDatabase():
def __init__(self, cursor):
self.cursor = cursor
def get_item_by_id(self, *args):
self.cursor.execute(QU.get_item, args)
return self.cursor.fetchone()
def add_reference(self, *args):
self.cursor.execute(QU.add_reference, args)
def update_reference(self, *args):
self.cursor.execute(QU.update_reference, args)
def update_parent_id(self, *args):
''' Parent_id is the parent Kodi id.
'''
self.cursor.execute(QU.update_parent, args)
def get_item_id_by_parent_id(self, *args):
self.cursor.execute(QU.get_item_id_by_parent, args)
return self.cursor.fetchall()
def get_item_by_parent_id(self, *args):
self.cursor.execute(QU.get_item_by_parent, args)
return self.cursor.fetchall()
def get_item_by_media_folder(self, *args):
self.cursor.execute(QU.get_item_by_media_folder, args)
return self.cursor.fetchall()
def get_item_by_wild_id(self, item_id):
self.cursor.execute(QU.get_item_by_wild, (item_id + "%",))
return self.cursor.fetchall()
def get_checksum(self, *args):
self.cursor.execute(QU.get_checksum, args)
return self.cursor.fetchall()
def get_item_by_kodi_id(self, *args):
try:
self.cursor.execute(QU.get_item_by_kodi, args)
return self.cursor.fetchone()[0]
except TypeError:
return
def get_full_item_by_kodi_id(self, *args):
try:
self.cursor.execute(QU.get_item_by_kodi, args)
return self.cursor.fetchone()
except TypeError:
return
def get_media_by_id(self, *args):
try:
self.cursor.execute(QU.get_media_by_id, args)
return self.cursor.fetchone()[0]
except TypeError:
return
def remove_item(self, *args):
self.cursor.execute(QU.delete_item, args)
def remove_items_by_parent_id(self, *args):
self.cursor.execute(QU.delete_item_by_parent, args)
def remove_item_by_kodi_id(self, *args):
self.cursor.execute(QU.delete_item_by_kodi, args)
def remove_wild_item(self, item_id):
self.cursor.execute(QU.delete_item_by_wild, (item_id + "%",))
def get_view_name(self, item_id):
try:
self.cursor.execute(QU.get_view_name, (item_id,))
return self.cursor.fetchone()[0]
except Exception as error:
return
def get_view(self, *args):
try:
self.cursor.execute(QU.get_view, args)
return self.cursor.fetchone()
except TypeError:
return
def add_view(self, *args):
self.cursor.execute(QU.add_view, args)
def remove_view(self, *args):
self.cursor.execute(QU.delete_view, args)
def get_views(self, *args):
self.cursor.execute(QU.get_views, args)
return self.cursor.fetchall()
def get_items_by_media(self, *args):
self.cursor.execute(QU.get_items_by_media, args)
return self.cursor.fetchall()
"""
def get_version(self, version=None):
if version is not None:
self.embycursor.execute("DELETE FROM version")
query = "INSERT INTO version(idVersion) VALUES (?)"
self.embycursor.execute(query, (version,))
else:
query = "SELECT idVersion FROM version"
self.embycursor.execute(query)
try:
version = self.embycursor.fetchone()[0]
except TypeError:
pass
return version
def getViews(self):
views = []
query = ' '.join((
"SELECT view_id",
"FROM view"
))
self.embycursor.execute(query)
rows = self.embycursor.fetchall()
for row in rows:
views.append(row[0])
return views
def getView_embyId(self, item_id):
# Returns ancestors using embyId
url = "{server}/emby/Items/%s/Ancestors?UserId={UserId}&format=json" % item_id
try:
view_list = self.download(url)
except Exception as error:
log.info("Error getting views: " + str(error))
view_list = []
if view_list is None:
view_list = []
for view in view_list:
if view['Type'] == "CollectionFolder":
# Found view
view_id = view['Id']
break
else: # No view found
return [None, None]
# Compare to view table in emby database
query = ' '.join((
"SELECT view_name",
"FROM view",
"WHERE view_id = ?"
))
self.embycursor.execute(query, (view_id,))
try:
view_name = self.embycursor.fetchone()[0]
except TypeError:
view_name = None
return [view_name, view_id]
def getView_byId(self, viewid):
query = ' '.join((
"SELECT view_name, media_type, kodi_tagid",
"FROM view",
"WHERE view_id = ?"
))
self.embycursor.execute(query, (viewid,))
view = self.embycursor.fetchone()
return view
def getView_byType(self, mediatype):
views = []
query = ' '.join((
"SELECT view_id, view_name",
"FROM view",
"WHERE media_type = ?"
))
self.embycursor.execute(query, (mediatype,))
rows = self.embycursor.fetchall()
for row in rows:
views.append({
'id': row[0],
'name': row[1],
'mediatype': mediatype
})
if mediatype in ('tvshows', 'movies'):
query = ' '.join((
"SELECT view_id, view_name",
"FROM view",
"WHERE media_type = ?"
))
self.embycursor.execute(query, ("mixed",))
rows = self.embycursor.fetchall()
for row in rows:
views.append({
'id': row[0],
'name': row[1],
'mediatype': "mixed"
})
return views
def getView_byName(self, tagname):
query = ' '.join((
"SELECT view_id",
"FROM view",
"WHERE view_name = ?"
))
self.embycursor.execute(query, (tagname,))
try:
view = self.embycursor.fetchone()[0]
except TypeError:
view = None
return view
def addView(self, embyid, name, mediatype, tagid, group_series):
query = (
'''
INSERT INTO view(
view_id, view_name, media_type, kodi_tagid, group_series)
VALUES (?, ?, ?, ?, ?)
'''
)
self.embycursor.execute(query, (embyid, name, mediatype, tagid, group_series))
def get_view_grouped_series(self, view_id):
query = ' '.join((
"SELECT group_series",
"FROM view",
"WHERE view_id = ?"
))
try:
self.embycursor.execute(query, (view_id,))
return self.embycursor.fetchone()
except: return False
def update_view_grouped_series(self, view_id, group_series):
query = ' '.join((
"UPDATE view",
"SET group_series = ?",
"WHERE view_id = ?"
))
self.embycursor.execute(query, (group_series, view_id))
def updateView(self, name, tagid, mediafolderid):
query = ' '.join((
"UPDATE view",
"SET view_name = ?, kodi_tagid = ?",
"WHERE view_id = ?"
))
self.embycursor.execute(query, (name, tagid, mediafolderid))
def removeView(self, viewid):
query = ' '.join((
"DELETE FROM view",
"WHERE view_id = ?"
))
self.embycursor.execute(query, (viewid,))
def getItem_byId(self, embyid):
query = ' '.join((
"SELECT kodi_id, kodi_fileid, kodi_pathid, parent_id, media_type, emby_type",
"FROM emby",
"WHERE emby_id = ?"
))
try:
self.embycursor.execute(query, (embyid,))
item = self.embycursor.fetchone()
return item
except: return None
def getItem_byView(self, mediafolderid):
query = ' '.join((
"SELECT kodi_id",
"FROM emby",
"WHERE media_folder = ?"
))
self.embycursor.execute(query, (mediafolderid,))
return self.embycursor.fetchall()
def get_item_by_view(self, view_id):
query = ' '.join((
"SELECT emby_id",
"FROM emby",
"WHERE media_folder = ?"
))
self.embycursor.execute(query, (view_id,))
return self.embycursor.fetchall()
def get_checksum_by_view(self, media_type, view_id):
query = ' '.join((
"SELECT emby_id, checksum",
"FROM emby",
"WHERE emby_type = ?",
"AND media_folder = ?"
))
self.embycursor.execute(query, (media_type, view_id,))
return self.embycursor.fetchall()
def getMediaType_byId(self, embyid):
query = ' '.join((
"SELECT emby_type",
"FROM emby",
"WHERE emby_id = ?"
))
self.embycursor.execute(query, (embyid,))
try:
itemtype = self.embycursor.fetchone()[0]
except TypeError:
itemtype = None
return itemtype
def sortby_mediaType(self, itemids, unsorted=True):
sorted_items = {}
for itemid in itemids:
mediatype = self.getMediaType_byId(itemid)
if mediatype:
sorted_items.setdefault(mediatype, []).append(itemid)
elif unsorted:
sorted_items.setdefault('Unsorted', []).append(itemid)
return sorted_items
"""

158
resources/lib/database/queries.py Normal file
View file

@ -0,0 +1,158 @@
get_item = """ SELECT kodi_id, kodi_fileid, kodi_pathid, parent_id, media_type,
emby_type, media_folder
FROM emby
WHERE emby_id = ?
"""
get_item_obj = [ "{Id}"
]
get_item_series_obj = [ "{SeriesId}"
]
get_item_song_obj = [ "{SongAlbumId}"
]
get_item_id_by_parent = """ SELECT emby_id, kodi_id
FROM emby
WHERE parent_id = ?
AND media_type = ?
"""
get_item_id_by_parent_boxset_obj = [ "{SetId}","movie"
]
get_item_by_parent = """ SELECT emby_id, kodi_id, kodi_fileid
FROM emby
WHERE parent_id = ?
AND media_type = ?
"""
get_item_by_media_folder = """ SELECT emby_id, emby_type
FROM emby
WHERE media_folder = ?
"""
get_item_by_parent_movie_obj = [ "{KodiId}","movie"
]
get_item_by_parent_tvshow_obj = [ "{ParentId}","tvshow"
]
get_item_by_parent_season_obj = [ "{ParentId}","season"
]
get_item_by_parent_episode_obj = [ "{ParentId}","episode"
]
get_item_by_parent_album_obj = [ "{ParentId}","album"
]
get_item_by_parent_song_obj = [ "{ParentId}","song"
]
get_item_by_wild = """ SELECT kodi_id, media_type
FROM emby
WHERE emby_id LIKE ?
"""
get_item_by_wild_obj = [ "{Id}"
]
get_item_by_kodi = """ SELECT emby_id, parent_id, media_folder, emby_type, checksum
FROM emby
WHERE kodi_id = ?
AND media_type = ?
"""
get_checksum = """ SELECT emby_id, checksum
FROM emby
WHERE emby_type = ?
"""
get_view_name = """ SELECT view_name
FROM view
WHERE view_id = ?
"""
get_media_by_id = """ SELECT emby_type
FROM emby
WHERE emby_id = ?
"""
get_view = """ SELECT view_name, media_type
FROM view
WHERE view_id = ?
"""
get_views = """ SELECT *
FROM view
"""
get_items_by_media = """ SELECT emby_id
FROM emby
WHERE media_type = ?
"""
add_reference = """ INSERT OR REPLACE INTO emby(emby_id, kodi_id, kodi_fileid, kodi_pathid, emby_type,
media_type, parent_id, checksum, media_folder)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
"""
add_reference_movie_obj = [ "{Id}","{MovieId}","{FileId}","{PathId}","Movie","movie", None,"{Checksum}","{LibraryId}"
]
add_reference_boxset_obj = [ "{Id}","{SetId}",None,None,"BoxSet","set",None,"{Checksum}",None
]
add_reference_tvshow_obj = [ "{Id}","{ShowId}",None,"{PathId}","Series","tvshow",None,"{Checksum}","{LibraryId}"
]
add_reference_season_obj = [ "{Id}","{SeasonId}",None,None,"Season","season","{ShowId}",None,None
]
add_reference_pool_obj = [ "{SeriesId}","{ShowId}",None,"{PathId}","Series","tvshow",None,"{Checksum}","{LibraryId}"
]
add_reference_episode_obj = [ "{Id}","{EpisodeId}","{FileId}","{PathId}","Episode","episode","{SeasonId}","{Checksum}",None
]
add_reference_mvideo_obj = [ "{Id}","{MvideoId}","{FileId}","{PathId}","MusicVideo","musicvideo",None,"{Checksum}",
"{LibraryId}"
]
add_reference_artist_obj = [ "{Id}","{ArtistId}",None,None,"{ArtistType}","artist",None,"{Checksum}","{LibraryId}"
]
add_reference_album_obj = [ "{Id}","{AlbumId}",None,None,"MusicAlbum","album",None,"{Checksum}",None
]
add_reference_song_obj = [ "{Id}","{SongId}",None,"{PathId}","Audio","song","{AlbumId}","{Checksum}",None
]
add_view = """ INSERT OR REPLACE INTO view(view_id, view_name, media_type)
VALUES (?, ?, ?)
"""
update_reference = """ UPDATE emby
SET checksum = ?
WHERE emby_id = ?
"""
update_reference_obj = [ "{Checksum}", "{Id}"
]
update_parent = """ UPDATE emby
SET parent_id = ?
WHERE emby_id = ?
"""
update_parent_movie_obj = [ "{SetId}","{Id}"
]
update_parent_episode_obj = [ "{SeasonId}","{Id}"
]
update_parent_album_obj = [ "{ArtistId}","{AlbumId}"]
delete_item = """ DELETE FROM emby
WHERE emby_id = ?
"""
delete_item_obj = [ "{Id}"
]
delete_item_by_parent = """ DELETE FROM emby
WHERE parent_id = ?
AND media_type = ?
"""
delete_item_by_parent_tvshow_obj = [ "{ParentId}","tvshow"
]
delete_item_by_parent_season_obj = [ "{ParentId}","season"
]
delete_item_by_parent_episode_obj = [ "{ParentId}","episode"
]
delete_item_by_parent_song_obj = [ "{ParentId}","song"
]
delete_item_by_parent_artist_obj = [ "{ParentId}","artist"
]
delete_item_by_parent_album_obj = [ "{KodiId}","album"
]
delete_item_by_kodi = """ DELETE FROM emby
WHERE kodi_id = ?
AND media_type = ?
"""
delete_item_by_wild = """ DELETE FROM emby
WHERE emby_id LIKE ?
"""
delete_view = """ DELETE FROM view
WHERE view_id = ?
"""
delete_parent_boxset_obj = [ None, "{Movie}"
]