fine_uploader 3.1.1 → 3.4.1

data/vendor/assets/javascripts/fine_uploader/handler.base.js

@@ -1,115 +1,187 @@
 /**
  * Class for uploading files, uploading itself is handled by child classes
  */
-qq.UploadHandlerAbstract = function(o){
+/*globals qq*/
+qq.UploadHandler = function(o) {
+    "use strict";
+
+    var queue = [],
+        options, log, dequeue, handlerImpl;
+
     // Default options, can be overridden by the user
-    this._options = {
+    options = {
         debug: false,
-        endpoint: '/upload.php',
+        forceMultipart: true,
         paramsInBody: false,
-        // maximum number of concurrent uploads
-        maxConnections: 999,
+        paramsStore: {},
+        endpointStore: {},
+        cors: {
+            expected: false,
+            sendCredentials: false
+        },
+        maxConnections: 3, // maximum number of concurrent uploads
+        uuidParamName: 'qquuid',
+        totalFileSizeParamName: 'qqtotalfilesize',
+        chunking: {
+            enabled: false,
+            partSize: 2000000, //bytes
+            paramNames: {
+                partIndex: 'qqpartindex',
+                partByteOffset: 'qqpartbyteoffset',
+                chunkSize: 'qqchunksize',
+                totalParts: 'qqtotalparts',
+                filename: 'qqfilename'
+            }
+        },
+        resume: {
+            enabled: false,
+            id: null,
+            cookiesExpireIn: 7, //days
+            paramNames: {
+                resuming: "qqresume"
+            }
+        },
+        blobs: {
+            paramNames: {
+                name: 'qqblobname'
+            }
+        },
         log: function(str, level) {},
         onProgress: function(id, fileName, loaded, total){},
         onComplete: function(id, fileName, response, xhr){},
         onCancel: function(id, fileName){},
-        onUpload: function(id, fileName, xhr){},
-        onAutoRetry: function(id, fileName, response, xhr){}
+        onUpload: function(id, fileName){},
+        onUploadChunk: function(id, fileName, chunkData){},
+        onAutoRetry: function(id, fileName, response, xhr){},
+        onResume: function(id, fileName, chunkData){}
 
     };
-    qq.extend(this._options, o);
+    qq.extend(options, o);
 
-    this._queue = [];
+    log = options.log;
 
-    this.log = this._options.log;
-};
-qq.UploadHandlerAbstract.prototype = {
     /**
-     * Adds file or file input to the queue
-     * @returns id
-     **/
-    add: function(file){},
-    /**
-     * Sends the file identified by id
+     * Removes element from queue, starts upload of next
      */
-    upload: function(id){
-        var len = this._queue.push(id);
+    dequeue = function(id) {
+        var i = qq.indexOf(queue, id),
+            max = options.maxConnections,
+            nextId;
 
-        // if too many active uploads, wait...
-        if (len <= this._options.maxConnections){
-            this._upload(id);
-        }
-    },
-    retry: function(id) {
-        var i = qq.indexOf(this._queue, id);
         if (i >= 0) {
-            this._upload(id);
-        }
-        else {
-            this.upload(id);
-        }
-    },
-    /**
-     * Cancels file upload by id
-     */
-    cancel: function(id){
-        this.log('Cancelling ' + id);
-        this._options.paramsStore.remove(id);
-        this._cancel(id);
-        this._dequeue(id);
-    },
-    /**
-     * Cancells all uploads
-     */
-    cancelAll: function(){
-        for (var i=0; i<this._queue.length; i++){
-            this._cancel(this._queue[i]);
+            queue.splice(i, 1);
+
+            if (queue.length >= max && i < max){
+                nextId = queue[max-1];
+                handlerImpl.upload(nextId);
+            }
         }
-        this._queue = [];
-    },
-    /**
-     * Returns name of the file identified by id
-     */
-    getName: function(id){},
-    /**
-     * Returns size of the file identified by id
-     */
-    getSize: function(id){},
-    /**
-     * Returns id of files being uploaded or
-     * waiting for their turn
-     */
-    getQueue: function(){
-        return this._queue;
-    },
-    reset: function() {
-        this.log('Resetting upload handler');
-        this._queue = [];
-    },
-    /**
-     * Actual upload method
-     */
-    _upload: function(id){},
-    /**
-     * Actual cancel method
-     */
-    _cancel: function(id){},
-    /**
-     * Removes element from queue, starts upload of next
-     */
-    _dequeue: function(id){
-        var i = qq.indexOf(this._queue, id);
-        this._queue.splice(i, 1);
+    };
+
+    if (qq.isXhrUploadSupported()) {
+        handlerImpl = new qq.UploadHandlerXhr(options, dequeue, log);
+    }
+    else {
+        handlerImpl = new qq.UploadHandlerForm(options, dequeue, log);
+    }
+
+
+    return {
+        /**
+         * Adds file or file input to the queue
+         * @returns id
+         **/
+        add: function(file){
+            return handlerImpl.add(file);
+        },
+        /**
+         * Sends the file identified by id
+         */
+        upload: function(id){
+            var len = queue.push(id);
 
-        var max = this._options.maxConnections;
+            // if too many active uploads, wait...
+            if (len <= options.maxConnections){
+                return handlerImpl.upload(id);
+            }
+        },
+        retry: function(id) {
+            var i = qq.indexOf(queue, id);
+            if (i >= 0) {
+                return handlerImpl.upload(id, true);
+            }
+            else {
+                return this.upload(id);
+            }
+        },
+        /**
+         * Cancels file upload by id
+         */
+        cancel: function(id) {
+            log('Cancelling ' + id);
+            options.paramsStore.remove(id);
+            handlerImpl.cancel(id);
+            dequeue(id);
+        },
+        /**
+         * Cancels all queued or in-progress uploads
+         */
+        cancelAll: function() {
+            var self = this,
+                queueCopy = [];
 
-        if (this._queue.length >= max && i < max){
-            var nextId = this._queue[max-1];
-            this._upload(nextId);
+            qq.extend(queueCopy, queue);
+            qq.each(queueCopy, function(idx, fileId) {
+                self.cancel(fileId);
+            });
+
+            queue = [];
+        },
+        /**
+         * Returns name of the file identified by id
+         */
+        getName: function(id){
+            return handlerImpl.getName(id);
+        },
+        /**
+         * Returns size of the file identified by id
+         */
+        getSize: function(id){
+            if (handlerImpl.getSize) {
+                return handlerImpl.getSize(id);
+            }
+        },
+        getFile: function(id) {
+            if (handlerImpl.getFile) {
+                return handlerImpl.getFile(id);
+            }
+        },
+        /**
+         * Returns id of files being uploaded or
+         * waiting for their turn
+         */
+        getQueue: function(){
+            return queue;
+        },
+        reset: function() {
+            log('Resetting upload handler');
+            queue = [];
+            handlerImpl.reset();
+        },
+        getUuid: function(id) {
+            return handlerImpl.getUuid(id);
+        },
+        /**
+         * Determine if the file exists.
+         */
+        isValid: function(id) {
+            return handlerImpl.isValid(id);
+        },
+        getResumableFilesData: function() {
+            if (handlerImpl.getResumableFilesData) {
+                return handlerImpl.getResumableFilesData();
+            }
+            return [];
         }
-    },
-    /**
-     * Determine if the file exists.
-     */
-    isValid: function(id) {}
+    };
 };