Merge branch 'master' into feature_unify_pause_at_height

plugins/3MFReader/ThreeMFReader.py

@@ -88,7 +88,10 @@ class ThreeMFReader(MeshReader):
     #   \returns Scene node.
     def _convertSavitarNodeToUMNode(self, savitar_node: Savitar.SceneNode, file_name: str = "") -> Optional[SceneNode]:
         self._object_count += 1
-        node_name = "Object %s" % self._object_count
+
+        node_name = savitar_node.getName()
+        if node_name == "":
+            node_name = "Object %s" % self._object_count
 
         active_build_plate = CuraApplication.getInstance().getMultiBuildPlateModel().activeBuildPlate
 

plugins/3MFWriter/ThreeMFWorkspaceWriter.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2018 Ultimaker B.V.
+# Copyright (c) 2020 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 import configparser
@@ -6,9 +6,12 @@ from io import StringIO
 import zipfile
 
 from UM.Application import Application
+from UM.Logger import Logger
 from UM.Preferences import Preferences
 from UM.Settings.ContainerRegistry import ContainerRegistry
 from UM.Workspace.WorkspaceWriter import WorkspaceWriter
+from UM.i18n import i18nCatalog
+catalog = i18nCatalog("cura")
 
 from cura.Utils.Threading import call_on_qt_thread
 
@@ -25,6 +28,8 @@ class ThreeMFWorkspaceWriter(WorkspaceWriter):
         mesh_writer = application.getMeshFileHandler().getWriter("3MFWriter")
 
         if not mesh_writer:  # We need to have the 3mf mesh writer, otherwise we can't save the entire workspace
+            self.setInformation(catalog.i18nc("@error:zip", "3MF Writer plug-in is corrupt."))
+            Logger.error("3MF Writer class is unavailable. Can't write workspace.")
             return False
 
         # Indicate that the 3mf mesh writer should not close the archive just yet (we still need to add stuff to it).
@@ -37,19 +42,24 @@ class ThreeMFWorkspaceWriter(WorkspaceWriter):
 
         global_stack = machine_manager.activeMachine
 
-        # Add global container stack data to the archive.
-        self._writeContainerToArchive(global_stack, archive)
+        try:
+            # Add global container stack data to the archive.
+            self._writeContainerToArchive(global_stack, archive)
 
-        # Also write all containers in the stack to the file
-        for container in global_stack.getContainers():
-            self._writeContainerToArchive(container, archive)
-
-        # Check if the machine has extruders and save all that data as well.
-        for extruder_stack in global_stack.extruders.values():
-            self._writeContainerToArchive(extruder_stack, archive)
-            for container in extruder_stack.getContainers():
+            # Also write all containers in the stack to the file
+            for container in global_stack.getContainers():
                 self._writeContainerToArchive(container, archive)
 
+            # Check if the machine has extruders and save all that data as well.
+            for extruder_stack in global_stack.extruders.values():
+                self._writeContainerToArchive(extruder_stack, archive)
+                for container in extruder_stack.getContainers():
+                    self._writeContainerToArchive(container, archive)
+        except PermissionError:
+            self.setInformation(catalog.i18nc("@error:zip", "No permission to write the workspace here."))
+            Logger.error("No permission to write workspace to this stream.")
+            return False
+
         # Write preferences to archive
         original_preferences = Application.getInstance().getPreferences() #Copy only the preferences that we use to the workspace.
         temp_preferences = Preferences()
@@ -59,24 +69,29 @@ class ThreeMFWorkspaceWriter(WorkspaceWriter):
         preferences_string = StringIO()
         temp_preferences.writeToFile(preferences_string)
         preferences_file = zipfile.ZipInfo("Cura/preferences.cfg")
-        archive.writestr(preferences_file, preferences_string.getvalue())
+        try:
+            archive.writestr(preferences_file, preferences_string.getvalue())
 
-        # Save Cura version
-        version_file = zipfile.ZipInfo("Cura/version.ini")
-        version_config_parser = configparser.ConfigParser(interpolation = None)
-        version_config_parser.add_section("versions")
-        version_config_parser.set("versions", "cura_version", application.getVersion())
-        version_config_parser.set("versions", "build_type", application.getBuildType())
-        version_config_parser.set("versions", "is_debug_mode", str(application.getIsDebugMode()))
+            # Save Cura version
+            version_file = zipfile.ZipInfo("Cura/version.ini")
+            version_config_parser = configparser.ConfigParser(interpolation = None)
+            version_config_parser.add_section("versions")
+            version_config_parser.set("versions", "cura_version", application.getVersion())
+            version_config_parser.set("versions", "build_type", application.getBuildType())
+            version_config_parser.set("versions", "is_debug_mode", str(application.getIsDebugMode()))
 
-        version_file_string = StringIO()
-        version_config_parser.write(version_file_string)
-        archive.writestr(version_file, version_file_string.getvalue())
+            version_file_string = StringIO()
+            version_config_parser.write(version_file_string)
+            archive.writestr(version_file, version_file_string.getvalue())
 
-        self._writePluginMetadataToArchive(archive)
+            self._writePluginMetadataToArchive(archive)
 
-        # Close the archive & reset states.
-        archive.close()
+            # Close the archive & reset states.
+            archive.close()
+        except PermissionError:
+            self.setInformation(catalog.i18nc("@error:zip", "No permission to write the workspace here."))
+            Logger.error("No permission to write workspace to this stream.")
+            return False
         mesh_writer.setStoreArchive(False)
         return True
 

plugins/3MFWriter/ThreeMFWriter.py

@@ -77,6 +77,7 @@ class ThreeMFWriter(MeshWriter):
             return
 
         savitar_node = Savitar.SceneNode()
+        savitar_node.setName(um_node.getName())
 
         node_matrix = um_node.getLocalTransformation()
 

plugins/CuraDrive/src/CreateBackupJob.py

