diff --git a/plugin.video.alfa/addon.xml b/plugin.video.alfa/addon.xml
index 7d27e2ce..b44f5691 100755
--- a/plugin.video.alfa/addon.xml
+++ b/plugin.video.alfa/addon.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<addon id="plugin.video.alfa" name="Alfa" version="2.5.28" provider-name="Alfa Addon">
+<addon id="plugin.video.alfa" name="Alfa" version="2.5.29" provider-name="Alfa Addon">
   <requires>
     <import addon="xbmc.python" version="2.1.0"/>
     <import addon="script.module.libtorrent" optional="true"/>
@@ -19,10 +19,14 @@
     </assets>
       <news>[B]Estos son los cambios para esta versión:[/B]
       [COLOR green][B]Canales agregados y arreglos[/B][/COLOR] 
-      ¤ mejortorrent                ¤ mejortorrent1
-      ¤ newpct1                        ¤ inkaseries
-      ¤ wikiseries                      ¤ powvideo
-      ¤ mega
+      ¤ doomtv                    ¤ locopelis
+      ¤ veseriesonline        ¤ hdfull
+      ¤ flashx                       ¤ powvideo
+      ¤ vidoza                      ¤ alltorrent
+      ¤ elitetorrent             ¤ grantorrent
+      ¤ mejortorrent          ¤ newpct1
+      ¤ poseidonhd
+      
       ¤ arreglos internos
       
       ¤ Agradecimientos a @angedam por colaborar en ésta versión
diff --git a/plugin.video.alfa/channels/alltorrent.json b/plugin.video.alfa/channels/alltorrent.json
index c627ebbb..e2188b7b 100755
--- a/plugin.video.alfa/channels/alltorrent.json
+++ b/plugin.video.alfa/channels/alltorrent.json
@@ -4,7 +4,8 @@
   "active": true,
   "adult": false,
   "language": ["cast"],
-  "thumbnail": "http://imgur.com/sLaXHvp.png",
+  "thumbnail": "altorrent.png",
+  "fanart": "altorrent.jpg",
   "categories": [
     "torrent",
     "movie"
@@ -22,7 +23,7 @@
       "id": "include_in_global_search",
       "type": "bool",
       "label": "Incluir en busqueda global",
-      "default": true,
+      "default": false,
       "enabled": true,
       "visible": true
     },
diff --git a/plugin.video.alfa/channels/alltorrent.py b/plugin.video.alfa/channels/alltorrent.py
index 34869367..505f5059 100755
--- a/plugin.video.alfa/channels/alltorrent.py
+++ b/plugin.video.alfa/channels/alltorrent.py
@@ -1,93 +1,261 @@
 # -*- coding: utf-8 -*-
 
-import os
 import re
-import unicodedata
-from threading import Thread
+import sys
+import urllib
+import urlparse
 
+from channelselector import get_thumb
 from core import httptools
 from core import scrapertools
 from core import servertools
-from core import tmdb
 from core.item import Item
 from platformcode import config, logger
-
-__modo_grafico__ = config.get_setting('modo_grafico', "ver-pelis")
-
-
-# Para la busqueda en bing evitando baneos
-
-
-def browser(url):
-    import mechanize
-
-    # Utilizamos Browser mechanize para saltar problemas con la busqueda en bing
-    br = mechanize.Browser()
-    # Browser options
-    br.set_handle_equiv(False)
-    br.set_handle_gzip(True)
-    br.set_handle_redirect(True)
-    br.set_handle_referer(False)
-    br.set_handle_robots(False)
-    # Follows refresh 0 but not hangs on refresh > 0
-    br.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(), max_time=1)
-    # Want debugging messages?
-    # br.set_debug_http(True)
-    # br.set_debug_redirects(True)
-    # br.set_debug_responses(True)
-
-    # User-Agent (this is cheating, ok?)
-    # br.addheaders = [('User-agent', 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/600.7.12 (KHTML, like Gecko) Version/7.1.7 Safari/537.85.16')]
-    # br.addheaders =[('Cookie','SRCHD=AF=QBRE; domain=.bing.com; expires=25 de febrero de 2018 13:00:28 GMT+1; MUIDB=3B942052D204686335322894D3086911; domain=www.bing.com;expires=24 de febrero de 2018 13:00:28 GMT+1')]
-    # Open some site, let's pick a random one, the first that pops in mind
-    r = br.open(url)
-    response = r.read()
-    print response
-    if "img,divreturn" in response:
-        r = br.open("http://ssl-proxy.my-addr.org/myaddrproxy.php/" + url)
-        print "prooooxy"
-        response = r.read()
-
-    return response
-
-
-api_key = "2e2160006592024ba87ccdf78c28f49f"
-api_fankey = "dffe90fba4d02c199ae7a9e71330c987"
+from core import tmdb
+from lib import generictools
 
 host = 'http://alltorrent.net/'
+__modo_grafico__ = config.get_setting('modo_grafico', 'alltorrent')
+
 
 def mainlist(item):
     logger.info()
     itemlist = []
-    i = 0
-    global i
-    itemlist.append(item.clone(title="[COLOR springgreen][B]Todas Las Películas[/B][/COLOR]", action="scraper",
-                               url="http://alltorrent.net/", thumbnail="http://imgur.com/XLqPZoF.png",
-                               fanart="http://imgur.com/v3ChkZu.jpg", contentType="movie"))
-    itemlist.append(item.clone(title="[COLOR springgreen]      Incluyen 1080p[/COLOR]", action="scraper",
-                               url="http://alltorrent.net/rezolucia/1080p/", thumbnail="http://imgur.com/XLqPZoF.png",
-                               fanart="http://imgur.com/v3ChkZu.jpg", contentType="movie"))
-    itemlist.append(item.clone(title="[COLOR springgreen]      Incluyen 720p[/COLOR]", action="scraper",
-                               url="http://alltorrent.net/rezolucia/720p/", thumbnail="http://imgur.com/XLqPZoF.png",
-                               fanart="http://imgur.com/v3ChkZu.jpg", contentType="movie"))
-    itemlist.append(item.clone(title="[COLOR springgreen]      Incluyen Hdrip[/COLOR]", action="scraper",
-                               url="http://alltorrent.net/rezolucia/hdrip/", thumbnail="http://imgur.com/XLqPZoF.png",
-                               fanart="http://imgur.com/v3ChkZu.jpg", contentType="movie"))
-    itemlist.append(item.clone(title="[COLOR springgreen]      Incluyen 3D[/COLOR]", action="scraper",
-                               url="http://alltorrent.net/rezolucia/3d/", thumbnail="http://imgur.com/XLqPZoF.png",
-                               fanart="http://imgur.com/v3ChkZu.jpg", contentType="movie"))
-    itemlist.append(itemlist[-1].clone(title="[COLOR floralwhite][B]Buscar[/B][/COLOR]", action="search",
-                                       thumbnail="http://imgur.com/5EBwccS.png", fanart="http://imgur.com/v3ChkZu.jpg",
-                                       contentType="movie", extra="titulo"))
-    itemlist.append(itemlist[-1].clone(title="[COLOR oldlace]         Por Título[/COLOR]", action="search",
-                                       thumbnail="http://imgur.com/5EBwccS.png", fanart="http://imgur.com/v3ChkZu.jpg",
-                                       contentType="movie", extra="titulo"))
-    itemlist.append(itemlist[-1].clone(title="[COLOR oldlace]         Por Año[/COLOR]", action="search",
-                                       thumbnail="http://imgur.com/5EBwccS.png", fanart="http://imgur.com/v3ChkZu.jpg",
-                                       contentType="movie", extra="año"))
-    itemlist.append(itemlist[-1].clone(title="[COLOR oldlace]         Por Rating Imdb[/COLOR]", action="search",
-                                       thumbnail="http://imgur.com/5EBwccS.png", fanart="http://imgur.com/v3ChkZu.jpg",
-                                       contentType="movie", extra="rating"))
+    
+    thumb_pelis = get_thumb("channels_movie.png")
+    thumb_pelis_hd = get_thumb("channels_movie_hd.png")
+    thumb_series = get_thumb("channels_tvshow.png")
+    thumb_series_hd = get_thumb("channels_tvshow_hd.png")
+    thumb_buscar = get_thumb("search.png")
+
+    itemlist.append(item.clone(title="[COLOR springgreen][B]Todas Las Películas[/B][/COLOR]", action="listado",
+                               url=host, thumbnail=thumb_pelis, extra="pelicula"))
+    itemlist.append(item.clone(title="[COLOR springgreen]      Incluyen 1080p[/COLOR]", action="listado",
+                               url=host + "rezolucia/1080p/", thumbnail=thumb_pelis_hd, extra="pelicula"))
+    itemlist.append(item.clone(title="[COLOR springgreen]      Incluyen 720p[/COLOR]", action="listado",
+                               url=host + "rezolucia/720p/", thumbnail=thumb_pelis_hd, extra="pelicula"))
+    itemlist.append(item.clone(title="[COLOR springgreen]      Incluyen Hdrip[/COLOR]", action="listado",
+                               url=host + "rezolucia/hdrip/", thumbnail=thumb_pelis, extra="pelicula"))
+    itemlist.append(item.clone(title="[COLOR springgreen]      Incluyen 3D[/COLOR]", action="listado",
+                               url=host + "rezolucia/3d/", thumbnail=thumb_pelis_hd, extra="pelicula"))
+    itemlist.append(item.clone(title="[COLOR floralwhite][B]Buscar[/B][/COLOR]", action="search", thumbnail=thumb_buscar,
+                                       extra="titulo"))
+    itemlist.append(item.clone(title="[COLOR oldlace]         Por Título[/COLOR]", action="search", thumbnail=thumb_buscar,
+                                       extra="titulo"))
+    itemlist.append(item.clone(title="[COLOR oldlace]         Por Año[/COLOR]", action="search", thumbnail=thumb_buscar,
+                                       extra="año"))
+    itemlist.append(item.clone(title="[COLOR oldlace]         Por Rating Imdb[/COLOR]", action="search", thumbnail=thumb_buscar,
+                                       extra="rating"))
+
+    return itemlist
+    
+
+def listado(item):
+    logger.info()
+    itemlist = []
+
+    # Descarga la página
+    data = ''
+    try:
+        data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.url).data)
+    except:
+        pass
+    
+    if not data:        #Si la web está caída salimos sin dar error
+        logger.error("ERROR 01: LISTADO: La Web no responde o ha cambiado de URL: " + item.url + " / DATA: " + data)
+        itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 01: LISTADO:.  La Web no responde o ha cambiado de URL. Si la Web está activa, reportar el error con el log'))
+        return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
+    
+    patron = '<div class="browse-movie-wrap col-xs-10 col-sm-4 col-md-5 col-lg-4"><a href="([^"]+)".*?src="([^"]+)".*?alt="([^"]+)".*?rel="tag">([^"]+)<\/a>\s?<\/div><div class="[^"]+">(.*?)<\/div><\/div><\/div>'
+    #data = scrapertools.find_single_match(data, patron)
+    matches = re.compile(patron, re.DOTALL).findall(data)
+    if not matches and not '<ul class="tsc_pagination tsc_pagination' in data:               #error
+        item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+        if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+            item, itemlist = generictools.post_tmdb_episodios(item, itemlist)   #Llamamos al método para el pintado del error
+            return itemlist                                                     #Salimos
+        
+        logger.error("ERROR 02: LISTADO: Ha cambiado la estructura de la Web " + " / PATRON: " + patron + " / DATA: " + data)
+        itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 02: LISTADO: Ha cambiado la estructura de la Web.  Reportar el error con el log'))
+        return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
+    
+    #logger.debug("PATRON: " + patron)
+    #logger.debug(matches)
+    #logger.debug(data)
+
+    for scrapedurl, scrapedthumbnail, scrapedtitle, scrapedyear, scrapedqualities in matches:
+        item_local = item.clone()           #Creamos copia de Item para trabajar
+        title_subs = []
+        
+        title = re.sub('\r\n', '', scrapedtitle).decode('utf8').strip()
+        item_local.url = scrapedurl
+        item_local.thumbnail = scrapedthumbnail
+        
+        scrapedtorrent = ''
+        if scrapedqualities:
+            patron_quality = '<a href="([^"]+)"\s?rel="[^"]+"\s?title="[^"]+">(.*?)<\/a>'
+            matches_quality = re.compile(patron_quality, re.DOTALL).findall(scrapedqualities)
+            quality = ''
+
+            for scrapedtorrent, scrapedquality in matches_quality:
+                quality_inter = scrapedquality
+                quality_inter = re.sub('HDr$', 'HDrip', quality_inter)
+                quality_inter = re.sub('720$', '720p', quality_inter)
+                quality_inter = re.sub('1080$', '1080p', quality_inter)
+                if quality:
+                    quality += ', %s' % quality_inter
+                else:
+                    quality = quality_inter
+            if quality:
+                item_local.quality = quality
+
+        item_local.language = []            #Verificamos el idioma por si encontramos algo
+        if "latino" in scrapedtorrent.lower() or "latino" in item.url or "latino" in title.lower():
+            item_local.language += ["LAT"]
+        if "ingles" in scrapedtorrent.lower() or "ingles" in item.url or "vose" in scrapedurl or "vose" in item.url:
+            if "VOSE" in scrapedtorrent.lower() or "sub" in title.lower() or "vose" in scrapedurl or "vose" in item.url:
+                item_local.language += ["VOS"]
+            else:
+                item_local.language += ["VO"]
+        if "dual" in scrapedtorrent.lower() or "dual" in title.lower():
+            item_local.language[0:0] = ["DUAL"]
+        
+        #Limpiamos el título de la basura innecesaria
+        title = title.replace("Dual", "").replace("dual", "").replace("Subtitulada", "").replace("subtitulada", "").replace("Subt", "").replace("subt", "").replace("Sub", "").replace("sub", "").replace("(Proper)", "").replace("(proper)", "").replace("Proper", "").replace("proper", "").replace("#", "").replace("(Latino)", "").replace("Latino", "")
+        title = title.replace("- HDRip", "").replace("(HDRip)", "").replace("- Hdrip", "").replace("(microHD)", "").replace("(DVDRip)", "").replace("(HDRip)", "").replace("(BR-LINE)", "").replace("(HDTS-SCREENER)", "").replace("(BDRip)", "").replace("(BR-Screener)", "").replace("(DVDScreener)", "").replace("TS-Screener", "").replace(" TS", "").replace(" Ts", "")
+        title = re.sub(r'\??\s?\d*?\&.*', '', title).title().strip()
+
+        item_local.contentType = "movie"
+        item_local.contentTitle = title
+        item_local.extra = "peliculas"
+        item_local.action = "findvideos"
+        item_local.title = title.strip()
+        item_local.infoLabels['year'] = "-"
+        
+        if scrapedyear >= "1900" and scrapedyear <= "2040":
+            title_subs += [scrapedyear]
+
+        itemlist.append(item_local.clone())     #Pintar pantalla
+   
+    if not item.category:       #Si este campo no existe es que viene de la primera pasada de una búsqueda global
+        return itemlist         #Retornamos sin pasar por la fase de maquillaje para ahorra tiempo
+
+    #Pasamos a TMDB la lista completa Itemlist
+    tmdb.set_infoLabels(itemlist, True)
+    
+    #Llamamos al método para el maquillaje de los títulos obtenidos desde TMDB
+    item, itemlist = generictools.post_tmdb_listado(item, itemlist)
+    
+    # Extrae el paginador
+    patron = '<li><a href="[^"]+">(\d+)<\/a><\/li>'         #total de páginas
+    patron += '<li><a href="([^"]+\/page\/(\d+)\/)"\s?rel="[^"]+">Página siguiente[^<]+<\/a><\/li><\/ul><\/div><\/ul>' #url siguiente
+    url_next = ''
+    if scrapertools.find_single_match(data, patron):
+        last_page, url_next, next_num = scrapertools.find_single_match(data, patron)
+
+    if url_next:
+        if last_page:
+            title = '[COLOR gold]Página siguiente >>[/COLOR] %s de %s' % (int(next_num) - 1, last_page)
+        else:
+            title = '[COLOR gold]Página siguiente >>[/COLOR] %s' % (int(next_num) - 1)
+        
+        itemlist.append(Item(channel=item.channel, action="listado", title=title, url=url_next, extra=item.extra))
+
+    return itemlist
+
+    
+def findvideos(item):
+    logger.info()
+    itemlist = []
+
+    #Bajamos los datos de la página
+    data = ''
+    try:
+        data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.url).data)
+    except:
+        pass
+        
+    if not data:
+        logger.error("ERROR 01: FINDVIDEOS: La Web no responde o la URL es erronea: " + item.url + " / DATA: " + data)
+        itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 01: FINDVIDEOS:.  La Web no responde o la URL es erronea. Si la Web está activa, reportar el error con el log'))
+        return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
+
+    patron = 'id="modal-quality-\w+"><span>(.*?)</span>.*?class="quality-size">(.*?)</p>.*?href="([^"]+)"'      #coge los .torrent
+    matches = re.compile(patron, re.DOTALL).findall(data)
+    if not matches:                    #error
+        logger.error("ERROR 02: FINDVIDEOS: El archivo Torrent no existe o ha cambiado la estructura de la Web " + " / PATRON: " + patron + " / DATA: " + data)
+        itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 02: FINDVIDEOS: El archivo Torrent no existe o ha cambiado la estructura de la Web.  Verificar en la Web y reportar el error con el log'))
+        return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
+    
+    #Llamamos al método para crear el título general del vídeo, con toda la información obtenida de TMDB
+    item, itemlist = generictools.post_tmdb_findvideos(item, itemlist)    
+    
+    #logger.debug("PATRON: " + patron)
+    #logger.debug(matches)
+    
+    for scrapedquality, scrapedsize, scrapedtorrent in matches:                             #leemos los torrents con la diferentes calidades
+        #Generamos una copia de Item para trabajar sobre ella
+        item_local = item.clone()
+        
+        item_local.quality = scrapedquality
+        if item.infoLabels['duration']:
+            item_local.quality += scrapertools.find_single_match(item.quality, '(\s\[.*?\])')   #Copiamos la duración
+        
+        #Añadimos el tamaño para todos
+        item_local.quality = '%s [%s]' % (item_local.quality, scrapedsize)                  #Agregamos size al final de calidad
+        item_local.quality = item_local.quality.replace("G", "G ").replace("M", "M ")       #Se evita la palabra reservada en Unify
+
+        #Ahora pintamos el link del Torrent
+        item_local.url = scrapedtorrent
+        item_local.title = '[COLOR yellow][?][/COLOR] [COLOR yellow][Torrent][/COLOR] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (item_local.quality, str(item_local.language))                    #Preparamos título de Torrent
+        item_local.title = re.sub(r'\s\[COLOR \w+\]\[\[?\]?\]\[\/COLOR\]', '', item_local.title)    #Quitamos etiquetas vacías
+        item_local.title = re.sub(r'\s\[COLOR \w+\]\[\/COLOR\]', '', item_local.title)      #Quitamos colores vacíos
+        item_local.alive = "??"                                                             #Calidad del link sin verificar
+        item_local.action = "play"                                                          #Visualizar vídeo
+        item_local.server = "torrent"                                                       #Seridor Torrent
+        
+        itemlist.append(item_local.clone())     #Pintar pantalla
+
+        #logger.debug("TORRENT: " + scrapedtorrent + " / title gen/torr: " + item.title + " / " + item_local.title + " / calidad: " + item_local.quality + " / tamaño: " + scrapedsize + " / content: " + item_local.contentTitle + " / " + item_local.contentSerieName)
+        #logger.debug(item_local)
+        
+    #Ahora tratamos el servidor directo
+    item_local = item.clone()
+    servidor = 'openload'
+    enlace = scrapertools.find_single_match(data, 'button-green-download-big".*?href="([^"]+)"><span class="icon-play">')
+    if enlace:
+        try:
+            devuelve = servertools.findvideosbyserver(enlace, servidor)                             #existe el link ?
+            if devuelve:
+                enlace = devuelve[0][1]                                                             #Se guarda el link
+                item_local.alive = "??"                                                             #Se asume poe defecto que es link es dudoso
+                
+                #Llama a la subfunción de check_list_links(itemlist) para cada link de servidor
+                item_local.alive = servertools.check_video_link(enlace, servidor, timeout=5)        #activo el link ?
+                
+                #Si el link no está activo se ignora
+                if item_local.alive == "??":                #dudoso
+                    item_local.title = '[COLOR yellow][?][/COLOR] [COLOR yellow][%s][/COLOR] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (servidor.capitalize(), item_local.quality, str(item_local.language))
+                elif item_local.alive.lower() == "no":      #No está activo.  Lo preparo, pero no lo pinto
+                    item_local.title = '[COLOR red][%s][/COLOR] [COLOR yellow][%s][/COLOR] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (item_local.alive, servidor.capitalize(), item_local.quality, str(item_local.language))
+                    logger.debug(item_local.alive + ": ALIVE / " + title + " / " + servidor + " / " + enlace)
+                    raise
+                else:               #Sí está activo
+                    item_local.title = '[COLOR yellow][%s][/COLOR] [COLOR limegreen][%s][/COLOR] [COLOR red]%s[/COLOR]' % (servidor.capitalize(), item_local.quality, str(item_local.language))
+                    
+                #Preparamos el resto de variables de Item para ver los vídeos en directo    
+                item_local.action = "play"
+                item_local.server = servidor
+                item_local.url = enlace
+                item_local.title = item_local.title.replace("[]", "").strip()
+                item_local.title = re.sub(r'\s\[COLOR \w+\]\[\[?\]?\]\[\/COLOR\]', '', item_local.title).strip()
+                item_local.title = re.sub(r'\s\[COLOR \w+\]\[\/COLOR\]', '', item_local.title).strip()
+                itemlist.append(item_local.clone())
+                
+                #logger.debug(item_local)
+                    
+        except:
+            pass
 
     return itemlist
 
@@ -96,305 +264,17 @@ def search(item, texto):
     logger.info()
     texto = texto.replace(" ", "+")
     if item.extra == "titulo":
-        item.url = "http://alltorrent.net/?s=" + texto
+        item.url = host + "?s=" + texto
 
     elif item.extra == "año":
-        item.url = "http://alltorrent.net/weli/" + texto
+        item.url = host + "weli/" + texto + "/"
     else:
-        item.url = "http://alltorrent.net/imdb/" + texto
+        item.extra == "imdb"
+        item.url = host + "imdb/" + texto + "/"
     if texto != '':
