oqtopus 0.1.14__py3-none-any.whl

oqtopus/gui/database_create_dialog.py

@@ -0,0 +1,210 @@
+# -----------------------------------------------------------
+#
+# Profile
+# Copyright (C) 2025  Damiano Lombardi
+# -----------------------------------------------------------
+#
+# licensed under the terms of GNU GPL 2
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, print to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# ---------------------------------------------------------------------
+
+import psycopg
+from pgserviceparser import service_config as pgserviceparser_service_config
+from pgserviceparser import service_names as pgserviceparser_service_names
+from pgserviceparser import write_service as pgserviceparser_write_service
+from qgis.PyQt.QtCore import Qt
+from qgis.PyQt.QtWidgets import QDialog, QMessageBox
+
+from ..utils.plugin_utils import PluginUtils, logger
+from ..utils.qt_utils import OverrideCursor
+
+DIALOG_UI = PluginUtils.get_ui_class("database_create_dialog.ui")
+
+
+class DatabaseCreateDialog(QDialog, DIALOG_UI):
+    def __init__(self, selected_service=None, parent=None):
+        QDialog.__init__(self, parent)
+        self.setupUi(self)
+
+        self.existingService_comboBox.clear()
+        for service_name in pgserviceparser_service_names():
+            self.existingService_comboBox.addItem(service_name)
+
+        if selected_service:
+            self.existingService_comboBox.setCurrentText(selected_service)
+
+        self.existingService_comboBox.currentIndexChanged.connect(self._serviceChanged)
+
+        self.enterManually_radioButton.toggled.connect(self._enterManuallyToggled)
+
+        self.parameters_ssl_comboBox.clear()
+        self.parameters_ssl_comboBox.addItem("Not set", None)
+        notSetFont = self.parameters_ssl_comboBox.font()
+        notSetFont.setItalic(True)
+        self.parameters_ssl_comboBox.setItemData(0, notSetFont, Qt.ItemDataRole.FontRole)
+        self.parameters_ssl_comboBox.addItem("disable", "disable")
+        self.parameters_ssl_comboBox.addItem("allow", "allow")
+        self.parameters_ssl_comboBox.addItem("prefer", "prefer")
+        self.parameters_ssl_comboBox.addItem("require", "require")
+        self.parameters_ssl_comboBox.addItem("verify-ca", "verify-ca")
+        self.parameters_ssl_comboBox.addItem("verify-full", "verify-full")
+
+        self.database_lineEdit.textChanged.connect(self._databaseTextChanged)
+
+        self.buttonBox.accepted.connect(self._accept)
+
+        if self.existingService_comboBox.count() > 0:
+            self._serviceChanged()
+
+    def created_service_name(self):
+        return self.service_lineEdit.text()
+
+    def _serviceChanged(self):
+        service_name = self.existingService_comboBox.currentText()
+        service_config = pgserviceparser_service_config(service_name)
+
+        service_host = service_config.get("host", None)
+        service_port = service_config.get("port", None)
+        service_ssl = service_config.get("sslmode", None)
+        service_dbname = service_config.get("dbname", None)
+        service_user = service_config.get("user", None)
+        service_password = service_config.get("password", None)
+
+        self.parameters_host_lineEdit.setText(service_host)
+        self.parameters_port_lineEdit.setText(service_port)
+
+        parameter_ssl_index = self.parameters_ssl_comboBox.findData(service_ssl)
+        self.parameters_ssl_comboBox.setCurrentIndex(parameter_ssl_index)
+        self.parameters_user_lineEdit.setText(service_user)
+        self.parameters_password_lineEdit.setText(service_password)
+
+        self.database_lineEdit.setText(service_dbname)
+
+    def _enterManuallyToggled(self, checked):
+        self.parameters_frame.setEnabled(checked)
+
+    def _databaseTextChanged(self, text):
+        self.database_label.setText(text)
+
+    def _accept(self):
+        service_name = self.created_service_name()
+
+        if service_name == "":
+            QMessageBox.critical(self, "Error", "Please enter a service name.")
+            return
+
+        # Check if the service name is already in use
+        if service_name in pgserviceparser_service_names():
+            QMessageBox.critical(
+                self, "Error", self.tr(f"Service name '{service_name}' already exists.")
+            )
+            return
+
+        new_database_name = self.database_lineEdit.text()
+        if new_database_name == "":
+            QMessageBox.critical(self, "Error", "Please enter a database name.")
+            return
+
+        database_connection = None
+        try:
+            with OverrideCursor(Qt.CursorShape.WaitCursor):
+                database_connection = psycopg.connect(**self._get_connection_parameters())
+                database_connection.autocommit = True
+                with database_connection.cursor() as cursor:
+                    cursor.execute(
+                        psycopg.sql.SQL("CREATE DATABASE {}").format(
+                            psycopg.sql.Identifier(new_database_name)
+                        )
+                    )
+
+        except Exception as e:
+            errorText = self.tr(f"Error creating the new database:\n{e}.")
+            logger.error(errorText)
+            QMessageBox.critical(self, "Error", errorText)
+            return
+
+        finally:
+            if database_connection:
+                database_connection.close()
+
+        # Proceed with writing the new service configuration
+        service_settings = self._get_new_service_settings()
+
+        try:
+            pgserviceparser_write_service(
+                service_name=service_name,
+                settings=service_settings,
+                create_if_not_found=True,
+            )
+        except Exception as e:
+            errorText = self.tr(f"Error writing the new service configuration:\n{e}.")
+            logger.error(errorText)
+            QMessageBox.critical(self, "Error", errorText)
+            return
+
+        super().accept()
+
+    def _get_connection_parameters(self):
+        """
+        Returns a dictionary of connection parameters suitable for psycopg.connect().
+        Uses manual input if 'Enter manually' is checked, otherwise uses the selected service name.
+        """
+        settings = dict()
+        if self.enterManually_radioButton.isChecked():
+            settings.update(self._get_manual_connection_parameters())
+        else:
+            # Use the selected service name
+            service_name = self.existingService_comboBox.currentText()
+            if service_name:
+                settings["service"] = service_name
+
+        return settings
+
+    def _get_new_service_settings(self):
+        settings = dict()
+
+        if self.enterManually_radioButton.isChecked():
+            settings.update(self._get_manual_connection_parameters())
+        else:
+            # Copy settings from the selected existing service
+            service_name = self.existingService_comboBox.currentText()
+            existing_settings = pgserviceparser_service_config(service_name)
+            settings.update(existing_settings)
+            # Overwrite dbname with the new database name
+            if self.database_lineEdit.text():
+                settings["dbname"] = self.database_lineEdit.text()
+
+        return settings
+
+    def _get_manual_connection_parameters(self):
+        parameters = dict()
+
+        # Collect parameters from manual input fields
+        if self.parameters_host_lineEdit.text():
+            parameters["host"] = self.parameters_host_lineEdit.text()
+        if self.parameters_port_lineEdit.text():
+            parameters["port"] = self.parameters_port_lineEdit.text()
+        if self.parameters_ssl_comboBox.currentData():
+            parameters["sslmode"] = self.parameters_ssl_comboBox.currentData()
+        if self.parameters_user_lineEdit.text():
+            parameters["user"] = self.parameters_user_lineEdit.text()
+        if self.parameters_password_lineEdit.text():
+            parameters["password"] = self.parameters_password_lineEdit.text()
+        if self.database_lineEdit.text():
+            parameters["dbname"] = self.database_lineEdit.text()
+
+        return parameters