@@ -0,0 +1,134 @@
+# Copyright (c) 2020 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+import json
+import threading
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+import sentry_sdk
+from PyQt5.QtNetwork import QNetworkReply
+
+from UM.Job import Job
+from UM.Logger import Logger
+from UM.Message import Message
+from UM.TaskManagement.HttpRequestManager import HttpRequestManager
+from UM.TaskManagement.HttpRequestScope import JsonDecoratorScope
+from UM.i18n import i18nCatalog
+from cura.CuraApplication import CuraApplication
+from cura.UltimakerCloud.UltimakerCloudScope import UltimakerCloudScope
+
+catalog = i18nCatalog("cura")
+
+
+class CreateBackupJob(Job):
+    """Creates backup zip, requests upload url and uploads the backup file to cloud storage."""
+
+    MESSAGE_TITLE = catalog.i18nc("@info:title", "Backups")
+    DEFAULT_UPLOAD_ERROR_MESSAGE = catalog.i18nc("@info:backup_status", "There was an error while uploading your backup.")
+
+    def __init__(self, api_backup_url: str) -> None:
+        """ Create a new backup Job. start the job by calling start()
+
+        :param api_backup_url: The url of the 'backups' endpoint of the Cura Drive Api
+        """
+
+        super().__init__()
+
+        self._api_backup_url = api_backup_url
+        self._json_cloud_scope = JsonDecoratorScope(UltimakerCloudScope(CuraApplication.getInstance()))
+
+        self._backup_zip = None  # type: Optional[bytes]
+        self._job_done = threading.Event()
+        """Set when the job completes. Does not indicate success."""
+        self.backup_upload_error_message = ""
+        """After the job completes, an empty string indicates success. Othrerwise, the value is a translated message."""
+
+    def run(self) -> None:
+        upload_message = Message(catalog.i18nc("@info:backup_status", "Creating your backup..."), title = self.MESSAGE_TITLE, progress = -1)
+        upload_message.show()
+        CuraApplication.getInstance().processEvents()
+        cura_api = CuraApplication.getInstance().getCuraAPI()
+        self._backup_zip, backup_meta_data = cura_api.backups.createBackup()
+
+        if not self._backup_zip or not backup_meta_data:
+            self.backup_upload_error_message = catalog.i18nc("@info:backup_status", "There was an error while creating your backup.")
+            upload_message.hide()
+            return
+
+        upload_message.setText(catalog.i18nc("@info:backup_status", "Uploading your backup..."))
+        CuraApplication.getInstance().processEvents()
+
+        # Create an upload entry for the backup.
+        timestamp = datetime.now().isoformat()
+        backup_meta_data["description"] = "{}.backup.{}.cura.zip".format(timestamp, backup_meta_data["cura_release"])
+        self._requestUploadSlot(backup_meta_data, len(self._backup_zip))
+
+        self._job_done.wait()
+        if self.backup_upload_error_message == "":
+            upload_message.setText(catalog.i18nc("@info:backup_status", "Your backup has finished uploading."))
+            upload_message.setProgress(None)  # Hide progress bar
+        else:
+            # some error occurred. This error is presented to the user by DrivePluginExtension
+            upload_message.hide()
+
+    def _requestUploadSlot(self, backup_metadata: Dict[str, Any], backup_size: int) -> None:
+        """Request a backup upload slot from the API.
+
+        :param backup_metadata: A dict containing some meta data about the backup.
+        :param backup_size: The size of the backup file in bytes.
+        """
+
+        payload = json.dumps({"data": {"backup_size": backup_size,
+                                       "metadata": backup_metadata
+                                       }
+                              }).encode()
+
+        HttpRequestManager.getInstance().put(
+            self._api_backup_url,
+            data = payload,
+            callback = self._onUploadSlotCompleted,
+            error_callback = self._onUploadSlotCompleted,
+            scope = self._json_cloud_scope)
+
+    def _onUploadSlotCompleted(self, reply: QNetworkReply, error: Optional["QNetworkReply.NetworkError"] = None) -> None:
+        if HttpRequestManager.safeHttpStatus(reply) >= 300:
+            replyText = HttpRequestManager.readText(reply)
+            Logger.warning("Could not request backup upload: %s", replyText)
+            self.backup_upload_error_message = self.DEFAULT_UPLOAD_ERROR_MESSAGE
+
+            if HttpRequestManager.safeHttpStatus(reply) == 400:
+                errors = json.loads(replyText)["errors"]
+                if "moreThanMaximum" in [error["code"] for error in errors if error["meta"] and error["meta"]["field_name"] == "backup_size"]:
+                    if self._backup_zip is None:  # will never happen; keep mypy happy
+                        zip_error = "backup is None."
+                    else:
+                        zip_error = "{} exceeds max size.".format(str(len(self._backup_zip)))
+                    sentry_sdk.capture_message("backup failed: {}".format(zip_error), level ="warning")
+                    self.backup_upload_error_message = catalog.i18nc("@error:file_size", "The backup exceeds the maximum file size.")
+                    from sentry_sdk import capture_message
+
+            self._job_done.set()
+            return
+
+        if error is not None:
+            Logger.warning("Could not request backup upload: %s", HttpRequestManager.qt_network_error_name(error))
+            self.backup_upload_error_message = self.DEFAULT_UPLOAD_ERROR_MESSAGE
+            self._job_done.set()
+            return
+
+        backup_upload_url = HttpRequestManager.readJSON(reply)["data"]["upload_url"]
+
+        # Upload the backup to storage.
+        HttpRequestManager.getInstance().put(
+            backup_upload_url,
+            data=self._backup_zip,
+            callback=self._uploadFinishedCallback,
+            error_callback=self._uploadFinishedCallback
+        )
+
+    def _uploadFinishedCallback(self, reply: QNetworkReply, error: QNetworkReply.NetworkError = None):
+        if not HttpRequestManager.replyIndicatesSuccess(reply, error):
+            Logger.log("w", "Could not upload backup file: %s", HttpRequestManager.readText(reply))
+            self.backup_upload_error_message = self.DEFAULT_UPLOAD_ERROR_MESSAGE
+
+        self._job_done.set()

plugins/CuraDrive/src/DriveApiService.py

@@ -1,90 +1,70 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-import base64
-import hashlib
-from datetime import datetime
-from tempfile import NamedTemporaryFile
-from typing import Any, Optional, List, Dict
+from typing import Any, Optional, List, Dict, Callable
 
-import requests
+from PyQt5.QtNetwork import QNetworkReply
 
 from UM.Logger import Logger
-from UM.Message import Message
 from UM.Signal import Signal, signalemitter
+from UM.TaskManagement.HttpRequestManager import HttpRequestManager
+from UM.TaskManagement.HttpRequestScope import JsonDecoratorScope
+from UM.i18n import i18nCatalog
 from cura.CuraApplication import CuraApplication
-
-from .UploadBackupJob import UploadBackupJob
+from cura.UltimakerCloud.UltimakerCloudScope import UltimakerCloudScope
+from .CreateBackupJob import CreateBackupJob
+from .RestoreBackupJob import RestoreBackupJob
 from .Settings import Settings
 
-from UM.i18n import i18nCatalog
 catalog = i18nCatalog("cura")
 
 
-## The DriveApiService is responsible for interacting with the CuraDrive API and Cura's backup handling.
 @signalemitter
 class DriveApiService:
+    """The DriveApiService is responsible for interacting with the CuraDrive API and Cura's backup handling."""
+
     BACKUP_URL = "{}/backups".format(Settings.DRIVE_API_URL)
 
-    # Emit signal when restoring backup started or finished.
     restoringStateChanged = Signal()
+    """Emits signal when restoring backup started or finished."""
 
-    # Emit signal when creating backup started or finished.
     creatingStateChanged = Signal()
+    """Emits signal when creating backup started or finished."""
 
     def __init__(self) -> None:
         self._cura_api = CuraApplication.getInstance().getCuraAPI()
