Refactor get_plan_json.

Changed lambda call to use QNetworkRequest and created the required QNetworkProxy.

Changed settings to store Proxy host and port. Added lambda url to settings.

Author: Mtk112

arho_feature_template/core/plan_manager.py

@@ -1,24 +1,34 @@
 import json
 
-import requests  # type: ignore
 from qgis.core import QgsExpressionContextUtils, QgsProject, QgsVectorLayer
+from qgis.PyQt.QtCore import QByteArray, QUrl
+from qgis.PyQt.QtNetwork import QNetworkAccessManager, QNetworkProxy, QNetworkReply, QNetworkRequest
 from qgis.PyQt.QtWidgets import QDialog, QMessageBox
 from qgis.utils import iface
 
 from arho_feature_template.core.update_plan import LandUsePlan, update_selected_plan
 from arho_feature_template.gui.load_plan_dialog import LoadPlanDialog
 from arho_feature_template.gui.serialize_plan import SerializePlan
 from arho_feature_template.utils.db_utils import get_existing_database_connection_names
-from arho_feature_template.utils.misc_utils import get_active_plan_id, get_lambda_settings, handle_unsaved_changes
+from arho_feature_template.utils.misc_utils import get_active_plan_id, get_settings, handle_unsaved_changes
 
 
 class PlanManager:
     HTTP_STATUS_OK = 200
 
     def __init__(self):
+        # Init network manager
+        self.network_manager = QNetworkAccessManager()
+        proxy_host, proxy_port, self.lambda_url = get_settings()
+
+        # SOCKS5 Proxy
+        proxy = QNetworkProxy()
+        proxy.setType(QNetworkProxy.Socks5Proxy)
+        proxy.setHostName(proxy_host)
+        proxy.setPort(int(proxy_port))
+        self.network_manager.setProxy(proxy)
+
         self.kaava_layer = self.get_layer_by_name("Kaava")
-        lambda_host, lambda_port = get_lambda_settings()
-        self.lambda_url = f"https://{lambda_host}:{lambda_port}/v0/ryhti"
 
     def get_layer_by_name(self, layer_name):
         """Retrieve a layer by name from the project."""
@@ -119,8 +129,8 @@ def get_plan_json(self):
         """Serializes plan and plan outline to JSON"""
         dialog = SerializePlan()
         if dialog.exec_() == QDialog.Accepted:
-            json_plan_path = dialog.plan_widget.filePath()
-            json_plan_outline_path = dialog.plan_outline_widget.filePath()
+            json_plan_path = dialog.plan_path_edit.text()
+            json_plan_outline_path = dialog.plan_outline_path_edit.text()
 
             plan_id = get_active_plan_id()
 
@@ -129,43 +139,76 @@ def get_plan_json(self):
                 return
 
             payload = {"action": "get_plans", "plan_uuid": plan_id}
+            payload_bytes = QByteArray(json.dumps(payload).encode("utf-8"))
+
+            request = QNetworkRequest(QUrl(self.lambda_url))
+            request.setHeader(QNetworkRequest.ContentTypeHeader, "application/json")
+
+            reply = self.network_manager.post(request, payload_bytes)
+
+            # Connect the finished signal to a lambda to pass extra arguments
+            reply.finished.connect(lambda: self._handle_response(reply, json_plan_path, json_plan_outline_path))
+
+    def _handle_response(self, reply: QNetworkReply, json_plan_path: str, json_plan_outline_path: str):
+        """Handle the API response and process the plan and outline data."""
+        if reply.error() != QNetworkReply.NoError:
+            error_string = reply.errorString()
+            QMessageBox.critical(None, "Virhe API kutsussa", f"Virhe: {error_string}")
+            return
+
+        try:
+            response_data = reply.readAll().data().decode('utf-8')
+            response_json = json.loads(response_data)
+
+            details = response_json.get("details")
+            if not details:
+                QMessageBox.warning(None, "Varoitus", "Vastauksesta puuttuu 'details' kenttä.")
+                return
+
+            # Extract plan and write it to file
+            plan_id = get_active_plan_id()
+            if not plan_id:
+                QMessageBox.critical(None, "Virhe", "Ei aktiivista kaavaa.")
+                return
 