oqtopus/gui/database_duplicate_dialog.py

@@ -0,0 +1,100 @@
+# -----------------------------------------------------------
+#
+# Profile
+# Copyright (C) 2025  Damiano Lombardi
+# -----------------------------------------------------------
+#
+# licensed under the terms of GNU GPL 2
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, print to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# ---------------------------------------------------------------------
+
+import psycopg
+from pgserviceparser import service_config as pgserviceparser_service_config
+from qgis.PyQt.QtCore import Qt
+from qgis.PyQt.QtWidgets import QDialog, QMessageBox
+
+from ..utils.plugin_utils import PluginUtils
+from ..utils.qt_utils import OverrideCursor
+
+DIALOG_UI = PluginUtils.get_ui_class("database_duplicate_dialog.ui")
+
+
+class DatabaseDuplicateDialog(QDialog, DIALOG_UI):
+    def __init__(self, selected_service=None, parent=None):
+        QDialog.__init__(self, parent)
+        self.setupUi(self)
+
+        self.existingService_label.setText(selected_service)
+
+        self.__existing_service_config = pgserviceparser_service_config(selected_service)
+        self.existingDatabase_label.setText(self.__existing_service_config.get("dbname", ""))
+
+        self.buttonBox.accepted.connect(self._accept)
+
+    def _accept(self):
+
+        if self.newDatabase_lineEdit.text() == "":
+            QMessageBox.critical(self, "Error", "Please enter a database name.")
+            return
+
+        if self.newService_lineEdit.text() == "":
+            QMessageBox.critical(self, "Error", "Please enter a service name.")
+            return
+
+        service_name = self.existingService_label.text()
+        try:
+            database_connection = psycopg.connect(service=service_name)
+
+        except Exception as exception:
+            errorText = self.tr(f"Can't connect to service '{service_name}':\n{exception}.")
+            QMessageBox.critical(self, "Error", errorText)
+            return
+
+        # Duplicate the database
+        new_database_name = self.newDatabase_lineEdit.text()
+        try:
+            database_connection.autocommit = True
+            with OverrideCursor(Qt.CursorShape.WaitCursor):
+                with database_connection.cursor() as cursor:
+                    cursor.execute(
+                        f"CREATE DATABASE {new_database_name} TEMPLATE {self.__existing_service_config.get('dbname')}"
+                    )
+        except psycopg.Error as e:
+            errorText = self.tr(f"Error duplicating database:\n{e}.")
+            QMessageBox.critical(self, "Error", errorText)
+            return
+        finally:
+            database_connection.close()
+
+        # Create new service configuration
+        new_service_name = self.newService_lineEdit.text()
+        new_service_config = pgserviceparser_service_config(
+            new_service_name,
+            dbname=new_database_name,
+            host=self.__existing_service_config.get("host", ""),
+            port=self.__existing_service_config.get("port", ""),
+            user=self.__existing_service_config.get("user", ""),
+            password=self.__existing_service_config.get("password", ""),
+        )
+        try:
+            pgserviceparser_service_config.write_service_config(new_service_config)
+        except Exception as e:
+            errorText = self.tr(f"Error writing new service configuration:\n{e}.")
+            QMessageBox.critical(self, "Error", errorText)
+            return
+
+        super().accept()

