qooxview 1.9.9

data/lib/qooxview/frontend/UploadMgr/server/php.php

@@ -0,0 +1,116 @@
+<?php
+
+/* ***********************************************************************
+
+   QxUploadMgr - provides an API for uploading one or multiple files
+   with progress feedback (on modern browsers), does not block the user 
+   interface during uploads, supports cancelling uploads.
+
+   http://qooxdoo.org
+
+   Copyright:
+     2011 Zenesis Limited, http://www.zenesis.com
+
+   License:
+     LGPL: http://www.gnu.org/licenses/lgpl.html
+     EPL: http://www.eclipse.org/org/documents/epl-v10.php
+     
+     This software is provided under the same licensing terms as Qooxdoo,
+     please see the LICENSE file in the Qooxdoo project's top-level directory 
+     for details.
+
+     Parts of this code is based on the work by Andrew Valums (andrew@valums.com)
+     and is covered by the GNU GPL and GNU LGPL2 licenses; please see
+     http://valums.com/ajax-upload/.
+
+   Authors:
+     * John Spackman (john.spackman@zenesis.com)
+
+************************************************************************/
+
+class QxUploadMgr {
+
+	/**
+	 * Handles the upload
+	 * @param $uploadDirectory {String} the path to upload to
+	 * @param $replaceOldFile {Boolean} whether to replace existing files
+	 */
+	public static function handleUpload($uploadDirectory, $replaceOldFile = FALSE) {
+        if (!is_writable($uploadDirectory))
+            throw new Exception("Server error. Upload directory isn't writable.");
+            
+        /*if ($_SERVER['CONTENT_TYPE'] == "application/octet-stream")
+            return QxUploadMgr::handleApplicationOctet($uploadDirectory, $replaceOldFile);
+        else*/
+            return QxUploadMgr::handleMultipartFormData($uploadDirectory, $replaceOldFile);
+	}
+	
+	/**
+	 * Determins the filename for the upload
+	 * @param $uploadDirectory {String} the path to upload to
+	 * @param $originalName {String} the filename as given by the browser
+	 * @param $replaceOldFile {Boolean} whether to replace existing files
+	 */
+	public static function getFilename($uploadDirectory, $originalName, $replaceOldFile) {
+        $pathinfo = pathinfo($originalName);
+        $filename = $uploadDirectory . '/' . $pathinfo['filename'] . '.' . $pathinfo['extension'];
+
+        if (!$replaceOldFile){
+        	$index = 1;
+            while (file_exists($filename)) {
+		        $filename = $uploadDirectory . '/' . $pathinfo['filename'] . '-' . $index . '.' . $pathinfo['extension'];
+		        $index++;
+            }
+        }
+        return $filename;
+	}
+	
+	/**
+	 * Handles the upload where content type is "application/octet-stream"
+	 * @param $uploadDirectory {String} the path to upload to
+	 * @param $replaceOldFile {Boolean} whether to replace existing files
+	 */
+	public static function handleApplicationOctet($uploadDirectory, $replaceOldFile) {
+		$filename = QxUploadMgr::getFilename($uploadDirectory, $_SERVER['HTTP_X_FILE_NAME'], $replaceOldFile);
+        error_log("Receiving application/octet-stream into $filename");
+        
+        $input = fopen("php://input", "r");
+        $target = fopen($filename, "w");        
+        $realSize = stream_copy_to_stream($input, $target);
+        fclose($input);
+        fclose($target);
+        
+        if (isset($_SERVER["CONTENT_LENGTH"])) {
+            $expectedSize = (int)$_SERVER["CONTENT_LENGTH"];
+            if ($realSize != $expectedSize)
+            	return array('error' => 'File is the wrong size');
+        }
+        
+        return array('success'=>true);
+    }
+	
+	/**
+	 * Handles the upload where content type is "multipart/form-data"
+	 * @param $uploadDirectory {String} the path to upload to
+	 * @param $replaceOldFile {Boolean} whether to replace existing files
+	 */
+    public static function handleMultipartFormdata($uploadDirectory, $replaceOldFile) {
+    error_log("hello, count()=" . $_FILES.count());
+    	foreach ($_FILES as $file) {
+    		error_log("$file=" . $file);
+    		$filename = QxUploadMgr::getFilename($uploadDirectory, $file['name'], $replaceOldFile);
+	        error_log("Receiving multipart/formdata into $filename");
+    		if (!move_uploaded_file($file['tmp_name'], $filename)) {
+    			error_log("Failed to move uploaded file from ". $file['tmp_name']. " to $filename");
+    			return array('error' => 'Failed to move uploaded file');
+    		}
+    	}
+        
+        return array('success'=>true);
+    }
+}
+
+$result = QxUploadMgr::handleUpload('uploads');
+
+// to pass data through iframe you will need to encode all html tags
+echo htmlspecialchars(json_encode($result), ENT_NOQUOTES);

