excel2moodle 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

excel2moodle/question_types/cloze.py

@@ -5,6 +5,7 @@ All Answers are calculated off an equation using the same variables.
 """
 
 import logging
+import math
 import re
 from typing import Literal, overload
 
@@ -18,6 +19,7 @@ from excel2moodle.core.globals import (
 from excel2moodle.core.question import (
     ParametricQuestion,
     Parametrics,
+    QuestionData,
 )
 from excel2moodle.core.settings import Tags
 from excel2moodle.logger import LogAdapterQuestionID
@@ -67,7 +69,8 @@ class ClozePart:
             return
         if self.typ == "NFM":
             result = self.result.getResult(variant)
-            self._element.text = ClozeQuestionParser.getNumericAnsStr(
+            self._element.text = self.getNumericAnsStr(
+                self.question.rawData,
                 result,
                 self.question.rawData.get(Tags.TOLERANCE),
                 wrongSignCount=self.question.rawData.get(Tags.WRONGSIGNPERCENT),
@@ -99,16 +102,20 @@ class ClozePart:
         return f"{self.question.id}-{self.num}"
 
     @property
-    def points(self) -> float:
+    def points(self) -> int:
+        """Points of clozes can be only integers.
+
+        Otherwise the moodle import fails.
+        """
         if hasattr(self, "_points"):
             return self._points
-        return 0.0
+        return 0
         self.question.logger.error("Invalid call to points of unparsed cloze part")
-        return 0.0
+        return 0
 
     @points.setter
-    def points(self, points: float) -> None:
-        self._points = points if points > 0 else 0.0
+    def points(self, points: int) -> None:
+        self._points = max(0, points)
 
     @property
     def mcAnswerString(self) -> str:
@@ -131,6 +138,73 @@ class ClozePart:
     def __repr__(self) -> str:
         return f"Cloze Part {self.id}-{self.typ}"
 
+    @staticmethod
+    def getNumericAnsStr(
+        questionData: QuestionData,
+        result: float,
+        tolerance: float = 0.0,
+        points: int = 1,
+        wrongSignCount: int = 0,
+        wrongSignFeedback: str | None = None,
+    ) -> str:
+        """Generate the answer string from `result`.
+
+        Parameters.
+        ----------
+        wrongSignCount:
+            If the wrong sign `+` or `-` is given, how much of the points should be given.
+            Interpreted as percent.
+        tolerance:
+            The relative tolerance, as fraction
+
+        """
+        if wrongSignFeedback is None:
+            wrongSignFeedback = questionData.get(Tags.WRONGSIGNFB)
+        if wrongSignCount == 0:
+            wrongSignCount = questionData.get(Tags.WRONGSIGNPERCENT)
+        if tolerance == 0.0:
+            tolerance = questionData.get(Tags.TOLERANCE)
+        absTol = f":{round(result * tolerance, 3)}"
+        answerParts: list[str | float] = [
+            "{",
+            points,
+            ":NUMERICAL:=",
+            round(result, 3),
+            absTol,
+            "~%",
+            wrongSignCount,
+            "%",
+            round(result * (-1), 3),
+            absTol,
+            f"#{wrongSignFeedback}",
+            "}",
+        ]
+        answerPStrings = [str(part) for part in answerParts]
+        return "".join(answerPStrings)
+
+    @staticmethod
+    def getMCAnsStr(
+        true: list[str],
+        false: list[str],
+        points: int = 1,
+    ) -> str:
+        """Generate the answer string for the MC answers."""
+        truePercent: float = round(100 / len(true), 1)
+        falsePercent: float = round(100 / len(false), 1)
+        falseList: list[str] = [f"~%-{falsePercent}%{ans}" for ans in false]
+        trueList: list[str] = [f"~%{truePercent}%{ans}" for ans in true]
+        answerParts: list[str | float] = [
+            "{",
+            points,
+            ":MULTIRESPONSE:",
+        ]
+        answerParts.extend(trueList)
+        answerParts.extend(falseList)
+        answerParts.append("}")
+
+        answerPStrings = [str(part) for part in answerParts]
+        return "".join(answerPStrings)
+
 
 class ClozeQuestion(ParametricQuestion):
     """Cloze Question Type."""
@@ -146,13 +220,18 @@ class ClozeQuestion(ParametricQuestion):
         return len(self.questionParts)
 
     @property
-    def points(self) -> float:
-        pts: float = 0
-        if self.isParsed:
-            for p in self.questionParts.values():
-                pts = pts + p.points
-        else:
-            pts = self.rawData.get(Tags.POINTS)
+    def points(self) -> int:
+        """Points for the cloze question. The sum of all its parts points.
+
+        Returns only integer values.
+        """
+        pts: int = 0
+        if not self.isParsed:
+            msg = "The Cloze question has no points because it is not yet parsed"
+            logger.warning(msg)
+            return pts
+        for p in self.questionParts.values():
+            pts = pts + p.points
         return pts
 
     def getUpdatedElement(self, variant: int = 0) -> ET.Element:
@@ -232,17 +311,30 @@ class ClozeQuestionParser(NFMQuestionParser):
                 raise QNotParsedException(msg, self.question.id)
         if len(points) == 0:
             pts = round(self.rawInput.get(Tags.POINTS) / partsNum, 3)
+            point = self._roundClozePartPoints(pts)
             for part in parts.values():
-                part.points = pts
-        elif len(points) != partsNum:
+                part.points = point
+        else:
             logger.warning(
                 "Some Answer parts are missing the points, they will get the standard points"
             )
             for num, part in parts.items():
-                p = points.get(num)
-                part.points = p if p is not None else self.rawInput.get(Tags.POINTS)
+                part.points = self._roundClozePartPoints(points=points.get(num))
         self.question.questionParts = parts
 
+    def _roundClozePartPoints(self, points: float | None = None) -> int:
+        """Get the integer points for the cloze part."""
+        if points is None:
+            points = self.rawInput.get(Tags.POINTS)
+        corrPoints: int = round(points)
+        if not math.isclose(corrPoints, points):
+            logger.warning(
+                "Type cloze supports only integers as points. %s was round to %s",
+                points,
+                corrPoints,
+            )
+        return corrPoints
+
     @overload
     def _getPartValues(self, Tag: Literal[Tags.RESULT]) -> dict[int, str]: ...
     @overload
@@ -270,17 +362,18 @@ class ClozeQuestionParser(NFMQuestionParser):
         for partNum, part in self.question.questionParts.items():
             if part.typ == "NFM":
                 result = self.question.parametrics.getResult(1, partNum)
-                ansStr = self.getNumericAnsStr(
-                    result,
-                    self.rawInput.get(Tags.TOLERANCE),
-                    wrongSignCount=self.rawInput.get(Tags.WRONGSIGNPERCENT),
+                ansStr = ClozePart.getNumericAnsStr(
+                    self.rawInput,
+                    result=result,
                     points=part.points,
                 )
                 self.logger.info("NF answer part: %s ", ansStr)
                 logger.debug("Appended NF part %s result", partNum)
             elif part.typ == "MC":
-                ansStr = self.getMCAnsStr(
-                    part.trueAnswers, part.falseAnswers, points=part.points
+                ansStr = ClozePart.getMCAnsStr(
+                    part.trueAnswers,
+                    part.falseAnswers,
+                    points=part.points,
                 )
                 part.mcAnswerString = ansStr
                 logger.debug("Appended MC part %s: %s", partNum, ansStr)
@@ -311,63 +404,3 @@ class ClozeQuestionParser(NFMQuestionParser):
             raise QNotParsedException(msg, self.question.id)
         else:
             return int(num)
-
-    @staticmethod
-    def getNumericAnsStr(
-        result: float,
-        tolerance: float,
-        points: float = 1,
-        wrongSignCount: int = 50,
-        wrongSignFeedback: str = "your result has the wrong sign (+-)",
-    ) -> str:
-        """Generate the answer string from `result`.
-
-        Parameters.
-        ----------
-        wrongSignCount:
-            If the wrong sign `+` or `-` is given, how much of the points should be given.
-            Interpreted as percent.
-        tolerance:
-            The relative tolerance, as fraction
-
-        """
-        absTol = f":{round(result * tolerance, 3)}"
-        answerParts: list[str | float] = [
-            "{",
-            points,
-            ":NUMERICAL:=",
-            round(result, 3),
-            absTol,
-            "~%",
-            wrongSignCount,
-            "%",
-            round(result * (-1), 3),
-            absTol,
-            f"#{wrongSignFeedback}",
-            "}",
-        ]
-        answerPStrings = [str(part) for part in answerParts]
-        return "".join(answerPStrings)
-
-    @staticmethod
-    def getMCAnsStr(
-        true: list[str],
-        false: list[str],
-        points: float = 1,
-    ) -> str:
-        """Generate the answer string for the MC answers."""
-        truePercent: float = round(100 / len(true), 1)
-        falsePercent: float = round(100 / len(false), 1)
-        falseList: list[str] = [f"~%-{falsePercent}%{ans}" for ans in false]
-        trueList: list[str] = [f"~%{truePercent}%{ans}" for ans in true]
-        answerParts: list[str | float] = [
-            "{",
-            points,
-            ":MULTIRESPONSE:",
-        ]
-        answerParts.extend(trueList)
-        answerParts.extend(falseList)
-        answerParts.append("}")
-
-        answerPStrings = [str(part) for part in answerParts]
-        return "".join(answerPStrings)

excel2moodle/question_types/mc.py

@@ -12,7 +12,6 @@ from excel2moodle.core.globals import (
     Tags,
     TextElements,
     XMLTags,
-    feedbackStr,
 )
 from excel2moodle.core.parser import QuestionParser
 from excel2moodle.core.question import Picture, Question
@@ -46,11 +45,6 @@ class MCQuestionParser(QuestionParser):
 
     def __init__(self) -> None:
         super().__init__()
-        self.genFeedbacks = [
-            XMLTags.CORFEEDB,
-            XMLTags.PCORFEEDB,
-            XMLTags.INCORFEEDB,
-        ]
 
     def setup(self, question: MCQuestion) -> None:
         self.question: MCQuestion = question
@@ -76,9 +70,9 @@ class MCQuestionParser(QuestionParser):
             elementList[-1].append(text)
             if fraction < 0:
                 elementList[-1].append(
-                    eth.getFeedBEle(
+                    self.getFeedBEle(
                         XMLTags.ANSFEEDBACK,
-                        text=feedbackStr["wrong"],
+                        text=self.rawInput.get(Tags.FALSEFB),
                         style=TextElements.SPANRED,
                     ),
                 )
@@ -86,9 +80,9 @@ class MCQuestionParser(QuestionParser):
                     elementList[-1].append(self.falseImgs[i].element)
             elif fraction > 0:
                 elementList[-1].append(
-                    eth.getFeedBEle(
+                    self.getFeedBEle(
                         XMLTags.ANSFEEDBACK,
-                        text=feedbackStr["right"],
+                        text=self.rawInput.get(Tags.TRUEFB),
                         style=TextElements.SPANGREEN,
                     ),
                 )
@@ -135,3 +129,14 @@ class MCQuestionParser(QuestionParser):
             self.getAnsElementsList(falseAList, fraction=round(falsefrac, 4)),
         )
         return ansList
+
+    def parse(self) -> None:
+        super().parse()
+        feedBacks = {
+            XMLTags.CORFEEDB: Tags.TRUEFB,
+            XMLTags.PCORFEEDB: Tags.PCORRECFB,
+            XMLTags.INCORFEEDB: Tags.FALSEFB,
+        }
+        for feedb, tag in feedBacks.items():
+            self.tmpEle.append(self.getFeedBEle(feedb, text=self.rawInput.get(tag)))
+        self._finalizeParsing()

excel2moodle/question_types/nf.py

@@ -30,7 +30,7 @@ class NFQuestionParser(QuestionParser):
 
     def __init__(self) -> None:
         super().__init__()
-        self.genFeedbacks = [XMLTags.GENFEEDB]
+        self.feedBackList = {XMLTags.GENFEEDB: Tags.GENERALFB}
 
     def setup(self, question: NFQuestion) -> None:
         self.question: NFQuestion = question
@@ -41,3 +41,9 @@ class NFQuestionParser(QuestionParser):
         ansEle: list[ET.Element] = []
         ansEle.append(self.getNumericAnsElement(result=result))
         return ansEle
+
+    def _finalizeParsing(self) -> None:
+        self.tmpEle.append(
+            self.getFeedBEle(XMLTags.GENFEEDB, text=self.rawInput.get(Tags.GENERALFB))
+        )
+        return super()._finalizeParsing()

excel2moodle/question_types/nfm.py

@@ -22,6 +22,7 @@ class NFMQuestion(ParametricQuestion):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.answerElement: ET.Element
+        self.answerElementWrongSign: ET.Element
 
     def getUpdatedElement(self, variant: int = 1) -> ET.Element:
         """Update and get the Question Elements to reflect the version.
