def showGenre():
oGui = cGui()
params = ParameterHandler()
if params.exist("sUrl"):
sUrl = params.getValue("sUrl")
oRequest = cRequestHandler(sUrl)
sHtmlContent = oRequest.request()
sPattern = '<TR>.*?<a href="([^"]+)">(.*?)</a>.*?<TD id="tdmovies" width="50">(.*?)</TD>'
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
if aResult[0] == True:
for aEntry in aResult[1]:
sUrl = aEntry[0].strip()
if not (sUrl.startswith("http")):
sUrl = URL_MAIN + "/" + sUrl
sTitle = aEntry[1] + " (" + aEntry[2] + ")"
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction("parseMovieSimpleList")
oGuiElement.setTitle(sTitle)
oOutputParameterHandler = ParameterHandler()
oOutputParameterHandler.setParam("sUrl", sUrl)
oGui.addFolder(oGuiElement, oOutputParameterHandler)
oGui.setEndOfDirectory()
def showFrontPage():
oParams = ParameterHandler()
sPattern = '<div class="box-container">.*?<a href="(.*?)".*?Staffel (.*?) Episode (.*?)".*?src="(http://seriesever.net/uploads/posters/thumb/.*?)".*?alt="(.*?)"'
# request
sHtmlContent = __getHtmlContent(URL_MAIN)
# parse content
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
oGui = cGui()
if (aResult[0] == True):
for link, season, episode, img, title in aResult[1]:
guiElement = cGuiElement('%s: Season %s - Episode %s' % (title, season, episode), SITE_IDENTIFIER, 'showHosters')
guiElement.setMediaType('episode')
guiElement.setSeason(season)
# Special fix for non-int episode numbers (like Attack on Titan 13.5)
# Can't even check this on thetvdb.com, because AOT 13.5 for example is Season 0 Episode 1
# May I can use "<airsbefore_episode>" and "<airsbefore_season>" for metadata
if representsInt(episode):
guiElement.setEpisode(episode)
guiElement.setTVShowTitle(title)
guiElement.setThumbnail(img)
oParams.setParam('sUrl', link)
oGui.addFolder(guiElement, oParams, bIsFolder=False)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def parseMovieEntrySite():
oParams = ParameterHandler()
sSecurityValue = oParams.getValue('securityCookie')
if oParams.exist('sUrl'):
sUrl = oParams.getValue('sUrl')
# get movieEntrySite content
sHtmlContent = __getHtmlContent(sUrl, sSecurityValue)
sMovieTitle = __createMovieTitle(sHtmlContent)
# get thumbnail
result = cParser().parse(sHtmlContent, '<div class="Grahpics">.*?<img src="([^"]+)"')
thumbnail = URL_MAIN + str(result[1][0]) if result[0] else False
bIsSerie = __isSerie(sHtmlContent)
if bIsSerie:
oGui = cGui()
aSeriesItems = parseSerieSite(sHtmlContent)
if not aSeriesItems[0]: return
total = len(aSeriesItems)
for aEntry in aSeriesItems[1]:
seasonNum = str(aEntry)
guiElement = cGuiElement('%s - Staffel %s' % (sMovieTitle, seasonNum), SITE_IDENTIFIER, 'showEpisodes')
guiElement.setMediaType('season')
guiElement.setSeason(seasonNum)
guiElement.setTVShowTitle(sMovieTitle)
oParams.setParam('Season', seasonNum)
if thumbnail:
guiElement.setThumbnail(thumbnail)
oGui.addFolder(guiElement, oParams, iTotal=total)
oGui.setView('seasons')
oGui.setEndOfDirectory()
else:
logger.info('Movie')
result = showHosters(sHtmlContent, sMovieTitle)
return result
def showSeasons():
logger.info('load showSeasons')
oParams = ParameterHandler()
sTitle = oParams.getValue('Title')
sPattern = '<a href="#season-(.*?)" data-parent=".*?>(.*?)</a>'
# request
sHtmlContent = __getHtmlContent()
# parse content
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
oGui = cGui()
if aResult[0]:
for sId, seasonNum in aResult[1]:
guiElement = cGuiElement('%s - Staffel %s' % (sTitle, seasonNum), SITE_IDENTIFIER, 'showEpisodes')
guiElement.setMediaType('season')
guiElement.setSeason(seasonNum)
guiElement.setTVShowTitle(sTitle)
oParams.setParam('Season', seasonNum)
oGui.addFolder(guiElement, oParams)
oGui.setView('seasons')
oGui.setEndOfDirectory()
def showXXX():
params = ParameterHandler()
oGui = cGui()
__createMainMenuEntry(oGui, 'All P**n', 661)
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('displaySearch')
oGuiElement.setTitle('Search XXX Streams')
params.setParam('searchType', '530')
oGui.addFolder(oGuiElement, params)
__createMainMenuEntry(oGui, 'Gay', '661&prefixid=Gay')
__createMainMenuEntry(oGui, 'Amateure', '661&prefixid=Amateure1')
__createMainMenuEntry(oGui, 'Anal', '661&prefixid=Anal')
__createMainMenuEntry(oGui, 'Asia', '661&prefixid=Asia')
__createMainMenuEntry(oGui, 'Black', '661&prefixid=Ebony')
__createMainMenuEntry(oGui, 'B*****b', '661&prefixid=B*****b')
__createMainMenuEntry(oGui, 'Deutsch', '661&prefixid=Deutsch')
__createMainMenuEntry(oGui, 'Fetish', '661&prefixid=Fetish')
__createMainMenuEntry(oGui, 'Gruppensex', '661&prefixid=Gruppensex')
__createMainMenuEntry(oGui, 'Hardcore', '661&prefixid=Hardcore')
__createMainMenuEntry(oGui, 'International', '661&prefixid=International')
__createMainMenuEntry(oGui, 'Lesben', '661&prefixid=Lesben')
__createMainMenuEntry(oGui, 'Masturbation', '661&prefixid=Masturbation')
__createMainMenuEntry(oGui, 'Teens', '661&prefixid=Teens')
oGui.setEndOfDirectory()
def showEpisodes():
oGui = cGui()
oParams = ParameterHandler()
sShowTitle = oParams.getValue('Title')
seriesId = oParams.getValue('seriesID')
sImdb = oParams.getValue('imdbID')
sSeason = oParams.getValue('Season')
logger.info("%s: show episodes of '%s' season '%s' " % (SITE_NAME, sShowTitle, sSeason))
data = _getJsonContent("series/%s/%s" % (seriesId, sSeason))
total = len(data['epi'])
for episode in data['epi']:
title = "%d - " % int(episode['epi'])
if episode['german']:
title += episode['german'].encode('utf-8')
else:
title += episode['english'].encode('utf-8')
guiElement = cGuiElement(title, SITE_IDENTIFIER, 'showHosters')
guiElement.setMediaType('episode')
guiElement.setSeason(data['season'])
guiElement.setEpisode(episode['epi'])
guiElement.setTVShowTitle(sShowTitle)
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
oParams.setParam('EpisodeNr', episode['epi'])
oGui.addFolder(guiElement, oParams, bIsFolder = False, iTotal = total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def __getAllSeasons(sUrl):
oGui = cGui()
oRequest = cRequestHandler(sUrl)
sHtmlContent = oRequest.request()
sPattern = '<SELECT name="season".*?>(.*?)</SELECT>'
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
if (aResult[0] == True):
sPattern = '<OPTION value="(\d+)".*?>([^<]+)</OPTION>'
aResult = oParser.parse(sHtmlContent,sPattern)
if (aResult[0] == True):
for aEntry in aResult[1]:
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('showAllEpisodes')
sTitle = aEntry[1].strip()
oGuiElement.setTitle(sTitle)
oOutputParameterHandler = ParameterHandler()
oOutputParameterHandler.setParam('sUrl', sUrl)
oOutputParameterHandler.setParam('season', aEntry[0])
oGui.addFolder(oGuiElement, oOutputParameterHandler)
oGui.setView('seasons')
oGui.setEndOfDirectory()
def showSeasons():
oGui = cGui()
params = ParameterHandler()
sTitle = params.getValue('Title')
seriesId = params.getValue('seriesID')
sImdb = params.getValue('imdbID')
logger.info("%s: show seasons of '%s' " % (SITE_NAME, sTitle))
data = _getJsonContent("series/%s/1" % seriesId)
rangeStart = not int(data["series"]["movies"])
total = int(data["series"]["seasons"])
for i in range(rangeStart, total + 1):
seasonNum = str(i)
if i is 0:
seasonTitle = 'Film(e)'
dialogType = 'showCinemaMovies'
else:
seasonTitle = '%s - Staffel %s' %(sTitle, seasonNum)
if params.getValue('specific') == 'Episode':
dialogType = 'randomEpisode'
else:
dialogType = 'showEpisodes'
guiElement = cGuiElement(seasonTitle, SITE_IDENTIFIER, dialogType)
guiElement.setMediaType('season')
guiElement.setSeason(seasonNum)
guiElement.setTVShowTitle(sTitle)
params.setParam('Season', seasonNum)
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
oGui.addFolder(guiElement, params, iTotal = total)
oGui.setView('seasons')
oGui.setEndOfDirectory()
def showEpisodes():
logger.info('load showEpisodes')
oParams = ParameterHandler()
sTitle = oParams.getValue('Title')
sSeason = oParams.getValue('Season')
sPattern = 'class="list-group-item".*?<span itemprop="name">Staffel ' + sSeason + ' Episode(?:[\s]*)(.*?)</span>.*?<a class="episode-name" href="(.*?)" title="(.*?)"'
# request
sHtmlContent = __getHtmlContent()
# parse content
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
oGui = cGui()
if (aResult[0] == True):
for eNr, link, title in aResult[1]:
guiElement = cGuiElement('Episode %s - %s' % (eNr, title), SITE_IDENTIFIER, 'showHosters')
guiElement.setMediaType('episode')
guiElement.setSeason(sSeason)
# Special fix for non-int episode numbers (like Attack on Titan 13.5)
# Can't even check this on thetvdb.com, because AOT 13.5 for example is Season 0 Episode 1
# May I can use "<airsbefore_episode>" and "<airsbefore_season>" for metadata
if representsInt(eNr):
guiElement.setEpisode(eNr)
guiElement.setTVShowTitle(sTitle)
oParams.setParam('sUrl', link)
oGui.addFolder(guiElement, oParams, bIsFolder=False)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def showEntries(entryUrl = False, sGui = False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not entryUrl: entryUrl = params.getValue('sUrl')
oRequest = cRequestHandler(entryUrl)
oGui.setView('tvshows' if 'serien/' in entryUrl else 'movies')
sHtmlContent = oRequest.request()
# Grab the link and title
pattern = '<a[^>]*href="([^"]*)"[^>]*title="([^"]*)"[^>]*>[^<]*'
# Grab the thumbnail
pattern +='<img[^>]*src=["\']([^"\']*)["\'][^>]*class="cover-opacity"[^>]*>'
aResult = cParser().parse(sHtmlContent, pattern)
if not aResult[0]:
return
for sUrl, sName, sThumbnail in aResult[1]:
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, 'showHosters')
oGuiElement.setMediaType('movie')
oGuiElement.setThumbnail(__checkUrl(sThumbnail))
params.setParam('entryUrl', __checkUrl(sUrl))
oGui.addFolder(oGuiElement, params, bIsFolder = False)
pattern = '<a[^>]*class="[^"]*pageing[^"]*"[^>]*'
pattern += 'href=["\']([^"\']*)["\'][^>]*>[ ]*vorw'
aResult = cParser().parse(sHtmlContent, pattern)
if aResult[0] and aResult[1][0]:
params.setParam('sUrl', aResult[1][0])
oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)
if not sGui:
oGui.setEndOfDirectory()
def showEpisodes():
oGui = cGui()
params = ParameterHandler()
sHtmlContent = _getRequestHandler(params.getValue('entryUrl')).request()
pattern = "<a[^>]*href=['\"]#streams_episodes_%d_(\d+)['\"][^>]*>.*?" % int(params.getValue('iReleaseId')) # EpisodeId
pattern += "<strong>(\d+)</strong>(.*?)</span>" # Episode-Nr / Name
aResult = cParser().parse(sHtmlContent, pattern)
if not aResult[0] or not aResult[1][0]:
oGui.showInfo('xStream','Es wurde kein Eintrag gefunden')
return
sThumbnail = params.getValue('sThumbnail')
sName = params.getValue('sName')
total = len(aResult[1])
for sEpisodeId, sNumber, sEpisodName in aResult[1]:
oGuiElement = cGuiElement(str(int(sNumber)) + " - " + sEpisodName, SITE_IDENTIFIER, 'showHosters')
oGuiElement.setTVShowTitle(sName)
oGuiElement.setMediaType('episode')
oGuiElement.setEpisode(int(sNumber))
oGuiElement.setThumbnail(sThumbnail)
params.setParam('iEpisodeId', int(sEpisodeId))
oGui.addFolder(oGuiElement, params, False, total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def showCharacters():
logger.info('load showCharacters')
oGui = cGui()
oParams = ParameterHandler()
sSecurityValue = oParams.getValue('securityCookie')
if oParams.exist('sUrl') and oParams.exist('page') and oParams.exist('mediaType'):
siteUrl = oParams.getValue('sUrl')
# iPage = oParams.getValue('page')
# sMediaType = oParams.getValue('mediaType')
# request
sHtmlContent = __getHtmlContent(siteUrl, sSecurityValue)
# parse content
sPattern = 'class="LetterMode.*?>([^>]+)</a>'
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
if aResult[0]:
for aEntry in aResult[1]:
oGuiElement = cGuiElement(aEntry, SITE_IDENTIFIER, 'ajaxCall')
# oOutputParameterHandler = ParameterHandler()
oParams.setParam('character', aEntry[0])
# oOutputParameterHandler.addParameter('page', iPage)
# oOutputParameterHandler.addParameter('mediaType', sMediaType)
# oOutputParameterHandler.addParameter('securityCookie', sSecurityValue)
if oParams.exist('mediaTypePageId'):
sMediaTypePageId = oParams.getValue('mediaTypePageId')
oParams.setParam('mediaTypePageId', sMediaTypePageId)
oGui.addFolder(oGuiElement, oParams)
oGui.setEndOfDirectory()
def randomSeason():
oGui = cGui()
oParams = ParameterHandler()
if oParams.getValue('specific') == 'Season' and not oParams.getValue('seriesID'):
showSeries()
return
data = _getJsonContent("series/%s/1" % oParams.getValue('seriesID'))
seasons = int(data["series"]["seasons"])+1
randomSeason = random.randrange(1, seasons, 1)
seasonNum = str(randomSeason)
seasonTitle = '%s - Staffel %s' % (oParams.getValue('Title'), seasonNum)
dialogType = 'showEpisodes'
guiElement = cGuiElement(seasonTitle, SITE_IDENTIFIER, dialogType)
guiElement.setMediaType('season')
guiElement.setSeason(seasonNum)
guiElement.setTVShowTitle(oParams.getValue('Title'))
oParams.setParam('Season', seasonNum)
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
oGui.addFolder(guiElement, oParams, iTotal=1)
oGui.setEndOfDirectory()
def showGenres():
oGui = cGui()
params = ParameterHandler()
for key in sorted(URL_GENRES_LIST):
params.setParam("sUrl", (URL_MAIN + URL_GENRES_LIST[key]))
oGui.addFolder(cGuiElement(key, SITE_IDENTIFIER, "showEntries"), params)
oGui.setEndOfDirectory()
def _cinema(oGui):
sPattern = '<div class="Opt leftOpt Headlne"><a title="(.*?)" href="(.*?)">.*?src="(.*?)".*?class="Descriptor">(.*?)</div.*?/lng/([0-9]+).png".*?IMDb:</b> (.*?) /'
oParams = ParameterHandler()
sSecurityValue = oParams.getValue('securityCookie')
sHtmlContent = __getHtmlContent(URL_CINEMA_PAGE, sSecurityValue)
# parse content
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
# iterate result and create GuiElements
if not aResult[0]: return
total = len(aResult[1])
for aEntry in aResult[1]:
sMovieTitle = aEntry[0]
lang = __createLanguage(aEntry[4])
rating = aEntry[5]
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('parseMovieEntrySite')
oGuiElement.setLanguage(lang)
oGuiElement.setTitle(sMovieTitle)
oGuiElement.setDescription(aEntry[3])
oGuiElement.setMediaType('movie')
oGuiElement.setThumbnail(URL_MAIN + str(aEntry[2]))
oGuiElement.addItemValue('rating', rating)
oParams.setParam('sUrl', URL_MAIN + str(aEntry[1]))
oGui.addFolder(oGuiElement, oParams, bIsFolder=False, iTotal=total)
def showSearchEntries(entryUrl=False, sGui=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not entryUrl:
entryUrl = params.getValue("sUrl")
sHtmlContent = cRequestHandler(entryUrl).request()
pattern = (
'class="short">.*?href="([^"]+)"[^>]class="title">([^<(]+)[^>]([^")]+).*?<img[^>]src="([^"]+)".*?>([^<]+)</p>'
)
aResult = cParser().parse(sHtmlContent, pattern)
if not aResult[0]:
if not sGui:
oGui.showInfo("xStream", "Es wurde kein Eintrag gefunden")
return
total = len(aResult[1])
util = cUtil()
for sEntryUrl, sName, sYear, sThumbnail, sDescription in aResult[1]:
oGuiElement = cGuiElement(util.unescape(sName.decode("utf-8")).encode("utf-8"), SITE_IDENTIFIER, "showHosters")
oGuiElement.setThumbnail(URL_MAIN + sThumbnail)
oGuiElement.setDescription(util.unescape(sDescription.decode("utf-8")).encode("utf-8"))
oGuiElement.setYear(sYear)
oGuiElement.setMediaType("movie")
params.setParam("entryUrl", sEntryUrl)
oGui.addFolder(oGuiElement, params, False, total)
return
def _cinema(oGui):
sPattern = '<div class="Opt leftOpt Headlne"><a title="(.*?)" href="(.*?)">.*?src="(.*?)".*?class="Descriptor">(.*?)</div.*?/lng/([0-9]+).png".*?IMDb:</b> (.*?) /'
oParams = ParameterHandler()
sSecurityValue = oParams.getValue('securityCookie')
sHtmlContent = __getHtmlContent(URL_CINEMA_PAGE, sSecurityValue)
# parse content
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
# iterate result and create GuiElements
if (aResult[0] == True):
total = len(aResult[1])
for aEntry in aResult[1]:
sMovieTitle = aEntry[0]
lang = aEntry[4]
rating = aEntry[5]
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('parseMovieEntrySite')
oGuiElement.setTitle(__createTitleWithLanguage(lang, sMovieTitle))
oGuiElement.setDescription(aEntry[3])
oGuiElement.setMediaType('movie')
oGuiElement.setThumbnail(aEntry[2])
oGuiElement.addItemValue('rating',rating)
#if META:
# oMetaget = metahandlers.MetaData()
# meta = oMetaget.get_meta('movie', sMovieTitle)
# oGuiElement.setItemValues(meta)
# oGuiElement.setThumbnail(meta['cover_url'])
# oGuiElement.setFanart(meta['backdrop_url'])
# oParams.setParam('imdbID', meta['imdb_id'])
oParams.setParam('sUrl', URL_MAIN + str(aEntry[1]))
oGui.addFolder(oGuiElement, oParams, bIsFolder = False, iTotal = total)
def showEntries(entryUrl = False, sGui = False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not entryUrl: entryUrl = params.getValue('sUrl')
sHtmlContent = cRequestHandler(entryUrl).request()
pattern = '<table[^>]*class="eBlock"[^>]*>.*?'
pattern += '<a[^>]*href="([^"]*)"[^>]*>(.*?)</a>.*?' # url / title
pattern += '<img[^>]*src="([^"]*)"[^>]*>.*?' # img
pattern += '(?:<fieldset[^>]*>.*?Jahr:</b>\s+(\d+).*?</fieldset>.*?)?' # year (opt)
pattern += '</table>'
aResult = cParser().parse(sHtmlContent, pattern)
if aResult[0] and aResult[1][0]:
total = len (aResult[1])
util = cUtil()
for sUrl, sName, sThumbnail, sJahr in aResult[1]:
oGuiElement = cGuiElement(util.unescape(sName.decode('utf-8')).encode('utf-8'), SITE_IDENTIFIER, 'showHosters')
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setThumbnail(sThumbnail if sThumbnail.startswith("http") else 'http:' + sThumbnail)
oGuiElement.setMediaType('movie')
oGuiElement.setYear(sJahr)
params.setParam('entryUrl', sUrl if sUrl.startswith("http") else URL_MAIN + sUrl)
oGui.addFolder(oGuiElement, params, False, total)
pattern = '<a[^>]*class="swchItem"[^>]*href="([^"]+)"[^>]*><span>»</span>'
aResult = cParser().parse(sHtmlContent, pattern)
if aResult[0] and aResult[1][0]:
params.setParam('sUrl', URL_MAIN + aResult[1][0])
oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)
if not sGui:
oGui.setView('movies')
oGui.setEndOfDirectory()
def showSeasons():
oGui = cGui()
params = ParameterHandler()
sTitle = params.getValue('Title')
seriesId = params.getValue('seriesID')
sImdb = params.getValue('imdbID')
logger.info("%s: show seasons of '%s' " % (SITE_NAME, sTitle))
sHtmlContent = _getContent("series/%s/1" % seriesId)
data = json.loads(sHtmlContent)
total = int(data["series"]["seasons"])
for i in range(1,total+1):
seasonNum = str(i)
guiElement = cGuiElement('%s - Staffel %s' %(sTitle,seasonNum), SITE_IDENTIFIER, 'showEpisodes')
guiElement.setMediaType('season')
guiElement.setSeason(seasonNum)
guiElement.setTVShowTitle(sTitle)
params.setParam('Season', seasonNum)
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
oGui.addFolder(guiElement, params, iTotal = total)
oGui.setView('seasons')
oGui.setEndOfDirectory()
def showGenre():
oGui = cGui()
oInputParameterHandler = ParameterHandler()
if (oInputParameterHandler.exist('sUrl')):
sUrl = oInputParameterHandler.getValue('sUrl')
oRequest = cRequestHandler(sUrl)
sHtmlContent = oRequest.request()
sPattern = '<TR>.*?<a href="([^"]+)">(.*?)</a>.*?<TD id="tdmovies" width="50">(.*?)</TD>'
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
if (aResult[0] == True):
for aEntry in aResult[1]:
sUrl = aEntry[0].strip()
if not (sUrl.startswith('http')):
sUrl = URL_MAIN + sUrl
sTitle = aEntry[1] + ' (' + aEntry[2] + ')'
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('parseMovieSimpleList')
oGuiElement.setTitle(sTitle)
oOutputParameterHandler = ParameterHandler()
oOutputParameterHandler.setParam('sUrl', sUrl)
oGui.addFolder(oGuiElement, oOutputParameterHandler)
oGui.setEndOfDirectory()
def __displayItems(oGui, sHtmlContent):
# Test if a cookie was set, else define the default empty one
sSecurityValue = ""
oParams = ParameterHandler()
if oParams.exist("securityCookie"):
sSecurityValue = oParams.getValue("securityCookie")
# The pattern to filter every item of the list
sPattern = '<td class="Icon"><img width="16" height="11" src="/gr/sys/lng/(\d+).png" alt="language"></td>'+\
'.*?title="([^\"]+)".*?<td class="Title">.*?<a href="([^\"]+)" onclick="return false;">([^<]+)</a>'
# Parse to get all items of the list
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
if not aResult[0]:
logger.error("Could not find an item")
return
# Go throught all items and create a gui element for them.
for aEntry in aResult[1]:
sTitle = __createTitleWithLanguage(aEntry[0], aEntry[3])
sUrl = URL_MAIN + aEntry[2]
if aEntry[1] == 'movie' or aEntry[1] == 'cinema':
mediaType = 'movie'
else:
mediaType = aEntry[1]
oGuiElement = cGuiElement(sTitle, SITE_IDENTIFIER, 'parseMovieEntrySite')
oParams.setParam('sUrl',sUrl)
oParams.setParam('mediaType',mediaType)
if mediaType == 'series':
oGui.addFolder(oGuiElement,oParams)
else:
oGui.addFolder(oGuiElement,oParams,bIsFolder=False)
def __getAllSeasons(sUrl):
oGui = cGui()
oRequest = cRequestHandler(sUrl)
sHtmlContent = oRequest.request()
sPattern = '<SELECT name="season".*?>(.*?)</SELECT>'
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
if not aResult[0]:
return
sPattern = '<OPTION value="(\d+)".*?>([^<]+)</OPTION>'
aResult = oParser.parse(sHtmlContent, sPattern)
if aResult[0] == True:
total = len(aResult[1])
for aEntry in aResult[1]:
season = aEntry[0]
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction("showAllEpisodes")
sTitle = aEntry[1].strip()
oGuiElement.setTitle(sTitle)
oGuiElement.setSeason(season)
oGuiElement.setMediaType("season")
oOutputParameterHandler = ParameterHandler()
oOutputParameterHandler.setParam("sUrl", sUrl)
oOutputParameterHandler.setParam("season", season)
oGui.addFolder(oGuiElement, oOutputParameterHandler, iTotal=total)
oGui.setView("seasons")
oGui.setEndOfDirectory()
def _parseMovieList(url):
oGui = cGui()
params = ParameterHandler()
oRequestHandler = cRequestHandler(url)
sHtmlContent = oRequestHandler.request()
# parse movie entries
pattern = 'class="tabel-topasd".*?<a href="([^"]+)"><img src="([^"]+)" title="([^"]+)".*?<span.*?>([^<>]+)</span>.*?title="([^"]+)"/>'
oParser = cParser()
aResult = oParser.parse(sHtmlContent, pattern)
if not aResult[0]:
return
total = len(aResult[1]) # Anzahl der Treffer
for link, img, title, plot, qual in aResult[1]:
titleParts = title.split('(') # Titel von Jahr trennen
movieTitle = titleParts[0].strip().decode('iso-8859-1').encode('utf-8') # encoding anpassen wegen Umlauten
guiElement = cGuiElement(movieTitle, SITE_IDENTIFIER, 'getHosters')
guiElement.setThumbnail(img) #Cover als Thumbnail setzen
guiElement.setDescription(plot.decode('iso-8859-1')) # Filmbeschreibung setzen, decode wegen Umlauten
if len(titleParts)>1:
tag = titleParts[-1].replace(')','')
if tag.isdigit() and len(tag)==4:
guiElement.setYear(tag)
guiElement.setMediaType('movie')
if '720p' in qual: # erst mal unwichtig
guiElement._sQuality = 720
elif '1080p' in qual:
guiElement._sQuality = 1080
params.setParam('siteUrl',link)
oGui.addFolder(guiElement, params, bIsFolder = False, iTotal = total)
oGui.setView('movies') #diese Liste unterliegt den automatisch ViewSettings für Filmlisten
oGui.setEndOfDirectory()
def _search(oGui, sSearchString):
searchUrl = URL_MAIN + 'livesearch.php?q='
oRequest = cRequestHandler(searchUrl + sSearchString)
content = oRequest.request()
searchPattern = "<table.*?<a href='([^']+)'.*?<img src='([^']+)'.*?>([^<>']+)</a>"
oParser = cParser()
aResult = oParser.parse(content, searchPattern)
if not aResult[0]:
return
###### parse entries
params = ParameterHandler()
function = 'getHosters'
iTotal = len(aResult[1])
for link, img, title in aResult[1]:
sLabel = title.split('(')
sTitle = sLabel[0].strip()
sNextUrl = link
params.setParam('siteUrl',sNextUrl)
oGuiElement = cGuiElement(sTitle, SITE_IDENTIFIER, function)
oGuiElement.setThumbnail(img)
#oGuiElement.setMediaType('movie')
if len(sLabel)>1:
year = sLabel[-1].replace(')','')
oGuiElement.setYear(year)
if 'site=Movies' in link:
oGuiElement.setMediaType('movie')
oGui.addFolder(oGuiElement, params, bIsFolder = False, iTotal = iTotal)
else:
continue
def showEpisodes():
oGui = cGui()
oParams = ParameterHandler()
sShowTitle = oParams.getValue('Title')
sUrl = oParams.getValue('siteUrl')
sImdb = oParams.getValue('imdbID')
sSeason = oParams.getValue('Season')
logger.info("%s: show episodes of '%s' season '%s' " % (SITE_NAME, sShowTitle, sSeason))
oRequestHandler = cRequestHandler(sUrl+"/"+sSeason)
sHtmlContent = oRequestHandler.request();
data = json.loads(sHtmlContent)
total = len(data['epi'])
for episode in data['epi']:
if episode['german']:
title = episode['german'].encode('utf-8')
else:
title = episode['english'].encode('utf-8')
guiElement = cGuiElement(str(episode['epi'])+" - "+title, SITE_IDENTIFIER, 'showHosters')
guiElement.setMediaType('episode')
guiElement.setSeason(data['season'])
guiElement.setEpisode(episode['epi'])
guiElement.setTVShowTitle(sShowTitle)
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
#oParams.setParam('EpisodeNr', episode['epi'])
oParams.setParam('siteUrl',sUrl+"/"+sSeason+"/"+episode['epi'])
oGui.addFolder(guiElement, oParams, bIsFolder = False, iTotal = total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def showFeaturedSeries():
oInputParameterHandler = ParameterHandler()
if (oInputParameterHandler.exist('sUrl')):
sUrl = oInputParameterHandler.getValue('sUrl')
oRequest = cRequestHandler(sUrl)
sHtmlContent = oRequest.request()
sPattern = '<div id="maincontenttvshow">(.*?)<BR><BR>'
aResult = cParser().parse(sHtmlContent,sPattern)
if aResult[0] == True:
sPattern = '<div style="float:left"><a href="([^"]+)"><img src="([^"]+)" border=0.*?title="([^"]+)"></a>.*?<img src="http://img.movie4k.to/img/(.*?).png"'
sHtmlContent = aResult[1][0]
aResult = cParser().parse(sHtmlContent, sPattern)
if aResult[0] == True:
oGui = cGui()
for aEntry in aResult[1]:
newUrl = str(aEntry[0]).strip()
if not (newUrl.startswith('http')):
newUrl = URL_MAIN + newUrl
sThumbnail = aEntry[1]
sMovieTitle = aEntry[2].strip().replace('\t', '')
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('showAllSeasons')
oGuiElement.setTitle(sMovieTitle)
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setLanguage(__getLanguage(aEntry[3]))
oOutputParameterHandler = ParameterHandler()
oOutputParameterHandler.setParam('sUrl', newUrl)
oGui.addFolder(oGuiElement, oOutputParameterHandler)
oGui.setView('tvshows')
oGui.setEndOfDirectory()
def showEntries(entryUrl=False, sGui=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not entryUrl: entryUrl = params.getValue('sUrl')
sHtmlContent = cRequestHandler(entryUrl).request()
pattern = 'class="list_film.*?img src="([^"]+).*?\s=\s\'([^\']+).*?>([^"(]+).*?\(([^")]+)'
aResult = cParser().parse(sHtmlContent, pattern)
if aResult[0] and aResult[1][0]:
total = len(aResult[1])
util = cUtil()
for sThumbnail, sUrl, sName, sJahr in aResult[1]:
oGuiElement = cGuiElement(
util.unescape(sName.decode('utf-8')).encode('utf-8'),
SITE_IDENTIFIER, 'showHosters')
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setYear(sJahr)
oGuiElement.setMediaType('movie')
params.setParam('entryUrl', URL_MAIN + sUrl)
oGui.addFolder(oGuiElement, params, False, total)
pattern = '"><a href="([^"]+)"([^>]+)?>»'
aResult = cParser().parse(sHtmlContent, pattern)
if aResult[0] and aResult[1][0] and 'void' not in aResult[1][0][0]:
params.setParam('sUrl', URL_MAIN + aResult[1][0][0])
oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)
if not sGui:
oGui.setView('movies')
oGui.setEndOfDirectory()
def showXXX():
params = ParameterHandler()
oGui = cGui()
__createMainMenuEntry(oGui, 'Alle Pornos', 661)
#im Moment können keine Clips abgespielt werden da die Cliphoster nicht aufgelöst werden können
#__createMainMenuEntry(oGui, 'Clips', 669, sSecurityValue)
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('displaySearch')
oGuiElement.setTitle('Suche XXX Streams')
params.setParam('searchType', '530')
oGui.addFolder(oGuiElement, params)
__createMainMenuEntry(oGui, 'Amateure', '661&prefixid=Amateure1')
__createMainMenuEntry(oGui, 'Anal', '661&prefixid=Anal')
__createMainMenuEntry(oGui, 'Asia', '661&prefixid=Asia')
__createMainMenuEntry(oGui, 'Black', '661&prefixid=Ebony')
__createMainMenuEntry(oGui, 'B*****b', '661&prefixid=B*****b')
__createMainMenuEntry(oGui, 'Deutsch', '661&prefixid=Deutsch')
__createMainMenuEntry(oGui, 'Fetish', '661&prefixid=Fetish')
__createMainMenuEntry(oGui, 'Große Brüste', '661&prefixid=GrosseBrueste')
__createMainMenuEntry(oGui, 'Gruppensex', '661&prefixid=Gruppensex')
__createMainMenuEntry(oGui, 'Gay', '661&prefixid=Gay')
__createMainMenuEntry(oGui, 'Hardcore', '661&prefixid=Hardcore')
__createMainMenuEntry(oGui, 'International', '661&prefixid=International')
__createMainMenuEntry(oGui, 'Lesben', '661&prefixid=Lesben')
__createMainMenuEntry(oGui, 'Masturbation', '661&prefixid=Masturbation')
__createMainMenuEntry(oGui, 'Teens', '661&prefixid=Teens')
oGui.setEndOfDirectory()
def showEpisodes():
oGui = cGui()
oParams = ParameterHandler()
sSeason = oParams.getValue('season')
sMovieTitle = oParams.getValue('sMovieTitle')
sMovie = oParams.getValue(PARAM_MOVIESEGMENT_KEY).replace(".html","/")
sUrl = URL_SERIES_EPISODEURL + sMovie
oRequest = cRequestHandler(sUrl)
#oRequest.setHeaderEntry("Accept","application/json, text/javascript, */*; q=0.01")
oRequest.addParameters("season",sSeason)
oRequest.addHeaderEntry("X-Requested-With","XMLHttpRequest")
oRequest.addHeaderEntry('Referer', sUrl)
oRequest.addHeaderEntry('Accept', '*/*')
oRequest.addHeaderEntry('Host', SITE_NAME.lower())
sHtmlContent = oRequest.request()
aData = sorted(loads(sHtmlContent)['episodes'])
for aEntry in aData:
logger.info(aEntry['episode'])
oGuiElement = cGuiElement()
oGuiElement.setFunction('_playEpisode')
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setTitle(sMovieTitle + '- S'+sSeason+'E'+str(aEntry['episode']))
oOutputParameterHandler = ParameterHandler()
oOutputParameterHandler.setParam('link',aEntry['link'])
oOutputParameterHandler.setParam('season',sSeason)
oOutputParameterHandler.setParam('episode',aEntry['episode'])
oOutputParameterHandler.setParam('sMovieTitle',sMovieTitle)
oOutputParameterHandler.setParam(PARAM_URL_KEY,"http://www.ecostream.tv/stream/"+aEntry['link']+".html")
oGui.addFolder(oGuiElement, oOutputParameterHandler, bIsFolder=False, iTotal = len(aData))
oGui.setView('episodes')
oGui.setEndOfDirectory()
def __createMainMenuItem(oGui, sTitle, sPlaylistId):
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('listVideos')
oGuiElement.setTitle(sTitle)
oOutputParameterHandler = ParameterHandler()
oOutputParameterHandler.setParam('playlistId', sPlaylistId)
oGui.addFolder(oGuiElement, oOutputParameterHandler)
def showGenre():
sHtmlContent = cRequestHandler(URL_MAIN).request()
pattern = '>Genre[^>]Listen</a>.*?</ul>'
isMatch, sContainer = cParser().parseSingleResult(sHtmlContent, pattern)
if not isMatch:
return
pattern = '<a[^>]href="([^"]+).*?">([^<]+)'
isMatch, aResult = cParser().parse(sContainer, pattern)
if not isMatch:
return
oGui = cGui()
params = ParameterHandler()
for sUrl, sName in aResult:
params.setParam('sUrl', sUrl)
oGui.addFolder(cGuiElement(sName , SITE_IDENTIFIER, 'showEntries'), params)
oGui.setEndOfDirectory()
def showGenre():
oGui = cGui()
params = ParameterHandler()
entryUrl = params.getValue('sUrl')
sHtmlContent = cRequestHandler(entryUrl).request()
parser = cParser()
isMatch, aResult = parser.parse(sHtmlContent, '<h1>Genre.*?</h1>.*?</div>')
if isMatch:
sHtmlContent = aResult[0]
pattern = '<li><a[^>]href="([^"]+)">([^"<]+)' # url / title
isMatch, aResult = parser.parse(sHtmlContent, pattern)
for sUrl, sTitle in aResult:
params.setParam('sUrl', URL_MAIN + '/' + sUrl)
oGui.addFolder(cGuiElement(sTitle, SITE_IDENTIFIER, 'showEntries'),
params)
oGui.setEndOfDirectory()
def showMenu():
oGui = cGui()
params = ParameterHandler()
baseURL = params.getValue('sUrl')
oGui.addFolder(cGuiElement('Top 100', SITE_IDENTIFIER, 'showTop100'),
params)
params.setParam('sUrl', baseURL + PARMS_GENRE_ALL + PARMS_SORT_LAST_UPDATE)
oGui.addFolder(
cGuiElement('Letztes Update', SITE_IDENTIFIER, 'showEntries'), params)
params.setParam('sUrl', baseURL + PARMS_GENRE_ALL + PARMS_SORT_BLOCKBUSTER)
oGui.addFolder(cGuiElement('Blockbuster', SITE_IDENTIFIER, 'showEntries'),
params)
params.setParam('sUrl', baseURL + PARMS_GENRE_ALL + PARMS_SORT_IMDB_RATING)
oGui.addFolder(cGuiElement('IMDB Rating', SITE_IDENTIFIER, 'showEntries'),
params)
params.setParam('sUrl', baseURL + PARMS_GENRE_ALL + PARMS_SORT_YEAR)
oGui.addFolder(cGuiElement('Jahr', SITE_IDENTIFIER, 'showEntries'), params)
params.setParam('sUrl', baseURL + PARMS_GENRE_ALL + PARMS_SORT_LAST_UPDATE)
oGui.addFolder(cGuiElement('Genre', SITE_IDENTIFIER, 'showGenre'), params)
oGui.setEndOfDirectory()
def showGenre():
oGui = cGui()
params = ParameterHandler()
entryUrl = params.getValue('sUrl')
sHtmlContent = cRequestHandler(entryUrl).request()
pattern = 'divider.*?<div[^>]class'
isMatch, sContainer = cParser.parseSingleResult(sHtmlContent, pattern)
if isMatch:
pattern = '#">(.*?)<'
isMatch, aResult = cParser.parse(sContainer, pattern)
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
for sName in aResult:
params.setParam('type', sName)
oGui.addFolder(cGuiElement(sName, SITE_IDENTIFIER, 'showEntries'),
params)
oGui.setEndOfDirectory()
def showSeries():# Danke Lynx187
oGui = cGui()
params = ParameterHandler()
sHtmlContent = cRequestHandler(URL_SERIES).request()
pattern = '<h3>([^<]+)</h3>\s*<p>\|.+?</p>'
aResult = cParser().parse(sHtmlContent, pattern)
if not aResult[0]:
oGui.showInfo('xStream','Es wurde kein Eintrag gefunden')
return
total = len(aResult[1])
util = cUtil()
for name in aResult[1]:
title = util.unescape(name.decode('utf-8')).encode('utf-8')
oGuiElement = cGuiElement(title, SITE_IDENTIFIER, 'showSeasons')
oGuiElement.setMediaType('tvshow')
oGuiElement.setTVShowTitle(title)
params.setParam('selectedShow', name)
oGui.addFolder(oGuiElement, params, True, total)
oGui.setView('tvshows')
oGui.setEndOfDirectory()
def showGenre():
oGui = cGui()
params = ParameterHandler()
sHtmlContent = cRequestHandler(params.getValue('sUrl')).request()
pattern = '<i[^>]*class="genre.*?<span>Genre</span>'
isMatch, sHtmlContainer = cParser.parseSingleResult(sHtmlContent, pattern)
if isMatch:
pattern = '<a[^>]*href="([^"]+)".*?i>([^<]+)'
isMatch, aResult = cParser.parse(sHtmlContainer, pattern)
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
for sUrl, sName in aResult:
params.setParam('sUrl', URL_MAIN + sUrl)
oGui.addFolder(
cGuiElement(sName.strip(), SITE_IDENTIFIER, 'showEntries'), params)
oGui.setEndOfDirectory()
def showGenreList():
oGui = cGui()
params = ParameterHandler()
sHtmlContent = cRequestHandler(params.getValue('sUrl')).request()
pattern = '<a[^>]*href="([^"]*)".*?' # url
pattern += '<i[^>]*class="fa fa-dot-circle-o".*?i>(.*?)</a>.*?' # title
aResult = cParser().parse(sHtmlContent, pattern)
if not aResult[0]:
return
total = len(aResult[1])
for sUrl, sTitle in aResult[1]:
params.setParam('sUrl', URL_MAIN + sUrl)
oGui.addFolder(cGuiElement(sTitle.strip(), SITE_IDENTIFIER,
'showEntries'),
params,
iTotal=total)
oGui.setEndOfDirectory()
def __createMainMenuEntry(oGui, sMenuName, iCategoryId, sSecurityValue=''):
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setTitle(sMenuName)
oGuiElement.setFunction('parseMovieResultSite')
params = ParameterHandler()
params.setParam('normalySiteUrl',
URL_CATEGORIES + str(iCategoryId) + '&order=desc&page=')
params.setParam('siteUrl',
URL_CATEGORIES + str(iCategoryId) + '&order=desc&page=1')
params.setParam('iPage', 1)
params.setParam('securityCookie', sSecurityValue)
oGui.addFolder(oGuiElement, params)
def showEntries(entryUrl=False, sGui=False, sSearchText=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not entryUrl: entryUrl = params.getValue('sUrl')
sHtmlContent = cRequestHandler(entryUrl,
ignoreErrors=(sGui is not False)).request()
pattern = '<div[^>]*class="poster">.*?<img[^>]*src="([^"]+).*?<a[^>]*href="([^"]+)">([^<]+).*?(?:<span>([^<]+)?).*?(?:<div[^>]*class="texto">([^<]+)?)'
isMatch, aResult = cParser.parse(sHtmlContent, pattern)
if not isMatch:
pattern = '<div[^>]*class="search_page_form">.*?</div></div></div>'
isMatch, sHtmlContainer = cParser.parseSingleResult(
sHtmlContent, pattern)
if not isMatch:
if not sGui:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
pattern = '<img[^>]*src="([^"]+).*?<a[^>]*href="([^"]+)">([^<]+)</a>.*?(?:<span[^>]*class="year">([^<]+)?).*?<p>([^<]+)'
isMatch, aResult = cParser.parse(sHtmlContainer, pattern)
if not isMatch:
if not sGui: oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
total = len(aResult)
for sThumbnail, sUrl, sName, sYear, sDesc in aResult:
if sSearchText and not cParser().search(sSearchText, sName):
continue
sThumbnail = cParser.replace('-\d+x\d+\.', '.', sThumbnail)
isTvshow = True if "tvshow" in sUrl else False
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER,
'showSeasons' if isTvshow else 'showHosters')
oGuiElement.setMediaType('tvshow' if isTvshow else 'movie')
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setFanart(sThumbnail)
oGuiElement.setYear(sYear)
oGuiElement.setDescription(sDesc)
params.setParam('entryUrl', sUrl)
params.setParam('sName', sName)
params.setParam('sThumbnail', sThumbnail)
oGui.addFolder(oGuiElement, params, isTvshow, total)
if not sGui:
pattern = "class=[^>]current.*?href='([^']+)"
isMatchNextPage, sNextUrl = cParser.parseSingleResult(
sHtmlContent, pattern)
if isMatchNextPage:
params.setParam('sUrl', sNextUrl)
oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)
oGui.setView('tvshows' if 'serien' in entryUrl else 'movies')
oGui.setEndOfDirectory()
def showEntries(entryUrl=False, sGui=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not entryUrl: entryUrl = params.getValue('sUrl')
iPage = int(params.getValue('page'))
if iPage > 0:
entryUrl = entryUrl + ('&' if '?' in entryUrl else
'?') + 'page=' + str(iPage)
oRequestHandler = cRequestHandler(entryUrl,
ignoreErrors=(sGui is not False))
sHtmlContent = oRequestHandler.request()
pattern = '<div class="cover"><a[^>]*href="([^"]+)" title="([^"]+).*?data-src="([^"]+)'
parser = cParser()
isMatch, aResult = parser.parse(sHtmlContent, pattern)
if not isMatch:
if not sGui: oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
total = len(aResult)
for sUrl, sName, sThumbnail in aResult:
sFunction = "showHosters" if not "serie" in sUrl else "showSeasons"
sThumbnail = cCFScrape().createUrl(URL_MAIN + sThumbnail,
oRequestHandler)
oGuiElement = cGuiElement(
cUtil().unescape(sName.decode('utf-8')).encode('utf-8'),
SITE_IDENTIFIER, sFunction)
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setMediaType('serie' if 'serie' in sUrl else 'movie')
params.setParam('entryUrl', URL_MAIN + sUrl)
params.setParam('sName', sName)
params.setParam('Thumbnail', sThumbnail)
oGui.addFolder(oGuiElement,
params,
bIsFolder="serie" in sUrl,
iTotal=total)
isMatch, strPage = parser.parseSingleResult(
sHtmlContent,
"<a[^>]class='current'.*?<a[^>]href='[^']*'[^>]*>(\d+)<[^>]*>")
if isMatch:
params.setParam('page', int(strPage))
oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)
if not sGui:
oGui.setView('tvshows' if 'serie' in entryUrl else 'movies')
oGui.setEndOfDirectory()
def showEntries(entryUrl=False, sGui=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not entryUrl: entryUrl = params.getValue('sUrl')
oRequestHandler = cRequestHandler(entryUrl, ignoreErrors=(sGui is not False))
oRequestHandler.addHeaderEntry('Referer', entryUrl)
sHtmlContent = oRequestHandler.request()
parser = cParser()
pattern = '<li[^>]*>\s*' # container start
pattern += "<a[^>]*href='[^>]*-(\d+).[^>]*'[^>]*>.*?" # entryId
pattern += "<img[^>]*src='([^']*)'[^>]*>.*?</a>.*?" # thumbnail
pattern += '<a[^>]*title="([^"]*)"[^>]*>([^<]*)</a>.*?' # desc, title
pattern += '<p>(\d+)</p>.*?' # year
pattern += '</li[^>]*>' # container end
isMatch, aResult = parser.parse(sHtmlContent, pattern)
if not isMatch:
if not sGui: oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
total = len(aResult)
for sEntryId, sThumbnail, sDesc, sName, sYear in aResult:
if sDesc.startswith(sName):
sDesc = sDesc[len(sName) + 3:].strip()
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, 'showHosters')
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setDescription(sDesc)
oGuiElement.setYear(sYear)
params.setParam('sUrl', URL_Hoster % sEntryId)
oGui.addFolder(oGuiElement, params, False, total)
if not sGui:
isMatchNextPage, sNextUrl = parser.parseSingleResult(sHtmlContent, '</strong>.*?<a[^>]*href="([^"]+)"[^>]*>\d+')
if isMatchNextPage:
params.setParam('sUrl', URL_MAIN + cUtil.unescape(sNextUrl))
oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)
oGui.setEndOfDirectory()
def showEntries(sContent=False, sGui=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if sContent:
sHtmlContent = sContent
else:
oRequestHandler = cRequestHandler(params.getValue('sUrl'))
sHtmlContent = oRequestHandler.request()
# Grab the thumbnail
pattern = '<div class="screenshot".*?<a href="([^"]+)"'
# Grab the name and link
pattern += '.*?<a class="[^"]*?entryLink[^"]*?".*?href="([^"]+)">(.*?)</a>'
# Grab the description
pattern += '.*?<div class="MessWrapsNews2".*?>([^<>]+).*?</div>'
aResult = cParser().parse(sHtmlContent, pattern)
if not aResult[0]:
return
for sThumbnail, sUrl, sName, sDesc in aResult[1]:
# Remove HTML tags from the name
sName = re.sub('<[^<]+?>', '', sName)
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, 'showHosters')
oGuiElement.setMediaType('movie')
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setDescription(sDesc.strip())
params.setParam('entryUrl', URL_MAIN + sUrl)
oGui.addFolder(oGuiElement, params, bIsFolder=False)
pattern = '<a class="swchItem" href="([^"]+)".*?><span>(\d+)</span></a>'
aResult = cParser().parse(sHtmlContent, pattern)
if aResult[0]:
currentPage = int(params.getValue('mediaTypePageId'))
for sUrl, sPage in aResult[1]:
page = int(sPage)
if page <= currentPage: continue
params.setParam('sUrl', URL_MAIN + sUrl)
params.setParam('mediaTypePageId', page)
oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)
break
oGui.setView('movies')
if not sGui:
oGui.setEndOfDirectory()
def showEntries(entryUrl=False, sGui=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not entryUrl: entryUrl = params.getValue('sUrl')
iPage = int(params.getValue('page'))
if iPage > 0:
entryUrl = entryUrl + ('&' if '?' in entryUrl else
'?') + 'page=' + str(iPage)
oRequestHandler = cRequestHandler(entryUrl,
ignoreErrors=(sGui is not False))
sHtmlContent = oRequestHandler.request()
pattern = '<a[^>]*href="([^"]+)" title="([^"]+)"><img src="([^"]+)" alt="'
parser = cParser()
isMatch, aResult = parser.parse(sHtmlContent, pattern)
if not isMatch:
if not sGui:
oGui.showInfo('streamon', 'Es wurde kein Eintrag gefunden')
return
total = len(aResult)
for sUrl, sName, sThumbnail in aResult:
sFunction = "showHosters" if not "serie" in sUrl else "showSeasons"
if sThumbnail.startswith('/'):
sThumbnail = URL_MAIN + sThumbnail
sThumbnail = cCFScrape().createUrl(sThumbnail, oRequestHandler)
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, sFunction)
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setMediaType('serie' if 'serie' in sUrl else 'movie')
params.setParam('entryUrl', URL_MAIN + sUrl)
params.setParam('sName', sName)
params.setParam('Thumbnail', sThumbnail)
oGui.addFolder(oGuiElement,
params,
bIsFolder="serie" in sUrl,
iTotal=total)
if not sGui:
isMatch, strPage = parser.parseSingleResult(
sHtmlContent,
'<a[^>]*class="next page-numbers"[^>]*href="[^>]*page=([^"]+)">Next »'
)
if isMatch:
params.setParam('page', int(strPage))
oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)
oGui.setView('tvshows' if 'serie' in entryUrl else 'movies')
oGui.setEndOfDirectory()
def searchRequest(dictFilter=False, sGui=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
dictFilter = {}
for (prop, val) in SEARCH_DICT.items():
parmVal = params.getValue(prop)
parmVal = ast.literal_eval(
parmVal
) if prop == 'year[]' and parmVal else parmVal # yes a bit ugly
dictFilter[prop] = parmVal if parmVal else val
params.setParam(prop, dictFilter[prop])
oResponse = _getJSonResponse(URL_SEARCH, dictFilter, (sGui is not False))
if 'entries' not in oResponse or len(oResponse['entries']) == 0:
if not sGui:
oGui.showInfo('streamon', 'Es wurde kein Eintrag gefunden')
return
sLanguage = _getPrefLanguage()
total = len(oResponse['entries'])
for aEntry in oResponse['entries']:
aLang = re.compile('(\w+)-').findall(aEntry['language'])
if sLanguage and sLanguage not in aLang:
continue
elif sLanguage:
aLang = [sLanguage]
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('showHosters')
oGuiElement.setTitle(aEntry['title'].encode('utf-8'))
oGuiElement.setMediaType('movie')
oGuiElement.setThumbnail(URL_PROTOCOL + aEntry['cover'])
oGuiElement.setYear(aEntry['year'])
oGuiElement.setLanguage(', '.join(map(str, aLang)))
if oGui.isMetaOn:
oGuiElement.addItemValue('imdb_id', 'tt' + aEntry['imdb'])
oOutParms = ParameterHandler()
oOutParms.setParam('itemID', aEntry['imdb'])
oOutParms.setParam('lang', aEntry['language'])
oGui.addFolder(oGuiElement, oOutParms, False, total, True)
if not sGui:
if int(oResponse['current']) < int(oResponse['pages']):
params.setParam('page', int(oResponse['current']) + 1)
oGui.addNextPage(SITE_IDENTIFIER, 'searchRequest', params)
oGui.setView('movies')
oGui.setEndOfDirectory()
def showEntries(entryUrl=False, sGui=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not entryUrl: entryUrl = params.getValue('sUrl')
oRequest = cRequestHandler(entryUrl, ignoreErrors=(sGui is not False))
sHtmlContent = oRequest.request()
pattern = 'data-id=.*?">[^>]*<a[^>]href="([^"]+)".*?'
pattern += "(?:url[^>]'([^']+)?).*?"
pattern += 'filename">([^<]+)'
isMatch, aResult = cParser().parse(sHtmlContent, pattern)
if not isMatch:
if not sGui: oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
cf = createUrl(entryUrl, oRequest)
total = len(aResult)
for sUrl, sThumbnail, sName in aResult:
isMatch, sYear = cParser.parse(sName, "(.*?)\((\d*)\)")
for name, year in sYear:
sName = name
sYear = year
break
isTvshow = True if "series" in sUrl else False
oGuiElement = cGuiElement(
sName, SITE_IDENTIFIER,
'showEpisodes' if isTvshow else 'showHosters')
oGuiElement.setMediaType('tvshow' if isTvshow else 'movie')
oGuiElement.setThumbnail(sThumbnail + cf)
oGuiElement.setFanart(sThumbnail + cf)
if sYear:
oGuiElement.setYear(sYear)
params.setParam('entryUrl', sUrl)
oGui.addFolder(oGuiElement, params, isTvshow, total)
isMatchNextPage, sNextUrl = cParser().parseSingleResult(
sHtmlContent, '<a[^>]href="([^"]+)"[^>]*rel="next"')
if isMatchNextPage:
sNextUrl = cUtil.cleanse_text(sNextUrl)
params.setParam('sUrl', sNextUrl)
oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)
if not sGui:
oGui.setView('tvshows' if 'serie' in entryUrl else 'movies')
oGui.setEndOfDirectory()
def showEntries(sGui = False, sSearchText = None):
oGui = sGui if sGui else cGui()
oParams = ParameterHandler()
oRequest = cRequestHandler(URL_REQUEST, ignoreErrors = (sGui is not False))
for key in DEFAULT_REQUEST_PARAMS:
oRequest.addParameters(key, DEFAULT_REQUEST_PARAMS[key])
oRequest.addParameters('type', oParams.getValue('type'))
if oParams.getValue('iDisplayStart'):
oRequest.addParameters('iDisplayStart', oParams.getValue('iDisplayStart'))
if sSearchText:
oRequest.addParameters('sSearch', sSearchText)
oRequest.addParameters('type', '')
oRequest.setRequestType(1)
sHtmlContent = oRequest.request()
isMatch, aResult = cParser().parse(sHtmlContent, '#tt(\d*).*?">(.*?)<')
if not isMatch:
if not sGui: oGui.showInfo('xStream','Es wurde kein Eintrag gefunden')
return
threads = []
for mId, sName in aResult:
t = threading.Thread(target=_addEntry, args=(oGui, sName, mId), name=sName)
threads += [t]
t.start()
for count, t in enumerate(threads):
t.join()
maxEntries = json.loads(sHtmlContent).items()[3][1]
if maxEntries > int(oParams.getValue('iDisplayStart')) and maxEntries > 50:
oParams.setParam('iDisplayStart', int(oParams.getValue('iDisplayStart')) + 50)
oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', oParams)
if not sGui:
oGui.setEndOfDirectory()
def load():
oGui = cGui()
sSecurityValue = __getSecurityCookieValue()
__createMainMenuEntry(oGui, 'Aktuelle KinoFilme', 542, sSecurityValue)
oGui.addFolder(cGuiElement('HD Filme', SITE_IDENTIFIER, 'showHDMovies'))
__createMainMenuEntry(oGui, 'Action', 591, sSecurityValue)
__createMainMenuEntry(oGui, 'Horror', 593, sSecurityValue)
__createMainMenuEntry(oGui, 'Komoedie', 592, sSecurityValue)
__createMainMenuEntry(oGui, 'Thriller', 595, sSecurityValue)
__createMainMenuEntry(oGui, 'Drama', 594, sSecurityValue)
__createMainMenuEntry(oGui, 'Fantasy', 655, sSecurityValue)
__createMainMenuEntry(oGui, 'Abenteuer', 596, sSecurityValue)
__createMainMenuEntry(oGui, 'Animation', 677, sSecurityValue)
__createMainMenuEntry(oGui, 'Dokumentation', 751, sSecurityValue)
#__createMainMenuEntry(oGui, 'Serien', 543, sSecurityValue)
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('displaySearch')
oGuiElement.setTitle('Suche Filme')
params = ParameterHandler()
params.setParam('securityCookie', sSecurityValue)
params.setParam('searchType', '528')
oGui.addFolder(oGuiElement, params)
# Serien parsing nicht implementiert
#oGuiElement = cGuiElement()
#oGuiElement.setSiteName(SITE_IDENTIFIER)
#oGuiElement.setFunction('displaySearch')
#oGuiElement.setTitle('Suche Serien')
#params.setParam('searchType', '532')
#oGui.addFolder(oGuiElement, params)
if showAdult():
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('showXXX')
oGuiElement.setTitle('XXX')
oGui.addFolder(oGuiElement, params)
oGui.setEndOfDirectory()
def showEpisodes():
oGui = cGui()
params = ParameterHandler()
entryUrl = params.getValue('entryUrl')
sThumbnail = params.getValue('sThumbnail')
imdbid = params.getValue('imdbid')
slanguage = params.getValue('language')
sSeason = params.getValue('Season')
sTVShowTitle = params.getValue('Name')
oRequest = cRequestHandler(EPISODE_URL)
oRequest.addHeaderEntry("X-Requested-With", "XMLHttpRequest")
oRequest.setRequestType(1)
oRequest.addParameters('imdbid', imdbid)
oRequest.addParameters('language', slanguage)
oRequest.addParameters('season', sSeason)
sHtmlContent = oRequest.request()
pattern = '>#([^<]+)</p>[^>]*[^>]*<script>.*?imdbid:[^>]"([^"]+).*?language:[^>]"([^"]+).*?season:[^>]"([^"]+)'
isMatch, aResult = cParser.parse(sHtmlContent, pattern)
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
sHtmlContent = cRequestHandler(entryUrl).request()
isMatchDesc, aResultDesc = cParser.parse(sHtmlContent, '<p[^>]*style=[^>]*>(.*?)</p>')
sDesc = ''
if isMatchDesc:
sDesc = aResultDesc[0]
total = len(aResult)
for sEpisode, imdbid, slanguage, sSeason in aResult:
oGuiElement = cGuiElement('Folge ' + sEpisode, SITE_IDENTIFIER, 'getHosters')
oGuiElement.setMediaType('season')
oGuiElement.setSeason(sSeason)
oGuiElement.setEpisode(sEpisode)
oGuiElement.setMediaType('episode')
oGuiElement.setTVShowTitle(sTVShowTitle)
oGuiElement.setDescription(sDesc)
if sThumbnail:
oGuiElement.setThumbnail(URL_MAIN + sThumbnail)
params.setParam('Episode', sEpisode)
params.setParam('Season', sSeason)
params.setParam('imdbid', imdbid)
params.setParam('language', slanguage)
oGui.addFolder(oGuiElement, params, False, total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def _addEntry(oGui, sName, mId):
oParams = ParameterHandler()
oParams.setParam('id', mId)
info = loadInformation(mId)
isFolder = False
if info:
isFolder = info[4] is not False
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER,
'showSeasons' if info[4] else 'showHosters')
oGuiElement.setTitle(info[5])
oGuiElement.setDescription(info[0])
oGuiElement.setLanguage(info[3])
oGuiElement.setThumbnail(info[1])
oGuiElement.setYear(info[2])
oParams.setParam('lang', info[3])
oGui.addFolder(oGuiElement,
oParams,
bIsFolder=isFolder,
isHoster=not isFolder)
def showGenre():
oGui = cGui()
params = ParameterHandler()
oRequestHandler = cRequestHandler(params.getValue('sUrl'))
sHtmlContent = oRequestHandler.request()
pattern = '<a[^>]*?class="CatInf"[^>]*?href="([^"]+).*?' # Link
pattern += '<div[^>]*?class="CatNumInf">(\d+).*?' # count
pattern += '<div[^>]*?class="CatNameInf">([^<]+)' # Name
isMatch, aResult = cParser.parse(sHtmlContent, pattern)
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
for sUrl, sCount, sName in aResult:
params.setParam('sUrl', sUrl)
params.setParam('PageId', 1)
oGui.addFolder(
cGuiElement("%s (%d)" % (sName, int(sCount)), SITE_IDENTIFIER,
'showEntries'), params)
oGui.setEndOfDirectory()
def showEpisodes(sEpisodes=False, sGui=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not sEpisodes: sEpisodes = params.getValue('sEpisodes')
sHtmlContent = cRequestHandler(sEpisodes).request()
pattern = 'data-video="([^"]+).*?<img[^>]*src="([^"]+)".*?</div><span[^>]*class="title">([^<]+)'
isMatch, aResult = cParser().parse(sHtmlContent, pattern)
if not isMatch:
if not sGui: oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
total = len(aResult)
for sUrl, sThumbnail, sName in aResult:
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, 'getHosterUrl')
isMatch, Episodes = cParser.parseSingleResult(sEpisodes, 'de/([^"]+/)')
oGuiElement.setThumbnail(URL_MAIN + Episodes + sThumbnail)
oGuiElement.setDescription(URL_MAIN + Episodes + sThumbnail)
params.setParam('url', 'https://www.youtube.com/watch?v=' + sUrl)
oGui.addFolder(oGuiElement, params, False, total)
oGui.setEndOfDirectory()
def showEpisodes():
oGui = cGui()
params = ParameterHandler()
sUrl = ParameterHandler().getValue('entryUrl')
oRequest = cRequestHandler(sUrl)
oRequest.addHeaderEntry('Upgrade-Insecure-Requests', '1')
sHtmlContent = oRequest.request()
pattern = 'data-title="([^"]+).*?data-url="([^"]+)'
isMatch, aResult = cParser.parse(sHtmlContent, pattern)
if not isMatch:
oGui.showInfo('streamon', 'Es wurde kein Eintrag gefunden')
return
total = len(aResult)
for sName, sUrl in aResult:
if not 'trailer' in sName.lower():
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, 'getHosterUrl')
params.setParam('sUrl', sUrl)
oGui.addFolder(oGuiElement, params, False, total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def showAlphaNumeric():
sHtmlContent = cRequestHandler(URL_MAIN).request()
pattern = '<div[^>]*class="catalog-nav"[^>]*>(.*?)</div>'
isMatch, sContainer = cParser().parseSingleResult(sHtmlContent, pattern)
if not isMatch:
return
pattern = '<a[^>]*href="([^"]+)"[^>]*>(\w)</a>'
isMatch, aResult = cParser().parse(sContainer, pattern)
if not isMatch:
return
oGui = cGui()
params = ParameterHandler()
for sUrl, sName in aResult:
params.setParam('sUrl', URL_MAIN + sUrl)
oGui.addFolder(cGuiElement(sName, SITE_IDENTIFIER, 'showEntries'),
params)
oGui.setEndOfDirectory()
def showYearOrGenreList():
oGui = cGui()
sHtmlContent = cRequestHandler(URL_MAIN).request()
pattern = "<a[^>]*href=['\"][^'\"]*['\"][^>]*>%s</a><ul class=['\"]sub-menu['\"]>(.*?)</ul>" % ParameterHandler(
).getValue('sTyp')
aResult = cParser().parse(sHtmlContent, pattern)
if aResult[0]:
aResult = cParser().parse(
aResult[1][0],
"<a[^>]*href=['\"]([^'\"]*)['\"][^>]*>(.*?)</a></li>")
if not aResult[0]:
return
total = len(aResult[1])
for sUrl, sTitle in aResult[1]:
oOutParms = ParameterHandler()
oOutParms.setParam('sUrl', sUrl)
oGui.addFolder(cGuiElement(sTitle.strip(), SITE_IDENTIFIER,
'showEntries'),
oOutParms,
iTotal=total)
oGui.setEndOfDirectory()
def showValue():
oGui = cGui()
params = ParameterHandler()
value = params.getValue("value")
sHtmlContent = cRequestHandler(params.getValue('sUrl')).request()
pattern = '<section[^>]id="%s">(.*?)</section>' % value
isMatch, sContainer = cParser.parseSingleResult(sHtmlContent, pattern)
if isMatch:
pattern = 'href="([^"]+)">([^<]+)'
isMatch, aResult = cParser.parse(sContainer, pattern)
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
for sUrl, sName in aResult:
params.setParam('sUrl', sUrl)
oGui.addFolder(cGuiElement(sName, SITE_IDENTIFIER, 'showEntries'),
params)
oGui.setEndOfDirectory()
def showSeasons(): # Danke Lynx187
oGui = cGui()
params = ParameterHandler()
selectedShow = params.getValue('selectedShow')
sHtmlContent = cRequestHandler(URL_SERIES).request()
pattern = '<h3>%s</h3>\s*<p>\|(.*?)</p>' % selectedShow
aResult = cParser().parse(sHtmlContent, pattern)
pattern = 'href="([^"]+)">([^<]+)<'
aResult = cParser().parse(aResult[1][0], pattern)
if not aResult[0]:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
total = len(aResult[1])
for link, name in aResult[1]:
oGuiElement = cGuiElement(name, SITE_IDENTIFIER, 'showEntries')
oGuiElement.setSeason(name.split(' ')[-1])
oGuiElement.setMediaType('season')
params.setParam('sUrl', link)
oGui.addFolder(oGuiElement, params, True, total)
oGui.setView('seasons')
oGui.setEndOfDirectory()
def showGenre():
oGui = cGui()
params = ParameterHandler()
entryUrl = params.getValue('sUrl')
sHtmlContent = cRequestHandler(entryUrl).request()
isMatch, sContainer = cParser.parseSingleResult(
sHtmlContent, 'id="categories.*?class="clear">')
if isMatch:
pattern = '<a[^>]href="([^"]+)"[^>]*>([^<]+)</a>([^<]+)'
isMatch, aResult = cParser.parse(sContainer, pattern)
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
for sUrl, sTitle, Nr in aResult:
params.setParam('sUrl', URL_MAIN + sUrl)
oGui.addFolder(
cGuiElement(sTitle + Nr, SITE_IDENTIFIER, 'showEntries'), params)
oGui.setEndOfDirectory()
def showMovieMenu():
sHtmlContent = cRequestHandler(URL_MAIN).request()
pattern = '<input[^>]*name="kind"[^>]*value="(.*?)"[^>]*>' # kind
isMatch, aResult = cParser().parse(sHtmlContent, pattern)
if not isMatch:
return
oGui = cGui()
params = ParameterHandler()
for sKind in aResult:
params.setParam('kind', sKind)
oGui.addFolder(
cGuiElement(sKind.title(), SITE_IDENTIFIER, 'searchRequest'),
params)
oGui.addFolder(cGuiElement('Genre', SITE_IDENTIFIER, 'showGenresMenu'))
oGui.addFolder(
cGuiElement('Erscheinungszeitraum', SITE_IDENTIFIER, 'showYearSearch'))
oGui.addFolder(
cGuiElement('Geringstes Rating', SITE_IDENTIFIER, 'showRatingSearch'))
oGui.setEndOfDirectory()
def load():
logger.info("Load %s" % SITE_NAME)
oGui = cGui()
params = ParameterHandler()
params.setParam('sUrl', URL_KINO)
oGui.addFolder(cGuiElement('Kino Filme', SITE_IDENTIFIER, 'showEntries'),
params)
params.setParam('sUrl', URL_FILME)
oGui.addFolder(cGuiElement('Filme', SITE_IDENTIFIER, 'showEntries'),
params)
params.setParam('sUrl', URL_SERIES)
oGui.addFolder(cGuiElement('Serien', SITE_IDENTIFIER, 'showEntries'),
params)
params.setParam('sUrl', URL_GENRES_FILM)
oGui.addFolder(cGuiElement('Film Genre', SITE_IDENTIFIER, 'showGenre'),
params)
params.setParam('sUrl', URL_GENRES_SERIE)
oGui.addFolder(cGuiElement('Serien Genre', SITE_IDENTIFIER, 'showGenre'),
params)
oGui.addFolder(cGuiElement('Suche', SITE_IDENTIFIER, 'showSearch'))
oGui.setEndOfDirectory()
def load():
# Logger-Eintrag
logger.info("Load %s" % SITE_NAME)
# GUI-Element erzeugen
oGui = cGui()
# ParameterHandler erzeugen
params = ParameterHandler()
# Einträge anlegen
params.setParam('sUrl', URL_MOVIES)
oGui.addFolder(cGuiElement('Filme', SITE_IDENTIFIER, 'showContentMenu'),
params)
params.setParam('sUrl', URL_SHOWS)
oGui.addFolder(cGuiElement('Serien', SITE_IDENTIFIER, 'showContentMenu'),
params)
oGui.addFolder(cGuiElement('Suche', SITE_IDENTIFIER, 'showSearch'))
# Liste abschließen
oGui.setEndOfDirectory()
