def update_channel(channel_name):
logger.info(channel_name)
import channeltools
remote_channel_url, remote_version_url = channeltools.get_channel_remote_url(
channel_name)
local_channel_path, local_version_path, local_compiled_path = channeltools.get_channel_local_path(
channel_name)
# Version remota
try:
data = scrapertools.cachePage(remote_version_url)
logger.info("remote_data=" + data)
remote_version = int(
scrapertools.find_single_match(data, '<version>([^<]+)</version>'))
addon_condition = int(
scrapertools.find_single_match(
data, "<addon_version>([^<]*)</addon_version>").replace(
".", "").ljust(
len(str(versiontools.get_current_plugin_version())),
'0'))
except:
remote_version = 0
addon_condition = 0
logger.info("remote_version=%d" % remote_version)
# Version local
if os.path.exists(local_version_path):
infile = open(local_version_path)
data = infile.read()
infile.close()
#logger.info("pelisalacarta.core.updater local_data="+data)
local_version = int(
scrapertools.find_single_match(data, '<version>([^<]+)</version>'))
else:
local_version = 0
logger.info("local_version=%d" % local_version)
# Comprueba si ha cambiado
updated = (remote_version > local_version) and (
versiontools.get_current_plugin_version() >= addon_condition)
if updated:
logger.info("downloading...")
download_channel(channel_name)
return updated
def get_available_updates():
logger.info()
# Cuantas actualizaciones hay?
number_of_updates = 0
new_published_version_tag = ""
# Lee la versión remota
from core import api
latest_packages = api.plugins_get_latest_packages()
for latest_package in latest_packages["body"]:
if latest_package["package"] == "plugin":
if latest_package[
"version"] > versiontools.get_current_plugin_version():
number_of_updates = number_of_updates + 1
new_published_version_tag = latest_package["tag"]
elif latest_package["package"] == "channels":
if latest_package[
"version"] > versiontools.get_current_channels_version():
number_of_updates = number_of_updates + 1
elif latest_package["package"] == "servers":
if latest_package[
"version"] > versiontools.get_current_servers_version():
number_of_updates = number_of_updates + 1
return new_published_version_tag, number_of_updates
def checkforupdates():
logger.info()
# Valores por defecto
numero_version_publicada = 0
tag_version_publicada = ""
# Lee la versión remota
from core import api
latest_packages = api.plugins_get_latest_packages()
for latest_package in latest_packages["body"]:
if latest_package["package"] == "plugin":
numero_version_publicada = latest_package["version"]
tag_version_publicada = latest_package["tag"]
break
logger.info("version remota=" + str(numero_version_publicada))
# Lee la versión local
numero_version_local = versiontools.get_current_plugin_version()
logger.info("version local=" + str(numero_version_local))
hayqueactualizar = numero_version_publicada > numero_version_local
logger.info("-> hayqueactualizar=" + repr(hayqueactualizar))
# Si hay actualización disponible, devuelve la Nueva versión para que cada plataforma se encargue de mostrar los avisos
if hayqueactualizar:
return tag_version_publicada
else:
return None
def get_available_updates():
logger.info("pelisalacarta.core.updater checkforupdates")
# Cuantas actualizaciones hay?
number_of_updates = 0
new_published_version_tag = ""
# Lee la versión remota
from core import api
latest_packages = api.plugins_get_latest_packages()
for latest_package in latest_packages["body"]:
if latest_package["package"]=="plugin":
if latest_package["version"] > versiontools.get_current_plugin_version():
number_of_updates = number_of_updates + 1
new_published_version_tag = latest_package["tag"]
elif latest_package["package"]=="channels":
if latest_package["version"] > versiontools.get_current_channels_version():
number_of_updates = number_of_updates + 1
elif latest_package["package"]=="servers":
if latest_package["version"] > versiontools.get_current_servers_version():
number_of_updates = number_of_updates + 1
return new_published_version_tag,number_of_updates
def checkforupdates():
logger.info("pelisalacarta.core.updater checkforupdates")
# Valores por defecto
numero_version_publicada = 0
tag_version_publicada = ""
# Lee la versión remota
from core import api
latest_packages = api.plugins_get_latest_packages()
for latest_package in latest_packages["body"]:
if latest_package["package"]=="plugin":
numero_version_publicada = latest_package["version"]
tag_version_publicada = latest_package["tag"]
break
logger.info("pelisalacarta.core.updater checkforupdates version remota="+str(numero_version_publicada))
# Lee la versión local
numero_version_local = versiontools.get_current_plugin_version()
logger.info("pelisalacarta.core.updater checkforupdates version local="+str(numero_version_local))
hayqueactualizar = numero_version_publicada > numero_version_local
logger.info("pelisalacarta.core.updater checkforupdates -> hayqueactualizar="+repr(hayqueactualizar))
# Si hay actualización disponible, devuelve la Nueva versión para que cada plataforma se encargue de mostrar los avisos
if hayqueactualizar:
return tag_version_publicada
else:
return None
def get_channel_parameters(channel_name):
# logger.info("streamondemand.core.channeltools get_channel_parameters channel_name="+channel_name)
channel_xml = os.path.join(config.get_runtime_path(), 'channels',
channel_name + ".xml")
if os.path.exists(channel_xml):
# logger.info("channel_name+".xml found")
infile = open(channel_xml, "rb")
data = infile.read()
infile.close()
channel_parameters = dict()
channel_parameters["title"] = scrapertools.find_single_match(
data, "<name>([^<]*)</name>")
channel_parameters["channel"] = scrapertools.find_single_match(
data, "<id>([^<]*)</id>")
channel_parameters["active"] = str_to_bool(
scrapertools.find_single_match(data, "<active>([^<]*)</active>"))
channel_parameters["adult"] = str_to_bool(
scrapertools.find_single_match(data, "<adult>([^<]*)</adult>"))
channel_parameters["language"] = scrapertools.find_single_match(
data, "<language>([^<]*)</language>")
channel_parameters["version"] = scrapertools.find_single_match(
data, "<version>([^<]*)</version>")
# Imagenes: se admiten url y archivos locales dentro de "resources/images"
channel_parameters["thumbnail"] = scrapertools.find_single_match(
data, "<thumbnail>([^<]*)</thumbnail>")
channel_parameters["bannermenu"] = scrapertools.find_single_match(
data, "<bannermenu>([^<]*)</bannermenu>")
channel_parameters["fanart"] = scrapertools.find_single_match(
data, "<fanart>([^<]*)</fanart>")
if channel_parameters["thumbnail"] and "://" not in channel_parameters[
"thumbnail"]:
channel_parameters["thumbnail"] = os.path.join(
config.get_runtime_path(), "resources", "images", "squares",
channel_parameters["thumbnail"])
if channel_parameters[
"bannermenu"] and "://" not in channel_parameters["bannermenu"]:
channel_parameters["bannermenu"] = os.path.join(
config.get_runtime_path(), "resources", "images", "bannermenu",
channel_parameters["bannermenu"])
if channel_parameters["fanart"] and "://" not in channel_parameters[
"fanart"]:
channel_parameters["fanart"] = os.path.join(
config.get_runtime_path(), "resources", "images", "fanart",
channel_parameters["fanart"])
channel_parameters["update_url"] = scrapertools.find_single_match(
data, "<update_url>([^<]*)</update_url>")
if channel_parameters["update_url"] == "":
channel_parameters["update_url"] = DEFAULT_UPDATE_URL
include_in_global_search = scrapertools.find_single_match(
data,
"<include_in_global_search>([^<]*)</include_in_global_search>")
if include_in_global_search in ["", "true"]:
channel_parameters["include_in_global_search"] = True
else:
channel_parameters["include_in_global_search"] = False
category_list = []
matches = scrapertools.find_multiple_matches(
data, "<category>([^<]*)</category>")
for match in matches:
category_list.append(match)
channel_parameters["categories"] = category_list
# Obtenemos si el canal tiene opciones de configuración
channel_parameters["has_settings"] = False
# esta regex devuelve 2 valores por elemento <settings>, el contenido del propio nodo y un \t, por lo que hay
# posteriormente coger solo el valor del indice 0.
matches = scrapertools.find_multiple_matches(
data, "<settings>((.|\n)*?)<\/settings>")
for match in matches:
_id = scrapertools.find_single_match(match[0], "<id>([^<]*)</id>")
if _id and "include_in_" not in _id:
channel_parameters["has_settings"] = True
break
# Inicio - condiciones para mostrar canal compatible
python_condition = scrapertools.find_single_match(
data, "<python>([^<]*)</python>")
if python_condition:
import sys
def versiontuple(v):
return tuple(map(int, (v.split("."))))
if sys.version_info < versiontuple(python_condition):
python_compatible = False
else:
python_compatible = True
else:
python_compatible = True
addon_version_condition = scrapertools.find_single_match(
data, "<addon_version>([^<]*)</addon_version>")
if addon_version_condition:
import versiontools
addon_version = int(
addon_version_condition.replace(".", "").ljust(
len(str(versiontools.get_current_plugin_version())), '0'))
if versiontools.get_current_plugin_version() < addon_version:
addon_version_compatible = False
else:
addon_version_compatible = True
else:
addon_version_compatible = True
channel_parameters["compatible"] = True
if not python_compatible or not addon_version_compatible:
channel_parameters["compatible"] = False
# Fin - condiciones para mostrar canal compatible
logger.info(channel_name + " -> " + repr(channel_parameters))
else:
logger.info(channel_name + ".xml NOT found")
channel_parameters = dict()
channel_parameters["adult"] = False
channel_parameters["update_url"] = DEFAULT_UPDATE_URL
return channel_parameters
def get_channel_parameters(channel_name):
global dict_channels_parameters
if channel_name not in dict_channels_parameters:
try:
channel_parameters = get_channel_json(channel_name)
# logger.debug(channel_parameters)
if channel_parameters:
# cambios de nombres y valores por defecto
channel_parameters["title"] = channel_parameters.pop("name")
channel_parameters["channel"] = channel_parameters.pop("id")
# si no existe el key se declaran valor por defecto para que no de fallos en las funciones que lo llaman
channel_parameters["update_url"] = channel_parameters.get(
"update_url", DEFAULT_UPDATE_URL)
channel_parameters["language"] = channel_parameters.get(
"language", "all")
channel_parameters["adult"] = channel_parameters.get(
"adult", False)
channel_parameters["active"] = channel_parameters.get(
"active", False)
channel_parameters[
"include_in_global_search"] = channel_parameters.get(
"include_in_global_search", False)
channel_parameters["categories"] = channel_parameters.get(
"categories", list())
channel_parameters["thumbnail"] = channel_parameters.get(
"thumbnail", "")
channel_parameters["banner"] = channel_parameters.get(
"banner", "")
channel_parameters["fanart"] = channel_parameters.get(
"fanart", "")
# Imagenes: se admiten url y archivos locales dentro de "resources/images"
if channel_parameters.get(
"thumbnail"
) and "://" not in channel_parameters["thumbnail"]:
channel_parameters["thumbnail"] = os.path.join(
config.get_runtime_path(), "resources", "media",
"channels", "thumb", channel_parameters["thumbnail"])
if channel_parameters.get(
"banner"
) and "://" not in channel_parameters["banner"]:
channel_parameters["banner"] = os.path.join(
config.get_runtime_path(), "resources", "media",
"channels", "banner", channel_parameters["banner"])
if channel_parameters.get(
"fanart"
) and "://" not in channel_parameters["fanart"]:
channel_parameters["fanart"] = os.path.join(
config.get_runtime_path(), "resources", "media",
"channels", "fanart", channel_parameters["fanart"])
# Obtenemos si el canal tiene opciones de configuración
channel_parameters["has_settings"] = False
if 'settings' in channel_parameters:
# if not isinstance(channel_parameters['settings'], list):
# channel_parameters['settings'] = [channel_parameters['settings']]
# if "include_in_global_search" in channel_parameters['settings']:
# channel_parameters["include_in_global_search"] = channel_parameters['settings']
# ["include_in_global_search"].get('default', False)
#
# found = False
# for el in channel_parameters['settings']:
# for key in el.items():
# if 'include_in' not in key:
# channel_parameters["has_settings"] = True
# found = True
# break
# if found:
# break
for s in channel_parameters['settings']:
if 'id' in s:
if s['id'] == "include_in_global_search":
channel_parameters[
"include_in_global_search"] = True
elif not s['id'].startswith("include_in_") and \
(s.get('enabled', False) or s.get('visible', False)):
channel_parameters["has_settings"] = True
del channel_parameters['settings']
# Compatibilidad
if 'compatible' in channel_parameters:
# compatible python
python_compatible = True
if 'python' in channel_parameters["compatible"]:
import sys
python_condition = channel_parameters["compatible"][
'python']
if sys.version_info < tuple(
map(int, (python_condition.split(".")))):
python_compatible = False
# compatible addon_version
addon_version_compatible = True
if 'addon_version' in channel_parameters["compatible"]:
import versiontools
addon_version_condition = channel_parameters[
"compatible"]['addon_version']
addon_version = int(
addon_version_condition.replace(".", "").ljust(
len(
str(versiontools.
get_current_plugin_version())), '0'))
if versiontools.get_current_plugin_version(
) < addon_version:
addon_version_compatible = False
channel_parameters[
"compatible"] = python_compatible and addon_version_compatible
else:
channel_parameters["compatible"] = True
dict_channels_parameters[channel_name] = channel_parameters
else:
# para evitar casos donde canales no están definidos como configuración
# lanzamos la excepcion y asi tenemos los valores básicos
raise Exception
except Exception, ex:
logger.error(channel_name + ".json error \n%s" % ex)
channel_parameters = dict()
channel_parameters["channel"] = ""
channel_parameters["adult"] = False
channel_parameters['active'] = False
channel_parameters["compatible"] = True
channel_parameters["language"] = ""
channel_parameters["update_url"] = DEFAULT_UPDATE_URL
return channel_parameters