-        return scraper(item)
-
-
-def scraper(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|\s{2}|&nbsp;", "", data)
-    patron = scrapertools.find_multiple_matches(data,
-                                                '<div class="browse-movie-wrap col-xs-10 col-sm-4 col-md-5 col-lg-4"><a href="([^"]+)".*?src="([^"]+)".*?alt="([^"]+)".*?rel="tag">([^"]+)</a> ')
-
-    for url, thumb, title, year in patron:
-        title = re.sub(r"\(\d+\)", "", title)
-
-        title = ''.join((c for c in unicodedata.normalize('NFD', unicode(title.decode('utf-8'))) if
-                         unicodedata.category(c) != 'Mn')).encode("ascii", "ignore")
-        titulo = "[COLOR lime]" + title + "[/COLOR]"
-        title = re.sub(r"!|\/.*", "", title).strip()
-
-        new_item = item.clone(action="findvideos", title=titulo, url=url, thumbnail=thumb, fulltitle=title,
-                              contentTitle=title, contentType="movie", library=True)
-        new_item.infoLabels['year'] = year
-        itemlist.append(new_item)
-
-    ## Paginación
-    next = scrapertools.find_single_match(data, '<li><a href="([^"]+)" rel="nofollow">Next Page')
-    if len(next) > 0:
-        url = next
-
-        itemlist.append(item.clone(title="[COLOR olivedrab][B]Siguiente >>[/B][/COLOR]", action="scraper", url=url,
-                                   thumbnail="http://imgur.com/TExhOJE.png"))
-
-    try:
-        from core import tmdb
-        tmdb.set_infoLabels_itemlist(itemlist, __modo_grafico__)
-        for item in itemlist:
-            if not "Siguiente >>" in item.title:
-                if "0." in str(item.infoLabels['rating']):
-                    item.infoLabels['rating'] = "[COLOR olive]Sin puntuación[/COLOR]"
-                else:
-                    item.infoLabels['rating'] = "[COLOR yellow]" + str(item.infoLabels['rating']) + "[/COLOR]"
-                item.title = item.title + "  " + str(item.infoLabels['rating'])
-    except:
-        pass
-
-    for item_tmdb in itemlist:
-        logger.info(str(item_tmdb.infoLabels['tmdb_id']))
-
-    return itemlist
-
-
-def findvideos(item):
-    logger.info()
-    itemlist = []
-    th = Thread(target=get_art(item))
-    th.setDaemon(True)
-    th.start()
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|\s{2}|&nbsp;", "", data)
-    enlaces = scrapertools.find_multiple_matches(data,
-                                                 'id="modal-quality-\w+"><span>(.*?)</span>.*?class="quality-size">(.*?)</p>.*?href="([^"]+)"')
-    for calidad, size, url in enlaces:
-        title = "[COLOR palegreen][B]Torrent[/B][/COLOR]" + " " + "[COLOR chartreuse]" + calidad + "[/COLOR]" + "[COLOR teal] ( [/COLOR]" + "[COLOR forestgreen]" + size + "[/COLOR]" + "[COLOR teal] )[/COLOR]"
-        itemlist.append(
-            Item(channel=item.channel, title=title, url=url, action="play", server="torrent", fanart=item.fanart,
-                 thumbnail=item.thumbnail, extra=item.extra, InfoLabels=item.infoLabels, folder=False))
-    dd = scrapertools.find_single_match(data, 'button-green-download-big".*?href="([^"]+)"><span class="icon-play">')
-    if dd:
-        if item.library:
-            itemlist.append(
-                Item(channel=item.channel, title="[COLOR floralwhite][B]Online[/B][/COLOR]", url=dd, action="dd_y_o",
-                     thumbnail="http://imgur.com/mRmBIV4.png", fanart=item.extra.split("|")[0],
-                     contentType=item.contentType, extra=item.extra, folder=True))
-        else:
-            videolist = servertools.find_video_items(data=str(dd))
-            for video in videolist:
-                icon_server = os.path.join(config.get_runtime_path(), "resources", "images", "servers",
-                                           "server_" + video.server + ".png")
-                if not os.path.exists(icon_server):
-                    icon_server = ""
-                itemlist.append(Item(channel=item.channel, url=video.url, server=video.server,
-                                     title="[COLOR floralwhite][B]" + video.server + "[/B][/COLOR]",
-                                     thumbnail=icon_server, fanart=item.extra.split("|")[1], action="play",
-                                     folder=False))
-    if item.library and config.get_videolibrary_support() and itemlist:
-        infoLabels = {'tmdb_id': item.infoLabels['tmdb_id'],
-                      'title': item.infoLabels['title']}
-        itemlist.append(Item(channel=item.channel, title="Añadir esta película a la videoteca",
-                             action="add_pelicula_to_library", url=item.url, infoLabels=infoLabels,
-                             text_color="0xFFe5ffcc",
-                             thumbnail='http://imgur.com/DNCBjUB.png', extra="library"))
-
-    return itemlist
-
-
-def dd_y_o(item):
-    itemlist = []
-    logger.info()
-    videolist = servertools.find_video_items(data=item.url)
-    for video in videolist:
-        icon_server = os.path.join(config.get_runtime_path(), "resources", "images", "servers",
-                                   "server_" + video.server + ".png")
-        if not os.path.exists(icon_server):
-            icon_server = ""
-        itemlist.append(Item(channel=item.channel, url=video.url, server=video.server,
-                             title="[COLOR floralwhite][B]" + video.server + "[/B][/COLOR]", thumbnail=icon_server,
-                             fanart=item.extra.split("|")[1], action="play", folder=False))
-    return itemlist
-
-
-def fanartv(item, id_tvdb, id, images={}):
-    headers = [['Content-Type', 'application/json']]
-    from core import jsontools
-    if item.contentType == "movie":
-        url = "http://webservice.fanart.tv/v3/movies/%s?api_key=cab16e262d72fea6a6843d679aa10300" \
-              % id
-    else:
-        url = "http://webservice.fanart.tv/v3/tv/%s?api_key=cab16e262d72fea6a6843d679aa10300" % id_tvdb
-    try:
-        data = jsontools.load(scrapertools.downloadpage(url, headers=headers))
-        if data and not "error message" in data:
-            for key, value in data.items():
-                if key not in ["name", "tmdb_id", "imdb_id", "thetvdb_id"]:
-                    images[key] = value
-        else:
-            images = []
-
-    except:
-        images = []
-    return images
-
-
-def get_art(item):
-    logger.info()
-    id = item.infoLabels['tmdb_id']
-    check_fanart = item.infoLabels['fanart']
-    if item.contentType != "movie":
-        tipo_ps = "tv"
-    else:
-        tipo_ps = "movie"
-    if not id:
-        year = item.extra
-        otmdb = tmdb.Tmdb(texto_buscado=item.fulltitle, year=year, tipo=tipo_ps)
-        id = otmdb.result.get("id")
-
-        if id == None:
-            otmdb = tmdb.Tmdb(texto_buscado=item.fulltitle, tipo=tipo_ps)
-            id = otmdb.result.get("id")
-            if id == None:
-                if item.contentType == "movie":
-                    urlbing_imdb = "http://www.bing.com/search?q=%s+%s+tv+series+site:imdb.com" % (
-                        item.fulltitle.replace(' ', '+'), year)
-                    data = browser(urlbing_imdb)
-                    data = re.sub(r"\n|\r|\t|\s{2}|&nbsp;|http://ssl-proxy.my-addr.org/myaddrproxy.php/", "", data)
-                    subdata_imdb = scrapertools.find_single_match(data,
-                                                                  '<li class="b_algo">(.*?)h="ID.*?<strong>.*?TV Series')
-                else:
-                    urlbing_imdb = "http://www.bing.com/search?q=%s+%s+site:imdb.com" % (
-                        item.fulltitle.replace(' ', '+'), year)
-                    data = browser(urlbing_imdb)
-                    data = re.sub(r"\n|\r|\t|\s{2}|&nbsp;|http://ssl-proxy.my-addr.org/myaddrproxy.php/", "", data)
-                    subdata_imdb = scrapertools.find_single_match(data, '<li class="b_algo">(.*?)h="ID.*?<strong>')
-                try:
-                    imdb_id = scrapertools.get_match(subdata_imdb, '<a href=.*?http.*?imdb.com/title/(.*?)/.*?"')
-                except:
-                    try:
-                        imdb_id = scrapertools.get_match(subdata_imdb,
-                                                         '<a href=.*?http.*?imdb.com/.*?/title/(.*?)/.*?"')
-                    except:
-                        imdb_id = ""
-                otmdb = tmdb.Tmdb(external_id=imdb_id, external_source="imdb_id", tipo=tipo_ps, idioma_busqueda="es")
-                id = otmdb.result.get("id")
-
-                if id == None:
-                    if "(" in item.fulltitle:
-                        title = scrapertools.find_single_match(item.fulltitle, '\(.*?\)')
-                        if item.contentType != "movie":
-                            urlbing_imdb = "http://www.bing.com/search?q=%s+%s+tv+series+site:imdb.com" % (
-                                title.replace(' ', '+'), year)
-                            data = browser(urlbing_imdb)
-                            data = re.sub(r"\n|\r|\t|\s{2}|&nbsp;|http://ssl-proxy.my-addr.org/myaddrproxy.php/", "",
-                                          data)
-                            subdata_imdb = scrapertools.find_single_match(data,
-                                                                          '<li class="b_algo">(.*?)h="ID.*?<strong>.*?TV Series')
-                        else:
-                            urlbing_imdb = "http://www.bing.com/search?q=%s+%s+site:imdb.com" % (
-                                title.replace(' ', '+'), year)
-                            data = browser(urlbing_imdb)
-                            data = re.sub(r"\n|\r|\t|\s{2}|&nbsp;|http://ssl-proxy.my-addr.org/myaddrproxy.php/", "",
-                                          data)
-                            subdata_imdb = scrapertools.find_single_match(data,
-                                                                          '<li class="b_algo">(.*?)h="ID.*?<strong>')
-                        try:
-                            imdb_id = scrapertools.get_match(subdata_imdb,
-                                                             '<a href=.*?http.*?imdb.com/title/(.*?)/.*?"')
-                        except:
-                            try:
-                                imdb_id = scrapertools.get_match(subdata_imdb,
-                                                                 '<a href=.*?http.*?imdb.com/.*?/title/(.*?)/.*?"')
-                            except:
-                                imdb_id = ""
-                        otmdb = tmdb.Tmdb(external_id=imdb_id, external_source="imdb_id", tipo=tipo_ps,
-                                          idioma_busqueda="es")
-                        id = otmdb.result.get("id")
-
-                        if not id:
-                            fanart = item.fanart
-
-    id_tvdb = ""
-    imagenes = []
-    itmdb = tmdb.Tmdb(id_Tmdb=id, tipo=tipo_ps)
-    images = itmdb.result.get("images")
-    if images:
-        for key, value in images.iteritems():
-            for detail in value:
-                imagenes.append('http://image.tmdb.org/t/p/original' + detail["file_path"])
-
-        if len(imagenes) >= 4:
-            if imagenes[0] != check_fanart:
-                item.fanart = imagenes[0]
-            else:
-                item.fanart = imagenes[1]
-            if imagenes[1] != check_fanart and imagenes[1] != item.fanart and imagenes[2] != check_fanart:
-                item.extra = imagenes[1] + "|" + imagenes[2]
-
-            else:
-                if imagenes[1] != check_fanart and imagenes[1] != item.fanart:
-                    item.extra = imagenes[1] + "|" + imagenes[3]
-                elif imagenes[2] != check_fanart:
-                    item.extra = imagenes[2] + "|" + imagenes[3]
-                else:
-                    item.extra = imagenes[3] + "|" + imagenes[3]
-        elif len(imagenes) == 3:
-            if imagenes[0] != check_fanart:
-                item.fanart = imagenes[0]
-            else:
-                item.fanart = imagenes[1]
-
-            if imagenes[1] != check_fanart and imagenes[1] != item.fanart and imagenes[2] != check_fanart:
-                item.extra = imagenes[1] + "|" + imagenes[2]
-
-            else:
-                if imagenes[1] != check_fanart and imagenes[1] != item.fanart:
-                    item.extra = imagenes[0] + "|" + imagenes[1]
-                elif imagenes[2] != check_fanart:
-                    item.extra = imagenes[1] + "|" + imagenes[2]
-                else:
-                    item.extra = imagenes[1] + "|" + imagenes[1]
-        elif len(imagenes) == 2:
-            if imagenes[0] != check_fanart:
-                item.fanart = imagenes[0]
-            else:
-                item.fanart = imagenes[1]
-            if imagenes[1] != check_fanart and imagenes[1] != item.fanart:
-                item.extra = imagenes[0] + "|" + imagenes[1]
-            else:
-                item.extra = imagenes[1] + "|" + imagenes[0]
-        elif len(imagenes) == 1:
-            item.extra = imagenes + "|" + imagenes
-        else:
-            item.extra = item.fanart + "|" + item.fanart
-
-    images_fanarttv = fanartv(item, id_tvdb, id)
-    if images_fanarttv:
-        if item.contentType == "movie":
-            if images_fanarttv.get("moviedisc"):
-                item.thumbnail = images_fanarttv.get("moviedisc")[0].get("url")
-            elif images_fanarttv.get("hdmovielogo"):
-                item.thumbnail = images_fanarttv.get("hdmovielogo")[0].get("url")
-            elif images_fanarttv.get("moviethumb"):
-                item.thumbnail = images_fanarttv.get("moviethumb")[0].get("url")
-            elif images_fanarttv.get("moviebanner"):
-                item.thumbnail_ = images_fanarttv.get("moviebanner")[0].get("url")
-            else:
-                item.thumbnail = item.thumbnail
-        else:
-            if images_fanarttv.get("hdtvlogo"):
-                item.thumbnail = images_fanarttv.get("hdtvlogo")[0].get("url")
-            elif images_fanarttv.get("clearlogo"):
-                item.thumbnail = images_fanarttv.get("hdmovielogo")[0].get("url")
-
-            if images_fanarttv.get("tvbanner"):
-                item.extra = item.extra + "|" + images_fanarttv.get("tvbanner")[0].get("url")
-            elif images_fanarttv.get("tvthumb"):
-                item.extra = item.extra + "|" + images_fanarttv.get("tvthumb")[0].get("url")
-            else:
-                item.extra = item.extra + "|" + item.thumbnail
-    else:
-        item.extra = item.extra + "|" + item.thumbnail
-
-
+        return listado(item)
+ 
+ 
 def newest(categoria):
     logger.info()
     itemlist = []
@@ -402,11 +282,11 @@ def newest(categoria):
     try:
         if categoria == 'torrent':
             item.url = host
+            item.extra = "peliculas"
 
-        itemlist = scraper(item)
-
-        if itemlist[-1].action == "[COLOR olivedrab][B]Siguiente >>[/B][/COLOR]":
-            itemlist.pop()
+            itemlist = listado(item)
+            if itemlist[-1].title == "Página siguiente >>":
+                itemlist.pop()
 
     # Se captura la excepción, para no interrumpir al canal novedades si un canal falla
     except:
diff --git a/plugin.video.alfa/channels/bajui.json b/plugin.video.alfa/channels/bajui.json
deleted file mode 100644
index 98d9be1f..00000000
--- a/plugin.video.alfa/channels/bajui.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "id": "bajui",
-  "name": "Bajui",
-  "active": false,
-  "adult": false,
-  "language": ["cast"],
-  "thumbnail": "bajui.png",
-  "banner": "bajui.png",
-  "fanart": "bajui.png",
-  "categories": [
-    "movie",
-    "tvshow",
-    "documentary",
-    "vos"
-  ],
-  "settings": [
-    {
-      "id": "include_in_global_search",
-      "type": "bool",
-      "label": "Incluir en busqueda global",
-      "default": false,
-      "enabled": true,
-      "visible": true
-    }
-  ]
-}
diff --git a/plugin.video.alfa/channels/bajui.py b/plugin.video.alfa/channels/bajui.py
deleted file mode 100644
index fde86422..00000000
--- a/plugin.video.alfa/channels/bajui.py
+++ /dev/null
@@ -1,247 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import re
-import urlparse
-
-from core import httptools
-from core import scrapertools
-from core import servertools
-from core.item import Item
-from platformcode import logger
-from channelselector import get_thumb
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    itemlist.append(Item(channel=item.channel, title="Películas", action="menupeliculas",
-                         url="http://www.bajui.org/descargas/categoria/2/peliculas",
-                         fanart=item.fanart, thumbnail=get_thumb('movies', auto=True)))
-    itemlist.append(Item(channel=item.channel, title="Series", action="menuseries",
-                         fanart=item.fanart, thumbnail=get_thumb('tvshows', auto=True)))
-    itemlist.append(Item(channel=item.channel, title="Documentales", action="menudocumentales",
-                         fanart=item.fanart, thumbnail=get_thumb('documentaries', auto=True)))
-    itemlist.append(Item(channel=item.channel, title="Buscar", action="search",
-                         fanart=item.fanart, thumbnail=get_thumb('search', auto=True)))
-    return itemlist
-
-
-def menupeliculas(item):
-    logger.info()
-    itemlist = []
-    itemlist.append(Item(channel=item.channel, title="Películas - Novedades", action="peliculas", url=item.url,
-                         fanart=item.fanart, viewmode="movie_with_plot"))
-    itemlist.append(
-        Item(channel=item.channel, title="Películas - A-Z", action="peliculas", url=item.url + "/orden:nombre",
-             fanart=item.fanart, viewmode="movie_with_plot"))
-
-    data = httptools.downloadpage(item.url).data
-    data = scrapertools.get_match(data, '<ul class="submenu2 subcategorias">(.*?)</ul>')
-    patron = '<a href="([^"]+)">([^<]+)</a>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-    for url, title in matches:
-        scrapedurl = urlparse.urljoin(item.url, url)
-        itemlist.append(Item(channel=item.channel, title="Películas en " + title, action="peliculas", url=scrapedurl,
-                             fanart=item.fanart, viewmode="movie_with_plot"))
-
-    itemlist.append(Item(channel=item.channel, title="Buscar", action="search", url="", fanart=item.fanart))
-    return itemlist
-
-
-def menuseries(item):
-    logger.info()
-    itemlist = []
-    itemlist.append(Item(channel=item.channel, title="Series - Novedades", action="peliculas",
-                         url="http://www.bajui.org/descargas/categoria/3/series",
-                         fanart=item.fanart, viewmode="movie_with_plot"))
-    itemlist.append(Item(channel=item.channel, title="Series - A-Z", action="peliculas",
-                         url="http://www.bajui.org/descargas/categoria/3/series/orden:nombre",
-                         fanart=item.fanart, viewmode="movie_with_plot"))
-    itemlist.append(Item(channel=item.channel, title="Series - HD", action="peliculas",
-                         url="http://www.bajui.org/descargas/subcategoria/11/hd/orden:nombre",
-                         fanart=item.fanart, viewmode="movie_with_plot"))
-    itemlist.append(Item(channel=item.channel, title="Buscar", action="search", url="",
-                         fanart=item.fanart))
-    return itemlist
-
-
-def menudocumentales(item):
-    logger.info()
-    itemlist = []
-    itemlist.append(Item(channel=item.channel, title="Documentales - Novedades", action="peliculas",
-                         url="http://www.bajui.org/descargas/categoria/7/docus-y-tv",
-                         fanart=item.fanart, viewmode="movie_with_plot"))
-    itemlist.append(Item(channel=item.channel, title="Documentales - A-Z", action="peliculas",
-                         url="http://www.bajui.org/descargas/categoria/7/docus-y-tv/orden:nombre",
-                         fanart=item.fanart, viewmode="movie_with_plot"))
-    itemlist.append(Item(channel=item.channel, title="Buscar", action="search", url="",
-                         fanart=item.fanart))
-    return itemlist
-
-
-def search(item, texto, categoria=""):
-    logger.info(item.url + " search " + texto)
-    itemlist = []
-    url = item.url
-    texto = texto.replace(" ", "+")
-    logger.info("categoria: " + categoria + " url: " + url)
-    try:
-        item.url = "http://www.bajui.org/descargas/busqueda/%s"
-        item.url = item.url % texto
-        itemlist.extend(peliculas(item))
-        return itemlist
-    # Se captura la excepción, para no interrumpir al buscador global si un canal falla
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def peliculas(item, paginacion=True):
-    logger.info()
-    url = item.url
-    data = httptools.downloadpage(url).data
-    patron = '<li id="ficha-\d+" class="ficha2[^<]+'
-    patron += '<div class="detalles-ficha"[^<]+'
-    patron += '<span class="nombre-det">Ficha\: ([^<]+)</span>[^<]+'
-    patron += '<span class="categoria-det">[^<]+</span>[^<]+'
-    patron += '<span class="descrip-det">(.*?)</span>[^<]+'
-    patron += '</div>.*?<a href="([^"]+)"[^<]+'
-    patron += '<img src="([^"]+)"'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-    itemlist = []
-
-    for title, plot, url, thumbnail in matches:
-        scrapedtitle = title
-        scrapedplot = clean_plot(plot)
-        scrapedurl = urlparse.urljoin(item.url, url)
-        scrapedthumbnail = urlparse.urljoin("http://bajui.org/", thumbnail.replace("_m.jpg", "_g.jpg"))
-        itemlist.append(
-            Item(channel=item.channel, action="enlaces", title=scrapedtitle, fulltitle=title, url=scrapedurl,
-                 thumbnail=scrapedthumbnail, plot=scrapedplot, extra=scrapedtitle, context="4|5",
-                 fanart=item.fanart, viewmode="movie_with_plot"))
-    patron = '<a href="([^"]+)" class="pagina pag_sig">Siguiente \&raquo\;</a>'
-    matches = re.compile(patron, re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-
-    if len(matches) > 0:
-        scrapedurl = urlparse.urljoin("http://www.bajui.org/", matches[0])
-        pagitem = Item(channel=item.channel, action="peliculas", title=">> Página siguiente", url=scrapedurl,
-                       fanart=item.fanart, viewmode="movie_with_plot")
-        if not paginacion:
-            itemlist.extend(peliculas(pagitem))
-        else:
-            itemlist.append(pagitem)
-
-    return itemlist
-
-
-def clean_plot(scrapedplot):
-    scrapedplot = scrapedplot.replace("\n", "").replace("\r", "")
-    scrapedplot = re.compile("TÍTULO ORIGINAL[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("AÑO[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Año[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("DURACIÓN[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Duración[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("PAIS[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("PAÍS[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Pais[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("País[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("DIRECTOR[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("DIRECCIÓN[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Dirección[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("REPARTO[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Reparto[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Interpretación[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("GUIÓN[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Guión[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("MÚSICA[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Música[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("FOTOGRAFÍA[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Fotografía[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("PRODUCTORA[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Producción[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Montaje[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Vestuario[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("GÉNERO[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("GENERO[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Genero[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Género[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("PREMIOS[^<]+<br />", re.DOTALL).sub("", scrapedplot)
-
-    scrapedplot = re.compile("SINOPSIS", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = re.compile("Sinopsis", re.DOTALL).sub("", scrapedplot)
-    scrapedplot = scrapertools.htmlclean(scrapedplot)
-    return scrapedplot
-
-
-def enlaces(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-
-    try:
-        item.plot = scrapertools.get_match(data, '<span class="ficha-descrip">(.*?)</span>')
-        item.plot = clean_plot(item.plot)
-    except:
-        pass
-
-    try:
-        item.thumbnail = scrapertools.get_match(data, '<div class="ficha-imagen"[^<]+<img src="([^"]+)"')
-        item.thumbnail = urlparse.urljoin("http://www.bajui.org/", item.thumbnail)
-    except:
-        pass
-
-    patron = '<div class="box-enlace-cabecera"[^<]+'
-    patron += '<div class="datos-usuario"><img class="avatar" src="([^"]+)" />Enlaces[^<]+'
-    patron += '<a class="nombre-usuario" href="[^"]+">([^<]+)</a[^<]+</div>[^<]+'
-    patron += '<div class="datos-act">Actualizado. ([^<]+)</div>.*?'
-    patron += '<div class="datos-boton-mostrar"><a id="boton-mostrar-\d+" class="boton" href="javascript.mostrar_enlaces\((\d+)\,\'([^\']+)\'[^>]+>Mostrar enlaces</a></div>[^<]+'
-    patron += '<div class="datos-servidores"><div class="datos-servidores-cell">(.*?)</div></div>'
-
-    matches = re.compile(patron, re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-
-    for thumbnail, usuario, fecha, id, id2, servidores in matches:
-        patronservidores = '<img src="[^"]+" title="([^"]+)"'
-        matches2 = re.compile(patronservidores, re.DOTALL).findall(servidores)
-        lista_servidores = ""
-        for servidor in matches2:
-            lista_servidores = lista_servidores + servidor + ", "
-        lista_servidores = lista_servidores[:-2]
-        scrapedthumbnail = item.thumbnail
-        scrapedurl = "http://www.bajui.org/ajax/mostrar-enlaces.php?id=" + id + "&code=" + id2
-        scrapedplot = item.plot
-        scrapedtitle = "Enlaces de " + usuario + " (" + fecha + ") (" + lista_servidores + ")"
-
-        itemlist.append(
-            Item(channel=item.channel, action="findvideos", title=scrapedtitle, fulltitle=item.title, url=scrapedurl,
-                 thumbnail=scrapedthumbnail, plot=scrapedplot, context="4|5",
-                 fanart=item.fanart))
-
-    return itemlist
-
-
-def findvideos(item):
-    logger.info()
-
-    data = httptools.downloadpage(item.url).data
-    itemlist = servertools.find_video_items(data=data)
-    for videoitem in itemlist:
-        videoitem.channel = item.channel
-        videoitem.plot = item.plot
-        videoitem.thumbnail = item.thumbnail
-        videoitem.fulltitle = item.fulltitle
-
-        try:
-            parsed_url = urlparse.urlparse(videoitem.url)
-            fichero = parsed_url.path
-            partes = fichero.split("/")
-            titulo = partes[len(partes) - 1]
-            videoitem.title = titulo + " - [" + videoitem.server + "]"
-        except:
-            videoitem.title = item.title
-
-    return itemlist
diff --git a/plugin.video.alfa/channels/divxtotal.json b/plugin.video.alfa/channels/divxtotal.json
deleted file mode 100755
index 04acc2be..00000000
--- a/plugin.video.alfa/channels/divxtotal.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
-  "id": "divxtotal",
-  "name": "Divxtotal",
-  "active": false,
-  "adult": false,
-  "language": ["cast"],
-  "thumbnail": "http://imgur.com/Madj03A.jpg",
-  "categories": [
-    "torrent",
-    "movie",
-    "tvshow"
-  ],
-  "settings": [
-    {
-      "id": "modo_grafico",
-      "type": "bool",
-      "label": "Buscar información extra",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "include_in_global_search",
-      "type": "bool",
-      "label": "Incluir en busqueda global",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "include_in_newest_torrent",
-      "type": "bool",
-      "label": "Incluir en Novedades - Torrent",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/plugin.video.alfa/channels/divxtotal.py b/plugin.video.alfa/channels/divxtotal.py
deleted file mode 100644
index 62f057e6..00000000
--- a/plugin.video.alfa/channels/divxtotal.py
+++ /dev/null
@@ -1,500 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import os
-import re
-import urllib
-
-from core import httptools
-from core import scrapertools
-from core import tmdb
-from core.item import Item
-from platformcode import config, logger
-from channelselector import get_thumb
-
-header = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:51.0) Gecko/20100101 Firefox/51.0'}
-host = "http://www.divxtotal.co"
-
-__modo_grafico__ = config.get_setting('modo_grafico', "divxtotal")
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    itemlist.append(item.clone(title="[COLOR orange][B]Películas[/B][/COLOR]", action="scraper",
-                               url = host + "/peliculas/", thumbnail=get_thumb('movies', auto=True),
-                               fanart="http://imgur.com/fdntKsy.jpg", contentType="movie"))
-    itemlist.append(item.clone(title="[COLOR orange][B]        Películas HD[/B][/COLOR]", action="scraper",
-                               url = host + "/peliculas-hd/", thumbnail="http://imgur.com/A4zN3OP.png",
-                               fanart="http://imgur.com/fdntKsy.jpg", contentType="movie"))
-    itemlist.append(itemlist[-1].clone(title="[COLOR orange][B]Series[/B][/COLOR]", action="scraper",
-                                       url = host + "/series/", thumbnail=get_thumb('tvshows', auto=True),
-                                       contentType="tvshow"))
-
-    itemlist.append(itemlist[-1].clone(title="[COLOR orangered][B]Buscar[/B][/COLOR]", action="search",
-                                       thumbnail=get_thumb('search', auto=True)))
-    return itemlist
-
-
-def search(item, texto):
-    logger.info()
-    texto = texto.replace(" ", "+")
-    item.url = host + "/?s=" + texto
-    item.extra = "search"
-    try:
-        return buscador(item)
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def buscador(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url, headers=header, cookies=False).data
-    data = re.sub(r"\n|\r|\t|\s{2}|&nbsp;", "", data)
-    patron = '<tr><td class="text-left"><a href="([^"]+)" title="([^"]+)">.*?-left">(.*?)</td>'
-    matches = scrapertools.find_multiple_matches(data, patron)
-    for url, title, check in matches:
-        if "N/A" in check:
-            checkmt = "tvshow"
-        else:
-            checkmt = "movie"
-        titulo = title
-        title = re.sub(r"!|¡|HD|\d+\d+\d+\d+|\(.*?\).*\[.*?]\]", "", title)
-        title = re.sub(r"&#8217;|PRE-Estreno", "'", title)
-        if checkmt == "movie":
-            new_item = item.clone(action="findvideos", title=titulo, url=url, fulltitle=title, contentTitle=title,
-                                  contentType="movie", library=True)
-        else:
-            if item.extra == "search":
-                new_item = item.clone(action="findtemporadas", title=titulo, url=url, fulltitle=title,
-                                      contentTitle=title, show=title, contentType="tvshow", library=True)
-            else:
-                new_item = item.clone(action="findvideos", title=titulo, url=url, fulltitle=title, contentTitle=title,
-                                      show=title, contentType="tvshow", library=True)
-        new_item.infoLabels['year'] = get_year(url)
-        itemlist.append(new_item)
-        ## Paginación
-    next = scrapertools.find_single_match(data, "<ul class=\"pagination\">.*?\(current\).*?href='([^']+)'")
-    if len(next) > 0:
-        url = next
-        itemlist.append(item.clone(title="[COLOR springgreen][B]Siguiente >>[/B][/COLOR]", action="buscador", url=url))
-    try:
-        from core import tmdb
-        tmdb.set_infoLabels_itemlist(itemlist, __modo_grafico__)
-        for item in itemlist:
-            if not "Siguiente >>" in item.title:
-                if "0." in str(item.infoLabels['rating']):
-                    item.infoLabels['rating'] = "[COLOR indianred]Sin puntuacíon[/COLOR]"
-                else:
-                    item.infoLabels['rating'] = "[COLOR springgreen]" + str(item.infoLabels['rating']) + "[/COLOR]"
-                item.title = item.title + "  " + str(item.infoLabels['rating'])
-    except:
-        pass
-    return itemlist
-
-
-def scraper(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url, headers=header, cookies=False).data
-    data = re.sub(r"\n|\r|\t|\s{2}|&nbsp;", "", data)
-    if item.contentType == "movie":
-        patron = '<tr><td><a href="([^"]+)" title="([^"]+)".*?\d+-\d+-([^"]+)</td><td>'
-        matches = scrapertools.find_multiple_matches(data, patron)
-        for url, title, year in matches:
-            titulo = re.sub(r"\d+\d+\d+\d+|\(.*?\).*", "", title)
-            title = re.sub(r"!|¡|HD|\d+\d+\d+\d+|\(.*?\).*", "", title)
-            title = title.replace("Autosia", "Autopsia")
-            title = re.sub(r"&#8217;|PRE-Estreno", "'", title)
-            new_item = item.clone(action="findvideos", title="[COLOR orange]" + titulo + "[/COLOR]", url=url,
-                                  fulltitle=title, contentTitle=title, contentType="movie", extra=year, library=True)
-            new_item.infoLabels['year'] = get_year(url)
-            itemlist.append(new_item)
-    else:
-        patron  = '(?s)<p class="secconimagen"><a href="([^"]+)"'
-        patron += ' title="[^"]+"><img src="([^"]+)".*?'
-        patron += 'rel="bookmark">([^<]+)<'
-        matches = scrapertools.find_multiple_matches(data, patron)
-        for url, thumb, title in matches:
-            titulo = title.strip()
-            title = re.sub(r"\d+x.*|\(.*?\)", "", title)
-            new_item = item.clone(action="findvideos", title="[COLOR orange]" + titulo + "[/COLOR]", url=url,
-                                  thumbnail=thumb,
-                                  fulltitle=title, contentTitle=title, show=title, contentType="tvshow", library=True)
-            new_item.infoLabels['year'] = get_year(url)
-            itemlist.append(new_item)
-    ## Paginación
-    next = scrapertools.find_single_match(data, "<ul class=\"pagination\">.*?\(current\).*?href='([^']+)'")
-    if len(next) > 0:
-        url = next
-
-        itemlist.append(
-            item.clone(title="[COLOR springgreen][B]Siguiente >>[/B][/COLOR]", thumbnail="http://imgur.com/a7lQAld.png",
-                       url=url))
-    try:
-        from core import tmdb
-        tmdb.set_infoLabels_itemlist(itemlist, __modo_grafico__)
-        for item in itemlist:
-            if not "Siguiente >>" in item.title:
-                if "0." in str(item.infoLabels['rating']):
-                    item.infoLabels['rating'] = "[COLOR indianred]Sin puntuacíon[/COLOR]"
-                else:
-                    item.infoLabels['rating'] = "[COLOR springgreen]" + str(item.infoLabels['rating']) + "[/COLOR]"
-                item.title = item.title + "  " + str(item.infoLabels['rating'])
-
-    except:
-        pass
-    return itemlist
-
-
-def findtemporadas(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    data = re.sub(r"\n|\r|\t|\s{2}|&nbsp;", "", data)
-    if len(item.extra.split("|")):
-        if len(item.extra.split("|")) >= 4:
-            fanart = item.extra.split("|")[2]
-            extra = item.extra.split("|")[3]
-            try:
-                fanart_extra = item.extra.split("|")[4]
-            except:
-                fanart_extra = item.extra.split("|")[3]
-            try:
-                fanart_info = item.extra.split("|")[5]
-            except:
-                fanart_extra = item.extra.split("|")[3]
-        elif len(item.extra.split("|")) == 3:
-            fanart = item.extra.split("|")[2]
-            extra = item.extra.split("|")[0]
-            fanart_extra = item.extra.split("|")[0]
-            fanart_info = item.extra.split("|")[1]
-        elif len(item.extra.split("|")) == 2:
-            fanart = item.extra.split("|")[1]
-            extra = item.extra.split("|")[0]
-            fanart_extra = item.extra.split("|")[0]
-            fanart_info = item.extra.split("|")[1]
-    else:
-        extra = item.extra
-        fanart_extra = item.extra
-        fanart_info = item.extra
-    try:
-        logger.info(fanart_extra)
-        logger.info(fanart_info)
-    except:
-        fanart_extra = item.fanart
-        fanart_info = item.fanart
-    bloque_episodios = scrapertools.find_multiple_matches(data, 'Temporada (\d+).*?<\/a>(.*?)<\/table>')
-    for temporada, bloque_epis in bloque_episodios:
-        item.infoLabels = item.InfoLabels
-        item.infoLabels['season'] = temporada
-        itemlist.append(item.clone(action="epis",
-                                   title="[COLOR saddlebrown][B]Temporada [/B][/COLOR]" + "[COLOR sandybrown][B]" + temporada + "[/B][/COLOR]",
-                                   url=bloque_epis, contentType=item.contentType, contentTitle=item.contentTitle,
-                                   show=item.show, extra=item.extra, fanart_extra=fanart_extra, fanart_info=fanart_info,
-                                   datalibrary=data, folder=True))
-    tmdb.set_infoLabels_itemlist(itemlist, __modo_grafico__)
-    for item in itemlist:
-        item.fanart = fanart
-        item.extra = extra
-    if config.get_videolibrary_support() and itemlist:
-        if len(bloque_episodios) == 1:
-            extra = "epis"
-        else:
-            extra = "epis###serie_add"
-
-        infoLabels = {'tmdb_id': item.infoLabels['tmdb_id'], 'tvdb_id': item.infoLabels['tvdb_id'],
-                      'imdb_id': item.infoLabels['imdb_id']}
-        itemlist.append(Item(channel=item.channel, title="Añadir esta serie a la videoteca", text_color="0xFFe5ffcc",
-                             action="add_serie_to_library", extra=extra, url=item.url,
-                             contentSerieName=item.fulltitle, infoLabels=infoLabels,
-                             thumbnail='http://imgur.com/xQNTqqy.png', datalibrary=data))
-    return itemlist
-
-
-def epis(item):
-    logger.info()
-    itemlist = []
-    if item.extra == "serie_add":
-        item.url = item.datalibrary
-    patron = '<td><img src=".*?images\/(.*?)\.png".*?href="([^"]+)" title="">.*?(\d+x\d+).*?td>'
-    matches = scrapertools.find_multiple_matches(item.url, patron)
-    for idioma, url, epi in matches:
-        episodio = scrapertools.find_single_match(epi, '\d+x(\d+)')
-        item.infoLabels['episode'] = episodio
-        itemlist.append(
-            item.clone(title="[COLOR orange]" + epi + "[/COLOR]" + "[COLOR sandybrown] " + idioma + "[/COLOR]", url=url,
-                       action="findvideos", show=item.show, fanart=item.extra, extra=item.extra,
-                       fanart_extra=item.fanart_extra, fanart_info=item.fanart_info, folder=True))
-    if item.extra != "serie_add":
-        tmdb.set_infoLabels_itemlist(itemlist, __modo_grafico__)
-        for item in itemlist:
-            item.fanart = item.extra
-            if item.infoLabels['title']: title = "[COLOR burlywood]" + item.infoLabels['title'] + "[/COLOR]"
-            item.title = item.title + " -- \"" + title + "\""
-    return itemlist
-
-
-def findvideos(item):
-    logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
-    if item.contentType != "movie":
-        if not item.infoLabels['episode']:
-            capitulo = scrapertools.find_single_match(item.title, '(\d+x\d+)')
-            patron = '<a href="(' + host + '/wp-content/uploads/.*?' + capitulo + '.*?.torrent)'
-            url_capitulo = scrapertools.find_single_match(data, patron)
-            if len(item.extra.split("|")) >= 2:
-                extra = item.extra
-            else:
-                extra = item.fanart
-        else:
-            capitulo = item.title
-            url_capitulo = item.url
-
-        ext_v, size = ext_size(url_capitulo)
-        try:
-            fanart = item.fanart_extra
-        except:
-            fanart = item.extra.split("|")[0]
-        itemlist.append(Item(channel=item.channel,
-                             title="[COLOR chocolate][B]Ver capítulo " + capitulo + "[/B][/COLOR]" + "-" + "[COLOR khaki] ( Video" + "[/COLOR]" + " " + "[COLOR khaki]" + ext_v + "[/COLOR]" + " " + "[COLOR khaki] " + size + " )" + "[/COLOR]",
-                             url=url_capitulo, action="play", server="torrent", fanart=fanart, thumbnail=item.thumbnail,
-                             extra=item.extra, fulltitle=item.fulltitle, folder=False))
-        if item.infoLabels['episode'] and item.library:
-            thumbnail = scrapertools.find_single_match(item.extra, 'http://assets.fanart.tv/.*jpg')
-            if thumbnail == "":
-                thumbnail = item.thumbnail
-            if not "assets.fanart" in item.fanart_info:
-                fanart = item.fanart_info
-            else:
-                fanart = item.fanart
-            itemlist.append(Item(channel=item.channel, title="[COLOR darksalmon][B]       info[/B][/COLOR]",
-                                 action="info_capitulos", fanart=fanart, thumbnail=item.thumb_art,
-                                 thumb_info=item.thumb_info, extra=item.extra, show=item.show,
-                                 InfoLabels=item.infoLabels, folder=False))
-        if not item.infoLabels['episode']:
-            itemlist.append(
-                Item(channel=item.channel, title="[COLOR moccasin][B]Todos los episodios[/B][/COLOR]", url=item.url,
-                     action="findtemporadas", server="torrent",
-                     thumbnail=item.thumbnail, extra=item.extra + "|" + item.thumbnail, contentType=item.contentType,
-                     contentTitle=item.contentTitle, InfoLabels=item.infoLabels, thumb_art=item.thumb_art,
-                     thumb_info=item.thumbnail, fulltitle=item.fulltitle, library=item.library, folder=True))
-    else:
-        url = scrapertools.find_single_match(data, '<h3 class="orange text-center">.*?href="([^"]+)"')
-        item.infoLabels['year'] = None
-        ext_v, size = ext_size(url)
-        itemlist.append(Item(channel=item.channel,
-                             title="[COLOR saddlebrown][B]Torrent [/B][/COLOR]" + "-" + "[COLOR khaki] ( Video" + "[/COLOR]" + " " + "[COLOR khaki]" + ext_v + "[/COLOR]" + " " + "[COLOR khaki] " + size + " )" + "[/COLOR]",
-                             url=url, action="play", server="torrent", fanart=item.fanart, thumbnail=item.thumbnail,
-                             extra=item.extra, InfoLabels=item.infoLabels, folder=False))
-
-        if item.library and config.get_videolibrary_support() and len(itemlist) > 0:
-            infoLabels = {'tmdb_id': item.infoLabels['tmdb_id'],
-                          'title': item.infoLabels['title']}
-            itemlist.append(Item(channel=item.channel, title="Añadir esta película a la videoteca",
-                                 action="add_pelicula_to_library", url=item.url, infoLabels=infoLabels,
-                                 text_color="0xFFe5ffcc",
-                                 thumbnail='http://imgur.com/xQNTqqy.png'))
-    return itemlist
-
-
-def info_capitulos(item, images={}):
-    logger.info()
-    try:
-        url = "http://thetvdb.com/api/1D62F2F90030C444/series/" + str(item.InfoLabels['tvdb_id']) + "/default/" + str(
-            item.InfoLabels['season']) + "/" + str(item.InfoLabels['episode']) + "/es.xml"
-        if "/0" in url:
-            url = url.replace("/0", "/")
-        from core import jsontools
-        data = httptools.downloadpage(url).data
-        if "<filename>episodes" in data:
-            image = scrapertools.find_single_match(data, '<Data>.*?<filename>(.*?)</filename>')
-            image = "http://thetvdb.com/banners/" + image
-        else:
-            try:
-                image = item.InfoLabels['episodio_imagen']
-            except:
-                image = "http://imgur.com/ZiEAVOD.png"
-
-        foto = item.thumb_info
-        if not ".png" in foto:
-            foto = "http://imgur.com/PRiEW1D.png"
-        try:
-            title = item.InfoLabels['episodio_titulo']
-        except:
-            title = ""
-        title = "[COLOR red][B]" + title + "[/B][/COLOR]"
-
-        try:
-            plot = "[COLOR peachpuff]" + str(item.InfoLabels['episodio_sinopsis']) + "[/COLOR]"
-        except:
-            plot = scrapertools.find_single_match(data, '<Overview>(.*?)</Overview>')
-            if plot == "":
-                plot = "Sin información todavia"
-        try:
-            rating = item.InfoLabels['episodio_vote_average']
-        except:
-            rating = 0
-        try:
-            if rating >= 5 and rating < 8:
-                rating = "[COLOR yellow]Puntuación[/COLOR] " + "[COLOR springgreen][B]" + str(rating) + "[/B][/COLOR]"
-            elif rating >= 8 and rating < 10:
-                rating = "[COLOR yellow]Puntuación[/COLOR] " + "[COLOR yellow][B]" + str(rating) + "[/B][/COLOR]"
-            elif rating == 10:
-                rating = "[COLOR yellow]Puntuación[/COLOR] " + "[COLOR orangered][B]" + str(rating) + "[/B][/COLOR]"
-            else:
-                rating = "[COLOR yellow]Puntuación[/COLOR] " + "[COLOR crimson][B]" + str(rating) + "[/B][/COLOR]"
-        except:
-            rating = "[COLOR yellow]Puntuación[/COLOR] " + "[COLOR crimson][B]" + str(rating) + "[/B][/COLOR]"
-        if "10." in rating:
-            rating = re.sub(r'10\.\d+', '10', rating)
-    except:
-        title = "[COLOR red][B]LO SENTIMOS...[/B][/COLOR]"
-        plot = "Este capitulo no tiene informacion..."
-        plot = "[COLOR yellow][B]" + plot + "[/B][/COLOR]"
-        image = "http://s6.postimg.cc/ub7pb76c1/noinfo.png"
-        foto = "http://s6.postimg.cc/nm3gk1xox/noinfosup2.png"
-        rating = ""
-    ventana = TextBox2(title=title, plot=plot, thumbnail=image, fanart=foto, rating=rating)
-    ventana.doModal()
-
-
-def tokenize(text, match=re.compile("([idel])|(\d+):|(-?\d+)").match):
-    i = 0
-    while i < len(text):
-        m = match(text, i)
-        s = m.group(m.lastindex)
-        i = m.end()
-        if m.lastindex == 2:
-            yield "s"
-            yield text[i:i + int(s)]
-            i = i + int(s)
-        else:
-            yield s
-
-
-def decode_item(next, token):
-    if token == "i":
-        # integer: "i" value "e"
-        data = int(next())
-        if next() != "e":
-            raise ValueError
-    elif token == "s":
-        # string: "s" value (virtual tokens)
-        data = next()
-    elif token == "l" or token == "d":
-        # container: "l" (or "d") values "e"
-        data = []
-        tok = next()
-        while tok != "e":
-            data.append(decode_item(next, tok))
-            tok = next()
-        if token == "d":
-            data = dict(zip(data[0::2], data[1::2]))
-    else:
-        raise ValueError
-    return data
-
-
-def decode(text):
-    try:
-        src = tokenize(text)
-        data = decode_item(src.next, src.next())
-        for token in src:  # look for more tokens
-            raise SyntaxError("trailing junk")
-    except (AttributeError, ValueError, StopIteration):
-        try:
-            data = data
-        except:
-            data = src
-    return data
-
-
-def convert_size(size):
-    import math
-    if (size == 0):
-        return '0B'
-    size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
-    i = int(math.floor(math.log(size, 1024)))
-    p = math.pow(1024, i)
-    s = round(size / p, 2)
-    return '%s %s' % (s, size_name[i])
-
-
-def get_year(url):
-    data = httptools.downloadpage(url, headers=header, cookies=False).data
-    data = re.sub(r"\n|\r|\t|\s{2}|&nbsp;", "", data)
-    year = scrapertools.find_single_match(data, '<h3>.*?(\d+\d+\d+\d+)')
-    if year == "":
-        year = " "
-    return year
-
-
-def ext_size(url):
-    torrents_path = config.get_videolibrary_path() + '/torrents'
-    if not os.path.exists(torrents_path):
-        os.mkdir(torrents_path)
-    try:
-        urllib.urlretrieve("http://anonymouse.org/cgi-bin/anon-www.cgi/" + url, torrents_path + "/temp.torrent")
-        pepe = open(torrents_path + "/temp.torrent", "rb").read()
-    except:
-        pepe = ""
-    torrent = decode(pepe)
-    try:
-        name = torrent["info"]["name"]
-        sizet = torrent["info"]['length']
-        sizet = convert_size(sizet)
-    except:
-        name = "no disponible"
-    try:
-        check_video = scrapertools.find_multiple_matches(str(torrent["info"]["files"]), "'length': (\d+)}")
-        size = max([int(i) for i in check_video])
-        for file in torrent["info"]["files"]:
-            manolo = "%r - %d bytes" % ("/".join(file["path"]), file["length"])
-            if str(size) in manolo:
-                video = manolo
-        size = convert_size(size)
-        ext_v = re.sub(r"-.*? bytes|.*?\[.*?\].|'|.*?COM.|.*?\[.*?\]|\(.*?\)|.*?\.", "", video)
-        try:
-            os.remove(torrents_path + "/temp.torrent")
-        except:
-            pass
-    except:
-        try:
-            size = sizet
-            ext_v = re.sub(r"-.*? bytes|.*?\[.*?\].|'|.*?COM.|.*?\.es.|.*?\[.*?\]|.*?\(.*?\)\.|.*?\.", "", name)
-        except:
-            size = "NO REPRODUCIBLE"
-            ext_v = ""
-        try:
-            os.remove(torrents_path + "/temp.torrent")
-        except:
-            pass
-    if "rar" in ext_v:
-        ext_v = ext_v + " -- No reproducible"
-        size = ""
-    return ext_v, size
-
-
-def newest(categoria):
-    logger.info()
-    itemlist = []
-    item = Item()
-    try:
-        if categoria == 'torrent':
-            item.url = host + '/peliculas/'
-            item.contentType="movie"
-        itemlist = scraper(item)
-        if itemlist[-1].title == "[COLOR springgreen][B]Siguiente >>[/B][/COLOR]":
-            itemlist.pop()
-    # Se captura la excepción, para no interrumpir al canal novedades si un canal falla
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("{0}".format(line))
-        return []
-    return itemlist
diff --git a/plugin.video.alfa/channels/doomtv.py b/plugin.video.alfa/channels/doomtv.py
index 4a9d5a38..d8c4907d 100644
--- a/plugin.video.alfa/channels/doomtv.py
+++ b/plugin.video.alfa/channels/doomtv.py
@@ -35,7 +35,9 @@ def mainlist(item):
                    action="lista",
                    thumbnail=get_thumb('all', auto=True),
                    fanart='https://s18.postimg.cc/fwvaeo6qh/todas.png',
-                   url='%s%s'%(host,'peliculas/page/1')
+                   url='%s%s'%(host,'peliculas/'),
+                   first=0
+
                    ))
 
     itemlist.append(
@@ -43,7 +45,7 @@ def mainlist(item):
                    action="seccion",
                    thumbnail=get_thumb('genres', auto=True),
                    fanart='https://s3.postimg.cc/5s9jg2wtf/generos.png',
-                   url='%s%s' % (host, 'peliculas/page/1'),
+                   url='%s%s' % (host, 'peliculas/'),
                    ))
 
     itemlist.append(
@@ -51,7 +53,8 @@ def mainlist(item):
                    action="lista",
                    thumbnail=get_thumb('more watched', auto=True),
                    fanart='https://s9.postimg.cc/wmhzu9d7z/vistas.png',
-                   url='%s%s'%(host,'top-imdb/page/1'),
+                   url='%s%s'%(host,'top-imdb/'),
+                   first=0
                    ))
 
     itemlist.append(
@@ -69,9 +72,7 @@ def lista(item):
     logger.info()
 
     itemlist = []
-    max_items = 20
-    next_page_url = ''
-
+    next = False
     data = httptools.downloadpage(item.url).data
     data = re.sub(r'"|\n|\r|\t|&nbsp;|<br>|\s{2,}', "", data)
 
@@ -80,23 +81,13 @@ def lista(item):
 
     matches = re.compile(patron, re.DOTALL).findall(data)
 
-    if item.next_page != 'b':
-        if len(matches) > max_items:
-            next_page_url = item.url
-            matches = matches[:max_items]
-            next_page = 'b'
-    else:
-        matches = matches[max_items:]
-        next_page = 'a'
-        next_page_str = scrapertools.find_single_match(data,"<li class='active'><a class=''>(\d+)</a>")
-        next_page_num = int(next_page_str)+1
-        page_base = re.sub(r'(page\/\d+)','', item.url)
-        next_page_url = '%s%s%s'%(page_base,'page/',next_page_num)
+    first = item.first
+    last = first + 19
+    if last > len(matches):
+        last = len(matches)
+        next = True
 
-        if next_page_url:
-            next_page_url =  next_page_url
-
-    for scrapedurl, quality, scrapedthumbnail, scrapedtitle, plot in matches:
+    for scrapedurl, quality, scrapedthumbnail, scrapedtitle, plot in matches[first:last]:
 
         url = scrapedurl
         thumbnail = scrapedthumbnail
@@ -118,17 +109,17 @@ def lista(item):
                  contentTitle=title
                  ))
     tmdb.set_infoLabels_itemlist(itemlist, seekTmdb = True)
-    # Paginacion
-    if next_page_url != '':
-        itemlist.append(
-            Item(channel=item.channel,
-                 action="lista",
-                 title='Siguiente >>>',
-                 url=next_page_url,
-                 thumbnail='https://s16.postimg.cc/9okdu7hhx/siguiente.png',
-                 extra=item.extra,
-                 next_page=next_page
-                 ))
+
+    if not next:
+        url_next_page = item.url
+        first = last
+    else:
+        url_next_page = scrapertools.find_single_match(data, "<a href=([^ ]+) class=page-link aria-label=Next>")
+        first = 0
+
+    if url_next_page:
+        itemlist.append(item.clone(title="Siguiente >>", url=url_next_page, action='lista', first=first))
+
     return itemlist
 
 
@@ -153,7 +144,8 @@ def seccion(item):
                      action='lista',
                      title=title,
                      url=url,
-                     thumbnail=thumbnail
+                     thumbnail=thumbnail,
+                     first=0
                      ))
     return itemlist
 
@@ -162,6 +154,7 @@ def search(item, texto):
     logger.info()
     texto = texto.replace(" ", "+")
     item.url = item.url + texto
+    item.first=0
     if texto != '':
         return lista(item)
 
@@ -178,6 +171,7 @@ def newest(categoria):
             item.url = host + 'categoria/animacion/'
         elif categoria == 'terror':
             item.url = host + '/categoria/terror/'
+        item.first=0
         itemlist = lista(item)
         if itemlist[-1].title == 'Siguiente >>>':
             itemlist.pop()
diff --git a/plugin.video.alfa/channels/elitetorrent.py b/plugin.video.alfa/channels/elitetorrent.py
index 235a7c40..224e94a6 100644
--- a/plugin.video.alfa/channels/elitetorrent.py
+++ b/plugin.video.alfa/channels/elitetorrent.py
@@ -40,9 +40,13 @@ def submenu(item):
     logger.info()
     itemlist = []
     
+    data = ''
     try:
         data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.url).data)
     except:
+        pass
+        
+    if not data:
         logger.error("ERROR 01: SUBMENU: La Web no responde o ha cambiado de URL: " + item.url)
         itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 01: La Web no responde o ha cambiado de URL. Si la Web está activa, reportar el error con el log'))
         return itemlist     #Algo no funciona, pintamos lo que tenemos
@@ -55,6 +59,13 @@ def submenu(item):
     patron = '<a href="(.*?)".*?title="(.*?)"'      #Encontrar todos los apartados
     matches = re.compile(patron, re.DOTALL).findall(data1)
     if not matches:
+        item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+        if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+            for clone_inter, autoridad in item.intervencion:
+                thumb_intervenido = get_thumb(autoridad)
+                itemlist.append(item.clone(action='', title="[COLOR yellow]" + clone_inter.capitalize() + ': [/COLOR]' + intervenido_judicial + '. Reportar el problema en el foro', thumbnail=thumb_intervenido))
+            return itemlist                                                     #Salimos
+        
         logger.error("ERROR 02: SUBMENU: Ha cambiado la estructura de la Web " + " / PATRON: " + patron + " / DATA: " + data1)
         itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 02: SUBMENU: Ha cambiado la estructura de la Web.  Reportar el error con el log'))
         return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
@@ -86,16 +97,16 @@ def listado(item):
     itemlist = []
 
     # Descarga la página
+    data = ''
     try:
         data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.url).data)
     except:
-            logger.error("ERROR 01: LISTADO: La Web no responde o ha cambiado de URL: " + item.url + " / DATA: " + data)
-            itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 01: LISTADO:.  La Web no responde o ha cambiado de URL. Si la Web está activa, reportar el error con el log'))
-            return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
+        pass
+        
     if not data:        #Si la web está caída salimos sin dar error
-            logger.error("ERROR 01: LISTADO: La Web no responde o ha cambiado de URL: " + item.url + " / DATA: " + data)
-            itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 01: LISTADO:.  La Web no responde o ha cambiado de URL. Si la Web está activa, reportar el error con el log'))
-            return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
+        logger.error("ERROR 01: LISTADO: La Web no responde o ha cambiado de URL: " + item.url + " / DATA: " + data)
+        itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 01: LISTADO:.  La Web no responde o ha cambiado de URL. Si la Web está activa, reportar el error con el log'))
+        return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
     
     patron = '<div id="principal">.*?<\/nav><\/div><\/div>'
     data = scrapertools.find_single_match(data, patron)
@@ -110,9 +121,14 @@ def listado(item):
 
     matches = re.compile(patron, re.DOTALL).findall(data)
     if not matches and not '<title>503 Backend fetch failed</title>' in data:       #error
-            logger.error("ERROR 02: LISTADO: Ha cambiado la estructura de la Web " + " / PATRON: " + patron + " / DATA: " + data)
-            itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 02: LISTADO: Ha cambiado la estructura de la Web.  Reportar el error con el log'))
-            return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
+        item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+        if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+            item, itemlist = generictools.post_tmdb_listado(item, itemlist)     #Llamamos al método para el pintado del error
+            return itemlist                                                     #Salimos
+        
+        logger.error("ERROR 02: LISTADO: Ha cambiado la estructura de la Web " + " / PATRON: " + patron + " / DATA: " + data)
+        itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 02: LISTADO: Ha cambiado la estructura de la Web.  Reportar el error con el log'))
+        return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
     
     #logger.debug("PATRON: " + patron)
     #logger.debug(matches)
@@ -153,7 +169,7 @@ def listado(item):
         if "dual" in scrapedcategory.lower() or "dual" in title.lower():
             item_local.language[0:0] = ["DUAL"]
         
-        #Limpiamos el título de la basuna innecesaria
+        #Limpiamos el título de la basura innecesaria
         title = title.replace("Dual", "").replace("dual", "").replace("Subtitulada", "").replace("subtitulada", "").replace("Subt", "").replace("subt", "").replace("Sub", "").replace("sub", "").replace("(Proper)", "").replace("(proper)", "").replace("Proper", "").replace("proper", "").replace("#", "").replace("(Latino)", "").replace("Latino", "")
         title = title.replace("- HDRip", "").replace("(HDRip)", "").replace("- Hdrip", "").replace("(microHD)", "").replace("(DVDRip)", "").replace("(HDRip)", "").replace("(BR-LINE)", "").replace("(HDTS-SCREENER)", "").replace("(BDRip)", "").replace("(BR-Screener)", "").replace("(DVDScreener)", "").replace("TS-Screener", "").replace(" TS", "").replace(" Ts", "")
         title = re.sub(r'\??\s?\d*?\&.*', '', title).title().strip()
@@ -199,11 +215,11 @@ def listado(item):
         
         itemlist.append(item_local.clone())     #Pintar pantalla
    
-    #if not item.category:       #Si este campo no existe es que viene de la primera pasada de una búsqueda global
-    #    return itemlist         #Retornamos sin pasar por la fase de maquillaje para ahorra tiempo
+    if not item.category:       #Si este campo no existe es que viene de la primera pasada de una búsqueda global
+        return itemlist         #Retornamos sin pasar por la fase de maquillaje para ahorra tiempo
 
     #Pasamos a TMDB la lista completa Itemlist
-    #tmdb.set_infoLabels(itemlist, True)
+    tmdb.set_infoLabels(itemlist, True)
     
     #Llamamos al método para el maquillaje de los títulos obtenidos desde TMDB
     item, itemlist = generictools.post_tmdb_listado(item, itemlist)
@@ -239,9 +255,13 @@ def findvideos(item):
     itemlist = []
 
     #Bajamos los datos de la página
+    data = ''
     try:
         data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.url).data)
     except:
+        pass
+        
+    if not data:
         logger.error("ERROR 01: FINDVIDEOS: La Web no responde o la URL es erronea: " + item.url + " / DATA: " + data)
         itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 01: FINDVIDEOS:.  La Web no responde o la URL es erronea. Si la Web está activa, reportar el error con el log'))
         return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
@@ -268,6 +288,11 @@ def findvideos(item):
     #logger.info("link Magnet: " + link_magnet)
     
     if not link_torrent and not link_magnet:                    #error
+        item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+        if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+            item, itemlist = generictools.post_tmdb_findvideos(item, itemlist)  #Llamamos al método para el pintado del error
+            return itemlist                                                     #Salimos
+            
         logger.error("ERROR 02: FINDVIDEOS: El archivo Torrent no existe o ha cambiado la estructura de la Web " + " / PATRON: " + patron_t + " / " + patron_m + " / DATA: " + data)
         itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 02: FINDVIDEOS: El archivo Torrent no existe o ha cambiado la estructura de la Web.  Verificar en la Web y reportar el error con el log'))
         return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
diff --git a/plugin.video.alfa/channels/grantorrent.py b/plugin.video.alfa/channels/grantorrent.py
index 597ad7b4..27ed4ee5 100644
--- a/plugin.video.alfa/channels/grantorrent.py
+++ b/plugin.video.alfa/channels/grantorrent.py
@@ -63,9 +63,13 @@ def submenu(item):
     
     thumb_buscar = get_thumb("search.png")
     
+    data = ''
     try:
         data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.url).data)
     except:
+        pass
+        
+    if not data:
         logger.error("ERROR 01: SUBMENU: La Web no responde o ha cambiado de URL: " + item.url)
         itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 01: La Web no responde o ha cambiado de URL. Si la Web está activa, reportar el error con el log'))
         return itemlist     #Algo no funciona, pintamos lo que tenemos
@@ -73,6 +77,13 @@ def submenu(item):
     if item.extra == "peliculas":
         patron = '<li class="navigation-top">.*?<a href="(.*?)".*?class="nav"> (.*?)\s?<\/a><\/li>'     
         matches = re.compile(patron, re.DOTALL).findall(data)
+        if not matches:
+            item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+            if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+                for clone_inter, autoridad in item.intervencion:
+                    thumb_intervenido = get_thumb(autoridad)
+                    itemlist.append(item.clone(action='', title="[COLOR yellow]" + clone_inter.capitalize() + ': [/COLOR]' + intervenido_judicial + '. Reportar el problema en el foro', thumbnail=thumb_intervenido))
+                return itemlist                                                     #Salimos
         
         itemlist.append(item.clone(action="listado", title="Novedades", url=host))       #Menú principal películas
     
@@ -87,6 +98,13 @@ def submenu(item):
     else:                  #Tratamos Series
         patron = '<li class="navigation-top-dcha">.*?<a href="(.*?)".*?class="series"> (.*?)\s?<\/a><\/li>'
         matches = re.compile(patron, re.DOTALL).findall(data)
+        if not matches:
+            item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+            if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+                for clone_inter, autoridad in item.intervencion:
+                    thumb_intervenido = get_thumb(autoridad)
+                    itemlist.append(item.clone(action='', title="[COLOR yellow]" + clone_inter.capitalize() + ': [/COLOR]' + intervenido_judicial + '. Reportar el problema en el foro', thumbnail=thumb_intervenido))
+                return itemlist                                                     #Salimos
 
         for scrapedurl, scrapedtitle in matches:
             scrapedtitle = re.sub('\r\n', '', scrapedtitle).decode('utf8').encode('utf8').strip()
@@ -121,6 +139,7 @@ def listado(item):
 
     while cnt_title <= cnt_tot and cnt_next < cnt_top:
         # Descarga la página
+        data = ''
         try:
             if not item.post:
                 item.post = item.url
@@ -128,9 +147,8 @@ def listado(item):
             data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.post).data)
             video_section = scrapertools.find_single_match(data, '<div class="contenedor-home">(.*?</div>)</div></div>')
         except:
-            logger.error("ERROR 01: LISTADO: La Web no responde o ha cambiado de URL: " + item.url + " / DATA: " + video_section)
-            itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 01: LISTADO:.  La Web no responde o ha cambiado de URL. Si la Web está activa, reportar el error con el log'))
-            return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
+            pass
+            
         cnt_next += 1
         if not data:        #Si la web está caída salimos sin dar error
             logger.error("ERROR 01: LISTADO: La Web no responde o ha cambiado de URL: " + item.url + " / DATA: " + video_section)
@@ -178,6 +196,11 @@ def listado(item):
 
         matches_alt = re.compile(patron, re.DOTALL).findall(video_section)
         if not matches_alt and not '<div class="titulo-load-core">0 resultados' in data:       #error
+            item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+            if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+                item, itemlist = generictools.post_tmdb_listado(item, itemlist)     #Llamamos al método para el pintado del error
+                return itemlist                                                     #Salimos
+            
             logger.error("ERROR 02: LISTADO: Ha cambiado la estructura de la Web " + " / PATRON: " + patron + " / DATA: " + data)
             itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 02: LISTADO: Ha cambiado la estructura de la Web.  Reportar el error con el log'))
             return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
@@ -349,9 +372,13 @@ def findvideos(item):
     itemlist = []
 
     #Bajamos los datos de la página
+    data = ''
     try:
         data = re.sub(r"\n|\r|\t|\s{2,}", "", httptools.downloadpage(item.url).data)
     except:
+        pass
+        
+    if not data:
         logger.error("ERROR 01: FINDVIDEOS: La Web no responde o la URL es erronea: " + item.url + " / DATA: " + data)
         itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 01: FINDVIDEOS:.  La Web no responde o la URL es erronea. Si la Web está activa, reportar el error con el log'))
         return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
@@ -361,6 +388,11 @@ def findvideos(item):
     patron = '\/icono_.*?png" title="(?P<lang>.*?)?" [^>]+><\/td><td>(?P<quality>.*?)?<?\/td>.*?<td>(?P<size>.*?)?<\/td><td><a class="link" href="(?P<url>.*?)?"'
     matches = re.compile(patron, re.DOTALL).findall(data)
     if not matches:                             #error
+        item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+        if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+            item, itemlist = generictools.post_tmdb_findvideos(item, itemlist)  #Llamamos al método para el pintado del error
+            return itemlist                                                     #Salimos
+        
         logger.error("ERROR 02: FINDVIDEOS: El archivo Torrent no existe o ha cambiado la estructura de la Web " + " / PATRON: " + patron + " / DATA: " + data)
         itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 02: FINDVIDEOS: El archivo Torrent no existe o ha cambiado la estructura de la Web.  Verificar en la Web y reportar el error con el log'))
         return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
@@ -421,7 +453,10 @@ def findvideos(item):
 
         #Tratamos la calidad y tamaño de cada link
         if quality:
-            item_local.quality = quality
+            tiempo = ''
+            if item_local.quality:
+                tiempo = scrapertools.find_single_match(item_local.quality, r'(\s\[.*?\])')
+            item_local.quality = quality + tiempo
         if "temporada" in temp_epi.lower():
             item_local.quality = '%s [Temporada]' % item_local.quality
         #if size and item_local.contentType != "episode":
@@ -460,6 +495,7 @@ def episodios(item):
     if not item.infoLabels['tmdb_id']:
         tmdb.set_infoLabels(item, True)
 
+    data = ''
     try:
         data = re.sub(r"\n|\r|\t|\s{2,}", "", httptools.downloadpage(item.url).data)    #Cargamos los datos de la página
 
@@ -648,6 +684,11 @@ def episodios(item):
         patron = '\/icono_.*?png" title="(?P<lang>.*?)?" [^>]+><\/td><td>(?P<temp_epi>.*?)?<?\/td>.*?<td>(?P<quality>.*?)?<\/td><td><a class="link" href="(?P<url>.*?)?"'
         matches = re.compile(patron, re.DOTALL).findall(data)
         if not matches:                             #error
+            item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+            if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+                item, itemlist = generictools.post_tmdb_episodios(item, itemlist)   #Llamamos al método para el pintado del error
+                return itemlist                                                     #Salimos
+            
             logger.error("ERROR 02: EPISODIOS: Ha cambiado la estructura de la Web " + " / PATRON: " + patron + " / DATA: " + data)
             itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 02: EPISODIOS: Ha cambiado la estructura de la Web.  Reportar el error con el log'))
             return itemlist                         #si no hay más datos, algo no funciona, pintamos lo que tenemos
diff --git a/plugin.video.alfa/channels/guaridavalencianista.json b/plugin.video.alfa/channels/guaridavalencianista.json
deleted file mode 100755
index 30e2e9d2..00000000
--- a/plugin.video.alfa/channels/guaridavalencianista.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "id": "guaridavalencianista",
-  "name": "La Guarida valencianista",
-  "active": false,
-  "adult": false,
-  "language": ["cast"],
-  "thumbnail": "guaridavalencianista.png",
-  "banner": "guaridavalencianista.png",
-  "categories": [
-    "documentary"
-  ]
-}
diff --git a/plugin.video.alfa/channels/guaridavalencianista.py b/plugin.video.alfa/channels/guaridavalencianista.py
deleted file mode 100755
index aa52d5da..00000000
--- a/plugin.video.alfa/channels/guaridavalencianista.py
+++ /dev/null
@@ -1,177 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import re
-import urlparse
-
-from core import scrapertools
-from core import servertools
-from core.item import Item
-from platformcode import logger
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-
-    itemlist.append(Item(channel=item.channel, title="Novedades", action="listvideos",
-                         url="http://guaridavalencia.blogspot.com.es"))
-    # itemlist.append( Item(channel=item.channel, title="Documentales - Series Disponibles"  , action="DocuSeries" , url="http://guaridavalencia.blogspot.com/"))
-    itemlist.append(
-        Item(channel=item.channel, title="Categorias", action="DocuTag", url="http://guaridavalencia.blogspot.com.es"))
-    itemlist.append(Item(channel=item.channel, title="Partidos de liga (Temporada 2014/2015)", action="listvideos",
-                         url="http://guaridavalencia.blogspot.com.es/search/label/PARTIDOS%20DEL%20VCF%20%28TEMPORADA%202014-15%29"))
-
-    return itemlist
-
-
-def DocuSeries(item):
-    logger.info()
-    itemlist = []
-
-    # Descarga la página
-    data = scrapertools.cache_page(item.url)
-
-    # Extrae las entradas (carpetas)
-    patronvideos = '<li><b><a href="([^"]+)" target="_blank">([^<]+)</a></b></li>'
-    matches = re.compile(patronvideos, re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-
-    for match in matches:
-        scrapedurl = match[0]
-        scrapedtitle = match[1]
-        scrapedthumbnail = ""
-        scrapedplot = ""
-        logger.debug("title=[" + scrapedtitle + "], url=[" + scrapedurl + "], thumbnail=[" + scrapedthumbnail + "]")
-        itemlist.append(Item(channel=item.channel, action="listvideos", title=scrapedtitle, url=scrapedurl,
-                             thumbnail=scrapedthumbnail, plot=scrapedplot, folder=True))
-
-    return itemlist
-
-
-def DocuTag(item):
-    logger.info()
-    itemlist = []
-    # Descarga la página
-    data = scrapertools.cache_page(item.url)
-    # ~ patronvideos  =    "<a dir='ltr' href='([^']+)'>([^<]+)</a>[^<]+<span class='label-count' dir='ltr'>(.+?)</span>"
-    patronvideos = "<li[^<]+<a dir='ltr' href='([^']+)'>([^<]+)</a[^<]+<span dir='ltr'>[^0-9]+([0-9]+)[^<]+</span[^<]+</li[^<]+"
-    # ~ patronvideos  =    "<li[^<]+<a dir='ltr' href='([^']+)'[^<]+([^<]+)</a>"
-    # ~ [^<]+<span class='label-count' dir='ltr'>(.+?)</span>"
-    matches = re.compile(patronvideos, re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-
-    for match in matches:
-        scrapedurl = match[0]
-        # Se debe quitar saltos de linea en match[1]
-        scrapedtitle = match[1][1:-1] + " (" + match[2] + ")"
-        # ~ scrapedtitle = match[1]
-        scrapedthumbnail = ""
-        scrapedplot = ""
-        logger.debug("title=[" + scrapedtitle + "], url=[" + scrapedurl + "], thumbnail=[" + scrapedthumbnail + "]")
-        itemlist.append(Item(channel=item.channel, action="listvideos", title=scrapedtitle, url=scrapedurl,
-                             thumbnail=scrapedthumbnail, plot=scrapedplot, folder=True))
-
-    return itemlist
-
-
-def DocuARCHIVO(item):
-    logger.info()
-    itemlist = []
-
-    # Descarga la página
-    data = scrapertools.cache_page(item.url)
-    patronvideos = "<a class='post-count-link' href='([^']+)'>([^<]+)</a>[^<]+"
-    patronvideos += "<span class='post-count' dir='ltr'>(.+?)</span>"
-    matches = re.compile(patronvideos, re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-
-    for match in matches:
-        scrapedurl = match[0]
-        scrapedtitle = match[1] + " " + match[2]
-        scrapedthumbnail = ""
-        scrapedplot = ""
-        logger.debug("title=[" + scrapedtitle + "], url=[" + scrapedurl + "], thumbnail=[" + scrapedthumbnail + "]")
-        itemlist.append(Item(channel=item.channel, action="listvideos", title=scrapedtitle, url=scrapedurl,
-                             thumbnail=scrapedthumbnail, plot=scrapedplot, folder=True))
-
-    return itemlist
-
-
-def listvideos(item):
-    logger.info()
-    itemlist = []
-
-    scrapedthumbnail = ""
-    scrapedplot = ""
-
-    # Descarga la página
-    data = scrapertools.cache_page(item.url)
-    patronvideos = "<h3 class='post-title entry-title'[^<]+"
-    patronvideos += "<a href='([^']+)'>([^<]+)</a>.*?"
-    patronvideos += "<div class='post-body entry-content'(.*?)<div class='post-footer'>"
-    matches = re.compile(patronvideos, re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-
-    for match in matches:
-        scrapedtitle = match[1]
-        scrapedtitle = re.sub("<[^>]+>", " ", scrapedtitle)
-        scrapedtitle = scrapertools.unescape(scrapedtitle)[1:-1]
-        scrapedurl = match[0]
-        regexp = re.compile(r'src="(http[^"]+)"')
-
-        matchthumb = regexp.search(match[2])
-        if matchthumb is not None:
-            scrapedthumbnail = matchthumb.group(1)
-        matchplot = re.compile('<div align="center">(<img.*?)</span></div>', re.DOTALL).findall(match[2])
-
-        if len(matchplot) > 0:
-            scrapedplot = matchplot[0]
-            # print matchplot
-        else:
-            scrapedplot = ""
-
-        scrapedplot = re.sub("<[^>]+>", " ", scrapedplot)
-        scrapedplot = scrapertools.unescape(scrapedplot)
-        logger.debug("title=[" + scrapedtitle + "], url=[" + scrapedurl + "], thumbnail=[" + scrapedthumbnail + "]")
-        itemlist.append(Item(channel=item.channel, action="findvideos", title=scrapedtitle, url=scrapedurl,
-                             thumbnail=scrapedthumbnail, plot=scrapedplot, folder=True))
-
-    # Extrae la marca de siguiente página
-    patronvideos = "<a class='blog-pager-older-link' href='([^']+)'"
-    matches = re.compile(patronvideos, re.DOTALL).findall(data)
-    scrapertools.printMatches(matches)
-
-    if len(matches) > 0:
-        scrapedtitle = "Página siguiente"
-        scrapedurl = urlparse.urljoin(item.url, matches[0])
-        scrapedthumbnail = ""
-        scrapedplot = ""
-        itemlist.append(Item(channel=item.channel, action="listvideos", title=scrapedtitle, url=scrapedurl,
-                             thumbnail=scrapedthumbnail, plot=scrapedplot, folder=True))
-
-    return itemlist
-
-    # ~ return itemlist
-
-
-def findvideos(item):
-    logger.info()
-    data = scrapertools.cachePage(item.url)
-
-    # Busca los enlaces a los videos
-
-    listavideos = servertools.findvideos(data)
-
-    if item is None:
-        item = Item()
-
-    itemlist = []
-    for video in listavideos:
-        scrapedtitle = video[0].strip() + " - " + item.title.strip()
-        scrapedurl = video[1]
-        server = video[2]
-
-        itemlist.append(Item(channel=item.channel, title=scrapedtitle, action="play", server=server, url=scrapedurl,
-                             thumbnail=item.thumbnail, show=item.show, plot=item.plot, folder=False))
-
-    return itemlist
diff --git a/plugin.video.alfa/channels/hdfull.py b/plugin.video.alfa/channels/hdfull.py
index f02dff6f..a05cd914 100644
--- a/plugin.video.alfa/channels/hdfull.py
+++ b/plugin.video.alfa/channels/hdfull.py
@@ -28,16 +28,12 @@ def settingCanal(item):
 
 def login():
     logger.info()
-
     data = agrupa_datos(httptools.downloadpage(host).data)
-
     patron = "<input type='hidden' name='__csrf_magic' value=\"([^\"]+)\" />"
     sid = scrapertools.find_single_match(data, patron)
-
     post = urllib.urlencode({'__csrf_magic': sid}) + "&username=" + config.get_setting('hdfulluser',
                                                                                        'hdfull') + "&password=" + config.get_setting(
         'hdfullpassword', 'hdfull') + "&action=login"
-
     httptools.downloadpage(host, post=post)
 
 
@@ -56,15 +52,12 @@ def mainlist(item):
     else:
         login()
         itemlist.append(Item(channel=item.channel, action="settingCanal", title="Configuración...", url=""))
-
     return itemlist
 
 
 def menupeliculas(item):
     logger.info()
-
     itemlist = []
-
     if account:
         itemlist.append(Item(channel=item.channel, action="items_usuario",
                              title="[COLOR orange][B]Favoritos[/B][/COLOR]",
@@ -72,7 +65,6 @@ def menupeliculas(item):
         itemlist.append(Item(channel=item.channel, action="items_usuario",
                              title="[COLOR orange][B]Pendientes[/B][/COLOR]",
                              url=host + "/a/my?target=movies&action=pending&start=-28&limit=28", folder=True))
-
     itemlist.append(Item(channel=item.channel, action="fichas", title="ABC", url=host + "/peliculas/abc", folder=True))
     itemlist.append(
         Item(channel=item.channel, action="fichas", title="Últimas películas", url=host + "/peliculas", folder=True))
@@ -89,15 +81,12 @@ def menupeliculas(item):
         itemlist.append(Item(channel=item.channel, action="items_usuario",
                              title="[COLOR orange][B]Vistas[/B][/COLOR]",
                              url=host + "/a/my?target=movies&action=seen&start=-28&limit=28", folder=True))
-
     return itemlist
 
 
 def menuseries(item):
     logger.info()
-
     itemlist = []
-
     if account:
         itemlist.append(Item(channel=item.channel, action="items_usuario",
                              title="[COLOR orange][B]Siguiendo[/B][/COLOR]",
@@ -105,9 +94,7 @@ def menuseries(item):
         itemlist.append(Item(channel=item.channel, action="items_usuario",
                              title="[COLOR orange][B]Para Ver[/B][/COLOR]",
                              url=host + "/a/my?target=shows&action=watch&start=-28&limit=28", folder=True))
-
     itemlist.append(Item(channel=item.channel, action="series_abc", title="A-Z", folder=True))
-
     itemlist.append(Item(channel=item.channel, action="novedades_episodios", title="Últimos Emitidos",
                          url=host + "/a/episodes?action=latest&start=-24&limit=24&elang=ALL", folder=True))
     itemlist.append(Item(channel=item.channel, action="novedades_episodios", title="Episodios Estreno",
@@ -132,20 +119,16 @@ def menuseries(item):
         itemlist.append(Item(channel=item.channel, action="items_usuario",
                              title="[COLOR orange][B]Vistas[/B][/COLOR]",
                              url=host + "/a/my?target=shows&action=seen&start=-28&limit=28", folder=True))
-
     return itemlist
 
 
 def search(item, texto):
     logger.info()
-
     data = agrupa_datos(httptools.downloadpage(host).data)
-
     sid = scrapertools.get_match(data, '.__csrf_magic. value="(sid:[^"]+)"')
     item.extra = urllib.urlencode({'__csrf_magic': sid}) + '&menu=search&query=' + texto
     item.title = "Buscar..."
     item.url = host + "/buscar"
-
     try:
         return fichas(item)
     # Se captura la excepción, para no interrumpir al buscador global si un canal falla
@@ -158,59 +141,44 @@ def search(item, texto):
 
 def series_abc(item):
     logger.info()
-
     itemlist = []
-
     az = "ABCDEFGHIJKLMNOPQRSTUVWXYZ#"
-
     for l in az:
         itemlist.append(
             Item(channel=item.channel, action='fichas', title=l, url=host + "/series/abc/" + l.replace('#', '9')))
-
     return itemlist
 
 
 def items_usuario(item):
     logger.info()
-
     itemlist = []
     ## Carga estados
     status = jsontools.load(httptools.downloadpage(host + '/a/status/all').data)
-
     ## Fichas usuario
     url = item.url.split("?")[0]
     post = item.url.split("?")[1]
-
     old_start = scrapertools.get_match(post, 'start=([^&]+)&')
     limit = scrapertools.get_match(post, 'limit=(\d+)')
     start = "%s" % (int(old_start) + int(limit))
-
     post = post.replace("start=" + old_start, "start=" + start)
     next_page = url + "?" + post
-
     ## Carga las fichas de usuario
     data = httptools.downloadpage(url, post=post).data
     fichas_usuario = jsontools.load(data)
-
     for ficha in fichas_usuario:
-
         try:
             title = ficha['title']['es'].strip()
         except:
             title = ficha['title']['en'].strip()
-
         try:
             title = title.encode('utf-8')
         except:
             pass
-
         show = title
-
         try:
             thumbnail = host + "/thumbs/" + ficha['thumbnail']
         except:
             thumbnail = host + "/thumbs/" + ficha['thumb']
-
         try:
             url = urlparse.urljoin(host, '/serie/' + ficha['permalink']) + "###" + ficha['id'] + ";1"
             action = "episodios"
@@ -237,37 +205,26 @@ def items_usuario(item):
             action = "findvideos"
             str = get_status(status, 'movies', ficha['id'])
         if str != "": title += str
-
-        # try: title = title.encode('utf-8')
-        # except: pass
-
         itemlist.append(
             Item(channel=item.channel, action=action, title=title, fulltitle=title, url=url, thumbnail=thumbnail,
                  show=show, folder=True))
-
     if len(itemlist) == int(limit):
         itemlist.append(
             Item(channel=item.channel, action="items_usuario", title=">> Página siguiente", url=next_page, folder=True))
-
     return itemlist
 
 
 def listado_series(item):
     logger.info()
-
     itemlist = []
-
     data = agrupa_datos(httptools.downloadpage(item.url).data)
-
     patron = '<div class="list-item"><a href="([^"]+)"[^>]+>([^<]+)</a></div>'
     matches = re.compile(patron, re.DOTALL).findall(data)
-
     for scrapedurl, scrapedtitle in matches:
         url = scrapedurl + "###0;1"
         itemlist.append(
             Item(channel=item.channel, action="episodios", title=scrapedtitle, fulltitle=scrapedtitle, url=url,
                  show=scrapedtitle, contentType="tvshow"))
-
     return itemlist
 
 
@@ -278,22 +235,19 @@ def fichas(item):
     infoLabels=dict()
     ## Carga estados
     status = jsontools.load(httptools.downloadpage(host + '/a/status/all').data)
-
     if item.title == "Buscar...":
         data = agrupa_datos(httptools.downloadpage(item.url, post=item.extra).data)
         s_p = scrapertools.get_match(data, '<h3 class="section-title">(.*?)<div id="footer-wrapper">').split(
             '<h3 class="section-title">')
-
         if len(s_p) == 1:
             data = s_p[0]
             if 'Lo sentimos</h3>' in s_p[0]:
                 return [Item(channel=item.channel, title="[COLOR gold][B]HDFull:[/B][/COLOR] [COLOR blue]" + texto.replace('%20',
-                                                                                      ' ') + "[/COLOR] sin resultados")]
+                                                                                       ' ') + "[/COLOR] sin resultados")]
         else:
             data = s_p[0] + s_p[1]
     else:
         data = agrupa_datos(httptools.downloadpage(item.url).data)
-
     data = re.sub(
         r'<div class="span-6[^<]+<div class="item"[^<]+' + \
         '<a href="([^"]+)"[^<]+' + \
@@ -305,32 +259,23 @@ def fichas(item):
         r"'url':'\1';'image':'\2';'langs':'\3';'rating':'\4';'title':\5;'id':'\6';",
         data
     )
-
     patron = "'url':'([^']+)';'image':'([^']+)';'langs':'([^']+)';'rating':'([^']+)';'title':([^;]+);'id':'([^']+)';"
-
     matches = re.compile(patron, re.DOTALL).findall(data)
-
     for scrapedurl, scrapedthumbnail, scrapedlangs, scrapedrating, scrapedtitle, scrapedid in matches:
-
-        #thumbnail = scrapedthumbnail.replace("/tthumb/130x190/", "/thumbs/")
         thumbnail = scrapedthumbnail
         language = ''
         title = scrapedtitle.strip()
         show = title
         contentTitle = scrapedtitle.strip()
-
         if scrapedlangs != ">":
             textoidiomas, language = extrae_idiomas(scrapedlangs)
             #Todo Quitar el idioma
             title += " ( [COLOR teal][B]" + textoidiomas + "[/B][/COLOR])"
-
         if scrapedrating != ">":
             valoracion = re.sub(r'><[^>]+>(\d+)<b class="dec">(\d+)</b>', r'\1,\2', scrapedrating)
             infoLabels['rating']=valoracion
             title += " ([COLOR orange]" + valoracion + "[/COLOR])"
-
         url = urlparse.urljoin(item.url, scrapedurl)
-
         if "/serie" in url or "/tags-tv" in url:
             action = "episodios"
             url += "###" + scrapedid + ";1"
@@ -341,10 +286,8 @@ def fichas(item):
             url += "###" + scrapedid + ";2"
             type = "movies"
             contentType = "movie"
-
         str = get_status(status, type, scrapedid)
         if str != "": title += str
-
         if item.title == "Buscar...":
             bus = host[-4:]
             tag_type = scrapertools.find_single_match(url, '%s/([^/]+)/' %bus)
@@ -356,7 +299,7 @@ def fichas(item):
                      language =language, infoLabels=infoLabels))
         else:
             itemlist.append(
-                Item(channel=item.channel, action=action, title=title, url=url, fulltitle=title, thumbnail=thumbnail,
+                Item(channel=item.channel, action=action, title=title, url=url, fulltitle=contentTitle, thumbnail=thumbnail,
                      folder=True, contentType=contentType, contentTitle=contentTitle,
                      language =language, infoLabels=infoLabels))
     ## Paginación
@@ -364,7 +307,6 @@ def fichas(item):
     if next_page_url != "":
         itemlist.append(Item(channel=item.channel, action="fichas", title=">> Página siguiente",
                              url=urlparse.urljoin(item.url, next_page_url), folder=True))
-
     return itemlist
 
 
@@ -372,25 +314,19 @@ def episodios(item):
     logger.info()
     id = "0"
     itemlist = []
-
     ## Carga estados
     status = jsontools.load(httptools.downloadpage(host + '/a/status/all').data)
-
     url_targets = item.url
-
     if "###" in item.url:
         id = item.url.split("###")[1].split(";")[0]
         type = item.url.split("###")[1].split(";")[1]
         item.url = item.url.split("###")[0]
-
     ## Temporadas
     data = agrupa_datos(httptools.downloadpage(item.url).data)
-
     if id == "0":
         ## Se saca el id de la serie de la página cuando viene de listado_series
         id = scrapertools.get_match(data, "<script>var sid = '([^']+)';</script>")
         url_targets = url_targets.replace('###0', '###' + id)
-
     str = get_status(status, "shows", id)
     if str != "" and account and item.category != "Series" and "XBMC" not in item.title:
         if config.get_videolibrary_support():
@@ -443,9 +379,6 @@ def episodios(item):
                 title = temporada + "x" + episodio + " - " + title.decode('utf-8') + ' ' + idiomas
             except:
                 title = temporada + "x" + episodio + " - " + title.decode('iso-8859-1') + ' ' + idiomas
-            # try: title = temporada + "x" + episodio + " - " + title + ' ' + idiomas
-            # except: pass
-            # except: title = temporada + "x" + episodio + " - " + title.decode('iso-8859-1') + ' ' + idiomas
             str = get_status(status, 'episodes', episode['id'])
             if str != "": title += str
             try:
@@ -473,25 +406,17 @@ def novedades_episodios(item):
     ## Episodios
     url = item.url.split("?")[0]
     post = item.url.split("?")[1]
-
     old_start = scrapertools.get_match(post, 'start=([^&]+)&')
     start = "%s" % (int(old_start) + 24)
-
     post = post.replace("start=" + old_start, "start=" + start)
     next_page = url + "?" + post
-
     data = httptools.downloadpage(url, post=post).data
-
     episodes = jsontools.load(data)
-
     for episode in episodes:
-
         thumbnail = host + "/thumbs/" + episode['thumbnail']
-
         temporada = episode['season']
         episodio = episode['episode']
         if len(episodio) == 1: episodio = '0' + episodio
-
         if episode['languages'] != "[]":
             idiomas = "( [COLOR teal][B]"
             for idioma in episode['languages']: idiomas += idioma + " "
@@ -499,95 +424,70 @@ def novedades_episodios(item):
             idiomas = idiomas
         else:
             idiomas = ""
-
         try:
-            show = episode['show']['title']['es'].strip()
+            contentSerieName = episode['show']['title']['es'].strip()
         except:
-            show = episode['show']['title']['en'].strip()
-
-        show = "[COLOR whitesmoke][B]" + show + "[/B][/COLOR]"
-
+            contentSerieName = episode['show']['title']['en'].strip()
+        show = "[COLOR whitesmoke][B]" + contentSerieName + "[/B][/COLOR]"
         if episode['title']:
             try:
                 title = episode['title']['es'].strip()
             except:
                 title = episode['title']['en'].strip()
-
         if len(title) == 0: title = "Temporada " + temporada + " Episodio " + episodio
-
         try:
             title = temporada + "x" + episodio + " - " + show.decode('utf-8') + ": " + title.decode(
                 'utf-8') + ' ' + idiomas
         except:
             title = temporada + "x" + episodio + " - " + show.decode('iso-8859-1') + ": " + title.decode(
                 'iso-8859-1') + ' ' + idiomas
-
         str = get_status(status, 'episodes', episode['id'])
         if str != "": title += str
-
         try:
             title = title.encode('utf-8')
         except:
             title = title.encode('iso-8859-1')
-        # try: show = show.encode('utf-8')
-        # except:  show = show.encode('iso-8859-1')
-
         url = urlparse.urljoin(host, '/serie/' + episode[
             'permalink'] + '/temporada-' + temporada + '/episodio-' + episodio) + "###" + episode['id'] + ";3"
-
         itemlist.append(
-            Item(channel=item.channel, action="findvideos", title=title, fulltitle=title, url=url, thumbnail=thumbnail,
+            Item(channel=item.channel, action="findvideos", title=title, contentSerieName=contentSerieName, url=url, thumbnail=thumbnail,
                  folder=True, contentType="episode"))
-
     if len(itemlist) == 24:
         itemlist.append(
             Item(channel=item.channel, action="novedades_episodios", title=">> Página siguiente", url=next_page,
                  folder=True))
-
     return itemlist
 
 
 def generos(item):
     logger.info()
-
     itemlist = []
-
     data = agrupa_datos(httptools.downloadpage(item.url).data)
     data = scrapertools.find_single_match(data, '<li class="dropdown"><a href="%s/peliculas"(.*?)</ul>' % host)
-
     patron = '<li><a href="([^"]+)">([^<]+)</a></li>'
     matches = re.compile(patron, re.DOTALL).findall(data)
-
     for scrapedurl, scrapedtitle in matches:
         title = scrapedtitle.strip()
         url = urlparse.urljoin(item.url, scrapedurl)
         thumbnail = ""
         plot = ""
-
         itemlist.append(Item(channel=item.channel, action="fichas", title=title, url=url, folder=True))
-
     return itemlist
 
 
 def generos_series(item):
     logger.info()
-
     itemlist = []
-
     data = agrupa_datos(httptools.downloadpage(item.url).data)
     data = scrapertools.find_single_match(data, '<li class="dropdown"><a href="%s/series"(.*?)</ul>' % host)
-
     patron = '<li><a href="([^"]+)">([^<]+)</a></li>'
     matches = re.compile(patron, re.DOTALL).findall(data)
-
     for scrapedurl, scrapedtitle in matches:
         title = scrapedtitle.strip()
         url = urlparse.urljoin(item.url, scrapedurl)
         thumbnail = ""
         plot = ""
-
         itemlist.append(Item(channel=item.channel, action="fichas", title=title, url=url, folder=True))
-
     return itemlist
 
 
@@ -599,7 +499,6 @@ def findvideos(item):
     ## Carga estados
     status = jsontools.load(httptools.downloadpage(host + '/a/status/all').data)
     url_targets = item.url
-
     ## Vídeos
     id = ""
     type = ""
@@ -616,21 +515,15 @@ def findvideos(item):
             title_label = " ( [COLOR gray][B]" + item.show + "[/B][/COLOR] )"
             it1.append(Item(channel=item.channel, action="findvideos", title=title_label, fulltitle=title_label,
                                  url=url_targets, thumbnail=item.thumbnail, show=item.show, folder=False))
-
             title_label = " ( [COLOR green][B]Tráiler[/B][/COLOR] )"
-
             it1.append(
                 item.clone(channel="trailertools", action="buscartrailer", title=title_label, contentTitle=item.show, url=item.url,
                      thumbnail=item.thumbnail, show=item.show))
-
         it1.append(Item(channel=item.channel, action="set_status", title=title, fulltitle=title, url=url_targets,
                              thumbnail=item.thumbnail, show=item.show, folder=True))
-
     data_js = httptools.downloadpage("%s/templates/hdfull/js/jquery.hdfull.view.min.js" % host).data
     key = scrapertools.find_single_match(data_js, 'JSON.parse\(atob.*?substrings\((.*?)\)')
-
     data_js = httptools.downloadpage("%s/js/providers.js" % host).data
-
     try:
         data_js = jhexdecode(data_js)
     except:
@@ -639,10 +532,8 @@ def findvideos(item):
         decode_aa = ""
         for match in data_js:
             decode_aa += aadecode(match)
-
         data_js = re.sub(r':(function.*?\})', r':"\g<1>"', decode_aa)
         data_js = re.sub(r':(var[^,]+),', r':"\g<1>",', data_js)
-
     data = agrupa_datos(httptools.downloadpage(item.url).data)
     data_obf = scrapertools.find_single_match(data, "var ad\s*=\s*'([^']+)'")
     data_decrypt = jsontools.load(obfs(base64.b64decode(data_obf), 126 - int(key)))
@@ -653,14 +544,11 @@ def findvideos(item):
     for match in data_decrypt:
         prov = eval(scrapertools.find_single_match(data_js, 'p\[%s\]\s*=\s*(\{.*?\}[\']\})' % match["provider"]))
         server_url = scrapertools.find_single_match(prov['l'], 'return\s*"(.*?)"')
-
         url = '%s%s' % (server_url, match['code'])
         url = re.sub(r'\'|"|\s|\+', '', url)
         url = re.sub(r'var_\d+\[\d+\]', '', url)
         embed = prov["e"]
-
         matches.append([match["lang"], match["quality"], url, embed])
-
     for idioma, calidad, url, embed in matches:
         mostrar_server = True
         option = "Ver"
@@ -675,14 +563,12 @@ def findvideos(item):
                                                                     '<meta property="og:description" content="([^"]+)"')
         plot = scrapertools.htmlclean(plot)
         fanart = scrapertools.find_single_match(data, '<div style="background-image.url. ([^\s]+)')
-
-
         if account:
             url += "###" + id + ";" + type
         it2.append(
             item.clone(channel=item.channel, action="play", title=title, url=url, thumbnail=thumbnail,
                  plot=plot, fanart=fanart, show=item.show, folder=True, infoLabels=infolabels,
-                 contentTitle=item.show, contentType=item.contentType, tipo=option, tipo1=option1, idioma=idioma))
+                 contentTitle=item.contentTitle, contentType=item.contentType, tipo=option, tipo1=option1, idioma=idioma))
     it2 = servertools.get_servers_itemlist(it2, lambda i: i.title % i.server.capitalize())
     it2.sort(key=lambda it: (it.tipo1, it.idioma, it.server))
     for item in it2:
@@ -700,7 +586,6 @@ def findvideos(item):
     return itemlist
 
 
-
 def play(item):
     if "###" in item.url:
         id = item.url.split("###")[1].split(";")[0]
@@ -708,7 +593,6 @@ def play(item):
         item.url = item.url.split("###")[0]
         post = "target_id=%s&target_type=%s&target_status=1" % (id, type)
         data = httptools.downloadpage(host + "/a/status", post=post).data
-
     devuelve = servertools.findvideosbyserver(item.url, item.server)
     if devuelve:
         item.url = devuelve[0][1]
@@ -741,10 +625,8 @@ def extrae_idiomas(bloqueidiomas):
         textoidiomas = textoidiomas + idioma +" "
         # TODO y dejar esto
         language.append(idioma)
-
     return textoidiomas, language
 
-
 ## --------------------------------------------------------------------------------
 
 def set_status(item):
@@ -752,28 +634,21 @@ def set_status(item):
         id = item.url.split("###")[1].split(";")[0]
         type = item.url.split("###")[1].split(";")[1]
         # item.url = item.url.split("###")[0]
-
     if "Abandonar" in item.title:
         path = "/a/status"
         post = "target_id=" + id + "&target_type=" + type + "&target_status=0"
-
     elif "Seguir" in item.title:
         target_status = "3"
         path = "/a/status"
         post = "target_id=" + id + "&target_type=" + type + "&target_status=3"
-
     elif "Agregar a Favoritos" in item.title:
         path = "/a/favorite"
         post = "like_id=" + id + "&like_type=" + type + "&like_comment=&vote=1"
-
     elif "Quitar de Favoritos" in item.title:
         path = "/a/favorite"
         post = "like_id=" + id + "&like_type=" + type + "&like_comment=&vote=-1"
-
     data = httptools.downloadpage(host + path, post=post).data
-
     title = "[COLOR green][B]OK[/B][/COLOR]"
-
     return [Item(channel=item.channel, action="episodios", title=title, fulltitle=title, url=item.url,
                  thumbnail=item.thumbnail, show=item.show, folder=False)]
 
@@ -783,27 +658,22 @@ def get_status(status, type, id):
         state = {'0': '', '1': 'Finalizada', '2': 'Pendiente', '3': 'Siguiendo'}
     else:
         state = {'0': '', '1': 'Visto', '2': 'Pendiente'}
-
     str = "";
     str1 = "";
     str2 = ""
-
     try:
         if id in status['favorites'][type]:
             str1 = " [COLOR orange][B]Favorito[/B][/COLOR]"
     except:
         str1 = ""
-
     try:
         if id in status['status'][type]:
             str2 = state[status['status'][type][id]]
             if str2 != "": str2 = "[COLOR green][B]" + state[status['status'][type][id]] + "[/B][/COLOR]"
     except:
         str2 = ""
-
     if str1 != "" or str2 != "":
         str = " (" + str1 + str2 + " )"
-
     return str
 
 
@@ -811,20 +681,16 @@ def get_status(status, type, id):
 ## --------------------------------------------------------------------------------
 
 
-
 def jhexdecode(t):
     r = re.sub(r'_\d+x\w+x(\d+)', 'var_' + r'\1', t)
     r = re.sub(r'_\d+x\w+', 'var_0', r)
-
     def to_hx(c):
         h = int("%s" % c.groups(0), 16)
         if 19 < h < 160:
             return chr(h)
         else:
             return ""
-
     r = re.sub(r'(?:\\|)x(\w{2})', to_hx, r).replace('var ', '')
-
     f = eval(scrapertools.get_match(r, '\s*var_0\s*=\s*([^;]+);'))
     for i, v in enumerate(f):
         r = r.replace('[[var_0[%s]]' % i, "." + f[i])
@@ -833,12 +699,11 @@ def jhexdecode(t):
         r = r.replace('(var_0[%s]' % i, "(\"" + f[i] + "\"")
         r = r.replace('[var_0[%s]]' % i, "." + f[i])
         if v == "": r = r.replace('var_0[%s]' % i, '""')
-
     r = re.sub(r':(function.*?\})', r":'\g<1>'", r)
     r = re.sub(r':(var[^,]+),', r":'\g<1>',", r)
-
     return r
 
+
 def obfs(data, key, n=126):
     chars = list(data)
     for i in range(0, len(chars)):
@@ -846,5 +711,4 @@ def obfs(data, key, n=126):
         if c <= n:
             number = (ord(chars[i]) + key) % n
             chars[i] = chr(number)
-
     return "".join(chars)
diff --git a/plugin.video.alfa/channels/lacajita.json b/plugin.video.alfa/channels/lacajita.json
deleted file mode 100755
index 99e170e9..00000000
--- a/plugin.video.alfa/channels/lacajita.json
+++ /dev/null
@@ -1,69 +0,0 @@
-{
-  "id": "lacajita",
-  "name": "LaCajita",
-  "language": ["cast", "lat"],
-  "active": false,
-  "adult": false,
-  "thumbnail": "http://i.imgur.com/LVdupxc.png",
-  "categories": [
-    "movie",
-    "vos"
-  ],
-  "settings": [
-    {
-      "id": "include_in_global_search",
-      "type": "bool",
-      "label": "Incluir en búsqueda global",
-      "default": false,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "modo_grafico",
-      "type": "bool",
-      "color": "0xFFd50b0b",
-      "label": "Buscar información extra",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "perfil",
-      "type": "list",
-      "label": "Perfil de color",
-      "default": 3,
-      "enabled": true,
-      "visible": true,
-      "lvalues": [
-        "Sin color",
-        "Perfil 3",
-        "Perfil 2",
-        "Perfil 1"
-      ]
-    },
-    {
-      "id": "include_in_newest_terror",
-      "type": "bool",
-      "label": "Incluir en Novedades - terror",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "include_in_newest_castellano",
-      "type": "bool",
-      "label": "Incluir en Novedades - Castellano",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    },
-    {
-      "id": "include_in_newest_latino",
-      "type": "bool",
-      "label": "Incluir en Novedades - Latino",
-      "default": true,
-      "enabled": true,
-      "visible": true
-    }
-  ]
-}
diff --git a/plugin.video.alfa/channels/lacajita.py b/plugin.video.alfa/channels/lacajita.py
deleted file mode 100644
index 5788e369..00000000
--- a/plugin.video.alfa/channels/lacajita.py
+++ /dev/null
@@ -1,297 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import re
-
-from core import httptools
-from core import scrapertools
-from core import servertools
-from core import tmdb
-from core.item import Item
-from platformcode import config, logger
-
-__modo_grafico__ = config.get_setting("modo_grafico", "lacajita")
-__perfil__ = config.get_setting("perfil", "lacajita")
-
-# Fijar perfil de color            
-perfil = [['0xFFFFE6CC', '0xFFFFCE9C', '0xFF994D00', '0xFFFE2E2E', '0xFF088A08'],
-          ['0xFFA5F6AF', '0xFF5FDA6D', '0xFF11811E', '0xFFFE2E2E', '0xFF088A08'],
-          ['0xFF58D3F7', '0xFF2E9AFE', '0xFF2E64FE', '0xFFFE2E2E', '0xFF088A08']]
-
-if __perfil__ - 1 >= 0:
-    color1, color2, color3, color4, color5 = perfil[__perfil__ - 1]
-else:
-    color1 = color2 = color3 = color4 = color5 = ""
-host = "http://lacajita.xyz"
-
-
-def mainlist(item):
-    logger.info()
-    itemlist = []
-    item.text_color = color1
-
-    itemlist.append(item.clone(title="Novedades DVD", action=""))
-    item.text_color = color2
-    itemlist.append(item.clone(title="     En Español", action="entradas", url=host + "/estrenos-dvd/es/", page=0))
-    itemlist.append(item.clone(title="     En Latino", action="entradas", url=host + "/estrenos-dvd/la/", page=0))
-    itemlist.append(item.clone(title="     En VOSE", action="entradas", url=host + "/estrenos-dvd/vos/", page=0))
-    item.text_color = color1
-    itemlist.append(item.clone(title="Estrenos", action=""))
-    item.text_color = color2
-    itemlist.append(item.clone(title="     En Español", action="entradas", url=host + "/estrenos/es/", page=0))
-    itemlist.append(item.clone(title="     En Latino", action="entradas", url=host + "/estrenos/la/", page=0))
-    itemlist.append(item.clone(title="     En VOSE", action="entradas", url=host + "/estrenos/vos/", page=0))
-    item.text_color = color1
-    itemlist.append(item.clone(title="Más Vistas", action="updated", url=host + "/listado-visto/", page=0))
-    itemlist.append(item.clone(title="Actualizadas", action="updated", url=host + "/actualizado/", page=0))
-    item.text_color = color5
-    itemlist.append(item.clone(title="Por género", action="indices"))
-    itemlist.append(item.clone(title="Buscar...", action="search", text_color=color4))
-    itemlist.append(item.clone(action="configuracion", title="Configurar canal...", text_color="gold", folder=False))
-
-    return itemlist
-
-
-def configuracion(item):
-    from platformcode import platformtools
-    ret = platformtools.show_channel_settings()
-    platformtools.itemlist_refresh()
-    return ret
-
-
-def search(item, texto):
-    logger.info()
-    texto = texto.replace(" ", "+")
-    try:
-        item.url = "%s/search.php?q1=%s" % (host, texto)
-        item.action = "busqueda"
-        item.page = 0
-        return busqueda(item)
-    # Se captura la excepción, para no interrumpir al buscador global si un canal falla
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("%s" % line)
-        return []
-
-
-def entradas(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    bloque = scrapertools.find_single_match(data, '<ul class="nav navbar-nav">(.*?)</ul>')
-
-    patron = "<li.*?href='([^']+)'.*?src='([^']+)'.*?>([^<]+)</p>(.*?)</button>"
-    matches = scrapertools.find_multiple_matches(bloque, patron)
-    matches_ = matches[item.page:item.page + 20]
-    for scrapedurl, scrapedthumbnail, scrapedtitle, data_idioma in matches_:
-        idiomas = []
-        if "es.png" in data_idioma:
-            idiomas.append("ESP")
-        if "la.png" in data_idioma:
-            idiomas.append("LAT")
-        if "vos.png" in data_idioma:
-            idiomas.append("VOSE")
-
-        titulo = scrapedtitle
-        if idiomas:
-            titulo += "  [%s]" % "/".join(idiomas)
-
-        scrapedurl = host + scrapedurl
-        scrapedthumbnail = scrapedthumbnail.replace("/w342/", "/w500/")
-        filtro_thumb = scrapedthumbnail.replace("https://image.tmdb.org/t/p/w500", "")
-        filtro = {"poster_path": filtro_thumb}.items()
-        itemlist.append(Item(channel=item.channel, action="findvideos", url=scrapedurl, title=titulo,
-                             contentTitle=scrapedtitle, infoLabels={'filtro': filtro}, text_color=color2,
-                             thumbnail=scrapedthumbnail, contentType="movie", fulltitle=scrapedtitle, language =
-                             idiomas))
-
-    tmdb.set_infoLabels_itemlist(itemlist, __modo_grafico__)
-    if len(matches) > item.page + 20:
-        page = item.page + 20
-        itemlist.append(item.clone(title=">> Página Siguiente", page=page, text_color=color3))
-
-    return itemlist
-
-
-def updated(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    bloque = scrapertools.find_single_match(data, '<ul class="nav navbar-nav">(.*?)</ul>')
-
-    matches = scrapertools.find_multiple_matches(bloque, "<li.*?href='([^']+)'.*?src='([^']+)'.*?>([^<]+)</p>")
-    matches_ = matches[item.page:item.page + 20]
-    for scrapedurl, scrapedthumbnail, scrapedtitle in matches_:
-        if scrapedtitle == "Today":
-            continue
-        scrapedurl = host + scrapedurl
-        scrapedthumbnail = scrapedthumbnail.replace("/w342/", "/w500/")
-        filtro_thumb = scrapedthumbnail.replace("https://image.tmdb.org/t/p/w500", "")
-        filtro = {"poster_path": filtro_thumb}.items()
-        itemlist.append(Item(channel=item.channel, action="findvideos", url=scrapedurl, title=scrapedtitle,
-                             contentTitle=scrapedtitle, infoLabels={'filtro': filtro}, text_color=color2,
-                             thumbnail=scrapedthumbnail, contentType="movie", fulltitle=scrapedtitle))
-
-    tmdb.set_infoLabels_itemlist(itemlist, __modo_grafico__)
-    if len(matches) > item.page + 20:
-        page = item.page + 20
-        itemlist.append(item.clone(title=">> Página Siguiente", page=page, text_color=color3))
-    else:
-        next = scrapertools.find_single_match(data, '<a href="([^"]+)">>>')
-        if next:
-            next = item.url + next
-            itemlist.append(item.clone(title=">> Página Siguiente", page=0, url=next, text_color=color3))
-
-    return itemlist
-
-
-def busqueda(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-    bloque = scrapertools.find_single_match(data, '<ul class="nav navbar-nav">(.*?)</ul>')
-
-    matches = scrapertools.find_multiple_matches(bloque, "<li.*?href='([^']+)'.*?src='([^']+)'.*?>\s*([^<]+)</a>")
-    matches_ = matches[item.page:item.page + 25]
-    for scrapedurl, scrapedthumbnail, scrapedtitle in matches_:
-        scrapedurl = host + scrapedurl
-        scrapedthumbnail = scrapedthumbnail.replace("/w342/", "/w500/")
-        if re.search(r"\(\d{4}\)", scrapedtitle):
-            title = scrapedtitle.rsplit("(", 1)[0]
-            year = scrapertools.find_single_match(scrapedtitle, '\((\d{4})\)')
-            infoLabels = {'year': year}
-        else:
-            title = scrapedtitle
-            filtro_thumb = scrapedthumbnail.replace("https://image.tmdb.org/t/p/w500", "")
-            filtro = {"poster_path": filtro_thumb}.items()
-            infoLabels = {'filtro': filtro}
-        itemlist.append(Item(channel=item.channel, action="findvideos", url=scrapedurl, title=scrapedtitle,
-                             contentTitle=title, infoLabels=infoLabels, text_color=color2,
-                             thumbnail=scrapedthumbnail, contentType="movie", fulltitle=title))
-
-    tmdb.set_infoLabels_itemlist(itemlist, __modo_grafico__)
-    if len(matches) > item.page + 25:
-        page = item.page + 25
-        itemlist.append(item.clone(title=">> Página Siguiente", page=page, text_color=color3))
-    else:
-        next = scrapertools.find_single_match(data, '<a href="([^"]+)">>>')
-        if next:
-            next = item.url + next
-            itemlist.append(item.clone(title=">> Página Siguiente", page=0, url=next, text_color=color3))
-
-    return itemlist
-
-
-def indices(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(host).data
-
-    matches = scrapertools.find_multiple_matches(data,
-                                                 '<li><a href="([^"]+)"><i class="fa fa-bookmark-o"></i>\s*(.*?)</a>')
-    for scrapedurl, scrapedtitle in matches:
-        scrapedurl = host + scrapedurl
-        itemlist.append(item.clone(action="updated", url=scrapedurl, title=scrapedtitle, page=0))
-
-    return itemlist
-
-
-def findvideos(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-
-    patron = '<div class="grid_content2 sno">.*?src="([^"]+)".*?href="([^"]+)".*?src=\'(.*?)(?:.png|.jpg)\'' \
-             '.*?<span>.*?<span>(.*?)</span>.*?<span>(.*?)</span>'
-    matches = scrapertools.find_multiple_matches(data, patron)
-    for idioma, url, servidor, calidad, detalle in matches:
-        url = host + url
-        servidor = servidor.rsplit("/", 1)[1]
-        servidor = servidor.replace("uploaded", "uploadedto").replace("streamin.to", "streaminto")
-        if "streamix" in servidor:
-            servidor = "streamixcloud"
-        try:
-            servers_module = __import__("servers." + servidor)
-            mostrar_server = servertools.is_server_enabled(servidor)
-            if not mostrar_server:
-                continue
-        except:
-            continue
-
-        if "es.png" in idioma:
-            idioma = "ESP"
-        elif "la.png" in idioma:
-            idioma = "LAT"
-        elif "vos.png" in idioma:
-            idioma = "VOSE"
-
-        title = "%s - %s - %s" % (servidor, idioma, calidad)
-        if detalle:
-            title += " (%s)" % detalle
-
-        itemlist.append(item.clone(action="play", url=url, title=title, server=servidor, text_color=color3,
-                                   language = idioma, quality = calidad))
-
-    if item.extra != "findvideos" and config.get_videolibrary_support():
-        itemlist.append(item.clone(title="Añadir película a la videoteca", action="add_pelicula_to_library",
-                                   extra="findvideos", text_color="green"))
-
-    return itemlist
-
-
-def play(item):
-    logger.info()
-    itemlist = []
-
-    data = httptools.downloadpage(item.url).data
-
-    url = scrapertools.find_single_match(data, 'window.open\("([^"]+)"')
-    enlaces = servertools.findvideosbyserver(url, item.server)
-    if enlaces:
-        itemlist.append(item.clone(action="play", url=enlaces[0][1]))
-    else:
-        enlaces = servertools.findvideos(url, True)
-        if enlaces:
-            itemlist.append(item.clone(action="play", server=enlaces[0][2], url=enlaces[0][1]))
-
-    return itemlist
-
-def newest(categoria):
-    logger.info()
-    itemlist = []
-    item = Item()
-    item.page = 0
-    try:
-        if categoria == "terror":
-            item.url = host +"/listado/terror/"
-            item.action = "updated"
-            itemlist = updated(item)
-        elif categoria == 'castellano':
-            item.url = host + "/estrenos/es/"
-            item.action = "entradas"
-
-        elif categoria == 'latino':
-            item.url = host + "/estrenos/la/"
-            item.action = "entradas"
-
-        if categoria != 'terror':
-            itemlist = entradas(item)
-
-
-        if itemlist[-1].action == item.action:
-            itemlist.pop()
-
-    # Se captura la excepción, para no interrumpir al canal novedades si un canal falla
-    except:
-        import sys
-        for line in sys.exc_info():
-            logger.error("{0}".format(line))
-        return []
-
-    return itemlist
-
diff --git a/plugin.video.alfa/channels/locopelis.py b/plugin.video.alfa/channels/locopelis.py
index f2649077..d22648dc 100755
--- a/plugin.video.alfa/channels/locopelis.py
+++ b/plugin.video.alfa/channels/locopelis.py
@@ -2,15 +2,21 @@
 
 import re
 import urlparse
+import urllib
 
 from channels import autoplay
 from channels import filtertools
 from core import httptools
 from core import scrapertools
+from core import servertools
+from core import jsontools
 from core import tmdb
 from core.item import Item
 from platformcode import config, logger
 from channelselector import get_thumb
+
+
+
 IDIOMAS = {'Latino': 'Latino', 'Español': 'Español', 'Sub español': 'VOS'}
 list_language = IDIOMAS.values()
 list_quality = []
@@ -18,12 +24,18 @@ list_servers = [
     'openload',
 ]
 
-host = 'http://www.locopelis.com/'
+host = 'https://www.locopelis.com/'
 
 audio = {'Latino': '[COLOR limegreen]LATINO[/COLOR]', 'Español': '[COLOR yellow]ESPAÑOL[/COLOR]',
          'Sub Español': '[COLOR red]SUB ESPAÑOL[/COLOR]'}
 
 
+def get_source(url):
+    logger.info()
+    data = httptools.downloadpage(url).data
+    data = re.sub(r'"|\n|\r|\t|&nbsp;|<br>|\s{2,}', "", data)
+    return data
+
 def mainlist(item):
     logger.info()
     autoplay.init(item.channel, list_servers, list_quality)
@@ -127,8 +139,6 @@ def todas(item):
         idioma = scrapertools.decodeHtmlentities(idioma_id)
         # if idioma == 'Espa&ntilde;ol':
         #    idioma ='Español'
-        logger.debug('idioma original: %s' % idioma_id)
-        logger.debug('idioma: %s' % idioma)
         if idioma in audio:
             idioma = audio[idioma]
 
@@ -338,24 +348,27 @@ def search(item, texto):
         return []
 
 
+def get_link(data):
+    new_url = scrapertools.find_single_match(data, '(?:IFRAME|iframe) src=(.*?) scrolling')
+    return new_url
+
 def findvideos(item):
     logger.info()
-    itemlist = []
-    data = httptools.downloadpage(item.url).data
 
-    from core import servertools
-    itemlist.extend(servertools.find_video_items(data=data))
-    if item.language == 'Espa&ntilde;ol':
-        item.language == 'Español'
-    for videoitem in itemlist:
-        videoitem.language = IDIOMAS[item.language]
-        videoitem.title = item.contentTitle + ' (' + videoitem.server + ') (' + videoitem.language + ')'
-        videoitem.channel = item.channel
-        videoitem.folder = False
-        videoitem.extra = item.thumbnail
-        videoitem.fulltitle = item.title
-        videoitem.quality = 'default'
-        videoitem.infoLabels = item.infoLabels
+    itemlist = []
+    new_url = get_link(get_source(item.url))
+    new_url = get_link(get_source(new_url))
+    video_id = scrapertools.find_single_match(new_url, 'http.*?h=(\w+)')
+    new_url = '%s%s' % (host, 'playeropstream/api.php')
+    post = {'h': video_id}
+    post = urllib.urlencode(post)
+    data = httptools.downloadpage(new_url, post=post).data
+    json_data = jsontools.load(data)
+    url = json_data['url']
+    server = servertools.get_server_from_url(url)
+    title = '%s [%s]' % (server, item.language)
+    itemlist.append(Item(channel=item.channel, title=title, url=url, action='play', language=item.language,
+                         server=server, infoLabels=item.infoLabels))
 
     # Requerido para FilterTools
 
diff --git a/plugin.video.alfa/channels/mejortorrent.json b/plugin.video.alfa/channels/mejortorrent.json
index f8a27b94..7cc93f83 100755
--- a/plugin.video.alfa/channels/mejortorrent.json
+++ b/plugin.video.alfa/channels/mejortorrent.json
@@ -1,18 +1,17 @@
 {
-  "active": true, 
-  "adult": false, 
-  "banner": "mejortorrent.png", 
+  "id": "mejortorrent",
+  "name": "Mejor Torrent",
+  "active": true,
+  "adult": false,
+  "language": ["*"],
+  "thumbnail": "thumb_intervenido_pn.jpeg",
+  "banner": "mejortorrent.png",
   "categories": [
-    "torrent", 
-    "movie", 
-    "tvshow", 
+    "torrent",
+    "movie",
+    "tvshow",
     "documentary"
-  ], 
-  "id": "mejortorrent", 
-  "language": [
-    "*"
-  ], 
-  "name": "Mejor Torrent", 
+  ],
   "settings": [
     {
       "default": "http://www.mejortorrent.com/", 
@@ -62,6 +61,5 @@
       "type": "bool", 
       "visible": true
     }
-  ], 
-  "thumbnail": ", thumb_intervenido_pn.jpeg"
+  ]
 }
\ No newline at end of file
diff --git a/plugin.video.alfa/channels/mejortorrent1.py b/plugin.video.alfa/channels/mejortorrent1.py
index cae2136d..1b746fa8 100644
--- a/plugin.video.alfa/channels/mejortorrent1.py
+++ b/plugin.video.alfa/channels/mejortorrent1.py
@@ -515,6 +515,7 @@ def listado_busqueda(item):
     while cnt_title <= cnt_tot and cnt_next < 5:
         
         status = False      # Calidad de los datos leídos
+        data = ''
         try:
             data = re.sub(r"\n|\r|\t|\s{2,}", "", httptools.downloadpage(url_next_page, post=item.post).data)
             data = re.sub('\r\n', '', data).decode('utf8').encode('utf8')
@@ -851,10 +852,14 @@ def episodios(item):
         tmdb.set_infoLabels(item, True)
 
     # Carga la página
+    data = ''
     try:
         data = re.sub(r"\n|\r|\t|\s{2}|(<!--.*?-->)", "", httptools.downloadpage(item.url).data)
         data = data.replace('"', "'")
     except:                                                                             #Algún error de proceso, salimos
+        pass
+        
+    if not data:
         logger.error("ERROR 01: EPISODIOS: La Web no responde o la URL es erronea" + item.url)
         itemlist.append(item.clone(action='', title=item.channel.capitalize() + ': ERROR 01: EPISODIOS:.  La Web no responde o la URL es erronea. Si la Web está activa, reportar el error con el log'))
         return itemlist
diff --git a/plugin.video.alfa/channels/newpct1.py b/plugin.video.alfa/channels/newpct1.py
index d0f6330f..89a6f77e 100644
--- a/plugin.video.alfa/channels/newpct1.py
+++ b/plugin.video.alfa/channels/newpct1.py
@@ -61,6 +61,11 @@ elif fecha_rango == 3: fecha_rango = 'Mes'
 elif fecha_rango == 4: fecha_rango = 'Siempre'
 episodio_serie = config.get_setting('clonenewpct1_serie_episodio_novedades', channel_py)    #Episodio o serie para Novedades
 
+#Temporal, sólo para actualizar newpct1_data.json con otro valor por defecto
+channel_banned = config.get_setting('clonenewpct1_excluir1_enlaces_veronline', channel_py)  #1er Canal baneado
+if channel_banned == 9:
+    config.set_setting('clonenewpct1_excluir1_enlaces_veronline', 22, channel_py)           #se pone el nuevo valor por defecto
+
 
 def mainlist(item):
     logger.info()
@@ -129,6 +134,13 @@ def submenu(item):
     patron = '<li><a\s?class="[^"]+"\s?href="http:[^"]+"><i\s?class=.*><\/i>.*Inicio<\/a><\/li>(.+)<\/ul>\s?<\/nav>'
     #Verificamos si se ha cargado una página, y si además tiene la estructura correcta
     if not data or not scrapertools.find_single_match(data, patron):
+        item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+        if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+            for clone_inter, autoridad in item.intervencion:
+                thumb_intervenido = get_thumb(autoridad)
+                itemlist.append(item.clone(action='', title="[COLOR yellow]" + clone_inter.capitalize() + ': [/COLOR]' + intervenido_judicial + '. Reportar el problema en el foro', thumbnail=thumb_intervenido))
+            return itemlist                                                     #Salimos
+        
         logger.error("ERROR 01: SUBMENU: La Web no responde o ha cambiado de URL: " + item.url + data)
         #Si no hay datos consistentes, llamamos al método de fail_over para que encuentre un canal que esté activo y pueda gestionar el submenú
         item, data = generictools.fail_over_newpct1(item, patron)
@@ -206,6 +218,13 @@ def submenu_novedades(item):
     patron = '<div class="content">.*?<ul class="noticias'
     #Verificamos si se ha cargado una página, y si además tiene la estructura correcta
     if not data or not scrapertools.find_single_match(data, patron):
+        item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+        if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+            for clone_inter, autoridad in item.intervencion:
+                thumb_intervenido = get_thumb(autoridad)
+                itemlist.append(item.clone(action='', title="[COLOR yellow]" + clone_inter.capitalize() + ': [/COLOR]' + intervenido_judicial + '. Reportar el problema en el foro', thumbnail=thumb_intervenido))
+            return itemlist                                                     #Salimos
+        
         logger.error("ERROR 01: SUBMENU: La Web no responde o ha cambiado de URL: " + item.url + data)
         #Si no hay datos consistentes, llamamos al método de fail_over para que encuentre un canal que esté activo y pueda gestionar el submenú
         item, data = generictools.fail_over_newpct1(item, patron)
@@ -274,6 +293,13 @@ def alfabeto(item):
 
     patron = '<ul class="alfabeto">(.*?)</ul>'
     if not data or not scrapertools.find_single_match(data, patron):
+        item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+        if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+            for clone_inter, autoridad in item.intervencion:
+                thumb_intervenido = get_thumb(autoridad)
+                itemlist.append(item.clone(action='', title="[COLOR yellow]" + clone_inter.capitalize() + ': [/COLOR]' + intervenido_judicial + '. Reportar el problema en el foro', thumbnail=thumb_intervenido))
+            return itemlist                                                     #Salimos
+        
         logger.error("ERROR 01: ALFABETO: La Web no responde o ha cambiado de URL: " + item.url + data)
         #Si no hay datos consistentes, llamamos al método de fail_over para que encuentre un canal que esté activo y pueda gestionar el submenú
         item, data = generictools.fail_over_newpct1(item, patron)
@@ -325,6 +351,11 @@ def listado(item):
     
     patron = '<ul class="' + clase + '">(.*?)</ul>'     #seleccionamos el bloque que nos interesa
     if not data or (not scrapertools.find_single_match(data, patron) and not '<h3><strong>( 0 ) Resultados encontrados </strong>' in data):
+        item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+        if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+            item, itemlist = generictools.post_tmdb_listado(item, itemlist)     #Llamamos al método para el pintado del error
+            return itemlist                                                     #Salimos
+            
         logger.error("ERROR 01: LISTADO: La Web no responde o ha cambiado de URL: " + item.url + " / DATA: " + data)
         #Si no hay datos consistentes, llamamos al método de fail_over para que encuentre un canal que esté activo y pueda gestionar el submenú
         item, data = generictools.fail_over_newpct1(item, patron)
@@ -645,6 +676,7 @@ def listado_busqueda(item):
     #Máximo num. de líneas permitidas por TMDB. Máx de 5 páginas por Itemlist para no degradar el rendimiento
     while cnt_title <= cnt_tot and cnt_next < 5:
 
+        data = ''
         try:
             data = re.sub(r"\n|\r|\t|\s{2,}", "", httptools.downloadpage(item.url, post=item.post, timeout=timeout_search).data)
         except:
@@ -656,6 +688,11 @@ def listado_busqueda(item):
         else:
             pattern = '<ul class="%s">(.*?)</ul>' % item.pattern                #seleccionamos el bloque que nos interesa
         if not data or (not scrapertools.find_single_match(data, pattern) and not '<h3><strong>( 0 ) Resultados encontrados </strong>' in data):
+            item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+            if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+                item, itemlist = generictools.post_tmdb_listado(item, itemlist)     #Llamamos al método para el pintado del error
+                return itemlist                                                     #Salimos
+            
             logger.error("ERROR 01: LISTADO_BUSQUEDA: La Web no responde o ha cambiado de URL: " + item.url + item.post + " / DATA: " + data)
             #Si no hay datos consistentes, llamamos al método de fail_over para que encuentre un canal que esté activo y pueda gestionar el submenú
             item, data = generictools.fail_over_newpct1(item, pattern)
@@ -1231,6 +1268,11 @@ def findvideos(item):
     patron = 'class="btn-torrent">.*?window.location.href = "(.*?)";'       #Patron para .torrent
     #Verificamos si se ha cargado una página, y si además tiene la estructura correcta
     if not data or not scrapertools.find_single_match(data, patron):
+        item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+        if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+            item, itemlist = generictools.post_tmdb_findvideos(item, itemlist)  #Llamamos al método para el pintado del error
+            return itemlist                                                     #Salimos
+        
         logger.error("ERROR 01: FINDVIDEOS: La Web no responde o la URL es erronea: " + item.url + " / DATA: " + data)
         
         #Si no hay datos consistentes, llamamos al método de fail_over para que encuentre un canal que esté activo y pueda gestionar el vídeo
@@ -1526,6 +1568,11 @@ def episodios(item):
             
     #Verificamos si se ha cargado una página, y si además tiene la estructura correcta
     if not data_alt or not scrapertools.find_single_match(data_alt, pattern):
+        item = generictools.web_intervenida(item, data)                         #Verificamos que no haya sido clausurada
+        if item.intervencion:                                                   #Sí ha sido clausurada judicialmente
+            item, itemlist = generictools.post_tmdb_episodios(item, itemlist)   #Llamamos al método para el pintado del error
+            return itemlist                                                     #Salimos
+        
         logger.error("ERROR 01: EPISODIOS: La Web no responde o la URL es erronea: " + item.url)
         logger.error(pattern + data)
 
diff --git a/plugin.video.alfa/channels/poseidonhd.py b/plugin.video.alfa/channels/poseidonhd.py
index f623a0f8..b3945d79 100644
--- a/plugin.video.alfa/channels/poseidonhd.py
+++ b/plugin.video.alfa/channels/poseidonhd.py
@@ -197,11 +197,11 @@ def seasons(item):
     if config.get_videolibrary_support() and len(itemlist) > 0:
         itemlist.append(
                 Item(channel=item.channel, title='[COLOR yellow]Añadir esta serie a la videoteca[/COLOR]', url=item.url,
-                     action="add_serie_to_library", extra="all_episodes", contentSerieName=item.contentSerieName))
+                     action="add_serie_to_library", extra="episodios", contentSerieName=item.contentSerieName))
 
     return itemlist
 
-def all_episodes(item):
+def episodios(item):
     logger.info()
     itemlist = []
     templist = seasons(item)
@@ -261,20 +261,36 @@ def findvideos(item):
                 subs = 'https:%s' % sub
 
             if 'index' in url:
-                file_id = scrapertools.find_single_match(url, 'file=(.*?)&')
-                post = {'link': file_id}
-                post = urllib.urlencode(post)
-                hidden_url = 'https://streamango.poseidonhd.net/repro/plugins/gkpluginsphp.php'
-                data_url = httptools.downloadpage(hidden_url, post=post).data
-                dict_vip_url = jsontools.load(data_url)
-                url = dict_vip_url['link']
+                try:
+                    file_id = scrapertools.find_single_match(url, 'file=(.*?)&')
+                    post = {'link': file_id}
+                    post = urllib.urlencode(post)
+                    hidden_url = 'https://streamango.poseidonhd.net/repro/plugins/gkpluginsphp.php'
+                    data_url = httptools.downloadpage(hidden_url, post=post).data
+                    dict_vip_url = jsontools.load(data_url)
+                    url = dict_vip_url['link']
+                except:
+                    pass
             else:
-                file_id = scrapertools.find_single_match(url, 'url=(.*?)&')
-                post = {'url': file_id}
-                post = urllib.urlencode(post)
-                hidden_url = 'https://streamango.poseidonhd.net/repro/r.php'
-                data_url = httptools.downloadpage(hidden_url, post=post, follow_redirects=False)
-                url = data_url.headers['location']
+                try:
+
+                    if 'openload' in url:
+                        file_id = scrapertools.find_single_match(url, 'h=(\w+)')
+                        post = {'h': file_id}
+                        post = urllib.urlencode(post)
+                        hidden_url = 'https://streamango.poseidonhd.net/repro/openload/api.php'
+                        data_url = httptools.downloadpage(hidden_url, post=post, follow_redirects=False).data
+                        json_data = jsontools.load(data_url)
+                        url = json_data['url']
+                    else:
+                        file_id = scrapertools.find_single_match(url, 'url=(.*?)&')
+                        post = {'url': file_id}
+                        post = urllib.urlencode(post)
+                        hidden_url = 'https://streamango.poseidonhd.net/repro/r.php'
+                        data_url = httptools.downloadpage(hidden_url, post=post, follow_redirects=False)
+                        url = data_url.headers['location']
+                except:
+                    pass
 
             itemlist.append(item.clone(title = '[%s] [%s]', url=url, action='play', subtitle=subs,
                             language=language, quality=quality, infoLabels=item.infoLabels))
diff --git a/plugin.video.alfa/channels/search.py b/plugin.video.alfa/channels/search.py
index 1b0eba5c..a07e4d89 100644
--- a/plugin.video.alfa/channels/search.py
+++ b/plugin.video.alfa/channels/search.py
@@ -84,12 +84,12 @@ def sub_menu(item):
                 "action": "setting_channel",
                 "channel": item.channel}]
     itemlist.append(Item(channel=item.channel, action="search",
-                         title=config.get_localized_string(70276), context=context,
+                         title=config.get_localized_string(30980), context=context,
                          thumbnail=get_thumb("search.png")))
 
     thumbnail = get_thumb("search_star.png")
 
-    itemlist.append(Item(channel='tvmoviedb', title=config.get_localized_string(59999), action="search_",
+    itemlist.append(Item(channel='tvmoviedb', title=config.get_localized_string(70036), action="search_",
                          search={'url': 'search/person', 'language': 'es', 'page': 1}, star=True,
                          thumbnail=thumbnail))
 
diff --git a/plugin.video.alfa/channels/seriesverde.json b/plugin.video.alfa/channels/seriesverde.json
index 8a9a8aeb..a407338a 100644
--- a/plugin.video.alfa/channels/seriesverde.json
+++ b/plugin.video.alfa/channels/seriesverde.json
@@ -1,7 +1,7 @@
 {
   "id": "seriesverde",
   "name": "SeriesVerde",
-  "active": true,
+  "active": false,
   "adult": false,
   "language": ["cast", "lat"],
   "thumbnail": "https://s33.postimg.cc/96dhv4trj/seriesverde.png",
diff --git a/plugin.video.alfa/channels/veseriesonline.json b/plugin.video.alfa/channels/veseriesonline.json
new file mode 100644
index 00000000..19bc192e
--- /dev/null
+++ b/plugin.video.alfa/channels/veseriesonline.json
@@ -0,0 +1,37 @@
+{
+  "id": "veseriesonline",
+  "name": "VeSeriesOnline",
+  "active": true,
+  "adult": false,
+  "language": ["cast", "lat"],
+  "thumbnail": "http://www.veseriesonline.com/wp-content/themes/theme-fb4/images/logo.png",
+  "banner": "",
+  "categories": [
+    "tvshow"
+  ],
+  "settings": [
+    {
+      "id": "include_in_global_search",
+      "type": "bool",
+      "label": "Incluir en busqueda global",
+      "default": false,
+      "enabled": false,
+      "visible": false
+    },
+    {
+      "id": "filter_languages",
+      "type": "list",
+      "label": "Mostrar enlaces en idioma...",
+      "default": 0,
+      "enabled": true,
+      "visible": true,
+      "lvalues": [
+        "No filtrar",
+		"Cast",
+		"Lat",
+        "VOSE",
+        "VO"
+      ]
+    }
+  ]
+}
diff --git a/plugin.video.alfa/channels/veseriesonline.pyo b/plugin.video.alfa/channels/veseriesonline.pyo
deleted file mode 100644
index fb8d4a5c..00000000
Binary files a/plugin.video.alfa/channels/veseriesonline.pyo and /dev/null differ
diff --git a/plugin.video.alfa/channels/videolibrary.py b/plugin.video.alfa/channels/videolibrary.py
index 80ffdbe9..0ac027d6 100644
--- a/plugin.video.alfa/channels/videolibrary.py
+++ b/plugin.video.alfa/channels/videolibrary.py
@@ -9,6 +9,7 @@ from core import videolibrarytools
 from core.item import Item
 from platformcode import config, logger
 from platformcode import platformtools
+from lib import generictools
 
 
 def mainlist(item):
@@ -31,7 +32,7 @@ def channel_config(item):
                                                caption=config.get_localized_string(60598))
 
 
-def list_movies(item):
+def list_movies(item, silent=False):
     logger.info()
     itemlist = []
 
@@ -39,6 +40,15 @@ def list_movies(item):
         for f in ficheros:
             if f.endswith(".nfo"):
                 nfo_path = filetools.join(raiz, f)
+                
+                #Sincronizamos las películas vistas desde la videoteca de Kodi con la de Alfa
+                try:
+                    if config.is_xbmc():                #Si es Kodi, lo hacemos
+                        from platformcode import xbmc_videolibrary
+                        xbmc_videolibrary.mark_content_as_watched_on_alfa(nfo_path)
+                except:
+                    pass
+                
                 head_nfo, new_item = videolibrarytools.read_nfo(nfo_path)
 
                 new_item.nfo = nfo_path
@@ -50,6 +60,12 @@ def list_movies(item):
                     # Si se ha eliminado el strm desde la bilbioteca de kodi, no mostrarlo
                     continue
 
+                ###### Redirección al canal NewPct1.py si es un clone, o a otro canal y url si ha intervención judicial
+                try:
+                    new_item, new_item, overwrite = generictools.redirect_clone_newpct1(new_item, head_nfo, new_item, raiz)
+                except:
+                    pass
+                
                 # Menu contextual: Marcar como visto/no visto
                 visto = new_item.library_playcounts.get(os.path.splitext(f)[0], 0)
                 new_item.infoLabels["playcount"] = visto
@@ -85,7 +101,10 @@ def list_movies(item):
                 # logger.debug("new_item: " + new_item.tostring('\n'))
                 itemlist.append(new_item)
 
-    return sorted(itemlist, key=lambda it: it.title.lower())
+    if silent == False:
+        return sorted(itemlist, key=lambda it: it.title.lower())
+    else:
+        return
 
 
 def list_tvshows(item):
@@ -98,6 +117,15 @@ def list_tvshows(item):
             if f == "tvshow.nfo":
                 tvshow_path = filetools.join(raiz, f)
                 # logger.debug(tvshow_path)
+                
+                #Sincronizamos los episodios vistos desde la videoteca de Kodi con la de Alfa
+                try:
+                    if config.is_xbmc():                #Si es Kodi, lo hacemos
+                        from platformcode import xbmc_videolibrary
+                        xbmc_videolibrary.mark_content_as_watched_on_alfa(tvshow_path)
+                except:
+                    pass
+                
                 head_nfo, item_tvshow = videolibrarytools.read_nfo(tvshow_path)
                 item_tvshow.title = item_tvshow.contentTitle
                 item_tvshow.path = raiz
@@ -292,7 +320,6 @@ def get_episodes(item):
 
 def findvideos(item):
     logger.info()
-    from lib import generictools
     # logger.debug("item:\n" + item.tostring('\n'))
 
     itemlist = []
@@ -362,7 +389,7 @@ def findvideos(item):
             platformtools.play_video(item_local)
 
         elif index > 0:
-            filtro_canal = opciones[index].replace(config.get_localized_string(70078), "")
+            filtro_canal = opciones[index].replace(config.get_localized_string(70078), "").strip()
             itemlist = []
 
     for nom_canal, json_path in list_canales.items():
@@ -552,7 +579,7 @@ def mark_content_as_watched2(item):
         # Guardamos los cambios en item.nfo
         if filetools.write(item.nfo, head_nfo + it.tojson()):
             item.infoLabels['playcount'] = item.playcount
-            logger.debug(item.playcount)
+            #logger.debug(item.playcount)
 
            # if  item.contentType == 'episodesss':
                 # Actualizar toda la serie
@@ -569,7 +596,7 @@ def mark_content_as_watched2(item):
 
 def mark_content_as_watched(item):
     logger.info()
-    logger.debug("item:\n" + item.tostring('\n'))
+    #logger.debug("item:\n" + item.tostring('\n'))
 
     if filetools.exists(item.nfo):
         head_nfo, it = videolibrarytools.read_nfo(item.nfo)
diff --git a/plugin.video.alfa/channelselector.py b/plugin.video.alfa/channelselector.py
index 2513e10e..5fd5eff4 100644
--- a/plugin.video.alfa/channelselector.py
+++ b/plugin.video.alfa/channelselector.py
@@ -194,7 +194,7 @@ def filterchannels(category, view="thumb_"):
         if view == "banner_" and "banner" in channel_parameters:
             channel_parameters["thumbnail"] = channel_parameters["banner"]
 
-        channelslist.insert(0, Item(title="Tengo una URL", action="mainlist", channel="url",
+        channelslist.insert(0, Item(title=config.get_localized_string(60088), action="mainlist", channel="url",
                                     thumbnail=channel_parameters["thumbnail"], type="generic", viewmode="list"))
 
     return channelslist
diff --git a/plugin.video.alfa/core/httptools.py b/plugin.video.alfa/core/httptools.py
index ee9195dc..ba6ddde2 100755
--- a/plugin.video.alfa/core/httptools.py
+++ b/plugin.video.alfa/core/httptools.py
@@ -28,7 +28,7 @@ ficherocookies = os.path.join(config.get_data_path(), "cookies.dat")
 
 # Headers por defecto, si no se especifica nada
 default_headers = dict()
-default_headers["User-Agent"] = "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3163.100 Safari/537.36"
+default_headers["User-Agent"] = "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3163.100 Safari/537.36"
 default_headers["Accept"] = "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8"
 default_headers["Accept-Language"] = "es-ES,es;q=0.8,en-US;q=0.5,en;q=0.3"
 default_headers["Accept-Charset"] = "UTF-8"
diff --git a/plugin.video.alfa/lib/generictools.py b/plugin.video.alfa/lib/generictools.py
index 0142ea08..8027c314 100644
--- a/plugin.video.alfa/lib/generictools.py
+++ b/plugin.video.alfa/lib/generictools.py
@@ -27,6 +27,7 @@ channel_py = "newpct1"
 intervenido_judicial = 'Dominio intervenido por la Autoridad Judicial'
 intervenido_policia = '<!--CATEGORY:Judicial_Policia_Nacional'
 intervenido_guardia = '<!--CATEGORY:Judicial_Guardia_Civil'
+intervenido_sucuri = 'Access Denied - Sucuri Website Firewall'
 
 
 def update_title(item):
@@ -664,6 +665,7 @@ def post_tmdb_findvideos(item, itemlist):
     En Itemlist devuelve un Item con el pseudotítulo.  Ahí el canal irá agregando el resto.
     
     """
+    #logger.debug(item)
     
     #Creción de título general del vídeo a visualizar en Findvideos
     itemlist = []
@@ -683,11 +685,12 @@ def post_tmdb_findvideos(item, itemlist):
     if item.infoLabels['temporada_num_episodios'] and item.contentEpisodeNumber <= item.infoLabels['temporada_num_episodios']:
         num_episodios = item.infoLabels['temporada_num_episodios']
 
-    # Obtener la información actualizada del Episodio, si no la hay.  Siempre cuando viene de Videoteca
-    if not item.infoLabels['tmdb_id'] or (not item.infoLabels['episodio_titulo'] and item.contentType == 'episode'):
-        tmdb.set_infoLabels(item, True)
-    elif (not item.infoLabels['tvdb_id'] and item.contentType == 'episode') or item.contentChannel == "videolibrary":
-        tmdb.set_infoLabels(item, True)
+    # Obtener la información actualizada del vídeo.  En una segunda lectura de TMDB da más información que en la primera
+    #if not item.infoLabels['tmdb_id'] or (not item.infoLabels['episodio_titulo'] and item.contentType == 'episode'):
+    #    tmdb.set_infoLabels(item, True)
+    #elif (not item.infoLabels['tvdb_id'] and item.contentType == 'episode') or item.contentChannel == "videolibrary":
+    #    tmdb.set_infoLabels(item, True)
+    tmdb.set_infoLabels(item, True)
     #Restauramos la información de max num. de episodios por temporada despues de TMDB
     try:
         if item.infoLabels['temporada_num_episodios']:
@@ -697,7 +700,7 @@ def post_tmdb_findvideos(item, itemlist):
             item.infoLabels['temporada_num_episodios'] = num_episodios
     except:
         pass
-    
+
     #Quitamos el la categoría o nombre del título, si lo tiene
     if item.contentTitle:
         item.contentTitle = re.sub(r' -%s-' % item.category, '', item.contentTitle)
@@ -721,6 +724,34 @@ def post_tmdb_findvideos(item, itemlist):
 
     if item.quality.lower() in ['gb', 'mb']:
         item.quality = item.quality.replace('GB', 'G B').replace('Gb', 'G b').replace('MB', 'M B').replace('Mb', 'M b')
+
+    #busco "duration" en infoLabels
+    tiempo = 0
+    if item.infoLabels['duration']:
+        tiempo = item.infoLabels['duration']
+    
+    elif item.contentChannel == 'videolibrary':                                     #No hay, viene de la Videoteca? buscamos en la DB
+    #Leo de la BD de Kodi la duración de la película o episodio.  En "from_fields" se pueden poner las columnas que se quiera
+        nun_records = 0
+        if item.contentType == 'movie':
+            nun_records, records = get_field_from_kodi_DB(item, from_fields='c11')  #Leo de la BD de Kodi la duración de la película
+        else:
+            nun_records, records = get_field_from_kodi_DB(item, from_fields='c09')  #Leo de la BD de Kodi la duración del episodio
+        if nun_records > 0:                                                         #Hay registros?
+            #Es un array, busco el campo del registro: añadir en el FOR un fieldX por nueva columna
+            for strFileName, field1 in records: 
+                tiempo = field1
+    
+    try:                                                                                #calculamos el timepo en hh:mm
+        tiempo_final = int(tiempo)                                                      #lo convierto a int, pero puede se null
+        if tiempo_final > 0:                                                            #Si el tiempo está a 0, pasamos
+            if tiempo_final > 700:                                                      #Si está en segundos
+                tiempo_final = tiempo_final / 60                                        #Lo transformo a minutos
+            horas = tiempo_final / 60                                                   #Lo transformo a horas
+            resto = tiempo_final - (horas * 60)                                         #guardo el resto de minutos de la hora
+            item.quality += ' [%s:%s]' % (str(horas).zfill(2), str(resto).zfill(2))     #Lo agrego a Calidad del Servidor
+    except:
+        pass
         
     #Ajustamos el nombre de la categoría
     if item.channel != channel_py:
@@ -783,6 +814,78 @@ def post_tmdb_findvideos(item, itemlist):
     
     return (item, itemlist)
     
+
+def get_field_from_kodi_DB(item, from_fields='*', files='file'):
+    logger.info()
+    """
+        
+    Llamada para leer de la DB de Kodi los campos que se reciben de entrada (from_fields, por defecto "*") del vídeo señalado en Item
+    Obviamente esto solo funciona con Kodi y si la película o serie está catalogada en las Videotecas de Alfa y Kodi
+    Se puede pedir que la búdqueda se haga por archivos (defecto), o por carpeta (series)
+    
+    La llamada es:
+        nun_records, records = generictools.get_field_from_kodi_DB(item, from_fields='cXX[, cYY,...]'[, files = 'file|folder'])
+    
+    Devuelve el num de registros encontrados y los registros.  Es importante que el llamador verifique que "nun_records > 0" antes de tratar "records"
+    
+    """
+
+    FOLDER_MOVIES = config.get_setting("folder_movies")
+    FOLDER_TVSHOWS = config.get_setting("folder_tvshows")
+    VIDEOLIBRARY_PATH = config.get_videolibrary_config_path()
+    
+    if item.contentType == 'movie':                                     #Agrego la carpeta correspondiente al path de la Videoteca
+        path = filetools.join(VIDEOLIBRARY_PATH, FOLDER_MOVIES)
+    else:
+        path = filetools.join(VIDEOLIBRARY_PATH, FOLDER_TVSHOWS)
+
+    raiz, carpetas, ficheros = filetools.walk(path).next()              #listo las series o películas en la Videoteca
+    carpetas = [filetools.join(path, f) for f in carpetas]              #agrego la carpeta del contenido al path
+    for carpeta in carpetas:                                            #busco el contenido seleccionado en la lista de carpetas
+        if item.contentType == 'movie' and (item.contentTitle.lower() in carpeta or item.contentTitle in carpeta):   #Películas?
+            path = carpeta                                              #Almacenamos la carpeta en el path
+            break
+        elif item.contentType in ['tvshow', 'season', 'episode'] and (item.contentSerieName.lower() in carpeta or item.contentSerieName in carpeta):                                   #Series?
+            path = carpeta                                              #Almacenamos la carpeta en el path
+            break
+    
+    file_search = '%'                                                   #Por defecto busca todos los archivos de la carpeta
+    if files == 'file':                                                 #Si se ha pedido son un archivo (defecto), se busca
+        if item.contentType == 'episode':                               #Si es episodio, se pone el nombre, si no de deja %
+            file_search = '%sx%s.strm' % (item.contentSeason, str(item.contentEpisodeNumber).zfill(2))      #Nombre para episodios
+
+    if "\\" in path:                                                    #Ajustamos los / en función de la plataforma
+        path = path.replace("/", "\\")
+        path += "\\"                                                    #Terminamos el path con un /
+    else:
+        path += "/"
+
+    if FOLDER_TVSHOWS in path:                                          #Compruebo si es CINE o SERIE
+        contentType = "episode_view"                                    #Marco la tabla de BBDD de Kodi Video
+    else:
+        contentType = "movie_view"                                      #Marco la tabla de BBDD de Kodi Video
+    path1 = path.replace("\\\\", "\\")                                  #para la SQL solo necesito la carpeta
+    path2 = path.replace("\\", "/")                                     #Formato no Windows
+
+    #Ejecutmos la sentencia SQL
+    if not from_fields:
+        from_fields = '*'
+    else:
+        from_fields = 'strFileName, %s' % from_fields                       #al menos dos campos, porque uno solo genera cosas raras
+    sql = 'select %s from %s where (strPath like "%s" or strPath like "%s") and strFileName like "%s"' % (from_fields, contentType, path1, path2, file_search)
+    nun_records = 0
+    records = None
+    try:
+        if config.is_xbmc():
+            from platformcode import xbmc_videolibrary
+            nun_records, records = xbmc_videolibrary.execute_sql_kodi(sql)      #ejecución de la SQL
+            if nun_records == 0:                                                #hay error?
+                logger.error("Error en la SQL: " + sql + ": 0 registros")       #No estará catalogada o hay un error en el SQL
+    except:
+        pass
+             
+    return (nun_records, records)
+    
     
 def fail_over_newpct1(item, patron, patron2=None, timeout=None):
     logger.info()
@@ -953,11 +1056,16 @@ def web_intervenida(item, data, desactivar=True):
     """
     
     intervencion = ()
-    
-    if intervenido_policia in data or intervenido_guardia in data:      #Verificamos que sea una intervención judicial
-        judicial = 'intervenido_gc.png'                                 #Por defecto thumb de la Benemérita
+    judicial = ''
+
+    #Verificamos que sea una intervención judicial
+    if intervenido_policia in data or intervenido_guardia in data or intervenido_sucuri in data:
+        if intervenido_guardia in data:
+            judicial = 'intervenido_gc.png'                             #thumb de la Benemérita
         if intervenido_policia in data:
             judicial = 'intervenido_pn.jpeg'                            #thumb de la Policia Nacional
+        if intervenido_sucuri in data:
+            judicial = 'intervenido_sucuri.png'                         #thumb de Sucuri
         category = item.category
         if not item.category:
             category = item.channel
@@ -966,7 +1074,7 @@ def web_intervenida(item, data, desactivar=True):
             item.intervencion = []                                      #Si no existe el array, lo creamos
         item.intervencion += [intervencion]                             #Añadimos esta intervención al array
         
-        logger.error("ERROR 99: " + category + ": " + intervenido_judicial + ": " + item.url + ": DESACTIVADO=" + str(desactivar) + " / DATA: " + data)
+        logger.error("ERROR 99: " + category + ": " + judicial + ": " + item.url + ": DESACTIVADO=" + str(desactivar) + " / DATA: " + data)
         
         if desactivar == False:                                         #Si no queremos desactivar el canal, nos vamos
             return item
@@ -979,7 +1087,7 @@ def web_intervenida(item, data, desactivar=True):
         if item.channel == channel_py:                                  #Si es un clone de Newpct1, lo desactivamos
             for settings in json_data['settings']:                      #Se recorren todos los settings
                 if settings['id'] == "clonenewpct1_channels_list":      #Encontramos en setting
-                    action_excluded = scrapertools.find_single_match(settings['default'], "\('\d', '%s', '[^']+', '[^']*', '([^']*)'\)" % item.category.lower())                #extraemos el valor de action_excluded
+                    action_excluded = scrapertools.find_single_match(settings['default'], "\('\d', '%s', '[^']+', '[^']*', '([^']*)'\)" % item.category.lower())               #extraemos el valor de action_excluded
                     if action_excluded:
                         if "intervenido" not in action_excluded:
                             action_excluded += ', %s' % judicial        #Agregamos el thumb de la autoridad judicial
@@ -991,11 +1099,13 @@ def web_intervenida(item, data, desactivar=True):
 
                     break
         else:
-            json_data['active'] = False                                 #Se desactiva el canal
+            #json_data['active'] = False                                 #Se desactiva el canal
             json_data['thumbnail'] = ', thumb_%s' % judicial            #Guardamos el thumb de la autoridad judicial
 
         #Guardamos los cambios hechos en el .json
         try:
+            if item.channel != channel_py:
+                disabled = config.set_setting('enabled', False, item.channel)
             channel_path = filetools.join(config.get_runtime_path(), "channels", item.channel + ".json")
             with open(channel_path, 'w') as outfile:                        #Grabamos el .json actualizado
                 json.dump(json_data, outfile, sort_keys = True, indent = 2, ensure_ascii = False)
@@ -1007,7 +1117,7 @@ def web_intervenida(item, data, desactivar=True):
     return item
 
     
-def redirect_clone_newpct1(item, head_nfo=None, it=None, overwrite=False, path=False):
+def redirect_clone_newpct1(item, head_nfo=None, it=None, path=False, overwrite=False, lookup=False):
     logger.info()
     
     """
@@ -1043,7 +1153,7 @@ def redirect_clone_newpct1(item, head_nfo=None, it=None, overwrite=False, path=F
                             - no:       no acción para videolibrary_service, solo redirige en visionado de videolibrary
         ejemplo: ('1', 'mejortorrent', 'mejortorrent1', 'http://www.mejortorrent.com/', 'https://mejortorrent1.com/', 'auto')
     
-    La llamada recibe el parámetro Item, el .nfo y los devuleve actualizados, así como opcionalmente el parámetro "overwrite· que puede forzar la reescritura de todos los archivos de la serie, y el parámetro "path" si viene de videolibrary_service
+    La llamada recibe el parámetro Item, el .nfo y los devuleve actualizados, así como opcionalmente el parámetro "overwrite· que puede forzar la reescritura de todos los archivos de la serie, y el parámetro "path" si viene de videolibrary_service.  Por último, recibe opcionalmente el parámetro "lookup" si se quiere solo averigurar si habrá migración para ese título, pero sin realizarla.
     
     """
     if not it:
@@ -1060,7 +1170,7 @@ def redirect_clone_newpct1(item, head_nfo=None, it=None, overwrite=False, path=F
         if settings['id'] == "clonenewpct1_channels_list":                  #Encontramos en setting
             fail_over_list = settings['default']                            #Carga lista de clones
         if settings['id'] == "intervenidos_channels_list":                  #Encontramos en setting
-            intervencion = settings['default']                         #Carga lista de clones y canales intervenidos
+            intervencion = settings['default']                              #Carga lista de clones y canales intervenidos
 
     #primero tratamos los clones de Newpct1
     channel_alt = item.channel                                              #Salvamos en nombre del canal o clone
@@ -1069,16 +1179,28 @@ def redirect_clone_newpct1(item, head_nfo=None, it=None, overwrite=False, path=F
         item.channel = channel_py
       
     #Ahora tratamos las webs intervenidas, tranformamos la url, el nfo y borramos los archivos obsoletos de la serie
-    if channel not in intervencion:                                         #Hacemos una lookup para ver si...
+    if channel not in intervencion and channel_alt != 'videolibrary':       #Hacemos una lookup para ver si...
         return (item, it, overwrite)                                        #... el canal/clone está listado
 
     import ast
     intervencion_list = ast.literal_eval(intervencion)                      #Convertir a Array el string
     #logger.debug(intervencion_list)
-    if item.channel != channel_py:
-        channel_enabled = channeltools.is_enabled(item.channel)             #Verificamos que el canal esté inactivo   
+    
+    if lookup == True:
+        overwrite = False                                                   #Solo avisamos si hay cambios
     for activo, canal_org, canal_des, url_org, url_des, patron1, patron2, patron3, patron4, patron5, content_inc, content_exc, ow_force in intervencion_list:
-        if activo == '1' and canal_org == channel_alt:                      #Es esta nuestra entrada?
+        if activo == '1' and (canal_org == channel_alt or channel_alt == 'videolibrary'):     #Es esta nuestra entrada?
+            if channel_alt == 'videolibrary':                               #Viene de videolibrary.list_movies
+                for canal_vid, url_vid in item.library_urls.items():
+                    if canal_org != canal_vid:                      #Miramos si canal_org de la regla está en item.library_urls
+                        continue
+                    else:
+                        channel_alt = canal_org                             #Sí, ponermos el nombre del canal de origen
+                        channel_b = "'%s'" % canal_org
+                        if channel_b in fail_over_list:                     #Si es un clone de Newpct1, se actualiza a newpct1
+                            channel_alt = channel_py
+                if channel_alt == 'videolibrary':
+                    continue
             if item.contentType == "list":                                  #Si viene de Videolibrary, le cambiamos ya el canal
                 if item.channel != channel_py:
                     item.channel = canal_des                                #Cambiamos el canal.  Si es clone, lo hace el canal
@@ -1087,60 +1209,110 @@ def redirect_clone_newpct1(item, head_nfo=None, it=None, overwrite=False, path=F
                 continue
             if item.contentType in content_exc:                             #Está el contenido excluido?
                 continue
-            if channel_enabled and canal_org != canal_des:                  #Si el canal está activo, puede ser solo...
+            if item.channel != channel_py:
+                channel_enabled = channeltools.is_enabled(channel_alt)      #Verificamos que el canal esté inactivo
+                channel_enabled_alt = config.get_setting('enabled', channel_alt)
+                channel_enabled = channel_enabled * channel_enabled_alt     #Si está inactivo en algún sitio, tomamos eso
+            if channel_enabled == 1 and canal_org != canal_des:             #Si el canal está activo, puede ser solo...
                 continue                                                    #... una intervención que afecte solo a una región
-            if ow_force == 'no' and path != False:                          #Queremos que el canal solo visualice sin migración?
-                continue                                                    #Salimos sin tocas archivos
-            item.url = item.url.replace(url_org, url_des)                   #reemplzamos una parte de url
+            if ow_force == 'no' and it.library_urls:                        #Esta regla solo vale para findvideos...
+                continue                                                    #... salidmos si estamos actualizando
+            if lookup == True:                                              #Queremos que el canal solo visualice sin migración?
+                if ow_force != 'no':
+                    overwrite = True                                        #Avisamos que hay cambios
+                continue                                                    #Salimos sin tocar archivos
+            url_total = ''
+            if item.url:
+                url_total = item.url
+            elif not item.url and item.library_urls:
+                url_total = item.library_urls[canal_org]
+            url_total = url_total.replace(url_org, url_des)                 #reemplazamos una parte de url
+            url = ''
             if patron1:                                                     #Hay expresión regex?
-                url = scrapertools.find_single_match(item.url, patron1)     #La aplicamos a url
+                url += scrapertools.find_single_match(url_total, patron1)   #La aplicamos a url
             if patron2:                                                     #Hay más expresión regex?
-                url += scrapertools.find_single_match(item.url, patron2)    #La aplicamos a url
+                url += scrapertools.find_single_match(url_total, patron2)   #La aplicamos a url
             if patron3:                                                     #Hay más expresión regex?
-                url += scrapertools.find_single_match(item.url, patron3)    #La aplicamos a url
+                url += scrapertools.find_single_match(url_total, patron3)   #La aplicamos a url
             if patron4:                                                     #Hay más expresión regex?
-                url += scrapertools.find_single_match(item.url, patron4)    #La aplicamos a url
+                url += scrapertools.find_single_match(url_total, patron4)   #La aplicamos a url
             if patron5:                                                     #Hay más expresión regex?
-                url += scrapertools.find_single_match(item.url, patron5)    #La aplicamos a url
-            item.url = url                                                  #Guardamos la suma de los resultados intermedios
+                url += scrapertools.find_single_match(url_total, patron5)   #La aplicamos a url
+            if url:
+                url_total = url                                             #Guardamos la suma de los resultados intermedios
             update_stat += 1                                                #Ya hemos actualizado algo
+            canal_org_def = canal_org
+            canal_des_def = canal_des
+            ow_force_def = ow_force
             
     if update_stat > 0:                                                 #Ha habido alguna actualización?  Entonces salvamos
-        if item.channel == channel_py:                                  #Si es Newpct1...
+        if item.channel == channel_py or channel in fail_over_list:     #Si es Newpct1...
             if item.contentType == "tvshow":
-                item.url = re.sub(r'\/\d+\/?$', '', item.url)           #parece que con el título  ecuentra la serie, normalmente...
-        if it.url:
-            it.url = item.url                                           #reemplazamos una parte de url en .nfo, aunque no suele haberla
+                url_total = re.sub(r'\/\d+\/?$', '', url_total)         #parece que con el título  ecuentra la serie, normalmente...
+        if item.url:
+            item.url = url_total                                        #Salvamos la url convertida
         if item.library_urls:
-            item.library_urls.pop(canal_org, None)
-            item.library_urls = {canal_des: item.url}
+            item.library_urls.pop(canal_org_def, None)
+            item.library_urls = {canal_des_def: url_total}
             it.library_urls = item.library_urls
-        if item.channel != channel_py:
-            item.channel = canal_des                                    #Cambiamos el canal.  Si es clone, lo hace el canal
+        if item.channel != channel_py and item.channel != 'videolibrary':
+            item.channel = canal_des_def                                #Cambiamos el canal.  Si es clone, lo hace el canal
             if channel_alt == item.category.lower():                    #Actualizamos la Categoría y si la tenía
                 item.category = item.channel.capitalize()
-        if ow_force == 'force':                                         #Queremos que el canal revise la serie entera?
-            item.ow_force = "1"                                         #Se lo decimos
-        if ow_force in ['force', 'auto']:                               #Sobreescribir la series?
-            overwrite = ow_force_param                                  #Sí, lo marcamos
+        if ow_force_def == 'force' and item.contentType != "movie":     #Queremos que el canal revise la serie entera?
+            item.ow_force = '1'                                         #Se lo decimos
+        if ow_force_def in ['force', 'auto']:                           #Sobreescribir la series?
+            overwrite = True                                            #Sí, lo marcamos
 
-
-        if item.contentType in ['tvshow', 'season'] and it.library_urls:
-            if path == False:
-                TVSHOWS_PATH = item.path
-            else:
-                TVSHOWS_PATH = path
+        #logger.debug(canal_org_def + canal_des_def + ow_force_def)
+        if it.library_urls and path != False and ow_force_def != 'no':      #Continuamos si hay .nfo, path, y queremos actualizarlo
+            if item.update_next:
+                del item.update_next                                        #Borramos estos campos para forzar la actualización ya
+            if it.update_next:
+                del it.update_next
         
             # Listamos todos los ficheros de la serie, asi evitamos tener que comprobar si existe uno por uno
-            raiz, carpetas_series, ficheros = filetools.walk(TVSHOWS_PATH).next()
-            ficheros = [filetools.join(TVSHOWS_PATH, f) for f in ficheros]          #Almacenamos la lista de archivos de la carpeta
-            canal_erase = '[%s]' % canal_org
+            raiz, carpetas_series, ficheros = filetools.walk(path).next()
+            ficheros = [filetools.join(path, f) for f in ficheros]          #Almacenamos la lista de archivos de la carpeta
+            canal_erase = '[%s]' % canal_org_def
             for archivo in ficheros:
-                if canal_erase in archivo:                                          #Borramos los .json que sean del canal intervenido
+                if canal_erase in archivo:                                  #Borramos los .json que sean del canal intervenido
+                    json_path = archivo.replace(canal_org_def, canal_des_def)   #Salvamos el path del .json para luego crearlo
                     filetools.remove(archivo)
-                if "tvshow.nfo" in archivo:
-                    filetools.write(archivo, head_nfo + it.tojson())                #escribo el .nfo por si aborta update
+                if item.contentType == "movie" and ".nfo" in archivo:
+                    filetools.write(archivo, head_nfo + it.tojson())        #escribo el .nfo de la peli por si aborta update
+                if item.contentType != "movie" and "tvshow.nfo" in archivo:
+                    filetools.write(archivo, head_nfo + it.tojson())        #escribo el tvshow.nfo por si aborta update
+            
+            #Aquí convertimos las películas.  Después de borrado el .json, dejamos que videolibrarytools lo regenere
+            if item.contentType == "movie":                                 #Dejamos que regenere el archivo .json
+                item_movie = item.clone()
+                item_movie.channel = canal_des_def                          #mombre del canal migrado
+                del item_movie.library_playcounts                           #Borramos lo que no es necesario en el .json
+                del item_movie.library_urls
+                item_movie.url = url_total                                  #url migrada
+                del item_movie.nfo
+                del item_movie.path
+                del item_movie.strm_path
+                del item_movie.text_color
+                filetools.write(json_path, item_movie.tojson())             #Salvamos el nuevo .json de la película
 
-    #logger.debug(item)
+    if update_stat > 0 and path != False and ow_force_def != 'no':
+        logger.debug(item)
     
-    return (item, it, overwrite)
\ No newline at end of file
+    return (item, it, overwrite)
+    
+
+def dejuice(data):
+    logger.info()
+    # Metodo para desobfuscar datos de JuicyCodes
+    
+    import base64
+    from lib import jsunpack
+
+    juiced = scrapertools.find_single_match(data, 'JuicyCodes.Run\((.*?)\);')
+    b64_data = juiced.replace('+', '').replace('"', '')
+    b64_decode = base64.b64decode(b64_data)
+    dejuiced = jsunpack.unpack(b64_decode)
+
+    return dejuiced
\ No newline at end of file
diff --git a/plugin.video.alfa/platformcode/platformtools.py b/plugin.video.alfa/platformcode/platformtools.py
index 6852a13f..f7ae5579 100644
--- a/plugin.video.alfa/platformcode/platformtools.py
+++ b/plugin.video.alfa/platformcode/platformtools.py
@@ -127,13 +127,12 @@ def render_items(itemlist, parent_item):
         if 'anime' in channeltools.get_channel_parameters(parent_item.channel)['categories']:
             anime = True
 
-    # Recorremos el itemlist
 
+    unify_enabled = config.get_setting('unify')
+    #logger.debug('unify_enabled: %s' % unify_enabled)
+
+    # Recorremos el itemlist
     for item in itemlist:
-        try:
-            channel_parameters = channeltools.get_channel_parameters(item.channel)
-        except:
-            pass
         #logger.debug(item)
         # Si el item no contiene categoria, le ponemos la del item padre
         if item.category == "":
@@ -143,9 +142,7 @@ def render_items(itemlist, parent_item):
         if item.fanart == "":
             item.fanart = parent_item.fanart
 
-
         if genre:
-
             valid_genre = True
             thumb = get_thumb(item.title, auto=True)
             if thumb != '':
@@ -155,12 +152,7 @@ def render_items(itemlist, parent_item):
                 valid_genre = True
 
 
-        unify_enabled = config.get_setting('unify')
-
-        #logger.debug('unify_enabled: %s' % unify_enabled)
-
-
-        if unify_enabled and not channel_parameters['adult'] and 'skip_unify' not in channel_parameters:
+        if unify_enabled:
             # Formatear titulo con unify
             item = unify.title_format(item)
         else:
diff --git a/plugin.video.alfa/platformcode/xbmc_videolibrary.py b/plugin.video.alfa/platformcode/xbmc_videolibrary.py
index e5f7c982..a5948d5b 100755
--- a/plugin.video.alfa/platformcode/xbmc_videolibrary.py
+++ b/plugin.video.alfa/platformcode/xbmc_videolibrary.py
@@ -319,12 +319,95 @@ def mark_season_as_watched_on_kodi(item, value=1):
     item_path2 = item_path1.replace("\\", "/")
 
     sql = 'update files set playCount= %s where idFile  in ' \
-          '(select idfile from episode_view where strPath like "%s" or strPath like "%s"%s)' % \
+          '(select idfile from episode_view where (strPath like "%s" or strPath like "%s")%s)' % \
           (value, item_path1, item_path2, request_season)
 
     execute_sql_kodi(sql)
 
 
+def mark_content_as_watched_on_alfa(path):
+    from channels import videolibrary
+    from core import videolibrarytools
+    from core import scrapertools
+    import re
+    """
+        marca toda la serie o película como vista o no vista en la Videoteca de Alfa basado en su estado en la Videoteca de Kodi
+        @type str: path
+        @param path: carpeta de contenido a marcar
+        """
+    logger.info()
+    #logger.debug("path: " + path)
+    
+    FOLDER_MOVIES = config.get_setting("folder_movies")
+    FOLDER_TVSHOWS = config.get_setting("folder_tvshows")
+    VIDEOLIBRARY_PATH = config.get_videolibrary_config_path()
+
+    # Solo podemos marcar el contenido como vista en la BBDD de Kodi si la BBDD es local,
+    # en caso de compartir BBDD esta funcionalidad no funcionara
+    #if config.get_setting("db_mode", "videolibrary"):
+    #    return
+    
+    path2 = ''
+    if "special://" in VIDEOLIBRARY_PATH:
+        if FOLDER_TVSHOWS in path:
+            path2 = re. sub(r'.*?%s' % FOLDER_TVSHOWS, VIDEOLIBRARY_PATH + "/" + FOLDER_TVSHOWS, path).replace("\\", "/")
+        if FOLDER_MOVIES in path:
+            path2 = re. sub(r'.*?%s' % FOLDER_MOVIES, VIDEOLIBRARY_PATH + "/" + FOLDER_MOVIES, path).replace("\\", "/")
+
+    if "\\" in path:
+        path = path.replace("/", "\\")
+    head_nfo, item = videolibrarytools.read_nfo(path)                   #Leo el .nfo del contenido
+
+    if FOLDER_TVSHOWS in path:                                          #Compruebo si es CINE o SERIE
+        contentType = "episode_view"                                    #Marco la tabla de BBDD de Kodi Video
+        nfo_name = "tvshow.nfo"                                         #Construyo el nombre del .nfo
+        path1 = path.replace("\\\\", "\\").replace(nfo_name, '')        #para la SQL solo necesito la carpeta
+        if not path2:
+            path2 = path1.replace("\\", "/")                            #Formato no Windows
+        else:
+            path2 = path2.replace(nfo_name, '')
+        
+    else:
+        contentType = "movie_view"                                      #Marco la tabla de BBDD de Kodi Video
+        path1 = path.replace("\\\\", "\\")                              #Formato Windows
+        if not path2:
+            path2 = path1.replace("\\", "/")                            #Formato no Windows
+        nfo_name = scrapertools.find_single_match(path2, '\]\/(.*?)$')  #Construyo el nombre del .nfo
+        path1 = path1.replace(nfo_name, '')                             #para la SQL solo necesito la carpeta
+        path2 = path2.replace(nfo_name, '')                             #para la SQL solo necesito la carpeta
+
+    #Ejecutmos la sentencia SQL
+    sql = 'select strFileName, playCount from %s where (strPath like "%s" or strPath like "%s")' % (contentType, path1, path2)
+    nun_records = 0
+    records = None
+    nun_records, records = execute_sql_kodi(sql)                        #ejecución de la SQL
+    if nun_records == 0:                                                #hay error?
+        logger.error("Error en la SQL: " + sql + ": 0 registros")
+        return                                                          #salimos: o no está catalogado en Kodi, o hay un error en la SQL
+    
+    for title, playCount in records:                                    #Ahora recorremos todos los registros obtenidos
+        if contentType == "episode_view":
+            title_plain = title.replace('.strm', '')                    #Si es Serie, quitamos el sufijo .strm
+        else:
+            title_plain = scrapertools.find_single_match(item.strm_path, '.(.*?\s\[.*?\])') #si es peli, quitamos el título
+        if playCount is None or playCount == 0:                         #todavía no se ha visto, lo ponemos a 0
+            playCount_final = 0
+        elif playCount >= 1:
+            playCount_final = 1
+        title_plain = title_plain.decode("utf-8").encode("utf-8")       #Hacemos esto porque si no genera esto: u'title_plain'
+        item.library_playcounts.update({title_plain: playCount_final})  #actualizamos el playCount del .nfo
+
+    if item.infoLabels['mediatype'] == "tvshow":                        #Actualizamos los playCounts de temporadas y Serie
+        for season in item.library_playcounts:
+            if "season" in season:                                      #buscamos las etiquetas "season" dentro de playCounts
+                season_num = int(scrapertools.find_single_match(season, 'season (\d+)'))    #salvamos el núm, de Temporada
+                item = videolibrary.check_season_playcount(item, season_num)    #llamamos al método que actualiza Temps. y Series
+
+    filetools.write(path, head_nfo + item.tojson())
+    
+    #logger.debug(item)
+    
+    
 def get_data(payload):
     """
     obtiene la información de la llamada JSON-RPC con la información pasada en payload
diff --git a/plugin.video.alfa/resources/language/Spanish (Argentina)/strings.po b/plugin.video.alfa/resources/language/Spanish (Argentina)/strings.po
index f52b1490..eb986820 100644
--- a/plugin.video.alfa/resources/language/Spanish (Argentina)/strings.po	
+++ b/plugin.video.alfa/resources/language/Spanish (Argentina)/strings.po	
@@ -3071,7 +3071,7 @@ msgstr "¿Realmente desea eliminar '%s' de su videoteca?"
 
 msgctxt "#70089"
 msgid "Show only links of %s"
-msgstr "Mostrar solo los enlaces de %s "
+msgstr "Mostrar solo los enlaces de %s"
 
 msgctxt "#70090"
 msgid "    Exclude all streams with specific words"
diff --git a/plugin.video.alfa/resources/language/Spanish (Mexico)/strings.po b/plugin.video.alfa/resources/language/Spanish (Mexico)/strings.po
index f52b1490..eb986820 100644
--- a/plugin.video.alfa/resources/language/Spanish (Mexico)/strings.po	
+++ b/plugin.video.alfa/resources/language/Spanish (Mexico)/strings.po	
@@ -3071,7 +3071,7 @@ msgstr "¿Realmente desea eliminar '%s' de su videoteca?"
 
 msgctxt "#70089"
 msgid "Show only links of %s"
-msgstr "Mostrar solo los enlaces de %s "
+msgstr "Mostrar solo los enlaces de %s"
 
 msgctxt "#70090"
 msgid "    Exclude all streams with specific words"
diff --git a/plugin.video.alfa/resources/language/Spanish/strings.po b/plugin.video.alfa/resources/language/Spanish/strings.po
index f52b1490..eb986820 100644
--- a/plugin.video.alfa/resources/language/Spanish/strings.po
+++ b/plugin.video.alfa/resources/language/Spanish/strings.po
@@ -3071,7 +3071,7 @@ msgstr "¿Realmente desea eliminar '%s' de su videoteca?"
 
 msgctxt "#70089"
 msgid "Show only links of %s"
-msgstr "Mostrar solo los enlaces de %s "
+msgstr "Mostrar solo los enlaces de %s"
 
 msgctxt "#70090"
 msgid "    Exclude all streams with specific words"
diff --git a/plugin.video.alfa/resources/media/channels/fanart/altorrent.jpg b/plugin.video.alfa/resources/media/channels/fanart/altorrent.jpg
new file mode 100644
index 00000000..b0759e2f
Binary files /dev/null and b/plugin.video.alfa/resources/media/channels/fanart/altorrent.jpg differ
diff --git a/plugin.video.alfa/resources/media/channels/thumb/altorrent.png b/plugin.video.alfa/resources/media/channels/thumb/altorrent.png
new file mode 100644
index 00000000..ad5cdb5f
Binary files /dev/null and b/plugin.video.alfa/resources/media/channels/thumb/altorrent.png differ
diff --git a/plugin.video.alfa/resources/media/channels/thumb/thumb_intervenido_sucuri.png b/plugin.video.alfa/resources/media/channels/thumb/thumb_intervenido_sucuri.png
new file mode 100644
index 00000000..7c7f08ee
Binary files /dev/null and b/plugin.video.alfa/resources/media/channels/thumb/thumb_intervenido_sucuri.png differ
diff --git a/plugin.video.alfa/servers/flashx.py b/plugin.video.alfa/servers/flashx.py
index 800d2ad1..987ea410 100644
--- a/plugin.video.alfa/servers/flashx.py
+++ b/plugin.video.alfa/servers/flashx.py
@@ -21,11 +21,11 @@ def get_video_url(page_url, premium=False, user="", password="", video_password=
     pfxfx = ""
     data = httptools.downloadpage(page_url, cookies=False).data
     data = data.replace("\n","")
-    cgi_counter = scrapertools.find_single_match(data, """(?is)src=.(https://www.flashx.cc/counter.cgi.*?[^(?:'|")]+)""")
+    cgi_counter = scrapertools.find_single_match(data, """(?is)src=.(https://www.flashx.co/counter.cgi.*?[^(?:'|")]+)""")
     cgi_counter = cgi_counter.replace("%0A","").replace("%22","")
-    playnow = scrapertools.find_single_match(data, 'https://www.flashx.cc/dl[^"]+')
+    playnow = scrapertools.find_single_match(data, 'https://www.flashx.co/dl[^"]+')
     # Para obtener el f y el fxfx
-    js_fxfx = "https://www." + scrapertools.find_single_match(data.replace("//","/"), """(?is)(flashx.cc/js\w+/c\w+.*?[^(?:'|")]+)""")
+    js_fxfx = "https://www." + scrapertools.find_single_match(data.replace("//","/"), """(?is)(flashx.co/js\w+/c\w+.*?[^(?:'|")]+)""")
     data_fxfx = httptools.downloadpage(js_fxfx).data
     mfxfx = scrapertools.find_single_match(data_fxfx, 'get.*?({.*?})').replace("'","").replace(" ","")
     matches = scrapertools.find_multiple_matches(mfxfx, '(\w+):(\w+)')
@@ -35,7 +35,7 @@ def get_video_url(page_url, premium=False, user="", password="", video_password=
     logger.info("mfxfxfx2= %s" %pfxfx)
     if pfxfx == "":
         pfxfx = "ss=yes&f=fail&fxfx=6"
-    coding_url = 'https://www.flashx.cc/flashx.php?%s' %pfxfx
+    coding_url = 'https://www.flashx.co/flashx.php?%s' %pfxfx
     # {f: 'y', fxfx: '6'}
     bloque = scrapertools.find_single_match(data, '(?s)Form method="POST" action(.*?)span')
     flashx_id = scrapertools.find_single_match(bloque, 'name="id" value="([^"]+)"')
diff --git a/plugin.video.alfa/servers/gamovideo.py b/plugin.video.alfa/servers/gamovideo.py
index cbb32783..b67149ff 100755
--- a/plugin.video.alfa/servers/gamovideo.py
+++ b/plugin.video.alfa/servers/gamovideo.py
@@ -7,8 +7,6 @@ from core import scrapertools
 from lib import jsunpack
 from platformcode import logger
 
-headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:58.0) Gecko/20100101 Firefox/58.0'}
-
 
 def test_video_exists(page_url):
     logger.info("(page_url='%s')" % page_url)
diff --git a/plugin.video.alfa/servers/powvideo.py b/plugin.video.alfa/servers/powvideo.py
index 2696c972..74336d7c 100755
--- a/plugin.video.alfa/servers/powvideo.py
+++ b/plugin.video.alfa/servers/powvideo.py
@@ -30,14 +30,24 @@ def get_video_url(page_url, premium=False, user="", password="", video_password=
 
     packed = scrapertools.find_single_match(data, "<script type=[\"']text/javascript[\"']>(eval.*?)</script>")
     unpacked = jsunpack.unpack(packed)
-
+    
     url = scrapertools.find_single_match(unpacked, "(?:src):\\\\'([^\\\\]+.mp4)\\\\'")
-    itemlist.append([".mp4" + " [powvideo]", decode_powvideo_url(url)])
+
+    a, b = scrapertools.find_single_match(data, "\['splice'\]\(0x([0-9a-fA-F]*),0x([0-9a-fA-F]*)\);")
+    if a and b:
+        url = decode_powvideo_url(url, int(a, 16), int(b, 16))
+    else:
+        logger.debug('No detectado splice! Revisar sistema de decode...')
+
+    itemlist.append([".mp4" + " [powvideo]", url])
     itemlist.sort(key=lambda x: x[0], reverse=True)
     return itemlist
 
-def decode_powvideo_url(url):
+def decode_powvideo_url(url, desde, num):
     tria = re.compile('[0-9a-z]{40,}', re.IGNORECASE).findall(url)[0]
     gira = tria[::-1]
-    x = gira[:1] + gira[2:]
+    if desde == 0:
+        x = gira[num:]
+    else:
+        x = gira[:desde] + gira[(desde+num):]
     return re.sub(tria, x, url)
diff --git a/plugin.video.alfa/servers/vidoza.py b/plugin.video.alfa/servers/vidoza.py
index a7b55f11..934b902d 100755
--- a/plugin.video.alfa/servers/vidoza.py
+++ b/plugin.video.alfa/servers/vidoza.py
@@ -3,6 +3,7 @@
 from core import httptools
 from core import scrapertools
 from platformcode import logger
+from core import jsontools
 
 
 def test_video_exists(page_url):
@@ -20,13 +21,25 @@ def get_video_url(page_url, premium=False, user="", password="", video_password=
     logger.info("(page_url='%s')" % page_url)
     data = httptools.downloadpage(page_url).data
     video_urls = []
-    matches = scrapertools.find_multiple_matches(data, 'src\s*:\s*"([^"]+)".*?label:\'([^\']+)\'')
-    for media_url, calidad in matches:
-        ext = media_url[-4:]
-        video_urls.append(["%s %s [vidoza]" % (ext, calidad), media_url])
+
+    s = scrapertools.find_single_match(data, 'sourcesCode\s*:\s*(\[\{.*?\}\])')
+    s = s.replace('src:', '"src":').replace('file:', '"file":').replace('type:', '"type":').replace('label:', '"label":').replace('res:', '"res":')
+    try:
+        data = jsontools.load(s)
+        for enlace in data:
+            if 'src' in enlace or 'file' in enlace:
+                url = enlace['src'] if 'src' in enlace else enlace['file']
+                tit = ''
+                if 'label' in enlace: tit += '[%s]' % enlace['label']
+                if 'res' in enlace: tit += '[%s]' % enlace['res']
+                if tit == '' and 'type' in enlace: tit = enlace['type']
+                if tit == '': tit = '.mp4'
+                
+                video_urls.append(["%s [vidoza]" % tit, url])
+    except:
+        logger.debug('No se detecta json %s' % s)
+        pass
 
     video_urls.reverse()
-    for video_url in video_urls:
-        logger.info("%s - %s" % (video_url[0], video_url[1]))
 
     return video_urls
diff --git a/plugin.video.alfa/videolibrary_service.py b/plugin.video.alfa/videolibrary_service.py
index f5dfb8f9..ecbde844 100644
--- a/plugin.video.alfa/videolibrary_service.py
+++ b/plugin.video.alfa/videolibrary_service.py
@@ -9,13 +9,13 @@ from core import channeltools, filetools, videolibrarytools
 from platformcode import config, logger
 from platformcode import platformtools
 from channels import videolibrary
+from lib import generictools
 
 
 def update(path, p_dialog, i, t, serie, overwrite):
     logger.info("Actualizando " + path)
-    from lib import generictools
     insertados_total = 0
-
+      
     head_nfo, it = videolibrarytools.read_nfo(path + '/tvshow.nfo')
 
     # logger.debug("%s: %s" %(serie.contentSerieName,str(list_canales) ))
@@ -25,7 +25,7 @@ def update(path, p_dialog, i, t, serie, overwrite):
         
         ###### Redirección al canal NewPct1.py si es un clone, o a otro canal y url si ha intervención judicial
         try:
-            serie, it, overwrite = generictools.redirect_clone_newpct1(serie, head_nfo, it, overwrite, path)
+            serie, it, overwrite = generictools.redirect_clone_newpct1(serie, head_nfo, it, path, overwrite)
         except:
             pass
 
@@ -46,8 +46,6 @@ def update(path, p_dialog, i, t, serie, overwrite):
 
                 obj = imp.load_source(serie.channel, pathchannels)
                 itemlist = obj.episodios(serie)
-                
-                serie.channel = channel             #Restauramos el valor incial del clone de NewPct1
 
                 try:
                     if int(overwrite) == 3:
@@ -80,11 +78,20 @@ def update(path, p_dialog, i, t, serie, overwrite):
         else:
             logger.debug("Canal %s no activo no se actualiza" % serie.channel)
 
+    #Sincronizamos los episodios vistos desde la videoteca de Kodi con la de Alfa
+    try:
+        if config.is_xbmc():                #Si es Kodi, lo hacemos
+            from platformcode import xbmc_videolibrary
+            xbmc_videolibrary.mark_content_as_watched_on_alfa(path + '/tvshow.nfo')
+    except:
+        pass
+    
     return insertados_total > 0
 
 
 def check_for_update(overwrite=True):
     logger.info("Actualizando series...")
+
     p_dialog = None
     serie_actualizada = False
     update_when_finished = False
@@ -108,7 +115,17 @@ def check_for_update(overwrite=True):
             for i, tvshow_file in enumerate(show_list):
                 head_nfo, serie = videolibrarytools.read_nfo(tvshow_file)
                 path = filetools.dirname(tvshow_file)
-
+                
+                ###### Redirección al canal NewPct1.py si es un clone, o a otro canal y url si ha intervención judicial
+                overwrite_forced = False
+                try:
+                    serie, serie, overwrite_forced = generictools.redirect_clone_newpct1(serie, head_nfo, serie, path, overwrite, lookup=True)
+                except:
+                    pass
+                if overwrite_forced == True:
+                    overwrite = True
+                    serie.update_next = ''
+                    
                 logger.info("serie=" + serie.contentSerieName)
                 p_dialog.update(int(math.ceil((i + 1) * t)), heading, serie.contentSerieName)
 
@@ -116,7 +133,16 @@ def check_for_update(overwrite=True):
 
                 if not serie.active:
                     # si la serie no esta activa descartar
-                    continue
+                    if overwrite_forced == False:
+                        #Sincronizamos los episodios vistos desde la videoteca de Kodi con la de Alfa, aunque la serie esté desactivada
+                        try:
+                            if config.is_xbmc():                #Si es Kodi, lo hacemos
+                                from platformcode import xbmc_videolibrary
+                                xbmc_videolibrary.mark_content_as_watched_on_alfa(path + '/tvshow.nfo')
+                        except:
+                            pass
+                    
+                        continue
 
                 # obtenemos las fecha de actualizacion y de la proxima programada para esta serie
                 update_next = serie.update_next
@@ -162,6 +188,7 @@ def check_for_update(overwrite=True):
                     if not serie_actualizada:
                         update_next += datetime.timedelta(days=interval)
 
+                head_nfo, serie = videolibrarytools.read_nfo(tvshow_file)       #Vuelve a leer el.nfo, que ha sido modificado
                 if interval != int(serie.active) or update_next.strftime('%Y-%m-%d') != serie.update_next:
                     serie.active = interval
                     serie.update_next = update_next.strftime('%Y-%m-%d')
@@ -197,6 +224,10 @@ def check_for_update(overwrite=True):
 
         if p_dialog:
             p_dialog.close()
+            
+    from core.item import Item
+    item_dummy = Item()
+    videolibrary.list_movies(item_dummy, silent=True)
 
 
 def start(thread=True):