diff options
| -rw-r--r-- | src/db_sqlite.py | 145 | ||||
| -rw-r--r-- | src/globals.py | 3 | ||||
| -rw-r--r-- | src/main.py | 16 | ||||
| -rw-r--r-- | src/rule.py | 40 | ||||
| -rw-r--r-- | src/rules_dialog.py | 128 |
5 files changed, 329 insertions, 3 deletions
diff --git a/src/db_sqlite.py b/src/db_sqlite.py index fd06b5a..00f4edb 100644 --- a/src/db_sqlite.py +++ b/src/db_sqlite.py @@ -6,6 +6,7 @@ from PyQt5.QtSql import QSqlDatabase, QSqlQuery import src.globals as Globals from src.group import Group from src.entry import Entry +from src.rule import Rule def initDB(): """ @@ -40,6 +41,7 @@ def createTables(): # Erase database contents so that we don't have duplicates query.exec_("DROP TABLE groups") query.exec_("DROP TABLE entries") + query.exec_("DROP TABLE rules") query.exec_(""" CREATE TABLE groups ( @@ -65,6 +67,19 @@ def createTables(): hidden TINYINT(1) DEFAULT FALSE ) """) + + query.exec_(""" + CREATE TABLE rules ( + id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL, + entry_id REFERENCES entries (id), + before_after TINYINT(1) DEFAULT TRUE, + date TEXT NOT NULL, + color VARCHAR(255) DEFAULT NULL, + highlight VARCHAR(255) DEFAULT NULL + ) + """) + + print(database.lastError().text()) database.close() @@ -118,6 +133,22 @@ def loadFromTables(): record.field("done").value(), record.field("hidden").value())) + # Load rules + Globals.rules = [] # Reset local rules array + query.exec_("SELECT * FROM rules") + while query.next(): + record = query.record() + date_struct = strptime(record.field("date").value(), "%Y-%m-%d") + date = QDate(date_struct.tm_year, date_struct.tm_mon, date_struct.tm_mday) + Globals.rules.append( + Rule( + record.field("id").value(), + record.field("entry_id").value(), + "before" if record.field("before_after").value() == 0 else "after", + date, + record.field("color").value(), + record.field("highlight").value())) + database.close() def insertGroup(new_group): @@ -195,6 +226,47 @@ def insertEntry(new_entry): return output +def insertRule(new_rule): + """ + Insert rule to the database at Globals.db_path + """ + output = -1 + + database = QSqlDatabase.addDatabase("QSQLITE") # SQlite version 3 + database.setDatabaseName(Globals.db_path) + + if not database.open(): + print("Unable to open data source file.") + sys.exit(1) # Error out. TODO consider throwing a dialog instead + + query = QSqlQuery() + + query.prepare(""" + INSERT INTO rules (entry_id, before_after, date, color, highlight) VALUES (:e_id, :when, :date, :color, :highlight) + """) + query.bindValue(":e_id", new_rule.entry_id) + query.bindValue(":when", 0 if new_rule.when.lower() == "before" else 1) + query.bindValue(":date", "{0}-{1}-{2}".format( + new_rule.date.year(), + new_rule.date.month(), + new_rule.date.day())) + query.bindValue(":color", new_rule.color) + query.bindValue(":highlight", new_rule.highlight) + success = query.exec_() + # DEBUG + #print(query.lastError().text()) + #print(query.boundValues()) + #if success: + # print("Query succeeded") + #else: + # print("Query failed") + + output = query.lastInsertId() + + database.close() + + return output + def updateGroup(group): """ Update group by its id @@ -264,6 +336,46 @@ def updateEntry(entry): database.close() +def updateRule(rule): + """ + Update rule by its id + """ + database = QSqlDatabase.addDatabase("QSQLITE") # SQlite version 3 + database.setDatabaseName(Globals.db_path) + + if not database.open(): + print("Unable to open data source file.") + sys.exit(1) # Error out. TODO consider throwing a dialog instead + + query = QSqlQuery() + + query.prepare(""" + UPDATE rules SET + before_after = :when, + date = :date, + color = :color, + highlight = :highlight + WHERE id = :id + """) + query.bindValue(":when", 0 if rule.when.lower() == "before" else 1) + query.bindValue(":date", "{0}-{1}-{2}".format( + rule.date.year(), + rule.date.month(), + rule.date.day())) + query.bindValue(":color", rule.color) + query.bindValue(":highlight", rule.highlight) + query.bindValue(":id", rule.id) + success = query.exec_() + # DEBUG + #print(query.lastError().text()) + #print(query.boundValues()) + #if success: + # print("Query succeeded") + #else: + # print("Query failed") + + database.close() + def removeGroup(group_id): """ Remove a group by id from the database @@ -322,6 +434,31 @@ def removeEntry(entry_id): database.close() return output +def removeRule(rule_id): + """ + Remove a rule by id from the database + (we do not preserve rules, unlike groups and entries) + """ + database = QSqlDatabase.addDatabase("QSQLITE") # SQlite version 3 + database.setDatabaseName(Globals.db_path) + + if not database.open(): + print("Unable to open data source file.") + sys.exit(1) # Error out. TODO consider throwing a dialog instead + + query = QSqlQuery() + + # Set entry to hidden + query.prepare(""" + DELETE FROM rules WHERE id = ? + """) + query.addBindValue(rule_id) + query.exec_() + + output = query.numRowsAffected() + database.close() + return output + def cleanHidden(): """ Permanently delete removed/hidden groups and entries @@ -335,6 +472,14 @@ def cleanHidden(): query = QSqlQuery() + # Remove rules associated with hidden entries + query.exec_(""" + DELETE FROM rules WHERE id IN ( + SELECT rules.id FROM rules + INNER JOIN entries ON rules.entry_id = entries.id + WHERE entries.hidden = 1 + )""") + # Remove hidden entries query.exec_(""" DELETE FROM entries WHERE hidden = 1 diff --git a/src/globals.py b/src/globals.py index 61c6156..bb6f717 100644 --- a/src/globals.py +++ b/src/globals.py @@ -1,3 +1,4 @@ groups = [] entries = [] -db_path = "./test.db" +rules = [] +db_path = "" diff --git a/src/main.py b/src/main.py index 1b82204..008e310 100644 --- a/src/main.py +++ b/src/main.py @@ -12,6 +12,7 @@ from src.add_entry_form import addEntryForm from src.edit_entry_form import editEntryForm import src.globals as Globals import src.db_sqlite as DB +from src.rules_dialog import RulesDialog class AssignmentList(QMainWindow): def __init__(self): @@ -39,7 +40,6 @@ class AssignmentList(QMainWindow): self.preferences_act.setShortcut("Alt+Return") self.preferences_act.triggered.connect(self.preferences) file_menu.addAction(self.preferences_act) - # TODO implement reload of DB that works self.reload_act = QAction("Reload", self) self.reload_act.setShortcut("F5") self.reload_act.triggered.connect(self.reload) @@ -184,6 +184,12 @@ class AssignmentList(QMainWindow): Globals.entries = list(filter(lambda e: e.id != id, Globals.entries)) self.drawGroups() + def editRules(self, id): + pass + need_redraw = RulesDialog(id) + if need_redraw: + self.drawGroups() + def entryContextMenu(self, entry_id): menu = QMenu() @@ -191,6 +197,10 @@ class AssignmentList(QMainWindow): edit_entry_act.triggered.connect((lambda id: lambda: self.editEntry(id))(entry_id)) menu.addAction(edit_entry_act) + rules_act = QAction("Rules") + rules_act.triggered.connect((lambda id: lambda: self.editRules(id))(entry_id)) + menu.addAction(rules_act) + mark_done_act = QAction("Done", checkable=True) if list(filter(lambda e: e.id == entry_id, Globals.entries))[0].done: mark_done_act.setChecked(True) @@ -206,7 +216,6 @@ class AssignmentList(QMainWindow): def preferences(self): # TODO not sure if this is working exactly how I think it does, but it works need_reload = PreferencesDialog() - print(need_reload) if need_reload: self.reload() @@ -238,6 +247,9 @@ class AssignmentList(QMainWindow): # Sort the entries Globals.entries = sorted(Globals.entries, key=lambda e: (e.parent_id, (e.due if e.due else QDate.currentDate()), e.done, e.id)) + # Sort the rules + Globals.rules = sorted(Globals.rules, key=lambda r: (r.id)) + # Create columns as vertical boxes column_left = QVBoxLayout() column_right = QVBoxLayout() diff --git a/src/rule.py b/src/rule.py new file mode 100644 index 0000000..6ecf7d7 --- /dev/null +++ b/src/rule.py @@ -0,0 +1,40 @@ + +from PyQt5.QtCore import QDate +from PyQt5.QtWidgets import QComboBox, QDateTimeEdit, QHBoxLayout, QLineEdit + + +class Rule: + def __init__(self, id, entry_id, when, date, color = "", highlight = ""): + self.id = id + self.entry_id = entry_id + self.when = when + self.date = date + self.color = color + self.highlight = highlight + + def buildLayout(self): + output = QHBoxLayout() + + when_widget = QComboBox() + when_widget.addItems(["Before", "After"]) + when_widget.setCurrentIndex(0 if self.when.lower() == "before" else 1) + output.addWidget(when_widget) + + date_widget = QDateTimeEdit(QDate.currentDate()) + date_widget.setDisplayFormat("MM/dd/yyyy") + date_widget.setDate(self.date) + output.addWidget(date_widget) + + output.addStretch() + + # TODO Consider making this a color selector widget + color_widget = QLineEdit() + color_widget.setPlaceholderText("Color") + output.addWidget(color_widget) + + # TODO Consider making this a color selector widget + highlight_widget = QLineEdit() + highlight_widget.setPlaceholderText("Highlight") + output.addWidget(highlight_widget) + + return output diff --git a/src/rules_dialog.py b/src/rules_dialog.py new file mode 100644 index 0000000..0980fdd --- /dev/null +++ b/src/rules_dialog.py @@ -0,0 +1,128 @@ +import sys +from PyQt5.QtCore import QDate +from PyQt5.QtWidgets import QApplication, QDialog, QHBoxLayout, QPushButton, QScrollArea, QVBoxLayout +from src.config import Config +from src.rule import Rule +import src.db_sqlite as DB +import src.globals as Globals + +class RulesDialog(QDialog): + """ + Show the list of rules associated with an entry + """ + def __init__(self, entry_id): + super().__init__() + + self.entry_id = entry_id + # class globals + self.config = Config() + self.relevant_rules = self.getRelevantRules() + + self.initializeUI() + + def initializeUI(self): + self.resize(500, 320) + self.setWindowTitle("Rules") + self.displayWidgets() + self.exec() + + def displayWidgets(self): + main_layout = QVBoxLayout() + main_layout_scroll_area = QScrollArea() + main_layout_scroll_area.setWidgetResizable(True) + main_layout_scroll_area.setLayout(main_layout) + + self.rules_layout = QVBoxLayout() + self.drawRules() + main_layout.addLayout(self.rules_layout) + + main_layout.addStretch() + # Create Close and Save buttons + buttons_hbox = QHBoxLayout() + buttons_hbox.addStretch() + + close_button = QPushButton("Close", self) + close_button.clicked.connect(self.close) + buttons_hbox.addWidget(close_button) + + save_button = QPushButton("Save", self) + save_button.clicked.connect(self.save) + buttons_hbox.addWidget(save_button) + + main_layout.addLayout(buttons_hbox) + self.setLayout(main_layout) + + def drawRules(self): + # Remove all children from layout + def recursiveClear(layout): + while layout.count(): + child = layout.takeAt(0) + if child.widget(): + child.widget().deleteLater() + elif child.layout(): + recursiveClear(child) + + recursiveClear(self.rules_layout) + + # Draw each rule + self.r_layouts_dict = {} # Use to help update things in the save() function + for r in self.relevant_rules: + r_layout = r.buildLayout() + self.r_layouts_dict[r.id] = r_layout + del_button = QPushButton("Delete", self) + del_button.clicked.connect((lambda id: lambda: self.deleteRule(id))(r.id)) + r_layout.addWidget(del_button) + self.rules_layout.addLayout(r_layout) + + # Draw a button to add rules + rules_buttons_hbox = QHBoxLayout() + add_rule_button = QPushButton("Add Rule", self) + add_rule_button.clicked.connect(self.addRule) + rules_buttons_hbox.addWidget(add_rule_button) + rules_buttons_hbox.addStretch() + self.rules_layout.addLayout(rules_buttons_hbox) + + def addRule(self): + self.apply() + + new_rule = Rule(0, self.entry_id, "before", QDate.currentDate()) + new_rule_id = DB.insertRule(new_rule) + new_rule.id = new_rule_id + Globals.rules.append(new_rule) + self.relevant_rules = self.getRelevantRules() + self.drawRules() + + def deleteRule(self, rule_id): + DB.removeRule(rule_id) + Globals.rules = list(filter(lambda r: r.id != rule_id, Globals.rules)) + self.relevant_rules = self.getRelevantRules() + self.drawRules() + + def getRelevantRules(self): + return list(filter(lambda r: r.entry_id == self.entry_id, Globals.rules)) + + def apply(self): + for id, layout in self.r_layouts_dict.items(): + updated_rule = Rule( + id, + self.entry_id, + layout.itemAt(0).widget().currentText(), + layout.itemAt(1).widget().date(), + layout.itemAt(3).widget().text(), + layout.itemAt(4).widget().text()) + DB.updateRule(updated_rule) + Globals.rules = list(filter(lambda r: r.id != id, Globals.rules)) + Globals.rules.append(updated_rule) + + def save(self): + """ + Save any existing rules. Added rules are automatically saved, + but changing rules is not, hence the need for a manual save + """ + self.apply() + self.done(1) + +if __name__ == "__main__": + app = QApplication(sys.argv) + window = RulesDialog() + sys.exit(app.exec_()) |