excel2moodle 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

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/UI_updateDlg.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+
+################################################################################
+## Form generated from reading UI file 'UI_updateDlg.ui'
+##
+## Created by: Qt User Interface Compiler version 6.9.1
+##
+## WARNING! All changes made in this file will be lost when recompiling UI file!
+################################################################################
+
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+    QMetaObject, QObject, QPoint, QRect,
+    QSize, QTime, QUrl, Qt)
+from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
+    QFont, QFontDatabase, QGradient, QIcon,
+    QImage, QKeySequence, QLinearGradient, QPainter,
+    QPalette, QPixmap, QRadialGradient, QTransform)
+from PySide6.QtWidgets import (QAbstractButton, QAbstractScrollArea, QApplication, QDialog,
+    QDialogButtonBox, QFrame, QLabel, QSizePolicy,
+    QTextBrowser, QVBoxLayout, QWidget)
+
+class Ui_UpdateDialog(object):
+    def setupUi(self, UpdateDialog):
+        if not UpdateDialog.objectName():
+            UpdateDialog.setObjectName(u"UpdateDialog")
+        UpdateDialog.setWindowModality(Qt.WindowModality.NonModal)
+        UpdateDialog.resize(534, 512)
+        UpdateDialog.setModal(True)
+        self.verticalLayout = QVBoxLayout(UpdateDialog)
+        self.verticalLayout.setObjectName(u"verticalLayout")
+        self.titleLabel = QLabel(UpdateDialog)
+        self.titleLabel.setObjectName(u"titleLabel")
+        sizePolicy = QSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.titleLabel.sizePolicy().hasHeightForWidth())
+        self.titleLabel.setSizePolicy(sizePolicy)
+
+        self.verticalLayout.addWidget(self.titleLabel)
+
+        self.fundingLabel = QLabel(UpdateDialog)
+        self.fundingLabel.setObjectName(u"fundingLabel")
+        sizePolicy.setHeightForWidth(self.fundingLabel.sizePolicy().hasHeightForWidth())
+        self.fundingLabel.setSizePolicy(sizePolicy)
+        self.fundingLabel.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.fundingLabel.setOpenExternalLinks(True)
+
+        self.verticalLayout.addWidget(self.fundingLabel)
+
+        self.line = QFrame(UpdateDialog)
+        self.line.setObjectName(u"line")
+        self.line.setFrameShape(QFrame.Shape.HLine)
+        self.line.setFrameShadow(QFrame.Shadow.Sunken)
+
+        self.verticalLayout.addWidget(self.line)
+
+        self.changelogLabel = QLabel(UpdateDialog)
+        self.changelogLabel.setObjectName(u"changelogLabel")
+        sizePolicy.setHeightForWidth(self.changelogLabel.sizePolicy().hasHeightForWidth())
+        self.changelogLabel.setSizePolicy(sizePolicy)
+
+        self.verticalLayout.addWidget(self.changelogLabel)
+
+        self.changelogBrowser = QTextBrowser(UpdateDialog)
+        self.changelogBrowser.setObjectName(u"changelogBrowser")
+        sizePolicy1 = QSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
+        sizePolicy1.setHorizontalStretch(0)
+        sizePolicy1.setVerticalStretch(0)
+        sizePolicy1.setHeightForWidth(self.changelogBrowser.sizePolicy().hasHeightForWidth())
+        self.changelogBrowser.setSizePolicy(sizePolicy1)
+        self.changelogBrowser.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+        self.changelogBrowser.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+        self.changelogBrowser.setSizeAdjustPolicy(QAbstractScrollArea.SizeAdjustPolicy.AdjustToContents)
+
+        self.verticalLayout.addWidget(self.changelogBrowser)
+
+        self.label = QLabel(UpdateDialog)
+        self.label.setObjectName(u"label")
+        sizePolicy.setHeightForWidth(self.label.sizePolicy().hasHeightForWidth())
+        self.label.setSizePolicy(sizePolicy)
+
+        self.verticalLayout.addWidget(self.label)
+
+        self.buttonBox = QDialogButtonBox(UpdateDialog)
+        self.buttonBox.setObjectName(u"buttonBox")
+        self.buttonBox.setOrientation(Qt.Orientation.Horizontal)
+        self.buttonBox.setStandardButtons(QDialogButtonBox.StandardButton.Ok)
+
+        self.verticalLayout.addWidget(self.buttonBox)
+
+
+        self.retranslateUi(UpdateDialog)
+        self.buttonBox.accepted.connect(UpdateDialog.accept)
+        self.buttonBox.rejected.connect(UpdateDialog.reject)
+
+        QMetaObject.connectSlotsByName(UpdateDialog)
+    # setupUi
+
+    def retranslateUi(self, UpdateDialog):
+        UpdateDialog.setWindowTitle(QCoreApplication.translate("UpdateDialog", u"Dialog", None))
+        self.titleLabel.setText(QCoreApplication.translate("UpdateDialog", u"<h2>A new <i>excel2moodle</i> version is available!</h2>", None))
+        self.fundingLabel.setText(QCoreApplication.translate("UpdateDialog", u"If you find this project useful, please consider supporting its development.", None))
+        self.changelogLabel.setText(QCoreApplication.translate("UpdateDialog", u"<h3>Changelog:</h3>", None))
+        self.label.setText(QCoreApplication.translate("UpdateDialog", u"To install the update run: 'uv tool upgrade excel2moodle'", None))
+    # retranslateUi
+

