Save created Regeltests within the database

RegeltestCreator.pyw

@@ -15,7 +15,7 @@ logging.getLogger().setLevel(log_level)
 def run():
     app = QApplication(sys.argv)
     main_window = MainWindow()
-    main_window.create_ruletabs(db.get_rulegroups())
+    main_window.create_ruletabs(db.get_all_rulegroups())
     main_window.show()
     exit_code = app.exec()
     db.close_connection()

src/database.py

@@ -71,13 +71,17 @@ def clear_database(self):
         Base.metadata.drop_all(self.engine)
         self.initialized = False
 
-    def get_rulegroups(self):
+    def add_object(self, datatype_object: Base):
+        self.session.add(datatype_object)
+        self.session.commit()
+
+    def get_all_rulegroups(self):
         rulegroups = self.session.query(QuestionGroup).all()
         return rulegroups
 
-    def add_rulegroup(self, rulegroup):
-        self.session.add(rulegroup)
-        self.session.commit()
+    def get_rulegroup(self, rulegroup_index: int):
+        rulegroup = self.session.query(QuestionGroup).where(QuestionGroup.id == rulegroup_index).first()
+        return rulegroup
 
     def get_question_multiplechoice(self):
         return_dict = []
@@ -86,20 +90,10 @@ def get_question_multiplechoice(self):
                 (question, self.session.query(MultipleChoice).where(MultipleChoice.question == question).all())]
         return return_dict
 
-    def update_question_set(self, question: Question):
-        self.session.add(question)
-        self.session.commit()
-        signature = question.signature
-        return signature
-
     def get_question(self, signature: str):
         question = self.session.query(Question).where(Question.signature == signature).first()
         return question
 
-    def get_rulegroup(self, rulegroup_index: int):
-        rulegroup = self.session.query(QuestionGroup).where(QuestionGroup.id == rulegroup_index).first()
-        return rulegroup
-
     def get_questions_by_foreignkey(self, rulegroup_id: int, mchoice=None, randomize: bool = False):
         questions = self.session.query(Question).where(Question.group_id == rulegroup_id)
         if mchoice is not None:
@@ -143,7 +137,7 @@ def get_new_rulegroup_id(self):
         return return_val
 
     def get_rulegroup_config(self) -> List[Tuple[QuestionGroup, int, int]]:
-        rulegroups = self.get_rulegroups()
+        rulegroups = self.get_all_rulegroups()
         return [(rulegroup,
                  len(self.get_questions_by_foreignkey(rulegroup_id=rulegroup.id, mchoice=False)),
                  len(self.get_questions_by_foreignkey(rulegroup_id=rulegroup.id, mchoice=True))) for rulegroup in

src/document_builder.py

@@ -1,11 +1,11 @@
 import os.path
 import random
-from typing import List, Tuple
+from typing import List
 
 from PIL import Image
 from reportlab.lib.styles import ParagraphStyle
 from reportlab.lib.units import inch, mm
-from reportlab.lib.utils import simpleSplit
+from reportlab.lib.utils import simpleSplit, ImageReader
 from reportlab.pdfgen.canvas import Canvas
 from reportlab.platypus import Flowable, SimpleDocTemplate, Spacer, Paragraph
 from reportlab.rl_config import defaultPageSize
@@ -132,7 +132,8 @@ def create_radio(index, text, x, y, height):
 class TitleFlowable(Flowable):
     canv: Canvas
 
-    def __init__(self, title_line, title_icon, username="", fontName='Helvetica', image_scalefactor=1, titleSize=14,
+    def __init__(self, title_line, title_icon: Image, username="", fontName='Helvetica', image_scalefactor=1,
+                 titleSize=14,
                  nameSize=10, x=0, y=0, width=4 / 5 * PAGE_WIDTH, max_points=30):
         super().__init__()
         self.x = x
@@ -141,19 +142,18 @@ def __init__(self, title_line, title_icon, username="", fontName='Helvetica', im
         self.height = 100
         self.paragraph_style = ParagraphStyle('DefaultStyle', fontName=fontName, fontSize=nameSize, alignment=0)
         self.title_style = ParagraphStyle('DefaultStyle', fontName=fontName, fontSize=titleSize, alignment=1)
-        self.title_icon = title_icon
         self.title_line = title_line
         self.max_points = max_points
         self.username = username
-        if title_icon:
-            self.image_size = Image.open(title_icon).size
-            image_size = Image.open(title_icon).size
-            ratio = image_size[0] / image_size[1]
+        self.title_icon = title_icon
+        if self.title_icon:
+            ratio = title_icon.size[0] / title_icon.size[1]
             self.image_size = (image_scalefactor * base_image_size * ratio, image_scalefactor * base_image_size / ratio)
 
     def draw(self):
         if self.title_icon:
-            self.canv.drawImage(self.title_icon, self.x, 30, width=self.image_size[0], height=self.image_size[1],
+            self.canv.drawImage(ImageReader(self.title_icon), self.x, 30, width=self.image_size[0],
+                                height=self.image_size[1],
                                 mask='auto')
         question = Paragraph(self.title_line, self.title_style)
         question.wrapOn(self.canv, 2 / 3 * self.width, self.height)
@@ -182,7 +182,7 @@ def draw(self):
                                              fontSize=self.paragraph_style.fontSize)
 
 
-def create_document(question_set: List[Tuple[Question, List[MultipleChoice]]], filename, title, icon_path=None,
+def create_document(questions: List[Question], filename, title, icon: Image = None,
                     solution_suffix='_LOESUNG', shuffle_mchoice=True, font_name='Helvetica', font_size=9):
     def page_setup(canvas, doc):
         canvas.saveState()
@@ -196,17 +196,18 @@ def page_setup(canvas, doc):
 
     doc_solution = SimpleDocTemplate(solution_path)
 
-    story_solution = [TitleFlowable(title, icon_path, username="Muster Lösung", max_points=len(question_set) * 2)]
-    story_question = [TitleFlowable(title, icon_path, max_points=len(question_set) * 2)]
+    story_solution = [TitleFlowable(title, icon, username="Muster Lösung", max_points=len(questions) * 2)]
+    story_question = [TitleFlowable(title, icon, max_points=len(questions) * 2)]
 
-    for i, (question, mchoice) in enumerate(question_set):
+    for i, question in enumerate(questions):
         random_state = random.getstate()
-        question_flow = QuestionFlowable(i + 1, question, mchoice, font_name, font_size, solution=False,
+        question_flow = QuestionFlowable(i + 1, question, question.multiple_choice, font_name, font_size,
+                                         solution=False,
                                          shuffle_mchoice=shuffle_mchoice, width=doc_question.width)
         story_question.append(question_flow)
         story_question.append(Spacer(1, 0.1 * inch))
         random.setstate(random_state)
-        question_flow = QuestionFlowable(i + 1, question, mchoice, font_name, font_size, solution=True,
+        question_flow = QuestionFlowable(i + 1, question, question.multiple_choice, font_name, font_size, solution=True,
                                          shuffle_mchoice=shuffle_mchoice, width=doc_solution.width)
         story_solution.append(question_flow)
         story_solution.append(Spacer(1, 0.1 * inch))

src/main_application.py

@@ -10,6 +10,7 @@
 
 import markdown2
 import requests
+from PIL import Image
 from PySide6.QtCore import QCoreApplication, Qt, Signal, QThread
 from PySide6.QtCore import QSortFilterProxyModel
 from PySide6.QtGui import QShortcut, QKeySequence
@@ -21,7 +22,7 @@
 from src.basic_config import app_version, check_for_update, display_name, is_bundled, app_dirs, base_path, \
     current_platform
 from src.database import db
-from src.datatypes import QuestionGroup, create_question_groups, create_questions_and_mchoice
+from src.datatypes import QuestionGroup, create_question_groups, create_questions_and_mchoice, Regeltest
 from src.filter_editor import FilterEditor
 from src.question_table import RulegroupView, RuleDataModel, RuleSortFilterProxyModel
 from src.regeltestcreator import RegeltestSaveDialog, RegeltestSetup
@@ -64,7 +65,7 @@ def save_dataset(parent: QWidget):
     QApplication.setOverrideCursor(Qt.WaitCursor)
     dataset = "<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>\n\
 <REGELTEST>\n<GRUPPEN>\n"
-    for rulegroup in db.get_rulegroups():
+    for rulegroup in db.get_all_rulegroups():
         dataset += rulegroup.export()
     dataset += "</GRUPPEN>\n"
     for question in db.get_question_multiplechoice():
@@ -280,7 +281,7 @@ def add_rulegroup(self):
                 self.ui.tabWidget.clear()
 
             rulegroup = QuestionGroup(id=editor.id, name=editor.name)
-            db.add_rulegroup(rulegroup)
+            db.add_object(rulegroup)
             self.create_ruletab(rulegroup)
 
     def _update_tabtitle(self, index):
@@ -294,7 +295,7 @@ def _display_setup_screen(self):
 
         def cleanup():
             self.ui.tabWidget.clear()
-            self.create_ruletabs(db.get_rulegroups())
+            self.create_ruletabs(db.get_all_rulegroups())
 
         setup_tab.action_done.connect(cleanup)
         self.ui.tabWidget.addTab(setup_tab, "Einrichten")
@@ -363,18 +364,23 @@ def refresh_column_filter(self):
             filter_model.invalidateFilter()
 
     def create_regeltest(self):
-        question_set = []
+        questions = []
         for signature in self.ui.regeltest_list.questions:
-            question_set += [
-                (db.get_question(signature), db.get_multiplechoice_by_foreignkey(signature))]
+            questions += [db.get_question(signature)]
         settings = RegeltestSaveDialog(self)
         settings.ui.title_edit.setFocus()
         result = settings.exec()
         output_path = settings.ui.output_edit.text()
-        if result:
+        if result == QDialog.Accepted:
             QApplication.setOverrideCursor(Qt.WaitCursor)
-            document_builder.create_document(question_set, output_path, settings.ui.title_edit.text(),
-                                             icon_path=settings.ui.icon_path_edit.text())
+            if settings.ui.icon_path_edit.text():
+                icon = Image.open(settings.ui.icon_path_edit.text())
+            else:
+                icon = None
+            db.add_object(Regeltest(title=settings.ui.title_edit.text(), description="", icon=icon.tobytes(),
+                                    questions=questions))
+            document_builder.create_document(questions, output_path, settings.ui.title_edit.text(),
+                                             icon=icon)
             QApplication.restoreOverrideCursor()
             webbrowser.open_new(output_path)
 

src/question_table.py

@@ -94,7 +94,7 @@ def data(self, index: Union[PySide6.QtCore.QModelIndex, PySide6.QtCore.QPersiste
     def setData(self, index: Union[PySide6.QtCore.QModelIndex, PySide6.QtCore.QPersistentModelIndex], value: Any,
                 role: int = ...) -> bool:
         if role == Qt.UserRole:
-            db.update_question_set(value)
+            db.add_object(value)
             self.questions[index.row()] = value
             return True
         return False
@@ -144,7 +144,7 @@ def insertRow(self, row: int,
         new_question.question_id = db.get_new_question_id(self.rulegroup.id)
         editor = QuestionEditor(new_question)
         if editor.exec() == QDialog.Accepted:
-            db.update_question_set(editor.question)
+            db.add_object(editor.question)
             self.questions.insert(row, editor.question)
             return True
         else: