def _build_lists_table():
control.anilistSyncDB_lock.acquire()
cursor = _get_connection_cursor(control.anilistSyncDB)
cursor.execute('CREATE TABLE IF NOT EXISTS shows ('
'mal_id INTEGER,'
'name TEXT NOT NULL, '
'image TEXT NOT NULL,'
'slug TEXT NOT NULL,'
'PRIMARY KEY (mal_id)) ')
cursor.execute(
'CREATE UNIQUE INDEX IF NOT EXISTS ix_shows ON "shows" (mal_id ASC )')
try:
cursor.execute(
"REPLACE INTO shows ("
"mal_id, name, image, slug)"
"VALUES "
"(?, ?, ?, ?)", (1, 'ss', 'hhtp', 'dfd-sds'))
cursor.connection.commit()
cursor.close()
except:
cursor.close()
import traceback
traceback.print_exc()
pass
finally:
control.try_release_lock(control.anilistSyncDB_lock)
def addSearchHistory(search_string, media_type):
try:
control.searchHistoryDB_lock.acquire()
cursor = _get_connection_cursor(control.searchHistoryDB)
cursor.execute('CREATE TABLE IF NOT EXISTS show (value TEXT)')
cursor.execute('CREATE TABLE IF NOT EXISTS movie (value TEXT)')
cursor.execute(
"CREATE UNIQUE INDEX IF NOT EXISTS ix_history ON movie (value)")
cursor.execute(
"CREATE UNIQUE INDEX IF NOT EXISTS ix_history ON show (value)")
cursor.execute("REPLACE INTO %s Values (?)" % media_type,
(search_string, ))
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
return []
finally:
control.try_release_lock(control.searchHistoryDB_lock)
def cache_insert(key, value):
control.cacheFile_lock.acquire()
try:
cursor = _get_connection_cursor(control.cacheFile)
now = int(time.time())
cursor.execute(
"CREATE TABLE IF NOT EXISTS %s (key TEXT, value TEXT, date INTEGER, UNIQUE(key))"
% cache_table)
cursor.execute("CREATE UNIQUE INDEX IF NOT EXISTS ix_%s ON %s (key)" %
(cache_table, cache_table))
cursor.execute(
"REPLACE INTO %s (key, value, date) VALUES (?, ?, ?)" %
cache_table, (key, value, now))
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
pass
finally:
control.try_release_lock(control.cacheFile_lock)
def mark_episode_unwatched_by_id():
control.anilistSyncDB_lock.acquire()
cursor = _get_connection_cursor(control.anilistSyncDB)
cursor.execute('UPDATE shows SET trakt_id=? WHERE anilist_id=?', (69, 2))
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
def getTorrentList(anilist_id):
control.torrentScrapeCacheFile_lock.acquire()
try:
cursor = _get_connection_cursor(control.torrentScrapeCacheFile)
_try_create_torrent_cache(cursor)
cursor.execute("SELECT * FROM %s WHERE anilist_id=?" % cache_table,
(anilist_id, ))
torrent_list = cursor.fetchone()
zfill_int = None
cursor.close()
if torrent_list:
zfill_int = torrent_list['zfill']
torrent_list = ast.literal_eval(torrent_list['sources'])
return [torrent_list, zfill_int]
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
return []
finally:
control.try_release_lock(control.torrentScrapeCacheFile_lock)
def getSearchHistory(media_type='show'):
try:
control.searchHistoryDB_lock.acquire()
cursor = _get_connection_cursor(control.searchHistoryDB)
cursor.execute('CREATE TABLE IF NOT EXISTS show (value TEXT)')
cursor.execute('CREATE TABLE IF NOT EXISTS movie (value TEXT)')
cursor.execute(
"CREATE UNIQUE INDEX IF NOT EXISTS ix_history ON movie (value)")
cursor.execute(
"CREATE UNIQUE INDEX IF NOT EXISTS ix_history ON show (value)")
cursor.execute("SELECT * FROM %s" % media_type)
history = cursor.fetchall()
cursor.close()
history.reverse()
history = history[:50]
filter = []
for i in history:
if i['value'] not in filter:
filter.append(i['value'])
return filter
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
return []
finally:
control.try_release_lock(control.searchHistoryDB_lock)
def addTorrentList(anilist_id, torrent_list, zfill_int):
try:
control.torrentScrapeCacheFile_lock.acquire()
cursor = _get_connection_cursor(control.torrentScrapeCacheFile)
_try_create_torrent_cache(cursor)
try:
cursor.execute(
"REPLACE INTO %s (anilist_id, sources, zfill) "
"VALUES (?, ?, ?)" % cache_table,
(anilist_id, str(torrent_list), int(zfill_int)))
except:
import traceback
traceback.print_exc()
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
return []
finally:
control.try_release_lock(control.torrentScrapeCacheFile_lock)
def torrent_cache_clear():
confirmation = control.yesno_dialog(
control.ADDON_NAME, "Are you sure you wish to clear the cache?")
if not confirmation:
return
try:
control.torrentScrapeCacheFile_lock.acquire()
cursor = _get_connection_cursor(control.torrentScrapeCacheFile)
for t in [cache_table, 'rel_list', 'rel_lib']:
try:
cursor.execute("DROP TABLE IF EXISTS %s" % t)
cursor.execute("VACUUM")
cursor.connection.commit()
except:
pass
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
control.try_release_lock(control.torrentScrapeCacheFile_lock)
control.showDialog.notification('{}: {}'.format(control.ADDON_NAME,
control.lang(30200)),
control.lang(30202),
time=5000)
def clearSearchHistory():
try:
control.searchHistoryDB_lock.acquire()
confirmation = control.yesno_dialog(control.ADDON_NAME,
"Clear search history?")
if not confirmation:
return
cursor = _get_connection_cursor(control.searchHistoryDB)
cursor.execute("DROP TABLE IF EXISTS movie")
cursor.execute("DROP TABLE IF EXISTS show")
try:
cursor.execute("VACCUM")
except:
pass
cursor.connection.commit()
cursor.close()
control.refresh()
control.showDialog.notification(control.ADDON_NAME,
"Search History has been cleared",
time=5000)
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
return []
finally:
control.try_release_lock(control.searchHistoryDB_lock)
def re_build_database(self, silent=False):
if not silent:
confirm = control.yesno_dialog(control.ADDON_NAME, control.lang(30203))
if confirm == 0:
return
control.anilistSyncDB_lock.acquire()
cursor = self._get_cursor()
cursor.execute('DROP TABLE IF EXISTS shows')
cursor.execute('DROP TABLE IF EXISTS seasons')
cursor.execute('DROP TABLE IF EXISTS episodes')
cursor.execute('DROP TABLE IF EXISTS activities')
try:
cursor.execute("VACCUM")
except:
pass
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
self._build_show_table()
self._build_episode_table()
self._build_sync_activities()
self._build_season_table()
self._set_base_activites()
self._refresh_activites()
def updateSlugs(anilist_id, sources):
try:
control.torrentScrapeCacheFile_lock.acquire()
cursor = _get_connection_cursor(control.torrentScrapeCacheFile)
_try_create_torrent_cache(cursor)
try:
cursor.execute('UPDATE cache SET sources=? WHERE anilist_id=?',
(sources, anilist_id))
except:
import traceback
traceback.print_exc()
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
return []
finally:
control.try_release_lock(control.torrentScrapeCacheFile_lock)
def add_meta_ids(anilist_id, meta_ids):
control.anilistSyncDB_lock.acquire()
cursor = _get_cursor()
cursor.execute('UPDATE shows SET meta_ids=? WHERE anilist_id=?',
(meta_ids, anilist_id))
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
def update_kodi_meta(anilist_id, kodi_meta):
control.anilistSyncDB_lock.acquire()
cursor = _get_cursor()
cursor.execute('UPDATE shows SET kodi_meta=? WHERE anilist_id=?',
(str(kodi_meta), anilist_id))
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
def get_episode_list(show_id):
control.anilistSyncDB_lock.acquire()
cursor = _get_cursor()
cursor.execute('SELECT* FROM episodes WHERE anilist_id = ?', (show_id, ))
episodes = cursor.fetchall()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
return episodes
def get_season_list(show_id):
control.anilistSyncDB_lock.acquire()
cursor = _get_cursor()
cursor.execute('SELECT* FROM seasons WHERE anilist_id = ?', (show_id, ))
seasons = cursor.fetchone()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
return seasons
def _get_show_list():
control.anilistSyncDB_lock.acquire()
cursor = _get_connection_cursor(control.anilistSyncDB)
cursor.execute('SELECT * FROM shows')
shows = cursor.fetchall()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
return shows
def add_mapping_id(anilist_id, column, value):
control.anilistSyncDB_lock.acquire()
cursor = _get_cursor()
cursor.execute('UPDATE shows SET %s=? WHERE anilist_id=?' % column,
(value, anilist_id))
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
def get_show_mal(mal_id):
control.anilistSyncDB_lock.acquire()
cursor = _get_connection_cursor(control.anilistSyncDB)
db_query = 'SELECT * FROM shows WHERE mal_id IN (%s)' % mal_id
cursor.execute(db_query)
shows = cursor.fetchone()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
return shows
def flush_activities(self, clear_meta=False):
if clear_meta:
self.clear_all_meta()
control.anilistSyncDB_lock.acquire()
cursor = self._get_cursor()
cursor.execute('DROP TABLE activities')
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
def _build_sync_activities(self):
control.anilistSyncDB_lock.acquire()
cursor = self._get_cursor()
cursor.execute('CREATE TABLE IF NOT EXISTS activities ('
'sync_id INTEGER PRIMARY KEY, '
'kaito_version TEXT NOT NULL) '
)
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
def cache_get(key):
try:
control.cacheFile_lock.acquire()
cursor = _get_connection_cursor(control.cacheFile)
cursor.execute("SELECT * FROM %s WHERE key = ?" % cache_table, [key])
results = cursor.fetchone()
cursor.close()
return results
except OperationalError:
return None
finally:
control.try_release_lock(control.cacheFile_lock)
def _build_season_table(self):
control.anilistSyncDB_lock.acquire()
cursor = self._get_cursor()
cursor.execute('CREATE TABLE IF NOT EXISTS seasons ('
'anilist_id INTEGER NOT NULL, '
'season INTEGER NOT NULL, '
'kodi_meta TEXT NOT NULL, '
'air_date TEXT, '
'FOREIGN KEY(anilist_id) REFERENCES shows(anilist_id) ON DELETE CASCADE)')
cursor.execute('CREATE UNIQUE INDEX IF NOT EXISTS ix_season ON seasons (anilist_id ASC, season ASC)')
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
def clear_all_meta(self, notify=True):
## if notify:
## confirm = tools.showDialog.yesno(tools.addonName, tools.lang(40139))
## if confirm == 0:
## return
control.anilistSyncDB_lock.acquire()
cursor = self._get_cursor()
cursor.execute("DELETE FROM shows")
cursor.execute("DELETE FROM seasons")
cursor.execute("DELETE FROM episodes")
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
control.showDialog.notification(control.ADDON_NAME + ': Trakt', 'sddsds', time=5000)
def _check_database_version(self):
# Migrate from an old version before database migrations
if 'kaito_version' not in self.activites:
## control.log('Upgrading Trakt Sync Database Version')
self.clear_all_meta(False)
control.anilistSyncDB_lock.acquire()
cursor = self._get_cursor()
cursor.execute('ALTER TABLE activities ADD COLUMN kaito_version TEXT')
cursor.execute('UPDATE activities SET kaito_version = ?', (self.last_meta_update,))
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
if self.check_version_numbers(self.activites['kaito_version'], self.last_meta_update):
## control.log('Rebuilding Trakt Sync Database Version')
self.re_build_database(True)
return
def remove_episodes(anilist_id):
control.anilistSyncDB_lock.acquire()
cursor = _get_cursor()
try:
cursor.execute("DELETE FROM episodes WHERE anilist_id = ?",
(anilist_id, ))
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
control.try_release_lock(control.anilistSyncDB_lock)
def _build_show_table(self):
control.anilistSyncDB_lock.acquire()
cursor = self._get_cursor()
cursor.execute('CREATE TABLE IF NOT EXISTS shows '
'(anilist_id INTEGER PRIMARY KEY, '
'mal_id INTEGER,'
'simkl_id INTEGER,'
'kitsu_id INTEGER,'
'meta_ids TEXT,'
'kodi_meta TEXT NOT NULL, '
'last_updated TEXT NOT NULL, '
'air_date TEXT, '
'UNIQUE(anilist_id))')
cursor.execute('CREATE UNIQUE INDEX IF NOT EXISTS ix_shows ON "shows" (anilist_id ASC )')
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
def _update_season(show_id, season):
control.anilistSyncDB_lock.acquire()
cursor = _get_cursor()
try:
cursor.execute(
"REPLACE INTO seasons ("
"anilist_id, season, kodi_meta, air_date)"
"VALUES "
"(?, ?, ?, ?)", (int(show_id), str(season), '', ''))
cursor.connection.commit()
cursor.close()
except:
cursor.close()
import traceback
traceback.print_exc()
pass
finally:
control.try_release_lock(control.anilistSyncDB_lock)
def _build_episode_table():
control.anilistSyncDB_lock.acquire()
cursor = _get_cursor()
cursor.execute(
'CREATE TABLE IF NOT EXISTS episodes ('
'anilist_id INTEGER NOT NULL, '
'season INTEGER NOT NULL, '
'kodi_meta TEXT NOT NULL, '
'last_updated TEXT NOT NULL, '
'number INTEGER NOT NULL, '
'number_abs INTEGER,'
'air_date TEXT, '
'FOREIGN KEY(anilist_id) REFERENCES shows(anilist_id) ON DELETE CASCADE)'
)
cursor.execute(
'CREATE UNIQUE INDEX IF NOT EXISTS ix_episodes ON episodes (anilist_id ASC, season ASC, number ASC)'
)
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
def cache_clear():
try:
control.cacheFile_lock.acquire()
cursor = _get_connection_cursor(control.cacheFile)
for t in [cache_table, 'rel_list', 'rel_lib']:
try:
cursor.execute("DROP TABLE IF EXISTS %s" % t)
cursor.execute("VACUUM")
cursor.connection.commit()
except:
pass
control.showDialog.notification('{}: {}'.format(
control.ADDON_NAME, control.lang(30200)),
control.lang(30201),
time=5000)
except:
pass
finally:
control.try_release_lock(control.cacheFile_lock)
def _build_lists_table(self):
control.anilistSyncDB_lock.acquire()
cursor = self._get_cursor()
cursor.execute('CREATE TABLE IF NOT EXISTS lists ('
'trakt_id INTEGER NOT NULL, '
'media_type TEXT NOT NULL,'
'name TEXT NOT NULL, '
'username TEXT NOT NULL, '
'kodi_meta TEXT NOT NULL, '
'updated_at TEXT NOT NULL,'
'list_type TEXT NOT NULL,'
'item_count INT NOT NULL,'
'sort_by TEXT NOT NULL,'
'sort_how TEXT NOT NULL,'
'slug TEXT NOT NULL,'
'PRIMARY KEY (trakt_id, media_type)) '
)
cursor.connection.commit()
cursor.close()
control.try_release_lock(control.anilistSyncDB_lock)
