oqtopus 0.1.14__py3-none-any.whl

oqtopus/gui/module_selection_widget.py

@@ -0,0 +1,350 @@
+from qgis.PyQt.QtCore import Qt, QUrl, pyqtSignal
+from qgis.PyQt.QtGui import QDesktopServices
+from qgis.PyQt.QtWidgets import QApplication, QFileDialog, QMessageBox, QWidget
+
+from ..core.module import Module
+from ..core.module_package import ModulePackage
+from ..core.package_prepare_task import PackagePrepareTask, PackagePrepareTaskCanceled
+from ..utils.plugin_utils import PluginUtils, logger
+from ..utils.qt_utils import CriticalMessageBox, OverrideCursor, QtUtils
+
+DIALOG_UI = PluginUtils.get_ui_class("module_selection_widget.ui")
+
+
+class ModuleSelectionWidget(QWidget, DIALOG_UI):
+
+    module_package_SPECIAL_LOAD_DEVELOPMENT = "Load development versions"
+
+    signal_loadingStarted = pyqtSignal()
+    signal_loadingFinished = pyqtSignal()
+
+    def __init__(self, modules_config, parent=None):
+        QWidget.__init__(self, parent)
+        self.setupUi(self)
+
+        self.__current_module = None
+        self.__current_module_package = None
+        self.__modules_config = modules_config
+
+        self.module_progressBar.setVisible(False)
+
+        self.module_module_comboBox.clear()
+        self.module_module_comboBox.addItem(self.tr("Please select a module"), None)
+        for config_module in self.__modules_config.modules:
+            module = Module(
+                name=config_module.name,
+                organisation=config_module.organisation,
+                repository=config_module.repository,
+                parent=self,
+            )
+            self.module_module_comboBox.addItem(module.name, module)
+            module.signal_versionsLoaded.connect(self.__loadVersionsFinished)
+            module.signal_developmentVersionsLoaded.connect(self.__loadDevelopmentVersionsFinished)
+
+        self.module_latestVersion_label.setText("")
+        QtUtils.setForegroundColor(self.module_latestVersion_label, PluginUtils.COLOR_GREEN)
+
+        self.module_package_comboBox.clear()
+        self.module_package_comboBox.addItem(self.tr("Please select a version"), None)
+
+        self.module_zipPackage_groupBox.setVisible(False)
+
+        self.module_module_comboBox.currentIndexChanged.connect(self.__moduleChanged)
+        self.module_package_comboBox.currentIndexChanged.connect(self.__moduleVersionChanged)
+        self.module_seeChangeLog_pushButton.clicked.connect(self.__seeChangeLogClicked)
+        self.module_browseZip_toolButton.clicked.connect(self.__moduleBrowseZipClicked)
+
+        self.__packagePrepareTask = PackagePrepareTask(self)
+        self.__packagePrepareTask.finished.connect(self.__packagePrepareTaskFinished)
+        self.__packagePrepareTask.signalPackagingProgress.connect(
+            self.__packagePrepareTaskProgress
+        )
+
+    def close(self):
+        if self.__packagePrepareTask.isRunning():
+            self.__packagePrepareTask.cancel()
+            self.__packagePrepareTask.wait()
+
+    def getSelectedModulePackage(self):
+        return self.__current_module_package
+
+    def lastError(self):
+        """
+        Returns the last error occurred during the loading process.
+        If no error occurred, returns None.
+        """
+        return self.__packagePrepareTask.lastError
+
+    def __moduleChanged(self, index):
+        if self.module_module_comboBox.currentData() == self.__current_module:
+            return
+
+        self.__current_module = self.module_module_comboBox.currentData()
+
+        self.module_latestVersion_label.setText("")
+        self.module_package_comboBox.clear()
+        self.module_package_comboBox.addItem(self.tr("Please select a version"), None)
+
+        if self.__current_module is None:
+            return
+
+        if self.__current_module.versions == list():
+            QApplication.setOverrideCursor(Qt.CursorShape.WaitCursor)
+            self.__current_module.start_load_versions()
+
+    def __moduleVersionChanged(self, index):
+
+        if (
+            self.module_package_comboBox.currentData()
+            == self.module_package_SPECIAL_LOAD_DEVELOPMENT
+        ):
+            self.__loadDevelopmentVersions()
+            return
+
+        if self.__packagePrepareTask.isRunning():
+            logger.info("Package prepare task is running, canceling it.")
+            self.__packagePrepareTask.cancel()
+            self.__packagePrepareTask.wait()
+
+        self.__current_module_package = self.module_package_comboBox.currentData()
+        if self.__current_module_package is None:
+            return
+
+        if self.__current_module_package.type == self.__current_module_package.Type.FROM_ZIP:
+            self.module_zippackage_groupBox.setVisible(True)
+            return
+        else:
+            self.module_zipPackage_groupBox.setVisible(False)
+
+        loading_text = self.tr(
+            f"Loading packages for module '{self.module_module_comboBox.currentText()}' version '{self.__current_module_package.display_name()}'..."
+        )
+        self.module_information_label.setText(loading_text)
+        QtUtils.resetForegroundColor(self.module_information_label)
+        logger.info(loading_text)
+
+        self.module_informationProject_label.setText("-")
+        self.module_informationPlugin_label.setText("-")
+
+        self.__packagePrepareTask.startFromModulePackage(self.__current_module_package)
+
+        self.signal_loadingStarted.emit()
+        self.module_progressBar.setVisible(True)
+
+    def __loadDevelopmentVersions(self):
+        if self.__current_module is None:
+            return
+
+        if self.__current_module.development_versions == list():
+            QApplication.setOverrideCursor(Qt.CursorShape.WaitCursor)
+            self.__current_module.start_load_development_versions()
+
+    def __moduleBrowseZipClicked(self):
+        filename, format = QFileDialog.getOpenFileName(
+            self, self.tr("Open from zip"), None, self.tr("Zip package (*.zip)")
+        )
+
+        if filename == "":
+            return
+
+        self.module_fromZip_lineEdit.setText(filename)
+
+        try:
+            with OverrideCursor(Qt.CursorShape.WaitCursor):
+                self.__loadModuleFromZip(filename)
+        except Exception as exception:
+            CriticalMessageBox(
+                self.tr("Error"), self.tr("Can't load module from zip file:"), exception, self
+            ).exec()
+            return
+
+    def __loadModuleFromZip(self, filename):
+
+        if self.__packagePrepareTask.isRunning():
+            self.__packagePrepareTask.cancel()
+            self.__packagePrepareTask.wait()
+
+        self.__packagePrepareTask.startFromZip(filename)
+
+        self.signal_loadingStarted.emit()
+        self.module_progressBar.setVisible(True)
+
+    def __packagePrepareTaskFinished(self):
+        logger.info("Load package task finished")
+
+        self.signal_loadingFinished.emit()
+        self.module_progressBar.setVisible(False)
+
+        if isinstance(self.__packagePrepareTask.lastError, PackagePrepareTaskCanceled):
+            logger.info("Load package task was canceled by user.")
+            self.module_information_label.setText(self.tr("Package loading canceled."))
+            QtUtils.setForegroundColor(self.module_information_label, PluginUtils.COLOR_WARNING)
+            return
+
+        if self.__packagePrepareTask.lastError is not None:
+            error_text = self.tr("Can't load module package:")
+            CriticalMessageBox(
+                self.tr("Error"), error_text, self.__packagePrepareTask.lastError, self
+            ).exec()
+            self.module_information_label.setText(error_text)
+            QtUtils.setForegroundColor(self.module_information_label, PluginUtils.COLOR_WARNING)
+            return
+
+        package_dir = self.module_package_comboBox.currentData().package_dir
+        logger.info(f"Package loaded into '{package_dir}'")
+        self.module_information_label.setText(package_dir)
+        QtUtils.resetForegroundColor(self.module_information_label)
+
+        asset_project = self.module_package_comboBox.currentData().asset_project
+        if asset_project:
+            self.module_informationProject_label.setText(asset_project.package_dir)
+        else:
+            self.module_informationProject_label.setText("No asset available")
+
+        asset_plugin = self.module_package_comboBox.currentData().asset_plugin
+        if asset_plugin:
+            self.module_informationPlugin_label.setText(asset_plugin.package_dir)
+        else:
+            self.module_informationPlugin_label.setText("No asset available")
+
+    def __packagePrepareTaskProgress(self, progress):
+        loading_text = self.tr("Load package task running...")
+        logger.info(loading_text)
+        self.module_information_label.setText(loading_text)
+
+    def __seeChangeLogClicked(self):
+        if self.__current_module_package.type == ModulePackage.Type.FROM_ZIP:
+            QMessageBox.warning(
+                self,
+                self.tr("Can't open changelog"),
+                self.tr("Changelog is not available for Zip packages."),
+            )
+            return
+
+        if self.__current_module_package is None:
+            QMessageBox.warning(
+                self,
+                self.tr("Can't open changelog"),
+                self.tr("Please select a module and version first."),
+            )
+            return
+
+        if self.__current_module_package.html_url is None:
+            QMessageBox.warning(
+                self,
+                self.tr("Can't open changelog"),
+                self.tr(
+                    f"Changelog not available for version '{self.__current_module_package.display_name()}'."
+                ),
+            )
+            return
+
+        changelog_url = self.__current_module_package.html_url
+        logger.info(f"Opening changelog URL: {changelog_url}")
+        QDesktopServices.openUrl(QUrl(changelog_url))
+
+    def __loadVersionsFinished(self, error):
+        logger.info("Loading versions finished")
+
+        QApplication.restoreOverrideCursor()
+        self.signal_loadingFinished.emit()
+        self.module_progressBar.setVisible(False)
+
+        if error:
+            if "rate limit exceeded for url" in error.lower():
+                QMessageBox.critical(
+                    self,
+                    self.tr("GitHub API Rate Limit Exceeded"),
+                    self.tr(
+                        "Oqtopus needs to download release data from GitHub to work properly.<br><br>"
+                        "GitHub limits the number of requests that can be made without authentication. "
+                        "You have reached the maximum number of requests allowed for unauthenticated users.<br><br>"
+                        "To continue using this feature, please create a free GitHub personal access token and enter it in the Settings dialog.<br><br>"
+                        "This will increase your request limit.<br><br>"
+                        "<b>How to get a token:</b><br>"
+                        "1. Go to <a href='https://github.com/settings/tokens'>GitHub Personal Access Tokens</a>.<br>"
+                        "2. Click <b>Generate new token</b> and select the <code>repo</code> scope.<br>"
+                        "3. Copy the generated token and paste it in the Settings dialog of this application."
+                    ),
+                )
+                return
+
+            error_text = self.tr(f"Can't load module versions: {error}")
+            QMessageBox.critical(self, self.tr("Error"), error_text)
+            self.module_information_label.setText(error_text)
+            QtUtils.setForegroundColor(self.module_information_label, PluginUtils.COLOR_WARNING)
+            return
+
+        for module_package in self.__current_module.versions:
+            self.module_package_comboBox.addItem(module_package.display_name(), module_package)
+
+        if self.__current_module.latest_version is not None:
+            self.module_latestVersion_label.setText(
+                f"Latest: {self.__current_module.latest_version.name}"
+            )
+
+        self.module_package_comboBox.insertSeparator(self.module_package_comboBox.count())
+        self.module_package_comboBox.addItem(
+            self.tr("Load from ZIP file"),
+            ModulePackage(
+                module=self.__current_module,
+                organisation=self.__current_module.organisation,
+                repository=self.__current_module.repository,
+                json_payload=None,
+                type=ModulePackage.Type.FROM_ZIP,
+            ),
+        )
+
+        self.module_package_comboBox.insertSeparator(self.module_package_comboBox.count())
+        self.module_package_comboBox.addItem(
+            self.tr("Load development branches"), self.module_package_SPECIAL_LOAD_DEVELOPMENT
+        )
+
+        self.module_progressBar.setVisible(False)
+        logger.info(f"Versions loaded for module '{self.__current_module.name}'.")
+
+    def __loadDevelopmentVersionsFinished(self, error):
+        logger.info("Loading development versions finished")
+
+        QApplication.restoreOverrideCursor()
+        self.signal_loadingFinished.emit()
+        self.module_progressBar.setVisible(False)
+
+        if error:
+            if "rate limit exceeded for url" in error.lower():
+                QMessageBox.critical(
+                    self,
+                    self.tr("GitHub API Rate Limit Exceeded"),
+                    self.tr(
+                        "Oqtopus needs to download release data from GitHub to work properly.<br><br>"
+                        "GitHub limits the number of requests that can be made without authentication. "
+                        "You have reached the maximum number of requests allowed for unauthenticated users.<br><br>"
+                        "To continue using this feature, please create a free GitHub personal access token and enter it in the Settings dialog.<br><br>"
+                        "This will increase your request limit.<br><br>"
+                        "<b>How to get a token:</b><br>"
+                        "1. Go to <a href='https://github.com/settings/tokens'>GitHub Personal Access Tokens</a>.<br>"
+                        "2. Click <b>Generate new token</b> and select the <code>repo</code> scope.<br>"
+                        "3. Copy the generated token and paste it in the Settings dialog of this application."
+                    ),
+                )
+                return
+
+            error_text = self.tr(f"Can't load module versions: {error}")
+            QMessageBox.critical(self, self.tr("Error"), error_text)
+            self.module_information_label.setText(error_text)
+            QtUtils.setForegroundColor(self.module_information_label, PluginUtils.COLOR_WARNING)
+            return
+
+        if self.__current_module.development_versions == list():
+            QMessageBox.warning(
+                self,
+                self.tr("No development versions found"),
+                self.tr("No development versions found for this module."),
+            )
+            return
+
+        self.module_package_comboBox.removeItem(self.module_package_comboBox.count() - 1)
+        self.module_package_comboBox.setCurrentIndex(0)
+
+        for module_package in self.__current_module.development_versions:
+            self.module_package_comboBox.addItem(module_package.display_name(), module_package)

