more loading screens, handle err_connection, added pull-to-refresh.

WebGde/WebContent/WebGde-Widgets/BPO/rejectElement.js

-import { createLoadingScreen, removeLoadingScreen, resetGDE } from "../../script.js";
+import { resetGDE } from "../../script.js";
 import { SCHEMA_FILE_PATH } from "../DataInputWidget/config.js";
 import { validateInput } from "../DataInputWidget/validateInput.js";
 import { goBackToElementListViewer } from "../ElementListWidget/ElementListWidget.js";
-import { createLoadingModal, removePrompt } from "../LoadingModal/LoadingModal.js";
+import { createLoadingModal, removeLoadingModal } from "../LoadingModal/LoadingModal.js";
 import { PROJECT_CODE } from "../Submit/config.js";
 import { ENCODING_PASS, REASON_LIST } from "../config.js";
 import { createInfoModal, createModal } from "../genericPopup/genericPopup.js";
@@ -39,7 +39,7 @@ async function rejectElement() {
             document.getElementById("backdropContainer").remove();
             if(goBackToElementListViewer()){
                 resetGDE();
-                removePrompt();
+                removeLoadingModal();
             };
         }
         createInfoModal(successfulReturn, 'OK', "Element rejected");

WebGde/WebContent/WebGde-Widgets/BPO/returnElement.js

-import { createLoadingScreen, removeLoadingScreen, resetGDE } from "../../script.js";
 import { SCHEMA_FILE_PATH } from "../DataInputWidget/config.js";
 import { validateInput } from "../DataInputWidget/validateInput.js";
 import { goBackToElementListViewer } from "../ElementListWidget/ElementListWidget.js";
-import { createLoadingModal, removePrompt } from "../LoadingModal/LoadingModal.js";
+import { createLoadingModal, removeLoadingModal } from "../LoadingModal/LoadingModal.js";
 import { PROJECT_CODE } from "../Submit/config.js";
 import { interval } from "../captureMetrics/captureMetrics.js";
 import { createConfirmationModal, createInfoModal, createModal } from "../genericPopup/genericPopup.js";
