Cura/plugins/Toolbox/src/Toolbox.py

# Copyright (c) 2018 Ultimaker B.V.
# Toolbox is released under the terms of the LGPLv3 or higher.

from typing import Dict
import json
import os
import tempfile
import platform

from PyQt5.QtCore import QUrl, QObject, pyqtProperty, pyqtSignal, pyqtSlot
from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply

from UM.Application import Application
from UM.Logger import Logger
from UM.PluginRegistry import PluginRegistry
from UM.Qt.Bindings.PluginsModel import PluginsModel
from UM.Extension import Extension
from UM.i18n import i18nCatalog
from cura.Utils.VersionTools import compareSemanticVersions

from cura.CuraApplication import CuraApplication
from .AuthorsModel import AuthorsModel
from .PackagesModel import PackagesModel

i18n_catalog = i18nCatalog("cura")


##  The Toolbox class is responsible of communicating with the server through the API
class Toolbox(QObject, Extension):
    def __init__(self, parent=None):
        super().__init__(parent)

        self._application = Application.getInstance()
        self._package_manager = None
        self._plugin_registry = Application.getInstance().getPluginRegistry()
        self._package_manager = None
        self._packages_version = self._plugin_registry.APIVersion
        self._api_version = 1
        self._api_url = "https://api-staging.ultimaker.com/cura-packages/v{api_version}/cura/v{package_version}".format( api_version = self._api_version, package_version = self._packages_version)

        self._get_packages_request = None
        self._get_showcase_request = None

        self._download_request = None
        self._download_reply = None
        self._download_progress = 0
        self._is_downloading = False

        self._network_manager = None
        self._request_header = [
            b"User-Agent",
            str.encode(
                "%s/%s (%s %s)" % (
                    Application.getInstance().getApplicationName(),
                    Application.getInstance().getVersion(),
                    platform.system(),
                    platform.machine(),
                )
            )
        ]

        self._packages_metadata = []
        self._packages_model = None
        self._plugins_showcase_model = None
        self._plugins_installed_model = None
        self._materials_showcase_model = None
        self._materials_installed_model = None
        self._authors_model = None

        # These properties are for keeping track of the UI state:
        # ----------------------------------------------------------------------
        # View category defines which filter to use, and therefore effectively
        # which category is currently being displayed. For example, possible
        # values include "plugin" or "material", but also "installed".
        self._view_category = "plugin"

        # View page defines which type of page layout to use. For example,
        # possible values include "overview", "detail" or "author".
        self._view_page = "loading"

        # View selection defines what is currently selected and should be
        # used in filtering. This could be an author name (if _view_page is set
        # to "author" or a plugin name if it is set to "detail").
        self._view_selection = ""

        # Active package refers to which package is currently being downloaded,
        # installed, or otherwise modified.
        self._active_package = None

        # Nowadays can be 'plugins', 'materials' or 'installed'
        self._current_view = "plugins"
        self._detail_data = {} # Extraneous since can just use the data prop of the model.

        self._dialog = None
        self._restartDialog = None
        self._restart_required = False

        # Installed plugins are really installed after reboot. In order to
        # prevent the user from downloading the same file over and over again,
        # we keep track of the upgraded plugins.
        self._newly_installed_plugin_ids = []
        self._newly_uninstalled_plugin_ids = []
        self._plugin_statuses = {} # type: Dict[str, str]

        # variables for the license agreement dialog
        self._license_dialog_plugin_name = ""
        self._license_dialog_license_content = ""
        self._license_dialog_plugin_file_location = ""
        self._restart_dialog_message = ""

        Application.getInstance().initializationFinished.connect(self._onAppInitialized)

    def _onAppInitialized(self):
        self._package_manager = Application.getInstance().getCuraPackageManager()

    packagesMetadataChanged = pyqtSignal()
    authorsMetadataChanged = pyqtSignal()
    pluginsShowcaseMetadataChanged = pyqtSignal()
    materialsShowcaseMetadataChanged = pyqtSignal()
    metadataChanged = pyqtSignal()

    # Downloading changes
    activePackageChanged = pyqtSignal()
    onDownloadProgressChanged = pyqtSignal()
    onIsDownloadingChanged = pyqtSignal()
    restartRequiredChanged = pyqtSignal()

    # UI changes
    viewChanged = pyqtSignal()
    detailViewChanged = pyqtSignal()
    filterChanged = pyqtSignal()
    showLicenseDialog = pyqtSignal()
    showRestartDialog = pyqtSignal()

    @pyqtSlot(result = str)
    def getLicenseDialogPluginName(self):
        return self._license_dialog_plugin_name

    @pyqtSlot(result = str)
    def getLicenseDialogPluginFileLocation(self):
        return self._license_dialog_plugin_file_location

    @pyqtSlot(result = str)
    def getLicenseDialogLicenseContent(self):
        return self._license_dialog_license_content

    @pyqtSlot(result = str)
    def getRestartDialogMessage(self):
        return self._restart_dialog_message

    def openLicenseDialog(self, plugin_name, license_content, plugin_file_location):
        self._license_dialog_plugin_name = plugin_name
        self._license_dialog_license_content = license_content
        self._license_dialog_plugin_file_location = plugin_file_location
        self.showLicenseDialog.emit()

    def openRestartDialog(self, message):
        self._restart_dialog_message = message
        self.showRestartDialog.emit()

    @pyqtSlot()
    def browsePackages(self):
        self._package_manager = Application.getInstance().getCuraPackageManager()
        # Create the network manager:
        # This was formerly its own function but really had no reason to be as
        # it was never called more than once ever.
        if self._network_manager:
            self._network_manager.finished.disconnect(self._onRequestFinished)
            self._network_manager.networkAccessibleChanged.disconnect(self._onNetworkAccesibleChanged)
        self._network_manager = QNetworkAccessManager()
        self._network_manager.finished.connect(self._onRequestFinished)
        self._network_manager.networkAccessibleChanged.connect(self._onNetworkAccesibleChanged)

        self._requestShowcase()
        self._requestPackages()
        if not self._dialog:
            self._dialog = self._createDialog("Toolbox.qml")
        self._dialog.show()

    def _createDialog(self, qml_name):
        Logger.log("d", "Toolbox: Creating dialog [%s].", qml_name)
        path = os.path.join(PluginRegistry.getInstance().getPluginPath(self.getPluginId()), "resources", "qml", qml_name)
        dialog = Application.getInstance().createQmlComponent(path, {"manager": self})
        return dialog

    @pyqtSlot(str)
    def installPlugin(self, file_path):
        self._package_manager.installPackage(file_path)
        self.metadataChanged.emit()
        self.openRestartDialog("TODO")
        self._restart_required = True
        self.restartRequiredChanged.emit()

    @pyqtSlot(str)
    def removePlugin(self, plugin_id):
        self._package_manager.removePackage(plugin_id)
        self.metadataChanged.emit()
        self._restart_required = True
        self.restartRequiredChanged.emit()

        Application.getInstance().messageBox(i18n_catalog.i18nc("@window:title", "Plugin browser"), "TODO")

    @pyqtSlot(str)
    def enablePlugin(self, plugin_id):
        self._plugin_registry.enablePlugin(plugin_id)
        self.metadataChanged.emit()
        Logger.log("i", "%s was set as 'active'", id)

    @pyqtSlot(str)
    def disablePlugin(self, plugin_id):
        self._plugin_registry.disablePlugin(plugin_id)
        self.metadataChanged.emit()
        Logger.log("i", "%s was set as 'deactive'", id)

    @pyqtProperty(QObject, notify = metadataChanged)
    def pluginsModel(self):
        self._plugins_model = PluginsModel(None, self._view_category)
        # self._plugins_model.update()

        # Check each plugin the registry for matching plugin from server
        # metadata, and if found, compare the versions. Higher version sets
        # 'can_upgrade' to 'True':
        for plugin in self._plugins_model.items:
            if self._checkCanUpgrade(plugin["id"], plugin["version"]):
                plugin["can_upgrade"] = True

                for item in self._packages_metadata:
                    if item["id"] == plugin["id"]:
                        plugin["update_url"] = item["file_location"]
        return self._plugins_model

    @pyqtProperty(QObject, notify = metadataChanged)
    def pluginsShowcaseModel(self):
        return self._plugins_showcase_model

    @pyqtProperty(QObject, notify = metadataChanged)
    def materialsShowcaseModel(self):
        return self._materials_showcase_model

    @pyqtProperty(QObject, notify = metadataChanged)
    def packagesModel(self):
        return self._packages_model

    @pyqtProperty(QObject, notify = metadataChanged)
    def authorsModel(self):
        return self._authors_model

    @pyqtProperty(bool, notify = metadataChanged)
    def dataReady(self):
        return self._packages_model is not None

    @pyqtProperty(bool, notify = restartRequiredChanged)
    def restartRequired(self):
        return self._restart_required

    @pyqtSlot()
    def restart(self):
        CuraApplication.getInstance().windowClosed()



    # Checks
    # --------------------------------------------------------------------------
    def _checkCanUpgrade(self, package_id: str, version: str) -> bool:
        installed_plugin_data = self._package_manager.getInstalledPackageInfo(package_id)
        if installed_plugin_data is None:
            return False

        installed_version = installed_plugin_data["package_version"]
        return compareSemanticVersions(version, installed_version) > 0

    def _checkInstalled(self, package_id: str):
        return self._package_manager.isPackageInstalled(package_id)

    def _checkEnabled(self, id):
        if id in self._plugin_registry.getActivePlugins():
            return True
        return False

    def _createNetworkManager(self):
        if self._network_manager:
            self._network_manager.finished.disconnect(self._onRequestFinished)
            self._network_manager.networkAccessibleChanged.disconnect(self._onNetworkAccesibleChanged)
        self._network_manager = QNetworkAccessManager()
        self._network_manager.finished.connect(self._onRequestFinished)
        self._network_manager.networkAccessibleChanged.connect(self._onNetworkAccesibleChanged)

    @pyqtProperty(bool, notify = restartRequiredChanged)
    def restartRequired(self):
        return self._restart_required

    @pyqtSlot()
    def restart(self):
        CuraApplication.getInstance().windowClosed()



    # Make API Calls
    # --------------------------------------------------------------------------
    def _requestPackages(self):
        Logger.log("i", "Toolbox: Requesting package list from server.")
        url = QUrl("{base_url}/packages".format(base_url = self._api_url))
        self._get_packages_request = QNetworkRequest(url)
        self._get_packages_request.setRawHeader(*self._request_header)
        self._network_manager.get(self._get_packages_request)

    def _requestShowcase(self):
        Logger.log("i", "Toolbox: Requesting showcase list from server.")
        url = QUrl("{base_url}/showcase".format(base_url = self._api_url))
        self._get_showcase_request = QNetworkRequest(url)
        self._get_showcase_request.setRawHeader(*self._request_header)
        self._network_manager.get(self._get_showcase_request)

    @pyqtSlot(str)
    def startDownload(self, url):
        Logger.log("i", "Toolbox: Attempting to download & install package from %s.", url)
        url = QUrl(url)
        self._download_request = QNetworkRequest(url)
        self._download_request.setAttribute(QNetworkRequest.RedirectPolicyAttribute, QNetworkRequest.NoLessSafeRedirectPolicy)
        self._download_request.setRawHeader(*self._request_header)
        self._download_reply = self._network_manager.get(self._download_request)
        self.setDownloadProgress(0)
        self.setIsDownloading(True)
        self._download_reply.downloadProgress.connect(self._onDownloadProgress)

    @pyqtSlot()
    def cancelDownload(self):
        Logger.log("i", "Toolbox: User cancelled the download of a plugin.")
        self._download_reply.abort()
        self._download_reply.downloadProgress.disconnect(self._onDownloadProgress)
        self._download_reply = None
        self._download_request = None
        self.setDownloadProgress(0)
        self.setIsDownloading(False)



    # Handlers for Download Events
    # --------------------------------------------------------------------------
    def _onNetworkAccesibleChanged(self, accessible):
        if accessible == 0:
            self.setDownloadProgress(0)
            self.setIsDownloading(False)
            if self._download_reply:
                self._download_reply.downloadProgress.disconnect(self._onDownloadProgress)
                self._download_reply.abort()
                self._download_reply = None

    # TODO: This function is sooooo ugly. Needs a rework:
    def _onRequestFinished(self, reply):
        reply_url = reply.url().toString()
        if reply.error() == QNetworkReply.TimeoutError:
            Logger.log("w", "Got a timeout.")
            # Reset everything.
            self.setDownloadProgress(0)
            self.setIsDownloading(False)
            if self._download_plugin_reply:
                self._download_plugin_reply.downloadProgress.disconnect(self._onDownloadProgress)
                self._download_plugin_reply.abort()
                self._download_plugin_reply = None
            return
        elif reply.error() == QNetworkReply.HostNotFoundError:
            Logger.log("w", "Unable to reach server.")
            return

        if reply.operation() == QNetworkAccessManager.GetOperation:
            if reply_url == "{base_url}/packages".format(base_url = self._api_url):
                try:
                    json_data = json.loads(bytes(reply.readAll()).decode("utf-8"))
                    print(json_data)
                    # Create packages model with all packages:
                    if not self._packages_model:
                        self._packages_model = PackagesModel()
                    self._packages_metadata = json_data["data"]
                    self._packages_model.setPackagesMetaData(self._packages_metadata)
                    self.metadataChanged.emit()

                    # Create authors model with all authors:
                    if not self._authors_model:
                        self._authors_model = AuthorsModel()
                    # TODO: Remove this hacky code once there's an API call for this.
                    self._authors_metadata = []
                    for package in self._packages_metadata:
                        package["author"]["type"] = package["package_type"]
                        if package["author"] not in self._authors_metadata:
                            self._authors_metadata.append(package["author"])
                    self._authors_model.setMetaData(self._authors_metadata)
                    self.metadataChanged.emit()
                    self.setViewPage("overview")

                    # TODO: Also replace this with a proper API call:
                    if not self._materials_showcase_model:
                        self._materials_showcase_model = AuthorsModel()
                    # TODO: Remove this hacky code once there's an API call for this.
                    self._materials_showcase_model.setMetaData([
                        {
                            "name": "DSM",
                            "email": "contact@dsm.nl",
                            "website": "www.dsm.nl",
                            "type": "material"
                        },
                        {
                            "name": "BASF",
                            "email": "contact@basf.de",
                            "website": "www.basf.de",
                            "type": "material"
                        }
                    ])
                    self.metadataChanged.emit()
                    self.setViewPage("overview")

                except json.decoder.JSONDecodeError:
                    Logger.log("w", "Toolbox: Received invalid JSON for package list.")
                    return


            elif reply_url == "{base_url}/showcase".format(base_url = self._api_url):
                try:
                    json_data = json.loads(bytes(reply.readAll()).decode("utf-8"))
                    # Create packages model with all packages:
                    if not self._plugins_showcase_model:
                        self._plugins_showcase_model = PackagesModel()
                    self._showcase_metadata = json_data["data"]
                    print(self._showcase_metadata)
                    self._plugins_showcase_model.setPackagesMetaData(self._showcase_metadata)
                    for package in self._plugins_showcase_model.items:
                        print(package)
                    self.metadataChanged.emit()
                except json.decoder.JSONDecodeError:
                    Logger.log("w", "Toolbox: Received invalid JSON for showcase.")
                    return
        else:
            # Ignore any operation that is not a get operation
            pass

    def _onDownloadProgress(self, bytes_sent, bytes_total):
        if bytes_total > 0:
            new_progress = bytes_sent / bytes_total * 100
            self.setDownloadProgress(new_progress)
            if new_progress == 100.0:
                self.setIsDownloading(False)
                self._download_reply.downloadProgress.disconnect(self._onDownloadProgress)
                # must not delete the temporary file on Windows
                self._temp_plugin_file = tempfile.NamedTemporaryFile(mode = "w+b", suffix = ".curapackage", delete = False)
                file_path = self._temp_plugin_file.name
                # write first and close, otherwise on Windows, it cannot read the file
                self._temp_plugin_file.write(self._download_reply.readAll())
                self._temp_plugin_file.close()
                self._onDownloadComplete(file_path)
                return

    def _onDownloadComplete(self, file_path):
        Logger.log("i", "Toolbox: Download complete.")
        print(file_path)
        try:
            package_info = self._package_manager.getPackageInfo(file_path)
        except:
            Logger.logException("w", "Toolbox: Package file [%s] was not a valid CuraPackage.", file_path)
            return

        license_content = self._package_manager.getPackageLicense(file_path)
        if license_content is not None:
            self.openLicenseDialog(package_info["package_id"], license_content, file_path)
            return

        self.installPlugin(file_path)
        return


    # Getter & Setters
    # --------------------------------------------------------------------------
    def setDownloadProgress(self, progress):
        if progress != self._download_progress:
            self._download_progress = progress
            self.onDownloadProgressChanged.emit()
    @pyqtProperty(int, fset = setDownloadProgress, notify = onDownloadProgressChanged)
    def downloadProgress(self):
        return self._download_progress

    def setIsDownloading(self, is_downloading):
        if self._is_downloading != is_downloading:
            self._is_downloading = is_downloading
            self.onIsDownloadingChanged.emit()
    @pyqtProperty(bool, fset = setIsDownloading, notify = onIsDownloadingChanged)
    def isDownloading(self):
        return self._is_downloading

    def setActivePackage(self, package):
        self._active_package = package
        self.activePackageChanged.emit()
    @pyqtProperty(QObject, fset = setActivePackage, notify = activePackageChanged)
    def activePackage(self):
        return self._active_package

    def setViewCategory(self, category = "plugins"):
        self._view_category = category
        self.viewChanged.emit()
    @pyqtProperty(str, fset = setViewCategory, notify = viewChanged)
    def viewCategory(self):
        return self._view_category

    def setViewPage(self, page = "overview"):
        self._view_page = page
        self.viewChanged.emit()
    @pyqtProperty(str, fset = setViewPage, notify = viewChanged)
    def viewPage(self):
        return self._view_page

    def setViewSelection(self, selection = ""):
        self._view_selection = selection
        self.viewChanged.emit()
    @pyqtProperty(str, fset = setViewSelection, notify = viewChanged)
    def viewSelection(self):
        return self._view_selection



    # Model Filtering
    # --------------------------------------------------------------------------
    @pyqtSlot(str, str)
    def filterPackages(self, filterType, parameter):
        if not self._packages_model:
            return
        self._packages_model.setFilter({ filterType: parameter })
        self.filterChanged.emit()

    @pyqtSlot()
    def unfilterPackages(self):
        if not self._packages_model:
            return
        self._packages_model.setFilter({})
        self.filterChanged.emit()

    @pyqtSlot(str, str)
    def filterAuthors(self, filterType, parameter):
        if not self._authors_model:
            return
        self._authors_model.setFilter({ filterType: parameter })
        self.filterChanged.emit()

    @pyqtSlot()
    def unfilterAuthors(self):
        if not self._authors_model:
            return
        self._authors_model.setFilter({})
        self.filterChanged.emit()