+        self._json_cloud_scope = JsonDecoratorScope(UltimakerCloudScope(CuraApplication.getInstance()))
 
-    def getBackups(self) -> List[Dict[str, Any]]:
-        access_token = self._cura_api.account.accessToken
-        if not access_token:
-            Logger.log("w", "Could not get access token.")
-            return []
-        try:
-            backup_list_request = requests.get(self.BACKUP_URL, headers = {
-                "Authorization": "Bearer {}".format(access_token)
-            })
-        except requests.exceptions.ConnectionError:
-            Logger.logException("w", "Unable to connect with the server.")
-            return []
+    def getBackups(self, changed: Callable[[List[Dict[str, Any]]], None]) -> None:
+        def callback(reply: QNetworkReply, error: Optional["QNetworkReply.NetworkError"] = None) -> None:
+            if error is not None:
+                Logger.log("w", "Could not get backups: " + str(error))
+                changed([])
+                return
 
-        # HTTP status 300s mean redirection. 400s and 500s are errors.
-        # Technically 300s are not errors, but the use case here relies on "requests" to handle redirects automatically.
-        if backup_list_request.status_code >= 300:
-            Logger.log("w", "Could not get backups list from remote: %s", backup_list_request.text)
-            Message(catalog.i18nc("@info:backup_status", "There was an error listing your backups."), title = catalog.i18nc("@info:title", "Backup")).show()
-            return []
+            backup_list_response = HttpRequestManager.readJSON(reply)
+            if "data" not in backup_list_response:
+                Logger.log("w", "Could not get backups from remote, actual response body was: %s",
+                           str(backup_list_response))
+                changed([])  # empty list of backups
+                return
 
-        backup_list_response = backup_list_request.json()
-        if "data" not in backup_list_response:
-            Logger.log("w", "Could not get backups from remote, actual response body was: %s", str(backup_list_response))
-            return []
+            changed(backup_list_response["data"])
 
-        return backup_list_response["data"]
+        HttpRequestManager.getInstance().get(
+            self.BACKUP_URL,
+            callback= callback,
+            error_callback = callback,
+            scope=self._json_cloud_scope
+        )
 
     def createBackup(self) -> None:
         self.creatingStateChanged.emit(is_creating = True)
-
-        # Create the backup.
-        backup_zip_file, backup_meta_data = self._cura_api.backups.createBackup()
-        if not backup_zip_file or not backup_meta_data:
-            self.creatingStateChanged.emit(is_creating = False, error_message ="Could not create backup.")
-            return
-
-        # Create an upload entry for the backup.
-        timestamp = datetime.now().isoformat()
-        backup_meta_data["description"] = "{}.backup.{}.cura.zip".format(timestamp, backup_meta_data["cura_release"])
-        backup_upload_url = self._requestBackupUpload(backup_meta_data, len(backup_zip_file))
-        if not backup_upload_url:
-            self.creatingStateChanged.emit(is_creating = False, error_message ="Could not upload backup.")
-            return
-
-        # Upload the backup to storage.
-        upload_backup_job = UploadBackupJob(backup_upload_url, backup_zip_file)
+        upload_backup_job = CreateBackupJob(self.BACKUP_URL)
         upload_backup_job.finished.connect(self._onUploadFinished)
         upload_backup_job.start()
 
-    def _onUploadFinished(self, job: "UploadBackupJob") -> None:
+    def _onUploadFinished(self, job: "CreateBackupJob") -> None:
         if job.backup_upload_error_message != "":
             # If the job contains an error message we pass it along so the UI can display it.
             self.creatingStateChanged.emit(is_creating = False, error_message = job.backup_upload_error_message)
@@ -96,96 +76,38 @@ class DriveApiService:
         download_url = backup.get("download_url")
         if not download_url:
             # If there is no download URL, we can't restore the backup.
-            return self._emitRestoreError()
+            Logger.warning("backup download_url is missing. Aborting backup.")
+            self.restoringStateChanged.emit(is_restoring = False,
+                                            error_message = catalog.i18nc("@info:backup_status",
+                                                                        "There was an error trying to restore your backup."))
+            return
 
-        try:
-            download_package = requests.get(download_url, stream = True)
-        except requests.exceptions.ConnectionError:
-            Logger.logException("e", "Unable to connect with the server")
-            return self._emitRestoreError()
+        restore_backup_job = RestoreBackupJob(backup)
+        restore_backup_job.finished.connect(self._onRestoreFinished)
+        restore_backup_job.start()
 
-        if download_package.status_code >= 300:
-            # Something went wrong when attempting to download the backup.
-            Logger.log("w", "Could not download backup from url %s: %s", download_url, download_package.text)
-            return self._emitRestoreError()
+    def _onRestoreFinished(self, job: "RestoreBackupJob") -> None:
+        if job.restore_backup_error_message != "":
+            # If the job contains an error message we pass it along so the UI can display it.
+            self.restoringStateChanged.emit(is_restoring=False)
+        else:
+            self.restoringStateChanged.emit(is_restoring = False, error_message = job.restore_backup_error_message)
 
-        # We store the file in a temporary path fist to ensure integrity.
-        temporary_backup_file = NamedTemporaryFile(delete = False)
-        with open(temporary_backup_file.name, "wb") as write_backup:
-            for chunk in download_package:
-                write_backup.write(chunk)
+    def deleteBackup(self, backup_id: str, finished_callable: Callable[[bool], None]):
 
-        if not self._verifyMd5Hash(temporary_backup_file.name, backup.get("md5_hash", "")):
-            # Don't restore the backup if the MD5 hashes do not match.
-            # This can happen if the download was interrupted.
-            Logger.log("w", "Remote and local MD5 hashes do not match, not restoring backup.")
-            return self._emitRestoreError()
+        def finishedCallback(reply: QNetworkReply, ca: Callable[[bool], None] = finished_callable) -> None:
+            self._onDeleteRequestCompleted(reply, ca)
 
-        # Tell Cura to place the backup back in the user data folder.
-        with open(temporary_backup_file.name, "rb") as read_backup:
-            self._cura_api.backups.restoreBackup(read_backup.read(), backup.get("metadata", {}))
-            self.restoringStateChanged.emit(is_restoring = False)
+        def errorCallback(reply: QNetworkReply, error: QNetworkReply.NetworkError, ca: Callable[[bool], None] = finished_callable) -> None:
+            self._onDeleteRequestCompleted(reply, ca, error)
 
-    def _emitRestoreError(self) -> None:
-        self.restoringStateChanged.emit(is_restoring = False,
-                                        error_message = catalog.i18nc("@info:backup_status",
-                                                                         "There was an error trying to restore your backup."))
+        HttpRequestManager.getInstance().delete(
+            url = "{}/{}".format(self.BACKUP_URL, backup_id),
+            callback = finishedCallback,
+            error_callback = errorCallback,
+            scope= self._json_cloud_scope
+        )
 
-    #   Verify the MD5 hash of a file.
-    #   \param file_path Full path to the file.
-    #   \param known_hash The known MD5 hash of the file.
-    #   \return: Success or not.
     @staticmethod
-    def _verifyMd5Hash(file_path: str, known_hash: str) -> bool:
-        with open(file_path, "rb") as read_backup:
-            local_md5_hash = base64.b64encode(hashlib.md5(read_backup.read()).digest(), altchars = b"_-").decode("utf-8")
-            return known_hash == local_md5_hash
-
-    def deleteBackup(self, backup_id: str) -> bool:
-        access_token = self._cura_api.account.accessToken
-        if not access_token:
-            Logger.log("w", "Could not get access token.")
-            return False
-
-        try:
-            delete_backup = requests.delete("{}/{}".format(self.BACKUP_URL, backup_id), headers = {
-                "Authorization": "Bearer {}".format(access_token)
-            })
-        except requests.exceptions.ConnectionError:
-            Logger.logException("e", "Unable to connect with the server")
-            return False
-
-        if delete_backup.status_code >= 300:
-            Logger.log("w", "Could not delete backup: %s", delete_backup.text)
-            return False
-        return True
-
-    #   Request a backup upload slot from the API.
-    #   \param backup_metadata: A dict containing some meta data about the backup.
-    #   \param backup_size The size of the backup file in bytes.
-    #   \return: The upload URL for the actual backup file if successful, otherwise None.
-    def _requestBackupUpload(self, backup_metadata: Dict[str, Any], backup_size: int) -> Optional[str]:
-        access_token = self._cura_api.account.accessToken
-        if not access_token:
-            Logger.log("w", "Could not get access token.")
-            return None
-        try:
-            backup_upload_request = requests.put(
-                self.BACKUP_URL,
-                json = {"data": {"backup_size": backup_size,
-                                 "metadata": backup_metadata
-                                 }
-                        },
-                headers = {
-                    "Authorization": "Bearer {}".format(access_token)
-                })
-        except requests.exceptions.ConnectionError:
-            Logger.logException("e", "Unable to connect with the server")
-            return None
-
-        # Any status code of 300 or above indicates an error.
-        if backup_upload_request.status_code >= 300:
-            Logger.log("w", "Could not request backup upload: %s", backup_upload_request.text)
-            return None
-        
-        return backup_upload_request.json()["data"]["upload_url"]
+    def _onDeleteRequestCompleted(reply: QNetworkReply, callable: Callable[[bool], None], error: Optional["QNetworkReply.NetworkError"] = None) -> None:
+        callable(HttpRequestManager.replyIndicatesSuccess(reply, error))

plugins/CuraDrive/src/DrivePluginExtension.py

@@ -133,7 +133,10 @@ class DrivePluginExtension(QObject, Extension):
 
     @pyqtSlot(name = "refreshBackups")
     def refreshBackups(self) -> None:
-        self._backups = self._drive_api_service.getBackups()
+        self._drive_api_service.getBackups(self._backupsChangedCallback)
+
+    def _backupsChangedCallback(self, backups: List[Dict[str, Any]]) -> None:
+        self._backups = backups
         self.backupsChanged.emit()
 
     @pyqtProperty(bool, notify = restoringStateChanged)
@@ -158,5 +161,8 @@ class DrivePluginExtension(QObject, Extension):
 
     @pyqtSlot(str, name = "deleteBackup")
     def deleteBackup(self, backup_id: str) -> None:
-        self._drive_api_service.deleteBackup(backup_id)
-        self.refreshBackups()
+        self._drive_api_service.deleteBackup(backup_id, self._backupDeletedCallback)
+
+    def _backupDeletedCallback(self, success: bool):
+        if success:
+            self.refreshBackups()

plugins/CuraDrive/src/RestoreBackupJob.py

@@ -0,0 +1,92 @@
+import base64
+import hashlib
+import threading
+from tempfile import NamedTemporaryFile
+from typing import Optional, Any, Dict
+
+from PyQt5.QtNetwork import QNetworkReply, QNetworkRequest
+
+from UM.Job import Job
+from UM.Logger import Logger
+from UM.PackageManager import catalog
+from UM.TaskManagement.HttpRequestManager import HttpRequestManager
+from cura.CuraApplication import CuraApplication
+
+
+class RestoreBackupJob(Job):
+    """Downloads a backup and overwrites local configuration with the backup.
+
+     When `Job.finished` emits, `restore_backup_error_message` will either be `""` (no error) or an error message
+     """
+
+    DISK_WRITE_BUFFER_SIZE = 512 * 1024
+    DEFAULT_ERROR_MESSAGE = catalog.i18nc("@info:backup_status", "There was an error trying to restore your backup.")
+
+    def __init__(self, backup: Dict[str, Any]) -> None:
+        """ Create a new restore Job. start the job by calling start()
+
+        :param backup: A dict containing a backup spec
+        """
+
+        super().__init__()
+        self._job_done = threading.Event()
+
+        self._backup = backup
+        self.restore_backup_error_message = ""
+
+    def run(self) -> None:
+
+        url = self._backup.get("download_url")
+        assert url is not None
+
+        HttpRequestManager.getInstance().get(
+            url = url,
+            callback = self._onRestoreRequestCompleted,
+            error_callback = self._onRestoreRequestCompleted
+        )
+
+        self._job_done.wait()  # A job is considered finished when the run function completes
+
+    def _onRestoreRequestCompleted(self, reply: QNetworkReply, error: Optional["QNetworkReply.NetworkError"] = None) -> None:
+        if not HttpRequestManager.replyIndicatesSuccess(reply, error):
+            Logger.warning("Requesting backup failed, response code %s while trying to connect to %s",
+                           reply.attribute(QNetworkRequest.HttpStatusCodeAttribute), reply.url())
+            self.restore_backup_error_message = self.DEFAULT_ERROR_MESSAGE
+            self._job_done.set()
+            return
+
+        # We store the file in a temporary path fist to ensure integrity.
+        temporary_backup_file = NamedTemporaryFile(delete = False)
+        with open(temporary_backup_file.name, "wb") as write_backup:
+            app = CuraApplication.getInstance()
+            bytes_read = reply.read(self.DISK_WRITE_BUFFER_SIZE)
+            while bytes_read:
+                write_backup.write(bytes_read)
+                bytes_read = reply.read(self.DISK_WRITE_BUFFER_SIZE)
+                app.processEvents()
+
+        if not self._verifyMd5Hash(temporary_backup_file.name, self._backup.get("md5_hash", "")):
+            # Don't restore the backup if the MD5 hashes do not match.
+            # This can happen if the download was interrupted.
+            Logger.log("w", "Remote and local MD5 hashes do not match, not restoring backup.")
+            self.restore_backup_error_message = self.DEFAULT_ERROR_MESSAGE
+
+        # Tell Cura to place the backup back in the user data folder.
+        with open(temporary_backup_file.name, "rb") as read_backup:
+            cura_api = CuraApplication.getInstance().getCuraAPI()
+            cura_api.backups.restoreBackup(read_backup.read(), self._backup.get("metadata", {}))
+
+        self._job_done.set()
+
+    @staticmethod
+    def _verifyMd5Hash(file_path: str, known_hash: str) -> bool:
+        """Verify the MD5 hash of a file.
+
+        :param file_path: Full path to the file.
+        :param known_hash: The known MD5 hash of the file.
+        :return: Success or not.
+        """
+
+        with open(file_path, "rb") as read_backup:
+            local_md5_hash = base64.b64encode(hashlib.md5(read_backup.read()).digest(), altchars = b"_-").decode("utf-8")
+            return known_hash == local_md5_hash

