def getChangedSeriesNames(markers):
IDs = []
for marker in markers:
(Serie, Info, WLID) = marker
IDs.append(WLID)
from SerienRecorderSeriesServer import SeriesServer
series = SeriesServer().getSeriesNamesAndInfoByWLID(IDs)
result = {}
#from SerienRecorderLogWriter import SRLogger
for marker in markers:
try:
(name, info, wl_id) = marker
for serie in series:
if str(wl_id) == str(serie['id']):
if name != serie['name'] or info != serie['info']:
#SRLogger.writeTestLog("Found difference: %s [%s / %s]" % (name, serie['name'], serie['info']))
result[str(wl_id)] = dict(old_name=name,
new_name=serie['name'],
new_info=serie['info'])
break
except:
continue
return result
def getData(self):
try:
infoText = SeriesServer().getSeriesInfo(self.serieID)
except:
infoText = 'Es ist ein Fehler beim Abrufen der Serien-Informationen aufgetreten!'
self['info'].setText(infoText)
SerienRecorder.getCover(self, self.serieName, self.serieID)
def readWebChannels(self):
print "[SerienRecorder] call webpage."
self['title'].setText("Lade Wunschliste-Sender...")
try:
self.createWebChannels(SeriesServer().doGetWebChannels(), False)
except:
self['title'].setText("Fehler beim Laden der Wunschliste-Sender")
def changeTVDBID(self):
if fileExists("/etc/enigma2/SerienRecorder.tvdb.id"):
self.tvdb_id = SeriesServer().getTVDBID(self.serien_id)
if self.tvdb_id is False:
self.session.open(
MessageBox,
"Fehler beim Abrufen der TVDB-ID vom SerienServer!",
MessageBox.TYPE_ERROR,
timeout=5)
else:
tvdb_id_text = str(
self.tvdb_id) if self.tvdb_id > 0 else 'Keine'
message = "Für ' %s ' ist folgende TVBD-ID zugewiesen: %s\n\nMöchten Sie die TVDB-ID ändern?" % (
self.serien_name, tvdb_id_text)
self.session.openWithCallback(self.enterTVDBID,
MessageBox,
message,
MessageBox.TYPE_YESNO,
default=False)
else:
message = "Cover und Serien-/Episodeninformationen stammen von 'TheTVDB' - dafür muss jeder Serie eine TVDB-ID zugewiesen werden. " \
"Für viele Serien stellt Wunschliste diese ID zur Verfügung, manchmal ist sie aber falsch oder fehlt ganz.\n\n" \
"In diesem Fall kann die TVDB-ID über diese Funktion direkt im SerienRecorder geändert und auf dem SerienServer " \
"gespeichert werden, sodass alle SerienRecorder Nutzer von der Änderung profitieren.\n\n" \
"Um Missbrauch zu verhindern, muss diese Funktion aber erst freigeschaltet werden, wer sich beteiligen möchte, kann " \
"sich an den SerienRecorder Entwickler wenden."
self.session.open(MessageBox,
message,
MessageBox.TYPE_INFO,
timeout=0)
def getData(self): try: infoText = SeriesServer().getEpisodeInfo(self.episodeID) except: infoText = 'Es ist ein Fehler beim Abrufen der Episoden-Informationen aufgetreten!' self['info'].setText(infoText) super(self.__class__, self).getCover(self.serien_name)
def readPlanerData(self, answer=True):
print "[SerienRecorder] readPlanerData"
if not showMainScreen:
self.keyCancel()
self.close()
return
self.loading = True
cache = serienRecSeriesPlanner.loadPlanerData(
config.plugins.serienRec.screenplaner.value)
if answer:
cache.clear()
self.setHeadline()
self['title'].instance.setForegroundColor(parseColor("foreground"))
lt = datetime.datetime.now()
if config.plugins.serienRec.screenplaner.value == 1:
lt += datetime.timedelta(days=self.page)
key = time.strftime('%d.%m.%Y', lt.timetuple())
if key in cache:
try:
self['title'].setText("Lade Infos vom Speicher...")
if config.plugins.serienRec.screenplaner.value == 1:
self.processPlanerData(cache[key], True)
else:
self.processTopThirty(cache[key], True)
except:
SRLogger.writeLog(
"Fehler beim Abrufen und Verarbeiten der Daten\n", True)
else:
self['title'].setText("Lade Infos vom Web...")
webChannels = self.database.getActiveChannels()
try:
if config.plugins.serienRec.screenplaner.value == 1:
planerData = SeriesServer().doGetPlanerData(
int(self.page), webChannels)
self.processPlanerData(planerData, False)
else:
topThirtyData = SeriesServer().doGetTopThirty()
self.processTopThirty(topThirtyData, False)
except:
SRLogger.writeLog(
"Fehler beim Abrufen und Verarbeiten der Daten\n", True)
def download(self, data): (seriesID, timeSpan, markerChannels, seriesTitle, season, fromEpisode, numberOfRecords, currentTime, futureTime, excludedWeekdays) = data try: isTransmissionFailed = False transmissions = SeriesServer().doGetTransmissions(seriesID, timeSpan, markerChannels) except: isTransmissionFailed = True transmissions = None self.resultQueue.put((isTransmissionFailed, transmissions, seriesID, seriesTitle, season, fromEpisode, numberOfRecords, currentTime, futureTime, excludedWeekdays))
def run(self):
try:
from SerienRecorderSeriesServer import SeriesServer
self.planerData = SeriesServer().doGetPlanerData(
self.daypage, self.webChannels)
except:
SRLogger.writeLog(
"Fehler beim Abrufen und Verarbeiten der SerienPlaner-Daten [%s]\n"
% str(self.daypage), True)
def autoMatch(self, execute):
if execute:
if config.plugins.serienRec.selectBouquets.value:
self.stbChannelList = STBHelpers.buildSTBChannelList(config.plugins.serienRec.MainBouquet.value)
else:
self.stbChannelList = STBHelpers.buildSTBChannelList()
self['title'].setText("Versuche automatische Zuordnung...")
try:
self.createWebChannels(SeriesServer().doGetWebChannels(), True)
except:
self['title'].setText("Fehler beim Laden der Wunschliste-Sender")
def loadEpisodes(self):
self.timer_default.stop()
if self.page in self.episodes_list_cache:
self.chooseMenuList.setList(map(self.buildList_episodes, self.episodes_list_cache[self.page]))
else:
getCover(self, self.serien_name, self.serien_id)
try:
episodes = SeriesServer().doGetEpisodes(int(self.serien_id), int(self.page))
self.resultsEpisodes(episodes)
except:
self['title'].setText("Fehler beim Abrufen der Episodenliste")
def setTVDBID(self, tvdb_id):
if tvdb_id:
from SerienRecorder import getCover
if not SeriesServer().setTVDBID(self.serien_id, tvdb_id):
self.session.open(
MessageBox,
"Die TVDB-ID konnte nicht auf dem SerienServer geändert werden!",
MessageBox.TYPE_ERROR,
timeout=5)
getCover(self.parent, self.serien_name, self.serien_id, False,
True)
def getCover(self, serien_name, serien_id, auto_check = False, forceReload = False):
if not config.plugins.serienRec.downloadCover.value:
return
serien_name = doReplaces(serien_name.encode('utf-8'))
serien_nameCover = "%s%s.jpg" % (config.plugins.serienRec.coverPath.value, serien_name)
png_serien_nameCover = "%s%s.png" % (config.plugins.serienRec.coverPath.value, serien_name)
try:
if self and config.plugins.serienRec.showCover.value:
self['cover'].hide()
global coverToShow
coverToShow = serien_nameCover
if not fileExists(config.plugins.serienRec.coverPath.value):
try:
os.mkdir(config.plugins.serienRec.coverPath.value)
except:
Notifications.AddPopup("Cover Pfad (%s) kann nicht angelegt werden.\n\nÜberprüfen Sie den Pfad und die Rechte!" % config.plugins.serienRec.coverPath.value, MessageBox.TYPE_INFO, timeout=10, id="checkFileAccess")
# Change PNG cover file extension to correct file extension JPG
if fileExists(png_serien_nameCover):
os.rename(png_serien_nameCover, serien_nameCover)
if forceReload:
os.remove(serien_nameCover)
if config.plugins.serienRec.refreshPlaceholderCover.value and fileExists(serien_nameCover) and os.path.getsize(serien_nameCover) == 0:
statinfo = os.stat(serien_nameCover)
if (statinfo.st_ctime + 5184000) <= time.time(): # Older than 60 days
os.remove(serien_nameCover)
if fileExists(serien_nameCover):
if self and config.plugins.serienRec.showCover.value:
showCover(serien_nameCover, self, serien_nameCover)
elif serien_id and (config.plugins.serienRec.showCover.value or (config.plugins.serienRec.downloadCover.value and auto_check)):
try:
posterURL = SeriesServer().doGetCoverURL(int(serien_id), serien_name)
#writeLog("Cover URL [%s] => %s" % (serien_name, posterURL), True)
if posterURL:
from twisted.web.client import downloadPage
downloadPage(posterURL, serien_nameCover).addCallback(showCover, self, serien_nameCover, False).addErrback(getCoverDataError, self, serien_nameCover)
else:
if config.plugins.serienRec.createPlaceholderCover.value:
open(serien_nameCover, "a").close()
except:
if config.plugins.serienRec.createPlaceholderCover.value:
open(serien_nameCover, "a").close()
getCoverDataError("failed", self, serien_nameCover)
except:
SRLogger.writeLog("Fehler bei Laden des Covers: %s " % serien_nameCover, True)
def __onLayoutFinished(self):
self._numberOfCovers = 0
from SerienRecorderSeriesServer import SeriesServer
print "[SerienRecorder] Get covers for id = ", str(self._wlID)
covers = SeriesServer().getCoverURLs(self._wlID)
if covers is not None:
print "[SerienRecorder] Number of covers found = ", len(covers)
self._numberOfCovers = len(covers)
ds = defer.DeferredSemaphore(tokens=5)
downloads = [ds.run(self.download, cover).addCallback(self.buildList, cover).addErrback(self.dataError) for cover in covers]
defer.DeferredList(downloads).addErrback(self.dataError).addCallback(self.dataFinish)
else:
self['footer'].setText("Keine Cover gefunden!")
def loadEpisodes(self):
self.timer_default.stop()
if self.page in self.episodes_list_cache:
self.chooseMenuList.setList(map(self.buildList_episodes, self.episodes_list_cache[self.page]))
self['title'].setText("%s Episoden für ' %s ' gefunden." % (self.numberOfEpisodes, self.serien_name))
else:
getCover(self, self.serien_name, self.serien_id)
try:
episodes = SeriesServer().doGetEpisodes(int(self.serien_id), int(self.page))
self.resultsEpisodes(episodes)
self['title'].setText("%s Episoden für ' %s ' gefunden." % (self.numberOfEpisodes, self.serien_name))
except:
self['title'].setText("Fehler beim Abrufen der Episodenliste")
self.loading = False
self['headline'].show()
def channelReset(self, execute):
if execute:
print "[SerienRecorder] channel-list reset..."
SRLogger.writeLog("Senderliste wird aktualisiert...")
if config.plugins.serienRec.selectBouquets.value:
self.stbChannelList = STBHelpers.buildSTBChannelList(config.plugins.serienRec.MainBouquet.value)
else:
self.stbChannelList = STBHelpers.buildSTBChannelList()
self['title'].setText("Lade Wunschliste-Sender...")
try:
self.createWebChannels(SeriesServer().doGetWebChannels(), False)
self.database.setChannelListLastUpdate()
except:
self['title'].setText("Fehler beim Laden der Wunschliste-Sender")
SRLogger.writeLog("Fehler beim Laden der Senderliste vom SerienServer.", True)
else:
print "[SerienRecorder] channel-list ok."
def startScreen(self):
print "[SerienRecorder] version %s is running..." % config.plugins.serienRec.showversion.value
if not SerienRecorder.refreshTimer:
if config.plugins.serienRec.timeUpdate.value:
SerienRecorder.serienRecCheckForRecording(
self.session, False, False)
if not SerienRecorder.initDB():
print "[SerienRecorder] initDB failed"
super(self.__class__, self).close()
self.database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
if not self.database.hasChannels():
print "[SerienRecorder] Channellist is empty !"
from SerienRecorderChannelScreen import serienRecMainChannelEdit
self.session.openWithCallback(self.readPlanerData,
serienRecMainChannelEdit)
else:
self.serviceRefs = self.database.getActiveServiceRefs()
remoteChannelListLastUpdated = SeriesServer.getChannelListLastUpdate(
)
channelListUpToDate = True
if remoteChannelListLastUpdated:
localChannelListLastUpdated = self.database.getChannelListLastUpdate(
)
if 0 < localChannelListLastUpdated < remoteChannelListLastUpdated:
SRLogger.writeLog(
"Auf dem Serien-Server wurde die Senderliste aktualisiert - bitte führen Sie auch eine Aktualisierung in der Senderzuordnung aus.",
True)
channelListUpToDate = False
if channelListUpToDate:
self.switchStartScreen()
else:
self.session.openWithCallback(
self.handleChannelListUpdate, MessageBox,
"Die Senderliste wurde auf dem Server aktualisiert.\nSie muss auch im SerienRecorder aktualisiert werden.\nWechseln Sie zur Senderzuordnung und aktualisieren Sie die Senderliste mit der grünen Taste.\n\nZur Senderzuordnung wechseln?",
MessageBox.TYPE_YESNO)
def getEmailData():
# extract all html parts
def get_html(email_message_instance):
maintype = email_message_instance.get_content_maintype()
if maintype == 'multipart':
for part in email_message_instance.get_payload():
if part.get_content_type() == 'text/html':
return part.get_payload()
SRLogger.writeLog("\n---------' Lade TV-Planer E-Mail '---------\n", True)
# get emails
if len(config.plugins.serienRec.imap_server.value) == 0:
SRLogger.writeLog("TV-Planer: imap_server nicht gesetzt", True)
return None
if len(config.plugins.serienRec.imap_login_hidden.value) == 0:
SRLogger.writeLog("TV-Planer: imap_login nicht gesetzt", True)
return None
if len(config.plugins.serienRec.imap_password_hidden.value) == 0:
SRLogger.writeLog("TV-Planer: imap_password nicht gesetzt", True)
return None
if len(config.plugins.serienRec.imap_mailbox.value) == 0:
SRLogger.writeLog("TV-Planer: imap_mailbox nicht gesetzt", True)
return None
if len(config.plugins.serienRec.imap_mail_subject.value) == 0:
SRLogger.writeLog("TV-Planer: imap_mail_subject nicht gesetzt", True)
return None
if 1 > config.plugins.serienRec.imap_mail_age.value > 100:
config.plugins.serienRec.imap_mail_age.value = 1
try:
if config.plugins.serienRec.imap_server_ssl.value:
mail = imaplib.IMAP4_SSL(config.plugins.serienRec.imap_server.value, config.plugins.serienRec.imap_server_port.value)
else:
mail = imaplib.IMAP4(config.plugins.serienRec.imap_server.value, config.plugins.serienRec.imap_server_port.value)
except imaplib.IMAP4.abort:
SRLogger.writeLog("TV-Planer: Verbindung zum Server fehlgeschlagen", True)
return None
except imaplib.IMAP4.error:
SRLogger.writeLog("TV-Planer: Verbindung zum Server fehlgeschlagen", True)
return None
try:
mail.login(decrypt(getmac("eth0"), config.plugins.serienRec.imap_login_hidden.value),
decrypt(getmac("eth0"), config.plugins.serienRec.imap_password_hidden.value))
print "[serienrecorder]: imap login ok"
except imaplib.IMAP4.error:
SRLogger.writeLog("TV-Planer: Anmeldung auf Server fehlgeschlagen", True)
print "[serienrecorder]: imap login failed"
return None
try:
mail.select(config.plugins.serienRec.imap_mailbox.value)
except imaplib.IMAP4.error:
SRLogger.writeLog("TV-Planer: Mailbox %r nicht gefunden" % config.plugins.serienRec.imap_mailbox.value, True)
return None
searchstr = TimeHelpers.getMailSearchString()
try:
result, data = mail.uid('search', None, searchstr)
if result != 'OK':
SRLogger.writeLog("TV-Planer: Fehler bei der Suche nach TV-Planer E-Mails", True)
SRLogger.writeLog("TV-Planer: %s" % data, True)
return None
except imaplib.IMAP4.error:
SRLogger.writeLog("TV-Planer: Keine TV-Planer Nachricht in den letzten %s Tagen" % str(config.plugins.serienRec.imap_mail_age.value), True)
SRLogger.writeLog("TV-Planer: %s" % searchstr, True)
return None
if len(data[0]) == 0:
SRLogger.writeLog("TV-Planer: Keine TV-Planer Nachricht in den letzten %s Tagen" % str(config.plugins.serienRec.imap_mail_age.value), True)
SRLogger.writeLog("TV-Planer: %s" % searchstr, True)
return None
# get the latest email
latest_email_uid = data[0].split()[-1]
# fetch the email body (RFC822) for the given UID
try:
result, data = mail.uid('fetch', latest_email_uid, '(RFC822)')
except:
SRLogger.writeLog("TV-Planer: Laden der E-Mail fehlgeschlagen", True)
return None
mail.logout()
# extract email message including headers and alternate payloads
email_message = email.message_from_string(data[0][1])
if len(email_message) == 0:
SRLogger.writeLog("TV-Planer: leere E-Mail", True)
return None
# get html of wunschliste
html = get_html(email_message)
if html is None or len(html) == 0:
SRLogger.writeLog("TV-Planer: leeres HTML", True)
return None
if config.plugins.serienRec.tvplaner.value and config.plugins.serienRec.tvplaner_backupHTML.value:
try:
htmlFilePath = SERIENRECORDER_TVPLANER_HTML_FILENAME % config.plugins.serienRec.LogFilePath.value
writeTVPlanerHTML = open(htmlFilePath, "w")
writeTVPlanerHTML.write(html)
writeTVPlanerHTML.close()
except:
SRLogger.writeLog("TV-Planer: HTML konnte nicht für die Fehlersuche gespeichert werden.", True)
# make one line and convert characters
html = html.replace('=\r\n', '').replace('=\n', '').replace('=\r', '').replace('\n', '').replace('\r', '')
html = html.replace('=3D', '=')
try:
def getTextContentByTitle(node, titleValue, default):
titleNodes = node.childNodes.getElementsByAttr('title', titleValue)
if titleNodes:
return titleNodes[0].textContent.encode('utf-8')
else:
return default
def getEpisodeTitle(node):
childNodes = node.childNodes.getElementsByTagName('a')
if childNodes:
return childNodes[0].textContent.encode('utf-8')
else:
# Movies does not a link to the episode => only country, year
childNodes = node.childNodes.getElementsByTagName('span')
if childNodes:
return childNodes[0].textContent.encode('utf-8')
else:
return ''
import AdvancedHTMLParser
parser = AdvancedHTMLParser.AdvancedHTMLParser()
html = parser.unescape(html).encode('utf-8')
parser.parseStr(html)
# Get tables from HTML
tables = parser.getElementsByTagName('table')
# Initialize regular expressions
date_regexp = re.compile('.*TV-Planer.*?den ([0-3][0-9]\.[0-1][0-9]\.20[0-9][0-9])\s.(?:\(ab (.*?) Uhr\))?')
url_title_regexp = re.compile('.*<a href="([^\?]+)(?:\?.*)?".*><strong.*>(.*)</strong>')
endtime_regexp = re.compile('.*bis:\s(.*)\sUhr.*')
# Get date and time of TV-Planer
header = tables[1].getAllChildNodes().getElementsByTagName('div')[0].textContent.encode('utf-8')
planerDateTime = date_regexp.findall(header)[0]
print planerDateTime
# Get transmissions
transmissions = []
transmissionTable = tables[1].getAllChildNodes().getElementsByTagName('table')[0]
transmissionRows = transmissionTable.childNodes
for transmissionRow in transmissionRows:
transmission = []
if not transmissionRow.hasAttribute('style'):
transmissionColumns = transmissionRow.childNodes
# Each transmission row has three columns
# [0]: Start time
starttime = transmissionColumns[0].textContent.encode('utf-8')
if starttime != 'Anzeige':
transmission.append(starttime.replace(' Uhr', ''))
# [1]: URL, Title, Season, Episode, Info
transmissionColumn = transmissionColumns[1]
# Season, Episode, Title, Episode info, End time
episodeInfo = ['0', '00', '', '', '0.00']
if transmissionColumn.firstChild:
# First child is always URL + Title
url_title = url_title_regexp.findall(transmissionColumn.firstChild.toHTML().encode('utf-8'))[0]
transmission.extend(url_title)
if transmissionColumn.lastChild:
# Last element => End time (it has to be filled with a time because later on the time will be splitted)
endtime = endtime_regexp.findall(transmissionColumn.lastChild.toHTML().encode('utf-8'))
if endtime:
episodeInfo[4] = endtime[0]
divPartIndex = 0
for transmissionPart in transmissionColumn.childNodes:
if transmissionPart is transmissionColumn.lastChild:
# Skip part if it the "last" part
continue
if transmissionPart.tagName == 'div' and divPartIndex == 0:
# First div element => Season / Episode / Title / e.g. NEU
episodeInfo[0] = getTextContentByTitle(transmissionPart, 'Staffel', '0')
episodeInfo[1] = getTextContentByTitle(transmissionPart, 'Episode', '00')
episodeInfo[2] = getEpisodeTitle(transmissionPart)
divPartIndex += 1
elif transmissionPart.tagName == 'div' and divPartIndex == 1:
# Second div element => Episode info
episodeInfo[3] = transmissionPart.textContent.encode('utf-8')
transmission.extend(episodeInfo)
# [2] Channel
transmission.append(transmissionColumns[2].textContent.encode('utf-8'))
print transmission
transmissions.append(transmission)
except:
SRLogger.writeLog("TV-Planer: HTML Parsing abgebrochen", True)
return None
# prepare transmissions
# [ ( seriesName, channel, start, end, season, episode, title, '0' ) ]
# calculate start time and end time of list in E-Mail
missingTime = False
if len(planerDateTime) != 2:
SRLogger.writeLog("TV-Planer: falsches Datumsformat", True)
return None
(day, month, year) = planerDateTime[0].split('.')
if not planerDateTime[1]:
if transmissions:
# Get time of first transmission
(hour, minute) = transmissions[0][0].split(':')
else:
missingTime = True
(hour, minute) = ('00', '00')
else:
(hour, minute) = planerDateTime[1].split(':')
liststarttime_unix = TimeHelpers.getRealUnixTime(minute, hour, day, month, year)
# generate dictionary with final transmissions
SRLogger.writeLog("Ab dem %s %s Uhr wurden die folgenden Sendungen gefunden:\n" % (planerDateTime[0], planerDateTime[1]))
print "[SerienRecorder] Ab dem %s %s Uhr wurden die folgenden Sendungen gefunden:" % (planerDateTime[0], planerDateTime[1])
if missingTime:
SRLogger.writeLog("In der Kopfzeile der TV-Planer E-Mail konnte keine Uhrzeit gefunden werden, bitte kontrollieren Sie die angelegten Timer!\n")
transmissiondict = dict()
for starttime, url, seriesname, season, episode, titel, description, endtime, channel in transmissions:
try:
if url.startswith('https://www.wunschliste.de/spielfilm'):
if not config.plugins.serienRec.tvplaner_movies.value:
SRLogger.writeLog("' %s - Filmaufzeichnung ist deaktiviert '" % seriesname, True)
print "' %s - Filmaufzeichnung ist deaktiviert '" % seriesname
continue
transmissiontype = '[ Film ]'
elif url.startswith('https://www.wunschliste.de/serie'):
if not config.plugins.serienRec.tvplaner_series.value:
SRLogger.writeLog("' %s - Serienaufzeichnung ist deaktiviert '" % seriesname, True)
print "' %s - Serienaufzeichnung ist deaktiviert '" % seriesname
continue
transmissiontype = '[ Serie ]'
else:
SRLogger.writeLog("' %s - Ungültige URL %r '" % (seriesname, url), True)
print "' %s - Serienaufzeichnung ist deaktiviert '" % seriesname
continue
# series
transmission = [ seriesname ]
# channel
channel = channel.replace(' (Pay-TV)','').replace(' (Schweiz)','').replace(' (GB)','').replace(' (Österreich)','').replace(' (USA)','').replace(' (RP)','').replace(' (F)','').strip()
transmission += [ channel ]
# start time
(hour, minute) = starttime.split(':')
transmissionstart_unix = TimeHelpers.getRealUnixTime(minute, hour, day, month, year)
if transmissionstart_unix < liststarttime_unix:
transmissionstart_unix = TimeHelpers.getRealUnixTimeWithDayOffset(minute, hour, day, month, year, 1)
transmission += [ transmissionstart_unix ]
# end time
(hour, minute) = endtime.split('.')
transmissionend_unix = TimeHelpers.getRealUnixTime(minute, hour, day, month, year)
if transmissionend_unix < transmissionstart_unix:
transmissionend_unix = TimeHelpers.getRealUnixTimeWithDayOffset(minute, hour, day, month, year, 1)
transmission += [ transmissionend_unix ]
# season
if season == '':
season = '0'
transmission += [ season ]
# episode
if episode == '':
episode = '00'
transmission += [ episode ]
# title
transmission += [ quopri.decodestring(titel) ]
# last
transmission += [ '0' ]
# url
transmission += [ url ]
# store in dictionary transmissiondict[seriesname] = [ seriesname: [ transmission 0 ], [ transmission 1], .... ]
if seriesname in transmissiondict:
transmissiondict[seriesname] += [ transmission ]
else:
transmissiondict[seriesname] = [ transmission ]
SRLogger.writeLog("' %s - S%sE%s - %s - %s - %s - %s - %s '" % (transmission[0], str(transmission[4]).zfill(2), str(transmission[5]).zfill(2), transmission[6], transmission[1], time.strftime("%d.%m.%Y %H:%M", time.localtime(int(transmissionstart_unix))), time.strftime("%d.%m.%Y %H:%M", time.localtime(int(transmissionend_unix))), transmissiontype), True)
print "[SerienRecorder] ' %s - S%sE%s - %s - %s - %s - %s - %s'" % (transmission[0], str(transmission[4]).zfill(2), str(transmission[5]).zfill(2), transmission[6], transmission[1], time.strftime("%d.%m.%Y %H:%M", time.localtime(int(transmissionstart_unix))), time.strftime("%d.%m.%Y %H:%M", time.localtime(int(transmissionend_unix))), transmissiontype)
except Exception as e:
SRLogger.writeLog("TV-Planer Verarbeitung fehlgeschlagen! [%s]" % str(e), True)
if config.plugins.serienRec.tvplaner_create_marker.value:
database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
for seriesname in transmissiondict.keys():
# marker isn't in database, create new marker
# url stored in marker isn't the final one, it is corrected later
url = transmissiondict[seriesname][0][-1]
marker_type = "Serien Marker"
try:
boxID = None
if url.startswith('https://www.wunschliste.de/serie'):
seriesID = SeriesServer().getIDByFSID(url[str.rindex(url, '/') + 1:])
if seriesID > 0:
url = str(seriesID)
else:
url = None
if config.plugins.serienRec.tvplaner_series_activeSTB.value:
boxID = config.plugins.serienRec.BoxID.value
elif url.startswith('https://www.wunschliste.de/spielfilm'):
marker_type = "Temporärer Serien Marker"
if config.plugins.serienRec.tvplaner_movies_activeSTB.value:
boxID = config.plugins.serienRec.BoxID.value
else:
url = None
if url and not database.markerExists(url):
if database.addMarker(url, seriesname, "", boxID, 1 if url.startswith('https://www.wunschliste.de/spielfilm') else 0):
SRLogger.writeLog("\n%s für ' %s ' wurde angelegt" % (marker_type, seriesname), True)
print "[SerienRecorder] ' %s - %s erzeugt '" % (seriesname, marker_type)
except Exception as e:
SRLogger.writeLog("\n%s für ' %s ' konnte wegen eines Fehlers nicht angelegt werden [%s]" % (marker_type, seriesname, str(e)), True)
print "[SerienRecorder] ' %s - %s konnte wegen eines Fehlers nicht angelegt werden [%s]'" % (seriesname, marker_type, str(e))
else:
SRLogger.writeLog("Es werden keine Serien-Marker aus der TV-Planer E-Mail erstellt.", True)
return transmissiondict
def run(self): from SerienRecorderSeriesServer import SeriesServer self.searchResults = SeriesServer().doSearch(self.seriesName, self.startOffset)
def run(self):
try:
self.transmissions = SeriesServer().doGetSeasonBegins(
self.webChannels)
except:
self.transmissions = None