Add possibility to create a new filter

src/filter_editor.py

@@ -1,10 +1,10 @@
 from datetime import datetime
-from typing import Dict
+from typing import Dict, Tuple, Callable
 
 from PySide6.QtCore import Qt
 from PySide6.QtWidgets import QDialog, QLineEdit, QCheckBox, QDateEdit, QSpinBox
 
-from src.datatypes import QuestionParameters
+from src.datatypes import QuestionParameters, FilterOption
 from src.ui_filter_editor import Ui_FilterEditor
 
 
@@ -52,3 +52,45 @@ def update_filteroptions(self, index):
             return
 
         self.ui.gridLayout.addWidget(self.filter, 2, 1, 1, 1)
+
+    def create_filter(self) -> Tuple[str, Callable]:
+        # ('answer_text', lambda x: 'FaD' in x)
+        index = self.ui.combobox_column.currentIndex()
+        dict_key, parameters = list(self.filter_configuration.items())[index]
+        parameters = parameters  # type: QuestionParameters
+
+        filter_option = parameters.filter_options[self.ui.combobox_filteroption.currentIndex()]
+
+        if parameters.datatype == str:
+            value = self.filter.text()
+        elif parameters.datatype == bool:
+            value = self.filter.isChecked()
+        elif parameters.datatype == datetime:
+            value = self.filter.date()
+        elif parameters.datatype == int:
+            value = self.filter.value()
+        else:
+            raise ValueError('Invalid datatype!')
+
+        if filter_option == FilterOption.smaller_equal:
+            def filter_callable(x):
+                return value <= x
+        elif filter_option == FilterOption.smaller:
+            def filter_callable(x):
+                return value < x
+        elif filter_option == FilterOption.larger_equal:
+            def filter_callable(x):
+                return value >= x
+        elif filter_option == FilterOption.larger:
+            def filter_callable(x):
+                return value > x
+        elif filter_option == FilterOption.equal:
+            def filter_callable(x):
+                return value == x
+        elif filter_option == FilterOption.contains:
+            def filter_callable(x):
+                return value in x
+        else:
+            raise ValueError('Invalid FilterOption!')
+
+        return dict_key, filter_callable

src/main_application.py

@@ -1,6 +1,6 @@
 import webbrowser
 from enum import Enum, auto
-from typing import List, Dict
+from typing import List, Dict, Callable
 from typing import Tuple
 
 import markdown2
@@ -195,12 +195,13 @@ def add_filter(self):
         elif return_val == QMessageBox.Save:
             print("Saved")
         else:
+            self.filter_column(editor.create_filter())
             print("Closed")
 
-    def filter_column(self, column, keyword, mode=FilterMode.Include):
+    def filter_column(self, filter_tuple: Tuple[str, Callable], mode=FilterMode.Include):
         # RuleSortFilterProxyModel.add_filter(('answer_text', lambda x: 'FaD' in x))
         # RuleSortFilterProxyModel.add_filter(('last_edited', lambda x: datetime.date.fromisoformat('2020-06-01') < x))
-
+        RuleSortFilterProxyModel.add_filter(filter_tuple)
         for (filter_model, _) in self.ruletabs.values():
             filter_model = filter_model  # type: RuleSortFilterProxyModel
             filter_model.invalidateFilter()