excel2moodle/ui/appUi.py

@@ -21,6 +21,7 @@ from PySide6.QtWidgets import (
 from excel2moodle import e2mMetadata, mainLogger
 from excel2moodle.core.category import Category
 from excel2moodle.core.dataStructure import QuestionDB
+from excel2moodle.core.exceptions import InvalidFieldException
 from excel2moodle.core.question import ParametricQuestion
 from excel2moodle.core.settings import Settings, Tags
 from excel2moodle.extra.variableGenerator import VariableGeneratorDialog
@@ -34,15 +35,14 @@ from excel2moodle.ui.UI_mainWindow import Ui_MoodleTestGenerator
 
 logger = logging.getLogger(__name__)
 
-loggerSignal = LogWindowHandler()
-mainLogger.addHandler(loggerSignal)
-
 
 class MainWindow(QMainWindow):
     def __init__(self, settings: Settings, testDB: QuestionDB) -> None:
         super().__init__()
         self.settings = settings
         self.qSettings = QSettings("jbosse3", "excel2moodle")
+        self.logHandler = LogWindowHandler()
+        mainLogger.addHandler(self.logHandler)
         logger.info("Settings are stored under: %s", self.qSettings.fileName())
 
         self.excelPath: Path | None = None
@@ -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"))
@@ -90,7 +93,7 @@ class MainWindow(QMainWindow):
         self.ui.checkBoxQuestionListSelectAll.checkStateChanged.connect(
             self.toggleQuestionSelectionState,
         )
-        loggerSignal.emitter.signal.connect(self.updateLog)
+        self.logHandler.emitter.signal.connect(self.updateLog)
         self.ui.actionEquationChecker.triggered.connect(self.openEqCheckerDlg)
         self.ui.actionParseAll.triggered.connect(self.parseSpreadsheetAll)
         self.testDB.signals.categoryQuestionsReady.connect(self.treeRefreshCategory)
@@ -107,6 +110,10 @@ class MainWindow(QMainWindow):
             self.openSpreadsheetExternally
         )
 
