def clear_trakt_list_contents_data(clear_all=False, user=None, slug=None):
from resources.lib.modules.trakt import get_trakt_my_lists, get_trakt_liked_lists
settings.check_database(trakt_cache_file)
if clear_all:
my_lists = [(item["user"]["username"], item["ids"]["slug"])
for item in get_trakt_my_lists(build_list=False)]
liked_lists = [(item["list"]["user"]["username"],
item["list"]["ids"]["slug"])
for item in get_trakt_liked_lists(build_list=False)]
my_lists.extend(liked_lists)
try:
dbcon = database.connect(trakt_cache_file)
dbcur = dbcon.cursor()
dbcur.execute(
"DELETE FROM fen_trakt WHERE id LIKE 'trakt_list_contents%'")
dbcon.commit()
except:
pass
for i in my_lists:
window.clearProperty('trakt_list_contents_%s_%s' % (i[0], i[1]))
else:
action = 'trakt_list_contents_%s_%s' % (user, slug)
try:
dbcon = database.connect(trakt_cache_file)
dbcur = dbcon.cursor()
dbcur.execute("DELETE FROM fen_trakt WHERE id=?", (action, ))
dbcon.commit()
window.clearProperty(action)
window.setProperty('trakt_reset_passed_list', 'true')
except:
pass
def get_watched_status(db_type, media_id, season='', episode=''):
try:
if settings.watched_indicators() in (1, 2):
if db_type == 'movie':
from resources.lib.modules.trakt import trakt_indicators_movies
watched = [i[0] for i in trakt_indicators_movies()]
if media_id in watched: return 1, 7
return 0, 6
else:
from resources.lib.modules.trakt import trakt_indicators_tv
watched = trakt_indicators_tv()
watched = [i[2] for i in watched if i[0] == media_id]
if watched:
watched = [
i for i in watched[0]
if i[0] == season and i[1] == episode
]
if watched: return 1, 7
return 0, 6
else:
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
"SELECT * FROM watched_status WHERE (db_type = ? and media_id = ? and season = ? and episode = ?)",
(db_type, media_id, season, episode))
watched = dbcur.fetchone()
dbcon.close()
if watched: return 1, 7
else: return 0, 6
except:
return 0, 6
def clear_trakt_next_episode_data(media_id=None):
settings.check_database(trakt_cache_file)
try:
dbcon = database.connect(trakt_cache_file)
dbcur = dbcon.cursor()
dbcur.execute("SELECT * FROM fen_trakt WHERE id = ?",
('trakt_watched_shows', ))
shows = dbcur.fetchone()[2]
shows = eval(shows)
show_ids = [i['show']['ids'] for i in shows]
except:
return
if media_id:
try:
trakt_id = [i['trakt'] for i in show_ids
if i['imdb'] == media_id][0]
dbcur.execute("DELETE FROM fen_trakt WHERE id=?",
('trakt_view_history_%s' % str(trakt_id), ))
dbcon.commit()
window.clearProperty('trakt_view_history_%s' % str(trakt_id))
except:
pass
return
if not media_id:
trakt_ids = [i['trakt'] for i in show_ids]
dbcur.execute(
"DELETE FROM fen_trakt WHERE id LIKE 'trakt_view_history%'")
dbcon.commit()
for i in trakt_ids:
window.clearProperty('trakt_view_history_%s' % str(i))
def erase_bookmark(db_type, media_id, season='', episode=''):
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
"DELETE FROM progress where db_type=? and media_id=? and season = ? and episode = ?",
(db_type, media_id, season, episode))
dbcon.commit()
def clear_trakt_list_data(list_type):
settings.check_database(trakt_cache_file)
action = 'trakt_my_lists' if list_type == 'my_lists' else 'trakt_liked_lists'
try:
dbcon = database.connect(trakt_cache_file)
dbcur = dbcon.cursor()
dbcur.execute("DELETE FROM fen_trakt WHERE id=?", (action, ))
dbcon.commit()
window.clearProperty(action)
except:
pass
def check_for_next_episode_excludes():
from urlparse import parse_qsl
from resources.lib.modules.nav_utils import notification
settings.check_database(WATCHED_DB)
params = dict(parse_qsl(sys.argv[2].replace('?','')))
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute('''SELECT media_id FROM exclude_from_next_episode''')
row = dbcur.fetchall()
dbcon.close()
return [str(i[0]) for i in row]
def clear_trakt_hidden_data(list_type):
settings.check_database(trakt_cache_file)
action = 'trakt_hidden_items_%s' % list_type
try:
dbcon = database.connect(trakt_cache_file)
dbcur = dbcon.cursor()
dbcur.execute("DELETE FROM fen_trakt WHERE id=?", (action, ))
dbcon.commit()
window.clearProperty(action)
except:
pass
def clear_trakt_collection_watchlist_data(list_type, db_type):
settings.check_database(trakt_cache_file)
action = 'trakt_collection_%s' % db_type if list_type == 'collection' else 'trakt_watchlist_%s' % db_type
try:
dbcon = database.connect(trakt_cache_file)
dbcur = dbcon.cursor()
dbcur.execute("DELETE FROM fen_trakt WHERE id=?", (action, ))
dbcon.commit()
window.clearProperty(action)
window.setProperty('trakt_reset_passed_list', 'true')
except:
pass
def __init__(self):
self.dialog = xbmcgui.Dialog()
self.fav_database = os.path.join(__addon_profile__, 'favourites.db')
settings.check_database(self.fav_database)
params = dict(parse_qsl(sys.argv[2].replace('?', '')))
self.db_type = params.get('db_type')
self.tmdb_id = params.get('tmdb_id')
self.title = params.get('title')
self.name = params.get('name')
self.id = params.get('_id')
self.url_dl = params.get('url_dl')
self.size = params.get('size')
def detect_bookmark(db_type, media_id, season='', episode=''):
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcon.row_factory = database.Row
dbcur = dbcon.cursor()
dbcur.execute(
"SELECT * FROM progress WHERE (db_type = ? and media_id = ? and season = ? and episode = ?)",
(db_type, media_id, season, episode))
for row in dbcur:
resume_point = row['resume_point']
curr_time = row['curr_time']
return resume_point, curr_time
def get_watched_status_tvshow(media_id, aired_eps):
playcount, overlay = 0, 6
watched, unwatched = 0, aired_eps
def get_playcount_overlay(use_trakt):
try:
if use_trakt:
watched = [
i for i in watched_info
if i[0] == media_id and i[1] == len(i[2])
]
if watched:
playcount, overlay = 1, 7
else:
if watched_info == aired_eps and not aired_eps == 0:
playcount, overlay = 1, 7
except:
pass
return playcount, overlay
def get_watched_episode_totals(use_trakt):
try:
if use_trakt:
watched = len([i[2] for i in watched_info
if i[0] == media_id][0])
unwatched = aired_eps - watched
else:
watched = watched_info
unwatched = aired_eps - watched
except:
pass
return watched, unwatched
try:
if settings.watched_indicators() in (1, 2):
from resources.lib.modules.trakt import trakt_indicators_tv
use_trakt = True
watched_info = trakt_indicators_tv()
else:
use_trakt = False
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
"SELECT * FROM watched_status WHERE (db_type = ? and media_id = ?)",
('episode', media_id))
watched_info = len(dbcur.fetchall())
dbcon.close()
watched, unwatched = get_watched_episode_totals(use_trakt)
playcount, overlay = get_playcount_overlay(use_trakt)
except:
pass
return playcount, overlay, watched, unwatched
def __init__(self,
db_type=None,
tmdb_id=None,
action=None,
orig_mode=None):
self.sub_database = os.path.join(__addon_profile__, 'subscriptions.db')
self.db_type = db_type
self.tmdb_id = tmdb_id
self.action = action
self.orig_mode = orig_mode
if self.db_type:
self.path = settings.movies_directory(
) if self.db_type == 'movie' else settings.tv_show_directory()
settings.check_database(self.sub_database)
def get_unwatched_next_episodes():
try:
if settings.watched_indicators() in (1, 2):
from resources.lib.modules.trakt import call_trakt, get_trakt_tvshow_id
data = call_trakt("sync/watchlist/shows?extended=full", method='sort_by_headers')
return [{"tmdb_id": get_trakt_tvshow_id(i), "season": 1, "episode": 0, "unwatched": True} for i in data]
else:
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute('''SELECT media_id FROM unwatched_next_episode''')
unwatched = dbcur.fetchall()
return [{"tmdb_id": i[0], "season": 1, "episode": 0, "unwatched": True} for i in unwatched]
except: return []
def clear_trakt_watched_data(db_type, media_id=None):
settings.check_database(trakt_cache_file)
dbcon = database.connect(trakt_cache_file)
dbcur = dbcon.cursor()
if db_type == 'tvshow':
clear_trakt_next_episode_data(media_id)
dbcur.execute("DELETE FROM fen_trakt WHERE id=?",
('trakt_watched_shows', ))
dbcon.commit()
window.clearProperty('trakt_watched_shows')
action = 'trakt_indicators_movies' if db_type in (
'movie', 'movies') else 'trakt_indicators_tv'
dbcur.execute("DELETE FROM fen_trakt WHERE id=?", (action, ))
dbcon.commit()
window.clearProperty(action)
def add_next_episode_unwatched(action=None, media_id=None, silent=False):
from urlparse import parse_qsl
from resources.lib.modules.nav_utils import notification
from resources.lib.modules.indicators_bookmarks import mark_as_watched_unwatched
settings.check_database(WATCHED_DB)
params = dict(parse_qsl(sys.argv[2].replace('?','')))
media_id = params['tmdb_id'] if not media_id else media_id
action = params['action'] if not action else action
if action == 'add': command, line1 = "INSERT OR IGNORE INTO unwatched_next_episode VALUES (?)", '%s Added to Fen Next Episode' % params.get('title')
else: command, line1 = "DELETE FROM unwatched_next_episode WHERE media_id=?", '%s Removed from Fen Next Episode' % params.get('title')
dbcon = database.connect(WATCHED_DB)
dbcon.execute(command, (media_id,))
dbcon.commit()
dbcon.close()
if not silent: notification(line1, time=3500)
xbmc.sleep(500)
xbmc.executebuiltin("Container.Refresh")
def setView(view_type):
from resources.lib.modules.settings import check_database
try:
from sqlite3 import dbapi2 as database
except:
from pysqlite2 import dbapi2 as database
try:
VIEWS_DB = os.path.join(profile_dir, "views.db")
check_database(VIEWS_DB)
dbcon = database.connect(VIEWS_DB)
dbcur = dbcon.cursor()
dbcur.execute("SELECT view_id FROM views WHERE view_type = ?",
(str(view_type), ))
view_id = dbcur.fetchone()[0]
xbmc.sleep(250)
return xbmc.executebuiltin("Container.SetViewMode(%s)" % str(view_id))
except:
return
def add_to_remove_from_next_episode_excludes():
from urlparse import parse_qsl
from resources.lib.modules.nav_utils import notification
settings.check_database(WATCHED_DB)
params = dict(parse_qsl(sys.argv[2].replace('?','')))
action = params.get('action')
media_id = str(params.get('media_id'))
title = str(params.get('title'))
dbcon = database.connect(WATCHED_DB)
if action == 'add':
dbcon.execute("INSERT INTO exclude_from_next_episode VALUES (?, ?)", (media_id, title))
line1 = '[B]{}[/B] excluded from Fen Next Episode'.format(title.upper())
elif action == 'remove':
dbcon.execute("DELETE FROM exclude_from_next_episode WHERE media_id=?", (media_id,))
line1 = '[B]{}[/B] included in Fen Next Episode'.format(title.upper())
dbcon.commit()
dbcon.close()
notification('{}'.format(line1), time=5000)
xbmc.sleep(500)
xbmc.executebuiltin("Container.Refresh")
def build_next_episode():
sync_watched_trakt_to_fen()
try:
threads = []
seen = set()
ep_list = []
ne_settings = settings.nextep_content_settings()
ne_display = settings.nextep_display_settings()
if ne_settings['include_unwatched']:
for i in get_unwatched_next_episodes(): ep_list.append(i)
if settings.watched_indicators() in (1, 2):
from resources.lib.modules.trakt import trakt_get_next_episodes
info = trakt_get_next_episodes()
for item in info:
try:
ep_list.append({"tmdb_id": get_trakt_tvshow_id(item), "season": item['season'], "episode": item['number'], "last_played": item['show']['last_watched_at']})
except: pass
else:
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute('''SELECT media_id, season, episode, last_played FROM watched_status WHERE db_type=?''', ('episode',))
rows = dbcur.fetchall()
rows = sorted(rows, key = lambda x: (x[0], x[1], x[2]), reverse=True)
[ep_list.append({"tmdb_id": a, "season": int(b), "episode": int(c), "last_played": d}) for a, b, c, d in rows if not (a in seen or seen.add(a))]
ep_list = [x for x in ep_list if x['tmdb_id'] not in check_for_next_episode_excludes()]
ep_list = [i for i in ep_list if not i['tmdb_id'] == None]
for item in ep_list: threads.append(Thread(process_eps, item, ne_settings, ne_display))
[i.start() for i in threads]
[i.join() for i in threads]
r = [i for i in result if i is not None]
r = sort_next_eps(r, ne_settings)
listitems = [i['listitem'] for i in r]
xbmcplugin.addDirectoryItems(__handle__, listitems, len(listitems))
xbmcplugin.setContent(__handle__, 'episodes')
xbmcplugin.endOfDirectory(__handle__)
setView('view.progress_next_episode')
except:
from resources.lib.modules.nav_utils import notification
notification('Error getting Next Episode Info', time=3500)
pass
def set_bookmark(db_type,
media_id,
curr_time,
total_time,
season='',
episode='',
from_search='false'):
settings.check_database(WATCHED_DB)
erase_bookmark(db_type, media_id, season, episode)
adjusted_current_time = curr_time - 4
resume_point = round(float(adjusted_current_time / total_time * 100), 1)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute("INSERT INTO progress VALUES (?, ?, ?, ?, ?, ?)",
(db_type, media_id, season, episode, str(resume_point),
str(curr_time)))
dbcon.commit()
if settings.sync_kodi_library_watchstatus():
from resources.lib.modules.kodi_library import set_bookmark_kodi_library
set_bookmark_kodi_library(db_type, media_id, curr_time, season,
episode)
refresh_container(from_search)
def mark_as_watched_unwatched(db_type='',
media_id='',
action='',
season='',
episode='',
title=''):
try:
settings.check_database(WATCHED_DB)
last_played = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
dbcon = database.connect(WATCHED_DB, timeout=40.0)
erase_bookmark(db_type, media_id, season, episode)
if action == 'mark_as_watched':
dbcon.execute(
"INSERT OR IGNORE INTO watched_status VALUES (?, ?, ?, ?, ?, ?)",
(db_type, media_id, season, episode, last_played,
to_unicode(title)))
elif action == 'mark_as_unwatched':
dbcon.execute(
"DELETE FROM watched_status WHERE (db_type = ? and media_id = ? and season = ? and episode = ?)",
(db_type, media_id, season, episode))
dbcon.commit()
except:
from resources.lib.modules.nav_utils import notification
notification('Error Marking Watched in Fen', time=5000)
def build_next_episode_manager():
from urlparse import parse_qsl
from resources.lib.indexers.tvshows import aired_episode_number_tvshow
from resources.lib.modules.nav_utils import add_dir
from resources.lib.modules.indicators_bookmarks import get_watched_status_tvshow
params = dict(parse_qsl(sys.argv[2].replace('?','')))
NEXT_EP_UNWATCHED = __addon__.getSetting('nextep.unwatched_colour')
if not NEXT_EP_UNWATCHED or NEXT_EP_UNWATCHED == '': NEXT_EP_UNWATCHED = 'red'
VIEW_NEM = __addon__.getSetting('view.main')
sorted_list = []
action = params['action']
if action == 'manage_unwatched':
tmdb_list = [i['tmdb_id'] for i in get_unwatched_next_episodes()]
heading = 'Select Show to remove from Fen Next Episode:'
elif settings.watched_indicators() in (1, 2):
from resources.lib.modules.trakt import trakt_get_next_episodes
tmdb_list, exclude_list = trakt_get_next_episodes(include_hidden=True)
heading = 'Select Show to Hide/Unhide from Trakt Progress:'
else:
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute('''SELECT media_id FROM watched_status WHERE db_type=? GROUP BY media_id''', ('episode',))
rows = dbcur.fetchall()
tmdb_list = [row[0] for row in rows]
exclude_list = check_for_next_episode_excludes()
heading = 'Select Show to Include/Exclude in Fen Next Episode:'
add_dir({'mode': 'nill'}, '[I][COLOR=grey][B]INFO:[/B][/COLOR] [COLOR=grey2]%s[/COLOR][/I]' % heading, iconImage='settings.png')
if not tmdb_list:
from resources.lib.modules.nav_utils import notification
notification('No Shows Present', time=5000)
else:
for tmdb_id in tmdb_list:
try:
meta = make_fresh_tvshow_meta('tmdb_id', tmdb_id)
if action == 'manage_unwatched':
action, display = 'remove', '[COLOR=%s][UNWATCHED][/COLOR] %s' % (NEXT_EP_UNWATCHED, meta['title'])
url_params = {'mode': 'add_next_episode_unwatched', 'action': 'remove', 'tmdb_id': meta['tmdb_id'], 'title': meta['title']}
elif settings.watched_indicators() in (1, 2):
action, display = 'unhide' if str(meta['tmdb_id']) in exclude_list else 'hide', '[COLOR=red][EXCLUDED][/COLOR] %s' % meta['title'] if str(meta['tmdb_id']) in exclude_list else '[COLOR=green][INCLUDED][/COLOR] %s' % meta['title']
url_params = {"mode": "hide_unhide_trakt_items", "action": action, "media_type": "shows", "media_id": meta['imdb_id'], "section": "progress_watched"}
else:
action, display = 'remove' if str(meta['tmdb_id']) in exclude_list else 'add', '[COLOR=red][EXCLUDED][/COLOR] %s' % meta['title'] if str(meta['tmdb_id']) in exclude_list else '[COLOR=green][INCLUDED][/COLOR] %s' % meta['title']
url_params = {'mode': 'add_to_remove_from_next_episode_excludes', 'action': action, 'title': meta['title'], 'media_id': meta['tmdb_id']}
sorted_list.append({'tmdb_id': tmdb_id, 'display': display, 'url_params': url_params, 'meta': json.dumps(meta)})
except: pass
sorted_items = sorted(sorted_list, key=lambda k: k['display'])
for i in sorted_items:
try:
cm = []
meta = json.loads(i['meta'])
rootname = meta['title'] + " (" + str(meta['year']) + ")"
meta['rootname'] = rootname
aired_episodes = aired_episode_number_tvshow(meta)
playcount, overlay, total_watched, total_unwatched = get_watched_status_tvshow(meta['tmdb_id'], aired_episodes)
url = build_url(i['url_params'])
browse_url = build_url({'mode': 'build_season_list', 'meta': i['meta']})
cm.append(("[B]Browse...[/B]",'XBMC.Container.Update(%s)' % browse_url))
listitem = xbmcgui.ListItem(i['display'])
listitem.setProperty('watchedepisodes', str(total_watched))
listitem.setProperty('unwatchedepisodes', str(total_unwatched))
listitem.setProperty('totalepisodes', str(aired_episodes))
listitem.setProperty('totalseasons', str(meta['number_of_seasons']))
listitem.addContextMenuItems(cm)
listitem.setArt({'poster': meta['poster'],
'fanart': meta['fanart'],
'banner': meta['banner'],
'clearart': meta['clearart'],
'clearlogo': meta['clearlogo'],
'landscape': meta['landscape']})
listitem.setCast(meta['cast'])
listitem.setInfo(
'video', {
'title': meta['title'], 'size': '0', 'duration': meta['duration'],
'plot': meta['plot'], 'rating': meta['rating'], 'premiered': meta['premiered'],
'studio': meta['studio'],'year': meta['year'],
'genre': meta['genre'],'imdbnumber': meta['imdb_id'], 'votes': meta['votes'],
'playcount': playcount, 'overlay': overlay})
xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True)
except: pass
xbmcplugin.setContent(__handle__, 'tvshows')
xbmcplugin.endOfDirectory(__handle__, cacheToDisc=False)
setView(VIEW_NEM)
def get_watched_items(db_type, page_no, letter, passed_list=[]):
import ast
from resources.lib.modules.nav_utils import paginate_list
from resources.lib.modules.utils import title_key, to_utf8
watched_indicators = settings.watched_indicators()
limit = 40
if db_type == 'tvshow':
from resources.lib.indexers.tvshows import aired_episode_number_tvshow
if watched_indicators in (1, 2):
if not passed_list:
from resources.lib.modules.trakt import trakt_indicators_tv
data = trakt_indicators_tv()
data = sorted(data, key=lambda tup: title_key(tup[3]))
original_list = [{
'media_id': i[0],
'title': i[3]
} for i in data if i[1] == len(i[2])]
else:
original_list = ast.literal_eval(passed_list)
else:
if not passed_list:
from resources.lib.indexers.tvshows import make_fresh_tvshow_meta
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
"SELECT media_id, title FROM watched_status WHERE db_type = ?",
('episode', ))
rows = dbcur.fetchall()
dbcon.close()
watched_list = list(set(to_utf8([(i[0], i[1]) for i in rows])))
data = []
for item in watched_list:
watched = get_watched_status_tvshow(
item[0],
aired_episode_number_tvshow(
make_fresh_tvshow_meta('tmdb_id', item[0])))
if watched[0] == 1: data.append(item)
else: pass
data = sorted(data, key=lambda tup: title_key(tup[1]))
original_list = [{
'media_id': i[0],
'title': i[1]
} for i in data]
else:
original_list = ast.literal_eval(passed_list)
else:
if watched_indicators in (1, 2):
if not passed_list:
from resources.lib.modules.trakt import trakt_indicators_movies
data = trakt_indicators_movies()
data = sorted(data, key=lambda tup: title_key(tup[1]))
original_list = [{
'media_id': i[0],
'title': i[1]
} for i in data]
else:
original_list = ast.literal_eval(passed_list)
else:
if not passed_list:
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
"SELECT media_id, title FROM watched_status WHERE db_type = ?",
(db_type, ))
rows = dbcur.fetchall()
dbcon.close()
data = to_utf8([(i[0], i[1]) for i in rows])
data = sorted(data, key=lambda tup: title_key(tup[1]))
original_list = [{
'media_id': i[0],
'title': i[1]
} for i in data]
else:
original_list = ast.literal_eval(passed_list)
paginated_list, total_pages = paginate_list(original_list, page_no, letter,
limit)
return paginated_list, original_list, total_pages, limit