data/lib/qooxview/frontend/UploadMgr/source/class/com/zenesis/qx/upload/AbstractHandler.js

@@ -0,0 +1,278 @@
+/* ***********************************************************************
+
+   UploadMgr - provides an API for uploading one or multiple files
+   with progress feedback (on modern browsers), does not block the user 
+   interface during uploads, supports cancelling uploads.
+
+   http://qooxdoo.org
+
+   Copyright:
+     2011 Zenesis Limited, http://www.zenesis.com
+
+   License:
+     LGPL: http://www.gnu.org/licenses/lgpl.html
+     EPL: http://www.eclipse.org/org/documents/epl-v10.php
+     
+     This software is provided under the same licensing terms as Qooxdoo,
+     please see the LICENSE file in the Qooxdoo project's top-level directory 
+     for details.
+
+   Authors:
+     * John Spackman (john.spackman@zenesis.com)
+
+************************************************************************/
+
+/**
+ * Base class for upload implementations; operates a queue of pending and
+ * current uploads, and restricts the number of simultaneous uploads.
+ */
+qx.Class.define("com.zenesis.qx.upload.AbstractHandler", {
+	extend: qx.core.Object,
+	
+	/**
+	 * Constructor
+	 * @param uploader {com.zenesis.qx.upload.UploadMgr} controller for uploading
+	 */
+	construct: function(uploader) {
+		this.base(arguments);
+		qx.core.Assert.assertNotNull(uploader);
+		this.__queue = [];
+		this.__current = [];
+		this.__params = {};
+		this.__uploader = uploader;
+	},
+	
+	properties: {
+		/**
+		 * Maximum number of simultaneous uploads
+		 */
+		maxConnections: {
+			check: "Integer",
+			init: 5,
+			nullable: false,
+			event: "changeMaxConnections"
+		}
+	},
+	
+	members: {
+		// Last unique ID used
+		__lastId: 0,
+		
+		// Uploader instance
+		__uploader: null,
+		
+		// Queue of com.zenesis.qx.upload.File's to send
+		__queue: null,
+		
+		// List of com.zenesis.qx.upload.File's currently being sent
+		__current: null,
+		
+		// Parameters to post with the file
+		__params: null,
+		
+		/**
+		 * Adds a file to the upload queue; this does not start uploading until
+		 * beginUploads is called.
+		 * @param input {DOM} either one input[type=file] or an array of input[type=file]
+		 * @param widget {Widget} the widget that trigger the upload
+		 */
+		addFile: function(input, widget) {
+			var files = this._createFile(input);
+			if (!qx.lang.Type.isArray(files)) {
+				files.setUploadWidget(widget);
+				this._addFile(files);
+			} else
+				for (var i = 0; i < files.length; i++) {
+					files[i].setUploadWidget(widget);
+					this._addFile(files[i]);
+				}
+		},
+		
+		/**
+		 * Adds a file to the outbound queue
+		 * @param file {com.zenesis.qx.upload.File} the file to add
+		 */
+		_addFile: function(file) {
+			this.__queue.push(file);
+			this.__uploader.fireDataEvent("addFile", file);
+		},
+		
+		/**
+		 * Begins spooling uploads to the server, up to the maxConnections 
+		 */
+		beginUploads: function() {
+			while (this.__queue.length > 0 && this.__current.length < this.getMaxConnections()) {
+				var file = this.__queue.shift();
+				this.__current.push(file);
+				this.__uploader.fireDataEvent("beginUpload", file);
+				file.setState("uploading");
+				this._doUpload(file);
+			}
+		},
+		
+		/**
+		 * Cancels a file
+		 * @param file {com.zenesis.qx.upload.File} the file to cancel
+		 */
+		cancel: function(file) {
+			var wasUploading = this.__current.length > 0;
+			//this.debug("cancelled: id=" + file.getId() + ", fileName=" + file.getFilename());
+			this._cancel(file);
+			if (wasUploading && this.__uploader.getAutoUpload())
+				this.beginUploads();
+		},
+		
+		/**
+		 * Cancels all uploads
+		 */
+		cancelAll: function() {
+			for (var current = this.__current, i = 0; i < current.length; i++)
+				this._cancel(current[i]);
+			this.__current.splice(0, this.__current.length);
+			this.__queue.splice(0, this.__queue.length);
+		},
+		
+		/**
+		 * Cancels a file
+		 * @param file {com.zenesis.qx.upload.File} the file to cancel
+		 */
+		_cancel: function(file) {
+			var inCurrent = false;
+			for (var current = this.__current, i = 0; i < current.length; i++)
+				if (current[i] == file) {
+					current.splice(i, 1);
+					inCurrent = true;
+					break;
+				}
+			for (var queue = this.__queue, i = 0; i < queue.length; i++)
+				if (queue[i] == file) {
+					queue.splice(i, 1);
+					break;
+				}
+			file.setState("cancelled");
+			if (inCurrent)
+				this._doCancel(file);
+			this.__uploader.fireDataEvent("cancelUpload", file);
+		},
+		
+		/**
+		 * Called by derived classes when a file has completed
+		 * @param file {com.zenesis.qx.upload.File} the file which has finsihed uploading
+		 * @param response {String} text received
+		 */
+		_onCompleted: function(file, response) {
+			//this.debug("completed: id=" + file.getId() + ", fileName=" + file.getFilename() + ", response=" + response);
+			var current = this.__current;
+			for (var i = 0; i < current.length; i++)
+				if (current[i] == file) {
+					current.splice(i, 1);
+					break;
+				}
+			
+			file.setResponse(response);
+			
+			// File state should be uploading or cancelled
+			if (file.getState() == "uploading") {
+				file.setState("uploaded");
+				this.__uploader.fireDataEvent("completeUpload", file);
+			}
+			
+			// Start the next one
+			this.beginUploads();
+		},
+		
+		/**
+		 * Returns the uploader
+		 * @returns {com.zenesis.qx.upload.UploadMgr}
+		 */
+		_getUploader: function() {
+			return this.__uploader;
+		},
+		
+		/**
+		 * Allocates a unique ID
+		 * @returns {Number}
+		 */
+		_getUniqueFileId: function() {
+			return ++this.__lastId;
+		},
+		
+		/**
+		 * Adds a parameter to send to the client
+		 * @param key {String} the name of the parameter
+		 * @param value {String} the value of the parameter
+		 * @deprecated see com.zenesis.qx.upload.UploadMgr.setParam or com.zenesis.qx.upload.File.setParam
+		 */
+		addParam: function(key, value) {
+			qx.log.Logger.deprecatedMethodWarning(arguments.callee, "see com.zenesis.qx.upload.UploadMgr.setParam or com.zenesis.qx.upload.File.setParam");
+			this.__params[key] = value;
+		},
+		
+		/**
+		 * Returns the paramaters map
+		 * @returns {Map}
+		 * @deprecated see com.zenesis.qx.upload.File.getParam
+		 */
+		getParams: function() {
+			qx.log.Logger.deprecatedMethodWarning(arguments.callee, "see com.zenesis.qx.upload.UploadMgr.getParam or com.zenesis.qx.upload.File.getParam");
+			return this.__params;
+		},
+		
+		/**
+		 * Helper method that produces a final list of parameter values, by merging those
+		 * set in this with those in the file.
+		 * @param file {File} the file object
+		 * @returns {Map} map of parameters to sent to the server
+		 */
+		_getMergedParams: function(file) {
+			var result = {};
+			for (var name in this.__params) {
+				var value = this.__params[name];
+				if (value !== null)
+					result[name] = value;
+			}
+			function merge(obj) {
+				var names = obj.getParamNames();
+				for (var i = 0; i < names.length; i++) {
+					var name = names[i],
+						value = obj.getParam(name);
+					if (value !== null)
+						result[name] = value;
+					else
+						delete result[name];
+				}
+			}
+			merge(this.__uploader);
+			if (typeof file.getParamNames == "function")
+				merge(file.getUploadWidget());
+			merge(file);
+			return result;
+		},
+		
+		/**
+		 * Implementation must create a com.zenesis.qx.upload.File or array of com.zenesis.qx.upload.File 
+		 * @param input {DOM} the DOM input[type=file]
+		 * @return {com.zenesis.qx.upload.File|com.zenesis.qx.upload.File[]}
+		 */
+		_createFile: function(input) {
+			/* abstract */
+		},
+		
+		/**
+		 * Called to do the real work of uploading the file
+		 * @param file {com.zenesis.qx.upload.File}
+		 */
+		_doUpload: function(file) {
+			/* abstract */
+		},
+		
+		/**
+		 * Called to cancel the upload
+		 * @param file {com.zenesis.qx.upload.File} file to cancel uploading
+		 */
+		_doCancel: function(file) {
+			/* abstract */
+		}
+		
+	}
+});