+    def showUpdateDialog(self, changelog, version) -> None:
+        dialog = dialogs.UpdateDialog(self, changelog=changelog, version=version)
+        dialog.exec()
+
     @Slot()
     def parseSpreadsheetAll(self) -> None:
         """Event triggered by the *Tools/Parse all Questions* Event.
@@ -156,7 +163,7 @@ class MainWindow(QMainWindow):
         selection = self.ui.treeWidget.selectedItems()
         for q in selection:
             questions += 1
-            count += q.getQuestion().points
+            count += q.question.points
         self.ui.pointCounter.setValue(count)
         self.ui.questionCounter.setValue(questions)
         if self.eqChecker.isVisible():
@@ -177,8 +184,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 +196,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")
 
@@ -208,18 +225,33 @@ class MainWindow(QMainWindow):
 
     @Slot(Category)
     def treeRefreshCategory(self, cat: Category) -> None:
-        """Append Category with its Questions to the treewidget."""
+        """Append Category with its Questions to the treewidget.
+
+        If the category already has an item, refresh it.
+        """
+        # Find existing item
+        for i in range(self.ui.treeWidget.topLevelItemCount()):
+            item = self.ui.treeWidget.topLevelItem(i)
+            # The top level items are categories
+            if isinstance(item, CategoryItem) and item.category.NAME == cat.NAME:
+                item.refresh()
+                return
+
         catItem = CategoryItem(self.ui.treeWidget, cat)
         catItem.setFlags(catItem.flags() & ~Qt.ItemIsSelectable)
-        for q in cat.questions.values():
-            QuestionItem(catItem, q)
+        try:
+            for q in cat.questions.values():
+                QuestionItem(catItem, q)
+        except ValueError:
+            logger.exception("No Questions to update.")
+        catItem.updateVariantCount()
         self.ui.treeWidget.sortItems(0, Qt.SortOrder.AscendingOrder)
 
     @Slot()
     def updateQuestionPreview(self) -> None:
         item = self.ui.treeWidget.currentItem()
         if isinstance(item, QuestionItem):
-            self.questionPreview.setupQuestion(item.getQuestion())
+            self.questionPreview.setupQuestion(item.question)
         else:
             logger.info("current Item is not a Question, can't preview")
 
@@ -231,12 +263,12 @@ class MainWindow(QMainWindow):
     def openEqCheckerDlg(self) -> None:
         item = self.ui.treeWidget.currentItem()
         if isinstance(item, QuestionItem):
-            question = item.getQuestion()
+            question = item.question
             if isinstance(question, (NFQuestion, MCQuestion)):
                 logger.debug("Can't check an MC or NF Question")
             else:
                 logger.debug("opening wEquationChecker \n")
-                self.eqChecker.setup(item.getQuestion())
+                self.eqChecker.setup(item.question)
                 self.eqChecker.show()
         else:
             logger.debug("No Question Item selected: %s", type(item))
@@ -249,17 +281,19 @@ 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()
     def openVariableGeneratorDlg(self) -> None:
         item = self.ui.treeWidget.currentItem()
         if isinstance(item, QuestionItem):
-            question = item.getQuestion()
+            question = item.question
             if isinstance(question, ParametricQuestion):
                 dialog = VariableGeneratorDialog(self, parametrics=question.parametrics)
                 if dialog.exec():
                     self.questionPreview.setupQuestion(question)
+                    self.treeRefreshCategory(question.category)
                     logger.info("Updated QuestionItem display for %s", question.id)
                     self.copyVariablesToClipboard(
                         variables=question.parametrics.variables
@@ -280,7 +314,7 @@ class MainWindow(QMainWindow):
         if not variables:
             item = self.ui.treeWidget.currentItem()
             if isinstance(item, QuestionItem):
-                question = item.getQuestion()
+                question = item.question
                 if isinstance(question, ParametricQuestion):
                     variables = question.parametrics.variables
         varsList = [
@@ -321,7 +355,15 @@ class ParseAllThread(QRunnable):
 
     @Slot()
     def run(self) -> None:
-        self.testDB.readCategoriesMetadata()
-        self.testDB.asyncInitAllCategories(self.mainApp.excelPath)
-        self.mainApp.setStatus("[OK] Tabellen wurde eingelesen")
-        self.testDB.parseAllQuestions()
+        try:
+            self.testDB.readCategoriesMetadata()
+        except InvalidFieldException:
+            logger.exception("Youre spreadsheet questionbank isn't correctly setup.")
+        except ValueError:
+            logger.exception(
+                "Did you forget to specify a 'settings' sheet in the file?"
+            )
+        else:
+            self.testDB.asyncInitAllCategories(self.mainApp.excelPath)
+            self.mainApp.setStatus("[OK] Tabellen wurde eingelesen")
+            self.testDB.parseAllQuestions()

excel2moodle/ui/dialogs.py

@@ -5,7 +5,8 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 import lxml.etree as ET
-from PySide6.QtWidgets import QDialog, QFileDialog, QMessageBox, QWidget
+from PySide6.QtCore import Slot
+from PySide6.QtWidgets import QDialog, QFileDialog, QMainWindow, QMessageBox, QWidget
 
 from excel2moodle import e2mMetadata
 from excel2moodle.core.globals import XMLTags
@@ -13,6 +14,7 @@ from excel2moodle.core.question import ParametricQuestion, Question
 from excel2moodle.core.settings import Tags
 from excel2moodle.extra import variableGenerator
 from excel2moodle.ui.UI_exportSettingsDialog import Ui_ExportDialog
+from excel2moodle.ui.UI_updateDlg import Ui_UpdateDialog
 from excel2moodle.ui.UI_variantDialog import Ui_Dialog
 
 if TYPE_CHECKING:
@@ -21,6 +23,22 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+class UpdateDialog(QDialog):
+    def __init__(
+        self, parent: QMainWindow, changelog: str = "", version: str = ""
+    ) -> None:
+        super().__init__(parent)
+        self.ui = Ui_UpdateDialog()
+        self.ui.setupUi(self)
+        self.ui.changelogBrowser.setMarkdown(changelog)
+        self.ui.titleLabel.setText(
+            f"<h2>New Version {version} of <i>exel2moodle</i> just dropped!!</h2>"
+        )
+        self.ui.fundingLabel.setText(
+            f'If you find this project useful, please consider supporting its development. <br> <a href="{e2mMetadata["funding"]}">Buy jbosse3 a coffee</a>, so he stays caffeinated during coding.',
+        )
+
+
 class QuestionVariantDialog(QDialog):
     def __init__(self, parent, question: ParametricQuestion) -> None:
         super().__init__(parent)
@@ -50,6 +68,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 +81,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,

excel2moodle/ui/treewidget.py

@@ -4,24 +4,33 @@ Those two are subclasses of `QTreeWidgetItem`, to provide an easy interface
 of accessing the corresponding questions from the items.
 """
 