plugins/CuraDrive/src/Settings.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from cura import UltimakerCloudAuthentication
+from cura.UltimakerCloud import UltimakerCloudAuthentication
 
 
 class Settings:

plugins/CuraDrive/src/UploadBackupJob.py

@@ -1,41 +0,0 @@
-# Copyright (c) 2018 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
-
-import requests
-
-from UM.Job import Job
-from UM.Logger import Logger
-from UM.Message import Message
-
-from UM.i18n import i18nCatalog
-catalog = i18nCatalog("cura")
-
-
-class UploadBackupJob(Job):
-    MESSAGE_TITLE = catalog.i18nc("@info:title", "Backups")
-
-    # This job is responsible for uploading the backup file to cloud storage.
-    # As it can take longer than some other tasks, we schedule this using a Cura Job.
-    def __init__(self, signed_upload_url: str, backup_zip: bytes) -> None:
-        super().__init__()
-        self._signed_upload_url = signed_upload_url
-        self._backup_zip = backup_zip
-        self._upload_success = False
-        self.backup_upload_error_message = ""
-
-    def run(self) -> None:
-        upload_message = Message(catalog.i18nc("@info:backup_status", "Uploading your backup..."), title = self.MESSAGE_TITLE, progress = -1)
-        upload_message.show()
-
-        backup_upload = requests.put(self._signed_upload_url, data = self._backup_zip)
-        upload_message.hide()
-
-        if backup_upload.status_code >= 300:
-            self.backup_upload_error_message = backup_upload.text
-            Logger.log("w", "Could not upload backup file: %s", backup_upload.text)
-            Message(catalog.i18nc("@info:backup_status", "There was an error while uploading your backup."), title = self.MESSAGE_TITLE).show()
-        else:
-            self._upload_success = True
-            Message(catalog.i18nc("@info:backup_status", "Your backup has finished uploading."), title = self.MESSAGE_TITLE).show()
-
-        self.finished.emit(self)

plugins/PostProcessingPlugin/PostProcessingPlugin.py

@@ -1,23 +1,24 @@
 # Copyright (c) 2018 Jaime van Kessel, Ultimaker B.V.
 # The PostProcessingPlugin is released under the terms of the AGPLv3 or higher.
 
-from PyQt5.QtCore import QObject, pyqtProperty, pyqtSignal, pyqtSlot
-from typing import Dict, Type, TYPE_CHECKING, List, Optional, cast
-
-from UM.PluginRegistry import PluginRegistry
-from UM.Resources import Resources
-from UM.Application import Application
-from UM.Extension import Extension
-from UM.Logger import Logger
-
 import configparser  # The script lists are stored in metadata as serialised config files.
+import importlib.util
 import io  # To allow configparser to write to a string.
 import os.path
 import pkgutil
 import sys
-import importlib.util
+from typing import Dict, Type, TYPE_CHECKING, List, Optional, cast
 
+from PyQt5.QtCore import QObject, pyqtProperty, pyqtSignal, pyqtSlot
+
+from UM.Application import Application
+from UM.Extension import Extension
+from UM.Logger import Logger
+from UM.PluginRegistry import PluginRegistry
+from UM.Resources import Resources
+from UM.Trust import Trust
 from UM.i18n import i18nCatalog
+from cura import ApplicationMetadata
 from cura.CuraApplication import CuraApplication
 
 i18n_catalog = i18nCatalog("cura")
@@ -161,7 +162,13 @@ class PostProcessingPlugin(QObject, Extension):
             # Iterate over all scripts.
             if script_name not in sys.modules:
                 try:
-                    spec = importlib.util.spec_from_file_location(__name__ + "." + script_name, os.path.join(path, script_name + ".py"))
+                    file_path = os.path.join(path, script_name + ".py")
+                    if not self._isScriptAllowed(file_path):
+                        Logger.warning("Skipped loading post-processing script {}: not trusted".format(file_path))
+                        continue
+
+                    spec = importlib.util.spec_from_file_location(__name__ + "." + script_name,
+                                                                  file_path)
                     loaded_script = importlib.util.module_from_spec(spec)
                     if spec.loader is None:
                         continue
@@ -334,4 +341,26 @@ class PostProcessingPlugin(QObject, Extension):
         if global_container_stack is not None:
             global_container_stack.propertyChanged.emit("post_processing_plugin", "value")
 
+    @staticmethod
+    def _isScriptAllowed(file_path: str) -> bool:
+        """Checks whether the given file is allowed to be loaded"""
+        if not ApplicationMetadata.IsEnterpriseVersion:
+            # No signature needed
+            return True
+
+        dir_path = os.path.split(file_path)[0]  # type: str
+        plugin_path = PluginRegistry.getInstance().getPluginPath("PostProcessingPlugin")
+        assert plugin_path is not None  # appease mypy
+        bundled_path = os.path.join(plugin_path, "scripts")
+        if dir_path == bundled_path:
+            # Bundled scripts are trusted.
+            return True
+
+        trust_instance = Trust.getInstanceOrNone()
+        if trust_instance is not None and Trust.signatureFileExistsFor(file_path):
+            if trust_instance.signedFileCheck(file_path):
+                return True
+
+        return False  # Default verdict should be False, being the most secure fallback
+
 

plugins/PostProcessingPlugin/scripts/PauseAtHeight.py

@@ -57,6 +57,17 @@ class PauseAtHeight(Script):
                     "options": {"marlin": "Marlin (M0)", "griffin": "Griffin (M0, firmware retract)", "bq": "BQ (M25)", "reprap": "RepRap (M226)", "repetier": "Repetier (@pause)"},
                     "default_value": "marlin",
                     "value": "\\\"griffin\\\" if machine_gcode_flavor==\\\"Griffin\\\" else \\\"reprap\\\" if machine_gcode_flavor==\\\"RepRap (RepRap)\\\" else \\\"repetier\\\" if machine_gcode_flavor==\\\"Repetier\\\" else \\\"bq\\\" if \\\"BQ\\\" in machine_name else \\\"marlin\\\""