@@ -33,14 +34,16 @@ class NFMQuestion(ParametricQuestion):
         result = self.parametrics.getResult(variant)
         tolerance = round(self.rawData.get(Tags.TOLERANCE) * result, 3)
         self.answerElement.find(XMLTags.TEXT).text = str(result)
+        self.answerElementWrongSign.find(XMLTags.TEXT).text = str(result * (-1))
         self.answerElement.find(XMLTags.TOLERANCE).text = str(tolerance)
+        self.answerElementWrongSign.find(XMLTags.TOLERANCE).text = str(tolerance)
         return super().getUpdatedElement(variant)
 
 
 class NFMQuestionParser(QuestionParser):
     def __init__(self) -> None:
         super().__init__()
-        self.genFeedbacks = [XMLTags.GENFEEDB]
+        self.feedBackList = {XMLTags.GENFEEDB: Tags.GENERALFB}
         self.question: NFMQuestion
 
     def setup(self, question: NFMQuestion) -> None:
@@ -61,13 +64,14 @@ class NFMQuestionParser(QuestionParser):
         )
         self.question.parametrics.variables = variables
         self.question.answerElement = self.getNumericAnsElement()
-        return [self.question.answerElement]
+        self.question.answerElementWrongSign = self.getNumericAnsElement(
+            fraction=self.rawInput.get(Tags.WRONGSIGNPERCENT),
+            feedback=self.rawInput.get(Tags.WRONGSIGNFB),
+        )
+        return [self.question.answerElement, self.question.answerElementWrongSign]
 
