Added functionality to load existing plan.

Added dialog for loading plan.
Added database connection selection, searchable listing of all plans in the database.
Filtering of layers based on id of selected plan.

Author: Mtk112

arho_feature_template/core/exceptions.py

@@ -0,0 +1,5 @@
+from arho_feature_template.qgis_plugin_tools.tools.exceptions import QgsPluginException
+
+
+class AuthConfigException(QgsPluginException):
+    pass

arho_feature_template/core/update_plan.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+
+from qgis.core import QgsMapLayer, QgsProject, QgsVectorLayer
+from qgis.utils import iface
+
+
+# To be extended and moved
+@dataclass
+class LandUsePlan:
+    id: str
+
+
+# To be replaced later
+LAYER_PLAN_ID_MAP = {
+    "Kaava": "id",
+    "Maankäytön kohteet": "plan_id",
+    "Muut pisteet": "plan_id",
+    "Viivat": "plan_id",
+    "Aluevaraus": "plan_id",
+    "Osa-alue": "plan_id",
+}
+
+
+def update_selected_plan(new_plan: LandUsePlan):
+    """Update the project layers based on the selected land use plan."""
+    plan_id = new_plan.id
+
+    for layer_name, field_name in LAYER_PLAN_ID_MAP.items():
+        # Set the filter on each layer using the plan_id
+        set_filter_for_vector_layer(layer_name, field_name, plan_id)
+
+
+def set_filter_for_vector_layer(layer_name: str, field_name: str, field_value: str):
+    """Set a filter for the given vector layer."""
+    layers = QgsProject.instance().mapLayersByName(layer_name)
+
+    if not _check_layer_count(layers):
+        return
+
+    layer = layers[0]
+
+    # Create the filter expression directly based on the plan_id
+    expression = f"\"{field_name}\" = '{field_value}'"  # Properly formatted filter expression
+
+    # Apply the filter to the layer
+    if not layer.setSubsetString(expression):
+        iface.messageBar().pushMessage("Error", f"Failed to filter layer {layer_name} with query {expression}", level=3)
+
+
+def _check_layer_count(layers: list) -> bool:
+    """Check if any layers are returned."""
+    if not layers:
+        iface.messageBar().pushMessage("Error", "ERROR: No layers found with the specified name.", level=3)
+        return False
+    return True
+
+
+def _check_vector_layer(layer: QgsMapLayer) -> bool:
+    """Check if the given layer is a vector layer."""
+    if not isinstance(layer, QgsVectorLayer):
+        iface.messageBar().pushMessage("Error", f"Layer {layer.name()} is not a vector layer: {type(layer)}", level=3)
+        return False
+    return True

arho_feature_template/gui/ask_credentials.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from importlib import resources
+
+from qgis.PyQt import uic
+from qgis.PyQt.QtWidgets import QDialog, QDialogButtonBox, QLineEdit
+
+# Load the .ui file path using importlib resources
+ui_path = resources.files(__package__) / "ask_credentials.ui"
+
+# Use uic.loadUiType to load the UI definition from the .ui file
+DbAskCredentialsDialogBase, _ = uic.loadUiType(ui_path)
+
+
+class DbAskCredentialsDialog(QDialog, DbAskCredentialsDialogBase):  # type: ignore
+    def __init__(self, parent: QDialog = None):
+        super().__init__(parent)
+
+        # Set up the UI from the loaded .ui file
+        self.setupUi(self)
+
+        # The UI elements defined in the .ui file
+        self.userLineEdit: QLineEdit = self.findChild(QLineEdit, "userLineEdit")
+        self.pwdLineEdit: QLineEdit = self.findChild(QLineEdit, "pwdLineEdit")
+        self.buttonBox: QDialogButtonBox = self.findChild(QDialogButtonBox, "buttonBox")
+
+        # Connect the OK and Cancel buttons to their respective functions
+        self.buttonBox.accepted.connect(self.accept)
+        self.buttonBox.rejected.connect(self.reject)
+
+    def get_credentials(self) -> tuple[str, str]:
+        """
+        Returns the entered username and password.
+        :return: Tuple (username, password)
+        """
+        return self.userLineEdit.text(), self.pwdLineEdit.text()

