class serienRecCheckForRecording:
instance = None
epgrefresh_instance = None
def __init__(self, session, manuell, tvplaner_manuell=False):
assert not serienRecCheckForRecording.instance, "Go is a singleton class!"
serienRecCheckForRecording.instance = self
self.session = session
self.database = None
self.manuell = manuell
self.tvplaner_manuell = tvplaner_manuell
print "[SerienRecorder] 1__init__ tvplaner_manuell: ", tvplaner_manuell
self.newSeriesOrEpisodesFound = False
self.senderListe = {}
self.markers = []
self.messageList = []
self.speedStartTime = 0
self.speedEndTime = 0
self.konflikt = ""
self.count_url = 0
self.countSerien = 0
self.countActivatedSeries = 0
self.noOfRecords = int(config.plugins.serienRec.NoOfRecords.value)
self.emailData = None
SRLogger.checkFileAccess()
lt = time.localtime()
self.uhrzeit = time.strftime("%d.%m.%Y - %H:%M:%S", lt)
SRLogger.writeLog("\n---------' %s '---------" % self.uhrzeit, True)
self.daypage = 0
global refreshTimer
if refreshTimer:
refreshTimer.stop()
refreshTimer = None
global refreshTimerConnection
if refreshTimerConnection:
refreshTimerConnection = None
self.tempDB = None
if config.plugins.serienRec.autochecktype.value == "0":
SRLogger.writeLog("Auto-Check ist deaktiviert - nur manuelle Timersuche", True)
elif config.plugins.serienRec.autochecktype.value == "1":
SRLogger.writeLog("Auto-Check ist aktiviert - er wird zur gewählten Uhrzeit gestartet", True)
elif config.plugins.serienRec.autochecktype.value == "2":
SRLogger.writeLog("Auto-Check ist aktiviert - er wird nach dem EPGRefresh ausgeführt", True)
if not self.manuell and 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("Verbleibende Zeit bis zum nächsten Auto-Check: %s Stunden\n" % TimeHelpers.td2HHMMstr(datetime.timedelta(minutes=deltatime+int(config.plugins.serienRec.maxDelayForAutocheck.value))), True)
if self.manuell:
print "[SerienRecorder] checkRecTimer manuell."
self.startCheck()
self.manuell = False
self.tvplaner_manuell = False
else:
try:
from Plugins.Extensions.EPGRefresh.EPGRefresh import epgrefresh
self.epgrefresh_instance = epgrefresh
config.plugins.serienRec.autochecktype.addNotifier(self.setEPGRefreshCallback)
except Exception as e:
SRLogger.writeLog("EPGRefresh plugin nicht installiert! " + str(e), True)
@staticmethod
def getNextAutoCheckTimer(lt):
acttime = (lt.tm_hour * 60 + lt.tm_min)
deltime = (config.plugins.serienRec.deltime.value[0] * 60 + config.plugins.serienRec.deltime.value[1])
if acttime < deltime:
deltatime = deltime - acttime
else:
deltatime = abs(1440 - acttime + deltime)
return deltatime
def setEPGRefreshCallback(self, configentry = None):
try:
if self.epgrefresh_instance:
if config.plugins.serienRec.autochecktype.value == "2":
self.epgrefresh_instance.addFinishNotifier(self.startCheck)
else:
self.epgrefresh_instance.removeFinishNotifier(self.startCheck)
except Exception as e:
try:
from Tools.HardwareInfoVu import HardwareInfoVu
pass
except:
SRLogger.writeLog("Um die EPGRefresh Optionen nutzen zu können, muss mindestens die EPGRefresh Version 2.1.1 installiert sein. " + str(e), True)
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 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 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 createTimer(self, result=True):
from SerienRecorderTimer import serienRecTimer
timer = serienRecTimer()
timer.setTempDB(self.tempDB)
# versuche deaktivierte Timer zu erstellen
timer.activate()
# jetzt die Timer erstellen
for x in range(self.noOfRecords):
timer.search(x)
# gleiche alte Timer mit EPG ab
current_time = int(time.time())
timer.adjustEPGtimes(current_time)
SRLogger.writeLog("\n", True)
# Datenbank aufräumen
self.database.rebuild()
self.tempDB.rebuild()
global autoCheckFinished
autoCheckFinished = True
(countTimer, countTimerUpdate, countNotActiveTimer, countTimerFromWishlist, self.messageList) = timer.getCounts()
# Statistik
self.speedEndTime = time.clock()
speedTime = (self.speedEndTime - self.speedStartTime)
if config.plugins.serienRec.eventid.value:
SRLogger.writeLog("%s/%s Serie(n) sind vorgemerkt davon wurde(n) %s Timer erstellt und %s Timer aktualisiert." % (str(self.countActivatedSeries), str(self.countSerien), str(countTimer), str(countTimerUpdate)), True)
print "[SerienRecorder] %s/%s Serie(n) sind vorgemerkt davon wurde(n) %s Timer erstellt und %s Timer aktualisiert." % (str(self.countActivatedSeries), str(self.countSerien), str(countTimer), str(countTimerUpdate))
else:
SRLogger.writeLog("%s/%s Serie(n) sind vorgemerkt davon wurde(n) %s Timer erstellt." % (str(self.countActivatedSeries), str(self.countSerien), str(countTimer)), True)
print "[SerienRecorder] %s/%s Serie(n) sind vorgemerkt davon wurde(n) %s Timer erstellt." % (str(self.countActivatedSeries), str(self.countSerien), str(countTimer))
if countNotActiveTimer > 0:
SRLogger.writeLog("%s Timer wurde(n) wegen Konflikten deaktiviert erstellt!" % str(countNotActiveTimer), True)
print "[SerienRecorder] %s Timer wurde(n) wegen Konflikten deaktiviert erstellt!" % str(countNotActiveTimer)
if countTimerFromWishlist > 0:
SRLogger.writeLog("%s Timer vom Merkzettel wurde(n) erstellt!" % str(countTimerFromWishlist), True)
print "[SerienRecorder] %s Timer vom Merkzettel wurde(n) erstellt!" % str(countTimerFromWishlist)
SRLogger.writeLog("---------' Auto-Check beendet (Ausführungsdauer: %3.2f Sek.)'---------" % speedTime, True)
print "[SerienRecorder] ---------' Auto-Check beendet (Ausführungsdauer: %3.2f Sek.)'---------" % speedTime
if (config.plugins.serienRec.showNotification.value in ("2", "3")) and (not self.manuell):
statisticMessage = "Serien vorgemerkt: %s/%s\nTimer erstellt: %s\nTimer aktualisiert: %s\nTimer mit Konflikten: %s\nTimer vom Merkzettel: %s" % (
str(self.countActivatedSeries), str(self.countSerien), str(countTimer), str(countTimerUpdate),
str(countNotActiveTimer), str(countTimerFromWishlist))
newSeasonOrEpisodeMessage = ""
if self.newSeriesOrEpisodesFound:
newSeasonOrEpisodeMessage = "\n\nNeuer Serien- oder Staffelbeginn gefunden"
Notifications.AddPopup("SerienRecorder Suchlauf für neue Timer wurde beendet.\n\n%s%s" % (
statisticMessage, newSeasonOrEpisodeMessage), MessageBox.TYPE_INFO, timeout=10, id="Suchlauf wurde beendet")
return result
def checkFinal(self):
print "[SerienRecorder] checkFinal"
# final processing
if config.plugins.serienRec.tvplaner.value and config.plugins.serienRec.tvplaner_movies.value:
# remove all serien markers created for movies
try:
self.database.removeMovieMarkers()
print "[SerienRecorder] ' TV-Planer FilmMarker gelöscht '"
except:
SRLogger.writeLog("' TV-Planer FilmMarker löschen fehlgeschlagen '", True)
print "[SerienRecorder] ' TV-Planer FilmMarker löschen fehlgeschlagen '"
global transmissionFailed
if transmissionFailed:
# always do fullcheck after transmission error
config.plugins.serienRec.tvplaner_last_full_check.value = int(0)
config.plugins.serienRec.tvplaner_last_full_check.save()
configfile.save()
if config.plugins.serienRec.AutoBackup.value == "after":
createBackup()
from SerienRecorderTVPlaner import backupTVPlanerHTML
backupTVPlanerHTML()
# trigger read of log file
global autoCheckFinished
autoCheckFinished = True
print "[SerienRecorder] checkFinal: autoCheckFinished"
if config.plugins.serienRec.autochecktype.value == "1":
lt = time.localtime()
deltatime = self.getNextAutoCheckTimer(lt)
SRLogger.writeLog("\nVerbleibende Zeit bis zum nächsten Auto-Check: %s Stunden\n" % TimeHelpers.td2HHMMstr(datetime.timedelta(minutes=deltatime+int(config.plugins.serienRec.maxDelayForAutocheck.value))), True)
if config.plugins.serienRec.tvplaner_full_check.value:
autoCheckDays = ((int(config.plugins.serienRec.tvplaner_last_full_check.value) + (int(config.plugins.serienRec.checkfordays.value) - 1) * 86400) - int(time.time())) / 86400
if autoCheckDays < 0:
autoCheckDays = 0
SRLogger.writeLog("Verbleibende Zeit bis zum nächsten vollen Auto-Check: %d Tage" % autoCheckDays, True)
self.tempDB = None
self.database = None
# in den deep-standby fahren.
self.askForDSB()
def processTransmission(self, data, serien_id, serien_name, staffeln, AbEpisode, AnzahlAufnahmen, current_time, future_time, excludedWeekdays=None):
print "[SerienRecorder] processTransmissions: %r" % serien_name
self.count_url += 1
if data is None:
SRLogger.writeLog("Fehler beim Abrufen und Verarbeiten der Ausstrahlungstermine [%s]" % serien_name, True)
#print "[SerienRecorder] processTransmissions: no Data"
return
(fromTime, toTime) = self.database.getTimeSpan(serien_name, config.plugins.serienRec.globalFromTime.value, config.plugins.serienRec.globalToTime.value)
if self.noOfRecords < AnzahlAufnahmen:
self.noOfRecords = AnzahlAufnahmen
TimeSpan_time = int(future_time)
if config.plugins.serienRec.forceRecording.value:
TimeSpan_time += (int(config.plugins.serienRec.TimeSpanForRegularTimer.value) - int(config.plugins.serienRec.checkfordays.value)) * 86400
# loop over all transmissions
self.tempDB.beginTransaction()
for current_serien_name, sender, startzeit, endzeit, staffel, episode, title, status in data:
start_unixtime = startzeit
end_unixtime = endzeit
# install missing covers
(dirname, dirname_serie) = getDirname(self.database, serien_name, staffel)
STBHelpers.createDirectory(current_serien_name, dirname, dirname_serie, True)
# setze die vorlauf/nachlauf-zeit
(margin_before, margin_after) = self.database.getMargins(serien_name, sender, config.plugins.serienRec.margin_before.value, config.plugins.serienRec.margin_after.value)
start_unixtime = int(start_unixtime) - (int(margin_before) * 60)
end_unixtime = int(end_unixtime) + (int(margin_after) * 60)
# if there is no season or episode number it can be a special
# but if we have more than one special and wunschliste.de does not
# give us an episode number we are unable to differentiate between these specials
if not staffel and not episode:
staffel = "S"
episode = "00"
# initialize strings
seasonEpisodeString = "S%sE%s" % (str(staffel).zfill(2), str(episode).zfill(2))
label_serie = "%s - %s - %s" % (serien_name, seasonEpisodeString, title)
if not config.plugins.serienRec.forceRecording.value:
if (int(fromTime) > 0) or (int(toTime) < (23*60)+59):
start_time = (time.localtime(int(start_unixtime)).tm_hour * 60) + time.localtime(int(start_unixtime)).tm_min
end_time = (time.localtime(int(end_unixtime)).tm_hour * 60) + time.localtime(int(end_unixtime)).tm_min
if not TimeHelpers.allowedTimeRange(fromTime, toTime, start_time, end_time):
print "[SerienRecorder] processTransmissions time range ignore: %r" % serien_name
timeRangeConfigured = "%s:%s - %s:%s" % (str(int(fromTime) / 60).zfill(2), str(int(fromTime) % 60).zfill(2), str(int(toTime) / 60).zfill(2), str(int(toTime) % 60).zfill(2))
timeRangeTransmission = "%s:%s - %s:%s" % (str(int(start_time) / 60).zfill(2), str(int(start_time) % 60).zfill(2), str(int(end_time) / 60).zfill(2), str(int(end_time) % 60).zfill(2))
SRLogger.writeLogFilter("timeRange", "' %s ' - Sendung (%s) nicht in Zeitspanne [%s]" % (label_serie, timeRangeTransmission, timeRangeConfigured))
continue
# Process channel relevant data
##############################
#
# CHECK
#
# ueberprueft welche sender aktiviert und eingestellt sind.
#
(webChannel, stbChannel, stbRef, altstbChannel, altstbRef, status) = self.checkSender(sender)
if stbChannel == "":
SRLogger.writeLogFilter("channels", "' %s ' - STB-Sender nicht gefunden ' -> ' %s '" % (label_serie, webChannel))
continue
if int(status) == 0:
SRLogger.writeLogFilter("channels", "' %s ' - STB-Sender deaktiviert -> ' %s '" % (label_serie, webChannel))
continue
##############################
#
# CHECK
#
# ueberprueft welche staffel(n) erlaubt sind
#
serieAllowed = False
if -2 in staffeln: # 'Manuell'
serieAllowed = False
elif (-1 in staffeln) and (0 in staffeln): # 'Alle'
serieAllowed = True
elif str(staffel).isdigit():
if int(staffel) == 0:
if str(episode).isdigit():
if int(episode) < int(AbEpisode):
if config.plugins.serienRec.writeLogAllowedEpisodes.value:
liste = staffeln[:]
liste.sort()
liste.reverse()
if -1 in staffeln:
liste.remove(-1)
liste[0] = "ab %s" % liste[0]
liste.reverse()
liste.insert(0, "0 ab E%s" % str(AbEpisode).zfill(2))
SRLogger.writeLogFilter("allowedEpisodes", "' %s ' - Episode nicht erlaubt -> ' %s ' -> ' %s '" % (label_serie, seasonEpisodeString, str(liste).replace("'", "").replace('"', "")))
continue
else:
serieAllowed = True
elif int(staffel) in staffeln:
serieAllowed = True
elif -1 in staffeln: # 'folgende'
if int(staffel) >= max(staffeln):
serieAllowed = True
elif self.database.getSpecialsAllowed(serien_name):
serieAllowed = True
vomMerkzettel = False
if not serieAllowed:
if self.database.hasBookmark(serien_name, staffel, episode):
SRLogger.writeLog("' %s ' - Timer vom Merkzettel wird angelegt @ %s" % (label_serie, stbChannel), True)
serieAllowed = True
vomMerkzettel = True
if not serieAllowed:
if config.plugins.serienRec.writeLogAllowedEpisodes.value:
liste = staffeln[:]
liste.sort()
liste.reverse()
if -1 in staffeln:
liste.remove(-1)
liste[0] = "ab %s" % liste[0]
liste.reverse()
if str(episode).isdigit():
if int(episode) < int(AbEpisode):
liste.insert(0, "0 ab E%s" % str(AbEpisode).zfill(2))
if -2 in staffeln:
liste.remove(-2)
liste.insert(0, "Manuell")
SRLogger.writeLogFilter("allowedEpisodes", "' %s ' - Staffel nicht erlaubt -> ' %s ' -> ' %s '" % (label_serie, seasonEpisodeString, str(liste).replace("'", "").replace('"', "")))
continue
##############################
#
# try to get eventID (eit) from epgCache
#
eit, new_end_unixtime, new_start_unixtime = STBHelpers.getStartEndTimeFromEPG(start_unixtime, end_unixtime, margin_before, margin_after, serien_name, stbRef)
alt_eit = 0
alt_end_unixtime = end_unixtime
alt_start_unixtime = start_unixtime
if altstbRef:
alt_eit, alt_end_unixtime, alt_start_unixtime = STBHelpers.getStartEndTimeFromEPG(start_unixtime, end_unixtime, margin_before, margin_after, serien_name, altstbRef)
updateFromEPG = self.database.getUpdateFromEPG(serien_name)
if updateFromEPG is False:
new_start_unixtime = start_unixtime
new_end_unixtime = end_unixtime
alt_end_unixtime = end_unixtime
alt_start_unixtime = start_unixtime
(dirname, dirname_serie) = getDirname(self.database, serien_name, staffel)
self.tempDB.addTransmission([(current_time, future_time, serien_name, staffel, episode, seasonEpisodeString, title, label_serie, webChannel, stbChannel, stbRef, new_start_unixtime, new_end_unixtime, eit, altstbChannel, altstbRef, alt_start_unixtime, alt_end_unixtime, alt_eit, dirname, AnzahlAufnahmen, fromTime, toTime, int(vomMerkzettel), excludedWeekdays, updateFromEPG)])
self.tempDB.commitTransaction()
def askForDSB(self):
if not self.manuell:
if config.plugins.serienRec.afterAutocheck.value != "0":
if config.plugins.serienRec.DSBTimeout.value > 0 and not Screens.Standby.inStandby:
print "[SerienRecorder] Try to display shutdown notification..."
try:
notificationText = "Soll der SerienRecorder die Box in den Ruhemodus (Standby) schalten?"
if config.plugins.serienRec.afterAutocheck.value == "2":
notificationText = "Soll der SerienRecorder die Box ausschalten (Deep-Standby)?"
Notifications.AddNotificationWithCallback(self.gotoDeepStandby, MessageBox, text=notificationText, type=MessageBox.TYPE_YESNO, timeout=config.plugins.serienRec.DSBTimeout.value, default=True)
except Exception as e:
print "[SerienRecorder] Could not display shutdown notification - shutdown box without notification... (%s)" % str(e)
self.gotoDeepStandby(True)
else:
self.gotoDeepStandby(True)
def gotoDeepStandby(self, answer):
if answer:
if config.plugins.serienRec.afterAutocheck.value == "2":
if not NavigationInstance.instance.RecordTimer.isRecording():
for each in self.messageList:
Notifications.RemovePopup(each[3])
print "[SerienRecorder] gehe in Deep-Standby"
SRLogger.writeLog("gehe in Deep-Standby")
if Screens.Standby.inStandby:
from RecordTimer import RecordTimerEntry
RecordTimerEntry.TryQuitMainloop()
else:
Notifications.AddNotificationWithID("Shutdown", Screens.Standby.TryQuitMainloop, 1)
else:
print "[SerienRecorder] Eine laufende Aufnahme verhindert den Deep-Standby"
SRLogger.writeLog("Eine laufende Aufnahme verhindert den Deep-Standby")
else:
print "[SerienRecorder] gehe in Standby"
SRLogger.writeLog("gehe in Standby")
Notifications.AddNotification(Screens.Standby.Standby)
def checkSender(self, channel):
if channel.lower() in self.senderListe:
(webChannel, stbChannel, stbRef, altstbChannel, altstbRef, status) = self.senderListe[channel.lower()]
else:
webChannel = channel
stbChannel = ""
stbRef = ""
altstbChannel = ""
altstbRef = ""
status = "0"
return webChannel, stbChannel, stbRef, altstbChannel, altstbRef, status
@staticmethod
def dataError(error):
print "[SerienRecorder] Es ist ein Fehler aufgetreten - die Daten konnten nicht abgerufen/verarbeitet werden: (%s)" % error
class serienRecMainChannelEdit(serienRecBaseScreen, Screen, HelpableScreen):
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 callHelpAction(self, *args):
HelpableScreen.callHelpAction(self, *args)
def setSkinProperties(self):
super(self.__class__, self).setSkinProperties()
self['text_green'].setText("Aktualisieren")
self['text_ok'].setText("Sender auswählen")
self.num_bt_text[3][1] = "Sender prüfen"
self.num_bt_text[4][1] = "Alle löschen"
if longButtonText:
self.num_bt_text[4][0] = ""
self['text_red'].setText("An/Aus (lang: Löschen)")
self.num_bt_text[4][2] = "Setup Sender (lang: global)"
else:
self.num_bt_text[4][0] = buttonText_na
self['text_red'].setText("(De)aktivieren/Löschen")
self.num_bt_text[4][2] = "Setup Sender/global"
self['text_blue'].setText("Auto-Zuordnung")
self.num_bt_text[2][2] = buttonText_na
self.num_bt_text[3][2] = buttonText_na
super(self.__class__, self).startDisplayTimer()
def setupSkin(self):
self.skin = None
InitSkin(self)
# normal
self.chooseMenuList = MenuList([],
enableWrapAround=True,
content=eListboxPythonMultiContent)
self.chooseMenuList.l.setFont(
0,
gFont('Regular',
20 + int(config.plugins.serienRec.listFontsize.value)))
self.chooseMenuList.l.setItemHeight(int(25 * skinFactor))
self['list'] = self.chooseMenuList
self['list'].show()
# popup
self.chooseMenuList_popup = MenuList(
[], enableWrapAround=True, content=eListboxPythonMultiContent)
self.chooseMenuList_popup.l.setFont(
0,
gFont('Regular',
20 + int(config.plugins.serienRec.listFontsize.value)))
self.chooseMenuList_popup.l.setItemHeight(int(25 * skinFactor))
self['popup_list'] = self.chooseMenuList_popup
self['popup_list'].hide()
# popup2
self.chooseMenuList_popup2 = MenuList(
[], enableWrapAround=True, content=eListboxPythonMultiContent)
self.chooseMenuList_popup2.l.setFont(
0,
gFont('Regular',
20 + int(config.plugins.serienRec.listFontsize.value)))
self.chooseMenuList_popup2.l.setItemHeight(int(25 * skinFactor))
self['popup_list2'] = self.chooseMenuList_popup2
self['popup_list2'].hide()
self['title'].setText("Lade Wunschliste-Sender...")
self['Web_Channel'].setText("Wunschliste")
self['STB_Channel'].setText("STB-Sender")
self['alt_STB_Channel'].setText("alt. STB-Sender")
self['Web_Channel'].show()
self['STB_Channel'].show()
self['alt_STB_Channel'].show()
self['separator'].show()
if not config.plugins.serienRec.showAllButtons.value:
self['bt_red'].show()
self['bt_green'].show()
self['bt_blue'].show()
self['bt_ok'].show()
self['bt_exit'].show()
#self['bt_text'].show()
self['bt_epg'].hide()
self['bt_info'].show()
self['bt_menu'].show()
self['text_red'].show()
self['text_green'].show()
self['text_blue'].show()
self['text_ok'].show()
self['text_0'].show()
self['text_1'].show()
self['text_2'].show()
self['text_3'].show()
self['text_4'].show()
def updateMenuKeys(self):
updateMenuKeys(self)
def channelSetup(self):
webSender = self['list'].getCurrent()[0][0]
self.session.open(serienRecChannelSetup, webSender)
def setupClose(self, result):
super(self.__class__, self).setupClose(result)
if result[1]:
self.showChannels()
def __onLayoutFinished(self):
self['title'].setText("Lade Wunschliste-Sender...")
self.timer_default.start(0)
def checkChannels(self):
channels = self.database.getChannels(True)
if config.plugins.serienRec.selectBouquets.value:
stbChannelList = STBHelpers.buildSTBChannelList(
config.plugins.serienRec.MainBouquet.value)
else:
stbChannelList = STBHelpers.buildSTBChannelList()
stbServiceRefs = [x[1] for x in stbChannelList]
serviceRefs = [x[2] for x in channels]
missingServiceRefs = []
missingServices = []
for serviceRef in serviceRefs:
if serviceRef not in stbServiceRefs:
missingServiceRefs.append(serviceRef)
for missingServiceRef in missingServiceRefs:
for channel in channels:
(webSender, servicename, serviceref, altservicename,
altserviceref, status) = channel
if serviceref is missingServiceRef and servicename and int(
status) != 0:
missingServices.append(servicename)
SRLogger.writeLog(
"%s => %s" % (missingServiceRef, servicename), True)
break
if missingServices:
self.session.open(
MessageBox,
"Für folgende Sender existiert die ServiceRef nicht mehr,\nbitte die Sender neu zuweisen:\n\n"
+ "\n".join(missingServices),
MessageBox.TYPE_INFO,
timeout=0)
else:
self.session.open(MessageBox,
"Alle zugewiesenen Sender sind noch vorhanden.",
MessageBox.TYPE_INFO,
timeout=7)
def showChannels(self):
self.timer_default.stop()
self.serienRecChannelList = []
channels = self.database.getChannels(True)
for channel in channels:
(webSender, servicename, serviceref, altservicename, altserviceref,
status) = channel
self.serienRecChannelList.append(
(webSender, servicename, altservicename, status))
if len(self.serienRecChannelList) != 0:
self['title'].setText("Sender zuordnen")
self.chooseMenuList.setList(
map(self.buildList, self.serienRecChannelList))
else:
self.channelReset(True)
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 createWebChannels(self, webChannelList, autoMatch):
if webChannelList:
webChannelList.sort(key=lambda x: x.lower())
self.serienRecChannelList = []
if len(webChannelList) != 0:
self['title'].setText("Erstelle Sender-Liste...")
# Get existing channels from database
dbChannels = self.database.getChannelPairs()
if autoMatch:
# Get all unassigned web channels and try to find the STB channel equivalent
# Update only matching channels in list
#sql = "UPDATE OR IGNORE Channels SET STBChannel=?, ServiceRef=?, Erlaubt=? WHERE LOWER(WebChannel)=?"
unassignedWebChannels = self.getUnassignedWebChannels(
dbChannels)
channels = []
for webChannel in unassignedWebChannels:
# Unmapped web channel
(servicename, serviceref
) = self.findWebChannelInSTBChannels(webChannel)
if servicename and serviceref:
channels.append((servicename, serviceref, 1,
webChannel.lower()))
self.serienRecChannelList.append(
(webChannel, servicename, "", "1"))
self.database.updateChannels(channels)
self.changesMade = True
else:
# Get all new web channels (missing in SR database)
(newWebChannels,
removedWebChannels) = self.getMissingWebChannels(
webChannelList, dbChannels)
# Delete remove channels
if removedWebChannels:
SRLogger.writeLog(
"Folgende Sender wurden bei Wunschliste nicht mehr gefunden, die Zuordnung im SerienRecorder wurde gelöscht:\n"
+ "\n".join(removedWebChannels), True)
self.session.open(
MessageBox,
"Folgende Sender wurden bei Wunschliste nicht mehr gefunden,\ndie Zuordnung im SerienRecorder wurde gelöscht:\n\n"
+ "\n".join(removedWebChannels),
MessageBox.TYPE_INFO,
timeout=10)
for webChannel in removedWebChannels:
self.selected_sender = webChannel
self.channelDelete(True)
if not newWebChannels:
SRLogger.writeLog(
"Die SerienRecorder Senderliste ist aktuell, es wurden keine neuen Sender bei Wunschliste gefunden."
)
self.session.open(
MessageBox,
"Die SerienRecorder Senderliste ist aktuell,\nes wurden keine neuen Sender bei Wunschliste gefunden.",
MessageBox.TYPE_INFO,
timeout=10)
self.showChannels()
else:
newChannelsMessage = "Folgende Sender wurden neu bei Wunschliste gefunden:\n" + "\n".join(
newWebChannels)
SRLogger.writeLog(newChannelsMessage, True)
self.session.open(
MessageBox,
"Folgende Sender wurden neu bei Wunschliste gefunden,\nsie wurden am Ende der Liste eingefügt:\n\n"
+ "\n".join(newWebChannels),
MessageBox.TYPE_INFO,
timeout=10)
channels = []
for webChannel in newWebChannels:
channels.append((webChannel, "", "", 0))
self.serienRecChannelList.append(
(webChannel, "", "", "0"))
self.database.addChannels(channels)
else:
print "[SerienRecorder] webChannel list leer."
if len(self.serienRecChannelList) != 0:
self.chooseMenuList.setList(
map(self.buildList, self.serienRecChannelList))
else:
print "[SerienRecorder] Fehler bei der Erstellung der SerienRecChlist."
else:
print "[SerienRecorder] get webChannel error."
self['title'].setText("Wunschliste-Sender / STB-Sender")
@staticmethod
def getMissingWebChannels(webChannels, dbChannels):
added = []
removed = []
dbWebChannels = [x[0] for x in dbChannels]
# append missing (new) channels
for webChannel in webChannels:
if webChannel not in [
dbWebChannel for dbWebChannel in dbWebChannels
]:
added.append(webChannel.encode('utf-8'))
# append removed channels
for dbWebChannel in dbWebChannels:
if dbWebChannel not in [webChannel for webChannel in webChannels]:
removed.append(dbWebChannel)
return added, removed
@staticmethod
def getUnassignedWebChannels(dbChannels):
result = []
#append unassigned
for x in dbChannels:
if not x[1]:
result.append(x[0])
return result
def findWebChannelInSTBChannels(self, webChannel):
result = (None, None)
channelFound = False
# First try to find the HD version
webChannelHD = webChannel + " HD"
for servicename, serviceref in self.stbChannelList:
self.sequenceMatcher.set_seqs(webChannelHD.lower(),
servicename.lower())
ratio = self.sequenceMatcher.ratio()
if ratio >= 0.98:
result = (servicename, serviceref)
channelFound = True
break
if not channelFound:
for servicename, serviceref in self.stbChannelList:
self.sequenceMatcher.set_seqs(webChannel.lower(),
servicename.lower())
ratio = self.sequenceMatcher.ratio()
if ratio >= 0.98:
result = (servicename, serviceref)
break
return result
@staticmethod
def buildList(entry):
from SerienRecorder import serienRecMainPath
(webSender, stbSender, altstbSender, status) = entry
if int(status) == 0:
imageStatus = "%simages/minus.png" % serienRecMainPath
else:
imageStatus = "%simages/plus.png" % serienRecMainPath
return [
entry,
(eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, 10,
7 * skinFactor, 16 * skinFactor, 16 * skinFactor,
loadPNG(imageStatus)),
(eListboxPythonMultiContent.TYPE_TEXT, 40 * skinFactor, 0,
300 * skinFactor, 26 * skinFactor, 0,
RT_HALIGN_LEFT | RT_VALIGN_CENTER, webSender),
(eListboxPythonMultiContent.TYPE_TEXT, 350 * skinFactor, 0,
250 * skinFactor, 26 * skinFactor, 0,
RT_HALIGN_LEFT | RT_VALIGN_CENTER, stbSender),
(eListboxPythonMultiContent.TYPE_TEXT, 600 * skinFactor, 0,
250 * skinFactor, 26 * skinFactor, 0,
RT_HALIGN_LEFT | RT_VALIGN_CENTER, altstbSender,
parseColor('yellow').argb())
]
@staticmethod
def buildList_popup(entry):
(servicename, serviceref) = entry
return [
entry,
(eListboxPythonMultiContent.TYPE_TEXT, 5, 1, 250 * skinFactor,
25 * skinFactor, 0, RT_HALIGN_LEFT | RT_VALIGN_CENTER,
servicename)
]
def keyOK(self):
if self['list'].getCurrent() is None:
print "[SerienRecorder] Sender-Liste leer."
return
if self.modus == "list":
self.modus = "popup_list"
self['popup_list'].show()
self['popup_bg'].show()
if config.plugins.serienRec.selectBouquets.value:
self.stbChannelList = STBHelpers.buildSTBChannelList(
config.plugins.serienRec.MainBouquet.value)
else:
self.stbChannelList = STBHelpers.buildSTBChannelList()
self.stbChannelList.insert(0, ("", ""))
self.chooseMenuList_popup.setList(
map(self.buildList_popup, self.stbChannelList))
idx = 0
(stbChannel, altstbChannel) = self.database.getSTBChannel(
self['list'].getCurrent()[0][0])
if stbChannel:
try:
idx = zip(*self.stbChannelList)[0].index(stbChannel)
except:
pass
self['popup_list'].moveToIndex(idx)
self['title'].setText("Standard STB-Sender für %s:" %
self['list'].getCurrent()[0][0])
elif config.plugins.serienRec.selectBouquets.value:
if self.modus == "popup_list":
self.modus = "popup_list2"
self['popup_list'].hide()
self['popup_list2'].show()
self['popup_bg'].show()
self.stbChannelList = STBHelpers.buildSTBChannelList(
config.plugins.serienRec.AlternativeBouquet.value)
self.stbChannelList.insert(0, ("", ""))
self.chooseMenuList_popup2.setList(
map(self.buildList_popup, self.stbChannelList))
idx = 0
(stbChannel, altstbChannel) = self.database.getSTBChannel(
self['list'].getCurrent()[0][0])
if stbChannel:
try:
idx = zip(*self.stbChannelList)[0].index(altstbChannel)
except:
pass
self['popup_list2'].moveToIndex(idx)
self['title'].setText("alternativer STB-Sender für %s:" %
self['list'].getCurrent()[0][0])
else:
self.modus = "list"
self['popup_list'].hide()
self['popup_list2'].hide()
self['popup_bg'].hide()
check = self['list'].getCurrent()
if check is None:
print "[SerienRecorder] Sender-Liste leer (list)."
return
check = self['popup_list'].getCurrent()
if check is None:
print "[SerienRecorder] Sender-Liste leer (popup_list)."
return
chlistSender = self['list'].getCurrent()[0][0]
stbSender = self['popup_list'].getCurrent()[0][0]
stbRef = self['popup_list'].getCurrent()[0][1]
altstbSender = self['popup_list2'].getCurrent()[0][0]
altstbRef = self['popup_list2'].getCurrent()[0][1]
print "[SerienRecorder] select:", chlistSender, stbSender, stbRef, altstbSender, altstbRef
channels = []
if stbSender != "" or altstbSender != "":
channels.append(
(stbSender, stbRef, altstbSender, altstbRef, 1,
chlistSender.lower()))
else:
channels.append(
(stbSender, stbRef, altstbSender, altstbRef, 0,
chlistSender.lower()))
self.database.updateChannels(channels, True)
self.changesMade = True
self['title'].setText("Sender zuordnen")
self.showChannels()
else:
self.modus = "list"
self['popup_list'].hide()
self['popup_list2'].hide()
self['popup_bg'].hide()
if self['list'].getCurrent() is None:
print "[SerienRecorder] Sender-Liste leer (list)."
return
if self['popup_list'].getCurrent() is None:
print "[SerienRecorder] Sender-Liste leer (popup_list)."
return
chlistSender = self['list'].getCurrent()[0][0]
stbSender = self['popup_list'].getCurrent()[0][0]
stbRef = self['popup_list'].getCurrent()[0][1]
print "[SerienRecorder] select:", chlistSender, stbSender, stbRef
channels = []
if stbSender != "":
channels.append((stbSender, stbRef, 1, chlistSender.lower()))
else:
channels.append((stbSender, stbRef, 0, chlistSender.lower()))
self.database.updateChannels(channels)
self.changesMade = True
self['title'].setText("Sender zuordnen")
self.showChannels()
def keyRed(self):
if self['list'].getCurrent() is None:
print "[SerienRecorder] Sender-Liste leer."
return
if self.modus == "list":
chlistSender = self['list'].getCurrent()[0][0]
sender_status = self['list'].getCurrent()[0][2]
print sender_status
self.database.changeChannelStatus(chlistSender)
self['title'].instance.setForegroundColor(parseColor("red"))
self['title'].setText("")
self['title'].setText("Sender '- %s -' wurde geändert." %
chlistSender)
self.changesMade = True
self['title'].instance.setForegroundColor(parseColor("foreground"))
self.showChannels()
def keyGreen(self):
self.session.openWithCallback(self.channelReset, MessageBox,
"Senderliste aktualisieren?",
MessageBox.TYPE_YESNO)
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 keyBlue(self):
self.session.openWithCallback(
self.autoMatch, MessageBox,
"Es wird versucht, für alle nicht zugeordneten Wunschliste-Sender, einen passenden STB-Sender zu finden, dabei werden zunächst HD Sender bevorzugt.\n\nDies kann, je nach Umfang der Senderliste, einige Zeit (u.U. einige Minuten) dauern - bitte haben Sie Geduld!\n\nAutomatische Zuordnung jetzt durchführen?",
MessageBox.TYPE_YESNO)
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 keyRedLong(self):
check = self['list'].getCurrent()
if check is None:
print "[SerienRecorder] Serien Marker leer."
return
else:
self.selected_sender = self['list'].getCurrent()[0][0]
if config.plugins.serienRec.confirmOnDelete.value:
self.session.openWithCallback(
self.channelDelete,
MessageBox,
"Soll '%s' wirklich entfernt werden?" %
self.selected_sender,
MessageBox.TYPE_YESNO,
default=False)
else:
self.channelDelete(True)
def channelDelete(self, answer):
if not answer:
return
self.database.removeChannel(self.selected_sender)
self.changesMade = True
self['title'].instance.setForegroundColor(parseColor("red"))
self['title'].setText("Sender '- %s -' entfernt." %
self.selected_sender)
self.showChannels()
def resetChannelList(self):
if config.plugins.serienRec.confirmOnDelete.value:
self.session.openWithCallback(
self.channelDeleteAll,
MessageBox,
"Sollen wirklich alle Senderzuordnungen entfernt werden?",
MessageBox.TYPE_YESNO,
default=False)
else:
self.channelDeleteAll(True)
def channelDeleteAll(self, answer):
if not answer:
return
self.database.removeAllChannels()
self.changesMade = True
self['title'].instance.setForegroundColor(parseColor("red"))
self['title'].setText("Alle Senderzuordnungen entfernt.")
self.showChannels()
def keyLeft(self):
self[self.modus].pageUp()
def keyRight(self):
self[self.modus].pageDown()
def keyDown(self):
self[self.modus].down()
def keyUp(self):
self[self.modus].up()
def __onClose(self):
self.stopDisplayTimer()
def keyCancel(self):
if self.modus == "popup_list":
self.modus = "list"
self['popup_list'].hide()
self['popup_bg'].hide()
elif self.modus == "popup_list2":
self.modus = "list"
self['popup_list2'].hide()
self['popup_bg'].hide()
else:
if config.plugins.serienRec.refreshViews.value:
self.close(self.changesMade)
else:
self.close(False)