-    # TODO: @jbosse3: Implement a new _setVariants() method, to show in treewidget
-    # def _setVariants(self, number: int) -> None:
-    #     self.question.variants = number
-    #     mvar = self.question.category.maxVariants
-    #     if mvar is None:
-    #         self.question.category.maxVariants = number
-    #     else:
-    #         self.question.category.maxVariants = min(number, mvar)
+    def _finalizeParsing(self) -> None:
+        self.tmpEle.append(
+            self.getFeedBEle(XMLTags.GENFEEDB, text=self.rawInput.get(Tags.GENERALFB))
+        )
+        return super()._finalizeParsing()

excel2moodle/ui/UI_exportSettingsDialog.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 ################################################################################
-## Form generated from reading UI file 'exportSettingsDialog.ui'
+## Form generated from reading UI file 'UI_exportSettingsDialog.ui'
 ##
 ## Created by: Qt User Interface Compiler version 6.9.1
 ##
@@ -43,38 +43,42 @@ class Ui_ExportDialog(object):
         self.label_9 = QLabel(ExportDialog)
         self.label_9.setObjectName(u"label_9")
 
-        self.formLayout_2.setWidget(1, QFormLayout.ItemRole.LabelRole, self.label_9)
+        self.formLayout_2.setWidget(2, QFormLayout.ItemRole.LabelRole, self.label_9)
 
         self.checkBoxIncludeCategories = QCheckBox(ExportDialog)
         self.checkBoxIncludeCategories.setObjectName(u"checkBoxIncludeCategories")
 