+import logging
+
 from PySide6.QtCore import Qt
 from PySide6.QtWidgets import QTreeWidgetItem
 
 from excel2moodle.core.dataStructure import Category
 from excel2moodle.core.question import ParametricQuestion, Question
 
+logger = logging.getLogger(__name__)
+
 
 class QuestionItem(QTreeWidgetItem):
     def __init__(self, parent, question: Question | ParametricQuestion) -> None:
         super().__init__(parent)
         self.setData(2, Qt.UserRole, question)
+        self.refresh()
+
+    def refresh(self) -> None:
+        question = self.question
         self.setText(0, question.id)
         self.setText(1, question.name)
         self.setText(2, str(question.points))
-        if hasattr(question, "variants") and question.variants is not None:
-            self.setText(3, str(question.variants))
+        if isinstance(question, ParametricQuestion):
+            self.setText(3, str(question.parametrics.variants))
 
-    def getQuestion(self) -> Question | ParametricQuestion:
+    @property
+    def question(self) -> Question | ParametricQuestion:
         """Return the question Object the QTreeWidgetItem represents."""
         return self.data(2, Qt.UserRole)
 
@@ -30,9 +39,9 @@ class CategoryItem(QTreeWidgetItem):
     def __init__(self, parent, category: Category) -> None:
         super().__init__(parent)
         self.setData(2, Qt.UserRole, category)
-        self.setText(0, category.NAME)
-        self.setText(1, category.desc)
-        self.setText(2, str(category.points))
+        self.refresh()
+
+    def updateVariantCount(self) -> None:
         var = self.getMaxVariants()
         if var != 0:
             self.setText(3, str(var))
@@ -44,10 +53,21 @@ class CategoryItem(QTreeWidgetItem):
     def getMaxVariants(self) -> int:
         count: int = 0
         for child in self.iterateChildren():
-            q = child.getQuestion()
-            if hasattr(q, "variants") and q.variants is not None:
-                count = max(q.variants, count)
+            q = child.question
+            if isinstance(q, ParametricQuestion):
+                count = max(q.parametrics.variants, count)
         return count
 
-    def getCategory(self) -> Category:
+    @property
+    def category(self) -> Category:
         return self.data(2, Qt.UserRole)
+
+    def refresh(self) -> None:
+        for child in self.iterateChildren():
+            child.refresh()
+        # Update category data, as it might have changed
+        cat = self.category
+        self.setText(0, cat.NAME)
+        self.setText(1, cat.desc)
+        self.setText(2, str(cat.points))
+        self.updateVariantCount()