-            try:
-                response = requests.post(
-                    self.lambda_url, json=payload, headers={"Content-Type": "application/json"}, timeout=15
+            plan_json = details.get(plan_id)
+            if not plan_json:
+                QMessageBox.warning(None, "Varoitus", f"Aktiiviselle kaavalle (id: {plan_id}) ei löydy tietoja.")
+                return
+
+            with open(json_plan_path, "w", encoding="utf-8") as full_file:
+                json.dump(plan_json, full_file, ensure_ascii=False, indent=2)
+
+            # Process the geographicalArea for the outline
+            geographical_area = plan_json.get("geographicalArea")
+            if geographical_area:
+                try:
+                    # Build the structured outline JSON and write to file
+                    outline_json = {
+                        "type": "Feature",
+                        "properties": {
+                            "name": "Example Polygon"
+                        },
+                        "srid": geographical_area.get("srid"),
+                        "geometry": geographical_area.get("geometry"),
+                    }
+
+                    with open(json_plan_outline_path, "w", encoding="utf-8") as outline_file:
+                        json.dump(outline_json, outline_file, ensure_ascii=False, indent=2)
+
+                    QMessageBox.information(None, "Success", "Kaava ja sen ulkorja tallennettu onnistuneesti.")
+                except KeyError as e:
+                    QMessageBox.critical(
+                        None,
+                        "Virhe",
+                        f"'geographicalArea' ei sisällä vaadittuja tietoja: {e}",
+                    )
+            else:
+                QMessageBox.warning(
+                    None, "Varoitus", "Kenttä 'geographicalArea' puuttuu kaavan tiedoista."
                 )
-                if response.status_code == self.HTTP_STATUS_OK:
-                    response_json = response.json()
-
-                    # Extract the "details" part for the full JSON
-                    details = response_json.get("details")
-                    if details:
-                        # Extract the plan_json
-                        plan_json = details.get(plan_id)
-
-                        if plan_json:
-                            with open(json_plan_path, "w", encoding="utf-8") as full_file:
-                                json.dump(plan_json, full_file, ensure_ascii=False, indent=2)
-
-                            # Extract and save the plan outline
-                            geographical_area = plan_json.get("geographicalArea")
-                            if geographical_area:
-                                with open(json_plan_outline_path, "w", encoding="utf-8") as outline_file:
-                                    json.dump(
-                                        {"geographicalArea": geographical_area},
-                                        outline_file,
-                                        ensure_ascii=False,
-                                        indent=2,
-                                    )
-
-                            else:
-                                QMessageBox.warning(
-                                    None, "Warning", "The geographicalArea field is missing in the plan details."
-                                )
-                        else:
-                            QMessageBox.warning(None, "Warning", "No plan data found for the specified plan ID.")
-                    else:
-                        QMessageBox.warning(None, "Warning", "No details found in the response JSON.")
-
-            except requests.RequestException as e:
-                QMessageBox.critical(None, "Request Error", f"An error occurred: {e!s}")
+        except json.JSONDecodeError as e:
+            QMessageBox.critical(None, "Virhe", f"Vastaus JSON:in purkaminen epäonnistui: {e}")
+
+        # Clean up the reply
+        reply.deleteLater()

arho_feature_template/gui/plugin_settings.py

@@ -22,16 +22,19 @@ def load_settings(self):
         """Load settings from QSettings with default values."""
         settings = QSettings("ArhoFeatureTemplate")
 
-        lambda_host = settings.value("lambda_host", "localhost")
-        lambda_port = settings.value("lambda_port", "5435")
+        proxy_host = settings.value("proxy_host", "localhost")
+        proxy_port = settings.value("proxy_port", "5443")
+        lambda_url = settings.value("lambda_url", "https://t5w26iqnsf.execute-api.eu-central-1.amazonaws.com/v0/ryhti")
 
-        self.hostInput.setText(lambda_host)
-        self.portInput.setText(lambda_port)
+        self.hostInput.setText(proxy_host)
+        self.portInput.setText(proxy_port)
+        self.lambdaInput.setText(lambda_url)
 
     def save_settings(self):
         """Save settings to QSettings."""
         settings = QSettings("ArhoFeatureTemplate")
-        settings.setValue("lambda_host", self.hostInput.text())
-        settings.setValue("lambda_port", self.portInput.text())
+        settings.setValue("proxy_host", self.hostInput.text())
+        settings.setValue("proxy_port", self.portInput.text())
+        settings.setValue("lambda_url", self.lambdaInput.text())
 
         self.accept()

arho_feature_template/gui/plugin_settings.ui

@@ -17,7 +17,7 @@
    <item>
     <widget class="QLabel" name="labelHost">
      <property name="text">
-      <string>Lambdan isäntä:</string>
+      <string>Proxy isäntä:</string>
      </property>
     </widget>
    </item>
@@ -27,13 +27,23 @@
    <item>
     <widget class="QLabel" name="labelPort">
      <property name="text">
-      <string>Lambdan portti:</string>
+      <string>Proxy portti:</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QLineEdit" name="portInput"/>
    </item>
+   <item>
+    <widget class="QLabel" name="labelLambda">
+     <property name="text">
+      <string>Lambdan osoite:</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QLineEdit" name="lambdaInput"/>
+   </item>
    <item>
     <widget class="QPushButton" name="saveButton">
      <property name="text">

arho_feature_template/gui/serialize_plan.py

@@ -1,7 +1,7 @@
 from importlib import resources
 
 from qgis.PyQt import uic
-from qgis.PyQt.QtWidgets import QDialog, QDialogButtonBox
+from qgis.PyQt.QtWidgets import QDialog, QDialogButtonBox, QFileDialog, QLineEdit, QPushButton
 
 ui_path = resources.files(__package__) / "serialize_plan.ui"
 FormClass, _ = uic.loadUiType(ui_path)
@@ -12,22 +12,37 @@ def __init__(self):
         super().__init__()
         self.setupUi(self)
 
-        # Connect the buttons and initialize
+        self.plan_outline_path_edit = self.findChild(QLineEdit, "plan_outline_path_edit")
+        self.plan_path_edit = self.findChild(QLineEdit, "plan_path_edit")
+        self.plan_outline_select_button = self.findChild(QPushButton, "plan_outline_select_button")
+        self.plan_select_button = self.findChild(QPushButton, "plan_select_button")
+
+        self.plan_outline_select_button.clicked.connect(self.select_plan_outline_file)
+        self.plan_select_button.clicked.connect(self.select_plan_file)
+
+        # Disable Save button initially
         self.buttonBox.button(QDialogButtonBox.Save).setEnabled(False)
         self.buttonBox.accepted.connect(self.accept)
         self.buttonBox.rejected.connect(self.reject)
 
-        # Connect to file widgets' signal to check inputs
-        self.plan_widget.fileChanged.connect(self.check_inputs)
-        self.plan_outline_widget.fileChanged.connect(self.check_inputs)
+    def select_plan_outline_file(self):
+        file_path, _ = QFileDialog.getSaveFileName(self, "Valitse kaavan ulkorajan tallennuspolku", "", "JSON Files (*.json)")
+        if file_path:
+            self.plan_outline_path_edit.setText(file_path)
+            self.check_inputs()
+
+    def select_plan_file(self):
+        file_path, _ = QFileDialog.getSaveFileName(self, "Valitse kaavan tallennuspolku", "", "JSON Files (*.json)")
+        if file_path:
+            self.plan_path_edit.setText(file_path)
+            self.check_inputs()
 
     def check_inputs(self):
-        # Enable save button if both file paths are set
-        if self.plan_widget.filePath() and self.plan_outline_widget.filePath():
+        # Enable Save button if both text fields have paths
+        if self.plan_outline_path_edit.text() and self.plan_path_edit.text():
             self.buttonBox.button(QDialogButtonBox.Save).setEnabled(True)
         else:
             self.buttonBox.button(QDialogButtonBox.Save).setEnabled(False)
 
     def get_paths(self):
-        # Retrieve the paths from the QgsFileWidgets
-        return self.plan_widget.filePath(), self.plan_outline_widget.filePath()
+        return self.plan_outline_path_edit.text(), self.plan_path_edit.text()

arho_feature_template/gui/serialize_plan.ui

@@ -1,113 +1,89 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>SerializePlan</class>
+ <class>Dialog</class>
  <widget class="QDialog" name="Dialog">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>395</width>
-    <height>204</height>
+    <width>558</width>
+    <height>193</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Tallenna kaava JSON</string>
   </property>
   <widget class="QDialogButtonBox" name="buttonBox">
-   <property name="enabled">
-    <bool>true</bool>
-   </property>
    <property name="geometry">
     <rect>
      <x>20</x>
-     <y>160</y>
-     <width>341</width>
+     <y>150</y>
+     <width>521</width>
      <height>32</height>
     </rect>
    </property>
-   <property name="orientation">
-    <enum>Qt::Horizontal</enum>
-   </property>
    <property name="standardButtons">
     <set>QDialogButtonBox::Cancel|QDialogButtonBox::Save</set>
    </property>
    <property name="centerButtons">
     <bool>true</bool>
    </property>
   </widget>
-  <widget class="QWidget" name="verticalLayoutWidget">
+  <widget class="QWidget" name="layoutWidget">
    <property name="geometry">
     <rect>
-     <x>30</x>
-     <y>30</y>
-     <width>341</width>
-     <height>111</height>
+     <x>20</x>
+     <y>20</y>
+     <width>521</width>
+     <height>120</height>
     </rect>
    </property>
-   <layout class="QVBoxLayout" name="verticalLayout">
-    <item>
+   <layout class="QGridLayout" name="gridLayout">
+    <item row="0" column="0">
      <widget class="QLabel" name="plan_outline_label">
       <property name="text">
        <string>Kaavan ulkorajan tallennuspolku:</string>
       </property>
      </widget>
     </item>
-    <item>
-     <widget class="QgsFileWidget" name="plan_widget"/>
+    <item row="0" column="1">
+     <widget class="QLineEdit" name="plan_outline_path_edit">
+      <property name="readOnly">
+       <bool>true</bool>
+      </property>
+     </widget>
+    </item>
+    <item row="0" column="2">
+     <widget class="QPushButton" name="plan_outline_select_button">
+      <property name="text">
+       <string>Valitse...</string>
+      </property>
+     </widget>
     </item>
-    <item>
+    <item row="1" column="0">
      <widget class="QLabel" name="plan_label">
       <property name="text">
        <string>Kaavan tallennuspolku:</string>
       </property>
      </widget>
     </item>
-    <item>
-     <widget class="QgsFileWidget" name="plan_outline_widget"/>
+    <item row="1" column="1">
+     <widget class="QLineEdit" name="plan_path_edit">
+      <property name="readOnly">
+       <bool>true</bool>
+      </property>
+     </widget>
+    </item>
+    <item row="1" column="2">
+     <widget class="QPushButton" name="plan_select_button">
+      <property name="text">
+       <string>Valitse...</string>
+      </property>
+     </widget>
     </item>
    </layout>
   </widget>
  </widget>
- <customwidgets>
-  <customwidget>
-   <class>QgsFileWidget</class>
-   <extends>QWidget</extends>
-   <header>qgsfilewidget.h</header>
-  </customwidget>
- </customwidgets>
  <resources/>
- <connections>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>accepted()</signal>
-   <receiver>SerializePlan</receiver>
-   <slot>accept()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>248</x>
-     <y>254</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>157</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>rejected()</signal>
-   <receiver>SerializePlan</receiver>
-   <slot>reject()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>316</x>
-     <y>260</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>286</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
+ <connections/>
 </ui>

arho_feature_template/utils/misc_utils.py

@@ -64,9 +64,10 @@ def get_active_plan_id():
     return QgsExpressionContextUtils.projectScope(QgsProject.instance()).variable("active_plan_id")
 
 
-def get_lambda_settings():
-    """Retrieve Lambda settings, using defaults if not set."""
+def get_settings():
+    """Retrieve stored settings, using defaults if not set."""
     settings = QSettings("ArhoFeatureTemplate")
-    lambda_host = settings.value("lambda_host", "localhost")
-    lambda_port = settings.value("lambda_port", "5443")
-    return lambda_host, lambda_port
+    proxy_host = settings.value("proxy_host", "localhost")
+    proxy_port = settings.value("proxy_port", "5443")
+    lambda_url = settings.value("lambda_url", "https://t5w26iqnsf.execute-api.eu-central-1.amazonaws.com/v0/ryhti")
+    return proxy_host, proxy_port, lambda_url