test Demo

nxdrive/data/i18n/i18n.json

@@ -287,6 +287,7 @@
     "OTHER": "Other",
     "PASSWORD": "Password",
     "PERSONAL_SPACE": "Personal space",
+    "PENDING_DOCUMENT_REVIEWS": "Awaiting document review for \"%1\" ",
     "PROXY": "Proxy",
     "PROXY_APPLIED": "Proxy settings have been updated",
     "PROXY_CHANGE_SETTINGS": "Proxy",
@@ -366,6 +367,7 @@
     "SYNCHRONIZATION_IN_PROGRESS": "Synchronization in progress",
     "SYNCHRONIZATION_ITEMS_LEFT": "Remaining items: %1",
     "SYSTEM": "System",
+    "TASK_MAMNAGER_WINDOW_TITLE": "Task Manager",
     "TECHNICAL_DETAILS": "Technical details:",
     "TYPE": "Type",
     "UNAUTHORIZED": "Incorrect credentials",

nxdrive/data/qml/Main.qml

@@ -82,4 +82,20 @@ QtObject {
 
         DirectTransfer { id: directTransfer }
     }
+
+    property var taskManagerWindow: CustomWindow {
+        id: taskManagerWindow
+        minimumWidth: 600
+        minimumHeight: 480
+        objectName: "taskManagerWindow"
+        title: qsTr("TASK_MAMNAGER_WINDOW_TITLE").arg(APP_NAME) + tl.tr
+        width: taskManager.width; height: taskManager.height
+        visible: false
+
+        signal setEngine(string uid)
+
+        onSetEngine: taskManagerWindow.setEngine(uid)
+
+        TaskManager { id: taskManager }
+    }
 }

nxdrive/data/qml/SystrayMenu.qml