oqtopus/gui/module_widget.py

@@ -0,0 +1,199 @@
+import os
+
+import psycopg
+from pum.pum_config import PumConfig
+from pum.schema_migrations import SchemaMigrations
+from pum.upgrader import Upgrader
+from qgis.PyQt.QtCore import Qt
+from qgis.PyQt.QtWidgets import QMessageBox, QWidget
+
+from ..core.module import Module
+from ..utils.plugin_utils import PluginUtils, logger
+from ..utils.qt_utils import CriticalMessageBox, OverrideCursor, QtUtils
+
+DIALOG_UI = PluginUtils.get_ui_class("module_widget.ui")
+
+
+class ModuleWidget(QWidget, DIALOG_UI):
+
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent)
+        self.setupUi(self)
+
+        self.moduleInfo_stackedWidget.setCurrentWidget(self.moduleInfo_stackedWidget_pageInstall)
+
+        self.db_demoData_checkBox.clicked.connect(
+            lambda checked: self.db_demoData_comboBox.setEnabled(checked)
+        )
+
+        self.moduleInfo_install_pushButton.clicked.connect(self.__installModuleClicked)
+        self.moduleInfo_upgrade_pushButton.clicked.connect(self.__upgradeModuleClicked)
+
+        self.__current_module_package = None
+        self.__database_connection = None
+
+    def setModulePackage(self, module_package: Module):
+        self.__current_module_package = module_package
+        self.__packagePrepareGetPUMConfig()
+        self.__updateModuleInfo()
+
+    def setDatabaseConnection(self, connection: psycopg.Connection):
+        self.__database_connection = connection
+        self.__updateModuleInfo()
+
+    def __packagePrepareGetPUMConfig(self):
+        package_dir = self.__current_module_package.package_dir
+
+        if package_dir is None:
+            CriticalMessageBox(
+                self.tr("Error"),
+                self.tr(
+                    f"The selected file '{self.__current_module_package.zip_file}' does not contain a valid package directory."
+                ),
+                None,
+                self,
+            ).exec()
+            return
+
+        self.__data_model_dir = os.path.join(package_dir, "datamodel")
+        pumConfigFilename = os.path.join(self.__data_model_dir, ".pum.yaml")
+        if not os.path.exists(pumConfigFilename):
+            CriticalMessageBox(
+                self.tr("Error"),
+                self.tr(
+                    f"The selected file '{self.__current_module_package.zip_file}' does not contain a valid .pum.yaml file."
+                ),
+                None,
+                self,
+            ).exec()
+            return
+
+        try:
+            self.__pum_config = PumConfig.from_yaml(pumConfigFilename, install_dependencies=True)
+        except Exception as exception:
+            CriticalMessageBox(
+                self.tr("Error"),
+                self.tr(f"Can't load PUM config from '{pumConfigFilename}':"),
+                exception,
+                self,
+            ).exec()
+            return
+
+        logger.info(f"PUM config loaded from '{pumConfigFilename}'")
+
+        self.parameters_groupbox.setParameters(self.__pum_config.parameters())
+
+        self.db_demoData_comboBox.clear()
+        for demo_data_name, demo_data_file in self.__pum_config.demo_data().items():
+            self.db_demoData_comboBox.addItem(demo_data_name, demo_data_file)
+
+    def __installModuleClicked(self):
+
+        if self.__current_module_package is None:
+            CriticalMessageBox(
+                self.tr("Error"), self.tr("Please select a module package first."), None, self
+            ).exec()
+            return
+
+        if self.__database_connection is None:
+            CriticalMessageBox(
+                self.tr("Error"), self.tr("Please select a database service first."), None, self
+            ).exec()
+            return
+
+        if self.__pum_config is None:
+            CriticalMessageBox(
+                self.tr("Error"), self.tr("No valid module available."), None, self
+            ).exec()
+            return
+
+        parameters = self.parameters_groupbox.parameters_values()
+
+        try:
+            upgrader = Upgrader(
+                config=self.__pum_config,
+            )
+            with OverrideCursor(Qt.CursorShape.WaitCursor):
+                upgrader.install(
+                    parameters=parameters,
+                    connection=self.__database_connection,
+                    roles=self.db_parameters_CreateAndGrantRoles_checkBox.isChecked(),
+                    grant=self.db_parameters_CreateAndGrantRoles_checkBox.isChecked(),
+                )
+
+                if self.db_demoData_checkBox.isChecked():
+                    demo_data_name = self.db_demoData_comboBox.currentText()
+                    upgrader.install_demo_data(
+                        connection=self.__database_connection,
+                        name=demo_data_name,
+                        parameters=parameters,
+                    )
+        except Exception as exception:
+            CriticalMessageBox(
+                self.tr("Error"), self.tr("Can't install the module:"), exception, self
+            ).exec()
+            return
+
+        QMessageBox.information(
+            self,
+            self.tr("Module installed"),
+            self.tr(
+                f"Module '{self.__current_module_package.module.name}' version '{self.__current_module_package.name}' has been successfully installed."
+            ),
+        )
+        logger.info(
+            f"Module '{self.__current_module_package.module.name}' version '{self.__current_module_package.name}' has been successfully installed."
+        )
+
+        self.__updateModuleInfo()
+
+    def __upgradeModuleClicked(self):
+        QMessageBox.critical(
+            self,
+            self.tr("Not implemented"),
+            self.tr("Upgrade module is not implemented yet."),
+        )
+        return
+
+    def __updateModuleInfo(self):
+        if self.__current_module_package is None:
+            self.moduleInfo_label.setText(self.tr("No module package selected"))
+            QtUtils.setForegroundColor(self.moduleInfo_label, PluginUtils.COLOR_WARNING)
+            return
+
+        if self.__database_connection is None:
+            self.moduleInfo_label.setText(self.tr("No database connection available"))
+            QtUtils.setForegroundColor(self.moduleInfo_label, PluginUtils.COLOR_WARNING)
+            return
+
+        if self.__pum_config is None:
+            self.moduleInfo_label.setText(self.tr("No PUM config available"))
+            QtUtils.setForegroundColor(self.moduleInfo_label, PluginUtils.COLOR_WARNING)
+            return
+
+        migrationVersion = self.__pum_config.last_version()
+        sm = SchemaMigrations(self.__pum_config)
+
+        if sm.exists(self.__database_connection):
+            # Case upgrade
+            baseline_version = sm.baseline(self.__database_connection)
+            self.moduleInfo_label.setText(self.tr(f"Version {baseline_version} found"))
+            QtUtils.resetForegroundColor(self.moduleInfo_label)
+            self.moduleInfo_upgrade_pushButton.setText(self.tr(f"Upgrade to {migrationVersion}"))
+
+            self.moduleInfo_stackedWidget.setCurrentWidget(
+                self.moduleInfo_stackedWidget_pageUpgrade
+            )
+
+            logger.info(
+                f"Migration table details: {sm.migration_details(self.__database_connection)}"
+            )
+
+        else:
+            # Case install
+            self.moduleInfo_label.setText(self.tr("No module found"))
+            QtUtils.resetForegroundColor(self.moduleInfo_label)
+            self.moduleInfo_install_pushButton.setText(self.tr(f"Install {migrationVersion}"))
+            self.moduleInfo_stackedWidget.setCurrentWidget(
+                self.moduleInfo_stackedWidget_pageInstall
+            )

