Merge branch 'dev' into dependabot/npm_and_yarn/npm_and_yarn-04d31be16b

Author: pradeeban

package-lock.json

@@ -1,11 +1,18 @@
-from model.workflows import *
+from model.workflows import WorkFlowModel
 from flask import request, make_response, Blueprint
 import defusedxml.ElementTree as ET
 
 workFlow = Blueprint('workflow', __name__)
 workFlowModel = WorkFlowModel()
 
 
+def isMissingWorkflow(graphml):
+    if graphml is None:
+        return True
+    # Backward-compatible guard for legacy model return type.
+    return isinstance(graphml, tuple) and len(graphml) > 0 and graphml[0] is False
+
+
 def getLasteshActionHash(root):
     xmlns = root.tag[root.tag.index('{')+1:root.tag.rindex('}')]
     return root.find(f'{{{xmlns}}}graph')\
@@ -32,7 +39,7 @@ def postWorkflow():
 @workFlow.route("/<serverID>")
 def getWorkflow(serverID):
     graphml = workFlowModel.get(serverID)
-    if graphml is None:
+    if isMissingWorkflow(graphml):
         return "Not Found", 404
     if('X-Latest-Hash' in request.headers):
         latestHash = request.headers['X-Latest-Hash']

server/controller/workflow.py

@@ -32,7 +32,7 @@ def insert(self, graphml, latestHash):
     def get(self, serverID):
         cl = self.collection.find_one({'serverID': serverID})
         if not cl:
-            return False, 'Record Not Found'
+            return None
         return cl['graphml']
 
     def update(self, serverID, graphml, latestHash, allHash):

server/model/workflows.py

@@ -1,5 +1,5 @@
 dnspython==2.6.1
-Flask==2.2.5
+Flask==3.1.3
 python-dotenv==0.19.0
 pymongo==4.6.3
 gunicorn==23.0.0

server/requirements.txt

@@ -0,0 +1,82 @@
+import importlib
+import pathlib
+import sys
+import types
+import unittest
+
+from flask import Flask
+
+VALID_GRAPHML = (
+    '<graphml xmlns="http://graphml.graphdrawing.org/xmlns">'
+    '<graph edgedefault="directed">'
+    '<actionHistory><hash>hash-1</hash></actionHistory>'
+    '</graph>'
+    '</graphml>'
+)
+
+
+class FakeWorkFlowModel:
+    def __init__(self, graph_response):
+        self.graph_response = graph_response
+
+    def get(self, _server_id):
+        return self.graph_response
+
+
+class WorkflowControllerTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        server_root = pathlib.Path(__file__).resolve().parents[1]
+        if str(server_root) not in sys.path:
+            sys.path.insert(0, str(server_root))
+
+        fake_model_pkg = types.ModuleType('model')
+        fake_model_workflows = types.ModuleType('model.workflows')
+
+        class StubWorkFlowModel:
+            def get(self, _server_id):
+                return None
+
+        fake_model_workflows.WorkFlowModel = StubWorkFlowModel
+        fake_model_pkg.workflows = fake_model_workflows
+
+        sys.modules['model'] = fake_model_pkg
+        sys.modules['model.workflows'] = fake_model_workflows
+
+        if 'controller.workflow' in sys.modules:
+            del sys.modules['controller.workflow']
+        cls.workflow_module = importlib.import_module('controller.workflow')
+
+    def make_client(self, graph_response):
+        self.workflow_module.workFlowModel = FakeWorkFlowModel(graph_response)
+        app = Flask(__name__)
+        app.register_blueprint(self.workflow_module.workFlow, url_prefix='/workflow')
+        return app.test_client()
+
+    def test_missing_workflow_returns_404_for_none(self):
+        client = self.make_client(None)
+        response = client.get('/workflow/missing-id')
+        self.assertEqual(response.status_code, 404)
+        self.assertEqual(response.get_data(as_text=True), 'Not Found')
+
+    def test_missing_workflow_returns_404_for_legacy_tuple(self):
+        client = self.make_client((False, 'Record Not Found'))
+        response = client.get('/workflow/missing-id')
+        self.assertEqual(response.status_code, 404)
+        self.assertEqual(response.get_data(as_text=True), 'Not Found')
+
+    def test_hash_header_returns_400_for_different_history(self):
+        client = self.make_client(VALID_GRAPHML)
+        response = client.get('/workflow/existing-id', headers={'X-Latest-Hash': 'unknown-hash'})
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.get_data(as_text=True), 'Different History')
+
+    def test_hash_header_returns_200_for_matching_history(self):
+        client = self.make_client(VALID_GRAPHML)
+        response = client.get('/workflow/existing-id', headers={'X-Latest-Hash': 'hash-1'})
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.get_data(as_text=True), VALID_GRAPHML)
+
+
+if __name__ == '__main__':
+    unittest.main()

server/tests/test_workflow_controller.py

@@ -56,11 +56,18 @@ function Graph({
     }, [active, instance, graphID, dispatcher]);
 
     useEffect(() => {
+        const handleResize = () => setContainerDim(ref.current);
+        let graph = null;
         if (ref.current) {
             setContainerDim(ref.current);
-            window.addEventListener('resize', () => setContainerDim(ref.current));
-            setInstance(initialiseNewGraph());
+            window.addEventListener('resize', handleResize);
+            graph = initialiseNewGraph();
+            setInstance(graph);
         }
+        return () => {
+            window.removeEventListener('resize', handleResize);
+            if (graph) graph.dispose();
+        };
     }, [ref]);
 
     // Update theme when darkMode changes