-        self.formLayout_2.setWidget(1, QFormLayout.ItemRole.FieldRole, self.checkBoxIncludeCategories)
+        self.formLayout_2.setWidget(2, QFormLayout.ItemRole.FieldRole, self.checkBoxIncludeCategories)
 
         self.label = QLabel(ExportDialog)
         self.label.setObjectName(u"label")
+        font = QFont()
+        font.setPointSize(12)
+        font.setBold(True)
+        self.label.setFont(font)
 
-        self.formLayout_2.setWidget(2, QFormLayout.ItemRole.LabelRole, self.label)
+        self.formLayout_2.setWidget(4, QFormLayout.ItemRole.LabelRole, self.label)
 
         self.btnExportFile = QPushButton(ExportDialog)
         self.btnExportFile.setObjectName(u"btnExportFile")
         self.btnExportFile.setMinimumSize(QSize(200, 0))
 
-        self.formLayout_2.setWidget(2, QFormLayout.ItemRole.FieldRole, self.btnExportFile)
+        self.formLayout_2.setWidget(4, QFormLayout.ItemRole.FieldRole, self.btnExportFile)
 
         self.line_2 = QFrame(ExportDialog)
         self.line_2.setObjectName(u"line_2")
         self.line_2.setFrameShape(QFrame.Shape.HLine)
         self.line_2.setFrameShadow(QFrame.Shadow.Sunken)
 