oqtopus/gui/parameters_groupbox.py

@@ -0,0 +1,75 @@
+import logging
+
+from pum import ParameterDefinition, ParameterType
+from qgis.PyQt.QtWidgets import (
+    QCheckBox,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QWidget,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ParameterWidget(QWidget):
+    def __init__(self, parameter_definition: ParameterDefinition, parent):
+        QWidget.__init__(self, parent)
+        self.layout = QHBoxLayout(self)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(self.layout)
+        self.value = None
+        self.__valueChanged = False
+
+        if parameter_definition.type != ParameterType.BOOLEAN:
+            self.layout.addWidget(QLabel(parameter_definition.name, self))
+
+        if parameter_definition.type == ParameterType.BOOLEAN:
+            self.widget = QCheckBox(parameter_definition.name, self)
+            self.widget.setChecked(parameter_definition.default)
+            self.widget.checked.connect(self.__valueChanged)
+            self.layout.addWidget(self.widget)
+            self.value = lambda: self.widget.isChecked()
+        elif parameter_definition.type in (
+            ParameterType.DECIMAL,
+            ParameterType.INTEGER,
+            ParameterType.TEXT,
+        ):
+            self.widget = QLineEdit(self)
+            if parameter_definition.default is not None:
+                self.widget.setPlaceholderText(str(parameter_definition.default))
+            self.layout.addWidget(self.widget)
+            if parameter_definition.type == ParameterType.INTEGER:
+                self.value = lambda: int(self.widget.text() or self.widget.placeholderText())
+            elif parameter_definition.type == ParameterType.DECIMAL:
+                self.value = lambda: float(self.widget.text() or self.widget.placeholderText())
+            else:
+                self.value = lambda: self.widget.text() or self.widget.placeholderText()
+
+
+class ParametersGroupBox(QGroupBox):
+    def __init__(self, parent):
+        QGroupBox.__init__(self, parent)
+        self.parameter_widgets = {}
+
+    def setParameters(self, parameters: list[ParameterDefinition]):
+        logger.info(f"Setting parameters in ParametersGroupBox ({len(parameters)})")
+        self.clean()
+        self.parameters = parameters
+        # Remove all widgets from the parameters_group_box layout
+        for parameter in parameters:
+            pw = ParameterWidget(parameter, self)
+            self.layout().addWidget(pw)
+            self.parameter_widgets[parameter.name] = pw
+
+    def parameters_values(self):
+        values = {}
+        for parameter in self.parameters:
+            values[parameter.name] = self.parameter_widgets[parameter.name].value()
+        return values
+
+    def clean(self):
+        for widget in self.parameter_widgets.values():
+            widget.deleteLater()
+        self.parameter_widgets = {}