@@ -14,6 +14,14 @@ ShadowRectangle {
     ColumnLayout {
         id: menuContent
         spacing: 0
+
+        SystrayMenuItem {
+            text: qsTr("Tasks")
+            onClicked: {
+                api.show_tasks("Tasks Manager")
+                control.visible = false
+            }
+        }
 
         SystrayMenuItem {
             text: qsTr("SETTINGS") + tl.tr

nxdrive/data/qml/TaskManager.qml

@@ -0,0 +1,51 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+import QtQuick.Layouts 1.15
+import QtQuick.Window 2.15
+import "icon-font/Icon.js" as MdiFont
+
+
+
+Rectangle {
+    id: taskManager
+    anchors.fill: parent
+
+    property string engineUid: ""
+    property int activeSessionsCount: 0
+    property int completedSessionsCount: 0
+    property double startTime: 0.0
+
+    signal setEngine(string uid)
+
+    onSetEngine: {
+        engineUid = uid
+    }
+
+    TabBar {
+        id: bar
+        width: parent.width
+        height: 50
+        spacing: 0
+
+        anchors.top: buttonzone.bottom
+
+        SettingsTab {
+            text: qsTr("Tasks") + tl.tr
+            barIndex: bar.currentIndex;
+            index: 0
+            anchors.top: parent.top
+        }
+
+   }
+
+   Text {
+            anchors.fill: parent
+            horizontalAlignment: Qt.AlignHCenter
+            verticalAlignment: Qt.AlignVCenter
+            height: 100
+            /*textFormat: Text.RichText*/
+            text: api.get_title(engineUid)
+            font.pointSize: point_size * 1.2
+            color: primaryText
+        }
+}

nxdrive/engine/engine.py

@@ -116,6 +116,7 @@
     directTransferNewFolderError = pyqtSignal()
     directTransferNewFolderSuccess = pyqtSignal(str)
     directTransferSessionFinished = pyqtSignal(str, str, str)
+    displayPendingTask = pyqtSignal(str, str)
 
     type = "NXDRIVE"
     # Folder locker - LocalFolder processor can prevent
@@ -199,6 +200,7 @@
             self.remote = self.init_remote()
 
         self._create_queue_manager()
+
         if Feature.synchronization:
             self._create_remote_watcher()
             self._create_local_watcher()
@@ -629,6 +631,9 @@
         # And add new pairs to the queue
         self.dao.queue_many_direct_transfer_items(current_max_row_id)
 
+    def fetch_pending_task_list(self, task_id: str) -> None:
+        self.displayPendingTask.emit(self.uid, task_id)
+
     def handle_session_status(self, session: Optional[Session], /) -> None:
         """Check the session status and send a notification if finished."""
         if not session or session.status is not TransferStatus.DONE:
@@ -747,6 +752,26 @@
         }
         return urls[self.force_ui or self.wui]
 
+    def get_task_url(self, remote_ref: str, /, *, edit: bool = False) -> str:
+        """
+        Build the document's metadata URL based on the server's UI.
+        Default is Web-UI.  In case of unknown UI, use the default value.
+
+        :param remote_ref: The document remote reference (UID) of the
+            document we want to show metadata.
+        :param edit: Show the metadata edit page instead of the document.
+        :return: The complete URL.
+        """
+        # uid = remote_ref.split("#")[-1]
+        repo = self.remote.client.repository
+        page = ("view_documents", "view_drive_metadata")[edit]
+
+        urls = {
+            "jsf": f"{self.server_url}tasks/{repo}/{remote_ref}/{page}",
+            "web": f"{self.server_url}ui#!/tasks/{remote_ref}",
+        }
+        return urls[self.force_ui or self.wui]
+
     def is_syncing(self) -> bool:
         return self._sync_started
 

nxdrive/gui/api.py

@@ -1,3 +1,5 @@
+# flake8: noqa
+
 import json
 from dataclasses import asdict
 from logging import getLogger
@@ -21,6 +23,7 @@
     TransferStatus,
 )
 from ..dao.engine import EngineDAO
+from ..engine.engine import Engine
 from ..exceptions import (
     AddonForbiddenError,
     AddonNotInstalledError,
@@ -305,6 +308,7 @@
         engine = self._manager.engines.get(uid)
         if engine:
             path = engine.local.abspath(Path(ref))
+            self.fetch_pending_tasks(engine)
             self.application.show_metadata(path)
 
     @pyqtSlot(str, result=list)
@@ -457,6 +461,43 @@
         self.application.hide_systray()
         log.info(f"Show settings on section {section}")
         self.application.show_settings(section)
+
+    @pyqtSlot(str)
+    def show_tasks(self, section: str, /) -> None:
+        self.application.hide_systray()
+        log.info(f"Show Task Manager {section}")
+        self.application.show_tasks(section)
+
+    @pyqtSlot()
+    def fetch_pending_tasks(self, engine: Engine, /) -> None:
+        log.info("Check for pending approval tasks")
+        endpoint = "/api/v1/task/"
+        url = "http://localhost:8080/nuxeo" + endpoint
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        try:
+            # response = NuxeoClient.request(self,method="GET", path=endpoint, headers=headers, ssl_verify=Options.ssl_no_verify)
+            response = requests.get(
+                url=url,
+                verify=True,
+                timeout=3600,
+                headers=headers,
+                auth=("Administrator", "Administrator"),
+            )
+            log.info(f">>>>> response type: {type(response)}")
+            data = response.json()
+            log.info(f">>>> response: {data}")
+            if data["resultsCount"] > 0:
+                log.info("Send pending task notification")
+                for task in data["entries"]:
+                    log.info(f">>>> task: {task}")
+                    log.info(f">>>> taskid: {task['id']}")
+                    engine.fetch_pending_task_list(task["id"])
+
+        except Exception:
+            log.exception("Unable to fetch tasks")
 
     @pyqtSlot()
     def quit(self) -> None:
@@ -576,7 +617,9 @@
     def _balance_percents(self, result: Dict[str, float], /) -> Dict[str, float]:
         """Return an altered version of the dict in which no value is under a minimum threshold."""
 
-        result = {k: v for k, v in sorted(result.items(), key=lambda item: item[1])}
+        result = {
+            k: v for k, v in sorted(result.items(), key=lambda item: item[1])
+        }  # noqa
         keys = list(result)
         min_threshold = 10
         data = 0.0
@@ -1099,8 +1142,47 @@
         except OSError:
             log.exception("Remote document cannot be opened")
 
+    @pyqtSlot(str, str, str)
+    def display_pending_task(self, uid: str, remote_ref: str, /) -> None:
+        log.info(f"Should open remote document ({remote_ref!r})")
+        try:
+            engine = self._manager.engines.get(uid)
+            if engine:
+                url = engine.get_task_url(remote_ref)
+                log.info(f">>>> doc url: {url}")
+                engine.open_remote(url=url)
+        except OSError:
+            log.exception("Remote document cannot be opened")
+
     @pyqtSlot(str, str, result=str)
     def get_remote_document_url(self, uid: str, remote_ref: str, /) -> str:
         """Return the URL to a remote document based on its reference."""
         engine = self._manager.engines.get(uid)
         return engine.get_metadata_url(remote_ref) if engine else ""
+
+    @pyqtSlot(str, result=str)
+    def get_title(self, uid: str, /) -> str:
+        endpoint = "/api/v1/task/"
+        url = "http://localhost:8080/nuxeo" + endpoint
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        try:
+            response = requests.get(
+                url=url,
+                verify=True,
+                timeout=3600,
+                headers=headers,
+                auth=("Administrator", "Administrator"),
+            )
+            data = response.json()
+            html = data["entries"][0]
+            html = html["variables"]
+            html = html["review_result"]
+            return html if html else "No Results To Show"
+
+        except Exception:
+            log.exception("Unable to fetch tasks")
+            return "No Results Found"
+

nxdrive/gui/application.py

@@ -215,6 +215,9 @@
         # Setup notification center for macOS
         if MAC:
             self._setup_notification_center()
+        current_uid = self.engine_model.engines_uid[0]
+        engine = self.manager.engines[current_uid]
+        self.api.fetch_pending_tasks(engine)
 
         # Application update
         self.manager.updater.appUpdated.connect(self.quit)
@@ -259,6 +262,7 @@
             del self.settings_window
             del self.systray_window
             del self.direct_transfer_window
+            del self.task_manager_window
         else:
             del self.app_engine
 
@@ -327,6 +331,15 @@
             self.direct_transfer_window.setSource(
                 QUrl.fromLocalFile(str(find_resource("qml", file="DirectTransfer.qml")))
             )
+
+            # Task Manager
+            self.task_manager_window = CustomWindow()
+            self.task_manager_window.setMinimumWidth(300)
+            self.task_manager_window.setMinimumHeight(240)
+            self._fill_qml_context(self.task_manager_window.rootContext())
+            self.task_manager_window.setSource(
+                QUrl.fromLocalFile(str(find_resource("qml", file="TaskManager.qml")))
+            )
 
             flags |= qt.Popup
         else:
@@ -342,6 +355,7 @@
             self.direct_transfer_window = root.findChild(
                 CustomWindow, "directTransferWindow"
             )
+            self.task_manager_window = root.findChild(CustomWindow, "taskManagerWindow")
 
             if LINUX:
                 flags |= qt.Drawer
@@ -360,6 +374,7 @@
         if self.manager.engines:
             current_uid = self.engine_model.engines_uid[0]
             engine = self.manager.engines[current_uid]
+            # self.api.fetch_pending_tasks(engine)
             self.get_last_files(current_uid)
             self.refresh_transfers(engine.dao)
             self.update_status(engine)
@@ -886,6 +901,14 @@
         }
         self._window_root(self.settings_window).setSection.emit(sections[section])
         self._center_on_screen(self.settings_window)
+
+    @pyqtSlot(str)
+    def show_tasks(self, section: str, /) -> None:
+        # Note: Keep synced with the TaskManager.qml file
+        sections = {
+        }
+        self._window_root(self.task_manager_window) # .setSection.emit(sections[section])
+        self._center_on_screen(self.task_manager_window)
 
     @pyqtSlot()
     def show_systray(self) -> None:

nxdrive/notification.py

@@ -189,6 +189,7 @@
             return
         notification = self._notifications[uid]
         if notification.is_actionable():
+            log.info(">>>>> sending actionable notification")
             self.triggerNotification.emit(notification.action, notification.action_args)
         if notification.is_discard_on_trigger():
             self.discard_notification(uid)
@@ -520,6 +521,31 @@
         )
 
 
