def run(self):
logger('FEN', 'ReuseLanguageInvokerCheck Service Starting')
addon_xml = translate_path(
'special://home/addons/plugin.video.fen/addon.xml')
tree = ET.parse(addon_xml)
root = tree.getroot()
current_addon_setting = get_setting('reuse_language_invoker', 'true')
try:
current_xml_setting = [
str(i.text) for i in root.iter('reuselanguageinvoker')
][0]
except:
return logger('FEN', 'ReuseLanguageInvokerCheck Service Finished')
if current_xml_setting == current_addon_setting:
return logger('FEN', 'ReuseLanguageInvokerCheck Service Finished')
for item in root.iter('reuselanguageinvoker'):
item.text = current_addon_setting
hash_start = gen_file_hash(addon_xml)
tree.write(addon_xml)
hash_end = gen_file_hash(addon_xml)
logger('FEN', 'ReuseLanguageInvokerCheck Service Finished')
if hash_start != hash_end:
if not kodi_utils.confirm_dialog(text='%s\n%s' %
(ls(33021), ls(33020))):
return
current_profile = kodi_utils.get_infolabel(
'system.profilename')
kodi_utils.execute_builtin('LoadProfile(%s)' % current_profile)
else:
kodi_utils.ok_dialog(text=32574, top_space=True)
def export(self):
try:
db_type = self.discover_params['db_type']
query = self.discover_params['final_string']
name = self.discover_params['name']
set_history(db_type, name, query)
if db_type == 'movie':
mode = 'build_movie_list'
action = 'tmdb_movies_discover'
else:
mode = 'build_tvshow_list'
action = 'tmdb_tv_discover'
final_params = {
'name': name,
'mode': mode,
'action': action,
'query': query,
'iconImage': 'discover.png'
}
url_params = {
'mode': 'navigator.adjust_main_lists',
'method': 'add_external',
'list_name': name,
'menu_item': json.dumps(final_params)
}
kodi_utils.execute_builtin('RunPlugin(%s)' %
self._build_url(url_params))
except:
kodi_utils.notification(32574)
def remove_from_favourites(self):
dbcon = database.connect(self.fav_database)
dbcon.execute("DELETE FROM favourites where db_type=? and tmdb_id=?", (self.db_type, str(self.tmdb_id)))
dbcon.commit()
dbcon.close()
execute_builtin('Container.Refresh')
notification(32576, 3500)
def get_search_term(params):
kodi_utils.close_all_dialog()
db_type = params.get('db_type', '')
query = params.get('query')
search_type = params.get('search_type', 'media_title')
if not query:
from urllib.parse import unquote
query = kodi_utils.dialog.input('Fen')
if not query: return
query = unquote(query)
if search_type == 'media_title':
mode, action = ('build_movie_list',
'tmdb_movies_search') if db_type == 'movie' else (
'build_tvshow_list', 'tmdb_tv_search')
url = {'mode': mode, 'action': action, 'query': query}
elif search_type == 'imdb_keyword':
url = {
'mode': 'imdb_build_keyword_results',
'db_type': db_type,
'query': query
}
if kodi_utils.external_browse():
return kodi_utils.execute_builtin('ActivateWindow(10025,%s,return)' %
kodi_utils.build_url(url))
return kodi_utils.execute_builtin('Container.Update(%s)' %
kodi_utils.build_url(url))
def toggle_language_invoker():
import xml.etree.ElementTree as ET
from modules.utils import gen_file_hash
kodi_utils.close_all_dialog()
kodi_utils.sleep(100)
addon_dir = kodi_utils.translate_path(
'special://home/addons/plugin.video.fen')
addon_xml = os.path.join(addon_dir, 'addon.xml')
tree = ET.parse(addon_xml)
root = tree.getroot()
try:
current_value = [
str(i.text) for i in root.iter('reuselanguageinvoker')
][0]
except:
return
current_setting = get_setting('reuse_language_invoker')
new_value = 'false' if current_value == 'true' else 'true'
if not kodi_utils.confirm_dialog(
text=ls(33018) % (current_value.upper(), new_value.upper())):
return
if new_value == 'true':
if not kodi_utils.confirm_dialog(text=33019, top_space=True): return
for item in root.iter('reuselanguageinvoker'):
item.text = new_value
hash_start = gen_file_hash(addon_xml)
tree.write(addon_xml)
hash_end = gen_file_hash(addon_xml)
if hash_start != hash_end:
set_setting('reuse_language_invoker', new_value)
else:
return kodi_utils.ok_dialog(text=32574, top_space=True)
kodi_utils.ok_dialog(text=33020, top_space=True)
kodi_utils.execute_builtin('LoadProfile(%s)' %
kodi_utils.get_infolabel('system.profilename'))
def toggle_jump_to():
from modules.settings import nav_jump_use_alphabet
(setting,
new_action) = ('0', ls(32022)) if nav_jump_use_alphabet() else ('1',
ls(32023))
set_setting('nav_jump', setting)
kodi_utils.execute_builtin('Container.Refresh')
kodi_utils.notification(ls(32851) % new_action)
def hide_unhide_trakt_items(action, db_type, media_id, list_type):
db_type = 'movies' if db_type in ['movie', 'movies'] else 'shows'
key = 'tmdb' if db_type == 'movies' else 'imdb'
url = 'users/hidden/%s' % list_type if action == 'hide' else 'users/hidden/%s/remove' % list_type
data = {db_type: [{'ids': {key: media_id}}]}
call_trakt(url, data=data)
trakt_sync_activities()
kodi_utils.execute_builtin('Container.Refresh')
def pm_delete(file_type, file_id):
if not kodi_utils.confirm_dialog(): return
result = Premiumize.delete_object(file_type, file_id)
if result == 'success':
Premiumize.clear_cache()
kodi_utils.execute_builtin('Container.Refresh')
else:
return kodi_utils.ok_dialog(text=32574, top_space=True)
def run(self):
try:
logger('FEN', 'AutoRun Service Starting')
if settings.auto_start_fen():
kodi_utils.execute_builtin('RunAddon(plugin.video.fen)')
logger('FEN', 'AutoRun Service Finished')
return
except:
return
def delete_trakt_list(params):
user = params['user']
list_slug = params['list_slug']
if not kodi_utils.confirm_dialog(): return
url = 'users/%s/lists/%s' % (user, list_slug)
call_trakt(url, is_delete=True)
trakt_sync_activities()
kodi_utils.notification(32576, 3000)
kodi_utils.execute_builtin('Container.Refresh')
def remove_from_collection(data):
result = call_trakt('/sync/collection/remove', data=data)
if result['deleted']['movies'] > 0: db_type = 'movie'
elif result['deleted']['episodes'] > 0: db_type = 'tvshow'
else: return kodi_utils.notification(32574, 3000)
kodi_utils.notification(32576, 3000)
trakt_sync_activities()
kodi_utils.execute_builtin('Container.Refresh')
return result
def remove_from_files(item_id):
if not kodi_utils.confirm_dialog(): return
response = Furk.file_unlink(item_id)
if Furk.check_status(response):
kodi_utils.notification(32576, 3500)
kodi_utils.execute_builtin('Container.Refresh')
else:
kodi_utils.notification(32574, 3500)
return (None, None)
def rd_delete(file_id, cache_type):
if not kodi_utils.confirm_dialog(): return
if cache_type == 'torrent': result = RealDebrid.delete_torrent(file_id)
else:
result = RealDebrid.delete_download(file_id) # cache_type: 'download'
if result.status_code in (401, 403, 404):
return kodi_utils.notification(32574)
RealDebrid.clear_cache()
kodi_utils.execute_builtin('Container.Refresh')
def pm_rename(file_type, file_id, current_name):
new_name = kodi_utils.dialog.input('Fen', defaultt=current_name)
if not new_name: return
result = Premiumize.rename_cache_item(file_type, file_id, new_name)
if result == 'success':
Premiumize.clear_cache()
kodi_utils.execute_builtin('Container.Refresh')
else:
return kodi_utils.ok_dialog(text=32574, top_space=True)
def _process(self, key=None, values=None, index=None):
if key:
index = self._listitem_position(key)
self.discover_params['search_string'][key] = values[0]
self.discover_params['search_name'][key] = values[1]
self._build_string()
self._build_name()
self._set_property()
kodi_utils.execute_builtin('Container.Refresh')
if index: kodi_utils.focus_index(index, 500)
def remove_from_history(params):
cache_file = kodi_utils.translate_path(
'special://profile/addon_data/plugin.video.fen/maincache.db')
dbcon = database.connect(cache_file)
dbcur = dbcon.cursor()
dbcur.execute("DELETE FROM maincache WHERE id=?", (params['data_id'], ))
dbcon.commit()
kodi_utils.clear_property(params['data_id'])
kodi_utils.execute_builtin('Container.Refresh')
if not params['silent']: kodi_utils.notification(32576)
def remove_from_list(user, slug, data):
result = call_trakt('/users/%s/lists/%s/items/remove' % (user, slug),
data=data)
if result['deleted']['shows'] > 0 or result['deleted']['movies'] > 0:
kodi_utils.notification(32576, 3000)
trakt_sync_activities()
kodi_utils.execute_builtin('Container.Refresh')
else:
kodi_utils.notification(32574, 3000)
return result
def myfiles_protect_unprotect(action, name, item_id):
is_protected = '1' if action == 'protect' else '0'
try:
response = Furk.file_protect(item_id, is_protected)
if Furk.check_status(response):
kodi_utils.execute_builtin('Container.Refresh')
return kodi_utils.notification(32576)
else:
kodi_utils.notification(32574)
except:
return
def make_new_trakt_list(params):
from urllib.parse import unquote
mode = params['mode']
list_title = kodi_utils.dialog.input('Fen')
if not list_title: return
list_name = unquote(list_title)
data = {'name': list_name, 'privacy': 'private', 'allow_comments': False}
call_trakt('users/me/lists', data=data)
trakt_sync_activities()
kodi_utils.notification(32576, 3000)
kodi_utils.execute_builtin('Container.Refresh')
def trakt_unlike_a_list(params):
user = params['user']
list_slug = params['list_slug']
try:
call_trakt('/users/%s/lists/%s/like' % (user, list_slug),
method='delete')
kodi_utils.notification(32576, 3000)
trakt_sync_activities()
kodi_utils.execute_builtin('Container.Refresh')
except:
kodi_utils.notification(32574, 3000)
def remove_from_search_history(params):
try:
result = main_cache.get(params['setting_id'])
result.remove(params.get('query'))
main_cache.set(params['setting_id'],
result,
expiration=EXPIRES_365_DAYS)
kodi_utils.notification(32576, 3500)
kodi_utils.execute_builtin('Container.Refresh')
except:
return
def build_navigate_to_page(params):
import json
from modules.settings import nav_jump_use_alphabet
use_alphabet = nav_jump_use_alphabet()
icon = kodi_utils.translate_path(
'special://home/addons/script.tikiart/resources/media/item_jump.png')
fanart = kodi_utils.translate_path(
'special://home/addons/plugin.video.fen/fanart.png')
db_type = params.get('db_type')
def _builder(use_alphabet):
for i in start_list:
if use_alphabet:
line1, line2 = i.upper(), ls(32821) % (db_type, i.upper())
else:
line1, line2 = '%s %s' % (ls(32022), i), ls(32822) % i
yield {'line1': line1, 'line2': line2, 'icon': icon}
if use_alphabet:
start_list = [chr(i) for i in range(97, 123)]
else:
start_list = [
str(i) for i in range(1,
int(params.get('total_pages')) + 1)
]
start_list.remove(params.get('current_page'))
list_items = list(_builder(use_alphabet))
kwargs = {
'items': json.dumps(list_items),
'heading': 'Fen',
'enumerate': 'false',
'multi_choice': 'false',
'multi_line': 'false'
}
new_start = kodi_utils.select_dialog(start_list, **kwargs)
kodi_utils.sleep(100)
if new_start == None: return
if use_alphabet: new_page, new_letter = '', new_start
else: new_page, new_letter = new_start, None
url_params = {
'mode': params.get('transfer_mode', ''),
'action': params.get('transfer_action', ''),
'new_page': new_page,
'new_letter': new_letter,
'media_type': params.get('media_type', ''),
'query': params.get('query', ''),
'actor_id': params.get('actor_id', ''),
'user': params.get('user', ''),
'slug': params.get('slug', '')
}
kodi_utils.execute_builtin('Container.Update(%s)' %
kodi_utils.build_url(url_params))
def refresh_cached_data(db_type, id_type, media_id, tvdb_id, meta_language):
from caches.meta_cache import metacache
try:
metacache.delete(db_type,
id_type,
media_id,
tvdb_id=tvdb_id,
meta_language=meta_language)
if db_type == 'tvshow':
metacache.delete_all_seasons_memory_cache(media_id)
kodi_utils.notification(32576)
kodi_utils.execute_builtin('Container.Refresh')
except:
kodi_utils.notification(32574)
def open_settings(query, addon='plugin.video.fen'):
kodi_utils.sleep(250)
if query:
try:
button, control = 100, 80
kodi_utils.hide_busy_dialog()
menu, function = query.split('.')
kodi_utils.execute_builtin('Addon.OpenSettings(%s)' % addon)
kodi_utils.execute_builtin('SetFocus(%i)' % (int(menu) - button))
kodi_utils.execute_builtin('SetFocus(%i)' %
(int(function) - control))
except:
kodi_utils.execute_builtin('Addon.OpenSettings(%s)' % addon)
else:
kodi_utils.execute_builtin('Addon.OpenSettings(%s)' % addon)
def refresh_artwork():
if not kodi_utils.confirm_dialog(): return
import sqlite3 as database
for item in ('icon.png', 'fanart.png'):
try:
icon_path = kodi_utils.translate_path(
'special://home/addons/plugin.video.fen/%s' % item)
thumbs_folder = kodi_utils.translate_path('special://thumbnails')
TEXTURE_DB = kodi_utils.translate_path(
'special://database/Textures13.db')
dbcon = database.connect(TEXTURE_DB)
dbcur = dbcon.cursor()
dbcur.execute("SELECT cachedurl FROM texture WHERE url = ?",
(icon_path, ))
image = dbcur.fetchone()[0]
dbcon.close()
removal_path = os.path.join(thumbs_folder, image)
kodi_utils.delete_file(removal_path)
except:
pass
kodi_utils.sleep(200)
kodi_utils.execute_builtin('ReloadSkin()')
kodi_utils.sleep(500)
kodi_utils.notification(32576)
def play_fetch_random(tmdb_id):
meta_user_info = metadata.retrieve_user_info()
meta = metadata.tvshow_meta('tmdb_id', tmdb_id, meta_user_info)
adjust_hours = date_offset()
current_date = get_datetime()
episodes_data = metadata.all_episodes_meta(meta, meta_user_info)
episodes_data = [
i for i in episodes_data if not i['season'] == 0 and
adjust_premiered_date(i['premiered'], adjust_hours)[0] <= current_date
]
if not episodes_data: return {'pass': True}
chosen_episode = choice(episodes_data)
title = meta['title']
season = int(chosen_episode['season'])
episode = int(chosen_episode['episode'])
query = title + ' S%.2dE%.2d' % (season, episode)
display_name = '%s - %dx%.2d' % (title, season, episode)
ep_name = chosen_episode['title']
plot = chosen_episode['plot']
try:
premiered = adjust_premiered_date(chosen_episode['premiered'],
adjust_hours)[1]
except:
premiered = chosen_episode['premiered']
meta.update({
'vid_type': 'episode',
'rootname': display_name,
'season': season,
'episode': episode,
'premiered': premiered,
'ep_name': ep_name,
'plot': plot,
'random': 'true'
})
url_params = {
'mode': 'play_media',
'vid_type': 'episode',
'tmdb_id': meta['tmdb_id'],
'query': query,
'tvshowtitle': meta['rootname'],
'season': season,
'episode': episode,
'autoplay': 'True'
}
return execute_builtin('RunPlugin(%s)' % build_url(url_params))
def _clear_property(self):
kodi_utils.clear_property(self.window_id)
self.discover_params = {}
kodi_utils.execute_builtin('Container.Refresh')
def options_menu(params, meta=None):
def _builder():
for item in listing:
line1 = item[0]
line2 = item[1]
if line2 == '': line2 = line1
yield {'line1': line1, 'line2': line2}
content = params.get('content', None)
if not content: content = kodi_utils.container_content()[:-1]
season = params.get('season', None)
episode = params.get('episode', None)
if not meta:
function = metadata.movie_meta if content == 'movie' else metadata.tvshow_meta
meta_user_info = metadata.retrieve_user_info()
meta = function('tmdb_id', params['tmdb_id'], meta_user_info)
watched_indicators = settings.watched_indicators()
on_str, off_str, currently_str, open_str, settings_str = ls(32090), ls(
32027), ls(32598), ls(32641), ls(32247)
autoplay_status, autoplay_toggle, quality_setting = (on_str, 'false', 'autoplay_quality_%s' % content) if settings.auto_play(content) \
else (off_str, 'true', 'results_quality_%s' % content)
quality_filter_setting = 'autoplay_quality_%s' % content if autoplay_status == on_str else 'results_quality_%s' % content
autoplay_next_status, autoplay_next_toggle = (
on_str, 'false') if settings.autoplay_next_episode() else (off_str,
'true')
results_xml_style_status = get_setting('results.xml_style', 'Default')
results_filter_ignore_status, results_filter_ignore_toggle = (
on_str, 'false') if settings.ignore_results_filter() else (off_str,
'true')
results_sorting_status = get_setting('results.sort_order_display').replace(
'$ADDON[plugin.video.fen 32582]', ls(32582))
current_results_highlights_action = get_setting('highlight.type')
results_highlights_status = ls(
32240) if current_results_highlights_action == '0' else ls(
32583) if current_results_highlights_action == '1' else ls(32241)
current_subs_action = get_setting('subtitles.subs_action')
current_subs_action_status = 'Auto' if current_subs_action == '0' else ls(
32193) if current_subs_action == '1' else off_str
active_internal_scrapers = [
i.replace('_', '') for i in settings.active_internal_scrapers()
]
current_scrapers_status = ', '.join([
i for i in active_internal_scrapers
]) if len(active_internal_scrapers) > 0 else 'N/A'
current_quality_status = ', '.join(
settings.quality_filter(quality_setting))
uncached_torrents_status, uncached_torrents_toggle = (
on_str, 'false') if settings.display_uncached_torrents() else (off_str,
'true')
listing = []
base_str1 = '%s%s'
base_str2 = '%s: [B]%s[/B]' % (currently_str, '%s')
if content in ('movie', 'episode'):
multi_line = 'true'
listing += [(ls(32014), '', 'clear_and_rescrape')]
listing += [(ls(32006), '', 'rescrape_with_disabled')]
listing += [(ls(32135), '', 'scrape_with_custom_values')]
listing += [(base_str1 % (ls(32175), ' (%s)' % content),
base_str2 % autoplay_status, 'toggle_autoplay')]
if autoplay_status == on_str and content == 'episode':
listing += [
(base_str1 % (ls(32178), ''), base_str2 % autoplay_next_status,
'toggle_autoplay_next')
]
listing += [(base_str1 % (ls(32105), ' (%s)' % content),
base_str2 % current_quality_status, 'set_quality')]
listing += [(base_str1 % ('', '%s %s' % (ls(32055), ls(32533))),
base_str2 % current_scrapers_status, 'enable_scrapers')]
if autoplay_status == off_str:
listing += [(base_str1 % ('', ls(32140)),
base_str2 % results_xml_style_status,
'set_results_xml_display')]
listing += [
(base_str1 % ('', ls(32151)),
base_str2 % results_sorting_status, 'set_results_sorting')
]
listing += [(base_str1 % ('', ls(32138)),
base_str2 % results_highlights_status,
'set_results_highlights')]
listing += [(base_str1 % ('', ls(32686)),
base_str2 % results_filter_ignore_status,
'set_results_filter_ignore')]
listing += [(base_str1 % ('', ls(32183)),
base_str2 % current_subs_action_status, 'set_subs_action')
]
if 'external' in active_internal_scrapers:
listing += [(base_str1 % ('', ls(32160)),
base_str2 % uncached_torrents_status,
'toggle_torrents_display_uncached')]
else:
multi_line = 'false'
listing += [(ls(32046), '', 'extras_lists_choice')]
if content in ('movie', 'tvshow') and meta:
listing += [
(ls(32604) %
(ls(32028) if meta['mediatype'] == 'movie' else ls(32029)), '',
'clear_media_cache')
]
if watched_indicators == 1:
listing += [(ls(32497) % ls(32037), '', 'clear_trakt_cache')]
if content in ('movie', 'episode'):
listing += [(ls(32637), '', 'clear_scrapers_cache')]
listing += [('%s %s' % (ls(32118), ls(32513)), '',
'open_external_scrapers_manager')]
listing += [('%s %s %s' % (open_str, ls(32522), settings_str), '',
'open_scraper_settings')]
listing += [('%s %s %s' % (open_str, ls(32036), settings_str), '',
'open_fen_settings')]
listing += [(ls(32640), '', 'save_and_exit')]
list_items = list(_builder())
heading = ls(32646).replace('[B]', '').replace('[/B]', '')
kwargs = {
'items': json.dumps(list_items),
'heading': heading,
'enumerate': 'false',
'multi_choice': 'false',
'multi_line': multi_line
}
choice = kodi_utils.select_dialog([i[2] for i in listing], **kwargs)
if choice in (None, 'save_and_exit'): return
elif choice == 'clear_and_rescrape':
return clear_and_rescrape(content, meta, season, episode)
elif choice == 'rescrape_with_disabled':
return rescrape_with_disabled(content, meta, season, episode)
elif choice == 'scrape_with_custom_values':
return scrape_with_custom_values(content, meta, season, episode)
elif choice == 'toggle_autoplay':
set_setting('auto_play_%s' % content, autoplay_toggle)
elif choice == 'toggle_autoplay_next':
set_setting('autoplay_next_episode', autoplay_next_toggle)
elif choice == 'enable_scrapers':
enable_scrapers_choice()
elif choice == 'set_results_xml_display':
results_layout_choice()
elif choice == 'set_results_sorting':
results_sorting_choice()
elif choice == 'set_results_filter_ignore':
set_setting('ignore_results_filter', results_filter_ignore_toggle)
elif choice == 'set_results_highlights':
results_highlights_choice()
elif choice == 'set_quality':
set_quality_choice(quality_filter_setting)
elif choice == 'set_subs_action':
set_subtitle_choice()
elif choice == 'extras_lists_choice':
extras_lists_choice()
elif choice == 'clear_media_cache':
return refresh_cached_data(meta['mediatype'], 'tmdb_id',
meta['tmdb_id'], meta['tvdb_id'],
settings.get_language())
elif choice == 'toggle_torrents_display_uncached':
set_setting('torrent.display.uncached', uncached_torrents_toggle)
elif choice == 'clear_trakt_cache':
return clear_cache('trakt')
elif choice == 'clear_scrapers_cache':
return clear_scrapers_cache()
elif choice == 'open_external_scrapers_manager':
return external_scrapers_manager()
elif choice == 'open_scraper_settings':
return kodi_utils.execute_builtin(
'Addon.OpenSettings(script.module.fenomscrapers)')
elif choice == 'open_fen_settings':
return open_settings('0.0')
if choice == 'clear_trakt_cache' and content in ('movie', 'tvshow',
'season', 'episode'):
kodi_utils.execute_builtin('Container.Refresh')
kodi_utils.show_busy_dialog()
kodi_utils.sleep(200)
kodi_utils.hide_busy_dialog()
options_menu(params, meta=meta)
def refresh_container(refresh='true'):
if refresh == 'true': kodi_utils.execute_builtin('Container.Refresh')
def link_folders(service, folder_name, action):
import json
from caches.main_cache import main_cache
def _get_media_type():
media_type_list = [('movie', ls(32028), 'movies.png'),
('tvshow', ls(32029), 'tv.png')]
list_items = [{
'line1': item[1],
'line2': ls(32693) % item[1],
'icon': os.path.join(theme_folder, item[2])
} for item in media_type_list]
kwargs = {
'items': json.dumps(list_items),
'heading': 'Fen',
'enumerate': 'false',
'multi_choice': 'false',
'multi_line': 'true'
}
chosen_media_type = kodi_utils.select_dialog(
[i[0] for i in media_type_list], **kwargs)
return chosen_media_type
theme_folder = kodi_utils.translate_path(
'special://home/addons/script.tikiart/resources/media')
string = 'FEN_%s_%s' % (service, folder_name)
current_link = main_cache.get(string)
if action == 'remove':
if not current_link: return
if not kodi_utils.confirm_dialog(text=ls(32694) % current_link,
top_space=True):
return
import sqlite3 as database
cache_file = kodi_utils.translate_path(
'special://profile/addon_data/plugin.video.fen/maincache.db')
dbcon = database.connect(cache_file)
dbcur = dbcon.cursor()
dbcur.execute("DELETE FROM maincache WHERE id=?", (string, ))
dbcon.commit()
dbcon.close()
kodi_utils.clear_property(string)
if service == 'FOLDER': clear_cache('folders', silent=True)
kodi_utils.execute_builtin('Container.Refresh')
return kodi_utils.ok_dialog(text=32576, top_space=True)
if current_link:
if not kodi_utils.confirm_dialog(text='%s[CR][B]%s[/B][CR]%s' %
(ls(32695), current_link, ls(32696))):
return
media_type = _get_media_type()
if media_type == None: return
title = kodi_utils.dialog.input(ls(32228)).lower()
if not title: return
from apis.tmdb_api import tmdb_movies_title_year, tmdb_tv_title_year
year = kodi_utils.dialog.input('%s (%s)' % (ls(32543), ls(32669)),
type=kodi_utils.numeric_input)
function = tmdb_movies_title_year if media_type == 'movie' else tmdb_tv_title_year
results = function(title, year)['results']
if len(results) == 0:
return kodi_utils.ok_dialog(text=32490, top_space=True)
name_key = 'title' if media_type == 'movie' else 'name'
released_key = 'release_date' if media_type == 'movie' else 'first_air_date'
function_list = []
function_list_append = function_list.append
def _builder():
for item in results:
title = item[name_key]
try:
year = item[released_key].split('-')[0]
except:
year = ''
if year: rootname = '%s (%s)' % (title, year)
else: rootname = title
icon = 'https://image.tmdb.org/t/p/w780%s' % item['poster_path'] if item.get('poster_path') \
else kodi_utils.translate_path('special://home/addons/plugin.video.fen/icon.png')
function_list_append(rootname)
yield {'line1': rootname, 'line2': item['overview'], 'icon': icon}
list_items = list(_builder())
kwargs = {
'items': json.dumps(list_items),
'heading': 'Fen',
'enumerate': 'false',
'multi_choice': 'false',
'multi_line': 'true'
}
rootname = kodi_utils.select_dialog(function_list, **kwargs)
if rootname == None: return
from datetime import timedelta
main_cache.set(string, rootname, expiration=timedelta(days=365))
if service == 'FOLDER': clear_cache('folders', silent=True)
kodi_utils.execute_builtin('Container.Refresh')
return kodi_utils.ok_dialog(text=32576, top_space=True)
