2278 lines
84 KiB
Python
2278 lines
84 KiB
Python
# -*- coding: utf-8 -*-
|
|
# vStream https://github.com/Kodi-vStream/venom-xbmc-addons
|
|
import imp
|
|
import random
|
|
import time
|
|
import xbmcvfs
|
|
from resources.lib.comaddon import progress, addon, dialog, VSlog, VSPath, isMatrix, xbmc
|
|
from resources.lib.handler.inputParameterHandler import cInputParameterHandler
|
|
from resources.lib.handler.requestHandler import cRequestHandler
|
|
from resources.lib.handler.outputParameterHandler import cOutputParameterHandler
|
|
from resources.lib.util import Quote, cUtil, Unquote
|
|
import resources.sites.ianime as i
|
|
from resources.lib.tmdb import cTMDb
|
|
from resources.lib.gui.gui import cGui
|
|
from resources.lib.gui.guiElement import cGuiElement
|
|
from resources.lib.gui.hoster import cHosterGui
|
|
from resources.lib.handler.premiumHandler import cPremiumHandler
|
|
|
|
try:
|
|
import urllib2
|
|
except ImportError:
|
|
import urllib.request as urllib2
|
|
|
|
try:
|
|
from sqlite3 import dbapi2 as sqlite
|
|
except:
|
|
from pysqlite2 import dbapi2 as sqlite
|
|
|
|
|
|
SITE_IDENTIFIER = 'astroport'
|
|
SITE_NAME = 'ASTROPORT _PROFIL_ (_LOGIN_) (_MDP_)'
|
|
SITE_DESC = 'Partage ~/astroport/films (animes, series) avec ses amis https://gchange.fr (https://cesium.app ) via IPFS'
|
|
|
|
URL_MAIN = 'http://127.0.0.1:8080/ipns/_IPFSNODEID_/._IPFSNODEID_/'
|
|
|
|
KEY_PASTE_ID = 'PASTE_ID'
|
|
SETTING_PASTE_ID = SITE_IDENTIFIER + '_id_'
|
|
SETTING_PASTE_LABEL = SITE_IDENTIFIER + '_label_'
|
|
UNCLASSIFIED_GENRE = '_NON CLASSÉ_'
|
|
UNCLASSIFIED = 'Indéterminé'
|
|
|
|
URL_SEARCH_MOVIES = (URL_MAIN + '&pasteID=' + KEY_PASTE_ID + '&sMedia=film&sSearch=', 'showSearchGlobal')
|
|
URL_SEARCH_SERIES = (URL_MAIN + '&pasteID=' + KEY_PASTE_ID + '&sMedia=serie&sSearch=', 'showSearchGlobal')
|
|
URL_SEARCH_ANIMS = (URL_MAIN + '&pasteID=' + KEY_PASTE_ID + '&sMedia=anime&sSearch=', 'showSearchGlobal')
|
|
URL_SEARCH_DIVERS = (URL_MAIN + '&pasteID=' + KEY_PASTE_ID + '&sMedia=divers&sSearch=', 'showSearchGlobal')
|
|
FUNCTION_SEARCH = 'showSearchGlobal'
|
|
|
|
|
|
CACHE = 'special://home/userdata/addon_data/plugin.video.vstream/%s_cache.db' % SITE_IDENTIFIER
|
|
|
|
if not isMatrix():
|
|
REALCACHE = VSPath(CACHE).decode('utf-8')
|
|
PATH = 'special://home/addons/plugin.video.vstream/resources/lib/pasteCrypt2.pyc'
|
|
else:
|
|
REALCACHE = VSPath(CACHE)
|
|
PATH = 'special://home/addons/plugin.video.vstream/resources/lib/pasteCrypt3.pyc'
|
|
|
|
|
|
def getNbItemParPage():
|
|
nbItem = addon().getSetting(SITE_IDENTIFIER + '_nbItemParPage')
|
|
if not nbItem:
|
|
nbItem = "25"
|
|
addon().setSetting(SITE_IDENTIFIER + '_nbItemParPage', nbItem)
|
|
return int(nbItem)
|
|
|
|
ITEM_PAR_PAGE = getNbItemParPage()
|
|
GROUPE_MAX = 50 # jusqu'à 50 dossiers, limitation du skin
|
|
PASTE_PAR_GROUPE = 100 # jusqu'à 100 liens pastebin par dossier
|
|
|
|
|
|
# Durée du cache, en Heures
|
|
def getCacheDuration():
|
|
cacheDuration = addon().getSetting(SITE_IDENTIFIER + '_cacheDuration')
|
|
if not cacheDuration:
|
|
cacheDuration = "12" # en heure
|
|
addon().setSetting(SITE_IDENTIFIER + '_cacheDuration', cacheDuration)
|
|
return min(int(cacheDuration), 168)
|
|
|
|
CACHE_DURATION = getCacheDuration()
|
|
|
|
|
|
""" GESTION DU CACHE """
|
|
|
|
class PasteCache:
|
|
|
|
def __init__(self):
|
|
|
|
try:
|
|
if not xbmcvfs.exists(CACHE):
|
|
self.db = sqlite.connect(REALCACHE)
|
|
self.db.row_factory = sqlite.Row
|
|
self.dbcur = self.db.cursor()
|
|
self.__createdb()
|
|
return
|
|
except:
|
|
VSlog('Error: Unable to create DB %s' % REALCACHE)
|
|
pass
|
|
|
|
try:
|
|
self.db = sqlite.connect(REALCACHE)
|
|
self.db.row_factory = sqlite.Row
|
|
self.dbcur = self.db.cursor()
|
|
except:
|
|
VSlog('Error: Unable to connect to %s' % REALCACHE)
|
|
pass
|
|
|
|
def __createdb(self):
|
|
|
|
sql_create = "CREATE TABLE IF NOT EXISTS %s ("\
|
|
"paste_id TEXT, "\
|
|
"date FLOAT, "\
|
|
"content BLOB,"\
|
|
"UNIQUE(paste_id)"\
|
|
");" % SITE_IDENTIFIER
|
|
try:
|
|
self.dbcur.execute(sql_create)
|
|
except:
|
|
VSlog('Error: Unable to create table %s' % SITE_IDENTIFIER)
|
|
|
|
self.dbcur.execute(sql_create)
|
|
VSlog('table %s creee' % SITE_IDENTIFIER)
|
|
|
|
def __del__(self):
|
|
""" Cleanup db when object destroyed """
|
|
try:
|
|
self.dbcur.close()
|
|
self.db.close()
|
|
except:
|
|
pass
|
|
|
|
# Récupérer dans le cache
|
|
def read(self, pasteID):
|
|
|
|
try:
|
|
sql_select = 'SELECT * FROM %s WHERE paste_id = \'%s\'' % (SITE_IDENTIFIER, pasteID)
|
|
self.dbcur.execute(sql_select)
|
|
matchedrow = self.dbcur.fetchone()
|
|
except Exception as e:
|
|
VSlog('************* Error selecting from %s db: %s' % (SITE_IDENTIFIER, e), 4)
|
|
return None, False
|
|
|
|
if matchedrow:
|
|
data = dict(matchedrow)
|
|
|
|
# Supprimer les données trop anciennes
|
|
cacheDuration = time.time() - CACHE_DURATION * 3600
|
|
if data['date'] < cacheDuration:
|
|
self.clean(cacheDuration)
|
|
return None, False
|
|
|
|
# Utiliser les données du cache
|
|
if isMatrix():
|
|
content = data['content'].decode("utf-8")
|
|
else:
|
|
content = str(data['content'])
|
|
if content[-1] == '.':
|
|
return content[:-1], True
|
|
return content, False
|
|
else:
|
|
return None, False
|
|
|
|
# Sauvegarde des données dans un cache
|
|
def save(self, pasteID, pasteContent, isMovie):
|
|
|
|
try:
|
|
sql = 'INSERT INTO %s (paste_id, content, date) VALUES (?, ?, ?)' % SITE_IDENTIFIER
|
|
buff = str(pasteContent)
|
|
if isMovie:
|
|
buff += '.'
|
|
|
|
if isMatrix():
|
|
buff = memoryview(bytes(buff, encoding='utf-8'))
|
|
else:
|
|
buff = buffer(buff)
|
|
|
|
self.dbcur.execute(sql, (pasteID, buff, time.time()))
|
|
self.db.commit()
|
|
except Exception as e:
|
|
VSlog('SQL ERROR INSERT into table \'%s\', ID=%s, e=%s' % (SITE_IDENTIFIER, pasteID, e) )
|
|
pass
|
|
|
|
# Suprimer une entrée
|
|
def remove(self, ID):
|
|
|
|
try:
|
|
sql_delete = 'DELETE FROM %s WHERE paste_id = \'%s\'' % (SITE_IDENTIFIER, ID)
|
|
self.dbcur.execute(sql_delete)
|
|
self.db.commit()
|
|
except Exception as e:
|
|
VSlog('************* Error deleting from cache db: %s, e=%s' % (ID, e), 4)
|
|
return None
|
|
|
|
|
|
# Suprimer les données trop anciennes
|
|
def clean(self, cacheDuration):
|
|
|
|
try:
|
|
sql_delete = 'DELETE FROM %s WHERE date < \'%s\'' % (SITE_IDENTIFIER, cacheDuration)
|
|
self.dbcur.execute(sql_delete)
|
|
self.db.commit()
|
|
except Exception as e:
|
|
VSlog('************* Error deleting from %s db: %s' % (SITE_IDENTIFIER, e), 4)
|
|
return None
|
|
|
|
|
|
|
|
# Exemple
|
|
# CAT; TMDB; TITLE; SAISON; YEAR; GENRES; URLS=https://uptobox.com/
|
|
# film;714;Demain ne meurt jamais;James BOND;1997;['Action', 'Aventure', 'Thriller'];['nwxxxx','nwYYzz']
|
|
# serie;48866;Les 100;Saison 2; 2014; ['Fantastique', 'Aventure']; {'S02E01':['lien1', 'lien2'], 'S02E02':['lien1']}
|
|
|
|
# Exemple minimum
|
|
# CAT;TITLE; URLS
|
|
# film;Demain ne meurt jamais;['https://uptobox.com/nwxxxx']
|
|
|
|
class PasteContent:
|
|
CAT = -1 # (Optionnel) - Catégorie 'film', 'serie' 'anime' (Film par défaut)
|
|
TMDB = -1 # (optionnel) - Id TMDB
|
|
TITLE = -1 # Titre du film / épisodes
|
|
SAISON = -1 # (optionnel) - Saison pour les séries (ex 'Saison 03' ou 'S03' ou '03') OU Saga pour les films (ex 'Mission impossible')
|
|
GROUPES = -1 # (optionnel) - Groupes tel que NETFLIX, HBO, MARVEL, DISNEY, Films enfants, ...
|
|
YEAR = -1 # (optionnel) - Année
|
|
GENRES = -1 # (optionnel) - Liste des genres
|
|
RES = -1 # (optionnel) - Résolution (720p, 1080p, 4K, ...)
|
|
DIRECTOR = -1 # (optionnel) - Réalisateur au format id:nom
|
|
CAST = -1 # (optionnel) - Acteurs au format id:nom
|
|
NETWORK = -1 # (optionnel) - Diffuseur au format id:nom
|
|
HEBERGEUR = '' # (optionnel) - URL de l'hebergeur, pour éviter de le mettre dans chaque URL, ex : 'https://uptobox.com/'
|
|
movies = False # Liste des liens, avec épisodes pour les séries
|
|
URLS = -1 # Liste des liens, avec épisodes pour les séries
|
|
chiffrer = None
|
|
cache = None
|
|
keyUpto = None
|
|
keyAlld = None
|
|
keyReald = None
|
|
|
|
# Pour comparer deux pastes, savoir si les champs sont dans le même ordre
|
|
def isFormat(self, other):
|
|
if not isinstance(other, PasteContent):
|
|
return False
|
|
|
|
return self.CAT == other.CAT \
|
|
and self.TMDB == other.TMDB \
|
|
and self.TITLE == other.TITLE \
|
|
and self.SAISON == other.SAISON \
|
|
and self.GROUPES == other.GROUPES \
|
|
and self.YEAR == other.YEAR \
|
|
and self.GENRES == other.GENRES \
|
|
and self.RES == other.RES \
|
|
and self.DIRECTOR == other.DIRECTOR \
|
|
and self.CAST == other.CAST \
|
|
and self.NETWORK == other.NETWORK \
|
|
and self.URLS == other.URLS
|
|
|
|
def getLines(self, pasteBin):
|
|
|
|
sContent, self.movies = self._getCache().read(pasteBin)
|
|
|
|
# Lecture en cache
|
|
if sContent:
|
|
lines = eval(sContent)
|
|
entete = lines[0].split(";")
|
|
|
|
# Lecture sur le site
|
|
else:
|
|
# test si paste accessible
|
|
lines, self.movies = self._decompress(pasteBin)
|
|
if not lines:
|
|
return []
|
|
|
|
# Vérifie si la ligne d'entete existe avec les champs obligatoires
|
|
entete = lines[0].split(";")
|
|
if 'TITLE' not in entete and 'URL' not in entete:
|
|
return []
|
|
self._getCache().save(pasteBin, lines, self.movies)
|
|
|
|
# Calcul des index de chaque champ
|
|
idx = 0
|
|
for champ in entete:
|
|
champ = champ.strip()
|
|
|
|
if 'URL' in champ: # supporte URL ou URLS
|
|
hebergeur = champ.split('=')
|
|
champ = 'URLS'
|
|
if len(hebergeur) > 1:
|
|
self.HEBERGEUR = hebergeur[1].replace(' ', '').replace('"', '').replace('\'', '')
|
|
if champ in dir(self):
|
|
setattr(self, champ, idx)
|
|
idx += 1
|
|
|
|
lines = [k.split(";") for k in lines[1:]]
|
|
|
|
return lines
|
|
|
|
def resolveLink(self, pasteBin, link):
|
|
if not self.movies:
|
|
return self.HEBERGEUR+link
|
|
|
|
if 'uptobox' in self.HEBERGEUR:
|
|
# Recherche d'un compte premium valide
|
|
links = None
|
|
if not self.keyUpto and not self.keyAlld and not self.keyReald:
|
|
self.keyUpto = cPremiumHandler('uptobox').getToken()
|
|
if self.keyUpto:
|
|
links = self._resolveLink(pasteBin, link)
|
|
if not links :
|
|
self.keyUpto = None
|
|
self.keyReald = cPremiumHandler('realdebrid').getToken()
|
|
if self.keyReald:
|
|
links = self._resolveLink(pasteBin, link)
|
|
if not links :
|
|
self.keyReald = None
|
|
self.keyAlld = cPremiumHandler('alldebrid').getToken()
|
|
if self.keyAlld:
|
|
links = self._resolveLink(pasteBin, link)
|
|
if not links :
|
|
self.keyAlld = None
|
|
|
|
# Un compte avec un des trois débrideurs
|
|
if not links and (self.keyUpto or self.keyAlld or self.keyReald):
|
|
links = self._resolveLink(pasteBin, link)
|
|
if not links :
|
|
dialog().VSinfo(err)
|
|
if links:
|
|
return links
|
|
else:
|
|
dialog().VSinfo('Certains liens nécessitent un Compte Premium')
|
|
|
|
return self.HEBERGEUR+link
|
|
|
|
def _resolveLink(self, pasteBin, link):
|
|
|
|
# Un token avec un des trois débrideurs
|
|
if self.keyUpto or self.keyAlld or self.keyReald:
|
|
links = self._getCrypt().resolveLink(pasteBin, link, self.keyUpto, self.keyAlld, self.keyReald)
|
|
if links and len(links)>1:
|
|
l = links[0]
|
|
if l:
|
|
return l
|
|
err = 'Erreur : ' + str(links[1])
|
|
VSlog(err)
|
|
|
|
def _decompress(self, pasteBin):
|
|
|
|
lines = []
|
|
hasMovies = False
|
|
try:
|
|
lines = self._getCrypt().loadFile(pasteBin)
|
|
if lines:
|
|
hasMovies = True
|
|
except Exception as e:
|
|
pass
|
|
|
|
if not hasMovies:
|
|
oRequestHandler = cRequestHandler(URL_MAIN + pasteBin)
|
|
oRequestHandler.setTimeout(4)
|
|
sContent = oRequestHandler.request()
|
|
if sContent.startswith('<'):
|
|
return [], False
|
|
|
|
if sContent.startswith('CAT;'):
|
|
lines = sContent.splitlines()
|
|
|
|
return lines, hasMovies
|
|
|
|
def _getCrypt(self):
|
|
if not self.chiffrer:
|
|
self.chiffrer = imp.load_compiled("Chiffrage", VSPath(PATH)).Crypt()
|
|
return self.chiffrer
|
|
|
|
def _getCache(self):
|
|
if not self.cache:
|
|
self.cache = PasteCache()
|
|
return self.cache
|
|
|
|
|
|
def load():
|
|
addons = addon()
|
|
oGui = cGui()
|
|
|
|
numID = 0
|
|
pasteListe = {}
|
|
|
|
# Recherche des listes déclarées
|
|
for numID in range(1, 50):
|
|
pasteLabel = addons.getSetting(SETTING_PASTE_LABEL + str(numID))
|
|
if pasteLabel:
|
|
pasteListe[pasteLabel] = numID
|
|
|
|
# Trie des dossiers par label
|
|
pasteListe = sorted(pasteListe.items(), key=lambda paste: paste[0])
|
|
|
|
if len(pasteListe) > 0:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
searchUrl = URL_SEARCH_MOVIES[0]
|
|
oOutputParameterHandler.addParameter('siteUrl', searchUrl)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showSearch', 'Recherche (Films)', 'search.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
searchUrl = URL_SEARCH_SERIES[0]
|
|
oOutputParameterHandler.addParameter('siteUrl', searchUrl)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showSearch', 'Recherche (Séries)', 'search.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
searchUrl = URL_SEARCH_ANIMS[0]
|
|
oOutputParameterHandler.addParameter('siteUrl', searchUrl)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showSearch', 'Recherche (Animes)', 'search.png', oOutputParameterHandler)
|
|
|
|
for pasteBin in pasteListe:
|
|
pasteLabel = pasteBin[0]
|
|
pasteID = pasteBin[1]
|
|
|
|
oGuiElement = cGuiElement()
|
|
oGuiElement.setSiteName(SITE_IDENTIFIER)
|
|
oGuiElement.setFunction('showMenu')
|
|
oGuiElement.setTitle(pasteLabel)
|
|
oGuiElement.setIcon("mark.png")
|
|
oGuiElement.setMeta(0)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('pasteID', pasteID)
|
|
oGui.CreateSimpleMenu(oGuiElement, oOutputParameterHandler, SITE_IDENTIFIER, SITE_IDENTIFIER, 'renamePasteName', addons.VSlang(30223))
|
|
oGui.CreateSimpleMenu(oGuiElement, oOutputParameterHandler, SITE_IDENTIFIER, SITE_IDENTIFIER, 'refreshPaste', "Forcer la mise à jour")
|
|
oGui.CreateSimpleMenu(oGuiElement, oOutputParameterHandler, SITE_IDENTIFIER, SITE_IDENTIFIER, 'deletePasteName', addons.VSlang(30412))
|
|
oGui.addFolder(oGuiElement, oOutputParameterHandler)
|
|
|
|
# Menu pour ajouter un dossier (hors widget)
|
|
if not xbmc.getCondVisibility('Window.IsActive(home)'):
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oGui.addDir(SITE_IDENTIFIER, 'addPasteName', '[COLOR coral]Ajouter un dossier %s[/COLOR]' % SITE_NAME, 'listes.png', oOutputParameterHandler)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showMenu():
|
|
addons = addon()
|
|
oGui = cGui()
|
|
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
pasteID = oInputParameterHandler.getValue('pasteID')
|
|
sMedia = oInputParameterHandler.getValue('sMedia')
|
|
|
|
pbContent = PasteContent()
|
|
prefixID = SETTING_PASTE_ID + str(pasteID)
|
|
pasteBin = addons.getSetting(prefixID)
|
|
contenu = getPasteBin(pbContent, pasteBin)
|
|
|
|
for numID in range(1, PASTE_PAR_GROUPE):
|
|
pasteBin = addons.getSetting(prefixID + '_' + str(numID))
|
|
contenu = contenu.union(getPasteBin(pbContent, pasteBin))
|
|
|
|
if not sMedia:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('pasteID', pasteID)
|
|
|
|
cnt = contenu.intersection(['containFilms', 'containSeries', 'containAnimes', 'containDivers'])
|
|
if len(cnt) == 1:
|
|
showDetailMenu(pasteID, contenu)
|
|
else:
|
|
if 'containFilms' in contenu:
|
|
oOutputParameterHandler.addParameter('sMedia', 'film')
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMenu', 'Films', 'films.png', oOutputParameterHandler)
|
|
|
|
if 'containSeries' in contenu:
|
|
oOutputParameterHandler.addParameter('sMedia', 'serie')
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMenu', 'Séries', 'tv.png', oOutputParameterHandler)
|
|
|
|
if 'containAnimes' in contenu:
|
|
oOutputParameterHandler.addParameter('sMedia', 'anime')
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMenu', 'Animes', 'animes.png', oOutputParameterHandler)
|
|
|
|
if 'containDivers' in contenu:
|
|
oOutputParameterHandler.addParameter('sMedia', 'divers')
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMenu', 'Divers', 'buzz.png', oOutputParameterHandler)
|
|
|
|
# Menu pour ajouter un lien (hors widget)
|
|
if not xbmc.getCondVisibility('Window.IsActive(home)'):
|
|
oGui.addDir(SITE_IDENTIFIER, 'addPasteID', '[COLOR coral]Ajouter un code %s[/COLOR]' % SITE_NAME, 'notes.png', oOutputParameterHandler)
|
|
oGui.addDir(SITE_IDENTIFIER, 'adminPasteID', '[COLOR coral]Retirer un code %s[/COLOR]' % SITE_NAME, 'trash.png', oOutputParameterHandler)
|
|
|
|
elif 'film' in sMedia:
|
|
contenu.discard('containSeries')
|
|
contenu.discard('containAnimes')
|
|
contenu.discard('containDivers')
|
|
showDetailMenu(pasteID, contenu)
|
|
elif 'serie' in sMedia:
|
|
contenu.discard('containFilms')
|
|
contenu.discard('containAnimes')
|
|
contenu.discard('containDivers')
|
|
showDetailMenu(pasteID, contenu)
|
|
elif 'anime' in sMedia:
|
|
contenu.discard('containFilms')
|
|
contenu.discard('containSeries')
|
|
contenu.discard('containDivers')
|
|
showDetailMenu(pasteID, contenu)
|
|
elif 'divers' in sMedia:
|
|
contenu.discard('containFilms')
|
|
contenu.discard('containSeries')
|
|
contenu.discard('containAnimes')
|
|
showDetailMenu(pasteID, contenu)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showDetailMenu(pasteID, contenu):
|
|
oGui = cGui()
|
|
|
|
sUrl = URL_MAIN + '&numPage=1' # + pasteBin
|
|
if 'containFilms' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
searchUrl = URL_SEARCH_MOVIES[0].replace(KEY_PASTE_ID, pasteID)
|
|
oOutputParameterHandler.addParameter('siteUrl', searchUrl)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showSearch', 'Recherche (Films)', 'search.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=film&bNews=True&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', 'Films (Derniers ajouts)', 'news.png', oOutputParameterHandler)
|
|
|
|
if 'containFilmGenres' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=film&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showGenres', 'Films (Genres)', 'genres.png', oOutputParameterHandler)
|
|
|
|
if 'containFilmGroupes' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=film&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showGroupes', 'Films (Listes)', 'listes.png', oOutputParameterHandler)
|
|
|
|
if 'containFilmSaga' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=film&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showSaga', 'Films (Saga)', 'genres.png', oOutputParameterHandler)
|
|
|
|
if 'containFilmYear' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=film&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showYears', 'Films (Par années)', 'annees.png', oOutputParameterHandler)
|
|
|
|
if 'containFilmRes' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=film&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showResolution', 'Films (Par résolutions)', 'hd.png', oOutputParameterHandler)
|
|
|
|
if 'containFilmNetwork' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=film&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showNetwork', 'Films (Par diffuseurs)', 'host.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=film&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'AlphaList', 'Films (Ordre alphabétique)', 'az.png', oOutputParameterHandler)
|
|
|
|
if 'containFilmReal' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=film&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showRealisateur', 'Films (Par réalisateurs)', 'actor.png', oOutputParameterHandler)
|
|
|
|
if 'containFilmCast' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=film&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showCast', 'Films (Par acteurs)', 'actor.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=film&bRandom=True&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', 'Films (Aléatoires)', 'listes.png', oOutputParameterHandler)
|
|
|
|
if 'containSeries' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
searchUrl = URL_SEARCH_SERIES[0].replace(KEY_PASTE_ID, pasteID)
|
|
oOutputParameterHandler.addParameter('siteUrl', searchUrl)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showSearch', 'Recherche (Séries)', 'search.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=serie&bNews=True&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', 'Séries (Derniers ajouts)', 'news.png', oOutputParameterHandler)
|
|
|
|
if 'containSerieGenres' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=serie&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showGenres', 'Séries (Genres)', 'genres.png', oOutputParameterHandler)
|
|
|
|
if 'containSerieGroupes' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=serie&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showGroupes', 'Séries (Listes)', 'listes.png', oOutputParameterHandler)
|
|
|
|
if 'containSerieNetwork' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=serie&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showNetwork', 'Séries (Par diffuseurs)', 'host.png', oOutputParameterHandler)
|
|
|
|
if 'containSerieYear' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=serie&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showYears', 'Séries (Par années)', 'annees.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=serie&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'AlphaList', 'Séries (Ordre alphabétique)', 'az.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=serie&bRandom=True&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', 'Séries (Aléatoires)', 'listes.png', oOutputParameterHandler)
|
|
|
|
if 'containAnimes' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
searchUrl = URL_SEARCH_ANIMS[0].replace(KEY_PASTE_ID, pasteID)
|
|
oOutputParameterHandler.addParameter('siteUrl', searchUrl)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showSearch', 'Recherche (Animes)', 'search.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=anime&bNews=True&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', 'Animes (Derniers ajouts)', 'news.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=anime&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showGenres', 'Animes (Genres)', 'genres.png', oOutputParameterHandler)
|
|
|
|
if 'containAnimeGroupes' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=anime&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showGroupes', 'Animes (Listes)', 'listes.png', oOutputParameterHandler)
|
|
|
|
if 'containAnimeNetwork' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=anime&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showNetwork', 'Animes (Par diffuseurs)', 'host.png', oOutputParameterHandler)
|
|
|
|
if 'containAnimeYear' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=anime&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showYears', 'Animes (Par années)', 'annees.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=anime&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'AlphaList', 'Animes (Ordre alphabétique)', 'az.png', oOutputParameterHandler)
|
|
|
|
if 'containDivers' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
searchUrl = URL_SEARCH_DIVERS[0].replace(KEY_PASTE_ID, pasteID)
|
|
oOutputParameterHandler.addParameter('siteUrl', searchUrl)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showSearch', 'Recherche (Divers)', 'search.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=divers&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', 'Divers (Derniers ajouts)', 'news.png', oOutputParameterHandler)
|
|
|
|
if 'containDiversGenres' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=divers&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showGenres', 'Divers (Catégories)', 'genres.png', oOutputParameterHandler)
|
|
|
|
if 'containDiversGroupes' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=divers&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showGroupes', 'Divers (Listes)', 'listes.png', oOutputParameterHandler)
|
|
|
|
if 'containDiversYear' in contenu:
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=divers&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showYears', 'Divers (Par années)', 'annees.png', oOutputParameterHandler)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl + '&sMedia=divers&pasteID=' + pasteID)
|
|
oGui.addDir(SITE_IDENTIFIER, 'AlphaList', 'Divers (Ordre alphabétique)', 'az.png', oOutputParameterHandler)
|
|
|
|
|
|
# Etablir les menus en fonction du contenu
|
|
def getPasteBin(pbContent, pasteBin):
|
|
|
|
containList = set()
|
|
|
|
if not pasteBin:
|
|
return containList
|
|
|
|
movies = pbContent.getLines(pasteBin)
|
|
|
|
# Calculer les menus
|
|
for movie in movies:
|
|
if pbContent.CAT == -1 or 'film' in movie[pbContent.CAT]:
|
|
containList.add('containFilms')
|
|
if pbContent.GENRES >= 0 and len(movie[pbContent.GENRES].strip()) > 2:
|
|
containList.add('containFilmGenres')
|
|
if pbContent.GROUPES >= 0 and len(movie[pbContent.GROUPES].replace('[', '').replace(']', '').strip()) > 0:
|
|
containList.add('containFilmGroupes')
|
|
if pbContent.YEAR >= 0 and len(movie[pbContent.YEAR].strip()) > 1:
|
|
containList.add('containFilmYear')
|
|
if pbContent.RES >= 0 and len(movie[pbContent.RES].replace('[', '').replace(']', '').replace(',', '').strip()) > 0:
|
|
containList.add('containFilmRes')
|
|
if pbContent.DIRECTOR >= 0 and len(movie[pbContent.DIRECTOR].replace('[', '').replace(']', '').replace(',', '').strip()) > 0:
|
|
containList.add('containFilmReal')
|
|
if pbContent.CAST >= 0 and len(movie[pbContent.CAST].replace('[', '').replace(']', '').replace(',', '').strip()) > 0:
|
|
containList.add('containFilmCast')
|
|
if pbContent.SAISON >= 0 and len(movie[pbContent.SAISON].strip()) > 0:
|
|
containList.add('containFilmSaga')
|
|
if pbContent.NETWORK >= 0 and len(movie[pbContent.NETWORK].replace('[', '').replace(']', '').strip()) > 0:
|
|
containList.add('containFilmNetwork')
|
|
|
|
elif 'serie' in movie[pbContent.CAT]:
|
|
containList.add('containSeries')
|
|
if pbContent.GENRES >= 0 and len(movie[pbContent.GENRES].strip()) > 2:
|
|
containList.add('containSerieGenres')
|
|
if pbContent.GROUPES >= 0 and len(movie[pbContent.GROUPES].replace('[', '').replace(']', '').strip()) > 0:
|
|
containList.add('containSerieGroupes')
|
|
if pbContent.NETWORK >=0 and len(movie[pbContent.NETWORK].replace('[', '').replace(']', '').strip()) > 0:
|
|
containList.add('containSerieNetwork')
|
|
if pbContent.YEAR >= 0 and len(movie[pbContent.YEAR].strip()) > 1:
|
|
containList.add('containSerieYear')
|
|
|
|
elif 'anime' in movie[pbContent.CAT]:
|
|
containList.add('containAnimes')
|
|
if pbContent.GROUPES >= 0 and len(movie[pbContent.GROUPES].replace('[', '').replace(']', '').strip()) > 0:
|
|
containList.add('containAnimeGroupes')
|
|
if pbContent.NETWORK >=0 and len(movie[pbContent.NETWORK].replace('[', '').replace(']', '').strip()) > 0:
|
|
containList.add('containAnimeNetwork')
|
|
if pbContent.YEAR >= 0 and len(movie[pbContent.YEAR].strip()) > 1:
|
|
containList.add('containAnimeYear')
|
|
|
|
elif 'divers' in movie[pbContent.CAT]:
|
|
containList.add('containDivers')
|
|
if pbContent.GENRES >= 0 and len(movie[pbContent.GENRES].strip()) > 2:
|
|
containList.add('containDiversGenres')
|
|
if pbContent.YEAR >= 0 and len(movie[pbContent.YEAR].strip()) > 1:
|
|
containList.add('containDiversYear')
|
|
if pbContent.GROUPES >= 0 and len(movie[pbContent.GROUPES].replace('[', '').replace(']', '').strip()) > 0:
|
|
containList.add('containDiversGroupes')
|
|
return containList
|
|
|
|
|
|
def showSearch():
|
|
oGui = cGui()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
sUrl = oInputParameterHandler.getValue('siteUrl')
|
|
|
|
sSearchText = oGui.showKeyBoard()
|
|
if (sSearchText != False):
|
|
sUrl += Quote(sSearchText)
|
|
|
|
# Recherche globale si le pastebin n'est pas indiqué
|
|
if KEY_PASTE_ID in sUrl:
|
|
showSearchGlobal(sUrl)
|
|
else:
|
|
showMovies(sUrl)
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showSearchGlobal(sSearch=''):
|
|
addons = addon()
|
|
|
|
sUrl = sSearch
|
|
|
|
for numID in range(1, GROUPE_MAX):
|
|
prefixID = SETTING_PASTE_LABEL + str(numID)
|
|
pastebin = addons.getSetting(prefixID)
|
|
if pastebin:
|
|
searchUrl = sUrl.replace(KEY_PASTE_ID, str(numID))
|
|
try:
|
|
showMovies(searchUrl)
|
|
except:
|
|
pass
|
|
|
|
|
|
def showGenres():
|
|
tmdb = cTMDb()
|
|
oGui = cGui()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
|
|
sUrl, params = siteUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
sMedia = aParams['sMedia'] if 'sMedia' in aParams else 'film'
|
|
pasteID = aParams['pasteID'] if 'pasteID' in aParams else None
|
|
|
|
listeIDs = getPasteList(sUrl, pasteID)
|
|
|
|
genres = {}
|
|
pbContent = PasteContent()
|
|
for pasteBin in listeIDs:
|
|
|
|
movies = pbContent.getLines(pasteBin)
|
|
|
|
for movie in movies:
|
|
if pbContent.CAT >= 0 and sMedia not in movie[pbContent.CAT]:
|
|
continue
|
|
|
|
genre = movie[pbContent.GENRES].strip()
|
|
if not genre or genre == '':
|
|
genre = "['" + UNCLASSIFIED_GENRE + "']"
|
|
elif "''" in genre:
|
|
genre = genre.replace("''", "'" + UNCLASSIFIED_GENRE + "'")
|
|
genre = eval(genre)
|
|
if isinstance(genre, int):
|
|
genre = [genre]
|
|
if genre:
|
|
for g in genre:
|
|
sDisplayGenre = g
|
|
if str(g).isdigit():
|
|
sDisplayGenre = tmdb.getGenreFromID(g)
|
|
if sDisplayGenre not in genres:
|
|
genres[sDisplayGenre] = g
|
|
|
|
genreKeys = genres.keys()
|
|
for sDisplayGenre in sorted(genreKeys):
|
|
genre = genres.get(sDisplayGenre)
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
sUrl = siteUrl + '&sGenre=' + str(genre)
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', sDisplayGenre, 'genres.png', oOutputParameterHandler)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showNetwork():
|
|
oGui = cGui()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
|
|
sUrl, params = siteUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
sMedia = aParams['sMedia'] if 'sMedia' in aParams else 'film'
|
|
pasteID = aParams['pasteID'] if 'pasteID' in aParams else None
|
|
|
|
pbContent = PasteContent()
|
|
movies = []
|
|
listeIDs = getPasteList(sUrl, pasteID)
|
|
for pasteBin in listeIDs:
|
|
moviesBin = pbContent.getLines(pasteBin)
|
|
movies += moviesBin
|
|
|
|
listNetwork = {}
|
|
for movie in movies:
|
|
if pbContent.CAT >= 0 and sMedia not in movie[pbContent.CAT]:
|
|
continue
|
|
|
|
networks = movie[pbContent.NETWORK].strip()
|
|
if networks != '':
|
|
networks = eval(networks)
|
|
if networks:
|
|
for network in networks:
|
|
if ':' in network:
|
|
networkId, networkName = network.split(':')
|
|
if networkName not in listNetwork:
|
|
listNetwork[networkName] = networkId
|
|
|
|
maxProgress = len(listNetwork)
|
|
progress_ = progress().VScreate(SITE_NAME)
|
|
|
|
for networkName, networkId in sorted(listNetwork.items()):
|
|
progress_.VSupdate(progress_, maxProgress)
|
|
if progress_.iscanceled():
|
|
break
|
|
|
|
sUrl = siteUrl + '&sNetwork=' + networkId + ":" + networkName.replace('+', '|')
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
oOutputParameterHandler.addParameter('sTmdbId', networkId) # Utilisé par TMDB
|
|
oGui.addNetwork(SITE_IDENTIFIER, 'showMovies', networkName, 'host.png', oOutputParameterHandler)
|
|
progress_.VSclose(progress_)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showRealisateur():
|
|
oGui = cGui()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
|
|
sUrl, params = siteUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
sMedia = aParams['sMedia'] if 'sMedia' in aParams else 'film'
|
|
pasteID = aParams['pasteID'] if 'pasteID' in aParams else None
|
|
numItem = oInputParameterHandler.getValue('numItem')
|
|
numPage = oInputParameterHandler.getValue('numPage')
|
|
|
|
# Gestion de la pagination
|
|
if not numItem:
|
|
numItem = 0
|
|
numPage = 1
|
|
numItem = int(numItem)
|
|
numPage = int(numPage)
|
|
|
|
pbContent = PasteContent()
|
|
movies = []
|
|
listeIDs = getPasteList(sUrl, pasteID)
|
|
for pasteBin in listeIDs:
|
|
moviesBin = pbContent.getLines(pasteBin)
|
|
movies += moviesBin
|
|
|
|
listReal = {}
|
|
for movie in movies:
|
|
if pbContent.CAT >= 0 and sMedia not in movie[pbContent.CAT]:
|
|
continue
|
|
|
|
reals = movie[pbContent.DIRECTOR].strip()
|
|
if reals != '':
|
|
reals = eval(reals)
|
|
if reals:
|
|
for real in reals:
|
|
if ':' in real:
|
|
realId, realName = real.split(':')
|
|
if realName not in listReal:
|
|
listReal[realName] = realId
|
|
|
|
nbItem = 0
|
|
index = 0
|
|
maxProgress = min(len(listReal), ITEM_PAR_PAGE)
|
|
progress_ = progress().VScreate(SITE_NAME)
|
|
|
|
for realName, realId in sorted(listReal.items()):
|
|
# Pagination, on se repositionne
|
|
index += 1
|
|
if index <= numItem:
|
|
continue
|
|
numItem += 1
|
|
|
|
progress_.VSupdate(progress_, maxProgress)
|
|
if progress_.iscanceled():
|
|
break
|
|
|
|
sUrl = siteUrl + '&sDirector=' + realId + ":" + realName
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
oOutputParameterHandler.addParameter('sTmdbId', realId) # Utilisé par TMDB
|
|
oGui.addPerson(SITE_IDENTIFIER, 'showMovies', realName, 'actor.png', oOutputParameterHandler)
|
|
|
|
nbItem += 1
|
|
if nbItem % ITEM_PAR_PAGE == 0 and numPage*ITEM_PAR_PAGE < len(listReal):
|
|
numPage += 1
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', siteUrl)
|
|
oOutputParameterHandler.addParameter('numPage', numPage)
|
|
oOutputParameterHandler.addParameter('numItem', numItem)
|
|
oGui.addNext(SITE_IDENTIFIER, 'showRealisateur', 'Page ' + str(numPage), oOutputParameterHandler)
|
|
break
|
|
|
|
progress_.VSclose(progress_)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showCast():
|
|
oGui = cGui()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
numItem = oInputParameterHandler.getValue('numItem')
|
|
numPage = oInputParameterHandler.getValue('numPage')
|
|
|
|
sUrl, params = siteUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
sMedia = aParams['sMedia'] if 'sMedia' in aParams else 'film'
|
|
pasteID = aParams['pasteID'] if 'pasteID' in aParams else None
|
|
if not numPage and 'numPage' in aParams:
|
|
numPage = aParams['numPage']
|
|
|
|
pbContent = PasteContent()
|
|
movies = []
|
|
listeIDs = getPasteList(sUrl, pasteID)
|
|
for pasteBin in listeIDs:
|
|
moviesBin = pbContent.getLines(pasteBin)
|
|
movies += moviesBin
|
|
|
|
listActeur = {}
|
|
for movie in movies:
|
|
if pbContent.CAT >= 0 and sMedia not in movie[pbContent.CAT]:
|
|
continue
|
|
|
|
acteurs = movie[pbContent.CAST].strip()
|
|
if acteurs != '':
|
|
acteurs = eval(acteurs)
|
|
if acteurs:
|
|
for acteur in acteurs:
|
|
if ':' in acteur:
|
|
acteurId, acteurName = acteur.split(':')
|
|
if acteurName not in listActeur:
|
|
listActeur[acteurName] = acteurId
|
|
|
|
# Gestion de la pagination
|
|
if not numItem:
|
|
numItem = 0
|
|
else:
|
|
numItem = int(numItem)
|
|
numPage = int(numPage)
|
|
if numPage > 1 and numItem == 0: # choix d'une page
|
|
numItem = (numPage-1) * ITEM_PAR_PAGE
|
|
if numItem > len(listActeur): # accès direct à la dernière page
|
|
numPage = len(listActeur) / ITEM_PAR_PAGE
|
|
numItem = (numPage-1) * ITEM_PAR_PAGE
|
|
|
|
nbItem = 0
|
|
index = 0
|
|
maxProgress = min(len(listActeur), ITEM_PAR_PAGE)
|
|
progress_ = progress().VScreate(SITE_NAME)
|
|
|
|
for acteurName, acteurId in sorted(listActeur.items()):
|
|
# Pagination, on se repositionne
|
|
index += 1
|
|
if index <= numItem:
|
|
continue
|
|
numItem += 1
|
|
|
|
progress_.VSupdate(progress_, maxProgress)
|
|
if progress_.iscanceled():
|
|
break
|
|
|
|
sUrl = siteUrl + '&sCast=' + acteurId + ":" + acteurName
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
oOutputParameterHandler.addParameter('sTmdbId', acteurId) # Utilisé par TMDB
|
|
oGui.addPerson(SITE_IDENTIFIER, 'showMovies', acteurName, 'actor.png', oOutputParameterHandler)
|
|
|
|
nbItem += 1
|
|
if nbItem % ITEM_PAR_PAGE == 0 and numPage*ITEM_PAR_PAGE < len(listActeur):
|
|
numPage += 1
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', siteUrl)
|
|
oOutputParameterHandler.addParameter('numPage', numPage)
|
|
oOutputParameterHandler.addParameter('numItem', numItem)
|
|
oGui.addNext(SITE_IDENTIFIER, 'showCast', 'Page ' + str(numPage), oOutputParameterHandler)
|
|
break
|
|
|
|
progress_.VSclose(progress_)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showGroupes():
|
|
oGui = cGui()
|
|
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
|
|
sUrl, params = siteUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
sMedia = aParams['sMedia'] if 'sMedia' in aParams else 'film'
|
|
pasteID = aParams['pasteID'] if 'pasteID' in aParams else None
|
|
|
|
pbContent = PasteContent()
|
|
movies = []
|
|
listeIDs = getPasteList(sUrl, pasteID)
|
|
for pasteBin in listeIDs:
|
|
moviesBin = pbContent.getLines(pasteBin)
|
|
movies += moviesBin
|
|
|
|
sousGroupe = set()
|
|
groupesPerso = set()
|
|
for movie in movies:
|
|
if pbContent.CAT >= 0 and sMedia not in movie[pbContent.CAT]:
|
|
continue
|
|
groupe = movie[pbContent.GROUPES].strip().replace("''", '')
|
|
if groupe:
|
|
groupe = eval(groupe)
|
|
if groupe:
|
|
for gr in groupe:
|
|
if ':' in gr:
|
|
grID = gr.split(':')[0]
|
|
if grID not in sousGroupe:
|
|
sousGroupe.add(grID)
|
|
else:
|
|
groupesPerso.add(gr)
|
|
|
|
groupes = groupesPerso.union(sousGroupe)
|
|
for sGroupe in sorted(groupes):
|
|
sUrl = siteUrl + '&sGroupe=' + sGroupe
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
if sGroupe in sousGroupe:
|
|
oGui.addDir(SITE_IDENTIFIER, 'showGroupeDetails', sGroupe, 'genres.png', oOutputParameterHandler)
|
|
else:
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', sGroupe, 'genres.png', oOutputParameterHandler)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showGroupeDetails():
|
|
oGui = cGui()
|
|
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
|
|
sUrl, params = siteUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
pasteID = aParams['pasteID'] if 'pasteID' in aParams else None
|
|
sGroupe = aParams['sGroupe'].replace('+', ' ') + ':' if 'sGroupe' in aParams else None
|
|
|
|
pbContent = PasteContent()
|
|
movies = []
|
|
listeIDs = getPasteList(sUrl, pasteID)
|
|
for pasteBin in listeIDs:
|
|
moviesBin = pbContent.getLines(pasteBin)
|
|
movies += moviesBin
|
|
|
|
groupes = set()
|
|
if sGroupe:
|
|
for movie in movies:
|
|
groupe = movie[pbContent.GROUPES].strip().replace("''", '')
|
|
if groupe:
|
|
groupe = eval(groupe)
|
|
if groupe:
|
|
for gr in groupe:
|
|
if gr.startswith(sGroupe):
|
|
groupes.add(gr)
|
|
|
|
for sGroupe in sorted(groupes):
|
|
sUrl = siteUrl + '&sGroupe=' + sGroupe.replace('+', '|')
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
sDisplayGroupe = sGroupe.split(':')[1]
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', sDisplayGroupe, 'genres.png', oOutputParameterHandler)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showSaga():
|
|
oGui = cGui()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
numItem = oInputParameterHandler.getValue('numItem')
|
|
numPage = oInputParameterHandler.getValue('numPage')
|
|
|
|
sUrl, params = siteUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
sMedia = aParams['sMedia'] if 'sMedia' in aParams else 'film'
|
|
pasteID = aParams['pasteID'] if 'pasteID' in aParams else None
|
|
if not numPage and 'numPage' in aParams:
|
|
numPage = aParams['numPage']
|
|
|
|
pbContent = PasteContent()
|
|
movies = []
|
|
listeIDs = getPasteList(sUrl, pasteID)
|
|
for pasteBin in listeIDs:
|
|
moviesBin = pbContent.getLines(pasteBin)
|
|
movies += moviesBin
|
|
|
|
sagas = {}
|
|
for movie in movies:
|
|
if pbContent.CAT >= 0 and sMedia not in movie[pbContent.CAT]:
|
|
continue
|
|
|
|
saga = movie[pbContent.SAISON].strip()
|
|
if saga != '':
|
|
sTmdbId = name = saga
|
|
idName = saga.split(':', 1)
|
|
if len(idName) > 1:
|
|
sTmdbId = idName[0]
|
|
name = idName[1]
|
|
if sTmdbId.isdigit():
|
|
sagas[name] = sTmdbId
|
|
else:
|
|
sagas[saga] = saga
|
|
|
|
# Gestion de la pagination
|
|
if not numItem:
|
|
numItem = 0
|
|
else:
|
|
numItem = int(numItem)
|
|
numPage = int(numPage)
|
|
if numPage > 1 and numItem == 0: # choix d'une page
|
|
numItem = (numPage-1) * ITEM_PAR_PAGE
|
|
if numItem > len(sagas): # accès direct à la dernière page
|
|
numPage = len(sagas) / ITEM_PAR_PAGE
|
|
numItem = (numPage-1) * ITEM_PAR_PAGE
|
|
|
|
nbItem = 0
|
|
index = 0
|
|
progress_ = progress().VScreate(SITE_NAME)
|
|
names = sagas.keys()
|
|
for sSagaName in sorted(names):
|
|
|
|
# Pagination, on se repositionne
|
|
index += 1
|
|
if index <= numItem:
|
|
continue
|
|
numItem += 1
|
|
|
|
progress_.VSupdate(progress_, ITEM_PAR_PAGE)
|
|
if progress_.iscanceled():
|
|
break
|
|
|
|
sTmdbId = sagas[sSagaName]
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
if sTmdbId.isdigit():
|
|
oOutputParameterHandler.addParameter('sTmdbId', sTmdbId) # Utilisé par TMDB
|
|
sUrl = siteUrl + '&sSaga=' + sTmdbId + ':' + sSagaName
|
|
else:
|
|
sUrl = siteUrl + '&sSaga=' + sSagaName
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
|
|
sDisplaySaga = sSagaName
|
|
sSagaName = sSagaName.replace('[', '').replace(']', '') # Exemple pour le film [REC], les crochets sont génant pour certaines fonctions
|
|
if not sSagaName.lower().endswith('saga'):
|
|
sSagaName = sSagaName + " Saga"
|
|
oOutputParameterHandler.addParameter('sMovieTitle', sSagaName)
|
|
|
|
oGui.addMoviePack(SITE_IDENTIFIER, 'showMovies', sDisplaySaga, 'genres.png', '', '', oOutputParameterHandler)
|
|
|
|
nbItem += 1
|
|
if nbItem % ITEM_PAR_PAGE == 0 and numPage*ITEM_PAR_PAGE < len(names):
|
|
numPage += 1
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', siteUrl)
|
|
oOutputParameterHandler.addParameter('numPage', numPage)
|
|
oOutputParameterHandler.addParameter('numItem', numItem)
|
|
oGui.addNext(SITE_IDENTIFIER, 'showSaga', 'Page ' + str(numPage), oOutputParameterHandler)
|
|
break
|
|
|
|
progress_.VSclose(progress_)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showYears():
|
|
oGui = cGui()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
|
|
sUrl, params = siteUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
sMedia = aParams['sMedia'] if 'sMedia' in aParams else 'film'
|
|
pasteID = aParams['pasteID'] if 'pasteID' in aParams else None
|
|
|
|
pbContent = PasteContent()
|
|
movies = []
|
|
listeIDs = getPasteList(sUrl, pasteID)
|
|
for pasteBin in listeIDs:
|
|
moviesBin = pbContent.getLines(pasteBin)
|
|
movies += moviesBin
|
|
|
|
years = set()
|
|
for line in movies:
|
|
if pbContent.CAT >= 0 and sMedia not in line[pbContent.CAT]:
|
|
continue
|
|
|
|
year = line[pbContent.YEAR].strip()
|
|
if not year:
|
|
year = UNCLASSIFIED
|
|
years.add(year)
|
|
|
|
for sYear in sorted(years, reverse=True):
|
|
sUrl = siteUrl + '&sYear=' + sYear
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', sYear, 'annees.png', oOutputParameterHandler)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showResolution():
|
|
oGui = cGui()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
|
|
sUrl, params = siteUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
sMedia = aParams['sMedia'] if 'sMedia' in aParams else 'film'
|
|
pasteID = aParams['pasteID'] if 'pasteID' in aParams else None
|
|
|
|
pbContent = PasteContent()
|
|
movies = []
|
|
listeIDs = getPasteList(sUrl, pasteID)
|
|
for pasteBin in listeIDs:
|
|
moviesBin = pbContent.getLines(pasteBin)
|
|
movies += moviesBin
|
|
|
|
resolutions = set()
|
|
for line in movies:
|
|
if pbContent.CAT >= 0 and sMedia not in line[pbContent.CAT]:
|
|
continue
|
|
|
|
res = line[pbContent.RES].strip()
|
|
if '[' in res:
|
|
if res != '[]':
|
|
res = eval(res)
|
|
resolutions = resolutions.union(res)
|
|
if '' in res or len(res) == 0:
|
|
resolutions.add(UNCLASSIFIED)
|
|
else:
|
|
resolutions.add(res)
|
|
|
|
if not res or res == '[]':
|
|
resolutions.add(UNCLASSIFIED)
|
|
|
|
resolutions.discard('')
|
|
|
|
# Trie des résolutions
|
|
resOrder = ['8K', '4K', '1080P', '720P', '576P', '540P', '480P', '360P']
|
|
|
|
def trie_res(key):
|
|
if key == UNCLASSIFIED:
|
|
return 20
|
|
key = key.replace('p', 'P')
|
|
if key not in resOrder:
|
|
resOrder.append(key)
|
|
return resOrder.index(key)
|
|
|
|
resolutions = sorted(resolutions, key=trie_res)
|
|
|
|
for sRes in resolutions:
|
|
if sRes == '':
|
|
continue
|
|
|
|
sDisplayRes = sRes
|
|
if sDisplayRes.isdigit(): sDisplayRes += 'p'
|
|
sDisplayRes = sDisplayRes\
|
|
.replace('P', 'p')\
|
|
.replace('1080p', 'fullHD [1080p]')\
|
|
.replace('720p', 'HD [720p]')\
|
|
.replace('540p', 'SD [540p]')\
|
|
.replace('480p', 'SD [480p]')\
|
|
.replace('360p', 'SD [360p]')\
|
|
.replace('4K', '2160p')\
|
|
.replace('8K', '4320p')\
|
|
.replace('2160p', '4K [2160p]')\
|
|
.replace('4320p', '8K [4320p]')
|
|
|
|
sUrl = siteUrl + '&sRes=' + sRes
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', sDisplayRes, 'hd.png', oOutputParameterHandler)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def AlphaList():
|
|
oGui = cGui()
|
|
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
|
|
for i in range(0, 36):
|
|
if (i < 10):
|
|
sLetter = chr(48 + i)
|
|
else:
|
|
sLetter = chr(65 + i -10)
|
|
|
|
sUrl = siteUrl + '&sAlpha=' + sLetter
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
oGui.addDir(SITE_IDENTIFIER, 'showMovies', '[COLOR teal] Lettre [COLOR red]' + sLetter + '[/COLOR][/COLOR]', 'listes.png', oOutputParameterHandler)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showMovies(sSearch=''):
|
|
oGui = cGui()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
numItem = oInputParameterHandler.getValue('numItem')
|
|
numPage = oInputParameterHandler.getValue('numPage')
|
|
sMedia = 'film' # Par défaut
|
|
pasteID = sGenre = sSaga = sGroupe = sYear = sRes = sAlpha = sNetwork = sDirector = sCast = None
|
|
bRandom = bNews = False
|
|
|
|
if sSearch:
|
|
siteUrl = sSearch
|
|
|
|
sSearchTitle = ''
|
|
|
|
# Pour supporter les caracteres '&' et '+' dans les noms alors qu'ils sont réservés
|
|
sUrl = siteUrl.replace('+', ' ').replace('|', '+').replace(' & ', ' | ')
|
|
|
|
sUrl, params = sUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
|
|
if 'pasteID' in aParams:
|
|
pasteID = aParams['pasteID']
|
|
if 'sMedia' in aParams:
|
|
sMedia = aParams['sMedia']
|
|
if 'sSearch' in aParams:
|
|
sSearchTitle = Unquote(aParams['sSearch']).replace(' | ', ' & ')
|
|
if 'sGenre' in aParams:
|
|
sGenre = aParams['sGenre'].replace(' | ', ' & ')
|
|
if 'sSaga' in aParams:
|
|
sSaga = aParams['sSaga'].replace(' | ', ' & ')
|
|
if 'sGroupe' in aParams:
|
|
sGroupe = aParams['sGroupe'].replace(' | ', ' & ')
|
|
if 'sYear' in aParams:
|
|
sYear = aParams['sYear']
|
|
if 'sRes' in aParams:
|
|
sRes = aParams['sRes']
|
|
if 'sAlpha' in aParams:
|
|
sAlpha = aParams['sAlpha']
|
|
if 'sNetwork' in aParams:
|
|
sNetwork = aParams['sNetwork']
|
|
if 'sDirector' in aParams:
|
|
sDirector = aParams['sDirector']
|
|
if 'sCast' in aParams:
|
|
sCast = aParams['sCast']
|
|
if 'bRandom' in aParams:
|
|
bRandom = aParams['bRandom']
|
|
if 'bNews' in aParams:
|
|
bNews = aParams['bNews']
|
|
if not numPage and 'numPage' in aParams:
|
|
numPage = aParams['numPage']
|
|
|
|
pbContent = PasteContent()
|
|
movies = []
|
|
pasteLen = []
|
|
pasteMaxLen = []
|
|
maxlen = 0
|
|
listeIDs = getPasteList(sUrl, pasteID)
|
|
|
|
for pasteBin in listeIDs:
|
|
moviesBin = pbContent.getLines(pasteBin)
|
|
movies += moviesBin
|
|
pasteLen.append(len(moviesBin))
|
|
maxlen += len(moviesBin)
|
|
pasteMaxLen.append(maxlen)
|
|
|
|
# si plusieurs pastes, on les parcourt en parallèle
|
|
if (bNews or sYear or sGenre or sRes) and len(listeIDs) > 1:
|
|
moviesNews = []
|
|
i = j = k = 0
|
|
lenMovie = len(movies)
|
|
while k < lenMovie:
|
|
if i < pasteMaxLen[j]:
|
|
moviesNews.append(movies[i])
|
|
k += 1
|
|
i += pasteLen[j]
|
|
j += 1
|
|
if j >= len(pasteMaxLen):
|
|
i = (i % lenMovie) + 1
|
|
j=0
|
|
|
|
movies = moviesNews
|
|
|
|
# Recherche par ordre alphabetique => le tableau doit être trié
|
|
if sAlpha:
|
|
movies = sorted(movies, key=lambda line: line[pbContent.TITLE])
|
|
|
|
# Recherche par saga => trie par années
|
|
if sSaga and pbContent.YEAR >= 0:
|
|
movies = sorted(movies, key=lambda line: line[pbContent.YEAR])
|
|
|
|
# Dans un dossier => trie par années inversées (du plus récent)
|
|
if sGroupe or sDirector or sCast:
|
|
movies = sorted(movies, key=lambda line: line[pbContent.YEAR], reverse=True)
|
|
|
|
# Gestion de la pagination
|
|
if not numItem:
|
|
numItem = 0
|
|
else:
|
|
numItem = int(numItem)
|
|
numPage = int(numPage)
|
|
if numPage > 1 and numItem == 0: # choix d'une page
|
|
numItem = (numPage-1) * ITEM_PAR_PAGE
|
|
if numItem > len(movies): # accès direct à la dernière page
|
|
numPage = len(movies) / ITEM_PAR_PAGE
|
|
numItem = (numPage-1) * ITEM_PAR_PAGE
|
|
|
|
if bRandom:
|
|
numItem = 0
|
|
# Génération d'indices aléatoires, ajout de deux indices car les doublons aléatoires sont rassemblés
|
|
randoms = [random.randint(0, len(movies)) for _ in range(ITEM_PAR_PAGE+2)]
|
|
|
|
movieIds = set()
|
|
|
|
nbItem = 0
|
|
index = 0
|
|
progress_ = progress().VScreate(SITE_NAME)
|
|
|
|
for movie in movies:
|
|
|
|
if bRandom and index not in randoms:
|
|
index += 1
|
|
continue
|
|
|
|
# Pagination, on se repositionne
|
|
index += 1
|
|
if index <= numItem:
|
|
continue
|
|
numItem += 1
|
|
|
|
# Filtrage par média (film/série), "film" par défaut si pas précisé
|
|
if pbContent.CAT >=0 and sMedia not in movie[pbContent.CAT]:
|
|
continue
|
|
|
|
# Filtrage par saga
|
|
if sSaga and sSaga != movie[pbContent.SAISON].strip():
|
|
continue
|
|
|
|
# Filtrage par genre
|
|
if sGenre and pbContent.GENRES >= 0:
|
|
genres = movie[pbContent.GENRES].strip()
|
|
if not genres or genres == '' or "''" in genres:
|
|
if sGenre != UNCLASSIFIED_GENRE:
|
|
continue
|
|
elif genres:
|
|
genres = eval(genres)
|
|
genres = [str(g) for g in genres]
|
|
if sGenre not in genres:
|
|
continue
|
|
|
|
# Filtrage par réalisateur
|
|
if sDirector and pbContent.DIRECTOR >= 0:
|
|
listDirector = movie[pbContent.DIRECTOR].strip()
|
|
if not listDirector:
|
|
continue
|
|
listDirector = eval(listDirector)
|
|
if sDirector not in listDirector:
|
|
continue
|
|
|
|
# Filtrage par acteur
|
|
if sCast and pbContent.CAST >= 0:
|
|
listCast = movie[pbContent.CAST].strip()
|
|
if not listCast:
|
|
continue
|
|
listCast = eval(listCast)
|
|
if sCast not in listCast:
|
|
continue
|
|
|
|
# Filtrage par diffuseur
|
|
if sNetwork and pbContent.NETWORK >= 0:
|
|
listNetwork = movie[pbContent.NETWORK].strip()
|
|
if not listNetwork:
|
|
continue
|
|
listNetwork = eval(listNetwork)
|
|
if sNetwork not in listNetwork:
|
|
continue
|
|
|
|
# Filtrage par groupe
|
|
if sGroupe and pbContent.GROUPES >= 0:
|
|
groupes = movie[pbContent.GROUPES].strip()
|
|
if not groupes:
|
|
continue
|
|
groupes = eval(groupes)
|
|
if sGroupe not in groupes:
|
|
continue
|
|
|
|
# Filtrage par titre
|
|
sTitle = movie[pbContent.TITLE].strip()
|
|
|
|
# l'ID TMDB
|
|
sTmdbId = None
|
|
if pbContent.TMDB >= 0:
|
|
sTmdbId = movie[pbContent.TMDB].strip()
|
|
if sTmdbId:
|
|
if sTmdbId in movieIds:
|
|
continue # Filtre des doublons
|
|
movieIds.add(sTmdbId)
|
|
if not sTmdbId:
|
|
if sTitle in movieIds:
|
|
continue # Filtre des doublons
|
|
movieIds.add(sTitle)
|
|
|
|
# Titre recherché
|
|
if sSearchTitle:
|
|
if cUtil().CheckOccurence(sSearchTitle, sTitle) == 0:
|
|
continue
|
|
|
|
# Recherche alphabétique
|
|
if sAlpha:
|
|
if sTitle[0].upper() != sAlpha:
|
|
continue
|
|
|
|
sDisplayTitle = sTitle
|
|
|
|
# Filtrage par années
|
|
movieYear = ''
|
|
if pbContent.YEAR >= 0:
|
|
movieYear = movie[pbContent.YEAR].strip()
|
|
# sDisplayTitle = '%s (%s)' % (sTitle, movieYear)
|
|
if sYear:
|
|
if sYear == UNCLASSIFIED:
|
|
if movieYear != '':
|
|
continue
|
|
elif not movieYear or sYear != movieYear:
|
|
continue
|
|
|
|
# Filtrage par résolutions vidéos
|
|
listRes = None
|
|
|
|
if 'film' in sMedia:
|
|
if pbContent.RES >= 0:
|
|
res = movie[pbContent.RES].strip()
|
|
listRes = []
|
|
if '[' in res:
|
|
listRes.extend(eval(res))
|
|
else:
|
|
listRes.append(res)
|
|
if len(listRes) == 0:
|
|
listRes.append('')
|
|
|
|
if sRes:
|
|
if sRes == UNCLASSIFIED:
|
|
if '' not in listRes:
|
|
continue
|
|
elif sRes not in listRes:
|
|
continue
|
|
|
|
nbItem += 1
|
|
progress_.VSupdate(progress_, ITEM_PAR_PAGE)
|
|
if progress_.iscanceled():
|
|
break
|
|
|
|
sUrl = URL_MAIN
|
|
if sMedia:
|
|
sUrl += '&sMedia=' + sMedia
|
|
if pasteID:
|
|
sUrl += '&pasteID=' + pasteID
|
|
if movieYear:
|
|
sUrl += '&sYear=' + movieYear
|
|
if sTmdbId:
|
|
sUrl += '&idTMDB=' + sTmdbId
|
|
if sRes:
|
|
sUrl += '&sRes=' + sRes
|
|
sUrl += '&sTitle=' + sTitle
|
|
|
|
# Pour supporter les caracteres '&' et '+' dans les noms alors qu'ils sont réservés
|
|
sTitle = sTitle.replace('+', ' ').replace(' & ', ' | ')
|
|
sTitle = sTitle.replace('[', '').replace(']', '') # Exemple pour le film [REC], les crochets sont génants pour certaines fonctions
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
oOutputParameterHandler.addParameter('sMovieTitle', sTitle)
|
|
if sTmdbId:
|
|
oOutputParameterHandler.addParameter('sTmdbId', sTmdbId) # Utilisé par TMDB
|
|
if movieYear:
|
|
oOutputParameterHandler.addParameter('sYear', movieYear) # Utilisé par TMDB
|
|
if listRes:
|
|
oOutputParameterHandler.addParameter('listRes', listRes)
|
|
|
|
if sMedia == 'serie':
|
|
oGui.addTV(SITE_IDENTIFIER, 'showSerieSaisons', sDisplayTitle, 'series.png', '', '', oOutputParameterHandler)
|
|
elif sMedia == 'anime':
|
|
oGui.addAnime(SITE_IDENTIFIER, 'showSerieSaisons', sDisplayTitle, 'animes.png', '', '', oOutputParameterHandler)
|
|
elif sMedia == 'divers':
|
|
oGui.addMisc(SITE_IDENTIFIER, 'showHosters', sDisplayTitle, 'doc.png', '', '', oOutputParameterHandler)
|
|
else:
|
|
oGui.addMovie(SITE_IDENTIFIER, 'showHosters', sDisplayTitle, 'films.png', '', '', oOutputParameterHandler)
|
|
|
|
# Gestion de la pagination
|
|
if not sSearch:
|
|
|
|
if nbItem % ITEM_PAR_PAGE == 0 and numPage*ITEM_PAR_PAGE < len(movies):
|
|
numPage += 1
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', siteUrl)
|
|
oOutputParameterHandler.addParameter('numPage', numPage)
|
|
oOutputParameterHandler.addParameter('numItem', numItem)
|
|
oGui.addNext(SITE_IDENTIFIER, 'showMovies', 'Page ' + str(numPage), oOutputParameterHandler)
|
|
break
|
|
|
|
progress_.VSclose(progress_)
|
|
|
|
if not sSearch:
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showSerieSaisons():
|
|
oGui = cGui()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
searchTitle = oInputParameterHandler.getValue('sMovieTitle')
|
|
searchYear = oInputParameterHandler.getValue('sYear')
|
|
|
|
# Pour supporter les caracteres '&' et '+' dans les noms alors qu'ils sont réservés
|
|
sUrl = siteUrl.replace('+', ' ').replace('|', '+').replace(' & ', ' | ')
|
|
|
|
sUrl, params = sUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
pasteID = aParams['pasteID'] if 'pasteID' in aParams else None
|
|
idTMDB = aParams['idTMDB'] if 'idTMDB' in aParams else None
|
|
sMedia = aParams['sMedia'] if 'sMedia' in aParams else 'serie'
|
|
|
|
saisons = {}
|
|
listeIDs = getPasteList(sUrl, pasteID)
|
|
pbContent = PasteContent()
|
|
for pasteBin in listeIDs:
|
|
moviesBin = pbContent.getLines(pasteBin)
|
|
|
|
# Recherche les saisons de la série
|
|
for serie in moviesBin:
|
|
|
|
if pbContent.CAT >= 0 and sMedia not in serie[pbContent.CAT]:
|
|
continue
|
|
|
|
# Recherche par id
|
|
found = False
|
|
if idTMDB and pbContent.TMDB >= 0:
|
|
sMovieID = serie[pbContent.TMDB].strip()
|
|
if sMovieID:
|
|
if sMovieID != idTMDB:
|
|
continue
|
|
found = True
|
|
|
|
# Sinon, recherche par titre/année
|
|
if not found:
|
|
if searchYear and pbContent.YEAR >= 0:
|
|
sYear = serie[pbContent.YEAR].strip()
|
|
if sYear and sYear != searchYear:
|
|
continue
|
|
|
|
sTitle = serie[pbContent.TITLE].strip()
|
|
if sTitle != searchTitle:
|
|
continue
|
|
|
|
numSaison = serie[pbContent.SAISON].strip()
|
|
if numSaison not in saisons:
|
|
saisons[numSaison] = set()
|
|
# Résolutions dispo pour la saison
|
|
listRes = saisons[numSaison]
|
|
if pbContent.RES >= 0:
|
|
res = serie[pbContent.RES].strip()
|
|
if '[' in res:
|
|
for r in eval(res):
|
|
listRes.add(r)
|
|
else:
|
|
listRes.add(res)
|
|
|
|
|
|
# # Une seule saison, directement les épisodes
|
|
# if len(saisons) == 1:
|
|
# key, res = saisons.items()
|
|
# siteUrl += '&sSaison=' + key
|
|
# showEpisodesLinks(siteUrl)
|
|
# return
|
|
|
|
# Proposer les différentes saisons
|
|
saisons = sorted(saisons.items(), key=lambda saison: saison[0])
|
|
for sSaison, res in saisons:
|
|
|
|
sDisplaySaison = sSaison
|
|
if sSaison.isdigit():
|
|
sDisplaySaison = 'S{:02d}'.format(int(sSaison))
|
|
|
|
if len(res) == 0:
|
|
sUrl = siteUrl + '&sSaison=' + sSaison
|
|
sDisplayTitle = searchTitle + ' - ' + sDisplaySaison
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
oOutputParameterHandler.addParameter('sMovieTitle', sDisplayTitle) # on ne passe pas le sTitre afin de pouvoir mettre la saison en marque-page
|
|
oGui.addEpisode(SITE_IDENTIFIER, 'showEpisodesLinks', sDisplayTitle, 'series.png', '', '', oOutputParameterHandler)
|
|
else:
|
|
for resolution in res:
|
|
sUrl = siteUrl + '&sSaison=' + sSaison + '&sRes=' + resolution
|
|
sDisplayTitle = ('%s %s [%s]') % (searchTitle, sDisplaySaison, resolution)
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
oOutputParameterHandler.addParameter('sMovieTitle', sDisplayTitle) # on ne passe pas le sTitre afin de pouvoir mettre la saison en marque-page
|
|
oGui.addEpisode(SITE_IDENTIFIER, 'showEpisodesLinks', sDisplayTitle, 'series.png', '', '', oOutputParameterHandler)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showEpisodesLinks(siteUrl=''):
|
|
oGui = cGui()
|
|
|
|
if not siteUrl:
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
|
|
# Pour supporter les caracteres '&' et '+' dans les noms alors qu'ils sont réservés
|
|
sUrl = siteUrl.replace('+', ' ').replace('|', '+').replace(' & ', ' | ')
|
|
params = sUrl.split('&', 1)[1]
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
sSaison = aParams['sSaison'] if 'sSaison' in aParams else None
|
|
sRes = aParams['sRes'] if 'sRes' in aParams else None
|
|
searchTitle = aParams['sTitle'].replace(' | ', ' & ')
|
|
|
|
if not sSaison:
|
|
oGui.setEndOfDirectory()
|
|
return
|
|
|
|
lines, listRes = getHosterList(siteUrl)
|
|
if len(listRes) != len(lines):
|
|
listRes = None
|
|
|
|
listeEpisodes = []
|
|
resIdx = 0
|
|
for episode in lines:
|
|
if listRes:
|
|
res = listRes[resIdx]
|
|
resIdx += 1
|
|
if sRes != res:
|
|
continue
|
|
for numEpisode in episode.keys():
|
|
if numEpisode not in listeEpisodes:
|
|
listeEpisodes.append(numEpisode)
|
|
|
|
sDisplaySaison = sSaison
|
|
if sSaison.isdigit():
|
|
sDisplaySaison = 'S{:02d}'.format(int(sSaison))
|
|
|
|
for episode in sorted(listeEpisodes):
|
|
sUrl = siteUrl + '&sEpisode=' + str(episode)
|
|
|
|
if str(episode).isdigit():
|
|
episode = '{}E{:02d}'.format(sDisplaySaison, int(episode))
|
|
else:
|
|
episode = '{}{}'.format(sDisplaySaison, episode)
|
|
sDisplayTitle = searchTitle + ' - ' + episode
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('siteUrl', sUrl)
|
|
oOutputParameterHandler.addParameter('sMovieTitle', sDisplayTitle)
|
|
oGui.addEpisode(SITE_IDENTIFIER, 'showHosters', sDisplayTitle, 'series.png', '', '', oOutputParameterHandler)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
def showHosters():
|
|
oGui = cGui()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
sTitle = oInputParameterHandler.getValue('sMovieTitle')
|
|
siteUrl = oInputParameterHandler.getValue('siteUrl')
|
|
|
|
sUrl = siteUrl.replace('+', ' ').replace('|', '+').replace(' & ', ' | ')
|
|
params = sUrl.split('&', 1)[1]
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
sRes = aParams['sRes'] if 'sRes' in aParams else None
|
|
|
|
listHoster, listRes = getHosterList(siteUrl)
|
|
|
|
if len(listRes) != len(listHoster):
|
|
listRes = None
|
|
|
|
resIdx = 0
|
|
for sHosterUrl in listHoster:
|
|
|
|
if not sHosterUrl.startswith('http'):
|
|
sHosterUrl += 'http://' + sHosterUrl
|
|
|
|
if '/dl/' in sHosterUrl or '.download.' in sHosterUrl:
|
|
oHoster = cHosterGui().getHoster('lien_direct')
|
|
else:
|
|
oHoster = cHosterGui().checkHoster(sHosterUrl)
|
|
|
|
if (oHoster != False):
|
|
|
|
if listRes:
|
|
res = listRes[resIdx]
|
|
resIdx += 1
|
|
|
|
# Filtre la résolution si demandée
|
|
if sRes:
|
|
if sRes == UNCLASSIFIED:
|
|
if res:
|
|
continue
|
|
else:
|
|
if sRes != res:
|
|
continue
|
|
|
|
if res.isdigit():
|
|
res += 'p'
|
|
res = res.replace('P', 'p').replace('1080p', 'fullHD').replace('720p', 'HD').replace('2160p', '4K')
|
|
sDisplayName = sTitle
|
|
if res:
|
|
sDisplayName += ' [%s]' % res
|
|
else:
|
|
sDisplayName = sTitle
|
|
|
|
oHoster.setDisplayName(sDisplayName)
|
|
oHoster.setFileName(sTitle)
|
|
cHosterGui().showHoster(oGui, oHoster, sHosterUrl, '')
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
# Retrouve tous les liens disponibles pour un film, ou un épisode, gère les groupes multipaste
|
|
def getHosterList(siteUrl):
|
|
# Pour supporter les caracteres '&' et '+' dans les noms alors qu'ils sont réservés
|
|
sUrl = siteUrl.replace('+', ' ').replace('|', '+').replace(' & ', ' | ')
|
|
|
|
siteUrl, params = sUrl.split('&', 1)
|
|
aParams = dict(param.split('=') for param in params.split('&'))
|
|
sMedia = aParams['sMedia'] if 'sMedia' in aParams else 'film'
|
|
pasteID = aParams['pasteID'] if 'pasteID' in aParams else None
|
|
searchYear = aParams['sYear'] if 'sYear' in aParams else None
|
|
searchSaison = aParams['sSaison'] if 'sSaison' in aParams else None
|
|
searchEpisode = aParams['sEpisode'] if 'sEpisode' in aParams else None
|
|
idTMDB = aParams['idTMDB'] if 'idTMDB' in aParams else None
|
|
searchTitle = aParams['sTitle'].replace(' | ', ' & ')
|
|
|
|
pbContent = PasteContent()
|
|
listHoster = []
|
|
listRes = []
|
|
listeIDs = getPasteList(siteUrl, pasteID)
|
|
|
|
for pasteBin in listeIDs:
|
|
moviesBin = pbContent.getLines(pasteBin)
|
|
|
|
for movie in moviesBin:
|
|
|
|
# Filtrer par catégorie
|
|
if pbContent.CAT >= 0 and sMedia not in movie[pbContent.CAT]:
|
|
continue
|
|
|
|
# Filtrage par saison
|
|
if searchSaison and pbContent.SAISON >= 0:
|
|
sSaisons = movie[pbContent.SAISON].strip()
|
|
if sSaisons and searchSaison != sSaisons:
|
|
continue
|
|
|
|
# Recherche par id
|
|
found = False
|
|
if idTMDB and pbContent.TMDB >= 0:
|
|
sMovieID = movie[pbContent.TMDB].strip()
|
|
if sMovieID:
|
|
if sMovieID != idTMDB:
|
|
continue
|
|
found = True
|
|
|
|
# sinon, recherche par titre/année
|
|
if not found:
|
|
# Filtrage par années
|
|
if searchYear and pbContent.YEAR >= 0:
|
|
sYear = movie[pbContent.YEAR].strip()
|
|
if sYear and sYear != searchYear:
|
|
continue
|
|
|
|
# Filtrage par titre
|
|
sTitle = movie[pbContent.TITLE].strip()
|
|
if sTitle != searchTitle:
|
|
continue
|
|
|
|
links = movie[pbContent.URLS]
|
|
|
|
# numérotation des épisodes 08 -> 8 (problème de décodage en octal)
|
|
if "{" in links:
|
|
links = links.replace('{0', '{').replace('{:', '{0:').replace(',0', ',')
|
|
|
|
listLinks = []
|
|
|
|
if "[" in links or "{" in links:
|
|
links = eval(links)
|
|
|
|
# Films
|
|
if isinstance(links, list):
|
|
for link in links:
|
|
listLinks.append(link)
|
|
|
|
#Séries
|
|
elif isinstance(links, dict):
|
|
if searchEpisode:
|
|
for numEpisode, link in links.items():
|
|
if str(numEpisode) == searchEpisode:
|
|
listLinks.append(link)
|
|
break
|
|
else:
|
|
listHoster.append(links)
|
|
|
|
# lien direct
|
|
else:
|
|
listLinks.append(links)
|
|
|
|
if len(listLinks) > 0:
|
|
listLinks = [(pbContent.resolveLink(pasteBin, link)) for link in listLinks]
|
|
listHoster.extend(listLinks)
|
|
|
|
# Retrouve les résolutions pour les films
|
|
if pbContent.RES >= 0 and 'film' in sMedia:
|
|
res = movie[pbContent.RES].strip()
|
|
if '[' in res:
|
|
listRes.extend(eval(res))
|
|
else:
|
|
listRes.append(res)
|
|
if len(listRes) < len(links): # On complete les résolutions manquantes
|
|
for _ in range(len(links) - len(listRes)):
|
|
listRes.append('')
|
|
|
|
# Retrouve les résolutions pour les séries
|
|
if pbContent.RES >= 0 and 'serie' in sMedia:
|
|
res = movie[pbContent.RES].strip()
|
|
if '[' in res:
|
|
listRes.extend(eval(res))
|
|
else:
|
|
listRes.append(res)
|
|
|
|
# Supprime les doublons en gardant l'ordre
|
|
# links = [links.extend(elem) for elem in listHoster if not elem in links]
|
|
|
|
return listHoster, listRes
|
|
|
|
|
|
# Ajout d'un dossier pastebin
|
|
def addPasteName():
|
|
oGui = cGui()
|
|
addons = addon()
|
|
|
|
# Recherche d'un setting de libre
|
|
names = set()
|
|
newID = 0
|
|
for numID in range(1, GROUPE_MAX):
|
|
pasteLabel = addons.getSetting(SETTING_PASTE_LABEL + str(numID))
|
|
if pasteLabel == '':
|
|
if newID == 0:
|
|
newID = numID
|
|
else:
|
|
names.add(pasteLabel) # Labels déjà utilisés
|
|
|
|
settingLabel = SETTING_PASTE_LABEL + str(newID)
|
|
|
|
# Demande du label et controle si déjà existant
|
|
sLabel = oGui.showKeyBoard('', "[COLOR coral]Saisir un nom pour le dossier[/COLOR]")
|
|
if sLabel == False:
|
|
return
|
|
if sLabel in names:
|
|
dialog().VSok(addons.VSlang(30082))
|
|
return
|
|
|
|
# Enregistrer Label/id dans les settings
|
|
addons.setSetting(settingLabel, sLabel)
|
|
dialog().VSinfo(addons.VSlang(30042))
|
|
|
|
oGui.updateDirectory()
|
|
|
|
|
|
# Retirer un dossier PasteBin
|
|
def deletePasteName():
|
|
|
|
addons = addon()
|
|
if not dialog().VSyesno(addons.VSlang(30456)):
|
|
return
|
|
|
|
cache = PasteCache()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
pasteID = oInputParameterHandler.getValue('pasteID')
|
|
|
|
labelSetting = SETTING_PASTE_LABEL + pasteID
|
|
addons.setSetting(labelSetting, '')
|
|
|
|
prefixID = SETTING_PASTE_ID + str(pasteID)
|
|
pasteID = addons.getSetting(prefixID)
|
|
if pasteID:
|
|
addons.setSetting(prefixID, '')
|
|
cache.remove(pasteID)
|
|
|
|
for numID in range(1, PASTE_PAR_GROUPE):
|
|
settingID = prefixID + '_' + str(numID)
|
|
pasteID = addons.getSetting(settingID)
|
|
if pasteID:
|
|
addons.setSetting(settingID, '')
|
|
cache.remove(pasteID)
|
|
|
|
cGui().updateDirectory()
|
|
|
|
|
|
# Renommer un dossier PasteBin
|
|
def renamePasteName():
|
|
|
|
addons = addon()
|
|
oGui = cGui()
|
|
|
|
# Recherche d'un setting de libre
|
|
names = set()
|
|
for numID in range(1, GROUPE_MAX):
|
|
pasteLabel = addons.getSetting(SETTING_PASTE_LABEL + str(numID))
|
|
if pasteLabel:
|
|
names.add(pasteLabel) # Labels déjà utilisés
|
|
|
|
# Demande du label et controle si déjà existant
|
|
sLabel = oGui.showKeyBoard('', "[COLOR coral]Saisir un nom pour le dossier[/COLOR]")
|
|
if sLabel == False:
|
|
return
|
|
if sLabel in names:
|
|
dialog().VSok(addons.VSlang(30082))
|
|
return
|
|
|
|
# Mettre à jour Label
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
pasteID = oInputParameterHandler.getValue('pasteID')
|
|
labelSetting = SETTING_PASTE_LABEL + pasteID
|
|
addons.setSetting(labelSetting, sLabel)
|
|
dialog().VSinfo(addons.VSlang(30042))
|
|
|
|
oGui.updateDirectory()
|
|
|
|
|
|
# Forcer la mise à jour d'un dossier PasteBin
|
|
def refreshPaste():
|
|
|
|
addons = addon()
|
|
cache = PasteCache()
|
|
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
pasteID = oInputParameterHandler.getValue('pasteID')
|
|
|
|
# Supprimer le cache de chaque paste du dossier
|
|
prefixID = SETTING_PASTE_ID + str(pasteID)
|
|
pasteBin = addons.getSetting(prefixID)
|
|
if pasteBin:
|
|
cache.remove(pasteBin)
|
|
for numID in range(1, PASTE_PAR_GROUPE):
|
|
pasteID = prefixID + '_' + str(numID)
|
|
pasteBin = addons.getSetting(pasteID)
|
|
if pasteBin != '':
|
|
cache.remove(pasteBin)
|
|
|
|
dialog().VSinfo(addons.VSlang(30014))
|
|
|
|
|
|
# Retirer tous les dossiers PasteBin
|
|
def deleteAllPasteName():
|
|
|
|
addons = addon()
|
|
cache = PasteCache()
|
|
|
|
for numID in range(1, GROUPE_MAX):
|
|
labelSetting = SETTING_PASTE_LABEL + str(numID)
|
|
pasteLabel = addons.getSetting(labelSetting)
|
|
if not pasteLabel:
|
|
continue
|
|
|
|
addons.setSetting(labelSetting, '')
|
|
|
|
prefixID = SETTING_PASTE_ID + str(numID)
|
|
pasteID = addons.getSetting(prefixID)
|
|
if pasteID:
|
|
addons.setSetting(prefixID, '')
|
|
cache.remove(pasteID)
|
|
|
|
for numID in range(1, PASTE_PAR_GROUPE):
|
|
settingID = prefixID + '_' + str(numID)
|
|
pasteID = addons.getSetting(settingID)
|
|
if pasteID:
|
|
addons.setSetting(settingID, '')
|
|
cache.remove(pasteID)
|
|
|
|
|
|
# Retourne la liste des PasteBin depuis l'URL ou un groupe
|
|
def getPasteList(siteUrl, pasteID):
|
|
addons = addon()
|
|
|
|
IDs = []
|
|
|
|
siteId = siteUrl.split(URL_MAIN) # Supporte le format https://pastebin.com/raw/izu23hfkjhd
|
|
if siteId[1]:
|
|
IDs.append(siteId[1])
|
|
|
|
if pasteID:
|
|
prefixID = SETTING_PASTE_ID + str(pasteID)
|
|
pasteBin = addons.getSetting(prefixID)
|
|
if pasteBin and pasteBin not in IDs:
|
|
IDs.append(pasteBin)
|
|
for numID in range(1, PASTE_PAR_GROUPE):
|
|
pasteID = prefixID + '_' + str(numID)
|
|
pasteBin = addons.getSetting(pasteID)
|
|
if pasteBin and pasteBin not in IDs:
|
|
IDs.append(pasteBin)
|
|
return IDs
|
|
|
|
|
|
# Ajout d'un lien pastebin
|
|
def addPasteID():
|
|
oGui = cGui()
|
|
addons = addon()
|
|
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
pasteID = oInputParameterHandler.getValue('pasteID')
|
|
|
|
# Recherche d'un setting de libre
|
|
# Et lister les pastes déjà déclarés pour éviter les doublons
|
|
IDs = set()
|
|
settingID = None
|
|
prefixID = SETTING_PASTE_ID + str(pasteID)
|
|
pasteBin = addons.getSetting(prefixID)
|
|
if pasteBin:
|
|
IDs.add(pasteBin) # IDs déjà renseigné
|
|
if pasteBin == '':
|
|
settingID = prefixID
|
|
for numID in range(1, PASTE_PAR_GROUPE):
|
|
pasteID = prefixID + '_' + str(numID)
|
|
pasteBin = addons.getSetting(pasteID)
|
|
if pasteBin != '':
|
|
IDs.add(pasteBin) # IDs déjà renseigné
|
|
elif not settingID:
|
|
settingID = pasteID
|
|
|
|
# Demande de l'id PasteBin
|
|
pasteID = oGui.showKeyBoard('', "[COLOR coral]Saisir le code du %s[/COLOR]" % SITE_NAME)
|
|
if pasteID == False:
|
|
return
|
|
if pasteID in IDs: # ID déjà dans le groupe
|
|
dialog().VSok(addons.VSlang(30082))
|
|
return
|
|
|
|
# Vérifier l'entete du Paste
|
|
pbContentNew = PasteContent()
|
|
|
|
try:
|
|
movies = pbContentNew.getLines(pasteID)
|
|
if len(movies) == 0:
|
|
dialog().VSok(addons.VSlang(30022))
|
|
return
|
|
except Exception:
|
|
dialog().VSinfo(addons.VSlang(30011))
|
|
raise
|
|
|
|
# Vérifier que les autres pastes du groupe ont le même format d'entete
|
|
if len(IDs) > 0:
|
|
pbContentOld = PasteContent()
|
|
pbContentOld.getLines(IDs.pop())
|
|
|
|
if not pbContentNew.isFormat(pbContentOld):
|
|
dialog().VSok(addons.VSlang(30022))
|
|
return
|
|
|
|
addons.setSetting(settingID, pasteID)
|
|
dialog().VSinfo(addons.VSlang(30042))
|
|
|
|
oGui.updateDirectory()
|
|
|
|
|
|
# Liste de pastes avec possibilité de les supprimer
|
|
def adminPasteID():
|
|
oGui = cGui()
|
|
addons = addon()
|
|
|
|
oGui.addText(SITE_IDENTIFIER, '[COLOR coral]Valider le code à retirer[/COLOR]', 'trash.png')
|
|
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
pasteID = oInputParameterHandler.getValue('pasteID') # Numéro du dossier
|
|
prefixID = SETTING_PASTE_ID + str(pasteID)
|
|
|
|
pbContentNew = PasteContent()
|
|
for numID in range(0, PASTE_PAR_GROUPE):
|
|
if numID == 0:
|
|
pasteBin = addons.getSetting(prefixID)
|
|
else:
|
|
pasteBin = addons.getSetting(prefixID + '_' + str(numID))
|
|
if not pasteBin:
|
|
continue
|
|
|
|
# Vérifier la qualité du Paste
|
|
color = 'white' # Forcer une couleur évite aussi le nettoyage du "titre"
|
|
try:
|
|
movies = pbContentNew.getLines(pasteBin)
|
|
if len(movies) == 0:
|
|
color = 'red'
|
|
except Exception:
|
|
dialog().VSinfo(addons.VSlang(30011))
|
|
raise
|
|
|
|
pasteLabel = '[COLOR %s]%s[/COLOR]' % (color, pasteBin)
|
|
|
|
oOutputParameterHandler = cOutputParameterHandler()
|
|
oOutputParameterHandler.addParameter('pasteID', pasteID)
|
|
oOutputParameterHandler.addParameter('pasteBin', pasteBin)
|
|
oGui.addDir(SITE_IDENTIFIER, 'deletePasteID', pasteLabel, 'trash.png', oOutputParameterHandler)
|
|
|
|
oGui.setEndOfDirectory()
|
|
|
|
|
|
# Suppression d'un paste dans un dossier
|
|
def deletePasteID():
|
|
|
|
addons = addon()
|
|
if not dialog().VSyesno(addons.VSlang(30456)):
|
|
return
|
|
|
|
cache = PasteCache()
|
|
oInputParameterHandler = cInputParameterHandler()
|
|
pasteID = oInputParameterHandler.getValue('pasteID') # Numéro du dossier
|
|
pasteDel = oInputParameterHandler.getValue('pasteBin') # Paste
|
|
|
|
prefixID = SETTING_PASTE_ID + str(pasteID)
|
|
pasteBin = addons.getSetting(prefixID)
|
|
if pasteDel == pasteBin:
|
|
addons.setSetting(prefixID, '')
|
|
cache.remove(pasteBin)
|
|
else:
|
|
for numID in range(1, PASTE_PAR_GROUPE):
|
|
pasteID = prefixID + '_' + str(numID)
|
|
pasteBin = addons.getSetting(pasteID)
|
|
if pasteDel == pasteBin:
|
|
addons.setSetting(pasteID, '')
|
|
cache.remove(pasteBin)
|
|
break
|
|
|
|
dialog().VSinfo(addons.VSlang(30072))
|
|
|
|
cGui().updateDirectory()
|