src/GraphArea.jsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import ZoomComp from './component/ZoomSetter';
-
-// import { actionType as T } from './reducer';
+import ConfirmModal from './component/modals/ConfirmModal';
+import { actionType as T } from './reducer';
 import './graphWorkspace.css';
 // import localStorageManager from './graph-builder/local-storage-manager';
 import TabBar from './component/TabBar';
@@ -80,6 +80,16 @@ const GraphComp = (props) => {
                 ))}
                 <ZoomComp dispatcher={dispatcher} superState={superState} />
             </div>
+            <ConfirmModal
+                isOpen={superState.confirmModal.open}
+                title="Confirm"
+                message={superState.confirmModal.message}
+                onConfirm={() => {
+                    if (superState.confirmModal.onConfirm) superState.confirmModal.onConfirm();
+                    dispatcher({ type: T.SET_CONFIRM_MODAL, payload: { open: false, message: '', onConfirm: null } });
+                }}
+                onCancel={() => dispatcher({ type: T.SET_CONFIRM_MODAL, payload: { open: false, message: '', onConfirm: null } })}
+            />
         </div>
     );
 };

src/GraphWorkspace.jsx

@@ -0,0 +1,52 @@
+import React from 'react';
+
+const crashStyle = {
+    minHeight: '100vh',
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    padding: '24px',
+    backgroundColor: 'var(--bg-primary)',
+    color: 'var(--text-primary)',
+    textAlign: 'center',
+};
+
+class ErrorBoundary extends React.Component {
+    constructor(props) {
+        super(props);
+        this.state = { hasError: false };
+    }
+
+    static getDerivedStateFromError() {
+        return { hasError: true };
+    }
+
+    render() {
+        const { hasError } = this.state;
+        const { children } = this.props;
+
+        if (hasError) {
+            return (
+                <div style={crashStyle}>
+                    <div>
+                        <h2 style={{ marginBottom: '8px' }}>Something went wrong</h2>
+                        <p style={{ marginBottom: '16px', opacity: 0.9 }}>
+                            The app hit an unexpected error. Reload to continue.
+                        </p>
+                        <button
+                            type="button"
+                            className="btn btn-primary"
+                            onClick={() => window.location.reload()}
+                        >
+                            Reload
+                        </button>
+                    </div>
+                </div>
+            );
+        }
+
+        return children;
+    }
+}
+
+export default ErrorBoundary;

src/component/ErrorBoundary.jsx

@@ -6,42 +6,58 @@ import { readFile } from '../toolbarActions/toolbarFunctions';
 
 const app = ({ superState, dispatcher }) => {
     const fileRef = React.useRef();
+    const superStateRef = React.useRef(superState);
+    const dispatcherRef = React.useRef(dispatcher);
+
+    useEffect(() => {
+        superStateRef.current = superState;
+        dispatcherRef.current = dispatcher;
+    });
 
     useEffect(() => {
         dispatcher({ type: T.SET_FILE_REF, payload: fileRef });
         const p = document.getElementsByTagName('body')[0];
         const c = document.getElementsByClassName('drag-drop-area')[0];
         let cc = 0;
-        p.addEventListener('dragenter', (e) => {
+
+        const onDragEnter = (e) => {
             e.preventDefault();
             cc += 1;
             if (cc === 1) c.classList.remove('hidden');
-        });
-        p.addEventListener('dragleave', (e) => {
+        };
+        const onDragLeave = (e) => {
             e.preventDefault();
             cc -= 1;
             if (cc === 0) c.classList.add('hidden');
-        });
-
-        p.addEventListener('dragover', (e) => {
+        };
+        const onDragOver = (e) => { e.preventDefault(); };
+        const onDragReset = (e) => {
             e.preventDefault();
-        });
-        ['dragend', 'dragexit', 'drop'].forEach((dragEvent) => {
-            p.addEventListener(dragEvent, (e) => {
-                e.preventDefault();
-                cc = 0;
-                c.classList.add('hidden');
-            });
-        });
-
-        p.addEventListener('drop', (e) => {
+            cc = 0;
+            c.classList.add('hidden');
+        };
+        const onDrop = (e) => {
             e.preventDefault();
             fileRef.current.value = null;
             if (e.dataTransfer.files.length === 1
                 && e.dataTransfer.files[0].name.split('.').slice(-1)[0] === 'graphml') {
-                readFile(superState, dispatcher, e.dataTransfer.files[0]);
+                readFile(superStateRef.current, dispatcherRef.current, e.dataTransfer.files[0]);
             }
-        });
+        };
+
+        p.addEventListener('dragenter', onDragEnter);
+        p.addEventListener('dragleave', onDragLeave);
+        p.addEventListener('dragover', onDragOver);
+        ['dragend', 'dragexit', 'drop'].forEach((dragEvent) => p.addEventListener(dragEvent, onDragReset));
+        p.addEventListener('drop', onDrop);
+
+        return () => {
+            p.removeEventListener('dragenter', onDragEnter);
+            p.removeEventListener('dragleave', onDragLeave);
+            p.removeEventListener('dragover', onDragOver);
+            ['dragend', 'dragexit', 'drop'].forEach((dragEvent) => p.removeEventListener(dragEvent, onDragReset));
+            p.removeEventListener('drop', onDrop);
+        };
     }, []);
     return (
         <div className="drag-drop-area hidden">

src/component/File-drag-drop.jsx

@@ -15,7 +15,11 @@ export default function FullScreenButton() {
     };
 
     return (
-        <button type="button" onClick={toggleFullscreen}>
+        <button
+            type="button"
+            aria-label={isFullscreen ? 'Exit fullscreen' : 'Enter fullscreen'}
+            onClick={toggleFullscreen}
+        >
             {isFullscreen ? <Minimize size={20} /> : <Maximize size={20} />}
         </button>
     );