Create UploadInterceptor orchestrator and plugin structure

  - Add UploadInterceptor.js orchestrator for managing upload system patches
  - Implement plugin registration system with hook-based architecture
  - Create plugin folder structure for ChecksumValidation and UploadVolumeChecker
  - Add PluginInterface.js documentation for plugin developers
  - Integrate UploadInterceptor system into main index.js
  - Support hooks: beforeUpload, onStatusChange, onUploadComplete, onUploadError

Author: Sunday-Crunk

src/js/core/UploadInterceptor/PluginInterface.js

@@ -0,0 +1,57 @@
+/**
+ * Plugin Interface Documentation
+ *
+ * This file documents the expected structure for UploadInterceptor plugins.
+ * Plugins should export an object with the following structure:
+ */
+
+/**
+ * Example plugin structure:
+ *
+ * export default {
+ *   name: 'ExamplePlugin',
+ *
+ *   hooks: {
+ *     // Called before upload starts
+ *     beforeUpload: (uploadItem) => {
+ *       console.log('Upload starting for:', uploadItem._label);
+ *     },
+ *
+ *     // Called when upload status changes
+ *     onStatusChange: (uploadItem, status) => {
+ *       console.log('Upload status changed to:', status);
+ *     },
+ *
+ *     // Called when upload completes successfully
+ *     onUploadComplete: (uploadItem) => {
+ *       console.log('Upload completed for:', uploadItem._label);
+ *     },
+ *
+ *     // Called when upload encounters an error
+ *     onUploadError: (uploadItem) => {
+ *       console.error('Upload failed for:', uploadItem._label);
+ *     }
+ *   }
+ * };
+ */
+
+/**
+ * Available uploadItem properties (from UploaderModel.UploadItem):
+ * - _file: The File object being uploaded
+ * - _label: Display name of the file
+ * - _targetNode: Destination node information
+ * - _observers: Observer system for status changes
+ * - Plus other Pydio-specific properties
+ */
+
+/**
+ * Hook execution order:
+ * 1. beforeUpload - Called immediately when upload starts
+ * 2. onStatusChange - Called for each status change during upload
+ * 3. onUploadComplete OR onUploadError - Called when upload finishes
+ */
+
+export default {
+  // This file is for documentation only
+  // Actual plugins should be in the plugins/ directory
+};

src/js/core/UploadInterceptor/UploadInterceptor.js

