def __init__(self, session):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.skin = None
self.conflictsListe = []
self.session = session
self.database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
self["actions"] = HelpableActionMap(self, "SerienRecorderActions", {
"cancel": (self.keyCancel, "zurück zur vorherigen Ansicht"),
"left": (self.keyLeft, "zur vorherigen Seite blättern"),
"right": (self.keyRight, "zur nächsten Seite blättern"),
"up": (self.keyUp, "eine Zeile nach oben"),
"down": (self.keyDown, "eine Zeile nach unten"),
"red": (self.keyCancel, "zurück zur vorherigen Ansicht"),
"blue": (self.keyBlue, "alle Einträge aus der Liste endgültig löschen"),
"menu": (self.recSetup, "Menü für globale Einstellungen öffnen"),
"0" : (self.readLogFile, "Log-File des letzten Suchlaufs anzeigen"),
"3" : (self.showProposalDB, "Liste der Serien/Staffel-Starts anzeigen"),
"7" : (self.showWishlist, "Merkzettel (vorgemerkte Folgen) anzeigen"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(["SerienRecorderActions" ,], {
"displayHelp" : self.showHelp,
"displayHelp_long" : self.showManual,
}, 0)
self.setupSkin()
self.onLayoutFinish.append(self.readConflicts)
self.onClose.append(self.__onClose)
self.onLayoutFinish.append(self.setSkinProperties)
def createBackup():
import SerienRecorder
from SerienRecorderLogWriter import SRLogger
from SerienRecorderTVPlaner import SERIENRECORDER_TVPLANER_HTML_FILENAME
lt = time.localtime()
# Remove old backups
if config.plugins.serienRec.deleteBackupFilesOlderThan.value > 0:
SRLogger.writeLog(
"\nEntferne alte Backup-Dateien und erzeuge neues Backup.", True)
now = time.time()
logFolderPattern = re.compile('\d{4}\d{2}\d{2}\d{2}\d{2}')
for root, dirs, files in os.walk(
config.plugins.serienRec.BackupPath.value, topdown=False):
for name in dirs:
if logFolderPattern.match(name) and os.stat(
os.path.join(root, name)).st_ctime < (
now - config.plugins.serienRec.
deleteBackupFilesOlderThan.value * 24 * 60 * 60):
shutil.rmtree(os.path.join(root, name), True)
SRLogger.writeLog(
"Lösche Ordner: %s" % os.path.join(root, name), True)
else:
SRLogger.writeLog("Erzeuge neues Backup", True)
BackupPath = "%s%s%s%s%s%s/" % (
config.plugins.serienRec.BackupPath.value, lt.tm_year, str(
lt.tm_mon).zfill(2), str(lt.tm_mday).zfill(2), str(
lt.tm_hour).zfill(2), str(lt.tm_min).zfill(2))
if not os.path.exists(BackupPath):
try:
os.makedirs(BackupPath)
except:
pass
if os.path.isdir(BackupPath):
try:
if fileExists(SerienRecorder.serienRecDataBaseFilePath):
from SerienRecorderDatabase import SRDatabase
database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
database.backup(BackupPath)
if fileExists(SRLogger.getLogFilePath()):
shutil.copy(SRLogger.getLogFilePath(), BackupPath)
if fileExists("/etc/enigma2/timers.xml"):
shutil.copy("/etc/enigma2/timers.xml", BackupPath)
if fileExists("%sConfig.backup" %
SerienRecorder.serienRecMainPath):
shutil.copy(
"%sConfig.backup" % SerienRecorder.serienRecMainPath,
BackupPath)
STBHelpers.saveEnigmaSettingsToFile(BackupPath)
for filename in os.listdir(BackupPath):
os.chmod(os.path.join(BackupPath, filename), 0o777)
if fileExists(SERIENRECORDER_TVPLANER_HTML_FILENAME %
config.plugins.serienRec.LogFilePath.value):
shutil.copy(
SERIENRECORDER_TVPLANER_HTML_FILENAME %
config.plugins.serienRec.LogFilePath.value, BackupPath)
except Exception, e:
SRLogger.writeLog("Backup konnte nicht erstellt werden: " + str(e),
True)
def getCover(self, serienName):
serien_id = None
from SerienRecorder import serienRecDataBaseFilePath, getCover
database = SRDatabase(serienRecDataBaseFilePath)
url = database.getMarkerURL(serienName)
if url:
serien_id = url
getCover(self, serienName, serien_id)
def __init__(self, session, serieName, serieID):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.session = session
self.picload = ePicLoad()
self.serieName = serieName
self.serieID = serieID
self.database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
self["actions"] = HelpableActionMap(
self, "SerienRecorderActions", {
"cancel": (self.keyCancel, "zurück zur vorherigen Ansicht"),
"left": (self.pageUp, "zur vorherigen Seite blättern"),
"right": (self.pageDown, "zur nächsten Seite blättern"),
"up": (self.pageUp, "zur vorherigen Seite blättern"),
"down": (self.pageDown, "zur nächsten Seite blättern"),
"menu":
(self.recSetup, "Menü für globale Einstellungen öffnen"),
"startTeletext":
(self.wunschliste,
"Informationen zur ausgewählten Serie auf Wunschliste anzeigen"
),
"red": (self.keyCancel, "zurück zur vorherigen Ansicht"),
"0":
(self.readLogFile, "Log-File des letzten Suchlaufs anzeigen"),
"3": (self.showProposalDB,
"Liste der Serien/Staffel-Starts anzeigen"),
"6":
(self.showConflicts, "Liste der Timer-Konflikte anzeigen"),
"7": (self.showWishlist,
"Merkzettel (vorgemerkte Folgen) anzeigen"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap([
"SerienRecorderActions",
], {
"displayHelp": self.showHelp,
"displayHelp_long": self.showManual,
}, 0)
self.setupSkin()
self.onLayoutFinish.append(self.getData)
self.onClose.append(self.__onClose)
self.onLayoutFinish.append(self.setSkinProperties)
def keyOK(self):
if self.loading:
return
check = self['menu_list'].getCurrent()
if check is None:
print "[SerienRecorder] keine infos gefunden"
return
Serie = self['menu_list'].getCurrent()[0][0]
Year = self['menu_list'].getCurrent()[0][1]
Id = self['menu_list'].getCurrent()[0][2]
print Serie, Year, Id
if Id == "":
return
if Id == "-1":
self.chooseMenuList.setList([])
self.searchSerie(int(Year))
return
self.serien_name = ""
database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
if config.plugins.serienRec.activateNewOnThisSTBOnly.value:
boxID = None
else:
boxID = config.plugins.serienRec.BoxID.value
if database.addMarker(str(Id), Serie, Year, boxID, 0):
from SerienRecorderLogWriter import SRLogger
SRLogger.writeLog("\nSerien Marker für ' %s ' wurde angelegt" % Serie, True)
self['title'].setText("Serie '- %s -' zum Serien Marker hinzugefügt." % Serie)
self['title'].instance.setForegroundColor(parseColor("green"))
if config.plugins.serienRec.openMarkerScreen.value:
self.close(Serie)
else:
self['title'].setText("Serie '- %s -' existiert bereits im Serien Marker." % Serie)
self['title'].instance.setForegroundColor(parseColor("red"))
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 __init__(self, session, serien_name, serie_url, serien_cover):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.ErrorMsg = ''
self.database = SRDatabase(serienRecDataBaseFilePath)
self.addedEpisodes = self.database.getTimerForSeries(serien_name)
self.modus = "menu_list"
self.session = session
self.picload = ePicLoad()
self.serien_name = serien_name
self.serien_id = 0
self.serien_cover = serien_cover
self.episodes_list_cache = {}
self.showEpisodes = True
self.aStaffel = None
self.aFromEpisode = None
self.aToEpisode = None
self.numberOfEpisodes = 0
self.page = 1
self.maxPages = 1
self.loading = False
self.changesMade = False
self["actions"] = HelpableActionMap(self, "SerienRecorderActions", {
"ok" : (self.keyOK, "Informationen zur ausgewählten Episode anzeigen"),
"cancel": (self.keyCancel, "Zurück zur Serien-Marker-Ansicht"),
"left" : (self.keyLeft, "Zur vorherigen Seite blättern"),
"right" : (self.keyRight, "Zur nächsten Seite blättern"),
"up" : (self.keyUp, "Eine Zeile nach oben"),
"down" : (self.keyDown, "Eine Zeile nach unten"),
"red" : (self.keyRed, "Diese Folge (nicht mehr) timern"),
"green" : (self.keyGreen, "Zeige nur Einträge aus der Timer-Liste"),
"yellow": (self.keyYellow, "Ausgewählte Folge auf den Merkzettel"),
"blue" : (self.keyBlue, "Neue Einträge manuell hinzufügen"),
"menu" : (self.recSetup, "Menü für globale Einstellungen öffnen"),
"nextBouquet" : (self.nextPage, "Nächste Seite laden"),
"prevBouquet" : (self.backPage, "Vorherige Seite laden"),
"startTeletext" : (self.wunschliste, "Informationen zur ausgewählten Serie auf Wunschliste anzeigen"),
"0" : (self.readLogFile, "Log-File des letzten Suchlaufs anzeigen"),
"3" : (self.showProposalDB, "Liste der Serien/Staffel-Starts anzeigen"),
"4" : (self.serieInfo, "Informationen zur ausgewählten Serie anzeigen"),
"6" : (self.showConflicts, "Liste der Timer-Konflikte anzeigen"),
"7" : (self.showWishlist, "Merkzettel (vorgemerkte Folgen) anzeigen"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(["SerienRecorderActions", ], {
"displayHelp" : self.showHelp,
"displayHelp_long" : self.showManual,
}, 0)
self.setupSkin()
self.serien_id = serie_url
self.timer_default = eTimer()
if isDreamOS():
self.timer_default_conn = self.timer_default.timeout.connect(self.loadEpisodes)
else:
self.timer_default.callback.append(self.loadEpisodes)
self.onLayoutFinish.append(self.setSkinProperties)
self.onLayoutFinish.append(self.searchEpisodes)
self.onClose.append(self.__onClose)
def startCheckTransmissions(self):
self.database = SRDatabase(serienRecDataBaseFilePath)
self.tempDB = SRTempDatabase()
self.tempDB.initialize()
# read channels
self.senderListe = {}
for s in self.database.getChannels():
self.senderListe[s[0].lower()] = s[:]
webChannels = self.database.getActiveChannels()
SRLogger.writeLog("\nAnzahl aktiver Websender: %d" % len(webChannels), True)
# get reference times
current_time = int(time.time())
future_time = int(config.plugins.serienRec.checkfordays.value) * 86400
future_time += int(current_time)
search_start = time.strftime("%d.%m.%Y - %H:%M", time.localtime(int(current_time)))
search_end = time.strftime("%d.%m.%Y - %H:%M", time.localtime(int(future_time)))
search_rerun_end = time.strftime("%d.%m.%Y - %H:%M", time.localtime(future_time + (int(config.plugins.serienRec.TimeSpanForRegularTimer.value) - int(config.plugins.serienRec.checkfordays.value)) * 86400))
SRLogger.writeLog("Berücksichtige Ausstrahlungstermine zwischen %s und %s" % (search_start, search_end), True)
SRLogger.writeLog("Berücksichtige Wiederholungen zwischen %s und %s" % (search_start, search_rerun_end), True)
# hier werden die wunschliste markers eingelesen
self.emailData = None
if config.plugins.serienRec.tvplaner.value and (not self.manuell or self.tvplaner_manuell):
# When TV-Planer processing is enabled then regular autocheck
# is only running for the transmissions received by email.
try:
from SerienRecorderTVPlaner import getEmailData
emailParserThread = backgroundThread(getEmailData)
emailParserThread.start()
emailParserThread.join()
self.emailData = emailParserThread.result
except:
SRLogger.writeLog("TV-Planer Verarbeitung fehlgeschlagen!", True)
print "[SerienRecorder] TV-Planer exception!"
self.emailData = None
print "[SerienRecorder] lastFullCheckTime %s" % time.strftime("%d.%m.%Y - %H:%M", time.localtime(int(config.plugins.serienRec.tvplaner_last_full_check.value)))
if self.emailData is None:
self.markers = self.database.getMarkers(config.plugins.serienRec.BoxID.value, config.plugins.serienRec.NoOfRecords.value)
config.plugins.serienRec.tvplaner_last_full_check.value = int(time.time())
config.plugins.serienRec.tvplaner_last_full_check.save()
configfile.save()
if config.plugins.serienRec.tvplaner.value:
fullCheck = "- keine TV-Planer Daten - voller Suchlauf'"
else:
fullCheck = "- voller Suchlauf'"
elif config.plugins.serienRec.tvplaner_full_check.value and (int(config.plugins.serienRec.tvplaner_last_full_check.value) + (int(config.plugins.serienRec.checkfordays.value) - 1) * 86400) < int(time.time()):
self.markers = self.database.getMarkers(config.plugins.serienRec.BoxID.value, config.plugins.serienRec.NoOfRecords.value)
config.plugins.serienRec.tvplaner_last_full_check.value = int(time.time())
config.plugins.serienRec.tvplaner_last_full_check.save()
configfile.save()
fullCheck = "- Zeit abgelaufen - voller Suchlauf'"
else:
self.markers = self.database.getMarkers(config.plugins.serienRec.BoxID.value, config.plugins.serienRec.NoOfRecords.value, self.emailData.keys())
fullCheck = "- nur Serien der TV-Planer E-Mail'"
self.count_url = 0
self.countSerien = 0
self.countActivatedSeries = 0
self.noOfRecords = int(config.plugins.serienRec.NoOfRecords.value)
# regular processing through serienrecorder server
# TODO: save all transmissions in files to protect from temporary SerienServer fails
# data will be read by the file reader below and used for timer programming
if len(self.markers) > 0:
while True:
#if config.plugins.serienRec.tvplaner.value and config.plugins.serienRec.tvplaner_skipSerienServer.value:
# Skip serien server processing
# break
global transmissionFailed
transmissionFailed = False
self.tempDB.cleanUp()
if not (config.plugins.serienRec.tvplaner.value and config.plugins.serienRec.tvplaner_skipSerienServer.value):
SRLogger.writeLog("\n---------' Verarbeite Daten vom Server %s ---------\n" % fullCheck, True)
print "[SerienRecorder] Verarbeite Daten vom Server"
# Create a job queue to keep the jobs processed by the threads
# Create a result queue to keep the results of the job threads
jobQueue = Queue.Queue()
resultQueue = Queue.Queue()
#SRLogger.writeLog("Active threads: %d" % threading.active_count(), True)
# Create the threads
for i in range(2):
worker = downloadTransmissionsThread(jobQueue, resultQueue)
worker.setDaemon(True)
worker.start()
for serienTitle,SerieUrl,SerieStaffel,SerieSender,AbEpisode,AnzahlAufnahmen,SerieEnabled,excludedWeekdays,skipSeriesServer,markerType in self.markers:
if config.plugins.serienRec.tvplaner.value and (config.plugins.serienRec.tvplaner_skipSerienServer.value or (skipSeriesServer is not None and skipSeriesServer)):
# Skip serien server processing
SRLogger.writeLog("' %s ' - Für diesen Serien-Marker sollen nur Timer aus der E-Mail angelegt werden." % serienTitle, True)
continue
if markerType == 1:
# temporary marker for movie recording
print "[SerienRecorder] ' %s - TV-Planer Film wird ignoriert '" % serienTitle
continue
self.countSerien += 1
if SerieEnabled:
# Download only if series is enabled
if 'Alle' in SerieSender:
markerChannels = webChannels
else:
markerChannels = SerieSender
self.countActivatedSeries += 1
seriesID = SerieUrl
jobQueue.put((seriesID, (int(config.plugins.serienRec.TimeSpanForRegularTimer.value)), markerChannels, serienTitle, SerieStaffel, AbEpisode, AnzahlAufnahmen, current_time, future_time, excludedWeekdays))
jobQueue.join()
while not resultQueue.empty():
(transmissionFailed, transmissions, seriesID, serienTitle, SerieStaffel, AbEpisode, AnzahlAufnahmen, current_time, future_time, excludedWeekdays) = resultQueue.get()
self.processTransmission(transmissions, seriesID, serienTitle, SerieStaffel, AbEpisode, AnzahlAufnahmen, current_time, future_time, excludedWeekdays)
resultQueue.task_done()
break
#
# In order to provide an emergency recording service when serien server is down or
# because Wunschliste isn't accessable, it is now possible to use the TV Wunschliste
# TV-Planer Infomails.
#
# With an account at www.wunschliste.de it is possible to mark series to appear at
# "TV-Planer" screen. This screen shows the transmissions of up to a week in advance.
# In "Einstellungen" it is possible to enable Infomails about TV-Planer. This Infomails
# can now be used by SerienRecorder to create timers without any further access to
# Wunschliste, and therefore avoids hitting Wunschliste with the enormous
# internet traffic that was caused by the many boxes with SerienRecorder.
#
# Wunschliste Settings:
# - put your favourite series on TV-Planer
# - enable TV-Planer Infomails in "Einstellungen"
# - set Vorlauf (i.e. 1 day)
# - set Programmtag-Beginn (i.e. 5.00 Uhr)
# - set MailFormat to HTML+Text (currently only HTML emails are recognized)
#
# When this has been finished the first TV-Planer email will be received next day.
#
# SerienRecorder Settings:
# - enable TVPlaner feature
# - set email server, login, password and possibly modify the other parameters
# - set the autocheck time to about 1 h after the time you receive the TV-planer emails
#
# Now every time the regular SerienRecorder autocheck runs, received
# TV-Planer emails will be used to program timers, even no marker
# has been created by SerienMarker before. The marker is created automatically,
# except for the correct url.
#
if config.plugins.serienRec.tvplaner.value and self.emailData is not None:
# check mailbox for TV-Planer EMail and create timer
SRLogger.writeLog("\n---------' Verarbeite Daten aus TV-Planer E-Mail '---------\n", True)
jobQueue = Queue.Queue()
resultQueue = Queue.Queue()
# Create the threads
for i in range(2):
worker = processEMailDataThread(self.emailData, jobQueue, resultQueue)
worker.setDaemon(True)
worker.start()
for serienTitle,SerieUrl,SerieStaffel,SerieSender,AbEpisode,AnzahlAufnahmen,SerieEnabled,excludedWeekdays,skipSeriesServer,markerType in self.database.getMarkers(config.plugins.serienRec.BoxID.value, config.plugins.serienRec.NoOfRecords.value, self.emailData.keys()):
print serienTitle
if SerieEnabled:
# Process only if series is enabled
if 'Alle' in SerieSender:
markerChannels = { x : x for x in webChannels }
else:
markerChannels = { x : x for x in SerieSender }
jobQueue.put((markerChannels, SerieUrl, serienTitle, SerieStaffel, AbEpisode, AnzahlAufnahmen, current_time, future_time, excludedWeekdays))
jobQueue.join()
while not resultQueue.empty():
(transmissions, seriesID, serienTitle, SerieStaffel, AbEpisode, AnzahlAufnahmen, current_time, future_time, excludedWeekdays) = resultQueue.get()
self.processTransmission(transmissions, seriesID, serienTitle, SerieStaffel, AbEpisode, AnzahlAufnahmen, current_time, future_time, excludedWeekdays)
resultQueue.task_done()
self.createTimer()
self.checkFinal()
def startCheck(self):
self.database = SRDatabase(serienRecDataBaseFilePath)
global autoCheckFinished
autoCheckFinished = False
print "[SerienRecorder] settings:"
print "[SerienRecorder] manuell:", self.manuell
print "[SerienRecorder] tvplaner_manuell:", self.tvplaner_manuell
print "[SerienRecorder] uhrzeit check:", config.plugins.serienRec.timeUpdate.value
lt = time.localtime()
self.uhrzeit = time.strftime("%d.%m.%Y - %H:%M:%S", lt)
global refreshTimer
global refreshTimerConnection
SRLogger.checkFileAccess()
SRLogger.writeLog("\n---------' %s '---------" % self.uhrzeit, True)
if not self.manuell and not initDB():
self.askForDSB()
return
if not self.database.hasMarkers() and not config.plugins.serienRec.tvplaner and not config.plugins.serienRec.tvplaner_create_marker:
SRLogger.writeLog("\n---------' Starte Auto-Check um %s '---------" % self.uhrzeit, True)
print "[SerienRecorder] check: Tabelle SerienMarker leer."
SRLogger.writeLog("Es sind keine Serien-Marker vorhanden - Auto-Check kann nicht ausgeführt werden.", True)
SRLogger.writeLog("---------' Auto-Check beendet '---------", True)
self.askForDSB()
return
if not self.database.hasChannels():
SRLogger.writeLog("\n---------' Starte Auto-Check um %s '---------" % self.uhrzeit, True)
print "[SerienRecorder] check: Tabelle Channels leer."
SRLogger.writeLog("Es wurden keine Sender zugeordnet - Auto-Check kann nicht ausgeführt werden.", True)
SRLogger.writeLog("---------' Auto-Check beendet '---------", True)
self.askForDSB()
return
if refreshTimer:
refreshTimer.stop()
refreshTimer = None
if refreshTimerConnection:
refreshTimerConnection = None
print "[SerienRecorder] Auto-Check Timer stop."
SRLogger.writeLog("Auto-Check stop.", True)
if config.plugins.serienRec.autochecktype.value == "1" and config.plugins.serienRec.timeUpdate.value:
deltatime = self.getNextAutoCheckTimer(lt)
refreshTimer = eTimer()
if isDreamOS():
refreshTimerConnection = refreshTimer.timeout.connect(self.startCheck)
else:
refreshTimer.callback.append(self.startCheck)
refreshTimer.start(((deltatime * 60) + random.randint(0, int(config.plugins.serienRec.maxDelayForAutocheck.value)*60)) * 1000, True)
print "[SerienRecorder] Auto-Check Uhrzeit-Timer gestartet."
print "[SerienRecorder] Verbleibende Zeit: %s Stunden" % (TimeHelpers.td2HHMMstr(datetime.timedelta(minutes=deltatime+int(config.plugins.serienRec.maxDelayForAutocheck.value))))
SRLogger.writeLog("Auto-Check Uhrzeit-Timer gestartet.", True)
SRLogger.writeLog("Verbleibende Zeit: %s Stunden" % TimeHelpers.td2HHMMstr(datetime.timedelta(minutes=deltatime+int(config.plugins.serienRec.maxDelayForAutocheck.value))), True)
if config.plugins.serienRec.AutoBackup.value == "before":
createBackup()
SRLogger.reset()
from SerienRecorderTVPlaner import resetTVPlanerHTMLBackup
resetTVPlanerHTMLBackup()
self.database.removeExpiredTimerConflicts()
if self.tvplaner_manuell and config.plugins.serienRec.tvplaner.value:
print "\n---------' Starte Check um %s (TV-Planer manuell) '---------" % self.uhrzeit
SRLogger.writeLog("\n---------' Starte Check um %s (TV-Planer manuell) '---------\n" % self.uhrzeit, True)
elif self.manuell:
print "\n---------' Starte Check um %s (manuell) '---------" % self.uhrzeit
SRLogger.writeLog("\n---------' Starte Check um %s (manuell) '---------\n" % self.uhrzeit, True)
elif config.plugins.serienRec.tvplaner.value:
print "\n---------' Starte Auto-Check um %s (TV-Planer auto) '---------" % self.uhrzeit
SRLogger.writeLog("\n---------' Starte Auto-Check um %s (TV-Planer auto) '---------\n" % self.uhrzeit, True)
else:
print "\n---------' Starte Auto-Check um %s (auto)'---------" % self.uhrzeit
SRLogger.writeLog("\n---------' Starte Auto-Check um %s (auto)'---------\n" % self.uhrzeit, True)
if config.plugins.serienRec.showNotification.value in ("1", "3"):
Notifications.AddPopup("SerienRecorder Suchlauf nach neuen Timern wurde gestartet.", MessageBox.TYPE_INFO, timeout=3, id="Suchlauf wurde gestartet")
if config.plugins.serienRec.writeLogVersion.value:
SRLogger.writeLog("STB Type: %s\nImage: %s" % (STBHelpers.getSTBType(), STBHelpers.getImageVersionString()), True)
SRLogger.writeLog("SR Version: %s\nDatenbank Version: %s" % (config.plugins.serienRec.showversion.value, str(self.database.getVersion())), True)
SRLogger.writeLog("Skin Auflösung: %s x %s" % (str(getDesktop(0).size().width()), str(getDesktop(0).size().height())), True)
sMsg = "\nDEBUG Filter: "
if config.plugins.serienRec.writeLogChannels.value:
sMsg += "Senderliste "
if config.plugins.serienRec.writeLogAllowedEpisodes.value:
sMsg += "Episoden "
if config.plugins.serienRec.writeLogAdded.value:
sMsg += "Added "
if config.plugins.serienRec.writeLogDisk.value:
sMsg += "Disk "
if config.plugins.serienRec.writeLogTimeRange.value:
sMsg += "Tageszeit "
if config.plugins.serienRec.writeLogTimeLimit.value:
sMsg += "Zeitlimit "
if config.plugins.serienRec.writeLogTimerDebug.value:
sMsg += "Timer "
SRLogger.writeLog(sMsg, True)
self.markers = []
self.messageList = []
self.speedStartTime = time.clock()
# teste Verbindung ins Internet
if not testWebConnection():
SRLogger.writeLog("\nKeine Verbindung ins Internet. Check wurde abgebrochen!!\n", True)
# Statistik
self.speedEndTime = time.clock()
speedTime = (self.speedEndTime - self.speedStartTime)
SRLogger.writeLog("---------' Auto-Check beendet ( Ausführungsdauer: %3.2f Sek.)'---------" % speedTime, True)
print "[SerienRecorder] ---------' Auto-Check beendet ( Ausführungsdauer: %3.2f Sek.)'---------" % speedTime
from SerienRecorderTVPlaner import backupTVPlanerHTML
backupTVPlanerHTML()
global autoCheckFinished
autoCheckFinished = True
if config.plugins.serienRec.AutoBackup.value == "after":
createBackup()
# in den deep-standby fahren.
self.askForDSB()
return
# Versuche Verzeichnisse zu erreichen
try:
SRLogger.writeLog("\nPrüfe konfigurierte Aufnahmeverzeichnisse:", True)
recordDirectories = self.database.getRecordDirectories(config.plugins.serienRec.savetopath.value)
for directory in recordDirectories:
SRLogger.writeLog(" %s" % directory, True)
os.path.exists(directory)
except:
SRLogger.writeLog("Es konnten nicht alle Aufnahmeverzeichnisse gefunden werden", True)
# suche nach neuen Serien, Covern und Planer-Cache
from twisted.internet import reactor
from SerienRecorderSeriesPlanner import serienRecSeriesPlanner
seriesPlanner = serienRecSeriesPlanner(self.manuell)
reactor.callFromThread(seriesPlanner.updatePlanerData())
#if config.plugins.serienRec.downloadCover.value:
# reactor.callFromThread(self.getMarkerCover())
self.startCheckTransmissions()
def getMarkerCover(self): self.database = SRDatabase(serienRecDataBaseFilePath) markers = self.database.getAllMarkers(False) for marker in markers: (ID, Serie, Info, Url, AufnahmeVerzeichnis, AlleStaffelnAb, alleSender, Vorlaufzeit, Nachlaufzeit, AnzahlAufnahmen, preferredChannel, useAlternativeChannel, AbEpisode, TimerForSpecials, ErlaubteSTB, ErlaubteStaffelCount) = marker getCover(None, Serie, ID, True)
def __init__(self, session):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.skin = None
self.session = session
self.picload = ePicLoad()
self.WochenTag = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
self.database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
self["actions"] = HelpableActionMap(
self, "SerienRecorderActions", {
"ok": (self.keyOK, "Liste der erstellten Timer bearbeiten"),
"cancel": (self.keyCancel, "zurück zur Serienplaner-Ansicht"),
"left": (self.keyLeft, "zur vorherigen Seite blättern"),
"right": (self.keyRight, "zur nächsten Seite blättern"),
"up": (self.keyUp, "eine Zeile nach oben"),
"down": (self.keyDown, "eine Zeile nach unten"),
"red": (self.keyRed, "ausgewählten Timer löschen"),
"green": (self.viewChange, "Sortierung ändern"),
"yellow":
(self.keyYellow, "umschalten alle/nur aktive Timer anzeigen"),
"blue": (self.keyBlue, "alle noch ausstehenden Timer löschen"),
"menu":
(self.recSetup, "Menü für globale Einstellungen öffnen"),
"startTeletext":
(self.wunschliste,
"Informationen zur ausgewählten Serie auf Wunschliste anzeigen"
),
"0":
(self.readLogFile, "Log-File des letzten Suchlaufs anzeigen"),
"3": (self.showProposalDB,
"Liste der Serien/Staffel-Starts anzeigen"),
"4": (self.serieInfo,
"Informationen zur ausgewählten Serie anzeigen"),
"6":
(self.showConflicts, "Liste der Timer-Konflikte anzeigen"),
"7": (self.showWishlist,
"Merkzettel (vorgemerkte Folgen) anzeigen"),
"8": (self.cleanUp, "Timerliste bereinigen"),
"9":
(self.dropAllTimer, "Alle Timer aus der Datenbank löschen"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(
[
"SerienRecorderActions",
],
{
# "ok" : self.keyOK,
"displayHelp": self.showHelp,
"displayHelp_long": self.showManual,
},
0)
self.setupSkin()
self.changesMade = False
self.filter = True
self.onLayoutFinish.append(self.readTimer)
self.onClose.append(self.__onClose)
self.onLayoutFinish.append(self.setSkinProperties)
def __init__(self, session, webSender):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.session = session
self.webSender = webSender
from SerienRecorder import serienRecDataBaseFilePath
from SerienRecorderDatabase import SRDatabase
self.database = SRDatabase(serienRecDataBaseFilePath)
self["actions"] = HelpableActionMap(
self, "SerienRecorderActions", {
"red": (self.cancel,
"Änderungen verwerfen und zurück zur Sender-Ansicht"),
"green":
(self.save,
"Einstellungen speichern und zurück zur Sender-Ansicht"),
"cancel":
(self.cancel,
"Änderungen verwerfen und zurück zur Sender-Ansicht"),
"ok": (self.ok, "---"),
"up": (self.keyUp, "eine Zeile nach oben"),
"down": (self.keyDown, "eine Zeile nach unten"),
"startTeletext": (self.showAbout, "Über dieses Plugin"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(
[
"SerienRecorderActions",
], {
"ok": self.ok,
"displayHelp": self.showHelp,
"displayHelp_long": self.showManual,
}, 0)
self.setupSkin()
if config.plugins.serienRec.showAllButtons.value:
setMenuTexts(self)
(Vorlaufzeit, Nachlaufzeit, vps,
autoAdjust) = self.database.getChannelsSettings(self.webSender)
if str(Vorlaufzeit).isdigit():
self.margin_before = ConfigInteger(Vorlaufzeit, (0, 99))
self.enable_margin_before = ConfigYesNo(default=True)
else:
self.margin_before = ConfigInteger(
config.plugins.serienRec.margin_before.value, (0, 99))
self.enable_margin_before = ConfigYesNo(default=False)
if str(Nachlaufzeit).isdigit():
self.margin_after = ConfigInteger(Nachlaufzeit, (0, 99))
self.enable_margin_after = ConfigYesNo(default=True)
else:
self.margin_after = ConfigInteger(
config.plugins.serienRec.margin_after.value, (0, 99))
self.enable_margin_after = ConfigYesNo(default=False)
if str(vps).isdigit():
self.enable_vps = ConfigYesNo(default=bool(vps & 0x1))
self.enable_vps_savemode = ConfigYesNo(default=bool(vps & 0x2))
else:
self.enable_vps = ConfigYesNo(default=False)
self.enable_vps_savemode = ConfigYesNo(default=False)
if str(autoAdjust).isdigit():
self.autoAdjust = ConfigYesNo(default=bool(autoAdjust))
self.enable_autoAdjust = ConfigYesNo(default=True)
else:
self.autoAdjust = ConfigYesNo(default=False)
self.enable_autoAdjust = ConfigYesNo(default=False)
self.changedEntry()
ConfigListScreen.__init__(self, self.list)
self.setInfoText()
self['config_information_text'].setText(
self.HilfeTexte[self.enable_margin_before])
self.onLayoutFinish.append(self.setSkinProperties)
def __init__(self, session):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.session = session
self.serienRecChannelList = []
self.stbChannelList = []
self.selected_sender = None
self.skin = None
self.displayMode = 2
self.chooseMenuList = None
self.chooseMenuList_popup = None
self.chooseMenuList_popup2 = None
from SerienRecorder import serienRecDataBaseFilePath
from SerienRecorderDatabase import SRDatabase
self.database = SRDatabase(serienRecDataBaseFilePath)
from difflib import SequenceMatcher
self.sequenceMatcher = SequenceMatcher(" ".__eq__, "", "")
self["actions"] = HelpableActionMap(
self, "SerienRecorderActions", {
"ok": (self.keyOK,
"Popup-Fenster zur Auswahl des STB-Sender öffnen"),
"cancel": (self.keyCancel, "zurück zur Serienplaner-Ansicht"),
"red":
(self.keyRed,
"umschalten ausgewählter Sender für Timererstellung aktiviert/deaktiviert"
),
"red_long":
(self.keyRedLong,
"ausgewählten Sender aus der Channelliste endgültig löschen"),
"green": (self.keyGreen, "Sender-Zuordnung aktualisieren"),
"blue": (self.keyBlue, "Automatische Sender-Zuordnung"),
"menu":
(self.channelSetup, "Menü für Sender-Einstellungen öffnen"),
"menu_long":
(self.recSetup, "Menü für globale Einstellungen öffnen"),
"left": (self.keyLeft, "zur vorherigen Seite blättern"),
"right": (self.keyRight, "zur nächsten Seite blättern"),
"up": (self.keyUp, "eine Zeile nach oben"),
"down": (self.keyDown, "eine Zeile nach unten"),
"0":
(self.readLogFile, "Log-File des letzten Suchlaufs anzeigen"),
"3": (self.showProposalDB,
"Liste der Serien/Staffel-Starts anzeigen"),
"6":
(self.showConflicts, "Liste der Timer-Konflikte anzeigen"),
"7": (self.showWishlist,
"Merkzettel (vorgemerkte Folgen) anzeigen"),
"8": (self.checkChannels, "Sender prüfen"),
"9": (self.resetChannelList, "Alle Zuordnungen löschen"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap([
"SerienRecorderActions",
], {
"displayHelp": self.showHelp,
"displayHelp_long": self.showManual,
}, 0)
self.setupSkin()
self.modus = "list"
self.changesMade = False
self.timer_default = eTimer()
if isDreamOS():
self.timer_default_conn = self.timer_default.timeout.connect(
self.showChannels)
else:
self.timer_default.callback.append(self.showChannels)
self.onLayoutFinish.append(self.__onLayoutFinished)
self.onClose.append(self.__onClose)
self.onLayoutFinish.append(self.setSkinProperties)
def __init__(self, session):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.modus = "menu_list"
self.session = session
self.picload = ePicLoad()
self.ErrorMsg = "unbekannt"
self.piconLoader = PiconLoader()
self.picloader = None
self.filter = False
self.database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
self.changesMade = False
self["actions"] = HelpableActionMap(
self, "SerienRecorderActions", {
"ok":
(self.keyOK, "Marker für die ausgewählte Serie hinzufügen"),
"cancel": (self.keyCancel, "zurück zur vorherigen Ansicht"),
"left": (self.keyLeft, "zur vorherigen Seite blättern"),
"right": (self.keyRight, "zur nächsten Seite blättern"),
"up": (self.keyUp, "eine Zeile nach oben"),
"down": (self.keyDown, "eine Zeile nach unten"),
"menu":
(self.recSetup, "Menü für globale Einstellungen öffnen"),
"yellow": (self.keyYellow, "Zeige nur Serien-Starts"),
"startTeletext":
(self.wunschliste,
"Informationen zur ausgewählten Serie auf Wunschliste anzeigen"
),
"0":
(self.readLogFile, "Log-File des letzten Suchlaufs anzeigen"),
"2": (self.changeTVDBID, "TVDB-ID ändern"),
"4": (self.serieInfo,
"Informationen zur ausgewählten Serie anzeigen"),
"6":
(self.showConflicts, "Liste der Timer-Konflikte anzeigen"),
"7": (self.showWishlist,
"Merkzettel (vorgemerkte Folgen) anzeigen"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap([
"SerienRecorderActions",
], {
"displayHelp": self.showHelp,
"displayHelp_long": self.showManual,
}, 0)
self.setupSkin()
self.timer_default = eTimer()
if isDreamOS():
self.timer_default_conn = self.timer_default.timeout.connect(
self.readProposal)
else:
self.timer_default.callback.append(self.readProposal)
self.proposalList = []
self.transmissions = {}
self.serviceRefs = self.database.getActiveServiceRefs()
self.onLayoutFinish.append(self.setSkinProperties)
self.onLayoutFinish.append(self.__onLayoutFinish)
self.onClose.append(self.__onClose)
def __init__(self, session):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.session = session
self.picload = ePicLoad()
self.database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
self.chooseMenuList_popup = MenuList(
[], enableWrapAround=True, content=eListboxPythonMultiContent)
self["actions"] = HelpableActionMap(
self, "SerienRecorderActions", {
"ok": (self.keyOK,
"für die ausgewählte Serien neue Einträge hinzufügen"),
"cancel": (self.keyCancel, "zurück zur vorherigen Ansicht"),
"left": (self.keyLeft, "zur vorherigen Seite blättern"),
"right": (self.keyRight, "zur nächsten Seite blättern"),
"up": (self.keyUp, "eine Zeile nach oben"),
"down": (self.keyDown, "eine Zeile nach unten"),
"red": (self.keyRed, "ausgewählten Eintrag löschen"),
"green":
(self.keyGreen,
"alle Änderungen speichern und zurück zur vorherigen Ansicht"
),
"yellow": (self.keyYellow, "umschalten Sortierung ein/aus"),
"blue": (self.keyBlue,
"alle Einträge aus der Liste endgültig löschen"),
"menu":
(self.recSetup, "Menü für globale Einstellungen öffnen"),
"0":
(self.readLogFile, "Log-File des letzten Suchlaufs anzeigen"),
"3": (self.showProposalDB,
"Liste der Serien/Staffel-Starts anzeigen"),
"4": (self.serieInfo,
"Informationen zur ausgewählten Serie anzeigen"),
"6":
(self.showConflicts, "Liste der Timer-Konflikte anzeigen"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap([
"SerienRecorderActions",
], {
"displayHelp": self.showHelp,
"displayHelp_long": self.showManual,
}, 0)
self.setupSkin()
self.delAdded = False
self.wishlist = []
self.wishlist_tmp = []
self.dbData = []
self.modus = "menu_list"
self.aSerie = ""
self.aStaffel = 0
self.aFromEpisode = 0
self.aToEpisode = 0
self.onLayoutFinish.append(self.readWishlist)
self.onClose.append(self.__onClose)
self.onLayoutFinish.append(self.setSkinProperties)
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 __init__(self, manuell):
self.database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
self.manuell = manuell
def initDB():
# type: () -> object
global serienRecDataBaseFilePath
# If database is at old default location (SerienRecorder plugin folder) we have to move the db to new default location
if fileExists("%sSerienRecorder.db" % serienRecMainPath):
shutil.move("%sSerienRecorder.db" % serienRecMainPath, serienRecDataBaseFilePath)
if not fileExists(serienRecDataBaseFilePath):
config.plugins.serienRec.databasePath.value = "/etc/enigma2/"
config.plugins.serienRec.databasePath.save()
configfile.save()
SRLogger.writeLog("Datenbankpfad nicht gefunden, auf Standardpfad zurückgesetzt!")
print "[SerienRecorder] Datenbankpfad nicht gefunden, auf Standardpfad zurückgesetzt!"
Notifications.AddPopup(
"SerienRecorder Datenbank wurde nicht gefunden.\nDer Standardpfad für die Datenbank wurde wiederhergestellt!",
MessageBox.TYPE_INFO, timeout=10)
serienRecDataBaseFilePath = "%sSerienRecorder.db" % config.plugins.serienRec.databasePath.value
try:
database = SRDatabase(serienRecDataBaseFilePath)
except:
SRLogger.writeLog("Fehler beim Initialisieren der Datenbank")
print "[SerienRecorder] Fehler beim Initialisieren der Datenbank"
Notifications.AddPopup("SerienRecorder Datenbank kann nicht initialisiert werden.\nSerienRecorder wurde beendet!", MessageBox.TYPE_INFO, timeout=10)
return False
if os.path.getsize(serienRecDataBaseFilePath) == 0:
database.initialize(config.plugins.serienRec.dbversion.value)
else:
dbVersionMatch = False
dbIncompatible = False
dbVersion = database.getVersion()
if dbVersion:
if dbVersion == config.plugins.serienRec.dbversion.value:
dbVersionMatch = True
elif dbVersion > config.plugins.serienRec.dbversion.value:
SRLogger.writeLog("Datenbankversion nicht kompatibel: SerienRecorder Version muss mindestens %s sein." % dbVersion)
Notifications.AddPopup("Die SerienRecorder Datenbank ist mit dieser Version nicht kompatibel.\nAktualisieren Sie mindestens auf die SerienRecorder Version %s!" % dbVersion, MessageBox.TYPE_INFO, timeout=10)
dbIncompatible = True
else:
dbIncompatible = True
mode = os.R_OK | os.W_OK
if not os.access(serienRecDataBaseFilePath, mode):
SRLogger.writeLog("Datenbankdatei hat nicht die richtigen Berechtigungen - es müssen Lese- und Schreibrechte gesetzt sein.")
Notifications.AddPopup("Datenbankdatei hat nicht die richtigen Berechtigungen - es müssen Lese- und Schreibrechte gesetzt sein.", MessageBox.TYPE_INFO, timeout=10)
dbIncompatible = True
# Database incompatible - do cleanup
if dbIncompatible:
database.close()
return False
if not dbVersionMatch:
SRLogger.writeLog("Datenbank ist zu alt - sie muss aktualisiert werden...", True)
database.close()
backupSerienRecDataBaseFilePath = "%sSerienRecorder_old.db" % config.plugins.serienRec.databasePath.value
SRLogger.writeLog("Erstelle Datenbank Backup - es kann nach erfolgreichem Update gelöscht werden: %s" % backupSerienRecDataBaseFilePath, True)
shutil.copy(serienRecDataBaseFilePath, backupSerienRecDataBaseFilePath)
database = SRDatabase(serienRecDataBaseFilePath)
if database.update(config.plugins.serienRec.dbversion.value):
SRLogger.writeLog("Datenbank von Version %s auf Version %s aktualisiert" % (dbVersion, config.plugins.serienRec.dbversion.value), True)
else:
database.close()
Notifications.AddPopup("SerienRecorder Datenbank konnte nicht aktualisiert werden. Fehler wurden in die Logdatei geschrieben.\nSerienRecorder wurde beendet!", MessageBox.TYPE_INFO, timeout=10)
return False
# Analyze database for query optimizer
try:
database.optimize()
except Exception as e:
database.close()
SRLogger.writeLog("Fehler beim Zugriff auf die Datenbank [%s]" % str(e))
Notifications.AddPopup("Fehler beim Zugriff auf die Datenbank!\n%s" % str(e), MessageBox.TYPE_INFO, timeout=10)
return False
database.close()
return True