PlexKodiConnect/resources/lib/kodi_db/video.py
2018-11-13 07:47:37 +01:00

985 lines
38 KiB
Python

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import absolute_import, division, unicode_literals
from logging import getLogger
from sqlite3 import IntegrityError
from . import common
from .. import path_ops, utils, variables as v, state
LOG = getLogger('PLEX.kodi_db.video')
class KodiVideoDB(common.KodiDBBase):
db_kind = 'video'
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.get_path('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.get_path('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 parent_path_id(self, path):
"""
Video DB: Adds all subdirectories to path table while setting a "trail"
of parent path ids
"""
parentpath = path_ops.path.abspath(
path_ops.path.join(path,
path_ops.decode_path(path_ops.path.pardir)))
pathid = self.get_path(parentpath)
if pathid is None:
self.cursor.execute("SELECT COALESCE(MAX(idPath),0) FROM path")
pathid = self.cursor.fetchone()[0] + 1
datetime = utils.unix_date_to_kodi(utils.unix_timestamp())
self.cursor.execute('''
INSERT INTO path(idPath, strPath, dateAdded)
VALUES (?, ?, ?)
''',
(pathid, parentpath, datetime))
if parentpath != path:
# In case we end up having media in the filesystem root, C:\
parent_id = self.parent_path_id(parentpath)
self.cursor.execute('UPDATE path SET idParentPath = ? WHERE idPath = ?',
(parent_id, pathid))
return pathid
def add_path(self, path, date_added=None, id_parent_path=None,
content=None, scraper=None):
"""
Returns the idPath from the path table. Creates a new entry if path
[unicode] does not yet exist (using date_added [kodi date type],
id_parent_path [int], content ['tvshows', 'movies', None], scraper
[usually 'metadata.local'])
WILL activate noUpdate for the path!
"""
path = '' if path is None else path
self.cursor.execute('SELECT idPath FROM path WHERE strPath = ? LIMIT 1',
(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
self.cursor.execute('''
INSERT INTO path(
idPath,
strPath,
dateAdded,
idParentPath,
strContent,
strScraper,
noUpdate)
VALUES (?, ?, ?, ?, ?, ?, ?)
''',
(pathid, path, date_added, id_parent_path,
content, scraper, 1))
return pathid
def get_path(self, path):
"""
Returns the idPath from the path table for path [unicode] or None
"""
self.cursor.execute('SELECT idPath FROM path WHERE strPath = ?',
(path, ))
try:
return self.cursor.fetchone()[0]
except TypeError:
pass
def add_file(self, filename, path_id, date_added):
"""
Adds the filename [unicode] to the table files if not already added
and returns the idFile.
"""
self.cursor.execute('SELECT COALESCE(MAX(idFile), 0) FROM files')
file_id = self.cursor.fetchone()[0] + 1
self.cursor.execute('''
INSERT INTO files(
idFile,
idPath,
strFilename,
dateAdded)
VALUES (?, ?, ?, ?)
''',
(file_id, path_id, filename, date_added))
return file_id
def modify_file(self, filename, path_id, date_added):
self.cursor.execute('SELECT idFile FROM files WHERE idPath = ? AND strFilename = ?',
(path_id, filename))
try:
file_id = self.cursor.fetchone()[0]
except TypeError:
file_id = self.add_file(filename, path_id, date_added)
return file_id
def obsolete_file_ids(self):
"""
Returns a generator for idFile of all Kodi file ids that do not have a
dateAdded set (dateAdded NULL) and the filename start with
'plugin://plugin.video.plexkodiconnect'
These entries should be deleted as they're created falsely by Kodi.
"""
return (x[0] for x in self.cursor.execute('''
SELECT idFile FROM files
WHERE dateAdded IS NULL
AND strFilename LIKE \'plugin://plugin.video.plexkodiconnect%\'
'''))
def show_id_from_path(self, path):
"""
Returns the idShow for path [unicode] or None
"""
self.cursor.execute('SELECT idPath FROM path WHERE strPath = ? LIMIT 1',
(path, ))
try:
path_id = self.cursor.fetchone()[0]
except TypeError:
return
self.cursor.execute('SELECT idShow FROM tvshowlinkpath WHERE idPath = ? LIMIT 1',
(path_id, ))
try:
return self.cursor.fetchone()[0]
except TypeError:
pass
def remove_file(self, file_id, remove_orphans=True, plex_type=None):
"""
Removes the entry for file_id from the files table. Will also delete
entries from the associated tables: bookmark, settings, streamdetails.
If remove_orphans is true, this method will delete any orphaned path
entries in the Kodi path table
Passing plex_type = v.PLEX_TYPE_EPISODE deletes any secondary files for
add-on paths
"""
if not state.DIRECT_PATHS and plex_type == v.PLEX_TYPE_EPISODE:
# Hack for the 2 entries for episodes for addon paths
self.cursor.execute('SELECT strFilename FROM files WHERE idFile = ? LIMIT 1',
(file_id, ))
filename = self.cursor.fetchone()
if not filename:
LOG.error('Could not find file_id %s', file_id)
return
for new_id in self.cursor.execute('SELECT idFile FROM files WHERE strFilename = ? LIMIT 2',
(filename[0], )):
self.remove_file(new_id[0], remove_orphans=remove_orphans)
return
self.cursor.execute('SELECT idPath FROM files WHERE idFile = ? LIMIT 1',
(file_id,))
try:
path_id = self.cursor.fetchone()[0]
except TypeError:
return
self.cursor.execute('DELETE FROM files WHERE idFile = ?',
(file_id,))
self.cursor.execute('DELETE FROM bookmark WHERE idFile = ?',
(file_id,))
self.cursor.execute('DELETE FROM settings WHERE idFile = ?',
(file_id,))
self.cursor.execute('DELETE FROM streamdetails WHERE idFile = ?',
(file_id,))
self.cursor.execute('DELETE FROM stacktimes WHERE idFile = ?',
(file_id,))
if remove_orphans:
# Delete orphaned path entry
self.cursor.execute('SELECT idFile FROM files WHERE idPath = ? LIMIT 1',
(path_id,))
if self.cursor.fetchone() is None:
self.cursor.execute('DELETE FROM path WHERE idPath = ?',
(path_id,))
def _modify_link_and_table(self, kodi_id, kodi_type, entries, link_table,
table, key, first_id=None):
first_id = first_id if first_id is not None else 1
entry_ids = []
for entry in entries:
self.cursor.execute('''
SELECT %s FROM %s WHERE name = ? COLLATE NOCASE LIMIT 1
''' % (key, table), (entry, ))
try:
entry_id = self.cursor.fetchone()[0]
except TypeError:
self.cursor.execute('SELECT COALESCE(MAX(%s), %s) FROM %s'
% (key, first_id - 1, table))
entry_id = self.cursor.fetchone()[0] + 1
self.cursor.execute('INSERT INTO %s(%s, name) values(?, ?)'
% (table, key), (entry_id, entry))
finally:
entry_ids.append(entry_id)
# Now process the ids obtained from the names
# Get the existing, old entries
outdated_entries = []
for entry_id in self.cursor.execute('SELECT %s FROM %s WHERE media_id = ? AND media_type = ?'
% (key, link_table), (kodi_id, kodi_type)):
try:
entry_ids.remove(entry_id[0])
except ValueError:
outdated_entries.append(entry_id[0])
# Add all new entries that haven't already been added
for entry_id in entry_ids:
try:
self.cursor.execute('INSERT INTO %s VALUES (?, ?, ?)' % link_table,
(entry_id, kodi_id, kodi_type))
except IntegrityError:
LOG.info('IntegrityError: skipping entry %s for table %s',
entry_id, link_table)
# Delete all outdated references in the link table. Also check whether
# we need to delete orphaned entries in the master table
for entry_id in outdated_entries:
self.cursor.execute('''
DELETE FROM %s WHERE %s = ? AND media_id = ? AND media_type = ?
''' % (link_table, key), (entry_id, kodi_id, kodi_type))
self.cursor.execute('SELECT %s FROM %s WHERE %s = ?' % (key, link_table, key),
(entry_id, ))
if self.cursor.fetchone() is None:
# Delete in the original table because entry is now orphaned
self.cursor.execute('DELETE FROM %s WHERE %s = ?' % (table, key),
(entry_id, ))
def modify_countries(self, kodi_id, kodi_type, countries=None):
"""
Writes a country (string) in the list countries into the Kodi DB. Will
also delete any orphaned country entries.
"""
self._modify_link_and_table(kodi_id,
kodi_type,
countries if countries else [],
'country_link',
'country',
'country_id')
def modify_genres(self, kodi_id, kodi_type, genres=None):
"""
Writes a country (string) in the list countries into the Kodi DB. Will
also delete any orphaned country entries.
"""
self._modify_link_and_table(kodi_id,
kodi_type,
genres if genres else [],
'genre_link',
'genre',
'genre_id')
def modify_studios(self, kodi_id, kodi_type, studios=None):
"""
Writes a country (string) in the list countries into the Kodi DB. Will
also delete any orphaned country entries.
"""
self._modify_link_and_table(kodi_id,
kodi_type,
studios if studios else [],
'studio_link',
'studio',
'studio_id')
def modify_tags(self, kodi_id, kodi_type, tags=None):
"""
Writes a country (string) in the list countries into the Kodi DB. Will
also delete any orphaned country entries.
"""
self._modify_link_and_table(kodi_id,
kodi_type,
tags if tags else [],
'tag_link',
'tag',
'tag_id')
def add_people(self, kodi_id, kodi_type, people):
"""
Makes sure that actors, directors and writers are recorded correctly
for the elmement kodi_id, kodi_type.
Will also delete a freshly orphaned actor entry.
"""
for kind, people_list in people.iteritems():
self._add_people_kind(kodi_id, kodi_type, kind, people_list)
def _add_people_kind(self, kodi_id, kodi_type, kind, people_list):
# Save new people to Kodi DB by iterating over the remaining entries
if kind == 'actor':
for person in people_list:
# Make sure the person entry in table actor exists
actor_id = self._get_actor_id(person[0], art_url=person[1])
# Link the person with the media element
try:
self.cursor.execute('INSERT INTO actor_link VALUES (?, ?, ?, ?, ?)',
(actor_id, kodi_id, kodi_type,
person[2], person[3]))
except IntegrityError:
# With Kodi, an actor may have only one role, unlike Plex
pass
else:
for person in people_list:
# Make sure the person entry in table actor exists:
actor_id = self._get_actor_id(person[0])
# Link the person with the media element
try:
self.cursor.execute('INSERT INTO %s_link VALUES (?, ?, ?)' % kind,
(actor_id, kodi_id, kodi_type))
except IntegrityError:
# Again, Kodi may have only one person assigned to a role
pass
def modify_people(self, kodi_id, kodi_type, people=None):
"""
Makes sure that actors, directors and writers are recorded correctly
for the elmement kodi_id, kodi_type.
Will also delete a freshly orphaned actor entry.
"""
for kind, people_list in (people if people else
{'actor': [],
'director': [],
'writer': []}).iteritems():
self._modify_people_kind(kodi_id, kodi_type, kind, people_list)
def _modify_people_kind(self, kodi_id, kodi_type, kind, people_list):
# Get the people already saved in the DB for this specific item
if kind == 'actor':
query = '''
SELECT actor.actor_id, actor.name, art.url, actor_link.role,
actor_link.cast_order
FROM actor_link
LEFT JOIN actor ON actor.actor_id = actor_link.actor_id
LEFT JOIN art ON (art.media_id = actor_link.actor_id AND
art.media_type = 'actor')
WHERE actor_link.media_id = ? AND actor_link.media_type = ?
'''
else:
query = '''
SELECT actor.actor_id, actor.name
FROM {0}_link
LEFT JOIN actor ON actor.actor_id = {0}_link.actor_id
WHERE {0}_link.media_id = ? AND {0}_link.media_type = ?
'''.format(kind)
self.cursor.execute(query, (kodi_id, kodi_type))
old_people = self.cursor.fetchall()
# Determine which people we need to save or delete
outdated_people = []
for person in old_people:
try:
people_list.remove(person[1:])
except ValueError:
outdated_people.append(person)
# Get rid of old entries
query = '''
DELETE FROM %s_link
WHERE actor_id = ? AND media_id = ? AND media_type = ?
''' % kind
query_actor_check = 'SELECT actor_id FROM %s_link WHERE actor_id = ?'
query_actor_delete = 'DELETE FROM actor WHERE actor_id = ?'
for person in outdated_people:
# Delete the outdated entry
self.cursor.execute(query, (person[0], kodi_id, kodi_type))
# Do we now have orphaned entries?
for person_kind in ('actor', 'writer', 'director'):
self.cursor.execute(query_actor_check % person_kind,
(person[0],))
if self.cursor.fetchone() is not None:
break
else:
# person entry in actor table is now orphaned
# Delete the person from actor table
self.cursor.execute(query_actor_delete, (person[0],))
if kind == 'actor':
# Delete any associated artwork
self.delete_artwork(person[0], 'actor')
# Save new people to Kodi DB by iterating over the remaining entries
self._add_people_kind(kodi_id, kodi_type, kind, people_list)
def _get_actor_id(self, name, art_url=None):
"""
Returns the actor_id [int] for name [unicode] in table actor (without
ensuring that the name matches).
If not, will create a new record with actor_id, name, art_url
Uses Plex ids and thus assumes that Plex person id is unique!
"""
self.cursor.execute('SELECT actor_id FROM actor WHERE name=? LIMIT 1',
(name,))
try:
return self.cursor.fetchone()[0]
except TypeError:
# Not yet in actor DB, add person
self.cursor.execute('SELECT COALESCE(MAX(actor_id),0) FROM actor')
actor_id = self.cursor.fetchone()[0] + 1
self.cursor.execute('INSERT INTO actor(actor_id, name) '
'VALUES (?, ?)',
(actor_id, name))
if art_url:
self.add_art(art_url, actor_id, 'actor', 'thumb')
return actor_id
def get_art(self, kodi_id, kodi_type):
"""
Returns a dict of all available artwork with unicode urls/paths:
{
'thumb'
'poster'
'banner'
'clearart'
'clearlogo'
'discart'
'fanart' and also potentially more fanart 'fanart1', 'fanart2',
}
Missing fanart will not appear in the dict. 'landscape' and 'icon'
might be implemented in the future.
"""
self.cursor.execute('SELECT type, url FROM art WHERE media_id=? AND media_type=?',
(kodi_id, kodi_type))
return dict(self.cursor.fetchall())
def modify_streams(self, fileid, streamdetails=None, runtime=None):
"""
Leave streamdetails and runtime empty to delete all stream entries for
fileid
"""
# First remove any existing entries
self.cursor.execute('DELETE FROM streamdetails WHERE idFile = ?',
(fileid,))
if not streamdetails:
return
for videotrack in streamdetails['video']:
self.cursor.execute('''
INSERT INTO streamdetails(
idFile, iStreamType, strVideoCodec, fVideoAspect,
iVideoWidth, iVideoHeight, iVideoDuration ,strStereoMode)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
''', (fileid, 0, videotrack['codec'],
videotrack['aspect'], videotrack['width'],
videotrack['height'], runtime,
videotrack['video3DFormat']))
for audiotrack in streamdetails['audio']:
self.cursor.execute('''
INSERT INTO streamdetails(
idFile, iStreamType, strAudioCodec, iAudioChannels,
strAudioLanguage)
VALUES (?, ?, ?, ?, ?)
''', (fileid, 1, audiotrack['codec'],
audiotrack['channels'],
audiotrack['language']))
for subtitletrack in streamdetails['subtitle']:
self.cursor.execute('''
INSERT INTO streamdetails(idFile, iStreamType,
strSubtitleLanguage)
VALUES (?, ?, ?)
''', (fileid, 2, subtitletrack))
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
"""
self.cursor.execute('SELECT idFile, idPath FROM files WHERE strFilename = ?',
(filename,))
files = self.cursor.fetchall()
if len(files) == 0:
LOG.info('Did not find any file, abort')
return
# 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('SELECT strPath FROM path WHERE idPath = ?',
(file[1], ))
try:
path_str = self.cursor.fetchone()[0]
except TypeError:
# idPath not found; skip
continue
# For whatever reason, double might have become triple
path_str = path_str.replace('///', '//').replace('\\\\\\', '\\\\')
if path_str == 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
file_id = result[0]
# Try movies first
self.cursor.execute('SELECT idMovie FROM movie WHERE idFile = ?',
(file_id, ))
try:
movie_id = self.cursor.fetchone()[0]
typus = v.KODI_TYPE_MOVIE
except TypeError:
# Try tv shows next
self.cursor.execute('SELECT idEpisode FROM episode WHERE idFile = ?',
(file_id, ))
try:
movie_id = self.cursor.fetchone()[0]
typus = v.KODI_TYPE_EPISODE
except TypeError:
LOG.debug('Did not find a video DB match')
return
return movie_id, typus
def get_resume(self, file_id):
"""
Returns the first resume point in seconds (int) if found, else None for
the Kodi file_id provided
"""
self.cursor.execute('SELECT timeInSeconds FROM bookmark WHERE idFile = ? LIMIT 1',
(file_id,))
try:
return self.cursor.fetchone()[0]
except TypeError:
pass
def get_playcount(self, file_id):
"""
Returns the playcount for the item file_id or None if not found
"""
self.cursor.execute('SELECT playCount FROM files WHERE idFile = ? LIMIT 1',
(file_id, ))
try:
return self.cursor.fetchone()[0]
except TypeError:
pass
def set_resume(self, file_id, resume_seconds, total_seconds, playcount,
dateplayed, plex_type):
"""
Adds a resume marker for a video library item. Will even set 2,
considering add-on path widget hacks.
"""
if not state.DIRECT_PATHS and plex_type == v.PLEX_TYPE_EPISODE:
# Need to make sure to set a SECOND bookmark entry for another,
# second file_id that points to the path .tvshows instead of
# .tvshows/<plex show id/!
self.cursor.execute('SELECT strFilename FROM files WHERE idFile = ? LIMIT 1',
(file_id, ))
for new_id in self.cursor.execute('SELECT idFile FROM files WHERE strFilename = ? LIMIT 2',
(self.cursor.fetchone()[0], )):
self.set_resume(new_id[0], resume_seconds, total_seconds,
playcount, dateplayed, None)
return
# Delete existing resume point
self.cursor.execute('DELETE FROM bookmark WHERE idFile = ?', (file_id,))
# Set watched count
self.cursor.execute('UPDATE files SET playCount = ?, lastPlayed = ? WHERE idFile = ?',
(playcount, dateplayed, file_id))
# Set the resume bookmark
if resume_seconds:
self.cursor.execute(
'SELECT COALESCE(MAX(idBookmark), 0) FROM bookmark')
bookmark_id = self.cursor.fetchone()[0] + 1
self.cursor.execute('''
INSERT INTO bookmark(
idBookmark,
idFile,
timeInSeconds,
totalTimeInSeconds,
thumbNailImage,
player,
playerState,
type)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
''', (bookmark_id,
file_id,
resume_seconds,
total_seconds,
'',
'VideoPlayer',
'',
1))
def create_tag(self, name):
"""
Will create a new tag if needed and return the tag_id
"""
self.cursor.execute('SELECT tag_id FROM tag WHERE name = ? COLLATE NOCASE',
(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
self.cursor.execute('INSERT INTO tag(tag_id, name) VALUES(?, ?)',
(tag_id, name))
return tag_id
def update_tag(self, oldtag, newtag, kodiid, mediatype):
"""
Updates the tag_id by replaying oldtag with newtag
"""
try:
self.cursor.execute('''
UPDATE tag_link
SET tag_id = ?
WHERE media_id = ? AND media_type = ? AND tag_id = ?
''', (newtag, kodiid, mediatype, oldtag,))
except:
# The new tag we are going to apply already exists for this item
# delete current tag instead
self.cursor.execute('''
DELETE FROM tag_link
WHERE media_id = ? AND media_type = ? AND tag_id = ?
''', (kodiid, mediatype, oldtag,))
def create_collection(self, set_name):
"""
Returns the collection/set id for set_name [unicode]
"""
self.cursor.execute('SELECT idSet FROM sets WHERE strSet = ? COLLATE NOCASE',
(set_name,))
try:
setid = self.cursor.fetchone()[0]
except TypeError:
self.cursor.execute("SELECT COALESCE(MAX(idSet), 0) FROM sets")
setid = self.cursor.fetchone()[0] + 1
self.cursor.execute('INSERT INTO sets(idSet, strSet) VALUES(?, ?)',
(setid, set_name))
return setid
def assign_collection(self, setid, movieid):
"""
Assign the movie to one set/collection
"""
self.cursor.execute('UPDATE movie SET idSet = ? WHERE idMovie = ?',
(setid, movieid,))
def remove_from_set(self, movieid):
"""
Remove the movie with movieid [int] from an associated movie set, movie
collection
"""
self.cursor.execute('UPDATE movie SET idSet = null WHERE idMovie = ?',
(movieid,))
def get_set_id(self, kodi_id):
"""
Returns the set_id for the movie with kodi_id or None
"""
self.cursor.execute('SELECT idSet FROM movie WHERE idMovie = ?',
(kodi_id, ))
try:
return self.cursor.fetchone()[0]
except TypeError:
pass
def delete_possibly_empty_set(self, set_id):
"""
Checks whether there are other movies in the set set_id. If not,
deletes the set
"""
self.cursor.execute('SELECT idSet FROM movie WHERE idSet = ?',
(set_id, ))
if self.cursor.fetchone() is None:
self.cursor.execute('DELETE FROM sets WHERE idSet = ?', (set_id,))
def add_season(self, showid, seasonnumber):
"""
Adds a TV show season to the Kodi video DB or simply returns the ID,
if there already is an entry in the DB
"""
self.cursor.execute("SELECT COALESCE(MAX(idSeason),0) FROM seasons")
seasonid = self.cursor.fetchone()[0] + 1
self.cursor.execute('''
INSERT INTO seasons(idSeason, idShow, season)
VALUES (?, ?, ?)
''', (seasonid, showid, seasonnumber))
return seasonid
def add_uniqueid(self, *args):
"""
Feed with:
uniqueid_id: int
media_id: int
media_type: string
value: string
type: e.g. 'imdb' or 'tvdb'
"""
self.cursor.execute('''
INSERT INTO uniqueid(
uniqueid_id,
media_id,
media_type,
value,
type)
VALUES (?, ?, ?, ?, ?)
''', (args))
def get_uniqueid(self, kodi_id, kodi_type):
"""
Returns the uniqueid_id
"""
self.cursor.execute('SELECT uniqueid_id FROM uniqueid WHERE media_id = ? AND media_type =?',
(kodi_id, kodi_type))
try:
return self.cursor.fetchone()[0]
except TypeError:
self.cursor.execute('SELECT COALESCE(MAX(uniqueid_id),0) FROM uniqueid')
return self.cursor.fetchone()[0] + 1
def update_uniqueid(self, *args):
"""
Pass in media_id, media_type, value, type, uniqueid_id
"""
self.cursor.execute('''
UPDATE uniqueid
SET media_id = ?, media_type = ?, value = ?, type = ?
WHERE uniqueid_id = ?
''', (args))
def remove_uniqueid(self, kodi_id, kodi_type):
"""
Deletes the entry from the uniqueid table for the item
"""
self.cursor.execute('DELETE FROM uniqueid WHERE media_id = ? AND media_type = ?',
(kodi_id, kodi_type))
def get_ratingid(self, kodi_id, kodi_type):
"""
Create if needed and return the unique rating_id from rating table
"""
self.cursor.execute('SELECT rating_id FROM rating WHERE media_id = ? AND media_type = ?',
(kodi_id, kodi_type))
try:
return self.cursor.fetchone()[0]
except TypeError:
self.cursor.execute('SELECT COALESCE(MAX(rating_id),0) FROM rating')
return self.cursor.fetchone()[0] + 1
def update_ratings(self, *args):
"""
Feed with media_id, media_type, rating_type, rating, votes, rating_id
"""
self.cursor.execute('''
UPDATE rating
SET media_id = ?,
media_type = ?,
rating_type = ?,
rating = ?,
votes = ?
WHERE rating_id = ?
''', (args))
def add_ratings(self, *args):
"""
feed with:
rating_id, media_id, media_type, rating_type, rating, votes
rating_type = 'default'
"""
self.cursor.execute('''
INSERT INTO rating(
rating_id,
media_id,
media_type,
rating_type,
rating, votes)
VALUES (?, ?, ?, ?, ?, ?)
''', (args))
def remove_ratings(self, kodi_id, kodi_type):
"""
Removes all ratings from the rating table for the item
"""
self.cursor.execute('DELETE FROM rating WHERE media_id = ? AND media_type = ?',
(kodi_id, kodi_type))
def new_show_id(self):
self.cursor.execute('SELECT COALESCE(MAX(idShow), 0) FROM tvshow')
return self.cursor.fetchone()[0] + 1
def new_episode_id(self):
self.cursor.execute('SELECT COALESCE(MAX(idEpisode), 0) FROM episode')
return self.cursor.fetchone()[0] + 1
def add_episode(self, *args):
self.cursor.execute(
'''
INSERT INTO episode(
idEpisode,
idFile,
c00,
c01,
c03,
c04,
c05,
c09,
c10,
c12,
c13,
c14,
idShow,
c15,
c16,
c18,
c19,
idSeason,
userrating)
VALUES
(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
''', (args))
def update_episode(self, *args):
self.cursor.execute(
'''
UPDATE episode
SET c00 = ?,
c01 = ?,
c03 = ?,
c04 = ?,
c05 = ?,
c09 = ?,
c10 = ?,
c12 = ?,
c13 = ?,
c14 = ?,
c15 = ?,
c16 = ?,
c18 = ?,
c19 = ?,
idFile=?,
idSeason = ?,
userrating = ?
WHERE idEpisode = ?
''', (args))
def add_show(self, *args):
self.cursor.execute(
'''
INSERT INTO tvshow(
idShow,
c00,
c01,
c04,
c05,
c08,
c09,
c12,
c13,
c14,
c15)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
''', (args))
def update_show(self, *args):
self.cursor.execute(
'''
UPDATE tvshow
SET c00 = ?,
c01 = ?,
c04 = ?,
c05 = ?,
c08 = ?,
c09 = ?,
c12 = ?,
c13 = ?,
c14 = ?,
c15 = ?
WHERE idShow = ?
''', (args))
def add_showlinkpath(self, kodi_id, kodi_pathid):
self.cursor.execute('INSERT INTO tvshowlinkpath(idShow, idPath) VALUES (?, ?)',
(kodi_id, kodi_pathid))
def remove_show(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):
self.cursor.execute('DELETE FROM episode WHERE idEpisode = ?',
(kodi_id,))
def new_movie_id(self):
self.cursor.execute('SELECT COALESCE(MAX(idMovie), 0) FROM movie')
return self.cursor.fetchone()[0] + 1
def add_movie(self, *args):
self.cursor.execute(
'''
INSERT OR REPLACE INTO movie(
idMovie,
idFile,
c00,
c01,
c02,
c03,
c04,
c05,
c06,
c07,
c09,
c10,
c11,
c12,
c14,
c15,
c16,
c18,
c19,
c21,
c22,
c23,
premiered,
userrating)
VALUES
(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
?, ?, ?, ?)
''', (args))
def remove_movie(self, kodi_id):
self.cursor.execute('DELETE FROM movie WHERE idMovie = ?', (kodi_id,))