def get_video_url(page_url, premium=False, video_password=""):
logger.info("pelisalacarta.servers.realdebrid get_video_url( page_url='%s' , video_password=%s)"
% (page_url, video_password))
# Se comprueba si existe un token guardado y sino se ejecuta el proceso de autentificación
token_auth = channeltools.get_channel_setting("realdebrid_token", "realdebrid")
if token_auth is None or token_auth == "":
if config.is_xbmc():
token_auth = authentication()
if token_auth == "":
return [["REAL-DEBRID: No se ha completado el proceso de autentificación", ""]]
else:
return [["Es necesario activar la cuenta. Accede al menú de ayuda", ""]]
post_link = urllib.urlencode([("link", page_url), ("password", video_password)])
headers["Authorization"] = "Bearer %s" % token_auth
url = "https://api.real-debrid.com/rest/1.0/unrestrict/link"
data = scrapertools.downloadpage(url, post=post_link, headers=headers.items())
data = jsontools.load_json(data)
# Si el token es erróneo o ha caducado, se solicita uno nuevo
if "error" in data and data["error"] == "bad_token":
debrid_id = channeltools.get_channel_setting("realdebrid_id", "realdebrid")
secret = channeltools.get_channel_setting("realdebrid_secret", "realdebrid")
refresh = channeltools.get_channel_setting("realdebrid_refresh", "realdebrid")
post_token = urllib.urlencode({"client_id": debrid_id, "client_secret": secret, "code": refresh,
"grant_type": "http://oauth.net/grant_type/device/1.0"})
renew_token = scrapertools.downloadpage("https://api.real-debrid.com/oauth/v2/token", post=post_token,
headers=headers.items())
renew_token = jsontools.load_json(renew_token)
if not "error" in renew_token:
token_auth = renew_token["access_token"]
channeltools.set_channel_setting("realdebrid_token", token_auth, "realdebrid")
headers["Authorization"] = "Bearer %s" % token_auth
data = scrapertools.downloadpage(url, post=post_link, headers=headers.items())
data = jsontools.load_json(data)
if "download" in data:
return get_enlaces(data)
else:
if "error" in data:
msg = data["error"].decode("utf-8","ignore")
msg = msg.replace("hoster_unavailable", "Servidor no disponible") \
.replace("unavailable_file", "Archivo no disponible") \
.replace("hoster_not_free", "Servidor no gratuito") \
.replace("bad_token", "Error en el token")
return [["REAL-DEBRID: " + msg, ""]]
else:
return [["REAL-DEBRID: No se ha generado ningún enlace", ""]]
def lastSearch(self):
logger.debug()
if not self.item.text:
if config.get_setting('last_search'): last_search = channeltools.get_channel_setting('Last_searched', 'search', '')
else: last_search = ''
if not self.item.text: self.item.text = platformtools.dialog_input(default=last_search, heading='')
if self.item.text: channeltools.set_channel_setting('Last_searched', self.item.text, 'search')
def get_setting(name, channel=""):
"""Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global o en la configuracion propia del canal 'channel'.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.pelisalacarta\settings_channels el archivo channel_data.json
y lee el valor del parametro 'name'. Si el archivo channel_data.json no existe busca en la carpeta channels el archivo
channel.xml y crea un archivo channel_data.json antes de retornar el valor solicitado.
Si el parametro 'name' no existe en channel_data.json lo busca en la configuracion global y si ahi tampoco existe devuelve un str vacio.
Parametros:
name -- nombre del parametro
channel [opcional] -- nombre del canal
Retorna:
value -- El valor del parametro 'name'
"""
if channel:
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
if not value is None:
return value
# Devolvemos el valor del parametro global 'name'
return __settings__.getSetting( name )
def get_setting(name, channel=""):
if channel:
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
if not value is None:
return value
# Devolvemos el valor del parametro global 'name'
if name == "cache.dir":
return ""
if name == "debug" or name == "download.enabled":
return "false"
if name == "cookies.dir":
return os.getcwd()
if name == "cache.mode" or name == "thumbnail_type":
return "2"
else:
import bridge
try:
devuelve = bridge.get_setting(name)
except:
devuelve = ""
if type(devuelve) == BooleanType:
if devuelve:
devuelve = "true"
else:
devuelve = "false"
return devuelve
def new_search(item):
logger.info()
itemlist = []
last_search = channeltools.get_channel_setting('Last_searched', 'search',
'')
searched_text = platformtools.dialog_input(default=last_search,
heading='Alfa (Busqueda)')
if not searched_text:
return
channeltools.set_channel_setting('Last_searched', searched_text, 'search')
searched_text = searched_text.replace("+", " ")
if item.mode == 'person':
item.searched_text = searched_text
return actor_list(item)
if item.mode != 'all':
tmdb_info = tmdb.Tmdb(texto_buscado=searched_text,
tipo=item.mode.replace('show', ''))
results = tmdb_info.results
for result in results:
result = tmdb_info.get_infoLabels(result, origen=result)
if item.mode == 'movie':
title = result['title']
else:
title = result['name']
item.mode = 'tvshow'
thumbnail = result.get('thumbnail', '')
fanart = result.get('fanart', '')
new_item = Item(channel=item.channel,
action='channel_search',
title=title,
text=searched_text,
thumbnail=thumbnail,
fanart=fanart,
mode=item.mode,
infoLabels=result)
if item.mode == 'movie':
new_item.contentTitle = result['title']
else:
new_item.contentSerieName = result['name']
itemlist.append(new_item)
if item.mode == 'all' or not itemlist:
itemlist = channel_search(
Item(channel=item.channel,
title=searched_text,
text=searched_text,
mode='all',
infoLabels={}))
return itemlist
def lastSearch(self):
logger.debug()
if not self.item.text:
if self.item.contentTitle:
self.item.text = self.item.contentTitle
elif self.item.contentSerieName:
self.item.text = self.item.contentSerieName
if not self.item.text:
if config.get_setting('last_search'):
last_search = channeltools.get_channel_setting(
'Last_searched', 'search', '')
else:
last_search = ''
if not self.item.text:
self.item.text = platformtools.dialog_input(
default=last_search, heading='')
if self.item.text:
channeltools.set_channel_setting('Last_searched',
self.item.text, 'search')
if self.item.mode == 'all':
save_search(self.item.text)
else:
if self.item.context:
del self.item.context # needed for preventing same content twice in saved search
save_search(self.item.__dict__)
def get_setting(name, channel=""):
if channel:
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
if not value is None:
return value
# Devolvemos el valor del parametro global 'name'
if name=="cache.dir":
return ""
if name=="debug" or name=="download.enabled":
return "false"
if name=="cookies.dir":
return os.getcwd()
if name=="cache.mode" or name=="thumbnail_type":
return "2"
else:
import bridge
try:
devuelve = bridge.get_setting(name)
except:
devuelve = ""
if type(devuelve) == BooleanType:
if devuelve:
devuelve = "true"
else:
devuelve = "false"
return devuelve
def get_video_url(page_url, premium=False, video_password=""):
logger.info("streamondemand.servers.realdebrid get_video_url( page_url='%s' , video_password=%s)"
% (page_url, video_password))
# Se comprueba si existe un token guardado y sino se ejecuta el proceso de autentificación
token_auth = channeltools.get_channel_setting("realdebrid_token", "realdebrid")
if token_auth is None or token_auth == "":
token_auth = authentication()
if token_auth == "":
return [["REAL-DEBRID: No se ha completado el proceso de autentificación", ""]]
post_link = urllib.urlencode([("link", page_url), ("password", video_password)])
headers["Authorization"] = "Bearer %s" % token_auth
url = "https://api.real-debrid.com/rest/1.0/unrestrict/link"
data = scrapertools.downloadpage(url, post=post_link, headers=headers.items())
data = jsontools.load_json(data)
# Si el token es erróneo o ha caducado, se solicita uno nuevo
if "error" in data and data["error"] == "bad_token":
debrid_id = channeltools.get_channel_setting("realdebrid_id", "realdebrid")
secret = channeltools.get_channel_setting("realdebrid_secret", "realdebrid")
refresh = channeltools.get_channel_setting("realdebrid_refresh", "realdebrid")
post_token = urllib.urlencode({"client_id": debrid_id, "client_secret": secret, "code": refresh,
"grant_type": "http://oauth.net/grant_type/device/1.0"})
renew_token = scrapertools.downloadpage("https://api.real-debrid.com/oauth/v2/token", post=post_token,
headers=headers.items())
renew_token = jsontools.load_json(renew_token)
if not "error" in renew_token:
token_auth = renew_token["access_token"]
channeltools.set_channel_setting("realdebrid_token", token_auth, "realdebrid")
headers["Authorization"] = "Bearer %s" % token_auth
data = scrapertools.downloadpage(url, post=post_link, headers=headers.items())
data = jsontools.load_json(data)
if "download" in data:
return get_enlaces(data)
else:
if "error" in data:
msg = data["error"].decode("utf-8","ignore")
msg = msg.replace("hoster_unavailable", "Servidor no disponible") \
.replace("unavailable_file", "Archivo no disponible") \
.replace("hoster_not_free", "Servidor no gratuito") \
.replace("bad_token", "Error en el token")
return [["REAL-DEBRID: " + msg, ""]]
else:
return [["REAL-DEBRID: No se ha generado ningún enlace", ""]]
def get_setting(name, channel="", server=""):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global o en la configuracion propia del canal 'channel'.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.pelisalacarta\settings_channels el
archivo channel_data.json y lee el valor del parametro 'name'. Si el archivo channel_data.json no existe busca en la
carpeta channels el archivo channel.xml y crea un archivo channel_data.json antes de retornar el valor solicitado.
Si el parametro 'name' no existe en channel_data.json lo busca en la configuracion global y si ahi tampoco existe
devuelve un str vacio.
Parametros:
name -- nombre del parametro
channel [opcional] -- nombre del canal
Retorna:
value -- El valor del parametro 'name'
"""
# Specific channel setting
if channel:
from core import channeltools
return channeltools.get_channel_setting(name, channel)
elif server:
from core import servertools
return servertools.get_server_setting(name, server)
# Global setting
else:
# Devolvemos el valor del parametro global 'name'
if name == "cache.dir":
value = ""
if name == "debug" or name == "download.enabled":
value = False
if name == "cookies.dir":
value = os.getcwd() #TODO no parece funcionar
if name == "cache.mode" or name == "thumbnail_type":
value = 2
else:
value = bridge.get_setting(name)
# hack para devolver el tipo correspondiente
settings_types = get_settings_types()
if isinstance(settings_types.get(name),
tuple) and settings_types[name][0] == 'enum':
value = settings_types[name][1].index(value)
elif settings_types.get(name) == 'bool':
value = bool(value)
return value
def get_setting(name, channel=""):
if channel:
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
if not value is None:
return value
return __settings__.getSetting( name )
def get_setting(name, channel="", server=""):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global o en la configuracion propia del canal 'channel'.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.pelisalacarta\settings_channels el
archivo channel_data.json y lee el valor del parametro 'name'. Si el archivo channel_data.json no existe busca en la
carpeta channels el archivo channel.xml y crea un archivo channel_data.json antes de retornar el valor solicitado.
Si el parametro 'name' no existe en channel_data.json lo busca en la configuracion global y si ahi tampoco existe
devuelve un str vacio.
Parametros:
name -- nombre del parametro
channel [opcional] -- nombre del canal
Retorna:
value -- El valor del parametro 'name'
"""
# Specific channel setting
if channel:
# xbmc.log("config.get_setting reading channel setting '"+name+"' from channel xml")
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
# xbmc.log.info("config.get_setting -> '"+repr(value)+"'")
return value
elif server:
# xbmc.log("config.get_setting reading server setting '"+name+"' from server xml")
from core import servertools
value = servertools.get_server_setting(name, server)
# xbmc.log("config.get_setting -> '"+repr(value)+"'")
return value
# Global setting
else:
#xbmc.log("config.get_setting reading main setting '"+name+"'")
import xbmcplugin
value = xbmcplugin.getSetting(name)
#xbmc.log("config.get_setting -> '"+value+"'")
# hack para devolver el tipo correspondiente
if value == "true":
return True
elif value == "false":
return False
else:
try:
value = int(value)
except ValueError:
pass
return value
def get_setting(name, channel="", server=""):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global o en la configuracion propia del canal 'channel'.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.pelisalacarta\settings_channels el
archivo channel_data.json y lee el valor del parametro 'name'. Si el archivo channel_data.json no existe busca en la
carpeta channels el archivo channel.xml y crea un archivo channel_data.json antes de retornar el valor solicitado.
Si el parametro 'name' no existe en channel_data.json lo busca en la configuracion global y si ahi tampoco existe
devuelve un str vacio.
Parametros:
name -- nombre del parametro
channel [opcional] -- nombre del canal
Retorna:
value -- El valor del parametro 'name'
"""
# Specific channel setting
if channel:
# logger.info("config.get_setting reading channel setting '"+name+"' from channel xml")
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
elif server:
# logger.info("config.get_setting reading server setting '"+name+"' from server xml")
from core import servertools
value = servertools.get_server_setting(name, server)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
# Global setting
else:
try:
if name in overrides:
dev = overrides[name]
#print "Overrides: ",name,"=",dev
#elif name=="debug":
# return "true"
else:
dev=configfile.get("General",name)
#print "Config file: ",name,"=",dev
#print "get_setting",name,dev
return dev
except:
#print "get_setting",name,"(vacío)"
return ""
def get_setting(name,channel=""):
if channel:
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
if not value is None:
return value
global settings_dic
if name in settings_dic:
return settings_dic[name]
else:
return ""
def get_setting(name, channel=""):
if channel:
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
if not value is None:
return value
global settings_dic
if name in settings_dic:
return settings_dic[name]
else:
return ""
def get_setting(name, channel=""):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global o en la configuracion propia del canal 'channel'.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.pelisalacarta\settings_channels el
archivo channel_data.json y lee el valor del parametro 'name'. Si el archivo channel_data.json no existe busca en la
carpeta channels el archivo channel.xml y crea un archivo channel_data.json antes de retornar el valor solicitado.
Si el parametro 'name' no existe en channel_data.json lo busca en la configuracion global y si ahi tampoco existe
devuelve un str vacio.
Parametros:
name -- nombre del parametro
channel [opcional] -- nombre del canal
Retorna:
value -- El valor del parametro 'name'
"""
# xbmc.log("config.get_setting name="+name+", channel="+channel+", OLD_PLATFORM="+str(OLD_PLATFORM))
# Specific channel setting
if channel:
# Old platforms read settings from settings-oldplatform.xml, all but the "include_in_global_search", "include_in_newest..."
if OLD_PLATFORM and ("user" in name or "password" in name):
# xbmc.log("config.get_setting reading channel setting from main xml '"+channel+"_"+name+"'")
value = __settings__.getSetting(channel + "_" + name)
# xbmc.log("config.get_setting -> '"+value+"'")
return value
# New platforms read settings from each channel
else:
# xbmc.log("config.get_setting reading channel setting '"+name+"' from channel xml")
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
# xbmc.log("config.get_setting -> '"+repr(value)+"'")
if value is not None:
return value
else:
return ""
# Global setting
else:
# xbmc.log("config.get_setting reading main setting '"+name+"'")
value = __settings__.getSetting(channel + name)
if value.startswith("special://"):
value = xbmc.translatePath(value)
# xbmc.log("config.get_setting -> '"+value+"'")
return value
def get_setting(name, channel=""):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global o en la configuracion propia del canal 'channel'.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.pelisalacarta\settings_channels el
archivo channel_data.json y lee el valor del parametro 'name'. Si el archivo channel_data.json no existe busca en la
carpeta channels el archivo channel.xml y crea un archivo channel_data.json antes de retornar el valor solicitado.
Si el parametro 'name' no existe en channel_data.json lo busca en la configuracion global y si ahi tampoco existe
devuelve un str vacio.
Parametros:
name -- nombre del parametro
channel [opcional] -- nombre del canal
Retorna:
value -- El valor del parametro 'name'
"""
# xbmc.log("config.get_setting name="+name+", channel="+channel+", OLD_PLATFORM="+str(OLD_PLATFORM))
# Specific channel setting
if channel:
# Old platforms read settings from settings-oldplatform.xml, all but the "include_in_global_search", "include_in_newest..."
if OLD_PLATFORM and ("user" in name or "password" in name):
# xbmc.log("config.get_setting reading channel setting from main xml '"+channel+"_"+name+"'")
value = __settings__.getSetting(channel+"_"+name)
# xbmc.log("config.get_setting -> '"+value+"'")
return value
# New platforms read settings from each channel
else:
# xbmc.log("config.get_setting reading channel setting '"+name+"' from channel xml")
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
# xbmc.log("config.get_setting -> '"+repr(value)+"'")
if value is not None:
return value
else:
return ""
# Global setting
else:
# xbmc.log("config.get_setting reading main setting '"+name+"'")
value = __settings__.getSetting(channel+name)
# xbmc.log("config.get_setting -> '"+value+"'")
return value
def get_setting(name, channel=""):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global o en la configuracion propia del canal 'channel'.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.pelisalacarta\settings_channels el
archivo channel_data.json y lee el valor del parametro 'name'. Si el archivo channel_data.json no existe busca en la
carpeta channels el archivo channel.xml y crea un archivo channel_data.json antes de retornar el valor solicitado.
Si el parametro 'name' no existe en channel_data.json lo busca en la configuracion global y si ahi tampoco existe
devuelve un str vacio.
Parametros:
name -- nombre del parametro
channel [opcional] -- nombre del canal
Retorna:
value -- El valor del parametro 'name'
"""
# Specific channel setting
if channel:
# logger.info("config.get_setting reading channel setting '"+name+"' from channel xml")
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
# logger.info("config.get_setting -> '"+repr(value)+"'")
if value is not None:
return value
else:
return ""
# Global setting
else:
# logger.info("config.get_setting reading main setting '"+name+"'")
global settings_dic
value = settings_dic.get(name, "")
if name == "adult_mode":
global adult_setting
id = threading.current_thread().name
if adult_setting.get(id) == True:
value = "2"
# logger.info("config.get_setting -> '"+value+"'")
return value
def search(item):
channel = importChannel(item)
from core import channeltools
if config.get_setting('last_search'):
last_search = channeltools.get_channel_setting('Last_searched', 'search', '')
else:
last_search = ''
search_text = platformtools.dialog_input(last_search)
if search_text is not None:
channeltools.set_channel_setting('Last_searched', search_text, 'search')
itemlist = new_search(item.clone(text=search_text), channel)
else:
return
platformtools.render_items(itemlist, item)
def get_setting(name, channel=""):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global o en la configuracion propia del canal 'channel'.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.pelisalacarta\settings_channels el
archivo channel_data.json y lee el valor del parametro 'name'. Si el archivo channel_data.json no existe busca en la
carpeta channels el archivo channel.xml y crea un archivo channel_data.json antes de retornar el valor solicitado.
Si el parametro 'name' no existe en channel_data.json lo busca en la configuracion global y si ahi tampoco existe
devuelve un str vacio.
Parametros:
name -- nombre del parametro
channel [opcional] -- nombre del canal
Retorna:
value -- El valor del parametro 'name'
"""
# Specific channel setting
if channel:
# logger.info("config.get_setting reading channel setting '"+name+"' from channel xml")
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
# logger.info("config.get_setting -> '"+repr(value)+"'")
if value is not None:
return value
else:
return ""
# Global setting
else:
# logger.info("config.get_setting reading main setting '"+name+"'")
value = __settings__.getSetting(channel + name)
# Translate Path if start with "special://"
if value.startswith("special://") and "librarypath" not in name:
value = xbmc.translatePath(value)
# logger.info("config.get_setting -> '"+value+"'")
return value
def get_setting(name, channel=""):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global o en la configuracion propia del canal 'channel'.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.pelisalacarta\settings_channels el
archivo channel_data.json y lee el valor del parametro 'name'. Si el archivo channel_data.json no existe busca en la
carpeta channels el archivo channel.xml y crea un archivo channel_data.json antes de retornar el valor solicitado.
Si el parametro 'name' no existe en channel_data.json lo busca en la configuracion global y si ahi tampoco existe
devuelve un str vacio.
Parametros:
name -- nombre del parametro
channel [opcional] -- nombre del canal
Retorna:
value -- El valor del parametro 'name'
"""
# Specific channel setting
if channel:
# logger.info("config.get_setting reading channel setting '"+name+"' from channel xml")
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
# logger.info("config.get_setting -> '"+repr(value)+"'")
if value is not None:
return value
else:
return ""
# Global setting
else:
# logger.info("config.get_setting reading main setting '"+name+"'")
value = xbmcplugin.getSetting(channel + name)
# Translate Path if start with "special://"
if value.startswith("special://") and "librarypath" not in name:
value = xbmc.translatePath(value)
# logger.info("config.get_setting -> '"+value+"'")
return value
def mainlist(item):
logger.info("pelisalacarta.channels.ayuda mainlist")
itemlist = []
cuantos = 0
if cuantos > 0:
itemlist.append(Item(channel=item.channel,
action="tutoriales", title="Ver guías y tutoriales en vídeo"))
else:
itemlist.extend(tutoriales(item))
itemlist.append(Item(channel=item.channel, action="", title="",
folder=False))
if config.is_xbmc():
#FIXME Al poner folder=False el log muestra: "WARNING: Attempt to use invalid handle -1"
itemlist.append(Item(channel=item.channel,
action="force_creation_advancedsettings",
title="Crear fichero advancedsettings.xml optimizado", folder=True))
cuantos += cuantos
if config.is_xbmc():
itemlist.append(Item(channel=item.channel,
action="recover_advancedsettings",
title="Restaurar advancedsettings.xml del backup", folder=False))
cuantos += cuantos
if not config.is_xbmc():
from core import channeltools
title = "Activar cuenta real-debrid (No activada)"
action = "realdebrid"
token_auth = channeltools.get_channel_setting("realdebrid_token", "realdebrid")
if config.get_setting("realdebridpremium") == "false":
title = "Activar cuenta real-debrid (Marca la casilla en la ventana de configuración de pelisalacarta para continuar)"
action = ""
elif token_auth:
title = "Activar cuenta real-debrid (Activada correctamente)"
itemlist.append(Item(channel=item.channel, action=action, title=title))
return itemlist
def lastSearch(self):
logger.debug()
if not self.item.text:
if self.item.contentTitle:
self.item.text = self.item.contentTitle
elif self.item.contentSerieName:
self.item.text = self.item.contentSerieName
if not self.item.text:
if config.get_setting('last_search'):
last_search = channeltools.get_channel_setting(
'Last_searched', 'search', '')
else:
last_search = ''
if not self.item.text:
self.item.text = platformtools.dialog_input(
default=last_search, heading='')
if self.item.text:
channeltools.set_channel_setting('Last_searched',
self.item.text, 'search')
from specials.search import save_search
save_search(self.item.text)
def get_setting(name, channel=""):
if channel:
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
if not value is None:
return value
# Devolvemos el valor del parametro global 'name'
if name=="cache.dir":
return ""
if name=="debug" or name=="download.enabled":
return "false"
if name=="cookies.dir":
return os.getcwd()
if name=="cache.mode" or name=="thumbnail_type":
return "2"
else:
try:
devuelve = bridge.get_setting(name)
except:
devuelve = ""
if type(devuelve) == BooleanType:
if devuelve:
devuelve = "true"
else:
devuelve = "false"
if name == "adult_mode":
devuelve = str(["Nunca","Siempre","Solo hasta que se reinicie Plex Media Server"].index(devuelve))
return devuelve
def run(item=None):
logger.info()
if not item:
# Extract item from sys.argv
if sys.argv[2]:
item = Item().fromurl(sys.argv[2])
# If no item, this is mainlist
else:
if config.get_setting("start_page"):
if not config.get_setting("custom_start"):
category = config.get_setting("category").lower()
item = Item(channel="news",
action="novedades",
extra=category,
mode='silent')
else:
from channels import side_menu
item = Item()
item = side_menu.check_user_home(item)
item.start = True
else:
item = Item(channel="channelselector",
action="getmainlist",
viewmode="movie")
if not config.get_setting('show_once'):
from platformcode import xbmc_videolibrary
xbmc_videolibrary.ask_set_content(1)
config.set_setting('show_once', True)
logger.info(item.tostring())
try:
if not config.get_setting('tmdb_active'):
config.set_setting('tmdb_active', True)
# If item has no action, stops here
if item.action == "":
logger.info("Item sin accion")
return
# Action for main menu in channelselector
elif item.action == "getmainlist":
import channelselector
itemlist = channelselector.getmainlist()
platformtools.render_items(itemlist, item)
# Action for channel types on channelselector: movies, series, etc.
elif item.action == "getchanneltypes":
import channelselector
itemlist = channelselector.getchanneltypes()
platformtools.render_items(itemlist, item)
# Action for channel listing on channelselector
elif item.action == "filterchannels":
import channelselector
itemlist = channelselector.filterchannels(item.channel_type)
platformtools.render_items(itemlist, item)
# Special action for playing a video from the library
elif item.action == "play_from_library":
play_from_library(item)
return
elif item.action == "keymap":
from platformcode import keymaptools
if item.open:
return keymaptools.open_shortcut_menu()
else:
return keymaptools.set_key()
elif item.action == "script":
from core import tmdb
if tmdb.drop_bd():
platformtools.dialog_notification(
config.get_localized_string(20000),
config.get_localized_string(60011),
time=2000,
sound=False)
# Action in certain channel specified in "action" and "channel" parameters
else:
# Entry point for a channel is the "mainlist" action, so here we check parental control
if item.action == "mainlist":
# Parental control
# If it is an adult channel, and user has configured pin, asks for it
if channeltools.is_adult(item.channel) and config.get_setting(
"adult_request_password"):
tecleado = platformtools.dialog_input(
"", config.get_localized_string(60334), True)
if tecleado is None or tecleado != config.get_setting(
"adult_password"):
return
# # Actualiza el canal individual
# if (item.action == "mainlist" and item.channel != "channelselector" and
# config.get_setting("check_for_channel_updates") == True):
# from core import updater
# updater.update_channel(item.channel)
# Checks if channel exists
channel_file = os.path.join(config.get_runtime_path(), 'channels',
item.channel + ".py")
logger.info("channel_file=%s" % channel_file)
channel = None
if os.path.exists(channel_file):
try:
channel = __import__('channels.%s' % item.channel, None,
None, ["channels.%s" % item.channel])
except ImportError:
exec("import channels." + item.channel + " as channel")
logger.info("Running channel %s | %s" %
(channel.__name__, channel.__file__))
# Special play action
if item.action == "play":
#define la info para trakt
try:
trakt_tools.set_trakt_info(item)
except:
pass
logger.info("item.action=%s" % item.action.upper())
# logger.debug("item_toPlay: " + "\n" + item.tostring('\n'))
# First checks if channel has a "play" function
if hasattr(channel, 'play'):
logger.info("Executing channel 'play' method")
itemlist = channel.play(item)
b_favourite = item.isFavourite
# Play should return a list of playable URLS
if len(itemlist) > 0 and isinstance(itemlist[0], Item):
item = itemlist[0]
if b_favourite:
item.isFavourite = True
platformtools.play_video(item)
# Permitir varias calidades desde play en el canal
elif len(itemlist) > 0 and isinstance(itemlist[0], list):
item.video_urls = itemlist
platformtools.play_video(item)
# If not, shows user an error message
else:
platformtools.dialog_ok(
config.get_localized_string(20000),
config.get_localized_string(60339))
# If player don't have a "play" function, not uses the standard play from platformtools
else:
logger.info("Executing core 'play' method")
platformtools.play_video(item)
# Special action for findvideos, where the plugin looks for known urls
elif item.action == "findvideos":
# First checks if channel has a "findvideos" function
if hasattr(channel, 'findvideos'):
itemlist = getattr(channel, item.action)(item)
itemlist = servertools.filter_servers(itemlist)
# If not, uses the generic findvideos function
else:
logger.info("No channel 'findvideos' method, "
"executing core method")
itemlist = servertools.find_video_items(item)
if config.get_setting("max_links", "videolibrary") != 0:
itemlist = limit_itemlist(itemlist)
from platformcode import subtitletools
subtitletools.saveSubtitleName(item)
platformtools.render_items(itemlist, item)
# Special action for adding a movie to the library
elif item.action == "add_pelicula_to_library":
videolibrarytools.add_movie(item)
# Special action for adding a serie to the library
elif item.action == "add_serie_to_library":
videolibrarytools.add_tvshow(item, channel)
# Special action for downloading all episodes from a serie
elif item.action == "download_all_episodes":
from channels import downloads
item.action = item.extra
del item.extra
downloads.save_download(item)
# Special action for searching, first asks for the words then call the "search" function
elif item.action == "search":
logger.info("item.action=%s" % item.action.upper())
# last_search = ""
# last_search_active = config.get_setting("last_search", "search")
# if last_search_active:
# try:
# current_saved_searches_list = list(config.get_setting("saved_searches_list", "search"))
# last_search = current_saved_searches_list[0]
# except:
# pass
last_search = channeltools.get_channel_setting(
'Last_searched', 'search', '')
tecleado = platformtools.dialog_input(last_search)
if tecleado is not None:
channeltools.set_channel_setting('Last_searched', tecleado,
'search')
itemlist = channel.search(item, tecleado)
else:
return
platformtools.render_items(itemlist, item)
# For all other actions
else:
logger.info("Executing channel '%s' method" % item.action)
itemlist = getattr(channel, item.action)(item)
if config.get_setting('trakt_sync'):
token_auth = config.get_setting("token_trakt", "trakt")
if not token_auth:
trakt_tools.auth_trakt()
else:
import xbmc
if not xbmc.getCondVisibility(
'System.HasAddon(script.trakt)'
) and config.get_setting('install_trakt'):
trakt_tools.ask_install_script()
itemlist = trakt_tools.trakt_check(itemlist)
else:
config.set_setting('install_trakt', True)
platformtools.render_items(itemlist, item)
except urllib2.URLError as e:
import traceback
logger.error(traceback.format_exc())
# Grab inner and third party errors
if hasattr(e, 'reason'):
logger.error("Razon del error, codigo: %s | Razon: %s" %
(str(e.reason[0]), str(e.reason[1])))
texto = config.get_localized_string(
30050) # "No se puede conectar con el sitio web"
platformtools.dialog_ok("alfa", texto)
# Grab server response errors
elif hasattr(e, 'code'):
logger.error("Codigo de error HTTP : %d" % e.code)
# "El sitio web no funciona correctamente (error http %d)"
platformtools.dialog_ok(
"alfa",
config.get_localized_string(30051) % e.code)
except WebErrorException as e:
import traceback
logger.error(traceback.format_exc())
patron = 'File "' + os.path.join(config.get_runtime_path(), "channels",
"").replace("\\",
"\\\\") + '([^.]+)\.py"'
canal = scrapertools.find_single_match(traceback.format_exc(), patron)
platformtools.dialog_ok(
config.get_localized_string(59985) + canal,
config.get_localized_string(60013) % (e))
except:
import traceback
logger.error(traceback.format_exc())
patron = 'File "' + os.path.join(config.get_runtime_path(), "channels",
"").replace("\\",
"\\\\") + '([^.]+)\.py"'
canal = scrapertools.find_single_match(traceback.format_exc(), patron)
try:
import xbmc
if config.get_platform(True)['num_version'] < 14:
log_name = "xbmc.log"
else:
log_name = "kodi.log"
log_message = config.get_localized_string(
50004) + xbmc.translatePath("special://logpath") + log_name
except:
log_message = ""
if canal:
platformtools.dialog_ok(
config.get_localized_string(60087) % canal,
config.get_localized_string(60014), log_message)
else:
platformtools.dialog_ok(config.get_localized_string(60038),
config.get_localized_string(60015),
log_message)
def mainlist(item):
logger.info()
itemlist = []
if config.is_xbmc():
itemlist.append(Item(channel=item.channel, action="", title="FAQ:",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False))
itemlist.append(Item(channel=item.channel, action="faq",
title=" - ¿Como reportar un error?",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False, extra="report_error"))
itemlist.append(Item(channel=item.channel, action="faq",
title=" - ¿Se pueden filtrar los enlaces?",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False, extra="filtrar_enlaces"))
itemlist.append(Item(channel=item.channel, action="faq",
title=" - ¿Se pueden activar/desactivar los canales?",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False, extra="onoff_canales"))
itemlist.append(Item(channel=item.channel, action="faq",
title=" - ¿Es posible la sincronización automática con Trakt?",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False, extra="trakt_sync"))
itemlist.append(Item(channel=item.channel, action="faq",
title=" - ¿Es posible mostrar todos los resultados juntos en el buscador global?",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False, extra="buscador_juntos"))
itemlist.append(Item(channel=item.channel, action="faq",
title=" - Los enlaces tardan en aparecer.",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False, extra="tiempo_enlaces"))
itemlist.append(Item(channel=item.channel, action="faq",
title=" - La búsqueda de contenido no se hace correctamente.",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False, extra="prob_busquedacont"))
itemlist.append(Item(channel=item.channel, action="faq",
title=" - Algún canal no funciona correctamente.",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False, extra="canal_fallo"))
itemlist.append(Item(channel=item.channel, action="faq",
title=" - Los enlaces Torrent no funcionan.",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False, extra="prob_torrent"))
itemlist.append(Item(channel=item.channel, action="faq",
title=" - No se actualiza correctamente la biblioteca.",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=True, extra="prob_bib"))
itemlist.append(Item(channel="ayuda", action="faq",
title=" - Aparece un error al pulsar sobre un episodio.",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=True, extra="prob_bib"))
itemlist.append(Item(channel="ayuda", action="faq",
title=" - Otros",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False, extra=""))
itemlist.append(Item(channel=item.channel, title="Videotutoriales:",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False, action=""))
itemlist.extend(tutoriales(item))
if config.is_xbmc():
itemlist.append(Item(channel=item.channel,
action="force_creation_advancedsettings",
title="Optimizar fichero advancedsettings.xml",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False))
itemlist.append(Item(channel=item.channel,
action="recover_advancedsettings",
title="Restaurar advancedsettings.xml del backup",
thumbnail=get_thumbnail_path("thumb_ayuda.png"),
folder=False))
if not config.is_xbmc():
from core import channeltools
title = "Activar cuenta real-debrid (No activada)"
action = "realdebrid"
token_auth = channeltools.get_channel_setting("realdebrid_token", "realdebrid")
if config.get_setting("realdebridpremium") == "false":
title = "Activar cuenta real-debrid (Marca la casilla en la ventana de configuración de pelisalacarta para continuar)"
action = ""
elif token_auth:
title = "Activar cuenta real-debrid (Activada correctamente)"
itemlist.append(Item(channel="ayuda", action=action, title=title))
return itemlist
def setting_channel_new(item):
import xbmcgui
# Cargar lista de opciones (canales activos del usuario y que permitan búsqueda global)
# ------------------------
lista = []
ids = []
lista_lang = []
lista_ctgs = []
channels_list = channelselector.filterchannels('all')
for channel in channels_list:
if channel.action == '':
continue
channel_parameters = channeltools.get_channel_parameters(
channel.channel)
# No incluir si en la configuracion del canal no existe "include_in_global_search"
if not channel_parameters['include_in_global_search']:
continue
lbl = '%s' % channel_parameters['language']
lbl += ' %s' % ', '.join(
config.get_localized_category(categ)
for categ in channel_parameters['categories'])
it = xbmcgui.ListItem(channel.title, lbl)
it.setArt({'thumb': channel.thumbnail, 'fanart': channel.fanart})
lista.append(it)
ids.append(channel.channel)
lista_lang.append(channel_parameters['language'])
lista_ctgs.append(channel_parameters['categories'])
# Diálogo para pre-seleccionar
# ----------------------------
preselecciones = [
'Buscar con la selección actual', 'Modificar selección actual',
'Modificar partiendo de Recomendados',
'Modificar partiendo de Frecuentes', 'Modificar partiendo de Todos',
'Modificar partiendo de Ninguno', 'Modificar partiendo de Castellano',
'Modificar partiendo de Latino'
]
presel_values = [
'skip', 'actual', 'recom', 'freq', 'all', 'none', 'cast', 'lat'
]
categs = [
'movie', 'tvshow', 'documentary', 'anime', 'vos', 'direct', 'torrent'
]
if config.get_setting('adult_mode') > 0:
categs.append('adult')
for c in categs:
preselecciones.append('Modificar partiendo de %s' %
config.get_localized_category(c))
presel_values.append(c)
if item.action == 'setting_channel': # Configuración de los canales incluídos en la búsqueda
del preselecciones[0]
del presel_values[0]
# else: # Llamada desde "buscar en otros canales" (se puede saltar la selección e ir directo a la búsqueda)
ret = platformtools.dialog_select(config.get_localized_string(59994),
preselecciones)
if ret == -1:
return False # pedido cancel
if presel_values[ret] == 'skip':
return True # continuar sin modificar
elif presel_values[ret] == 'none':
preselect = []
elif presel_values[ret] == 'all':
preselect = range(len(ids))
elif presel_values[ret] in ['cast', 'lat']:
preselect = []
for i, lg in enumerate(lista_lang):
if presel_values[ret] in lg or '*' in lg:
preselect.append(i)
elif presel_values[ret] == 'actual':
preselect = []
for i, canal in enumerate(ids):
channel_status = config.get_setting('include_in_global_search',
canal)
if channel_status:
preselect.append(i)
elif presel_values[ret] == 'recom':
preselect = []
for i, canal in enumerate(ids):
_not, set_canal_list = channeltools.get_channel_controls_settings(
canal)
if set_canal_list.get('include_in_global_search', False):
preselect.append(i)
elif presel_values[ret] == 'freq':
preselect = []
for i, canal in enumerate(ids):
frequency = channeltools.get_channel_setting('frequency', canal, 0)
if frequency > 0:
preselect.append(i)
else:
preselect = []
for i, ctgs in enumerate(lista_ctgs):
if presel_values[ret] in ctgs:
preselect.append(i)
# Diálogo para seleccionar
# ------------------------
ret = xbmcgui.Dialog().multiselect(config.get_localized_string(59994),
lista,
preselect=preselect,
useDetails=True)
if not ret:
return False # pedido cancel
seleccionados = [ids[i] for i in ret]
# Guardar cambios en canales para la búsqueda
# -------------------------------------------
for canal in ids:
channel_status = config.get_setting('include_in_global_search', canal)
# if not channel_status:
# channel_status = True
if channel_status and canal not in seleccionados:
config.set_setting('include_in_global_search', False, canal)
elif not channel_status and canal in seleccionados:
config.set_setting('include_in_global_search', True, canal)
return True
def set_context_commands(item, parent_item):
"""
Función para generar los menus contextuales.
1. Partiendo de los datos de item.context
a. Metodo antiguo item.context tipo str separando las opciones por "|" (ejemplo: item.context = "1|2|3")
(solo predefinidos)
b. Metodo list: item.context es un list con las diferentes opciones del menu:
- Predefinidos: Se cargara una opcion predefinida con un nombre.
item.context = ["1","2","3"]
- dict(): Se cargara el item actual modificando los campos que se incluyan en el dict() en caso de
modificar los campos channel y action estos serán guardados en from_channel y from_action.
item.context = [{"title":"Nombre del menu", "action": "action del menu", "channel",
"channel del menu"}, {...}]
2. Añadiendo opciones segun criterios
Se pueden añadir opciones al menu contextual a items que cumplan ciertas condiciones
3. Añadiendo opciones a todos los items
Se pueden añadir opciones al menu contextual para todos los items
@param item: elemento que contiene los menu contextuales
@type item: item
@param parent_item:
@type parent_item: item
"""
context_commands = []
version_xbmc = int(xbmc.getInfoLabel("System.BuildVersion").split(".", 1)[0])
# Creamos un list con las diferentes opciones incluidas en item.context
if type(item.context) == str:
context = item.context.split("|")
elif type(item.context) == list:
context = item.context
else:
context = []
# Opciones segun item.context
for command in context:
# Formato dict
if type(command) == dict:
# Los parametros del dict, se sobreescriben al nuevo context_item en caso de sobreescribir "action" y
# "channel", los datos originales se guardan en "from_action" y "from_channel"
if "action" in command:
command["from_action"] = item.action
if "channel" in command:
command["from_channel"] = item.channel
context_commands.append(
(command["title"], "XBMC.RunPlugin(%s?%s)" % (sys.argv[0], item.clone(**command).tourl())))
# Opciones segun criterios
if "info_partido" in item.context:
try:
name1, name2 = item.evento.split(" vs ")
if re.search(r'(?i)futbol|fútbol|soccer|football', item.deporte):
try:
from core import channeltools
modo = channeltools.get_channel_setting("modo", "futbol_window")
except:
modo = False
partidoCommand = "XBMC.RunPlugin(%s?%s)" % ( sys.argv[ 0 ] , item.clone(channel="futbol_window", action="ventana", maximiza=modo).tourl())
context_commands.append(("Abrir info del partido", partidoCommand))
except:
import traceback
logger.info(traceback.format_exc())
# Ir al Menu Principal (channel.mainlist)
if parent_item.channel not in ["novedades", "channelselector"] and item.action != "mainlist" \
and parent_item.action != "mainlist":
context_commands.append(("Ir al Menu Principal", "XBMC.Container.Refresh (%s?%s)" %
(sys.argv[0], Item(channel=item.channel, action="mainlist").tourl())))
# Abrir configuración
if parent_item.channel not in ["configuracion", "novedades", "buscador"]:
context_commands.append(("Abrir Configuración", "XBMC.Container.Update(%s?%s)" %
(sys.argv[0], Item(channel="configuracion", action="mainlist").tourl())))
return sorted(context_commands, key=lambda comand: comand[0])
def run(item=None):
# from core.support import dbg;dbg()
logger.debug()
if not item:
# Extract item from sys.argv
if sys.argv[2]:
sp = sys.argv[2].split('&')
url = sp[0]
item = Item().fromurl(url)
if len(sp) > 1:
for e in sp[1:]:
key, val = e.split('=')
item.__setattr__(key, val)
# If no item, this is mainlist
else:
item = Item(channel="channelselector",
action="getmainlist",
viewmode="movie")
if not config.get_setting('show_once'):
if not config.get_all_settings_addon():
logger.error('corrupted settings.xml!!')
settings_xml = os.path.join(config.get_data_path(),
"settings.xml")
settings_bak = os.path.join(config.get_data_path(),
"settings.bak")
if filetools.exists(settings_bak):
filetools.copy(settings_bak, settings_xml, True)
logger.info('restored settings.xml from backup')
else:
filetools.write(settings_xml,
'<settings version="2">\n</settings>'
) # resetted settings
else:
from platformcode import xbmc_videolibrary
xbmc_videolibrary.ask_set_content(silent=False)
config.set_setting('show_once', True)
logger.info(item.tostring())
try:
if not config.get_setting('tmdb_active'):
config.set_setting('tmdb_active', True)
# If item has no action, stops here
if item.action == "":
logger.debug("Item without action")
return
# Action for main menu in channelselector
elif item.action == "getmainlist":
import channelselector
itemlist = channelselector.getmainlist()
platformtools.render_items(itemlist, item)
# Action for channel types on channelselector: movies, series, etc.
elif item.action == "getchanneltypes":
import channelselector
itemlist = channelselector.getchanneltypes()
platformtools.render_items(itemlist, item)
# Action for channel listing on channelselector
elif item.action == "filterchannels":
import channelselector
itemlist = channelselector.filterchannels(item.channel_type)
platformtools.render_items(itemlist, item)
# Special action for playing a video from the library
elif item.action == "play_from_library":
play_from_library(item)
return
elif item.action == "keymap":
from platformcode import keymaptools
if item.open:
return keymaptools.open_shortcut_menu()
else:
return keymaptools.set_key()
elif item.channel == "infoplus":
from platformcode import infoplus
return infoplus.Main(item)
elif item.channel == "backup":
from platformcode import backup
return getattr(backup, item.action)(item)
elif item.channel == "elementum_download":
from platformcode import elementum_download
return getattr(elementum_download, item.action)(item)
elif item.channel == "shortcuts":
from platformcode import shortcuts
return getattr(shortcuts, item.action)(item)
elif item.channel == "autorenumber":
from platformcode import autorenumber
return getattr(autorenumber, item.action)(item)
elif item.action == "delete_key":
from platformcode import keymaptools
return keymaptools.delete_key()
elif item.action == "script":
from core import tmdb
if tmdb.drop_bd():
platformtools.dialog_notification(
config.get_localized_string(20000),
config.get_localized_string(60011),
time=2000,
sound=False)
elif item.action == "itemInfo":
platformtools.dialog_textviewer('Item info', item.parent)
elif item.action == "open_browser":
import webbrowser
if not webbrowser.open(item.url):
import xbmc
if xbmc.getCondVisibility(
'system.platform.linux') and xbmc.getCondVisibility(
'system.platform.android'): # android
xbmc.executebuiltin(
'StartAndroidActivity("", "android.intent.action.VIEW", "", "%s")'
% (item.url))
else:
try:
import urllib.request as urllib
except ImportError:
import urllib
short = urllib.urlopen(
'https://u.nu/api.php?action=shorturl&format=simple&url='
+ item.url).read().decode('utf-8')
platformtools.dialog_ok(
config.get_localized_string(20000),
config.get_localized_string(70740) % short)
# Action in certain channel specified in "action" and "channel" parameters
elif item.action == "check_channels":
from platformcode import checkhost
checkhost.check_channels()
else:
# Checks if channel exists
if os.path.isfile(
os.path.join(config.get_runtime_path(), 'channels',
item.channel + ".py")):
CHANNELS = 'channels'
else:
CHANNELS = 'specials'
channel_file = os.path.join(config.get_runtime_path(), CHANNELS,
item.channel + ".py")
logger.debug("channel_file= " + channel_file + ' - ' + CHANNELS +
' - ' + item.channel)
channel = None
if os.path.exists(channel_file):
try:
channel = __import__('%s.%s' % (CHANNELS, item.channel),
None, None,
['%s.%s' % (CHANNELS, item.channel)])
except ImportError:
exec("import " + CHANNELS + "." + item.channel +
" as channel")
logger.info("Running channel %s | %s" %
(channel.__name__, channel.__file__))
# Special play action
if item.action == "play":
# define la info para trakt
try:
from core import trakt_tools
trakt_tools.set_trakt_info(item)
except:
pass
logger.debug("item.action=%s" % item.action.upper())
# logger.debug("item_toPlay: " + "\n" + item.tostring('\n'))
# First checks if channel has a "play" function
if hasattr(channel, 'play'):
logger.debug("Executing channel 'play' method")
itemlist = channel.play(item)
b_favourite = item.isFavourite
# Play should return a list of playable URLS
if len(itemlist) > 0 and isinstance(itemlist[0], Item):
item = itemlist[0]
if b_favourite:
item.isFavourite = True
platformtools.play_video(item)
# Permitir varias calidades desde play en el Channel
elif len(itemlist) > 0 and isinstance(itemlist[0], list):
item.video_urls = itemlist
platformtools.play_video(item)
# If not, shows user an error message
else:
platformtools.dialog_ok(
config.get_localized_string(20000),
config.get_localized_string(60339))
# If player don't have a "play" function, not uses the standard play from platformtools
else:
logger.debug("Executing core 'play' method")
platformtools.play_video(item)
# Special action for findvideos, where the plugin looks for known urls
elif item.action == "findvideos":
from core import servertools
# First checks if channel has a "findvideos" function
if hasattr(channel, 'findvideos'):
itemlist = getattr(channel, item.action)(item)
# If not, uses the generic findvideos function
else:
logger.debug("No channel 'findvideos' method, "
"executing core method")
itemlist = servertools.find_video_items(item)
if config.get_setting("max_links", "videolibrary") != 0:
itemlist = limit_itemlist(itemlist)
from platformcode import subtitletools
subtitletools.saveSubtitleName(item)
platformtools.render_items(itemlist, item)
# Special action for adding a movie to the library
elif item.action == "add_pelicula_to_library":
from core import videolibrarytools
videolibrarytools.add_movie(item)
# Special action for adding a serie to the library
elif item.action == "add_serie_to_library":
from core import videolibrarytools
videolibrarytools.add_tvshow(item, channel)
# Special action for downloading all episodes from a serie
elif item.action == "download_all_episodes":
from specials import downloads
item.action = item.extra
del item.extra
downloads.save_download(item)
# Special action for searching, first asks for the words then call the "search" function
elif item.action == "search":
# from core.support import dbg;dbg()
if filetools.isfile(temp_search_file) and config.get_setting(
'videolibrary_kodi'):
itemlist = []
f = filetools.read(temp_search_file)
strList = f.split(',')
if strList[0] == '[V]' and strList[1] == item.channel:
for it in strList:
if it and it not in ['[V]', item.channel]:
itemlist.append(Item().fromurl(it))
filetools.write(temp_search_file, f[4:])
return platformtools.render_items(itemlist, item)
else:
filetools.remove(temp_search_file)
logger.debug("item.action=%s" % item.action.upper())
from core import channeltools
if config.get_setting('last_search'):
last_search = channeltools.get_channel_setting(
'Last_searched', 'search', '')
else:
last_search = ''
search_text = platformtools.dialog_input(last_search)
if search_text is not None:
channeltools.set_channel_setting('Last_searched',
search_text, 'search')
itemlist = new_search(item.clone(text=search_text),
channel)
else:
return
platformtools.render_items(itemlist, item)
# For all other actions
else:
# import web_pdb; web_pdb.set_trace()
logger.debug("Executing channel '%s' method" % item.action)
itemlist = getattr(channel, item.action)(item)
if config.get_setting('trakt_sync'):
from core import trakt_tools
token_auth = config.get_setting("token_trakt", "trakt")
if not token_auth:
trakt_tools.auth_trakt()
else:
import xbmc
if not xbmc.getCondVisibility(
'System.HasAddon(script.trakt)'
) and config.get_setting('install_trakt'):
trakt_tools.ask_install_script()
itemlist = trakt_tools.trakt_check(itemlist)
else:
config.set_setting('install_trakt', True)
platformtools.render_items(itemlist, item)
except WebErrorException as e:
import traceback
from core import scrapertools
logger.error(traceback.format_exc())
platformtools.dialog_ok(
config.get_localized_string(59985) % e.channel,
config.get_localized_string(60013) % e.url)
except Exception as e:
import traceback
from core import scrapertools
logger.error(traceback.format_exc())
patron = 'File "' + os.path.join(config.get_runtime_path(), "channels",
"").replace("\\",
"\\\\") + r'([^.]+)\.py"'
Channel = scrapertools.find_single_match(traceback.format_exc(),
patron)
if Channel or e.__class__ == logger.ChannelScraperException:
if item.url:
if platformtools.dialog_yesno(
config.get_localized_string(60087) % Channel,
config.get_localized_string(60014),
nolabel='ok',
yeslabel=config.get_localized_string(70739)):
run(Item(action="open_browser", url=item.url))
else:
platformtools.dialog_ok(
config.get_localized_string(60087) % Channel,
config.get_localized_string(60014))
else:
if platformtools.dialog_yesno(config.get_localized_string(60038),
config.get_localized_string(60015)):
run(Item(channel="setting", action="report_menu"))
def get_setting(name, channel="", server="", default=None):
"""
Returns the configuration value of the requested parameter.
Returns the value of the parameter 'name' in the global configuration, in the own configuration of the channel 'channel' or in that of the server 'server'.
The channel and server parameters should not be used simultaneously. If the channel name is specified it will be returned
the result of calling channeltools.get_channel_setting (name, channel, default). If the name of the
server will return the result of calling servertools.get_channel_setting (name, server, default). If I dont know
Specify none of the above will return the value of the parameter in the global configuration if it exists or
the default value otherwise.
@param name: parameter name
@type name: str
@param channel: channel name
@type channel: str
@param server: server name
@type server: str
@param default: return value in case the name parameter does not exist
@type default: any
@return: The value of the parameter 'name'
@rtype: any
"""
# Specific channel setting
if channel:
# logger.info("get_setting reading channel setting '"+name+"' from channel json")
from core import channeltools
value = channeltools.get_channel_setting(name, channel, default)
# logger.info("get_setting -> '"+repr(value)+"'")
return value
# Specific server setting
elif server:
# logger.info("get_setting reading server setting '"+name+"' from server json")
from core import servertools
value = servertools.get_server_setting(name, server, default)
# logger.info("get_setting -> '"+repr(value)+"'")
return value
# Global setting
else:
# logger.info("get_setting reading main setting '"+name+"'")
value = __settings__.getSetting(name)
if not value:
return default
# Translate Path if start with "special://"
if value.startswith("special://") and "videolibrarypath" not in name:
value = xbmc.translatePath(value)
# hack para devolver el tipo correspondiente
if value == "true":
return True
elif value == "false":
return False
else:
# special case return as str
try:
value = int(value)
except ValueError:
pass
return value
def start(itemlist, item):
'''
Metodo principal desde donde se reproduce automaticamente los enlaces
- En caso la opcion de personalizar activa utilizara las opciones definidas por el usuario.
- En caso contrario intentara reproducir cualquier enlace que cuente con el idioma preferido.
:param itemlist: list (lista de items listos para reproducir, o sea con action='play')
:param item: item (el item principal del canal)
:return: intenta autoreproducir, en caso de fallar devuelve el itemlist que recibio en un principio
'''
logger.info()
global PLAYED
global autoplay_node
PLAYED = False
base_item = item
if not config.is_xbmc():
#platformtools.dialog_notification('AutoPlay ERROR', 'Sólo disponible para XBMC/Kodi')
return itemlist
if not autoplay_node:
# Obtiene el nodo AUTOPLAY desde el json
autoplay_node = jsontools.get_node_from_file('autoplay', 'AUTOPLAY')
channel_id = item.channel
if item.channel == 'videolibrary':
autoplay_node = jsontools.get_node_from_file('autoplay', 'AUTOPLAY')
channel_id = item.contentChannel
try:
active = autoplay_node['status']
except:
active = is_active(item.channel)
if not channel_id in autoplay_node or not active:
return itemlist
# Agrega servidores y calidades que no estaban listados a autoplay_node
new_options = check_value(channel_id, itemlist)
# Obtiene el nodo del canal desde autoplay_node
channel_node = autoplay_node.get(channel_id, {})
# Obtiene los ajustes des autoplay para este canal
settings_node = channel_node.get('settings', {})
if get_setting('autoplay') or settings_node['active']:
url_list_valid = []
autoplay_list = []
autoplay_b = []
favorite_servers = []
favorite_quality = []
# Guarda el valor actual de "Accion y Player Mode" en preferencias
user_config_setting_action = config.get_setting("default_action")
user_config_setting_player = config.get_setting("player_mode")
# Habilita la accion "Ver en calidad alta" (si el servidor devuelve más de una calidad p.e. gdrive)
if user_config_setting_action != 2:
config.set_setting("default_action", 2)
if user_config_setting_player != 0:
config.set_setting("player_mode", 0)
# Informa que AutoPlay esta activo
#platformtools.dialog_notification('AutoPlay Activo', '', sound=False)
# Prioridades a la hora de ordenar itemlist:
# 0: Servidores y calidades
# 1: Calidades y servidores
# 2: Solo servidores
# 3: Solo calidades
# 4: No ordenar
if (settings_node['custom_servers'] and settings_node['custom_quality']):
priority = settings_node['priority'] # 0: Servidores y calidades o 1: Calidades y servidores
elif settings_node['custom_servers']:
priority = 2 # Solo servidores
elif settings_node['custom_quality']:
priority = 3 # Solo calidades
else:
priority = 4 # No ordenar
# Obtiene las listas servidores, calidades disponibles desde el nodo del json de AutoPlay
server_list = channel_node.get('servers', [])
for server in server_list:
server = server.lower()
quality_list = channel_node.get('quality', [])
# Si no se definen calidades la se asigna default como calidad unica
if len(quality_list) == 0:
quality_list =['default']
# Se guardan los textos de cada servidor y calidad en listas p.e. favorite_servers = ['openload',
# 'streamcloud']
for num in range(1, 4):
favorite_servers.append(channel_node['servers'][settings_node['server_%s' % num]].lower())
favorite_quality.append(channel_node['quality'][settings_node['quality_%s' % num]])
# Se filtran los enlaces de itemlist y que se correspondan con los valores de autoplay
for item in itemlist:
autoplay_elem = dict()
b_dict = dict()
# Comprobamos q se trata de un item de video
if 'server' not in item:
continue
# Agrega la opcion configurar AutoPlay al menu contextual
if 'context' not in item:
item.context = list()
if not filter(lambda x: x['action'] == 'autoplay_config', context):
item.context.append({"title": config.get_localized_string(60071),
"action": "autoplay_config",
"channel": "autoplay",
"from_channel": channel_id})
# Si no tiene calidad definida le asigna calidad 'default'
if item.quality == '':
item.quality = 'default'
# Se crea la lista para configuracion personalizada
if priority < 2: # 0: Servidores y calidades o 1: Calidades y servidores
# si el servidor y la calidad no se encuentran en las listas de favoritos o la url esta repetida,
# descartamos el item
if item.server.lower() not in favorite_servers or item.quality not in favorite_quality \
or item.url in url_list_valid:
item.type_b = True
b_dict['videoitem']= item
autoplay_b.append(b_dict)
continue
autoplay_elem["indice_server"] = favorite_servers.index(item.server.lower())
autoplay_elem["indice_quality"] = favorite_quality.index(item.quality)
elif priority == 2: # Solo servidores
# si el servidor no se encuentra en la lista de favoritos o la url esta repetida,
# descartamos el item
if item.server.lower() not in favorite_servers or item.url in url_list_valid:
item.type_b = True
b_dict['videoitem'] = item
autoplay_b.append(b_dict)
continue
autoplay_elem["indice_server"] = favorite_servers.index(item.server.lower())
elif priority == 3: # Solo calidades
# si la calidad no se encuentra en la lista de favoritos o la url esta repetida,
# descartamos el item
if item.quality not in favorite_quality or item.url in url_list_valid:
item.type_b = True
b_dict['videoitem'] = item
autoplay_b.append(b_dict)
continue
autoplay_elem["indice_quality"] = favorite_quality.index(item.quality)
else: # No ordenar
# si la url esta repetida, descartamos el item
if item.url in url_list_valid:
continue
# Si el item llega hasta aqui lo añadimos al listado de urls validas y a autoplay_list
url_list_valid.append(item.url)
item.plan_b=True
autoplay_elem['videoitem'] = item
# autoplay_elem['server'] = item.server
# autoplay_elem['quality'] = item.quality
autoplay_list.append(autoplay_elem)
# Ordenamos segun la prioridad
if priority == 0: # Servidores y calidades
autoplay_list.sort(key=lambda orden: (orden['indice_server'], orden['indice_quality']))
elif priority == 1: # Calidades y servidores
autoplay_list.sort(key=lambda orden: (orden['indice_quality'], orden['indice_server']))
elif priority == 2: # Solo servidores
autoplay_list.sort(key=lambda orden: orden['indice_server'])
elif priority == 3: # Solo calidades
autoplay_list.sort(key=lambda orden: orden['indice_quality'])
# Se prepara el plan b, en caso de estar activo se agregan los elementos no favoritos al final
try:
plan_b = settings_node['plan_b']
except:
plan_b = True
text_b = ''
if plan_b:
autoplay_list.extend(autoplay_b)
# Si hay elementos en la lista de autoplay se intenta reproducir cada elemento, hasta encontrar uno
# funcional o fallen todos
if autoplay_list or (plan_b and autoplay_b):
#played = False
max_intentos = 5
max_intentos_servers = {}
# Si se esta reproduciendo algo detiene la reproduccion
if platformtools.is_playing():
platformtools.stop_video()
for autoplay_elem in autoplay_list:
play_item = Item
# Si no es un elemento favorito si agrega el texto plan b
if autoplay_elem['videoitem'].type_b:
text_b = '(Plan B)'
if not platformtools.is_playing() and not PLAYED:
videoitem = autoplay_elem['videoitem']
if videoitem.server.lower() not in max_intentos_servers:
max_intentos_servers[videoitem.server.lower()] = max_intentos
# Si se han alcanzado el numero maximo de intentos de este servidor saltamos al siguiente
if max_intentos_servers[videoitem.server.lower()] == 0:
continue
lang = " "
if hasattr(videoitem, 'language') and videoitem.language != "":
lang = " '%s' " % videoitem.language
platformtools.dialog_notification("AutoPlay %s" %text_b, "%s%s%s" % (
videoitem.server.upper(), lang, videoitem.quality.upper()), sound=False)
# TODO videoitem.server es el id del server, pero podria no ser el nombre!!!
# Intenta reproducir los enlaces
# Si el canal tiene metodo play propio lo utiliza
channel = __import__('channels.%s' % channel_id, None, None, ["channels.%s" % channel_id])
if hasattr(channel, 'play'):
resolved_item = getattr(channel, 'play')(videoitem)
if len(resolved_item) > 0:
if isinstance(resolved_item[0], list):
videoitem.video_urls = resolved_item
else:
videoitem = resolved_item[0]
# Si no directamente reproduce y marca como visto
# Verifica si el item viene de la videoteca
try:
if base_item.contentChannel =='videolibrary':
# Marca como visto
from platformcode import xbmc_videolibrary
xbmc_videolibrary.mark_auto_as_watched(base_item)
# Rellena el video con los datos del item principal y reproduce
play_item = base_item.clone(url=videoitem)
platformtools.play_video(play_item.url, autoplay=True)
else:
# Si no viene de la videoteca solo reproduce
platformtools.play_video(videoitem, autoplay=True)
except:
pass
sleep(3)
try:
if platformtools.is_playing():
PLAYED = True
old_frequency = channeltools.get_channel_setting("frequency", channel_id, 0)
channeltools.set_channel_setting('frequency', old_frequency + 1, channel_id)
logger.debug('autoplay sumar frecuencia')
break
except:
logger.debug(str(len(autoplay_list)))
# Si hemos llegado hasta aqui es por q no se ha podido reproducir
max_intentos_servers[videoitem.server.lower()] -= 1
# Si se han alcanzado el numero maximo de intentos de este servidor
# preguntar si queremos seguir probando o lo ignoramos
if max_intentos_servers[videoitem.server.lower()] == 0:
text = config.get_localized_string(60072) % videoitem.server.upper()
if not platformtools.dialog_yesno("AutoPlay", text,
config.get_localized_string(60073)):
max_intentos_servers[videoitem.server.lower()] = max_intentos
# Si no quedan elementos en la lista se informa
if autoplay_elem == autoplay_list[-1]:
platformtools.dialog_notification('AutoPlay', config.get_localized_string(60072) % videoitem.server.upper())
else:
platformtools.dialog_notification(config.get_localized_string(60074), config.get_localized_string(60075))
if new_options:
platformtools.dialog_notification("AutoPlay", config.get_localized_string(60076), sound=False)
# Restaura si es necesario el valor previo de "Accion y Player Mode" en preferencias
if user_config_setting_action != 2:
config.set_setting("default_action", user_config_setting_action)
if user_config_setting_player != 0:
config.set_setting("player_mode", user_config_setting_player)
return itemlist
def new_search(item):
logger.debug()
temp_search_file = config.get_temp_file('temp-search')
if filetools.isfile(temp_search_file):
filetools.remove(temp_search_file)
itemlist = []
if config.get_setting('last_search'):
last_search = channeltools.get_channel_setting('Last_searched',
'search', '')
else:
last_search = ''
if item.search_text:
searched_text = item.search_text
else:
searched_text = platformtools.dialog_input(default=last_search,
heading='')
save_search(searched_text)
if not searched_text:
return
channeltools.set_channel_setting('Last_searched', searched_text, 'search')
searched_text = searched_text.replace("+", " ")
if item.mode == 'person':
item.searched_text = searched_text
return actor_list(item)
if item.mode != 'all':
tmdb_info = tmdb.Tmdb(searched_text=searched_text,
search_type=item.mode.replace('show', ''))
results = tmdb_info.results
for result in results:
result = tmdb_info.get_infoLabels(result, origen=result)
if item.mode == 'movie':
title = result['title']
else:
title = result['name']
item.mode = 'tvshow'
thumbnail = result.get('thumbnail', '')
fanart = result.get('fanart', '')
new_item = Item(channel=item.channel,
action='channel_search',
title=title,
text=searched_text,
thumbnail=thumbnail,
fanart=fanart,
mode=item.mode,
contentType=item.mode,
infoLabels=result)
if item.mode == 'movie':
new_item.contentTitle = result['title']
else:
new_item.contentSerieName = result['name']
itemlist.append(new_item)
if item.mode == 'all' or not itemlist:
return channel_search(
Item(channel=item.channel,
title=searched_text,
text=searched_text,
mode='all',
infoLabels={}))
return itemlist
def get_setting(name, channel="", server=""):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global o en la configuracion propia del canal 'channel'.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.pelisalacarta\settings_channels el
archivo channel_data.json y lee el valor del parametro 'name'. Si el archivo channel_data.json no existe busca en la
carpeta channels el archivo channel.xml y crea un archivo channel_data.json antes de retornar el valor solicitado.
Si el parametro 'name' no existe en channel_data.json lo busca en la configuracion global y si ahi tampoco existe
devuelve un str vacio.
Parametros:
name -- nombre del parametro
channel [opcional] -- nombre del canal
Retorna:
value -- El valor del parametro 'name'
"""
# Specific channel setting
if channel:
# logger.info("config.get_setting reading channel setting '"+name+"' from channel xml")
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
elif server:
# logger.info("config.get_setting reading server setting '"+name+"' from server xml")
from core import servertools
value = servertools.get_server_setting(name, server)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
# Global setting
else:
# logger.info("config.get_setting reading main setting '"+name+"'")
global settings_dic
value = settings_dic.get(name, "")
if name == "adult_mode":
global adult_setting
id = threading.current_thread().name
if adult_setting.get(id) == True:
value = "2"
# hack para devolver el tipo correspondiente
global settings_types
if settings_types.get(name) in ['enum', 'number']:
value = int(value)
elif settings_types.get(name) == 'bool':
value = value == 'true'
elif not settings_types.has_key(name):
try:
t = eval (value)
value = t[0](t[1])
except:
value = None
return value
def filterchannels(category, view="thumb_"):
logger.info()
channelslist = []
frequent_list = []
freq = False
if category == 'freq':
freq = True
category = 'all'
# Si category = "allchannelstatus" es que estamos activando/desactivando canales
# Si category = "all-channels" viene del canal test
appenddisabledchannels = False
if category == "allchannelstatus":
category = "all"
appenddisabledchannels = True
# Lee la lista de canales
channel_path = os.path.join(config.get_runtime_path(), "channels",
'*.json')
logger.info("channel_path=%s" % channel_path)
channel_files = glob.glob(channel_path)
logger.info("channel_files encontrados %s" % (len(channel_files)))
channel_language = config.get_setting("channel_language", default="all")
logger.info("channel_language=%s" % channel_language)
for channel_path in channel_files:
logger.info("channel=%s" % channel_path)
channel = os.path.basename(channel_path).replace(".json", "")
try:
channel_parameters = channeltools.get_channel_parameters(channel)
if channel_parameters["channel"] == 'community':
continue
# Si no es un canal lo saltamos
if not channel_parameters["channel"]:
continue
logger.info("channel_parameters=%s" % repr(channel_parameters))
# Si prefiere el banner y el canal lo tiene, cambia ahora de idea
if view == "banner_" and "banner" in channel_parameters:
channel_parameters["thumbnail"] = channel_parameters["banner"]
# si el canal está desactivado no se muestra el canal en la lista
if not channel_parameters["active"]:
continue
# Se salta el canal si no está activo y no estamos activando/desactivando los canales
channel_status = config.get_setting("enabled",
channel_parameters["channel"])
if channel_status is None:
# si channel_status no existe es que NO HAY valor en _data.json.
# como hemos llegado hasta aquí (el canal está activo en channel.json), se devuelve True
channel_status = True
if not channel_status:
# si obtenemos el listado de canales desde "activar/desactivar canales", y el canal está desactivado
# lo mostramos, si estamos listando todos los canales desde el listado general y está desactivado,
# no se muestra
if not appenddisabledchannels:
continue
# Se salta el canal para adultos si el modo adultos está desactivado
if channel_parameters["adult"] and config.get_setting(
"adult_mode") == 0:
if category != "all_channels":
continue
# Se salta el canal si está en un idioma filtrado
# Se muestran todos los canales si se elige "all" en el filtrado de idioma
# Se muestran sólo los idiomas filtrados, cast o lat
# Los canales de adultos se mostrarán siempre que estén activos
if channel_language != "all" and channel_language not in channel_parameters["language"] \
and "*" not in channel_parameters["language"]:
if category != "all_channels":
continue
# Se salta el canal si está en una categoria filtrado
if category != "all" and category not in channel_parameters[
"categories"]:
if category != "all_channels":
continue
# Si tiene configuración añadimos un item en el contexto
context = []
if channel_parameters["has_settings"]:
context.append({
"title": config.get_localized_string(70525),
"channel": "setting",
"action": "channel_config",
"config": channel_parameters["channel"]
})
if os.path.exists(
os.path.join(config.get_runtime_path(), 'channels',
'test.py')):
context.append({
"title": config.get_localized_string(70215),
"channel": "test",
"action": "test_channel",
"contentChannel": channel_parameters["channel"],
"parameters": "test_channel"
})
if channel_parameters["req_assistant"]:
channel_parameters[
"title"] = "{} [COLOR=yellow](requiere Assistant)[/COLOR]".format(
channel_parameters["title"])
channel_info = set_channel_info(channel_parameters)
# Si ha llegado hasta aquí, lo añade
frequency = channeltools.get_channel_setting(
"frequency", channel_parameters["channel"], 0)
channelslist.append(
Item(title=channel_parameters["title"],
channel=channel_parameters["channel"],
action="mainlist",
thumbnail=channel_parameters["thumbnail"],
fanart=channel_parameters["fanart"],
plot=channel_info,
category=channel_parameters["title"],
language=channel_parameters["language"],
viewmode="list",
context=context,
frequency=frequency))
except:
logger.error(
"Se ha producido un error al leer los datos del canal '%s'" %
channel)
import traceback
logger.error(traceback.format_exc())
if config.get_setting('frequents'):
for ch in channelslist:
if int(ch.frequency) != 0:
frequent_list.append(ch)
frequent_list = sorted(frequent_list,
key=lambda item: item.frequency,
reverse=True)
if freq:
max_ff = config.get_setting("max_frequents_folder")
if max_ff > 0:
return frequent_list[0:max_ff]
else:
return frequent_list
max_freq = config.get_setting("max_frequents")
if frequent_list and category != 'all_channels':
if len(frequent_list) >= max_freq:
max_freq = max_freq
else:
max_freq = len(frequent_list)
frequent_list = frequent_list[0:max_freq]
frequent_list.insert(
0, Item(title='- Canales frecuentes -', action=''))
frequent_list.append(Item(title='- Todos los canales -',
action=''))
elif freq:
for ch in channelslist:
if int(ch.frequency) != 0:
frequent_list.append(ch)
frequent_list = sorted(frequent_list,
key=lambda item: item.frequency,
reverse=True)
max_ff = config.get_setting("max_frequents_folder")
if max_ff > 0:
return frequent_list[0:max_ff]
else:
return frequent_list
channelslist.sort(key=lambda item: item.title.lower().strip())
if category == "all":
channel_parameters = channeltools.get_channel_parameters('url')
# Si prefiere el banner y el canal lo tiene, cambia ahora de idea
if view == "banner_" and "banner" in channel_parameters:
channel_parameters["thumbnail"] = channel_parameters["banner"]
channelslist.insert(
0,
Item(title=config.get_localized_string(60088),
action="mainlist",
channel="url",
thumbnail=channel_parameters["thumbnail"],
type="generic",
viewmode="list"))
if frequent_list and config.get_setting('frequents'):
channelslist = frequent_list + channelslist
if category in ['movie', 'tvshow']:
titles = [
config.get_localized_string(70028),
config.get_localized_string(30985),
config.get_localized_string(70559),
config.get_localized_string(60264),
config.get_localized_string(70560)
]
ids = ['popular', 'top_rated', 'now_playing', 'on_the_air']
for x in range(0, 3):
if x == 2 and category != 'movie':
title = titles[x + 1]
id = ids[x + 1]
else:
title = titles[x]
id = ids[x]
channelslist.insert(
x,
Item(channel='search',
action='discover_list',
title=title,
search_type='list',
list_type='%s/%s' % (category.replace('show', ''), id),
thumbnail=get_thumb(id + ".png"),
mode=category))
channelslist.insert(
3,
Item(channel='search',
action='years_menu',
title='Por Años',
type=category.replace('show', ''),
thumbnail=get_thumb("years.png"),
mode=category))
channelslist.insert(
4,
Item(channel='search',
action='genres_menu',
title='Generos',
type=category.replace('show', ''),
thumbnail=get_thumb("genres.png"),
mode=category))
### Especiales (Halloween, otros)
from datetime import date
today = date.today()
if today.month == 10 and category == "movie":
this_year = today.year
from_date = "%s-01-01" % this_year
discovery = {
"url": "discover/movie",
"with_genres": "27",
"primary_release_date.lte": "%s" % today,
"primary_release_date.gte": from_date,
"page": "1"
}
channelslist.insert(
0,
Item(channel="search",
title="Halloween %s" % this_year,
page=1,
action='discover_list',
discovery=discovery,
mode="movie",
thumbnail=get_thumb("channels_horror.png")))
return channelslist
def get_setting(name, channel="", server=""):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global o en la configuracion propia del canal 'channel'.
Si se especifica el nombre del canal busca en la ruta \addon_data\plugin.video.streamondemand\settings_channels el archivo channel_data.json
y lee el valor del parametro 'name'. Si el archivo channel_data.json no existe busca en la carpeta channels el archivo
channel.xml y crea un archivo channel_data.json antes de retornar el valor solicitado.
Si el parametro 'name' no existe en channel_data.json lo busca en la configuracion global y si ahi tampoco existe devuelve un str vacio.
Parametros:
name -- nombre del parametro
channel [opcional] -- nombre del canal
Retorna:
value -- El valor del parametro 'name'
"""
# Specific channel setting
if channel:
# logger.info("config.get_setting reading channel setting '"+name+"' from channel xml")
from core import channeltools
value = channeltools.get_channel_setting(name, channel)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
elif server:
# logger.info("config.get_setting reading server setting '"+name+"' from server xml")
from core import servertools
value = servertools.get_server_setting(name, server)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
# Global setting
else:
# logger.info("config.get_setting reading main setting '"+name+"'")
value = __settings__.getSetting(name)
# Translate Path if start with "special://"
if value.startswith("special://") and "librarypath" not in name:
value = xbmc.translatePath(value)
# hack para devolver el tipo correspondiente
settings_types = get_settings_types()
if settings_types.get(name) in ['enum', 'number']:
value = int(value)
elif settings_types.get(name) == 'bool':
value = value == 'true'
elif not settings_types.has_key(name):
try:
t = eval(value)
value = t[0](t[1])
except:
value = None
return value
def get_setting(name, channel="", server="", default=None):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global, en la configuracion propia del canal 'channel'
o en la del servidor 'server'.
Los parametros channel y server no deben usarse simultaneamente. Si se especifica el nombre del canal se devolvera
el resultado de llamar a channeltools.get_channel_setting(name, channel, default). Si se especifica el nombre del
servidor se devolvera el resultado de llamar a servertools.get_channel_setting(name, server, default). Si no se
especifica ninguno de los anteriores se devolvera el valor del parametro en la configuracion global si existe o
el valor default en caso contrario.
@param name: nombre del parametro
@type name: str
@param channel: nombre del canal
@type channel: str
@param server: nombre del servidor
@type server: str
@param default: valor devuelto en caso de que no exista el parametro name
@type default: any
@return: El valor del parametro 'name'
@rtype: any
"""
# Specific channel setting
if channel:
# logger.info("config.get_setting reading channel setting '"+name+"' from channel json")
from core import channeltools
value = channeltools.get_channel_setting(name, channel, default)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
elif server:
# logger.info("config.get_setting reading server setting '"+name+"' from server json")
from core import servertools
value = servertools.get_server_setting(name, server, default)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
# Global setting
else:
# logger.info("config.get_setting reading main setting '"+name+"'")
global settings_dic
value = settings_dic.get(name, default)
if value == default:
return value
# logger.info("config.get_setting -> '"+value+"'")
# hack para devolver el tipo correspondiente
if value == "true":
return True
elif value == "false":
return False
else:
# special case return as str
if name in ["adult_password", "adult_aux_intro_password", "adult_aux_new_password1",
"adult_aux_new_password2"]:
return value
else:
try:
value = int(value)
except ValueError:
pass
return value
def setting_channel_new(item):
import xbmcgui
# Load list of options (active user channels that allow global search)
lista = []
ids = []
lista_lang = []
lista_ctgs = []
channels_list = channelselector.filterchannels('all')
for channel in channels_list:
if channel.action == '':
continue
channel_parameters = channeltools.get_channel_parameters(channel.channel)
# Do not include if "include_in_global_search" does not exist in the channel configuration
if not channel_parameters['include_in_global_search']:
continue
lbl = '%s' % channel_parameters['language']
lbl += ' %s' % ', '.join(config.get_localized_category(categ) for categ in channel_parameters['categories'])
it = xbmcgui.ListItem(channel.title, lbl)
it.setArt({'thumb': channel.thumbnail, 'fanart': channel.fanart})
lista.append(it)
ids.append(channel.channel)
lista_lang.append(channel_parameters['language'])
lista_ctgs.append(channel_parameters['categories'])
# Pre-select dialog
preselecciones = [
config.get_localized_string(70570),
config.get_localized_string(70571),
# 'Modificar partiendo de Recomendados',
# 'Modificar partiendo de Frecuentes',
config.get_localized_string(70572),
config.get_localized_string(70573),
# 'Modificar partiendo de Castellano',
# 'Modificar partiendo de Latino'
]
# presel_values = ['skip', 'actual', 'recom', 'freq', 'all', 'none', 'cast', 'lat']
presel_values = ['skip', 'actual', 'all', 'none']
categs = ['movie', 'tvshow', 'documentary', 'anime', 'vos', 'direct', 'torrent']
for c in categs:
preselecciones.append(config.get_localized_string(70577) + config.get_localized_category(c))
presel_values.append(c)
if item.action == 'setting_channel': # Configuración de los canales incluídos en la búsqueda
del preselecciones[0]
del presel_values[0]
# else: # Call from "search on other channels" (you can skip the selection and go directly to the search)
ret = platformtools.dialog_select(config.get_localized_string(59994), preselecciones)
if ret == -1:
return False # order cancel
if presel_values[ret] == 'skip':
return True # continue unmodified
elif presel_values[ret] == 'none':
preselect = []
elif presel_values[ret] == 'all':
preselect = list(range(len(ids)))
elif presel_values[ret] in ['cast', 'lat']:
preselect = []
for i, lg in enumerate(lista_lang):
if presel_values[ret] in lg or '*' in lg:
preselect.append(i)
elif presel_values[ret] == 'actual':
preselect = []
for i, canal in enumerate(ids):
channel_status = config.get_setting('include_in_global_search', canal)
if channel_status:
preselect.append(i)
elif presel_values[ret] == 'recom':
preselect = []
for i, canal in enumerate(ids):
_not, set_canal_list = channeltools.get_channel_controls_settings(canal)
if set_canal_list.get('include_in_global_search', False):
preselect.append(i)
elif presel_values[ret] == 'freq':
preselect = []
for i, canal in enumerate(ids):
frequency = channeltools.get_channel_setting('frequency', canal, 0)
if frequency > 0:
preselect.append(i)
else:
preselect = []
for i, ctgs in enumerate(lista_ctgs):
if presel_values[ret] in ctgs:
preselect.append(i)
# Dialog to select
ret = platformtools.dialog_multiselect(config.get_localized_string(59994), lista, preselect=preselect, useDetails=True)
if ret == None: return False # order cancel
seleccionados = [ids[i] for i in ret]
# Save changes to search channels
for canal in ids:
channel_status = config.get_setting('include_in_global_search', canal)
# if not channel_status:
# channel_status = True
if channel_status and canal not in seleccionados:
config.set_setting('include_in_global_search', False, canal)
elif not channel_status and canal in seleccionados:
config.set_setting('include_in_global_search', True, canal)
return True
def get_setting(name, channel="", server="", default=None):
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global, en la configuracion propia del canal 'channel'
o en la del servidor 'server'.
Los parametros channel y server no deben usarse simultaneamente. Si se especifica el nombre del canal se devolvera
el resultado de llamar a channeltools.get_channel_setting(name, channel, default). Si se especifica el nombre del
servidor se devolvera el resultado de llamar a servertools.get_channel_setting(name, server, default). Si no se
especifica ninguno de los anteriores se devolvera el valor del parametro en la configuracion global si existe o
el valor default en caso contrario.
@param name: nombre del parametro
@type name: str
@param channel: nombre del canal
@type channel: str
@param server: nombre del servidor
@type server: str
@param default: valor devuelto en caso de que no exista el parametro name
@type default: cualquiera
@return: El valor del parametro 'name'
@rtype: El tipo del valor del parametro
"""
# Specific channel setting
if channel:
# logger.info("config.get_setting reading channel setting '"+name+"' from channel json")
from core import channeltools
value = channeltools.get_channel_setting(name, channel, default)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
# Specific server setting
elif server:
# logger.info("config.get_setting reading server setting '"+name+"' from server json")
from core import servertools
value = servertools.get_server_setting(name, server, default)
# logger.info("config.get_setting -> '"+repr(value)+"'")
return value
# Global setting
else:
# logger.info("config.get_setting reading main setting '"+name+"'")
value = __settings__.getSetting(name)
if not value:
return default
# Translate Path if start with "special://"
if value.startswith("special://") and "videolibrarypath" not in name:
value = xbmc.translatePath(value)
# hack para devolver el tipo correspondiente
settings_types = get_settings_types()
if settings_types.get(name) in ['enum', 'number']:
try:
value = int(value)
except Exception, ex:
from core import logger
logger.error(
"Error al convertir '%s' de tipo 'enum','number' \n%s" %
(name, ex))
elif settings_types.get(name) == 'bool':
value = value == 'true'
def get_setting(name, channel="", server="", default=None, caching_var=True):
global alfa_settings
"""
Retorna el valor de configuracion del parametro solicitado.
Devuelve el valor del parametro 'name' en la configuracion global, en la configuracion propia del canal 'channel'
o en la del servidor 'server'.
Los parametros channel y server no deben usarse simultaneamente. Si se especifica el nombre del canal se devolvera
el resultado de llamar a channeltools.get_channel_setting(name, channel, default). Si se especifica el nombre del
servidor se devolvera el resultado de llamar a servertools.get_channel_setting(name, server, default). Si no se
especifica ninguno de los anteriores se devolvera el valor del parametro en la configuracion global si existe o
el valor default en caso contrario.
@param name: nombre del parametro
@type name: str
@param channel: nombre del canal
@type channel: str
@param server: nombre del servidor
@type server: str
@param default: valor devuelto en caso de que no exista el parametro name
@type default: any
@return: El valor del parametro 'name'
@rtype: any
"""
# Specific channel setting
if channel:
# logger.info("get_setting reading channel setting '"+name+"' from channel json")
from core import channeltools
value = channeltools.get_channel_setting(name, channel, default, caching_var=caching_var)
# logger.info("get_setting -> '"+repr(value)+"'")
return value
# Specific server setting
elif server:
# logger.info("get_setting reading server setting '"+name+"' from server json")
from core import servertools
value = servertools.get_server_setting(name, server, default, caching_var=caching_var)
# logger.info("get_setting -> '"+repr(value)+"'")
return value
# Global setting
else:
alfa_caching = bool(window.getProperty("alfa_caching"))
if alfa_caching and caching_var:
alfa_settings = json.loads(window.getProperty("alfa_settings"))
# Si el alfa_caching está activo, se usa la variable cargada. Si no, se cargan por el método tradicional
if not alfa_settings:
get_all_settings_addon()
if alfa_caching and caching_var and name not in str(alfa_no_caching_vars) \
and alfa_settings.get(name, None) != None:
# Si el alfa_caching está activo y la variable cargada. Si no, se cargan por el método tradicional
return get_setting_values(name, alfa_settings.get(name, default))
else:
# logger.info("get_setting reading main setting '"+name+"'")
value = __settings__.getSetting(name)
if not value:
return default
return get_setting_values(name, value, decode_var_=False)