-        self.formLayout_2.setWidget(3, QFormLayout.ItemRole.LabelRole, self.line_2)
+        self.formLayout_2.setWidget(5, QFormLayout.ItemRole.LabelRole, self.line_2)
 
         self.label_2 = QLabel(ExportDialog)
         self.label_2.setObjectName(u"label_2")
-        font = QFont()
-        font.setPointSize(12)
-        self.label_2.setFont(font)
+        font1 = QFont()
+        font1.setPointSize(12)
+        self.label_2.setFont(font1)
 
-        self.formLayout_2.setWidget(4, QFormLayout.ItemRole.LabelRole, self.label_2)
+        self.formLayout_2.setWidget(6, QFormLayout.ItemRole.LabelRole, self.label_2)
 
         self.questionCount = QSpinBox(ExportDialog)
         self.questionCount.setObjectName(u"questionCount")
@@ -82,7 +86,7 @@ class Ui_ExportDialog(object):
         self.questionCount.setButtonSymbols(QAbstractSpinBox.ButtonSymbols.NoButtons)
         self.questionCount.setMaximum(999)
 
-        self.formLayout_2.setWidget(5, QFormLayout.ItemRole.LabelRole, self.questionCount)
+        self.formLayout_2.setWidget(7, QFormLayout.ItemRole.LabelRole, self.questionCount)
 
         self.pointCount = QDoubleSpinBox(ExportDialog)
         self.pointCount.setObjectName(u"pointCount")
@@ -93,7 +97,27 @@ class Ui_ExportDialog(object):
         self.pointCount.setDecimals(1)
         self.pointCount.setMaximum(1000.000000000000000)
 