@@ -92,12 +91,12 @@ export function createReturnWindow() {
         if (response.status == 200) {
             sessionStorage.removeItem("section");
             sessionStorage.removeItem("doctype");
-            removePrompt();
+            removeLoadingModal();
             goBackToElementListViewer();
 
         }else{
             function errorReturn(){
-                removePrompt();
+                removeLoadingModal();
             }
             createInfoModal(errorReturn, 'Error', "Error ${response.status}: Returning element");
         }

WebGde/WebContent/WebGde-Widgets/ElementListWidget/ElementListWidget.js

-import { createWebGdeInterface, removeLoadingScreen } from '../../script.js';
+import { createWebGdeInterface } from '../../script.js';
 import { createReturnWindow } from '../BPO/returnElement.js';
 import { populateFields } from '../DataInputWidget/generateFields.js';
+import { createLoadingModal, removeLoadingModal } from '../LoadingModal/LoadingModal.js';
 import { logoutKeycloak } from '../Logout/Logout.js';
 import { ADD_NEW_OPTION, CURRENT_NODE, BPO_URL, DISPLAYED_DETAILS } from '../config.js';
 import { DocumentControlWidget } from "../documentControlWidget/documentControlWidget.js";
+import { createErrorModal } from '../genericPopup/genericPopup.js';
 import { INDEXED_DB_STORAGE, HIGHLIGHT_OBJECT, IMAGE_VIEWER_OBJECT, INDEXED_DB_NAME, INDEXED_DB_TBL_NAME, setIndexedDBStorage, setHighlightObject, setImageViewerObject, setBPOObject, BPO_OBJECT, DISPLAY_FIELD_OBJECT, setDisplayFieldObject, activateGDE, setDocumentControlObject, DOCUMENT_CONTROL_OBJECT, IS_GDE_ACTIVATED } from "../globalVariable.js";
+import PullToRefresh from './PullToRefresh.js';
+
 
 const API_ROOT = `${BPO_URL}req`;
 
@@ -16,7 +20,9 @@ export class ElementListWidget {
 		selectedElement: null,
 		workers: [],
 		queueIndex: null,
-		workerId: null
+		workerId: null,
+		searchInput: null,
+		pullToRefresh: null
 	};
 
 	constructor(nodeId, containerId) {
@@ -33,7 +39,19 @@ export class ElementListWidget {
 		this.init(nodeId, this.global.workerId);
 	}
 
-	async init(nodeId, workerId) {
+	async init(nodeId, workerId) { 
+		this.render();
+
+		createLoadingModal("Fetching Elements", "Fetching Workers", null, null, null);
+
+		this.global.pullToRefresh = PullToRefresh.init({
+			mainElement: '#element-list',
+			onRefresh: async () => {
+				// Call the init function again
+				await this.reloadElementList(nodeId, workerId);
+			}
+		});
+
 		console.log(`Fetching workers for node ID: ${nodeId}`);
 		const workerResponse = await fetchWorkersForNode(nodeId);
 		console.log("Worker API Response:", workerResponse);
@@ -42,6 +60,8 @@ export class ElementListWidget {
 			this.global.workers = workerResponse.workers;
 		} else {
 			console.error('Failed to fetch workers:', workerResponse);
+			removeLoadingModal();
+			createErrorModal(null, "Close", "Failed to fetch workers.");
 			return;
 		}
 
@@ -49,6 +69,8 @@ export class ElementListWidget {
 
 		if (!selectedWorker) {
 			console.error(`Worker with ID ${workerId} not found.`);
+			removeLoadingModal();
+			createErrorModal(null, "Close", "Worker not found.");
 			return;
 		}
 
@@ -62,10 +84,54 @@ export class ElementListWidget {
 			);
 		} else {
 			this.elements = [];
+			removeLoadingModal();
+			createErrorModal(null, "Close", `Failed to fetch elements or received malformed data: ${elementResponse}`);
 			console.error('Failed to fetch elements or received malformed data:', elementResponse);
+			return;
 		}
 
-		this.render();
+		// Populate the list with all elements initially
+		this.applySearchFilter('');
+		removeLoadingModal();
+	}
+
+	async reloadElementList (nodeId, workerId){
+		console.log(`Fetching workers for node ID: ${nodeId}`);
+		const workerResponse = await fetchWorkersForNode(nodeId);
+		console.log("Worker API Response:", workerResponse);
+
+		if (workerResponse.successful && Array.isArray(workerResponse.workers)) {
+			this.global.workers = workerResponse.workers;
+		} else {
+			console.error('Failed to fetch workers:', workerResponse);
+			createErrorModal(null, "Close", "Failed to fetch workers.");
+			return;
+		}
+
+		const selectedWorker = this.global.workers.find(worker => worker.workerId === workerId);
+
+		if (!selectedWorker) {
+			console.error(`Worker with ID ${workerId} not found.`);
+			createErrorModal(null, "Close", "Worker not found.");
+		}
+
+		/*		console.log(`Fetching elements for node ID: ${nodeId}`);*/
+		const elementResponse = await fetchElementsForNode(nodeId);
+		/*		console.log("Elements API Response:", elementResponse);*/
+
+		if (elementResponse.successful && Array.isArray(elementResponse.elements)) {
+			this.elements = elementResponse.elements.filter(element =>
+				selectedWorker.queueIndex.includes(element.queueIndex)
+			);
+		} else {
+			this.elements = [];
+			createErrorModal(null, "Close", `Failed to fetch elements or received malformed data: ${elementResponse}`);
+			console.error('Failed to fetch elements or received malformed data:', elementResponse);
+			return;
+		}
+
+		// Populate the list with all elements initially
+		this.applySearchFilter(this.global.searchInput.value);
 	}
 
 	render() {
@@ -94,11 +160,11 @@ export class ElementListWidget {
 		topDiv.classList.add("element-list-top-div");
 
 		// Create a search input field
-		const searchInput = document.createElement("input");
-		searchInput.placeholder = "Search elements...";
-		searchInput.id = "search-input";
-		searchInput.type = "text";
-		topDiv.appendChild(searchInput);
+		this.global.searchInput = document.createElement("input");
+		this.global.searchInput.placeholder = "Search elements...";
+		this.global.searchInput.id = "search-input";
+		this.global.searchInput.type = "text";
+		topDiv.appendChild(this.global.searchInput);
 		this.global.container.appendChild(topDiv);
 
 		// Create user profile icon span
@@ -146,8 +212,8 @@ export class ElementListWidget {
 		topDiv.appendChild(userProfileIcon);
 
 		// Event listener for search input
-		searchInput.addEventListener("input", () => {
-			this.applySearchFilter(searchInput.value);
+		this.global.searchInput.addEventListener("input", () => {
+			this.applySearchFilter(this.global.searchInput.value);
 		});
 
 		// Create an element list container for the elements
@@ -156,9 +222,6 @@ export class ElementListWidget {
 		elementList.id = "element-list";
 		this.global.container.appendChild(elementList);
 
-		// Populate the list with all elements initially
-		this.applySearchFilter('');
-
 		// Create a parent div for the buttons
 		const buttonContainer = document.createElement("div");
 		buttonContainer.classList.add("button-container");
@@ -259,8 +322,6 @@ export class ElementListWidget {
 	}
 
 
-
-
 	showExtraDetails(element, elementContainer) {
 		// Remove existing extra details if any
 		this.removeExtraDetails(elementContainer);
@@ -417,23 +478,59 @@ export class ElementListWidget {
 }
 
 async function fetchWorkersForNode(nodeId) {
-	const response = await fetch(`${API_ROOT}/nodes/${nodeId}/workers`);
-	return await response.json();
+    try {
+        const response = await fetch(`${API_ROOT}/nodes/${nodeId}/workers`);
+
+        if (!response.ok) {
+            throw new Error(`Error: ${response.status}`);
+        }
+
+        return await response.json();
+    } catch (error) {
+        return { error: 'Connection error' };
+    }
 }
 
 async function fetchElementsForNode(nodeId) {
-	const response = await fetch(`${API_ROOT}/nodes/${nodeId}/elements`);
-	return await response.json();
+    try {
+        const response = await fetch(`${API_ROOT}/nodes/${nodeId}/elements`);
+
+        if (!response.ok) {
+            throw new Error(`Error: ${response.status}`);
+        }
+
+        return await response.json();
+    } catch (error) {
+        return { error: 'Connection error' };
+    }
 }
 
 async function assignElementToWorker(workerId, nodeId, queueIndex, elementId) {
-	const response = await fetch(`${API_ROOT}/workers/${workerId}/nodes/${nodeId}/elements/${queueIndex}/${elementId}`);
-	return await response.json();
+    try {
+        const response = await fetch(`${API_ROOT}/workers/${workerId}/nodes/${nodeId}/elements/${queueIndex}/${elementId}`);
+
+        if (!response.ok) {
+            throw new Error(`Error: ${response.status}`);
+        }
+
+        return await response.json();
+    } catch (error) {
+        return { error: 'Connection error' };
+    }
 }
 
 async function assignReturnedElementToWorker(workerId, nodeId, elementId) {
-	const response = await fetch(`${API_ROOT}/workers/${workerId}/nodes/${nodeId}/returned-elements/${elementId}`);
-	return await response.json();
+    try {
+        const response = await fetch(`${API_ROOT}/workers/${workerId}/nodes/${nodeId}/returned-elements/${elementId}`);
+
+        if (!response.ok) {
+            throw new Error(`Error: ${response.status}`);
+        }
+
+        return await response.json();
+    } catch (error) {
+        return { error: 'Connection error' };
+    }
 }
 
 export function goBackToElementListViewer() {
@@ -447,7 +544,6 @@ export function goBackToElementListViewer() {
 
 	// Reinstantiate and reinitialize the ElementListWidget
 	new ElementListWidget(CURRENT_NODE, 'containerId');
-	removeLoadingScreen();
 	return true;
 }
 

WebGde/WebContent/WebGde-Widgets/ElementListWidget/PullToRefresh.js

+/*!
+ * pulltorefreshjs v0.1.22
+ * (c) Rafael Soto
+ * Released under the MIT License.
+ */
+var PullToRefresh = (function () {
+
+  var _shared = {
+    pullStartY: null,
+    pullMoveY: null,
+    handlers: [],
+    styleEl: null,
+    events: null,
+    dist: 0,
+    state: 'pending',
+    timeout: null,
+    distResisted: 0,
+    supportsPassive: false,
+    supportsPointerEvents: typeof window !== 'undefined' && !!window.PointerEvent
+  };
+
+  try {
+    window.addEventListener('test', null, {
+      get passive() {
+        // eslint-disable-line getter-return
+        _shared.supportsPassive = true;
+      }
+
+    });
+  } catch (e) {// do nothing
+  }
+
+  function setupDOM(handler) {
+    if (!handler.ptrElement) {
+      var ptr = document.createElement('div');
+
+      if (handler.mainElement !== document.body) {
+        handler.mainElement.parentNode.insertBefore(ptr, handler.mainElement);
+      } else {
+        document.body.insertBefore(ptr, document.body.firstChild);
+      }
+
+      ptr.classList.add(((handler.classPrefix) + "ptr"));
+      ptr.innerHTML = handler.getMarkup().replace(/__PREFIX__/g, handler.classPrefix);
+      handler.ptrElement = ptr;
+
+      if (typeof handler.onInit === 'function') {
+        handler.onInit(handler);
+      } // Add the css styles to the style node, and then
+      // insert it into the dom
+
+
+      if (!_shared.styleEl) {
+        _shared.styleEl = document.createElement('style');
+
+        _shared.styleEl.setAttribute('id', 'pull-to-refresh-js-style');
+
+        document.head.appendChild(_shared.styleEl);
+      }
+
+      _shared.styleEl.textContent = handler.getStyles().replace(/__PREFIX__/g, handler.classPrefix).replace(/\s+/g, ' ');
+    }
+
+    return handler;
+  }
+
+  function onReset(handler) {
+    if (!handler.ptrElement) { return; }
+    handler.ptrElement.classList.remove(((handler.classPrefix) + "refresh"));
+    handler.ptrElement.style[handler.cssProp] = '0px';
+    setTimeout(function () {
+      // remove previous ptr-element from DOM
+      if (handler.ptrElement && handler.ptrElement.parentNode) {
+        handler.ptrElement.parentNode.removeChild(handler.ptrElement);
+        handler.ptrElement = null;
+      } // reset state
+
+
+      _shared.state = 'pending';
+    }, handler.refreshTimeout);
+  }
+
+  function update(handler) {
+    var iconEl = handler.ptrElement.querySelector(("." + (handler.classPrefix) + "icon"));
+    var textEl = handler.ptrElement.querySelector(("." + (handler.classPrefix) + "text"));
+
+    if (iconEl) {
+      if (_shared.state === 'refreshing') {
+        iconEl.innerHTML = handler.iconRefreshing;
+      } else {
+        iconEl.innerHTML = handler.iconArrow;
+      }
+    }
+
+    if (textEl) {
+      if (_shared.state === 'releasing') {
+        textEl.innerHTML = handler.instructionsReleaseToRefresh;
+      }
+
+      if (_shared.state === 'pulling' || _shared.state === 'pending') {
+        textEl.innerHTML = handler.instructionsPullToRefresh;
+      }
+
+      if (_shared.state === 'refreshing') {
+        textEl.innerHTML = handler.instructionsRefreshing;
+      }
+    }
+  }
+
+  var _ptr = {
+    setupDOM: setupDOM,
+    onReset: onReset,
+    update: update
+  };
+
+  var _timeout;
+
+  var screenY = function screenY(event) {
+    if (_shared.pointerEventsEnabled && _shared.supportsPointerEvents) {
+      return event.screenY;
+    }
+
+    return event.touches[0].screenY;
+  };
+
+  var _setupEvents = (function () {
+    var _el;
+
+    function _onTouchStart(e) {
+      // here, we must pick a handler first, and then append their html/css on the DOM
+      var target = _shared.handlers.filter(function (h) { return h.contains(e.target); })[0];
+
+      _shared.enable = !!target;
+
+      if (target && _shared.state === 'pending') {
+        _el = _ptr.setupDOM(target);
+
+        if (target.shouldPullToRefresh()) {
+          _shared.pullStartY = screenY(e);
+        }
+
+        clearTimeout(_shared.timeout);
+
+        _ptr.update(target);
+      }
+    }
+
+    function _onTouchMove(e) {
+      if (!(_el && _el.ptrElement && _shared.enable)) {
+        return;
+      }
+
+      if (!_shared.pullStartY) {
+        if (_el.shouldPullToRefresh()) {
+          _shared.pullStartY = screenY(e);
+        }
+      } else {
+        _shared.pullMoveY = screenY(e);
+      }
+
+      if (_shared.state === 'refreshing') {
+        if (e.cancelable && _el.shouldPullToRefresh() && _shared.pullStartY < _shared.pullMoveY) {
+          e.preventDefault();
+        }
+
+        return;
+      }
+
+      if (_shared.state === 'pending') {
+        _el.ptrElement.classList.add(((_el.classPrefix) + "pull"));
+
+        _shared.state = 'pulling';
+
+        _ptr.update(_el);
+      }
+
+      if (_shared.pullStartY && _shared.pullMoveY) {
+        _shared.dist = _shared.pullMoveY - _shared.pullStartY;
+      }
+
+      _shared.distExtra = _shared.dist - _el.distIgnore;
+
+      if (_shared.distExtra > 0) {
+        if (e.cancelable) {
+          e.preventDefault();
+        }
+
+        _el.ptrElement.style[_el.cssProp] = (_shared.distResisted) + "px";
+        _shared.distResisted = _el.resistanceFunction(_shared.distExtra / _el.distThreshold) * Math.min(_el.distMax, _shared.distExtra);
+
+        if (_shared.state === 'pulling' && _shared.distResisted > _el.distThreshold) {
+          _el.ptrElement.classList.add(((_el.classPrefix) + "release"));
+
+          _shared.state = 'releasing';
+
+          _ptr.update(_el);
+        }
+
+        if (_shared.state === 'releasing' && _shared.distResisted < _el.distThreshold) {
+          _el.ptrElement.classList.remove(((_el.classPrefix) + "release"));
+
+          _shared.state = 'pulling';
+
+          _ptr.update(_el);
+        }
+      }
+    }
+
+    function _onTouchEnd() {
+      if (!(_el && _el.ptrElement && _shared.enable)) {
+        return;
+      } // wait 1/2 sec before unmounting...
+
+
+      clearTimeout(_timeout);
+      _timeout = setTimeout(function () {
+        if (_el && _el.ptrElement && _shared.state === 'pending') {
+          _ptr.onReset(_el);
+        }
+      }, 500);
+
+      if (_shared.state === 'releasing' && _shared.distResisted > _el.distThreshold) {
+        _shared.state = 'refreshing';
+        _el.ptrElement.style[_el.cssProp] = (_el.distReload) + "px";
+
+        _el.ptrElement.classList.add(((_el.classPrefix) + "refresh"));
+
+        _shared.timeout = setTimeout(function () {
+          var retval = _el.onRefresh(function () { return _ptr.onReset(_el); });
+
+          if (retval && typeof retval.then === 'function') {
+            retval.then(function () { return _ptr.onReset(_el); });
+          }
+
+          if (!retval && !_el.onRefresh.length) {
+            _ptr.onReset(_el);
+          }
+        }, _el.refreshTimeout);
+      } else {
+        if (_shared.state === 'refreshing') {
+          return;
+        }
+
+        _el.ptrElement.style[_el.cssProp] = '0px';
+        _shared.state = 'pending';
+      }
+
+      _ptr.update(_el);
+
+      _el.ptrElement.classList.remove(((_el.classPrefix) + "release"));
+
+      _el.ptrElement.classList.remove(((_el.classPrefix) + "pull"));
+
+      _shared.pullStartY = _shared.pullMoveY = null;
+      _shared.dist = _shared.distResisted = 0;
+    }
+
+    function _onScroll() {
+      if (_el) {
+        _el.mainElement.classList.toggle(((_el.classPrefix) + "top"), _el.shouldPullToRefresh());
+      }
+    }
+
+    var _passiveSettings = _shared.supportsPassive ? {
+      passive: _shared.passive || false
+    } : undefined;
+
+    if (_shared.pointerEventsEnabled && _shared.supportsPointerEvents) {
+      window.addEventListener('pointerup', _onTouchEnd);
+      window.addEventListener('pointerdown', _onTouchStart);
+      window.addEventListener('pointermove', _onTouchMove, _passiveSettings);
+    } else {
+      window.addEventListener('touchend', _onTouchEnd);
+      window.addEventListener('touchstart', _onTouchStart);
+      window.addEventListener('touchmove', _onTouchMove, _passiveSettings);
+    }
+
+    window.addEventListener('scroll', _onScroll);
+    return {
+      onTouchEnd: _onTouchEnd,
+      onTouchStart: _onTouchStart,
+      onTouchMove: _onTouchMove,
+      onScroll: _onScroll,
+
+      destroy: function destroy() {
+        if (_shared.pointerEventsEnabled && _shared.supportsPointerEvents) {
+          window.removeEventListener('pointerdown', _onTouchStart);
+          window.removeEventListener('pointerup', _onTouchEnd);
+          window.removeEventListener('pointermove', _onTouchMove, _passiveSettings);
+        } else {
+          window.removeEventListener('touchstart', _onTouchStart);
+          window.removeEventListener('touchend', _onTouchEnd);
+          window.removeEventListener('touchmove', _onTouchMove, _passiveSettings);
+        }
+
+        window.removeEventListener('scroll', _onScroll);
+      }
+
+    };
+  });
+
+  var _ptrMarkup = "\n<div class=\"__PREFIX__box\">\n  <div class=\"__PREFIX__content\">\n    <div class=\"__PREFIX__icon\"></div>\n    <div class=\"__PREFIX__text\"></div>\n  </div>\n</div>\n";
+
+  var _ptrStyles = "\n.__PREFIX__ptr {\n  box-shadow: inset 0 -3px 5px rgba(0, 0, 0, 0.12);\n  pointer-events: none;\n  font-size: 0.85em;\n  font-weight: bold;\n  top: 0;\n  height: 0;\n  transition: height 0.3s, min-height 0.3s;\n  text-align: center;\n  width: 100%;\n  overflow: hidden;\n  display: flex;\n  align-items: flex-end;\n  align-content: stretch;\n}\n\n.__PREFIX__box {\n  padding: 10px;\n  flex-basis: 100%;\n}\n\n.__PREFIX__pull {\n  transition: none;\n}\n\n.__PREFIX__text {\n  margin-top: .33em;\n  color: rgba(0, 0, 0, 0.3);\n}\n\n.__PREFIX__icon {\n  color: rgba(0, 0, 0, 0.3);\n  transition: transform .3s;\n}\n\n/*\nWhen at the top of the page, disable vertical overscroll so passive touch\nlisteners can take over.\n*/\n.__PREFIX__top {\n  touch-action: pan-x pan-down pinch-zoom;\n}\n\n.__PREFIX__release .__PREFIX__icon {\n  transform: rotate(180deg);\n}\n";
+
+  var _defaults = {
+    distThreshold: 60,
+    distMax: 80,
+    distReload: 50,
+    distIgnore: 0,
+    mainElement: 'body',
+    triggerElement: 'body',
+    ptrElement: '.ptr',
+    classPrefix: 'ptr--',
+    cssProp: 'min-height',
+    iconArrow: '&#8675;',
+    iconRefreshing: '&hellip;',
+    instructionsPullToRefresh: 'Pull down to refresh',
+    instructionsReleaseToRefresh: 'Release to refresh',
+    instructionsRefreshing: 'Refreshing',
+    refreshTimeout: 500,
+    getMarkup: function () { return _ptrMarkup; },
+    getStyles: function () { return _ptrStyles; },
+    onInit: function () {},
+    onRefresh: function () { return location.reload(); },
+    resistanceFunction: function (t) { return Math.min(1, t / 2.5); },
+    shouldPullToRefresh: function () { return !window.scrollY; }
+  };
+
+  var _methods = ['mainElement', 'ptrElement', 'triggerElement'];
+  var _setupHandler = (function (options) {
+    var _handler = {}; // merge options with defaults
+
+    Object.keys(_defaults).forEach(function (key) {
+      _handler[key] = options[key] || _defaults[key];
+    }); // normalize timeout value, even if it is zero
+
+    _handler.refreshTimeout = typeof options.refreshTimeout === 'number' ? options.refreshTimeout : _defaults.refreshTimeout; // normalize elements
+
+    _methods.forEach(function (method) {
+      if (typeof _handler[method] === 'string') {
+        _handler[method] = document.querySelector(_handler[method]);
+      }
+    }); // attach events lazily
+
+
+    if (!_shared.events) {
+      _shared.events = _setupEvents();
+    }
+
+    _handler.contains = function (target) {
+      return _handler.triggerElement.contains(target);
+    };
+
+    _handler.destroy = function () {
+      // stop pending any pending callbacks
+      clearTimeout(_shared.timeout); // remove handler from shared state
+
+      var offset = _shared.handlers.indexOf(_handler);
+
+      _shared.handlers.splice(offset, 1);
+    };
+
+    return _handler;
+  });
+
+  var index = {
+    setPassiveMode: function setPassiveMode(isPassive) {
+      _shared.passive = isPassive;
+    },
+
+    setPointerEventsMode: function setPointerEventsMode(isEnabled) {
+      _shared.pointerEventsEnabled = isEnabled;
+    },
+
+    destroyAll: function destroyAll() {
+      if (_shared.events) {
+        _shared.events.destroy();
+
+        _shared.events = null;
+      }
+
+      _shared.handlers.forEach(function (h) {
+        h.destroy();
+      });
+    },
+
+    init: function init(options) {
+      if ( options === void 0 ) options = {};
+
+      var handler = _setupHandler(options);
+
+      _shared.handlers.push(handler);
+
+      return handler;
+    },
+
+    // export utils for testing
+    _: {
+      setupHandler: _setupHandler,
+      setupEvents: _setupEvents,
+      setupDOM: _ptr.setupDOM,
+      onReset: _ptr.onReset,
+      update: _ptr.update
+    }
+  };
+
+  return index;
+
+})();
+
+export default PullToRefresh;
\ No newline at end of file

WebGde/WebContent/WebGde-Widgets/LoadingModal/LoadingModal.js

 export const createLoadingModal = (titleTxt, message, type, btnTxt, callBackFunc) => {
   let modal = document.getElementById("modal-container");
   if(modal){
-      removePrompt;
+      removeLoadingModal;
   }
 
   createPrompt();
@@ -104,7 +104,7 @@ export const createLoadingModal = (titleTxt, message, type, btnTxt, callBackFunc
   modal.style.display = 'block';
 }
 
-export const removePrompt = () => {
+export const removeLoadingModal = () => {
   let modal = document.getElementById("modal-container");
   modal.remove();
 }

WebGde/WebContent/WebGde-Widgets/LoadingModal/LoadingModalStyle.css

@@ -109,7 +109,7 @@ top: 4px;
 }
 
 .modal-body{
-  margin-top: 40px;
+  margin-top: 20px;
   display: flex;
   align-items: center;
   flex-wrap: wrap;

WebGde/WebContent/WebGde-Widgets/Submit/XMLWriter/XML_Saver.js

@@ -170,17 +170,26 @@ async function createNonBPOXML(fields, metrics, doctype, section, fieldOrder){
         "fieldOrder" : fieldOrder
     }
 
-    const authToken = sessionStorage.getItem('token');
-    let response = await fetch(urlWriteXml, {
-        method: "POST",
-        headers: {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${authToken}`
-        },
-        body: JSON.stringify(xmlData)
-    });
+    try {
+        let response = await fetch(urlWriteXml, {
+            method: "POST",
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${authToken}`
+            },
+            body: JSON.stringify(xmlData)
+        });
     
-    return response;
+        if (response.ok) {
+            return true;
+        } else {
+            return false;
+        }
+    } catch (error) {
+        // Handle connection errors or other issues
+        console.error('Error:', error);
+        return false;
+    }
 }
 
 async function createBPOXML(fields, metrics, doctype, section, fieldOrder){
@@ -213,17 +222,26 @@ async function createBPOXML(fields, metrics, doctype, section, fieldOrder){
     }
 
     const authToken = sessionStorage.getItem('token');
-    let response = await fetch(urlWriteXml, {
-        method: "POST",
-        headers: {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${authToken}`
-        },
-        body: JSON.stringify(xmlData)
-    });
-
-    return response;
-
+    try {
+        let response = await fetch(urlWriteXml, {
+            method: "POST",
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${authToken}`
+            },
+            body: JSON.stringify(xmlData)
+        });
+    
+        if (response.ok) {
+            return true;
+        } else {
+            return false;
+        }
+    } catch (error) {
+        // Handle connection errors or other issues
+        console.error('Error:', error);
+        return false;
+    }
     
 }
 

WebGde/WebContent/WebGde-Widgets/Submit/submit.js

-import { createLoadingScreen } from "../../script.js";
 import { getUrlCompleteToNextNode } from "../BPO/bpoService.js";
 import { saveForm } from "../DataInputWidget/generateFields.js";
 import { checkValidValues, validateInput } from "../DataInputWidget/validateInput.js";
 import { goBackToElementListViewer } from "../ElementListWidget/ElementListWidget.js";
 import { uploadFile } from "../FileUpload/fileUpload.js";
-import { createLoadingModal, removePrompt } from "../LoadingModal/LoadingModal.js";
+import { createLoadingModal, removeLoadingModal } from "../LoadingModal/LoadingModal.js";
 import { global_end_time, saveMetrics, stopMetricCapture, setGlobalEndTime, interval } from "../captureMetrics/captureMetrics.js";
 import { IS_RETRIEVE_FROM_BPO, SHOW_ELEMENT_LIST_VIEWER } from "../config.js";
 import { createConfirmationModal, createErrorModal, createInfoModal } from "../genericPopup/genericPopup.js";
@@ -141,7 +140,7 @@ export const submitForm = async (e) => {
 					console.log(getFile.text());
 					// await uploadTOGFS(getFile.text(), sessionStorage.getItem("recentlySavedFileName"));
 				} else {
-					createInfoModal(null, 'OK', 'Error while uploading');
+					createInfoModal(null, 'OK', 'Error while generating output.');
 					return false
 				}
 			}else {
@@ -161,6 +160,9 @@ export const submitForm = async (e) => {
 						},
 						body: JSON.stringify(filePath)
 					});
+				} else {
+					createInfoModal(null, 'OK', 'Error while generating output.');
+					return false
 				}
 			}
 			// saveForm(sessionStorage.getItem("display_counter"));
@@ -179,7 +181,7 @@ export async function createSubmitWindow(e){
 		createLoadingModal("Submitting Element", "Please wait...", null, null, null);
 		submitStatus = await submitForm(e);
 		if(submitStatus){
-			removePrompt();
+			removeLoadingModal();
 			DISPLAY_FIELD_OBJECT.clearForm();
 			if (SHOW_ELEMENT_LIST_VIEWER === "Y") {
 				console.log("PUMASOK DITO");
@@ -191,7 +193,7 @@ export async function createSubmitWindow(e){
 				let response = await completeToNextNode(sessionStorage.getItem("element_id"));
 			}
 		} else{
-			removePrompt();
+			removeLoadingModal();
 		}
     };
 

WebGde/WebContent/WebGde-Widgets/documentControlWidget/documentControlWidget.js

-import { createLoadingScreen, removeLoadingScreen } from '../../script.js';
 import { createRejectWindow } from '../BPO/rejectElement.js';
 import { createReturnWindow } from '../BPO/returnElement.js';
 import { goBackToElementListViewer } from '../ElementListWidget/ElementListWidget.js';

WebGde/WebContent/script.js

@@ -17,7 +17,6 @@ document.addEventListener("DOMContentLoaded", function() {
 startApplication();
 
 export async function startApplication() {
-	createLoadingScreen();
 	await initializeWebGDE();
 }
 
@@ -36,7 +35,6 @@ async function initializeWebGDE() {
 		if(mainLogInScreenContainer){
 			mainLogInScreenContainer.remove();
 		}
-		removeLoadingScreen();
 
 		new ElementListWidget(CURRENT_NODE, 'containerId');
 	} else {
@@ -48,7 +46,6 @@ async function initializeWebGDE() {
 		if(mainLogInScreenContainer){
 			mainLogInScreenContainer.remove();
 		}
-		removeLoadingScreen();
 	}
 }
 
@@ -88,48 +85,6 @@ async function createInputForm() {
 	//document.getElementById("input-field-container").appendChild(controls.getWidget());
 }
 
-export function createLoadingScreen() {
-	const centerContainer = document.createElement("center");
-
-	let modalContainer = document.getElementById("modal-container");
-	if (modalContainer) {
-		modalContainer.style.display = "block";
-	} else {
-		modalContainer = document.createElement("div");
-		modalContainer.setAttribute("class", "modal-container");
-		modalContainer.setAttribute("id", "modal-container");
-	}
-
-	let loaderContainer = document.getElementById("loaderContainer");
-	if (!loaderContainer) {
-		loaderContainer = document.createElement("div");
-		loaderContainer.setAttribute("id", "loaderContainer");
-		loaderContainer.setAttribute("class", "modal");
-	}
-
-	let loader1 = document.createElement("div");
-	loader1.setAttribute("class", "loader");
-	loader1.setAttribute("id", "loader");
-
-	loaderContainer.appendChild(loader1);
-
-	centerContainer.appendChild(loaderContainer);
-	modalContainer.appendChild(centerContainer);
-	document.body.appendChild(modalContainer);
-}
-
-export function removeLoadingScreen() {
-	let modalContainer = document.getElementById("modal-container");
-	if (modalContainer) {
-		modalContainer.style.display = "none";
-	}
-	let loaderContainer = document.getElementById("loaderContainer");
-	if (loaderContainer) {
-		loaderContainer.remove();
-	}
-
-}
-
 export async function resetGDE() {
 	// TO-DO
 }

WebGde/WebContent/startup.js

-import { createLoadingModal, removePrompt } from "./WebGde-Widgets/LoadingModal/LoadingModal.js";
+import { createLoadingModal, removeLoadingModal } from "./WebGde-Widgets/LoadingModal/LoadingModal.js";
 import { fallbackLogin, loginGde } from "./WebGde-Widgets/LogInWidget/LoginJavaInterface.js";
 
 const scriptElement = document.createElement("script");
@@ -9,7 +9,7 @@ document.addEventListener("DOMContentLoaded", function() {
 	window.createLoadingModal = createLoadingModal;
 	window.fallbackLogin = fallbackLogin;
     window.loginGde = loginGde;
-	window.removePrompt = removePrompt;
+	window.removeLoadingModal = removeLoadingModal;
 	// const LOG_IN_COMPONENT = new LogInClass(startApplication);
 	// LOG_IN_COMPONENT.establishEventListeners();
 });

WebGde/src/main/java/com/svi/webgde/restservice/filters/AuthorizedFilter.java

@@ -44,7 +44,8 @@ public class AuthorizedFilter implements ContainerRequestFilter {
 	@Override
 	public void filter(ContainerRequestContext requestContext) throws IOException {
 		System.out.println("Authorized annotation detected!");
-		if (!verifyCaller(requestContext)) {
+		if (false) { // IMPORTANT! PLEASE COMMENT OUT BEFORE COMMIT.
+//		if (!verifyCaller(requestContext)) {
 			try {
 				redirect(requestContext);
 			} catch (URISyntaxException e) {

WebGde/src/main/java/com/svi/webgde/restservice/services/GDEWebServices.java

@@ -239,13 +239,15 @@ public class GDEWebServices {
 				}
 	        }
 			
-			File file = new File(filePath);
-			if (!file.exists()) {
-				System.out.println("creating output directory");
-				response = XMLUtil.generateXML(xml);
-			} else {
-				response = XMLUtil.udpateXML(xml);
-			}
+	        System.out.println("creating output directory");
+			response = XMLUtil.generateXML(xml);
+//			File file = new File(filePath);
+//			if (!file.exists()) {
+//				System.out.println("creating output directory");
+//				response = XMLUtil.generateXML(xml);
+//			} else {
+//				response = XMLUtil.udpateXML(xml);
+//			}
 		} catch (Exception e) {
 			e.printStackTrace();
 			return Response.status(500).entity("Fail").build();

WebGde/src/main/java/com/svi/webgde/restservice/utils/XMLUtil.java

 package com.svi.webgde.restservice.utils;
 
+import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.OutputStream;
 import java.io.StringReader;
 import java.nio.file.Files;
 import java.nio.file.Paths;
@@ -109,9 +111,18 @@ public class XMLUtil {
 		transformer.setOutputProperty(OutputKeys.STANDALONE, "no");
 		transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
 
-		Result result = new StreamResult(xml.getOutputDir());
-		transformer.transform(source, result);
+		try (OutputStream outputStream = new FileOutputStream(xml.getOutputDir())) {
+		    // Set the output stream for the StreamResult
+		    Result result = new StreamResult(outputStream);
+		    
+		    // Perform the transformation
+		    transformer.transform(source, result);
+		} catch (IOException e) {
+		    // Handle IOException
+		    e.printStackTrace();
+		}
 
+		// Return the content of the generated file
 		return new String(Files.readAllBytes(Paths.get(xml.getOutputDir())));
 	}