arho_feature_template/gui/ask_credentials.ui

@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>DbAskCredentialsDialogBase</class>
+ <widget class="QDialog" name="DbAskCredentialsDialogBase">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>200</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Käyttäjän autentikaatio</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QFormLayout" name="formLayout">
+     <item row="0" column="0">
+      <widget class="QLabel" name="label_username">
+       <property name="text">
+        <string>Käyttäjä:</string>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="1">
+      <widget class="QLineEdit" name="userLineEdit">
+       <property name="placeholderText">
+        <string>Käyttäjä...</string>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="0">
+      <widget class="QLabel" name="label_password">
+       <property name="text">
+        <string>Salasana:</string>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="1">
+      <widget class="QLineEdit" name="pwdLineEdit">
+       <property name="placeholderText">
+        <string>Salasana...</string>
+       </property>
+       <property name="echoMode">
+        <enum>QLineEdit::Password</enum>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

arho_feature_template/gui/connection_selection_dialog.py

@@ -0,0 +1,178 @@
+from importlib import resources
+
+import psycopg2
+from qgis.PyQt import uic
+from qgis.PyQt.QtCore import QRegularExpression, QSortFilterProxyModel, Qt
+from qgis.PyQt.QtGui import QStandardItem, QStandardItemModel
+from qgis.PyQt.QtWidgets import QComboBox, QDialog, QLineEdit, QMessageBox, QPushButton, QTableView
+
+from arho_feature_template.gui.ask_credentials import DbAskCredentialsDialog
+from arho_feature_template.utils.db_utils import get_db_connection_params
+
+ui_path = resources.files(__package__) / "connection_selection_dialog.ui"
+
+ConnectionSelectionDialogBase, _ = uic.loadUiType(ui_path)
+
+
+class PlanFilterProxyModel(QSortFilterProxyModel):
+    def filterAcceptsRow(self, source_row, source_parent):  # noqa: N802
+        model = self.sourceModel()
+        if not model:
+            return False
+
+        filter_text = self.filterRegularExpression().pattern()
+        if not filter_text:
+            return True
+
+        for column in range(5):
+            index = model.index(source_row, column, source_parent)
+            data = model.data(index)
+            if data and filter_text.lower() in data.lower():
+                return True
+
+        return False
+
+
+class ConnectionSelectionDialog(QDialog, ConnectionSelectionDialogBase):  # type: ignore
+    def __init__(self, parent, connections):
+        super().__init__(parent)
+
+        uic.loadUi(ui_path, self)
+
+        self.connectionComboBox: QComboBox = self.findChild(QComboBox, "connectionComboBox")
+        self.planTableView: QTableView = self.findChild(QTableView, "planTableView")
+        self.okButton: QPushButton = self.findChild(QPushButton, "okButton")
+
+        self.searchLineEdit: QLineEdit = self.findChild(QLineEdit, "searchLineEdit")
+        self.searchLineEdit.setPlaceholderText("Etsi kaavoja...")
+
+        self.connectionComboBox.addItems(connections)
+
+        self.connectionComboBox.currentIndexChanged.connect(self.load_plans)
+        self.okButton.clicked.connect(self.accept)
+
+        self.okButton.setEnabled(False)
+
+        self.filterProxyModel = PlanFilterProxyModel(self)
+        self.filterProxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
+
+        self.planTableView.setModel(self.filterProxyModel)
+        self.searchLineEdit.textChanged.connect(self.filter_plans)
+
+        self.selected_plan_id = None
+
+    def load_plans(self):
+        selected_connection = self.connectionComboBox.currentText()
+        if not selected_connection:
+            self.planTableView.setModel(QStandardItemModel())
+            return
+
+        cursor = None
+        conn = None
+
+        try:
+            conn_params = get_db_connection_params(selected_connection)
+
+            if not conn_params.get("user") or not conn_params.get("password"):
+                # Trigger dialog to ask for missing credentials
+                dialog = DbAskCredentialsDialog(self)
+                dialog.rejected.connect(self.reject)
+                if dialog.exec() == QDialog.Accepted:
+                    user, password = dialog.get_credentials()
+                    conn_params["user"] = user
+                    conn_params["password"] = password
+
+            conn = psycopg2.connect(
+                host=conn_params["host"],
+                port=conn_params["port"],
+                dbname=conn_params["dbname"],
+                user=conn_params["user"],
+                password=conn_params["password"],
+                sslmode=conn_params["sslmode"],
+            )
+
+            cursor = conn.cursor()
+
+            cursor.execute("""
+                SELECT
+                    p.id,
+                    p.producers_plan_identifier,
+                    p.name ->> 'fin' AS name_fin,
+                    l.name ->> 'fin' AS lifecycle_status_fin,
+                    pt.name ->> 'fin' AS plan_type_fin
+                FROM
+                    hame.plan p
+                LEFT JOIN
+                    codes.lifecycle_status l
+                ON
+                    p.lifecycle_status_id = l.id
+                LEFT JOIN
+                    codes.plan_type pt
+                ON
+                    p.plan_type_id = pt.id;
+            """)
+            plans = cursor.fetchall()
+
+            model = QStandardItemModel(len(plans), 5)
+            model.setHorizontalHeaderLabels(
+                [
+                    "ID",
+                    "Tuottajan kaavatunnus",
+                    "Nimi",
+                    "Kaavan elinkaaren tila",
+                    "Kaavalaji",
+                ]
+            )
+
+            for row_idx, plan in enumerate(plans):
+                model.setItem(row_idx, 0, QStandardItem(str(plan[0])))  # id
+                model.setItem(row_idx, 1, QStandardItem(str(plan[1])))  # producer_plan_identifier
+                model.setItem(row_idx, 2, QStandardItem(str(plan[2])))  # name_fin
+                model.setItem(row_idx, 3, QStandardItem(str(plan[3])))  # lifecycle_status_fin
+                model.setItem(row_idx, 4, QStandardItem(str(plan[4])))  # plan_type_fin
+
+            self.filterProxyModel.setSourceModel(model)
+
+            self.planTableView.setSelectionMode(QTableView.SingleSelection)
+            self.planTableView.setSelectionBehavior(QTableView.SelectRows)
+
+            self.planTableView.selectionModel().selectionChanged.connect(self.on_selection_changed)
+
+        except ValueError as ve:
+            QMessageBox.critical(self, "Connection Error", str(ve))
+            self.planTableView.setModel(QStandardItemModel())
+
+        except Exception as e:  # noqa: BLE001
+            QMessageBox.critical(self, "Error", f"Failed to load plans: {e}")
+            self.planTableView.setModel(QStandardItemModel())
+
+        finally:
+            if cursor:
+                cursor.close()
+            if conn:
+                conn.close()
+
+    def filter_plans(self):
+        search_text = self.searchLineEdit.text()
+        if search_text:
+            search_regex = QRegularExpression(search_text)
+            self.filterProxyModel.setFilterRegularExpression(search_regex)
+        else:
+            self.filterProxyModel.setFilterRegularExpression("")
+
+    def on_selection_changed(self):
+        # Enable the OK button only if a row is selected
+        selection = self.planTableView.selectionModel().selectedRows()
+        if selection:
+            selected_row = selection[0].row()
+            self.selected_plan_id = self.planTableView.model().index(selected_row, 0).data()
+            self.okButton.setEnabled(True)
+        else:
+            self.selected_plan_id = None
+            self.okButton.setEnabled(False)
+
+    def get_selected_connection(self):
+        return self.connectionComboBox.currentText()
+
+    def get_selected_plan_id(self):
+        return self.selected_plan_id