oqtopus/gui/logs_widget.py

@@ -0,0 +1,177 @@
+import logging
+
+from qgis.PyQt.QtCore import QAbstractItemModel, QModelIndex, QSortFilterProxyModel, Qt
+from qgis.PyQt.QtWidgets import QAbstractItemView, QApplication, QStyle, QWidget
+
+from ..utils.plugin_utils import LoggingBridge, PluginUtils
+
+DIALOG_UI = PluginUtils.get_ui_class("logs_widget.ui")
+
+
+COLUMNS = ["Level", "Module", "Message"]
+
+
+class LogModel(QAbstractItemModel):
+    def __init__(self, parent=None):
+        QAbstractItemModel.__init__(self, parent)
+        self.logs = []
+
+    def add_log(self, log):
+        self.beginInsertRows(QModelIndex(), len(self.logs), len(self.logs))
+        self.logs.append(log)
+        self.endInsertRows()
+
+    def headerData(self, section: int, orientation: Qt.Orientation, role: Qt.ItemDataRole = None):
+        if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Horizontal:
+            return COLUMNS[section]
+        return None
+
+    def rowCount(self, parent=None):
+        return len(self.logs)
+
+    def columnCount(self, parent=None):
+        return len(COLUMNS)
+
+    def data(self, index: QModelIndex, role: Qt.ItemDataRole = None):
+        if not index.isValid() or role != Qt.ItemDataRole.DisplayRole:
+            return None
+        if (
+            index.row() < 0
+            or index.row() >= len(self.logs)
+            or index.column() < 0
+            or index.column() >= len(COLUMNS)
+        ):
+            return None
+        log = self.logs[index.row()]
+        return log[COLUMNS[index.column()]]
+
+    def index(self, row: int, column: int, parent=None):
+        if row < 0 or row >= len(self.logs) or column < 0 or column >= len(COLUMNS):
+            return QModelIndex()
+        return self.createIndex(row, column)
+
+    def parent(self, index: QModelIndex):
+        if not index.isValid():
+            return QModelIndex()
+        return QModelIndex()
+
+    def flags(self, index: QModelIndex):
+        return (
+            Qt.ItemFlag.ItemIsEnabled
+            | Qt.ItemFlag.ItemIsSelectable
+            | Qt.ItemFlag.ItemNeverHasChildren
+        )
+
+
+class LogFilterProxyModel(QSortFilterProxyModel):
+    LEVELS = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.level_filter = None
+
+    def setLevelFilter(self, level):
+        self.level_filter = level
+        self.invalidateFilter()
+
+    def filterAcceptsRow(self, source_row, source_parent):
+        model = self.sourceModel()
+        index_level = model.index(source_row, 0, source_parent)  # Level column
+        index_message = model.index(source_row, 2, source_parent)  # Message column
+        index_module = model.index(source_row, 1, source_parent)  # Module column
+        # Level filter (show entries with at least the selected level)
+        if self.level_filter and self.level_filter != "ALL":
+            level = model.data(index_level, Qt.ItemDataRole.DisplayRole)
+            try:
+                filter_idx = self.LEVELS.index(self.level_filter)
+                level_idx = self.LEVELS.index(level)
+                if level_idx < filter_idx:
+                    return False
+            except ValueError:
+                return False
+        # Text filter (from QLineEdit)
+        filter_text = self.filterRegularExpression().pattern()
+        if filter_text:
+            msg = model.data(index_message, Qt.ItemDataRole.DisplayRole) or ""
+            mod = model.data(index_module, Qt.ItemDataRole.DisplayRole) or ""
+            if filter_text.lower() not in msg.lower() and filter_text.lower() not in mod.lower():
+                return False
+        return True
+
+
+class LogsWidget(QWidget, DIALOG_UI):
+
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent)
+        self.setupUi(self)
+        self.loggingBridge = LoggingBridge(
+            level=logging.NOTSET, excluded_modules=["urllib3.connectionpool"]
+        )
+        self.logs_model = LogModel(self)
+
+        # Use custom proxy model
+        self.proxy_model = LogFilterProxyModel(self)
+        self.proxy_model.setSourceModel(self.logs_model)
+        self.proxy_model.setFilterCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
+        self.proxy_model.setFilterKeyColumn(-1)
+
+        self.logs_treeView.setModel(self.proxy_model)
+        self.logs_treeView.setAlternatingRowColors(True)
+        self.logs_treeView.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.logs_treeView.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        self.logs_treeView.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.loggingBridge.loggedLine.connect(self.__logged_line)
+        logging.getLogger().addHandler(self.loggingBridge)
+
+        self.logs_level_comboBox.addItems(
+            [
+                "DEBUG",
+                "INFO",
+                "WARNING",
+                "ERROR",
+                "CRITICAL",
+            ]
+        )
+        self.logs_level_comboBox.currentTextChanged.connect(self.proxy_model.setLevelFilter)
+        self.logs_level_comboBox.setCurrentText("INFO")
+
+        self.logs_openFile_toolButton.setIcon(
+            QApplication.style().standardIcon(QStyle.StandardPixmap.SP_FileIcon)
+        )
+        self.logs_openFolder_toolButton.setIcon(
+            QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DirOpenIcon)
+        )
+        self.logs_clear_toolButton.setIcon(
+            QApplication.style().standardIcon(QStyle.StandardPixmap.SP_TitleBarCloseButton)
+        )
+        self.logs_openFile_toolButton.clicked.connect(self.__logsOpenFileClicked)
+        self.logs_openFolder_toolButton.clicked.connect(self.__logsOpenFolderClicked)
+        self.logs_clear_toolButton.clicked.connect(self.__logsClearClicked)
+        self.logs_filter_LineEdit.textChanged.connect(self.proxy_model.setFilterFixedString)
+
+    def close(self):
+        # uninstall the logging bridge
+        logging.getLogger().removeHandler(self.loggingBridge)
+
+    def __logged_line(self, record, line):
+
+        log_entry = {
+            "Level": record.levelname,
+            "Module": record.name,
+            "Message": record.msg,
+        }
+
+        self.logs_model.add_log(log_entry)
+
+        # Automatically scroll to the bottom of the logs
+        scroll_bar = self.logs_treeView.verticalScrollBar()
+        scroll_bar.setValue(scroll_bar.maximum())
+
+    def __logsOpenFileClicked(self):
+        PluginUtils.open_log_file()
+
+    def __logsOpenFolderClicked(self):
+        PluginUtils.open_logs_folder()
+
+    def __logsClearClicked(self):
+        self.logs_model.clear()

