def _cacheClear():
try:
data = database.Database(databaseName, connect=True)
data._drop(databaseTable, commit=True)
data._close()
except:
log_utils.error()
def _cacheProcess():
data = database.Database(databaseName, connect=True)
data._lock()
_cacheCreate(data)
data._unlock()
try:
while True:
# Execute the select and delete as atomic operations.
data._lock()
result = data._selectSingle(
'SELECT id, time, link, data FROM %s ORDER BY time ASC LIMIT 1;'
% (databaseTable))
if not result: raise Exception()
data._delete('DELETE FROM %s WHERE id IS %d;' %
(databaseTable, result[0]),
commit=True)
data._unlock()
result = getTrakt(url=result[2],
post=jsloads(result[3]) if result[3] else None,
cache=True,
check=False,
timestamp=result[1])
except:
log_utils.error()
data._unlock()
data._close()
def _cacheClear():
try:
data = database.Database(databaseName, connect=True)
data._drop(databaseTable, commit=True)
data._close()
except:
import traceback
traceback.print_exc()
def _cache(url, post=None, timestamp=None):
try:
# Only cache the requests that change something on the Trakt account.
# Trakt uses JSON post data to set things and only uses GET parameters to retrieve things.
if not post: return None
data = database.Database(databaseName, connect=True)
_cacheCreate(data)
# post parameter already jsdumps from getTrakt.
post = ('"%s"' % post.replace('"', '""').replace("'", "''")
) if post else data._null()
if not timestamp:
timestamp = int(time.time())
data._insert('''
INSERT INTO %s (time, link, data)
VALUES (%d, "%s", %s);
''' % (databaseTable, timestamp, url, post),
commit=True)
data._close()
except:
log_utils.error()
def failureClear(self): database.Database(name = self.DatabaseName)._drop(self.DatabaseFailure)
def _failureInitialize(self):
data = database.Database(name = self.DatabaseName)
data._create('CREATE TABLE IF NOT EXISTS %s (id TEXT, count INTEGER, time INTEGER, UNIQUE(id));' % self.DatabaseFailure)
return data
def _update(self, notifications=None):
try:
self._createDirectory(self._location(tools.Media.TypeMovie))
self._createDirectory(self._location(tools.Media.TypeShow))
self._createDirectory(self._location(tools.Media.TypeDocumentary))
self._createDirectory(self._location(tools.Media.TypeShort))
except:
pass
if notifications == None:
notifications = tools.Settings.getInteger(
'library.updates.shows.notifications')
notificationDuration = 10000000000 if notifications == 2 else 3000
notifications = notifications > 0
interface.Loader.hide()
try:
items = []
season, episode = [], []
show = [
tools.File.joinPath(self.mLocation, i)
for i in tools.File.listDirectory(self.mLocation)[0]
]
for s in show:
try:
season += [
tools.File.joinPath(s, i)
for i in tools.File.listDirectory(s)[0]
]
except:
pass
for s in season:
try:
episode.append([
tools.File.joinPath(s, i)
for i in tools.File.listDirectory(s)[1]
if i.endswith('.strm')
][-1])
except:
pass
for file in episode:
try:
data = tools.File.readNow(file).encode('utf-8')
if not data.startswith(sys.argv[0]): raise Exception()
params = dict(urlparse.parse_qsl(data.replace('?', '')))
try:
tvshowtitle = params['tvshowtitle']
except:
tvshowtitle = None
try:
tvshowtitle = params['show']
except:
pass
if tvshowtitle == None or tvshowtitle == '':
raise Exception()
year, imdb, tvdb = params['year'], params['imdb'], params[
'tvdb']
imdb = 'tt' + re.sub('[^0-9]', '', str(imdb))
try:
tmdb = params['tmdb']
except:
tmdb = '0'
items.append({
'tvshowtitle': tvshowtitle,
'year': year,
'imdb': imdb,
'tmdb': tmdb,
'tvdb': tvdb
})
except:
pass
items = [i for x, i in enumerate(items) if i not in items[x + 1:]]
if len(items) == 0: raise Exception()
except:
return
try:
library = tools.System.executeJson(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShows", "params": {"properties" : ["imdbnumber", "title", "year"]}, "id": 1}'
)
library = unicode(library, 'utf-8', errors='ignore')
library = tools.Converter.jsonFrom(library)['result']['tvshows']
except:
return
if notifications and self._ready():
interface.Dialog.notification(
title=33244,
message=35181,
icon=interface.Dialog.IconInformation,
time=notificationDuration)
self.mDialog = True
try:
base = database.Database(name=self.DatabaseName)
base._create(
'CREATE TABLE IF NOT EXISTS shows (id TEXT, items TEXT, UNIQUE(id));'
)
except:
return
try:
from resources.lib.indexers import episodes
except:
return
count = 0
for item in items:
if tools.System.aborted(): return sys.exit()
it = None
try:
fetch = base._selectSingle(
'SELECT * FROM shows WHERE id = "%s";' % item['tvdb'])
it = tools.Converter.jsonFrom(
tools.Converter.base64From(fetch[1].encode('utf-8')))
except:
pass
try:
if not it == None: raise Exception()
it = episodes.episodes().get(item['tvshowtitle'],
item['year'],
item['imdb'],
item['tvdb'],
idx=False)
status = it[0]['status'].lower()
it = [{
'title':
i['title'],
'year':
i['year'],
'imdb':
i['imdb'],
'tvdb':
i['tvdb'],
'season':
i['season'],
'episode':
i['episode'],
'tvshowtitle':
i['tvshowtitle'],
'premiered':
i['premiered'],
'seasoncount':
i['seasoncount'] if 'seasoncount' in i else None
} for i in it]
if status == 'continuing': raise Exception()
json = tools.Converter.base64To(tools.Converter.jsonTo(it))
base._insert('INSERT INTO shows VALUES ("%s", "%s");' %
(item['tvdb'], json))
except:
pass
try:
id = [item['imdb'], item['tvdb']]
if not item['tmdb'] == '0': id += [item['tmdb']]
episode = [
x['title'].encode('utf-8') for x in library
if str(x['imdbnumber']) in id or (
x['title'].encode('utf-8') == item['tvshowtitle']
and str(x['year']) == item['year'])
][0]
episode = tools.System.executeJson(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"filter":{"and": [{"field": "tvshow", "operator": "is", "value": "%s"}]}, "properties": ["season", "episode"]}, "id": 1}'
% episode)
episode = unicode(episode, 'utf-8', errors='ignore')
episode = tools.Converter.jsonFrom(episode).get(
'result', {}).get('episodes', {})
episode = [{
'season': int(i['season']),
'episode': int(i['episode'])
} for i in episode]
episode = sorted(episode,
key=lambda x: (x['season'], x['episode']))[-1]
num = [
x for x, y in enumerate(it)
if str(y['season']) == str(episode['season'])
and str(y['episode']) == str(episode['episode'])
][-1]
it = [y for x, y in enumerate(it) if x > num]
if len(it) == 0: continue
except:
continue
dateCurrent = int((datetime.datetime.utcnow() -
datetime.timedelta(hours=6)).strftime('%Y%m%d'))
for i in it:
try:
if tools.System.aborted(): return sys.exit()
try:
premiered = i['premiered']
except:
premiered = None
if not premiered or premiered == '' or premiered == '0':
premiered = None
#if (premiered and int(re.sub('[^0-9]', '', str(premiered))) > dateCurrent) or (not premiered and not self.mUnaired):
# continue
self._televisionFiles(i)
count += 1
except:
tools.Logger.error()
if notifications and self.mDialog:
interface.Dialog.notification(title=33244,
message=35182,
icon=interface.Dialog.IconSuccess)
if self.mUpdate and not self._libraryBusy() and count > 0:
self._libraryUpdate()