-        self.formLayout_2.setWidget(5, QFormLayout.ItemRole.FieldRole, self.pointCount)
+        self.formLayout_2.setWidget(7, QFormLayout.ItemRole.FieldRole, self.pointCount)
+
+        self.label_3 = QLabel(ExportDialog)
+        self.label_3.setObjectName(u"label_3")
+
+        self.formLayout_2.setWidget(1, QFormLayout.ItemRole.LabelRole, self.label_3)
+
+        self.checkBoxExportAll = QCheckBox(ExportDialog)
+        self.checkBoxExportAll.setObjectName(u"checkBoxExportAll")
+
+        self.formLayout_2.setWidget(1, QFormLayout.ItemRole.FieldRole, self.checkBoxExportAll)
+
+        self.label_4 = QLabel(ExportDialog)
+        self.label_4.setObjectName(u"label_4")
+
+        self.formLayout_2.setWidget(3, QFormLayout.ItemRole.LabelRole, self.label_4)
+
+        self.checkBoxGenerateReport = QCheckBox(ExportDialog)
+        self.checkBoxGenerateReport.setObjectName(u"checkBoxGenerateReport")
+
+        self.formLayout_2.setWidget(3, QFormLayout.ItemRole.FieldRole, self.checkBoxGenerateReport)
 
 
         self.horizontalLayout.addLayout(self.formLayout_2)
@@ -117,14 +141,36 @@ class Ui_ExportDialog(object):
         ExportDialog.setWindowTitle(QCoreApplication.translate("ExportDialog", u"Dialog", None))
         self.label_10.setText(QCoreApplication.translate("ExportDialog", u"Default Question Variant", None))
 #if QT_CONFIG(tooltip)
-        self.label_9.setToolTip(QCoreApplication.translate("ExportDialog", u"If enabled, all questions will be categorized, when importing into moodle. Otherwise they will all be imported into one category", None))
+        self.label_9.setToolTip("")
 #endif // QT_CONFIG(tooltip)
         self.label_9.setText(QCoreApplication.translate("ExportDialog", u"Include Categories", None))
+#if QT_CONFIG(tooltip)
+        self.checkBoxIncludeCategories.setToolTip(QCoreApplication.translate("ExportDialog", u"If enabled, all questions will be categorized, when importing into moodle. Otherwise they will all be imported into one category", None))
+#endif // QT_CONFIG(tooltip)
         self.checkBoxIncludeCategories.setText("")
-        self.label.setText(QCoreApplication.translate("ExportDialog", u"Export File:", None))
+        self.label.setText(QCoreApplication.translate("ExportDialog", u"Select Export File:", None))
+#if QT_CONFIG(tooltip)
+        self.btnExportFile.setToolTip(QCoreApplication.translate("ExportDialog", u"Select the file to write the questions into.", None))
+#endif // QT_CONFIG(tooltip)
         self.btnExportFile.setText("")
         self.label_2.setText(QCoreApplication.translate("ExportDialog", u"Export Information:", None))
         self.questionCount.setSuffix(QCoreApplication.translate("ExportDialog", u"   Qst.", None))
         self.pointCount.setSuffix(QCoreApplication.translate("ExportDialog", u"  Pts.", None))
+#if QT_CONFIG(tooltip)
+        self.label_3.setToolTip("")
+#endif // QT_CONFIG(tooltip)
+        self.label_3.setText(QCoreApplication.translate("ExportDialog", u"Export all Variants", None))
+#if QT_CONFIG(tooltip)
+        self.checkBoxExportAll.setToolTip(QCoreApplication.translate("ExportDialog", u"If enable all variants for each question are exported into a seperate category for each question", None))
+#endif // QT_CONFIG(tooltip)
+        self.checkBoxExportAll.setText("")
+#if QT_CONFIG(tooltip)
+        self.label_4.setToolTip("")
+#endif // QT_CONFIG(tooltip)
+        self.label_4.setText(QCoreApplication.translate("ExportDialog", u"Generate export report", None))
+#if QT_CONFIG(tooltip)
+        self.checkBoxGenerateReport.setToolTip(QCoreApplication.translate("ExportDialog", u"If enabled a yaml report file will be saved with a list of all exported questions and variants.", None))
+#endif // QT_CONFIG(tooltip)
+        self.checkBoxGenerateReport.setText("")
     # retranslateUi
 

excel2moodle/ui/appUi.py

@@ -73,9 +73,12 @@ class MainWindow(QMainWindow):
         self.exportDialog.ui.checkBoxIncludeCategories.setChecked(
             self.qSettings.value(Tags.INCLUDEINCATS, defaultValue=True, type=bool)
         )
