def clear_trakt_list_contents_data(clear_all=False, user=None, list_slug=None):
settings.check_database(trakt_cache_file)
if clear_all:
from apis.trakt_api import get_trakt_my_lists, get_trakt_liked_lists
my_lists = [(item["user"]["ids"]["slug"], item["ids"]["slug"])
for item in get_trakt_my_lists(build_list=False)]
liked_lists = [(item["list"]["user"]["ids"]["slug"],
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, list_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)
except:
pass
def history(self, db_type=None, display=True):
try: from sqlite3 import dbapi2 as database
except ImportError: from pysqlite2 import dbapi2 as database
cache_file = os.path.join(__addon_profile__, "fen_cache.db")
db_type = db_type if db_type else self.db_type
string = 'fen_discover_%s_%%' % self.db_type
settings.check_database(cache_file)
dbcon = database.connect(cache_file)
dbcur = dbcon.cursor()
dbcur.execute("SELECT id, data FROM fencache WHERE id LIKE ? ORDER BY rowid DESC", (string,))
history = dbcur.fetchall()
if not display: return [i[0] for i in history]
data = [eval(i[1]) for i in history]
for count, item in enumerate(data):
try:
cm = []
data_id = history[count][0]
name = item['name']
url_params = {'mode': item['mode'], 'action': item['action'], 'query': item['query'],
'name': name, 'iconImage': self.icon}
display = '%s | %s' % (count+1, name)
url = build_url(url_params)
remove_single_params = {'mode': 'discover.remove_from_history', 'data_id': data_id}
remove_all_params = {'mode': 'discover.remove_all_history', 'db_type': db_type}
export_params = {'mode': 'navigator.adjust_main_lists', 'method': 'add_external',
'list_name': name, 'menu_item': json.dumps(url_params)}
listitem = xbmcgui.ListItem(display)
listitem.setArt({'icon': self.icon, 'poster': self.icon, 'thumb': self.icon, 'fanart': self.fanart, 'banner': self.icon})
cm.append(("[B]Export List[/B]",'XBMC.RunPlugin(%s)'% self._build_url(export_params)))
cm.append(("[B]Remove From History[/B]",'XBMC.RunPlugin(%s)'% self._build_url(remove_single_params)))
cm.append(("[B]Clear All %s History[/B]" % db_type.capitalize(),'XBMC.RunPlugin(%s)'% self._build_url(remove_all_params)))
listitem.addContextMenuItems(cm)
xbmcplugin.addDirectoryItem(int(sys.argv[1]), url, listitem, isFolder=True)
except: pass
self._end_directory()
def setView(view_type, content='files'):
if not 'plugin' in xbmc.getInfoLabel('Container.PluginName'): return
import time
from modules.settings import check_database
try:
from sqlite3 import dbapi2 as database
except:
from pysqlite2 import dbapi2 as database
profile_dir = xbmc.translatePath(__addon__.getAddonInfo('profile'))
t = 0
try:
xbmc.sleep(500)
while not xbmc.getInfoLabel('Container.Content') == content:
if xbmc.abortRequested == True: break
t += 0.01
if t >= 60.0: break
time.sleep(0.01)
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]
return xbmc.executebuiltin("Container.SetViewMode(%s)" % str(view_id))
except:
return
def get_unwatched_next_episodes():
try:
if settings.watched_indicators() in (1, 2):
from apis.trakt_api import trakt_fetch_collection_watchlist, get_trakt_tvshow_id
data = trakt_fetch_collection_watchlist('watchlist', 'tvshow')
return [{
"tmdb_id": get_trakt_tvshow_id(i['media_ids']),
"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 build_in_progress_episode():
from modules.indicators_bookmarks import get_watched_info_tv
def process_eps(item):
listitem = build_episode(
{
"season": int(item[1]),
"episode": int(item[2]),
"meta": tvshow_meta('tmdb_id', item[0], meta_user_info)
}, watched_info, use_trakt, meta_user_info)['listitem']
xbmcplugin.addDirectoryItem(__handle__,
listitem[0],
listitem[1],
isFolder=listitem[2])
check_meta_database()
settings.check_database(WATCHED_DB)
watched_info, use_trakt = get_watched_info_tv()
meta_user_info = retrieve_user_info()
window.clearProperty('fen_fanart_error')
threads = []
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
'''SELECT media_id, season, episode FROM progress WHERE db_type=? ORDER BY rowid DESC''',
('episode', ))
rows = dbcur.fetchall()
for item in rows:
threads.append(Thread(target=process_eps, args=(item, )))
[i.start() for i in threads]
[i.join() for i in threads]
xbmcplugin.setContent(__handle__, 'episodes')
xbmcplugin.endOfDirectory(__handle__)
setView('view.episode_lists', 'episodes')
def erase_bookmark(db_type, media_id, season='', episode='', refresh='false'):
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()
refresh_container(refresh)
def check_for_next_episode_excludes():
from 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_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 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 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 __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 clear_trakt_watched_data(db_type):
settings.check_database(trakt_cache_file)
dbcon = database.connect(trakt_cache_file)
dbcur = dbcon.cursor()
if db_type == 'tvshow':
dbcur.execute("DELETE FROM fen_trakt WHERE id=?",
('trakt_tv_watched_raw', ))
window.clearProperty('trakt_tv_watched_raw')
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 clear_trakt_collection_watchlist_data(list_type, db_type):
settings.check_database(trakt_cache_file)
if db_type == 'movies': db_type = 'movie'
if db_type in ('tvshows', 'shows'): db_type = 'tvshow'
action = 'trakt_%s_%s' % (list_type, 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.clearProperty('fen_trakt_%s_%s' % (list_type, db_type))
except:
pass
def clear_trakt_calendar():
settings.check_database(trakt_cache_file)
try:
dbcon = database.connect(trakt_cache_file)
dbcur = dbcon.cursor()
dbcur.execute(
"SELECT id FROM fen_trakt WHERE id LIKE 'get_trakt_my_calendar%'")
c_days = dbcur.fetchall()
c_days = [str(i[0]) for i in c_days]
dbcur.execute(
"DELETE FROM fen_trakt WHERE id LIKE 'get_trakt_my_calendar%'")
dbcon.commit()
for i in c_days:
window.clearProperty(i)
except:
return
def in_progress_tvshow(db_type, page_no, letter):
from modules.utils import title_key
from modules.nav_utils import paginate_list
paginate = settings.paginate()
limit = settings.page_limit()
check_meta_database()
if settings.watched_indicators() in (1, 2):
from apis.trakt_api import trakt_indicators_tv
items = trakt_indicators_tv()
data = [(i[0], i[3]) for i in items if i[1] > len(i[2])]
else:
from modules.indicators_bookmarks import get_watched_status_tvshow, get_watched_info_tv
def _process(item):
meta = tvshow_meta('tmdb_id', item[0], meta_user_info)
watched_status = get_watched_status_tvshow(
watched_info, use_trakt, meta['tmdb_id'],
meta.get('total_episodes'))
if not watched_status[0] == 1: data.append(item)
data = []
threads = []
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
'''SELECT media_id, title, last_played FROM watched_status WHERE db_type=? ORDER BY rowid DESC''',
('episode', ))
rows1 = dbcur.fetchall()
in_progress_result = list(set([i for i in rows1]))
watched_info, use_trakt = get_watched_info_tv()
meta_user_info = retrieve_user_info()
window.setProperty('fen_fanart_error', 'true')
for item in in_progress_result:
threads.append(Thread(target=_process, args=(item, )))
[i.start() for i in threads]
[i.join() for i in threads]
data = sorted(data, key=lambda k: title_key(k[1]))
original_list = [{'media_id': i[0]} for i in data]
if paginate:
final_list, total_pages = paginate_list(original_list, page_no, letter,
limit)
else:
final_list, total_pages = original_list, 1
return final_list, total_pages
def remove_from_history(self, data_id=None):
try: from sqlite3 import dbapi2 as database
except ImportError: from pysqlite2 import dbapi2 as database
from modules.nav_utils import notification
display_notification = False
if not data_id:
params = dict(parse_qsl(sys.argv[2].replace('?','')))
data_id = params['data_id']
display_notification = True
cache_file = os.path.join(__addon_profile__, "fen_cache.db")
settings.check_database(cache_file)
dbcon = database.connect(cache_file)
dbcur = dbcon.cursor()
dbcur.execute("DELETE FROM fencache WHERE id=?", (data_id,))
dbcon.commit()
window.clearProperty(data_id)
xbmc.executebuiltin("Container.Refresh")
if display_notification: notification('Result Removed from Discover History')
def add_next_episode_unwatched(action=None, media_id=None, silent=False):
from modules.nav_utils import notification
from 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)
def in_progress_movie(db_type, page_no, letter):
from modules.nav_utils import paginate_list
paginate = settings.paginate()
limit = settings.page_limit()
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
'''SELECT media_id FROM progress WHERE db_type=? ORDER BY rowid DESC''',
('movie', ))
rows = dbcur.fetchall()
data = [i[0] for i in rows if not i[0] == '']
original_list = [{'media_id': i} for i in data]
if paginate:
final_list, total_pages = paginate_list(original_list, page_no, letter,
limit)
else:
final_list, total_pages = original_list, 1
return final_list, total_pages
def set_bookmark(db_type,
media_id,
curr_time,
total_time,
season='',
episode=''):
settings.check_database(WATCHED_DB)
erase_bookmark(db_type, media_id, season, episode)
adjusted_current_time = float(curr_time) - 5
resume_point = round(adjusted_current_time / float(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 modules.kodi_library import set_bookmark_kodi_library
set_bookmark_kodi_library(db_type, media_id, curr_time, season,
episode)
def get_watched_info_tv():
info = []
use_trakt = False
try:
if settings.watched_indicators() in (1, 2):
from apis.trakt_api import trakt_indicators_tv
use_trakt = True
info = trakt_indicators_tv()
else:
use_trakt = False
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
"SELECT media_id, season, episode, title FROM watched_status WHERE db_type = ?",
('episode', ))
info = dbcur.fetchall()
dbcon.close()
except:
pass
return info, use_trakt
def add_to_remove_from_next_episode_excludes():
from 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 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 modules.nav_utils import notification
notification('Error Marking Watched in Fen', time=5000)
def build_next_episode():
from modules.indicators_bookmarks import get_watched_info_tv
check_meta_database()
clear_all_trakt_cache_data(confirm=False)
sync_watched_trakt_to_fen()
try:
threads = []
seen = set()
ep_list = []
nextep_settings = settings.nextep_content_settings()
nextep_display_settings = settings.nextep_display_settings()
watched_info, use_trakt = get_watched_info_tv()
meta_user_info = retrieve_user_info()
cache_to_disk = nextep_settings['cache_to_disk']
nextep_display_settings['cache_to_disk'] = cache_to_disk
window.setProperty('fen_fanart_error', 'true')
if nextep_settings['include_unwatched']:
for i in get_unwatched_next_episodes():
ep_list.append(i)
if settings.watched_indicators() in (1, 2):
from apis.trakt_api import trakt_get_next_episodes
ep_list += trakt_get_next_episodes()
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(target=process_eps,
args=(item, nextep_settings, nextep_display_settings,
watched_info, use_trakt, meta_user_info)))
[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, nextep_settings)
item_list = [i['listitem'] for i in r]
for i in item_list:
xbmcplugin.addDirectoryItem(__handle__, i[0], i[1], i[2])
xbmcplugin.setContent(__handle__, 'episodes')
xbmcplugin.endOfDirectory(__handle__, cacheToDisc=cache_to_disk)
setView('view.episode_lists', 'episodes')
except:
from modules.nav_utils import notification
notification('Error getting Next Episode Info', time=3500)
pass
def build_next_episode_manager():
from modules.nav_utils import add_dir
from modules.indicators_bookmarks import get_watched_status_tvshow, get_watched_info_tv
def _process(tmdb_id, action):
try:
meta = tvshow_meta('tmdb_id', tmdb_id, meta_user_info)
title = meta['title']
if action == 'manage_unwatched':
action, display = 'remove', '[COLOR=%s][UNWATCHED][/COLOR] %s' % (
NEXT_EP_UNWATCHED, title)
url_params = {
'mode': 'add_next_episode_unwatched',
'action': 'remove',
'tmdb_id': tmdb_id,
'title': title
}
elif action == 'trakt_and_fen':
action, display = 'unhide' if tmdb_id in exclude_list else 'hide', '[COLOR=red][EXCLUDED][/COLOR] %s' % title if tmdb_id in exclude_list else '[COLOR=green][INCLUDED][/COLOR] %s' % 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 tmdb_id in exclude_list else 'add', '[COLOR=red][EXCLUDED][/COLOR] %s' % title if tmdb_id in exclude_list else '[COLOR=green][INCLUDED][/COLOR] %s' % title
url_params = {
'mode': 'add_to_remove_from_next_episode_excludes',
'action': action,
'title': title,
'media_id': tmdb_id
}
sorted_list.append({
'tmdb_id': tmdb_id,
'display': display,
'url_params': url_params,
'meta': json.dumps(meta)
})
except:
pass
check_meta_database()
clear_all_trakt_cache_data(confirm=False)
sync_watched_trakt_to_fen()
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'
threads = []
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 apis.trakt_api 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:'
action = 'trakt_and_fen'
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 modules.nav_utils import notification
return notification('No Shows Present', time=5000)
meta_user_info = retrieve_user_info()
window.setProperty('fen_fanart_error', 'true')
for tmdb_id in tmdb_list:
threads.append(Thread(target=_process, args=(tmdb_id, action)))
[i.start() for i in threads]
[i.join() for i in threads]
sorted_items = sorted(sorted_list, key=lambda k: k['display'])
watched_info, use_trakt = get_watched_info_tv()
for i in sorted_items:
try:
cm = []
meta = json.loads(i['meta'])
playcount, overlay, total_watched, total_unwatched = get_watched_status_tvshow(
watched_info, use_trakt, meta['tmdb_id'],
meta.get('total_episodes'))
meta.update({
'playcount': playcount,
'overlay': overlay,
'total_watched': str(total_watched),
'total_unwatched': str(total_unwatched)
})
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(meta['total_episodes']))
listitem.setProperty('totalseasons', str(meta['total_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', remove_unwanted_info_keys(meta))
xbmcplugin.addDirectoryItem(__handle__,
url,
listitem,
isFolder=True)
except:
pass
xbmcplugin.setContent(__handle__, 'tvshows')
xbmcplugin.endOfDirectory(__handle__, cacheToDisc=False)
setView('view.main', 'tvshows')
def debrid_link_folders(debrid_service, folder_name, action):
import xbmcgui
from modules import fen_cache
dialog = xbmcgui.Dialog()
_cache = fen_cache.FenCache()
string = 'FEN_%s_%s' % (debrid_service, folder_name)
check_show = _cache.get(string)
profile_dir = xbmc.translatePath(__addon__.getAddonInfo('profile'))
if action == 'remove':
if not check_show:
return dialog.ok('FEN DEBRID', 'No TV Show Linked to this Folder.')
if not dialog.yesno('FEN DEBRID',
'Clear Link to [B]%s[/B]?' % check_show):
return
from modules.settings import check_database
try:
from sqlite3 import dbapi2 as database
except ImportError:
from pysqlite2 import dbapi2 as database
window = xbmcgui.Window(10000)
cache_file = os.path.join(profile_dir, "fen_cache.db")
check_database(cache_file)
dbcon = database.connect(cache_file)
dbcur = dbcon.cursor()
dbcur.execute("DELETE FROM fencache WHERE id=?", (string, ))
dbcon.commit()
window.clearProperty(string)
return dialog.ok('FEN DEBRID', 'Link Removed.')
if check_show:
if not dialog.yesno(
'FEN DEBRID', 'This Folder is Already Linked to a TV Show:',
'[B]%s[/B]' % check_show,
'Do you wish to Link this Folder to a Different Show?'):
return
title = dialog.input("Enter TV Show Title").lower()
if not title: return
from apis.tmdb_api import tmdb_tv_title_year
year = dialog.input("Enter Year (Optional)", type=xbmcgui.INPUT_NUMERIC)
results = tmdb_tv_title_year(title, year)['results']
if len(results) == 0:
return dialog.ok('FEN DEBRID', 'No Matching Titles to Select.',
'Please Try a Different Search Term.')
choice_list = []
for item in results:
title = item['name']
try:
year = item['first_air_date'].split('-')[0]
except:
year = ''
if year: rootname = '%s (%s)' % (title, year)
else: rootname = title
line1 = rootname
line2 = '[I]%s[/I]' % item['overview']
icon = 'http://image.tmdb.org/t/p/w92%s' % item[
'poster_path'] if item.get('poster_path') else xbmc.translatePath(
__addon__.getAddonInfo('icon'))
listitem = xbmcgui.ListItem(line1, line2)
listitem.setArt({'icon': icon})
listitem.setProperty('rootname', rootname)
choice_list.append(listitem)
chosen_title = dialog.select("FEN DEBRID: Select Correct Title",
choice_list,
useDetails=True)
if chosen_title < 0: return
from datetime import timedelta
rootname = choice_list[chosen_title].getProperty('rootname')
_cache.set(string, rootname, expiration=timedelta(days=60))
return dialog.ok('FEN DEBRID', '[B]%s[/B]' % rootname,
'Linked to this Folder.')
def get_watched_items(db_type, page_no, letter):
from modules.nav_utils import paginate_list
from modules.utils import title_key, to_utf8
watched_indicators = settings.watched_indicators()
paginate = settings.paginate()
limit = settings.page_limit()
if db_type == 'tvshow':
if watched_indicators in (1, 2):
from apis.trakt_api 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:
import tikimeta
meta_user_info = tikimeta.retrieve_user_info()
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])))
watched_info, use_trakt = get_watched_info_tv()
data = []
for item in watched_list:
meta = tikimeta.tvshow_meta('tmdb_id', item[0], meta_user_info)
watched = get_watched_status_tvshow(watched_info, use_trakt,
item[0],
meta.get('total_episodes'))
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:
if watched_indicators in (1, 2):
from apis.trakt_api 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:
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]
if paginate:
final_list, total_pages = paginate_list(original_list, page_no, letter,
limit)
else:
final_list, total_pages = original_list, 1
return final_list, total_pages