def __init__(self, databasePath): """Creates a new instance of TrainObserver. @param databasePath Path to the DatabaseBackend that shall be used for observation.""" self._db = DatabaseBackend(databasePath) self._interval = 1 * 60# query every two minutes self._lookAhead = 2 # query trains starting in two minutes self._connections = self._db.connectionsAsList() self._start()
def _setupAttributes(self): """Sets up all private attributes.""" self._db = DatabaseBackend(dbpath) self._trainFilter = TrainFilter(self) self._overviewModel = OverviewModel(self._db, self.treeOverview) self._overviewModel.setFilter(self._trainFilter) self.treeOverview.setModel(self._overviewModel) self._setupStatsTimer() self._connectSignals() self._populateProductFilter() self._populateConnectionsFilter()
def setPermission(db, user, perms): db.c.execute("UPDATE users SET permission=? WHERE name=?", (perms, user)) @style.async def setRole(db, user, role): db.c.execute("UPDATE users SET role=? WHERE name=?", (role, user)) @style.queue def listUsers(db): db.c.execute('SELECT name FROM users') users = [] for row in db.c: users.append(row[0]) return users @style.queue def getAllUserData(db): db.c.execute("SELECT name, permission, role, template, email FROM users") user = {} for r in db.c: user[r[0]] = {"permission": r[1], "role": r[2], "template": r[3], "email": r[4]} return user @style.queue def removeUser(db, user): db.c.execute('DELETE FROM users WHERE name=?', (user,)) DatabaseBackend.registerSub(UserMethods)
@style.queue def listUsers(db): db.c.execute('SELECT name FROM users') users = [] for row in db.c: users.append(row[0]) return users @style.queue def getAllUserData(db): db.c.execute( "SELECT name, permission, role, template, email FROM users") user = {} for r in db.c: user[r[0]] = { "permission": r[1], "role": r[2], "template": r[3], "email": r[4] } return user @style.queue def removeUser(db, user): db.c.execute('DELETE FROM users WHERE name=?', (user, )) DatabaseBackend.registerSub(UserMethods)
class DBDD(QMainWindow, Ui_MainWindow): def __init__(self, dbpath, parent=None): """Creates a new instance of DBDD. @param dbpath Path to the dbdd database backend. @param parent Qt Parent.""" super(DBDD, self).__init__(parent) self.setupUi(self) self._setupAttributes() self._updateStats() def _setupAttributes(self): """Sets up all private attributes.""" self._db = DatabaseBackend(dbpath) self._trainFilter = TrainFilter(self) self._overviewModel = OverviewModel(self._db, self.treeOverview) self._overviewModel.setFilter(self._trainFilter) self.treeOverview.setModel(self._overviewModel) self._setupStatsTimer() self._connectSignals() self._populateProductFilter() self._populateConnectionsFilter() def _setupStatsTimer(self): """Sets up the timer that is used to refresh the statistics.""" self._statsTimer = QTimer(self) self._statsTimer.setInterval(10 * 1000) # update every 10 seconds self._statsTimer.timeout.connect(self._updateStats) self._statsTimer.start() def _connectSignals(self): """Sets up all signal/slot connections.""" self._trainFilter.filterChanged.connect(self._updateStats) self.buttonAddConnection.clicked.connect(self.showAddConnectionDialog) self.checkBoxConnectionFilter.toggled.connect(self._updateFilter) self.checkBoxDateFilter.toggled.connect(self._updateFilter) self.checkBoxTimeFilter.toggled.connect(self._updateFilter) self.checkBoxProductFilter.toggled.connect(self._updateFilter) self.checkBoxDelayFilter.toggled.connect(self._updateFilter) self.comboBoxConnections.currentIndexChanged.connect(self._updateFilter) self.comboBoxProducts.currentIndexChanged.connect(self._updateFilter) self.timeEditFrom.timeChanged.connect(self._updateFilter) self.timeEditTo.timeChanged.connect(self._updateFilter) self.dateEditFrom.dateChanged.connect(self._updateFilter) self.dateEditTo.dateChanged.connect(self._updateFilter) self.spinBoxDelay.valueChanged.connect(self._updateFilter) self.action_Create_Report.triggered.connect(self.showReportDialog) self.buttonCreateReport.clicked.connect(self.showReportDialog) def generateReport(self, connections): """Generates a report for the given connections.""" gen = ReportGenerator(self._db, connections) gen.doit() def showReportDialog(self): """Shows a dialog that lets the user generate a report.""" d = DialogCreateReport(self._db, self) ret = d.exec_() if ret == DialogCreateReport.Accepted: cons = d.getSelectedConnections() if len(cons) > 0: self.generateReport(cons) else: msg = QMessageBox() msg.setText(self.tr("No connections selected")) msg.setIcon(QMessageBox.Critical) msg.exec_() def showAddConnectionDialog(self): """Shows a dialog which lets the user add new connections.""" d = DialogAddConnection(self) ret = d.exec_() if ret == DialogAddConnection.Accepted: self._db.addConnection(d.startStation(), d.endStation()) self._populateConnectionsFilter() self._connectionsModel.reset() def _updateFilter(self): """Updates the TrainFilter. Since the OverviewModel uses a reference of this TrainFilter, all changes here will automatically take effect in the OverviewModel.""" fil = None if self.checkBoxConnectionFilter.checkState() == Qt.Checked: fil = self.comboBoxConnections.itemData(self.comboBoxConnections.currentIndex()) self._trainFilter.setConnectionFilter(fil) fil = None if self.checkBoxDateFilter.checkState() == Qt.Checked: f, t = self.dateEditFrom.date(), self.dateEditTo.date() fil = ( (".".join([str(f.day()), str(f.month()), str(f.year())])), (".".join([str(t.day()), str(t.month()), str(t.year())])), ) self._trainFilter.setDateFilter(fil) fil = None if self.checkBoxTimeFilter.checkState() == Qt.Checked: f, t = self.timeEditFrom.time(), self.timeEditTo.time() f = strptime(":".join([str(f.hour()), str(f.minute())]), "%H:%M") t = strptime(":".join([str(t.hour()), str(t.minute())]), "%H:%M") fil = (f, t) self._trainFilter.setTimeFilter(fil) fil = None if self.checkBoxProductFilter.checkState() == Qt.Checked: fil = self.comboBoxProducts.currentText() self._trainFilter.setProductFilter(fil) fil = None if self.checkBoxDelayFilter.checkState() == Qt.Checked: fil = self.spinBoxDelay.value() self._trainFilter.setDelayFilter(fil) def _updateStats(self): """Queries the DatabaseBackend, creates statistics and displays them. """ trains = self._db.getTrains() totalOnTime = 0 totalDelayed = 0 totalDelay = 0 totalLogged = 0 for t in trains: totalLogged += 1 if not t.delay() is None: totalDelay += t.delay() totalDelayed += 1 else: totalOnTime += 1 if totalLogged > 0: self.labelTotalLogged.setText(str(totalLogged)) self.labelTotalOnTime.setText(str(totalOnTime)) self.labelTotalDelayed.setText(str(totalDelayed)) self.labelOnTimePercentage.setText(str(100.0 - float(totalDelayed) / float(totalLogged) * 100.0) + "%") self.labelTotalDelay.setText(str(totalDelay)) self._updateFilteredStats() def _updateFilteredStats(self): """Updates the stats for the currently selected connection.""" self.labelTotalLoggedConnection.setText("") self.labelTotalOnTimeConnection.setText("") self.labelTotalDelayedConnection.setText("") self.labelOnTimePercentageConnection.setText("") self.labelTotalDelayConnection.setText("") self.labelConnection.setText("") con = self._trainFilter.connectionFilter() if not con is None: self.labelConnection.setText("{0} -> {1}".format(con[0], con[1])) else: self.labelConnection.setText("All Connections") trains = self._db.getTrainsFiltered(self._trainFilter) totalOnTime = 0 totalDelayed = 0 totalDelay = 0 totalLogged = 0 for t in trains: totalLogged += 1 if not t.delay() is None: totalDelay += t.delay() totalDelayed += 1 else: totalOnTime += 1 if totalLogged > 0: self.labelTotalLoggedConnection.setText(str(totalLogged)) self.labelTotalOnTimeConnection.setText(str(totalOnTime)) self.labelTotalDelayedConnection.setText(str(totalDelayed)) self.labelOnTimePercentageConnection.setText( str(100.0 - float(totalDelayed) / float(totalLogged) * 100.0) + "%" ) self.labelTotalDelayConnection.setText(str(totalDelay)) def _populateConnectionsFilter(self): """Retrieves all connections from the database and populates the connections combobox.""" self.comboBoxConnections.clear() for c in self._db.getConnections(): self.comboBoxConnections.addItem(c[0] + " -> " + c[1], c) def _populateProductFilter(self): """Retrieves all product strings from the database and populates the product combobox.""" products = {} for t in self._db.getTrains(): products[t.product()] = True for p in products.keys(): self.comboBoxProducts.addItem(p)
class TrainObserver(object): """This class queries reiseauskunft.bahn.de at a fixed interval to for all trains that travel on the travel connections that are stored in the DatabaseBackend. It determines if Trains are delayed or not and stores the result in the DatabaseBackend. """ def __init__(self, databasePath): """Creates a new instance of TrainObserver. @param databasePath Path to the DatabaseBackend that shall be used for observation.""" self._db = DatabaseBackend(databasePath) self._interval = 1 * 60# query every two minutes self._lookAhead = 2 # query trains starting in two minutes self._connections = self._db.connectionsAsList() self._start() def _start(self): """Starts the observation process.""" lastTrains = [] #remembers the trains that were retrieved last time for i in range(len(self._connections)): lastTrains.append([]) firstRun = True while True: print "Checking", len(self._connections), "connections" concnt = 0 for c in self._connections: tmp = localtime(time() + self._lookAhead * 60) departure = strftime("%H:%M", tmp) date = strftime("%d.%m.%Y", localtime()) trains = getTrains(c[0], c[1], date, departure) tl = [] trainsToProcess = list(lastTrains[concnt]) for t in trains: tl.append(t) if not t.delay() is None: try: print "Detected delayed train: {0} -> {1} ({2}): {3}".\ format(t.start(), t.end(), t.product(), "Start: {0}, delay: {1}".format( t.departure(), t.delay())) except: pass self.trainProcessed(t, trainsToProcess) if not firstRun: # are there trains left to be processed? # if so, add them to the database, because they left the # station for t in trainsToProcess: print "Adding train ", t.start(), t.end(), t.departure() self._db.addTrain(t) lastTrains[concnt] = tl concnt += 1 firstRun = False sleep(self._interval) self._connections = self._db.connectionsAsList() def trainProcessed(self, train, trains): """Checks if the train, that is processed is in the list of trains that are expected to be processed. If so, it is removed from the list. """ for t in trains: if t.departure() == train.departure() and\ t.start() == train.start() and\ t.end() == train.end(): trains.remove(t) return