+                },                    
+                "disarm_timeout":
+                {
+                    "label": "Disarm timeout",
+                    "description": "After this time steppers are going to disarm (meaning that they can easily lose their positions). Set this to 0 if you don't want to set any duration.",
+                    "type": "int",
+                    "value": "0",
+                    "minimum_value": "0",
+                    "minimum_value_warning": "0",
+                    "maximum_value_warning": "1800",
+                    "unit": "s"
                 },
                 "head_park_x":
                 {
@@ -206,6 +217,7 @@ class PauseAtHeight(Script):
         pause_at = self.getSettingValueByKey("pause_at")
         pause_height = self.getSettingValueByKey("pause_height")
         pause_layer = self.getSettingValueByKey("pause_layer")
+        disarm_timeout = self.getSettingValueByKey("disarm_timeout")
         retraction_amount = self.getSettingValueByKey("retraction_amount")
         retraction_speed = self.getSettingValueByKey("retraction_speed")
         extrude_amount = self.getSettingValueByKey("extrude_amount")
@@ -393,6 +405,10 @@ class PauseAtHeight(Script):
                 if display_text:
                     prepend_gcode += "M117 " + display_text + "\n"
 
+                # Set the disarm timeout
+                if disarm_timeout > 0:
+                    prepend_gcode += self.putValue(M = 18, S = disarm_timeout) + " ; Set the disarm timeout\n"
+
                 # Wait till the user continues printing
                 prepend_gcode += pause_command + " ; Do the actual pause\n"
 

plugins/PostProcessingPlugin/tests/TestPostProcessingPlugin.py

@@ -0,0 +1,61 @@
+
+import os
+import sys
+from unittest.mock import patch, MagicMock
+
+from UM.PluginRegistry import PluginRegistry
+from UM.Resources import Resources
+from UM.Trust import Trust
+from ..PostProcessingPlugin import PostProcessingPlugin
+
+# not sure if needed
+sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
+
+""" In this file, commnunity refers to regular Cura for makers."""
+
+mock_plugin_registry = MagicMock()
+mock_plugin_registry.getPluginPath = MagicMock(return_value = "mocked_plugin_path")
+
+
+# noinspection PyProtectedMember
+@patch("cura.ApplicationMetadata.IsEnterpriseVersion", False)
+def test_community_user_script_allowed():
+    assert PostProcessingPlugin._isScriptAllowed("blaat.py")
+
+
+# noinspection PyProtectedMember
+@patch("cura.ApplicationMetadata.IsEnterpriseVersion", False)
+def test_community_bundled_script_allowed():
+    assert PostProcessingPlugin._isScriptAllowed(_bundled_file_path())
+
+
+# noinspection PyProtectedMember
+@patch("cura.ApplicationMetadata.IsEnterpriseVersion", True)
+@patch.object(PluginRegistry, "getInstance", return_value=mock_plugin_registry)
+def test_enterprise_unsigned_user_script_not_allowed(plugin_registry):
+    assert not PostProcessingPlugin._isScriptAllowed("blaat.py")
+
+# noinspection PyProtectedMember
+@patch("cura.ApplicationMetadata.IsEnterpriseVersion", True)
+@patch.object(PluginRegistry, "getInstance", return_value=mock_plugin_registry)
+def test_enterprise_signed_user_script_allowed(plugin_registry):
+    mocked_trust = MagicMock()
+    mocked_trust.signedFileCheck = MagicMock(return_value=True)
+
+    plugin_registry.getPluginPath = MagicMock(return_value="mocked_plugin_path")
+
+    with patch.object(Trust, "signatureFileExistsFor", return_value = True):
+        with patch("UM.Trust.Trust.getInstanceOrNone", return_value=mocked_trust):
+            assert PostProcessingPlugin._isScriptAllowed("mocked_plugin_path/scripts/blaat.py")
+
+
+# noinspection PyProtectedMember
+@patch("cura.ApplicationMetadata.IsEnterpriseVersion", False)
+def test_enterprise_bundled_script_allowed():
+    assert PostProcessingPlugin._isScriptAllowed(_bundled_file_path())
+
+
+def _bundled_file_path():
+    return os.path.join(
+        Resources.getStoragePath(Resources.Resources) + "scripts/blaat.py"
+    )

plugins/PrepareStage/PrepareMain.qml

@@ -1,4 +1,4 @@
-//Copyright (c) 2019 Ultimaker B.V.
+//Copyright (c) 2020 Ultimaker B.V.
 //Cura is released under the terms of the LGPLv3 or higher.
 
 import QtQuick 2.4

plugins/Toolbox/resources/images/placeholder.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48">
+  <path d="M24,44,7,33.4V14.6L24,4,41,14.6V33.4ZM9,32.3l15,9.3,15-9.3V15.7L24,6.4,9,15.7Z"/>
+</svg>

plugins/Toolbox/resources/qml/components/ToolboxCompatibilityChart.qml

@@ -4,7 +4,7 @@
 import QtQuick 2.10
 import QtQuick.Controls 1.4
 
-import UM 1.1 as UM
+import UM 1.5 as UM
 
 Item
 {
@@ -203,7 +203,7 @@ Item
         font: UM.Theme.getFont("default")
         color: UM.Theme.getColor("text")
         linkColor: UM.Theme.getColor("text_link")
-        onLinkActivated: Qt.openUrlExternally(link)
+        onLinkActivated: UM.UrlUtil.openUrl(link, ["http", "https"])
         renderType: Text.NativeRendering
     }
 }

plugins/Toolbox/resources/qml/components/ToolboxDetailTileActions.qml

@@ -4,7 +4,7 @@
 import QtQuick 2.10
 import QtQuick.Controls 1.4
 import QtQuick.Controls.Styles 1.4
-import UM 1.1 as UM
+import UM 1.5 as UM
 import Cura 1.1 as Cura
 
 Column
@@ -85,7 +85,7 @@ Column
         MouseArea
         {
             anchors.fill: parent
-            onClicked: Qt.openUrlExternally(parent.whereToBuyUrl)
+            onClicked: UM.UrlUtil.openUrl(parent.whereToBuyUrl, ["https", "http"])
         }
     }
 

plugins/Toolbox/resources/qml/components/ToolboxDownloadsGridTile.qml

@@ -66,8 +66,10 @@ Item
             anchors.centerIn: parent
             width: UM.Theme.getSize("toolbox_thumbnail_small").width - UM.Theme.getSize("wide_margin").width
             height: UM.Theme.getSize("toolbox_thumbnail_small").height - UM.Theme.getSize("wide_margin").width
+            sourceSize.width: width
+            sourceSize.height: height
             fillMode: Image.PreserveAspectFit
-            source: model.icon_url || "../../images/logobot.svg"
+            source: model.icon_url || "../../images/placeholder.svg"
             mipmap: true
         }
         UM.RecolorImage

plugins/Toolbox/resources/qml/components/ToolboxDownloadsShowcaseTile.qml

@@ -22,8 +22,10 @@ Rectangle
         id: thumbnail
         height: UM.Theme.getSize("toolbox_thumbnail_large").height - 4 * UM.Theme.getSize("default_margin").height
         width: UM.Theme.getSize("toolbox_thumbnail_large").height - 4 * UM.Theme.getSize("default_margin").height
