def delete(item, dict_values): logger.info() if item: dict_series = jsontools.get_node_from_data_json(item.from_channel, TAG_TVSHOW_FILTER) tvshow = item.show.strip().lower() heading = "¿Está seguro que desea eliminar el filtro?" line1 = "Pulse 'Si' para eliminar el filtro de [COLOR %s]%s[/COLOR], pulse 'No' o cierre la ventana para " \ "no hacer nada." % (COLOR.get("selected", "auto"), item.show.strip()) if platformtools.dialog_yesno(heading, line1) == 1: lang_selected = dict_series.get(tvshow, {}).get(TAG_LANGUAGE, "") dict_series.pop(tvshow, None) result, json_data = jsontools.update_json_data(dict_series, item.from_channel, TAG_TVSHOW_FILTER) sound = False if result: message = "FILTRO ELIMINADO" else: message = "Error al guardar en disco" sound = True heading = "%s [%s]" % (item.show.strip(), lang_selected) platformtools.dialog_notification(heading, message, sound=sound) if item.action in ["findvideos", "play"]: platformtools.itemlist_refresh()
def write_data(channel, show, data): # OBTENEMOS LOS DATOS DEL JSON dict_series = jsontools.get_node_from_data_json(channel, TAG_TVSHOW_RENUMERATE) tvshow = show.strip() list_season_episode = dict_series.get(tvshow, {}).get(TAG_SEASON_EPISODE, []) logger.debug("data %s" % list_season_episode) if data: # cambiamos el orden para que se vea en orden descendente y usarse bien en el _data.json data.sort(key=lambda el: int(el[0]), reverse=True) dict_renumerate = {TAG_SEASON_EPISODE: data} dict_series[tvshow] = dict_renumerate else: # hemos borrado todos los elementos, por lo que se borra la serie del fichero dict_series.pop(tvshow, None) result, json_data = jsontools.update_json_data(dict_series, channel, TAG_TVSHOW_RENUMERATE) if result: if data: message = "FILTRO GUARDADO" else: message = "FILTRO BORRADO" else: message = "Error al guardar en disco" heading = show.strip() platformtools.dialog_notification(heading, message)
def save(item, dict_data_saved): ''' Guarda los datos de la ventana de configuracion :param item: item :param dict_data_saved: dict :return: ''' logger.info() global autoplay_node if not autoplay_node: # Obtiene el nodo AUTOPLAY desde el json autoplay_node = jsontools.get_node_from_data_json( 'autoplay', 'AUTOPLAY') channel_node = autoplay_node.get(item.from_channel) config.set_setting("filter_languages", dict_data_saved.pop("language"), item.from_channel) channel_node['settings'] = dict_data_saved result, json_data = jsontools.update_json_data(autoplay_node, 'autoplay', 'AUTOPLAY') return result
def mainlist(channel): """ Muestra una lista de las series renumeradas :param channel: nombre del canal para obtener las series renumeradas :type channel: str :return: lista de Item :rtype: list[Item] """ logger.info() itemlist = [] dict_series = jsontools.get_node_from_data_json(channel, TAG_TVSHOW_RENUMERATE) idx = 0 for tvshow in sorted(dict_series): tag_color = "0xff008000" if idx % 2 == 0: tag_color = "blue" idx += 1 name = tvshow title = "Configurar [COLOR %s][%s][/COLOR]" % (tag_color, name) itemlist.append(Item(channel=__channel__, action="config_item", title=title, show=name, from_channel=channel)) if len(itemlist) == 0: itemlist.append(Item(channel=channel, action="mainlist", title="No se han encontrado series, busca una serie y pulsa en menú contextual " "'RENUMERAR'")) return itemlist
def is_active(): ''' Devuelve un booleano q indica si esta activo o no autoplay en el canal desde el que se llama :return: True si esta activo autoplay para el canal desde el que se llama, False en caso contrario. ''' logger.info() global autoplay_node if not config.is_xbmc(): return False if not autoplay_node: # Obtiene el nodo AUTOPLAY desde el json autoplay_node = jsontools.get_node_from_data_json( 'autoplay', 'AUTOPLAY') # Obtine el canal desde el q se hace la llamada import inspect module = inspect.getmodule(inspect.currentframe().f_back) canal = module.__name__.split('.')[1] logger.debug(canal) # Obtiene el nodo del canal desde autoplay_node channel_node = autoplay_node.get(canal, {}) # Obtiene los ajustes des autoplay para este canal settings_node = channel_node.get('settings', {}) return settings_node.get('active', False)
def __get_data(self, item, global_filter_lang_id): dict_filtered_shows = jsontools.get_node_from_data_json(item.channel, TAG_TVSHOW_FILTER) tvshow = item.show.lower().strip() global_filter_language = config.get_setting(global_filter_lang_id, item.channel) if tvshow in dict_filtered_shows.keys(): self.result = ResultFilter({TAG_ACTIVE: dict_filtered_shows[tvshow][TAG_ACTIVE], TAG_LANGUAGE: dict_filtered_shows[tvshow][TAG_LANGUAGE], TAG_QUALITY_ALLOWED: dict_filtered_shows[tvshow][TAG_QUALITY_ALLOWED]}) # opcion general "no filtrar" elif global_filter_language != 0: from core import channeltools list_controls, dict_settings = channeltools.get_channel_controls_settings(item.channel) for control in list_controls: if control["id"] == global_filter_lang_id: try: language = control["lvalues"][global_filter_language] # logger.debug("language %s" % language) except: logger.error("No se ha encontrado el valor asociado al codigo '%s': %s" % (global_filter_lang_id, global_filter_language)) break self.result = ResultFilter({TAG_ACTIVE: True, TAG_LANGUAGE: language, TAG_QUALITY_ALLOWED: []}) break
def delete_from_context(item): """ Elimina el filtro a través del menú contextual @param item: item @type item: item """ logger.info() # venimos desde get_links y no se ha obtenido ningún resultado, en menu contextual y damos a borrar if item.to_channel != "": item.from_channel = item.to_channel dict_series = jsontools.get_node_from_data_json(item.from_channel, TAG_TVSHOW_FILTER) tvshow = item.show.strip().lower() lang_selected = dict_series.get(tvshow, {}).get(TAG_LANGUAGE, "") dict_series.pop(tvshow, None) result, json_data = jsontools.update_json_data(dict_series, item.from_channel, TAG_TVSHOW_FILTER) sound = False if result: message = "FILTRO ELIMINADO" else: message = "Error al guardar en disco" sound = True heading = "%s [%s]" % (item.show.strip(), lang_selected) platformtools.dialog_notification(heading, message, sound=sound) if item.from_action in ["findvideos", "play", "no_filter"]: # 'no_filter' es el mismo caso que L#601 platformtools.itemlist_refresh()
def save_from_context(item): """ Salva el filtro a través del menú contextual @param item: item @type item: item """ logger.info() dict_series = jsontools.get_node_from_data_json(item.from_channel, TAG_TVSHOW_FILTER) tvshow = item.show.strip().lower() dict_filter = {TAG_NAME: item.show, TAG_ACTIVE: True, TAG_LANGUAGE: item.language, TAG_QUALITY_ALLOWED: []} dict_series[tvshow] = dict_filter result, json_data = jsontools.update_json_data(dict_series, item.from_channel, TAG_TVSHOW_FILTER) sound = False if result: message = "FILTRO GUARDADO" else: message = "Error al guardar en disco" sound = True heading = "%s [%s]" % (item.show.strip(), item.language) platformtools.dialog_notification(heading, message, sound=sound) if item.from_action in ["findvideos", "play"]: platformtools.itemlist_refresh()
def config_item(item): """ muestra una serie renumerada para su configuración :param item: item :type item: Item """ logger.info("item %s" % item.tostring("\n")) dict_series = jsontools.get_node_from_data_json(item.from_channel, TAG_TVSHOW_RENUMERATE) data = dict_series.get(item.show, {}) if data: data = data.get(TAG_SEASON_EPISODE, []) ventana = RenumberWindow(show=item.show, channel=item.from_channel, data=data) del ventana else: # tenemos información y devolvemos los datos añadidos para que se muestre en la ventana if data: return add_season(data) # es la primera vez que se añaden datos (usando menú contextual) por lo que no devolvemos nada # para evitar error al listar los items else: data = add_season(data) write_data(item.from_channel, item.show, data)
def mainlist(channel, list_language, list_quality): """ Muestra una lista de las series filtradas @param channel: nombre del canal para obtener las series filtradas @type channel: str @param list_language: lista de idiomas del canal @type list_language: list[str] @param list_quality: lista de calidades del canal @type list_quality: list[str] @return: lista de Item @rtype: list[Item] """ logger.info() itemlist = [] dict_series = jsontools.get_node_from_data_json(channel, TAG_TVSHOW_FILTER) idx = 0 for tvshow in sorted(dict_series): if idx % 2 == 0: if dict_series[tvshow][TAG_ACTIVE]: tag_color = COLOR.get("striped_even_active", "auto") else: tag_color = COLOR.get("striped_even_inactive", "auto") else: if dict_series[tvshow][TAG_ACTIVE]: tag_color = COLOR.get("striped_odd_active", "auto") else: tag_color = COLOR.get("striped_odd_inactive", "auto") idx += 1 name = dict_series.get(tvshow, {}).get(TAG_NAME, tvshow) activo = " (desactivado)" if dict_series[tvshow][TAG_ACTIVE]: activo = "" title = "Configurar [COLOR %s][%s][/COLOR]%s" % (tag_color, name, activo) itemlist.append( Item(channel=__channel__, action="config_item", title=title, show=name, list_language=list_language, list_quality=list_quality, from_channel=channel)) if len(itemlist) == 0: itemlist.append( Item(channel=channel, action="mainlist", title="No existen filtros, busca una serie y " "pulsa en menú contextual 'FILTRO: Configurar'")) return itemlist
def save(item, dict_data_saved): """ Guarda los valores configurados en la ventana @param item: item @type item: Item @param dict_data_saved: diccionario con los datos salvados @type dict_data_saved: dict """ logger.info() if item and dict_data_saved: logger.debug('item: %s\ndatos: %s' % (item.tostring(), dict_data_saved)) if item.from_channel == "biblioteca": item.from_channel = item.contentChannel dict_series = jsontools.get_node_from_data_json( item.from_channel, TAG_TVSHOW_FILTER) tvshow = item.show.strip().lower() logger.info("Se actualiza los datos") list_quality = [] for _id, value in dict_data_saved.items(): if _id in item.list_quality and value: list_quality.append(_id.lower()) lang_selected = item.list_language[dict_data_saved[TAG_LANGUAGE]] dict_filter = { TAG_NAME: item.show, TAG_ACTIVE: dict_data_saved.get(TAG_ACTIVE, True), TAG_LANGUAGE: lang_selected, TAG_QUALITY_ALLOWED: list_quality } dict_series[tvshow] = dict_filter result, json_data = jsontools.update_json_data(dict_series, item.from_channel, TAG_TVSHOW_FILTER) sound = False if result: message = "FILTRO GUARDADO" else: message = "Error al guardar en disco" sound = True heading = "%s [%s]" % (item.show.strip(), lang_selected) platformtools.dialog_notification(heading, message, sound=sound) if item.from_action in ["findvideos", "play"]: platformtools.itemlist_refresh()
def upgrade_version(channel, list_quality): if channel in ['seriesblanco', 'seriesdanko', 'seriespapaya']: if not config.get_setting("var_temp_filtertools_v2_%s" % channel): dict_series = jsontools.get_node_from_data_json(channel, TAG_TVSHOW_FILTER) if dict_series: # Informamos al usuario platformtools.dialog_notification("Espere por favor", "Actualizando filtros al nuevo formato") # Hacemos backup del fichero original = filetools.join(config.get_data_path(), "settings_channels", channel + "_data.json") backup = filetools.join(config.get_data_path(), "settings_channels", channel + "_data.bk_ft") filetools.copy(original, backup) try: for serie in dict_series.keys(): logger.debug("serie %s" % serie) quality_not_allowed = dict_series[serie]["quality_not_allowed"] # Eliminamos el nodo antiguo dict_series[serie].pop("quality_not_allowed", None) # ponemos en minúsculas quality_allowed = [x.lower() for x in list_quality] for quality in quality_not_allowed: if quality in quality_allowed: quality_allowed.remove(quality) # añadimos el nuevo nodo con los datos correctos dict_series[serie][TAG_QUALITY_ALLOWED] = quality_allowed result, json_data = jsontools.update_json_data(dict_series, channel, TAG_TVSHOW_FILTER) except: logger.error("Se ha producido un error al convertir los filtros") logger.error("Debe suministrar el fichero '%s'" % backup) result = False if result: message = "Conversión correcta" config.set_setting("var_temp_filtertools_v2_%s" % channel, "s") else: message = "Error, reporte en el foro" heading = "Proceso terminado" platformtools.dialog_notification(heading, message) else: config.set_setting("var_temp_filtertools_v2_%s" % channel, "s")
def numbered_for_tratk(channel, show, season, episode): """ Devuelve la temporada y episodio convertido para que se marque correctamente en tratk.tv @param channel: Nombre del canal @type channel: str @param show: Nombre de la serie a comprobar @type show: str @param season: Temporada que devuelve el scrapper @type season: int @param episode: Episodio que devuelve el scrapper @type episode: int @return: season, episode @rtype: int, int """ logger.info() show = show.lower() new_season = season new_episode = episode dict_series = jsontools.get_node_from_data_json(channel, TAG_TVSHOW_RENUMERATE) # ponemos en minusculas el key, ya que previamente hemos hecho lo mismo con show. for key in dict_series.keys(): new_key = key.lower() if new_key != key: dict_series[new_key] = dict_series[key] del dict_series[key] if show in dict_series: logger.debug("ha encontrado algo: %s" % dict_series[show]) if len(dict_series[show]['season_episode']) > 1: for row in dict_series[show]['season_episode']: if new_episode > row[1]: new_episode -= row[1] new_season = row[0] break else: new_season = dict_series[show]['season_episode'][0][0] new_episode += dict_series[show]['season_episode'][0][1] logger.debug("%s:%s" % (new_season, new_episode)) return new_season, new_episode
def borrar(channel, show): logger.info() heading = "¿Está seguro que desea eliminar renumeración?" line1 = "Pulse 'Si' para eliminar la renumeración de [COLOR blue]%s[/COLOR], pulse 'No' o cierre la ventana " \ "para no hacer nada." % show.strip() if platformtools.dialog_yesno(heading, line1) == 1: dict_series = jsontools.get_node_from_data_json(channel, TAG_TVSHOW_RENUMERATE) dict_series.pop(show, None) result, json_data = jsontools.update_json_data(dict_series, channel, TAG_TVSHOW_RENUMERATE) if result: message = "FILTRO ELIMINADO" else: message = "Error al guardar en disco" heading = show.strip() platformtools.dialog_notification(heading, message)
def check_value(channel, itemlist): ''' comprueba la existencia de un valor en la lista de servidores o calidades si no existiera los agrega a la lista en el json :param channel: str :param values: list (una de servidores o calidades) :param value_type: str (server o quality) :return: list ''' logger.info() global autoplay_node change = False if not autoplay_node: # Obtiene el nodo AUTOPLAY desde el json autoplay_node = jsontools.get_node_from_data_json( 'autoplay', 'AUTOPLAY') channel_node = autoplay_node.get(channel) server_list = channel_node.get('servers') if not server_list: server_list = channel_node['servers'] = list() quality_list = channel_node.get('quality') if not quality_list: quality_list = channel_node['quality'] = list() for item in itemlist: if item.server not in server_list: server_list.append(item.server) change = True if item.quality not in quality_list: quality_list.append(item.quality) change = True if change: change, json_data = jsontools.update_json_data(autoplay_node, 'autoplay', 'AUTOPLAY') return change
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 autoplay_node if not config.is_xbmc(): platformtools.dialog_notification('AutoPlay ERROR', 'Sólo disponible para XBMC/Kodi') return itemlist else: if not autoplay_node: # Obtiene el nodo AUTOPLAY desde el json autoplay_node = jsontools.get_node_from_data_json( 'autoplay', 'AUTOPLAY') # Agrega servidores y calidades que no estaban listados a autoplay_node new_options = check_value(item.channel, itemlist) # Obtiene el nodo del canal desde autoplay_node channel_node = autoplay_node.get(item.channel, {}) # Obtiene los ajustes des autoplay para este canal settings_node = channel_node.get('settings', {}) if settings_node['active']: url_list_valid = [] autoplay_list = [] favorite_servers = [] favorite_quality = [] # Guarda el valor actual de "Accion al seleccionar vídeo:" en preferencias user_config_setting = config.get_setting("default_action") # Habilita la accion "Ver en calidad alta" (si el servidor devuelve más de una calidad p.e. gdrive) if user_config_setting != 2: config.set_setting("default_action", 2) # 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', []) quality_list = channel_node.get('quality', []) # 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]]) 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() # 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": "Configurar AutoPlay", "action": "autoplay_config", "channel": "autoplay", "from_channel": item.channel }) # 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 not in favorite_servers or item.quality not in favorite_quality \ or item.url in url_list_valid: continue autoplay_elem["indice_server"] = favorite_servers.index( item.server) 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 not in favorite_servers or item.url in url_list_valid: continue autoplay_elem["indice_server"] = favorite_servers.index( item.server) 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: 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) 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']) # Si hay elementos en la lista de autoplay se intenta reproducir cada elemento, hasta encontrar uno # funcional o fallen todos if autoplay_list: 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: if not platformtools.is_playing() and not played: videoitem = autoplay_elem['videoitem'] if videoitem.server not in max_intentos_servers: max_intentos_servers[ videoitem.server] = max_intentos # Si se han alcanzado el numero maximo de intentos de este servidor saltamos al siguiente if max_intentos_servers[videoitem.server] == 0: continue lang = " " if hasattr(videoitem, 'language') and videoitem.language != "": lang = " '%s' " % videoitem.language platformtools.dialog_notification( "AutoPlay", "%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' % item.channel, None, None, ["channels.%s" % item.channel]) 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 platformtools.play_video(videoitem) try: if platformtools.is_playing(): played = True break except: # TODO evitar el informe de que el conector fallo o el video no se encuentra logger.debug(str(len(autoplay_list))) # Si hemos llegado hasta aqui es por q no se ha podido reproducir max_intentos_servers[videoitem.server] -= 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] == 0: text = "Parece que los enlaces de %s no estan funcionando." % videoitem.server.upper( ) if not platformtools.dialog_yesno( "AutoPlay", text, "¿Desea ignorar todos los enlaces de este servidor?" ): max_intentos_servers[ videoitem.server] = max_intentos else: platformtools.dialog_notification('AutoPlay No Fue Posible', 'No Hubo Coincidencias') if new_options: platformtools.dialog_notification( "AutoPlay", "Nueva Calidad/Servidor disponible en la " "configuracion", sound=False) # Restaura si es necesario el valor previo de "Accion al seleccionar vídeo:" en preferencias if user_config_setting != 2: config.set_setting("default_action", user_config_setting) # devuelve la lista de enlaces para la eleccion manual return itemlist
def autoplay_config(item): logger.info() global autoplay_node dict_values = {} list_controls = [] channel_parameters = channeltools.get_channel_parameters(item.from_channel) channel_name = channel_parameters['title'] if not autoplay_node: # Obtiene el nodo AUTOPLAY desde el json autoplay_node = jsontools.get_node_from_data_json( 'autoplay', 'AUTOPLAY') channel_node = autoplay_node.get(item.from_channel, {}) settings_node = channel_node.get('settings', {}) allow_option = True active_settings = { "id": "active", "label": "AutoPlay (activar/desactivar la auto-reproduccion)", "color": "0xffffff99", "type": "bool", "default": False, "enabled": allow_option, "visible": allow_option } list_controls.append(active_settings) dict_values['active'] = settings_node.get('active', False) # Idioma status_language = config.get_setting("filter_languages", item.from_channel) if not status_language: status_language = 0 set_language = { "id": "language", "label": "Idioma para AutoPlay (Opcional)", "color": "0xffffff99", "type": "list", "default": 0, "enabled": "eq(-1,true)", "visible": True, "lvalues": get_languages(item.from_channel) } list_controls.append(set_language) dict_values['language'] = status_language separador = { "id": "label", "label": " " "_________________________________________________________________________________________", "type": "label", "enabled": True, "visible": True } list_controls.append(separador) # Seccion servidores Preferidos server_list = channel_node.get("servers", []) if not server_list: enabled = False server_list = ["No disponible"] else: enabled = "eq(-3,true)" custom_servers_settings = { "id": "custom_servers", "label": " Servidores Preferidos", "color": "0xff66ffcc", "type": "bool", "default": False, "enabled": enabled, "visible": True } list_controls.append(custom_servers_settings) if dict_values['active'] and enabled: dict_values['custom_servers'] = settings_node.get( 'custom_servers', False) else: dict_values['custom_servers'] = False for num in range(1, 4): pos1 = num + 3 default = num - 1 if default > len(server_list) - 1: default = 0 set_servers = { "id": "server_%s" % num, "label": u" \u2665 Servidor Favorito %s" % num, "color": "0xfffcab14", "type": "list", "default": default, "enabled": "eq(-%s,true)+eq(-%s,true)" % (pos1, num), "visible": True, "lvalues": server_list } list_controls.append(set_servers) dict_values["server_%s" % num] = settings_node.get( "server_%s" % num, 0) if settings_node.get("server_%s" % num, 0) > len(server_list) - 1: dict_values["server_%s" % num] = 0 # Seccion Calidades Preferidas quality_list = channel_node.get("quality", []) if not quality_list: enabled = False quality_list = ["No disponible"] else: enabled = "eq(-7,true)" custom_quality_settings = { "id": "custom_quality", "label": " Calidades Preferidas", "color": "0xff66ffcc", "type": "bool", "default": False, "enabled": enabled, "visible": True } list_controls.append(custom_quality_settings) if dict_values['active'] and enabled: dict_values['custom_quality'] = settings_node.get( 'custom_quality', False) else: dict_values['custom_quality'] = False for num in range(1, 4): pos1 = num + 7 default = num - 1 if default > len(quality_list) - 1: default = 0 set_quality = { "id": "quality_%s" % num, "label": u" \u2665 Calidad Favorita %s" % num, "color": "0xfff442d9", "type": "list", "default": default, "enabled": "eq(-%s,true)+eq(-%s,true)" % (pos1, num), "visible": True, "lvalues": quality_list } list_controls.append(set_quality) dict_values["quality_%s" % num] = settings_node.get( "quality_%s" % num, 0) if settings_node.get("quality_%s" % num, 0) > len(quality_list) - 1: dict_values["quality_%s" % num] = 0 # Seccion Prioridades priority_list = ["Servidor y Calidad", "Calidad y Servidor"] set_priority = { "id": "priority", "label": " Prioridad (Indica el orden para Auto-Reproducir)", "color": "0xffffff99", "type": "list", "default": 0, "enabled": True, "visible": "eq(-4,true)+eq(-8,true)+eq(-11,true)", "lvalues": priority_list } list_controls.append(set_priority) dict_values["priority"] = settings_node.get("priority", 0) # Abrir cuadro de dialogo platformtools.show_channel_settings(list_controls=list_controls, dict_values=dict_values, callback='save', item=item, caption='%s - AutoPlay' % channel_name)
def init(channel, list_servers, list_quality): ''' Comprueba la existencia de canal en el archivo de configuracion de Autoplay y si no existe lo añade. Es necesario llamar a esta funcion al entrar a cualquier canal que incluya la funcion Autoplay. :param channel: (str) id del canal :param list_servers: (list) lista inicial de servidores validos para el canal. No es necesario incluirlos todos, ya que la lista de servidores validos se ira actualizando dinamicamente. :param list_quality: (list) lista inicial de calidades validas para el canal. No es necesario incluirlas todas, ya que la lista de calidades validas se ira actualizando dinamicamente. :return: (bool) True si la inicializacion ha sido correcta. ''' logger.info() change = False result = True if not config.is_xbmc(): platformtools.dialog_notification('AutoPlay ERROR', 'Sólo disponible para XBMC/Kodi') result = False else: autoplay_path = os.path.join(config.get_data_path(), "settings_channels", 'autoplay_data.json') if os.path.exists(autoplay_path): autoplay_node = jsontools.get_node_from_data_json( 'autoplay', "AUTOPLAY") else: change = True autoplay_node = {"AUTOPLAY": {}} if channel not in autoplay_node: change = True # Se comprueba que no haya calidades ni servidores duplicados list_servers = list(set(list_servers)) list_quality = list(set(list_quality)) # Creamos el nodo del canal y lo añadimos channel_node = { "servers": list_servers, "quality": list_quality, "settings": { "active": False, "custom_servers": False, "custom_quality": False, "priority": 0 } } for n in range(1, 4): s = c = 0 if len(list_servers) >= n: s = n - 1 if len(list_quality) >= n: c = n - 1 channel_node["settings"]["server_%s" % n] = s channel_node["settings"]["quality_%s" % n] = c autoplay_node[channel] = channel_node if change: result, json_data = jsontools.update_json_data( autoplay_node, 'autoplay', 'AUTOPLAY') if result: heading = "AutoPlay Disponible" msj = "Seleccione '<Configurar AutoPlay>' para activarlo." icon = 0 else: heading = "Error al iniciar AutoPlay" msj = "Consulte su log para obtener mas información." icon = 1 platformtools.dialog_notification(heading, msj, icon, sound=False) return result
def config_item(item): """ muestra una serie filtrada para su configuración @param item: item @type item: Item """ logger.info() logger.info("item %s" % item.tostring()) # OBTENEMOS LOS DATOS DEL JSON dict_series = jsontools.get_node_from_data_json(item.from_channel, TAG_TVSHOW_FILTER) tvshow = item.show.lower().strip() lang_selected = dict_series.get(tvshow, {}).get(TAG_LANGUAGE, 'Español') list_quality = dict_series.get(tvshow, {}).get( TAG_QUALITY_ALLOWED, [x.lower() for x in item.list_quality]) # logger.info("lang selected {}".format(lang_selected)) # logger.info("list quality {}".format(list_quality)) active = True custom_button = {'visible': False} allow_option = False if item.show.lower().strip() in dict_series: allow_option = True active = dict_series.get(item.show.lower().strip(), {}).get(TAG_ACTIVE, False) custom_button = { 'label': 'Borrar', 'function': 'delete', 'visible': True, 'close': True } list_controls = [] if allow_option: active_control = { "id": "active", "type": "bool", "label": "¿Activar/Desactivar filtro?", "color": "", "default": active, "enabled": allow_option, "visible": allow_option, } list_controls.append(active_control) language_option = { "id": "language", "type": "list", "label": "Idioma", "color": "0xFFee66CC", "default": item.list_language.index(lang_selected), "enabled": True, "visible": True, "lvalues": item.list_language } list_controls.append(language_option) if item.list_quality: list_controls_calidad = [ { "id": "textoCalidad", "type": "label", "label": "Calidad permitida", "color": "0xffC6C384", "enabled": True, "visible": True, }, ] for element in sorted(item.list_quality, key=str.lower): list_controls_calidad.append({ "id": element, "type": "bool", "label": element, "default": (False, True)[element.lower() in list_quality], "enabled": True, "visible": True, }) # concatenamos list_controls con list_controls_calidad list_controls.extend(list_controls_calidad) title = "Filtrado de enlaces para: [COLOR %s]%s[/COLOR]" % (COLOR.get( "selected", "auto"), item.show) platformtools.show_channel_settings(list_controls=list_controls, callback='save', item=item, caption=title, custom_button=custom_button)