@@ -0,0 +1,204 @@
+/**
+ * UploadInterceptor - Orchestrates upload interception and plugin system
+ *
+ * This class manages the monkey patching of Pydio's upload system and
+ * provides a plugin architecture for extending upload functionality.
+ */
+class UploadInterceptor {
+  constructor() {
+    this.plugins = new Map();
+    this.isPatched = false;
+    this.originalUploadPresigned = null;
+  }
+
+  /**
+   * Register a plugin with the upload interceptor
+   * @param {Object} plugin - Plugin object with name and hooks
+   * @param {string} plugin.name - Unique plugin name
+   * @param {Object} plugin.hooks - Event hooks object
+   * @param {Function} [plugin.hooks.beforeUpload] - Called before upload starts
+   * @param {Function} [plugin.hooks.onUploadComplete] - Called when upload completes
+   * @param {Function} [plugin.hooks.onUploadError] - Called when upload errors
+   * @param {Function} [plugin.hooks.onStatusChange] - Called when upload status changes
+   */
+  register(plugin) {
+    if (!plugin.name) {
+      throw new Error('Plugin must have a name');
+    }
+
+    if (this.plugins.has(plugin.name)) {
+      console.warn(`Plugin '${plugin.name}' is already registered. Overwriting.`);
+    }
+
+    this.plugins.set(plugin.name, plugin);
+    console.log(`UploadInterceptor: Registered plugin '${plugin.name}'`);
+
+    // If we haven't patched yet, patch now that we have plugins
+    if (!this.isPatched) {
+      this.patchUploadSystem();
+    }
+  }
+
+  /**
+   * Unregister a plugin
+   * @param {string} pluginName - Name of plugin to remove
+   */
+  unregister(pluginName) {
+    if (this.plugins.delete(pluginName)) {
+      console.log(`UploadInterceptor: Unregistered plugin '${pluginName}'`);
+    }
+  }
+
+  /**
+   * Get list of registered plugin names
+   * @returns {string[]} Array of plugin names
+   */
+  getRegisteredPlugins() {
+    return Array.from(this.plugins.keys());
+  }
+
+  /**
+   * Monkey patch the Pydio upload system
+   */
+  patchUploadSystem() {
+    if (this.isPatched) {
+      console.warn('UploadInterceptor: Upload system already patched');
+      return;
+    }
+
+    // Wait for UploaderModel to be available
+    this.waitForUploaderModel().then(() => {
+      this.applyUploadPatch();
+    });
+  }
+
+  /**
+   * Wait for UploaderModel to be defined in the global scope
+   * @returns {Promise<void>}
+   */
+  async waitForUploaderModel() {
+    while (typeof UploaderModel === "undefined" || !UploaderModel.UploadItem) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+
+  /**
+   * Apply the actual upload system patch
+   */
+  applyUploadPatch() {
+    // Store the original uploadPresigned function
+    this.originalUploadPresigned = UploaderModel.UploadItem.prototype.uploadPresigned;
+
+    // Override the uploadPresigned method
+    UploaderModel.UploadItem.prototype.uploadPresigned = this.createPatchedUploadMethod();
+
+    this.isPatched = true;
+    console.log('UploadInterceptor: Successfully patched upload system');
+  }
+
+  /**
+   * Create the patched upload method
+   * @returns {Function} Patched upload method
+   */
+  createPatchedUploadMethod() {
+    const self = this;
+
+    return function() {
+      // 'this' refers to the UploaderModel.UploadItem instance
+      const uploadItem = this;
+
+      // Execute the original upload logic first
+      const originalPromise = self.originalUploadPresigned.apply(uploadItem, arguments);
+
+      // Call beforeUpload hooks
+      self.callPluginHooks('beforeUpload', uploadItem);
+
+      // Create observer to watch for upload status changes
+      const observer = (status) => {
+        // Call onStatusChange hooks
+        self.callPluginHooks('onStatusChange', uploadItem, status);
+
+        // Handle upload completion
+        if (status === "loaded") {
+          // Remove observer to prevent multiple calls
+          self.removeObserver(uploadItem, observer);
+
+          // Call onUploadComplete hooks
+          self.callPluginHooks('onUploadComplete', uploadItem);
+        } else if (status === "error") {
+          // Remove observer
+          self.removeObserver(uploadItem, observer);
+
+          // Call onUploadError hooks
+          self.callPluginHooks('onUploadError', uploadItem);
+        }
+      };
+
+      // Add observer to the upload item
+      self.addObserver(uploadItem, observer);
+
+      return originalPromise;
+    };
+  }
+
+  /**
+   * Call a specific hook on all registered plugins
+   * @param {string} hookName - Name of hook to call
+   * @param {...any} args - Arguments to pass to hook
+   */
+  callPluginHooks(hookName, ...args) {
+    for (const [pluginName, plugin] of this.plugins) {
+      try {
+        if (plugin.hooks && typeof plugin.hooks[hookName] === 'function') {
+          plugin.hooks[hookName](...args);
+        }
+      } catch (error) {
+        console.error(`UploadInterceptor: Error in plugin '${pluginName}' hook '${hookName}':`, error);
+      }
+    }
+  }
+
+  /**
+   * Add observer to upload item
+   * @param {Object} uploadItem - Upload item instance
+   * @param {Function} observer - Observer function
+   */
+  addObserver(uploadItem, observer) {
+    if (!uploadItem._observers) uploadItem._observers = {};
+    if (!uploadItem._observers.status) uploadItem._observers.status = [];
+
+    if (!uploadItem._observers.status.includes(observer)) {
+      uploadItem._observers.status.push(observer);
+    }
+  }
+
+  /**
+   * Remove observer from upload item
+   * @param {Object} uploadItem - Upload item instance
+   * @param {Function} observer - Observer function to remove
+   */
+  removeObserver(uploadItem, observer) {
+    if (uploadItem._observers && uploadItem._observers.status) {
+      const index = uploadItem._observers.status.indexOf(observer);
+      if (index > -1) {
+        uploadItem._observers.status.splice(index, 1);
+      }
+    }
+  }
+
+  /**
+   * Restore the original upload system (for testing/cleanup)
+   */
+  unpatch() {
+    if (this.isPatched && this.originalUploadPresigned) {
+      UploaderModel.UploadItem.prototype.uploadPresigned = this.originalUploadPresigned;
+      this.isPatched = false;
+      console.log('UploadInterceptor: Unpatched upload system');
+    }
+  }
+}
+
+// Create singleton instance
+const uploadInterceptor = new UploadInterceptor();
+
+export default uploadInterceptor;

src/js/core/UploadInterceptor/index.js

@@ -0,0 +1,23 @@
+/**
+ * UploadInterceptor System Initialization
+ *
+ * This file initializes the upload interceptor system and registers plugins.
+ * Import this file to activate the upload interception system.
+ */
+
+import UploadInterceptor from './UploadInterceptor.js';
+import UploadVolumeChecker from './plugins/UploadVolumeChecker/UploadVolumeChecker.js';
+
+// Initialize the upload interceptor system when DOM loads
+window.addEventListener("load", () => {
+  console.log('UploadInterceptor: Initializing upload interception system');
+
+  // Register plugins
+  UploadInterceptor.register(UploadVolumeChecker);
+
+  // Note: ChecksumValidation plugin will be registered here after refactoring
+
+  console.log('UploadInterceptor: System initialized with plugins:', UploadInterceptor.getRegisteredPlugins());
+});
+
+export default UploadInterceptor;

src/js/core/UploadInterceptor/plugins/UploadVolumeChecker/UploadVolumeChecker.js

@@ -0,0 +1,49 @@
+/**
+ * UploadVolumeChecker Plugin
+ *
+ * Monitors and restricts upload volume based on configurable thresholds.
+ * Provides warnings and blocks uploads that exceed specified limits.
+ */
+
+// TODO: Implement volume checking logic
+// This is a placeholder for the actual implementation
+
+export default {
+  name: 'UploadVolumeChecker',
+
+  // Configuration (can be made configurable later)
+  config: {
+    maxFileCount: 1000,        // Maximum number of files in a single upload
+    warningFileCount: 500,     // Show warning at this threshold
+    maxTotalSize: 10 * 1024 * 1024 * 1024, // 10GB max total size
+    warningTotalSize: 5 * 1024 * 1024 * 1024,  // 5GB warning threshold
+  },
+
+  hooks: {
+    beforeUpload: (uploadItem) => {
+      console.log('UploadVolumeChecker: Checking upload volume for:', uploadItem._label);
+
+      // TODO: Implement volume checking logic
+      // - Count files in current upload
+      // - Calculate total size
+      // - Check against thresholds
+      // - Show warnings or block upload
+    },
+
+    onUploadComplete: (uploadItem) => {
+      console.log('UploadVolumeChecker: Upload completed for:', uploadItem._label);
+
+      // TODO: Implement post-upload cleanup
+      // - Reset counters
+      // - Log upload statistics
+    },
+
+    onUploadError: (uploadItem) => {
+      console.log('UploadVolumeChecker: Upload failed for:', uploadItem._label);
+
+      // TODO: Implement error handling
+      // - Reset counters
+      // - Log error statistics
+    }
+  }
+};

src/js/index.js

@@ -6,6 +6,7 @@ import "../js/core/OAIHarvestClient.js";
 import "../js/core/publicAccessModifier.js";
 import "../js/core/tourModifier.js";
 import "../js/core/ChecksumValidation.js";
+import "../js/core/UploadInterceptor/index.js";
 import "../js/core/PassOaiToChildren.js";
 import "../js/core/consoleModifier.js";
 import "../js/core/messageModifier.js";