oqtopus/gui/main_dialog.py

@@ -0,0 +1,168 @@
+# -----------------------------------------------------------
+#
+# Profile
+# Copyright (C) 2025  Damiano Lombardi
+# -----------------------------------------------------------
+#
+# licensed under the terms of GNU GPL 2
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, print to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# ---------------------------------------------------------------------
+
+
+import os
+import sys
+
+from qgis.PyQt.QtCore import QUrl
+from qgis.PyQt.QtGui import QAction, QDesktopServices
+from qgis.PyQt.QtWidgets import (
+    QDialog,
+    QMenuBar,
+)
+
+from ..utils.plugin_utils import PluginUtils, logger
+from .about_dialog import AboutDialog
+from .settings_dialog import SettingsDialog
+
+libs_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "libs"))
+if libs_path not in sys.path:
+    sys.path.insert(0, libs_path)
+
+from .database_connection_widget import DatabaseConnectionWidget  # noqa: E402
+from .logs_widget import LogsWidget  # noqa: E402
+from .module_selection_widget import ModuleSelectionWidget  # noqa: E402
+from .module_widget import ModuleWidget  # noqa: E402
+from .project_widget import ProjectWidget  # noqa: E402
+
+DIALOG_UI = PluginUtils.get_ui_class("main_dialog.ui")
+
+
+class MainDialog(QDialog, DIALOG_UI):
+
+    def __init__(self, modules_config, parent=None):
+        QDialog.__init__(self, parent)
+        self.setupUi(self)
+
+        self.buttonBox.rejected.connect(self.__closeDialog)
+        self.buttonBox.helpRequested.connect(self.__helpRequested)
+
+        # Init GUI Modules
+        self.__moduleSelectionWidget = ModuleSelectionWidget(modules_config, self)
+        self.moduleSelection_groupBox.layout().addWidget(self.__moduleSelectionWidget)
+
+        # Init GUI Database
+        self.__databaseConnectionWidget = DatabaseConnectionWidget(self)
+        self.db_groupBox.layout().addWidget(self.__databaseConnectionWidget)
+
+        # Init GUI Module Info
+        self.__moduleWidget = ModuleWidget(self)
+        self.module_tab.layout().addWidget(self.__moduleWidget)
+
+        # Init GUI Project
+        self.__projectWidget = ProjectWidget(self)
+        self.project_tab.layout().addWidget(self.__projectWidget)
+
+        # Init GUI Logs
+        self.__logsWidget = LogsWidget(self)
+        self.logs_groupBox.layout().addWidget(self.__logsWidget)
+
+        # Add menubar
+        self.menubar = QMenuBar(self)
+        # On macOS, setNativeMenuBar(False) to show the menu bar inside the dialog window
+        if sys.platform == "darwin":
+            self.menubar.setNativeMenuBar(False)
+        self.layout().setMenuBar(self.menubar)
+
+        # Settings action
+        settings_action = QAction(self.tr("Settings"), self)
+        settings_action.triggered.connect(self.__open_settings_dialog)
+
+        # About action
+        about_action = QAction(self.tr("About"), self)
+        about_action.triggered.connect(self.__show_about_dialog)
+
+        # Add actions to menubar
+        self.menubar.addAction(settings_action)
+        self.menubar.addAction(about_action)
+
+        self.__moduleSelectionWidget.signal_loadingStarted.connect(
+            self.__moduleSelection_loadingStarted
+        )
+        self.__moduleSelectionWidget.signal_loadingFinished.connect(
+            self.__moduleSelection_loadingFinished
+        )
+
+        self.__databaseConnectionWidget.signal_connectionChanged.connect(
+            self.__databaseConnectionWidget_connectionChanged
+        )
+
+        self.module_tab.setEnabled(False)
+        self.plugin_tab.setEnabled(False)
+        self.project_tab.setEnabled(False)
+
+        logger.info("Ready.")
+
+    def __closeDialog(self):
+        self.__moduleSelectionWidget.close()
+        self.__logsWidget.close()
+        self.accept()
+
+    def __helpRequested(self):
+        help_page = "https://github.com/oqtopus/Oqtopus"
+        logger.info(f"Opening help page {help_page}")
+        QDesktopServices.openUrl(QUrl(help_page))
+
+    def __open_settings_dialog(self):
+        dlg = SettingsDialog(self)
+        dlg.exec()
+
+    def __show_about_dialog(self):
+        dialog = AboutDialog(self)
+        dialog.exec()
+
+    def __moduleSelection_loadingStarted(self):
+        self.db_groupBox.setEnabled(False)
+        self.module_tab.setEnabled(False)
+        self.plugin_tab.setEnabled(False)
+        self.project_tab.setEnabled(False)
+
+    def __moduleSelection_loadingFinished(self):
+        self.db_groupBox.setEnabled(True)
+
+        module_package = self.__moduleSelectionWidget.getSelectedModulePackage()
+        if module_package is None:
+            return
+
+        if self.__moduleSelectionWidget.lastError() is not None:
+            return
+
+        self.module_tab.setEnabled(True)
+
+        if module_package.asset_plugin is not None:
+            self.plugin_tab.setEnabled(True)
+
+        if module_package.asset_project is not None:
+            self.project_tab.setEnabled(True)
+
+        self.__moduleWidget.setModulePackage(
+            self.__moduleSelectionWidget.getSelectedModulePackage()
+        )
+        self.__projectWidget.setModulePackage(
+            self.__moduleSelectionWidget.getSelectedModulePackage()
+        )
+
+    def __databaseConnectionWidget_connectionChanged(self):
+        self.__moduleWidget.setDatabaseConnection(self.__databaseConnectionWidget.getConnection())