+class DisplayPendingTask(Notification):
+    """Display a notification for pending tasks"""
+
+    def __init__(self, engine_uid: str, remote_ref: str, /) -> None:
+        values = [remote_ref]
+        super().__init__(
+            uid="PENDING_DOCUMENT_REVIEWS",
+            title="Display Pending Task",
+            description=Translator.get("PENDING_DOCUMENT_REVIEWS", values=values),
+            level=Notification.LEVEL_INFO,
+            flags=(
+                Notification.FLAG_PERSISTENT
+                | Notification.FLAG_BUBBLE
+                | Notification.FLAG_ACTIONABLE
+                | Notification.FLAG_DISCARD_ON_TRIGGER
+                | Notification.FLAG_REMOVE_ON_DISCARD
+            ),
+            action="display_pending_task",
+            action_args=(
+                engine_uid,
+                remote_ref,
+            ),
+        )
+
+
 class DefaultNotificationService(NotificationService):
     def init_signals(self) -> None:
         self._manager.initEngine.connect(self._connect_engine)
@@ -539,6 +565,10 @@
         engine.directTransferSessionFinished.connect(
             self._direct_transfer_session_finshed
         )
+        engine.displayPendingTask.connect(self._display_pending_task)
+
+    def _display_pending_task(self, engine_uid: str, remote_ref: str, /) -> None:
+        self.send_notification(DisplayPendingTask(engine_uid, remote_ref))
 
     def _direct_transfer_error(self, file: Path, /) -> None:
         """Display a notification when a Direct Transfer is in error."""