data/lib/qooxview/frontend/UploadMgr/source/class/com/zenesis/qx/upload/File.js

@@ -0,0 +1,178 @@
+/* ***********************************************************************
+
+   UploadMgr - provides an API for uploading one or multiple files
+   with progress feedback (on modern browsers), does not block the user 
+   interface during uploads, supports cancelling uploads.
+
+   http://qooxdoo.org
+
+   Copyright:
+     2011 Zenesis Limited, http://www.zenesis.com
+
+   License:
+     LGPL: http://www.gnu.org/licenses/lgpl.html
+     EPL: http://www.eclipse.org/org/documents/epl-v10.php
+     
+     This software is provided under the same licensing terms as Qooxdoo,
+     please see the LICENSE file in the Qooxdoo project's top-level directory 
+     for details.
+
+   Authors:
+     * John Spackman (john.spackman@zenesis.com)
+
+************************************************************************/
+
+/**
+ * Represents a file that is to be or has been uploaded; this should be instantiated
+ * by the _createFile method of AbstractHandler implementations and is not expected 
+ * to be used separately
+ */
+qx.Class.define("com.zenesis.qx.upload.File", {
+	extend: qx.core.Object,
+	
+	/**
+	 * Constructor
+	 * @param browserObject {DOM} Anythign the AbstractHandler wants to store, typically an input[type=file] or a File
+	 * @param filename {String} the name of the file
+	 * @param id {String} the unique id of the file
+	 */
+	construct: function(browserObject, filename, id) {
+		this.base(arguments);
+		qx.core.Assert.assertNotNull(browserObject);
+		qx.core.Assert.assertNotNull(filename);
+		qx.core.Assert.assertNotNull(id);
+		this.__browserObject = browserObject;
+		this.setFilename(filename);
+		this.setId(id);
+	},
+	
+	properties: {
+		/**
+		 * The filename
+		 */
+		filename: {
+			check: "String",
+			nullable: false,
+			event: "changeFilename"
+		},
+		
+		/**
+		 * A unique ID for the upload 
+		 */
+		id: {
+			check: "String",
+			nullable: false,
+			event: "changeId"
+		},
+		
+		/**
+		 * Size of the file, if known (not available on older browsers)
+		 */
+		size: {
+			check: "Integer",
+			nullable: false,
+			init: -1,
+			event: "changeSize"
+		},
+		
+		/**
+		 * Progress of the upload, if known (not available on older browsers)
+		 */
+		progress: {
+			check: "Integer",
+			nullable: false,
+			init: 0,
+			event: "changeProgress"
+		},
+		
+		/**
+		 * State of the file, re: uploading
+		 */
+		state: {
+			check: [ "not-started", "uploading", "cancelled", "uploaded" ],
+			nullable: false,
+			init: "not-started",
+			event: "changeState",
+			apply: "_applyState"
+		},
+		
+		/**
+		 * The response string received from the server
+		 */
+		response: {
+			init: null,
+			nullable: true,
+			check: "String",
+			event: "changeResponse"
+		},
+		
+		/**
+		 * The widget that triggered the upload
+		 */
+		uploadWidget: {
+			init: null,
+			nullable: true,
+			event: "changeUploadWidget"
+		}
+	},
+	
+	members: {
+		__browserObject: null,
+		__params: null,
+		
+		/**
+		 * Sets a parameter value to be sent with the file
+		 * @param name {String} name of the parameter
+		 * @param value {String} the value of the parameter, or null to delete a previous parameter
+		 */
+		setParam: function(name, value) {
+			if (value !== null && typeof value != "string")
+				value ="" + value;
+			if (!this.__params)
+				this.__params = {};
+			this.__params[name] = value;
+		},
+		
+		/**
+		 * Returns a parameter value to be sent with the file
+		 * @param name
+		 * @returns {Boolean}
+		 */
+		getParam: function(name) {
+			return this.__params && this.__params[name];
+		},
+		
+		/**
+		 * Returns a list of parameter names
+		 * @returns {Array}
+		 */
+		getParamNames: function() {
+			var result = [];
+			if (this.__params)
+				for (var name in this.__params)
+					result.push(name);
+			return result;
+		},
+		
+		/**
+		 * Returns the browser object
+		 * @returns {DOM}
+		 */
+		getBrowserObject: function() {
+			return this.__browserObject;
+		},
+		
+		/**
+		 * Called for changes to the state
+		 * @param value
+		 * @param oldValue
+		 */
+		_applyState: function(value, oldValue) {
+			qx.core.Assert.assertTrue(
+					(!oldValue && value == "not-started") ||
+					(oldValue == "not-started" && (value == "cancelled" || value == "uploading")) ||
+					(oldValue == "uploading" && (value == "cancelled" || value == "uploaded"))
+					);
+		}
+	}
+});