-        self.exportDialog.ui.spinBoxDefaultQVariant.setValue(
-            self.qSettings.value(Tags.QUESTIONVARIANT, defaultValue=1, type=int)
-        )
+        variant = self.qSettings.value(Tags.QUESTIONVARIANT, defaultValue=1, type=int)
+        if variant == -1:
+            self.exportDialog.ui.checkBoxExportAll.setChecked(True)
+            self.exportDialog.ui.spinBoxDefaultQVariant.setEnabled(False)
+        else:
+            self.exportDialog.ui.spinBoxDefaultQVariant.setValue(variant)
         try:
             self.resize(self.qSettings.value("windowSize"))
             self.move(self.qSettings.value("windowPosition"))
@@ -177,8 +180,10 @@ class MainWindow(QMainWindow):
         """Open a file Dialog so the export file may be choosen."""
         selection: list[QuestionItem] = self.ui.treeWidget.selectedItems()
         self.exportDialog.exportFile = Path(self.mainPath / "TestFile.xml")
-        self.exportDialog.ui.questionCount.setValue(self.ui.questionCounter.value())
-        self.exportDialog.ui.pointCount.setValue(self.ui.pointCounter.value())
+        qCount = self.ui.questionCounter.value()
+        pCount = self.ui.pointCounter.value()
+        self.exportDialog.ui.questionCount.setValue(qCount)
+        self.exportDialog.ui.pointCount.setValue(pCount)
         if self.exportDialog.exec():
             self.exportFile = self.exportDialog.exportFile
             self.settings.set(
@@ -187,10 +192,18 @@ class MainWindow(QMainWindow):
             )
             self.settings.set(
                 Tags.QUESTIONVARIANT,
-                self.exportDialog.ui.spinBoxDefaultQVariant.value(),
+                -1
+                if self.exportDialog.ui.checkBoxExportAll.isChecked()
+                else self.exportDialog.ui.spinBoxDefaultQVariant.value(),
+            )
+            self.settings.set(
+                Tags.GENEXPORTREPORT,
+                self.exportDialog.ui.checkBoxGenerateReport.isChecked(),
             )
             logger.info("New Export File is set %s", self.exportFile)
-            self.testDB.appendQuestions(selection, self.exportFile)
+            self.testDB.appendQuestions(
+                selection, self.exportFile, pCount=pCount, qCount=qCount
+            )
         else:
             logger.info("Aborting Export")
 
@@ -249,6 +262,7 @@ class MainWindow(QMainWindow):
     @Slot()
     def openDocumentation(self) -> None:
         url = QUrl(e2mMetadata["documentation"])
+        logger.info("Opening documentation in your Webbrowser...%s", url)
         QDesktopServices.openUrl(url)
 
     @Slot()

excel2moodle/ui/dialogs.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 import lxml.etree as ET
+from PySide6.QtCore import Slot
 from PySide6.QtWidgets import QDialog, QFileDialog, QMessageBox, QWidget
 
 from excel2moodle import e2mMetadata
@@ -50,6 +51,7 @@ class ExportDialog(QDialog):
         self.ui = Ui_ExportDialog()
         self.ui.setupUi(self)
         self.ui.btnExportFile.clicked.connect(self.getExportFile)
+        self.ui.checkBoxExportAll.clicked.connect(self.toggleExportAll)
 
     @property
     def exportFile(self) -> Path:
@@ -62,6 +64,16 @@ class ExportDialog(QDialog):
             f"../{(self.exportFile.parent.name)}/{self.exportFile.name}"
         )
 
+    @Slot()
+    def toggleExportAll(self) -> None:
+        self.ui.spinBoxDefaultQVariant.setEnabled(
+            not self.ui.checkBoxExportAll.isChecked()
+        )
+        self.ui.checkBoxIncludeCategories.setChecked(
+            self.ui.checkBoxExportAll.isChecked()
+        )
+
+    @Slot()
     def getExportFile(self) -> None:
         path = QFileDialog.getSaveFileName(
             self,