+        sourceSize.height: height
+        sourceSize.width: width
         fillMode: Image.PreserveAspectFit
-        source: model.icon_url || "../../images/logobot.svg"
+        source: model.icon_url || "../../images/placeholder.svg"
         mipmap: true
         anchors
         {

plugins/Toolbox/resources/qml/dialogs/CompatibilityDialog.qml

@@ -68,9 +68,11 @@ UM.Dialog{
                             Image
                             {
                                 id: packageIcon
-                                source: model.icon_url || "../../images/logobot.svg"
+                                source: model.icon_url || "../../images/placeholder.svg"
                                 height: lineHeight
                                 width: height
+                                sourceSize.height: height
+                                sourceSize.width: width
                                 mipmap: true
                                 fillMode: Image.PreserveAspectFit
                             }
@@ -111,9 +113,11 @@ UM.Dialog{
                             Image
                             {
                                 id: packageIcon
-                                source: model.icon_url || "../../images/logobot.svg"
+                                source: model.icon_url || "../../images/placeholder.svg"
                                 height: lineHeight
                                 width: height
+                                sourceSize.height: height
+                                sourceSize.width: width
                                 mipmap: true
                                 fillMode: Image.PreserveAspectFit
                             }

plugins/Toolbox/resources/qml/dialogs/ToolboxLicenseDialog.qml

@@ -53,8 +53,10 @@ UM.Dialog
                 id: icon
                 width: 30 * screenScaleFactor
                 height: width
+                sourceSize.width: width
+                sourceSize.height: height
                 fillMode: Image.PreserveAspectFit
-                source: licenseModel.iconUrl || "../../images/logobot.svg"
+                source: licenseModel.iconUrl || "../../images/placeholder.svg"
                 mipmap: true
             }
 

plugins/Toolbox/resources/qml/pages/ToolboxAuthorPage.qml

@@ -4,7 +4,7 @@
 import QtQuick 2.10
 import QtQuick.Controls 1.4
 import QtQuick.Controls.Styles 1.4
-import UM 1.1 as UM
+import UM 1.5 as UM
 
 import "../components"
 
@@ -33,7 +33,7 @@ Item
             width: UM.Theme.getSize("toolbox_thumbnail_medium").width
             height: UM.Theme.getSize("toolbox_thumbnail_medium").height
             fillMode: Image.PreserveAspectFit
-            source: details.icon_url || "../../images/logobot.svg"
+            source: details.icon_url || "../../images/placeholder.svg"
             mipmap: true
             anchors
             {
@@ -132,7 +132,7 @@ Item
                 font: UM.Theme.getFont("default")
                 color: UM.Theme.getColor("text")
                 linkColor: UM.Theme.getColor("text_link")
-                onLinkActivated: Qt.openUrlExternally(link)
+                onLinkActivated: UM.UrlUtil.openUrl(link, ["https", "http"])
                 renderType: Text.NativeRendering
             }
 

plugins/Toolbox/resources/qml/pages/ToolboxDetailPage.qml

@@ -4,7 +4,7 @@
 import QtQuick 2.10
 import QtQuick.Controls 1.4
 import QtQuick.Controls.Styles 1.4
-import UM 1.1 as UM
+import UM 1.5 as UM
 
 import Cura 1.1 as Cura
 
@@ -46,8 +46,12 @@ Item
             {
                 anchors.fill: parent
                 fillMode: Image.PreserveAspectFit
-                source: details === null ? "" : (details.icon_url || "../../images/logobot.svg")
+                source: details === null ? "" : (details.icon_url || "../../images/placeholder.svg")
                 mipmap: true
+                height: UM.Theme.getSize("toolbox_thumbnail_large").height - 4 * UM.Theme.getSize("default_margin").height
+                width: UM.Theme.getSize("toolbox_thumbnail_large").height - 4 * UM.Theme.getSize("default_margin").height
+                sourceSize.height: height
+                sourceSize.width: width
             }
         }
 
@@ -217,7 +221,7 @@ Item
                 font: UM.Theme.getFont("default")
                 color: UM.Theme.getColor("text")
                 linkColor: UM.Theme.getColor("text_link")
-                onLinkActivated: Qt.openUrlExternally(link)
+                onLinkActivated: UM.UrlUtil.openUrl(link, ["http", "https"])
                 renderType: Text.NativeRendering
             }
             Label

plugins/Toolbox/src/CloudApiModel.py

@@ -1,6 +1,7 @@
 from typing import Union
 
-from cura import ApplicationMetadata, UltimakerCloudAuthentication
+from cura import ApplicationMetadata
+from cura.UltimakerCloud import UltimakerCloudAuthentication
 
 
 class CloudApiModel:

plugins/Toolbox/src/CloudSync/CloudApiClient.py

@@ -1,8 +1,9 @@
 from UM.Logger import Logger
 from UM.TaskManagement.HttpRequestManager import HttpRequestManager
+from UM.TaskManagement.HttpRequestScope import JsonDecoratorScope
 from cura.CuraApplication import CuraApplication
+from cura.UltimakerCloud.UltimakerCloudScope import UltimakerCloudScope
 from ..CloudApiModel import CloudApiModel
-from ..UltimakerCloudScope import UltimakerCloudScope
 
 
 class CloudApiClient:
@@ -26,7 +27,7 @@ class CloudApiClient:
         if self.__instance is not None:
             raise RuntimeError("This is a Singleton. use getInstance()")
 
-        self._scope = UltimakerCloudScope(app)  # type: UltimakerCloudScope
+        self._scope = JsonDecoratorScope(UltimakerCloudScope(app))  # type: JsonDecoratorScope
 
         app.getPackageManager().packageInstalled.connect(self._onPackageInstalled)
 

plugins/Toolbox/src/CloudSync/CloudPackageChecker.py

@@ -2,6 +2,7 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 import json
+from typing import List, Dict, Any
 from typing import Optional
 
 from PyQt5.QtCore import QObject
@@ -11,12 +12,12 @@ from UM import i18nCatalog
 from UM.Logger import Logger
 from UM.Message import Message
 from UM.Signal import Signal
+from UM.TaskManagement.HttpRequestScope import JsonDecoratorScope
 from cura.CuraApplication import CuraApplication, ApplicationMetadata
-from ..CloudApiModel import CloudApiModel
+from cura.UltimakerCloud.UltimakerCloudScope import UltimakerCloudScope
 from .SubscribedPackagesModel import SubscribedPackagesModel
-from ..UltimakerCloudScope import UltimakerCloudScope
+from ..CloudApiModel import CloudApiModel
 
-from typing import List, Dict, Any
 
 class CloudPackageChecker(QObject):
     def __init__(self, application: CuraApplication) -> None:
@@ -24,7 +25,7 @@ class CloudPackageChecker(QObject):
 
         self.discrepancies = Signal()  # Emits SubscribedPackagesModel
         self._application = application  # type: CuraApplication
-        self._scope = UltimakerCloudScope(application)
+        self._scope = JsonDecoratorScope(UltimakerCloudScope(application))
         self._model = SubscribedPackagesModel()
         self._message = None  # type: Optional[Message]
 
@@ -111,4 +112,4 @@ class CloudPackageChecker(QObject):
 
     def _onSyncButtonClicked(self, sync_message: Message, sync_message_action: str) -> None:
         sync_message.hide()
-        self.discrepancies.emit(self._model)
+        self.discrepancies.emit(self._model)

plugins/Toolbox/src/CloudSync/DownloadPresenter.py

@@ -12,8 +12,8 @@ from UM.Message import Message
 from UM.Signal import Signal
 from UM.TaskManagement.HttpRequestManager import HttpRequestManager
 from cura.CuraApplication import CuraApplication
+from cura.UltimakerCloud.UltimakerCloudScope import UltimakerCloudScope
 from .SubscribedPackagesModel import SubscribedPackagesModel
-from ..UltimakerCloudScope import UltimakerCloudScope
 
 
 ## Downloads a set of packages from the Ultimaker Cloud Marketplace

plugins/Toolbox/src/Toolbox.py

@@ -9,22 +9,20 @@ from typing import cast, Any, Dict, List, Set, TYPE_CHECKING, Tuple, Optional, U
 from PyQt5.QtCore import QObject, pyqtProperty, pyqtSignal, pyqtSlot
 from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
 
+from UM.Extension import Extension
 from UM.Logger import Logger
 from UM.PluginRegistry import PluginRegistry
-from UM.Extension import Extension
-from UM.i18n import i18nCatalog
+from UM.TaskManagement.HttpRequestScope import JsonDecoratorScope
 from UM.Version import Version
-
+from UM.i18n import i18nCatalog
 from cura import ApplicationMetadata
-
 from cura.CuraApplication import CuraApplication
 from cura.Machines.ContainerTree import ContainerTree
-
-from .CloudApiModel import CloudApiModel
+from cura.UltimakerCloud.UltimakerCloudScope import UltimakerCloudScope
 from .AuthorsModel import AuthorsModel
+from .CloudApiModel import CloudApiModel
 from .CloudSync.LicenseModel import LicenseModel
 from .PackagesModel import PackagesModel
-from .UltimakerCloudScope import UltimakerCloudScope
 
 if TYPE_CHECKING:
     from UM.TaskManagement.HttpRequestData import HttpRequestData
@@ -54,7 +52,8 @@ class Toolbox(QObject, Extension):
         self._download_request_data = None  # type: Optional[HttpRequestData]
         self._download_progress = 0  # type: float
         self._is_downloading = False  # type: bool
-        self._scope = UltimakerCloudScope(application)  # type: UltimakerCloudScope
+        self._cloud_scope = UltimakerCloudScope(application)  # type: UltimakerCloudScope
+        self._json_scope = JsonDecoratorScope(self._cloud_scope)  # type: JsonDecoratorScope
 
         self._request_urls = {}  # type: Dict[str, str]
         self._to_update = []  # type: List[str] # Package_ids that are waiting to be updated
@@ -151,7 +150,7 @@ class Toolbox(QObject, Extension):
         url = "{base_url}/packages/{package_id}/ratings".format(base_url = CloudApiModel.api_url, package_id = package_id)
         data = "{\"data\": {\"cura_version\": \"%s\", \"rating\": %i}}" % (Version(self._application.getVersion()), rating)
 
-        self._application.getHttpRequestManager().put(url, data = data.encode(), scope = self._scope)
+        self._application.getHttpRequestManager().put(url, data = data.encode(), scope = self._json_scope)
 
     def getLicenseDialogPluginFileLocation(self) -> str:
         return self._license_dialog_plugin_file_location
@@ -541,7 +540,7 @@ class Toolbox(QObject, Extension):
         self._application.getHttpRequestManager().get(url,
                                                       callback = callback,
                                                       error_callback = error_callback,
-                                                      scope=self._scope)
+                                                      scope=self._json_scope)
 
     @pyqtSlot(str)
     def startDownload(self, url: str) -> None:
@@ -554,7 +553,7 @@ class Toolbox(QObject, Extension):
                                                                      callback = callback,
                                                                      error_callback = error_callback,
                                                                      download_progress_callback = download_progress_callback,
-                                                                     scope=self._scope
+                                                                     scope=self._cloud_scope
                                                                      )
 
         self._download_request_data = request_data

plugins/Toolbox/src/UltimakerCloudScope.py

@@ -1,28 +0,0 @@
-from PyQt5.QtNetwork import QNetworkRequest
-
-from UM.Logger import Logger
-from UM.TaskManagement.HttpRequestScope import DefaultUserAgentScope
-from cura.API import Account
-from cura.CuraApplication import CuraApplication
-
-
-## Add a Authorization header to the request for Ultimaker Cloud Api requests.
-# When the user is not logged in or a token is not available, a warning will be logged
-# Also add the user agent headers (see DefaultUserAgentScope)
-class UltimakerCloudScope(DefaultUserAgentScope):
-    def __init__(self, application: CuraApplication):
-        super().__init__(application)
-        api = application.getCuraAPI()
-        self._account = api.account  # type: Account
-
-    def request_hook(self, request: QNetworkRequest):
-        super().request_hook(request)
-        token = self._account.accessToken
-        if not self._account.isLoggedIn or token is None:
-            Logger.warning("Cannot add authorization to Cloud Api request")
-            return
-
-        header_dict = {
-            "Authorization": "Bearer {}".format(token)
-        }
-        self.add_headers(request, header_dict)

plugins/UM3NetworkPrinting/src/Cloud/CloudApiClient.py

@@ -9,18 +9,16 @@ from PyQt5.QtCore import QUrl
 from PyQt5.QtNetwork import QNetworkRequest, QNetworkReply, QNetworkAccessManager
 
 from UM.Logger import Logger
-from cura import UltimakerCloudAuthentication
 from cura.API import Account
-
+from cura.UltimakerCloud import UltimakerCloudAuthentication
 from .ToolPathUploader import ToolPathUploader
 from ..Models.BaseModel import BaseModel
 from ..Models.Http.CloudClusterResponse import CloudClusterResponse
-from ..Models.Http.CloudError import CloudError
 from ..Models.Http.CloudClusterStatus import CloudClusterStatus
+from ..Models.Http.CloudError import CloudError
+from ..Models.Http.CloudPrintJobResponse import CloudPrintJobResponse
 from ..Models.Http.CloudPrintJobUploadRequest import CloudPrintJobUploadRequest
 from ..Models.Http.CloudPrintResponse import CloudPrintResponse
-from ..Models.Http.CloudPrintJobResponse import CloudPrintJobResponse
-
 
 ## The generic type variable used to document the methods below.
 CloudApiClientModel = TypeVar("CloudApiClientModel", bound=BaseModel)