diff --git a/services/web/Gruntfile.coffee b/services/web/Gruntfile.coffee
index b93cc8dcbb..c49add4a91 100644
--- a/services/web/Gruntfile.coffee
+++ b/services/web/Gruntfile.coffee
@@ -196,6 +196,7 @@ module.exports = (grunt) ->
"mathjax": "/js/libs/mathjax/MathJax.js?config=TeX-AMS_HTML"
"pdfjs-dist/build/pdf": "libs/#{PackageVersions.lib('pdfjs')}/pdf"
"ace": "#{PackageVersions.lib('ace')}"
+ "fineuploader": "libs/#{PackageVersions.lib('fineuploader')}"
shim:
"pdfjs-dist/build/pdf":
deps: ["libs/#{PackageVersions.lib('pdfjs')}/compatibility"]
diff --git a/services/web/Jenkinsfile b/services/web/Jenkinsfile
index 9cdebb434c..6421296330 100644
--- a/services/web/Jenkinsfile
+++ b/services/web/Jenkinsfile
@@ -42,7 +42,7 @@ pipeline {
checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'modules/tpr-webmodule'], [$class: 'CloneOption', shallow: true]], userRemoteConfigs: [[credentialsId: 'GIT_DEPLOY_KEY', url: 'git@github.com:sharelatex/tpr-webmodule.git ']]])
checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'modules/learn-wiki'], [$class: 'CloneOption', shallow: true]], userRemoteConfigs: [[credentialsId: 'GIT_DEPLOY_KEY', url: 'git@bitbucket.org:sharelatex/learn-wiki-web-module.git']]])
checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'modules/templates'], [$class: 'CloneOption', shallow: true]], userRemoteConfigs: [[credentialsId: 'GIT_DEPLOY_KEY', url: 'git@github.com:sharelatex/templates-webmodule.git']]])
- checkout([$class: 'GitSCM', branches: [[name: '*/sk-unlisted-projects']], extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'modules/track-changes'], [$class: 'CloneOption', shallow: true]], userRemoteConfigs: [[credentialsId: 'GIT_DEPLOY_KEY', url: 'git@github.com:sharelatex/track-changes-web-module.git']]])
+ checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'modules/track-changes'], [$class: 'CloneOption', shallow: true]], userRemoteConfigs: [[credentialsId: 'GIT_DEPLOY_KEY', url: 'git@github.com:sharelatex/track-changes-web-module.git']]])
checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'modules/overleaf-integration'], [$class: 'CloneOption', shallow: true]], userRemoteConfigs: [[credentialsId: 'GIT_DEPLOY_KEY', url: 'git@github.com:sharelatex/overleaf-integration-web-module.git']]])
checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'modules/overleaf-account-merge'], [$class: 'CloneOption', shallow: true]], userRemoteConfigs: [[credentialsId: 'GIT_DEPLOY_KEY', url: 'git@github.com:sharelatex/overleaf-account-merge.git']]])
}
diff --git a/services/web/Makefile b/services/web/Makefile
index 44017629d1..98695a8c1f 100644
--- a/services/web/Makefile
+++ b/services/web/Makefile
@@ -30,11 +30,11 @@ clean:
rm -rf $$dir/test/unit/js; \
rm -rf $$dir/test/acceptance/js; \
done
- # Deletes node_modules volume
- docker-compose down --volumes
# Regenerate docker-shared.yml - not stictly a 'clean',
# but lets `make clean install` work nicely
bin/generate_volumes_file
+ # Deletes node_modules volume
+ docker-compose down --volumes
# Need regenerating if you change the web modules you have installed
docker-shared.yml:
diff --git a/services/web/app/coffee/infrastructure/ExpressLocals.coffee b/services/web/app/coffee/infrastructure/ExpressLocals.coffee
index fa9a223ad7..2fdf219962 100644
--- a/services/web/app/coffee/infrastructure/ExpressLocals.coffee
+++ b/services/web/app/coffee/infrastructure/ExpressLocals.coffee
@@ -24,6 +24,7 @@ jsPath =
ace = PackageVersions.lib('ace')
pdfjs = PackageVersions.lib('pdfjs')
+fineuploader = PackageVersions.lib('fineuploader')
getFileContent = (filePath)->
filePath = Path.join __dirname, "../../../", "public#{filePath}"
@@ -37,6 +38,7 @@ getFileContent = (filePath)->
logger.log "Generating file fingerprints..."
pathList = [
+ ["#{jsPath}libs/#{fineuploader}.js"]
["#{jsPath}libs/require.js"]
["#{jsPath}ide.js"]
["#{jsPath}main.js"]
diff --git a/services/web/app/coffee/infrastructure/PackageVersions.coffee b/services/web/app/coffee/infrastructure/PackageVersions.coffee
index f8c2011c11..5acdfec666 100644
--- a/services/web/app/coffee/infrastructure/PackageVersions.coffee
+++ b/services/web/app/coffee/infrastructure/PackageVersions.coffee
@@ -2,6 +2,7 @@ version = {
"pdfjs": "1.7.225"
"moment": "2.9.0"
"ace": "1.2.5"
+ "fineuploader": "5.15.4"
}
module.exports = {
diff --git a/services/web/app/views/layout.pug b/services/web/app/views/layout.pug
index 822923ac08..31afc17d29 100644
--- a/services/web/app/views/layout.pug
+++ b/services/web/app/views/layout.pug
@@ -132,7 +132,8 @@ html(itemscope, itemtype='http://schema.org/Product')
// minimal requirejs configuration (can be extended/overridden)
window.requirejs = {
"paths" : {
- "moment": "libs/#{lib('moment')}"
+ "moment": "libs/#{lib('moment')}",
+ "fineuploader": "libs/#{lib('fineuploader')}"
},
"urlArgs": "fingerprint=#{fingerprint(jsPath + 'main.js')}-#{fingerprint(jsPath + 'libs.js')}",
"config":{
diff --git a/services/web/app/views/project/editor.pug b/services/web/app/views/project/editor.pug
index 1e1f2c982b..625bea883d 100644
--- a/services/web/app/views/project/editor.pug
+++ b/services/web/app/views/project/editor.pug
@@ -130,7 +130,8 @@ block requirejs
"moment": "libs/#{lib('moment')}",
"pdfjs-dist/build/pdf": "libs/#{lib('pdfjs')}/pdf",
"pdfjs-dist/build/pdf.worker": "#{pdfWorkerPath}",
- "ace": "#{lib('ace')}"
+ "ace": "#{lib('ace')}",
+ "fineuploader": "libs/#{lib('fineuploader')}"
},
"urlArgs" : "fingerprint=#{fingerprint(jsPath + 'ide.js')}-#{fingerprint(jsPath + 'libs.js')}",
"waitSeconds": 0,
diff --git a/services/web/public/coffee/directives/fineUpload.coffee b/services/web/public/coffee/directives/fineUpload.coffee
index 7fffcc366a..b3d3766ba6 100644
--- a/services/web/public/coffee/directives/fineUpload.coffee
+++ b/services/web/public/coffee/directives/fineUpload.coffee
@@ -1,6 +1,6 @@
define [
"base"
- "libs/fineuploader"
+ "fineuploader"
], (App, qq) ->
App.directive 'fineUpload', ($timeout) ->
return {
diff --git a/services/web/public/coffee/libs.coffee b/services/web/public/coffee/libs.coffee
index 533891548b..2b0b034fb7 100644
--- a/services/web/public/coffee/libs.coffee
+++ b/services/web/public/coffee/libs.coffee
@@ -1,12 +1,10 @@
define [
- "moment"
"libs/angular-autocomplete/angular-autocomplete"
"libs/ui-bootstrap"
"libs/ng-context-menu-0.1.4"
"libs/underscore-1.3.3"
"libs/algolia-2.5.2"
"libs/jquery.storage"
- "libs/fineuploader"
"libs/angular-sanitize-1.2.17"
"libs/angular-cookie"
"libs/passfield"
diff --git a/services/web/public/js/libs/fineuploader-5.15.4.js b/services/web/public/js/libs/fineuploader-5.15.4.js
new file mode 100644
index 0000000000..606a2fb70a
--- /dev/null
+++ b/services/web/public/js/libs/fineuploader-5.15.4.js
@@ -0,0 +1,7455 @@
+// Fine Uploader 5.15.4 - MIT licensed. http://fineuploader.com
+(function(global) {
+ var qq = function(element) {
+ "use strict";
+ return {
+ hide: function() {
+ element.style.display = "none";
+ return this;
+ },
+ attach: function(type, fn) {
+ if (element.addEventListener) {
+ element.addEventListener(type, fn, false);
+ } else if (element.attachEvent) {
+ element.attachEvent("on" + type, fn);
+ }
+ return function() {
+ qq(element).detach(type, fn);
+ };
+ },
+ detach: function(type, fn) {
+ if (element.removeEventListener) {
+ element.removeEventListener(type, fn, false);
+ } else if (element.attachEvent) {
+ element.detachEvent("on" + type, fn);
+ }
+ return this;
+ },
+ contains: function(descendant) {
+ if (!descendant) {
+ return false;
+ }
+ if (element === descendant) {
+ return true;
+ }
+ if (element.contains) {
+ return element.contains(descendant);
+ } else {
+ return !!(descendant.compareDocumentPosition(element) & 8);
+ }
+ },
+ insertBefore: function(elementB) {
+ elementB.parentNode.insertBefore(element, elementB);
+ return this;
+ },
+ remove: function() {
+ element.parentNode.removeChild(element);
+ return this;
+ },
+ css: function(styles) {
+ if (element.style == null) {
+ throw new qq.Error("Can't apply style to node as it is not on the HTMLElement prototype chain!");
+ }
+ if (styles.opacity != null) {
+ if (typeof element.style.opacity !== "string" && typeof element.filters !== "undefined") {
+ styles.filter = "alpha(opacity=" + Math.round(100 * styles.opacity) + ")";
+ }
+ }
+ qq.extend(element.style, styles);
+ return this;
+ },
+ hasClass: function(name, considerParent) {
+ var re = new RegExp("(^| )" + name + "( |$)");
+ return re.test(element.className) || !!(considerParent && re.test(element.parentNode.className));
+ },
+ addClass: function(name) {
+ if (!qq(element).hasClass(name)) {
+ element.className += " " + name;
+ }
+ return this;
+ },
+ removeClass: function(name) {
+ var re = new RegExp("(^| )" + name + "( |$)");
+ element.className = element.className.replace(re, " ").replace(/^\s+|\s+$/g, "");
+ return this;
+ },
+ getByClass: function(className, first) {
+ var candidates, result = [];
+ if (first && element.querySelector) {
+ return element.querySelector("." + className);
+ } else if (element.querySelectorAll) {
+ return element.querySelectorAll("." + className);
+ }
+ candidates = element.getElementsByTagName("*");
+ qq.each(candidates, function(idx, val) {
+ if (qq(val).hasClass(className)) {
+ result.push(val);
+ }
+ });
+ return first ? result[0] : result;
+ },
+ getFirstByClass: function(className) {
+ return qq(element).getByClass(className, true);
+ },
+ children: function() {
+ var children = [], child = element.firstChild;
+ while (child) {
+ if (child.nodeType === 1) {
+ children.push(child);
+ }
+ child = child.nextSibling;
+ }
+ return children;
+ },
+ setText: function(text) {
+ element.innerText = text;
+ element.textContent = text;
+ return this;
+ },
+ clearText: function() {
+ return qq(element).setText("");
+ },
+ hasAttribute: function(attrName) {
+ var attrVal;
+ if (element.hasAttribute) {
+ if (!element.hasAttribute(attrName)) {
+ return false;
+ }
+ return /^false$/i.exec(element.getAttribute(attrName)) == null;
+ } else {
+ attrVal = element[attrName];
+ if (attrVal === undefined) {
+ return false;
+ }
+ return /^false$/i.exec(attrVal) == null;
+ }
+ }
+ };
+ };
+ (function() {
+ "use strict";
+ qq.canvasToBlob = function(canvas, mime, quality) {
+ return qq.dataUriToBlob(canvas.toDataURL(mime, quality));
+ };
+ qq.dataUriToBlob = function(dataUri) {
+ var arrayBuffer, byteString, createBlob = function(data, mime) {
+ var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder, blobBuilder = BlobBuilder && new BlobBuilder();
+ if (blobBuilder) {
+ blobBuilder.append(data);
+ return blobBuilder.getBlob(mime);
+ } else {
+ return new Blob([ data ], {
+ type: mime
+ });
+ }
+ }, intArray, mimeString;
+ if (dataUri.split(",")[0].indexOf("base64") >= 0) {
+ byteString = atob(dataUri.split(",")[1]);
+ } else {
+ byteString = decodeURI(dataUri.split(",")[1]);
+ }
+ mimeString = dataUri.split(",")[0].split(":")[1].split(";")[0];
+ arrayBuffer = new ArrayBuffer(byteString.length);
+ intArray = new Uint8Array(arrayBuffer);
+ qq.each(byteString, function(idx, character) {
+ intArray[idx] = character.charCodeAt(0);
+ });
+ return createBlob(arrayBuffer, mimeString);
+ };
+ qq.log = function(message, level) {
+ if (window.console) {
+ if (!level || level === "info") {
+ window.console.log(message);
+ } else {
+ if (window.console[level]) {
+ window.console[level](message);
+ } else {
+ window.console.log("<" + level + "> " + message);
+ }
+ }
+ }
+ };
+ qq.isObject = function(variable) {
+ return variable && !variable.nodeType && Object.prototype.toString.call(variable) === "[object Object]";
+ };
+ qq.isFunction = function(variable) {
+ return typeof variable === "function";
+ };
+ qq.isArray = function(value) {
+ return Object.prototype.toString.call(value) === "[object Array]" || value && window.ArrayBuffer && value.buffer && value.buffer.constructor === ArrayBuffer;
+ };
+ qq.isItemList = function(maybeItemList) {
+ return Object.prototype.toString.call(maybeItemList) === "[object DataTransferItemList]";
+ };
+ qq.isNodeList = function(maybeNodeList) {
+ return Object.prototype.toString.call(maybeNodeList) === "[object NodeList]" || maybeNodeList.item && maybeNodeList.namedItem;
+ };
+ qq.isString = function(maybeString) {
+ return Object.prototype.toString.call(maybeString) === "[object String]";
+ };
+ qq.trimStr = function(string) {
+ if (String.prototype.trim) {
+ return string.trim();
+ }
+ return string.replace(/^\s+|\s+$/g, "");
+ };
+ qq.format = function(str) {
+ var args = Array.prototype.slice.call(arguments, 1), newStr = str, nextIdxToReplace = newStr.indexOf("{}");
+ qq.each(args, function(idx, val) {
+ var strBefore = newStr.substring(0, nextIdxToReplace), strAfter = newStr.substring(nextIdxToReplace + 2);
+ newStr = strBefore + val + strAfter;
+ nextIdxToReplace = newStr.indexOf("{}", nextIdxToReplace + val.length);
+ if (nextIdxToReplace < 0) {
+ return false;
+ }
+ });
+ return newStr;
+ };
+ qq.isFile = function(maybeFile) {
+ return window.File && Object.prototype.toString.call(maybeFile) === "[object File]";
+ };
+ qq.isFileList = function(maybeFileList) {
+ return window.FileList && Object.prototype.toString.call(maybeFileList) === "[object FileList]";
+ };
+ qq.isFileOrInput = function(maybeFileOrInput) {
+ return qq.isFile(maybeFileOrInput) || qq.isInput(maybeFileOrInput);
+ };
+ qq.isInput = function(maybeInput, notFile) {
+ var evaluateType = function(type) {
+ var normalizedType = type.toLowerCase();
+ if (notFile) {
+ return normalizedType !== "file";
+ }
+ return normalizedType === "file";
+ };
+ if (window.HTMLInputElement) {
+ if (Object.prototype.toString.call(maybeInput) === "[object HTMLInputElement]") {
+ if (maybeInput.type && evaluateType(maybeInput.type)) {
+ return true;
+ }
+ }
+ }
+ if (maybeInput.tagName) {
+ if (maybeInput.tagName.toLowerCase() === "input") {
+ if (maybeInput.type && evaluateType(maybeInput.type)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ };
+ qq.isBlob = function(maybeBlob) {
+ if (window.Blob && Object.prototype.toString.call(maybeBlob) === "[object Blob]") {
+ return true;
+ }
+ };
+ qq.isXhrUploadSupported = function() {
+ var input = document.createElement("input");
+ input.type = "file";
+ return input.multiple !== undefined && typeof File !== "undefined" && typeof FormData !== "undefined" && typeof qq.createXhrInstance().upload !== "undefined";
+ };
+ qq.createXhrInstance = function() {
+ if (window.XMLHttpRequest) {
+ return new XMLHttpRequest();
+ }
+ try {
+ return new ActiveXObject("MSXML2.XMLHTTP.3.0");
+ } catch (error) {
+ qq.log("Neither XHR or ActiveX are supported!", "error");
+ return null;
+ }
+ };
+ qq.isFolderDropSupported = function(dataTransfer) {
+ return dataTransfer.items && dataTransfer.items.length > 0 && dataTransfer.items[0].webkitGetAsEntry;
+ };
+ qq.isFileChunkingSupported = function() {
+ return !qq.androidStock() && qq.isXhrUploadSupported() && (File.prototype.slice !== undefined || File.prototype.webkitSlice !== undefined || File.prototype.mozSlice !== undefined);
+ };
+ qq.sliceBlob = function(fileOrBlob, start, end) {
+ var slicer = fileOrBlob.slice || fileOrBlob.mozSlice || fileOrBlob.webkitSlice;
+ return slicer.call(fileOrBlob, start, end);
+ };
+ qq.arrayBufferToHex = function(buffer) {
+ var bytesAsHex = "", bytes = new Uint8Array(buffer);
+ qq.each(bytes, function(idx, byt) {
+ var byteAsHexStr = byt.toString(16);
+ if (byteAsHexStr.length < 2) {
+ byteAsHexStr = "0" + byteAsHexStr;
+ }
+ bytesAsHex += byteAsHexStr;
+ });
+ return bytesAsHex;
+ };
+ qq.readBlobToHex = function(blob, startOffset, length) {
+ var initialBlob = qq.sliceBlob(blob, startOffset, startOffset + length), fileReader = new FileReader(), promise = new qq.Promise();
+ fileReader.onload = function() {
+ promise.success(qq.arrayBufferToHex(fileReader.result));
+ };
+ fileReader.onerror = promise.failure;
+ fileReader.readAsArrayBuffer(initialBlob);
+ return promise;
+ };
+ qq.extend = function(first, second, extendNested) {
+ qq.each(second, function(prop, val) {
+ if (extendNested && qq.isObject(val)) {
+ if (first[prop] === undefined) {
+ first[prop] = {};
+ }
+ qq.extend(first[prop], val, true);
+ } else {
+ first[prop] = val;
+ }
+ });
+ return first;
+ };
+ qq.override = function(target, sourceFn) {
+ var super_ = {}, source = sourceFn(super_);
+ qq.each(source, function(srcPropName, srcPropVal) {
+ if (target[srcPropName] !== undefined) {
+ super_[srcPropName] = target[srcPropName];
+ }
+ target[srcPropName] = srcPropVal;
+ });
+ return target;
+ };
+ qq.indexOf = function(arr, elt, from) {
+ if (arr.indexOf) {
+ return arr.indexOf(elt, from);
+ }
+ from = from || 0;
+ var len = arr.length;
+ if (from < 0) {
+ from += len;
+ }
+ for (;from < len; from += 1) {
+ if (arr.hasOwnProperty(from) && arr[from] === elt) {
+ return from;
+ }
+ }
+ return -1;
+ };
+ qq.getUniqueId = function() {
+ return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+ var r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+ return v.toString(16);
+ });
+ };
+ qq.ie = function() {
+ return navigator.userAgent.indexOf("MSIE") !== -1 || navigator.userAgent.indexOf("Trident") !== -1;
+ };
+ qq.ie7 = function() {
+ return navigator.userAgent.indexOf("MSIE 7") !== -1;
+ };
+ qq.ie8 = function() {
+ return navigator.userAgent.indexOf("MSIE 8") !== -1;
+ };
+ qq.ie10 = function() {
+ return navigator.userAgent.indexOf("MSIE 10") !== -1;
+ };
+ qq.ie11 = function() {
+ return qq.ie() && navigator.userAgent.indexOf("rv:11") !== -1;
+ };
+ qq.edge = function() {
+ return navigator.userAgent.indexOf("Edge") >= 0;
+ };
+ qq.safari = function() {
+ return navigator.vendor !== undefined && navigator.vendor.indexOf("Apple") !== -1;
+ };
+ qq.chrome = function() {
+ return navigator.vendor !== undefined && navigator.vendor.indexOf("Google") !== -1;
+ };
+ qq.opera = function() {
+ return navigator.vendor !== undefined && navigator.vendor.indexOf("Opera") !== -1;
+ };
+ qq.firefox = function() {
+ return !qq.edge() && !qq.ie11() && navigator.userAgent.indexOf("Mozilla") !== -1 && navigator.vendor !== undefined && navigator.vendor === "";
+ };
+ qq.windows = function() {
+ return navigator.platform === "Win32";
+ };
+ qq.android = function() {
+ return navigator.userAgent.toLowerCase().indexOf("android") !== -1;
+ };
+ qq.androidStock = function() {
+ return qq.android() && navigator.userAgent.toLowerCase().indexOf("chrome") < 0;
+ };
+ qq.ios6 = function() {
+ return qq.ios() && navigator.userAgent.indexOf(" OS 6_") !== -1;
+ };
+ qq.ios7 = function() {
+ return qq.ios() && navigator.userAgent.indexOf(" OS 7_") !== -1;
+ };
+ qq.ios8 = function() {
+ return qq.ios() && navigator.userAgent.indexOf(" OS 8_") !== -1;
+ };
+ qq.ios800 = function() {
+ return qq.ios() && navigator.userAgent.indexOf(" OS 8_0 ") !== -1;
+ };
+ qq.ios = function() {
+ return navigator.userAgent.indexOf("iPad") !== -1 || navigator.userAgent.indexOf("iPod") !== -1 || navigator.userAgent.indexOf("iPhone") !== -1;
+ };
+ qq.iosChrome = function() {
+ return qq.ios() && navigator.userAgent.indexOf("CriOS") !== -1;
+ };
+ qq.iosSafari = function() {
+ return qq.ios() && !qq.iosChrome() && navigator.userAgent.indexOf("Safari") !== -1;
+ };
+ qq.iosSafariWebView = function() {
+ return qq.ios() && !qq.iosChrome() && !qq.iosSafari();
+ };
+ qq.preventDefault = function(e) {
+ if (e.preventDefault) {
+ e.preventDefault();
+ } else {
+ e.returnValue = false;
+ }
+ };
+ qq.toElement = function() {
+ var div = document.createElement("div");
+ return function(html) {
+ div.innerHTML = html;
+ var element = div.firstChild;
+ div.removeChild(element);
+ return element;
+ };
+ }();
+ qq.each = function(iterableItem, callback) {
+ var keyOrIndex, retVal;
+ if (iterableItem) {
+ if (window.Storage && iterableItem.constructor === window.Storage) {
+ for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {
+ retVal = callback(iterableItem.key(keyOrIndex), iterableItem.getItem(iterableItem.key(keyOrIndex)));
+ if (retVal === false) {
+ break;
+ }
+ }
+ } else if (qq.isArray(iterableItem) || qq.isItemList(iterableItem) || qq.isNodeList(iterableItem)) {
+ for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {
+ retVal = callback(keyOrIndex, iterableItem[keyOrIndex]);
+ if (retVal === false) {
+ break;
+ }
+ }
+ } else if (qq.isString(iterableItem)) {
+ for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {
+ retVal = callback(keyOrIndex, iterableItem.charAt(keyOrIndex));
+ if (retVal === false) {
+ break;
+ }
+ }
+ } else {
+ for (keyOrIndex in iterableItem) {
+ if (Object.prototype.hasOwnProperty.call(iterableItem, keyOrIndex)) {
+ retVal = callback(keyOrIndex, iterableItem[keyOrIndex]);
+ if (retVal === false) {
+ break;
+ }
+ }
+ }
+ }
+ }
+ };
+ qq.bind = function(oldFunc, context) {
+ if (qq.isFunction(oldFunc)) {
+ var args = Array.prototype.slice.call(arguments, 2);
+ return function() {
+ var newArgs = qq.extend([], args);
+ if (arguments.length) {
+ newArgs = newArgs.concat(Array.prototype.slice.call(arguments));
+ }
+ return oldFunc.apply(context, newArgs);
+ };
+ }
+ throw new Error("first parameter must be a function!");
+ };
+ qq.obj2url = function(obj, temp, prefixDone) {
+ var uristrings = [], prefix = "&", add = function(nextObj, i) {
+ var nextTemp = temp ? /\[\]$/.test(temp) ? temp : temp + "[" + i + "]" : i;
+ if (nextTemp !== "undefined" && i !== "undefined") {
+ uristrings.push(typeof nextObj === "object" ? qq.obj2url(nextObj, nextTemp, true) : Object.prototype.toString.call(nextObj) === "[object Function]" ? encodeURIComponent(nextTemp) + "=" + encodeURIComponent(nextObj()) : encodeURIComponent(nextTemp) + "=" + encodeURIComponent(nextObj));
+ }
+ };
+ if (!prefixDone && temp) {
+ prefix = /\?/.test(temp) ? /\?$/.test(temp) ? "" : "&" : "?";
+ uristrings.push(temp);
+ uristrings.push(qq.obj2url(obj));
+ } else if (Object.prototype.toString.call(obj) === "[object Array]" && typeof obj !== "undefined") {
+ qq.each(obj, function(idx, val) {
+ add(val, idx);
+ });
+ } else if (typeof obj !== "undefined" && obj !== null && typeof obj === "object") {
+ qq.each(obj, function(prop, val) {
+ add(val, prop);
+ });
+ } else {
+ uristrings.push(encodeURIComponent(temp) + "=" + encodeURIComponent(obj));
+ }
+ if (temp) {
+ return uristrings.join(prefix);
+ } else {
+ return uristrings.join(prefix).replace(/^&/, "").replace(/%20/g, "+");
+ }
+ };
+ qq.obj2FormData = function(obj, formData, arrayKeyName) {
+ if (!formData) {
+ formData = new FormData();
+ }
+ qq.each(obj, function(key, val) {
+ key = arrayKeyName ? arrayKeyName + "[" + key + "]" : key;
+ if (qq.isObject(val)) {
+ qq.obj2FormData(val, formData, key);
+ } else if (qq.isFunction(val)) {
+ formData.append(key, val());
+ } else {
+ formData.append(key, val);
+ }
+ });
+ return formData;
+ };
+ qq.obj2Inputs = function(obj, form) {
+ var input;
+ if (!form) {
+ form = document.createElement("form");
+ }
+ qq.obj2FormData(obj, {
+ append: function(key, val) {
+ input = document.createElement("input");
+ input.setAttribute("name", key);
+ input.setAttribute("value", val);
+ form.appendChild(input);
+ }
+ });
+ return form;
+ };
+ qq.parseJson = function(json) {
+ if (window.JSON && qq.isFunction(JSON.parse)) {
+ return JSON.parse(json);
+ } else {
+ return eval("(" + json + ")");
+ }
+ };
+ qq.getExtension = function(filename) {
+ var extIdx = filename.lastIndexOf(".") + 1;
+ if (extIdx > 0) {
+ return filename.substr(extIdx, filename.length - extIdx);
+ }
+ };
+ qq.getFilename = function(blobOrFileInput) {
+ if (qq.isInput(blobOrFileInput)) {
+ return blobOrFileInput.value.replace(/.*(\/|\\)/, "");
+ } else if (qq.isFile(blobOrFileInput)) {
+ if (blobOrFileInput.fileName !== null && blobOrFileInput.fileName !== undefined) {
+ return blobOrFileInput.fileName;
+ }
+ }
+ return blobOrFileInput.name;
+ };
+ qq.DisposeSupport = function() {
+ var disposers = [];
+ return {
+ dispose: function() {
+ var disposer;
+ do {
+ disposer = disposers.shift();
+ if (disposer) {
+ disposer();
+ }
+ } while (disposer);
+ },
+ attach: function() {
+ var args = arguments;
+ this.addDisposer(qq(args[0]).attach.apply(this, Array.prototype.slice.call(arguments, 1)));
+ },
+ addDisposer: function(disposeFunction) {
+ disposers.push(disposeFunction);
+ }
+ };
+ };
+ })();
+ (function() {
+ "use strict";
+ if (typeof define === "function" && define.amd) {
+ define(function() {
+ return qq;
+ });
+ } else if (typeof module !== "undefined" && module.exports) {
+ module.exports = qq;
+ } else {
+ global.qq = qq;
+ }
+ })();
+ (function() {
+ "use strict";
+ qq.Error = function(message) {
+ this.message = "[Fine Uploader " + qq.version + "] " + message;
+ };
+ qq.Error.prototype = new Error();
+ })();
+ qq.version = "5.15.4";
+ qq.supportedFeatures = function() {
+ "use strict";
+ var supportsUploading, supportsUploadingBlobs, supportsFileDrop, supportsAjaxFileUploading, supportsFolderDrop, supportsChunking, supportsResume, supportsUploadViaPaste, supportsUploadCors, supportsDeleteFileXdr, supportsDeleteFileCorsXhr, supportsDeleteFileCors, supportsFolderSelection, supportsImagePreviews, supportsUploadProgress;
+ function testSupportsFileInputElement() {
+ var supported = true, tempInput;
+ try {
+ tempInput = document.createElement("input");
+ tempInput.type = "file";
+ qq(tempInput).hide();
+ if (tempInput.disabled) {
+ supported = false;
+ }
+ } catch (ex) {
+ supported = false;
+ }
+ return supported;
+ }
+ function isChrome21OrHigher() {
+ return (qq.chrome() || qq.opera()) && navigator.userAgent.match(/Chrome\/[2][1-9]|Chrome\/[3-9][0-9]/) !== undefined;
+ }
+ function isChrome14OrHigher() {
+ return (qq.chrome() || qq.opera()) && navigator.userAgent.match(/Chrome\/[1][4-9]|Chrome\/[2-9][0-9]/) !== undefined;
+ }
+ function isCrossOriginXhrSupported() {
+ if (window.XMLHttpRequest) {
+ var xhr = qq.createXhrInstance();
+ return xhr.withCredentials !== undefined;
+ }
+ return false;
+ }
+ function isXdrSupported() {
+ return window.XDomainRequest !== undefined;
+ }
+ function isCrossOriginAjaxSupported() {
+ if (isCrossOriginXhrSupported()) {
+ return true;
+ }
+ return isXdrSupported();
+ }
+ function isFolderSelectionSupported() {
+ return document.createElement("input").webkitdirectory !== undefined;
+ }
+ function isLocalStorageSupported() {
+ try {
+ return !!window.localStorage && qq.isFunction(window.localStorage.setItem);
+ } catch (error) {
+ return false;
+ }
+ }
+ function isDragAndDropSupported() {
+ var span = document.createElement("span");
+ return ("draggable" in span || "ondragstart" in span && "ondrop" in span) && !qq.android() && !qq.ios();
+ }
+ supportsUploading = testSupportsFileInputElement();
+ supportsAjaxFileUploading = supportsUploading && qq.isXhrUploadSupported();
+ supportsUploadingBlobs = supportsAjaxFileUploading && !qq.androidStock();
+ supportsFileDrop = supportsAjaxFileUploading && isDragAndDropSupported();
+ supportsFolderDrop = supportsFileDrop && isChrome21OrHigher();
+ supportsChunking = supportsAjaxFileUploading && qq.isFileChunkingSupported();
+ supportsResume = supportsAjaxFileUploading && supportsChunking && isLocalStorageSupported();
+ supportsUploadViaPaste = supportsAjaxFileUploading && isChrome14OrHigher();
+ supportsUploadCors = supportsUploading && (window.postMessage !== undefined || supportsAjaxFileUploading);
+ supportsDeleteFileCorsXhr = isCrossOriginXhrSupported();
+ supportsDeleteFileXdr = isXdrSupported();
+ supportsDeleteFileCors = isCrossOriginAjaxSupported();
+ supportsFolderSelection = isFolderSelectionSupported();
+ supportsImagePreviews = supportsAjaxFileUploading && window.FileReader !== undefined;
+ supportsUploadProgress = function() {
+ if (supportsAjaxFileUploading) {
+ return !qq.androidStock() && !qq.iosChrome();
+ }
+ return false;
+ }();
+ return {
+ ajaxUploading: supportsAjaxFileUploading,
+ blobUploading: supportsUploadingBlobs,
+ canDetermineSize: supportsAjaxFileUploading,
+ chunking: supportsChunking,
+ deleteFileCors: supportsDeleteFileCors,
+ deleteFileCorsXdr: supportsDeleteFileXdr,
+ deleteFileCorsXhr: supportsDeleteFileCorsXhr,
+ dialogElement: !!window.HTMLDialogElement,
+ fileDrop: supportsFileDrop,
+ folderDrop: supportsFolderDrop,
+ folderSelection: supportsFolderSelection,
+ imagePreviews: supportsImagePreviews,
+ imageValidation: supportsImagePreviews,
+ itemSizeValidation: supportsAjaxFileUploading,
+ pause: supportsChunking,
+ progressBar: supportsUploadProgress,
+ resume: supportsResume,
+ scaling: supportsImagePreviews && supportsUploadingBlobs,
+ tiffPreviews: qq.safari(),
+ unlimitedScaledImageSize: !qq.ios(),
+ uploading: supportsUploading,
+ uploadCors: supportsUploadCors,
+ uploadCustomHeaders: supportsAjaxFileUploading,
+ uploadNonMultipart: supportsAjaxFileUploading,
+ uploadViaPaste: supportsUploadViaPaste
+ };
+ }();
+ qq.isGenericPromise = function(maybePromise) {
+ "use strict";
+ return !!(maybePromise && maybePromise.then && qq.isFunction(maybePromise.then));
+ };
+ qq.Promise = function() {
+ "use strict";
+ var successArgs, failureArgs, successCallbacks = [], failureCallbacks = [], doneCallbacks = [], state = 0;
+ qq.extend(this, {
+ then: function(onSuccess, onFailure) {
+ if (state === 0) {
+ if (onSuccess) {
+ successCallbacks.push(onSuccess);
+ }
+ if (onFailure) {
+ failureCallbacks.push(onFailure);
+ }
+ } else if (state === -1) {
+ onFailure && onFailure.apply(null, failureArgs);
+ } else if (onSuccess) {
+ onSuccess.apply(null, successArgs);
+ }
+ return this;
+ },
+ done: function(callback) {
+ if (state === 0) {
+ doneCallbacks.push(callback);
+ } else {
+ callback.apply(null, failureArgs === undefined ? successArgs : failureArgs);
+ }
+ return this;
+ },
+ success: function() {
+ state = 1;
+ successArgs = arguments;
+ if (successCallbacks.length) {
+ qq.each(successCallbacks, function(idx, callback) {
+ callback.apply(null, successArgs);
+ });
+ }
+ if (doneCallbacks.length) {
+ qq.each(doneCallbacks, function(idx, callback) {
+ callback.apply(null, successArgs);
+ });
+ }
+ return this;
+ },
+ failure: function() {
+ state = -1;
+ failureArgs = arguments;
+ if (failureCallbacks.length) {
+ qq.each(failureCallbacks, function(idx, callback) {
+ callback.apply(null, failureArgs);
+ });
+ }
+ if (doneCallbacks.length) {
+ qq.each(doneCallbacks, function(idx, callback) {
+ callback.apply(null, failureArgs);
+ });
+ }
+ return this;
+ }
+ });
+ };
+ qq.BlobProxy = function(referenceBlob, onCreate) {
+ "use strict";
+ qq.extend(this, {
+ referenceBlob: referenceBlob,
+ create: function() {
+ return onCreate(referenceBlob);
+ }
+ });
+ };
+ qq.UploadButton = function(o) {
+ "use strict";
+ var self = this, disposeSupport = new qq.DisposeSupport(), options = {
+ acceptFiles: null,
+ element: null,
+ focusClass: "qq-upload-button-focus",
+ folders: false,
+ hoverClass: "qq-upload-button-hover",
+ ios8BrowserCrashWorkaround: false,
+ multiple: false,
+ name: "qqfile",
+ onChange: function(input) {},
+ title: null
+ }, input, buttonId;
+ qq.extend(options, o);
+ buttonId = qq.getUniqueId();
+ function createInput() {
+ var input = document.createElement("input");
+ input.setAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME, buttonId);
+ input.setAttribute("title", options.title);
+ self.setMultiple(options.multiple, input);
+ if (options.folders && qq.supportedFeatures.folderSelection) {
+ input.setAttribute("webkitdirectory", "");
+ }
+ if (options.acceptFiles) {
+ input.setAttribute("accept", options.acceptFiles);
+ }
+ input.setAttribute("type", "file");
+ input.setAttribute("name", options.name);
+ qq(input).css({
+ position: "absolute",
+ right: 0,
+ top: 0,
+ fontFamily: "Arial",
+ fontSize: qq.ie() && !qq.ie8() ? "3500px" : "118px",
+ margin: 0,
+ padding: 0,
+ cursor: "pointer",
+ opacity: 0
+ });
+ !qq.ie7() && qq(input).css({
+ height: "100%"
+ });
+ options.element.appendChild(input);
+ disposeSupport.attach(input, "change", function() {
+ options.onChange(input);
+ });
+ disposeSupport.attach(input, "mouseover", function() {
+ qq(options.element).addClass(options.hoverClass);
+ });
+ disposeSupport.attach(input, "mouseout", function() {
+ qq(options.element).removeClass(options.hoverClass);
+ });
+ disposeSupport.attach(input, "focus", function() {
+ qq(options.element).addClass(options.focusClass);
+ });
+ disposeSupport.attach(input, "blur", function() {
+ qq(options.element).removeClass(options.focusClass);
+ });
+ return input;
+ }
+ qq(options.element).css({
+ position: "relative",
+ overflow: "hidden",
+ direction: "ltr"
+ });
+ qq.extend(this, {
+ getInput: function() {
+ return input;
+ },
+ getButtonId: function() {
+ return buttonId;
+ },
+ setMultiple: function(isMultiple, optInput) {
+ var input = optInput || this.getInput();
+ if (options.ios8BrowserCrashWorkaround && qq.ios8() && (qq.iosChrome() || qq.iosSafariWebView())) {
+ input.setAttribute("multiple", "");
+ } else {
+ if (isMultiple) {
+ input.setAttribute("multiple", "");
+ } else {
+ input.removeAttribute("multiple");
+ }
+ }
+ },
+ setAcceptFiles: function(acceptFiles) {
+ if (acceptFiles !== options.acceptFiles) {
+ input.setAttribute("accept", acceptFiles);
+ }
+ },
+ reset: function() {
+ if (input.parentNode) {
+ qq(input).remove();
+ }
+ qq(options.element).removeClass(options.focusClass);
+ input = null;
+ input = createInput();
+ }
+ });
+ input = createInput();
+ };
+ qq.UploadButton.BUTTON_ID_ATTR_NAME = "qq-button-id";
+ qq.UploadData = function(uploaderProxy) {
+ "use strict";
+ var data = [], byUuid = {}, byStatus = {}, byProxyGroupId = {}, byBatchId = {};
+ function getDataByIds(idOrIds) {
+ if (qq.isArray(idOrIds)) {
+ var entries = [];
+ qq.each(idOrIds, function(idx, id) {
+ entries.push(data[id]);
+ });
+ return entries;
+ }
+ return data[idOrIds];
+ }
+ function getDataByUuids(uuids) {
+ if (qq.isArray(uuids)) {
+ var entries = [];
+ qq.each(uuids, function(idx, uuid) {
+ entries.push(data[byUuid[uuid]]);
+ });
+ return entries;
+ }
+ return data[byUuid[uuids]];
+ }
+ function getDataByStatus(status) {
+ var statusResults = [], statuses = [].concat(status);
+ qq.each(statuses, function(index, statusEnum) {
+ var statusResultIndexes = byStatus[statusEnum];
+ if (statusResultIndexes !== undefined) {
+ qq.each(statusResultIndexes, function(i, dataIndex) {
+ statusResults.push(data[dataIndex]);
+ });
+ }
+ });
+ return statusResults;
+ }
+ qq.extend(this, {
+ addFile: function(spec) {
+ var status = spec.status || qq.status.SUBMITTING, id = data.push({
+ name: spec.name,
+ originalName: spec.name,
+ uuid: spec.uuid,
+ size: spec.size == null ? -1 : spec.size,
+ status: status
+ }) - 1;
+ if (spec.batchId) {
+ data[id].batchId = spec.batchId;
+ if (byBatchId[spec.batchId] === undefined) {
+ byBatchId[spec.batchId] = [];
+ }
+ byBatchId[spec.batchId].push(id);
+ }
+ if (spec.proxyGroupId) {
+ data[id].proxyGroupId = spec.proxyGroupId;
+ if (byProxyGroupId[spec.proxyGroupId] === undefined) {
+ byProxyGroupId[spec.proxyGroupId] = [];
+ }
+ byProxyGroupId[spec.proxyGroupId].push(id);
+ }
+ data[id].id = id;
+ byUuid[spec.uuid] = id;
+ if (byStatus[status] === undefined) {
+ byStatus[status] = [];
+ }
+ byStatus[status].push(id);
+ spec.onBeforeStatusChange && spec.onBeforeStatusChange(id);
+ uploaderProxy.onStatusChange(id, null, status);
+ return id;
+ },
+ retrieve: function(optionalFilter) {
+ if (qq.isObject(optionalFilter) && data.length) {
+ if (optionalFilter.id !== undefined) {
+ return getDataByIds(optionalFilter.id);
+ } else if (optionalFilter.uuid !== undefined) {
+ return getDataByUuids(optionalFilter.uuid);
+ } else if (optionalFilter.status) {
+ return getDataByStatus(optionalFilter.status);
+ }
+ } else {
+ return qq.extend([], data, true);
+ }
+ },
+ reset: function() {
+ data = [];
+ byUuid = {};
+ byStatus = {};
+ byBatchId = {};
+ },
+ setStatus: function(id, newStatus) {
+ var oldStatus = data[id].status, byStatusOldStatusIndex = qq.indexOf(byStatus[oldStatus], id);
+ byStatus[oldStatus].splice(byStatusOldStatusIndex, 1);
+ data[id].status = newStatus;
+ if (byStatus[newStatus] === undefined) {
+ byStatus[newStatus] = [];
+ }
+ byStatus[newStatus].push(id);
+ uploaderProxy.onStatusChange(id, oldStatus, newStatus);
+ },
+ uuidChanged: function(id, newUuid) {
+ var oldUuid = data[id].uuid;
+ data[id].uuid = newUuid;
+ byUuid[newUuid] = id;
+ delete byUuid[oldUuid];
+ },
+ updateName: function(id, newName) {
+ data[id].name = newName;
+ },
+ updateSize: function(id, newSize) {
+ data[id].size = newSize;
+ },
+ setParentId: function(targetId, parentId) {
+ data[targetId].parentId = parentId;
+ },
+ getIdsInProxyGroup: function(id) {
+ var proxyGroupId = data[id].proxyGroupId;
+ if (proxyGroupId) {
+ return byProxyGroupId[proxyGroupId];
+ }
+ return [];
+ },
+ getIdsInBatch: function(id) {
+ var batchId = data[id].batchId;
+ return byBatchId[batchId];
+ }
+ });
+ };
+ qq.status = {
+ SUBMITTING: "submitting",
+ SUBMITTED: "submitted",
+ REJECTED: "rejected",
+ QUEUED: "queued",
+ CANCELED: "canceled",
+ PAUSED: "paused",
+ UPLOADING: "uploading",
+ UPLOAD_RETRYING: "retrying upload",
+ UPLOAD_SUCCESSFUL: "upload successful",
+ UPLOAD_FAILED: "upload failed",
+ DELETE_FAILED: "delete failed",
+ DELETING: "deleting",
+ DELETED: "deleted"
+ };
+ (function() {
+ "use strict";
+ qq.basePublicApi = {
+ addBlobs: function(blobDataOrArray, params, endpoint) {
+ this.addFiles(blobDataOrArray, params, endpoint);
+ },
+ addInitialFiles: function(cannedFileList) {
+ var self = this;
+ qq.each(cannedFileList, function(index, cannedFile) {
+ self._addCannedFile(cannedFile);
+ });
+ },
+ addFiles: function(data, params, endpoint) {
+ this._maybeHandleIos8SafariWorkaround();
+ var batchId = this._storedIds.length === 0 ? qq.getUniqueId() : this._currentBatchId, processBlob = qq.bind(function(blob) {
+ this._handleNewFile({
+ blob: blob,
+ name: this._options.blobs.defaultName
+ }, batchId, verifiedFiles);
+ }, this), processBlobData = qq.bind(function(blobData) {
+ this._handleNewFile(blobData, batchId, verifiedFiles);
+ }, this), processCanvas = qq.bind(function(canvas) {
+ var blob = qq.canvasToBlob(canvas);
+ this._handleNewFile({
+ blob: blob,
+ name: this._options.blobs.defaultName + ".png"
+ }, batchId, verifiedFiles);
+ }, this), processCanvasData = qq.bind(function(canvasData) {
+ var normalizedQuality = canvasData.quality && canvasData.quality / 100, blob = qq.canvasToBlob(canvasData.canvas, canvasData.type, normalizedQuality);
+ this._handleNewFile({
+ blob: blob,
+ name: canvasData.name
+ }, batchId, verifiedFiles);
+ }, this), processFileOrInput = qq.bind(function(fileOrInput) {
+ if (qq.isInput(fileOrInput) && qq.supportedFeatures.ajaxUploading) {
+ var files = Array.prototype.slice.call(fileOrInput.files), self = this;
+ qq.each(files, function(idx, file) {
+ self._handleNewFile(file, batchId, verifiedFiles);
+ });
+ } else {
+ this._handleNewFile(fileOrInput, batchId, verifiedFiles);
+ }
+ }, this), normalizeData = function() {
+ if (qq.isFileList(data)) {
+ data = Array.prototype.slice.call(data);
+ }
+ data = [].concat(data);
+ }, self = this, verifiedFiles = [];
+ this._currentBatchId = batchId;
+ if (data) {
+ normalizeData();
+ qq.each(data, function(idx, fileContainer) {
+ if (qq.isFileOrInput(fileContainer)) {
+ processFileOrInput(fileContainer);
+ } else if (qq.isBlob(fileContainer)) {
+ processBlob(fileContainer);
+ } else if (qq.isObject(fileContainer)) {
+ if (fileContainer.blob && fileContainer.name) {
+ processBlobData(fileContainer);
+ } else if (fileContainer.canvas && fileContainer.name) {
+ processCanvasData(fileContainer);
+ }
+ } else if (fileContainer.tagName && fileContainer.tagName.toLowerCase() === "canvas") {
+ processCanvas(fileContainer);
+ } else {
+ self.log(fileContainer + " is not a valid file container! Ignoring!", "warn");
+ }
+ });
+ this.log("Received " + verifiedFiles.length + " files.");
+ this._prepareItemsForUpload(verifiedFiles, params, endpoint);
+ }
+ },
+ cancel: function(id) {
+ this._handler.cancel(id);
+ },
+ cancelAll: function() {
+ var storedIdsCopy = [], self = this;
+ qq.extend(storedIdsCopy, this._storedIds);
+ qq.each(storedIdsCopy, function(idx, storedFileId) {
+ self.cancel(storedFileId);
+ });
+ this._handler.cancelAll();
+ },
+ clearStoredFiles: function() {
+ this._storedIds = [];
+ },
+ continueUpload: function(id) {
+ var uploadData = this._uploadData.retrieve({
+ id: id
+ });
+ if (!qq.supportedFeatures.pause || !this._options.chunking.enabled) {
+ return false;
+ }
+ if (uploadData.status === qq.status.PAUSED) {
+ this.log(qq.format("Paused file ID {} ({}) will be continued. Not paused.", id, this.getName(id)));
+ this._uploadFile(id);
+ return true;
+ } else {
+ this.log(qq.format("Ignoring continue for file ID {} ({}). Not paused.", id, this.getName(id)), "error");
+ }
+ return false;
+ },
+ deleteFile: function(id) {
+ return this._onSubmitDelete(id);
+ },
+ doesExist: function(fileOrBlobId) {
+ return this._handler.isValid(fileOrBlobId);
+ },
+ drawThumbnail: function(fileId, imgOrCanvas, maxSize, fromServer, customResizeFunction) {
+ var promiseToReturn = new qq.Promise(), fileOrUrl, options;
+ if (this._imageGenerator) {
+ fileOrUrl = this._thumbnailUrls[fileId];
+ options = {
+ customResizeFunction: customResizeFunction,
+ maxSize: maxSize > 0 ? maxSize : null,
+ scale: maxSize > 0
+ };
+ if (!fromServer && qq.supportedFeatures.imagePreviews) {
+ fileOrUrl = this.getFile(fileId);
+ }
+ if (fileOrUrl == null) {
+ promiseToReturn.failure({
+ container: imgOrCanvas,
+ error: "File or URL not found."
+ });
+ } else {
+ this._imageGenerator.generate(fileOrUrl, imgOrCanvas, options).then(function success(modifiedContainer) {
+ promiseToReturn.success(modifiedContainer);
+ }, function failure(container, reason) {
+ promiseToReturn.failure({
+ container: container,
+ error: reason || "Problem generating thumbnail"
+ });
+ });
+ }
+ } else {
+ promiseToReturn.failure({
+ container: imgOrCanvas,
+ error: "Missing image generator module"
+ });
+ }
+ return promiseToReturn;
+ },
+ getButton: function(fileId) {
+ return this._getButton(this._buttonIdsForFileIds[fileId]);
+ },
+ getEndpoint: function(fileId) {
+ return this._endpointStore.get(fileId);
+ },
+ getFile: function(fileOrBlobId) {
+ return this._handler.getFile(fileOrBlobId) || null;
+ },
+ getInProgress: function() {
+ return this._uploadData.retrieve({
+ status: [ qq.status.UPLOADING, qq.status.UPLOAD_RETRYING, qq.status.QUEUED ]
+ }).length;
+ },
+ getName: function(id) {
+ return this._uploadData.retrieve({
+ id: id
+ }).name;
+ },
+ getParentId: function(id) {
+ var uploadDataEntry = this.getUploads({
+ id: id
+ }), parentId = null;
+ if (uploadDataEntry) {
+ if (uploadDataEntry.parentId !== undefined) {
+ parentId = uploadDataEntry.parentId;
+ }
+ }
+ return parentId;
+ },
+ getResumableFilesData: function() {
+ return this._handler.getResumableFilesData();
+ },
+ getSize: function(id) {
+ return this._uploadData.retrieve({
+ id: id
+ }).size;
+ },
+ getNetUploads: function() {
+ return this._netUploaded;
+ },
+ getRemainingAllowedItems: function() {
+ var allowedItems = this._currentItemLimit;
+ if (allowedItems > 0) {
+ return allowedItems - this._netUploadedOrQueued;
+ }
+ return null;
+ },
+ getUploads: function(optionalFilter) {
+ return this._uploadData.retrieve(optionalFilter);
+ },
+ getUuid: function(id) {
+ return this._uploadData.retrieve({
+ id: id
+ }).uuid;
+ },
+ log: function(str, level) {
+ if (this._options.debug && (!level || level === "info")) {
+ qq.log("[Fine Uploader " + qq.version + "] " + str);
+ } else if (level && level !== "info") {
+ qq.log("[Fine Uploader " + qq.version + "] " + str, level);
+ }
+ },
+ pauseUpload: function(id) {
+ var uploadData = this._uploadData.retrieve({
+ id: id
+ });
+ if (!qq.supportedFeatures.pause || !this._options.chunking.enabled) {
+ return false;
+ }
+ if (qq.indexOf([ qq.status.UPLOADING, qq.status.UPLOAD_RETRYING ], uploadData.status) >= 0) {
+ if (this._handler.pause(id)) {
+ this._uploadData.setStatus(id, qq.status.PAUSED);
+ return true;
+ } else {
+ this.log(qq.format("Unable to pause file ID {} ({}).", id, this.getName(id)), "error");
+ }
+ } else {
+ this.log(qq.format("Ignoring pause for file ID {} ({}). Not in progress.", id, this.getName(id)), "error");
+ }
+ return false;
+ },
+ removeFileRef: function(id) {
+ this._handler.expunge(id);
+ },
+ reset: function() {
+ this.log("Resetting uploader...");
+ this._handler.reset();
+ this._storedIds = [];
+ this._autoRetries = [];
+ this._retryTimeouts = [];
+ this._preventRetries = [];
+ this._thumbnailUrls = [];
+ qq.each(this._buttons, function(idx, button) {
+ button.reset();
+ });
+ this._paramsStore.reset();
+ this._endpointStore.reset();
+ this._netUploadedOrQueued = 0;
+ this._netUploaded = 0;
+ this._uploadData.reset();
+ this._buttonIdsForFileIds = [];
+ this._pasteHandler && this._pasteHandler.reset();
+ this._options.session.refreshOnReset && this._refreshSessionData();
+ this._succeededSinceLastAllComplete = [];
+ this._failedSinceLastAllComplete = [];
+ this._totalProgress && this._totalProgress.reset();
+ },
+ retry: function(id) {
+ return this._manualRetry(id);
+ },
+ scaleImage: function(id, specs) {
+ var self = this;
+ return qq.Scaler.prototype.scaleImage(id, specs, {
+ log: qq.bind(self.log, self),
+ getFile: qq.bind(self.getFile, self),
+ uploadData: self._uploadData
+ });
+ },
+ setCustomHeaders: function(headers, id) {
+ this._customHeadersStore.set(headers, id);
+ },
+ setDeleteFileCustomHeaders: function(headers, id) {
+ this._deleteFileCustomHeadersStore.set(headers, id);
+ },
+ setDeleteFileEndpoint: function(endpoint, id) {
+ this._deleteFileEndpointStore.set(endpoint, id);
+ },
+ setDeleteFileParams: function(params, id) {
+ this._deleteFileParamsStore.set(params, id);
+ },
+ setEndpoint: function(endpoint, id) {
+ this._endpointStore.set(endpoint, id);
+ },
+ setForm: function(elementOrId) {
+ this._updateFormSupportAndParams(elementOrId);
+ },
+ setItemLimit: function(newItemLimit) {
+ this._currentItemLimit = newItemLimit;
+ },
+ setName: function(id, newName) {
+ this._uploadData.updateName(id, newName);
+ },
+ setParams: function(params, id) {
+ this._paramsStore.set(params, id);
+ },
+ setUuid: function(id, newUuid) {
+ return this._uploadData.uuidChanged(id, newUuid);
+ },
+ setStatus: function(id, newStatus) {
+ var fileRecord = this.getUploads({
+ id: id
+ });
+ if (!fileRecord) {
+ throw new qq.Error(id + " is not a valid file ID.");
+ }
+ switch (newStatus) {
+ case qq.status.DELETED:
+ this._onDeleteComplete(id, null, false);
+ break;
+
+ case qq.status.DELETE_FAILED:
+ this._onDeleteComplete(id, null, true);
+ break;
+
+ default:
+ var errorMessage = "Method setStatus called on '" + name + "' not implemented yet for " + newStatus;
+ this.log(errorMessage);
+ throw new qq.Error(errorMessage);
+ }
+ },
+ uploadStoredFiles: function() {
+ if (this._storedIds.length === 0) {
+ this._itemError("noFilesError");
+ } else {
+ this._uploadStoredFiles();
+ }
+ }
+ };
+ qq.basePrivateApi = {
+ _addCannedFile: function(sessionData) {
+ var self = this;
+ return this._uploadData.addFile({
+ uuid: sessionData.uuid,
+ name: sessionData.name,
+ size: sessionData.size,
+ status: qq.status.UPLOAD_SUCCESSFUL,
+ onBeforeStatusChange: function(id) {
+ sessionData.deleteFileEndpoint && self.setDeleteFileEndpoint(sessionData.deleteFileEndpoint, id);
+ sessionData.deleteFileParams && self.setDeleteFileParams(sessionData.deleteFileParams, id);
+ if (sessionData.thumbnailUrl) {
+ self._thumbnailUrls[id] = sessionData.thumbnailUrl;
+ }
+ self._netUploaded++;
+ self._netUploadedOrQueued++;
+ }
+ });
+ },
+ _annotateWithButtonId: function(file, associatedInput) {
+ if (qq.isFile(file)) {
+ file.qqButtonId = this._getButtonId(associatedInput);
+ }
+ },
+ _batchError: function(message) {
+ this._options.callbacks.onError(null, null, message, undefined);
+ },
+ _createDeleteHandler: function() {
+ var self = this;
+ return new qq.DeleteFileAjaxRequester({
+ method: this._options.deleteFile.method.toUpperCase(),
+ maxConnections: this._options.maxConnections,
+ uuidParamName: this._options.request.uuidName,
+ customHeaders: this._deleteFileCustomHeadersStore,
+ paramsStore: this._deleteFileParamsStore,
+ endpointStore: this._deleteFileEndpointStore,
+ cors: this._options.cors,
+ log: qq.bind(self.log, self),
+ onDelete: function(id) {
+ self._onDelete(id);
+ self._options.callbacks.onDelete(id);
+ },
+ onDeleteComplete: function(id, xhrOrXdr, isError) {
+ self._onDeleteComplete(id, xhrOrXdr, isError);
+ self._options.callbacks.onDeleteComplete(id, xhrOrXdr, isError);
+ }
+ });
+ },
+ _createPasteHandler: function() {
+ var self = this;
+ return new qq.PasteSupport({
+ targetElement: this._options.paste.targetElement,
+ callbacks: {
+ log: qq.bind(self.log, self),
+ pasteReceived: function(blob) {
+ self._handleCheckedCallback({
+ name: "onPasteReceived",
+ callback: qq.bind(self._options.callbacks.onPasteReceived, self, blob),
+ onSuccess: qq.bind(self._handlePasteSuccess, self, blob),
+ identifier: "pasted image"
+ });
+ }
+ }
+ });
+ },
+ _createStore: function(initialValue, _readOnlyValues_) {
+ var store = {}, catchall = initialValue, perIdReadOnlyValues = {}, readOnlyValues = _readOnlyValues_, copy = function(orig) {
+ if (qq.isObject(orig)) {
+ return qq.extend({}, orig);
+ }
+ return orig;
+ }, getReadOnlyValues = function() {
+ if (qq.isFunction(readOnlyValues)) {
+ return readOnlyValues();
+ }
+ return readOnlyValues;
+ }, includeReadOnlyValues = function(id, existing) {
+ if (readOnlyValues && qq.isObject(existing)) {
+ qq.extend(existing, getReadOnlyValues());
+ }
+ if (perIdReadOnlyValues[id]) {
+ qq.extend(existing, perIdReadOnlyValues[id]);
+ }
+ };
+ return {
+ set: function(val, id) {
+ if (id == null) {
+ store = {};
+ catchall = copy(val);
+ } else {
+ store[id] = copy(val);
+ }
+ },
+ get: function(id) {
+ var values;
+ if (id != null && store[id]) {
+ values = store[id];
+ } else {
+ values = copy(catchall);
+ }
+ includeReadOnlyValues(id, values);
+ return copy(values);
+ },
+ addReadOnly: function(id, values) {
+ if (qq.isObject(store)) {
+ if (id === null) {
+ if (qq.isFunction(values)) {
+ readOnlyValues = values;
+ } else {
+ readOnlyValues = readOnlyValues || {};
+ qq.extend(readOnlyValues, values);
+ }
+ } else {
+ perIdReadOnlyValues[id] = perIdReadOnlyValues[id] || {};
+ qq.extend(perIdReadOnlyValues[id], values);
+ }
+ }
+ },
+ remove: function(fileId) {
+ return delete store[fileId];
+ },
+ reset: function() {
+ store = {};
+ perIdReadOnlyValues = {};
+ catchall = initialValue;
+ }
+ };
+ },
+ _createUploadDataTracker: function() {
+ var self = this;
+ return new qq.UploadData({
+ getName: function(id) {
+ return self.getName(id);
+ },
+ getUuid: function(id) {
+ return self.getUuid(id);
+ },
+ getSize: function(id) {
+ return self.getSize(id);
+ },
+ onStatusChange: function(id, oldStatus, newStatus) {
+ self._onUploadStatusChange(id, oldStatus, newStatus);
+ self._options.callbacks.onStatusChange(id, oldStatus, newStatus);
+ self._maybeAllComplete(id, newStatus);
+ if (self._totalProgress) {
+ setTimeout(function() {
+ self._totalProgress.onStatusChange(id, oldStatus, newStatus);
+ }, 0);
+ }
+ }
+ });
+ },
+ _createUploadButton: function(spec) {
+ var self = this, acceptFiles = spec.accept || this._options.validation.acceptFiles, allowedExtensions = spec.allowedExtensions || this._options.validation.allowedExtensions, button;
+ function allowMultiple() {
+ if (qq.supportedFeatures.ajaxUploading) {
+ if (self._options.workarounds.iosEmptyVideos && qq.ios() && !qq.ios6() && self._isAllowedExtension(allowedExtensions, ".mov")) {
+ return false;
+ }
+ if (spec.multiple === undefined) {
+ return self._options.multiple;
+ }
+ return spec.multiple;
+ }
+ return false;
+ }
+ button = new qq.UploadButton({
+ acceptFiles: acceptFiles,
+ element: spec.element,
+ focusClass: this._options.classes.buttonFocus,
+ folders: spec.folders,
+ hoverClass: this._options.classes.buttonHover,
+ ios8BrowserCrashWorkaround: this._options.workarounds.ios8BrowserCrash,
+ multiple: allowMultiple(),
+ name: this._options.request.inputName,
+ onChange: function(input) {
+ self._onInputChange(input);
+ },
+ title: spec.title == null ? this._options.text.fileInputTitle : spec.title
+ });
+ this._disposeSupport.addDisposer(function() {
+ button.dispose();
+ });
+ self._buttons.push(button);
+ return button;
+ },
+ _createUploadHandler: function(additionalOptions, namespace) {
+ var self = this, lastOnProgress = {}, options = {
+ debug: this._options.debug,
+ maxConnections: this._options.maxConnections,
+ cors: this._options.cors,
+ paramsStore: this._paramsStore,
+ endpointStore: this._endpointStore,
+ chunking: this._options.chunking,
+ resume: this._options.resume,
+ blobs: this._options.blobs,
+ log: qq.bind(self.log, self),
+ preventRetryParam: this._options.retry.preventRetryResponseProperty,
+ onProgress: function(id, name, loaded, total) {
+ if (loaded < 0 || total < 0) {
+ return;
+ }
+ if (lastOnProgress[id]) {
+ if (lastOnProgress[id].loaded !== loaded || lastOnProgress[id].total !== total) {
+ self._onProgress(id, name, loaded, total);
+ self._options.callbacks.onProgress(id, name, loaded, total);
+ }
+ } else {
+ self._onProgress(id, name, loaded, total);
+ self._options.callbacks.onProgress(id, name, loaded, total);
+ }
+ lastOnProgress[id] = {
+ loaded: loaded,
+ total: total
+ };
+ },
+ onComplete: function(id, name, result, xhr) {
+ delete lastOnProgress[id];
+ var status = self.getUploads({
+ id: id
+ }).status, retVal;
+ if (status === qq.status.UPLOAD_SUCCESSFUL || status === qq.status.UPLOAD_FAILED) {
+ return;
+ }
+ retVal = self._onComplete(id, name, result, xhr);
+ if (retVal instanceof qq.Promise) {
+ retVal.done(function() {
+ self._options.callbacks.onComplete(id, name, result, xhr);
+ });
+ } else {
+ self._options.callbacks.onComplete(id, name, result, xhr);
+ }
+ },
+ onCancel: function(id, name, cancelFinalizationEffort) {
+ var promise = new qq.Promise();
+ self._handleCheckedCallback({
+ name: "onCancel",
+ callback: qq.bind(self._options.callbacks.onCancel, self, id, name),
+ onFailure: promise.failure,
+ onSuccess: function() {
+ cancelFinalizationEffort.then(function() {
+ self._onCancel(id, name);
+ });
+ promise.success();
+ },
+ identifier: id
+ });
+ return promise;
+ },
+ onUploadPrep: qq.bind(this._onUploadPrep, this),
+ onUpload: function(id, name) {
+ self._onUpload(id, name);
+ self._options.callbacks.onUpload(id, name);
+ },
+ onUploadChunk: function(id, name, chunkData) {
+ self._onUploadChunk(id, chunkData);
+ self._options.callbacks.onUploadChunk(id, name, chunkData);
+ },
+ onUploadChunkSuccess: function(id, chunkData, result, xhr) {
+ self._options.callbacks.onUploadChunkSuccess.apply(self, arguments);
+ },
+ onResume: function(id, name, chunkData) {
+ return self._options.callbacks.onResume(id, name, chunkData);
+ },
+ onAutoRetry: function(id, name, responseJSON, xhr) {
+ return self._onAutoRetry.apply(self, arguments);
+ },
+ onUuidChanged: function(id, newUuid) {
+ self.log("Server requested UUID change from '" + self.getUuid(id) + "' to '" + newUuid + "'");
+ self.setUuid(id, newUuid);
+ },
+ getName: qq.bind(self.getName, self),
+ getUuid: qq.bind(self.getUuid, self),
+ getSize: qq.bind(self.getSize, self),
+ setSize: qq.bind(self._setSize, self),
+ getDataByUuid: function(uuid) {
+ return self.getUploads({
+ uuid: uuid
+ });
+ },
+ isQueued: function(id) {
+ var status = self.getUploads({
+ id: id
+ }).status;
+ return status === qq.status.QUEUED || status === qq.status.SUBMITTED || status === qq.status.UPLOAD_RETRYING || status === qq.status.PAUSED;
+ },
+ getIdsInProxyGroup: self._uploadData.getIdsInProxyGroup,
+ getIdsInBatch: self._uploadData.getIdsInBatch
+ };
+ qq.each(this._options.request, function(prop, val) {
+ options[prop] = val;
+ });
+ options.customHeaders = this._customHeadersStore;
+ if (additionalOptions) {
+ qq.each(additionalOptions, function(key, val) {
+ options[key] = val;
+ });
+ }
+ return new qq.UploadHandlerController(options, namespace);
+ },
+ _fileOrBlobRejected: function(id) {
+ this._netUploadedOrQueued--;
+ this._uploadData.setStatus(id, qq.status.REJECTED);
+ },
+ _formatSize: function(bytes) {
+ if (bytes === 0) {
+ return bytes + this._options.text.sizeSymbols[0];
+ }
+ var i = -1;
+ do {
+ bytes = bytes / 1e3;
+ i++;
+ } while (bytes > 999);
+ return Math.max(bytes, .1).toFixed(1) + this._options.text.sizeSymbols[i];
+ },
+ _generateExtraButtonSpecs: function() {
+ var self = this;
+ this._extraButtonSpecs = {};
+ qq.each(this._options.extraButtons, function(idx, extraButtonOptionEntry) {
+ var multiple = extraButtonOptionEntry.multiple, validation = qq.extend({}, self._options.validation, true), extraButtonSpec = qq.extend({}, extraButtonOptionEntry);
+ if (multiple === undefined) {
+ multiple = self._options.multiple;
+ }
+ if (extraButtonSpec.validation) {
+ qq.extend(validation, extraButtonOptionEntry.validation, true);
+ }
+ qq.extend(extraButtonSpec, {
+ multiple: multiple,
+ validation: validation
+ }, true);
+ self._initExtraButton(extraButtonSpec);
+ });
+ },
+ _getButton: function(buttonId) {
+ var extraButtonsSpec = this._extraButtonSpecs[buttonId];
+ if (extraButtonsSpec) {
+ return extraButtonsSpec.element;
+ } else if (buttonId === this._defaultButtonId) {
+ return this._options.button;
+ }
+ },
+ _getButtonId: function(buttonOrFileInputOrFile) {
+ var inputs, fileInput, fileBlobOrInput = buttonOrFileInputOrFile;
+ if (fileBlobOrInput instanceof qq.BlobProxy) {
+ fileBlobOrInput = fileBlobOrInput.referenceBlob;
+ }
+ if (fileBlobOrInput && !qq.isBlob(fileBlobOrInput)) {
+ if (qq.isFile(fileBlobOrInput)) {
+ return fileBlobOrInput.qqButtonId;
+ } else if (fileBlobOrInput.tagName.toLowerCase() === "input" && fileBlobOrInput.type.toLowerCase() === "file") {
+ return fileBlobOrInput.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME);
+ }
+ inputs = fileBlobOrInput.getElementsByTagName("input");
+ qq.each(inputs, function(idx, input) {
+ if (input.getAttribute("type") === "file") {
+ fileInput = input;
+ return false;
+ }
+ });
+ if (fileInput) {
+ return fileInput.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME);
+ }
+ }
+ },
+ _getNotFinished: function() {
+ return this._uploadData.retrieve({
+ status: [ qq.status.UPLOADING, qq.status.UPLOAD_RETRYING, qq.status.QUEUED, qq.status.SUBMITTING, qq.status.SUBMITTED, qq.status.PAUSED ]
+ }).length;
+ },
+ _getValidationBase: function(buttonId) {
+ var extraButtonSpec = this._extraButtonSpecs[buttonId];
+ return extraButtonSpec ? extraButtonSpec.validation : this._options.validation;
+ },
+ _getValidationDescriptor: function(fileWrapper) {
+ if (fileWrapper.file instanceof qq.BlobProxy) {
+ return {
+ name: qq.getFilename(fileWrapper.file.referenceBlob),
+ size: fileWrapper.file.referenceBlob.size
+ };
+ }
+ return {
+ name: this.getUploads({
+ id: fileWrapper.id
+ }).name,
+ size: this.getUploads({
+ id: fileWrapper.id
+ }).size
+ };
+ },
+ _getValidationDescriptors: function(fileWrappers) {
+ var self = this, fileDescriptors = [];
+ qq.each(fileWrappers, function(idx, fileWrapper) {
+ fileDescriptors.push(self._getValidationDescriptor(fileWrapper));
+ });
+ return fileDescriptors;
+ },
+ _handleCameraAccess: function() {
+ if (this._options.camera.ios && qq.ios()) {
+ var acceptIosCamera = "image/*;capture=camera", button = this._options.camera.button, buttonId = button ? this._getButtonId(button) : this._defaultButtonId, optionRoot = this._options;
+ if (buttonId && buttonId !== this._defaultButtonId) {
+ optionRoot = this._extraButtonSpecs[buttonId];
+ }
+ optionRoot.multiple = false;
+ if (optionRoot.validation.acceptFiles === null) {
+ optionRoot.validation.acceptFiles = acceptIosCamera;
+ } else {
+ optionRoot.validation.acceptFiles += "," + acceptIosCamera;
+ }
+ qq.each(this._buttons, function(idx, button) {
+ if (button.getButtonId() === buttonId) {
+ button.setMultiple(optionRoot.multiple);
+ button.setAcceptFiles(optionRoot.acceptFiles);
+ return false;
+ }
+ });
+ }
+ },
+ _handleCheckedCallback: function(details) {
+ var self = this, callbackRetVal = details.callback();
+ if (qq.isGenericPromise(callbackRetVal)) {
+ this.log(details.name + " - waiting for " + details.name + " promise to be fulfilled for " + details.identifier);
+ return callbackRetVal.then(function(successParam) {
+ self.log(details.name + " promise success for " + details.identifier);
+ details.onSuccess(successParam);
+ }, function() {
+ if (details.onFailure) {
+ self.log(details.name + " promise failure for " + details.identifier);
+ details.onFailure();
+ } else {
+ self.log(details.name + " promise failure for " + details.identifier);
+ }
+ });
+ }
+ if (callbackRetVal !== false) {
+ details.onSuccess(callbackRetVal);
+ } else {
+ if (details.onFailure) {
+ this.log(details.name + " - return value was 'false' for " + details.identifier + ". Invoking failure callback.");
+ details.onFailure();
+ } else {
+ this.log(details.name + " - return value was 'false' for " + details.identifier + ". Will not proceed.");
+ }
+ }
+ return callbackRetVal;
+ },
+ _handleNewFile: function(file, batchId, newFileWrapperList) {
+ var self = this, uuid = qq.getUniqueId(), size = -1, name = qq.getFilename(file), actualFile = file.blob || file, handler = this._customNewFileHandler ? this._customNewFileHandler : qq.bind(self._handleNewFileGeneric, self);
+ if (!qq.isInput(actualFile) && actualFile.size >= 0) {
+ size = actualFile.size;
+ }
+ handler(actualFile, name, uuid, size, newFileWrapperList, batchId, this._options.request.uuidName, {
+ uploadData: self._uploadData,
+ paramsStore: self._paramsStore,
+ addFileToHandler: function(id, file) {
+ self._handler.add(id, file);
+ self._netUploadedOrQueued++;
+ self._trackButton(id);
+ }
+ });
+ },
+ _handleNewFileGeneric: function(file, name, uuid, size, fileList, batchId) {
+ var id = this._uploadData.addFile({
+ uuid: uuid,
+ name: name,
+ size: size,
+ batchId: batchId
+ });
+ this._handler.add(id, file);
+ this._trackButton(id);
+ this._netUploadedOrQueued++;
+ fileList.push({
+ id: id,
+ file: file
+ });
+ },
+ _handlePasteSuccess: function(blob, extSuppliedName) {
+ var extension = blob.type.split("/")[1], name = extSuppliedName;
+ if (name == null) {
+ name = this._options.paste.defaultName;
+ }
+ name += "." + extension;
+ this.addFiles({
+ name: name,
+ blob: blob
+ });
+ },
+ _handleDeleteSuccess: function(id) {
+ if (this.getUploads({
+ id: id
+ }).status !== qq.status.DELETED) {
+ var name = this.getName(id);
+ this._netUploadedOrQueued--;
+ this._netUploaded--;
+ this._handler.expunge(id);
+ this._uploadData.setStatus(id, qq.status.DELETED);
+ this.log("Delete request for '" + name + "' has succeeded.");
+ }
+ },
+ _handleDeleteFailed: function(id, xhrOrXdr) {
+ var name = this.getName(id);
+ this._uploadData.setStatus(id, qq.status.DELETE_FAILED);
+ this.log("Delete request for '" + name + "' has failed.", "error");
+ if (!xhrOrXdr || xhrOrXdr.withCredentials === undefined) {
+ this._options.callbacks.onError(id, name, "Delete request failed", xhrOrXdr);
+ } else {
+ this._options.callbacks.onError(id, name, "Delete request failed with response code " + xhrOrXdr.status, xhrOrXdr);
+ }
+ },
+ _initExtraButton: function(spec) {
+ var button = this._createUploadButton({
+ accept: spec.validation.acceptFiles,
+ allowedExtensions: spec.validation.allowedExtensions,
+ element: spec.element,
+ folders: spec.folders,
+ multiple: spec.multiple,
+ title: spec.fileInputTitle
+ });
+ this._extraButtonSpecs[button.getButtonId()] = spec;
+ },
+ _initFormSupportAndParams: function() {
+ this._formSupport = qq.FormSupport && new qq.FormSupport(this._options.form, qq.bind(this.uploadStoredFiles, this), qq.bind(this.log, this));
+ if (this._formSupport && this._formSupport.attachedToForm) {
+ this._paramsStore = this._createStore(this._options.request.params, this._formSupport.getFormInputsAsObject);
+ this._options.autoUpload = this._formSupport.newAutoUpload;
+ if (this._formSupport.newEndpoint) {
+ this._options.request.endpoint = this._formSupport.newEndpoint;
+ }
+ } else {
+ this._paramsStore = this._createStore(this._options.request.params);
+ }
+ },
+ _isDeletePossible: function() {
+ if (!qq.DeleteFileAjaxRequester || !this._options.deleteFile.enabled) {
+ return false;
+ }
+ if (this._options.cors.expected) {
+ if (qq.supportedFeatures.deleteFileCorsXhr) {
+ return true;
+ }
+ if (qq.supportedFeatures.deleteFileCorsXdr && this._options.cors.allowXdr) {
+ return true;
+ }
+ return false;
+ }
+ return true;
+ },
+ _isAllowedExtension: function(allowed, fileName) {
+ var valid = false;
+ if (!allowed.length) {
+ return true;
+ }
+ qq.each(allowed, function(idx, allowedExt) {
+ if (qq.isString(allowedExt)) {
+ var extRegex = new RegExp("\\." + allowedExt + "$", "i");
+ if (fileName.match(extRegex) != null) {
+ valid = true;
+ return false;
+ }
+ }
+ });
+ return valid;
+ },
+ _itemError: function(code, maybeNameOrNames, item) {
+ var message = this._options.messages[code], allowedExtensions = [], names = [].concat(maybeNameOrNames), name = names[0], buttonId = this._getButtonId(item), validationBase = this._getValidationBase(buttonId), extensionsForMessage, placeholderMatch;
+ function r(name, replacement) {
+ message = message.replace(name, replacement);
+ }
+ qq.each(validationBase.allowedExtensions, function(idx, allowedExtension) {
+ if (qq.isString(allowedExtension)) {
+ allowedExtensions.push(allowedExtension);
+ }
+ });
+ extensionsForMessage = allowedExtensions.join(", ").toLowerCase();
+ r("{file}", this._options.formatFileName(name));
+ r("{extensions}", extensionsForMessage);
+ r("{sizeLimit}", this._formatSize(validationBase.sizeLimit));
+ r("{minSizeLimit}", this._formatSize(validationBase.minSizeLimit));
+ placeholderMatch = message.match(/(\{\w+\})/g);
+ if (placeholderMatch !== null) {
+ qq.each(placeholderMatch, function(idx, placeholder) {
+ r(placeholder, names[idx]);
+ });
+ }
+ this._options.callbacks.onError(null, name, message, undefined);
+ return message;
+ },
+ _manualRetry: function(id, callback) {
+ if (this._onBeforeManualRetry(id)) {
+ this._netUploadedOrQueued++;
+ this._uploadData.setStatus(id, qq.status.UPLOAD_RETRYING);
+ if (callback) {
+ callback(id);
+ } else {
+ this._handler.retry(id);
+ }
+ return true;
+ }
+ },
+ _maybeAllComplete: function(id, status) {
+ var self = this, notFinished = this._getNotFinished();
+ if (status === qq.status.UPLOAD_SUCCESSFUL) {
+ this._succeededSinceLastAllComplete.push(id);
+ } else if (status === qq.status.UPLOAD_FAILED) {
+ this._failedSinceLastAllComplete.push(id);
+ }
+ if (notFinished === 0 && (this._succeededSinceLastAllComplete.length || this._failedSinceLastAllComplete.length)) {
+ setTimeout(function() {
+ self._onAllComplete(self._succeededSinceLastAllComplete, self._failedSinceLastAllComplete);
+ }, 0);
+ }
+ },
+ _maybeHandleIos8SafariWorkaround: function() {
+ var self = this;
+ if (this._options.workarounds.ios8SafariUploads && qq.ios800() && qq.iosSafari()) {
+ setTimeout(function() {
+ window.alert(self._options.messages.unsupportedBrowserIos8Safari);
+ }, 0);
+ throw new qq.Error(this._options.messages.unsupportedBrowserIos8Safari);
+ }
+ },
+ _maybeParseAndSendUploadError: function(id, name, response, xhr) {
+ if (!response.success) {
+ if (xhr && xhr.status !== 200 && !response.error) {
+ this._options.callbacks.onError(id, name, "XHR returned response code " + xhr.status, xhr);
+ } else {
+ var errorReason = response.error ? response.error : this._options.text.defaultResponseError;
+ this._options.callbacks.onError(id, name, errorReason, xhr);
+ }
+ }
+ },
+ _maybeProcessNextItemAfterOnValidateCallback: function(validItem, items, index, params, endpoint) {
+ var self = this;
+ if (items.length > index) {
+ if (validItem || !this._options.validation.stopOnFirstInvalidFile) {
+ setTimeout(function() {
+ var validationDescriptor = self._getValidationDescriptor(items[index]), buttonId = self._getButtonId(items[index].file), button = self._getButton(buttonId);
+ self._handleCheckedCallback({
+ name: "onValidate",
+ callback: qq.bind(self._options.callbacks.onValidate, self, validationDescriptor, button),
+ onSuccess: qq.bind(self._onValidateCallbackSuccess, self, items, index, params, endpoint),
+ onFailure: qq.bind(self._onValidateCallbackFailure, self, items, index, params, endpoint),
+ identifier: "Item '" + validationDescriptor.name + "', size: " + validationDescriptor.size
+ });
+ }, 0);
+ } else if (!validItem) {
+ for (;index < items.length; index++) {
+ self._fileOrBlobRejected(items[index].id);
+ }
+ }
+ }
+ },
+ _onAllComplete: function(successful, failed) {
+ this._totalProgress && this._totalProgress.onAllComplete(successful, failed, this._preventRetries);
+ this._options.callbacks.onAllComplete(qq.extend([], successful), qq.extend([], failed));
+ this._succeededSinceLastAllComplete = [];
+ this._failedSinceLastAllComplete = [];
+ },
+ _onAutoRetry: function(id, name, responseJSON, xhr, callback) {
+ var self = this;
+ self._preventRetries[id] = responseJSON[self._options.retry.preventRetryResponseProperty];
+ if (self._shouldAutoRetry(id, name, responseJSON)) {
+ var retryWaitPeriod = self._options.retry.autoAttemptDelay * 1e3;
+ self._maybeParseAndSendUploadError.apply(self, arguments);
+ self._options.callbacks.onAutoRetry(id, name, self._autoRetries[id]);
+ self._onBeforeAutoRetry(id, name);
+ self._uploadData.setStatus(id, qq.status.UPLOAD_RETRYING);
+ self._retryTimeouts[id] = setTimeout(function() {
+ self.log("Starting retry for " + name + "...");
+ if (callback) {
+ callback(id);
+ } else {
+ self._handler.retry(id);
+ }
+ }, retryWaitPeriod);
+ return true;
+ }
+ },
+ _onBeforeAutoRetry: function(id, name) {
+ this.log("Waiting " + this._options.retry.autoAttemptDelay + " seconds before retrying " + name + "...");
+ },
+ _onBeforeManualRetry: function(id) {
+ var itemLimit = this._currentItemLimit, fileName;
+ if (this._preventRetries[id]) {
+ this.log("Retries are forbidden for id " + id, "warn");
+ return false;
+ } else if (this._handler.isValid(id)) {
+ fileName = this.getName(id);
+ if (this._options.callbacks.onManualRetry(id, fileName) === false) {
+ return false;
+ }
+ if (itemLimit > 0 && this._netUploadedOrQueued + 1 > itemLimit) {
+ this._itemError("retryFailTooManyItems");
+ return false;
+ }
+ this.log("Retrying upload for '" + fileName + "' (id: " + id + ")...");
+ return true;
+ } else {
+ this.log("'" + id + "' is not a valid file ID", "error");
+ return false;
+ }
+ },
+ _onCancel: function(id, name) {
+ this._netUploadedOrQueued--;
+ clearTimeout(this._retryTimeouts[id]);
+ var storedItemIndex = qq.indexOf(this._storedIds, id);
+ if (!this._options.autoUpload && storedItemIndex >= 0) {
+ this._storedIds.splice(storedItemIndex, 1);
+ }
+ this._uploadData.setStatus(id, qq.status.CANCELED);
+ },
+ _onComplete: function(id, name, result, xhr) {
+ if (!result.success) {
+ this._netUploadedOrQueued--;
+ this._uploadData.setStatus(id, qq.status.UPLOAD_FAILED);
+ if (result[this._options.retry.preventRetryResponseProperty] === true) {
+ this._preventRetries[id] = true;
+ }
+ } else {
+ if (result.thumbnailUrl) {
+ this._thumbnailUrls[id] = result.thumbnailUrl;
+ }
+ this._netUploaded++;
+ this._uploadData.setStatus(id, qq.status.UPLOAD_SUCCESSFUL);
+ }
+ this._maybeParseAndSendUploadError(id, name, result, xhr);
+ return result.success ? true : false;
+ },
+ _onDelete: function(id) {
+ this._uploadData.setStatus(id, qq.status.DELETING);
+ },
+ _onDeleteComplete: function(id, xhrOrXdr, isError) {
+ var name = this.getName(id);
+ if (isError) {
+ this._handleDeleteFailed(id, xhrOrXdr);
+ } else {
+ this._handleDeleteSuccess(id);
+ }
+ },
+ _onInputChange: function(input) {
+ var fileIndex;
+ if (qq.supportedFeatures.ajaxUploading) {
+ for (fileIndex = 0; fileIndex < input.files.length; fileIndex++) {
+ this._annotateWithButtonId(input.files[fileIndex], input);
+ }
+ this.addFiles(input.files);
+ } else if (input.value.length > 0) {
+ this.addFiles(input);
+ }
+ qq.each(this._buttons, function(idx, button) {
+ button.reset();
+ });
+ },
+ _onProgress: function(id, name, loaded, total) {
+ this._totalProgress && this._totalProgress.onIndividualProgress(id, loaded, total);
+ },
+ _onSubmit: function(id, name) {},
+ _onSubmitCallbackSuccess: function(id, name) {
+ this._onSubmit.apply(this, arguments);
+ this._uploadData.setStatus(id, qq.status.SUBMITTED);
+ this._onSubmitted.apply(this, arguments);
+ if (this._options.autoUpload) {
+ this._options.callbacks.onSubmitted.apply(this, arguments);
+ this._uploadFile(id);
+ } else {
+ this._storeForLater(id);
+ this._options.callbacks.onSubmitted.apply(this, arguments);
+ }
+ },
+ _onSubmitDelete: function(id, onSuccessCallback, additionalMandatedParams) {
+ var uuid = this.getUuid(id), adjustedOnSuccessCallback;
+ if (onSuccessCallback) {
+ adjustedOnSuccessCallback = qq.bind(onSuccessCallback, this, id, uuid, additionalMandatedParams);
+ }
+ if (this._isDeletePossible()) {
+ this._handleCheckedCallback({
+ name: "onSubmitDelete",
+ callback: qq.bind(this._options.callbacks.onSubmitDelete, this, id),
+ onSuccess: adjustedOnSuccessCallback || qq.bind(this._deleteHandler.sendDelete, this, id, uuid, additionalMandatedParams),
+ identifier: id
+ });
+ return true;
+ } else {
+ this.log("Delete request ignored for ID " + id + ", delete feature is disabled or request not possible " + "due to CORS on a user agent that does not support pre-flighting.", "warn");
+ return false;
+ }
+ },
+ _onSubmitted: function(id) {},
+ _onTotalProgress: function(loaded, total) {
+ this._options.callbacks.onTotalProgress(loaded, total);
+ },
+ _onUploadPrep: function(id) {},
+ _onUpload: function(id, name) {
+ this._uploadData.setStatus(id, qq.status.UPLOADING);
+ },
+ _onUploadChunk: function(id, chunkData) {},
+ _onUploadStatusChange: function(id, oldStatus, newStatus) {
+ if (newStatus === qq.status.PAUSED) {
+ clearTimeout(this._retryTimeouts[id]);
+ }
+ },
+ _onValidateBatchCallbackFailure: function(fileWrappers) {
+ var self = this;
+ qq.each(fileWrappers, function(idx, fileWrapper) {
+ self._fileOrBlobRejected(fileWrapper.id);
+ });
+ },
+ _onValidateBatchCallbackSuccess: function(validationDescriptors, items, params, endpoint, button) {
+ var errorMessage, itemLimit = this._currentItemLimit, proposedNetFilesUploadedOrQueued = this._netUploadedOrQueued;
+ if (itemLimit === 0 || proposedNetFilesUploadedOrQueued <= itemLimit) {
+ if (items.length > 0) {
+ this._handleCheckedCallback({
+ name: "onValidate",
+ callback: qq.bind(this._options.callbacks.onValidate, this, validationDescriptors[0], button),
+ onSuccess: qq.bind(this._onValidateCallbackSuccess, this, items, 0, params, endpoint),
+ onFailure: qq.bind(this._onValidateCallbackFailure, this, items, 0, params, endpoint),
+ identifier: "Item '" + items[0].file.name + "', size: " + items[0].file.size
+ });
+ } else {
+ this._itemError("noFilesError");
+ }
+ } else {
+ this._onValidateBatchCallbackFailure(items);
+ errorMessage = this._options.messages.tooManyItemsError.replace(/\{netItems\}/g, proposedNetFilesUploadedOrQueued).replace(/\{itemLimit\}/g, itemLimit);
+ this._batchError(errorMessage);
+ }
+ },
+ _onValidateCallbackFailure: function(items, index, params, endpoint) {
+ var nextIndex = index + 1;
+ this._fileOrBlobRejected(items[index].id, items[index].file.name);
+ this._maybeProcessNextItemAfterOnValidateCallback(false, items, nextIndex, params, endpoint);
+ },
+ _onValidateCallbackSuccess: function(items, index, params, endpoint) {
+ var self = this, nextIndex = index + 1, validationDescriptor = this._getValidationDescriptor(items[index]);
+ this._validateFileOrBlobData(items[index], validationDescriptor).then(function() {
+ self._upload(items[index].id, params, endpoint);
+ self._maybeProcessNextItemAfterOnValidateCallback(true, items, nextIndex, params, endpoint);
+ }, function() {
+ self._maybeProcessNextItemAfterOnValidateCallback(false, items, nextIndex, params, endpoint);
+ });
+ },
+ _prepareItemsForUpload: function(items, params, endpoint) {
+ if (items.length === 0) {
+ this._itemError("noFilesError");
+ return;
+ }
+ var validationDescriptors = this._getValidationDescriptors(items), buttonId = this._getButtonId(items[0].file), button = this._getButton(buttonId);
+ this._handleCheckedCallback({
+ name: "onValidateBatch",
+ callback: qq.bind(this._options.callbacks.onValidateBatch, this, validationDescriptors, button),
+ onSuccess: qq.bind(this._onValidateBatchCallbackSuccess, this, validationDescriptors, items, params, endpoint, button),
+ onFailure: qq.bind(this._onValidateBatchCallbackFailure, this, items),
+ identifier: "batch validation"
+ });
+ },
+ _preventLeaveInProgress: function() {
+ var self = this;
+ this._disposeSupport.attach(window, "beforeunload", function(e) {
+ if (self.getInProgress()) {
+ e = e || window.event;
+ e.returnValue = self._options.messages.onLeave;
+ return self._options.messages.onLeave;
+ }
+ });
+ },
+ _refreshSessionData: function() {
+ var self = this, options = this._options.session;
+ if (qq.Session && this._options.session.endpoint != null) {
+ if (!this._session) {
+ qq.extend(options, {
+ cors: this._options.cors
+ });
+ options.log = qq.bind(this.log, this);
+ options.addFileRecord = qq.bind(this._addCannedFile, this);
+ this._session = new qq.Session(options);
+ }
+ setTimeout(function() {
+ self._session.refresh().then(function(response, xhrOrXdr) {
+ self._sessionRequestComplete();
+ self._options.callbacks.onSessionRequestComplete(response, true, xhrOrXdr);
+ }, function(response, xhrOrXdr) {
+ self._options.callbacks.onSessionRequestComplete(response, false, xhrOrXdr);
+ });
+ }, 0);
+ }
+ },
+ _sessionRequestComplete: function() {},
+ _setSize: function(id, newSize) {
+ this._uploadData.updateSize(id, newSize);
+ this._totalProgress && this._totalProgress.onNewSize(id);
+ },
+ _shouldAutoRetry: function(id, name, responseJSON) {
+ var uploadData = this._uploadData.retrieve({
+ id: id
+ });
+ if (!this._preventRetries[id] && this._options.retry.enableAuto && uploadData.status !== qq.status.PAUSED) {
+ if (this._autoRetries[id] === undefined) {
+ this._autoRetries[id] = 0;
+ }
+ if (this._autoRetries[id] < this._options.retry.maxAutoAttempts) {
+ this._autoRetries[id] += 1;
+ return true;
+ }
+ }
+ return false;
+ },
+ _storeForLater: function(id) {
+ this._storedIds.push(id);
+ },
+ _trackButton: function(id) {
+ var buttonId;
+ if (qq.supportedFeatures.ajaxUploading) {
+ buttonId = this._handler.getFile(id).qqButtonId;
+ } else {
+ buttonId = this._getButtonId(this._handler.getInput(id));
+ }
+ if (buttonId) {
+ this._buttonIdsForFileIds[id] = buttonId;
+ }
+ },
+ _updateFormSupportAndParams: function(formElementOrId) {
+ this._options.form.element = formElementOrId;
+ this._formSupport = qq.FormSupport && new qq.FormSupport(this._options.form, qq.bind(this.uploadStoredFiles, this), qq.bind(this.log, this));
+ if (this._formSupport && this._formSupport.attachedToForm) {
+ this._paramsStore.addReadOnly(null, this._formSupport.getFormInputsAsObject);
+ this._options.autoUpload = this._formSupport.newAutoUpload;
+ if (this._formSupport.newEndpoint) {
+ this.setEndpoint(this._formSupport.newEndpoint);
+ }
+ }
+ },
+ _upload: function(id, params, endpoint) {
+ var name = this.getName(id);
+ if (params) {
+ this.setParams(params, id);
+ }
+ if (endpoint) {
+ this.setEndpoint(endpoint, id);
+ }
+ this._handleCheckedCallback({
+ name: "onSubmit",
+ callback: qq.bind(this._options.callbacks.onSubmit, this, id, name),
+ onSuccess: qq.bind(this._onSubmitCallbackSuccess, this, id, name),
+ onFailure: qq.bind(this._fileOrBlobRejected, this, id, name),
+ identifier: id
+ });
+ },
+ _uploadFile: function(id) {
+ if (!this._handler.upload(id)) {
+ this._uploadData.setStatus(id, qq.status.QUEUED);
+ }
+ },
+ _uploadStoredFiles: function() {
+ var idToUpload, stillSubmitting, self = this;
+ while (this._storedIds.length) {
+ idToUpload = this._storedIds.shift();
+ this._uploadFile(idToUpload);
+ }
+ stillSubmitting = this.getUploads({
+ status: qq.status.SUBMITTING
+ }).length;
+ if (stillSubmitting) {
+ qq.log("Still waiting for " + stillSubmitting + " files to clear submit queue. Will re-parse stored IDs array shortly.");
+ setTimeout(function() {
+ self._uploadStoredFiles();
+ }, 1e3);
+ }
+ },
+ _validateFileOrBlobData: function(fileWrapper, validationDescriptor) {
+ var self = this, file = function() {
+ if (fileWrapper.file instanceof qq.BlobProxy) {
+ return fileWrapper.file.referenceBlob;
+ }
+ return fileWrapper.file;
+ }(), name = validationDescriptor.name, size = validationDescriptor.size, buttonId = this._getButtonId(fileWrapper.file), validationBase = this._getValidationBase(buttonId), validityChecker = new qq.Promise();
+ validityChecker.then(function() {}, function() {
+ self._fileOrBlobRejected(fileWrapper.id, name);
+ });
+ if (qq.isFileOrInput(file) && !this._isAllowedExtension(validationBase.allowedExtensions, name)) {
+ this._itemError("typeError", name, file);
+ return validityChecker.failure();
+ }
+ if (!this._options.validation.allowEmpty && size === 0) {
+ this._itemError("emptyError", name, file);
+ return validityChecker.failure();
+ }
+ if (size > 0 && validationBase.sizeLimit && size > validationBase.sizeLimit) {
+ this._itemError("sizeError", name, file);
+ return validityChecker.failure();
+ }
+ if (size > 0 && size < validationBase.minSizeLimit) {
+ this._itemError("minSizeError", name, file);
+ return validityChecker.failure();
+ }
+ if (qq.ImageValidation && qq.supportedFeatures.imagePreviews && qq.isFile(file)) {
+ new qq.ImageValidation(file, qq.bind(self.log, self)).validate(validationBase.image).then(validityChecker.success, function(errorCode) {
+ self._itemError(errorCode + "ImageError", name, file);
+ validityChecker.failure();
+ });
+ } else {
+ validityChecker.success();
+ }
+ return validityChecker;
+ },
+ _wrapCallbacks: function() {
+ var self, safeCallback, prop;
+ self = this;
+ safeCallback = function(name, callback, args) {
+ var errorMsg;
+ try {
+ return callback.apply(self, args);
+ } catch (exception) {
+ errorMsg = exception.message || exception.toString();
+ self.log("Caught exception in '" + name + "' callback - " + errorMsg, "error");
+ }
+ };
+ for (prop in this._options.callbacks) {
+ (function() {
+ var callbackName, callbackFunc;
+ callbackName = prop;
+ callbackFunc = self._options.callbacks[callbackName];
+ self._options.callbacks[callbackName] = function() {
+ return safeCallback(callbackName, callbackFunc, arguments);
+ };
+ })();
+ }
+ }
+ };
+ })();
+ (function() {
+ "use strict";
+ qq.FineUploaderBasic = function(o) {
+ var self = this;
+ this._options = {
+ debug: false,
+ button: null,
+ multiple: true,
+ maxConnections: 3,
+ disableCancelForFormUploads: false,
+ autoUpload: true,
+ request: {
+ customHeaders: {},
+ endpoint: "/server/upload",
+ filenameParam: "qqfilename",
+ forceMultipart: true,
+ inputName: "qqfile",
+ method: "POST",
+ params: {},
+ paramsInBody: true,
+ totalFileSizeName: "qqtotalfilesize",
+ uuidName: "qquuid"
+ },
+ validation: {
+ allowedExtensions: [],
+ sizeLimit: 0,
+ minSizeLimit: 0,
+ itemLimit: 0,
+ stopOnFirstInvalidFile: true,
+ acceptFiles: null,
+ image: {
+ maxHeight: 0,
+ maxWidth: 0,
+ minHeight: 0,
+ minWidth: 0
+ },
+ allowEmpty: false
+ },
+ callbacks: {
+ onSubmit: function(id, name) {},
+ onSubmitted: function(id, name) {},
+ onComplete: function(id, name, responseJSON, maybeXhr) {},
+ onAllComplete: function(successful, failed) {},
+ onCancel: function(id, name) {},
+ onUpload: function(id, name) {},
+ onUploadChunk: function(id, name, chunkData) {},
+ onUploadChunkSuccess: function(id, chunkData, responseJSON, xhr) {},
+ onResume: function(id, fileName, chunkData) {},
+ onProgress: function(id, name, loaded, total) {},
+ onTotalProgress: function(loaded, total) {},
+ onError: function(id, name, reason, maybeXhrOrXdr) {},
+ onAutoRetry: function(id, name, attemptNumber) {},
+ onManualRetry: function(id, name) {},
+ onValidateBatch: function(fileOrBlobData) {},
+ onValidate: function(fileOrBlobData) {},
+ onSubmitDelete: function(id) {},
+ onDelete: function(id) {},
+ onDeleteComplete: function(id, xhrOrXdr, isError) {},
+ onPasteReceived: function(blob) {},
+ onStatusChange: function(id, oldStatus, newStatus) {},
+ onSessionRequestComplete: function(response, success, xhrOrXdr) {}
+ },
+ messages: {
+ typeError: "{file} has an invalid extension. Valid extension(s): {extensions}.",
+ sizeError: "{file} is too large, maximum file size is {sizeLimit}.",
+ minSizeError: "{file} is too small, minimum file size is {minSizeLimit}.",
+ emptyError: "{file} is empty, please select files again without it.",
+ noFilesError: "No files to upload.",
+ tooManyItemsError: "Too many items ({netItems}) would be uploaded. Item limit is {itemLimit}.",
+ maxHeightImageError: "Image is too tall.",
+ maxWidthImageError: "Image is too wide.",
+ minHeightImageError: "Image is not tall enough.",
+ minWidthImageError: "Image is not wide enough.",
+ retryFailTooManyItems: "Retry failed - you have reached your file limit.",
+ onLeave: "The files are being uploaded, if you leave now the upload will be canceled.",
+ unsupportedBrowserIos8Safari: "Unrecoverable error - this browser does not permit file uploading of any kind due to serious bugs in iOS8 Safari. Please use iOS8 Chrome until Apple fixes these issues."
+ },
+ retry: {
+ enableAuto: false,
+ maxAutoAttempts: 3,
+ autoAttemptDelay: 5,
+ preventRetryResponseProperty: "preventRetry"
+ },
+ classes: {
+ buttonHover: "qq-upload-button-hover",
+ buttonFocus: "qq-upload-button-focus"
+ },
+ chunking: {
+ enabled: false,
+ concurrent: {
+ enabled: false
+ },
+ mandatory: false,
+ paramNames: {
+ partIndex: "qqpartindex",
+ partByteOffset: "qqpartbyteoffset",
+ chunkSize: "qqchunksize",
+ totalFileSize: "qqtotalfilesize",
+ totalParts: "qqtotalparts"
+ },
+ partSize: 2e6,
+ success: {
+ endpoint: null
+ }
+ },
+ resume: {
+ enabled: false,
+ recordsExpireIn: 7,
+ paramNames: {
+ resuming: "qqresume"
+ }
+ },
+ formatFileName: function(fileOrBlobName) {
+ return fileOrBlobName;
+ },
+ text: {
+ defaultResponseError: "Upload failure reason unknown",
+ fileInputTitle: "file input",
+ sizeSymbols: [ "kB", "MB", "GB", "TB", "PB", "EB" ]
+ },
+ deleteFile: {
+ enabled: false,
+ method: "DELETE",
+ endpoint: "/server/upload",
+ customHeaders: {},
+ params: {}
+ },
+ cors: {
+ expected: false,
+ sendCredentials: false,
+ allowXdr: false
+ },
+ blobs: {
+ defaultName: "misc_data"
+ },
+ paste: {
+ targetElement: null,
+ defaultName: "pasted_image"
+ },
+ camera: {
+ ios: false,
+ button: null
+ },
+ extraButtons: [],
+ session: {
+ endpoint: null,
+ params: {},
+ customHeaders: {},
+ refreshOnReset: true
+ },
+ form: {
+ element: "qq-form",
+ autoUpload: false,
+ interceptSubmit: true
+ },
+ scaling: {
+ customResizer: null,
+ sendOriginal: true,
+ orient: true,
+ defaultType: null,
+ defaultQuality: 80,
+ failureText: "Failed to scale",
+ includeExif: false,
+ sizes: []
+ },
+ workarounds: {
+ iosEmptyVideos: true,
+ ios8SafariUploads: true,
+ ios8BrowserCrash: false
+ }
+ };
+ qq.extend(this._options, o, true);
+ this._buttons = [];
+ this._extraButtonSpecs = {};
+ this._buttonIdsForFileIds = [];
+ this._wrapCallbacks();
+ this._disposeSupport = new qq.DisposeSupport();
+ this._storedIds = [];
+ this._autoRetries = [];
+ this._retryTimeouts = [];
+ this._preventRetries = [];
+ this._thumbnailUrls = [];
+ this._netUploadedOrQueued = 0;
+ this._netUploaded = 0;
+ this._uploadData = this._createUploadDataTracker();
+ this._initFormSupportAndParams();
+ this._customHeadersStore = this._createStore(this._options.request.customHeaders);
+ this._deleteFileCustomHeadersStore = this._createStore(this._options.deleteFile.customHeaders);
+ this._deleteFileParamsStore = this._createStore(this._options.deleteFile.params);
+ this._endpointStore = this._createStore(this._options.request.endpoint);
+ this._deleteFileEndpointStore = this._createStore(this._options.deleteFile.endpoint);
+ this._handler = this._createUploadHandler();
+ this._deleteHandler = qq.DeleteFileAjaxRequester && this._createDeleteHandler();
+ if (this._options.button) {
+ this._defaultButtonId = this._createUploadButton({
+ element: this._options.button,
+ title: this._options.text.fileInputTitle
+ }).getButtonId();
+ }
+ this._generateExtraButtonSpecs();
+ this._handleCameraAccess();
+ if (this._options.paste.targetElement) {
+ if (qq.PasteSupport) {
+ this._pasteHandler = this._createPasteHandler();
+ } else {
+ this.log("Paste support module not found", "error");
+ }
+ }
+ this._preventLeaveInProgress();
+ this._imageGenerator = qq.ImageGenerator && new qq.ImageGenerator(qq.bind(this.log, this));
+ this._refreshSessionData();
+ this._succeededSinceLastAllComplete = [];
+ this._failedSinceLastAllComplete = [];
+ this._scaler = qq.Scaler && new qq.Scaler(this._options.scaling, qq.bind(this.log, this)) || {};
+ if (this._scaler.enabled) {
+ this._customNewFileHandler = qq.bind(this._scaler.handleNewFile, this._scaler);
+ }
+ if (qq.TotalProgress && qq.supportedFeatures.progressBar) {
+ this._totalProgress = new qq.TotalProgress(qq.bind(this._onTotalProgress, this), function(id) {
+ var entry = self._uploadData.retrieve({
+ id: id
+ });
+ return entry && entry.size || 0;
+ });
+ }
+ this._currentItemLimit = this._options.validation.itemLimit;
+ };
+ qq.FineUploaderBasic.prototype = qq.basePublicApi;
+ qq.extend(qq.FineUploaderBasic.prototype, qq.basePrivateApi);
+ })();
+ qq.AjaxRequester = function(o) {
+ "use strict";
+ var log, shouldParamsBeInQueryString, queue = [], requestData = {}, options = {
+ acceptHeader: null,
+ validMethods: [ "PATCH", "POST", "PUT" ],
+ method: "POST",
+ contentType: "application/x-www-form-urlencoded",
+ maxConnections: 3,
+ customHeaders: {},
+ endpointStore: {},
+ paramsStore: {},
+ mandatedParams: {},
+ allowXRequestedWithAndCacheControl: true,
+ successfulResponseCodes: {
+ DELETE: [ 200, 202, 204 ],
+ PATCH: [ 200, 201, 202, 203, 204 ],
+ POST: [ 200, 201, 202, 203, 204 ],
+ PUT: [ 200, 201, 202, 203, 204 ],
+ GET: [ 200 ]
+ },
+ cors: {
+ expected: false,
+ sendCredentials: false
+ },
+ log: function(str, level) {},
+ onSend: function(id) {},
+ onComplete: function(id, xhrOrXdr, isError) {},
+ onProgress: null
+ };
+ qq.extend(options, o);
+ log = options.log;
+ if (qq.indexOf(options.validMethods, options.method) < 0) {
+ throw new Error("'" + options.method + "' is not a supported method for this type of request!");
+ }
+ function isSimpleMethod() {
+ return qq.indexOf([ "GET", "POST", "HEAD" ], options.method) >= 0;
+ }
+ function containsNonSimpleHeaders(headers) {
+ var containsNonSimple = false;
+ qq.each(containsNonSimple, function(idx, header) {
+ if (qq.indexOf([ "Accept", "Accept-Language", "Content-Language", "Content-Type" ], header) < 0) {
+ containsNonSimple = true;
+ return false;
+ }
+ });
+ return containsNonSimple;
+ }
+ function isXdr(xhr) {
+ return options.cors.expected && xhr.withCredentials === undefined;
+ }
+ function getCorsAjaxTransport() {
+ var xhrOrXdr;
+ if (window.XMLHttpRequest || window.ActiveXObject) {
+ xhrOrXdr = qq.createXhrInstance();
+ if (xhrOrXdr.withCredentials === undefined) {
+ xhrOrXdr = new XDomainRequest();
+ xhrOrXdr.onload = function() {};
+ xhrOrXdr.onerror = function() {};
+ xhrOrXdr.ontimeout = function() {};
+ xhrOrXdr.onprogress = function() {};
+ }
+ }
+ return xhrOrXdr;
+ }
+ function getXhrOrXdr(id, suppliedXhr) {
+ var xhrOrXdr = requestData[id].xhr;
+ if (!xhrOrXdr) {
+ if (suppliedXhr) {
+ xhrOrXdr = suppliedXhr;
+ } else {
+ if (options.cors.expected) {
+ xhrOrXdr = getCorsAjaxTransport();
+ } else {
+ xhrOrXdr = qq.createXhrInstance();
+ }
+ }
+ requestData[id].xhr = xhrOrXdr;
+ }
+ return xhrOrXdr;
+ }
+ function dequeue(id) {
+ var i = qq.indexOf(queue, id), max = options.maxConnections, nextId;
+ delete requestData[id];
+ queue.splice(i, 1);
+ if (queue.length >= max && i < max) {
+ nextId = queue[max - 1];
+ sendRequest(nextId);
+ }
+ }
+ function onComplete(id, xdrError) {
+ var xhr = getXhrOrXdr(id), method = options.method, isError = xdrError === true;
+ dequeue(id);
+ if (isError) {
+ log(method + " request for " + id + " has failed", "error");
+ } else if (!isXdr(xhr) && !isResponseSuccessful(xhr.status)) {
+ isError = true;
+ log(method + " request for " + id + " has failed - response code " + xhr.status, "error");
+ }
+ options.onComplete(id, xhr, isError);
+ }
+ function getParams(id) {
+ var onDemandParams = requestData[id].additionalParams, mandatedParams = options.mandatedParams, params;
+ if (options.paramsStore.get) {
+ params = options.paramsStore.get(id);
+ }
+ if (onDemandParams) {
+ qq.each(onDemandParams, function(name, val) {
+ params = params || {};
+ params[name] = val;
+ });
+ }
+ if (mandatedParams) {
+ qq.each(mandatedParams, function(name, val) {
+ params = params || {};
+ params[name] = val;
+ });
+ }
+ return params;
+ }
+ function sendRequest(id, optXhr) {
+ var xhr = getXhrOrXdr(id, optXhr), method = options.method, params = getParams(id), payload = requestData[id].payload, url;
+ options.onSend(id);
+ url = createUrl(id, params, requestData[id].additionalQueryParams);
+ if (isXdr(xhr)) {
+ xhr.onload = getXdrLoadHandler(id);
+ xhr.onerror = getXdrErrorHandler(id);
+ } else {
+ xhr.onreadystatechange = getXhrReadyStateChangeHandler(id);
+ }
+ registerForUploadProgress(id);
+ xhr.open(method, url, true);
+ if (options.cors.expected && options.cors.sendCredentials && !isXdr(xhr)) {
+ xhr.withCredentials = true;
+ }
+ setHeaders(id);
+ log("Sending " + method + " request for " + id);
+ if (payload) {
+ xhr.send(payload);
+ } else if (shouldParamsBeInQueryString || !params) {
+ xhr.send();
+ } else if (params && options.contentType && options.contentType.toLowerCase().indexOf("application/x-www-form-urlencoded") >= 0) {
+ xhr.send(qq.obj2url(params, ""));
+ } else if (params && options.contentType && options.contentType.toLowerCase().indexOf("application/json") >= 0) {
+ xhr.send(JSON.stringify(params));
+ } else {
+ xhr.send(params);
+ }
+ return xhr;
+ }
+ function createUrl(id, params, additionalQueryParams) {
+ var endpoint = options.endpointStore.get(id), addToPath = requestData[id].addToPath;
+ if (addToPath != undefined) {
+ endpoint += "/" + addToPath;
+ }
+ if (shouldParamsBeInQueryString && params) {
+ endpoint = qq.obj2url(params, endpoint);
+ }
+ if (additionalQueryParams) {
+ endpoint = qq.obj2url(additionalQueryParams, endpoint);
+ }
+ return endpoint;
+ }
+ function getXhrReadyStateChangeHandler(id) {
+ return function() {
+ if (getXhrOrXdr(id).readyState === 4) {
+ onComplete(id);
+ }
+ };
+ }
+ function registerForUploadProgress(id) {
+ var onProgress = options.onProgress;
+ if (onProgress) {
+ getXhrOrXdr(id).upload.onprogress = function(e) {
+ if (e.lengthComputable) {
+ onProgress(id, e.loaded, e.total);
+ }
+ };
+ }
+ }
+ function getXdrLoadHandler(id) {
+ return function() {
+ onComplete(id);
+ };
+ }
+ function getXdrErrorHandler(id) {
+ return function() {
+ onComplete(id, true);
+ };
+ }
+ function setHeaders(id) {
+ var xhr = getXhrOrXdr(id), customHeaders = options.customHeaders, onDemandHeaders = requestData[id].additionalHeaders || {}, method = options.method, allHeaders = {};
+ if (!isXdr(xhr)) {
+ options.acceptHeader && xhr.setRequestHeader("Accept", options.acceptHeader);
+ if (options.allowXRequestedWithAndCacheControl) {
+ if (!options.cors.expected || (!isSimpleMethod() || containsNonSimpleHeaders(customHeaders))) {
+ xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+ xhr.setRequestHeader("Cache-Control", "no-cache");
+ }
+ }
+ if (options.contentType && (method === "POST" || method === "PUT")) {
+ xhr.setRequestHeader("Content-Type", options.contentType);
+ }
+ qq.extend(allHeaders, qq.isFunction(customHeaders) ? customHeaders(id) : customHeaders);
+ qq.extend(allHeaders, onDemandHeaders);
+ qq.each(allHeaders, function(name, val) {
+ xhr.setRequestHeader(name, val);
+ });
+ }
+ }
+ function isResponseSuccessful(responseCode) {
+ return qq.indexOf(options.successfulResponseCodes[options.method], responseCode) >= 0;
+ }
+ function prepareToSend(id, optXhr, addToPath, additionalParams, additionalQueryParams, additionalHeaders, payload) {
+ requestData[id] = {
+ addToPath: addToPath,
+ additionalParams: additionalParams,
+ additionalQueryParams: additionalQueryParams,
+ additionalHeaders: additionalHeaders,
+ payload: payload
+ };
+ var len = queue.push(id);
+ if (len <= options.maxConnections) {
+ return sendRequest(id, optXhr);
+ }
+ }
+ shouldParamsBeInQueryString = options.method === "GET" || options.method === "DELETE";
+ qq.extend(this, {
+ initTransport: function(id) {
+ var path, params, headers, payload, cacheBuster, additionalQueryParams;
+ return {
+ withPath: function(appendToPath) {
+ path = appendToPath;
+ return this;
+ },
+ withParams: function(additionalParams) {
+ params = additionalParams;
+ return this;
+ },
+ withQueryParams: function(_additionalQueryParams_) {
+ additionalQueryParams = _additionalQueryParams_;
+ return this;
+ },
+ withHeaders: function(additionalHeaders) {
+ headers = additionalHeaders;
+ return this;
+ },
+ withPayload: function(thePayload) {
+ payload = thePayload;
+ return this;
+ },
+ withCacheBuster: function() {
+ cacheBuster = true;
+ return this;
+ },
+ send: function(optXhr) {
+ if (cacheBuster && qq.indexOf([ "GET", "DELETE" ], options.method) >= 0) {
+ params.qqtimestamp = new Date().getTime();
+ }
+ return prepareToSend(id, optXhr, path, params, additionalQueryParams, headers, payload);
+ }
+ };
+ },
+ canceled: function(id) {
+ dequeue(id);
+ }
+ });
+ };
+ qq.UploadHandler = function(spec) {
+ "use strict";
+ var proxy = spec.proxy, fileState = {}, onCancel = proxy.onCancel, getName = proxy.getName;
+ qq.extend(this, {
+ add: function(id, fileItem) {
+ fileState[id] = fileItem;
+ fileState[id].temp = {};
+ },
+ cancel: function(id) {
+ var self = this, cancelFinalizationEffort = new qq.Promise(), onCancelRetVal = onCancel(id, getName(id), cancelFinalizationEffort);
+ onCancelRetVal.then(function() {
+ if (self.isValid(id)) {
+ fileState[id].canceled = true;
+ self.expunge(id);
+ }
+ cancelFinalizationEffort.success();
+ });
+ },
+ expunge: function(id) {
+ delete fileState[id];
+ },
+ getThirdPartyFileId: function(id) {
+ return fileState[id].key;
+ },
+ isValid: function(id) {
+ return fileState[id] !== undefined;
+ },
+ reset: function() {
+ fileState = {};
+ },
+ _getFileState: function(id) {
+ return fileState[id];
+ },
+ _setThirdPartyFileId: function(id, thirdPartyFileId) {
+ fileState[id].key = thirdPartyFileId;
+ },
+ _wasCanceled: function(id) {
+ return !!fileState[id].canceled;
+ }
+ });
+ };
+ qq.UploadHandlerController = function(o, namespace) {
+ "use strict";
+ var controller = this, chunkingPossible = false, concurrentChunkingPossible = false, chunking, preventRetryResponse, log, handler, options = {
+ paramsStore: {},
+ maxConnections: 3,
+ chunking: {
+ enabled: false,
+ multiple: {
+ enabled: false
+ }
+ },
+ log: function(str, level) {},
+ onProgress: function(id, fileName, loaded, total) {},
+ onComplete: function(id, fileName, response, xhr) {},
+ onCancel: function(id, fileName) {},
+ onUploadPrep: function(id) {},
+ onUpload: function(id, fileName) {},
+ onUploadChunk: function(id, fileName, chunkData) {},
+ onUploadChunkSuccess: function(id, chunkData, response, xhr) {},
+ onAutoRetry: function(id, fileName, response, xhr) {},
+ onResume: function(id, fileName, chunkData) {},
+ onUuidChanged: function(id, newUuid) {},
+ getName: function(id) {},
+ setSize: function(id, newSize) {},
+ isQueued: function(id) {},
+ getIdsInProxyGroup: function(id) {},
+ getIdsInBatch: function(id) {}
+ }, chunked = {
+ done: function(id, chunkIdx, response, xhr) {
+ var chunkData = handler._getChunkData(id, chunkIdx);
+ handler._getFileState(id).attemptingResume = false;
+ delete handler._getFileState(id).temp.chunkProgress[chunkIdx];
+ handler._getFileState(id).loaded += chunkData.size;
+ options.onUploadChunkSuccess(id, handler._getChunkDataForCallback(chunkData), response, xhr);
+ },
+ finalize: function(id) {
+ var size = options.getSize(id), name = options.getName(id);
+ log("All chunks have been uploaded for " + id + " - finalizing....");
+ handler.finalizeChunks(id).then(function(response, xhr) {
+ log("Finalize successful for " + id);
+ var normaizedResponse = upload.normalizeResponse(response, true);
+ options.onProgress(id, name, size, size);
+ handler._maybeDeletePersistedChunkData(id);
+ upload.cleanup(id, normaizedResponse, xhr);
+ }, function(response, xhr) {
+ var normaizedResponse = upload.normalizeResponse(response, false);
+ log("Problem finalizing chunks for file ID " + id + " - " + normaizedResponse.error, "error");
+ if (normaizedResponse.reset) {
+ chunked.reset(id);
+ }
+ if (!options.onAutoRetry(id, name, normaizedResponse, xhr)) {
+ upload.cleanup(id, normaizedResponse, xhr);
+ }
+ });
+ },
+ handleFailure: function(chunkIdx, id, response, xhr) {
+ var name = options.getName(id);
+ log("Chunked upload request failed for " + id + ", chunk " + chunkIdx);
+ handler.clearCachedChunk(id, chunkIdx);
+ var responseToReport = upload.normalizeResponse(response, false), inProgressIdx;
+ if (responseToReport.reset) {
+ chunked.reset(id);
+ } else {
+ inProgressIdx = qq.indexOf(handler._getFileState(id).chunking.inProgress, chunkIdx);
+ if (inProgressIdx >= 0) {
+ handler._getFileState(id).chunking.inProgress.splice(inProgressIdx, 1);
+ handler._getFileState(id).chunking.remaining.unshift(chunkIdx);
+ }
+ }
+ if (!handler._getFileState(id).temp.ignoreFailure) {
+ if (concurrentChunkingPossible) {
+ handler._getFileState(id).temp.ignoreFailure = true;
+ log(qq.format("Going to attempt to abort these chunks: {}. These are currently in-progress: {}.", JSON.stringify(Object.keys(handler._getXhrs(id))), JSON.stringify(handler._getFileState(id).chunking.inProgress)));
+ qq.each(handler._getXhrs(id), function(ckid, ckXhr) {
+ log(qq.format("Attempting to abort file {}.{}. XHR readyState {}. ", id, ckid, ckXhr.readyState));
+ ckXhr.abort();
+ ckXhr._cancelled = true;
+ });
+ handler.moveInProgressToRemaining(id);
+ connectionManager.free(id, true);
+ }
+ if (!options.onAutoRetry(id, name, responseToReport, xhr)) {
+ upload.cleanup(id, responseToReport, xhr);
+ }
+ }
+ },
+ hasMoreParts: function(id) {
+ return !!handler._getFileState(id).chunking.remaining.length;
+ },
+ nextPart: function(id) {
+ var nextIdx = handler._getFileState(id).chunking.remaining.shift();
+ if (nextIdx >= handler._getTotalChunks(id)) {
+ nextIdx = null;
+ }
+ return nextIdx;
+ },
+ reset: function(id) {
+ log("Server or callback has ordered chunking effort to be restarted on next attempt for item ID " + id, "error");
+ handler._maybeDeletePersistedChunkData(id);
+ handler.reevaluateChunking(id);
+ handler._getFileState(id).loaded = 0;
+ },
+ sendNext: function(id) {
+ var size = options.getSize(id), name = options.getName(id), chunkIdx = chunked.nextPart(id), chunkData = handler._getChunkData(id, chunkIdx), resuming = handler._getFileState(id).attemptingResume, inProgressChunks = handler._getFileState(id).chunking.inProgress || [];
+ if (handler._getFileState(id).loaded == null) {
+ handler._getFileState(id).loaded = 0;
+ }
+ if (resuming && options.onResume(id, name, chunkData) === false) {
+ chunked.reset(id);
+ chunkIdx = chunked.nextPart(id);
+ chunkData = handler._getChunkData(id, chunkIdx);
+ resuming = false;
+ }
+ if (chunkIdx == null && inProgressChunks.length === 0) {
+ chunked.finalize(id);
+ } else {
+ log(qq.format("Sending chunked upload request for item {}.{}, bytes {}-{} of {}.", id, chunkIdx, chunkData.start + 1, chunkData.end, size));
+ options.onUploadChunk(id, name, handler._getChunkDataForCallback(chunkData));
+ inProgressChunks.push(chunkIdx);
+ handler._getFileState(id).chunking.inProgress = inProgressChunks;
+ if (concurrentChunkingPossible) {
+ connectionManager.open(id, chunkIdx);
+ }
+ if (concurrentChunkingPossible && connectionManager.available() && handler._getFileState(id).chunking.remaining.length) {
+ chunked.sendNext(id);
+ }
+ if (chunkData.blob.size === 0) {
+ log(qq.format("Chunk {} for file {} will not be uploaded, zero sized chunk.", chunkIdx, id), "error");
+ chunked.handleFailure(chunkIdx, id, "File is no longer available", null);
+ } else {
+ handler.uploadChunk(id, chunkIdx, resuming).then(function success(response, xhr) {
+ log("Chunked upload request succeeded for " + id + ", chunk " + chunkIdx);
+ handler.clearCachedChunk(id, chunkIdx);
+ var inProgressChunks = handler._getFileState(id).chunking.inProgress || [], responseToReport = upload.normalizeResponse(response, true), inProgressChunkIdx = qq.indexOf(inProgressChunks, chunkIdx);
+ log(qq.format("Chunk {} for file {} uploaded successfully.", chunkIdx, id));
+ chunked.done(id, chunkIdx, responseToReport, xhr);
+ if (inProgressChunkIdx >= 0) {
+ inProgressChunks.splice(inProgressChunkIdx, 1);
+ }
+ handler._maybePersistChunkedState(id);
+ if (!chunked.hasMoreParts(id) && inProgressChunks.length === 0) {
+ chunked.finalize(id);
+ } else if (chunked.hasMoreParts(id)) {
+ chunked.sendNext(id);
+ } else {
+ log(qq.format("File ID {} has no more chunks to send and these chunk indexes are still marked as in-progress: {}", id, JSON.stringify(inProgressChunks)));
+ }
+ }, function failure(response, xhr) {
+ chunked.handleFailure(chunkIdx, id, response, xhr);
+ }).done(function() {
+ handler.clearXhr(id, chunkIdx);
+ });
+ }
+ }
+ }
+ }, connectionManager = {
+ _open: [],
+ _openChunks: {},
+ _waiting: [],
+ available: function() {
+ var max = options.maxConnections, openChunkEntriesCount = 0, openChunksCount = 0;
+ qq.each(connectionManager._openChunks, function(fileId, openChunkIndexes) {
+ openChunkEntriesCount++;
+ openChunksCount += openChunkIndexes.length;
+ });
+ return max - (connectionManager._open.length - openChunkEntriesCount + openChunksCount);
+ },
+ free: function(id, dontAllowNext) {
+ var allowNext = !dontAllowNext, waitingIndex = qq.indexOf(connectionManager._waiting, id), connectionsIndex = qq.indexOf(connectionManager._open, id), nextId;
+ delete connectionManager._openChunks[id];
+ if (upload.getProxyOrBlob(id) instanceof qq.BlobProxy) {
+ log("Generated blob upload has ended for " + id + ", disposing generated blob.");
+ delete handler._getFileState(id).file;
+ }
+ if (waitingIndex >= 0) {
+ connectionManager._waiting.splice(waitingIndex, 1);
+ } else if (allowNext && connectionsIndex >= 0) {
+ connectionManager._open.splice(connectionsIndex, 1);
+ nextId = connectionManager._waiting.shift();
+ if (nextId >= 0) {
+ connectionManager._open.push(nextId);
+ upload.start(nextId);
+ }
+ }
+ },
+ getWaitingOrConnected: function() {
+ var waitingOrConnected = [];
+ qq.each(connectionManager._openChunks, function(fileId, chunks) {
+ if (chunks && chunks.length) {
+ waitingOrConnected.push(parseInt(fileId));
+ }
+ });
+ qq.each(connectionManager._open, function(idx, fileId) {
+ if (!connectionManager._openChunks[fileId]) {
+ waitingOrConnected.push(parseInt(fileId));
+ }
+ });
+ waitingOrConnected = waitingOrConnected.concat(connectionManager._waiting);
+ return waitingOrConnected;
+ },
+ isUsingConnection: function(id) {
+ return qq.indexOf(connectionManager._open, id) >= 0;
+ },
+ open: function(id, chunkIdx) {
+ if (chunkIdx == null) {
+ connectionManager._waiting.push(id);
+ }
+ if (connectionManager.available()) {
+ if (chunkIdx == null) {
+ connectionManager._waiting.pop();
+ connectionManager._open.push(id);
+ } else {
+ (function() {
+ var openChunksEntry = connectionManager._openChunks[id] || [];
+ openChunksEntry.push(chunkIdx);
+ connectionManager._openChunks[id] = openChunksEntry;
+ })();
+ }
+ return true;
+ }
+ return false;
+ },
+ reset: function() {
+ connectionManager._waiting = [];
+ connectionManager._open = [];
+ }
+ }, simple = {
+ send: function(id, name) {
+ handler._getFileState(id).loaded = 0;
+ log("Sending simple upload request for " + id);
+ handler.uploadFile(id).then(function(response, optXhr) {
+ log("Simple upload request succeeded for " + id);
+ var responseToReport = upload.normalizeResponse(response, true), size = options.getSize(id);
+ options.onProgress(id, name, size, size);
+ upload.maybeNewUuid(id, responseToReport);
+ upload.cleanup(id, responseToReport, optXhr);
+ }, function(response, optXhr) {
+ log("Simple upload request failed for " + id);
+ var responseToReport = upload.normalizeResponse(response, false);
+ if (!options.onAutoRetry(id, name, responseToReport, optXhr)) {
+ upload.cleanup(id, responseToReport, optXhr);
+ }
+ });
+ }
+ }, upload = {
+ cancel: function(id) {
+ log("Cancelling " + id);
+ options.paramsStore.remove(id);
+ connectionManager.free(id);
+ },
+ cleanup: function(id, response, optXhr) {
+ var name = options.getName(id);
+ options.onComplete(id, name, response, optXhr);
+ if (handler._getFileState(id)) {
+ handler._clearXhrs && handler._clearXhrs(id);
+ }
+ connectionManager.free(id);
+ },
+ getProxyOrBlob: function(id) {
+ return handler.getProxy && handler.getProxy(id) || handler.getFile && handler.getFile(id);
+ },
+ initHandler: function() {
+ var handlerType = namespace ? qq[namespace] : qq.traditional, handlerModuleSubtype = qq.supportedFeatures.ajaxUploading ? "Xhr" : "Form";
+ handler = new handlerType[handlerModuleSubtype + "UploadHandler"](options, {
+ getDataByUuid: options.getDataByUuid,
+ getName: options.getName,
+ getSize: options.getSize,
+ getUuid: options.getUuid,
+ log: log,
+ onCancel: options.onCancel,
+ onProgress: options.onProgress,
+ onUuidChanged: options.onUuidChanged
+ });
+ if (handler._removeExpiredChunkingRecords) {
+ handler._removeExpiredChunkingRecords();
+ }
+ },
+ isDeferredEligibleForUpload: function(id) {
+ return options.isQueued(id);
+ },
+ maybeDefer: function(id, blob) {
+ if (blob && !handler.getFile(id) && blob instanceof qq.BlobProxy) {
+ options.onUploadPrep(id);
+ log("Attempting to generate a blob on-demand for " + id);
+ blob.create().then(function(generatedBlob) {
+ log("Generated an on-demand blob for " + id);
+ handler.updateBlob(id, generatedBlob);
+ options.setSize(id, generatedBlob.size);
+ handler.reevaluateChunking(id);
+ upload.maybeSendDeferredFiles(id);
+ }, function(errorMessage) {
+ var errorResponse = {};
+ if (errorMessage) {
+ errorResponse.error = errorMessage;
+ }
+ log(qq.format("Failed to generate blob for ID {}. Error message: {}.", id, errorMessage), "error");
+ options.onComplete(id, options.getName(id), qq.extend(errorResponse, preventRetryResponse), null);
+ upload.maybeSendDeferredFiles(id);
+ connectionManager.free(id);
+ });
+ } else {
+ return upload.maybeSendDeferredFiles(id);
+ }
+ return false;
+ },
+ maybeSendDeferredFiles: function(id) {
+ var idsInGroup = options.getIdsInProxyGroup(id), uploadedThisId = false;
+ if (idsInGroup && idsInGroup.length) {
+ log("Maybe ready to upload proxy group file " + id);
+ qq.each(idsInGroup, function(idx, idInGroup) {
+ if (upload.isDeferredEligibleForUpload(idInGroup) && !!handler.getFile(idInGroup)) {
+ uploadedThisId = idInGroup === id;
+ upload.now(idInGroup);
+ } else if (upload.isDeferredEligibleForUpload(idInGroup)) {
+ return false;
+ }
+ });
+ } else {
+ uploadedThisId = true;
+ upload.now(id);
+ }
+ return uploadedThisId;
+ },
+ maybeNewUuid: function(id, response) {
+ if (response.newUuid !== undefined) {
+ options.onUuidChanged(id, response.newUuid);
+ }
+ },
+ normalizeResponse: function(originalResponse, successful) {
+ var response = originalResponse;
+ if (!qq.isObject(originalResponse)) {
+ response = {};
+ if (qq.isString(originalResponse) && !successful) {
+ response.error = originalResponse;
+ }
+ }
+ response.success = successful;
+ return response;
+ },
+ now: function(id) {
+ var name = options.getName(id);
+ if (!controller.isValid(id)) {
+ throw new qq.Error(id + " is not a valid file ID to upload!");
+ }
+ options.onUpload(id, name);
+ if (chunkingPossible && handler._shouldChunkThisFile(id)) {
+ chunked.sendNext(id);
+ } else {
+ simple.send(id, name);
+ }
+ },
+ start: function(id) {
+ var blobToUpload = upload.getProxyOrBlob(id);
+ if (blobToUpload) {
+ return upload.maybeDefer(id, blobToUpload);
+ } else {
+ upload.now(id);
+ return true;
+ }
+ }
+ };
+ qq.extend(this, {
+ add: function(id, file) {
+ handler.add.apply(this, arguments);
+ },
+ upload: function(id) {
+ if (connectionManager.open(id)) {
+ return upload.start(id);
+ }
+ return false;
+ },
+ retry: function(id) {
+ if (concurrentChunkingPossible) {
+ handler._getFileState(id).temp.ignoreFailure = false;
+ }
+ if (connectionManager.isUsingConnection(id)) {
+ return upload.start(id);
+ } else {
+ return controller.upload(id);
+ }
+ },
+ cancel: function(id) {
+ var cancelRetVal = handler.cancel(id);
+ if (qq.isGenericPromise(cancelRetVal)) {
+ cancelRetVal.then(function() {
+ upload.cancel(id);
+ });
+ } else if (cancelRetVal !== false) {
+ upload.cancel(id);
+ }
+ },
+ cancelAll: function() {
+ var waitingOrConnected = connectionManager.getWaitingOrConnected(), i;
+ if (waitingOrConnected.length) {
+ for (i = waitingOrConnected.length - 1; i >= 0; i--) {
+ controller.cancel(waitingOrConnected[i]);
+ }
+ }
+ connectionManager.reset();
+ },
+ getFile: function(id) {
+ if (handler.getProxy && handler.getProxy(id)) {
+ return handler.getProxy(id).referenceBlob;
+ }
+ return handler.getFile && handler.getFile(id);
+ },
+ isProxied: function(id) {
+ return !!(handler.getProxy && handler.getProxy(id));
+ },
+ getInput: function(id) {
+ if (handler.getInput) {
+ return handler.getInput(id);
+ }
+ },
+ reset: function() {
+ log("Resetting upload handler");
+ controller.cancelAll();
+ connectionManager.reset();
+ handler.reset();
+ },
+ expunge: function(id) {
+ if (controller.isValid(id)) {
+ return handler.expunge(id);
+ }
+ },
+ isValid: function(id) {
+ return handler.isValid(id);
+ },
+ getResumableFilesData: function() {
+ if (handler.getResumableFilesData) {
+ return handler.getResumableFilesData();
+ }
+ return [];
+ },
+ getThirdPartyFileId: function(id) {
+ if (controller.isValid(id)) {
+ return handler.getThirdPartyFileId(id);
+ }
+ },
+ pause: function(id) {
+ if (controller.isResumable(id) && handler.pause && controller.isValid(id) && handler.pause(id)) {
+ connectionManager.free(id);
+ handler.moveInProgressToRemaining(id);
+ return true;
+ }
+ return false;
+ },
+ isResumable: function(id) {
+ return !!handler.isResumable && handler.isResumable(id);
+ }
+ });
+ qq.extend(options, o);
+ log = options.log;
+ chunkingPossible = options.chunking.enabled && qq.supportedFeatures.chunking;
+ concurrentChunkingPossible = chunkingPossible && options.chunking.concurrent.enabled;
+ preventRetryResponse = function() {
+ var response = {};
+ response[options.preventRetryParam] = true;
+ return response;
+ }();
+ upload.initHandler();
+ };
+ qq.WindowReceiveMessage = function(o) {
+ "use strict";
+ var options = {
+ log: function(message, level) {}
+ }, callbackWrapperDetachers = {};
+ qq.extend(options, o);
+ qq.extend(this, {
+ receiveMessage: function(id, callback) {
+ var onMessageCallbackWrapper = function(event) {
+ callback(event.data);
+ };
+ if (window.postMessage) {
+ callbackWrapperDetachers[id] = qq(window).attach("message", onMessageCallbackWrapper);
+ } else {
+ log("iframe message passing not supported in this browser!", "error");
+ }
+ },
+ stopReceivingMessages: function(id) {
+ if (window.postMessage) {
+ var detacher = callbackWrapperDetachers[id];
+ if (detacher) {
+ detacher();
+ }
+ }
+ }
+ });
+ };
+ qq.FormUploadHandler = function(spec) {
+ "use strict";
+ var options = spec.options, handler = this, proxy = spec.proxy, formHandlerInstanceId = qq.getUniqueId(), onloadCallbacks = {}, detachLoadEvents = {}, postMessageCallbackTimers = {}, isCors = options.isCors, inputName = options.inputName, getUuid = proxy.getUuid, log = proxy.log, corsMessageReceiver = new qq.WindowReceiveMessage({
+ log: log
+ });
+ function expungeFile(id) {
+ delete detachLoadEvents[id];
+ if (isCors) {
+ clearTimeout(postMessageCallbackTimers[id]);
+ delete postMessageCallbackTimers[id];
+ corsMessageReceiver.stopReceivingMessages(id);
+ }
+ var iframe = document.getElementById(handler._getIframeName(id));
+ if (iframe) {
+ iframe.setAttribute("src", "javascript:false;");
+ qq(iframe).remove();
+ }
+ }
+ function getFileIdForIframeName(iframeName) {
+ return iframeName.split("_")[0];
+ }
+ function initIframeForUpload(name) {
+ var iframe = qq.toElement("");
+ iframe.setAttribute("id", name);
+ iframe.style.display = "none";
+ document.body.appendChild(iframe);
+ return iframe;
+ }
+ function registerPostMessageCallback(iframe, callback) {
+ var iframeName = iframe.id, fileId = getFileIdForIframeName(iframeName), uuid = getUuid(fileId);
+ onloadCallbacks[uuid] = callback;
+ detachLoadEvents[fileId] = qq(iframe).attach("load", function() {
+ if (handler.getInput(fileId)) {
+ log("Received iframe load event for CORS upload request (iframe name " + iframeName + ")");
+ postMessageCallbackTimers[iframeName] = setTimeout(function() {
+ var errorMessage = "No valid message received from loaded iframe for iframe name " + iframeName;
+ log(errorMessage, "error");
+ callback({
+ error: errorMessage
+ });
+ }, 1e3);
+ }
+ });
+ corsMessageReceiver.receiveMessage(iframeName, function(message) {
+ log("Received the following window message: '" + message + "'");
+ var fileId = getFileIdForIframeName(iframeName), response = handler._parseJsonResponse(message), uuid = response.uuid, onloadCallback;
+ if (uuid && onloadCallbacks[uuid]) {
+ log("Handling response for iframe name " + iframeName);
+ clearTimeout(postMessageCallbackTimers[iframeName]);
+ delete postMessageCallbackTimers[iframeName];
+ handler._detachLoadEvent(iframeName);
+ onloadCallback = onloadCallbacks[uuid];
+ delete onloadCallbacks[uuid];
+ corsMessageReceiver.stopReceivingMessages(iframeName);
+ onloadCallback(response);
+ } else if (!uuid) {
+ log("'" + message + "' does not contain a UUID - ignoring.");
+ }
+ });
+ }
+ qq.extend(this, new qq.UploadHandler(spec));
+ qq.override(this, function(super_) {
+ return {
+ add: function(id, fileInput) {
+ super_.add(id, {
+ input: fileInput
+ });
+ fileInput.setAttribute("name", inputName);
+ if (fileInput.parentNode) {
+ qq(fileInput).remove();
+ }
+ },
+ expunge: function(id) {
+ expungeFile(id);
+ super_.expunge(id);
+ },
+ isValid: function(id) {
+ return super_.isValid(id) && handler._getFileState(id).input !== undefined;
+ }
+ };
+ });
+ qq.extend(this, {
+ getInput: function(id) {
+ return handler._getFileState(id).input;
+ },
+ _attachLoadEvent: function(iframe, callback) {
+ var responseDescriptor;
+ if (isCors) {
+ registerPostMessageCallback(iframe, callback);
+ } else {
+ detachLoadEvents[iframe.id] = qq(iframe).attach("load", function() {
+ log("Received response for " + iframe.id);
+ if (!iframe.parentNode) {
+ return;
+ }
+ try {
+ if (iframe.contentDocument && iframe.contentDocument.body && iframe.contentDocument.body.innerHTML == "false") {
+ return;
+ }
+ } catch (error) {
+ log("Error when attempting to access iframe during handling of upload response (" + error.message + ")", "error");
+ responseDescriptor = {
+ success: false
+ };
+ }
+ callback(responseDescriptor);
+ });
+ }
+ },
+ _createIframe: function(id) {
+ var iframeName = handler._getIframeName(id);
+ return initIframeForUpload(iframeName);
+ },
+ _detachLoadEvent: function(id) {
+ if (detachLoadEvents[id] !== undefined) {
+ detachLoadEvents[id]();
+ delete detachLoadEvents[id];
+ }
+ },
+ _getIframeName: function(fileId) {
+ return fileId + "_" + formHandlerInstanceId;
+ },
+ _initFormForUpload: function(spec) {
+ var method = spec.method, endpoint = spec.endpoint, params = spec.params, paramsInBody = spec.paramsInBody, targetName = spec.targetName, form = qq.toElement(""), url = endpoint;
+ if (paramsInBody) {
+ qq.obj2Inputs(params, form);
+ } else {
+ url = qq.obj2url(params, endpoint);
+ }
+ form.setAttribute("action", url);
+ form.setAttribute("target", targetName);
+ form.style.display = "none";
+ document.body.appendChild(form);
+ return form;
+ },
+ _parseJsonResponse: function(innerHtmlOrMessage) {
+ var response = {};
+ try {
+ response = qq.parseJson(innerHtmlOrMessage);
+ } catch (error) {
+ log("Error when attempting to parse iframe upload response (" + error.message + ")", "error");
+ }
+ return response;
+ }
+ });
+ };
+ qq.XhrUploadHandler = function(spec) {
+ "use strict";
+ var handler = this, namespace = spec.options.namespace, proxy = spec.proxy, chunking = spec.options.chunking, resume = spec.options.resume, chunkFiles = chunking && spec.options.chunking.enabled && qq.supportedFeatures.chunking, resumeEnabled = resume && spec.options.resume.enabled && chunkFiles && qq.supportedFeatures.resume, getName = proxy.getName, getSize = proxy.getSize, getUuid = proxy.getUuid, getEndpoint = proxy.getEndpoint, getDataByUuid = proxy.getDataByUuid, onUuidChanged = proxy.onUuidChanged, onProgress = proxy.onProgress, log = proxy.log;
+ function abort(id) {
+ qq.each(handler._getXhrs(id), function(xhrId, xhr) {
+ var ajaxRequester = handler._getAjaxRequester(id, xhrId);
+ xhr.onreadystatechange = null;
+ xhr.upload.onprogress = null;
+ xhr.abort();
+ ajaxRequester && ajaxRequester.canceled && ajaxRequester.canceled(id);
+ });
+ }
+ qq.extend(this, new qq.UploadHandler(spec));
+ qq.override(this, function(super_) {
+ return {
+ add: function(id, blobOrProxy) {
+ if (qq.isFile(blobOrProxy) || qq.isBlob(blobOrProxy)) {
+ super_.add(id, {
+ file: blobOrProxy
+ });
+ } else if (blobOrProxy instanceof qq.BlobProxy) {
+ super_.add(id, {
+ proxy: blobOrProxy
+ });
+ } else {
+ throw new Error("Passed obj is not a File, Blob, or proxy");
+ }
+ handler._initTempState(id);
+ resumeEnabled && handler._maybePrepareForResume(id);
+ },
+ expunge: function(id) {
+ abort(id);
+ handler._maybeDeletePersistedChunkData(id);
+ handler._clearXhrs(id);
+ super_.expunge(id);
+ }
+ };
+ });
+ qq.extend(this, {
+ clearCachedChunk: function(id, chunkIdx) {
+ delete handler._getFileState(id).temp.cachedChunks[chunkIdx];
+ },
+ clearXhr: function(id, chunkIdx) {
+ var tempState = handler._getFileState(id).temp;
+ if (tempState.xhrs) {
+ delete tempState.xhrs[chunkIdx];
+ }
+ if (tempState.ajaxRequesters) {
+ delete tempState.ajaxRequesters[chunkIdx];
+ }
+ },
+ finalizeChunks: function(id, responseParser) {
+ var lastChunkIdx = handler._getTotalChunks(id) - 1, xhr = handler._getXhr(id, lastChunkIdx);
+ if (responseParser) {
+ return new qq.Promise().success(responseParser(xhr), xhr);
+ }
+ return new qq.Promise().success({}, xhr);
+ },
+ getFile: function(id) {
+ return handler.isValid(id) && handler._getFileState(id).file;
+ },
+ getProxy: function(id) {
+ return handler.isValid(id) && handler._getFileState(id).proxy;
+ },
+ getResumableFilesData: function() {
+ var resumableFilesData = [];
+ handler._iterateResumeRecords(function(key, uploadData) {
+ handler.moveInProgressToRemaining(null, uploadData.chunking.inProgress, uploadData.chunking.remaining);
+ var data = {
+ name: uploadData.name,
+ remaining: uploadData.chunking.remaining,
+ size: uploadData.size,
+ uuid: uploadData.uuid
+ };
+ if (uploadData.key) {
+ data.key = uploadData.key;
+ }
+ resumableFilesData.push(data);
+ });
+ return resumableFilesData;
+ },
+ isResumable: function(id) {
+ return !!chunking && handler.isValid(id) && !handler._getFileState(id).notResumable;
+ },
+ moveInProgressToRemaining: function(id, optInProgress, optRemaining) {
+ var inProgress = optInProgress || handler._getFileState(id).chunking.inProgress, remaining = optRemaining || handler._getFileState(id).chunking.remaining;
+ if (inProgress) {
+ log(qq.format("Moving these chunks from in-progress {}, to remaining.", JSON.stringify(inProgress)));
+ inProgress.reverse();
+ qq.each(inProgress, function(idx, chunkIdx) {
+ remaining.unshift(chunkIdx);
+ });
+ inProgress.length = 0;
+ }
+ },
+ pause: function(id) {
+ if (handler.isValid(id)) {
+ log(qq.format("Aborting XHR upload for {} '{}' due to pause instruction.", id, getName(id)));
+ handler._getFileState(id).paused = true;
+ abort(id);
+ return true;
+ }
+ },
+ reevaluateChunking: function(id) {
+ if (chunking && handler.isValid(id)) {
+ var state = handler._getFileState(id), totalChunks, i;
+ delete state.chunking;
+ state.chunking = {};
+ totalChunks = handler._getTotalChunks(id);
+ if (totalChunks > 1 || chunking.mandatory) {
+ state.chunking.enabled = true;
+ state.chunking.parts = totalChunks;
+ state.chunking.remaining = [];
+ for (i = 0; i < totalChunks; i++) {
+ state.chunking.remaining.push(i);
+ }
+ handler._initTempState(id);
+ } else {
+ state.chunking.enabled = false;
+ }
+ }
+ },
+ updateBlob: function(id, newBlob) {
+ if (handler.isValid(id)) {
+ handler._getFileState(id).file = newBlob;
+ }
+ },
+ _clearXhrs: function(id) {
+ var tempState = handler._getFileState(id).temp;
+ qq.each(tempState.ajaxRequesters, function(chunkId) {
+ delete tempState.ajaxRequesters[chunkId];
+ });
+ qq.each(tempState.xhrs, function(chunkId) {
+ delete tempState.xhrs[chunkId];
+ });
+ },
+ _createXhr: function(id, optChunkIdx) {
+ return handler._registerXhr(id, optChunkIdx, qq.createXhrInstance());
+ },
+ _getAjaxRequester: function(id, optChunkIdx) {
+ var chunkIdx = optChunkIdx == null ? -1 : optChunkIdx;
+ return handler._getFileState(id).temp.ajaxRequesters[chunkIdx];
+ },
+ _getChunkData: function(id, chunkIndex) {
+ var chunkSize = chunking.partSize, fileSize = getSize(id), fileOrBlob = handler.getFile(id), startBytes = chunkSize * chunkIndex, endBytes = startBytes + chunkSize >= fileSize ? fileSize : startBytes + chunkSize, totalChunks = handler._getTotalChunks(id), cachedChunks = this._getFileState(id).temp.cachedChunks, blob = cachedChunks[chunkIndex] || qq.sliceBlob(fileOrBlob, startBytes, endBytes);
+ cachedChunks[chunkIndex] = blob;
+ return {
+ part: chunkIndex,
+ start: startBytes,
+ end: endBytes,
+ count: totalChunks,
+ blob: blob,
+ size: endBytes - startBytes
+ };
+ },
+ _getChunkDataForCallback: function(chunkData) {
+ return {
+ partIndex: chunkData.part,
+ startByte: chunkData.start + 1,
+ endByte: chunkData.end,
+ totalParts: chunkData.count
+ };
+ },
+ _getLocalStorageId: function(id) {
+ var formatVersion = "5.0", name = getName(id), size = getSize(id), chunkSize = chunking.partSize, endpoint = getEndpoint(id);
+ return qq.format("qq{}resume{}-{}-{}-{}-{}", namespace, formatVersion, name, size, chunkSize, endpoint);
+ },
+ _getMimeType: function(id) {
+ return handler.getFile(id).type;
+ },
+ _getPersistableData: function(id) {
+ return handler._getFileState(id).chunking;
+ },
+ _getTotalChunks: function(id) {
+ if (chunking) {
+ var fileSize = getSize(id), chunkSize = chunking.partSize;
+ return Math.ceil(fileSize / chunkSize);
+ }
+ },
+ _getXhr: function(id, optChunkIdx) {
+ var chunkIdx = optChunkIdx == null ? -1 : optChunkIdx;
+ return handler._getFileState(id).temp.xhrs[chunkIdx];
+ },
+ _getXhrs: function(id) {
+ return handler._getFileState(id).temp.xhrs;
+ },
+ _iterateResumeRecords: function(callback) {
+ if (resumeEnabled) {
+ qq.each(localStorage, function(key, item) {
+ if (key.indexOf(qq.format("qq{}resume", namespace)) === 0) {
+ var uploadData = JSON.parse(item);
+ callback(key, uploadData);
+ }
+ });
+ }
+ },
+ _initTempState: function(id) {
+ handler._getFileState(id).temp = {
+ ajaxRequesters: {},
+ chunkProgress: {},
+ xhrs: {},
+ cachedChunks: {}
+ };
+ },
+ _markNotResumable: function(id) {
+ handler._getFileState(id).notResumable = true;
+ },
+ _maybeDeletePersistedChunkData: function(id) {
+ var localStorageId;
+ if (resumeEnabled && handler.isResumable(id)) {
+ localStorageId = handler._getLocalStorageId(id);
+ if (localStorageId && localStorage.getItem(localStorageId)) {
+ localStorage.removeItem(localStorageId);
+ return true;
+ }
+ }
+ return false;
+ },
+ _maybePrepareForResume: function(id) {
+ var state = handler._getFileState(id), localStorageId, persistedData;
+ if (resumeEnabled && state.key === undefined) {
+ localStorageId = handler._getLocalStorageId(id);
+ persistedData = localStorage.getItem(localStorageId);
+ if (persistedData) {
+ persistedData = JSON.parse(persistedData);
+ if (getDataByUuid(persistedData.uuid)) {
+ handler._markNotResumable(id);
+ } else {
+ log(qq.format("Identified file with ID {} and name of {} as resumable.", id, getName(id)));
+ onUuidChanged(id, persistedData.uuid);
+ state.key = persistedData.key;
+ state.chunking = persistedData.chunking;
+ state.loaded = persistedData.loaded;
+ state.attemptingResume = true;
+ handler.moveInProgressToRemaining(id);
+ }
+ }
+ }
+ },
+ _maybePersistChunkedState: function(id) {
+ var state = handler._getFileState(id), localStorageId, persistedData;
+ if (resumeEnabled && handler.isResumable(id)) {
+ localStorageId = handler._getLocalStorageId(id);
+ persistedData = {
+ name: getName(id),
+ size: getSize(id),
+ uuid: getUuid(id),
+ key: state.key,
+ chunking: state.chunking,
+ loaded: state.loaded,
+ lastUpdated: Date.now()
+ };
+ try {
+ localStorage.setItem(localStorageId, JSON.stringify(persistedData));
+ } catch (error) {
+ log(qq.format("Unable to save resume data for '{}' due to error: '{}'.", id, error.toString()), "warn");
+ }
+ }
+ },
+ _registerProgressHandler: function(id, chunkIdx, chunkSize) {
+ var xhr = handler._getXhr(id, chunkIdx), name = getName(id), progressCalculator = {
+ simple: function(loaded, total) {
+ var fileSize = getSize(id);
+ if (loaded === total) {
+ onProgress(id, name, fileSize, fileSize);
+ } else {
+ onProgress(id, name, loaded >= fileSize ? fileSize - 1 : loaded, fileSize);
+ }
+ },
+ chunked: function(loaded, total) {
+ var chunkProgress = handler._getFileState(id).temp.chunkProgress, totalSuccessfullyLoadedForFile = handler._getFileState(id).loaded, loadedForRequest = loaded, totalForRequest = total, totalFileSize = getSize(id), estActualChunkLoaded = loadedForRequest - (totalForRequest - chunkSize), totalLoadedForFile = totalSuccessfullyLoadedForFile;
+ chunkProgress[chunkIdx] = estActualChunkLoaded;
+ qq.each(chunkProgress, function(chunkIdx, chunkLoaded) {
+ totalLoadedForFile += chunkLoaded;
+ });
+ onProgress(id, name, totalLoadedForFile, totalFileSize);
+ }
+ };
+ xhr.upload.onprogress = function(e) {
+ if (e.lengthComputable) {
+ var type = chunkSize == null ? "simple" : "chunked";
+ progressCalculator[type](e.loaded, e.total);
+ }
+ };
+ },
+ _registerXhr: function(id, optChunkIdx, xhr, optAjaxRequester) {
+ var xhrsId = optChunkIdx == null ? -1 : optChunkIdx, tempState = handler._getFileState(id).temp;
+ tempState.xhrs = tempState.xhrs || {};
+ tempState.ajaxRequesters = tempState.ajaxRequesters || {};
+ tempState.xhrs[xhrsId] = xhr;
+ if (optAjaxRequester) {
+ tempState.ajaxRequesters[xhrsId] = optAjaxRequester;
+ }
+ return xhr;
+ },
+ _removeExpiredChunkingRecords: function() {
+ var expirationDays = resume.recordsExpireIn;
+ handler._iterateResumeRecords(function(key, uploadData) {
+ var expirationDate = new Date(uploadData.lastUpdated);
+ expirationDate.setDate(expirationDate.getDate() + expirationDays);
+ if (expirationDate.getTime() <= Date.now()) {
+ log("Removing expired resume record with key " + key);
+ localStorage.removeItem(key);
+ }
+ });
+ },
+ _shouldChunkThisFile: function(id) {
+ var state = handler._getFileState(id);
+ if (!state.chunking) {
+ handler.reevaluateChunking(id);
+ }
+ return state.chunking.enabled;
+ }
+ });
+ };
+ qq.DeleteFileAjaxRequester = function(o) {
+ "use strict";
+ var requester, options = {
+ method: "DELETE",
+ uuidParamName: "qquuid",
+ endpointStore: {},
+ maxConnections: 3,
+ customHeaders: function(id) {
+ return {};
+ },
+ paramsStore: {},
+ cors: {
+ expected: false,
+ sendCredentials: false
+ },
+ log: function(str, level) {},
+ onDelete: function(id) {},
+ onDeleteComplete: function(id, xhrOrXdr, isError) {}
+ };
+ qq.extend(options, o);
+ function getMandatedParams() {
+ if (options.method.toUpperCase() === "POST") {
+ return {
+ _method: "DELETE"
+ };
+ }
+ return {};
+ }
+ requester = qq.extend(this, new qq.AjaxRequester({
+ acceptHeader: "application/json",
+ validMethods: [ "POST", "DELETE" ],
+ method: options.method,
+ endpointStore: options.endpointStore,
+ paramsStore: options.paramsStore,
+ mandatedParams: getMandatedParams(),
+ maxConnections: options.maxConnections,
+ customHeaders: function(id) {
+ return options.customHeaders.get(id);
+ },
+ log: options.log,
+ onSend: options.onDelete,
+ onComplete: options.onDeleteComplete,
+ cors: options.cors
+ }));
+ qq.extend(this, {
+ sendDelete: function(id, uuid, additionalMandatedParams) {
+ var additionalOptions = additionalMandatedParams || {};
+ options.log("Submitting delete file request for " + id);
+ if (options.method === "DELETE") {
+ requester.initTransport(id).withPath(uuid).withParams(additionalOptions).send();
+ } else {
+ additionalOptions[options.uuidParamName] = uuid;
+ requester.initTransport(id).withParams(additionalOptions).send();
+ }
+ }
+ });
+ };
+ (function() {
+ function detectSubsampling(img) {
+ var iw = img.naturalWidth, ih = img.naturalHeight, canvas = document.createElement("canvas"), ctx;
+ if (iw * ih > 1024 * 1024) {
+ canvas.width = canvas.height = 1;
+ ctx = canvas.getContext("2d");
+ ctx.drawImage(img, -iw + 1, 0);
+ return ctx.getImageData(0, 0, 1, 1).data[3] === 0;
+ } else {
+ return false;
+ }
+ }
+ function detectVerticalSquash(img, iw, ih) {
+ var canvas = document.createElement("canvas"), sy = 0, ey = ih, py = ih, ctx, data, alpha, ratio;
+ canvas.width = 1;
+ canvas.height = ih;
+ ctx = canvas.getContext("2d");
+ ctx.drawImage(img, 0, 0);
+ data = ctx.getImageData(0, 0, 1, ih).data;
+ while (py > sy) {
+ alpha = data[(py - 1) * 4 + 3];
+ if (alpha === 0) {
+ ey = py;
+ } else {
+ sy = py;
+ }
+ py = ey + sy >> 1;
+ }
+ ratio = py / ih;
+ return ratio === 0 ? 1 : ratio;
+ }
+ function renderImageToDataURL(img, blob, options, doSquash) {
+ var canvas = document.createElement("canvas"), mime = options.mime || "image/jpeg", promise = new qq.Promise();
+ renderImageToCanvas(img, blob, canvas, options, doSquash).then(function() {
+ promise.success(canvas.toDataURL(mime, options.quality || .8));
+ });
+ return promise;
+ }
+ function maybeCalculateDownsampledDimensions(spec) {
+ var maxPixels = 5241e3;
+ if (!qq.ios()) {
+ throw new qq.Error("Downsampled dimensions can only be reliably calculated for iOS!");
+ }
+ if (spec.origHeight * spec.origWidth > maxPixels) {
+ return {
+ newHeight: Math.round(Math.sqrt(maxPixels * (spec.origHeight / spec.origWidth))),
+ newWidth: Math.round(Math.sqrt(maxPixels * (spec.origWidth / spec.origHeight)))
+ };
+ }
+ }
+ function renderImageToCanvas(img, blob, canvas, options, doSquash) {
+ var iw = img.naturalWidth, ih = img.naturalHeight, width = options.width, height = options.height, ctx = canvas.getContext("2d"), promise = new qq.Promise(), modifiedDimensions;
+ ctx.save();
+ if (options.resize) {
+ return renderImageToCanvasWithCustomResizer({
+ blob: blob,
+ canvas: canvas,
+ image: img,
+ imageHeight: ih,
+ imageWidth: iw,
+ orientation: options.orientation,
+ resize: options.resize,
+ targetHeight: height,
+ targetWidth: width
+ });
+ }
+ if (!qq.supportedFeatures.unlimitedScaledImageSize) {
+ modifiedDimensions = maybeCalculateDownsampledDimensions({
+ origWidth: width,
+ origHeight: height
+ });
+ if (modifiedDimensions) {
+ qq.log(qq.format("Had to reduce dimensions due to device limitations from {}w / {}h to {}w / {}h", width, height, modifiedDimensions.newWidth, modifiedDimensions.newHeight), "warn");
+ width = modifiedDimensions.newWidth;
+ height = modifiedDimensions.newHeight;
+ }
+ }
+ transformCoordinate(canvas, width, height, options.orientation);
+ if (qq.ios()) {
+ (function() {
+ if (detectSubsampling(img)) {
+ iw /= 2;
+ ih /= 2;
+ }
+ var d = 1024, tmpCanvas = document.createElement("canvas"), vertSquashRatio = doSquash ? detectVerticalSquash(img, iw, ih) : 1, dw = Math.ceil(d * width / iw), dh = Math.ceil(d * height / ih / vertSquashRatio), sy = 0, dy = 0, tmpCtx, sx, dx;
+ tmpCanvas.width = tmpCanvas.height = d;
+ tmpCtx = tmpCanvas.getContext("2d");
+ while (sy < ih) {
+ sx = 0;
+ dx = 0;
+ while (sx < iw) {
+ tmpCtx.clearRect(0, 0, d, d);
+ tmpCtx.drawImage(img, -sx, -sy);
+ ctx.drawImage(tmpCanvas, 0, 0, d, d, dx, dy, dw, dh);
+ sx += d;
+ dx += dw;
+ }
+ sy += d;
+ dy += dh;
+ }
+ ctx.restore();
+ tmpCanvas = tmpCtx = null;
+ })();
+ } else {
+ ctx.drawImage(img, 0, 0, width, height);
+ }
+ canvas.qqImageRendered && canvas.qqImageRendered();
+ promise.success();
+ return promise;
+ }
+ function renderImageToCanvasWithCustomResizer(resizeInfo) {
+ var blob = resizeInfo.blob, image = resizeInfo.image, imageHeight = resizeInfo.imageHeight, imageWidth = resizeInfo.imageWidth, orientation = resizeInfo.orientation, promise = new qq.Promise(), resize = resizeInfo.resize, sourceCanvas = document.createElement("canvas"), sourceCanvasContext = sourceCanvas.getContext("2d"), targetCanvas = resizeInfo.canvas, targetHeight = resizeInfo.targetHeight, targetWidth = resizeInfo.targetWidth;
+ transformCoordinate(sourceCanvas, imageWidth, imageHeight, orientation);
+ targetCanvas.height = targetHeight;
+ targetCanvas.width = targetWidth;
+ sourceCanvasContext.drawImage(image, 0, 0);
+ resize({
+ blob: blob,
+ height: targetHeight,
+ image: image,
+ sourceCanvas: sourceCanvas,
+ targetCanvas: targetCanvas,
+ width: targetWidth
+ }).then(function success() {
+ targetCanvas.qqImageRendered && targetCanvas.qqImageRendered();
+ promise.success();
+ }, promise.failure);
+ return promise;
+ }
+ function transformCoordinate(canvas, width, height, orientation) {
+ switch (orientation) {
+ case 5:
+ case 6:
+ case 7:
+ case 8:
+ canvas.width = height;
+ canvas.height = width;
+ break;
+
+ default:
+ canvas.width = width;
+ canvas.height = height;
+ }
+ var ctx = canvas.getContext("2d");
+ switch (orientation) {
+ case 2:
+ ctx.translate(width, 0);
+ ctx.scale(-1, 1);
+ break;
+
+ case 3:
+ ctx.translate(width, height);
+ ctx.rotate(Math.PI);
+ break;
+
+ case 4:
+ ctx.translate(0, height);
+ ctx.scale(1, -1);
+ break;
+
+ case 5:
+ ctx.rotate(.5 * Math.PI);
+ ctx.scale(1, -1);
+ break;
+
+ case 6:
+ ctx.rotate(.5 * Math.PI);
+ ctx.translate(0, -height);
+ break;
+
+ case 7:
+ ctx.rotate(.5 * Math.PI);
+ ctx.translate(width, -height);
+ ctx.scale(-1, 1);
+ break;
+
+ case 8:
+ ctx.rotate(-.5 * Math.PI);
+ ctx.translate(-width, 0);
+ break;
+
+ default:
+ break;
+ }
+ }
+ function MegaPixImage(srcImage, errorCallback) {
+ var self = this;
+ if (window.Blob && srcImage instanceof Blob) {
+ (function() {
+ var img = new Image(), URL = window.URL && window.URL.createObjectURL ? window.URL : window.webkitURL && window.webkitURL.createObjectURL ? window.webkitURL : null;
+ if (!URL) {
+ throw Error("No createObjectURL function found to create blob url");
+ }
+ img.src = URL.createObjectURL(srcImage);
+ self.blob = srcImage;
+ srcImage = img;
+ })();
+ }
+ if (!srcImage.naturalWidth && !srcImage.naturalHeight) {
+ srcImage.onload = function() {
+ var listeners = self.imageLoadListeners;
+ if (listeners) {
+ self.imageLoadListeners = null;
+ setTimeout(function() {
+ for (var i = 0, len = listeners.length; i < len; i++) {
+ listeners[i]();
+ }
+ }, 0);
+ }
+ };
+ srcImage.onerror = errorCallback;
+ this.imageLoadListeners = [];
+ }
+ this.srcImage = srcImage;
+ }
+ MegaPixImage.prototype.render = function(target, options) {
+ options = options || {};
+ var self = this, imgWidth = this.srcImage.naturalWidth, imgHeight = this.srcImage.naturalHeight, width = options.width, height = options.height, maxWidth = options.maxWidth, maxHeight = options.maxHeight, doSquash = !this.blob || this.blob.type === "image/jpeg", tagName = target.tagName.toLowerCase(), opt;
+ if (this.imageLoadListeners) {
+ this.imageLoadListeners.push(function() {
+ self.render(target, options);
+ });
+ return;
+ }
+ if (width && !height) {
+ height = imgHeight * width / imgWidth << 0;
+ } else if (height && !width) {
+ width = imgWidth * height / imgHeight << 0;
+ } else {
+ width = imgWidth;
+ height = imgHeight;
+ }
+ if (maxWidth && width > maxWidth) {
+ width = maxWidth;
+ height = imgHeight * width / imgWidth << 0;
+ }
+ if (maxHeight && height > maxHeight) {
+ height = maxHeight;
+ width = imgWidth * height / imgHeight << 0;
+ }
+ opt = {
+ width: width,
+ height: height
+ }, qq.each(options, function(optionsKey, optionsValue) {
+ opt[optionsKey] = optionsValue;
+ });
+ if (tagName === "img") {
+ (function() {
+ var oldTargetSrc = target.src;
+ renderImageToDataURL(self.srcImage, self.blob, opt, doSquash).then(function(dataUri) {
+ target.src = dataUri;
+ oldTargetSrc === target.src && target.onload();
+ });
+ })();
+ } else if (tagName === "canvas") {
+ renderImageToCanvas(this.srcImage, this.blob, target, opt, doSquash);
+ }
+ if (typeof this.onrender === "function") {
+ this.onrender(target);
+ }
+ };
+ qq.MegaPixImage = MegaPixImage;
+ })();
+ qq.ImageGenerator = function(log) {
+ "use strict";
+ function isImg(el) {
+ return el.tagName.toLowerCase() === "img";
+ }
+ function isCanvas(el) {
+ return el.tagName.toLowerCase() === "canvas";
+ }
+ function isImgCorsSupported() {
+ return new Image().crossOrigin !== undefined;
+ }
+ function isCanvasSupported() {
+ var canvas = document.createElement("canvas");
+ return canvas.getContext && canvas.getContext("2d");
+ }
+ function determineMimeOfFileName(nameWithPath) {
+ var pathSegments = nameWithPath.split("/"), name = pathSegments[pathSegments.length - 1].split("?")[0], extension = qq.getExtension(name);
+ extension = extension && extension.toLowerCase();
+ switch (extension) {
+ case "jpeg":
+ case "jpg":
+ return "image/jpeg";
+
+ case "png":
+ return "image/png";
+
+ case "bmp":
+ return "image/bmp";
+
+ case "gif":
+ return "image/gif";
+
+ case "tiff":
+ case "tif":
+ return "image/tiff";
+ }
+ }
+ function isCrossOrigin(url) {
+ var targetAnchor = document.createElement("a"), targetProtocol, targetHostname, targetPort;
+ targetAnchor.href = url;
+ targetProtocol = targetAnchor.protocol;
+ targetPort = targetAnchor.port;
+ targetHostname = targetAnchor.hostname;
+ if (targetProtocol.toLowerCase() !== window.location.protocol.toLowerCase()) {
+ return true;
+ }
+ if (targetHostname.toLowerCase() !== window.location.hostname.toLowerCase()) {
+ return true;
+ }
+ if (targetPort !== window.location.port && !qq.ie()) {
+ return true;
+ }
+ return false;
+ }
+ function registerImgLoadListeners(img, promise) {
+ img.onload = function() {
+ img.onload = null;
+ img.onerror = null;
+ promise.success(img);
+ };
+ img.onerror = function() {
+ img.onload = null;
+ img.onerror = null;
+ log("Problem drawing thumbnail!", "error");
+ promise.failure(img, "Problem drawing thumbnail!");
+ };
+ }
+ function registerCanvasDrawImageListener(canvas, promise) {
+ canvas.qqImageRendered = function() {
+ promise.success(canvas);
+ };
+ }
+ function registerThumbnailRenderedListener(imgOrCanvas, promise) {
+ var registered = isImg(imgOrCanvas) || isCanvas(imgOrCanvas);
+ if (isImg(imgOrCanvas)) {
+ registerImgLoadListeners(imgOrCanvas, promise);
+ } else if (isCanvas(imgOrCanvas)) {
+ registerCanvasDrawImageListener(imgOrCanvas, promise);
+ } else {
+ promise.failure(imgOrCanvas);
+ log(qq.format("Element container of type {} is not supported!", imgOrCanvas.tagName), "error");
+ }
+ return registered;
+ }
+ function draw(fileOrBlob, container, options) {
+ var drawPreview = new qq.Promise(), identifier = new qq.Identify(fileOrBlob, log), maxSize = options.maxSize, orient = options.orient == null ? true : options.orient, megapixErrorHandler = function() {
+ container.onerror = null;
+ container.onload = null;
+ log("Could not render preview, file may be too large!", "error");
+ drawPreview.failure(container, "Browser cannot render image!");
+ };
+ identifier.isPreviewable().then(function(mime) {
+ var dummyExif = {
+ parse: function() {
+ return new qq.Promise().success();
+ }
+ }, exif = orient ? new qq.Exif(fileOrBlob, log) : dummyExif, mpImg = new qq.MegaPixImage(fileOrBlob, megapixErrorHandler);
+ if (registerThumbnailRenderedListener(container, drawPreview)) {
+ exif.parse().then(function(exif) {
+ var orientation = exif && exif.Orientation;
+ mpImg.render(container, {
+ maxWidth: maxSize,
+ maxHeight: maxSize,
+ orientation: orientation,
+ mime: mime,
+ resize: options.customResizeFunction
+ });
+ }, function(failureMsg) {
+ log(qq.format("EXIF data could not be parsed ({}). Assuming orientation = 1.", failureMsg));
+ mpImg.render(container, {
+ maxWidth: maxSize,
+ maxHeight: maxSize,
+ mime: mime,
+ resize: options.customResizeFunction
+ });
+ });
+ }
+ }, function() {
+ log("Not previewable");
+ drawPreview.failure(container, "Not previewable");
+ });
+ return drawPreview;
+ }
+ function drawOnCanvasOrImgFromUrl(url, canvasOrImg, draw, maxSize, customResizeFunction) {
+ var tempImg = new Image(), tempImgRender = new qq.Promise();
+ registerThumbnailRenderedListener(tempImg, tempImgRender);
+ if (isCrossOrigin(url)) {
+ tempImg.crossOrigin = "anonymous";
+ }
+ tempImg.src = url;
+ tempImgRender.then(function rendered() {
+ registerThumbnailRenderedListener(canvasOrImg, draw);
+ var mpImg = new qq.MegaPixImage(tempImg);
+ mpImg.render(canvasOrImg, {
+ maxWidth: maxSize,
+ maxHeight: maxSize,
+ mime: determineMimeOfFileName(url),
+ resize: customResizeFunction
+ });
+ }, draw.failure);
+ }
+ function drawOnImgFromUrlWithCssScaling(url, img, draw, maxSize) {
+ registerThumbnailRenderedListener(img, draw);
+ qq(img).css({
+ maxWidth: maxSize + "px",
+ maxHeight: maxSize + "px"
+ });
+ img.src = url;
+ }
+ function drawFromUrl(url, container, options) {
+ var draw = new qq.Promise(), scale = options.scale, maxSize = scale ? options.maxSize : null;
+ if (scale && isImg(container)) {
+ if (isCanvasSupported()) {
+ if (isCrossOrigin(url) && !isImgCorsSupported()) {
+ drawOnImgFromUrlWithCssScaling(url, container, draw, maxSize);
+ } else {
+ drawOnCanvasOrImgFromUrl(url, container, draw, maxSize);
+ }
+ } else {
+ drawOnImgFromUrlWithCssScaling(url, container, draw, maxSize);
+ }
+ } else if (isCanvas(container)) {
+ drawOnCanvasOrImgFromUrl(url, container, draw, maxSize);
+ } else if (registerThumbnailRenderedListener(container, draw)) {
+ container.src = url;
+ }
+ return draw;
+ }
+ qq.extend(this, {
+ generate: function(fileBlobOrUrl, container, options) {
+ if (qq.isString(fileBlobOrUrl)) {
+ log("Attempting to update thumbnail based on server response.");
+ return drawFromUrl(fileBlobOrUrl, container, options || {});
+ } else {
+ log("Attempting to draw client-side image preview.");
+ return draw(fileBlobOrUrl, container, options || {});
+ }
+ }
+ });
+ this._testing = {};
+ this._testing.isImg = isImg;
+ this._testing.isCanvas = isCanvas;
+ this._testing.isCrossOrigin = isCrossOrigin;
+ this._testing.determineMimeOfFileName = determineMimeOfFileName;
+ };
+ qq.Exif = function(fileOrBlob, log) {
+ "use strict";
+ var TAG_IDS = [ 274 ], TAG_INFO = {
+ 274: {
+ name: "Orientation",
+ bytes: 2
+ }
+ };
+ function parseLittleEndian(hex) {
+ var result = 0, pow = 0;
+ while (hex.length > 0) {
+ result += parseInt(hex.substring(0, 2), 16) * Math.pow(2, pow);
+ hex = hex.substring(2, hex.length);
+ pow += 8;
+ }
+ return result;
+ }
+ function seekToApp1(offset, promise) {
+ var theOffset = offset, thePromise = promise;
+ if (theOffset === undefined) {
+ theOffset = 2;
+ thePromise = new qq.Promise();
+ }
+ qq.readBlobToHex(fileOrBlob, theOffset, 4).then(function(hex) {
+ var match = /^ffe([0-9])/.exec(hex), segmentLength;
+ if (match) {
+ if (match[1] !== "1") {
+ segmentLength = parseInt(hex.slice(4, 8), 16);
+ seekToApp1(theOffset + segmentLength + 2, thePromise);
+ } else {
+ thePromise.success(theOffset);
+ }
+ } else {
+ thePromise.failure("No EXIF header to be found!");
+ }
+ });
+ return thePromise;
+ }
+ function getApp1Offset() {
+ var promise = new qq.Promise();
+ qq.readBlobToHex(fileOrBlob, 0, 6).then(function(hex) {
+ if (hex.indexOf("ffd8") !== 0) {
+ promise.failure("Not a valid JPEG!");
+ } else {
+ seekToApp1().then(function(offset) {
+ promise.success(offset);
+ }, function(error) {
+ promise.failure(error);
+ });
+ }
+ });
+ return promise;
+ }
+ function isLittleEndian(app1Start) {
+ var promise = new qq.Promise();
+ qq.readBlobToHex(fileOrBlob, app1Start + 10, 2).then(function(hex) {
+ promise.success(hex === "4949");
+ });
+ return promise;
+ }
+ function getDirEntryCount(app1Start, littleEndian) {
+ var promise = new qq.Promise();
+ qq.readBlobToHex(fileOrBlob, app1Start + 18, 2).then(function(hex) {
+ if (littleEndian) {
+ return promise.success(parseLittleEndian(hex));
+ } else {
+ promise.success(parseInt(hex, 16));
+ }
+ });
+ return promise;
+ }
+ function getIfd(app1Start, dirEntries) {
+ var offset = app1Start + 20, bytes = dirEntries * 12;
+ return qq.readBlobToHex(fileOrBlob, offset, bytes);
+ }
+ function getDirEntries(ifdHex) {
+ var entries = [], offset = 0;
+ while (offset + 24 <= ifdHex.length) {
+ entries.push(ifdHex.slice(offset, offset + 24));
+ offset += 24;
+ }
+ return entries;
+ }
+ function getTagValues(littleEndian, dirEntries) {
+ var TAG_VAL_OFFSET = 16, tagsToFind = qq.extend([], TAG_IDS), vals = {};
+ qq.each(dirEntries, function(idx, entry) {
+ var idHex = entry.slice(0, 4), id = littleEndian ? parseLittleEndian(idHex) : parseInt(idHex, 16), tagsToFindIdx = tagsToFind.indexOf(id), tagValHex, tagName, tagValLength;
+ if (tagsToFindIdx >= 0) {
+ tagName = TAG_INFO[id].name;
+ tagValLength = TAG_INFO[id].bytes;
+ tagValHex = entry.slice(TAG_VAL_OFFSET, TAG_VAL_OFFSET + tagValLength * 2);
+ vals[tagName] = littleEndian ? parseLittleEndian(tagValHex) : parseInt(tagValHex, 16);
+ tagsToFind.splice(tagsToFindIdx, 1);
+ }
+ if (tagsToFind.length === 0) {
+ return false;
+ }
+ });
+ return vals;
+ }
+ qq.extend(this, {
+ parse: function() {
+ var parser = new qq.Promise(), onParseFailure = function(message) {
+ log(qq.format("EXIF header parse failed: '{}' ", message));
+ parser.failure(message);
+ };
+ getApp1Offset().then(function(app1Offset) {
+ log(qq.format("Moving forward with EXIF header parsing for '{}'", fileOrBlob.name === undefined ? "blob" : fileOrBlob.name));
+ isLittleEndian(app1Offset).then(function(littleEndian) {
+ log(qq.format("EXIF Byte order is {} endian", littleEndian ? "little" : "big"));
+ getDirEntryCount(app1Offset, littleEndian).then(function(dirEntryCount) {
+ log(qq.format("Found {} APP1 directory entries", dirEntryCount));
+ getIfd(app1Offset, dirEntryCount).then(function(ifdHex) {
+ var dirEntries = getDirEntries(ifdHex), tagValues = getTagValues(littleEndian, dirEntries);
+ log("Successfully parsed some EXIF tags");
+ parser.success(tagValues);
+ }, onParseFailure);
+ }, onParseFailure);
+ }, onParseFailure);
+ }, onParseFailure);
+ return parser;
+ }
+ });
+ this._testing = {};
+ this._testing.parseLittleEndian = parseLittleEndian;
+ };
+ qq.Identify = function(fileOrBlob, log) {
+ "use strict";
+ function isIdentifiable(magicBytes, questionableBytes) {
+ var identifiable = false, magicBytesEntries = [].concat(magicBytes);
+ qq.each(magicBytesEntries, function(idx, magicBytesArrayEntry) {
+ if (questionableBytes.indexOf(magicBytesArrayEntry) === 0) {
+ identifiable = true;
+ return false;
+ }
+ });
+ return identifiable;
+ }
+ qq.extend(this, {
+ isPreviewable: function() {
+ var self = this, identifier = new qq.Promise(), previewable = false, name = fileOrBlob.name === undefined ? "blob" : fileOrBlob.name;
+ log(qq.format("Attempting to determine if {} can be rendered in this browser", name));
+ log("First pass: check type attribute of blob object.");
+ if (this.isPreviewableSync()) {
+ log("Second pass: check for magic bytes in file header.");
+ qq.readBlobToHex(fileOrBlob, 0, 4).then(function(hex) {
+ qq.each(self.PREVIEWABLE_MIME_TYPES, function(mime, bytes) {
+ if (isIdentifiable(bytes, hex)) {
+ if (mime !== "image/tiff" || qq.supportedFeatures.tiffPreviews) {
+ previewable = true;
+ identifier.success(mime);
+ }
+ return false;
+ }
+ });
+ log(qq.format("'{}' is {} able to be rendered in this browser", name, previewable ? "" : "NOT"));
+ if (!previewable) {
+ identifier.failure();
+ }
+ }, function() {
+ log("Error reading file w/ name '" + name + "'. Not able to be rendered in this browser.");
+ identifier.failure();
+ });
+ } else {
+ identifier.failure();
+ }
+ return identifier;
+ },
+ isPreviewableSync: function() {
+ var fileMime = fileOrBlob.type, isRecognizedImage = qq.indexOf(Object.keys(this.PREVIEWABLE_MIME_TYPES), fileMime) >= 0, previewable = false, name = fileOrBlob.name === undefined ? "blob" : fileOrBlob.name;
+ if (isRecognizedImage) {
+ if (fileMime === "image/tiff") {
+ previewable = qq.supportedFeatures.tiffPreviews;
+ } else {
+ previewable = true;
+ }
+ }
+ !previewable && log(name + " is not previewable in this browser per the blob's type attr");
+ return previewable;
+ }
+ });
+ };
+ qq.Identify.prototype.PREVIEWABLE_MIME_TYPES = {
+ "image/jpeg": "ffd8ff",
+ "image/gif": "474946",
+ "image/png": "89504e",
+ "image/bmp": "424d",
+ "image/tiff": [ "49492a00", "4d4d002a" ]
+ };
+ qq.ImageValidation = function(blob, log) {
+ "use strict";
+ function hasNonZeroLimits(limits) {
+ var atLeastOne = false;
+ qq.each(limits, function(limit, value) {
+ if (value > 0) {
+ atLeastOne = true;
+ return false;
+ }
+ });
+ return atLeastOne;
+ }
+ function getWidthHeight() {
+ var sizeDetermination = new qq.Promise();
+ new qq.Identify(blob, log).isPreviewable().then(function() {
+ var image = new Image(), url = window.URL && window.URL.createObjectURL ? window.URL : window.webkitURL && window.webkitURL.createObjectURL ? window.webkitURL : null;
+ if (url) {
+ image.onerror = function() {
+ log("Cannot determine dimensions for image. May be too large.", "error");
+ sizeDetermination.failure();
+ };
+ image.onload = function() {
+ sizeDetermination.success({
+ width: this.width,
+ height: this.height
+ });
+ };
+ image.src = url.createObjectURL(blob);
+ } else {
+ log("No createObjectURL function available to generate image URL!", "error");
+ sizeDetermination.failure();
+ }
+ }, sizeDetermination.failure);
+ return sizeDetermination;
+ }
+ function getFailingLimit(limits, dimensions) {
+ var failingLimit;
+ qq.each(limits, function(limitName, limitValue) {
+ if (limitValue > 0) {
+ var limitMatcher = /(max|min)(Width|Height)/.exec(limitName), dimensionPropName = limitMatcher[2].charAt(0).toLowerCase() + limitMatcher[2].slice(1), actualValue = dimensions[dimensionPropName];
+ switch (limitMatcher[1]) {
+ case "min":
+ if (actualValue < limitValue) {
+ failingLimit = limitName;
+ return false;
+ }
+ break;
+
+ case "max":
+ if (actualValue > limitValue) {
+ failingLimit = limitName;
+ return false;
+ }
+ break;
+ }
+ }
+ });
+ return failingLimit;
+ }
+ this.validate = function(limits) {
+ var validationEffort = new qq.Promise();
+ log("Attempting to validate image.");
+ if (hasNonZeroLimits(limits)) {
+ getWidthHeight().then(function(dimensions) {
+ var failingLimit = getFailingLimit(limits, dimensions);
+ if (failingLimit) {
+ validationEffort.failure(failingLimit);
+ } else {
+ validationEffort.success();
+ }
+ }, validationEffort.success);
+ } else {
+ validationEffort.success();
+ }
+ return validationEffort;
+ };
+ };
+ qq.Session = function(spec) {
+ "use strict";
+ var options = {
+ endpoint: null,
+ params: {},
+ customHeaders: {},
+ cors: {},
+ addFileRecord: function(sessionData) {},
+ log: function(message, level) {}
+ };
+ qq.extend(options, spec, true);
+ function isJsonResponseValid(response) {
+ if (qq.isArray(response)) {
+ return true;
+ }
+ options.log("Session response is not an array.", "error");
+ }
+ function handleFileItems(fileItems, success, xhrOrXdr, promise) {
+ var someItemsIgnored = false;
+ success = success && isJsonResponseValid(fileItems);
+ if (success) {
+ qq.each(fileItems, function(idx, fileItem) {
+ if (fileItem.uuid == null) {
+ someItemsIgnored = true;
+ options.log(qq.format("Session response item {} did not include a valid UUID - ignoring.", idx), "error");
+ } else if (fileItem.name == null) {
+ someItemsIgnored = true;
+ options.log(qq.format("Session response item {} did not include a valid name - ignoring.", idx), "error");
+ } else {
+ try {
+ options.addFileRecord(fileItem);
+ return true;
+ } catch (err) {
+ someItemsIgnored = true;
+ options.log(err.message, "error");
+ }
+ }
+ return false;
+ });
+ }
+ promise[success && !someItemsIgnored ? "success" : "failure"](fileItems, xhrOrXdr);
+ }
+ this.refresh = function() {
+ var refreshEffort = new qq.Promise(), refreshCompleteCallback = function(response, success, xhrOrXdr) {
+ handleFileItems(response, success, xhrOrXdr, refreshEffort);
+ }, requesterOptions = qq.extend({}, options), requester = new qq.SessionAjaxRequester(qq.extend(requesterOptions, {
+ onComplete: refreshCompleteCallback
+ }));
+ requester.queryServer();
+ return refreshEffort;
+ };
+ };
+ qq.SessionAjaxRequester = function(spec) {
+ "use strict";
+ var requester, options = {
+ endpoint: null,
+ customHeaders: {},
+ params: {},
+ cors: {
+ expected: false,
+ sendCredentials: false
+ },
+ onComplete: function(response, success, xhrOrXdr) {},
+ log: function(str, level) {}
+ };
+ qq.extend(options, spec);
+ function onComplete(id, xhrOrXdr, isError) {
+ var response = null;
+ if (xhrOrXdr.responseText != null) {
+ try {
+ response = qq.parseJson(xhrOrXdr.responseText);
+ } catch (err) {
+ options.log("Problem parsing session response: " + err.message, "error");
+ isError = true;
+ }
+ }
+ options.onComplete(response, !isError, xhrOrXdr);
+ }
+ requester = qq.extend(this, new qq.AjaxRequester({
+ acceptHeader: "application/json",
+ validMethods: [ "GET" ],
+ method: "GET",
+ endpointStore: {
+ get: function() {
+ return options.endpoint;
+ }
+ },
+ customHeaders: options.customHeaders,
+ log: options.log,
+ onComplete: onComplete,
+ cors: options.cors
+ }));
+ qq.extend(this, {
+ queryServer: function() {
+ var params = qq.extend({}, options.params);
+ options.log("Session query request.");
+ requester.initTransport("sessionRefresh").withParams(params).withCacheBuster().send();
+ }
+ });
+ };
+ qq.Scaler = function(spec, log) {
+ "use strict";
+ var self = this, customResizeFunction = spec.customResizer, includeOriginal = spec.sendOriginal, orient = spec.orient, defaultType = spec.defaultType, defaultQuality = spec.defaultQuality / 100, failedToScaleText = spec.failureText, includeExif = spec.includeExif, sizes = this._getSortedSizes(spec.sizes);
+ qq.extend(this, {
+ enabled: qq.supportedFeatures.scaling && sizes.length > 0,
+ getFileRecords: function(originalFileUuid, originalFileName, originalBlobOrBlobData) {
+ var self = this, records = [], originalBlob = originalBlobOrBlobData.blob ? originalBlobOrBlobData.blob : originalBlobOrBlobData, identifier = new qq.Identify(originalBlob, log);
+ if (identifier.isPreviewableSync()) {
+ qq.each(sizes, function(idx, sizeRecord) {
+ var outputType = self._determineOutputType({
+ defaultType: defaultType,
+ requestedType: sizeRecord.type,
+ refType: originalBlob.type
+ });
+ records.push({
+ uuid: qq.getUniqueId(),
+ name: self._getName(originalFileName, {
+ name: sizeRecord.name,
+ type: outputType,
+ refType: originalBlob.type
+ }),
+ blob: new qq.BlobProxy(originalBlob, qq.bind(self._generateScaledImage, self, {
+ customResizeFunction: customResizeFunction,
+ maxSize: sizeRecord.maxSize,
+ orient: orient,
+ type: outputType,
+ quality: defaultQuality,
+ failedText: failedToScaleText,
+ includeExif: includeExif,
+ log: log
+ }))
+ });
+ });
+ records.push({
+ uuid: originalFileUuid,
+ name: originalFileName,
+ size: originalBlob.size,
+ blob: includeOriginal ? originalBlob : null
+ });
+ } else {
+ records.push({
+ uuid: originalFileUuid,
+ name: originalFileName,
+ size: originalBlob.size,
+ blob: originalBlob
+ });
+ }
+ return records;
+ },
+ handleNewFile: function(file, name, uuid, size, fileList, batchId, uuidParamName, api) {
+ var self = this, buttonId = file.qqButtonId || file.blob && file.blob.qqButtonId, scaledIds = [], originalId = null, addFileToHandler = api.addFileToHandler, uploadData = api.uploadData, paramsStore = api.paramsStore, proxyGroupId = qq.getUniqueId();
+ qq.each(self.getFileRecords(uuid, name, file), function(idx, record) {
+ var blobSize = record.size, id;
+ if (record.blob instanceof qq.BlobProxy) {
+ blobSize = -1;
+ }
+ id = uploadData.addFile({
+ uuid: record.uuid,
+ name: record.name,
+ size: blobSize,
+ batchId: batchId,
+ proxyGroupId: proxyGroupId
+ });
+ if (record.blob instanceof qq.BlobProxy) {
+ scaledIds.push(id);
+ } else {
+ originalId = id;
+ }
+ if (record.blob) {
+ addFileToHandler(id, record.blob);
+ fileList.push({
+ id: id,
+ file: record.blob
+ });
+ } else {
+ uploadData.setStatus(id, qq.status.REJECTED);
+ }
+ });
+ if (originalId !== null) {
+ qq.each(scaledIds, function(idx, scaledId) {
+ var params = {
+ qqparentuuid: uploadData.retrieve({
+ id: originalId
+ }).uuid,
+ qqparentsize: uploadData.retrieve({
+ id: originalId
+ }).size
+ };
+ params[uuidParamName] = uploadData.retrieve({
+ id: scaledId
+ }).uuid;
+ uploadData.setParentId(scaledId, originalId);
+ paramsStore.addReadOnly(scaledId, params);
+ });
+ if (scaledIds.length) {
+ (function() {
+ var param = {};
+ param[uuidParamName] = uploadData.retrieve({
+ id: originalId
+ }).uuid;
+ paramsStore.addReadOnly(originalId, param);
+ })();
+ }
+ }
+ }
+ });
+ };
+ qq.extend(qq.Scaler.prototype, {
+ scaleImage: function(id, specs, api) {
+ "use strict";
+ if (!qq.supportedFeatures.scaling) {
+ throw new qq.Error("Scaling is not supported in this browser!");
+ }
+ var scalingEffort = new qq.Promise(), log = api.log, file = api.getFile(id), uploadData = api.uploadData.retrieve({
+ id: id
+ }), name = uploadData && uploadData.name, uuid = uploadData && uploadData.uuid, scalingOptions = {
+ customResizer: specs.customResizer,
+ sendOriginal: false,
+ orient: specs.orient,
+ defaultType: specs.type || null,
+ defaultQuality: specs.quality,
+ failedToScaleText: "Unable to scale",
+ sizes: [ {
+ name: "",
+ maxSize: specs.maxSize
+ } ]
+ }, scaler = new qq.Scaler(scalingOptions, log);
+ if (!qq.Scaler || !qq.supportedFeatures.imagePreviews || !file) {
+ scalingEffort.failure();
+ log("Could not generate requested scaled image for " + id + ". " + "Scaling is either not possible in this browser, or the file could not be located.", "error");
+ } else {
+ qq.bind(function() {
+ var record = scaler.getFileRecords(uuid, name, file)[0];
+ if (record && record.blob instanceof qq.BlobProxy) {
+ record.blob.create().then(scalingEffort.success, scalingEffort.failure);
+ } else {
+ log(id + " is not a scalable image!", "error");
+ scalingEffort.failure();
+ }
+ }, this)();
+ }
+ return scalingEffort;
+ },
+ _determineOutputType: function(spec) {
+ "use strict";
+ var requestedType = spec.requestedType, defaultType = spec.defaultType, referenceType = spec.refType;
+ if (!defaultType && !requestedType) {
+ if (referenceType !== "image/jpeg") {
+ return "image/png";
+ }
+ return referenceType;
+ }
+ if (!requestedType) {
+ return defaultType;
+ }
+ if (qq.indexOf(Object.keys(qq.Identify.prototype.PREVIEWABLE_MIME_TYPES), requestedType) >= 0) {
+ if (requestedType === "image/tiff") {
+ return qq.supportedFeatures.tiffPreviews ? requestedType : defaultType;
+ }
+ return requestedType;
+ }
+ return defaultType;
+ },
+ _getName: function(originalName, scaledVersionProperties) {
+ "use strict";
+ var startOfExt = originalName.lastIndexOf("."), versionType = scaledVersionProperties.type || "image/png", referenceType = scaledVersionProperties.refType, scaledName = "", scaledExt = qq.getExtension(originalName), nameAppendage = "";
+ if (scaledVersionProperties.name && scaledVersionProperties.name.trim().length) {
+ nameAppendage = " (" + scaledVersionProperties.name + ")";
+ }
+ if (startOfExt >= 0) {
+ scaledName = originalName.substr(0, startOfExt);
+ if (referenceType !== versionType) {
+ scaledExt = versionType.split("/")[1];
+ }
+ scaledName += nameAppendage + "." + scaledExt;
+ } else {
+ scaledName = originalName + nameAppendage;
+ }
+ return scaledName;
+ },
+ _getSortedSizes: function(sizes) {
+ "use strict";
+ sizes = qq.extend([], sizes);
+ return sizes.sort(function(a, b) {
+ if (a.maxSize > b.maxSize) {
+ return 1;
+ }
+ if (a.maxSize < b.maxSize) {
+ return -1;
+ }
+ return 0;
+ });
+ },
+ _generateScaledImage: function(spec, sourceFile) {
+ "use strict";
+ var self = this, customResizeFunction = spec.customResizeFunction, log = spec.log, maxSize = spec.maxSize, orient = spec.orient, type = spec.type, quality = spec.quality, failedText = spec.failedText, includeExif = spec.includeExif && sourceFile.type === "image/jpeg" && type === "image/jpeg", scalingEffort = new qq.Promise(), imageGenerator = new qq.ImageGenerator(log), canvas = document.createElement("canvas");
+ log("Attempting to generate scaled version for " + sourceFile.name);
+ imageGenerator.generate(sourceFile, canvas, {
+ maxSize: maxSize,
+ orient: orient,
+ customResizeFunction: customResizeFunction
+ }).then(function() {
+ var scaledImageDataUri = canvas.toDataURL(type, quality), signalSuccess = function() {
+ log("Success generating scaled version for " + sourceFile.name);
+ var blob = qq.dataUriToBlob(scaledImageDataUri);
+ scalingEffort.success(blob);
+ };
+ if (includeExif) {
+ self._insertExifHeader(sourceFile, scaledImageDataUri, log).then(function(scaledImageDataUriWithExif) {
+ scaledImageDataUri = scaledImageDataUriWithExif;
+ signalSuccess();
+ }, function() {
+ log("Problem inserting EXIF header into scaled image. Using scaled image w/out EXIF data.", "error");
+ signalSuccess();
+ });
+ } else {
+ signalSuccess();
+ }
+ }, function() {
+ log("Failed attempt to generate scaled version for " + sourceFile.name, "error");
+ scalingEffort.failure(failedText);
+ });
+ return scalingEffort;
+ },
+ _insertExifHeader: function(originalImage, scaledImageDataUri, log) {
+ "use strict";
+ var reader = new FileReader(), insertionEffort = new qq.Promise(), originalImageDataUri = "";
+ reader.onload = function() {
+ originalImageDataUri = reader.result;
+ insertionEffort.success(qq.ExifRestorer.restore(originalImageDataUri, scaledImageDataUri));
+ };
+ reader.onerror = function() {
+ log("Problem reading " + originalImage.name + " during attempt to transfer EXIF data to scaled version.", "error");
+ insertionEffort.failure();
+ };
+ reader.readAsDataURL(originalImage);
+ return insertionEffort;
+ },
+ _dataUriToBlob: function(dataUri) {
+ "use strict";
+ var byteString, mimeString, arrayBuffer, intArray;
+ if (dataUri.split(",")[0].indexOf("base64") >= 0) {
+ byteString = atob(dataUri.split(",")[1]);
+ } else {
+ byteString = decodeURI(dataUri.split(",")[1]);
+ }
+ mimeString = dataUri.split(",")[0].split(":")[1].split(";")[0];
+ arrayBuffer = new ArrayBuffer(byteString.length);
+ intArray = new Uint8Array(arrayBuffer);
+ qq.each(byteString, function(idx, character) {
+ intArray[idx] = character.charCodeAt(0);
+ });
+ return this._createBlob(arrayBuffer, mimeString);
+ },
+ _createBlob: function(data, mime) {
+ "use strict";
+ var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder, blobBuilder = BlobBuilder && new BlobBuilder();
+ if (blobBuilder) {
+ blobBuilder.append(data);
+ return blobBuilder.getBlob(mime);
+ } else {
+ return new Blob([ data ], {
+ type: mime
+ });
+ }
+ }
+ });
+ qq.ExifRestorer = function() {
+ var ExifRestorer = {};
+ ExifRestorer.KEY_STR = "ABCDEFGHIJKLMNOP" + "QRSTUVWXYZabcdef" + "ghijklmnopqrstuv" + "wxyz0123456789+/" + "=";
+ ExifRestorer.encode64 = function(input) {
+ var output = "", chr1, chr2, chr3 = "", enc1, enc2, enc3, enc4 = "", i = 0;
+ do {
+ chr1 = input[i++];
+ chr2 = input[i++];
+ chr3 = input[i++];
+ enc1 = chr1 >> 2;
+ enc2 = (chr1 & 3) << 4 | chr2 >> 4;
+ enc3 = (chr2 & 15) << 2 | chr3 >> 6;
+ enc4 = chr3 & 63;
+ if (isNaN(chr2)) {
+ enc3 = enc4 = 64;
+ } else if (isNaN(chr3)) {
+ enc4 = 64;
+ }
+ output = output + this.KEY_STR.charAt(enc1) + this.KEY_STR.charAt(enc2) + this.KEY_STR.charAt(enc3) + this.KEY_STR.charAt(enc4);
+ chr1 = chr2 = chr3 = "";
+ enc1 = enc2 = enc3 = enc4 = "";
+ } while (i < input.length);
+ return output;
+ };
+ ExifRestorer.restore = function(origFileBase64, resizedFileBase64) {
+ var expectedBase64Header = "data:image/jpeg;base64,";
+ if (!origFileBase64.match(expectedBase64Header)) {
+ return resizedFileBase64;
+ }
+ var rawImage = this.decode64(origFileBase64.replace(expectedBase64Header, ""));
+ var segments = this.slice2Segments(rawImage);
+ var image = this.exifManipulation(resizedFileBase64, segments);
+ return expectedBase64Header + this.encode64(image);
+ };
+ ExifRestorer.exifManipulation = function(resizedFileBase64, segments) {
+ var exifArray = this.getExifArray(segments), newImageArray = this.insertExif(resizedFileBase64, exifArray), aBuffer = new Uint8Array(newImageArray);
+ return aBuffer;
+ };
+ ExifRestorer.getExifArray = function(segments) {
+ var seg;
+ for (var x = 0; x < segments.length; x++) {
+ seg = segments[x];
+ if (seg[0] == 255 & seg[1] == 225) {
+ return seg;
+ }
+ }
+ return [];
+ };
+ ExifRestorer.insertExif = function(resizedFileBase64, exifArray) {
+ var imageData = resizedFileBase64.replace("data:image/jpeg;base64,", ""), buf = this.decode64(imageData), separatePoint = buf.indexOf(255, 3), mae = buf.slice(0, separatePoint), ato = buf.slice(separatePoint), array = mae;
+ array = array.concat(exifArray);
+ array = array.concat(ato);
+ return array;
+ };
+ ExifRestorer.slice2Segments = function(rawImageArray) {
+ var head = 0, segments = [];
+ while (1) {
+ if (rawImageArray[head] == 255 & rawImageArray[head + 1] == 218) {
+ break;
+ }
+ if (rawImageArray[head] == 255 & rawImageArray[head + 1] == 216) {
+ head += 2;
+ } else {
+ var length = rawImageArray[head + 2] * 256 + rawImageArray[head + 3], endPoint = head + length + 2, seg = rawImageArray.slice(head, endPoint);
+ segments.push(seg);
+ head = endPoint;
+ }
+ if (head > rawImageArray.length) {
+ break;
+ }
+ }
+ return segments;
+ };
+ ExifRestorer.decode64 = function(input) {
+ var output = "", chr1, chr2, chr3 = "", enc1, enc2, enc3, enc4 = "", i = 0, buf = [];
+ var base64test = /[^A-Za-z0-9\+\/\=]/g;
+ if (base64test.exec(input)) {
+ throw new Error("There were invalid base64 characters in the input text. " + "Valid base64 characters are A-Z, a-z, 0-9, '+', '/',and '='");
+ }
+ input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+ do {
+ enc1 = this.KEY_STR.indexOf(input.charAt(i++));
+ enc2 = this.KEY_STR.indexOf(input.charAt(i++));
+ enc3 = this.KEY_STR.indexOf(input.charAt(i++));
+ enc4 = this.KEY_STR.indexOf(input.charAt(i++));
+ chr1 = enc1 << 2 | enc2 >> 4;
+ chr2 = (enc2 & 15) << 4 | enc3 >> 2;
+ chr3 = (enc3 & 3) << 6 | enc4;
+ buf.push(chr1);
+ if (enc3 != 64) {
+ buf.push(chr2);
+ }
+ if (enc4 != 64) {
+ buf.push(chr3);
+ }
+ chr1 = chr2 = chr3 = "";
+ enc1 = enc2 = enc3 = enc4 = "";
+ } while (i < input.length);
+ return buf;
+ };
+ return ExifRestorer;
+ }();
+ qq.TotalProgress = function(callback, getSize) {
+ "use strict";
+ var perFileProgress = {}, totalLoaded = 0, totalSize = 0, lastLoadedSent = -1, lastTotalSent = -1, callbackProxy = function(loaded, total) {
+ if (loaded !== lastLoadedSent || total !== lastTotalSent) {
+ callback(loaded, total);
+ }
+ lastLoadedSent = loaded;
+ lastTotalSent = total;
+ }, noRetryableFiles = function(failed, retryable) {
+ var none = true;
+ qq.each(failed, function(idx, failedId) {
+ if (qq.indexOf(retryable, failedId) >= 0) {
+ none = false;
+ return false;
+ }
+ });
+ return none;
+ }, onCancel = function(id) {
+ updateTotalProgress(id, -1, -1);
+ delete perFileProgress[id];
+ }, onAllComplete = function(successful, failed, retryable) {
+ if (failed.length === 0 || noRetryableFiles(failed, retryable)) {
+ callbackProxy(totalSize, totalSize);
+ this.reset();
+ }
+ }, onNew = function(id) {
+ var size = getSize(id);
+ if (size > 0) {
+ updateTotalProgress(id, 0, size);
+ perFileProgress[id] = {
+ loaded: 0,
+ total: size
+ };
+ }
+ }, updateTotalProgress = function(id, newLoaded, newTotal) {
+ var oldLoaded = perFileProgress[id] ? perFileProgress[id].loaded : 0, oldTotal = perFileProgress[id] ? perFileProgress[id].total : 0;
+ if (newLoaded === -1 && newTotal === -1) {
+ totalLoaded -= oldLoaded;
+ totalSize -= oldTotal;
+ } else {
+ if (newLoaded) {
+ totalLoaded += newLoaded - oldLoaded;
+ }
+ if (newTotal) {
+ totalSize += newTotal - oldTotal;
+ }
+ }
+ callbackProxy(totalLoaded, totalSize);
+ };
+ qq.extend(this, {
+ onAllComplete: onAllComplete,
+ onStatusChange: function(id, oldStatus, newStatus) {
+ if (newStatus === qq.status.CANCELED || newStatus === qq.status.REJECTED) {
+ onCancel(id);
+ } else if (newStatus === qq.status.SUBMITTING) {
+ onNew(id);
+ }
+ },
+ onIndividualProgress: function(id, loaded, total) {
+ updateTotalProgress(id, loaded, total);
+ perFileProgress[id] = {
+ loaded: loaded,
+ total: total
+ };
+ },
+ onNewSize: function(id) {
+ onNew(id);
+ },
+ reset: function() {
+ perFileProgress = {};
+ totalLoaded = 0;
+ totalSize = 0;
+ }
+ });
+ };
+ qq.PasteSupport = function(o) {
+ "use strict";
+ var options, detachPasteHandler;
+ options = {
+ targetElement: null,
+ callbacks: {
+ log: function(message, level) {},
+ pasteReceived: function(blob) {}
+ }
+ };
+ function isImage(item) {
+ return item.type && item.type.indexOf("image/") === 0;
+ }
+ function registerPasteHandler() {
+ detachPasteHandler = qq(options.targetElement).attach("paste", function(event) {
+ var clipboardData = event.clipboardData;
+ if (clipboardData) {
+ qq.each(clipboardData.items, function(idx, item) {
+ if (isImage(item)) {
+ var blob = item.getAsFile();
+ options.callbacks.pasteReceived(blob);
+ }
+ });
+ }
+ });
+ }
+ function unregisterPasteHandler() {
+ if (detachPasteHandler) {
+ detachPasteHandler();
+ }
+ }
+ qq.extend(options, o);
+ registerPasteHandler();
+ qq.extend(this, {
+ reset: function() {
+ unregisterPasteHandler();
+ }
+ });
+ };
+ qq.FormSupport = function(options, startUpload, log) {
+ "use strict";
+ var self = this, interceptSubmit = options.interceptSubmit, formEl = options.element, autoUpload = options.autoUpload;
+ qq.extend(this, {
+ newEndpoint: null,
+ newAutoUpload: autoUpload,
+ attachedToForm: false,
+ getFormInputsAsObject: function() {
+ if (formEl == null) {
+ return null;
+ }
+ return self._form2Obj(formEl);
+ }
+ });
+ function determineNewEndpoint(formEl) {
+ if (formEl.getAttribute("action")) {
+ self.newEndpoint = formEl.getAttribute("action");
+ }
+ }
+ function validateForm(formEl, nativeSubmit) {
+ if (formEl.checkValidity && !formEl.checkValidity()) {
+ log("Form did not pass validation checks - will not upload.", "error");
+ nativeSubmit();
+ } else {
+ return true;
+ }
+ }
+ function maybeUploadOnSubmit(formEl) {
+ var nativeSubmit = formEl.submit;
+ qq(formEl).attach("submit", function(event) {
+ event = event || window.event;
+ if (event.preventDefault) {
+ event.preventDefault();
+ } else {
+ event.returnValue = false;
+ }
+ validateForm(formEl, nativeSubmit) && startUpload();
+ });
+ formEl.submit = function() {
+ validateForm(formEl, nativeSubmit) && startUpload();
+ };
+ }
+ function determineFormEl(formEl) {
+ if (formEl) {
+ if (qq.isString(formEl)) {
+ formEl = document.getElementById(formEl);
+ }
+ if (formEl) {
+ log("Attaching to form element.");
+ determineNewEndpoint(formEl);
+ interceptSubmit && maybeUploadOnSubmit(formEl);
+ }
+ }
+ return formEl;
+ }
+ formEl = determineFormEl(formEl);
+ this.attachedToForm = !!formEl;
+ };
+ qq.extend(qq.FormSupport.prototype, {
+ _form2Obj: function(form) {
+ "use strict";
+ var obj = {}, notIrrelevantType = function(type) {
+ var irrelevantTypes = [ "button", "image", "reset", "submit" ];
+ return qq.indexOf(irrelevantTypes, type.toLowerCase()) < 0;
+ }, radioOrCheckbox = function(type) {
+ return qq.indexOf([ "checkbox", "radio" ], type.toLowerCase()) >= 0;
+ }, ignoreValue = function(el) {
+ if (radioOrCheckbox(el.type) && !el.checked) {
+ return true;
+ }
+ return el.disabled && el.type.toLowerCase() !== "hidden";
+ }, selectValue = function(select) {
+ var value = null;
+ qq.each(qq(select).children(), function(idx, child) {
+ if (child.tagName.toLowerCase() === "option" && child.selected) {
+ value = child.value;
+ return false;
+ }
+ });
+ return value;
+ };
+ qq.each(form.elements, function(idx, el) {
+ if ((qq.isInput(el, true) || el.tagName.toLowerCase() === "textarea") && notIrrelevantType(el.type) && !ignoreValue(el)) {
+ obj[el.name] = el.value;
+ } else if (el.tagName.toLowerCase() === "select" && !ignoreValue(el)) {
+ var value = selectValue(el);
+ if (value !== null) {
+ obj[el.name] = value;
+ }
+ }
+ });
+ return obj;
+ }
+ });
+ qq.traditional = qq.traditional || {};
+ qq.traditional.FormUploadHandler = function(options, proxy) {
+ "use strict";
+ var handler = this, getName = proxy.getName, getUuid = proxy.getUuid, log = proxy.log;
+ function getIframeContentJson(id, iframe) {
+ var response, doc, innerHtml;
+ try {
+ doc = iframe.contentDocument || iframe.contentWindow.document;
+ innerHtml = doc.body.innerHTML;
+ log("converting iframe's innerHTML to JSON");
+ log("innerHTML = " + innerHtml);
+ if (innerHtml && innerHtml.match(/^ 1 && !options.allowMultipleItems) {
+ options.callbacks.processingDroppedFilesComplete([]);
+ options.callbacks.dropError("tooManyFilesError", "");
+ uploadDropZone.dropDisabled(false);
+ handleDataTransferPromise.failure();
+ } else {
+ droppedFiles = [];
+ if (qq.isFolderDropSupported(dataTransfer)) {
+ qq.each(dataTransfer.items, function(idx, item) {
+ var entry = item.webkitGetAsEntry();
+ if (entry) {
+ if (entry.isFile) {
+ droppedFiles.push(item.getAsFile());
+ } else {
+ pendingFolderPromises.push(traverseFileTree(entry).done(function() {
+ pendingFolderPromises.pop();
+ if (pendingFolderPromises.length === 0) {
+ handleDataTransferPromise.success();
+ }
+ }));
+ }
+ }
+ });
+ } else {
+ droppedFiles = dataTransfer.files;
+ }
+ if (pendingFolderPromises.length === 0) {
+ handleDataTransferPromise.success();
+ }
+ }
+ return handleDataTransferPromise;
+ }
+ function setupDropzone(dropArea) {
+ var dropZone = new qq.UploadDropZone({
+ HIDE_ZONES_EVENT_NAME: HIDE_ZONES_EVENT_NAME,
+ element: dropArea,
+ onEnter: function(e) {
+ qq(dropArea).addClass(options.classes.dropActive);
+ e.stopPropagation();
+ },
+ onLeaveNotDescendants: function(e) {
+ qq(dropArea).removeClass(options.classes.dropActive);
+ },
+ onDrop: function(e) {
+ handleDataTransfer(e.dataTransfer, dropZone).then(function() {
+ uploadDroppedFiles(droppedFiles, dropZone);
+ }, function() {
+ options.callbacks.dropLog("Drop event DataTransfer parsing failed. No files will be uploaded.", "error");
+ });
+ }
+ });
+ disposeSupport.addDisposer(function() {
+ dropZone.dispose();
+ });
+ qq(dropArea).hasAttribute(HIDE_BEFORE_ENTER_ATTR) && qq(dropArea).hide();
+ uploadDropZones.push(dropZone);
+ return dropZone;
+ }
+ function isFileDrag(dragEvent) {
+ var fileDrag;
+ qq.each(dragEvent.dataTransfer.types, function(key, val) {
+ if (val === "Files") {
+ fileDrag = true;
+ return false;
+ }
+ });
+ return fileDrag;
+ }
+ function leavingDocumentOut(e) {
+ if (qq.safari()) {
+ return e.x < 0 || e.y < 0;
+ }
+ return e.x === 0 && e.y === 0;
+ }
+ function setupDragDrop() {
+ var dropZones = options.dropZoneElements, maybeHideDropZones = function() {
+ setTimeout(function() {
+ qq.each(dropZones, function(idx, dropZone) {
+ qq(dropZone).hasAttribute(HIDE_BEFORE_ENTER_ATTR) && qq(dropZone).hide();
+ qq(dropZone).removeClass(options.classes.dropActive);
+ });
+ }, 10);
+ };
+ qq.each(dropZones, function(idx, dropZone) {
+ var uploadDropZone = setupDropzone(dropZone);
+ if (dropZones.length && qq.supportedFeatures.fileDrop) {
+ disposeSupport.attach(document, "dragenter", function(e) {
+ if (!uploadDropZone.dropDisabled() && isFileDrag(e)) {
+ qq.each(dropZones, function(idx, dropZone) {
+ if (dropZone instanceof HTMLElement && qq(dropZone).hasAttribute(HIDE_BEFORE_ENTER_ATTR)) {
+ qq(dropZone).css({
+ display: "block"
+ });
+ }
+ });
+ }
+ });
+ }
+ });
+ disposeSupport.attach(document, "dragleave", function(e) {
+ if (leavingDocumentOut(e)) {
+ maybeHideDropZones();
+ }
+ });
+ disposeSupport.attach(qq(document).children()[0], "mouseenter", function(e) {
+ maybeHideDropZones();
+ });
+ disposeSupport.attach(document, "drop", function(e) {
+ if (isFileDrag(e)) {
+ e.preventDefault();
+ maybeHideDropZones();
+ }
+ });
+ disposeSupport.attach(document, HIDE_ZONES_EVENT_NAME, maybeHideDropZones);
+ }
+ setupDragDrop();
+ qq.extend(this, {
+ setupExtraDropzone: function(element) {
+ options.dropZoneElements.push(element);
+ setupDropzone(element);
+ },
+ removeDropzone: function(element) {
+ var i, dzs = options.dropZoneElements;
+ for (i in dzs) {
+ if (dzs[i] === element) {
+ return dzs.splice(i, 1);
+ }
+ }
+ },
+ dispose: function() {
+ disposeSupport.dispose();
+ qq.each(uploadDropZones, function(idx, dropZone) {
+ dropZone.dispose();
+ });
+ }
+ });
+ };
+ qq.DragAndDrop.callbacks = function() {
+ "use strict";
+ return {
+ processingDroppedFiles: function() {},
+ processingDroppedFilesComplete: function(files, targetEl) {},
+ dropError: function(code, errorSpecifics) {
+ qq.log("Drag & drop error code '" + code + " with these specifics: '" + errorSpecifics + "'", "error");
+ },
+ dropLog: function(message, level) {
+ qq.log(message, level);
+ }
+ };
+ };
+ qq.UploadDropZone = function(o) {
+ "use strict";
+ var disposeSupport = new qq.DisposeSupport(), options, element, preventDrop, dropOutsideDisabled;
+ options = {
+ element: null,
+ onEnter: function(e) {},
+ onLeave: function(e) {},
+ onLeaveNotDescendants: function(e) {},
+ onDrop: function(e) {}
+ };
+ qq.extend(options, o);
+ element = options.element;
+ function dragoverShouldBeCanceled() {
+ return qq.safari() || qq.firefox() && qq.windows();
+ }
+ function disableDropOutside(e) {
+ if (!dropOutsideDisabled) {
+ if (dragoverShouldBeCanceled) {
+ disposeSupport.attach(document, "dragover", function(e) {
+ e.preventDefault();
+ });
+ } else {
+ disposeSupport.attach(document, "dragover", function(e) {
+ if (e.dataTransfer) {
+ e.dataTransfer.dropEffect = "none";
+ e.preventDefault();
+ }
+ });
+ }
+ dropOutsideDisabled = true;
+ }
+ }
+ function isValidFileDrag(e) {
+ if (!qq.supportedFeatures.fileDrop) {
+ return false;
+ }
+ var effectTest, dt = e.dataTransfer, isSafari = qq.safari();
+ effectTest = qq.ie() && qq.supportedFeatures.fileDrop ? true : dt.effectAllowed !== "none";
+ return dt && effectTest && (dt.files && dt.files.length || !isSafari && dt.types.contains && dt.types.contains("Files") || dt.types.includes && dt.types.includes("Files"));
+ }
+ function isOrSetDropDisabled(isDisabled) {
+ if (isDisabled !== undefined) {
+ preventDrop = isDisabled;
+ }
+ return preventDrop;
+ }
+ function triggerHidezonesEvent() {
+ var hideZonesEvent;
+ function triggerUsingOldApi() {
+ hideZonesEvent = document.createEvent("Event");
+ hideZonesEvent.initEvent(options.HIDE_ZONES_EVENT_NAME, true, true);
+ }
+ if (window.CustomEvent) {
+ try {
+ hideZonesEvent = new CustomEvent(options.HIDE_ZONES_EVENT_NAME);
+ } catch (err) {
+ triggerUsingOldApi();
+ }
+ } else {
+ triggerUsingOldApi();
+ }
+ document.dispatchEvent(hideZonesEvent);
+ }
+ function attachEvents() {
+ disposeSupport.attach(element, "dragover", function(e) {
+ if (!isValidFileDrag(e)) {
+ return;
+ }
+ var effect = qq.ie() && qq.supportedFeatures.fileDrop ? null : e.dataTransfer.effectAllowed;
+ if (effect === "move" || effect === "linkMove") {
+ e.dataTransfer.dropEffect = "move";
+ } else {
+ e.dataTransfer.dropEffect = "copy";
+ }
+ e.stopPropagation();
+ e.preventDefault();
+ });
+ disposeSupport.attach(element, "dragenter", function(e) {
+ if (!isOrSetDropDisabled()) {
+ if (!isValidFileDrag(e)) {
+ return;
+ }
+ options.onEnter(e);
+ }
+ });
+ disposeSupport.attach(element, "dragleave", function(e) {
+ if (!isValidFileDrag(e)) {
+ return;
+ }
+ options.onLeave(e);
+ var relatedTarget = document.elementFromPoint(e.clientX, e.clientY);
+ if (qq(this).contains(relatedTarget)) {
+ return;
+ }
+ options.onLeaveNotDescendants(e);
+ });
+ disposeSupport.attach(element, "drop", function(e) {
+ if (!isOrSetDropDisabled()) {
+ if (!isValidFileDrag(e)) {
+ return;
+ }
+ e.preventDefault();
+ e.stopPropagation();
+ options.onDrop(e);
+ triggerHidezonesEvent();
+ }
+ });
+ }
+ disableDropOutside();
+ attachEvents();
+ qq.extend(this, {
+ dropDisabled: function(isDisabled) {
+ return isOrSetDropDisabled(isDisabled);
+ },
+ dispose: function() {
+ disposeSupport.dispose();
+ },
+ getElement: function() {
+ return element;
+ }
+ });
+ this._testing = {};
+ this._testing.isValidFileDrag = isValidFileDrag;
+ };
+ (function() {
+ "use strict";
+ qq.uiPublicApi = {
+ addInitialFiles: function(cannedFileList) {
+ this._parent.prototype.addInitialFiles.apply(this, arguments);
+ this._templating.addCacheToDom();
+ },
+ clearStoredFiles: function() {
+ this._parent.prototype.clearStoredFiles.apply(this, arguments);
+ this._templating.clearFiles();
+ },
+ addExtraDropzone: function(element) {
+ this._dnd && this._dnd.setupExtraDropzone(element);
+ },
+ removeExtraDropzone: function(element) {
+ if (this._dnd) {
+ return this._dnd.removeDropzone(element);
+ }
+ },
+ getItemByFileId: function(id) {
+ if (!this._templating.isHiddenForever(id)) {
+ return this._templating.getFileContainer(id);
+ }
+ },
+ reset: function() {
+ this._parent.prototype.reset.apply(this, arguments);
+ this._templating.reset();
+ if (!this._options.button && this._templating.getButton()) {
+ this._defaultButtonId = this._createUploadButton({
+ element: this._templating.getButton(),
+ title: this._options.text.fileInputTitle
+ }).getButtonId();
+ }
+ if (this._dnd) {
+ this._dnd.dispose();
+ this._dnd = this._setupDragAndDrop();
+ }
+ this._totalFilesInBatch = 0;
+ this._filesInBatchAddedToUi = 0;
+ this._setupClickAndEditEventHandlers();
+ },
+ setName: function(id, newName) {
+ var formattedFilename = this._options.formatFileName(newName);
+ this._parent.prototype.setName.apply(this, arguments);
+ this._templating.updateFilename(id, formattedFilename);
+ },
+ pauseUpload: function(id) {
+ var paused = this._parent.prototype.pauseUpload.apply(this, arguments);
+ paused && this._templating.uploadPaused(id);
+ return paused;
+ },
+ continueUpload: function(id) {
+ var continued = this._parent.prototype.continueUpload.apply(this, arguments);
+ continued && this._templating.uploadContinued(id);
+ return continued;
+ },
+ getId: function(fileContainerOrChildEl) {
+ return this._templating.getFileId(fileContainerOrChildEl);
+ },
+ getDropTarget: function(fileId) {
+ var file = this.getFile(fileId);
+ return file.qqDropTarget;
+ }
+ };
+ qq.uiPrivateApi = {
+ _getButton: function(buttonId) {
+ var button = this._parent.prototype._getButton.apply(this, arguments);
+ if (!button) {
+ if (buttonId === this._defaultButtonId) {
+ button = this._templating.getButton();
+ }
+ }
+ return button;
+ },
+ _removeFileItem: function(fileId) {
+ this._templating.removeFile(fileId);
+ },
+ _setupClickAndEditEventHandlers: function() {
+ this._fileButtonsClickHandler = qq.FileButtonsClickHandler && this._bindFileButtonsClickEvent();
+ this._focusinEventSupported = !qq.firefox();
+ if (this._isEditFilenameEnabled()) {
+ this._filenameClickHandler = this._bindFilenameClickEvent();
+ this._filenameInputFocusInHandler = this._bindFilenameInputFocusInEvent();
+ this._filenameInputFocusHandler = this._bindFilenameInputFocusEvent();
+ }
+ },
+ _setupDragAndDrop: function() {
+ var self = this, dropZoneElements = this._options.dragAndDrop.extraDropzones, templating = this._templating, defaultDropZone = templating.getDropZone();
+ defaultDropZone && dropZoneElements.push(defaultDropZone);
+ return new qq.DragAndDrop({
+ dropZoneElements: dropZoneElements,
+ allowMultipleItems: this._options.multiple,
+ classes: {
+ dropActive: this._options.classes.dropActive
+ },
+ callbacks: {
+ processingDroppedFiles: function() {
+ templating.showDropProcessing();
+ },
+ processingDroppedFilesComplete: function(files, targetEl) {
+ templating.hideDropProcessing();
+ qq.each(files, function(idx, file) {
+ file.qqDropTarget = targetEl;
+ });
+ if (files.length) {
+ self.addFiles(files, null, null);
+ }
+ },
+ dropError: function(code, errorData) {
+ self._itemError(code, errorData);
+ },
+ dropLog: function(message, level) {
+ self.log(message, level);
+ }
+ }
+ });
+ },
+ _bindFileButtonsClickEvent: function() {
+ var self = this;
+ return new qq.FileButtonsClickHandler({
+ templating: this._templating,
+ log: function(message, lvl) {
+ self.log(message, lvl);
+ },
+ onDeleteFile: function(fileId) {
+ self.deleteFile(fileId);
+ },
+ onCancel: function(fileId) {
+ self.cancel(fileId);
+ },
+ onRetry: function(fileId) {
+ self.retry(fileId);
+ },
+ onPause: function(fileId) {
+ self.pauseUpload(fileId);
+ },
+ onContinue: function(fileId) {
+ self.continueUpload(fileId);
+ },
+ onGetName: function(fileId) {
+ return self.getName(fileId);
+ }
+ });
+ },
+ _isEditFilenameEnabled: function() {
+ return this._templating.isEditFilenamePossible() && !this._options.autoUpload && qq.FilenameClickHandler && qq.FilenameInputFocusHandler && qq.FilenameInputFocusHandler;
+ },
+ _filenameEditHandler: function() {
+ var self = this, templating = this._templating;
+ return {
+ templating: templating,
+ log: function(message, lvl) {
+ self.log(message, lvl);
+ },
+ onGetUploadStatus: function(fileId) {
+ return self.getUploads({
+ id: fileId
+ }).status;
+ },
+ onGetName: function(fileId) {
+ return self.getName(fileId);
+ },
+ onSetName: function(id, newName) {
+ self.setName(id, newName);
+ },
+ onEditingStatusChange: function(id, isEditing) {
+ var qqInput = qq(templating.getEditInput(id)), qqFileContainer = qq(templating.getFileContainer(id));
+ if (isEditing) {
+ qqInput.addClass("qq-editing");
+ templating.hideFilename(id);
+ templating.hideEditIcon(id);
+ } else {
+ qqInput.removeClass("qq-editing");
+ templating.showFilename(id);
+ templating.showEditIcon(id);
+ }
+ qqFileContainer.addClass("qq-temp").removeClass("qq-temp");
+ }
+ };
+ },
+ _onUploadStatusChange: function(id, oldStatus, newStatus) {
+ this._parent.prototype._onUploadStatusChange.apply(this, arguments);
+ if (this._isEditFilenameEnabled()) {
+ if (this._templating.getFileContainer(id) && newStatus !== qq.status.SUBMITTED) {
+ this._templating.markFilenameEditable(id);
+ this._templating.hideEditIcon(id);
+ }
+ }
+ if (oldStatus === qq.status.UPLOAD_RETRYING && newStatus === qq.status.UPLOADING) {
+ this._templating.hideRetry(id);
+ this._templating.setStatusText(id);
+ qq(this._templating.getFileContainer(id)).removeClass(this._classes.retrying);
+ } else if (newStatus === qq.status.UPLOAD_FAILED) {
+ this._templating.hidePause(id);
+ }
+ },
+ _bindFilenameInputFocusInEvent: function() {
+ var spec = qq.extend({}, this._filenameEditHandler());
+ return new qq.FilenameInputFocusInHandler(spec);
+ },
+ _bindFilenameInputFocusEvent: function() {
+ var spec = qq.extend({}, this._filenameEditHandler());
+ return new qq.FilenameInputFocusHandler(spec);
+ },
+ _bindFilenameClickEvent: function() {
+ var spec = qq.extend({}, this._filenameEditHandler());
+ return new qq.FilenameClickHandler(spec);
+ },
+ _storeForLater: function(id) {
+ this._parent.prototype._storeForLater.apply(this, arguments);
+ this._templating.hideSpinner(id);
+ },
+ _onAllComplete: function(successful, failed) {
+ this._parent.prototype._onAllComplete.apply(this, arguments);
+ this._templating.resetTotalProgress();
+ },
+ _onSubmit: function(id, name) {
+ var file = this.getFile(id);
+ if (file && file.qqPath && this._options.dragAndDrop.reportDirectoryPaths) {
+ this._paramsStore.addReadOnly(id, {
+ qqpath: file.qqPath
+ });
+ }
+ this._parent.prototype._onSubmit.apply(this, arguments);
+ this._addToList(id, name);
+ },
+ _onSubmitted: function(id) {
+ if (this._isEditFilenameEnabled()) {
+ this._templating.markFilenameEditable(id);
+ this._templating.showEditIcon(id);
+ if (!this._focusinEventSupported) {
+ this._filenameInputFocusHandler.addHandler(this._templating.getEditInput(id));
+ }
+ }
+ },
+ _onProgress: function(id, name, loaded, total) {
+ this._parent.prototype._onProgress.apply(this, arguments);
+ this._templating.updateProgress(id, loaded, total);
+ if (total === 0 || Math.round(loaded / total * 100) === 100) {
+ this._templating.hideCancel(id);
+ this._templating.hidePause(id);
+ this._templating.hideProgress(id);
+ this._templating.setStatusText(id, this._options.text.waitingForResponse);
+ this._displayFileSize(id);
+ } else {
+ this._displayFileSize(id, loaded, total);
+ }
+ },
+ _onTotalProgress: function(loaded, total) {
+ this._parent.prototype._onTotalProgress.apply(this, arguments);
+ this._templating.updateTotalProgress(loaded, total);
+ },
+ _onComplete: function(id, name, result, xhr) {
+ var parentRetVal = this._parent.prototype._onComplete.apply(this, arguments), templating = this._templating, fileContainer = templating.getFileContainer(id), self = this;
+ function completeUpload(result) {
+ if (!fileContainer) {
+ return;
+ }
+ templating.setStatusText(id);
+ qq(fileContainer).removeClass(self._classes.retrying);
+ templating.hideProgress(id);
+ if (self.getUploads({
+ id: id
+ }).status !== qq.status.UPLOAD_FAILED) {
+ templating.hideCancel(id);
+ }
+ templating.hideSpinner(id);
+ if (result.success) {
+ self._markFileAsSuccessful(id);
+ } else {
+ qq(fileContainer).addClass(self._classes.fail);
+ templating.showCancel(id);
+ if (templating.isRetryPossible() && !self._preventRetries[id]) {
+ qq(fileContainer).addClass(self._classes.retryable);
+ templating.showRetry(id);
+ }
+ self._controlFailureTextDisplay(id, result);
+ }
+ }
+ if (parentRetVal instanceof qq.Promise) {
+ parentRetVal.done(function(newResult) {
+ completeUpload(newResult);
+ });
+ } else {
+ completeUpload(result);
+ }
+ return parentRetVal;
+ },
+ _markFileAsSuccessful: function(id) {
+ var templating = this._templating;
+ if (this._isDeletePossible()) {
+ templating.showDeleteButton(id);
+ }
+ qq(templating.getFileContainer(id)).addClass(this._classes.success);
+ this._maybeUpdateThumbnail(id);
+ },
+ _onUploadPrep: function(id) {
+ this._parent.prototype._onUploadPrep.apply(this, arguments);
+ this._templating.showSpinner(id);
+ },
+ _onUpload: function(id, name) {
+ var parentRetVal = this._parent.prototype._onUpload.apply(this, arguments);
+ this._templating.showSpinner(id);
+ return parentRetVal;
+ },
+ _onUploadChunk: function(id, chunkData) {
+ this._parent.prototype._onUploadChunk.apply(this, arguments);
+ if (chunkData.partIndex > 0 && this._handler.isResumable(id)) {
+ this._templating.allowPause(id);
+ }
+ },
+ _onCancel: function(id, name) {
+ this._parent.prototype._onCancel.apply(this, arguments);
+ this._removeFileItem(id);
+ if (this._getNotFinished() === 0) {
+ this._templating.resetTotalProgress();
+ }
+ },
+ _onBeforeAutoRetry: function(id) {
+ var retryNumForDisplay, maxAuto, retryNote;
+ this._parent.prototype._onBeforeAutoRetry.apply(this, arguments);
+ this._showCancelLink(id);
+ if (this._options.retry.showAutoRetryNote) {
+ retryNumForDisplay = this._autoRetries[id];
+ maxAuto = this._options.retry.maxAutoAttempts;
+ retryNote = this._options.retry.autoRetryNote.replace(/\{retryNum\}/g, retryNumForDisplay);
+ retryNote = retryNote.replace(/\{maxAuto\}/g, maxAuto);
+ this._templating.setStatusText(id, retryNote);
+ qq(this._templating.getFileContainer(id)).addClass(this._classes.retrying);
+ }
+ },
+ _onBeforeManualRetry: function(id) {
+ if (this._parent.prototype._onBeforeManualRetry.apply(this, arguments)) {
+ this._templating.resetProgress(id);
+ qq(this._templating.getFileContainer(id)).removeClass(this._classes.fail);
+ this._templating.setStatusText(id);
+ this._templating.showSpinner(id);
+ this._showCancelLink(id);
+ return true;
+ } else {
+ qq(this._templating.getFileContainer(id)).addClass(this._classes.retryable);
+ this._templating.showRetry(id);
+ return false;
+ }
+ },
+ _onSubmitDelete: function(id) {
+ var onSuccessCallback = qq.bind(this._onSubmitDeleteSuccess, this);
+ this._parent.prototype._onSubmitDelete.call(this, id, onSuccessCallback);
+ },
+ _onSubmitDeleteSuccess: function(id, uuid, additionalMandatedParams) {
+ if (this._options.deleteFile.forceConfirm) {
+ this._showDeleteConfirm.apply(this, arguments);
+ } else {
+ this._sendDeleteRequest.apply(this, arguments);
+ }
+ },
+ _onDeleteComplete: function(id, xhr, isError) {
+ this._parent.prototype._onDeleteComplete.apply(this, arguments);
+ this._templating.hideSpinner(id);
+ if (isError) {
+ this._templating.setStatusText(id, this._options.deleteFile.deletingFailedText);
+ this._templating.showDeleteButton(id);
+ } else {
+ this._removeFileItem(id);
+ }
+ },
+ _sendDeleteRequest: function(id, uuid, additionalMandatedParams) {
+ this._templating.hideDeleteButton(id);
+ this._templating.showSpinner(id);
+ this._templating.setStatusText(id, this._options.deleteFile.deletingStatusText);
+ this._deleteHandler.sendDelete.apply(this, arguments);
+ },
+ _showDeleteConfirm: function(id, uuid, mandatedParams) {
+ var fileName = this.getName(id), confirmMessage = this._options.deleteFile.confirmMessage.replace(/\{filename\}/g, fileName), uuid = this.getUuid(id), deleteRequestArgs = arguments, self = this, retVal;
+ retVal = this._options.showConfirm(confirmMessage);
+ if (qq.isGenericPromise(retVal)) {
+ retVal.then(function() {
+ self._sendDeleteRequest.apply(self, deleteRequestArgs);
+ });
+ } else if (retVal !== false) {
+ self._sendDeleteRequest.apply(self, deleteRequestArgs);
+ }
+ },
+ _addToList: function(id, name, canned) {
+ var prependData, prependIndex = 0, dontDisplay = this._handler.isProxied(id) && this._options.scaling.hideScaled, record;
+ if (this._options.display.prependFiles) {
+ if (this._totalFilesInBatch > 1 && this._filesInBatchAddedToUi > 0) {
+ prependIndex = this._filesInBatchAddedToUi - 1;
+ }
+ prependData = {
+ index: prependIndex
+ };
+ }
+ if (!canned) {
+ if (this._options.disableCancelForFormUploads && !qq.supportedFeatures.ajaxUploading) {
+ this._templating.disableCancel();
+ }
+ if (!this._options.multiple) {
+ record = this.getUploads({
+ id: id
+ });
+ this._handledProxyGroup = this._handledProxyGroup || record.proxyGroupId;
+ if (record.proxyGroupId !== this._handledProxyGroup || !record.proxyGroupId) {
+ this._handler.cancelAll();
+ this._clearList();
+ this._handledProxyGroup = null;
+ }
+ }
+ }
+ if (canned) {
+ this._templating.addFileToCache(id, this._options.formatFileName(name), prependData, dontDisplay);
+ this._templating.updateThumbnail(id, this._thumbnailUrls[id], true, this._options.thumbnails.customResizer);
+ } else {
+ this._templating.addFile(id, this._options.formatFileName(name), prependData, dontDisplay);
+ this._templating.generatePreview(id, this.getFile(id), this._options.thumbnails.customResizer);
+ }
+ this._filesInBatchAddedToUi += 1;
+ if (canned || this._options.display.fileSizeOnSubmit && qq.supportedFeatures.ajaxUploading) {
+ this._displayFileSize(id);
+ }
+ },
+ _clearList: function() {
+ this._templating.clearFiles();
+ this.clearStoredFiles();
+ },
+ _displayFileSize: function(id, loadedSize, totalSize) {
+ var size = this.getSize(id), sizeForDisplay = this._formatSize(size);
+ if (size >= 0) {
+ if (loadedSize !== undefined && totalSize !== undefined) {
+ sizeForDisplay = this._formatProgress(loadedSize, totalSize);
+ }
+ this._templating.updateSize(id, sizeForDisplay);
+ }
+ },
+ _formatProgress: function(uploadedSize, totalSize) {
+ var message = this._options.text.formatProgress;
+ function r(name, replacement) {
+ message = message.replace(name, replacement);
+ }
+ r("{percent}", Math.round(uploadedSize / totalSize * 100));
+ r("{total_size}", this._formatSize(totalSize));
+ return message;
+ },
+ _controlFailureTextDisplay: function(id, response) {
+ var mode, responseProperty, failureReason;
+ mode = this._options.failedUploadTextDisplay.mode;
+ responseProperty = this._options.failedUploadTextDisplay.responseProperty;
+ if (mode === "custom") {
+ failureReason = response[responseProperty];
+ if (!failureReason) {
+ failureReason = this._options.text.failUpload;
+ }
+ this._templating.setStatusText(id, failureReason);
+ if (this._options.failedUploadTextDisplay.enableTooltip) {
+ this._showTooltip(id, failureReason);
+ }
+ } else if (mode === "default") {
+ this._templating.setStatusText(id, this._options.text.failUpload);
+ } else if (mode !== "none") {
+ this.log("failedUploadTextDisplay.mode value of '" + mode + "' is not valid", "warn");
+ }
+ },
+ _showTooltip: function(id, text) {
+ this._templating.getFileContainer(id).title = text;
+ },
+ _showCancelLink: function(id) {
+ if (!this._options.disableCancelForFormUploads || qq.supportedFeatures.ajaxUploading) {
+ this._templating.showCancel(id);
+ }
+ },
+ _itemError: function(code, name, item) {
+ var message = this._parent.prototype._itemError.apply(this, arguments);
+ this._options.showMessage(message);
+ },
+ _batchError: function(message) {
+ this._parent.prototype._batchError.apply(this, arguments);
+ this._options.showMessage(message);
+ },
+ _setupPastePrompt: function() {
+ var self = this;
+ this._options.callbacks.onPasteReceived = function() {
+ var message = self._options.paste.namePromptMessage, defaultVal = self._options.paste.defaultName;
+ return self._options.showPrompt(message, defaultVal);
+ };
+ },
+ _fileOrBlobRejected: function(id, name) {
+ this._totalFilesInBatch -= 1;
+ this._parent.prototype._fileOrBlobRejected.apply(this, arguments);
+ },
+ _prepareItemsForUpload: function(items, params, endpoint) {
+ this._totalFilesInBatch = items.length;
+ this._filesInBatchAddedToUi = 0;
+ this._parent.prototype._prepareItemsForUpload.apply(this, arguments);
+ },
+ _maybeUpdateThumbnail: function(fileId) {
+ var thumbnailUrl = this._thumbnailUrls[fileId], fileStatus = this.getUploads({
+ id: fileId
+ }).status;
+ if (fileStatus !== qq.status.DELETED && (thumbnailUrl || this._options.thumbnails.placeholders.waitUntilResponse || !qq.supportedFeatures.imagePreviews)) {
+ this._templating.updateThumbnail(fileId, thumbnailUrl, this._options.thumbnails.customResizer);
+ }
+ },
+ _addCannedFile: function(sessionData) {
+ var id = this._parent.prototype._addCannedFile.apply(this, arguments);
+ this._addToList(id, this.getName(id), true);
+ this._templating.hideSpinner(id);
+ this._templating.hideCancel(id);
+ this._markFileAsSuccessful(id);
+ return id;
+ },
+ _setSize: function(id, newSize) {
+ this._parent.prototype._setSize.apply(this, arguments);
+ this._templating.updateSize(id, this._formatSize(newSize));
+ },
+ _sessionRequestComplete: function() {
+ this._templating.addCacheToDom();
+ this._parent.prototype._sessionRequestComplete.apply(this, arguments);
+ }
+ };
+ })();
+ qq.FineUploader = function(o, namespace) {
+ "use strict";
+ var self = this;
+ this._parent = namespace ? qq[namespace].FineUploaderBasic : qq.FineUploaderBasic;
+ this._parent.apply(this, arguments);
+ qq.extend(this._options, {
+ element: null,
+ button: null,
+ listElement: null,
+ dragAndDrop: {
+ extraDropzones: [],
+ reportDirectoryPaths: false
+ },
+ text: {
+ formatProgress: "{percent}% of {total_size}",
+ failUpload: "Upload failed",
+ waitingForResponse: "Processing...",
+ paused: "Paused"
+ },
+ template: "qq-template",
+ classes: {
+ retrying: "qq-upload-retrying",
+ retryable: "qq-upload-retryable",
+ success: "qq-upload-success",
+ fail: "qq-upload-fail",
+ editable: "qq-editable",
+ hide: "qq-hide",
+ dropActive: "qq-upload-drop-area-active"
+ },
+ failedUploadTextDisplay: {
+ mode: "default",
+ responseProperty: "error",
+ enableTooltip: true
+ },
+ messages: {
+ tooManyFilesError: "You may only drop one file",
+ unsupportedBrowser: "Unrecoverable error - this browser does not permit file uploading of any kind."
+ },
+ retry: {
+ showAutoRetryNote: true,
+ autoRetryNote: "Retrying {retryNum}/{maxAuto}..."
+ },
+ deleteFile: {
+ forceConfirm: false,
+ confirmMessage: "Are you sure you want to delete {filename}?",
+ deletingStatusText: "Deleting...",
+ deletingFailedText: "Delete failed"
+ },
+ display: {
+ fileSizeOnSubmit: false,
+ prependFiles: false
+ },
+ paste: {
+ promptForName: false,
+ namePromptMessage: "Please name this image"
+ },
+ thumbnails: {
+ customResizer: null,
+ maxCount: 0,
+ placeholders: {
+ waitUntilResponse: false,
+ notAvailablePath: null,
+ waitingPath: null
+ },
+ timeBetweenThumbs: 750
+ },
+ scaling: {
+ hideScaled: false
+ },
+ showMessage: function(message) {
+ if (self._templating.hasDialog("alert")) {
+ return self._templating.showDialog("alert", message);
+ } else {
+ setTimeout(function() {
+ window.alert(message);
+ }, 0);
+ }
+ },
+ showConfirm: function(message) {
+ if (self._templating.hasDialog("confirm")) {
+ return self._templating.showDialog("confirm", message);
+ } else {
+ return window.confirm(message);
+ }
+ },
+ showPrompt: function(message, defaultValue) {
+ if (self._templating.hasDialog("prompt")) {
+ return self._templating.showDialog("prompt", message, defaultValue);
+ } else {
+ return window.prompt(message, defaultValue);
+ }
+ }
+ }, true);
+ qq.extend(this._options, o, true);
+ this._templating = new qq.Templating({
+ log: qq.bind(this.log, this),
+ templateIdOrEl: this._options.template,
+ containerEl: this._options.element,
+ fileContainerEl: this._options.listElement,
+ button: this._options.button,
+ imageGenerator: this._imageGenerator,
+ classes: {
+ hide: this._options.classes.hide,
+ editable: this._options.classes.editable
+ },
+ limits: {
+ maxThumbs: this._options.thumbnails.maxCount,
+ timeBetweenThumbs: this._options.thumbnails.timeBetweenThumbs
+ },
+ placeholders: {
+ waitUntilUpdate: this._options.thumbnails.placeholders.waitUntilResponse,
+ thumbnailNotAvailable: this._options.thumbnails.placeholders.notAvailablePath,
+ waitingForThumbnail: this._options.thumbnails.placeholders.waitingPath
+ },
+ text: this._options.text
+ });
+ if (this._options.workarounds.ios8SafariUploads && qq.ios800() && qq.iosSafari()) {
+ this._templating.renderFailure(this._options.messages.unsupportedBrowserIos8Safari);
+ } else if (!qq.supportedFeatures.uploading || this._options.cors.expected && !qq.supportedFeatures.uploadCors) {
+ this._templating.renderFailure(this._options.messages.unsupportedBrowser);
+ } else {
+ this._wrapCallbacks();
+ this._templating.render();
+ this._classes = this._options.classes;
+ if (!this._options.button && this._templating.getButton()) {
+ this._defaultButtonId = this._createUploadButton({
+ element: this._templating.getButton(),
+ title: this._options.text.fileInputTitle
+ }).getButtonId();
+ }
+ this._setupClickAndEditEventHandlers();
+ if (qq.DragAndDrop && qq.supportedFeatures.fileDrop) {
+ this._dnd = this._setupDragAndDrop();
+ }
+ if (this._options.paste.targetElement && this._options.paste.promptForName) {
+ if (qq.PasteSupport) {
+ this._setupPastePrompt();
+ } else {
+ this.log("Paste support module not found.", "error");
+ }
+ }
+ this._totalFilesInBatch = 0;
+ this._filesInBatchAddedToUi = 0;
+ }
+ };
+ qq.extend(qq.FineUploader.prototype, qq.basePublicApi);
+ qq.extend(qq.FineUploader.prototype, qq.basePrivateApi);
+ qq.extend(qq.FineUploader.prototype, qq.uiPublicApi);
+ qq.extend(qq.FineUploader.prototype, qq.uiPrivateApi);
+ qq.Templating = function(spec) {
+ "use strict";
+ var FILE_ID_ATTR = "qq-file-id", FILE_CLASS_PREFIX = "qq-file-id-", THUMBNAIL_MAX_SIZE_ATTR = "qq-max-size", THUMBNAIL_SERVER_SCALE_ATTR = "qq-server-scale", HIDE_DROPZONE_ATTR = "qq-hide-dropzone", DROPZPONE_TEXT_ATTR = "qq-drop-area-text", IN_PROGRESS_CLASS = "qq-in-progress", HIDDEN_FOREVER_CLASS = "qq-hidden-forever", fileBatch = {
+ content: document.createDocumentFragment(),
+ map: {}
+ }, isCancelDisabled = false, generatedThumbnails = 0, thumbnailQueueMonitorRunning = false, thumbGenerationQueue = [], thumbnailMaxSize = -1, options = {
+ log: null,
+ limits: {
+ maxThumbs: 0,
+ timeBetweenThumbs: 750
+ },
+ templateIdOrEl: "qq-template",
+ containerEl: null,
+ fileContainerEl: null,
+ button: null,
+ imageGenerator: null,
+ classes: {
+ hide: "qq-hide",
+ editable: "qq-editable"
+ },
+ placeholders: {
+ waitUntilUpdate: false,
+ thumbnailNotAvailable: null,
+ waitingForThumbnail: null
+ },
+ text: {
+ paused: "Paused"
+ }
+ }, selectorClasses = {
+ button: "qq-upload-button-selector",
+ alertDialog: "qq-alert-dialog-selector",
+ dialogCancelButton: "qq-cancel-button-selector",
+ confirmDialog: "qq-confirm-dialog-selector",
+ dialogMessage: "qq-dialog-message-selector",
+ dialogOkButton: "qq-ok-button-selector",
+ promptDialog: "qq-prompt-dialog-selector",
+ uploader: "qq-uploader-selector",
+ drop: "qq-upload-drop-area-selector",
+ list: "qq-upload-list-selector",
+ progressBarContainer: "qq-progress-bar-container-selector",
+ progressBar: "qq-progress-bar-selector",
+ totalProgressBarContainer: "qq-total-progress-bar-container-selector",
+ totalProgressBar: "qq-total-progress-bar-selector",
+ file: "qq-upload-file-selector",
+ spinner: "qq-upload-spinner-selector",
+ size: "qq-upload-size-selector",
+ cancel: "qq-upload-cancel-selector",
+ pause: "qq-upload-pause-selector",
+ continueButton: "qq-upload-continue-selector",
+ deleteButton: "qq-upload-delete-selector",
+ retry: "qq-upload-retry-selector",
+ statusText: "qq-upload-status-text-selector",
+ editFilenameInput: "qq-edit-filename-selector",
+ editNameIcon: "qq-edit-filename-icon-selector",
+ dropText: "qq-upload-drop-area-text-selector",
+ dropProcessing: "qq-drop-processing-selector",
+ dropProcessingSpinner: "qq-drop-processing-spinner-selector",
+ thumbnail: "qq-thumbnail-selector"
+ }, previewGeneration = {}, cachedThumbnailNotAvailableImg = new qq.Promise(), cachedWaitingForThumbnailImg = new qq.Promise(), log, isEditElementsExist, isRetryElementExist, templateDom, container, fileList, showThumbnails, serverScale, cacheThumbnailPlaceholders = function() {
+ var notAvailableUrl = options.placeholders.thumbnailNotAvailable, waitingUrl = options.placeholders.waitingForThumbnail, spec = {
+ maxSize: thumbnailMaxSize,
+ scale: serverScale
+ };
+ if (showThumbnails) {
+ if (notAvailableUrl) {
+ options.imageGenerator.generate(notAvailableUrl, new Image(), spec).then(function(updatedImg) {
+ cachedThumbnailNotAvailableImg.success(updatedImg);
+ }, function() {
+ cachedThumbnailNotAvailableImg.failure();
+ log("Problem loading 'not available' placeholder image at " + notAvailableUrl, "error");
+ });
+ } else {
+ cachedThumbnailNotAvailableImg.failure();
+ }
+ if (waitingUrl) {
+ options.imageGenerator.generate(waitingUrl, new Image(), spec).then(function(updatedImg) {
+ cachedWaitingForThumbnailImg.success(updatedImg);
+ }, function() {
+ cachedWaitingForThumbnailImg.failure();
+ log("Problem loading 'waiting for thumbnail' placeholder image at " + waitingUrl, "error");
+ });
+ } else {
+ cachedWaitingForThumbnailImg.failure();
+ }
+ }
+ }, displayWaitingImg = function(thumbnail) {
+ var waitingImgPlacement = new qq.Promise();
+ cachedWaitingForThumbnailImg.then(function(img) {
+ maybeScalePlaceholderViaCss(img, thumbnail);
+ if (!thumbnail.src) {
+ thumbnail.src = img.src;
+ thumbnail.onload = function() {
+ thumbnail.onload = null;
+ show(thumbnail);
+ waitingImgPlacement.success();
+ };
+ } else {
+ waitingImgPlacement.success();
+ }
+ }, function() {
+ hide(thumbnail);
+ waitingImgPlacement.success();
+ });
+ return waitingImgPlacement;
+ }, generateNewPreview = function(id, blob, spec) {
+ var thumbnail = getThumbnail(id);
+ log("Generating new thumbnail for " + id);
+ blob.qqThumbnailId = id;
+ return options.imageGenerator.generate(blob, thumbnail, spec).then(function() {
+ generatedThumbnails++;
+ show(thumbnail);
+ previewGeneration[id].success();
+ }, function() {
+ previewGeneration[id].failure();
+ if (!options.placeholders.waitUntilUpdate) {
+ maybeSetDisplayNotAvailableImg(id, thumbnail);
+ }
+ });
+ }, generateNextQueuedPreview = function() {
+ if (thumbGenerationQueue.length) {
+ thumbnailQueueMonitorRunning = true;
+ var queuedThumbRequest = thumbGenerationQueue.shift();
+ if (queuedThumbRequest.update) {
+ processUpdateQueuedPreviewRequest(queuedThumbRequest);
+ } else {
+ processNewQueuedPreviewRequest(queuedThumbRequest);
+ }
+ } else {
+ thumbnailQueueMonitorRunning = false;
+ }
+ }, getCancel = function(id) {
+ return getTemplateEl(getFile(id), selectorClasses.cancel);
+ }, getContinue = function(id) {
+ return getTemplateEl(getFile(id), selectorClasses.continueButton);
+ }, getDialog = function(type) {
+ return getTemplateEl(container, selectorClasses[type + "Dialog"]);
+ }, getDelete = function(id) {
+ return getTemplateEl(getFile(id), selectorClasses.deleteButton);
+ }, getDropProcessing = function() {
+ return getTemplateEl(container, selectorClasses.dropProcessing);
+ }, getEditIcon = function(id) {
+ return getTemplateEl(getFile(id), selectorClasses.editNameIcon);
+ }, getFile = function(id) {
+ return fileBatch.map[id] || qq(fileList).getFirstByClass(FILE_CLASS_PREFIX + id);
+ }, getFilename = function(id) {
+ return getTemplateEl(getFile(id), selectorClasses.file);
+ }, getPause = function(id) {
+ return getTemplateEl(getFile(id), selectorClasses.pause);
+ }, getProgress = function(id) {
+ if (id == null) {
+ return getTemplateEl(container, selectorClasses.totalProgressBarContainer) || getTemplateEl(container, selectorClasses.totalProgressBar);
+ }
+ return getTemplateEl(getFile(id), selectorClasses.progressBarContainer) || getTemplateEl(getFile(id), selectorClasses.progressBar);
+ }, getRetry = function(id) {
+ return getTemplateEl(getFile(id), selectorClasses.retry);
+ }, getSize = function(id) {
+ return getTemplateEl(getFile(id), selectorClasses.size);
+ }, getSpinner = function(id) {
+ return getTemplateEl(getFile(id), selectorClasses.spinner);
+ }, getTemplateEl = function(context, cssClass) {
+ return context && qq(context).getFirstByClass(cssClass);
+ }, getThumbnail = function(id) {
+ return showThumbnails && getTemplateEl(getFile(id), selectorClasses.thumbnail);
+ }, hide = function(el) {
+ el && qq(el).addClass(options.classes.hide);
+ }, maybeScalePlaceholderViaCss = function(placeholder, thumbnail) {
+ var maxWidth = placeholder.style.maxWidth, maxHeight = placeholder.style.maxHeight;
+ if (maxHeight && maxWidth && !thumbnail.style.maxWidth && !thumbnail.style.maxHeight) {
+ qq(thumbnail).css({
+ maxWidth: maxWidth,
+ maxHeight: maxHeight
+ });
+ }
+ }, maybeSetDisplayNotAvailableImg = function(id, thumbnail) {
+ var previewing = previewGeneration[id] || new qq.Promise().failure(), notAvailableImgPlacement = new qq.Promise();
+ cachedThumbnailNotAvailableImg.then(function(img) {
+ previewing.then(function() {
+ notAvailableImgPlacement.success();
+ }, function() {
+ maybeScalePlaceholderViaCss(img, thumbnail);
+ thumbnail.onload = function() {
+ thumbnail.onload = null;
+ notAvailableImgPlacement.success();
+ };
+ thumbnail.src = img.src;
+ show(thumbnail);
+ });
+ });
+ return notAvailableImgPlacement;
+ }, parseAndGetTemplate = function() {
+ var scriptEl, scriptHtml, fileListNode, tempTemplateEl, fileListEl, defaultButton, dropArea, thumbnail, dropProcessing, dropTextEl, uploaderEl;
+ log("Parsing template");
+ if (options.templateIdOrEl == null) {
+ throw new Error("You MUST specify either a template element or ID!");
+ }
+ if (qq.isString(options.templateIdOrEl)) {
+ scriptEl = document.getElementById(options.templateIdOrEl);
+ if (scriptEl === null) {
+ throw new Error(qq.format("Cannot find template script at ID '{}'!", options.templateIdOrEl));
+ }
+ scriptHtml = scriptEl.innerHTML;
+ } else {
+ if (options.templateIdOrEl.innerHTML === undefined) {
+ throw new Error("You have specified an invalid value for the template option! " + "It must be an ID or an Element.");
+ }
+ scriptHtml = options.templateIdOrEl.innerHTML;
+ }
+ scriptHtml = qq.trimStr(scriptHtml);
+ tempTemplateEl = document.createElement("div");
+ tempTemplateEl.appendChild(qq.toElement(scriptHtml));
+ uploaderEl = qq(tempTemplateEl).getFirstByClass(selectorClasses.uploader);
+ if (options.button) {
+ defaultButton = qq(tempTemplateEl).getFirstByClass(selectorClasses.button);
+ if (defaultButton) {
+ qq(defaultButton).remove();
+ }
+ }
+ if (!qq.DragAndDrop || !qq.supportedFeatures.fileDrop) {
+ dropProcessing = qq(tempTemplateEl).getFirstByClass(selectorClasses.dropProcessing);
+ if (dropProcessing) {
+ qq(dropProcessing).remove();
+ }
+ }
+ dropArea = qq(tempTemplateEl).getFirstByClass(selectorClasses.drop);
+ if (dropArea && !qq.DragAndDrop) {
+ log("DnD module unavailable.", "info");
+ qq(dropArea).remove();
+ }
+ if (!qq.supportedFeatures.fileDrop) {
+ uploaderEl.removeAttribute(DROPZPONE_TEXT_ATTR);
+ if (dropArea && qq(dropArea).hasAttribute(HIDE_DROPZONE_ATTR)) {
+ qq(dropArea).css({
+ display: "none"
+ });
+ }
+ } else if (qq(uploaderEl).hasAttribute(DROPZPONE_TEXT_ATTR) && dropArea) {
+ dropTextEl = qq(dropArea).getFirstByClass(selectorClasses.dropText);
+ dropTextEl && qq(dropTextEl).remove();
+ }
+ thumbnail = qq(tempTemplateEl).getFirstByClass(selectorClasses.thumbnail);
+ if (!showThumbnails) {
+ thumbnail && qq(thumbnail).remove();
+ } else if (thumbnail) {
+ thumbnailMaxSize = parseInt(thumbnail.getAttribute(THUMBNAIL_MAX_SIZE_ATTR));
+ thumbnailMaxSize = thumbnailMaxSize > 0 ? thumbnailMaxSize : null;
+ serverScale = qq(thumbnail).hasAttribute(THUMBNAIL_SERVER_SCALE_ATTR);
+ }
+ showThumbnails = showThumbnails && thumbnail;
+ isEditElementsExist = qq(tempTemplateEl).getByClass(selectorClasses.editFilenameInput).length > 0;
+ isRetryElementExist = qq(tempTemplateEl).getByClass(selectorClasses.retry).length > 0;
+ fileListNode = qq(tempTemplateEl).getFirstByClass(selectorClasses.list);
+ if (fileListNode == null) {
+ throw new Error("Could not find the file list container in the template!");
+ }
+ fileListEl = fileListNode.children[0].cloneNode(true);
+ fileListNode.innerHTML = "";
+ if (tempTemplateEl.getElementsByTagName("DIALOG").length) {
+ document.createElement("dialog");
+ }
+ log("Template parsing complete");
+ return {
+ template: tempTemplateEl,
+ fileTemplate: fileListEl
+ };
+ }, prependFile = function(el, index, fileList) {
+ var parentEl = fileList, beforeEl = parentEl.firstChild;
+ if (index > 0) {
+ beforeEl = qq(parentEl).children()[index].nextSibling;
+ }
+ parentEl.insertBefore(el, beforeEl);
+ }, processNewQueuedPreviewRequest = function(queuedThumbRequest) {
+ var id = queuedThumbRequest.id, optFileOrBlob = queuedThumbRequest.optFileOrBlob, relatedThumbnailId = optFileOrBlob && optFileOrBlob.qqThumbnailId, thumbnail = getThumbnail(id), spec = {
+ customResizeFunction: queuedThumbRequest.customResizeFunction,
+ maxSize: thumbnailMaxSize,
+ orient: true,
+ scale: true
+ };
+ if (qq.supportedFeatures.imagePreviews) {
+ if (thumbnail) {
+ if (options.limits.maxThumbs && options.limits.maxThumbs <= generatedThumbnails) {
+ maybeSetDisplayNotAvailableImg(id, thumbnail);
+ generateNextQueuedPreview();
+ } else {
+ displayWaitingImg(thumbnail).done(function() {
+ previewGeneration[id] = new qq.Promise();
+ previewGeneration[id].done(function() {
+ setTimeout(generateNextQueuedPreview, options.limits.timeBetweenThumbs);
+ });
+ if (relatedThumbnailId != null) {
+ useCachedPreview(id, relatedThumbnailId);
+ } else {
+ generateNewPreview(id, optFileOrBlob, spec);
+ }
+ });
+ }
+ } else {
+ generateNextQueuedPreview();
+ }
+ } else if (thumbnail) {
+ displayWaitingImg(thumbnail);
+ generateNextQueuedPreview();
+ }
+ }, processUpdateQueuedPreviewRequest = function(queuedThumbRequest) {
+ var id = queuedThumbRequest.id, thumbnailUrl = queuedThumbRequest.thumbnailUrl, showWaitingImg = queuedThumbRequest.showWaitingImg, thumbnail = getThumbnail(id), spec = {
+ customResizeFunction: queuedThumbRequest.customResizeFunction,
+ scale: serverScale,
+ maxSize: thumbnailMaxSize
+ };
+ if (thumbnail) {
+ if (thumbnailUrl) {
+ if (options.limits.maxThumbs && options.limits.maxThumbs <= generatedThumbnails) {
+ maybeSetDisplayNotAvailableImg(id, thumbnail);
+ generateNextQueuedPreview();
+ } else {
+ if (showWaitingImg) {
+ displayWaitingImg(thumbnail);
+ }
+ return options.imageGenerator.generate(thumbnailUrl, thumbnail, spec).then(function() {
+ show(thumbnail);
+ generatedThumbnails++;
+ setTimeout(generateNextQueuedPreview, options.limits.timeBetweenThumbs);
+ }, function() {
+ maybeSetDisplayNotAvailableImg(id, thumbnail);
+ setTimeout(generateNextQueuedPreview, options.limits.timeBetweenThumbs);
+ });
+ }
+ } else {
+ maybeSetDisplayNotAvailableImg(id, thumbnail);
+ generateNextQueuedPreview();
+ }
+ }
+ }, setProgressBarWidth = function(id, percent) {
+ var bar = getProgress(id), progressBarSelector = id == null ? selectorClasses.totalProgressBar : selectorClasses.progressBar;
+ if (bar && !qq(bar).hasClass(progressBarSelector)) {
+ bar = qq(bar).getFirstByClass(progressBarSelector);
+ }
+ if (bar) {
+ qq(bar).css({
+ width: percent + "%"
+ });
+ bar.setAttribute("aria-valuenow", percent);
+ }
+ }, show = function(el) {
+ el && qq(el).removeClass(options.classes.hide);
+ }, useCachedPreview = function(targetThumbnailId, cachedThumbnailId) {
+ var targetThumbnail = getThumbnail(targetThumbnailId), cachedThumbnail = getThumbnail(cachedThumbnailId);
+ log(qq.format("ID {} is the same file as ID {}. Will use generated thumbnail from ID {} instead.", targetThumbnailId, cachedThumbnailId, cachedThumbnailId));
+ previewGeneration[cachedThumbnailId].then(function() {
+ generatedThumbnails++;
+ previewGeneration[targetThumbnailId].success();
+ log(qq.format("Now using previously generated thumbnail created for ID {} on ID {}.", cachedThumbnailId, targetThumbnailId));
+ targetThumbnail.src = cachedThumbnail.src;
+ show(targetThumbnail);
+ }, function() {
+ previewGeneration[targetThumbnailId].failure();
+ if (!options.placeholders.waitUntilUpdate) {
+ maybeSetDisplayNotAvailableImg(targetThumbnailId, targetThumbnail);
+ }
+ });
+ };
+ qq.extend(options, spec);
+ log = options.log;
+ if (!qq.supportedFeatures.imagePreviews) {
+ options.limits.timeBetweenThumbs = 0;
+ options.limits.maxThumbs = 0;
+ }
+ container = options.containerEl;
+ showThumbnails = options.imageGenerator !== undefined;
+ templateDom = parseAndGetTemplate();
+ cacheThumbnailPlaceholders();
+ qq.extend(this, {
+ render: function() {
+ log("Rendering template in DOM.");
+ generatedThumbnails = 0;
+ container.appendChild(templateDom.template.cloneNode(true));
+ hide(getDropProcessing());
+ this.hideTotalProgress();
+ fileList = options.fileContainerEl || getTemplateEl(container, selectorClasses.list);
+ log("Template rendering complete");
+ },
+ renderFailure: function(message) {
+ var cantRenderEl = qq.toElement(message);
+ container.innerHTML = "";
+ container.appendChild(cantRenderEl);
+ },
+ reset: function() {
+ this.render();
+ },
+ clearFiles: function() {
+ fileList.innerHTML = "";
+ },
+ disableCancel: function() {
+ isCancelDisabled = true;
+ },
+ addFile: function(id, name, prependInfo, hideForever, batch) {
+ var fileEl = templateDom.fileTemplate.cloneNode(true), fileNameEl = getTemplateEl(fileEl, selectorClasses.file), uploaderEl = getTemplateEl(container, selectorClasses.uploader), fileContainer = batch ? fileBatch.content : fileList, thumb;
+ if (batch) {
+ fileBatch.map[id] = fileEl;
+ }
+ qq(fileEl).addClass(FILE_CLASS_PREFIX + id);
+ uploaderEl.removeAttribute(DROPZPONE_TEXT_ATTR);
+ if (fileNameEl) {
+ qq(fileNameEl).setText(name);
+ fileNameEl.setAttribute("title", name);
+ }
+ fileEl.setAttribute(FILE_ID_ATTR, id);
+ if (prependInfo) {
+ prependFile(fileEl, prependInfo.index, fileContainer);
+ } else {
+ fileContainer.appendChild(fileEl);
+ }
+ if (hideForever) {
+ fileEl.style.display = "none";
+ qq(fileEl).addClass(HIDDEN_FOREVER_CLASS);
+ } else {
+ hide(getProgress(id));
+ hide(getSize(id));
+ hide(getDelete(id));
+ hide(getRetry(id));
+ hide(getPause(id));
+ hide(getContinue(id));
+ if (isCancelDisabled) {
+ this.hideCancel(id);
+ }
+ thumb = getThumbnail(id);
+ if (thumb && !thumb.src) {
+ cachedWaitingForThumbnailImg.then(function(waitingImg) {
+ thumb.src = waitingImg.src;
+ if (waitingImg.style.maxHeight && waitingImg.style.maxWidth) {
+ qq(thumb).css({
+ maxHeight: waitingImg.style.maxHeight,
+ maxWidth: waitingImg.style.maxWidth
+ });
+ }
+ show(thumb);
+ });
+ }
+ }
+ },
+ addFileToCache: function(id, name, prependInfo, hideForever) {
+ this.addFile(id, name, prependInfo, hideForever, true);
+ },
+ addCacheToDom: function() {
+ fileList.appendChild(fileBatch.content);
+ fileBatch.content = document.createDocumentFragment();
+ fileBatch.map = {};
+ },
+ removeFile: function(id) {
+ qq(getFile(id)).remove();
+ },
+ getFileId: function(el) {
+ var currentNode = el;
+ if (currentNode) {
+ while (currentNode.getAttribute(FILE_ID_ATTR) == null) {
+ currentNode = currentNode.parentNode;
+ }
+ return parseInt(currentNode.getAttribute(FILE_ID_ATTR));
+ }
+ },
+ getFileList: function() {
+ return fileList;
+ },
+ markFilenameEditable: function(id) {
+ var filename = getFilename(id);
+ filename && qq(filename).addClass(options.classes.editable);
+ },
+ updateFilename: function(id, name) {
+ var filenameEl = getFilename(id);
+ if (filenameEl) {
+ qq(filenameEl).setText(name);
+ filenameEl.setAttribute("title", name);
+ }
+ },
+ hideFilename: function(id) {
+ hide(getFilename(id));
+ },
+ showFilename: function(id) {
+ show(getFilename(id));
+ },
+ isFileName: function(el) {
+ return qq(el).hasClass(selectorClasses.file);
+ },
+ getButton: function() {
+ return options.button || getTemplateEl(container, selectorClasses.button);
+ },
+ hideDropProcessing: function() {
+ hide(getDropProcessing());
+ },
+ showDropProcessing: function() {
+ show(getDropProcessing());
+ },
+ getDropZone: function() {
+ return getTemplateEl(container, selectorClasses.drop);
+ },
+ isEditFilenamePossible: function() {
+ return isEditElementsExist;
+ },
+ hideRetry: function(id) {
+ hide(getRetry(id));
+ },
+ isRetryPossible: function() {
+ return isRetryElementExist;
+ },
+ showRetry: function(id) {
+ show(getRetry(id));
+ },
+ getFileContainer: function(id) {
+ return getFile(id);
+ },
+ showEditIcon: function(id) {
+ var icon = getEditIcon(id);
+ icon && qq(icon).addClass(options.classes.editable);
+ },
+ isHiddenForever: function(id) {
+ return qq(getFile(id)).hasClass(HIDDEN_FOREVER_CLASS);
+ },
+ hideEditIcon: function(id) {
+ var icon = getEditIcon(id);
+ icon && qq(icon).removeClass(options.classes.editable);
+ },
+ isEditIcon: function(el) {
+ return qq(el).hasClass(selectorClasses.editNameIcon, true);
+ },
+ getEditInput: function(id) {
+ return getTemplateEl(getFile(id), selectorClasses.editFilenameInput);
+ },
+ isEditInput: function(el) {
+ return qq(el).hasClass(selectorClasses.editFilenameInput, true);
+ },
+ updateProgress: function(id, loaded, total) {
+ var bar = getProgress(id), percent;
+ if (bar && total > 0) {
+ percent = Math.round(loaded / total * 100);
+ if (percent === 100) {
+ hide(bar);
+ } else {
+ show(bar);
+ }
+ setProgressBarWidth(id, percent);
+ }
+ },
+ updateTotalProgress: function(loaded, total) {
+ this.updateProgress(null, loaded, total);
+ },
+ hideProgress: function(id) {
+ var bar = getProgress(id);
+ bar && hide(bar);
+ },
+ hideTotalProgress: function() {
+ this.hideProgress();
+ },
+ resetProgress: function(id) {
+ setProgressBarWidth(id, 0);
+ this.hideTotalProgress(id);
+ },
+ resetTotalProgress: function() {
+ this.resetProgress();
+ },
+ showCancel: function(id) {
+ if (!isCancelDisabled) {
+ var cancel = getCancel(id);
+ cancel && qq(cancel).removeClass(options.classes.hide);
+ }
+ },
+ hideCancel: function(id) {
+ hide(getCancel(id));
+ },
+ isCancel: function(el) {
+ return qq(el).hasClass(selectorClasses.cancel, true);
+ },
+ allowPause: function(id) {
+ show(getPause(id));
+ hide(getContinue(id));
+ },
+ uploadPaused: function(id) {
+ this.setStatusText(id, options.text.paused);
+ this.allowContinueButton(id);
+ hide(getSpinner(id));
+ },
+ hidePause: function(id) {
+ hide(getPause(id));
+ },
+ isPause: function(el) {
+ return qq(el).hasClass(selectorClasses.pause, true);
+ },
+ isContinueButton: function(el) {
+ return qq(el).hasClass(selectorClasses.continueButton, true);
+ },
+ allowContinueButton: function(id) {
+ show(getContinue(id));
+ hide(getPause(id));
+ },
+ uploadContinued: function(id) {
+ this.setStatusText(id, "");
+ this.allowPause(id);
+ show(getSpinner(id));
+ },
+ showDeleteButton: function(id) {
+ show(getDelete(id));
+ },
+ hideDeleteButton: function(id) {
+ hide(getDelete(id));
+ },
+ isDeleteButton: function(el) {
+ return qq(el).hasClass(selectorClasses.deleteButton, true);
+ },
+ isRetry: function(el) {
+ return qq(el).hasClass(selectorClasses.retry, true);
+ },
+ updateSize: function(id, text) {
+ var size = getSize(id);
+ if (size) {
+ show(size);
+ qq(size).setText(text);
+ }
+ },
+ setStatusText: function(id, text) {
+ var textEl = getTemplateEl(getFile(id), selectorClasses.statusText);
+ if (textEl) {
+ if (text == null) {
+ qq(textEl).clearText();
+ } else {
+ qq(textEl).setText(text);
+ }
+ }
+ },
+ hideSpinner: function(id) {
+ qq(getFile(id)).removeClass(IN_PROGRESS_CLASS);
+ hide(getSpinner(id));
+ },
+ showSpinner: function(id) {
+ qq(getFile(id)).addClass(IN_PROGRESS_CLASS);
+ show(getSpinner(id));
+ },
+ generatePreview: function(id, optFileOrBlob, customResizeFunction) {
+ if (!this.isHiddenForever(id)) {
+ thumbGenerationQueue.push({
+ id: id,
+ customResizeFunction: customResizeFunction,
+ optFileOrBlob: optFileOrBlob
+ });
+ !thumbnailQueueMonitorRunning && generateNextQueuedPreview();
+ }
+ },
+ updateThumbnail: function(id, thumbnailUrl, showWaitingImg, customResizeFunction) {
+ if (!this.isHiddenForever(id)) {
+ thumbGenerationQueue.push({
+ customResizeFunction: customResizeFunction,
+ update: true,
+ id: id,
+ thumbnailUrl: thumbnailUrl,
+ showWaitingImg: showWaitingImg
+ });
+ !thumbnailQueueMonitorRunning && generateNextQueuedPreview();
+ }
+ },
+ hasDialog: function(type) {
+ return qq.supportedFeatures.dialogElement && !!getDialog(type);
+ },
+ showDialog: function(type, message, defaultValue) {
+ var dialog = getDialog(type), messageEl = getTemplateEl(dialog, selectorClasses.dialogMessage), inputEl = dialog.getElementsByTagName("INPUT")[0], cancelBtn = getTemplateEl(dialog, selectorClasses.dialogCancelButton), okBtn = getTemplateEl(dialog, selectorClasses.dialogOkButton), promise = new qq.Promise(), closeHandler = function() {
+ cancelBtn.removeEventListener("click", cancelClickHandler);
+ okBtn && okBtn.removeEventListener("click", okClickHandler);
+ promise.failure();
+ }, cancelClickHandler = function() {
+ cancelBtn.removeEventListener("click", cancelClickHandler);
+ dialog.close();
+ }, okClickHandler = function() {
+ dialog.removeEventListener("close", closeHandler);
+ okBtn.removeEventListener("click", okClickHandler);
+ dialog.close();
+ promise.success(inputEl && inputEl.value);
+ };
+ dialog.addEventListener("close", closeHandler);
+ cancelBtn.addEventListener("click", cancelClickHandler);
+ okBtn && okBtn.addEventListener("click", okClickHandler);
+ if (inputEl) {
+ inputEl.value = defaultValue;
+ }
+ messageEl.textContent = message;
+ dialog.showModal();
+ return promise;
+ }
+ });
+ };
+ qq.UiEventHandler = function(s, protectedApi) {
+ "use strict";
+ var disposer = new qq.DisposeSupport(), spec = {
+ eventType: "click",
+ attachTo: null,
+ onHandled: function(target, event) {}
+ };
+ qq.extend(this, {
+ addHandler: function(element) {
+ addHandler(element);
+ },
+ dispose: function() {
+ disposer.dispose();
+ }
+ });
+ function addHandler(element) {
+ disposer.attach(element, spec.eventType, function(event) {
+ event = event || window.event;
+ var target = event.target || event.srcElement;
+ spec.onHandled(target, event);
+ });
+ }
+ qq.extend(protectedApi, {
+ getFileIdFromItem: function(item) {
+ return item.qqFileId;
+ },
+ getDisposeSupport: function() {
+ return disposer;
+ }
+ });
+ qq.extend(spec, s);
+ if (spec.attachTo) {
+ addHandler(spec.attachTo);
+ }
+ };
+ qq.FileButtonsClickHandler = function(s) {
+ "use strict";
+ var inheritedInternalApi = {}, spec = {
+ templating: null,
+ log: function(message, lvl) {},
+ onDeleteFile: function(fileId) {},
+ onCancel: function(fileId) {},
+ onRetry: function(fileId) {},
+ onPause: function(fileId) {},
+ onContinue: function(fileId) {},
+ onGetName: function(fileId) {}
+ }, buttonHandlers = {
+ cancel: function(id) {
+ spec.onCancel(id);
+ },
+ retry: function(id) {
+ spec.onRetry(id);
+ },
+ deleteButton: function(id) {
+ spec.onDeleteFile(id);
+ },
+ pause: function(id) {
+ spec.onPause(id);
+ },
+ continueButton: function(id) {
+ spec.onContinue(id);
+ }
+ };
+ function examineEvent(target, event) {
+ qq.each(buttonHandlers, function(buttonType, handler) {
+ var firstLetterCapButtonType = buttonType.charAt(0).toUpperCase() + buttonType.slice(1), fileId;
+ if (spec.templating["is" + firstLetterCapButtonType](target)) {
+ fileId = spec.templating.getFileId(target);
+ qq.preventDefault(event);
+ spec.log(qq.format("Detected valid file button click event on file '{}', ID: {}.", spec.onGetName(fileId), fileId));
+ handler(fileId);
+ return false;
+ }
+ });
+ }
+ qq.extend(spec, s);
+ spec.eventType = "click";
+ spec.onHandled = examineEvent;
+ spec.attachTo = spec.templating.getFileList();
+ qq.extend(this, new qq.UiEventHandler(spec, inheritedInternalApi));
+ };
+ qq.FilenameClickHandler = function(s) {
+ "use strict";
+ var inheritedInternalApi = {}, spec = {
+ templating: null,
+ log: function(message, lvl) {},
+ classes: {
+ file: "qq-upload-file",
+ editNameIcon: "qq-edit-filename-icon"
+ },
+ onGetUploadStatus: function(fileId) {},
+ onGetName: function(fileId) {}
+ };
+ qq.extend(spec, s);
+ function examineEvent(target, event) {
+ if (spec.templating.isFileName(target) || spec.templating.isEditIcon(target)) {
+ var fileId = spec.templating.getFileId(target), status = spec.onGetUploadStatus(fileId);
+ if (status === qq.status.SUBMITTED) {
+ spec.log(qq.format("Detected valid filename click event on file '{}', ID: {}.", spec.onGetName(fileId), fileId));
+ qq.preventDefault(event);
+ inheritedInternalApi.handleFilenameEdit(fileId, target, true);
+ }
+ }
+ }
+ spec.eventType = "click";
+ spec.onHandled = examineEvent;
+ qq.extend(this, new qq.FilenameEditHandler(spec, inheritedInternalApi));
+ };
+ qq.FilenameInputFocusInHandler = function(s, inheritedInternalApi) {
+ "use strict";
+ var spec = {
+ templating: null,
+ onGetUploadStatus: function(fileId) {},
+ log: function(message, lvl) {}
+ };
+ if (!inheritedInternalApi) {
+ inheritedInternalApi = {};
+ }
+ function handleInputFocus(target, event) {
+ if (spec.templating.isEditInput(target)) {
+ var fileId = spec.templating.getFileId(target), status = spec.onGetUploadStatus(fileId);
+ if (status === qq.status.SUBMITTED) {
+ spec.log(qq.format("Detected valid filename input focus event on file '{}', ID: {}.", spec.onGetName(fileId), fileId));
+ inheritedInternalApi.handleFilenameEdit(fileId, target);
+ }
+ }
+ }
+ spec.eventType = "focusin";
+ spec.onHandled = handleInputFocus;
+ qq.extend(spec, s);
+ qq.extend(this, new qq.FilenameEditHandler(spec, inheritedInternalApi));
+ };
+ qq.FilenameInputFocusHandler = function(spec) {
+ "use strict";
+ spec.eventType = "focus";
+ spec.attachTo = null;
+ qq.extend(this, new qq.FilenameInputFocusInHandler(spec, {}));
+ };
+ qq.FilenameEditHandler = function(s, inheritedInternalApi) {
+ "use strict";
+ var spec = {
+ templating: null,
+ log: function(message, lvl) {},
+ onGetUploadStatus: function(fileId) {},
+ onGetName: function(fileId) {},
+ onSetName: function(fileId, newName) {},
+ onEditingStatusChange: function(fileId, isEditing) {}
+ };
+ function getFilenameSansExtension(fileId) {
+ var filenameSansExt = spec.onGetName(fileId), extIdx = filenameSansExt.lastIndexOf(".");
+ if (extIdx > 0) {
+ filenameSansExt = filenameSansExt.substr(0, extIdx);
+ }
+ return filenameSansExt;
+ }
+ function getOriginalExtension(fileId) {
+ var origName = spec.onGetName(fileId);
+ return qq.getExtension(origName);
+ }
+ function handleNameUpdate(newFilenameInputEl, fileId) {
+ var newName = newFilenameInputEl.value, origExtension;
+ if (newName !== undefined && qq.trimStr(newName).length > 0) {
+ origExtension = getOriginalExtension(fileId);
+ if (origExtension !== undefined) {
+ newName = newName + "." + origExtension;
+ }
+ spec.onSetName(fileId, newName);
+ }
+ spec.onEditingStatusChange(fileId, false);
+ }
+ function registerInputBlurHandler(inputEl, fileId) {
+ inheritedInternalApi.getDisposeSupport().attach(inputEl, "blur", function() {
+ handleNameUpdate(inputEl, fileId);
+ });
+ }
+ function registerInputEnterKeyHandler(inputEl, fileId) {
+ inheritedInternalApi.getDisposeSupport().attach(inputEl, "keyup", function(event) {
+ var code = event.keyCode || event.which;
+ if (code === 13) {
+ handleNameUpdate(inputEl, fileId);
+ }
+ });
+ }
+ qq.extend(spec, s);
+ spec.attachTo = spec.templating.getFileList();
+ qq.extend(this, new qq.UiEventHandler(spec, inheritedInternalApi));
+ qq.extend(inheritedInternalApi, {
+ handleFilenameEdit: function(id, target, focusInput) {
+ var newFilenameInputEl = spec.templating.getEditInput(id);
+ spec.onEditingStatusChange(id, true);
+ newFilenameInputEl.value = getFilenameSansExtension(id);
+ if (focusInput) {
+ newFilenameInputEl.focus();
+ }
+ registerInputBlurHandler(newFilenameInputEl, id);
+ registerInputEnterKeyHandler(newFilenameInputEl, id);
+ }
+ });
+ };
+})(window);
+//# sourceMappingURL=fine-uploader.js.map
diff --git a/services/web/public/js/libs/fineuploader.js b/services/web/public/js/libs/fineuploader.js
index 606a2fb70a..b109b8a1c1 100644
--- a/services/web/public/js/libs/fineuploader.js
+++ b/services/web/public/js/libs/fineuploader.js
@@ -1,7455 +1,3761 @@
-// Fine Uploader 5.15.4 - MIT licensed. http://fineuploader.com
-(function(global) {
- var qq = function(element) {
- "use strict";
- return {
- hide: function() {
- element.style.display = "none";
- return this;
- },
- attach: function(type, fn) {
- if (element.addEventListener) {
- element.addEventListener(type, fn, false);
- } else if (element.attachEvent) {
- element.attachEvent("on" + type, fn);
- }
- return function() {
- qq(element).detach(type, fn);
- };
- },
- detach: function(type, fn) {
- if (element.removeEventListener) {
- element.removeEventListener(type, fn, false);
- } else if (element.attachEvent) {
- element.detachEvent("on" + type, fn);
- }
- return this;
- },
- contains: function(descendant) {
- if (!descendant) {
- return false;
- }
- if (element === descendant) {
- return true;
- }
- if (element.contains) {
- return element.contains(descendant);
- } else {
- return !!(descendant.compareDocumentPosition(element) & 8);
- }
- },
- insertBefore: function(elementB) {
- elementB.parentNode.insertBefore(element, elementB);
- return this;
- },
- remove: function() {
- element.parentNode.removeChild(element);
- return this;
- },
- css: function(styles) {
- if (element.style == null) {
- throw new qq.Error("Can't apply style to node as it is not on the HTMLElement prototype chain!");
- }
- if (styles.opacity != null) {
- if (typeof element.style.opacity !== "string" && typeof element.filters !== "undefined") {
- styles.filter = "alpha(opacity=" + Math.round(100 * styles.opacity) + ")";
- }
- }
- qq.extend(element.style, styles);
- return this;
- },
- hasClass: function(name, considerParent) {
- var re = new RegExp("(^| )" + name + "( |$)");
- return re.test(element.className) || !!(considerParent && re.test(element.parentNode.className));
- },
- addClass: function(name) {
- if (!qq(element).hasClass(name)) {
- element.className += " " + name;
- }
- return this;
- },
- removeClass: function(name) {
- var re = new RegExp("(^| )" + name + "( |$)");
- element.className = element.className.replace(re, " ").replace(/^\s+|\s+$/g, "");
- return this;
- },
- getByClass: function(className, first) {
- var candidates, result = [];
- if (first && element.querySelector) {
- return element.querySelector("." + className);
- } else if (element.querySelectorAll) {
- return element.querySelectorAll("." + className);
- }
- candidates = element.getElementsByTagName("*");
- qq.each(candidates, function(idx, val) {
- if (qq(val).hasClass(className)) {
- result.push(val);
- }
- });
- return first ? result[0] : result;
- },
- getFirstByClass: function(className) {
- return qq(element).getByClass(className, true);
- },
- children: function() {
- var children = [], child = element.firstChild;
- while (child) {
- if (child.nodeType === 1) {
- children.push(child);
- }
- child = child.nextSibling;
- }
- return children;
- },
- setText: function(text) {
- element.innerText = text;
- element.textContent = text;
- return this;
- },
- clearText: function() {
- return qq(element).setText("");
- },
- hasAttribute: function(attrName) {
- var attrVal;
- if (element.hasAttribute) {
- if (!element.hasAttribute(attrName)) {
- return false;
- }
- return /^false$/i.exec(element.getAttribute(attrName)) == null;
- } else {
- attrVal = element[attrName];
- if (attrVal === undefined) {
- return false;
- }
- return /^false$/i.exec(attrVal) == null;
- }
+/**
+ * http://github.com/Valums-File-Uploader/file-uploader
+ *
+ * Multiple file upload component with progress-bar, drag-and-drop, support for all modern browsers.
+ *
+ * Original version: 1.0 © 2010 Andrew Valums ( andrew(at)valums.com )
+ * Current Maintainer (2.0+): © 2012, Ray Nicholus ( fineuploader(at)garstasio.com )
+ *
+ * Licensed under MIT license, GNU GPL 2 or later, GNU LGPL 2 or later, see license.txt.
+ */
+/*globals window, navigator, document, FormData, File, HTMLInputElement, XMLHttpRequest, Blob*/
+var qq = function(element) {
+ "use strict";
+
+ return {
+ hide: function() {
+ element.style.display = 'none';
+ return this;
+ },
+
+ /** Returns the function which detaches attached event */
+ attach: function(type, fn) {
+ if (element.addEventListener){
+ element.addEventListener(type, fn, false);
+ } else if (element.attachEvent){
+ element.attachEvent('on' + type, fn);
}
- };
- };
- (function() {
- "use strict";
- qq.canvasToBlob = function(canvas, mime, quality) {
- return qq.dataUriToBlob(canvas.toDataURL(mime, quality));
- };
- qq.dataUriToBlob = function(dataUri) {
- var arrayBuffer, byteString, createBlob = function(data, mime) {
- var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder, blobBuilder = BlobBuilder && new BlobBuilder();
- if (blobBuilder) {
- blobBuilder.append(data);
- return blobBuilder.getBlob(mime);
- } else {
- return new Blob([ data ], {
- type: mime
- });
- }
- }, intArray, mimeString;
- if (dataUri.split(",")[0].indexOf("base64") >= 0) {
- byteString = atob(dataUri.split(",")[1]);
- } else {
- byteString = decodeURI(dataUri.split(",")[1]);
- }
- mimeString = dataUri.split(",")[0].split(":")[1].split(";")[0];
- arrayBuffer = new ArrayBuffer(byteString.length);
- intArray = new Uint8Array(arrayBuffer);
- qq.each(byteString, function(idx, character) {
- intArray[idx] = character.charCodeAt(0);
- });
- return createBlob(arrayBuffer, mimeString);
- };
- qq.log = function(message, level) {
- if (window.console) {
- if (!level || level === "info") {
- window.console.log(message);
- } else {
- if (window.console[level]) {
- window.console[level](message);
- } else {
- window.console.log("<" + level + "> " + message);
- }
- }
- }
- };
- qq.isObject = function(variable) {
- return variable && !variable.nodeType && Object.prototype.toString.call(variable) === "[object Object]";
- };
- qq.isFunction = function(variable) {
- return typeof variable === "function";
- };
- qq.isArray = function(value) {
- return Object.prototype.toString.call(value) === "[object Array]" || value && window.ArrayBuffer && value.buffer && value.buffer.constructor === ArrayBuffer;
- };
- qq.isItemList = function(maybeItemList) {
- return Object.prototype.toString.call(maybeItemList) === "[object DataTransferItemList]";
- };
- qq.isNodeList = function(maybeNodeList) {
- return Object.prototype.toString.call(maybeNodeList) === "[object NodeList]" || maybeNodeList.item && maybeNodeList.namedItem;
- };
- qq.isString = function(maybeString) {
- return Object.prototype.toString.call(maybeString) === "[object String]";
- };
- qq.trimStr = function(string) {
- if (String.prototype.trim) {
- return string.trim();
- }
- return string.replace(/^\s+|\s+$/g, "");
- };
- qq.format = function(str) {
- var args = Array.prototype.slice.call(arguments, 1), newStr = str, nextIdxToReplace = newStr.indexOf("{}");
- qq.each(args, function(idx, val) {
- var strBefore = newStr.substring(0, nextIdxToReplace), strAfter = newStr.substring(nextIdxToReplace + 2);
- newStr = strBefore + val + strAfter;
- nextIdxToReplace = newStr.indexOf("{}", nextIdxToReplace + val.length);
- if (nextIdxToReplace < 0) {
- return false;
- }
- });
- return newStr;
- };
- qq.isFile = function(maybeFile) {
- return window.File && Object.prototype.toString.call(maybeFile) === "[object File]";
- };
- qq.isFileList = function(maybeFileList) {
- return window.FileList && Object.prototype.toString.call(maybeFileList) === "[object FileList]";
- };
- qq.isFileOrInput = function(maybeFileOrInput) {
- return qq.isFile(maybeFileOrInput) || qq.isInput(maybeFileOrInput);
- };
- qq.isInput = function(maybeInput, notFile) {
- var evaluateType = function(type) {
- var normalizedType = type.toLowerCase();
- if (notFile) {
- return normalizedType !== "file";
- }
- return normalizedType === "file";
+ return function() {
+ qq(element).detach(type, fn);
};
- if (window.HTMLInputElement) {
- if (Object.prototype.toString.call(maybeInput) === "[object HTMLInputElement]") {
- if (maybeInput.type && evaluateType(maybeInput.type)) {
- return true;
- }
- }
+ },
+
+ detach: function(type, fn) {
+ if (element.removeEventListener){
+ element.removeEventListener(type, fn, false);
+ } else if (element.attachEvent){
+ element.detachEvent('on' + type, fn);
}
- if (maybeInput.tagName) {
- if (maybeInput.tagName.toLowerCase() === "input") {
- if (maybeInput.type && evaluateType(maybeInput.type)) {
- return true;
- }
- }
- }
- return false;
- };
- qq.isBlob = function(maybeBlob) {
- if (window.Blob && Object.prototype.toString.call(maybeBlob) === "[object Blob]") {
+ return this;
+ },
+
+ contains: function(descendant) {
+ // compareposition returns false in this case
+ if (element === descendant) {
return true;
}
- };
- qq.isXhrUploadSupported = function() {
- var input = document.createElement("input");
- input.type = "file";
- return input.multiple !== undefined && typeof File !== "undefined" && typeof FormData !== "undefined" && typeof qq.createXhrInstance().upload !== "undefined";
- };
- qq.createXhrInstance = function() {
- if (window.XMLHttpRequest) {
- return new XMLHttpRequest();
- }
- try {
- return new ActiveXObject("MSXML2.XMLHTTP.3.0");
- } catch (error) {
- qq.log("Neither XHR or ActiveX are supported!", "error");
- return null;
- }
- };
- qq.isFolderDropSupported = function(dataTransfer) {
- return dataTransfer.items && dataTransfer.items.length > 0 && dataTransfer.items[0].webkitGetAsEntry;
- };
- qq.isFileChunkingSupported = function() {
- return !qq.androidStock() && qq.isXhrUploadSupported() && (File.prototype.slice !== undefined || File.prototype.webkitSlice !== undefined || File.prototype.mozSlice !== undefined);
- };
- qq.sliceBlob = function(fileOrBlob, start, end) {
- var slicer = fileOrBlob.slice || fileOrBlob.mozSlice || fileOrBlob.webkitSlice;
- return slicer.call(fileOrBlob, start, end);
- };
- qq.arrayBufferToHex = function(buffer) {
- var bytesAsHex = "", bytes = new Uint8Array(buffer);
- qq.each(bytes, function(idx, byt) {
- var byteAsHexStr = byt.toString(16);
- if (byteAsHexStr.length < 2) {
- byteAsHexStr = "0" + byteAsHexStr;
- }
- bytesAsHex += byteAsHexStr;
- });
- return bytesAsHex;
- };
- qq.readBlobToHex = function(blob, startOffset, length) {
- var initialBlob = qq.sliceBlob(blob, startOffset, startOffset + length), fileReader = new FileReader(), promise = new qq.Promise();
- fileReader.onload = function() {
- promise.success(qq.arrayBufferToHex(fileReader.result));
- };
- fileReader.onerror = promise.failure;
- fileReader.readAsArrayBuffer(initialBlob);
- return promise;
- };
- qq.extend = function(first, second, extendNested) {
- qq.each(second, function(prop, val) {
- if (extendNested && qq.isObject(val)) {
- if (first[prop] === undefined) {
- first[prop] = {};
- }
- qq.extend(first[prop], val, true);
- } else {
- first[prop] = val;
- }
- });
- return first;
- };
- qq.override = function(target, sourceFn) {
- var super_ = {}, source = sourceFn(super_);
- qq.each(source, function(srcPropName, srcPropVal) {
- if (target[srcPropName] !== undefined) {
- super_[srcPropName] = target[srcPropName];
- }
- target[srcPropName] = srcPropVal;
- });
- return target;
- };
- qq.indexOf = function(arr, elt, from) {
- if (arr.indexOf) {
- return arr.indexOf(elt, from);
- }
- from = from || 0;
- var len = arr.length;
- if (from < 0) {
- from += len;
- }
- for (;from < len; from += 1) {
- if (arr.hasOwnProperty(from) && arr[from] === elt) {
- return from;
- }
- }
- return -1;
- };
- qq.getUniqueId = function() {
- return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
- var r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
- return v.toString(16);
- });
- };
- qq.ie = function() {
- return navigator.userAgent.indexOf("MSIE") !== -1 || navigator.userAgent.indexOf("Trident") !== -1;
- };
- qq.ie7 = function() {
- return navigator.userAgent.indexOf("MSIE 7") !== -1;
- };
- qq.ie8 = function() {
- return navigator.userAgent.indexOf("MSIE 8") !== -1;
- };
- qq.ie10 = function() {
- return navigator.userAgent.indexOf("MSIE 10") !== -1;
- };
- qq.ie11 = function() {
- return qq.ie() && navigator.userAgent.indexOf("rv:11") !== -1;
- };
- qq.edge = function() {
- return navigator.userAgent.indexOf("Edge") >= 0;
- };
- qq.safari = function() {
- return navigator.vendor !== undefined && navigator.vendor.indexOf("Apple") !== -1;
- };
- qq.chrome = function() {
- return navigator.vendor !== undefined && navigator.vendor.indexOf("Google") !== -1;
- };
- qq.opera = function() {
- return navigator.vendor !== undefined && navigator.vendor.indexOf("Opera") !== -1;
- };
- qq.firefox = function() {
- return !qq.edge() && !qq.ie11() && navigator.userAgent.indexOf("Mozilla") !== -1 && navigator.vendor !== undefined && navigator.vendor === "";
- };
- qq.windows = function() {
- return navigator.platform === "Win32";
- };
- qq.android = function() {
- return navigator.userAgent.toLowerCase().indexOf("android") !== -1;
- };
- qq.androidStock = function() {
- return qq.android() && navigator.userAgent.toLowerCase().indexOf("chrome") < 0;
- };
- qq.ios6 = function() {
- return qq.ios() && navigator.userAgent.indexOf(" OS 6_") !== -1;
- };
- qq.ios7 = function() {
- return qq.ios() && navigator.userAgent.indexOf(" OS 7_") !== -1;
- };
- qq.ios8 = function() {
- return qq.ios() && navigator.userAgent.indexOf(" OS 8_") !== -1;
- };
- qq.ios800 = function() {
- return qq.ios() && navigator.userAgent.indexOf(" OS 8_0 ") !== -1;
- };
- qq.ios = function() {
- return navigator.userAgent.indexOf("iPad") !== -1 || navigator.userAgent.indexOf("iPod") !== -1 || navigator.userAgent.indexOf("iPhone") !== -1;
- };
- qq.iosChrome = function() {
- return qq.ios() && navigator.userAgent.indexOf("CriOS") !== -1;
- };
- qq.iosSafari = function() {
- return qq.ios() && !qq.iosChrome() && navigator.userAgent.indexOf("Safari") !== -1;
- };
- qq.iosSafariWebView = function() {
- return qq.ios() && !qq.iosChrome() && !qq.iosSafari();
- };
- qq.preventDefault = function(e) {
- if (e.preventDefault) {
- e.preventDefault();
+
+ if (element.contains){
+ return element.contains(descendant);
} else {
- e.returnValue = false;
+ /*jslint bitwise: true*/
+ return !!(descendant.compareDocumentPosition(element) & 8);
}
- };
- qq.toElement = function() {
- var div = document.createElement("div");
- return function(html) {
- div.innerHTML = html;
- var element = div.firstChild;
- div.removeChild(element);
- return element;
- };
- }();
- qq.each = function(iterableItem, callback) {
- var keyOrIndex, retVal;
- if (iterableItem) {
- if (window.Storage && iterableItem.constructor === window.Storage) {
- for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {
- retVal = callback(iterableItem.key(keyOrIndex), iterableItem.getItem(iterableItem.key(keyOrIndex)));
- if (retVal === false) {
- break;
- }
- }
- } else if (qq.isArray(iterableItem) || qq.isItemList(iterableItem) || qq.isNodeList(iterableItem)) {
- for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {
- retVal = callback(keyOrIndex, iterableItem[keyOrIndex]);
- if (retVal === false) {
- break;
- }
- }
- } else if (qq.isString(iterableItem)) {
- for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {
- retVal = callback(keyOrIndex, iterableItem.charAt(keyOrIndex));
- if (retVal === false) {
- break;
- }
- }
- } else {
- for (keyOrIndex in iterableItem) {
- if (Object.prototype.hasOwnProperty.call(iterableItem, keyOrIndex)) {
- retVal = callback(keyOrIndex, iterableItem[keyOrIndex]);
- if (retVal === false) {
- break;
- }
- }
- }
+ },
+
+ /**
+ * Insert this element before elementB.
+ */
+ insertBefore: function(elementB) {
+ elementB.parentNode.insertBefore(element, elementB);
+ return this;
+ },
+
+ remove: function() {
+ element.parentNode.removeChild(element);
+ return this;
+ },
+
+ /**
+ * Sets styles for an element.
+ * Fixes opacity in IE6-8.
+ */
+ css: function(styles) {
+ if (styles.opacity !== null){
+ if (typeof element.style.opacity !== 'string' && typeof(element.filters) !== 'undefined'){
+ styles.filter = 'alpha(opacity=' + Math.round(100 * styles.opacity) + ')';
}
}
- };
- qq.bind = function(oldFunc, context) {
- if (qq.isFunction(oldFunc)) {
- var args = Array.prototype.slice.call(arguments, 2);
- return function() {
- var newArgs = qq.extend([], args);
- if (arguments.length) {
- newArgs = newArgs.concat(Array.prototype.slice.call(arguments));
- }
- return oldFunc.apply(context, newArgs);
- };
+ qq.extend(element.style, styles);
+
+ return this;
+ },
+
+ hasClass: function(name) {
+ var re = new RegExp('(^| )' + name + '( |$)');
+ return re.test(element.className);
+ },
+
+ addClass: function(name) {
+ if (!qq(element).hasClass(name)){
+ element.className += ' ' + name;
}
- throw new Error("first parameter must be a function!");
- };
- qq.obj2url = function(obj, temp, prefixDone) {
- var uristrings = [], prefix = "&", add = function(nextObj, i) {
- var nextTemp = temp ? /\[\]$/.test(temp) ? temp : temp + "[" + i + "]" : i;
- if (nextTemp !== "undefined" && i !== "undefined") {
- uristrings.push(typeof nextObj === "object" ? qq.obj2url(nextObj, nextTemp, true) : Object.prototype.toString.call(nextObj) === "[object Function]" ? encodeURIComponent(nextTemp) + "=" + encodeURIComponent(nextObj()) : encodeURIComponent(nextTemp) + "=" + encodeURIComponent(nextObj));
- }
- };
- if (!prefixDone && temp) {
- prefix = /\?/.test(temp) ? /\?$/.test(temp) ? "" : "&" : "?";
- uristrings.push(temp);
- uristrings.push(qq.obj2url(obj));
- } else if (Object.prototype.toString.call(obj) === "[object Array]" && typeof obj !== "undefined") {
- qq.each(obj, function(idx, val) {
- add(val, idx);
- });
- } else if (typeof obj !== "undefined" && obj !== null && typeof obj === "object") {
- qq.each(obj, function(prop, val) {
- add(val, prop);
- });
- } else {
- uristrings.push(encodeURIComponent(temp) + "=" + encodeURIComponent(obj));
+ return this;
+ },
+
+ removeClass: function(name) {
+ var re = new RegExp('(^| )' + name + '( |$)');
+ element.className = element.className.replace(re, ' ').replace(/^\s+|\s+$/g, "");
+ return this;
+ },
+
+ getByClass: function(className) {
+ var candidates,
+ result = [];
+
+ if (element.querySelectorAll){
+ return element.querySelectorAll('.' + className);
}
- if (temp) {
- return uristrings.join(prefix);
- } else {
- return uristrings.join(prefix).replace(/^&/, "").replace(/%20/g, "+");
- }
- };
- qq.obj2FormData = function(obj, formData, arrayKeyName) {
- if (!formData) {
- formData = new FormData();
- }
- qq.each(obj, function(key, val) {
- key = arrayKeyName ? arrayKeyName + "[" + key + "]" : key;
- if (qq.isObject(val)) {
- qq.obj2FormData(val, formData, key);
- } else if (qq.isFunction(val)) {
- formData.append(key, val());
- } else {
- formData.append(key, val);
+
+ candidates = element.getElementsByTagName("*");
+
+ qq.each(candidates, function(idx, val) {
+ if (qq(val).hasClass(className)){
+ result.push(val);
}
});
- return formData;
- };
- qq.obj2Inputs = function(obj, form) {
- var input;
- if (!form) {
- form = document.createElement("form");
- }
- qq.obj2FormData(obj, {
- append: function(key, val) {
- input = document.createElement("input");
- input.setAttribute("name", key);
- input.setAttribute("value", val);
- form.appendChild(input);
+ return result;
+ },
+
+ children: function() {
+ var children = [],
+ child = element.firstChild;
+
+ while (child){
+ if (child.nodeType === 1){
+ children.push(child);
}
- });
- return form;
- };
- qq.parseJson = function(json) {
- if (window.JSON && qq.isFunction(JSON.parse)) {
- return JSON.parse(json);
- } else {
- return eval("(" + json + ")");
+ child = child.nextSibling;
}
- };
- qq.getExtension = function(filename) {
- var extIdx = filename.lastIndexOf(".") + 1;
- if (extIdx > 0) {
- return filename.substr(extIdx, filename.length - extIdx);
+
+ return children;
+ },
+
+ setText: function(text) {
+ element.innerText = text;
+ element.textContent = text;
+ return this;
+ },
+
+ clearText: function() {
+ return qq(element).setText("");
+ }
+ };
+};
+
+qq.log = function(message, level) {
+ "use strict";
+
+ if (window.console) {
+ if (!level || level === 'info') {
+ window.console.log(message);
+ }
+ else
+ {
+ if (window.console[level]) {
+ window.console[level](message);
}
- };
- qq.getFilename = function(blobOrFileInput) {
- if (qq.isInput(blobOrFileInput)) {
- return blobOrFileInput.value.replace(/.*(\/|\\)/, "");
- } else if (qq.isFile(blobOrFileInput)) {
- if (blobOrFileInput.fileName !== null && blobOrFileInput.fileName !== undefined) {
- return blobOrFileInput.fileName;
- }
+ else {
+ window.console.log('<' + level + '> ' + message);
}
- return blobOrFileInput.name;
- };
- qq.DisposeSupport = function() {
- var disposers = [];
- return {
- dispose: function() {
- var disposer;
- do {
- disposer = disposers.shift();
- if (disposer) {
- disposer();
- }
- } while (disposer);
- },
- attach: function() {
- var args = arguments;
- this.addDisposer(qq(args[0]).attach.apply(this, Array.prototype.slice.call(arguments, 1)));
- },
- addDisposer: function(disposeFunction) {
- disposers.push(disposeFunction);
- }
- };
- };
- })();
- (function() {
- "use strict";
- if (typeof define === "function" && define.amd) {
- define(function() {
- return qq;
- });
- } else if (typeof module !== "undefined" && module.exports) {
- module.exports = qq;
- } else {
- global.qq = qq;
}
- })();
- (function() {
- "use strict";
- qq.Error = function(message) {
- this.message = "[Fine Uploader " + qq.version + "] " + message;
- };
- qq.Error.prototype = new Error();
- })();
- qq.version = "5.15.4";
- qq.supportedFeatures = function() {
- "use strict";
- var supportsUploading, supportsUploadingBlobs, supportsFileDrop, supportsAjaxFileUploading, supportsFolderDrop, supportsChunking, supportsResume, supportsUploadViaPaste, supportsUploadCors, supportsDeleteFileXdr, supportsDeleteFileCorsXhr, supportsDeleteFileCors, supportsFolderSelection, supportsImagePreviews, supportsUploadProgress;
- function testSupportsFileInputElement() {
- var supported = true, tempInput;
- try {
- tempInput = document.createElement("input");
- tempInput.type = "file";
- qq(tempInput).hide();
- if (tempInput.disabled) {
- supported = false;
- }
- } catch (ex) {
- supported = false;
- }
- return supported;
- }
- function isChrome21OrHigher() {
- return (qq.chrome() || qq.opera()) && navigator.userAgent.match(/Chrome\/[2][1-9]|Chrome\/[3-9][0-9]/) !== undefined;
- }
- function isChrome14OrHigher() {
- return (qq.chrome() || qq.opera()) && navigator.userAgent.match(/Chrome\/[1][4-9]|Chrome\/[2-9][0-9]/) !== undefined;
- }
- function isCrossOriginXhrSupported() {
- if (window.XMLHttpRequest) {
- var xhr = qq.createXhrInstance();
- return xhr.withCredentials !== undefined;
- }
- return false;
- }
- function isXdrSupported() {
- return window.XDomainRequest !== undefined;
- }
- function isCrossOriginAjaxSupported() {
- if (isCrossOriginXhrSupported()) {
+ }
+};
+
+qq.isObject = function(variable) {
+ "use strict";
+ return variable !== null && variable && typeof(variable) === "object" && variable.constructor === Object;
+};
+
+qq.isFunction = function(variable) {
+ "use strict";
+ return typeof(variable) === "function";
+};
+
+qq.trimStr = function(string) {
+ if (String.prototype.trim) {
+ return string.trim();
+ }
+
+ return string.replace(/^\s+|\s+$/g,'');
+};
+
+qq.isFileOrInput = function(maybeFileOrInput) {
+ "use strict";
+ if (qq.isBlob(maybeFileOrInput) && window.File && maybeFileOrInput instanceof File) {
+ return true;
+ }
+ else if (window.HTMLInputElement) {
+ if (maybeFileOrInput instanceof HTMLInputElement) {
+ if (maybeFileOrInput.type && maybeFileOrInput.type.toLowerCase() === 'file') {
return true;
}
- return isXdrSupported();
}
- function isFolderSelectionSupported() {
- return document.createElement("input").webkitdirectory !== undefined;
- }
- function isLocalStorageSupported() {
- try {
- return !!window.localStorage && qq.isFunction(window.localStorage.setItem);
- } catch (error) {
- return false;
+ }
+ else if (maybeFileOrInput.tagName) {
+ if (maybeFileOrInput.tagName.toLowerCase() === 'input') {
+ if (maybeFileOrInput.type && maybeFileOrInput.type.toLowerCase() === 'file') {
+ return true;
}
}
- function isDragAndDropSupported() {
- var span = document.createElement("span");
- return ("draggable" in span || "ondragstart" in span && "ondrop" in span) && !qq.android() && !qq.ios();
- }
- supportsUploading = testSupportsFileInputElement();
- supportsAjaxFileUploading = supportsUploading && qq.isXhrUploadSupported();
- supportsUploadingBlobs = supportsAjaxFileUploading && !qq.androidStock();
- supportsFileDrop = supportsAjaxFileUploading && isDragAndDropSupported();
- supportsFolderDrop = supportsFileDrop && isChrome21OrHigher();
- supportsChunking = supportsAjaxFileUploading && qq.isFileChunkingSupported();
- supportsResume = supportsAjaxFileUploading && supportsChunking && isLocalStorageSupported();
- supportsUploadViaPaste = supportsAjaxFileUploading && isChrome14OrHigher();
- supportsUploadCors = supportsUploading && (window.postMessage !== undefined || supportsAjaxFileUploading);
- supportsDeleteFileCorsXhr = isCrossOriginXhrSupported();
- supportsDeleteFileXdr = isXdrSupported();
- supportsDeleteFileCors = isCrossOriginAjaxSupported();
- supportsFolderSelection = isFolderSelectionSupported();
- supportsImagePreviews = supportsAjaxFileUploading && window.FileReader !== undefined;
- supportsUploadProgress = function() {
- if (supportsAjaxFileUploading) {
- return !qq.androidStock() && !qq.iosChrome();
+ }
+
+ return false;
+};
+
+qq.isBlob = function(maybeBlob) {
+ "use strict";
+ return window.Blob && maybeBlob instanceof Blob;
+};
+
+qq.isXhrUploadSupported = function() {
+ "use strict";
+ var input = document.createElement('input');
+ input.type = 'file';
+
+ return (
+ input.multiple !== undefined &&
+ typeof File !== "undefined" &&
+ typeof FormData !== "undefined" &&
+ typeof (new XMLHttpRequest()).upload !== "undefined" );
+};
+
+qq.isFolderDropSupported = function(dataTransfer) {
+ "use strict";
+ return (dataTransfer.items && dataTransfer.items[0].webkitGetAsEntry);
+};
+
+qq.isFileChunkingSupported = function() {
+ "use strict";
+ return !qq.android() && //android's impl of Blob.slice is broken
+ qq.isXhrUploadSupported() &&
+ (File.prototype.slice || File.prototype.webkitSlice || File.prototype.mozSlice);
+};
+
+qq.extend = function (first, second, extendNested) {
+ "use strict";
+ qq.each(second, function(prop, val) {
+ if (extendNested && qq.isObject(val)) {
+ if (first[prop] === undefined) {
+ first[prop] = {};
+ }
+ qq.extend(first[prop], val, true);
+ }
+ else {
+ first[prop] = val;
+ }
+ });
+};
+
+/**
+ * Searches for a given element in the array, returns -1 if it is not present.
+ * @param {Number} [from] The index at which to begin the search
+ */
+qq.indexOf = function(arr, elt, from){
+ "use strict";
+
+ if (arr.indexOf) {
+ return arr.indexOf(elt, from);
+ }
+
+ from = from || 0;
+ var len = arr.length;
+
+ if (from < 0) {
+ from += len;
+ }
+
+ for (; from < len; from+=1){
+ if (arr.hasOwnProperty(from) && arr[from] === elt){
+ return from;
+ }
+ }
+ return -1;
+};
+
+//this is a version 4 UUID
+qq.getUniqueId = function(){
+ "use strict";
+
+ return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+ /*jslint eqeq: true, bitwise: true*/
+ var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
+ return v.toString(16);
+ });
+};
+
+//
+// Browsers and platforms detection
+
+qq.ie = function(){
+ "use strict";
+ return navigator.userAgent.indexOf('MSIE') !== -1;
+};
+qq.ie10 = function(){
+ "use strict";
+ return navigator.userAgent.indexOf('MSIE 10') !== -1;
+};
+qq.safari = function(){
+ "use strict";
+ return navigator.vendor !== undefined && navigator.vendor.indexOf("Apple") !== -1;
+};
+qq.chrome = function(){
+ "use strict";
+ return navigator.vendor !== undefined && navigator.vendor.indexOf('Google') !== -1;
+};
+qq.firefox = function(){
+ "use strict";
+ return (navigator.userAgent.indexOf('Mozilla') !== -1 && navigator.vendor !== undefined && navigator.vendor === '');
+};
+qq.windows = function(){
+ "use strict";
+ return navigator.platform === "Win32";
+};
+qq.android = function(){
+ "use strict";
+ return navigator.userAgent.toLowerCase().indexOf('android') !== -1;
+};
+
+//
+// Events
+
+qq.preventDefault = function(e){
+ "use strict";
+ if (e.preventDefault){
+ e.preventDefault();
+ } else{
+ e.returnValue = false;
+ }
+};
+
+/**
+ * Creates and returns element from html string
+ * Uses innerHTML to create an element
+ */
+qq.toElement = (function(){
+ "use strict";
+ var div = document.createElement('div');
+ return function(html){
+ div.innerHTML = html;
+ var element = div.firstChild;
+ div.removeChild(element);
+ return element;
+ };
+}());
+
+//key and value are passed to callback for each item in the object or array
+qq.each = function(obj, callback) {
+ "use strict";
+ var key, retVal;
+ if (obj) {
+ for (key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) {
+ retVal = callback(key, obj[key]);
+ if (retVal === false) {
+ break;
+ }
+ }
+ }
+ }
+};
+
+/**
+ * obj2url() takes a json-object as argument and generates
+ * a querystring. pretty much like jQuery.param()
+ *
+ * how to use:
+ *
+ * `qq.obj2url({a:'b',c:'d'},'http://any.url/upload?otherParam=value');`
+ *
+ * will result in:
+ *
+ * `http://any.url/upload?otherParam=value&a=b&c=d`
+ *
+ * @param Object JSON-Object
+ * @param String current querystring-part
+ * @return String encoded querystring
+ */
+qq.obj2url = function(obj, temp, prefixDone){
+ "use strict";
+ /*jshint laxbreak: true*/
+ var i, len,
+ uristrings = [],
+ prefix = '&',
+ add = function(nextObj, i){
+ var nextTemp = temp
+ ? (/\[\]$/.test(temp)) // prevent double-encoding
+ ? temp
+ : temp+'['+i+']'
+ : i;
+ if ((nextTemp !== 'undefined') && (i !== 'undefined')) {
+ uristrings.push(
+ (typeof nextObj === 'object')
+ ? qq.obj2url(nextObj, nextTemp, true)
+ : (Object.prototype.toString.call(nextObj) === '[object Function]')
+ ? encodeURIComponent(nextTemp) + '=' + encodeURIComponent(nextObj())
+ : encodeURIComponent(nextTemp) + '=' + encodeURIComponent(nextObj)
+ );
}
- return false;
- }();
- return {
- ajaxUploading: supportsAjaxFileUploading,
- blobUploading: supportsUploadingBlobs,
- canDetermineSize: supportsAjaxFileUploading,
- chunking: supportsChunking,
- deleteFileCors: supportsDeleteFileCors,
- deleteFileCorsXdr: supportsDeleteFileXdr,
- deleteFileCorsXhr: supportsDeleteFileCorsXhr,
- dialogElement: !!window.HTMLDialogElement,
- fileDrop: supportsFileDrop,
- folderDrop: supportsFolderDrop,
- folderSelection: supportsFolderSelection,
- imagePreviews: supportsImagePreviews,
- imageValidation: supportsImagePreviews,
- itemSizeValidation: supportsAjaxFileUploading,
- pause: supportsChunking,
- progressBar: supportsUploadProgress,
- resume: supportsResume,
- scaling: supportsImagePreviews && supportsUploadingBlobs,
- tiffPreviews: qq.safari(),
- unlimitedScaledImageSize: !qq.ios(),
- uploading: supportsUploading,
- uploadCors: supportsUploadCors,
- uploadCustomHeaders: supportsAjaxFileUploading,
- uploadNonMultipart: supportsAjaxFileUploading,
- uploadViaPaste: supportsUploadViaPaste
};
- }();
- qq.isGenericPromise = function(maybePromise) {
- "use strict";
- return !!(maybePromise && maybePromise.then && qq.isFunction(maybePromise.then));
- };
- qq.Promise = function() {
- "use strict";
- var successArgs, failureArgs, successCallbacks = [], failureCallbacks = [], doneCallbacks = [], state = 0;
- qq.extend(this, {
- then: function(onSuccess, onFailure) {
- if (state === 0) {
- if (onSuccess) {
- successCallbacks.push(onSuccess);
- }
- if (onFailure) {
- failureCallbacks.push(onFailure);
- }
- } else if (state === -1) {
- onFailure && onFailure.apply(null, failureArgs);
- } else if (onSuccess) {
- onSuccess.apply(null, successArgs);
- }
- return this;
- },
- done: function(callback) {
- if (state === 0) {
- doneCallbacks.push(callback);
- } else {
- callback.apply(null, failureArgs === undefined ? successArgs : failureArgs);
- }
- return this;
- },
- success: function() {
- state = 1;
- successArgs = arguments;
- if (successCallbacks.length) {
- qq.each(successCallbacks, function(idx, callback) {
- callback.apply(null, successArgs);
- });
- }
- if (doneCallbacks.length) {
- qq.each(doneCallbacks, function(idx, callback) {
- callback.apply(null, successArgs);
- });
- }
- return this;
- },
- failure: function() {
- state = -1;
- failureArgs = arguments;
- if (failureCallbacks.length) {
- qq.each(failureCallbacks, function(idx, callback) {
- callback.apply(null, failureArgs);
- });
- }
- if (doneCallbacks.length) {
- qq.each(doneCallbacks, function(idx, callback) {
- callback.apply(null, failureArgs);
- });
- }
- return this;
- }
- });
- };
- qq.BlobProxy = function(referenceBlob, onCreate) {
- "use strict";
- qq.extend(this, {
- referenceBlob: referenceBlob,
- create: function() {
- return onCreate(referenceBlob);
- }
- });
- };
- qq.UploadButton = function(o) {
- "use strict";
- var self = this, disposeSupport = new qq.DisposeSupport(), options = {
- acceptFiles: null,
- element: null,
- focusClass: "qq-upload-button-focus",
- folders: false,
- hoverClass: "qq-upload-button-hover",
- ios8BrowserCrashWorkaround: false,
- multiple: false,
- name: "qqfile",
- onChange: function(input) {},
- title: null
- }, input, buttonId;
- qq.extend(options, o);
- buttonId = qq.getUniqueId();
- function createInput() {
- var input = document.createElement("input");
- input.setAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME, buttonId);
- input.setAttribute("title", options.title);
- self.setMultiple(options.multiple, input);
- if (options.folders && qq.supportedFeatures.folderSelection) {
- input.setAttribute("webkitdirectory", "");
- }
- if (options.acceptFiles) {
- input.setAttribute("accept", options.acceptFiles);
- }
- input.setAttribute("type", "file");
- input.setAttribute("name", options.name);
- qq(input).css({
- position: "absolute",
- right: 0,
- top: 0,
- fontFamily: "Arial",
- fontSize: qq.ie() && !qq.ie8() ? "3500px" : "118px",
- margin: 0,
- padding: 0,
- cursor: "pointer",
- opacity: 0
- });
- !qq.ie7() && qq(input).css({
- height: "100%"
- });
- options.element.appendChild(input);
- disposeSupport.attach(input, "change", function() {
- options.onChange(input);
- });
- disposeSupport.attach(input, "mouseover", function() {
- qq(options.element).addClass(options.hoverClass);
- });
- disposeSupport.attach(input, "mouseout", function() {
- qq(options.element).removeClass(options.hoverClass);
- });
- disposeSupport.attach(input, "focus", function() {
- qq(options.element).addClass(options.focusClass);
- });
- disposeSupport.attach(input, "blur", function() {
- qq(options.element).removeClass(options.focusClass);
- });
- return input;
+
+ if (!prefixDone && temp) {
+ prefix = (/\?/.test(temp)) ? (/\?$/.test(temp)) ? '' : '&' : '?';
+ uristrings.push(temp);
+ uristrings.push(qq.obj2url(obj));
+ } else if ((Object.prototype.toString.call(obj) === '[object Array]') && (typeof obj !== 'undefined') ) {
+ // we wont use a for-in-loop on an array (performance)
+ for (i = -1, len = obj.length; i < len; i+=1){
+ add(obj[i], i);
}
- qq(options.element).css({
- position: "relative",
- overflow: "hidden",
- direction: "ltr"
- });
- qq.extend(this, {
- getInput: function() {
- return input;
- },
- getButtonId: function() {
- return buttonId;
- },
- setMultiple: function(isMultiple, optInput) {
- var input = optInput || this.getInput();
- if (options.ios8BrowserCrashWorkaround && qq.ios8() && (qq.iosChrome() || qq.iosSafariWebView())) {
- input.setAttribute("multiple", "");
- } else {
- if (isMultiple) {
- input.setAttribute("multiple", "");
- } else {
- input.removeAttribute("multiple");
- }
- }
- },
- setAcceptFiles: function(acceptFiles) {
- if (acceptFiles !== options.acceptFiles) {
- input.setAttribute("accept", acceptFiles);
- }
- },
- reset: function() {
- if (input.parentNode) {
- qq(input).remove();
- }
- qq(options.element).removeClass(options.focusClass);
- input = null;
- input = createInput();
+ } else if ((typeof obj !== 'undefined') && (obj !== null) && (typeof obj === "object")){
+ // for anything else but a scalar, we will use for-in-loop
+ for (i in obj){
+ if (obj.hasOwnProperty(i)) {
+ add(obj[i], i);
}
- });
- input = createInput();
+ }
+ } else {
+ uristrings.push(encodeURIComponent(temp) + '=' + encodeURIComponent(obj));
+ }
+
+ if (temp) {
+ return uristrings.join(prefix);
+ } else {
+ return uristrings.join(prefix)
+ .replace(/^&/, '')
+ .replace(/%20/g, '+');
+ }
+};
+
+qq.obj2FormData = function(obj, formData, arrayKeyName) {
+ "use strict";
+ if (!formData) {
+ formData = new FormData();
+ }
+
+ qq.each(obj, function(key, val) {
+ key = arrayKeyName ? arrayKeyName + '[' + key + ']' : key;
+
+ if (qq.isObject(val)) {
+ qq.obj2FormData(val, formData, key);
+ }
+ else if (qq.isFunction(val)) {
+ formData.append(key, val());
+ }
+ else {
+ formData.append(key, val);
+ }
+ });
+
+ return formData;
+};
+
+qq.obj2Inputs = function(obj, form) {
+ "use strict";
+ var input;
+
+ if (!form) {
+ form = document.createElement('form');
+ }
+
+ qq.obj2FormData(obj, {
+ append: function(key, val) {
+ input = document.createElement('input');
+ input.setAttribute('name', key);
+ input.setAttribute('value', val);
+ form.appendChild(input);
+ }
+ });
+
+ return form;
+};
+
+qq.setCookie = function(name, value, days) {
+ var date = new Date(),
+ expires = "";
+
+ if (days) {
+ date.setTime(date.getTime()+(days*24*60*60*1000));
+ expires = "; expires="+date.toGMTString();
+ }
+
+ document.cookie = name+"="+value+expires+"; path=/";
+};
+
+qq.getCookie = function(name) {
+ var nameEQ = name + "=",
+ ca = document.cookie.split(';'),
+ c;
+
+ for(var i=0;i < ca.length;i++) {
+ c = ca[i];
+ while (c.charAt(0)==' ') {
+ c = c.substring(1,c.length);
+ }
+ if (c.indexOf(nameEQ) === 0) {
+ return c.substring(nameEQ.length,c.length);
+ }
+ }
+};
+
+qq.getCookieNames = function(regexp) {
+ var cookies = document.cookie.split(';'),
+ cookieNames = [];
+
+ qq.each(cookies, function(idx, cookie) {
+ cookie = qq.trimStr(cookie);
+
+ var equalsIdx = cookie.indexOf("=");
+
+ if (cookie.match(regexp)) {
+ cookieNames.push(cookie.substr(0, equalsIdx));
+ }
+ });
+
+ return cookieNames;
+};
+
+qq.deleteCookie = function(name) {
+ qq.setCookie(name, "", -1);
+};
+
+qq.areCookiesEnabled = function() {
+ var randNum = Math.random() * 100000,
+ name = "qqCookieTest:" + randNum;
+ qq.setCookie(name, 1);
+
+ if (qq.getCookie(name)) {
+ qq.deleteCookie(name);
+ return true;
+ }
+ return false;
+};
+
+/**
+ * Not recommended for use outside of Fine Uploader since this falls back to an unchecked eval if JSON.parse is not
+ * implemented. For a more secure JSON.parse polyfill, use Douglas Crockford's json2.js.
+ */
+qq.parseJson = function(json) {
+ /*jshint evil: true*/
+ if (window.JSON && qq.isFunction(JSON.parse)) {
+ return JSON.parse(json);
+ } else {
+ return eval("(" + json + ")");
+ }
+};
+
+/**
+ * A generic module which supports object disposing in dispose() method.
+ * */
+qq.DisposeSupport = function() {
+ "use strict";
+ var disposers = [];
+
+ return {
+ /** Run all registered disposers */
+ dispose: function() {
+ var disposer;
+ do {
+ disposer = disposers.shift();
+ if (disposer) {
+ disposer();
+ }
+ }
+ while (disposer);
+ },
+
+ /** Attach event handler and register de-attacher as a disposer */
+ attach: function() {
+ var args = arguments;
+ /*jslint undef:true*/
+ this.addDisposer(qq(args[0]).attach.apply(this, Array.prototype.slice.call(arguments, 1)));
+ },
+
+ /** Add disposer to the collection */
+ addDisposer: function(disposeFunction) {
+ disposers.push(disposeFunction);
+ }
};
- qq.UploadButton.BUTTON_ID_ATTR_NAME = "qq-button-id";
- qq.UploadData = function(uploaderProxy) {
+};
+qq.UploadButton = function(o){
+ this._options = {
+ element: null,
+ // if set to true adds multiple attribute to file input
+ multiple: false,
+ acceptFiles: null,
+ // name attribute of file input
+ name: 'file',
+ onChange: function(input){},
+ hoverClass: 'qq-upload-button-hover',
+ focusClass: 'qq-upload-button-focus'
+ };
+
+ qq.extend(this._options, o);
+ this._disposeSupport = new qq.DisposeSupport();
+
+ this._element = this._options.element;
+
+ // make button suitable container for input
+ qq(this._element).css({
+ position: 'relative',
+ overflow: 'hidden',
+ // Make sure browse button is in the right side
+ // in Internet Explorer
+ direction: 'ltr'
+ });
+
+ this._input = this._createInput();
+};
+
+qq.UploadButton.prototype = {
+ /* returns file input element */
+ getInput: function(){
+ return this._input;
+ },
+ /* cleans/recreates the file input */
+ reset: function(){
+ if (this._input.parentNode){
+ qq(this._input).remove();
+ }
+
+ qq(this._element).removeClass(this._options.focusClass);
+ this._input = this._createInput();
+ },
+ _createInput: function(){
+ var input = document.createElement("input");
+
+ if (this._options.multiple){
+ input.setAttribute("multiple", "multiple");
+ }
+
+ if (this._options.acceptFiles) input.setAttribute("accept", this._options.acceptFiles);
+
+ input.setAttribute("type", "file");
+ input.setAttribute("name", this._options.name);
+
+ qq(input).css({
+ position: 'absolute',
+ // in Opera only 'browse' button
+ // is clickable and it is located at
+ // the right side of the input
+ right: 0,
+ top: 0,
+ fontFamily: 'Arial',
+ // 4 persons reported this, the max values that worked for them were 243, 236, 236, 118
+ fontSize: '118px',
+ margin: 0,
+ padding: 0,
+ cursor: 'pointer',
+ opacity: 0
+ });
+
+ this._element.appendChild(input);
+
+ var self = this;
+ this._disposeSupport.attach(input, 'change', function(){
+ self._options.onChange(input);
+ });
+
+ this._disposeSupport.attach(input, 'mouseover', function(){
+ qq(self._element).addClass(self._options.hoverClass);
+ });
+ this._disposeSupport.attach(input, 'mouseout', function(){
+ qq(self._element).removeClass(self._options.hoverClass);
+ });
+ this._disposeSupport.attach(input, 'focus', function(){
+ qq(self._element).addClass(self._options.focusClass);
+ });
+ this._disposeSupport.attach(input, 'blur', function(){
+ qq(self._element).removeClass(self._options.focusClass);
+ });
+
+ // IE and Opera, unfortunately have 2 tab stops on file input
+ // which is unacceptable in our case, disable keyboard access
+ if (window.attachEvent){
+ // it is IE or Opera
+ input.setAttribute('tabIndex', "-1");
+ }
+
+ return input;
+ }
+};
+qq.FineUploaderBasic = function(o){
+ var that = this;
+ this._options = {
+ debug: false,
+ button: null,
+ multiple: true,
+ maxConnections: 3,
+ disableCancelForFormUploads: false,
+ autoUpload: true,
+ request: {
+ endpoint: '/server/upload',
+ params: {},
+ paramsInBody: true,
+ customHeaders: {},
+ forceMultipart: true,
+ inputName: 'qqfile',
+ uuidName: 'qquuid',
+ totalFileSizeName: 'qqtotalfilesize'
+ },
+ validation: {
+ allowedExtensions: [],
+ sizeLimit: 0,
+ minSizeLimit: 0,
+ stopOnFirstInvalidFile: true
+ },
+ callbacks: {
+ onSubmit: function(id, name){},
+ onComplete: function(id, name, responseJSON){},
+ onCancel: function(id, name){},
+ onUpload: function(id, name){},
+ onUploadChunk: function(id, name, chunkData){},
+ onResume: function(id, fileName, chunkData){},
+ onProgress: function(id, name, loaded, total){},
+ onError: function(id, name, reason) {},
+ onAutoRetry: function(id, name, attemptNumber) {},
+ onManualRetry: function(id, name) {},
+ onValidateBatch: function(fileOrBlobData) {},
+ onValidate: function(fileOrBlobData) {},
+ onSubmitDelete: function(id) {},
+ onDelete: function(id){},
+ onDeleteComplete: function(id, xhr, isError){}
+ },
+ messages: {
+ typeError: "{file} has an invalid extension. Valid extension(s): {extensions}.",
+ sizeError: "{file} is too large, maximum file size is {sizeLimit}.",
+ minSizeError: "{file} is too small, minimum file size is {minSizeLimit}.",
+ emptyError: "{file} is empty, please select files again without it.",
+ noFilesError: "No files to upload.",
+ onLeave: "The files are being uploaded, if you leave now the upload will be cancelled."
+ },
+ retry: {
+ enableAuto: false,
+ maxAutoAttempts: 3,
+ autoAttemptDelay: 5,
+ preventRetryResponseProperty: 'preventRetry'
+ },
+ classes: {
+ buttonHover: 'qq-upload-button-hover',
+ buttonFocus: 'qq-upload-button-focus'
+ },
+ chunking: {
+ enabled: false,
+ partSize: 2000000,
+ paramNames: {
+ partIndex: 'qqpartindex',
+ partByteOffset: 'qqpartbyteoffset',
+ chunkSize: 'qqchunksize',
+ totalFileSize: 'qqtotalfilesize',
+ totalParts: 'qqtotalparts',
+ filename: 'qqfilename'
+ }
+ },
+ resume: {
+ enabled: false,
+ id: null,
+ cookiesExpireIn: 7, //days
+ paramNames: {
+ resuming: "qqresume"
+ }
+ },
+ formatFileName: function(fileOrBlobName) {
+ if (fileOrBlobName.length > 33) {
+ fileOrBlobName = fileOrBlobName.slice(0, 19) + '...' + fileOrBlobName.slice(-14);
+ }
+ return fileOrBlobName;
+ },
+ text: {
+ sizeSymbols: ['kB', 'MB', 'GB', 'TB', 'PB', 'EB']
+ },
+ deleteFile : {
+ enabled: false,
+ endpoint: '/server/upload',
+ customHeaders: {},
+ params: {}
+ },
+ cors: {
+ expected: false,
+ sendCredentials: false
+ },
+ blobs: {
+ defaultName: 'Misc data',
+ paramNames: {
+ name: 'qqblobname'
+ }
+ }
+ };
+
+ qq.extend(this._options, o, true);
+ this._wrapCallbacks();
+ this._disposeSupport = new qq.DisposeSupport();
+
+ // number of files being uploaded
+ this._filesInProgress = [];
+
+ this._storedIds = [];
+
+ this._autoRetries = [];
+ this._retryTimeouts = [];
+ this._preventRetries = [];
+
+ this._paramsStore = this._createParamsStore("request");
+ this._deleteFileParamsStore = this._createParamsStore("deleteFile");
+
+ this._endpointStore = this._createEndpointStore("request");
+ this._deleteFileEndpointStore = this._createEndpointStore("deleteFile");
+
+ this._handler = this._createUploadHandler();
+ this._deleteHandler = this._createDeleteHandler();
+
+ if (this._options.button){
+ this._button = this._createUploadButton(this._options.button);
+ }
+
+ this._preventLeaveInProgress();
+};
+
+qq.FineUploaderBasic.prototype = {
+ log: function(str, level) {
+ if (this._options.debug && (!level || level === 'info')) {
+ qq.log('[FineUploader] ' + str);
+ }
+ else if (level && level !== 'info') {
+ qq.log('[FineUploader] ' + str, level);
+
+ }
+ },
+ setParams: function(params, id) {
+ /*jshint eqeqeq: true, eqnull: true*/
+ if (id == null) {
+ this._options.request.params = params;
+ }
+ else {
+ this._paramsStore.setParams(params, id);
+ }
+ },
+ setDeleteFileParams: function(params, id) {
+ /*jshint eqeqeq: true, eqnull: true*/
+ if (id == null) {
+ this._options.deleteFile.params = params;
+ }
+ else {
+ this._deleteFileParamsStore.setParams(params, id);
+ }
+ },
+ setEndpoint: function(endpoint, id) {
+ /*jshint eqeqeq: true, eqnull: true*/
+ if (id == null) {
+ this._options.request.endpoint = endpoint;
+ }
+ else {
+ this._endpointStore.setEndpoint(endpoint, id);
+ }
+ },
+ getInProgress: function(){
+ return this._filesInProgress.length;
+ },
+ uploadStoredFiles: function(){
"use strict";
- var data = [], byUuid = {}, byStatus = {}, byProxyGroupId = {}, byBatchId = {};
- function getDataByIds(idOrIds) {
- if (qq.isArray(idOrIds)) {
- var entries = [];
- qq.each(idOrIds, function(idx, id) {
- entries.push(data[id]);
- });
- return entries;
- }
- return data[idOrIds];
+ var idToUpload;
+
+ while(this._storedIds.length) {
+ idToUpload = this._storedIds.shift();
+ this._filesInProgress.push(idToUpload);
+ this._handler.upload(idToUpload);
}
- function getDataByUuids(uuids) {
- if (qq.isArray(uuids)) {
- var entries = [];
- qq.each(uuids, function(idx, uuid) {
- entries.push(data[byUuid[uuid]]);
- });
- return entries;
- }
- return data[byUuid[uuids]];
+ },
+ clearStoredFiles: function(){
+ this._storedIds = [];
+ },
+ retry: function(id) {
+ if (this._onBeforeManualRetry(id)) {
+ this._handler.retry(id);
+ return true;
}
- function getDataByStatus(status) {
- var statusResults = [], statuses = [].concat(status);
- qq.each(statuses, function(index, statusEnum) {
- var statusResultIndexes = byStatus[statusEnum];
- if (statusResultIndexes !== undefined) {
- qq.each(statusResultIndexes, function(i, dataIndex) {
- statusResults.push(data[dataIndex]);
+ else {
+ return false;
+ }
+ },
+ cancel: function(id) {
+ this._handler.cancel(id);
+ },
+ cancelAll: function() {
+ var storedIdsCopy = [],
+ self = this;
+
+ qq.extend(storedIdsCopy, this._storedIds);
+ qq.each(storedIdsCopy, function(idx, storedFileId) {
+ self.cancel(storedFileId);
+ });
+
+ this._handler.cancelAll();
+ },
+ reset: function() {
+ this.log("Resetting uploader...");
+ this._handler.reset();
+ this._filesInProgress = [];
+ this._storedIds = [];
+ this._autoRetries = [];
+ this._retryTimeouts = [];
+ this._preventRetries = [];
+ this._button.reset();
+ this._paramsStore.reset();
+ this._endpointStore.reset();
+ },
+ addFiles: function(filesBlobDataOrInputs) {
+ var self = this,
+ verifiedFilesOrInputs = [],
+ index, fileOrInput;
+
+ if (filesBlobDataOrInputs) {
+ if (!window.FileList || !(filesBlobDataOrInputs instanceof FileList)) {
+ filesBlobDataOrInputs = [].concat(filesBlobDataOrInputs);
+ }
+
+ for (index = 0; index < filesBlobDataOrInputs.length; index+=1) {
+ fileOrInput = filesBlobDataOrInputs[index];
+
+ if (qq.isFileOrInput(fileOrInput)) {
+ verifiedFilesOrInputs.push(fileOrInput);
+ }
+ else {
+ self.log(fileOrInput + ' is not a File or INPUT element! Ignoring!', 'warn');
+ }
+ }
+
+ this.log('Processing ' + verifiedFilesOrInputs.length + ' files or inputs...');
+ this._uploadFileOrBlobDataList(verifiedFilesOrInputs);
+ }
+ },
+ addBlobs: function(blobDataOrArray) {
+ if (blobDataOrArray) {
+ var blobDataArray = [].concat(blobDataOrArray),
+ verifiedBlobDataList = [],
+ self = this;
+
+ qq.each(blobDataArray, function(idx, blobData) {
+ if (qq.isBlob(blobData) && !qq.isFileOrInput(blobData)) {
+ verifiedBlobDataList.push({
+ blob: blobData,
+ name: self._options.blobs.defaultName
});
}
+ else if (qq.isObject(blobData) && blobData.blob && blobData.name) {
+ verifiedBlobDataList.push(blobData);
+ }
+ else {
+ self.log("addBlobs: entry at index " + idx + " is not a Blob or a BlobData object", "error");
+ }
});
- return statusResults;
+
+ this._uploadFileOrBlobDataList(verifiedBlobDataList);
}
- qq.extend(this, {
- addFile: function(spec) {
- var status = spec.status || qq.status.SUBMITTING, id = data.push({
- name: spec.name,
- originalName: spec.name,
- uuid: spec.uuid,
- size: spec.size == null ? -1 : spec.size,
- status: status
- }) - 1;
- if (spec.batchId) {
- data[id].batchId = spec.batchId;
- if (byBatchId[spec.batchId] === undefined) {
- byBatchId[spec.batchId] = [];
- }
- byBatchId[spec.batchId].push(id);
- }
- if (spec.proxyGroupId) {
- data[id].proxyGroupId = spec.proxyGroupId;
- if (byProxyGroupId[spec.proxyGroupId] === undefined) {
- byProxyGroupId[spec.proxyGroupId] = [];
- }
- byProxyGroupId[spec.proxyGroupId].push(id);
- }
- data[id].id = id;
- byUuid[spec.uuid] = id;
- if (byStatus[status] === undefined) {
- byStatus[status] = [];
- }
- byStatus[status].push(id);
- spec.onBeforeStatusChange && spec.onBeforeStatusChange(id);
- uploaderProxy.onStatusChange(id, null, status);
- return id;
+ else {
+ this.log("undefined or non-array parameter passed into addBlobs", "error");
+ }
+ },
+ getUuid: function(id) {
+ return this._handler.getUuid(id);
+ },
+ getResumableFilesData: function() {
+ return this._handler.getResumableFilesData();
+ },
+ getSize: function(id) {
+ return this._handler.getSize(id);
+ },
+ getFile: function(fileOrBlobId) {
+ return this._handler.getFile(fileOrBlobId);
+ },
+ deleteFile: function(id) {
+ this._onSubmitDelete(id);
+ },
+ setDeleteFileEndpoint: function(endpoint, id) {
+ /*jshint eqeqeq: true, eqnull: true*/
+ if (id == null) {
+ this._options.deleteFile.endpoint = endpoint;
+ }
+ else {
+ this._deleteFileEndpointStore.setEndpoint(endpoint, id);
+ }
+ },
+ _createUploadButton: function(element){
+ var self = this;
+
+ var button = new qq.UploadButton({
+ element: element,
+ multiple: this._options.multiple && qq.isXhrUploadSupported(),
+ acceptFiles: this._options.validation.acceptFiles,
+ onChange: function(input){
+ self._onInputChange(input);
},
- retrieve: function(optionalFilter) {
- if (qq.isObject(optionalFilter) && data.length) {
- if (optionalFilter.id !== undefined) {
- return getDataByIds(optionalFilter.id);
- } else if (optionalFilter.uuid !== undefined) {
- return getDataByUuids(optionalFilter.uuid);
- } else if (optionalFilter.status) {
- return getDataByStatus(optionalFilter.status);
- }
- } else {
- return qq.extend([], data, true);
- }
- },
- reset: function() {
- data = [];
- byUuid = {};
- byStatus = {};
- byBatchId = {};
- },
- setStatus: function(id, newStatus) {
- var oldStatus = data[id].status, byStatusOldStatusIndex = qq.indexOf(byStatus[oldStatus], id);
- byStatus[oldStatus].splice(byStatusOldStatusIndex, 1);
- data[id].status = newStatus;
- if (byStatus[newStatus] === undefined) {
- byStatus[newStatus] = [];
- }
- byStatus[newStatus].push(id);
- uploaderProxy.onStatusChange(id, oldStatus, newStatus);
- },
- uuidChanged: function(id, newUuid) {
- var oldUuid = data[id].uuid;
- data[id].uuid = newUuid;
- byUuid[newUuid] = id;
- delete byUuid[oldUuid];
- },
- updateName: function(id, newName) {
- data[id].name = newName;
- },
- updateSize: function(id, newSize) {
- data[id].size = newSize;
- },
- setParentId: function(targetId, parentId) {
- data[targetId].parentId = parentId;
- },
- getIdsInProxyGroup: function(id) {
- var proxyGroupId = data[id].proxyGroupId;
- if (proxyGroupId) {
- return byProxyGroupId[proxyGroupId];
- }
- return [];
- },
- getIdsInBatch: function(id) {
- var batchId = data[id].batchId;
- return byBatchId[batchId];
- }
+ hoverClass: this._options.classes.buttonHover,
+ focusClass: this._options.classes.buttonFocus
});
- };
- qq.status = {
- SUBMITTING: "submitting",
- SUBMITTED: "submitted",
- REJECTED: "rejected",
- QUEUED: "queued",
- CANCELED: "canceled",
- PAUSED: "paused",
- UPLOADING: "uploading",
- UPLOAD_RETRYING: "retrying upload",
- UPLOAD_SUCCESSFUL: "upload successful",
- UPLOAD_FAILED: "upload failed",
- DELETE_FAILED: "delete failed",
- DELETING: "deleting",
- DELETED: "deleted"
- };
- (function() {
- "use strict";
- qq.basePublicApi = {
- addBlobs: function(blobDataOrArray, params, endpoint) {
- this.addFiles(blobDataOrArray, params, endpoint);
- },
- addInitialFiles: function(cannedFileList) {
- var self = this;
- qq.each(cannedFileList, function(index, cannedFile) {
- self._addCannedFile(cannedFile);
- });
- },
- addFiles: function(data, params, endpoint) {
- this._maybeHandleIos8SafariWorkaround();
- var batchId = this._storedIds.length === 0 ? qq.getUniqueId() : this._currentBatchId, processBlob = qq.bind(function(blob) {
- this._handleNewFile({
- blob: blob,
- name: this._options.blobs.defaultName
- }, batchId, verifiedFiles);
- }, this), processBlobData = qq.bind(function(blobData) {
- this._handleNewFile(blobData, batchId, verifiedFiles);
- }, this), processCanvas = qq.bind(function(canvas) {
- var blob = qq.canvasToBlob(canvas);
- this._handleNewFile({
- blob: blob,
- name: this._options.blobs.defaultName + ".png"
- }, batchId, verifiedFiles);
- }, this), processCanvasData = qq.bind(function(canvasData) {
- var normalizedQuality = canvasData.quality && canvasData.quality / 100, blob = qq.canvasToBlob(canvasData.canvas, canvasData.type, normalizedQuality);
- this._handleNewFile({
- blob: blob,
- name: canvasData.name
- }, batchId, verifiedFiles);
- }, this), processFileOrInput = qq.bind(function(fileOrInput) {
- if (qq.isInput(fileOrInput) && qq.supportedFeatures.ajaxUploading) {
- var files = Array.prototype.slice.call(fileOrInput.files), self = this;
- qq.each(files, function(idx, file) {
- self._handleNewFile(file, batchId, verifiedFiles);
- });
- } else {
- this._handleNewFile(fileOrInput, batchId, verifiedFiles);
- }
- }, this), normalizeData = function() {
- if (qq.isFileList(data)) {
- data = Array.prototype.slice.call(data);
- }
- data = [].concat(data);
- }, self = this, verifiedFiles = [];
- this._currentBatchId = batchId;
- if (data) {
- normalizeData();
- qq.each(data, function(idx, fileContainer) {
- if (qq.isFileOrInput(fileContainer)) {
- processFileOrInput(fileContainer);
- } else if (qq.isBlob(fileContainer)) {
- processBlob(fileContainer);
- } else if (qq.isObject(fileContainer)) {
- if (fileContainer.blob && fileContainer.name) {
- processBlobData(fileContainer);
- } else if (fileContainer.canvas && fileContainer.name) {
- processCanvasData(fileContainer);
- }
- } else if (fileContainer.tagName && fileContainer.tagName.toLowerCase() === "canvas") {
- processCanvas(fileContainer);
- } else {
- self.log(fileContainer + " is not a valid file container! Ignoring!", "warn");
- }
- });
- this.log("Received " + verifiedFiles.length + " files.");
- this._prepareItemsForUpload(verifiedFiles, params, endpoint);
- }
- },
- cancel: function(id) {
- this._handler.cancel(id);
- },
- cancelAll: function() {
- var storedIdsCopy = [], self = this;
- qq.extend(storedIdsCopy, this._storedIds);
- qq.each(storedIdsCopy, function(idx, storedFileId) {
- self.cancel(storedFileId);
- });
- this._handler.cancelAll();
- },
- clearStoredFiles: function() {
- this._storedIds = [];
- },
- continueUpload: function(id) {
- var uploadData = this._uploadData.retrieve({
- id: id
- });
- if (!qq.supportedFeatures.pause || !this._options.chunking.enabled) {
- return false;
- }
- if (uploadData.status === qq.status.PAUSED) {
- this.log(qq.format("Paused file ID {} ({}) will be continued. Not paused.", id, this.getName(id)));
- this._uploadFile(id);
- return true;
- } else {
- this.log(qq.format("Ignoring continue for file ID {} ({}). Not paused.", id, this.getName(id)), "error");
- }
- return false;
- },
- deleteFile: function(id) {
- return this._onSubmitDelete(id);
- },
- doesExist: function(fileOrBlobId) {
- return this._handler.isValid(fileOrBlobId);
- },
- drawThumbnail: function(fileId, imgOrCanvas, maxSize, fromServer, customResizeFunction) {
- var promiseToReturn = new qq.Promise(), fileOrUrl, options;
- if (this._imageGenerator) {
- fileOrUrl = this._thumbnailUrls[fileId];
- options = {
- customResizeFunction: customResizeFunction,
- maxSize: maxSize > 0 ? maxSize : null,
- scale: maxSize > 0
- };
- if (!fromServer && qq.supportedFeatures.imagePreviews) {
- fileOrUrl = this.getFile(fileId);
- }
- if (fileOrUrl == null) {
- promiseToReturn.failure({
- container: imgOrCanvas,
- error: "File or URL not found."
- });
- } else {
- this._imageGenerator.generate(fileOrUrl, imgOrCanvas, options).then(function success(modifiedContainer) {
- promiseToReturn.success(modifiedContainer);
- }, function failure(container, reason) {
- promiseToReturn.failure({
- container: container,
- error: reason || "Problem generating thumbnail"
- });
- });
- }
- } else {
- promiseToReturn.failure({
- container: imgOrCanvas,
- error: "Missing image generator module"
- });
- }
- return promiseToReturn;
- },
- getButton: function(fileId) {
- return this._getButton(this._buttonIdsForFileIds[fileId]);
- },
- getEndpoint: function(fileId) {
- return this._endpointStore.get(fileId);
- },
- getFile: function(fileOrBlobId) {
- return this._handler.getFile(fileOrBlobId) || null;
- },
- getInProgress: function() {
- return this._uploadData.retrieve({
- status: [ qq.status.UPLOADING, qq.status.UPLOAD_RETRYING, qq.status.QUEUED ]
- }).length;
- },
- getName: function(id) {
- return this._uploadData.retrieve({
- id: id
- }).name;
- },
- getParentId: function(id) {
- var uploadDataEntry = this.getUploads({
- id: id
- }), parentId = null;
- if (uploadDataEntry) {
- if (uploadDataEntry.parentId !== undefined) {
- parentId = uploadDataEntry.parentId;
- }
- }
- return parentId;
- },
- getResumableFilesData: function() {
- return this._handler.getResumableFilesData();
- },
- getSize: function(id) {
- return this._uploadData.retrieve({
- id: id
- }).size;
- },
- getNetUploads: function() {
- return this._netUploaded;
- },
- getRemainingAllowedItems: function() {
- var allowedItems = this._currentItemLimit;
- if (allowedItems > 0) {
- return allowedItems - this._netUploadedOrQueued;
- }
- return null;
- },
- getUploads: function(optionalFilter) {
- return this._uploadData.retrieve(optionalFilter);
- },
- getUuid: function(id) {
- return this._uploadData.retrieve({
- id: id
- }).uuid;
- },
+
+ this._disposeSupport.addDisposer(function() { button.dispose(); });
+ return button;
+ },
+ _createUploadHandler: function(){
+ var self = this;
+
+ return new qq.UploadHandler({
+ debug: this._options.debug,
+ forceMultipart: this._options.request.forceMultipart,
+ maxConnections: this._options.maxConnections,
+ customHeaders: this._options.request.customHeaders,
+ inputName: this._options.request.inputName,
+ uuidParamName: this._options.request.uuidName,
+ totalFileSizeParamName: this._options.request.totalFileSizeName,
+ cors: this._options.cors,
+ demoMode: this._options.demoMode,
+ paramsInBody: this._options.request.paramsInBody,
+ paramsStore: this._paramsStore,
+ endpointStore: this._endpointStore,
+ chunking: this._options.chunking,
+ resume: this._options.resume,
+ blobs: this._options.blobs,
log: function(str, level) {
- if (this._options.debug && (!level || level === "info")) {
- qq.log("[Fine Uploader " + qq.version + "] " + str);
- } else if (level && level !== "info") {
- qq.log("[Fine Uploader " + qq.version + "] " + str, level);
- }
+ self.log(str, level);
},
- pauseUpload: function(id) {
- var uploadData = this._uploadData.retrieve({
- id: id
- });
- if (!qq.supportedFeatures.pause || !this._options.chunking.enabled) {
+ onProgress: function(id, name, loaded, total){
+ self._onProgress(id, name, loaded, total);
+ self._options.callbacks.onProgress(id, name, loaded, total);
+ },
+ onComplete: function(id, name, result, xhr){
+ self._onComplete(id, name, result, xhr);
+ self._options.callbacks.onComplete(id, name, result);
+ },
+ onCancel: function(id, name){
+ self._onCancel(id, name);
+ self._options.callbacks.onCancel(id, name);
+ },
+ onUpload: function(id, name){
+ self._onUpload(id, name);
+ self._options.callbacks.onUpload(id, name);
+ },
+ onUploadChunk: function(id, name, chunkData){
+ self._options.callbacks.onUploadChunk(id, name, chunkData);
+ },
+ onResume: function(id, name, chunkData) {
+ return self._options.callbacks.onResume(id, name, chunkData);
+ },
+ onAutoRetry: function(id, name, responseJSON, xhr) {
+ self._preventRetries[id] = responseJSON[self._options.retry.preventRetryResponseProperty];
+
+ if (self._shouldAutoRetry(id, name, responseJSON)) {
+ self._maybeParseAndSendUploadError(id, name, responseJSON, xhr);
+ self._options.callbacks.onAutoRetry(id, name, self._autoRetries[id] + 1);
+ self._onBeforeAutoRetry(id, name);
+
+ self._retryTimeouts[id] = setTimeout(function() {
+ self._onAutoRetry(id, name, responseJSON)
+ }, self._options.retry.autoAttemptDelay * 1000);
+
+ return true;
+ }
+ else {
return false;
}
- if (qq.indexOf([ qq.status.UPLOADING, qq.status.UPLOAD_RETRYING ], uploadData.status) >= 0) {
- if (this._handler.pause(id)) {
- this._uploadData.setStatus(id, qq.status.PAUSED);
- return true;
- } else {
- this.log(qq.format("Unable to pause file ID {} ({}).", id, this.getName(id)), "error");
- }
- } else {
- this.log(qq.format("Ignoring pause for file ID {} ({}). Not in progress.", id, this.getName(id)), "error");
- }
- return false;
- },
- removeFileRef: function(id) {
- this._handler.expunge(id);
- },
- reset: function() {
- this.log("Resetting uploader...");
- this._handler.reset();
- this._storedIds = [];
- this._autoRetries = [];
- this._retryTimeouts = [];
- this._preventRetries = [];
- this._thumbnailUrls = [];
- qq.each(this._buttons, function(idx, button) {
- button.reset();
- });
- this._paramsStore.reset();
- this._endpointStore.reset();
- this._netUploadedOrQueued = 0;
- this._netUploaded = 0;
- this._uploadData.reset();
- this._buttonIdsForFileIds = [];
- this._pasteHandler && this._pasteHandler.reset();
- this._options.session.refreshOnReset && this._refreshSessionData();
- this._succeededSinceLastAllComplete = [];
- this._failedSinceLastAllComplete = [];
- this._totalProgress && this._totalProgress.reset();
- },
- retry: function(id) {
- return this._manualRetry(id);
- },
- scaleImage: function(id, specs) {
- var self = this;
- return qq.Scaler.prototype.scaleImage(id, specs, {
- log: qq.bind(self.log, self),
- getFile: qq.bind(self.getFile, self),
- uploadData: self._uploadData
- });
- },
- setCustomHeaders: function(headers, id) {
- this._customHeadersStore.set(headers, id);
- },
- setDeleteFileCustomHeaders: function(headers, id) {
- this._deleteFileCustomHeadersStore.set(headers, id);
- },
- setDeleteFileEndpoint: function(endpoint, id) {
- this._deleteFileEndpointStore.set(endpoint, id);
- },
- setDeleteFileParams: function(params, id) {
- this._deleteFileParamsStore.set(params, id);
- },
- setEndpoint: function(endpoint, id) {
- this._endpointStore.set(endpoint, id);
- },
- setForm: function(elementOrId) {
- this._updateFormSupportAndParams(elementOrId);
- },
- setItemLimit: function(newItemLimit) {
- this._currentItemLimit = newItemLimit;
- },
- setName: function(id, newName) {
- this._uploadData.updateName(id, newName);
- },
- setParams: function(params, id) {
- this._paramsStore.set(params, id);
- },
- setUuid: function(id, newUuid) {
- return this._uploadData.uuidChanged(id, newUuid);
- },
- setStatus: function(id, newStatus) {
- var fileRecord = this.getUploads({
- id: id
- });
- if (!fileRecord) {
- throw new qq.Error(id + " is not a valid file ID.");
- }
- switch (newStatus) {
- case qq.status.DELETED:
- this._onDeleteComplete(id, null, false);
- break;
-
- case qq.status.DELETE_FAILED:
- this._onDeleteComplete(id, null, true);
- break;
-
- default:
- var errorMessage = "Method setStatus called on '" + name + "' not implemented yet for " + newStatus;
- this.log(errorMessage);
- throw new qq.Error(errorMessage);
- }
- },
- uploadStoredFiles: function() {
- if (this._storedIds.length === 0) {
- this._itemError("noFilesError");
- } else {
- this._uploadStoredFiles();
- }
+ }
+ });
+ },
+ _createDeleteHandler: function() {
+ var self = this;
+
+ return new qq.DeleteFileAjaxRequestor({
+ maxConnections: this._options.maxConnections,
+ customHeaders: this._options.deleteFile.customHeaders,
+ paramsStore: this._deleteFileParamsStore,
+ endpointStore: this._deleteFileEndpointStore,
+ demoMode: this._options.demoMode,
+ cors: this._options.cors,
+ log: function(str, level) {
+ self.log(str, level);
+ },
+ onDelete: function(id) {
+ self._onDelete(id);
+ self._options.callbacks.onDelete(id);
+ },
+ onDeleteComplete: function(id, xhr, isError) {
+ self._onDeleteComplete(id, xhr, isError);
+ self._options.callbacks.onDeleteComplete(id, xhr, isError);
+ }
+
+ });
+ },
+ _preventLeaveInProgress: function(){
+ var self = this;
+
+ this._disposeSupport.attach(window, 'beforeunload', function(e){
+ if (!self._filesInProgress.length){return;}
+
+ var e = e || window.event;
+ // for ie, ff
+ e.returnValue = self._options.messages.onLeave;
+ // for webkit
+ return self._options.messages.onLeave;
+ });
+ },
+ _onSubmit: function(id, name){
+ if (this._options.autoUpload) {
+ this._filesInProgress.push(id);
+ }
+ },
+ _onProgress: function(id, name, loaded, total){
+ },
+ _onComplete: function(id, name, result, xhr){
+ this._removeFromFilesInProgress(id);
+ this._maybeParseAndSendUploadError(id, name, result, xhr);
+ },
+ _onCancel: function(id, name){
+ this._removeFromFilesInProgress(id);
+
+ clearTimeout(this._retryTimeouts[id]);
+
+ var storedItemIndex = qq.indexOf(this._storedIds, id);
+ if (!this._options.autoUpload && storedItemIndex >= 0) {
+ this._storedIds.splice(storedItemIndex, 1);
+ }
+ },
+ _isDeletePossible: function() {
+ return (this._options.deleteFile.enabled &&
+ (!this._options.cors.expected ||
+ (this._options.cors.expected && (qq.ie10() || !qq.ie()))
+ )
+ );
+ },
+ _onSubmitDelete: function(id) {
+ if (this._isDeletePossible()) {
+ if (this._options.callbacks.onSubmitDelete(id)) {
+ this._deleteHandler.sendDelete(id, this.getUuid(id));
+ }
+ }
+ else {
+ this.log("Delete request ignored for ID " + id + ", delete feature is disabled or request not possible " +
+ "due to CORS on a user agent that does not support pre-flighting.", "warn");
+ return false;
+ }
+ },
+ _onDelete: function(fileId) {},
+ _onDeleteComplete: function(id, xhr, isError) {
+ var name = this._handler.getName(id);
+
+ if (isError) {
+ this.log("Delete request for '" + name + "' has failed.", "error");
+ this._options.callbacks.onError(id, name, "Delete request failed with response code " + xhr.status);
+ }
+ else {
+ this.log("Delete request for '" + name + "' has succeeded.");
+ }
+ },
+ _removeFromFilesInProgress: function(id) {
+ var index = qq.indexOf(this._filesInProgress, id);
+ if (index >= 0) {
+ this._filesInProgress.splice(index, 1);
+ }
+ },
+ _onUpload: function(id, name){},
+ _onInputChange: function(input){
+ if (qq.isXhrUploadSupported()){
+ this.addFiles(input.files);
+ } else {
+ this.addFiles(input);
+ }
+ this._button.reset();
+ },
+ _onBeforeAutoRetry: function(id, name) {
+ this.log("Waiting " + this._options.retry.autoAttemptDelay + " seconds before retrying " + name + "...");
+ },
+ _onAutoRetry: function(id, name, responseJSON) {
+ this.log("Retrying " + name + "...");
+ this._autoRetries[id]++;
+ this._handler.retry(id);
+ },
+ _shouldAutoRetry: function(id, name, responseJSON) {
+ if (!this._preventRetries[id] && this._options.retry.enableAuto) {
+ if (this._autoRetries[id] === undefined) {
+ this._autoRetries[id] = 0;
+ }
+
+ return this._autoRetries[id] < this._options.retry.maxAutoAttempts
+ }
+
+ return false;
+ },
+ //return false if we should not attempt the requested retry
+ _onBeforeManualRetry: function(id) {
+ if (this._preventRetries[id]) {
+ this.log("Retries are forbidden for id " + id, 'warn');
+ return false;
+ }
+ else if (this._handler.isValid(id)) {
+ var fileName = this._handler.getName(id);
+
+ if (this._options.callbacks.onManualRetry(id, fileName) === false) {
+ return false;
+ }
+
+ this.log("Retrying upload for '" + fileName + "' (id: " + id + ")...");
+ this._filesInProgress.push(id);
+ return true;
+ }
+ else {
+ this.log("'" + id + "' is not a valid file ID", 'error');
+ return false;
+ }
+ },
+ _maybeParseAndSendUploadError: function(id, name, response, xhr) {
+ //assuming no one will actually set the response code to something other than 200 and still set 'success' to true
+ if (!response.success){
+ if (xhr && xhr.status !== 200 && !response.error) {
+ this._options.callbacks.onError(id, name, "XHR returned response code " + xhr.status);
+ }
+ else {
+ var errorReason = response.error ? response.error : "Upload failure reason unknown";
+ this._options.callbacks.onError(id, name, errorReason);
+ }
+ }
+ },
+ _uploadFileOrBlobDataList: function(fileOrBlobDataList){
+ var validationDescriptors, index, batchInvalid;
+
+ validationDescriptors = this._getValidationDescriptors(fileOrBlobDataList);
+ batchInvalid = this._options.callbacks.onValidateBatch(validationDescriptors) === false;
+
+ if (!batchInvalid) {
+ if (fileOrBlobDataList.length > 0) {
+ for (index = 0; index < fileOrBlobDataList.length; index++){
+ if (this._validateFileOrBlobData(fileOrBlobDataList[index])){
+ this._upload(fileOrBlobDataList[index]);
+ } else {
+ if (this._options.validation.stopOnFirstInvalidFile){
+ return;
+ }
+ }
+ }
+ }
+ else {
+ this._error('noFilesError', "");
+ }
+ }
+ },
+ _upload: function(blobOrFileContainer){
+ var id = this._handler.add(blobOrFileContainer);
+ var name = this._handler.getName(id);
+
+ if (this._options.callbacks.onSubmit(id, name) !== false){
+ this._onSubmit(id, name);
+ if (this._options.autoUpload) {
+ this._handler.upload(id);
+ }
+ else {
+ this._storeForLater(id);
+ }
+ }
+ },
+ _storeForLater: function(id) {
+ this._storedIds.push(id);
+ },
+ _validateFileOrBlobData: function(fileOrBlobData){
+ var validationDescriptor, name, size;
+
+ validationDescriptor = this._getValidationDescriptor(fileOrBlobData);
+ name = validationDescriptor.name;
+ size = validationDescriptor.size;
+
+ if (this._options.callbacks.onValidate(validationDescriptor) === false) {
+ return false;
+ }
+
+ if (qq.isFileOrInput(fileOrBlobData) && !this._isAllowedExtension(name)){
+ this._error('typeError', name);
+ return false;
+
+ }
+ else if (size === 0){
+ this._error('emptyError', name);
+ return false;
+
+ }
+ else if (size && this._options.validation.sizeLimit && size > this._options.validation.sizeLimit){
+ this._error('sizeError', name);
+ return false;
+
+ }
+ else if (size && size < this._options.validation.minSizeLimit){
+ this._error('minSizeError', name);
+ return false;
+ }
+
+ return true;
+ },
+ _error: function(code, name){
+ var message = this._options.messages[code];
+ function r(name, replacement){ message = message.replace(name, replacement); }
+
+ var extensions = this._options.validation.allowedExtensions.join(', ').toLowerCase();
+
+ r('{file}', this._options.formatFileName(name));
+ r('{extensions}', extensions);
+ r('{sizeLimit}', this._formatSize(this._options.validation.sizeLimit));
+ r('{minSizeLimit}', this._formatSize(this._options.validation.minSizeLimit));
+
+ this._options.callbacks.onError(null, name, message);
+
+ return message;
+ },
+ _isAllowedExtension: function(fileName){
+ var allowed = this._options.validation.allowedExtensions,
+ valid = false;
+
+ if (!allowed.length) {
+ return true;
+ }
+
+ qq.each(allowed, function(idx, allowedExt) {
+ /*jshint eqeqeq: true, eqnull: true*/
+ var extRegex = new RegExp('\\.' + allowedExt + "$", 'i');
+
+ if (fileName.match(extRegex) != null) {
+ valid = true;
+ return false;
+ }
+ });
+
+ return valid;
+ },
+ _formatSize: function(bytes){
+ var i = -1;
+ do {
+ bytes = bytes / 1024;
+ i++;
+ } while (bytes > 99);
+
+ return Math.max(bytes, 0.1).toFixed(1) + this._options.text.sizeSymbols[i];
+ },
+ _wrapCallbacks: function() {
+ var self, safeCallback;
+
+ self = this;
+
+ safeCallback = function(name, callback, args) {
+ try {
+ return callback.apply(self, args);
+ }
+ catch (exception) {
+ self.log("Caught exception in '" + name + "' callback - " + exception.message, 'error');
+ }
+ }
+
+ for (var prop in this._options.callbacks) {
+ (function() {
+ var callbackName, callbackFunc;
+ callbackName = prop;
+ callbackFunc = self._options.callbacks[callbackName];
+ self._options.callbacks[callbackName] = function() {
+ return safeCallback(callbackName, callbackFunc, arguments);
+ }
+ }());
+ }
+ },
+ _parseFileOrBlobDataName: function(fileOrBlobData) {
+ var name;
+
+ if (qq.isFileOrInput(fileOrBlobData)) {
+ if (fileOrBlobData.value) {
+ // it is a file input
+ // get input value and remove path to normalize
+ name = fileOrBlobData.value.replace(/.*(\/|\\)/, "");
+ } else {
+ // fix missing properties in Safari 4 and firefox 11.0a2
+ name = (fileOrBlobData.fileName !== null && fileOrBlobData.fileName !== undefined) ? fileOrBlobData.fileName : fileOrBlobData.name;
+ }
+ }
+ else {
+ name = fileOrBlobData.name;
+ }
+
+ return name;
+ },
+ _parseFileOrBlobDataSize: function(fileOrBlobData) {
+ var size;
+
+ if (qq.isFileOrInput(fileOrBlobData)) {
+ if (!fileOrBlobData.value){
+ // fix missing properties in Safari 4 and firefox 11.0a2
+ size = (fileOrBlobData.fileSize !== null && fileOrBlobData.fileSize !== undefined) ? fileOrBlobData.fileSize : fileOrBlobData.size;
+ }
+ }
+ else {
+ size = fileOrBlobData.blob.size;
+ }
+
+ return size;
+ },
+ _getValidationDescriptor: function(fileOrBlobData) {
+ var name, size, fileDescriptor;
+
+ fileDescriptor = {};
+ name = this._parseFileOrBlobDataName(fileOrBlobData);
+ size = this._parseFileOrBlobDataSize(fileOrBlobData);
+
+ fileDescriptor.name = name;
+ if (size) {
+ fileDescriptor.size = size;
+ }
+
+ return fileDescriptor;
+ },
+ _getValidationDescriptors: function(files) {
+ var self = this,
+ fileDescriptors = [];
+
+ qq.each(files, function(idx, file) {
+ fileDescriptors.push(self._getValidationDescriptor(file));
+ });
+
+ return fileDescriptors;
+ },
+ _createParamsStore: function(type) {
+ var paramsStore = {},
+ self = this;
+
+ return {
+ setParams: function(params, id) {
+ var paramsCopy = {};
+ qq.extend(paramsCopy, params);
+ paramsStore[id] = paramsCopy;
+ },
+
+ getParams: function(id) {
+ /*jshint eqeqeq: true, eqnull: true*/
+ var paramsCopy = {};
+
+ if (id != null && paramsStore[id]) {
+ qq.extend(paramsCopy, paramsStore[id]);
+ }
+ else {
+ qq.extend(paramsCopy, self._options[type].params);
+ }
+
+ return paramsCopy;
+ },
+
+ remove: function(fileId) {
+ return delete paramsStore[fileId];
+ },
+
+ reset: function() {
+ paramsStore = {};
}
};
- qq.basePrivateApi = {
- _addCannedFile: function(sessionData) {
- var self = this;
- return this._uploadData.addFile({
- uuid: sessionData.uuid,
- name: sessionData.name,
- size: sessionData.size,
- status: qq.status.UPLOAD_SUCCESSFUL,
- onBeforeStatusChange: function(id) {
- sessionData.deleteFileEndpoint && self.setDeleteFileEndpoint(sessionData.deleteFileEndpoint, id);
- sessionData.deleteFileParams && self.setDeleteFileParams(sessionData.deleteFileParams, id);
- if (sessionData.thumbnailUrl) {
- self._thumbnailUrls[id] = sessionData.thumbnailUrl;
- }
- self._netUploaded++;
- self._netUploadedOrQueued++;
- }
- });
+ },
+ _createEndpointStore: function(type) {
+ var endpointStore = {},
+ self = this;
+
+ return {
+ setEndpoint: function(endpoint, id) {
+ endpointStore[id] = endpoint;
},
- _annotateWithButtonId: function(file, associatedInput) {
- if (qq.isFile(file)) {
- file.qqButtonId = this._getButtonId(associatedInput);
+
+ getEndpoint: function(id) {
+ /*jshint eqeqeq: true, eqnull: true*/
+ if (id != null && endpointStore[id]) {
+ return endpointStore[id];
}
+
+ return self._options[type].endpoint;
},
- _batchError: function(message) {
- this._options.callbacks.onError(null, null, message, undefined);
+
+ remove: function(fileId) {
+ return delete endpointStore[fileId];
},
- _createDeleteHandler: function() {
- var self = this;
- return new qq.DeleteFileAjaxRequester({
- method: this._options.deleteFile.method.toUpperCase(),
- maxConnections: this._options.maxConnections,
- uuidParamName: this._options.request.uuidName,
- customHeaders: this._deleteFileCustomHeadersStore,
- paramsStore: this._deleteFileParamsStore,
- endpointStore: this._deleteFileEndpointStore,
- cors: this._options.cors,
- log: qq.bind(self.log, self),
- onDelete: function(id) {
- self._onDelete(id);
- self._options.callbacks.onDelete(id);
- },
- onDeleteComplete: function(id, xhrOrXdr, isError) {
- self._onDeleteComplete(id, xhrOrXdr, isError);
- self._options.callbacks.onDeleteComplete(id, xhrOrXdr, isError);
- }
- });
- },
- _createPasteHandler: function() {
- var self = this;
- return new qq.PasteSupport({
- targetElement: this._options.paste.targetElement,
- callbacks: {
- log: qq.bind(self.log, self),
- pasteReceived: function(blob) {
- self._handleCheckedCallback({
- name: "onPasteReceived",
- callback: qq.bind(self._options.callbacks.onPasteReceived, self, blob),
- onSuccess: qq.bind(self._handlePasteSuccess, self, blob),
- identifier: "pasted image"
- });
- }
- }
- });
- },
- _createStore: function(initialValue, _readOnlyValues_) {
- var store = {}, catchall = initialValue, perIdReadOnlyValues = {}, readOnlyValues = _readOnlyValues_, copy = function(orig) {
- if (qq.isObject(orig)) {
- return qq.extend({}, orig);
- }
- return orig;
- }, getReadOnlyValues = function() {
- if (qq.isFunction(readOnlyValues)) {
- return readOnlyValues();
- }
- return readOnlyValues;
- }, includeReadOnlyValues = function(id, existing) {
- if (readOnlyValues && qq.isObject(existing)) {
- qq.extend(existing, getReadOnlyValues());
- }
- if (perIdReadOnlyValues[id]) {
- qq.extend(existing, perIdReadOnlyValues[id]);
- }
- };
- return {
- set: function(val, id) {
- if (id == null) {
- store = {};
- catchall = copy(val);
- } else {
- store[id] = copy(val);
- }
- },
- get: function(id) {
- var values;
- if (id != null && store[id]) {
- values = store[id];
- } else {
- values = copy(catchall);
- }
- includeReadOnlyValues(id, values);
- return copy(values);
- },
- addReadOnly: function(id, values) {
- if (qq.isObject(store)) {
- if (id === null) {
- if (qq.isFunction(values)) {
- readOnlyValues = values;
- } else {
- readOnlyValues = readOnlyValues || {};
- qq.extend(readOnlyValues, values);
- }
- } else {
- perIdReadOnlyValues[id] = perIdReadOnlyValues[id] || {};
- qq.extend(perIdReadOnlyValues[id], values);
+
+ reset: function() {
+ endpointStore = {};
+ }
+ };
+ }
+};
+/*globals qq, document*/
+qq.DragAndDrop = function(o) {
+ "use strict";
+
+ var options, dz, dirPending,
+ droppedFiles = [],
+ droppedEntriesCount = 0,
+ droppedEntriesParsedCount = 0,
+ disposeSupport = new qq.DisposeSupport();
+
+ options = {
+ dropArea: null,
+ extraDropzones: [],
+ hideDropzones: true,
+ multiple: true,
+ classes: {
+ dropActive: null
+ },
+ callbacks: {
+ dropProcessing: function(isProcessing, files) {},
+ error: function(code, filename) {},
+ log: function(message, level) {}
+ }
+ };
+
+ qq.extend(options, o);
+
+ function maybeUploadDroppedFiles() {
+ if (droppedEntriesCount === droppedEntriesParsedCount && !dirPending) {
+ options.callbacks.log('Grabbed ' + droppedFiles.length + " files after tree traversal.");
+ dz.dropDisabled(false);
+ options.callbacks.dropProcessing(false, droppedFiles);
+ }
+ }
+ function addDroppedFile(file) {
+ droppedFiles.push(file);
+ droppedEntriesParsedCount+=1;
+ maybeUploadDroppedFiles();
+ }
+
+ function traverseFileTree(entry) {
+ var dirReader, i;
+
+ droppedEntriesCount+=1;
+
+ if (entry.isFile) {
+ entry.file(function(file) {
+ addDroppedFile(file);
+ });
+ }
+ else if (entry.isDirectory) {
+ dirPending = true;
+ dirReader = entry.createReader();
+ dirReader.readEntries(function(entries) {
+ droppedEntriesParsedCount+=1;
+ for (i = 0; i < entries.length; i+=1) {
+ traverseFileTree(entries[i]);
+ }
+
+ dirPending = false;
+
+ if (!entries.length) {
+ maybeUploadDroppedFiles();
+ }
+ });
+ }
+ }
+
+ function handleDataTransfer(dataTransfer) {
+ var i, items, entry;
+
+ options.callbacks.dropProcessing(true);
+ dz.dropDisabled(true);
+
+ if (dataTransfer.files.length > 1 && !options.multiple) {
+ options.callbacks.dropProcessing(false);
+ options.callbacks.error('tooManyFilesError', "");
+ dz.dropDisabled(false);
+ }
+ else {
+ droppedFiles = [];
+ droppedEntriesCount = 0;
+ droppedEntriesParsedCount = 0;
+
+ if (qq.isFolderDropSupported(dataTransfer)) {
+ items = dataTransfer.items;
+
+ for (i = 0; i < items.length; i+=1) {
+ entry = items[i].webkitGetAsEntry();
+ if (entry) {
+ //due to a bug in Chrome's File System API impl - #149735
+ if (entry.isFile) {
+ droppedFiles.push(items[i].getAsFile());
+ if (i === items.length-1) {
+ maybeUploadDroppedFiles();
}
}
- },
- remove: function(fileId) {
- return delete store[fileId];
- },
- reset: function() {
- store = {};
- perIdReadOnlyValues = {};
- catchall = initialValue;
- }
- };
- },
- _createUploadDataTracker: function() {
- var self = this;
- return new qq.UploadData({
- getName: function(id) {
- return self.getName(id);
- },
- getUuid: function(id) {
- return self.getUuid(id);
- },
- getSize: function(id) {
- return self.getSize(id);
- },
- onStatusChange: function(id, oldStatus, newStatus) {
- self._onUploadStatusChange(id, oldStatus, newStatus);
- self._options.callbacks.onStatusChange(id, oldStatus, newStatus);
- self._maybeAllComplete(id, newStatus);
- if (self._totalProgress) {
- setTimeout(function() {
- self._totalProgress.onStatusChange(id, oldStatus, newStatus);
- }, 0);
- }
- }
- });
- },
- _createUploadButton: function(spec) {
- var self = this, acceptFiles = spec.accept || this._options.validation.acceptFiles, allowedExtensions = spec.allowedExtensions || this._options.validation.allowedExtensions, button;
- function allowMultiple() {
- if (qq.supportedFeatures.ajaxUploading) {
- if (self._options.workarounds.iosEmptyVideos && qq.ios() && !qq.ios6() && self._isAllowedExtension(allowedExtensions, ".mov")) {
- return false;
- }
- if (spec.multiple === undefined) {
- return self._options.multiple;
- }
- return spec.multiple;
- }
- return false;
- }
- button = new qq.UploadButton({
- acceptFiles: acceptFiles,
- element: spec.element,
- focusClass: this._options.classes.buttonFocus,
- folders: spec.folders,
- hoverClass: this._options.classes.buttonHover,
- ios8BrowserCrashWorkaround: this._options.workarounds.ios8BrowserCrash,
- multiple: allowMultiple(),
- name: this._options.request.inputName,
- onChange: function(input) {
- self._onInputChange(input);
- },
- title: spec.title == null ? this._options.text.fileInputTitle : spec.title
- });
- this._disposeSupport.addDisposer(function() {
- button.dispose();
- });
- self._buttons.push(button);
- return button;
- },
- _createUploadHandler: function(additionalOptions, namespace) {
- var self = this, lastOnProgress = {}, options = {
- debug: this._options.debug,
- maxConnections: this._options.maxConnections,
- cors: this._options.cors,
- paramsStore: this._paramsStore,
- endpointStore: this._endpointStore,
- chunking: this._options.chunking,
- resume: this._options.resume,
- blobs: this._options.blobs,
- log: qq.bind(self.log, self),
- preventRetryParam: this._options.retry.preventRetryResponseProperty,
- onProgress: function(id, name, loaded, total) {
- if (loaded < 0 || total < 0) {
- return;
- }
- if (lastOnProgress[id]) {
- if (lastOnProgress[id].loaded !== loaded || lastOnProgress[id].total !== total) {
- self._onProgress(id, name, loaded, total);
- self._options.callbacks.onProgress(id, name, loaded, total);
- }
- } else {
- self._onProgress(id, name, loaded, total);
- self._options.callbacks.onProgress(id, name, loaded, total);
- }
- lastOnProgress[id] = {
- loaded: loaded,
- total: total
- };
- },
- onComplete: function(id, name, result, xhr) {
- delete lastOnProgress[id];
- var status = self.getUploads({
- id: id
- }).status, retVal;
- if (status === qq.status.UPLOAD_SUCCESSFUL || status === qq.status.UPLOAD_FAILED) {
- return;
- }
- retVal = self._onComplete(id, name, result, xhr);
- if (retVal instanceof qq.Promise) {
- retVal.done(function() {
- self._options.callbacks.onComplete(id, name, result, xhr);
- });
- } else {
- self._options.callbacks.onComplete(id, name, result, xhr);
- }
- },
- onCancel: function(id, name, cancelFinalizationEffort) {
- var promise = new qq.Promise();
- self._handleCheckedCallback({
- name: "onCancel",
- callback: qq.bind(self._options.callbacks.onCancel, self, id, name),
- onFailure: promise.failure,
- onSuccess: function() {
- cancelFinalizationEffort.then(function() {
- self._onCancel(id, name);
- });
- promise.success();
- },
- identifier: id
- });
- return promise;
- },
- onUploadPrep: qq.bind(this._onUploadPrep, this),
- onUpload: function(id, name) {
- self._onUpload(id, name);
- self._options.callbacks.onUpload(id, name);
- },
- onUploadChunk: function(id, name, chunkData) {
- self._onUploadChunk(id, chunkData);
- self._options.callbacks.onUploadChunk(id, name, chunkData);
- },
- onUploadChunkSuccess: function(id, chunkData, result, xhr) {
- self._options.callbacks.onUploadChunkSuccess.apply(self, arguments);
- },
- onResume: function(id, name, chunkData) {
- return self._options.callbacks.onResume(id, name, chunkData);
- },
- onAutoRetry: function(id, name, responseJSON, xhr) {
- return self._onAutoRetry.apply(self, arguments);
- },
- onUuidChanged: function(id, newUuid) {
- self.log("Server requested UUID change from '" + self.getUuid(id) + "' to '" + newUuid + "'");
- self.setUuid(id, newUuid);
- },
- getName: qq.bind(self.getName, self),
- getUuid: qq.bind(self.getUuid, self),
- getSize: qq.bind(self.getSize, self),
- setSize: qq.bind(self._setSize, self),
- getDataByUuid: function(uuid) {
- return self.getUploads({
- uuid: uuid
- });
- },
- isQueued: function(id) {
- var status = self.getUploads({
- id: id
- }).status;
- return status === qq.status.QUEUED || status === qq.status.SUBMITTED || status === qq.status.UPLOAD_RETRYING || status === qq.status.PAUSED;
- },
- getIdsInProxyGroup: self._uploadData.getIdsInProxyGroup,
- getIdsInBatch: self._uploadData.getIdsInBatch
- };
- qq.each(this._options.request, function(prop, val) {
- options[prop] = val;
- });
- options.customHeaders = this._customHeadersStore;
- if (additionalOptions) {
- qq.each(additionalOptions, function(key, val) {
- options[key] = val;
- });
- }
- return new qq.UploadHandlerController(options, namespace);
- },
- _fileOrBlobRejected: function(id) {
- this._netUploadedOrQueued--;
- this._uploadData.setStatus(id, qq.status.REJECTED);
- },
- _formatSize: function(bytes) {
- if (bytes === 0) {
- return bytes + this._options.text.sizeSymbols[0];
- }
- var i = -1;
- do {
- bytes = bytes / 1e3;
- i++;
- } while (bytes > 999);
- return Math.max(bytes, .1).toFixed(1) + this._options.text.sizeSymbols[i];
- },
- _generateExtraButtonSpecs: function() {
- var self = this;
- this._extraButtonSpecs = {};
- qq.each(this._options.extraButtons, function(idx, extraButtonOptionEntry) {
- var multiple = extraButtonOptionEntry.multiple, validation = qq.extend({}, self._options.validation, true), extraButtonSpec = qq.extend({}, extraButtonOptionEntry);
- if (multiple === undefined) {
- multiple = self._options.multiple;
- }
- if (extraButtonSpec.validation) {
- qq.extend(validation, extraButtonOptionEntry.validation, true);
- }
- qq.extend(extraButtonSpec, {
- multiple: multiple,
- validation: validation
- }, true);
- self._initExtraButton(extraButtonSpec);
- });
- },
- _getButton: function(buttonId) {
- var extraButtonsSpec = this._extraButtonSpecs[buttonId];
- if (extraButtonsSpec) {
- return extraButtonsSpec.element;
- } else if (buttonId === this._defaultButtonId) {
- return this._options.button;
- }
- },
- _getButtonId: function(buttonOrFileInputOrFile) {
- var inputs, fileInput, fileBlobOrInput = buttonOrFileInputOrFile;
- if (fileBlobOrInput instanceof qq.BlobProxy) {
- fileBlobOrInput = fileBlobOrInput.referenceBlob;
- }
- if (fileBlobOrInput && !qq.isBlob(fileBlobOrInput)) {
- if (qq.isFile(fileBlobOrInput)) {
- return fileBlobOrInput.qqButtonId;
- } else if (fileBlobOrInput.tagName.toLowerCase() === "input" && fileBlobOrInput.type.toLowerCase() === "file") {
- return fileBlobOrInput.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME);
- }
- inputs = fileBlobOrInput.getElementsByTagName("input");
- qq.each(inputs, function(idx, input) {
- if (input.getAttribute("type") === "file") {
- fileInput = input;
- return false;
- }
- });
- if (fileInput) {
- return fileInput.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME);
- }
- }
- },
- _getNotFinished: function() {
- return this._uploadData.retrieve({
- status: [ qq.status.UPLOADING, qq.status.UPLOAD_RETRYING, qq.status.QUEUED, qq.status.SUBMITTING, qq.status.SUBMITTED, qq.status.PAUSED ]
- }).length;
- },
- _getValidationBase: function(buttonId) {
- var extraButtonSpec = this._extraButtonSpecs[buttonId];
- return extraButtonSpec ? extraButtonSpec.validation : this._options.validation;
- },
- _getValidationDescriptor: function(fileWrapper) {
- if (fileWrapper.file instanceof qq.BlobProxy) {
- return {
- name: qq.getFilename(fileWrapper.file.referenceBlob),
- size: fileWrapper.file.referenceBlob.size
- };
- }
- return {
- name: this.getUploads({
- id: fileWrapper.id
- }).name,
- size: this.getUploads({
- id: fileWrapper.id
- }).size
- };
- },
- _getValidationDescriptors: function(fileWrappers) {
- var self = this, fileDescriptors = [];
- qq.each(fileWrappers, function(idx, fileWrapper) {
- fileDescriptors.push(self._getValidationDescriptor(fileWrapper));
- });
- return fileDescriptors;
- },
- _handleCameraAccess: function() {
- if (this._options.camera.ios && qq.ios()) {
- var acceptIosCamera = "image/*;capture=camera", button = this._options.camera.button, buttonId = button ? this._getButtonId(button) : this._defaultButtonId, optionRoot = this._options;
- if (buttonId && buttonId !== this._defaultButtonId) {
- optionRoot = this._extraButtonSpecs[buttonId];
- }
- optionRoot.multiple = false;
- if (optionRoot.validation.acceptFiles === null) {
- optionRoot.validation.acceptFiles = acceptIosCamera;
- } else {
- optionRoot.validation.acceptFiles += "," + acceptIosCamera;
- }
- qq.each(this._buttons, function(idx, button) {
- if (button.getButtonId() === buttonId) {
- button.setMultiple(optionRoot.multiple);
- button.setAcceptFiles(optionRoot.acceptFiles);
- return false;
- }
- });
- }
- },
- _handleCheckedCallback: function(details) {
- var self = this, callbackRetVal = details.callback();
- if (qq.isGenericPromise(callbackRetVal)) {
- this.log(details.name + " - waiting for " + details.name + " promise to be fulfilled for " + details.identifier);
- return callbackRetVal.then(function(successParam) {
- self.log(details.name + " promise success for " + details.identifier);
- details.onSuccess(successParam);
- }, function() {
- if (details.onFailure) {
- self.log(details.name + " promise failure for " + details.identifier);
- details.onFailure();
- } else {
- self.log(details.name + " promise failure for " + details.identifier);
- }
- });
- }
- if (callbackRetVal !== false) {
- details.onSuccess(callbackRetVal);
- } else {
- if (details.onFailure) {
- this.log(details.name + " - return value was 'false' for " + details.identifier + ". Invoking failure callback.");
- details.onFailure();
- } else {
- this.log(details.name + " - return value was 'false' for " + details.identifier + ". Will not proceed.");
- }
- }
- return callbackRetVal;
- },
- _handleNewFile: function(file, batchId, newFileWrapperList) {
- var self = this, uuid = qq.getUniqueId(), size = -1, name = qq.getFilename(file), actualFile = file.blob || file, handler = this._customNewFileHandler ? this._customNewFileHandler : qq.bind(self._handleNewFileGeneric, self);
- if (!qq.isInput(actualFile) && actualFile.size >= 0) {
- size = actualFile.size;
- }
- handler(actualFile, name, uuid, size, newFileWrapperList, batchId, this._options.request.uuidName, {
- uploadData: self._uploadData,
- paramsStore: self._paramsStore,
- addFileToHandler: function(id, file) {
- self._handler.add(id, file);
- self._netUploadedOrQueued++;
- self._trackButton(id);
- }
- });
- },
- _handleNewFileGeneric: function(file, name, uuid, size, fileList, batchId) {
- var id = this._uploadData.addFile({
- uuid: uuid,
- name: name,
- size: size,
- batchId: batchId
- });
- this._handler.add(id, file);
- this._trackButton(id);
- this._netUploadedOrQueued++;
- fileList.push({
- id: id,
- file: file
- });
- },
- _handlePasteSuccess: function(blob, extSuppliedName) {
- var extension = blob.type.split("/")[1], name = extSuppliedName;
- if (name == null) {
- name = this._options.paste.defaultName;
- }
- name += "." + extension;
- this.addFiles({
- name: name,
- blob: blob
- });
- },
- _handleDeleteSuccess: function(id) {
- if (this.getUploads({
- id: id
- }).status !== qq.status.DELETED) {
- var name = this.getName(id);
- this._netUploadedOrQueued--;
- this._netUploaded--;
- this._handler.expunge(id);
- this._uploadData.setStatus(id, qq.status.DELETED);
- this.log("Delete request for '" + name + "' has succeeded.");
- }
- },
- _handleDeleteFailed: function(id, xhrOrXdr) {
- var name = this.getName(id);
- this._uploadData.setStatus(id, qq.status.DELETE_FAILED);
- this.log("Delete request for '" + name + "' has failed.", "error");
- if (!xhrOrXdr || xhrOrXdr.withCredentials === undefined) {
- this._options.callbacks.onError(id, name, "Delete request failed", xhrOrXdr);
- } else {
- this._options.callbacks.onError(id, name, "Delete request failed with response code " + xhrOrXdr.status, xhrOrXdr);
- }
- },
- _initExtraButton: function(spec) {
- var button = this._createUploadButton({
- accept: spec.validation.acceptFiles,
- allowedExtensions: spec.validation.allowedExtensions,
- element: spec.element,
- folders: spec.folders,
- multiple: spec.multiple,
- title: spec.fileInputTitle
- });
- this._extraButtonSpecs[button.getButtonId()] = spec;
- },
- _initFormSupportAndParams: function() {
- this._formSupport = qq.FormSupport && new qq.FormSupport(this._options.form, qq.bind(this.uploadStoredFiles, this), qq.bind(this.log, this));
- if (this._formSupport && this._formSupport.attachedToForm) {
- this._paramsStore = this._createStore(this._options.request.params, this._formSupport.getFormInputsAsObject);
- this._options.autoUpload = this._formSupport.newAutoUpload;
- if (this._formSupport.newEndpoint) {
- this._options.request.endpoint = this._formSupport.newEndpoint;
- }
- } else {
- this._paramsStore = this._createStore(this._options.request.params);
- }
- },
- _isDeletePossible: function() {
- if (!qq.DeleteFileAjaxRequester || !this._options.deleteFile.enabled) {
- return false;
- }
- if (this._options.cors.expected) {
- if (qq.supportedFeatures.deleteFileCorsXhr) {
- return true;
- }
- if (qq.supportedFeatures.deleteFileCorsXdr && this._options.cors.allowXdr) {
- return true;
- }
- return false;
- }
- return true;
- },
- _isAllowedExtension: function(allowed, fileName) {
- var valid = false;
- if (!allowed.length) {
- return true;
- }
- qq.each(allowed, function(idx, allowedExt) {
- if (qq.isString(allowedExt)) {
- var extRegex = new RegExp("\\." + allowedExt + "$", "i");
- if (fileName.match(extRegex) != null) {
- valid = true;
- return false;
- }
- }
- });
- return valid;
- },
- _itemError: function(code, maybeNameOrNames, item) {
- var message = this._options.messages[code], allowedExtensions = [], names = [].concat(maybeNameOrNames), name = names[0], buttonId = this._getButtonId(item), validationBase = this._getValidationBase(buttonId), extensionsForMessage, placeholderMatch;
- function r(name, replacement) {
- message = message.replace(name, replacement);
- }
- qq.each(validationBase.allowedExtensions, function(idx, allowedExtension) {
- if (qq.isString(allowedExtension)) {
- allowedExtensions.push(allowedExtension);
- }
- });
- extensionsForMessage = allowedExtensions.join(", ").toLowerCase();
- r("{file}", this._options.formatFileName(name));
- r("{extensions}", extensionsForMessage);
- r("{sizeLimit}", this._formatSize(validationBase.sizeLimit));
- r("{minSizeLimit}", this._formatSize(validationBase.minSizeLimit));
- placeholderMatch = message.match(/(\{\w+\})/g);
- if (placeholderMatch !== null) {
- qq.each(placeholderMatch, function(idx, placeholder) {
- r(placeholder, names[idx]);
- });
- }
- this._options.callbacks.onError(null, name, message, undefined);
- return message;
- },
- _manualRetry: function(id, callback) {
- if (this._onBeforeManualRetry(id)) {
- this._netUploadedOrQueued++;
- this._uploadData.setStatus(id, qq.status.UPLOAD_RETRYING);
- if (callback) {
- callback(id);
- } else {
- this._handler.retry(id);
- }
- return true;
- }
- },
- _maybeAllComplete: function(id, status) {
- var self = this, notFinished = this._getNotFinished();
- if (status === qq.status.UPLOAD_SUCCESSFUL) {
- this._succeededSinceLastAllComplete.push(id);
- } else if (status === qq.status.UPLOAD_FAILED) {
- this._failedSinceLastAllComplete.push(id);
- }
- if (notFinished === 0 && (this._succeededSinceLastAllComplete.length || this._failedSinceLastAllComplete.length)) {
- setTimeout(function() {
- self._onAllComplete(self._succeededSinceLastAllComplete, self._failedSinceLastAllComplete);
- }, 0);
- }
- },
- _maybeHandleIos8SafariWorkaround: function() {
- var self = this;
- if (this._options.workarounds.ios8SafariUploads && qq.ios800() && qq.iosSafari()) {
- setTimeout(function() {
- window.alert(self._options.messages.unsupportedBrowserIos8Safari);
- }, 0);
- throw new qq.Error(this._options.messages.unsupportedBrowserIos8Safari);
- }
- },
- _maybeParseAndSendUploadError: function(id, name, response, xhr) {
- if (!response.success) {
- if (xhr && xhr.status !== 200 && !response.error) {
- this._options.callbacks.onError(id, name, "XHR returned response code " + xhr.status, xhr);
- } else {
- var errorReason = response.error ? response.error : this._options.text.defaultResponseError;
- this._options.callbacks.onError(id, name, errorReason, xhr);
- }
- }
- },
- _maybeProcessNextItemAfterOnValidateCallback: function(validItem, items, index, params, endpoint) {
- var self = this;
- if (items.length > index) {
- if (validItem || !this._options.validation.stopOnFirstInvalidFile) {
- setTimeout(function() {
- var validationDescriptor = self._getValidationDescriptor(items[index]), buttonId = self._getButtonId(items[index].file), button = self._getButton(buttonId);
- self._handleCheckedCallback({
- name: "onValidate",
- callback: qq.bind(self._options.callbacks.onValidate, self, validationDescriptor, button),
- onSuccess: qq.bind(self._onValidateCallbackSuccess, self, items, index, params, endpoint),
- onFailure: qq.bind(self._onValidateCallbackFailure, self, items, index, params, endpoint),
- identifier: "Item '" + validationDescriptor.name + "', size: " + validationDescriptor.size
- });
- }, 0);
- } else if (!validItem) {
- for (;index < items.length; index++) {
- self._fileOrBlobRejected(items[index].id);
+
+ else {
+ traverseFileTree(entry);
}
}
}
+ }
+ else {
+ options.callbacks.dropProcessing(false, dataTransfer.files);
+ dz.dropDisabled(false);
+ }
+ }
+ }
+
+ function setupDropzone(dropArea){
+ dz = new qq.UploadDropZone({
+ element: dropArea,
+ onEnter: function(e){
+ qq(dropArea).addClass(options.classes.dropActive);
+ e.stopPropagation();
},
- _onAllComplete: function(successful, failed) {
- this._totalProgress && this._totalProgress.onAllComplete(successful, failed, this._preventRetries);
- this._options.callbacks.onAllComplete(qq.extend([], successful), qq.extend([], failed));
- this._succeededSinceLastAllComplete = [];
- this._failedSinceLastAllComplete = [];
+ onLeaveNotDescendants: function(e){
+ qq(dropArea).removeClass(options.classes.dropActive);
},
- _onAutoRetry: function(id, name, responseJSON, xhr, callback) {
- var self = this;
- self._preventRetries[id] = responseJSON[self._options.retry.preventRetryResponseProperty];
- if (self._shouldAutoRetry(id, name, responseJSON)) {
- var retryWaitPeriod = self._options.retry.autoAttemptDelay * 1e3;
- self._maybeParseAndSendUploadError.apply(self, arguments);
- self._options.callbacks.onAutoRetry(id, name, self._autoRetries[id]);
- self._onBeforeAutoRetry(id, name);
- self._uploadData.setStatus(id, qq.status.UPLOAD_RETRYING);
- self._retryTimeouts[id] = setTimeout(function() {
- self.log("Starting retry for " + name + "...");
- if (callback) {
- callback(id);
- } else {
- self._handler.retry(id);
- }
- }, retryWaitPeriod);
- return true;
+ onDrop: function(e){
+ if (options.hideDropzones) {
+ qq(dropArea).hide();
}
- },
- _onBeforeAutoRetry: function(id, name) {
- this.log("Waiting " + this._options.retry.autoAttemptDelay + " seconds before retrying " + name + "...");
- },
- _onBeforeManualRetry: function(id) {
- var itemLimit = this._currentItemLimit, fileName;
- if (this._preventRetries[id]) {
- this.log("Retries are forbidden for id " + id, "warn");
- return false;
- } else if (this._handler.isValid(id)) {
- fileName = this.getName(id);
- if (this._options.callbacks.onManualRetry(id, fileName) === false) {
- return false;
+ qq(dropArea).removeClass(options.classes.dropActive);
+
+ handleDataTransfer(e.dataTransfer);
+ }
+ });
+
+ disposeSupport.addDisposer(function() {
+ dz.dispose();
+ });
+
+ if (options.hideDropzones) {
+ qq(dropArea).hide();
+ }
+ }
+
+ function isFileDrag(dragEvent) {
+ var fileDrag;
+
+ qq.each(dragEvent.dataTransfer.types, function(key, val) {
+ if (val === 'Files') {
+ fileDrag = true;
+ return false;
+ }
+ });
+
+ return fileDrag;
+ }
+
+ function setupDragDrop(){
+ if (options.dropArea) {
+ options.extraDropzones.push(options.dropArea);
+ }
+
+ var i, dropzones = options.extraDropzones;
+
+ for (i=0; i < dropzones.length; i+=1){
+ setupDropzone(dropzones[i]);
+ }
+
+ // IE <= 9 does not support the File API used for drag+drop uploads
+ if (options.dropArea && (!qq.ie() || qq.ie10())) {
+ disposeSupport.attach(document, 'dragenter', function(e) {
+ if (!dz.dropDisabled() && isFileDrag(e)) {
+ if (qq(options.dropArea).hasClass(options.classes.dropDisabled)) {
+ return;
}
- if (itemLimit > 0 && this._netUploadedOrQueued + 1 > itemLimit) {
- this._itemError("retryFailTooManyItems");
- return false;
+
+ options.dropArea.style.display = 'block';
+ for (i=0; i < dropzones.length; i+=1) {
+ dropzones[i].style.display = 'block';
}
- this.log("Retrying upload for '" + fileName + "' (id: " + id + ")...");
- return true;
- } else {
- this.log("'" + id + "' is not a valid file ID", "error");
- return false;
}
- },
- _onCancel: function(id, name) {
- this._netUploadedOrQueued--;
- clearTimeout(this._retryTimeouts[id]);
- var storedItemIndex = qq.indexOf(this._storedIds, id);
- if (!this._options.autoUpload && storedItemIndex >= 0) {
- this._storedIds.splice(storedItemIndex, 1);
+ });
+ }
+ disposeSupport.attach(document, 'dragleave', function(e){
+ if (options.hideDropzones && qq.FineUploader.prototype._leaving_document_out(e)) {
+ for (i=0; i < dropzones.length; i+=1) {
+ qq(dropzones[i]).hide();
}
- this._uploadData.setStatus(id, qq.status.CANCELED);
- },
- _onComplete: function(id, name, result, xhr) {
- if (!result.success) {
- this._netUploadedOrQueued--;
- this._uploadData.setStatus(id, qq.status.UPLOAD_FAILED);
- if (result[this._options.retry.preventRetryResponseProperty] === true) {
- this._preventRetries[id] = true;
- }
- } else {
- if (result.thumbnailUrl) {
- this._thumbnailUrls[id] = result.thumbnailUrl;
- }
- this._netUploaded++;
- this._uploadData.setStatus(id, qq.status.UPLOAD_SUCCESSFUL);
+ }
+ });
+ disposeSupport.attach(document, 'drop', function(e){
+ if (options.hideDropzones) {
+ for (i=0; i < dropzones.length; i+=1) {
+ qq(dropzones[i]).hide();
}
- this._maybeParseAndSendUploadError(id, name, result, xhr);
- return result.success ? true : false;
- },
- _onDelete: function(id) {
- this._uploadData.setStatus(id, qq.status.DELETING);
- },
- _onDeleteComplete: function(id, xhrOrXdr, isError) {
- var name = this.getName(id);
- if (isError) {
- this._handleDeleteFailed(id, xhrOrXdr);
- } else {
- this._handleDeleteSuccess(id);
+ }
+ e.preventDefault();
+ });
+ }
+
+ return {
+ setup: function() {
+ setupDragDrop();
+ },
+
+ setupExtraDropzone: function(element) {
+ options.extraDropzones.push(element);
+ setupDropzone(element);
+ },
+
+ removeExtraDropzone: function(element) {
+ var i, dzs = options.extraDropzones;
+ for(i in dzs) {
+ if (dzs[i] === element) {
+ return dzs.splice(i, 1);
}
- },
- _onInputChange: function(input) {
- var fileIndex;
- if (qq.supportedFeatures.ajaxUploading) {
- for (fileIndex = 0; fileIndex < input.files.length; fileIndex++) {
- this._annotateWithButtonId(input.files[fileIndex], input);
- }
- this.addFiles(input.files);
- } else if (input.value.length > 0) {
- this.addFiles(input);
- }
- qq.each(this._buttons, function(idx, button) {
- button.reset();
+ }
+ },
+
+ dispose: function() {
+ disposeSupport.dispose();
+ dz.dispose();
+ }
+ };
+};
+
+
+qq.UploadDropZone = function(o){
+ "use strict";
+
+ var options, element, preventDrop, dropOutsideDisabled, disposeSupport = new qq.DisposeSupport();
+
+ options = {
+ element: null,
+ onEnter: function(e){},
+ onLeave: function(e){},
+ // is not fired when leaving element by hovering descendants
+ onLeaveNotDescendants: function(e){},
+ onDrop: function(e){}
+ };
+
+ qq.extend(options, o);
+ element = options.element;
+
+ function dragover_should_be_canceled(){
+ return qq.safari() || (qq.firefox() && qq.windows());
+ }
+
+ function disableDropOutside(e){
+ // run only once for all instances
+ if (!dropOutsideDisabled ){
+
+ // for these cases we need to catch onDrop to reset dropArea
+ if (dragover_should_be_canceled){
+ disposeSupport.attach(document, 'dragover', function(e){
+ e.preventDefault();
});
- },
- _onProgress: function(id, name, loaded, total) {
- this._totalProgress && this._totalProgress.onIndividualProgress(id, loaded, total);
- },
- _onSubmit: function(id, name) {},
- _onSubmitCallbackSuccess: function(id, name) {
- this._onSubmit.apply(this, arguments);
- this._uploadData.setStatus(id, qq.status.SUBMITTED);
- this._onSubmitted.apply(this, arguments);
- if (this._options.autoUpload) {
- this._options.callbacks.onSubmitted.apply(this, arguments);
- this._uploadFile(id);
- } else {
- this._storeForLater(id);
- this._options.callbacks.onSubmitted.apply(this, arguments);
- }
- },
- _onSubmitDelete: function(id, onSuccessCallback, additionalMandatedParams) {
- var uuid = this.getUuid(id), adjustedOnSuccessCallback;
- if (onSuccessCallback) {
- adjustedOnSuccessCallback = qq.bind(onSuccessCallback, this, id, uuid, additionalMandatedParams);
- }
- if (this._isDeletePossible()) {
- this._handleCheckedCallback({
- name: "onSubmitDelete",
- callback: qq.bind(this._options.callbacks.onSubmitDelete, this, id),
- onSuccess: adjustedOnSuccessCallback || qq.bind(this._deleteHandler.sendDelete, this, id, uuid, additionalMandatedParams),
- identifier: id
- });
- return true;
- } else {
- this.log("Delete request ignored for ID " + id + ", delete feature is disabled or request not possible " + "due to CORS on a user agent that does not support pre-flighting.", "warn");
- return false;
- }
- },
- _onSubmitted: function(id) {},
- _onTotalProgress: function(loaded, total) {
- this._options.callbacks.onTotalProgress(loaded, total);
- },
- _onUploadPrep: function(id) {},
- _onUpload: function(id, name) {
- this._uploadData.setStatus(id, qq.status.UPLOADING);
- },
- _onUploadChunk: function(id, chunkData) {},
- _onUploadStatusChange: function(id, oldStatus, newStatus) {
- if (newStatus === qq.status.PAUSED) {
- clearTimeout(this._retryTimeouts[id]);
- }
- },
- _onValidateBatchCallbackFailure: function(fileWrappers) {
- var self = this;
- qq.each(fileWrappers, function(idx, fileWrapper) {
- self._fileOrBlobRejected(fileWrapper.id);
- });
- },
- _onValidateBatchCallbackSuccess: function(validationDescriptors, items, params, endpoint, button) {
- var errorMessage, itemLimit = this._currentItemLimit, proposedNetFilesUploadedOrQueued = this._netUploadedOrQueued;
- if (itemLimit === 0 || proposedNetFilesUploadedOrQueued <= itemLimit) {
- if (items.length > 0) {
- this._handleCheckedCallback({
- name: "onValidate",
- callback: qq.bind(this._options.callbacks.onValidate, this, validationDescriptors[0], button),
- onSuccess: qq.bind(this._onValidateCallbackSuccess, this, items, 0, params, endpoint),
- onFailure: qq.bind(this._onValidateCallbackFailure, this, items, 0, params, endpoint),
- identifier: "Item '" + items[0].file.name + "', size: " + items[0].file.size
- });
- } else {
- this._itemError("noFilesError");
+ } else {
+ disposeSupport.attach(document, 'dragover', function(e){
+ if (e.dataTransfer){
+ e.dataTransfer.dropEffect = 'none';
+ e.preventDefault();
}
- } else {
- this._onValidateBatchCallbackFailure(items);
- errorMessage = this._options.messages.tooManyItemsError.replace(/\{netItems\}/g, proposedNetFilesUploadedOrQueued).replace(/\{itemLimit\}/g, itemLimit);
- this._batchError(errorMessage);
- }
- },
- _onValidateCallbackFailure: function(items, index, params, endpoint) {
- var nextIndex = index + 1;
- this._fileOrBlobRejected(items[index].id, items[index].file.name);
- this._maybeProcessNextItemAfterOnValidateCallback(false, items, nextIndex, params, endpoint);
- },
- _onValidateCallbackSuccess: function(items, index, params, endpoint) {
- var self = this, nextIndex = index + 1, validationDescriptor = this._getValidationDescriptor(items[index]);
- this._validateFileOrBlobData(items[index], validationDescriptor).then(function() {
- self._upload(items[index].id, params, endpoint);
- self._maybeProcessNextItemAfterOnValidateCallback(true, items, nextIndex, params, endpoint);
- }, function() {
- self._maybeProcessNextItemAfterOnValidateCallback(false, items, nextIndex, params, endpoint);
});
- },
- _prepareItemsForUpload: function(items, params, endpoint) {
- if (items.length === 0) {
- this._itemError("noFilesError");
+ }
+
+ dropOutsideDisabled = true;
+ }
+ }
+
+ function isValidFileDrag(e){
+ // e.dataTransfer currently causing IE errors
+ // IE9 does NOT support file API, so drag-and-drop is not possible
+ if (qq.ie() && !qq.ie10()) {
+ return false;
+ }
+
+ var effectTest, dt = e.dataTransfer,
+ // do not check dt.types.contains in webkit, because it crashes safari 4
+ isSafari = qq.safari();
+
+ // dt.effectAllowed is none in Safari 5
+ // dt.types.contains check is for firefox
+ effectTest = qq.ie10() ? true : dt.effectAllowed !== 'none';
+ return dt && effectTest && (dt.files || (!isSafari && dt.types.contains && dt.types.contains('Files')));
+ }
+
+ function isOrSetDropDisabled(isDisabled) {
+ if (isDisabled !== undefined) {
+ preventDrop = isDisabled;
+ }
+ return preventDrop;
+ }
+
+ function attachEvents(){
+ disposeSupport.attach(element, 'dragover', function(e){
+ if (!isValidFileDrag(e)) {
+ return;
+ }
+
+ var effect = qq.ie() ? null : e.dataTransfer.effectAllowed;
+ if (effect === 'move' || effect === 'linkMove'){
+ e.dataTransfer.dropEffect = 'move'; // for FF (only move allowed)
+ } else {
+ e.dataTransfer.dropEffect = 'copy'; // for Chrome
+ }
+
+ e.stopPropagation();
+ e.preventDefault();
+ });
+
+ disposeSupport.attach(element, 'dragenter', function(e){
+ if (!isOrSetDropDisabled()) {
+ if (!isValidFileDrag(e)) {
return;
}
- var validationDescriptors = this._getValidationDescriptors(items), buttonId = this._getButtonId(items[0].file), button = this._getButton(buttonId);
- this._handleCheckedCallback({
- name: "onValidateBatch",
- callback: qq.bind(this._options.callbacks.onValidateBatch, this, validationDescriptors, button),
- onSuccess: qq.bind(this._onValidateBatchCallbackSuccess, this, validationDescriptors, items, params, endpoint, button),
- onFailure: qq.bind(this._onValidateBatchCallbackFailure, this, items),
- identifier: "batch validation"
- });
- },
- _preventLeaveInProgress: function() {
- var self = this;
- this._disposeSupport.attach(window, "beforeunload", function(e) {
- if (self.getInProgress()) {
- e = e || window.event;
- e.returnValue = self._options.messages.onLeave;
- return self._options.messages.onLeave;
- }
- });
- },
- _refreshSessionData: function() {
- var self = this, options = this._options.session;
- if (qq.Session && this._options.session.endpoint != null) {
- if (!this._session) {
- qq.extend(options, {
- cors: this._options.cors
- });
- options.log = qq.bind(this.log, this);
- options.addFileRecord = qq.bind(this._addCannedFile, this);
- this._session = new qq.Session(options);
- }
- setTimeout(function() {
- self._session.refresh().then(function(response, xhrOrXdr) {
- self._sessionRequestComplete();
- self._options.callbacks.onSessionRequestComplete(response, true, xhrOrXdr);
- }, function(response, xhrOrXdr) {
- self._options.callbacks.onSessionRequestComplete(response, false, xhrOrXdr);
- });
- }, 0);
- }
- },
- _sessionRequestComplete: function() {},
- _setSize: function(id, newSize) {
- this._uploadData.updateSize(id, newSize);
- this._totalProgress && this._totalProgress.onNewSize(id);
- },
- _shouldAutoRetry: function(id, name, responseJSON) {
- var uploadData = this._uploadData.retrieve({
- id: id
- });
- if (!this._preventRetries[id] && this._options.retry.enableAuto && uploadData.status !== qq.status.PAUSED) {
- if (this._autoRetries[id] === undefined) {
- this._autoRetries[id] = 0;
- }
- if (this._autoRetries[id] < this._options.retry.maxAutoAttempts) {
- this._autoRetries[id] += 1;
- return true;
- }
- }
- return false;
- },
- _storeForLater: function(id) {
- this._storedIds.push(id);
- },
- _trackButton: function(id) {
- var buttonId;
- if (qq.supportedFeatures.ajaxUploading) {
- buttonId = this._handler.getFile(id).qqButtonId;
- } else {
- buttonId = this._getButtonId(this._handler.getInput(id));
- }
- if (buttonId) {
- this._buttonIdsForFileIds[id] = buttonId;
- }
- },
- _updateFormSupportAndParams: function(formElementOrId) {
- this._options.form.element = formElementOrId;
- this._formSupport = qq.FormSupport && new qq.FormSupport(this._options.form, qq.bind(this.uploadStoredFiles, this), qq.bind(this.log, this));
- if (this._formSupport && this._formSupport.attachedToForm) {
- this._paramsStore.addReadOnly(null, this._formSupport.getFormInputsAsObject);
- this._options.autoUpload = this._formSupport.newAutoUpload;
- if (this._formSupport.newEndpoint) {
- this.setEndpoint(this._formSupport.newEndpoint);
- }
- }
- },
- _upload: function(id, params, endpoint) {
- var name = this.getName(id);
- if (params) {
- this.setParams(params, id);
- }
- if (endpoint) {
- this.setEndpoint(endpoint, id);
- }
- this._handleCheckedCallback({
- name: "onSubmit",
- callback: qq.bind(this._options.callbacks.onSubmit, this, id, name),
- onSuccess: qq.bind(this._onSubmitCallbackSuccess, this, id, name),
- onFailure: qq.bind(this._fileOrBlobRejected, this, id, name),
- identifier: id
- });
- },
- _uploadFile: function(id) {
- if (!this._handler.upload(id)) {
- this._uploadData.setStatus(id, qq.status.QUEUED);
- }
- },
- _uploadStoredFiles: function() {
- var idToUpload, stillSubmitting, self = this;
- while (this._storedIds.length) {
- idToUpload = this._storedIds.shift();
- this._uploadFile(idToUpload);
- }
- stillSubmitting = this.getUploads({
- status: qq.status.SUBMITTING
- }).length;
- if (stillSubmitting) {
- qq.log("Still waiting for " + stillSubmitting + " files to clear submit queue. Will re-parse stored IDs array shortly.");
- setTimeout(function() {
- self._uploadStoredFiles();
- }, 1e3);
- }
- },
- _validateFileOrBlobData: function(fileWrapper, validationDescriptor) {
- var self = this, file = function() {
- if (fileWrapper.file instanceof qq.BlobProxy) {
- return fileWrapper.file.referenceBlob;
- }
- return fileWrapper.file;
- }(), name = validationDescriptor.name, size = validationDescriptor.size, buttonId = this._getButtonId(fileWrapper.file), validationBase = this._getValidationBase(buttonId), validityChecker = new qq.Promise();
- validityChecker.then(function() {}, function() {
- self._fileOrBlobRejected(fileWrapper.id, name);
- });
- if (qq.isFileOrInput(file) && !this._isAllowedExtension(validationBase.allowedExtensions, name)) {
- this._itemError("typeError", name, file);
- return validityChecker.failure();
- }
- if (!this._options.validation.allowEmpty && size === 0) {
- this._itemError("emptyError", name, file);
- return validityChecker.failure();
- }
- if (size > 0 && validationBase.sizeLimit && size > validationBase.sizeLimit) {
- this._itemError("sizeError", name, file);
- return validityChecker.failure();
- }
- if (size > 0 && size < validationBase.minSizeLimit) {
- this._itemError("minSizeError", name, file);
- return validityChecker.failure();
- }
- if (qq.ImageValidation && qq.supportedFeatures.imagePreviews && qq.isFile(file)) {
- new qq.ImageValidation(file, qq.bind(self.log, self)).validate(validationBase.image).then(validityChecker.success, function(errorCode) {
- self._itemError(errorCode + "ImageError", name, file);
- validityChecker.failure();
- });
- } else {
- validityChecker.success();
- }
- return validityChecker;
- },
- _wrapCallbacks: function() {
- var self, safeCallback, prop;
- self = this;
- safeCallback = function(name, callback, args) {
- var errorMsg;
- try {
- return callback.apply(self, args);
- } catch (exception) {
- errorMsg = exception.message || exception.toString();
- self.log("Caught exception in '" + name + "' callback - " + errorMsg, "error");
- }
- };
- for (prop in this._options.callbacks) {
- (function() {
- var callbackName, callbackFunc;
- callbackName = prop;
- callbackFunc = self._options.callbacks[callbackName];
- self._options.callbacks[callbackName] = function() {
- return safeCallback(callbackName, callbackFunc, arguments);
- };
- })();
- }
+ options.onEnter(e);
}
+ });
+
+ disposeSupport.attach(element, 'dragleave', function(e){
+ if (!isValidFileDrag(e)) {
+ return;
+ }
+
+ options.onLeave(e);
+
+ var relatedTarget = document.elementFromPoint(e.clientX, e.clientY);
+ // do not fire when moving a mouse over a descendant
+ if (qq(this).contains(relatedTarget)) {
+ return;
+ }
+
+ options.onLeaveNotDescendants(e);
+ });
+
+ disposeSupport.attach(element, 'drop', function(e){
+ if (!isOrSetDropDisabled()) {
+ if (!isValidFileDrag(e)) {
+ return;
+ }
+
+ e.preventDefault();
+ options.onDrop(e);
+ }
+ });
+ }
+
+ disableDropOutside();
+ attachEvents();
+
+ return {
+ dropDisabled: function(isDisabled) {
+ return isOrSetDropDisabled(isDisabled);
+ },
+
+ dispose: function() {
+ disposeSupport.dispose();
+ }
+ };
+};
+/**
+ * Class that creates upload widget with drag-and-drop and file list
+ * @inherits qq.FineUploaderBasic
+ */
+qq.FineUploader = function(o){
+ // call parent constructor
+ qq.FineUploaderBasic.apply(this, arguments);
+
+ // additional options
+ qq.extend(this._options, {
+ element: null,
+ listElement: null,
+ dragAndDrop: {
+ extraDropzones: [],
+ hideDropzones: true,
+ disableDefaultDropzone: false
+ },
+ text: {
+ uploadButton: 'Upload a file',
+ cancelButton: 'Cancel',
+ retryButton: 'Retry',
+ deleteButton: 'Delete',
+ failUpload: 'Upload failed',
+ dragZone: 'Drop files here to upload',
+ dropProcessing: 'Processing dropped files...',
+ formatProgress: "{percent}% of {total_size}",
+ waitingForResponse: "Processing..."
+ },
+ template: '' +
+ ((!this._options.dragAndDrop || !this._options.dragAndDrop.disableDefaultDropzone) ? '
{dragZoneText}
' : '') +
+ (!this._options.button ? '
' : '') +
+ '
{dropProcessingText}' +
+ (!this._options.listElement ? '
' : '') +
+ '
' +
+ '' +
+ '' +
+ '' +
+ '' +
+ '' +
+ '{cancelButtonText}' +
+ '{retryButtonText}' +
+ '{deleteButtonText}' +
+ '{statusText}' +
+ '',
+ classes: {
+ button: 'qq-upload-button',
+ drop: 'qq-upload-drop-area',
+ dropActive: 'qq-upload-drop-area-active',
+ dropDisabled: 'qq-upload-drop-area-disabled',
+ list: 'qq-upload-list',
+ progressBar: 'qq-progress-bar',
+ file: 'qq-upload-file',
+ spinner: 'qq-upload-spinner',
+ finished: 'qq-upload-finished',
+ retrying: 'qq-upload-retrying',
+ retryable: 'qq-upload-retryable',
+ size: 'qq-upload-size',
+ cancel: 'qq-upload-cancel',
+ deleteButton: 'qq-upload-delete',
+ retry: 'qq-upload-retry',
+ statusText: 'qq-upload-status-text',
+
+ success: 'qq-upload-success',
+ fail: 'qq-upload-fail',
+
+ successIcon: null,
+ failIcon: null,
+
+ dropProcessing: 'qq-drop-processing',
+ dropProcessingSpinner: 'qq-drop-processing-spinner'
+ },
+ failedUploadTextDisplay: {
+ mode: 'default', //default, custom, or none
+ maxChars: 50,
+ responseProperty: 'error',
+ enableTooltip: true
+ },
+ messages: {
+ tooManyFilesError: "You may only drop one file"
+ },
+ retry: {
+ showAutoRetryNote: true,
+ autoRetryNote: "Retrying {retryNum}/{maxAuto}...",
+ showButton: false
+ },
+ deleteFile: {
+ forceConfirm: false,
+ confirmMessage: "Are you sure you want to delete {filename}?",
+ deletingStatusText: "Deleting...",
+ deletingFailedText: "Delete failed"
+
+ },
+ display: {
+ fileSizeOnSubmit: false
+ },
+ showMessage: function(message){
+ setTimeout(function() {
+ alert(message);
+ }, 0);
+ },
+ showConfirm: function(message, okCallback, cancelCallback) {
+ setTimeout(function() {
+ var result = confirm(message);
+ if (result) {
+ okCallback();
+ }
+ else if (cancelCallback) {
+ cancelCallback();
+ }
+ }, 0);
+ }
+ }, true);
+
+ // overwrite options with user supplied
+ qq.extend(this._options, o, true);
+ this._wrapCallbacks();
+
+ // overwrite the upload button text if any
+ // same for the Cancel button and Fail message text
+ this._options.template = this._options.template.replace(/\{dragZoneText\}/g, this._options.text.dragZone);
+ this._options.template = this._options.template.replace(/\{uploadButtonText\}/g, this._options.text.uploadButton);
+ this._options.template = this._options.template.replace(/\{dropProcessingText\}/g, this._options.text.dropProcessing);
+ this._options.fileTemplate = this._options.fileTemplate.replace(/\{cancelButtonText\}/g, this._options.text.cancelButton);
+ this._options.fileTemplate = this._options.fileTemplate.replace(/\{retryButtonText\}/g, this._options.text.retryButton);
+ this._options.fileTemplate = this._options.fileTemplate.replace(/\{deleteButtonText\}/g, this._options.text.deleteButton);
+ this._options.fileTemplate = this._options.fileTemplate.replace(/\{statusText\}/g, "");
+
+ this._element = this._options.element;
+ this._element.innerHTML = this._options.template;
+ this._listElement = this._options.listElement || this._find(this._element, 'list');
+
+ this._classes = this._options.classes;
+
+ if (!this._button) {
+ this._button = this._createUploadButton(this._find(this._element, 'button'));
+ }
+
+ this._bindCancelAndRetryEvents();
+
+ this._dnd = this._setupDragAndDrop();
+};
+
+// inherit from Basic Uploader
+qq.extend(qq.FineUploader.prototype, qq.FineUploaderBasic.prototype);
+
+qq.extend(qq.FineUploader.prototype, {
+ clearStoredFiles: function() {
+ qq.FineUploaderBasic.prototype.clearStoredFiles.apply(this, arguments);
+ this._listElement.innerHTML = "";
+ },
+ addExtraDropzone: function(element){
+ this._dnd.setupExtraDropzone(element);
+ },
+ removeExtraDropzone: function(element){
+ return this._dnd.removeExtraDropzone(element);
+ },
+ getItemByFileId: function(id){
+ var item = this._listElement.firstChild;
+
+ // there can't be txt nodes in dynamically created list
+ // and we can use nextSibling
+ while (item){
+ if (item.qqFileId == id) return item;
+ item = item.nextSibling;
+ }
+ },
+ reset: function() {
+ qq.FineUploaderBasic.prototype.reset.apply(this, arguments);
+ this._element.innerHTML = this._options.template;
+ this._listElement = this._options.listElement || this._find(this._element, 'list');
+ if (!this._options.button) {
+ this._button = this._createUploadButton(this._find(this._element, 'button'));
+ }
+ this._bindCancelAndRetryEvents();
+ this._dnd.dispose();
+ this._dnd = this._setupDragAndDrop();
+ },
+ _removeFileItem: function(fileId) {
+ var item = this.getItemByFileId(fileId);
+ qq(item).remove();
+ },
+ _setupDragAndDrop: function() {
+ var self = this,
+ dropProcessingEl = this._find(this._element, 'dropProcessing'),
+ dnd, preventSelectFiles, defaultDropAreaEl;
+
+ preventSelectFiles = function(event) {
+ event.preventDefault();
};
- })();
- (function() {
- "use strict";
- qq.FineUploaderBasic = function(o) {
- var self = this;
- this._options = {
- debug: false,
- button: null,
- multiple: true,
- maxConnections: 3,
- disableCancelForFormUploads: false,
- autoUpload: true,
- request: {
- customHeaders: {},
- endpoint: "/server/upload",
- filenameParam: "qqfilename",
- forceMultipart: true,
- inputName: "qqfile",
- method: "POST",
- params: {},
- paramsInBody: true,
- totalFileSizeName: "qqtotalfilesize",
- uuidName: "qquuid"
- },
- validation: {
- allowedExtensions: [],
- sizeLimit: 0,
- minSizeLimit: 0,
- itemLimit: 0,
- stopOnFirstInvalidFile: true,
- acceptFiles: null,
- image: {
- maxHeight: 0,
- maxWidth: 0,
- minHeight: 0,
- minWidth: 0
- },
- allowEmpty: false
- },
- callbacks: {
- onSubmit: function(id, name) {},
- onSubmitted: function(id, name) {},
- onComplete: function(id, name, responseJSON, maybeXhr) {},
- onAllComplete: function(successful, failed) {},
- onCancel: function(id, name) {},
- onUpload: function(id, name) {},
- onUploadChunk: function(id, name, chunkData) {},
- onUploadChunkSuccess: function(id, chunkData, responseJSON, xhr) {},
- onResume: function(id, fileName, chunkData) {},
- onProgress: function(id, name, loaded, total) {},
- onTotalProgress: function(loaded, total) {},
- onError: function(id, name, reason, maybeXhrOrXdr) {},
- onAutoRetry: function(id, name, attemptNumber) {},
- onManualRetry: function(id, name) {},
- onValidateBatch: function(fileOrBlobData) {},
- onValidate: function(fileOrBlobData) {},
- onSubmitDelete: function(id) {},
- onDelete: function(id) {},
- onDeleteComplete: function(id, xhrOrXdr, isError) {},
- onPasteReceived: function(blob) {},
- onStatusChange: function(id, oldStatus, newStatus) {},
- onSessionRequestComplete: function(response, success, xhrOrXdr) {}
- },
- messages: {
- typeError: "{file} has an invalid extension. Valid extension(s): {extensions}.",
- sizeError: "{file} is too large, maximum file size is {sizeLimit}.",
- minSizeError: "{file} is too small, minimum file size is {minSizeLimit}.",
- emptyError: "{file} is empty, please select files again without it.",
- noFilesError: "No files to upload.",
- tooManyItemsError: "Too many items ({netItems}) would be uploaded. Item limit is {itemLimit}.",
- maxHeightImageError: "Image is too tall.",
- maxWidthImageError: "Image is too wide.",
- minHeightImageError: "Image is not tall enough.",
- minWidthImageError: "Image is not wide enough.",
- retryFailTooManyItems: "Retry failed - you have reached your file limit.",
- onLeave: "The files are being uploaded, if you leave now the upload will be canceled.",
- unsupportedBrowserIos8Safari: "Unrecoverable error - this browser does not permit file uploading of any kind due to serious bugs in iOS8 Safari. Please use iOS8 Chrome until Apple fixes these issues."
- },
- retry: {
- enableAuto: false,
- maxAutoAttempts: 3,
- autoAttemptDelay: 5,
- preventRetryResponseProperty: "preventRetry"
- },
- classes: {
- buttonHover: "qq-upload-button-hover",
- buttonFocus: "qq-upload-button-focus"
- },
- chunking: {
- enabled: false,
- concurrent: {
- enabled: false
- },
- mandatory: false,
- paramNames: {
- partIndex: "qqpartindex",
- partByteOffset: "qqpartbyteoffset",
- chunkSize: "qqchunksize",
- totalFileSize: "qqtotalfilesize",
- totalParts: "qqtotalparts"
- },
- partSize: 2e6,
- success: {
- endpoint: null
+
+ if (!this._options.dragAndDrop.disableDefaultDropzone) {
+ defaultDropAreaEl = this._find(this._options.element, 'drop');
+ }
+
+ dnd = new qq.DragAndDrop({
+ dropArea: defaultDropAreaEl,
+ extraDropzones: this._options.dragAndDrop.extraDropzones,
+ hideDropzones: this._options.dragAndDrop.hideDropzones,
+ multiple: this._options.multiple,
+ classes: {
+ dropActive: this._options.classes.dropActive
+ },
+ callbacks: {
+ dropProcessing: function(isProcessing, files) {
+ var input = self._button.getInput();
+
+ if (isProcessing) {
+ qq(dropProcessingEl).css({display: 'block'});
+ qq(input).attach('click', preventSelectFiles);
+ }
+ else {
+ qq(dropProcessingEl).hide();
+ qq(input).detach('click', preventSelectFiles);
+ }
+
+ if (files) {
+ self.addFiles(files);
}
},
- resume: {
- enabled: false,
- recordsExpireIn: 7,
- paramNames: {
- resuming: "qqresume"
- }
+ error: function(code, filename) {
+ self._error(code, filename);
},
- formatFileName: function(fileOrBlobName) {
- return fileOrBlobName;
- },
- text: {
- defaultResponseError: "Upload failure reason unknown",
- fileInputTitle: "file input",
- sizeSymbols: [ "kB", "MB", "GB", "TB", "PB", "EB" ]
- },
- deleteFile: {
- enabled: false,
- method: "DELETE",
- endpoint: "/server/upload",
- customHeaders: {},
- params: {}
- },
- cors: {
- expected: false,
- sendCredentials: false,
- allowXdr: false
- },
- blobs: {
- defaultName: "misc_data"
- },
- paste: {
- targetElement: null,
- defaultName: "pasted_image"
- },
- camera: {
- ios: false,
- button: null
- },
- extraButtons: [],
- session: {
- endpoint: null,
- params: {},
- customHeaders: {},
- refreshOnReset: true
- },
- form: {
- element: "qq-form",
- autoUpload: false,
- interceptSubmit: true
- },
- scaling: {
- customResizer: null,
- sendOriginal: true,
- orient: true,
- defaultType: null,
- defaultQuality: 80,
- failureText: "Failed to scale",
- includeExif: false,
- sizes: []
- },
- workarounds: {
- iosEmptyVideos: true,
- ios8SafariUploads: true,
- ios8BrowserCrash: false
- }
- };
- qq.extend(this._options, o, true);
- this._buttons = [];
- this._extraButtonSpecs = {};
- this._buttonIdsForFileIds = [];
- this._wrapCallbacks();
- this._disposeSupport = new qq.DisposeSupport();
- this._storedIds = [];
- this._autoRetries = [];
- this._retryTimeouts = [];
- this._preventRetries = [];
- this._thumbnailUrls = [];
- this._netUploadedOrQueued = 0;
- this._netUploaded = 0;
- this._uploadData = this._createUploadDataTracker();
- this._initFormSupportAndParams();
- this._customHeadersStore = this._createStore(this._options.request.customHeaders);
- this._deleteFileCustomHeadersStore = this._createStore(this._options.deleteFile.customHeaders);
- this._deleteFileParamsStore = this._createStore(this._options.deleteFile.params);
- this._endpointStore = this._createStore(this._options.request.endpoint);
- this._deleteFileEndpointStore = this._createStore(this._options.deleteFile.endpoint);
- this._handler = this._createUploadHandler();
- this._deleteHandler = qq.DeleteFileAjaxRequester && this._createDeleteHandler();
- if (this._options.button) {
- this._defaultButtonId = this._createUploadButton({
- element: this._options.button,
- title: this._options.text.fileInputTitle
- }).getButtonId();
- }
- this._generateExtraButtonSpecs();
- this._handleCameraAccess();
- if (this._options.paste.targetElement) {
- if (qq.PasteSupport) {
- this._pasteHandler = this._createPasteHandler();
- } else {
- this.log("Paste support module not found", "error");
+ log: function(message, level) {
+ self.log(message, level);
}
}
- this._preventLeaveInProgress();
- this._imageGenerator = qq.ImageGenerator && new qq.ImageGenerator(qq.bind(this.log, this));
- this._refreshSessionData();
- this._succeededSinceLastAllComplete = [];
- this._failedSinceLastAllComplete = [];
- this._scaler = qq.Scaler && new qq.Scaler(this._options.scaling, qq.bind(this.log, this)) || {};
- if (this._scaler.enabled) {
- this._customNewFileHandler = qq.bind(this._scaler.handleNewFile, this._scaler);
+ });
+
+ dnd.setup();
+
+ return dnd;
+ },
+ _leaving_document_out: function(e){
+ return ((qq.chrome() || (qq.safari() && qq.windows())) && e.clientX == 0 && e.clientY == 0) // null coords for Chrome and Safari Windows
+ || (qq.firefox() && !e.relatedTarget); // null e.relatedTarget for Firefox
+ },
+ _storeForLater: function(id) {
+ qq.FineUploaderBasic.prototype._storeForLater.apply(this, arguments);
+ var item = this.getItemByFileId(id);
+ qq(this._find(item, 'spinner')).hide();
+ },
+ /**
+ * Gets one of the elements listed in this._options.classes
+ **/
+ _find: function(parent, type){
+ var element = qq(parent).getByClass(this._options.classes[type])[0];
+ if (!element){
+ throw new Error('element not found ' + type);
+ }
+
+ return element;
+ },
+ _onSubmit: function(id, name){
+ qq.FineUploaderBasic.prototype._onSubmit.apply(this, arguments);
+ this._addToList(id, name);
+ },
+ // Update the progress bar & percentage as the file is uploaded
+ _onProgress: function(id, name, loaded, total){
+ qq.FineUploaderBasic.prototype._onProgress.apply(this, arguments);
+
+ var item, progressBar, percent, cancelLink;
+
+ item = this.getItemByFileId(id);
+ progressBar = this._find(item, 'progressBar');
+ percent = Math.round(loaded / total * 100);
+
+ if (loaded === total) {
+ cancelLink = this._find(item, 'cancel');
+ qq(cancelLink).hide();
+
+ qq(progressBar).hide();
+ qq(this._find(item, 'statusText')).setText(this._options.text.waitingForResponse);
+
+ // If last byte was sent, display total file size
+ this._displayFileSize(id);
+ }
+ else {
+ // If still uploading, display percentage - total size is actually the total request(s) size
+ this._displayFileSize(id, loaded, total);
+
+ qq(progressBar).css({display: 'block'});
+ }
+
+ // Update progress bar element
+ qq(progressBar).css({width: percent + '%'});
+ },
+ _onComplete: function(id, name, result, xhr){
+ qq.FineUploaderBasic.prototype._onComplete.apply(this, arguments);
+
+ var item = this.getItemByFileId(id);
+
+ qq(this._find(item, 'statusText')).clearText();
+
+ qq(item).removeClass(this._classes.retrying);
+ qq(this._find(item, 'progressBar')).hide();
+
+ if (!this._options.disableCancelForFormUploads || qq.isXhrUploadSupported()) {
+ qq(this._find(item, 'cancel')).hide();
+ }
+ qq(this._find(item, 'spinner')).hide();
+
+ if (result.success) {
+ if (this._isDeletePossible()) {
+ this._showDeleteLink(id);
}
- if (qq.TotalProgress && qq.supportedFeatures.progressBar) {
- this._totalProgress = new qq.TotalProgress(qq.bind(this._onTotalProgress, this), function(id) {
- var entry = self._uploadData.retrieve({
- id: id
- });
- return entry && entry.size || 0;
- });
+
+ qq(item).addClass(this._classes.success);
+ if (this._classes.successIcon) {
+ this._find(item, 'finished').style.display = "inline-block";
+ qq(item).addClass(this._classes.successIcon);
}
- this._currentItemLimit = this._options.validation.itemLimit;
- };
- qq.FineUploaderBasic.prototype = qq.basePublicApi;
- qq.extend(qq.FineUploaderBasic.prototype, qq.basePrivateApi);
- })();
- qq.AjaxRequester = function(o) {
- "use strict";
- var log, shouldParamsBeInQueryString, queue = [], requestData = {}, options = {
- acceptHeader: null,
- validMethods: [ "PATCH", "POST", "PUT" ],
- method: "POST",
- contentType: "application/x-www-form-urlencoded",
+ } else {
+ qq(item).addClass(this._classes.fail);
+ if (this._classes.failIcon) {
+ this._find(item, 'finished').style.display = "inline-block";
+ qq(item).addClass(this._classes.failIcon);
+ }
+ if (this._options.retry.showButton && !this._preventRetries[id]) {
+ qq(item).addClass(this._classes.retryable);
+ }
+ this._controlFailureTextDisplay(item, result);
+ }
+ },
+ _onUpload: function(id, name){
+ qq.FineUploaderBasic.prototype._onUpload.apply(this, arguments);
+
+ this._showSpinner(id);
+ },
+ _onCancel: function(id, name) {
+ qq.FineUploaderBasic.prototype._onCancel.apply(this, arguments);
+ this._removeFileItem(id);
+ },
+ _onBeforeAutoRetry: function(id) {
+ var item, progressBar, failTextEl, retryNumForDisplay, maxAuto, retryNote;
+
+ qq.FineUploaderBasic.prototype._onBeforeAutoRetry.apply(this, arguments);
+
+ item = this.getItemByFileId(id);
+ progressBar = this._find(item, 'progressBar');
+
+ this._showCancelLink(item);
+ progressBar.style.width = 0;
+ qq(progressBar).hide();
+
+ if (this._options.retry.showAutoRetryNote) {
+ failTextEl = this._find(item, 'statusText');
+ retryNumForDisplay = this._autoRetries[id] + 1;
+ maxAuto = this._options.retry.maxAutoAttempts;
+
+ retryNote = this._options.retry.autoRetryNote.replace(/\{retryNum\}/g, retryNumForDisplay);
+ retryNote = retryNote.replace(/\{maxAuto\}/g, maxAuto);
+
+ qq(failTextEl).setText(retryNote);
+ if (retryNumForDisplay === 1) {
+ qq(item).addClass(this._classes.retrying);
+ }
+ }
+ },
+ //return false if we should not attempt the requested retry
+ _onBeforeManualRetry: function(id) {
+ if (qq.FineUploaderBasic.prototype._onBeforeManualRetry.apply(this, arguments)) {
+ var item = this.getItemByFileId(id);
+ this._find(item, 'progressBar').style.width = 0;
+ qq(item).removeClass(this._classes.fail);
+ qq(this._find(item, 'statusText')).clearText();
+ this._showSpinner(id);
+ this._showCancelLink(item);
+ return true;
+ }
+ return false;
+ },
+ _onSubmitDelete: function(id) {
+ if (this._isDeletePossible()) {
+ if (this._options.callbacks.onSubmitDelete(id) !== false) {
+ if (this._options.deleteFile.forceConfirm) {
+ this._showDeleteConfirm(id);
+ }
+ else {
+ this._sendDeleteRequest(id);
+ }
+ }
+ }
+ else {
+ this.log("Delete request ignored for file ID " + id + ", delete feature is disabled.", "warn");
+ return false;
+ }
+ },
+ _onDeleteComplete: function(id, xhr, isError) {
+ qq.FineUploaderBasic.prototype._onDeleteComplete.apply(this, arguments);
+
+ var item = this.getItemByFileId(id),
+ spinnerEl = this._find(item, 'spinner'),
+ statusTextEl = this._find(item, 'statusText');
+
+ qq(spinnerEl).hide();
+
+ if (isError) {
+ qq(statusTextEl).setText(this._options.deleteFile.deletingFailedText);
+ this._showDeleteLink(id);
+ }
+ else {
+ this._removeFileItem(id);
+ }
+ },
+ _sendDeleteRequest: function(id) {
+ var item = this.getItemByFileId(id),
+ deleteLink = this._find(item, 'deleteButton'),
+ statusTextEl = this._find(item, 'statusText');
+
+ qq(deleteLink).hide();
+ this._showSpinner(id);
+ qq(statusTextEl).setText(this._options.deleteFile.deletingStatusText);
+ this._deleteHandler.sendDelete(id, this.getUuid(id));
+ },
+ _showDeleteConfirm: function(id) {
+ var fileName = this._handler.getName(id),
+ confirmMessage = this._options.deleteFile.confirmMessage.replace(/\{filename\}/g, fileName),
+ uuid = this.getUuid(id),
+ self = this;
+
+ this._options.showConfirm(confirmMessage, function() {
+ self._sendDeleteRequest(id);
+ });
+ },
+ _addToList: function(id, name){
+ var item = qq.toElement(this._options.fileTemplate);
+ if (this._options.disableCancelForFormUploads && !qq.isXhrUploadSupported()) {
+ var cancelLink = this._find(item, 'cancel');
+ qq(cancelLink).remove();
+ }
+
+ item.qqFileId = id;
+
+ var fileElement = this._find(item, 'file');
+ qq(fileElement).setText(this._options.formatFileName(name));
+ qq(this._find(item, 'size')).hide();
+ if (!this._options.multiple) {
+ this._handler.cancelAll();
+ this._clearList();
+ }
+
+ this._listElement.appendChild(item);
+
+ if (this._options.display.fileSizeOnSubmit && qq.isXhrUploadSupported()) {
+ this._displayFileSize(id);
+ }
+ },
+ _clearList: function(){
+ this._listElement.innerHTML = '';
+ this.clearStoredFiles();
+ },
+ _displayFileSize: function(id, loadedSize, totalSize) {
+ var item = this.getItemByFileId(id),
+ size = this.getSize(id),
+ sizeForDisplay = this._formatSize(size),
+ sizeEl = this._find(item, 'size');
+
+ if (loadedSize !== undefined && totalSize !== undefined) {
+ sizeForDisplay = this._formatProgress(loadedSize, totalSize);
+ }
+
+ qq(sizeEl).css({display: 'inline'});
+ qq(sizeEl).setText(sizeForDisplay);
+ },
+ /**
+ * delegate click event for cancel & retry links
+ **/
+ _bindCancelAndRetryEvents: function(){
+ var self = this,
+ list = this._listElement;
+
+ this._disposeSupport.attach(list, 'click', function(e){
+ e = e || window.event;
+ var target = e.target || e.srcElement;
+
+ if (qq(target).hasClass(self._classes.cancel) || qq(target).hasClass(self._classes.retry) || qq(target).hasClass(self._classes.deleteButton)){
+ qq.preventDefault(e);
+
+ var item = target.parentNode;
+ while(item.qqFileId === undefined) {
+ item = target = target.parentNode;
+ }
+
+ if (qq(target).hasClass(self._classes.deleteButton)) {
+ self.deleteFile(item.qqFileId);
+ }
+ else if (qq(target).hasClass(self._classes.cancel)) {
+ self.cancel(item.qqFileId);
+ }
+ else {
+ qq(item).removeClass(self._classes.retryable);
+ self.retry(item.qqFileId);
+ }
+ }
+ });
+ },
+ _formatProgress: function (uploadedSize, totalSize) {
+ var message = this._options.text.formatProgress;
+ function r(name, replacement) { message = message.replace(name, replacement); }
+
+ r('{percent}', Math.round(uploadedSize / totalSize * 100));
+ r('{total_size}', this._formatSize(totalSize));
+ return message;
+ },
+ _controlFailureTextDisplay: function(item, response) {
+ var mode, maxChars, responseProperty, failureReason, shortFailureReason;
+
+ mode = this._options.failedUploadTextDisplay.mode;
+ maxChars = this._options.failedUploadTextDisplay.maxChars;
+ responseProperty = this._options.failedUploadTextDisplay.responseProperty;
+
+ if (mode === 'custom') {
+ failureReason = response[responseProperty];
+ if (failureReason) {
+ if (failureReason.length > maxChars) {
+ shortFailureReason = failureReason.substring(0, maxChars) + '...';
+ }
+ }
+ else {
+ failureReason = this._options.text.failUpload;
+ this.log("'" + responseProperty + "' is not a valid property on the server response.", 'warn');
+ }
+
+ qq(this._find(item, 'statusText')).setText(shortFailureReason || failureReason);
+
+ if (this._options.failedUploadTextDisplay.enableTooltip) {
+ this._showTooltip(item, failureReason);
+ }
+ }
+ else if (mode === 'default') {
+ qq(this._find(item, 'statusText')).setText(this._options.text.failUpload);
+ }
+ else if (mode !== 'none') {
+ this.log("failedUploadTextDisplay.mode value of '" + mode + "' is not valid", 'warn');
+ }
+ },
+ _showTooltip: function(item, text) {
+ item.title = text;
+ },
+ _showSpinner: function(id) {
+ var item = this.getItemByFileId(id),
+ spinnerEl = this._find(item, 'spinner');
+
+ spinnerEl.style.display = "inline-block";
+ },
+ _showCancelLink: function(item) {
+ if (!this._options.disableCancelForFormUploads || qq.isXhrUploadSupported()) {
+ var cancelLink = this._find(item, 'cancel');
+
+ qq(cancelLink).css({display: 'inline'});
+ }
+ },
+ _showDeleteLink: function(id) {
+ var item = this.getItemByFileId(id),
+ deleteLink = this._find(item, 'deleteButton');
+
+ qq(deleteLink).css({display: 'inline'});
+ },
+ _error: function(code, name){
+ var message = qq.FineUploaderBasic.prototype._error.apply(this, arguments);
+ this._options.showMessage(message);
+ }
+});
+/** Generic class for sending non-upload ajax requests and handling the associated responses **/
+//TODO Use XDomainRequest if expectCors = true. Not necessary now since only DELETE requests are sent and XDR doesn't support pre-flighting.
+/*globals qq, XMLHttpRequest*/
+qq.AjaxRequestor = function(o) {
+ "use strict";
+
+ var log, shouldParamsBeInQueryString,
+ queue = [],
+ requestState = [],
+ options = {
+ method: 'POST',
maxConnections: 3,
customHeaders: {},
endpointStore: {},
paramsStore: {},
- mandatedParams: {},
- allowXRequestedWithAndCacheControl: true,
- successfulResponseCodes: {
- DELETE: [ 200, 202, 204 ],
- PATCH: [ 200, 201, 202, 203, 204 ],
- POST: [ 200, 201, 202, 203, 204 ],
- PUT: [ 200, 201, 202, 203, 204 ],
- GET: [ 200 ]
- },
+ successfulResponseCodes: [200],
+ demoMode: false,
cors: {
expected: false,
sendCredentials: false
},
log: function(str, level) {},
onSend: function(id) {},
- onComplete: function(id, xhrOrXdr, isError) {},
- onProgress: null
+ onComplete: function(id, xhr, isError) {},
+ onCancel: function(id) {}
};
- qq.extend(options, o);
- log = options.log;
- if (qq.indexOf(options.validMethods, options.method) < 0) {
- throw new Error("'" + options.method + "' is not a supported method for this type of request!");
+
+ qq.extend(options, o);
+ log = options.log;
+ shouldParamsBeInQueryString = getMethod() === 'GET' || getMethod() === 'DELETE';
+
+
+ /**
+ * Removes element from queue, sends next request
+ */
+ function dequeue(id) {
+ var i = qq.indexOf(queue, id),
+ max = options.maxConnections,
+ nextId;
+
+ delete requestState[id];
+ queue.splice(i, 1);
+
+ if (queue.length >= max && i < max){
+ nextId = queue[max-1];
+ sendRequest(nextId);
}
- function isSimpleMethod() {
- return qq.indexOf([ "GET", "POST", "HEAD" ], options.method) >= 0;
+ }
+
+ function onComplete(id) {
+ var xhr = requestState[id].xhr,
+ method = getMethod(),
+ isError = false;
+
+ dequeue(id);
+
+ if (!isResponseSuccessful(xhr.status)) {
+ isError = true;
+ log(method + " request for " + id + " has failed - response code " + xhr.status, "error");
}
- function containsNonSimpleHeaders(headers) {
- var containsNonSimple = false;
- qq.each(containsNonSimple, function(idx, header) {
- if (qq.indexOf([ "Accept", "Accept-Language", "Content-Language", "Content-Type" ], header) < 0) {
- containsNonSimple = true;
- return false;
- }
- });
- return containsNonSimple;
+
+ options.onComplete(id, xhr, isError);
+ }
+
+ function sendRequest(id) {
+ var xhr = new XMLHttpRequest(),
+ method = getMethod(),
+ params = {},
+ url;
+
+ options.onSend(id);
+
+ if (options.paramsStore.getParams) {
+ params = options.paramsStore.getParams(id);
}
- function isXdr(xhr) {
- return options.cors.expected && xhr.withCredentials === undefined;
+
+ url = createUrl(id, params);
+
+ requestState[id].xhr = xhr;
+ xhr.onreadystatechange = getReadyStateChangeHandler(id);
+ xhr.open(method, url, true);
+
+ if (options.cors.expected && options.cors.sendCredentials) {
+ xhr.withCredentials = true;
}
- function getCorsAjaxTransport() {
- var xhrOrXdr;
- if (window.XMLHttpRequest || window.ActiveXObject) {
- xhrOrXdr = qq.createXhrInstance();
- if (xhrOrXdr.withCredentials === undefined) {
- xhrOrXdr = new XDomainRequest();
- xhrOrXdr.onload = function() {};
- xhrOrXdr.onerror = function() {};
- xhrOrXdr.ontimeout = function() {};
- xhrOrXdr.onprogress = function() {};
- }
- }
- return xhrOrXdr;
+
+ setHeaders(id);
+
+ log('Sending ' + method + " request for " + id);
+ if (!shouldParamsBeInQueryString && params) {
+ xhr.send(qq.obj2url(params, ""));
}
- function getXhrOrXdr(id, suppliedXhr) {
- var xhrOrXdr = requestData[id].xhr;
- if (!xhrOrXdr) {
- if (suppliedXhr) {
- xhrOrXdr = suppliedXhr;
- } else {
- if (options.cors.expected) {
- xhrOrXdr = getCorsAjaxTransport();
- } else {
- xhrOrXdr = qq.createXhrInstance();
- }
- }
- requestData[id].xhr = xhrOrXdr;
- }
- return xhrOrXdr;
+ else {
+ xhr.send();
}
- function dequeue(id) {
- var i = qq.indexOf(queue, id), max = options.maxConnections, nextId;
- delete requestData[id];
- queue.splice(i, 1);
- if (queue.length >= max && i < max) {
- nextId = queue[max - 1];
- sendRequest(nextId);
- }
+ }
+
+ function createUrl(id, params) {
+ var endpoint = options.endpointStore.getEndpoint(id),
+ addToPath = requestState[id].addToPath;
+
+ if (addToPath !== undefined) {
+ endpoint += "/" + addToPath;
}
- function onComplete(id, xdrError) {
- var xhr = getXhrOrXdr(id), method = options.method, isError = xdrError === true;
- dequeue(id);
- if (isError) {
- log(method + " request for " + id + " has failed", "error");
- } else if (!isXdr(xhr) && !isResponseSuccessful(xhr.status)) {
- isError = true;
- log(method + " request for " + id + " has failed - response code " + xhr.status, "error");
- }
- options.onComplete(id, xhr, isError);
+
+ if (shouldParamsBeInQueryString && params) {
+ return qq.obj2url(params, endpoint);
}
- function getParams(id) {
- var onDemandParams = requestData[id].additionalParams, mandatedParams = options.mandatedParams, params;
- if (options.paramsStore.get) {
- params = options.paramsStore.get(id);
- }
- if (onDemandParams) {
- qq.each(onDemandParams, function(name, val) {
- params = params || {};
- params[name] = val;
- });
- }
- if (mandatedParams) {
- qq.each(mandatedParams, function(name, val) {
- params = params || {};
- params[name] = val;
- });
- }
- return params;
- }
- function sendRequest(id, optXhr) {
- var xhr = getXhrOrXdr(id, optXhr), method = options.method, params = getParams(id), payload = requestData[id].payload, url;
- options.onSend(id);
- url = createUrl(id, params, requestData[id].additionalQueryParams);
- if (isXdr(xhr)) {
- xhr.onload = getXdrLoadHandler(id);
- xhr.onerror = getXdrErrorHandler(id);
- } else {
- xhr.onreadystatechange = getXhrReadyStateChangeHandler(id);
- }
- registerForUploadProgress(id);
- xhr.open(method, url, true);
- if (options.cors.expected && options.cors.sendCredentials && !isXdr(xhr)) {
- xhr.withCredentials = true;
- }
- setHeaders(id);
- log("Sending " + method + " request for " + id);
- if (payload) {
- xhr.send(payload);
- } else if (shouldParamsBeInQueryString || !params) {
- xhr.send();
- } else if (params && options.contentType && options.contentType.toLowerCase().indexOf("application/x-www-form-urlencoded") >= 0) {
- xhr.send(qq.obj2url(params, ""));
- } else if (params && options.contentType && options.contentType.toLowerCase().indexOf("application/json") >= 0) {
- xhr.send(JSON.stringify(params));
- } else {
- xhr.send(params);
- }
- return xhr;
- }
- function createUrl(id, params, additionalQueryParams) {
- var endpoint = options.endpointStore.get(id), addToPath = requestData[id].addToPath;
- if (addToPath != undefined) {
- endpoint += "/" + addToPath;
- }
- if (shouldParamsBeInQueryString && params) {
- endpoint = qq.obj2url(params, endpoint);
- }
- if (additionalQueryParams) {
- endpoint = qq.obj2url(additionalQueryParams, endpoint);
- }
+ else {
return endpoint;
}
- function getXhrReadyStateChangeHandler(id) {
- return function() {
- if (getXhrOrXdr(id).readyState === 4) {
- onComplete(id);
- }
- };
- }
- function registerForUploadProgress(id) {
- var onProgress = options.onProgress;
- if (onProgress) {
- getXhrOrXdr(id).upload.onprogress = function(e) {
- if (e.lengthComputable) {
- onProgress(id, e.loaded, e.total);
- }
- };
- }
- }
- function getXdrLoadHandler(id) {
- return function() {
- onComplete(id);
- };
- }
- function getXdrErrorHandler(id) {
- return function() {
- onComplete(id, true);
- };
- }
- function setHeaders(id) {
- var xhr = getXhrOrXdr(id), customHeaders = options.customHeaders, onDemandHeaders = requestData[id].additionalHeaders || {}, method = options.method, allHeaders = {};
- if (!isXdr(xhr)) {
- options.acceptHeader && xhr.setRequestHeader("Accept", options.acceptHeader);
- if (options.allowXRequestedWithAndCacheControl) {
- if (!options.cors.expected || (!isSimpleMethod() || containsNonSimpleHeaders(customHeaders))) {
- xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
- xhr.setRequestHeader("Cache-Control", "no-cache");
- }
- }
- if (options.contentType && (method === "POST" || method === "PUT")) {
- xhr.setRequestHeader("Content-Type", options.contentType);
- }
- qq.extend(allHeaders, qq.isFunction(customHeaders) ? customHeaders(id) : customHeaders);
- qq.extend(allHeaders, onDemandHeaders);
- qq.each(allHeaders, function(name, val) {
- xhr.setRequestHeader(name, val);
- });
- }
- }
- function isResponseSuccessful(responseCode) {
- return qq.indexOf(options.successfulResponseCodes[options.method], responseCode) >= 0;
- }
- function prepareToSend(id, optXhr, addToPath, additionalParams, additionalQueryParams, additionalHeaders, payload) {
- requestData[id] = {
- addToPath: addToPath,
- additionalParams: additionalParams,
- additionalQueryParams: additionalQueryParams,
- additionalHeaders: additionalHeaders,
- payload: payload
- };
- var len = queue.push(id);
- if (len <= options.maxConnections) {
- return sendRequest(id, optXhr);
- }
- }
- shouldParamsBeInQueryString = options.method === "GET" || options.method === "DELETE";
- qq.extend(this, {
- initTransport: function(id) {
- var path, params, headers, payload, cacheBuster, additionalQueryParams;
- return {
- withPath: function(appendToPath) {
- path = appendToPath;
- return this;
- },
- withParams: function(additionalParams) {
- params = additionalParams;
- return this;
- },
- withQueryParams: function(_additionalQueryParams_) {
- additionalQueryParams = _additionalQueryParams_;
- return this;
- },
- withHeaders: function(additionalHeaders) {
- headers = additionalHeaders;
- return this;
- },
- withPayload: function(thePayload) {
- payload = thePayload;
- return this;
- },
- withCacheBuster: function() {
- cacheBuster = true;
- return this;
- },
- send: function(optXhr) {
- if (cacheBuster && qq.indexOf([ "GET", "DELETE" ], options.method) >= 0) {
- params.qqtimestamp = new Date().getTime();
- }
- return prepareToSend(id, optXhr, path, params, additionalQueryParams, headers, payload);
- }
- };
- },
- canceled: function(id) {
- dequeue(id);
- }
- });
- };
- qq.UploadHandler = function(spec) {
- "use strict";
- var proxy = spec.proxy, fileState = {}, onCancel = proxy.onCancel, getName = proxy.getName;
- qq.extend(this, {
- add: function(id, fileItem) {
- fileState[id] = fileItem;
- fileState[id].temp = {};
- },
- cancel: function(id) {
- var self = this, cancelFinalizationEffort = new qq.Promise(), onCancelRetVal = onCancel(id, getName(id), cancelFinalizationEffort);
- onCancelRetVal.then(function() {
- if (self.isValid(id)) {
- fileState[id].canceled = true;
- self.expunge(id);
- }
- cancelFinalizationEffort.success();
- });
- },
- expunge: function(id) {
- delete fileState[id];
- },
- getThirdPartyFileId: function(id) {
- return fileState[id].key;
- },
- isValid: function(id) {
- return fileState[id] !== undefined;
- },
- reset: function() {
- fileState = {};
- },
- _getFileState: function(id) {
- return fileState[id];
- },
- _setThirdPartyFileId: function(id, thirdPartyFileId) {
- fileState[id].key = thirdPartyFileId;
- },
- _wasCanceled: function(id) {
- return !!fileState[id].canceled;
- }
- });
- };
- qq.UploadHandlerController = function(o, namespace) {
- "use strict";
- var controller = this, chunkingPossible = false, concurrentChunkingPossible = false, chunking, preventRetryResponse, log, handler, options = {
- paramsStore: {},
- maxConnections: 3,
- chunking: {
- enabled: false,
- multiple: {
- enabled: false
- }
- },
- log: function(str, level) {},
- onProgress: function(id, fileName, loaded, total) {},
- onComplete: function(id, fileName, response, xhr) {},
- onCancel: function(id, fileName) {},
- onUploadPrep: function(id) {},
- onUpload: function(id, fileName) {},
- onUploadChunk: function(id, fileName, chunkData) {},
- onUploadChunkSuccess: function(id, chunkData, response, xhr) {},
- onAutoRetry: function(id, fileName, response, xhr) {},
- onResume: function(id, fileName, chunkData) {},
- onUuidChanged: function(id, newUuid) {},
- getName: function(id) {},
- setSize: function(id, newSize) {},
- isQueued: function(id) {},
- getIdsInProxyGroup: function(id) {},
- getIdsInBatch: function(id) {}
- }, chunked = {
- done: function(id, chunkIdx, response, xhr) {
- var chunkData = handler._getChunkData(id, chunkIdx);
- handler._getFileState(id).attemptingResume = false;
- delete handler._getFileState(id).temp.chunkProgress[chunkIdx];
- handler._getFileState(id).loaded += chunkData.size;
- options.onUploadChunkSuccess(id, handler._getChunkDataForCallback(chunkData), response, xhr);
- },
- finalize: function(id) {
- var size = options.getSize(id), name = options.getName(id);
- log("All chunks have been uploaded for " + id + " - finalizing....");
- handler.finalizeChunks(id).then(function(response, xhr) {
- log("Finalize successful for " + id);
- var normaizedResponse = upload.normalizeResponse(response, true);
- options.onProgress(id, name, size, size);
- handler._maybeDeletePersistedChunkData(id);
- upload.cleanup(id, normaizedResponse, xhr);
- }, function(response, xhr) {
- var normaizedResponse = upload.normalizeResponse(response, false);
- log("Problem finalizing chunks for file ID " + id + " - " + normaizedResponse.error, "error");
- if (normaizedResponse.reset) {
- chunked.reset(id);
- }
- if (!options.onAutoRetry(id, name, normaizedResponse, xhr)) {
- upload.cleanup(id, normaizedResponse, xhr);
- }
- });
- },
- handleFailure: function(chunkIdx, id, response, xhr) {
- var name = options.getName(id);
- log("Chunked upload request failed for " + id + ", chunk " + chunkIdx);
- handler.clearCachedChunk(id, chunkIdx);
- var responseToReport = upload.normalizeResponse(response, false), inProgressIdx;
- if (responseToReport.reset) {
- chunked.reset(id);
- } else {
- inProgressIdx = qq.indexOf(handler._getFileState(id).chunking.inProgress, chunkIdx);
- if (inProgressIdx >= 0) {
- handler._getFileState(id).chunking.inProgress.splice(inProgressIdx, 1);
- handler._getFileState(id).chunking.remaining.unshift(chunkIdx);
- }
- }
- if (!handler._getFileState(id).temp.ignoreFailure) {
- if (concurrentChunkingPossible) {
- handler._getFileState(id).temp.ignoreFailure = true;
- log(qq.format("Going to attempt to abort these chunks: {}. These are currently in-progress: {}.", JSON.stringify(Object.keys(handler._getXhrs(id))), JSON.stringify(handler._getFileState(id).chunking.inProgress)));
- qq.each(handler._getXhrs(id), function(ckid, ckXhr) {
- log(qq.format("Attempting to abort file {}.{}. XHR readyState {}. ", id, ckid, ckXhr.readyState));
- ckXhr.abort();
- ckXhr._cancelled = true;
- });
- handler.moveInProgressToRemaining(id);
- connectionManager.free(id, true);
- }
- if (!options.onAutoRetry(id, name, responseToReport, xhr)) {
- upload.cleanup(id, responseToReport, xhr);
- }
- }
- },
- hasMoreParts: function(id) {
- return !!handler._getFileState(id).chunking.remaining.length;
- },
- nextPart: function(id) {
- var nextIdx = handler._getFileState(id).chunking.remaining.shift();
- if (nextIdx >= handler._getTotalChunks(id)) {
- nextIdx = null;
- }
- return nextIdx;
- },
- reset: function(id) {
- log("Server or callback has ordered chunking effort to be restarted on next attempt for item ID " + id, "error");
- handler._maybeDeletePersistedChunkData(id);
- handler.reevaluateChunking(id);
- handler._getFileState(id).loaded = 0;
- },
- sendNext: function(id) {
- var size = options.getSize(id), name = options.getName(id), chunkIdx = chunked.nextPart(id), chunkData = handler._getChunkData(id, chunkIdx), resuming = handler._getFileState(id).attemptingResume, inProgressChunks = handler._getFileState(id).chunking.inProgress || [];
- if (handler._getFileState(id).loaded == null) {
- handler._getFileState(id).loaded = 0;
- }
- if (resuming && options.onResume(id, name, chunkData) === false) {
- chunked.reset(id);
- chunkIdx = chunked.nextPart(id);
- chunkData = handler._getChunkData(id, chunkIdx);
- resuming = false;
- }
- if (chunkIdx == null && inProgressChunks.length === 0) {
- chunked.finalize(id);
- } else {
- log(qq.format("Sending chunked upload request for item {}.{}, bytes {}-{} of {}.", id, chunkIdx, chunkData.start + 1, chunkData.end, size));
- options.onUploadChunk(id, name, handler._getChunkDataForCallback(chunkData));
- inProgressChunks.push(chunkIdx);
- handler._getFileState(id).chunking.inProgress = inProgressChunks;
- if (concurrentChunkingPossible) {
- connectionManager.open(id, chunkIdx);
- }
- if (concurrentChunkingPossible && connectionManager.available() && handler._getFileState(id).chunking.remaining.length) {
- chunked.sendNext(id);
- }
- if (chunkData.blob.size === 0) {
- log(qq.format("Chunk {} for file {} will not be uploaded, zero sized chunk.", chunkIdx, id), "error");
- chunked.handleFailure(chunkIdx, id, "File is no longer available", null);
- } else {
- handler.uploadChunk(id, chunkIdx, resuming).then(function success(response, xhr) {
- log("Chunked upload request succeeded for " + id + ", chunk " + chunkIdx);
- handler.clearCachedChunk(id, chunkIdx);
- var inProgressChunks = handler._getFileState(id).chunking.inProgress || [], responseToReport = upload.normalizeResponse(response, true), inProgressChunkIdx = qq.indexOf(inProgressChunks, chunkIdx);
- log(qq.format("Chunk {} for file {} uploaded successfully.", chunkIdx, id));
- chunked.done(id, chunkIdx, responseToReport, xhr);
- if (inProgressChunkIdx >= 0) {
- inProgressChunks.splice(inProgressChunkIdx, 1);
- }
- handler._maybePersistChunkedState(id);
- if (!chunked.hasMoreParts(id) && inProgressChunks.length === 0) {
- chunked.finalize(id);
- } else if (chunked.hasMoreParts(id)) {
- chunked.sendNext(id);
- } else {
- log(qq.format("File ID {} has no more chunks to send and these chunk indexes are still marked as in-progress: {}", id, JSON.stringify(inProgressChunks)));
- }
- }, function failure(response, xhr) {
- chunked.handleFailure(chunkIdx, id, response, xhr);
- }).done(function() {
- handler.clearXhr(id, chunkIdx);
- });
- }
- }
- }
- }, connectionManager = {
- _open: [],
- _openChunks: {},
- _waiting: [],
- available: function() {
- var max = options.maxConnections, openChunkEntriesCount = 0, openChunksCount = 0;
- qq.each(connectionManager._openChunks, function(fileId, openChunkIndexes) {
- openChunkEntriesCount++;
- openChunksCount += openChunkIndexes.length;
- });
- return max - (connectionManager._open.length - openChunkEntriesCount + openChunksCount);
- },
- free: function(id, dontAllowNext) {
- var allowNext = !dontAllowNext, waitingIndex = qq.indexOf(connectionManager._waiting, id), connectionsIndex = qq.indexOf(connectionManager._open, id), nextId;
- delete connectionManager._openChunks[id];
- if (upload.getProxyOrBlob(id) instanceof qq.BlobProxy) {
- log("Generated blob upload has ended for " + id + ", disposing generated blob.");
- delete handler._getFileState(id).file;
- }
- if (waitingIndex >= 0) {
- connectionManager._waiting.splice(waitingIndex, 1);
- } else if (allowNext && connectionsIndex >= 0) {
- connectionManager._open.splice(connectionsIndex, 1);
- nextId = connectionManager._waiting.shift();
- if (nextId >= 0) {
- connectionManager._open.push(nextId);
- upload.start(nextId);
- }
- }
- },
- getWaitingOrConnected: function() {
- var waitingOrConnected = [];
- qq.each(connectionManager._openChunks, function(fileId, chunks) {
- if (chunks && chunks.length) {
- waitingOrConnected.push(parseInt(fileId));
- }
- });
- qq.each(connectionManager._open, function(idx, fileId) {
- if (!connectionManager._openChunks[fileId]) {
- waitingOrConnected.push(parseInt(fileId));
- }
- });
- waitingOrConnected = waitingOrConnected.concat(connectionManager._waiting);
- return waitingOrConnected;
- },
- isUsingConnection: function(id) {
- return qq.indexOf(connectionManager._open, id) >= 0;
- },
- open: function(id, chunkIdx) {
- if (chunkIdx == null) {
- connectionManager._waiting.push(id);
- }
- if (connectionManager.available()) {
- if (chunkIdx == null) {
- connectionManager._waiting.pop();
- connectionManager._open.push(id);
- } else {
- (function() {
- var openChunksEntry = connectionManager._openChunks[id] || [];
- openChunksEntry.push(chunkIdx);
- connectionManager._openChunks[id] = openChunksEntry;
- })();
- }
- return true;
- }
- return false;
- },
- reset: function() {
- connectionManager._waiting = [];
- connectionManager._open = [];
- }
- }, simple = {
- send: function(id, name) {
- handler._getFileState(id).loaded = 0;
- log("Sending simple upload request for " + id);
- handler.uploadFile(id).then(function(response, optXhr) {
- log("Simple upload request succeeded for " + id);
- var responseToReport = upload.normalizeResponse(response, true), size = options.getSize(id);
- options.onProgress(id, name, size, size);
- upload.maybeNewUuid(id, responseToReport);
- upload.cleanup(id, responseToReport, optXhr);
- }, function(response, optXhr) {
- log("Simple upload request failed for " + id);
- var responseToReport = upload.normalizeResponse(response, false);
- if (!options.onAutoRetry(id, name, responseToReport, optXhr)) {
- upload.cleanup(id, responseToReport, optXhr);
- }
- });
- }
- }, upload = {
- cancel: function(id) {
- log("Cancelling " + id);
- options.paramsStore.remove(id);
- connectionManager.free(id);
- },
- cleanup: function(id, response, optXhr) {
- var name = options.getName(id);
- options.onComplete(id, name, response, optXhr);
- if (handler._getFileState(id)) {
- handler._clearXhrs && handler._clearXhrs(id);
- }
- connectionManager.free(id);
- },
- getProxyOrBlob: function(id) {
- return handler.getProxy && handler.getProxy(id) || handler.getFile && handler.getFile(id);
- },
- initHandler: function() {
- var handlerType = namespace ? qq[namespace] : qq.traditional, handlerModuleSubtype = qq.supportedFeatures.ajaxUploading ? "Xhr" : "Form";
- handler = new handlerType[handlerModuleSubtype + "UploadHandler"](options, {
- getDataByUuid: options.getDataByUuid,
- getName: options.getName,
- getSize: options.getSize,
- getUuid: options.getUuid,
- log: log,
- onCancel: options.onCancel,
- onProgress: options.onProgress,
- onUuidChanged: options.onUuidChanged
- });
- if (handler._removeExpiredChunkingRecords) {
- handler._removeExpiredChunkingRecords();
- }
- },
- isDeferredEligibleForUpload: function(id) {
- return options.isQueued(id);
- },
- maybeDefer: function(id, blob) {
- if (blob && !handler.getFile(id) && blob instanceof qq.BlobProxy) {
- options.onUploadPrep(id);
- log("Attempting to generate a blob on-demand for " + id);
- blob.create().then(function(generatedBlob) {
- log("Generated an on-demand blob for " + id);
- handler.updateBlob(id, generatedBlob);
- options.setSize(id, generatedBlob.size);
- handler.reevaluateChunking(id);
- upload.maybeSendDeferredFiles(id);
- }, function(errorMessage) {
- var errorResponse = {};
- if (errorMessage) {
- errorResponse.error = errorMessage;
- }
- log(qq.format("Failed to generate blob for ID {}. Error message: {}.", id, errorMessage), "error");
- options.onComplete(id, options.getName(id), qq.extend(errorResponse, preventRetryResponse), null);
- upload.maybeSendDeferredFiles(id);
- connectionManager.free(id);
- });
- } else {
- return upload.maybeSendDeferredFiles(id);
- }
- return false;
- },
- maybeSendDeferredFiles: function(id) {
- var idsInGroup = options.getIdsInProxyGroup(id), uploadedThisId = false;
- if (idsInGroup && idsInGroup.length) {
- log("Maybe ready to upload proxy group file " + id);
- qq.each(idsInGroup, function(idx, idInGroup) {
- if (upload.isDeferredEligibleForUpload(idInGroup) && !!handler.getFile(idInGroup)) {
- uploadedThisId = idInGroup === id;
- upload.now(idInGroup);
- } else if (upload.isDeferredEligibleForUpload(idInGroup)) {
- return false;
- }
- });
- } else {
- uploadedThisId = true;
- upload.now(id);
- }
- return uploadedThisId;
- },
- maybeNewUuid: function(id, response) {
- if (response.newUuid !== undefined) {
- options.onUuidChanged(id, response.newUuid);
- }
- },
- normalizeResponse: function(originalResponse, successful) {
- var response = originalResponse;
- if (!qq.isObject(originalResponse)) {
- response = {};
- if (qq.isString(originalResponse) && !successful) {
- response.error = originalResponse;
- }
- }
- response.success = successful;
- return response;
- },
- now: function(id) {
- var name = options.getName(id);
- if (!controller.isValid(id)) {
- throw new qq.Error(id + " is not a valid file ID to upload!");
- }
- options.onUpload(id, name);
- if (chunkingPossible && handler._shouldChunkThisFile(id)) {
- chunked.sendNext(id);
- } else {
- simple.send(id, name);
- }
- },
- start: function(id) {
- var blobToUpload = upload.getProxyOrBlob(id);
- if (blobToUpload) {
- return upload.maybeDefer(id, blobToUpload);
- } else {
- upload.now(id);
- return true;
- }
+ }
+
+ function getReadyStateChangeHandler(id) {
+ var xhr = requestState[id].xhr;
+
+ return function() {
+ if (xhr.readyState === 4) {
+ onComplete(id, xhr);
}
};
- qq.extend(this, {
- add: function(id, file) {
- handler.add.apply(this, arguments);
- },
- upload: function(id) {
- if (connectionManager.open(id)) {
- return upload.start(id);
- }
- return false;
- },
- retry: function(id) {
- if (concurrentChunkingPossible) {
- handler._getFileState(id).temp.ignoreFailure = false;
- }
- if (connectionManager.isUsingConnection(id)) {
- return upload.start(id);
- } else {
- return controller.upload(id);
- }
- },
- cancel: function(id) {
- var cancelRetVal = handler.cancel(id);
- if (qq.isGenericPromise(cancelRetVal)) {
- cancelRetVal.then(function() {
- upload.cancel(id);
- });
- } else if (cancelRetVal !== false) {
- upload.cancel(id);
- }
- },
- cancelAll: function() {
- var waitingOrConnected = connectionManager.getWaitingOrConnected(), i;
- if (waitingOrConnected.length) {
- for (i = waitingOrConnected.length - 1; i >= 0; i--) {
- controller.cancel(waitingOrConnected[i]);
- }
- }
- connectionManager.reset();
- },
- getFile: function(id) {
- if (handler.getProxy && handler.getProxy(id)) {
- return handler.getProxy(id).referenceBlob;
- }
- return handler.getFile && handler.getFile(id);
- },
- isProxied: function(id) {
- return !!(handler.getProxy && handler.getProxy(id));
- },
- getInput: function(id) {
- if (handler.getInput) {
- return handler.getInput(id);
- }
- },
- reset: function() {
- log("Resetting upload handler");
- controller.cancelAll();
- connectionManager.reset();
- handler.reset();
- },
- expunge: function(id) {
- if (controller.isValid(id)) {
- return handler.expunge(id);
- }
- },
- isValid: function(id) {
- return handler.isValid(id);
- },
- getResumableFilesData: function() {
- if (handler.getResumableFilesData) {
- return handler.getResumableFilesData();
- }
- return [];
- },
- getThirdPartyFileId: function(id) {
- if (controller.isValid(id)) {
- return handler.getThirdPartyFileId(id);
- }
- },
- pause: function(id) {
- if (controller.isResumable(id) && handler.pause && controller.isValid(id) && handler.pause(id)) {
- connectionManager.free(id);
- handler.moveInProgressToRemaining(id);
- return true;
- }
- return false;
- },
- isResumable: function(id) {
- return !!handler.isResumable && handler.isResumable(id);
- }
+ }
+
+ function setHeaders(id) {
+ var xhr = requestState[id].xhr,
+ customHeaders = options.customHeaders;
+
+ xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+ xhr.setRequestHeader("Cache-Control", "no-cache");
+
+ qq.each(customHeaders, function(name, val) {
+ xhr.setRequestHeader(name, val);
});
- qq.extend(options, o);
- log = options.log;
- chunkingPossible = options.chunking.enabled && qq.supportedFeatures.chunking;
- concurrentChunkingPossible = chunkingPossible && options.chunking.concurrent.enabled;
- preventRetryResponse = function() {
- var response = {};
- response[options.preventRetryParam] = true;
- return response;
- }();
- upload.initHandler();
- };
- qq.WindowReceiveMessage = function(o) {
- "use strict";
- var options = {
- log: function(message, level) {}
- }, callbackWrapperDetachers = {};
- qq.extend(options, o);
- qq.extend(this, {
- receiveMessage: function(id, callback) {
- var onMessageCallbackWrapper = function(event) {
- callback(event.data);
- };
- if (window.postMessage) {
- callbackWrapperDetachers[id] = qq(window).attach("message", onMessageCallbackWrapper);
- } else {
- log("iframe message passing not supported in this browser!", "error");
- }
- },
- stopReceivingMessages: function(id) {
- if (window.postMessage) {
- var detacher = callbackWrapperDetachers[id];
- if (detacher) {
- detacher();
- }
- }
- }
- });
- };
- qq.FormUploadHandler = function(spec) {
- "use strict";
- var options = spec.options, handler = this, proxy = spec.proxy, formHandlerInstanceId = qq.getUniqueId(), onloadCallbacks = {}, detachLoadEvents = {}, postMessageCallbackTimers = {}, isCors = options.isCors, inputName = options.inputName, getUuid = proxy.getUuid, log = proxy.log, corsMessageReceiver = new qq.WindowReceiveMessage({
- log: log
- });
- function expungeFile(id) {
- delete detachLoadEvents[id];
- if (isCors) {
- clearTimeout(postMessageCallbackTimers[id]);
- delete postMessageCallbackTimers[id];
- corsMessageReceiver.stopReceivingMessages(id);
- }
- var iframe = document.getElementById(handler._getIframeName(id));
- if (iframe) {
- iframe.setAttribute("src", "javascript:false;");
- qq(iframe).remove();
- }
+ }
+
+ function cancelRequest(id) {
+ var xhr = requestState[id].xhr,
+ method = getMethod();
+
+ if (xhr) {
+ xhr.onreadystatechange = null;
+ xhr.abort();
+ dequeue(id);
+
+ log('Cancelled ' + method + " for " + id);
+ options.onCancel(id);
+
+ return true;
}
- function getFileIdForIframeName(iframeName) {
- return iframeName.split("_")[0];
+
+ return false;
+ }
+
+ function isResponseSuccessful(responseCode) {
+ return qq.indexOf(options.successfulResponseCodes, responseCode) >= 0;
+ }
+
+ function getMethod() {
+ if (options.demoMode) {
+ return "GET";
}
- function initIframeForUpload(name) {
- var iframe = qq.toElement("");
- iframe.setAttribute("id", name);
- iframe.style.display = "none";
- document.body.appendChild(iframe);
- return iframe;
- }
- function registerPostMessageCallback(iframe, callback) {
- var iframeName = iframe.id, fileId = getFileIdForIframeName(iframeName), uuid = getUuid(fileId);
- onloadCallbacks[uuid] = callback;
- detachLoadEvents[fileId] = qq(iframe).attach("load", function() {
- if (handler.getInput(fileId)) {
- log("Received iframe load event for CORS upload request (iframe name " + iframeName + ")");
- postMessageCallbackTimers[iframeName] = setTimeout(function() {
- var errorMessage = "No valid message received from loaded iframe for iframe name " + iframeName;
- log(errorMessage, "error");
- callback({
- error: errorMessage
- });
- }, 1e3);
- }
- });
- corsMessageReceiver.receiveMessage(iframeName, function(message) {
- log("Received the following window message: '" + message + "'");
- var fileId = getFileIdForIframeName(iframeName), response = handler._parseJsonResponse(message), uuid = response.uuid, onloadCallback;
- if (uuid && onloadCallbacks[uuid]) {
- log("Handling response for iframe name " + iframeName);
- clearTimeout(postMessageCallbackTimers[iframeName]);
- delete postMessageCallbackTimers[iframeName];
- handler._detachLoadEvent(iframeName);
- onloadCallback = onloadCallbacks[uuid];
- delete onloadCallbacks[uuid];
- corsMessageReceiver.stopReceivingMessages(iframeName);
- onloadCallback(response);
- } else if (!uuid) {
- log("'" + message + "' does not contain a UUID - ignoring.");
- }
- });
- }
- qq.extend(this, new qq.UploadHandler(spec));
- qq.override(this, function(super_) {
- return {
- add: function(id, fileInput) {
- super_.add(id, {
- input: fileInput
- });
- fileInput.setAttribute("name", inputName);
- if (fileInput.parentNode) {
- qq(fileInput).remove();
- }
- },
- expunge: function(id) {
- expungeFile(id);
- super_.expunge(id);
- },
- isValid: function(id) {
- return super_.isValid(id) && handler._getFileState(id).input !== undefined;
- }
+
+ return options.method;
+ }
+
+
+ return {
+ send: function(id, addToPath) {
+ requestState[id] = {
+ addToPath: addToPath
};
- });
- qq.extend(this, {
- getInput: function(id) {
- return handler._getFileState(id).input;
- },
- _attachLoadEvent: function(iframe, callback) {
- var responseDescriptor;
- if (isCors) {
- registerPostMessageCallback(iframe, callback);
- } else {
- detachLoadEvents[iframe.id] = qq(iframe).attach("load", function() {
- log("Received response for " + iframe.id);
- if (!iframe.parentNode) {
- return;
- }
- try {
- if (iframe.contentDocument && iframe.contentDocument.body && iframe.contentDocument.body.innerHTML == "false") {
- return;
- }
- } catch (error) {
- log("Error when attempting to access iframe during handling of upload response (" + error.message + ")", "error");
- responseDescriptor = {
- success: false
- };
- }
- callback(responseDescriptor);
- });
- }
- },
- _createIframe: function(id) {
- var iframeName = handler._getIframeName(id);
- return initIframeForUpload(iframeName);
- },
- _detachLoadEvent: function(id) {
- if (detachLoadEvents[id] !== undefined) {
- detachLoadEvents[id]();
- delete detachLoadEvents[id];
- }
- },
- _getIframeName: function(fileId) {
- return fileId + "_" + formHandlerInstanceId;
- },
- _initFormForUpload: function(spec) {
- var method = spec.method, endpoint = spec.endpoint, params = spec.params, paramsInBody = spec.paramsInBody, targetName = spec.targetName, form = qq.toElement(""), url = endpoint;
- if (paramsInBody) {
- qq.obj2Inputs(params, form);
- } else {
- url = qq.obj2url(params, endpoint);
- }
- form.setAttribute("action", url);
- form.setAttribute("target", targetName);
- form.style.display = "none";
- document.body.appendChild(form);
- return form;
- },
- _parseJsonResponse: function(innerHtmlOrMessage) {
- var response = {};
- try {
- response = qq.parseJson(innerHtmlOrMessage);
- } catch (error) {
- log("Error when attempting to parse iframe upload response (" + error.message + ")", "error");
- }
- return response;
+
+ var len = queue.push(id);
+
+ // if too many active connections, wait...
+ if (len <= options.maxConnections){
+ sendRequest(id);
}
- });
- };
- qq.XhrUploadHandler = function(spec) {
- "use strict";
- var handler = this, namespace = spec.options.namespace, proxy = spec.proxy, chunking = spec.options.chunking, resume = spec.options.resume, chunkFiles = chunking && spec.options.chunking.enabled && qq.supportedFeatures.chunking, resumeEnabled = resume && spec.options.resume.enabled && chunkFiles && qq.supportedFeatures.resume, getName = proxy.getName, getSize = proxy.getSize, getUuid = proxy.getUuid, getEndpoint = proxy.getEndpoint, getDataByUuid = proxy.getDataByUuid, onUuidChanged = proxy.onUuidChanged, onProgress = proxy.onProgress, log = proxy.log;
- function abort(id) {
- qq.each(handler._getXhrs(id), function(xhrId, xhr) {
- var ajaxRequester = handler._getAjaxRequester(id, xhrId);
- xhr.onreadystatechange = null;
- xhr.upload.onprogress = null;
- xhr.abort();
- ajaxRequester && ajaxRequester.canceled && ajaxRequester.canceled(id);
- });
+ },
+ cancel: function(id) {
+ return cancelRequest(id);
}
- qq.extend(this, new qq.UploadHandler(spec));
- qq.override(this, function(super_) {
- return {
- add: function(id, blobOrProxy) {
- if (qq.isFile(blobOrProxy) || qq.isBlob(blobOrProxy)) {
- super_.add(id, {
- file: blobOrProxy
- });
- } else if (blobOrProxy instanceof qq.BlobProxy) {
- super_.add(id, {
- proxy: blobOrProxy
- });
- } else {
- throw new Error("Passed obj is not a File, Blob, or proxy");
- }
- handler._initTempState(id);
- resumeEnabled && handler._maybePrepareForResume(id);
- },
- expunge: function(id) {
- abort(id);
- handler._maybeDeletePersistedChunkData(id);
- handler._clearXhrs(id);
- super_.expunge(id);
- }
- };
- });
- qq.extend(this, {
- clearCachedChunk: function(id, chunkIdx) {
- delete handler._getFileState(id).temp.cachedChunks[chunkIdx];
- },
- clearXhr: function(id, chunkIdx) {
- var tempState = handler._getFileState(id).temp;
- if (tempState.xhrs) {
- delete tempState.xhrs[chunkIdx];
- }
- if (tempState.ajaxRequesters) {
- delete tempState.ajaxRequesters[chunkIdx];
- }
- },
- finalizeChunks: function(id, responseParser) {
- var lastChunkIdx = handler._getTotalChunks(id) - 1, xhr = handler._getXhr(id, lastChunkIdx);
- if (responseParser) {
- return new qq.Promise().success(responseParser(xhr), xhr);
- }
- return new qq.Promise().success({}, xhr);
- },
- getFile: function(id) {
- return handler.isValid(id) && handler._getFileState(id).file;
- },
- getProxy: function(id) {
- return handler.isValid(id) && handler._getFileState(id).proxy;
- },
- getResumableFilesData: function() {
- var resumableFilesData = [];
- handler._iterateResumeRecords(function(key, uploadData) {
- handler.moveInProgressToRemaining(null, uploadData.chunking.inProgress, uploadData.chunking.remaining);
- var data = {
- name: uploadData.name,
- remaining: uploadData.chunking.remaining,
- size: uploadData.size,
- uuid: uploadData.uuid
- };
- if (uploadData.key) {
- data.key = uploadData.key;
- }
- resumableFilesData.push(data);
- });
- return resumableFilesData;
- },
- isResumable: function(id) {
- return !!chunking && handler.isValid(id) && !handler._getFileState(id).notResumable;
- },
- moveInProgressToRemaining: function(id, optInProgress, optRemaining) {
- var inProgress = optInProgress || handler._getFileState(id).chunking.inProgress, remaining = optRemaining || handler._getFileState(id).chunking.remaining;
- if (inProgress) {
- log(qq.format("Moving these chunks from in-progress {}, to remaining.", JSON.stringify(inProgress)));
- inProgress.reverse();
- qq.each(inProgress, function(idx, chunkIdx) {
- remaining.unshift(chunkIdx);
- });
- inProgress.length = 0;
- }
- },
- pause: function(id) {
- if (handler.isValid(id)) {
- log(qq.format("Aborting XHR upload for {} '{}' due to pause instruction.", id, getName(id)));
- handler._getFileState(id).paused = true;
- abort(id);
- return true;
- }
- },
- reevaluateChunking: function(id) {
- if (chunking && handler.isValid(id)) {
- var state = handler._getFileState(id), totalChunks, i;
- delete state.chunking;
- state.chunking = {};
- totalChunks = handler._getTotalChunks(id);
- if (totalChunks > 1 || chunking.mandatory) {
- state.chunking.enabled = true;
- state.chunking.parts = totalChunks;
- state.chunking.remaining = [];
- for (i = 0; i < totalChunks; i++) {
- state.chunking.remaining.push(i);
- }
- handler._initTempState(id);
- } else {
- state.chunking.enabled = false;
- }
- }
- },
- updateBlob: function(id, newBlob) {
- if (handler.isValid(id)) {
- handler._getFileState(id).file = newBlob;
- }
- },
- _clearXhrs: function(id) {
- var tempState = handler._getFileState(id).temp;
- qq.each(tempState.ajaxRequesters, function(chunkId) {
- delete tempState.ajaxRequesters[chunkId];
- });
- qq.each(tempState.xhrs, function(chunkId) {
- delete tempState.xhrs[chunkId];
- });
- },
- _createXhr: function(id, optChunkIdx) {
- return handler._registerXhr(id, optChunkIdx, qq.createXhrInstance());
- },
- _getAjaxRequester: function(id, optChunkIdx) {
- var chunkIdx = optChunkIdx == null ? -1 : optChunkIdx;
- return handler._getFileState(id).temp.ajaxRequesters[chunkIdx];
- },
- _getChunkData: function(id, chunkIndex) {
- var chunkSize = chunking.partSize, fileSize = getSize(id), fileOrBlob = handler.getFile(id), startBytes = chunkSize * chunkIndex, endBytes = startBytes + chunkSize >= fileSize ? fileSize : startBytes + chunkSize, totalChunks = handler._getTotalChunks(id), cachedChunks = this._getFileState(id).temp.cachedChunks, blob = cachedChunks[chunkIndex] || qq.sliceBlob(fileOrBlob, startBytes, endBytes);
- cachedChunks[chunkIndex] = blob;
- return {
- part: chunkIndex,
- start: startBytes,
- end: endBytes,
- count: totalChunks,
- blob: blob,
- size: endBytes - startBytes
- };
- },
- _getChunkDataForCallback: function(chunkData) {
- return {
- partIndex: chunkData.part,
- startByte: chunkData.start + 1,
- endByte: chunkData.end,
- totalParts: chunkData.count
- };
- },
- _getLocalStorageId: function(id) {
- var formatVersion = "5.0", name = getName(id), size = getSize(id), chunkSize = chunking.partSize, endpoint = getEndpoint(id);
- return qq.format("qq{}resume{}-{}-{}-{}-{}", namespace, formatVersion, name, size, chunkSize, endpoint);
- },
- _getMimeType: function(id) {
- return handler.getFile(id).type;
- },
- _getPersistableData: function(id) {
- return handler._getFileState(id).chunking;
- },
- _getTotalChunks: function(id) {
- if (chunking) {
- var fileSize = getSize(id), chunkSize = chunking.partSize;
- return Math.ceil(fileSize / chunkSize);
- }
- },
- _getXhr: function(id, optChunkIdx) {
- var chunkIdx = optChunkIdx == null ? -1 : optChunkIdx;
- return handler._getFileState(id).temp.xhrs[chunkIdx];
- },
- _getXhrs: function(id) {
- return handler._getFileState(id).temp.xhrs;
- },
- _iterateResumeRecords: function(callback) {
- if (resumeEnabled) {
- qq.each(localStorage, function(key, item) {
- if (key.indexOf(qq.format("qq{}resume", namespace)) === 0) {
- var uploadData = JSON.parse(item);
- callback(key, uploadData);
- }
- });
- }
- },
- _initTempState: function(id) {
- handler._getFileState(id).temp = {
- ajaxRequesters: {},
- chunkProgress: {},
- xhrs: {},
- cachedChunks: {}
- };
- },
- _markNotResumable: function(id) {
- handler._getFileState(id).notResumable = true;
- },
- _maybeDeletePersistedChunkData: function(id) {
- var localStorageId;
- if (resumeEnabled && handler.isResumable(id)) {
- localStorageId = handler._getLocalStorageId(id);
- if (localStorageId && localStorage.getItem(localStorageId)) {
- localStorage.removeItem(localStorageId);
- return true;
- }
- }
- return false;
- },
- _maybePrepareForResume: function(id) {
- var state = handler._getFileState(id), localStorageId, persistedData;
- if (resumeEnabled && state.key === undefined) {
- localStorageId = handler._getLocalStorageId(id);
- persistedData = localStorage.getItem(localStorageId);
- if (persistedData) {
- persistedData = JSON.parse(persistedData);
- if (getDataByUuid(persistedData.uuid)) {
- handler._markNotResumable(id);
- } else {
- log(qq.format("Identified file with ID {} and name of {} as resumable.", id, getName(id)));
- onUuidChanged(id, persistedData.uuid);
- state.key = persistedData.key;
- state.chunking = persistedData.chunking;
- state.loaded = persistedData.loaded;
- state.attemptingResume = true;
- handler.moveInProgressToRemaining(id);
- }
- }
- }
- },
- _maybePersistChunkedState: function(id) {
- var state = handler._getFileState(id), localStorageId, persistedData;
- if (resumeEnabled && handler.isResumable(id)) {
- localStorageId = handler._getLocalStorageId(id);
- persistedData = {
- name: getName(id),
- size: getSize(id),
- uuid: getUuid(id),
- key: state.key,
- chunking: state.chunking,
- loaded: state.loaded,
- lastUpdated: Date.now()
- };
- try {
- localStorage.setItem(localStorageId, JSON.stringify(persistedData));
- } catch (error) {
- log(qq.format("Unable to save resume data for '{}' due to error: '{}'.", id, error.toString()), "warn");
- }
- }
- },
- _registerProgressHandler: function(id, chunkIdx, chunkSize) {
- var xhr = handler._getXhr(id, chunkIdx), name = getName(id), progressCalculator = {
- simple: function(loaded, total) {
- var fileSize = getSize(id);
- if (loaded === total) {
- onProgress(id, name, fileSize, fileSize);
- } else {
- onProgress(id, name, loaded >= fileSize ? fileSize - 1 : loaded, fileSize);
- }
- },
- chunked: function(loaded, total) {
- var chunkProgress = handler._getFileState(id).temp.chunkProgress, totalSuccessfullyLoadedForFile = handler._getFileState(id).loaded, loadedForRequest = loaded, totalForRequest = total, totalFileSize = getSize(id), estActualChunkLoaded = loadedForRequest - (totalForRequest - chunkSize), totalLoadedForFile = totalSuccessfullyLoadedForFile;
- chunkProgress[chunkIdx] = estActualChunkLoaded;
- qq.each(chunkProgress, function(chunkIdx, chunkLoaded) {
- totalLoadedForFile += chunkLoaded;
- });
- onProgress(id, name, totalLoadedForFile, totalFileSize);
- }
- };
- xhr.upload.onprogress = function(e) {
- if (e.lengthComputable) {
- var type = chunkSize == null ? "simple" : "chunked";
- progressCalculator[type](e.loaded, e.total);
- }
- };
- },
- _registerXhr: function(id, optChunkIdx, xhr, optAjaxRequester) {
- var xhrsId = optChunkIdx == null ? -1 : optChunkIdx, tempState = handler._getFileState(id).temp;
- tempState.xhrs = tempState.xhrs || {};
- tempState.ajaxRequesters = tempState.ajaxRequesters || {};
- tempState.xhrs[xhrsId] = xhr;
- if (optAjaxRequester) {
- tempState.ajaxRequesters[xhrsId] = optAjaxRequester;
- }
- return xhr;
- },
- _removeExpiredChunkingRecords: function() {
- var expirationDays = resume.recordsExpireIn;
- handler._iterateResumeRecords(function(key, uploadData) {
- var expirationDate = new Date(uploadData.lastUpdated);
- expirationDate.setDate(expirationDate.getDate() + expirationDays);
- if (expirationDate.getTime() <= Date.now()) {
- log("Removing expired resume record with key " + key);
- localStorage.removeItem(key);
- }
- });
- },
- _shouldChunkThisFile: function(id) {
- var state = handler._getFileState(id);
- if (!state.chunking) {
- handler.reevaluateChunking(id);
- }
- return state.chunking.enabled;
- }
- });
};
- qq.DeleteFileAjaxRequester = function(o) {
- "use strict";
- var requester, options = {
- method: "DELETE",
- uuidParamName: "qquuid",
+};
+/** Generic class for sending non-upload ajax requests and handling the associated responses **/
+/*globals qq, XMLHttpRequest*/
+qq.DeleteFileAjaxRequestor = function(o) {
+ "use strict";
+
+ var requestor,
+ options = {
endpointStore: {},
maxConnections: 3,
- customHeaders: function(id) {
- return {};
- },
+ customHeaders: {},
paramsStore: {},
+ demoMode: false,
cors: {
expected: false,
sendCredentials: false
},
log: function(str, level) {},
onDelete: function(id) {},
- onDeleteComplete: function(id, xhrOrXdr, isError) {}
+ onDeleteComplete: function(id, xhr, isError) {}
};
- qq.extend(options, o);
- function getMandatedParams() {
- if (options.method.toUpperCase() === "POST") {
- return {
- _method: "DELETE"
- };
- }
- return {};
- }
- requester = qq.extend(this, new qq.AjaxRequester({
- acceptHeader: "application/json",
- validMethods: [ "POST", "DELETE" ],
- method: options.method,
- endpointStore: options.endpointStore,
- paramsStore: options.paramsStore,
- mandatedParams: getMandatedParams(),
- maxConnections: options.maxConnections,
- customHeaders: function(id) {
- return options.customHeaders.get(id);
- },
- log: options.log,
- onSend: options.onDelete,
- onComplete: options.onDeleteComplete,
- cors: options.cors
- }));
- qq.extend(this, {
- sendDelete: function(id, uuid, additionalMandatedParams) {
- var additionalOptions = additionalMandatedParams || {};
- options.log("Submitting delete file request for " + id);
- if (options.method === "DELETE") {
- requester.initTransport(id).withPath(uuid).withParams(additionalOptions).send();
- } else {
- additionalOptions[options.uuidParamName] = uuid;
- requester.initTransport(id).withParams(additionalOptions).send();
- }
- }
- });
- };
- (function() {
- function detectSubsampling(img) {
- var iw = img.naturalWidth, ih = img.naturalHeight, canvas = document.createElement("canvas"), ctx;
- if (iw * ih > 1024 * 1024) {
- canvas.width = canvas.height = 1;
- ctx = canvas.getContext("2d");
- ctx.drawImage(img, -iw + 1, 0);
- return ctx.getImageData(0, 0, 1, 1).data[3] === 0;
- } else {
- return false;
- }
- }
- function detectVerticalSquash(img, iw, ih) {
- var canvas = document.createElement("canvas"), sy = 0, ey = ih, py = ih, ctx, data, alpha, ratio;
- canvas.width = 1;
- canvas.height = ih;
- ctx = canvas.getContext("2d");
- ctx.drawImage(img, 0, 0);
- data = ctx.getImageData(0, 0, 1, ih).data;
- while (py > sy) {
- alpha = data[(py - 1) * 4 + 3];
- if (alpha === 0) {
- ey = py;
- } else {
- sy = py;
- }
- py = ey + sy >> 1;
- }
- ratio = py / ih;
- return ratio === 0 ? 1 : ratio;
- }
- function renderImageToDataURL(img, blob, options, doSquash) {
- var canvas = document.createElement("canvas"), mime = options.mime || "image/jpeg", promise = new qq.Promise();
- renderImageToCanvas(img, blob, canvas, options, doSquash).then(function() {
- promise.success(canvas.toDataURL(mime, options.quality || .8));
- });
- return promise;
- }
- function maybeCalculateDownsampledDimensions(spec) {
- var maxPixels = 5241e3;
- if (!qq.ios()) {
- throw new qq.Error("Downsampled dimensions can only be reliably calculated for iOS!");
- }
- if (spec.origHeight * spec.origWidth > maxPixels) {
- return {
- newHeight: Math.round(Math.sqrt(maxPixels * (spec.origHeight / spec.origWidth))),
- newWidth: Math.round(Math.sqrt(maxPixels * (spec.origWidth / spec.origHeight)))
- };
- }
- }
- function renderImageToCanvas(img, blob, canvas, options, doSquash) {
- var iw = img.naturalWidth, ih = img.naturalHeight, width = options.width, height = options.height, ctx = canvas.getContext("2d"), promise = new qq.Promise(), modifiedDimensions;
- ctx.save();
- if (options.resize) {
- return renderImageToCanvasWithCustomResizer({
- blob: blob,
- canvas: canvas,
- image: img,
- imageHeight: ih,
- imageWidth: iw,
- orientation: options.orientation,
- resize: options.resize,
- targetHeight: height,
- targetWidth: width
- });
- }
- if (!qq.supportedFeatures.unlimitedScaledImageSize) {
- modifiedDimensions = maybeCalculateDownsampledDimensions({
- origWidth: width,
- origHeight: height
- });
- if (modifiedDimensions) {
- qq.log(qq.format("Had to reduce dimensions due to device limitations from {}w / {}h to {}w / {}h", width, height, modifiedDimensions.newWidth, modifiedDimensions.newHeight), "warn");
- width = modifiedDimensions.newWidth;
- height = modifiedDimensions.newHeight;
- }
- }
- transformCoordinate(canvas, width, height, options.orientation);
- if (qq.ios()) {
- (function() {
- if (detectSubsampling(img)) {
- iw /= 2;
- ih /= 2;
- }
- var d = 1024, tmpCanvas = document.createElement("canvas"), vertSquashRatio = doSquash ? detectVerticalSquash(img, iw, ih) : 1, dw = Math.ceil(d * width / iw), dh = Math.ceil(d * height / ih / vertSquashRatio), sy = 0, dy = 0, tmpCtx, sx, dx;
- tmpCanvas.width = tmpCanvas.height = d;
- tmpCtx = tmpCanvas.getContext("2d");
- while (sy < ih) {
- sx = 0;
- dx = 0;
- while (sx < iw) {
- tmpCtx.clearRect(0, 0, d, d);
- tmpCtx.drawImage(img, -sx, -sy);
- ctx.drawImage(tmpCanvas, 0, 0, d, d, dx, dy, dw, dh);
- sx += d;
- dx += dw;
- }
- sy += d;
- dy += dh;
- }
- ctx.restore();
- tmpCanvas = tmpCtx = null;
- })();
- } else {
- ctx.drawImage(img, 0, 0, width, height);
- }
- canvas.qqImageRendered && canvas.qqImageRendered();
- promise.success();
- return promise;
- }
- function renderImageToCanvasWithCustomResizer(resizeInfo) {
- var blob = resizeInfo.blob, image = resizeInfo.image, imageHeight = resizeInfo.imageHeight, imageWidth = resizeInfo.imageWidth, orientation = resizeInfo.orientation, promise = new qq.Promise(), resize = resizeInfo.resize, sourceCanvas = document.createElement("canvas"), sourceCanvasContext = sourceCanvas.getContext("2d"), targetCanvas = resizeInfo.canvas, targetHeight = resizeInfo.targetHeight, targetWidth = resizeInfo.targetWidth;
- transformCoordinate(sourceCanvas, imageWidth, imageHeight, orientation);
- targetCanvas.height = targetHeight;
- targetCanvas.width = targetWidth;
- sourceCanvasContext.drawImage(image, 0, 0);
- resize({
- blob: blob,
- height: targetHeight,
- image: image,
- sourceCanvas: sourceCanvas,
- targetCanvas: targetCanvas,
- width: targetWidth
- }).then(function success() {
- targetCanvas.qqImageRendered && targetCanvas.qqImageRendered();
- promise.success();
- }, promise.failure);
- return promise;
- }
- function transformCoordinate(canvas, width, height, orientation) {
- switch (orientation) {
- case 5:
- case 6:
- case 7:
- case 8:
- canvas.width = height;
- canvas.height = width;
- break;
- default:
- canvas.width = width;
- canvas.height = height;
- }
- var ctx = canvas.getContext("2d");
- switch (orientation) {
- case 2:
- ctx.translate(width, 0);
- ctx.scale(-1, 1);
- break;
+ qq.extend(options, o);
- case 3:
- ctx.translate(width, height);
- ctx.rotate(Math.PI);
- break;
-
- case 4:
- ctx.translate(0, height);
- ctx.scale(1, -1);
- break;
-
- case 5:
- ctx.rotate(.5 * Math.PI);
- ctx.scale(1, -1);
- break;
-
- case 6:
- ctx.rotate(.5 * Math.PI);
- ctx.translate(0, -height);
- break;
-
- case 7:
- ctx.rotate(.5 * Math.PI);
- ctx.translate(width, -height);
- ctx.scale(-1, 1);
- break;
-
- case 8:
- ctx.rotate(-.5 * Math.PI);
- ctx.translate(-width, 0);
- break;
-
- default:
- break;
- }
- }
- function MegaPixImage(srcImage, errorCallback) {
- var self = this;
- if (window.Blob && srcImage instanceof Blob) {
- (function() {
- var img = new Image(), URL = window.URL && window.URL.createObjectURL ? window.URL : window.webkitURL && window.webkitURL.createObjectURL ? window.webkitURL : null;
- if (!URL) {
- throw Error("No createObjectURL function found to create blob url");
- }
- img.src = URL.createObjectURL(srcImage);
- self.blob = srcImage;
- srcImage = img;
- })();
- }
- if (!srcImage.naturalWidth && !srcImage.naturalHeight) {
- srcImage.onload = function() {
- var listeners = self.imageLoadListeners;
- if (listeners) {
- self.imageLoadListeners = null;
- setTimeout(function() {
- for (var i = 0, len = listeners.length; i < len; i++) {
- listeners[i]();
- }
- }, 0);
- }
- };
- srcImage.onerror = errorCallback;
- this.imageLoadListeners = [];
- }
- this.srcImage = srcImage;
- }
- MegaPixImage.prototype.render = function(target, options) {
- options = options || {};
- var self = this, imgWidth = this.srcImage.naturalWidth, imgHeight = this.srcImage.naturalHeight, width = options.width, height = options.height, maxWidth = options.maxWidth, maxHeight = options.maxHeight, doSquash = !this.blob || this.blob.type === "image/jpeg", tagName = target.tagName.toLowerCase(), opt;
- if (this.imageLoadListeners) {
- this.imageLoadListeners.push(function() {
- self.render(target, options);
- });
- return;
- }
- if (width && !height) {
- height = imgHeight * width / imgWidth << 0;
- } else if (height && !width) {
- width = imgWidth * height / imgHeight << 0;
- } else {
- width = imgWidth;
- height = imgHeight;
- }
- if (maxWidth && width > maxWidth) {
- width = maxWidth;
- height = imgHeight * width / imgWidth << 0;
- }
- if (maxHeight && height > maxHeight) {
- height = maxHeight;
- width = imgWidth * height / imgHeight << 0;
- }
- opt = {
- width: width,
- height: height
- }, qq.each(options, function(optionsKey, optionsValue) {
- opt[optionsKey] = optionsValue;
- });
- if (tagName === "img") {
- (function() {
- var oldTargetSrc = target.src;
- renderImageToDataURL(self.srcImage, self.blob, opt, doSquash).then(function(dataUri) {
- target.src = dataUri;
- oldTargetSrc === target.src && target.onload();
- });
- })();
- } else if (tagName === "canvas") {
- renderImageToCanvas(this.srcImage, this.blob, target, opt, doSquash);
- }
- if (typeof this.onrender === "function") {
- this.onrender(target);
- }
- };
- qq.MegaPixImage = MegaPixImage;
- })();
- qq.ImageGenerator = function(log) {
- "use strict";
- function isImg(el) {
- return el.tagName.toLowerCase() === "img";
- }
- function isCanvas(el) {
- return el.tagName.toLowerCase() === "canvas";
- }
- function isImgCorsSupported() {
- return new Image().crossOrigin !== undefined;
- }
- function isCanvasSupported() {
- var canvas = document.createElement("canvas");
- return canvas.getContext && canvas.getContext("2d");
- }
- function determineMimeOfFileName(nameWithPath) {
- var pathSegments = nameWithPath.split("/"), name = pathSegments[pathSegments.length - 1].split("?")[0], extension = qq.getExtension(name);
- extension = extension && extension.toLowerCase();
- switch (extension) {
- case "jpeg":
- case "jpg":
- return "image/jpeg";
-
- case "png":
- return "image/png";
-
- case "bmp":
- return "image/bmp";
-
- case "gif":
- return "image/gif";
-
- case "tiff":
- case "tif":
- return "image/tiff";
- }
- }
- function isCrossOrigin(url) {
- var targetAnchor = document.createElement("a"), targetProtocol, targetHostname, targetPort;
- targetAnchor.href = url;
- targetProtocol = targetAnchor.protocol;
- targetPort = targetAnchor.port;
- targetHostname = targetAnchor.hostname;
- if (targetProtocol.toLowerCase() !== window.location.protocol.toLowerCase()) {
- return true;
- }
- if (targetHostname.toLowerCase() !== window.location.hostname.toLowerCase()) {
- return true;
- }
- if (targetPort !== window.location.port && !qq.ie()) {
- return true;
- }
- return false;
- }
- function registerImgLoadListeners(img, promise) {
- img.onload = function() {
- img.onload = null;
- img.onerror = null;
- promise.success(img);
- };
- img.onerror = function() {
- img.onload = null;
- img.onerror = null;
- log("Problem drawing thumbnail!", "error");
- promise.failure(img, "Problem drawing thumbnail!");
- };
- }
- function registerCanvasDrawImageListener(canvas, promise) {
- canvas.qqImageRendered = function() {
- promise.success(canvas);
- };
- }
- function registerThumbnailRenderedListener(imgOrCanvas, promise) {
- var registered = isImg(imgOrCanvas) || isCanvas(imgOrCanvas);
- if (isImg(imgOrCanvas)) {
- registerImgLoadListeners(imgOrCanvas, promise);
- } else if (isCanvas(imgOrCanvas)) {
- registerCanvasDrawImageListener(imgOrCanvas, promise);
- } else {
- promise.failure(imgOrCanvas);
- log(qq.format("Element container of type {} is not supported!", imgOrCanvas.tagName), "error");
- }
- return registered;
- }
- function draw(fileOrBlob, container, options) {
- var drawPreview = new qq.Promise(), identifier = new qq.Identify(fileOrBlob, log), maxSize = options.maxSize, orient = options.orient == null ? true : options.orient, megapixErrorHandler = function() {
- container.onerror = null;
- container.onload = null;
- log("Could not render preview, file may be too large!", "error");
- drawPreview.failure(container, "Browser cannot render image!");
- };
- identifier.isPreviewable().then(function(mime) {
- var dummyExif = {
- parse: function() {
- return new qq.Promise().success();
- }
- }, exif = orient ? new qq.Exif(fileOrBlob, log) : dummyExif, mpImg = new qq.MegaPixImage(fileOrBlob, megapixErrorHandler);
- if (registerThumbnailRenderedListener(container, drawPreview)) {
- exif.parse().then(function(exif) {
- var orientation = exif && exif.Orientation;
- mpImg.render(container, {
- maxWidth: maxSize,
- maxHeight: maxSize,
- orientation: orientation,
- mime: mime,
- resize: options.customResizeFunction
- });
- }, function(failureMsg) {
- log(qq.format("EXIF data could not be parsed ({}). Assuming orientation = 1.", failureMsg));
- mpImg.render(container, {
- maxWidth: maxSize,
- maxHeight: maxSize,
- mime: mime,
- resize: options.customResizeFunction
- });
- });
- }
- }, function() {
- log("Not previewable");
- drawPreview.failure(container, "Not previewable");
- });
- return drawPreview;
- }
- function drawOnCanvasOrImgFromUrl(url, canvasOrImg, draw, maxSize, customResizeFunction) {
- var tempImg = new Image(), tempImgRender = new qq.Promise();
- registerThumbnailRenderedListener(tempImg, tempImgRender);
- if (isCrossOrigin(url)) {
- tempImg.crossOrigin = "anonymous";
- }
- tempImg.src = url;
- tempImgRender.then(function rendered() {
- registerThumbnailRenderedListener(canvasOrImg, draw);
- var mpImg = new qq.MegaPixImage(tempImg);
- mpImg.render(canvasOrImg, {
- maxWidth: maxSize,
- maxHeight: maxSize,
- mime: determineMimeOfFileName(url),
- resize: customResizeFunction
- });
- }, draw.failure);
- }
- function drawOnImgFromUrlWithCssScaling(url, img, draw, maxSize) {
- registerThumbnailRenderedListener(img, draw);
- qq(img).css({
- maxWidth: maxSize + "px",
- maxHeight: maxSize + "px"
- });
- img.src = url;
- }
- function drawFromUrl(url, container, options) {
- var draw = new qq.Promise(), scale = options.scale, maxSize = scale ? options.maxSize : null;
- if (scale && isImg(container)) {
- if (isCanvasSupported()) {
- if (isCrossOrigin(url) && !isImgCorsSupported()) {
- drawOnImgFromUrlWithCssScaling(url, container, draw, maxSize);
- } else {
- drawOnCanvasOrImgFromUrl(url, container, draw, maxSize);
- }
- } else {
- drawOnImgFromUrlWithCssScaling(url, container, draw, maxSize);
- }
- } else if (isCanvas(container)) {
- drawOnCanvasOrImgFromUrl(url, container, draw, maxSize);
- } else if (registerThumbnailRenderedListener(container, draw)) {
- container.src = url;
- }
- return draw;
- }
- qq.extend(this, {
- generate: function(fileBlobOrUrl, container, options) {
- if (qq.isString(fileBlobOrUrl)) {
- log("Attempting to update thumbnail based on server response.");
- return drawFromUrl(fileBlobOrUrl, container, options || {});
- } else {
- log("Attempting to draw client-side image preview.");
- return draw(fileBlobOrUrl, container, options || {});
- }
- }
- });
- this._testing = {};
- this._testing.isImg = isImg;
- this._testing.isCanvas = isCanvas;
- this._testing.isCrossOrigin = isCrossOrigin;
- this._testing.determineMimeOfFileName = determineMimeOfFileName;
- };
- qq.Exif = function(fileOrBlob, log) {
- "use strict";
- var TAG_IDS = [ 274 ], TAG_INFO = {
- 274: {
- name: "Orientation",
- bytes: 2
- }
- };
- function parseLittleEndian(hex) {
- var result = 0, pow = 0;
- while (hex.length > 0) {
- result += parseInt(hex.substring(0, 2), 16) * Math.pow(2, pow);
- hex = hex.substring(2, hex.length);
- pow += 8;
- }
- return result;
- }
- function seekToApp1(offset, promise) {
- var theOffset = offset, thePromise = promise;
- if (theOffset === undefined) {
- theOffset = 2;
- thePromise = new qq.Promise();
- }
- qq.readBlobToHex(fileOrBlob, theOffset, 4).then(function(hex) {
- var match = /^ffe([0-9])/.exec(hex), segmentLength;
- if (match) {
- if (match[1] !== "1") {
- segmentLength = parseInt(hex.slice(4, 8), 16);
- seekToApp1(theOffset + segmentLength + 2, thePromise);
- } else {
- thePromise.success(theOffset);
- }
- } else {
- thePromise.failure("No EXIF header to be found!");
- }
- });
- return thePromise;
- }
- function getApp1Offset() {
- var promise = new qq.Promise();
- qq.readBlobToHex(fileOrBlob, 0, 6).then(function(hex) {
- if (hex.indexOf("ffd8") !== 0) {
- promise.failure("Not a valid JPEG!");
- } else {
- seekToApp1().then(function(offset) {
- promise.success(offset);
- }, function(error) {
- promise.failure(error);
- });
- }
- });
- return promise;
- }
- function isLittleEndian(app1Start) {
- var promise = new qq.Promise();
- qq.readBlobToHex(fileOrBlob, app1Start + 10, 2).then(function(hex) {
- promise.success(hex === "4949");
- });
- return promise;
- }
- function getDirEntryCount(app1Start, littleEndian) {
- var promise = new qq.Promise();
- qq.readBlobToHex(fileOrBlob, app1Start + 18, 2).then(function(hex) {
- if (littleEndian) {
- return promise.success(parseLittleEndian(hex));
- } else {
- promise.success(parseInt(hex, 16));
- }
- });
- return promise;
- }
- function getIfd(app1Start, dirEntries) {
- var offset = app1Start + 20, bytes = dirEntries * 12;
- return qq.readBlobToHex(fileOrBlob, offset, bytes);
- }
- function getDirEntries(ifdHex) {
- var entries = [], offset = 0;
- while (offset + 24 <= ifdHex.length) {
- entries.push(ifdHex.slice(offset, offset + 24));
- offset += 24;
- }
- return entries;
- }
- function getTagValues(littleEndian, dirEntries) {
- var TAG_VAL_OFFSET = 16, tagsToFind = qq.extend([], TAG_IDS), vals = {};
- qq.each(dirEntries, function(idx, entry) {
- var idHex = entry.slice(0, 4), id = littleEndian ? parseLittleEndian(idHex) : parseInt(idHex, 16), tagsToFindIdx = tagsToFind.indexOf(id), tagValHex, tagName, tagValLength;
- if (tagsToFindIdx >= 0) {
- tagName = TAG_INFO[id].name;
- tagValLength = TAG_INFO[id].bytes;
- tagValHex = entry.slice(TAG_VAL_OFFSET, TAG_VAL_OFFSET + tagValLength * 2);
- vals[tagName] = littleEndian ? parseLittleEndian(tagValHex) : parseInt(tagValHex, 16);
- tagsToFind.splice(tagsToFindIdx, 1);
- }
- if (tagsToFind.length === 0) {
- return false;
- }
- });
- return vals;
- }
- qq.extend(this, {
- parse: function() {
- var parser = new qq.Promise(), onParseFailure = function(message) {
- log(qq.format("EXIF header parse failed: '{}' ", message));
- parser.failure(message);
- };
- getApp1Offset().then(function(app1Offset) {
- log(qq.format("Moving forward with EXIF header parsing for '{}'", fileOrBlob.name === undefined ? "blob" : fileOrBlob.name));
- isLittleEndian(app1Offset).then(function(littleEndian) {
- log(qq.format("EXIF Byte order is {} endian", littleEndian ? "little" : "big"));
- getDirEntryCount(app1Offset, littleEndian).then(function(dirEntryCount) {
- log(qq.format("Found {} APP1 directory entries", dirEntryCount));
- getIfd(app1Offset, dirEntryCount).then(function(ifdHex) {
- var dirEntries = getDirEntries(ifdHex), tagValues = getTagValues(littleEndian, dirEntries);
- log("Successfully parsed some EXIF tags");
- parser.success(tagValues);
- }, onParseFailure);
- }, onParseFailure);
- }, onParseFailure);
- }, onParseFailure);
- return parser;
- }
- });
- this._testing = {};
- this._testing.parseLittleEndian = parseLittleEndian;
- };
- qq.Identify = function(fileOrBlob, log) {
- "use strict";
- function isIdentifiable(magicBytes, questionableBytes) {
- var identifiable = false, magicBytesEntries = [].concat(magicBytes);
- qq.each(magicBytesEntries, function(idx, magicBytesArrayEntry) {
- if (questionableBytes.indexOf(magicBytesArrayEntry) === 0) {
- identifiable = true;
- return false;
- }
- });
- return identifiable;
- }
- qq.extend(this, {
- isPreviewable: function() {
- var self = this, identifier = new qq.Promise(), previewable = false, name = fileOrBlob.name === undefined ? "blob" : fileOrBlob.name;
- log(qq.format("Attempting to determine if {} can be rendered in this browser", name));
- log("First pass: check type attribute of blob object.");
- if (this.isPreviewableSync()) {
- log("Second pass: check for magic bytes in file header.");
- qq.readBlobToHex(fileOrBlob, 0, 4).then(function(hex) {
- qq.each(self.PREVIEWABLE_MIME_TYPES, function(mime, bytes) {
- if (isIdentifiable(bytes, hex)) {
- if (mime !== "image/tiff" || qq.supportedFeatures.tiffPreviews) {
- previewable = true;
- identifier.success(mime);
- }
- return false;
- }
- });
- log(qq.format("'{}' is {} able to be rendered in this browser", name, previewable ? "" : "NOT"));
- if (!previewable) {
- identifier.failure();
- }
- }, function() {
- log("Error reading file w/ name '" + name + "'. Not able to be rendered in this browser.");
- identifier.failure();
- });
- } else {
- identifier.failure();
- }
- return identifier;
- },
- isPreviewableSync: function() {
- var fileMime = fileOrBlob.type, isRecognizedImage = qq.indexOf(Object.keys(this.PREVIEWABLE_MIME_TYPES), fileMime) >= 0, previewable = false, name = fileOrBlob.name === undefined ? "blob" : fileOrBlob.name;
- if (isRecognizedImage) {
- if (fileMime === "image/tiff") {
- previewable = qq.supportedFeatures.tiffPreviews;
- } else {
- previewable = true;
- }
- }
- !previewable && log(name + " is not previewable in this browser per the blob's type attr");
- return previewable;
- }
- });
- };
- qq.Identify.prototype.PREVIEWABLE_MIME_TYPES = {
- "image/jpeg": "ffd8ff",
- "image/gif": "474946",
- "image/png": "89504e",
- "image/bmp": "424d",
- "image/tiff": [ "49492a00", "4d4d002a" ]
- };
- qq.ImageValidation = function(blob, log) {
- "use strict";
- function hasNonZeroLimits(limits) {
- var atLeastOne = false;
- qq.each(limits, function(limit, value) {
- if (value > 0) {
- atLeastOne = true;
- return false;
- }
- });
- return atLeastOne;
- }
- function getWidthHeight() {
- var sizeDetermination = new qq.Promise();
- new qq.Identify(blob, log).isPreviewable().then(function() {
- var image = new Image(), url = window.URL && window.URL.createObjectURL ? window.URL : window.webkitURL && window.webkitURL.createObjectURL ? window.webkitURL : null;
- if (url) {
- image.onerror = function() {
- log("Cannot determine dimensions for image. May be too large.", "error");
- sizeDetermination.failure();
- };
- image.onload = function() {
- sizeDetermination.success({
- width: this.width,
- height: this.height
- });
- };
- image.src = url.createObjectURL(blob);
- } else {
- log("No createObjectURL function available to generate image URL!", "error");
- sizeDetermination.failure();
- }
- }, sizeDetermination.failure);
- return sizeDetermination;
- }
- function getFailingLimit(limits, dimensions) {
- var failingLimit;
- qq.each(limits, function(limitName, limitValue) {
- if (limitValue > 0) {
- var limitMatcher = /(max|min)(Width|Height)/.exec(limitName), dimensionPropName = limitMatcher[2].charAt(0).toLowerCase() + limitMatcher[2].slice(1), actualValue = dimensions[dimensionPropName];
- switch (limitMatcher[1]) {
- case "min":
- if (actualValue < limitValue) {
- failingLimit = limitName;
- return false;
- }
- break;
-
- case "max":
- if (actualValue > limitValue) {
- failingLimit = limitName;
- return false;
- }
- break;
- }
- }
- });
- return failingLimit;
- }
- this.validate = function(limits) {
- var validationEffort = new qq.Promise();
- log("Attempting to validate image.");
- if (hasNonZeroLimits(limits)) {
- getWidthHeight().then(function(dimensions) {
- var failingLimit = getFailingLimit(limits, dimensions);
- if (failingLimit) {
- validationEffort.failure(failingLimit);
- } else {
- validationEffort.success();
- }
- }, validationEffort.success);
- } else {
- validationEffort.success();
- }
- return validationEffort;
- };
- };
- qq.Session = function(spec) {
- "use strict";
- var options = {
- endpoint: null,
- params: {},
- customHeaders: {},
- cors: {},
- addFileRecord: function(sessionData) {},
- log: function(message, level) {}
- };
- qq.extend(options, spec, true);
- function isJsonResponseValid(response) {
- if (qq.isArray(response)) {
- return true;
- }
- options.log("Session response is not an array.", "error");
- }
- function handleFileItems(fileItems, success, xhrOrXdr, promise) {
- var someItemsIgnored = false;
- success = success && isJsonResponseValid(fileItems);
- if (success) {
- qq.each(fileItems, function(idx, fileItem) {
- if (fileItem.uuid == null) {
- someItemsIgnored = true;
- options.log(qq.format("Session response item {} did not include a valid UUID - ignoring.", idx), "error");
- } else if (fileItem.name == null) {
- someItemsIgnored = true;
- options.log(qq.format("Session response item {} did not include a valid name - ignoring.", idx), "error");
- } else {
- try {
- options.addFileRecord(fileItem);
- return true;
- } catch (err) {
- someItemsIgnored = true;
- options.log(err.message, "error");
- }
- }
- return false;
- });
- }
- promise[success && !someItemsIgnored ? "success" : "failure"](fileItems, xhrOrXdr);
- }
- this.refresh = function() {
- var refreshEffort = new qq.Promise(), refreshCompleteCallback = function(response, success, xhrOrXdr) {
- handleFileItems(response, success, xhrOrXdr, refreshEffort);
- }, requesterOptions = qq.extend({}, options), requester = new qq.SessionAjaxRequester(qq.extend(requesterOptions, {
- onComplete: refreshCompleteCallback
- }));
- requester.queryServer();
- return refreshEffort;
- };
- };
- qq.SessionAjaxRequester = function(spec) {
- "use strict";
- var requester, options = {
- endpoint: null,
- customHeaders: {},
- params: {},
- cors: {
- expected: false,
- sendCredentials: false
- },
- onComplete: function(response, success, xhrOrXdr) {},
- log: function(str, level) {}
- };
- qq.extend(options, spec);
- function onComplete(id, xhrOrXdr, isError) {
- var response = null;
- if (xhrOrXdr.responseText != null) {
- try {
- response = qq.parseJson(xhrOrXdr.responseText);
- } catch (err) {
- options.log("Problem parsing session response: " + err.message, "error");
- isError = true;
- }
- }
- options.onComplete(response, !isError, xhrOrXdr);
- }
- requester = qq.extend(this, new qq.AjaxRequester({
- acceptHeader: "application/json",
- validMethods: [ "GET" ],
- method: "GET",
- endpointStore: {
- get: function() {
- return options.endpoint;
- }
- },
- customHeaders: options.customHeaders,
- log: options.log,
- onComplete: onComplete,
- cors: options.cors
- }));
- qq.extend(this, {
- queryServer: function() {
- var params = qq.extend({}, options.params);
- options.log("Session query request.");
- requester.initTransport("sessionRefresh").withParams(params).withCacheBuster().send();
- }
- });
- };
- qq.Scaler = function(spec, log) {
- "use strict";
- var self = this, customResizeFunction = spec.customResizer, includeOriginal = spec.sendOriginal, orient = spec.orient, defaultType = spec.defaultType, defaultQuality = spec.defaultQuality / 100, failedToScaleText = spec.failureText, includeExif = spec.includeExif, sizes = this._getSortedSizes(spec.sizes);
- qq.extend(this, {
- enabled: qq.supportedFeatures.scaling && sizes.length > 0,
- getFileRecords: function(originalFileUuid, originalFileName, originalBlobOrBlobData) {
- var self = this, records = [], originalBlob = originalBlobOrBlobData.blob ? originalBlobOrBlobData.blob : originalBlobOrBlobData, identifier = new qq.Identify(originalBlob, log);
- if (identifier.isPreviewableSync()) {
- qq.each(sizes, function(idx, sizeRecord) {
- var outputType = self._determineOutputType({
- defaultType: defaultType,
- requestedType: sizeRecord.type,
- refType: originalBlob.type
- });
- records.push({
- uuid: qq.getUniqueId(),
- name: self._getName(originalFileName, {
- name: sizeRecord.name,
- type: outputType,
- refType: originalBlob.type
- }),
- blob: new qq.BlobProxy(originalBlob, qq.bind(self._generateScaledImage, self, {
- customResizeFunction: customResizeFunction,
- maxSize: sizeRecord.maxSize,
- orient: orient,
- type: outputType,
- quality: defaultQuality,
- failedText: failedToScaleText,
- includeExif: includeExif,
- log: log
- }))
- });
- });
- records.push({
- uuid: originalFileUuid,
- name: originalFileName,
- size: originalBlob.size,
- blob: includeOriginal ? originalBlob : null
- });
- } else {
- records.push({
- uuid: originalFileUuid,
- name: originalFileName,
- size: originalBlob.size,
- blob: originalBlob
- });
- }
- return records;
- },
- handleNewFile: function(file, name, uuid, size, fileList, batchId, uuidParamName, api) {
- var self = this, buttonId = file.qqButtonId || file.blob && file.blob.qqButtonId, scaledIds = [], originalId = null, addFileToHandler = api.addFileToHandler, uploadData = api.uploadData, paramsStore = api.paramsStore, proxyGroupId = qq.getUniqueId();
- qq.each(self.getFileRecords(uuid, name, file), function(idx, record) {
- var blobSize = record.size, id;
- if (record.blob instanceof qq.BlobProxy) {
- blobSize = -1;
- }
- id = uploadData.addFile({
- uuid: record.uuid,
- name: record.name,
- size: blobSize,
- batchId: batchId,
- proxyGroupId: proxyGroupId
- });
- if (record.blob instanceof qq.BlobProxy) {
- scaledIds.push(id);
- } else {
- originalId = id;
- }
- if (record.blob) {
- addFileToHandler(id, record.blob);
- fileList.push({
- id: id,
- file: record.blob
- });
- } else {
- uploadData.setStatus(id, qq.status.REJECTED);
- }
- });
- if (originalId !== null) {
- qq.each(scaledIds, function(idx, scaledId) {
- var params = {
- qqparentuuid: uploadData.retrieve({
- id: originalId
- }).uuid,
- qqparentsize: uploadData.retrieve({
- id: originalId
- }).size
- };
- params[uuidParamName] = uploadData.retrieve({
- id: scaledId
- }).uuid;
- uploadData.setParentId(scaledId, originalId);
- paramsStore.addReadOnly(scaledId, params);
- });
- if (scaledIds.length) {
- (function() {
- var param = {};
- param[uuidParamName] = uploadData.retrieve({
- id: originalId
- }).uuid;
- paramsStore.addReadOnly(originalId, param);
- })();
- }
- }
- }
- });
- };
- qq.extend(qq.Scaler.prototype, {
- scaleImage: function(id, specs, api) {
- "use strict";
- if (!qq.supportedFeatures.scaling) {
- throw new qq.Error("Scaling is not supported in this browser!");
- }
- var scalingEffort = new qq.Promise(), log = api.log, file = api.getFile(id), uploadData = api.uploadData.retrieve({
- id: id
- }), name = uploadData && uploadData.name, uuid = uploadData && uploadData.uuid, scalingOptions = {
- customResizer: specs.customResizer,
- sendOriginal: false,
- orient: specs.orient,
- defaultType: specs.type || null,
- defaultQuality: specs.quality,
- failedToScaleText: "Unable to scale",
- sizes: [ {
- name: "",
- maxSize: specs.maxSize
- } ]
- }, scaler = new qq.Scaler(scalingOptions, log);
- if (!qq.Scaler || !qq.supportedFeatures.imagePreviews || !file) {
- scalingEffort.failure();
- log("Could not generate requested scaled image for " + id + ". " + "Scaling is either not possible in this browser, or the file could not be located.", "error");
- } else {
- qq.bind(function() {
- var record = scaler.getFileRecords(uuid, name, file)[0];
- if (record && record.blob instanceof qq.BlobProxy) {
- record.blob.create().then(scalingEffort.success, scalingEffort.failure);
- } else {
- log(id + " is not a scalable image!", "error");
- scalingEffort.failure();
- }
- }, this)();
- }
- return scalingEffort;
- },
- _determineOutputType: function(spec) {
- "use strict";
- var requestedType = spec.requestedType, defaultType = spec.defaultType, referenceType = spec.refType;
- if (!defaultType && !requestedType) {
- if (referenceType !== "image/jpeg") {
- return "image/png";
- }
- return referenceType;
- }
- if (!requestedType) {
- return defaultType;
- }
- if (qq.indexOf(Object.keys(qq.Identify.prototype.PREVIEWABLE_MIME_TYPES), requestedType) >= 0) {
- if (requestedType === "image/tiff") {
- return qq.supportedFeatures.tiffPreviews ? requestedType : defaultType;
- }
- return requestedType;
- }
- return defaultType;
- },
- _getName: function(originalName, scaledVersionProperties) {
- "use strict";
- var startOfExt = originalName.lastIndexOf("."), versionType = scaledVersionProperties.type || "image/png", referenceType = scaledVersionProperties.refType, scaledName = "", scaledExt = qq.getExtension(originalName), nameAppendage = "";
- if (scaledVersionProperties.name && scaledVersionProperties.name.trim().length) {
- nameAppendage = " (" + scaledVersionProperties.name + ")";
- }
- if (startOfExt >= 0) {
- scaledName = originalName.substr(0, startOfExt);
- if (referenceType !== versionType) {
- scaledExt = versionType.split("/")[1];
- }
- scaledName += nameAppendage + "." + scaledExt;
- } else {
- scaledName = originalName + nameAppendage;
- }
- return scaledName;
- },
- _getSortedSizes: function(sizes) {
- "use strict";
- sizes = qq.extend([], sizes);
- return sizes.sort(function(a, b) {
- if (a.maxSize > b.maxSize) {
- return 1;
- }
- if (a.maxSize < b.maxSize) {
- return -1;
- }
- return 0;
- });
- },
- _generateScaledImage: function(spec, sourceFile) {
- "use strict";
- var self = this, customResizeFunction = spec.customResizeFunction, log = spec.log, maxSize = spec.maxSize, orient = spec.orient, type = spec.type, quality = spec.quality, failedText = spec.failedText, includeExif = spec.includeExif && sourceFile.type === "image/jpeg" && type === "image/jpeg", scalingEffort = new qq.Promise(), imageGenerator = new qq.ImageGenerator(log), canvas = document.createElement("canvas");
- log("Attempting to generate scaled version for " + sourceFile.name);
- imageGenerator.generate(sourceFile, canvas, {
- maxSize: maxSize,
- orient: orient,
- customResizeFunction: customResizeFunction
- }).then(function() {
- var scaledImageDataUri = canvas.toDataURL(type, quality), signalSuccess = function() {
- log("Success generating scaled version for " + sourceFile.name);
- var blob = qq.dataUriToBlob(scaledImageDataUri);
- scalingEffort.success(blob);
- };
- if (includeExif) {
- self._insertExifHeader(sourceFile, scaledImageDataUri, log).then(function(scaledImageDataUriWithExif) {
- scaledImageDataUri = scaledImageDataUriWithExif;
- signalSuccess();
- }, function() {
- log("Problem inserting EXIF header into scaled image. Using scaled image w/out EXIF data.", "error");
- signalSuccess();
- });
- } else {
- signalSuccess();
- }
- }, function() {
- log("Failed attempt to generate scaled version for " + sourceFile.name, "error");
- scalingEffort.failure(failedText);
- });
- return scalingEffort;
- },
- _insertExifHeader: function(originalImage, scaledImageDataUri, log) {
- "use strict";
- var reader = new FileReader(), insertionEffort = new qq.Promise(), originalImageDataUri = "";
- reader.onload = function() {
- originalImageDataUri = reader.result;
- insertionEffort.success(qq.ExifRestorer.restore(originalImageDataUri, scaledImageDataUri));
- };
- reader.onerror = function() {
- log("Problem reading " + originalImage.name + " during attempt to transfer EXIF data to scaled version.", "error");
- insertionEffort.failure();
- };
- reader.readAsDataURL(originalImage);
- return insertionEffort;
- },
- _dataUriToBlob: function(dataUri) {
- "use strict";
- var byteString, mimeString, arrayBuffer, intArray;
- if (dataUri.split(",")[0].indexOf("base64") >= 0) {
- byteString = atob(dataUri.split(",")[1]);
- } else {
- byteString = decodeURI(dataUri.split(",")[1]);
- }
- mimeString = dataUri.split(",")[0].split(":")[1].split(";")[0];
- arrayBuffer = new ArrayBuffer(byteString.length);
- intArray = new Uint8Array(arrayBuffer);
- qq.each(byteString, function(idx, character) {
- intArray[idx] = character.charCodeAt(0);
- });
- return this._createBlob(arrayBuffer, mimeString);
- },
- _createBlob: function(data, mime) {
- "use strict";
- var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder, blobBuilder = BlobBuilder && new BlobBuilder();
- if (blobBuilder) {
- blobBuilder.append(data);
- return blobBuilder.getBlob(mime);
- } else {
- return new Blob([ data ], {
- type: mime
- });
- }
- }
+ requestor = new qq.AjaxRequestor({
+ method: 'DELETE',
+ endpointStore: options.endpointStore,
+ paramsStore: options.paramsStore,
+ maxConnections: options.maxConnections,
+ customHeaders: options.customHeaders,
+ successfulResponseCodes: [200, 202, 204],
+ demoMode: options.demoMode,
+ log: options.log,
+ onSend: options.onDelete,
+ onComplete: options.onDeleteComplete
});
- qq.ExifRestorer = function() {
- var ExifRestorer = {};
- ExifRestorer.KEY_STR = "ABCDEFGHIJKLMNOP" + "QRSTUVWXYZabcdef" + "ghijklmnopqrstuv" + "wxyz0123456789+/" + "=";
- ExifRestorer.encode64 = function(input) {
- var output = "", chr1, chr2, chr3 = "", enc1, enc2, enc3, enc4 = "", i = 0;
- do {
- chr1 = input[i++];
- chr2 = input[i++];
- chr3 = input[i++];
- enc1 = chr1 >> 2;
- enc2 = (chr1 & 3) << 4 | chr2 >> 4;
- enc3 = (chr2 & 15) << 2 | chr3 >> 6;
- enc4 = chr3 & 63;
- if (isNaN(chr2)) {
- enc3 = enc4 = 64;
- } else if (isNaN(chr3)) {
- enc4 = 64;
- }
- output = output + this.KEY_STR.charAt(enc1) + this.KEY_STR.charAt(enc2) + this.KEY_STR.charAt(enc3) + this.KEY_STR.charAt(enc4);
- chr1 = chr2 = chr3 = "";
- enc1 = enc2 = enc3 = enc4 = "";
- } while (i < input.length);
- return output;
- };
- ExifRestorer.restore = function(origFileBase64, resizedFileBase64) {
- var expectedBase64Header = "data:image/jpeg;base64,";
- if (!origFileBase64.match(expectedBase64Header)) {
- return resizedFileBase64;
+
+
+ return {
+ sendDelete: function(id, uuid) {
+ requestor.send(id, uuid);
+ options.log("Submitted delete file request for " + id);
+ }
+ };
+};
+qq.WindowReceiveMessage = function(o) {
+ var options = {
+ log: function(message, level) {}
+ },
+ callbackWrapperDetachers = {};
+
+ qq.extend(options, o);
+
+ return {
+ receiveMessage : function(id, callback) {
+ var onMessageCallbackWrapper = function(event) {
+ callback(event.data);
+ };
+
+ if (window.postMessage) {
+ callbackWrapperDetachers[id] = qq(window).attach("message", onMessageCallbackWrapper);
}
- var rawImage = this.decode64(origFileBase64.replace(expectedBase64Header, ""));
- var segments = this.slice2Segments(rawImage);
- var image = this.exifManipulation(resizedFileBase64, segments);
- return expectedBase64Header + this.encode64(image);
- };
- ExifRestorer.exifManipulation = function(resizedFileBase64, segments) {
- var exifArray = this.getExifArray(segments), newImageArray = this.insertExif(resizedFileBase64, exifArray), aBuffer = new Uint8Array(newImageArray);
- return aBuffer;
- };
- ExifRestorer.getExifArray = function(segments) {
- var seg;
- for (var x = 0; x < segments.length; x++) {
- seg = segments[x];
- if (seg[0] == 255 & seg[1] == 225) {
- return seg;
+ else {
+ log("iframe message passing not supported in this browser!", "error");
+ }
+ },
+
+ stopReceivingMessages : function(id) {
+ if (window.postMessage) {
+ var detacher = callbackWrapperDetachers[id];
+ if (detacher) {
+ detacher();
}
}
+ }
+ };
+};
+/**
+ * Class for uploading files, uploading itself is handled by child classes
+ */
+/*globals qq*/
+qq.UploadHandler = function(o) {
+ "use strict";
+
+ var queue = [],
+ options, log, dequeue, handlerImpl;
+
+ // Default options, can be overridden by the user
+ options = {
+ debug: false,
+ forceMultipart: true,
+ paramsInBody: false,
+ 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){},
+ onUploadChunk: function(id, fileName, chunkData){},
+ onAutoRetry: function(id, fileName, response, xhr){},
+ onResume: function(id, fileName, chunkData){}
+
+ };
+ qq.extend(options, o);
+
+ log = options.log;
+
+ /**
+ * Removes element from queue, starts upload of next
+ */
+ dequeue = function(id) {
+ var i = qq.indexOf(queue, id),
+ max = options.maxConnections,
+ nextId;
+
+ if (i >= 0) {
+ queue.splice(i, 1);
+
+ if (queue.length >= max && i < max){
+ nextId = queue[max-1];
+ handlerImpl.upload(nextId);
+ }
+ }
+ };
+
+ 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);
+
+ // 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 = [];
+
+ 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 [];
- };
- ExifRestorer.insertExif = function(resizedFileBase64, exifArray) {
- var imageData = resizedFileBase64.replace("data:image/jpeg;base64,", ""), buf = this.decode64(imageData), separatePoint = buf.indexOf(255, 3), mae = buf.slice(0, separatePoint), ato = buf.slice(separatePoint), array = mae;
- array = array.concat(exifArray);
- array = array.concat(ato);
- return array;
- };
- ExifRestorer.slice2Segments = function(rawImageArray) {
- var head = 0, segments = [];
- while (1) {
- if (rawImageArray[head] == 255 & rawImageArray[head + 1] == 218) {
- break;
- }
- if (rawImageArray[head] == 255 & rawImageArray[head + 1] == 216) {
- head += 2;
- } else {
- var length = rawImageArray[head + 2] * 256 + rawImageArray[head + 3], endPoint = head + length + 2, seg = rawImageArray.slice(head, endPoint);
- segments.push(seg);
- head = endPoint;
- }
- if (head > rawImageArray.length) {
- break;
- }
- }
- return segments;
- };
- ExifRestorer.decode64 = function(input) {
- var output = "", chr1, chr2, chr3 = "", enc1, enc2, enc3, enc4 = "", i = 0, buf = [];
- var base64test = /[^A-Za-z0-9\+\/\=]/g;
- if (base64test.exec(input)) {
- throw new Error("There were invalid base64 characters in the input text. " + "Valid base64 characters are A-Z, a-z, 0-9, '+', '/',and '='");
- }
- input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
- do {
- enc1 = this.KEY_STR.indexOf(input.charAt(i++));
- enc2 = this.KEY_STR.indexOf(input.charAt(i++));
- enc3 = this.KEY_STR.indexOf(input.charAt(i++));
- enc4 = this.KEY_STR.indexOf(input.charAt(i++));
- chr1 = enc1 << 2 | enc2 >> 4;
- chr2 = (enc2 & 15) << 4 | enc3 >> 2;
- chr3 = (enc3 & 3) << 6 | enc4;
- buf.push(chr1);
- if (enc3 != 64) {
- buf.push(chr2);
- }
- if (enc4 != 64) {
- buf.push(chr3);
- }
- chr1 = chr2 = chr3 = "";
- enc1 = enc2 = enc3 = enc4 = "";
- } while (i < input.length);
- return buf;
- };
- return ExifRestorer;
- }();
- qq.TotalProgress = function(callback, getSize) {
- "use strict";
- var perFileProgress = {}, totalLoaded = 0, totalSize = 0, lastLoadedSent = -1, lastTotalSent = -1, callbackProxy = function(loaded, total) {
- if (loaded !== lastLoadedSent || total !== lastTotalSent) {
- callback(loaded, total);
- }
- lastLoadedSent = loaded;
- lastTotalSent = total;
- }, noRetryableFiles = function(failed, retryable) {
- var none = true;
- qq.each(failed, function(idx, failedId) {
- if (qq.indexOf(retryable, failedId) >= 0) {
- none = false;
- return false;
- }
- });
- return none;
- }, onCancel = function(id) {
- updateTotalProgress(id, -1, -1);
- delete perFileProgress[id];
- }, onAllComplete = function(successful, failed, retryable) {
- if (failed.length === 0 || noRetryableFiles(failed, retryable)) {
- callbackProxy(totalSize, totalSize);
- this.reset();
- }
- }, onNew = function(id) {
- var size = getSize(id);
- if (size > 0) {
- updateTotalProgress(id, 0, size);
- perFileProgress[id] = {
- loaded: 0,
- total: size
- };
- }
- }, updateTotalProgress = function(id, newLoaded, newTotal) {
- var oldLoaded = perFileProgress[id] ? perFileProgress[id].loaded : 0, oldTotal = perFileProgress[id] ? perFileProgress[id].total : 0;
- if (newLoaded === -1 && newTotal === -1) {
- totalLoaded -= oldLoaded;
- totalSize -= oldTotal;
- } else {
- if (newLoaded) {
- totalLoaded += newLoaded - oldLoaded;
- }
- if (newTotal) {
- totalSize += newTotal - oldTotal;
- }
- }
- callbackProxy(totalLoaded, totalSize);
- };
- qq.extend(this, {
- onAllComplete: onAllComplete,
- onStatusChange: function(id, oldStatus, newStatus) {
- if (newStatus === qq.status.CANCELED || newStatus === qq.status.REJECTED) {
- onCancel(id);
- } else if (newStatus === qq.status.SUBMITTING) {
- onNew(id);
- }
- },
- onIndividualProgress: function(id, loaded, total) {
- updateTotalProgress(id, loaded, total);
- perFileProgress[id] = {
- loaded: loaded,
- total: total
- };
- },
- onNewSize: function(id) {
- onNew(id);
- },
- reset: function() {
- perFileProgress = {};
- totalLoaded = 0;
- totalSize = 0;
- }
- });
- };
- qq.PasteSupport = function(o) {
- "use strict";
- var options, detachPasteHandler;
- options = {
- targetElement: null,
- callbacks: {
- log: function(message, level) {},
- pasteReceived: function(blob) {}
- }
- };
- function isImage(item) {
- return item.type && item.type.indexOf("image/") === 0;
}
- function registerPasteHandler() {
- detachPasteHandler = qq(options.targetElement).attach("paste", function(event) {
- var clipboardData = event.clipboardData;
- if (clipboardData) {
- qq.each(clipboardData.items, function(idx, item) {
- if (isImage(item)) {
- var blob = item.getAsFile();
- options.callbacks.pasteReceived(blob);
- }
+ };
+};
+/*globals qq, document, setTimeout*/
+/*globals clearTimeout*/
+qq.UploadHandlerForm = function(o, uploadCompleteCallback, logCallback) {
+ "use strict";
+
+ var options = o,
+ inputs = [],
+ uuids = [],
+ detachLoadEvents = {},
+ postMessageCallbackTimers = {},
+ uploadComplete = uploadCompleteCallback,
+ log = logCallback,
+ corsMessageReceiver = new qq.WindowReceiveMessage({log: log}),
+ onloadCallbacks = {},
+ api;
+
+
+ function detachLoadEvent(id) {
+ if (detachLoadEvents[id] !== undefined) {
+ detachLoadEvents[id]();
+ delete detachLoadEvents[id];
+ }
+ }
+
+ function registerPostMessageCallback(iframe, callback) {
+ var id = iframe.id;
+
+ onloadCallbacks[uuids[id]] = callback;
+
+ detachLoadEvents[id] = qq(iframe).attach('load', function() {
+ if (inputs[id]) {
+ log("Received iframe load event for CORS upload request (file id " + id + ")");
+
+ postMessageCallbackTimers[id] = setTimeout(function() {
+ var errorMessage = "No valid message received from loaded iframe for file id " + id;
+ log(errorMessage, "error");
+ callback({
+ error: errorMessage
});
- }
- });
- }
- function unregisterPasteHandler() {
- if (detachPasteHandler) {
- detachPasteHandler();
- }
- }
- qq.extend(options, o);
- registerPasteHandler();
- qq.extend(this, {
- reset: function() {
- unregisterPasteHandler();
+ }, 1000);
}
});
- };
- qq.FormSupport = function(options, startUpload, log) {
- "use strict";
- var self = this, interceptSubmit = options.interceptSubmit, formEl = options.element, autoUpload = options.autoUpload;
- qq.extend(this, {
- newEndpoint: null,
- newAutoUpload: autoUpload,
- attachedToForm: false,
- getFormInputsAsObject: function() {
- if (formEl == null) {
- return null;
- }
- return self._form2Obj(formEl);
+
+ corsMessageReceiver.receiveMessage(id, function(message) {
+ log("Received the following window message: '" + message + "'");
+ var response = qq.parseJson(message),
+ uuid = response.uuid,
+ onloadCallback;
+
+ if (uuid && onloadCallbacks[uuid]) {
+ clearTimeout(postMessageCallbackTimers[id]);
+ delete postMessageCallbackTimers[id];
+
+ detachLoadEvent(id);
+
+ onloadCallback = onloadCallbacks[uuid];
+
+ delete onloadCallbacks[uuid];
+ corsMessageReceiver.stopReceivingMessages(id);
+ onloadCallback(response);
+ }
+ else if (!uuid) {
+ log("'" + message + "' does not contain a UUID - ignoring.");
}
});
- function determineNewEndpoint(formEl) {
- if (formEl.getAttribute("action")) {
- self.newEndpoint = formEl.getAttribute("action");
- }
+ }
+
+ function attachLoadEvent(iframe, callback) {
+ /*jslint eqeq: true*/
+
+ if (options.cors.expected) {
+ registerPostMessageCallback(iframe, callback);
}
- function validateForm(formEl, nativeSubmit) {
- if (formEl.checkValidity && !formEl.checkValidity()) {
- log("Form did not pass validation checks - will not upload.", "error");
- nativeSubmit();
- } else {
- return true;
- }
- }
- function maybeUploadOnSubmit(formEl) {
- var nativeSubmit = formEl.submit;
- qq(formEl).attach("submit", function(event) {
- event = event || window.event;
- if (event.preventDefault) {
- event.preventDefault();
- } else {
- event.returnValue = false;
+ else {
+ detachLoadEvents[iframe.id] = qq(iframe).attach('load', function(){
+ log('Received response for ' + iframe.id);
+
+ // when we remove iframe from dom
+ // the request stops, but in IE load
+ // event fires
+ if (!iframe.parentNode){
+ return;
}
- validateForm(formEl, nativeSubmit) && startUpload();
- });
- formEl.submit = function() {
- validateForm(formEl, nativeSubmit) && startUpload();
- };
- }
- function determineFormEl(formEl) {
- if (formEl) {
- if (qq.isString(formEl)) {
- formEl = document.getElementById(formEl);
- }
- if (formEl) {
- log("Attaching to form element.");
- determineNewEndpoint(formEl);
- interceptSubmit && maybeUploadOnSubmit(formEl);
- }
- }
- return formEl;
- }
- formEl = determineFormEl(formEl);
- this.attachedToForm = !!formEl;
- };
- qq.extend(qq.FormSupport.prototype, {
- _form2Obj: function(form) {
- "use strict";
- var obj = {}, notIrrelevantType = function(type) {
- var irrelevantTypes = [ "button", "image", "reset", "submit" ];
- return qq.indexOf(irrelevantTypes, type.toLowerCase()) < 0;
- }, radioOrCheckbox = function(type) {
- return qq.indexOf([ "checkbox", "radio" ], type.toLowerCase()) >= 0;
- }, ignoreValue = function(el) {
- if (radioOrCheckbox(el.type) && !el.checked) {
- return true;
- }
- return el.disabled && el.type.toLowerCase() !== "hidden";
- }, selectValue = function(select) {
- var value = null;
- qq.each(qq(select).children(), function(idx, child) {
- if (child.tagName.toLowerCase() === "option" && child.selected) {
- value = child.value;
- return false;
- }
- });
- return value;
- };
- qq.each(form.elements, function(idx, el) {
- if ((qq.isInput(el, true) || el.tagName.toLowerCase() === "textarea") && notIrrelevantType(el.type) && !ignoreValue(el)) {
- obj[el.name] = el.value;
- } else if (el.tagName.toLowerCase() === "select" && !ignoreValue(el)) {
- var value = selectValue(el);
- if (value !== null) {
- obj[el.name] = value;
+
+ try {
+ // fixing Opera 10.53
+ if (iframe.contentDocument &&
+ iframe.contentDocument.body &&
+ iframe.contentDocument.body.innerHTML == "false"){
+ // In Opera event is fired second time
+ // when body.innerHTML changed from false
+ // to server response approx. after 1 sec
+ // when we upload file with iframe
+ return;
}
}
- });
- return obj;
- }
- });
- qq.traditional = qq.traditional || {};
- qq.traditional.FormUploadHandler = function(options, proxy) {
- "use strict";
- var handler = this, getName = proxy.getName, getUuid = proxy.getUuid, log = proxy.log;
- function getIframeContentJson(id, iframe) {
- var response, doc, innerHtml;
- try {
- doc = iframe.contentDocument || iframe.contentWindow.document;
- innerHtml = doc.body.innerHTML;
- log("converting iframe's innerHTML to JSON");
- log("innerHTML = " + innerHtml);
- if (innerHtml && innerHtml.match(/^');
+
+ iframe.setAttribute('id', id);
+
+ iframe.style.display = 'none';
+ document.body.appendChild(iframe);
+
+ return iframe;
+ }
+
+ /**
+ * Creates form, that will be submitted to iframe
+ */
+ function createForm(id, iframe){
+ var params = options.paramsStore.getParams(id),
+ protocol = options.demoMode ? "GET" : "POST",
+ form = qq.toElement(''),
+ endpoint = options.endpointStore.getEndpoint(id),
+ url = endpoint;
+
+ params[options.uuidParamName] = uuids[id];
+
+ if (!options.paramsInBody) {
+ url = qq.obj2url(params, endpoint);
+ }
+ else {
+ qq.obj2Inputs(params, form);
+ }
+
+ form.setAttribute('action', url);
+ form.setAttribute('target', iframe.name);
+ form.style.display = 'none';
+ document.body.appendChild(form);
+
+ return form;
+ }
+
+
+ api = {
+ add: function(fileInput) {
+ fileInput.setAttribute('name', options.inputName);
+
+ var id = inputs.push(fileInput) - 1;
+ uuids[id] = qq.getUniqueId();
+
+ // remove file input from DOM
+ if (fileInput.parentNode){
+ qq(fileInput).remove();
+ }
+
+ return id;
+ },
+ getName: function(id) {
+ /*jslint regexp: true*/
+
+ // get input value and remove path to normalize
+ return inputs[id].value.replace(/.*(\/|\\)/, "");
+ },
+ isValid: function(id) {
+ return inputs[id] !== undefined;
+ },
+ reset: function() {
+ qq.UploadHandler.prototype.reset.apply(this, arguments);
+ inputs = [];
+ uuids = [];
+ detachLoadEvents = {};
+ },
+ getUuid: function(id) {
+ return uuids[id];
+ },
+ cancel: function(id) {
+ options.onCancel(id, this.getName(id));
+
+ delete inputs[id];
+ delete uuids[id];
+ delete detachLoadEvents[id];
+
+ if (options.cors.expected) {
+ clearTimeout(postMessageCallbackTimers[id]);
+ delete postMessageCallbackTimers[id];
+ corsMessageReceiver.stopReceivingMessages(id);
+ }
+
+ var iframe = document.getElementById(id);
+ if (iframe) {
+ // to cancel request set src to something else
+ // we use src="javascript:false;" because it doesn't
+ // trigger ie6 prompt on https
+ iframe.setAttribute('src', 'java' + String.fromCharCode(115) + 'cript:false;'); //deal with "JSLint: javascript URL" warning, which apparently cannot be turned off
+
+ qq(iframe).remove();
+ }
+ },
+ upload: function(id){
+ var input = inputs[id],
+ fileName = api.getName(id),
+ iframe = createIframe(id),
+ form;
+
+ if (!input){
+ throw new Error('file with passed id was not added, or already uploaded or cancelled');
+ }
+
+ options.onUpload(id, this.getName(id));
+
form = createForm(id, iframe);
form.appendChild(input);
- handler._attachLoadEvent(iframe, function(responseFromMessage) {
- log("iframe loaded");
- var response = responseFromMessage ? responseFromMessage : getIframeContentJson(id, iframe);
- handler._detachLoadEvent(id);
+
+ attachLoadEvent(iframe, function(responseFromMessage){
+ log('iframe loaded');
+
+ var response = responseFromMessage ? responseFromMessage : getIframeContentJson(iframe);
+
+ detachLoadEvent(id);
+
+ //we can't remove an iframe if the iframe doesn't belong to the same domain
if (!options.cors.expected) {
qq(iframe).remove();
}
- if (response.success) {
- promise.success(response);
- } else {
- promise.failure(response);
+
+ if (!response.success) {
+ if (options.onAutoRetry(id, fileName, response)) {
+ return;
+ }
}
+ options.onComplete(id, fileName, response);
+ uploadComplete(id);
});
- log("Sending upload request for " + id);
+
+ log('Sending upload request for ' + id);
form.submit();
qq(form).remove();
- return promise;
- };
- qq.extend(this, new qq.FormUploadHandler({
- options: {
- isCors: options.cors.expected,
- inputName: options.inputName
- },
- proxy: {
- onCancel: options.onCancel,
- getName: getName,
- getUuid: getUuid,
- log: log
- }
- }));
+
+ return id;
+ }
};
- qq.traditional = qq.traditional || {};
- qq.traditional.XhrUploadHandler = function(spec, proxy) {
- "use strict";
- var handler = this, getName = proxy.getName, getSize = proxy.getSize, getUuid = proxy.getUuid, log = proxy.log, multipart = spec.forceMultipart || spec.paramsInBody, addChunkingSpecificParams = function(id, params, chunkData) {
- var size = getSize(id), name = getName(id);
- params[spec.chunking.paramNames.partIndex] = chunkData.part;
- params[spec.chunking.paramNames.partByteOffset] = chunkData.start;
- params[spec.chunking.paramNames.chunkSize] = chunkData.size;
- params[spec.chunking.paramNames.totalParts] = chunkData.count;
- params[spec.totalFileSizeName] = size;
- if (multipart) {
- params[spec.filenameParam] = name;
- }
- }, allChunksDoneRequester = new qq.traditional.AllChunksDoneAjaxRequester({
- cors: spec.cors,
- endpoint: spec.chunking.success.endpoint,
- log: log
- }), createReadyStateChangedHandler = function(id, xhr) {
- var promise = new qq.Promise();
- xhr.onreadystatechange = function() {
- if (xhr.readyState === 4) {
- var result = onUploadOrChunkComplete(id, xhr);
- if (result.success) {
- promise.success(result.response, xhr);
- } else {
- promise.failure(result.response, xhr);
- }
- }
- };
- return promise;
- }, getChunksCompleteParams = function(id) {
- var params = spec.paramsStore.get(id), name = getName(id), size = getSize(id);
- params[spec.uuidName] = getUuid(id);
- params[spec.filenameParam] = name;
- params[spec.totalFileSizeName] = size;
- params[spec.chunking.paramNames.totalParts] = handler._getTotalChunks(id);
- return params;
- }, isErrorUploadResponse = function(xhr, response) {
- return qq.indexOf([ 200, 201, 202, 203, 204 ], xhr.status) < 0 || !response.success || response.reset;
- }, onUploadOrChunkComplete = function(id, xhr) {
- var response;
- log("xhr - server response received for " + id);
- log("responseText = " + xhr.responseText);
- response = parseResponse(true, xhr);
- return {
- success: !isErrorUploadResponse(xhr, response),
- response: response
- };
- }, parseResponse = function(upload, xhr) {
- var response = {};
- try {
- log(qq.format("Received response status {} with body: {}", xhr.status, xhr.responseText));
- response = qq.parseJson(xhr.responseText);
- } catch (error) {
- upload && log("Error when attempting to parse xhr response text (" + error.message + ")", "error");
- }
- return response;
- }, sendChunksCompleteRequest = function(id) {
- var promise = new qq.Promise();
- allChunksDoneRequester.complete(id, handler._createXhr(id), getChunksCompleteParams(id), spec.customHeaders.get(id)).then(function(xhr) {
- promise.success(parseResponse(false, xhr), xhr);
- }, function(xhr) {
- promise.failure(parseResponse(false, xhr), xhr);
- });
- return promise;
- }, setParamsAndGetEntityToSend = function(params, xhr, fileOrBlob, id) {
- var formData = new FormData(), method = spec.method, endpoint = spec.endpointStore.get(id), name = getName(id), size = getSize(id);
- params[spec.uuidName] = getUuid(id);
- params[spec.filenameParam] = name;
- if (multipart) {
- params[spec.totalFileSizeName] = size;
- }
- if (!spec.paramsInBody) {
- if (!multipart) {
- params[spec.inputName] = name;
- }
- endpoint = qq.obj2url(params, endpoint);
- }
- xhr.open(method, endpoint, true);
- if (spec.cors.expected && spec.cors.sendCredentials) {
- xhr.withCredentials = true;
- }
- if (multipart) {
- if (spec.paramsInBody) {
- qq.obj2FormData(params, formData);
- }
- formData.append(spec.inputName, fileOrBlob);
- return formData;
- }
- return fileOrBlob;
- }, setUploadHeaders = function(id, xhr) {
- var extraHeaders = spec.customHeaders.get(id), fileOrBlob = handler.getFile(id);
- xhr.setRequestHeader("Accept", "application/json");
- xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
- xhr.setRequestHeader("Cache-Control", "no-cache");
- if (!multipart) {
- xhr.setRequestHeader("Content-Type", "application/octet-stream");
- xhr.setRequestHeader("X-Mime-Type", fileOrBlob.type);
- }
- qq.each(extraHeaders, function(name, val) {
- xhr.setRequestHeader(name, val);
- });
- };
- qq.extend(this, {
- uploadChunk: function(id, chunkIdx, resuming) {
- var chunkData = handler._getChunkData(id, chunkIdx), xhr = handler._createXhr(id, chunkIdx), size = getSize(id), promise, toSend, params;
- promise = createReadyStateChangedHandler(id, xhr);
- handler._registerProgressHandler(id, chunkIdx, chunkData.size);
- params = spec.paramsStore.get(id);
- addChunkingSpecificParams(id, params, chunkData);
- if (resuming) {
- params[spec.resume.paramNames.resuming] = true;
- }
- toSend = setParamsAndGetEntityToSend(params, xhr, chunkData.blob, id);
- setUploadHeaders(id, xhr);
- xhr.send(toSend);
- return promise;
- },
- uploadFile: function(id) {
- var fileOrBlob = handler.getFile(id), promise, xhr, params, toSend;
- xhr = handler._createXhr(id);
- handler._registerProgressHandler(id);
- promise = createReadyStateChangedHandler(id, xhr);
- params = spec.paramsStore.get(id);
- toSend = setParamsAndGetEntityToSend(params, xhr, fileOrBlob, id);
- setUploadHeaders(id, xhr);
- xhr.send(toSend);
- return promise;
- }
- });
- qq.extend(this, new qq.XhrUploadHandler({
- options: qq.extend({
- namespace: "traditional"
- }, spec),
- proxy: qq.extend({
- getEndpoint: spec.endpointStore.get
- }, proxy)
- }));
- qq.override(this, function(super_) {
- return {
- finalizeChunks: function(id) {
- if (spec.chunking.success.endpoint) {
- return sendChunksCompleteRequest(id);
- } else {
- return super_.finalizeChunks(id, qq.bind(parseResponse, this, true));
- }
- }
- };
- });
- };
- qq.traditional.AllChunksDoneAjaxRequester = function(o) {
- "use strict";
- var requester, method = "POST", options = {
- cors: {
- allowXdr: false,
- expected: false,
- sendCredentials: false
- },
- endpoint: null,
- log: function(str, level) {}
- }, promises = {}, endpointHandler = {
- get: function(id) {
- return options.endpoint;
- }
- };
- qq.extend(options, o);
- requester = qq.extend(this, new qq.AjaxRequester({
- acceptHeader: "application/json",
- validMethods: [ method ],
- method: method,
- endpointStore: endpointHandler,
- allowXRequestedWithAndCacheControl: false,
- cors: options.cors,
- log: options.log,
- onComplete: function(id, xhr, isError) {
- var promise = promises[id];
- delete promises[id];
- if (isError) {
- promise.failure(xhr);
- } else {
- promise.success(xhr);
- }
- }
- }));
- qq.extend(this, {
- complete: function(id, xhr, params, headers) {
- var promise = new qq.Promise();
- options.log("Submitting All Chunks Done request for " + id);
- promises[id] = promise;
- requester.initTransport(id).withParams(params).withHeaders(headers).send(xhr);
- return promise;
- }
- });
- };
- qq.DragAndDrop = function(o) {
- "use strict";
- var options, HIDE_ZONES_EVENT_NAME = "qq-hidezones", HIDE_BEFORE_ENTER_ATTR = "qq-hide-dropzone", uploadDropZones = [], droppedFiles = [], disposeSupport = new qq.DisposeSupport();
- options = {
- dropZoneElements: [],
- allowMultipleItems: true,
- classes: {
- dropActive: null
- },
- callbacks: new qq.DragAndDrop.callbacks()
- };
- qq.extend(options, o, true);
- function uploadDroppedFiles(files, uploadDropZone) {
- var filesAsArray = Array.prototype.slice.call(files);
- options.callbacks.dropLog("Grabbed " + files.length + " dropped files.");
- uploadDropZone.dropDisabled(false);
- options.callbacks.processingDroppedFilesComplete(filesAsArray, uploadDropZone.getElement());
+
+ return api;
+};
+/*globals qq, File, XMLHttpRequest, FormData, Blob*/
+qq.UploadHandlerXhr = function(o, uploadCompleteCallback, logCallback) {
+ "use strict";
+
+ var options = o,
+ uploadComplete = uploadCompleteCallback,
+ log = logCallback,
+ fileState = [],
+ cookieItemDelimiter = "|",
+ chunkFiles = options.chunking.enabled && qq.isFileChunkingSupported(),
+ resumeEnabled = options.resume.enabled && chunkFiles && qq.areCookiesEnabled(),
+ resumeId = getResumeId(),
+ multipart = options.forceMultipart || options.paramsInBody,
+ api;
+
+
+ function addChunkingSpecificParams(id, params, chunkData) {
+ var size = api.getSize(id),
+ name = api.getName(id);
+
+ params[options.chunking.paramNames.partIndex] = chunkData.part;
+ params[options.chunking.paramNames.partByteOffset] = chunkData.start;
+ params[options.chunking.paramNames.chunkSize] = chunkData.size;
+ params[options.chunking.paramNames.totalParts] = chunkData.count;
+ params[options.totalFileSizeParamName] = size;
+
+ /**
+ * When a Blob is sent in a multipart request, the filename value in the content-disposition header is either "blob"
+ * or an empty string. So, we will need to include the actual file name as a param in this case.
+ */
+ if (multipart) {
+ params[options.chunking.paramNames.filename] = name;
}
- function traverseFileTree(entry) {
- var parseEntryPromise = new qq.Promise();
- if (entry.isFile) {
- entry.file(function(file) {
- var name = entry.name, fullPath = entry.fullPath, indexOfNameInFullPath = fullPath.indexOf(name);
- fullPath = fullPath.substr(0, indexOfNameInFullPath);
- if (fullPath.charAt(0) === "/") {
- fullPath = fullPath.substr(1);
- }
- file.qqPath = fullPath;
- droppedFiles.push(file);
- parseEntryPromise.success();
- }, function(fileError) {
- options.callbacks.dropLog("Problem parsing '" + entry.fullPath + "'. FileError code " + fileError.code + ".", "error");
- parseEntryPromise.failure();
- });
- } else if (entry.isDirectory) {
- getFilesInDirectory(entry).then(function allEntriesRead(entries) {
- var entriesLeft = entries.length;
- qq.each(entries, function(idx, entry) {
- traverseFileTree(entry).done(function() {
- entriesLeft -= 1;
- if (entriesLeft === 0) {
- parseEntryPromise.success();
- }
- });
- });
- if (!entries.length) {
- parseEntryPromise.success();
- }
- }, function readFailure(fileError) {
- options.callbacks.dropLog("Problem parsing '" + entry.fullPath + "'. FileError code " + fileError.code + ".", "error");
- parseEntryPromise.failure();
- });
- }
- return parseEntryPromise;
+ }
+
+ function addResumeSpecificParams(params) {
+ params[options.resume.paramNames.resuming] = true;
+ }
+
+ function getChunk(fileOrBlob, startByte, endByte) {
+ if (fileOrBlob.slice) {
+ return fileOrBlob.slice(startByte, endByte);
}
- function getFilesInDirectory(entry, reader, accumEntries, existingPromise) {
- var promise = existingPromise || new qq.Promise(), dirReader = reader || entry.createReader();
- dirReader.readEntries(function readSuccess(entries) {
- var newEntries = accumEntries ? accumEntries.concat(entries) : entries;
- if (entries.length) {
- setTimeout(function() {
- getFilesInDirectory(entry, dirReader, newEntries, promise);
- }, 0);
- } else {
- promise.success(newEntries);
- }
- }, promise.failure);
- return promise;
+ else if (fileOrBlob.mozSlice) {
+ return fileOrBlob.mozSlice(startByte, endByte);
}
- function handleDataTransfer(dataTransfer, uploadDropZone) {
- var pendingFolderPromises = [], handleDataTransferPromise = new qq.Promise();
- options.callbacks.processingDroppedFiles();
- uploadDropZone.dropDisabled(true);
- if (dataTransfer.files.length > 1 && !options.allowMultipleItems) {
- options.callbacks.processingDroppedFilesComplete([]);
- options.callbacks.dropError("tooManyFilesError", "");
- uploadDropZone.dropDisabled(false);
- handleDataTransferPromise.failure();
- } else {
- droppedFiles = [];
- if (qq.isFolderDropSupported(dataTransfer)) {
- qq.each(dataTransfer.items, function(idx, item) {
- var entry = item.webkitGetAsEntry();
- if (entry) {
- if (entry.isFile) {
- droppedFiles.push(item.getAsFile());
- } else {
- pendingFolderPromises.push(traverseFileTree(entry).done(function() {
- pendingFolderPromises.pop();
- if (pendingFolderPromises.length === 0) {
- handleDataTransferPromise.success();
- }
- }));
- }
- }
- });
- } else {
- droppedFiles = dataTransfer.files;
- }
- if (pendingFolderPromises.length === 0) {
- handleDataTransferPromise.success();
- }
- }
- return handleDataTransferPromise;
+ else if (fileOrBlob.webkitSlice) {
+ return fileOrBlob.webkitSlice(startByte, endByte);
}
- function setupDropzone(dropArea) {
- var dropZone = new qq.UploadDropZone({
- HIDE_ZONES_EVENT_NAME: HIDE_ZONES_EVENT_NAME,
- element: dropArea,
- onEnter: function(e) {
- qq(dropArea).addClass(options.classes.dropActive);
- e.stopPropagation();
- },
- onLeaveNotDescendants: function(e) {
- qq(dropArea).removeClass(options.classes.dropActive);
- },
- onDrop: function(e) {
- handleDataTransfer(e.dataTransfer, dropZone).then(function() {
- uploadDroppedFiles(droppedFiles, dropZone);
- }, function() {
- options.callbacks.dropLog("Drop event DataTransfer parsing failed. No files will be uploaded.", "error");
- });
- }
- });
- disposeSupport.addDisposer(function() {
- dropZone.dispose();
- });
- qq(dropArea).hasAttribute(HIDE_BEFORE_ENTER_ATTR) && qq(dropArea).hide();
- uploadDropZones.push(dropZone);
- return dropZone;
- }
- function isFileDrag(dragEvent) {
- var fileDrag;
- qq.each(dragEvent.dataTransfer.types, function(key, val) {
- if (val === "Files") {
- fileDrag = true;
- return false;
- }
- });
- return fileDrag;
- }
- function leavingDocumentOut(e) {
- if (qq.safari()) {
- return e.x < 0 || e.y < 0;
- }
- return e.x === 0 && e.y === 0;
- }
- function setupDragDrop() {
- var dropZones = options.dropZoneElements, maybeHideDropZones = function() {
- setTimeout(function() {
- qq.each(dropZones, function(idx, dropZone) {
- qq(dropZone).hasAttribute(HIDE_BEFORE_ENTER_ATTR) && qq(dropZone).hide();
- qq(dropZone).removeClass(options.classes.dropActive);
- });
- }, 10);
- };
- qq.each(dropZones, function(idx, dropZone) {
- var uploadDropZone = setupDropzone(dropZone);
- if (dropZones.length && qq.supportedFeatures.fileDrop) {
- disposeSupport.attach(document, "dragenter", function(e) {
- if (!uploadDropZone.dropDisabled() && isFileDrag(e)) {
- qq.each(dropZones, function(idx, dropZone) {
- if (dropZone instanceof HTMLElement && qq(dropZone).hasAttribute(HIDE_BEFORE_ENTER_ATTR)) {
- qq(dropZone).css({
- display: "block"
- });
- }
- });
- }
- });
- }
- });
- disposeSupport.attach(document, "dragleave", function(e) {
- if (leavingDocumentOut(e)) {
- maybeHideDropZones();
- }
- });
- disposeSupport.attach(qq(document).children()[0], "mouseenter", function(e) {
- maybeHideDropZones();
- });
- disposeSupport.attach(document, "drop", function(e) {
- if (isFileDrag(e)) {
- e.preventDefault();
- maybeHideDropZones();
- }
- });
- disposeSupport.attach(document, HIDE_ZONES_EVENT_NAME, maybeHideDropZones);
- }
- setupDragDrop();
- qq.extend(this, {
- setupExtraDropzone: function(element) {
- options.dropZoneElements.push(element);
- setupDropzone(element);
- },
- removeDropzone: function(element) {
- var i, dzs = options.dropZoneElements;
- for (i in dzs) {
- if (dzs[i] === element) {
- return dzs.splice(i, 1);
- }
- }
- },
- dispose: function() {
- disposeSupport.dispose();
- qq.each(uploadDropZones, function(idx, dropZone) {
- dropZone.dispose();
- });
- }
- });
- };
- qq.DragAndDrop.callbacks = function() {
- "use strict";
+ }
+
+ function getChunkData(id, chunkIndex) {
+ var chunkSize = options.chunking.partSize,
+ fileSize = api.getSize(id),
+ fileOrBlob = fileState[id].file || fileState[id].blobData.blob,
+ startBytes = chunkSize * chunkIndex,
+ endBytes = startBytes+chunkSize >= fileSize ? fileSize : startBytes+chunkSize,
+ totalChunks = getTotalChunks(id);
+
return {
- processingDroppedFiles: function() {},
- processingDroppedFilesComplete: function(files, targetEl) {},
- dropError: function(code, errorSpecifics) {
- qq.log("Drag & drop error code '" + code + " with these specifics: '" + errorSpecifics + "'", "error");
- },
- dropLog: function(message, level) {
- qq.log(message, level);
- }
+ part: chunkIndex,
+ start: startBytes,
+ end: endBytes,
+ count: totalChunks,
+ blob: getChunk(fileOrBlob, startBytes, endBytes),
+ size: endBytes - startBytes
};
- };
- qq.UploadDropZone = function(o) {
- "use strict";
- var disposeSupport = new qq.DisposeSupport(), options, element, preventDrop, dropOutsideDisabled;
- options = {
- element: null,
- onEnter: function(e) {},
- onLeave: function(e) {},
- onLeaveNotDescendants: function(e) {},
- onDrop: function(e) {}
- };
- qq.extend(options, o);
- element = options.element;
- function dragoverShouldBeCanceled() {
- return qq.safari() || qq.firefox() && qq.windows();
- }
- function disableDropOutside(e) {
- if (!dropOutsideDisabled) {
- if (dragoverShouldBeCanceled) {
- disposeSupport.attach(document, "dragover", function(e) {
- e.preventDefault();
- });
- } else {
- disposeSupport.attach(document, "dragover", function(e) {
- if (e.dataTransfer) {
- e.dataTransfer.dropEffect = "none";
- e.preventDefault();
- }
- });
- }
- dropOutsideDisabled = true;
+ }
+
+ function getTotalChunks(id) {
+ var fileSize = api.getSize(id),
+ chunkSize = options.chunking.partSize;
+
+ return Math.ceil(fileSize / chunkSize);
+ }
+
+ function createXhr(id) {
+ var xhr = new XMLHttpRequest();
+
+ fileState[id].xhr = xhr;
+
+ return xhr;
+ }
+
+ function setParamsAndGetEntityToSend(params, xhr, fileOrBlob, id) {
+ var formData = new FormData(),
+ method = options.demoMode ? "GET" : "POST",
+ endpoint = options.endpointStore.getEndpoint(id),
+ url = endpoint,
+ name = api.getName(id),
+ size = api.getSize(id),
+ blobData = fileState[id].blobData;
+
+ params[options.uuidParamName] = fileState[id].uuid;
+
+ if (multipart) {
+ params[options.totalFileSizeParamName] = size;
+
+ if (blobData) {
+ /**
+ * When a Blob is sent in a multipart request, the filename value in the content-disposition header is either "blob"
+ * or an empty string. So, we will need to include the actual file name as a param in this case.
+ */
+ params[options.blobs.paramNames.name] = blobData.name;
}
}
- function isValidFileDrag(e) {
- if (!qq.supportedFeatures.fileDrop) {
- return false;
+
+ //build query string
+ if (!options.paramsInBody) {
+ if (!multipart) {
+ params[options.inputName] = name;
}
- var effectTest, dt = e.dataTransfer, isSafari = qq.safari();
- effectTest = qq.ie() && qq.supportedFeatures.fileDrop ? true : dt.effectAllowed !== "none";
- return dt && effectTest && (dt.files && dt.files.length || !isSafari && dt.types.contains && dt.types.contains("Files") || dt.types.includes && dt.types.includes("Files"));
+ url = qq.obj2url(params, endpoint);
}
- function isOrSetDropDisabled(isDisabled) {
- if (isDisabled !== undefined) {
- preventDrop = isDisabled;
- }
- return preventDrop;
+
+ xhr.open(method, url, true);
+
+ if (options.cors.expected && options.cors.sendCredentials) {
+ xhr.withCredentials = true;
}
- function triggerHidezonesEvent() {
- var hideZonesEvent;
- function triggerUsingOldApi() {
- hideZonesEvent = document.createEvent("Event");
- hideZonesEvent.initEvent(options.HIDE_ZONES_EVENT_NAME, true, true);
+
+ if (multipart) {
+ if (options.paramsInBody) {
+ qq.obj2FormData(params, formData);
}
- if (window.CustomEvent) {
- try {
- hideZonesEvent = new CustomEvent(options.HIDE_ZONES_EVENT_NAME);
- } catch (err) {
- triggerUsingOldApi();
- }
- } else {
- triggerUsingOldApi();
- }
- document.dispatchEvent(hideZonesEvent);
+
+ formData.append(options.inputName, fileOrBlob);
+ return formData;
}
- function attachEvents() {
- disposeSupport.attach(element, "dragover", function(e) {
- if (!isValidFileDrag(e)) {
- return;
- }
- var effect = qq.ie() && qq.supportedFeatures.fileDrop ? null : e.dataTransfer.effectAllowed;
- if (effect === "move" || effect === "linkMove") {
- e.dataTransfer.dropEffect = "move";
- } else {
- e.dataTransfer.dropEffect = "copy";
- }
- e.stopPropagation();
- e.preventDefault();
- });
- disposeSupport.attach(element, "dragenter", function(e) {
- if (!isOrSetDropDisabled()) {
- if (!isValidFileDrag(e)) {
- return;
- }
- options.onEnter(e);
- }
- });
- disposeSupport.attach(element, "dragleave", function(e) {
- if (!isValidFileDrag(e)) {
- return;
- }
- options.onLeave(e);
- var relatedTarget = document.elementFromPoint(e.clientX, e.clientY);
- if (qq(this).contains(relatedTarget)) {
- return;
- }
- options.onLeaveNotDescendants(e);
- });
- disposeSupport.attach(element, "drop", function(e) {
- if (!isOrSetDropDisabled()) {
- if (!isValidFileDrag(e)) {
- return;
- }
- e.preventDefault();
- e.stopPropagation();
- options.onDrop(e);
- triggerHidezonesEvent();
- }
- });
+
+ return fileOrBlob;
+ }
+
+ function setHeaders(id, xhr) {
+ var extraHeaders = options.customHeaders,
+ fileOrBlob = fileState[id].file || fileState[id].blobData.blob;
+
+ xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+ xhr.setRequestHeader("Cache-Control", "no-cache");
+
+ if (!multipart) {
+ xhr.setRequestHeader("Content-Type", "application/octet-stream");
+ //NOTE: return mime type in xhr works on chrome 16.0.9 firefox 11.0a2
+ xhr.setRequestHeader("X-Mime-Type", fileOrBlob.type);
}
- disableDropOutside();
- attachEvents();
- qq.extend(this, {
- dropDisabled: function(isDisabled) {
- return isOrSetDropDisabled(isDisabled);
- },
- dispose: function() {
- disposeSupport.dispose();
- },
- getElement: function() {
- return element;
- }
+
+ qq.each(extraHeaders, function(name, val) {
+ xhr.setRequestHeader(name, val);
});
- this._testing = {};
- this._testing.isValidFileDrag = isValidFileDrag;
- };
- (function() {
- "use strict";
- qq.uiPublicApi = {
- addInitialFiles: function(cannedFileList) {
- this._parent.prototype.addInitialFiles.apply(this, arguments);
- this._templating.addCacheToDom();
- },
- clearStoredFiles: function() {
- this._parent.prototype.clearStoredFiles.apply(this, arguments);
- this._templating.clearFiles();
- },
- addExtraDropzone: function(element) {
- this._dnd && this._dnd.setupExtraDropzone(element);
- },
- removeExtraDropzone: function(element) {
- if (this._dnd) {
- return this._dnd.removeDropzone(element);
- }
- },
- getItemByFileId: function(id) {
- if (!this._templating.isHiddenForever(id)) {
- return this._templating.getFileContainer(id);
- }
- },
- reset: function() {
- this._parent.prototype.reset.apply(this, arguments);
- this._templating.reset();
- if (!this._options.button && this._templating.getButton()) {
- this._defaultButtonId = this._createUploadButton({
- element: this._templating.getButton(),
- title: this._options.text.fileInputTitle
- }).getButtonId();
- }
- if (this._dnd) {
- this._dnd.dispose();
- this._dnd = this._setupDragAndDrop();
- }
- this._totalFilesInBatch = 0;
- this._filesInBatchAddedToUi = 0;
- this._setupClickAndEditEventHandlers();
- },
- setName: function(id, newName) {
- var formattedFilename = this._options.formatFileName(newName);
- this._parent.prototype.setName.apply(this, arguments);
- this._templating.updateFilename(id, formattedFilename);
- },
- pauseUpload: function(id) {
- var paused = this._parent.prototype.pauseUpload.apply(this, arguments);
- paused && this._templating.uploadPaused(id);
- return paused;
- },
- continueUpload: function(id) {
- var continued = this._parent.prototype.continueUpload.apply(this, arguments);
- continued && this._templating.uploadContinued(id);
- return continued;
- },
- getId: function(fileContainerOrChildEl) {
- return this._templating.getFileId(fileContainerOrChildEl);
- },
- getDropTarget: function(fileId) {
- var file = this.getFile(fileId);
- return file.qqDropTarget;
+ }
+
+ function handleCompletedItem(id, response, xhr) {
+ var name = api.getName(id),
+ size = api.getSize(id);
+
+ fileState[id].attemptingResume = false;
+
+ options.onProgress(id, name, size, size);
+
+ options.onComplete(id, name, response, xhr);
+ delete fileState[id].xhr;
+ uploadComplete(id);
+ }
+
+ function uploadNextChunk(id) {
+ var chunkIdx = fileState[id].remainingChunkIdxs[0],
+ chunkData = getChunkData(id, chunkIdx),
+ xhr = createXhr(id),
+ size = api.getSize(id),
+ name = api.getName(id),
+ toSend, params;
+
+ if (fileState[id].loaded === undefined) {
+ fileState[id].loaded = 0;
+ }
+
+ if (resumeEnabled && fileState[id].file) {
+ persistChunkData(id, chunkData);
+ }
+
+ xhr.onreadystatechange = getReadyStateChangeHandler(id, xhr);
+
+ xhr.upload.onprogress = function(e) {
+ if (e.lengthComputable) {
+ var totalLoaded = e.loaded + fileState[id].loaded,
+ estTotalRequestsSize = calcAllRequestsSizeForChunkedUpload(id, chunkIdx, e.total);
+
+ options.onProgress(id, name, totalLoaded, estTotalRequestsSize);
}
};
- qq.uiPrivateApi = {
- _getButton: function(buttonId) {
- var button = this._parent.prototype._getButton.apply(this, arguments);
- if (!button) {
- if (buttonId === this._defaultButtonId) {
- button = this._templating.getButton();
- }
- }
- return button;
- },
- _removeFileItem: function(fileId) {
- this._templating.removeFile(fileId);
- },
- _setupClickAndEditEventHandlers: function() {
- this._fileButtonsClickHandler = qq.FileButtonsClickHandler && this._bindFileButtonsClickEvent();
- this._focusinEventSupported = !qq.firefox();
- if (this._isEditFilenameEnabled()) {
- this._filenameClickHandler = this._bindFilenameClickEvent();
- this._filenameInputFocusInHandler = this._bindFilenameInputFocusInEvent();
- this._filenameInputFocusHandler = this._bindFilenameInputFocusEvent();
- }
- },
- _setupDragAndDrop: function() {
- var self = this, dropZoneElements = this._options.dragAndDrop.extraDropzones, templating = this._templating, defaultDropZone = templating.getDropZone();
- defaultDropZone && dropZoneElements.push(defaultDropZone);
- return new qq.DragAndDrop({
- dropZoneElements: dropZoneElements,
- allowMultipleItems: this._options.multiple,
- classes: {
- dropActive: this._options.classes.dropActive
- },
- callbacks: {
- processingDroppedFiles: function() {
- templating.showDropProcessing();
- },
- processingDroppedFilesComplete: function(files, targetEl) {
- templating.hideDropProcessing();
- qq.each(files, function(idx, file) {
- file.qqDropTarget = targetEl;
- });
- if (files.length) {
- self.addFiles(files, null, null);
- }
- },
- dropError: function(code, errorData) {
- self._itemError(code, errorData);
- },
- dropLog: function(message, level) {
- self.log(message, level);
- }
- }
- });
- },
- _bindFileButtonsClickEvent: function() {
- var self = this;
- return new qq.FileButtonsClickHandler({
- templating: this._templating,
- log: function(message, lvl) {
- self.log(message, lvl);
- },
- onDeleteFile: function(fileId) {
- self.deleteFile(fileId);
- },
- onCancel: function(fileId) {
- self.cancel(fileId);
- },
- onRetry: function(fileId) {
- self.retry(fileId);
- },
- onPause: function(fileId) {
- self.pauseUpload(fileId);
- },
- onContinue: function(fileId) {
- self.continueUpload(fileId);
- },
- onGetName: function(fileId) {
- return self.getName(fileId);
- }
- });
- },
- _isEditFilenameEnabled: function() {
- return this._templating.isEditFilenamePossible() && !this._options.autoUpload && qq.FilenameClickHandler && qq.FilenameInputFocusHandler && qq.FilenameInputFocusHandler;
- },
- _filenameEditHandler: function() {
- var self = this, templating = this._templating;
+
+ options.onUploadChunk(id, name, getChunkDataForCallback(chunkData));
+
+ params = options.paramsStore.getParams(id);
+ addChunkingSpecificParams(id, params, chunkData);
+
+ if (fileState[id].attemptingResume) {
+ addResumeSpecificParams(params);
+ }
+
+ toSend = setParamsAndGetEntityToSend(params, xhr, chunkData.blob, id);
+ setHeaders(id, xhr);
+
+ log('Sending chunked upload request for item ' + id + ": bytes " + (chunkData.start+1) + "-" + chunkData.end + " of " + size);
+ xhr.send(toSend);
+ }
+
+ function calcAllRequestsSizeForChunkedUpload(id, chunkIdx, requestSize) {
+ var chunkData = getChunkData(id, chunkIdx),
+ blobSize = chunkData.size,
+ overhead = requestSize - blobSize,
+ size = api.getSize(id),
+ chunkCount = chunkData.count,
+ initialRequestOverhead = fileState[id].initialRequestOverhead,
+ overheadDiff = overhead - initialRequestOverhead;
+
+ fileState[id].lastRequestOverhead = overhead;
+
+ if (chunkIdx === 0) {
+ fileState[id].lastChunkIdxProgress = 0;
+ fileState[id].initialRequestOverhead = overhead;
+ fileState[id].estTotalRequestsSize = size + (chunkCount * overhead);
+ }
+ else if (fileState[id].lastChunkIdxProgress !== chunkIdx) {
+ fileState[id].lastChunkIdxProgress = chunkIdx;
+ fileState[id].estTotalRequestsSize += overheadDiff;
+ }
+
+ return fileState[id].estTotalRequestsSize;
+ }
+
+ function getLastRequestOverhead(id) {
+ if (multipart) {
+ return fileState[id].lastRequestOverhead;
+ }
+ else {
+ return 0;
+ }
+ }
+
+ function handleSuccessfullyCompletedChunk(id, response, xhr) {
+ var chunkIdx = fileState[id].remainingChunkIdxs.shift(),
+ chunkData = getChunkData(id, chunkIdx);
+
+ fileState[id].attemptingResume = false;
+ fileState[id].loaded += chunkData.size + getLastRequestOverhead(id);
+
+ if (fileState[id].remainingChunkIdxs.length > 0) {
+ uploadNextChunk(id);
+ }
+ else {
+ if (resumeEnabled) {
+ deletePersistedChunkData(id);
+ }
+
+ handleCompletedItem(id, response, xhr);
+ }
+ }
+
+ function isErrorResponse(xhr, response) {
+ return xhr.status !== 200 || !response.success || response.reset;
+ }
+
+ function parseResponse(xhr) {
+ var response;
+
+ try {
+ response = qq.parseJson(xhr.responseText);
+ }
+ catch(error) {
+ log('Error when attempting to parse xhr response text (' + error + ')', 'error');
+ response = {};
+ }
+
+ return response;
+ }
+
+ function handleResetResponse(id) {
+ log('Server has ordered chunking effort to be restarted on next attempt for item ID ' + id, 'error');
+
+ if (resumeEnabled) {
+ deletePersistedChunkData(id);
+ fileState[id].attemptingResume = false;
+ }
+
+ fileState[id].remainingChunkIdxs = [];
+ delete fileState[id].loaded;
+ delete fileState[id].estTotalRequestsSize;
+ delete fileState[id].initialRequestOverhead;
+ }
+
+ function handleResetResponseOnResumeAttempt(id) {
+ fileState[id].attemptingResume = false;
+ log("Server has declared that it cannot handle resume for item ID " + id + " - starting from the first chunk", 'error');
+ handleResetResponse(id);
+ api.upload(id, true);
+ }
+
+ function handleNonResetErrorResponse(id, response, xhr) {
+ var name = api.getName(id);
+
+ if (options.onAutoRetry(id, name, response, xhr)) {
+ return;
+ }
+ else {
+ handleCompletedItem(id, response, xhr);
+ }
+ }
+
+ function onComplete(id, xhr) {
+ var response;
+
+ // the request was aborted/cancelled
+ if (!fileState[id]) {
+ return;
+ }
+
+ log("xhr - server response received for " + id);
+ log("responseText = " + xhr.responseText);
+ response = parseResponse(xhr);
+
+ if (isErrorResponse(xhr, response)) {
+ if (response.reset) {
+ handleResetResponse(id);
+ }
+
+ if (fileState[id].attemptingResume && response.reset) {
+ handleResetResponseOnResumeAttempt(id);
+ }
+ else {
+ handleNonResetErrorResponse(id, response, xhr);
+ }
+ }
+ else if (chunkFiles) {
+ handleSuccessfullyCompletedChunk(id, response, xhr);
+ }
+ else {
+ handleCompletedItem(id, response, xhr);
+ }
+ }
+
+ function getChunkDataForCallback(chunkData) {
+ return {
+ partIndex: chunkData.part,
+ startByte: chunkData.start + 1,
+ endByte: chunkData.end,
+ totalParts: chunkData.count
+ };
+ }
+
+ function getReadyStateChangeHandler(id, xhr) {
+ return function() {
+ if (xhr.readyState === 4) {
+ onComplete(id, xhr);
+ }
+ };
+ }
+
+ function persistChunkData(id, chunkData) {
+ var fileUuid = api.getUuid(id),
+ lastByteSent = fileState[id].loaded,
+ initialRequestOverhead = fileState[id].initialRequestOverhead,
+ estTotalRequestsSize = fileState[id].estTotalRequestsSize,
+ cookieName = getChunkDataCookieName(id),
+ cookieValue = fileUuid +
+ cookieItemDelimiter + chunkData.part +
+ cookieItemDelimiter + lastByteSent +
+ cookieItemDelimiter + initialRequestOverhead +
+ cookieItemDelimiter + estTotalRequestsSize,
+ cookieExpDays = options.resume.cookiesExpireIn;
+
+ qq.setCookie(cookieName, cookieValue, cookieExpDays);
+ }
+
+ function deletePersistedChunkData(id) {
+ if (fileState[id].file) {
+ var cookieName = getChunkDataCookieName(id);
+ qq.deleteCookie(cookieName);
+ }
+ }
+
+ function getPersistedChunkData(id) {
+ var chunkCookieValue = qq.getCookie(getChunkDataCookieName(id)),
+ filename = api.getName(id),
+ sections, uuid, partIndex, lastByteSent, initialRequestOverhead, estTotalRequestsSize;
+
+ if (chunkCookieValue) {
+ sections = chunkCookieValue.split(cookieItemDelimiter);
+
+ if (sections.length === 5) {
+ uuid = sections[0];
+ partIndex = parseInt(sections[1], 10);
+ lastByteSent = parseInt(sections[2], 10);
+ initialRequestOverhead = parseInt(sections[3], 10);
+ estTotalRequestsSize = parseInt(sections[4], 10);
+
return {
- templating: templating,
- log: function(message, lvl) {
- self.log(message, lvl);
- },
- onGetUploadStatus: function(fileId) {
- return self.getUploads({
- id: fileId
- }).status;
- },
- onGetName: function(fileId) {
- return self.getName(fileId);
- },
- onSetName: function(id, newName) {
- self.setName(id, newName);
- },
- onEditingStatusChange: function(id, isEditing) {
- var qqInput = qq(templating.getEditInput(id)), qqFileContainer = qq(templating.getFileContainer(id));
- if (isEditing) {
- qqInput.addClass("qq-editing");
- templating.hideFilename(id);
- templating.hideEditIcon(id);
- } else {
- qqInput.removeClass("qq-editing");
- templating.showFilename(id);
- templating.showEditIcon(id);
- }
- qqFileContainer.addClass("qq-temp").removeClass("qq-temp");
- }
+ uuid: uuid,
+ part: partIndex,
+ lastByteSent: lastByteSent,
+ initialRequestOverhead: initialRequestOverhead,
+ estTotalRequestsSize: estTotalRequestsSize
};
- },
- _onUploadStatusChange: function(id, oldStatus, newStatus) {
- this._parent.prototype._onUploadStatusChange.apply(this, arguments);
- if (this._isEditFilenameEnabled()) {
- if (this._templating.getFileContainer(id) && newStatus !== qq.status.SUBMITTED) {
- this._templating.markFilenameEditable(id);
- this._templating.hideEditIcon(id);
+ }
+ else {
+ log('Ignoring previously stored resume/chunk cookie for ' + filename + " - old cookie format", "warn");
+ }
+ }
+ }
+
+ function getChunkDataCookieName(id) {
+ var filename = api.getName(id),
+ fileSize = api.getSize(id),
+ maxChunkSize = options.chunking.partSize,
+ cookieName;
+
+ cookieName = "qqfilechunk" + cookieItemDelimiter + encodeURIComponent(filename) + cookieItemDelimiter + fileSize + cookieItemDelimiter + maxChunkSize;
+
+ if (resumeId !== undefined) {
+ cookieName += cookieItemDelimiter + resumeId;
+ }
+
+ return cookieName;
+ }
+
+ function getResumeId() {
+ if (options.resume.id !== null &&
+ options.resume.id !== undefined &&
+ !qq.isFunction(options.resume.id) &&
+ !qq.isObject(options.resume.id)) {
+
+ return options.resume.id;
+ }
+ }
+
+ function handleFileChunkingUpload(id, retry) {
+ var name = api.getName(id),
+ firstChunkIndex = 0,
+ persistedChunkInfoForResume, firstChunkDataForResume, currentChunkIndex;
+
+ if (!fileState[id].remainingChunkIdxs || fileState[id].remainingChunkIdxs.length === 0) {
+ fileState[id].remainingChunkIdxs = [];
+
+ if (resumeEnabled && !retry && fileState[id].file) {
+ persistedChunkInfoForResume = getPersistedChunkData(id);
+ if (persistedChunkInfoForResume) {
+ firstChunkDataForResume = getChunkData(id, persistedChunkInfoForResume.part);
+ if (options.onResume(id, name, getChunkDataForCallback(firstChunkDataForResume)) !== false) {
+ firstChunkIndex = persistedChunkInfoForResume.part;
+ fileState[id].uuid = persistedChunkInfoForResume.uuid;
+ fileState[id].loaded = persistedChunkInfoForResume.lastByteSent;
+ fileState[id].estTotalRequestsSize = persistedChunkInfoForResume.estTotalRequestsSize;
+ fileState[id].initialRequestOverhead = persistedChunkInfoForResume.initialRequestOverhead;
+ fileState[id].attemptingResume = true;
+ log('Resuming ' + name + " at partition index " + firstChunkIndex);
}
}
- if (oldStatus === qq.status.UPLOAD_RETRYING && newStatus === qq.status.UPLOADING) {
- this._templating.hideRetry(id);
- this._templating.setStatusText(id);
- qq(this._templating.getFileContainer(id)).removeClass(this._classes.retrying);
- } else if (newStatus === qq.status.UPLOAD_FAILED) {
- this._templating.hidePause(id);
- }
- },
- _bindFilenameInputFocusInEvent: function() {
- var spec = qq.extend({}, this._filenameEditHandler());
- return new qq.FilenameInputFocusInHandler(spec);
- },
- _bindFilenameInputFocusEvent: function() {
- var spec = qq.extend({}, this._filenameEditHandler());
- return new qq.FilenameInputFocusHandler(spec);
- },
- _bindFilenameClickEvent: function() {
- var spec = qq.extend({}, this._filenameEditHandler());
- return new qq.FilenameClickHandler(spec);
- },
- _storeForLater: function(id) {
- this._parent.prototype._storeForLater.apply(this, arguments);
- this._templating.hideSpinner(id);
- },
- _onAllComplete: function(successful, failed) {
- this._parent.prototype._onAllComplete.apply(this, arguments);
- this._templating.resetTotalProgress();
- },
- _onSubmit: function(id, name) {
- var file = this.getFile(id);
- if (file && file.qqPath && this._options.dragAndDrop.reportDirectoryPaths) {
- this._paramsStore.addReadOnly(id, {
- qqpath: file.qqPath
- });
- }
- this._parent.prototype._onSubmit.apply(this, arguments);
- this._addToList(id, name);
- },
- _onSubmitted: function(id) {
- if (this._isEditFilenameEnabled()) {
- this._templating.markFilenameEditable(id);
- this._templating.showEditIcon(id);
- if (!this._focusinEventSupported) {
- this._filenameInputFocusHandler.addHandler(this._templating.getEditInput(id));
- }
- }
- },
- _onProgress: function(id, name, loaded, total) {
- this._parent.prototype._onProgress.apply(this, arguments);
- this._templating.updateProgress(id, loaded, total);
- if (total === 0 || Math.round(loaded / total * 100) === 100) {
- this._templating.hideCancel(id);
- this._templating.hidePause(id);
- this._templating.hideProgress(id);
- this._templating.setStatusText(id, this._options.text.waitingForResponse);
- this._displayFileSize(id);
- } else {
- this._displayFileSize(id, loaded, total);
- }
- },
- _onTotalProgress: function(loaded, total) {
- this._parent.prototype._onTotalProgress.apply(this, arguments);
- this._templating.updateTotalProgress(loaded, total);
- },
- _onComplete: function(id, name, result, xhr) {
- var parentRetVal = this._parent.prototype._onComplete.apply(this, arguments), templating = this._templating, fileContainer = templating.getFileContainer(id), self = this;
- function completeUpload(result) {
- if (!fileContainer) {
- return;
- }
- templating.setStatusText(id);
- qq(fileContainer).removeClass(self._classes.retrying);
- templating.hideProgress(id);
- if (self.getUploads({
- id: id
- }).status !== qq.status.UPLOAD_FAILED) {
- templating.hideCancel(id);
- }
- templating.hideSpinner(id);
- if (result.success) {
- self._markFileAsSuccessful(id);
- } else {
- qq(fileContainer).addClass(self._classes.fail);
- templating.showCancel(id);
- if (templating.isRetryPossible() && !self._preventRetries[id]) {
- qq(fileContainer).addClass(self._classes.retryable);
- templating.showRetry(id);
- }
- self._controlFailureTextDisplay(id, result);
- }
- }
- if (parentRetVal instanceof qq.Promise) {
- parentRetVal.done(function(newResult) {
- completeUpload(newResult);
- });
- } else {
- completeUpload(result);
- }
- return parentRetVal;
- },
- _markFileAsSuccessful: function(id) {
- var templating = this._templating;
- if (this._isDeletePossible()) {
- templating.showDeleteButton(id);
- }
- qq(templating.getFileContainer(id)).addClass(this._classes.success);
- this._maybeUpdateThumbnail(id);
- },
- _onUploadPrep: function(id) {
- this._parent.prototype._onUploadPrep.apply(this, arguments);
- this._templating.showSpinner(id);
- },
- _onUpload: function(id, name) {
- var parentRetVal = this._parent.prototype._onUpload.apply(this, arguments);
- this._templating.showSpinner(id);
- return parentRetVal;
- },
- _onUploadChunk: function(id, chunkData) {
- this._parent.prototype._onUploadChunk.apply(this, arguments);
- if (chunkData.partIndex > 0 && this._handler.isResumable(id)) {
- this._templating.allowPause(id);
- }
- },
- _onCancel: function(id, name) {
- this._parent.prototype._onCancel.apply(this, arguments);
- this._removeFileItem(id);
- if (this._getNotFinished() === 0) {
- this._templating.resetTotalProgress();
- }
- },
- _onBeforeAutoRetry: function(id) {
- var retryNumForDisplay, maxAuto, retryNote;
- this._parent.prototype._onBeforeAutoRetry.apply(this, arguments);
- this._showCancelLink(id);
- if (this._options.retry.showAutoRetryNote) {
- retryNumForDisplay = this._autoRetries[id];
- maxAuto = this._options.retry.maxAutoAttempts;
- retryNote = this._options.retry.autoRetryNote.replace(/\{retryNum\}/g, retryNumForDisplay);
- retryNote = retryNote.replace(/\{maxAuto\}/g, maxAuto);
- this._templating.setStatusText(id, retryNote);
- qq(this._templating.getFileContainer(id)).addClass(this._classes.retrying);
- }
- },
- _onBeforeManualRetry: function(id) {
- if (this._parent.prototype._onBeforeManualRetry.apply(this, arguments)) {
- this._templating.resetProgress(id);
- qq(this._templating.getFileContainer(id)).removeClass(this._classes.fail);
- this._templating.setStatusText(id);
- this._templating.showSpinner(id);
- this._showCancelLink(id);
- return true;
- } else {
- qq(this._templating.getFileContainer(id)).addClass(this._classes.retryable);
- this._templating.showRetry(id);
- return false;
- }
- },
- _onSubmitDelete: function(id) {
- var onSuccessCallback = qq.bind(this._onSubmitDeleteSuccess, this);
- this._parent.prototype._onSubmitDelete.call(this, id, onSuccessCallback);
- },
- _onSubmitDeleteSuccess: function(id, uuid, additionalMandatedParams) {
- if (this._options.deleteFile.forceConfirm) {
- this._showDeleteConfirm.apply(this, arguments);
- } else {
- this._sendDeleteRequest.apply(this, arguments);
- }
- },
- _onDeleteComplete: function(id, xhr, isError) {
- this._parent.prototype._onDeleteComplete.apply(this, arguments);
- this._templating.hideSpinner(id);
- if (isError) {
- this._templating.setStatusText(id, this._options.deleteFile.deletingFailedText);
- this._templating.showDeleteButton(id);
- } else {
- this._removeFileItem(id);
- }
- },
- _sendDeleteRequest: function(id, uuid, additionalMandatedParams) {
- this._templating.hideDeleteButton(id);
- this._templating.showSpinner(id);
- this._templating.setStatusText(id, this._options.deleteFile.deletingStatusText);
- this._deleteHandler.sendDelete.apply(this, arguments);
- },
- _showDeleteConfirm: function(id, uuid, mandatedParams) {
- var fileName = this.getName(id), confirmMessage = this._options.deleteFile.confirmMessage.replace(/\{filename\}/g, fileName), uuid = this.getUuid(id), deleteRequestArgs = arguments, self = this, retVal;
- retVal = this._options.showConfirm(confirmMessage);
- if (qq.isGenericPromise(retVal)) {
- retVal.then(function() {
- self._sendDeleteRequest.apply(self, deleteRequestArgs);
- });
- } else if (retVal !== false) {
- self._sendDeleteRequest.apply(self, deleteRequestArgs);
- }
- },
- _addToList: function(id, name, canned) {
- var prependData, prependIndex = 0, dontDisplay = this._handler.isProxied(id) && this._options.scaling.hideScaled, record;
- if (this._options.display.prependFiles) {
- if (this._totalFilesInBatch > 1 && this._filesInBatchAddedToUi > 0) {
- prependIndex = this._filesInBatchAddedToUi - 1;
- }
- prependData = {
- index: prependIndex
- };
- }
- if (!canned) {
- if (this._options.disableCancelForFormUploads && !qq.supportedFeatures.ajaxUploading) {
- this._templating.disableCancel();
- }
- if (!this._options.multiple) {
- record = this.getUploads({
- id: id
- });
- this._handledProxyGroup = this._handledProxyGroup || record.proxyGroupId;
- if (record.proxyGroupId !== this._handledProxyGroup || !record.proxyGroupId) {
- this._handler.cancelAll();
- this._clearList();
- this._handledProxyGroup = null;
- }
- }
- }
- if (canned) {
- this._templating.addFileToCache(id, this._options.formatFileName(name), prependData, dontDisplay);
- this._templating.updateThumbnail(id, this._thumbnailUrls[id], true, this._options.thumbnails.customResizer);
- } else {
- this._templating.addFile(id, this._options.formatFileName(name), prependData, dontDisplay);
- this._templating.generatePreview(id, this.getFile(id), this._options.thumbnails.customResizer);
- }
- this._filesInBatchAddedToUi += 1;
- if (canned || this._options.display.fileSizeOnSubmit && qq.supportedFeatures.ajaxUploading) {
- this._displayFileSize(id);
- }
- },
- _clearList: function() {
- this._templating.clearFiles();
- this.clearStoredFiles();
- },
- _displayFileSize: function(id, loadedSize, totalSize) {
- var size = this.getSize(id), sizeForDisplay = this._formatSize(size);
- if (size >= 0) {
- if (loadedSize !== undefined && totalSize !== undefined) {
- sizeForDisplay = this._formatProgress(loadedSize, totalSize);
- }
- this._templating.updateSize(id, sizeForDisplay);
- }
- },
- _formatProgress: function(uploadedSize, totalSize) {
- var message = this._options.text.formatProgress;
- function r(name, replacement) {
- message = message.replace(name, replacement);
- }
- r("{percent}", Math.round(uploadedSize / totalSize * 100));
- r("{total_size}", this._formatSize(totalSize));
- return message;
- },
- _controlFailureTextDisplay: function(id, response) {
- var mode, responseProperty, failureReason;
- mode = this._options.failedUploadTextDisplay.mode;
- responseProperty = this._options.failedUploadTextDisplay.responseProperty;
- if (mode === "custom") {
- failureReason = response[responseProperty];
- if (!failureReason) {
- failureReason = this._options.text.failUpload;
- }
- this._templating.setStatusText(id, failureReason);
- if (this._options.failedUploadTextDisplay.enableTooltip) {
- this._showTooltip(id, failureReason);
- }
- } else if (mode === "default") {
- this._templating.setStatusText(id, this._options.text.failUpload);
- } else if (mode !== "none") {
- this.log("failedUploadTextDisplay.mode value of '" + mode + "' is not valid", "warn");
- }
- },
- _showTooltip: function(id, text) {
- this._templating.getFileContainer(id).title = text;
- },
- _showCancelLink: function(id) {
- if (!this._options.disableCancelForFormUploads || qq.supportedFeatures.ajaxUploading) {
- this._templating.showCancel(id);
- }
- },
- _itemError: function(code, name, item) {
- var message = this._parent.prototype._itemError.apply(this, arguments);
- this._options.showMessage(message);
- },
- _batchError: function(message) {
- this._parent.prototype._batchError.apply(this, arguments);
- this._options.showMessage(message);
- },
- _setupPastePrompt: function() {
- var self = this;
- this._options.callbacks.onPasteReceived = function() {
- var message = self._options.paste.namePromptMessage, defaultVal = self._options.paste.defaultName;
- return self._options.showPrompt(message, defaultVal);
- };
- },
- _fileOrBlobRejected: function(id, name) {
- this._totalFilesInBatch -= 1;
- this._parent.prototype._fileOrBlobRejected.apply(this, arguments);
- },
- _prepareItemsForUpload: function(items, params, endpoint) {
- this._totalFilesInBatch = items.length;
- this._filesInBatchAddedToUi = 0;
- this._parent.prototype._prepareItemsForUpload.apply(this, arguments);
- },
- _maybeUpdateThumbnail: function(fileId) {
- var thumbnailUrl = this._thumbnailUrls[fileId], fileStatus = this.getUploads({
- id: fileId
- }).status;
- if (fileStatus !== qq.status.DELETED && (thumbnailUrl || this._options.thumbnails.placeholders.waitUntilResponse || !qq.supportedFeatures.imagePreviews)) {
- this._templating.updateThumbnail(fileId, thumbnailUrl, this._options.thumbnails.customResizer);
- }
- },
- _addCannedFile: function(sessionData) {
- var id = this._parent.prototype._addCannedFile.apply(this, arguments);
- this._addToList(id, this.getName(id), true);
- this._templating.hideSpinner(id);
- this._templating.hideCancel(id);
- this._markFileAsSuccessful(id);
- return id;
- },
- _setSize: function(id, newSize) {
- this._parent.prototype._setSize.apply(this, arguments);
- this._templating.updateSize(id, this._formatSize(newSize));
- },
- _sessionRequestComplete: function() {
- this._templating.addCacheToDom();
- this._parent.prototype._sessionRequestComplete.apply(this, arguments);
+ }
+
+ for (currentChunkIndex = getTotalChunks(id)-1; currentChunkIndex >= firstChunkIndex; currentChunkIndex-=1) {
+ fileState[id].remainingChunkIdxs.unshift(currentChunkIndex);
+ }
+ }
+
+ uploadNextChunk(id);
+ }
+
+ function handleStandardFileUpload(id) {
+ var fileOrBlob = fileState[id].file || fileState[id].blobData.blob,
+ name = api.getName(id),
+ xhr, params, toSend;
+
+ fileState[id].loaded = 0;
+
+ xhr = createXhr(id);
+
+ xhr.upload.onprogress = function(e){
+ if (e.lengthComputable){
+ fileState[id].loaded = e.loaded;
+ options.onProgress(id, name, e.loaded, e.total);
}
};
- })();
- qq.FineUploader = function(o, namespace) {
- "use strict";
- var self = this;
- this._parent = namespace ? qq[namespace].FineUploaderBasic : qq.FineUploaderBasic;
- this._parent.apply(this, arguments);
- qq.extend(this._options, {
- element: null,
- button: null,
- listElement: null,
- dragAndDrop: {
- extraDropzones: [],
- reportDirectoryPaths: false
- },
- text: {
- formatProgress: "{percent}% of {total_size}",
- failUpload: "Upload failed",
- waitingForResponse: "Processing...",
- paused: "Paused"
- },
- template: "qq-template",
- classes: {
- retrying: "qq-upload-retrying",
- retryable: "qq-upload-retryable",
- success: "qq-upload-success",
- fail: "qq-upload-fail",
- editable: "qq-editable",
- hide: "qq-hide",
- dropActive: "qq-upload-drop-area-active"
- },
- failedUploadTextDisplay: {
- mode: "default",
- responseProperty: "error",
- enableTooltip: true
- },
- messages: {
- tooManyFilesError: "You may only drop one file",
- unsupportedBrowser: "Unrecoverable error - this browser does not permit file uploading of any kind."
- },
- retry: {
- showAutoRetryNote: true,
- autoRetryNote: "Retrying {retryNum}/{maxAuto}..."
- },
- deleteFile: {
- forceConfirm: false,
- confirmMessage: "Are you sure you want to delete {filename}?",
- deletingStatusText: "Deleting...",
- deletingFailedText: "Delete failed"
- },
- display: {
- fileSizeOnSubmit: false,
- prependFiles: false
- },
- paste: {
- promptForName: false,
- namePromptMessage: "Please name this image"
- },
- thumbnails: {
- customResizer: null,
- maxCount: 0,
- placeholders: {
- waitUntilResponse: false,
- notAvailablePath: null,
- waitingPath: null
- },
- timeBetweenThumbs: 750
- },
- scaling: {
- hideScaled: false
- },
- showMessage: function(message) {
- if (self._templating.hasDialog("alert")) {
- return self._templating.showDialog("alert", message);
- } else {
- setTimeout(function() {
- window.alert(message);
- }, 0);
+
+ xhr.onreadystatechange = getReadyStateChangeHandler(id, xhr);
+
+ params = options.paramsStore.getParams(id);
+ toSend = setParamsAndGetEntityToSend(params, xhr, fileOrBlob, id);
+ setHeaders(id, xhr);
+
+ log('Sending upload request for ' + id);
+ xhr.send(toSend);
+ }
+
+
+ api = {
+ /**
+ * Adds File or Blob to the queue
+ * Returns id to use with upload, cancel
+ **/
+ add: function(fileOrBlobData){
+ var id;
+
+ if (fileOrBlobData instanceof File) {
+ id = fileState.push({file: fileOrBlobData}) - 1;
+ }
+ else if (fileOrBlobData.blob instanceof Blob) {
+ id = fileState.push({blobData: fileOrBlobData}) - 1;
+ }
+ else {
+ throw new Error('Passed obj in not a File or BlobData (in qq.UploadHandlerXhr)');
+ }
+
+ fileState[id].uuid = qq.getUniqueId();
+ return id;
+ },
+ getName: function(id){
+ var file = fileState[id].file,
+ blobData = fileState[id].blobData;
+
+ if (file) {
+ // fix missing name in Safari 4
+ //NOTE: fixed missing name firefox 11.0a2 file.fileName is actually undefined
+ return (file.fileName !== null && file.fileName !== undefined) ? file.fileName : file.name;
+ }
+ else {
+ return blobData.name;
+ }
+ },
+ getSize: function(id){
+ /*jshint eqnull: true*/
+ var fileOrBlob = fileState[id].file || fileState[id].blobData.blob;
+
+ if (qq.isFileOrInput(fileOrBlob)) {
+ return fileOrBlob.fileSize != null ? fileOrBlob.fileSize : fileOrBlob.size;
+ }
+ else {
+ return fileOrBlob.size;
+ }
+ },
+ getFile: function(id) {
+ if (fileState[id]) {
+ return fileState[id].file || fileState[id].blobData.blob;
+ }
+ },
+ /**
+ * Returns uploaded bytes for file identified by id
+ */
+ getLoaded: function(id){
+ return fileState[id].loaded || 0;
+ },
+ isValid: function(id) {
+ return fileState[id] !== undefined;
+ },
+ reset: function() {
+ fileState = [];
+ },
+ getUuid: function(id) {
+ return fileState[id].uuid;
+ },
+ /**
+ * Sends the file identified by id to the server
+ */
+ upload: function(id, retry){
+ var name = this.getName(id);
+
+ options.onUpload(id, name);
+
+ if (chunkFiles) {
+ handleFileChunkingUpload(id, retry);
+ }
+ else {
+ handleStandardFileUpload(id);
+ }
+ },
+ cancel: function(id){
+ var xhr = fileState[id].xhr;
+
+ options.onCancel(id, this.getName(id));
+
+ if (xhr) {
+ xhr.onreadystatechange = null;
+ xhr.abort();
+ }
+
+ if (resumeEnabled) {
+ deletePersistedChunkData(id);
+ }
+
+ delete fileState[id];
+ },
+ getResumableFilesData: function() {
+ var matchingCookieNames = [],
+ resumableFilesData = [];
+
+ if (chunkFiles && resumeEnabled) {
+ if (resumeId === undefined) {
+ matchingCookieNames = qq.getCookieNames(new RegExp("^qqfilechunk\\" + cookieItemDelimiter + ".+\\" +
+ cookieItemDelimiter + "\\d+\\" + cookieItemDelimiter + options.chunking.partSize + "="));
}
- },
- showConfirm: function(message) {
- if (self._templating.hasDialog("confirm")) {
- return self._templating.showDialog("confirm", message);
- } else {
- return window.confirm(message);
+ else {
+ matchingCookieNames = qq.getCookieNames(new RegExp("^qqfilechunk\\" + cookieItemDelimiter + ".+\\" +
+ cookieItemDelimiter + "\\d+\\" + cookieItemDelimiter + options.chunking.partSize + "\\" +
+ cookieItemDelimiter + resumeId + "="));
}
- },
- showPrompt: function(message, defaultValue) {
- if (self._templating.hasDialog("prompt")) {
- return self._templating.showDialog("prompt", message, defaultValue);
- } else {
- return window.prompt(message, defaultValue);
- }
- }
- }, true);
- qq.extend(this._options, o, true);
- this._templating = new qq.Templating({
- log: qq.bind(this.log, this),
- templateIdOrEl: this._options.template,
- containerEl: this._options.element,
- fileContainerEl: this._options.listElement,
- button: this._options.button,
- imageGenerator: this._imageGenerator,
- classes: {
- hide: this._options.classes.hide,
- editable: this._options.classes.editable
- },
- limits: {
- maxThumbs: this._options.thumbnails.maxCount,
- timeBetweenThumbs: this._options.thumbnails.timeBetweenThumbs
- },
- placeholders: {
- waitUntilUpdate: this._options.thumbnails.placeholders.waitUntilResponse,
- thumbnailNotAvailable: this._options.thumbnails.placeholders.notAvailablePath,
- waitingForThumbnail: this._options.thumbnails.placeholders.waitingPath
- },
- text: this._options.text
- });
- if (this._options.workarounds.ios8SafariUploads && qq.ios800() && qq.iosSafari()) {
- this._templating.renderFailure(this._options.messages.unsupportedBrowserIos8Safari);
- } else if (!qq.supportedFeatures.uploading || this._options.cors.expected && !qq.supportedFeatures.uploadCors) {
- this._templating.renderFailure(this._options.messages.unsupportedBrowser);
- } else {
- this._wrapCallbacks();
- this._templating.render();
- this._classes = this._options.classes;
- if (!this._options.button && this._templating.getButton()) {
- this._defaultButtonId = this._createUploadButton({
- element: this._templating.getButton(),
- title: this._options.text.fileInputTitle
- }).getButtonId();
- }
- this._setupClickAndEditEventHandlers();
- if (qq.DragAndDrop && qq.supportedFeatures.fileDrop) {
- this._dnd = this._setupDragAndDrop();
- }
- if (this._options.paste.targetElement && this._options.paste.promptForName) {
- if (qq.PasteSupport) {
- this._setupPastePrompt();
- } else {
- this.log("Paste support module not found.", "error");
- }
- }
- this._totalFilesInBatch = 0;
- this._filesInBatchAddedToUi = 0;
- }
- };
- qq.extend(qq.FineUploader.prototype, qq.basePublicApi);
- qq.extend(qq.FineUploader.prototype, qq.basePrivateApi);
- qq.extend(qq.FineUploader.prototype, qq.uiPublicApi);
- qq.extend(qq.FineUploader.prototype, qq.uiPrivateApi);
- qq.Templating = function(spec) {
- "use strict";
- var FILE_ID_ATTR = "qq-file-id", FILE_CLASS_PREFIX = "qq-file-id-", THUMBNAIL_MAX_SIZE_ATTR = "qq-max-size", THUMBNAIL_SERVER_SCALE_ATTR = "qq-server-scale", HIDE_DROPZONE_ATTR = "qq-hide-dropzone", DROPZPONE_TEXT_ATTR = "qq-drop-area-text", IN_PROGRESS_CLASS = "qq-in-progress", HIDDEN_FOREVER_CLASS = "qq-hidden-forever", fileBatch = {
- content: document.createDocumentFragment(),
- map: {}
- }, isCancelDisabled = false, generatedThumbnails = 0, thumbnailQueueMonitorRunning = false, thumbGenerationQueue = [], thumbnailMaxSize = -1, options = {
- log: null,
- limits: {
- maxThumbs: 0,
- timeBetweenThumbs: 750
- },
- templateIdOrEl: "qq-template",
- containerEl: null,
- fileContainerEl: null,
- button: null,
- imageGenerator: null,
- classes: {
- hide: "qq-hide",
- editable: "qq-editable"
- },
- placeholders: {
- waitUntilUpdate: false,
- thumbnailNotAvailable: null,
- waitingForThumbnail: null
- },
- text: {
- paused: "Paused"
- }
- }, selectorClasses = {
- button: "qq-upload-button-selector",
- alertDialog: "qq-alert-dialog-selector",
- dialogCancelButton: "qq-cancel-button-selector",
- confirmDialog: "qq-confirm-dialog-selector",
- dialogMessage: "qq-dialog-message-selector",
- dialogOkButton: "qq-ok-button-selector",
- promptDialog: "qq-prompt-dialog-selector",
- uploader: "qq-uploader-selector",
- drop: "qq-upload-drop-area-selector",
- list: "qq-upload-list-selector",
- progressBarContainer: "qq-progress-bar-container-selector",
- progressBar: "qq-progress-bar-selector",
- totalProgressBarContainer: "qq-total-progress-bar-container-selector",
- totalProgressBar: "qq-total-progress-bar-selector",
- file: "qq-upload-file-selector",
- spinner: "qq-upload-spinner-selector",
- size: "qq-upload-size-selector",
- cancel: "qq-upload-cancel-selector",
- pause: "qq-upload-pause-selector",
- continueButton: "qq-upload-continue-selector",
- deleteButton: "qq-upload-delete-selector",
- retry: "qq-upload-retry-selector",
- statusText: "qq-upload-status-text-selector",
- editFilenameInput: "qq-edit-filename-selector",
- editNameIcon: "qq-edit-filename-icon-selector",
- dropText: "qq-upload-drop-area-text-selector",
- dropProcessing: "qq-drop-processing-selector",
- dropProcessingSpinner: "qq-drop-processing-spinner-selector",
- thumbnail: "qq-thumbnail-selector"
- }, previewGeneration = {}, cachedThumbnailNotAvailableImg = new qq.Promise(), cachedWaitingForThumbnailImg = new qq.Promise(), log, isEditElementsExist, isRetryElementExist, templateDom, container, fileList, showThumbnails, serverScale, cacheThumbnailPlaceholders = function() {
- var notAvailableUrl = options.placeholders.thumbnailNotAvailable, waitingUrl = options.placeholders.waitingForThumbnail, spec = {
- maxSize: thumbnailMaxSize,
- scale: serverScale
- };
- if (showThumbnails) {
- if (notAvailableUrl) {
- options.imageGenerator.generate(notAvailableUrl, new Image(), spec).then(function(updatedImg) {
- cachedThumbnailNotAvailableImg.success(updatedImg);
- }, function() {
- cachedThumbnailNotAvailableImg.failure();
- log("Problem loading 'not available' placeholder image at " + notAvailableUrl, "error");
+
+ qq.each(matchingCookieNames, function(idx, cookieName) {
+ var cookiesNameParts = cookieName.split(cookieItemDelimiter);
+ var cookieValueParts = qq.getCookie(cookieName).split(cookieItemDelimiter);
+
+ resumableFilesData.push({
+ name: decodeURIComponent(cookiesNameParts[1]),
+ size: cookiesNameParts[2],
+ uuid: cookieValueParts[0],
+ partIdx: cookieValueParts[1]
});
- } else {
- cachedThumbnailNotAvailableImg.failure();
- }
- if (waitingUrl) {
- options.imageGenerator.generate(waitingUrl, new Image(), spec).then(function(updatedImg) {
- cachedWaitingForThumbnailImg.success(updatedImg);
- }, function() {
- cachedWaitingForThumbnailImg.failure();
- log("Problem loading 'waiting for thumbnail' placeholder image at " + waitingUrl, "error");
- });
- } else {
- cachedWaitingForThumbnailImg.failure();
- }
- }
- }, displayWaitingImg = function(thumbnail) {
- var waitingImgPlacement = new qq.Promise();
- cachedWaitingForThumbnailImg.then(function(img) {
- maybeScalePlaceholderViaCss(img, thumbnail);
- if (!thumbnail.src) {
- thumbnail.src = img.src;
- thumbnail.onload = function() {
- thumbnail.onload = null;
- show(thumbnail);
- waitingImgPlacement.success();
- };
- } else {
- waitingImgPlacement.success();
- }
- }, function() {
- hide(thumbnail);
- waitingImgPlacement.success();
- });
- return waitingImgPlacement;
- }, generateNewPreview = function(id, blob, spec) {
- var thumbnail = getThumbnail(id);
- log("Generating new thumbnail for " + id);
- blob.qqThumbnailId = id;
- return options.imageGenerator.generate(blob, thumbnail, spec).then(function() {
- generatedThumbnails++;
- show(thumbnail);
- previewGeneration[id].success();
- }, function() {
- previewGeneration[id].failure();
- if (!options.placeholders.waitUntilUpdate) {
- maybeSetDisplayNotAvailableImg(id, thumbnail);
- }
- });
- }, generateNextQueuedPreview = function() {
- if (thumbGenerationQueue.length) {
- thumbnailQueueMonitorRunning = true;
- var queuedThumbRequest = thumbGenerationQueue.shift();
- if (queuedThumbRequest.update) {
- processUpdateQueuedPreviewRequest(queuedThumbRequest);
- } else {
- processNewQueuedPreviewRequest(queuedThumbRequest);
- }
- } else {
- thumbnailQueueMonitorRunning = false;
- }
- }, getCancel = function(id) {
- return getTemplateEl(getFile(id), selectorClasses.cancel);
- }, getContinue = function(id) {
- return getTemplateEl(getFile(id), selectorClasses.continueButton);
- }, getDialog = function(type) {
- return getTemplateEl(container, selectorClasses[type + "Dialog"]);
- }, getDelete = function(id) {
- return getTemplateEl(getFile(id), selectorClasses.deleteButton);
- }, getDropProcessing = function() {
- return getTemplateEl(container, selectorClasses.dropProcessing);
- }, getEditIcon = function(id) {
- return getTemplateEl(getFile(id), selectorClasses.editNameIcon);
- }, getFile = function(id) {
- return fileBatch.map[id] || qq(fileList).getFirstByClass(FILE_CLASS_PREFIX + id);
- }, getFilename = function(id) {
- return getTemplateEl(getFile(id), selectorClasses.file);
- }, getPause = function(id) {
- return getTemplateEl(getFile(id), selectorClasses.pause);
- }, getProgress = function(id) {
- if (id == null) {
- return getTemplateEl(container, selectorClasses.totalProgressBarContainer) || getTemplateEl(container, selectorClasses.totalProgressBar);
- }
- return getTemplateEl(getFile(id), selectorClasses.progressBarContainer) || getTemplateEl(getFile(id), selectorClasses.progressBar);
- }, getRetry = function(id) {
- return getTemplateEl(getFile(id), selectorClasses.retry);
- }, getSize = function(id) {
- return getTemplateEl(getFile(id), selectorClasses.size);
- }, getSpinner = function(id) {
- return getTemplateEl(getFile(id), selectorClasses.spinner);
- }, getTemplateEl = function(context, cssClass) {
- return context && qq(context).getFirstByClass(cssClass);
- }, getThumbnail = function(id) {
- return showThumbnails && getTemplateEl(getFile(id), selectorClasses.thumbnail);
- }, hide = function(el) {
- el && qq(el).addClass(options.classes.hide);
- }, maybeScalePlaceholderViaCss = function(placeholder, thumbnail) {
- var maxWidth = placeholder.style.maxWidth, maxHeight = placeholder.style.maxHeight;
- if (maxHeight && maxWidth && !thumbnail.style.maxWidth && !thumbnail.style.maxHeight) {
- qq(thumbnail).css({
- maxWidth: maxWidth,
- maxHeight: maxHeight
});
+
+ return resumableFilesData;
}
- }, maybeSetDisplayNotAvailableImg = function(id, thumbnail) {
- var previewing = previewGeneration[id] || new qq.Promise().failure(), notAvailableImgPlacement = new qq.Promise();
- cachedThumbnailNotAvailableImg.then(function(img) {
- previewing.then(function() {
- notAvailableImgPlacement.success();
- }, function() {
- maybeScalePlaceholderViaCss(img, thumbnail);
- thumbnail.onload = function() {
- thumbnail.onload = null;
- notAvailableImgPlacement.success();
- };
- thumbnail.src = img.src;
- show(thumbnail);
- });
- });
- return notAvailableImgPlacement;
- }, parseAndGetTemplate = function() {
- var scriptEl, scriptHtml, fileListNode, tempTemplateEl, fileListEl, defaultButton, dropArea, thumbnail, dropProcessing, dropTextEl, uploaderEl;
- log("Parsing template");
- if (options.templateIdOrEl == null) {
- throw new Error("You MUST specify either a template element or ID!");
- }
- if (qq.isString(options.templateIdOrEl)) {
- scriptEl = document.getElementById(options.templateIdOrEl);
- if (scriptEl === null) {
- throw new Error(qq.format("Cannot find template script at ID '{}'!", options.templateIdOrEl));
- }
- scriptHtml = scriptEl.innerHTML;
- } else {
- if (options.templateIdOrEl.innerHTML === undefined) {
- throw new Error("You have specified an invalid value for the template option! " + "It must be an ID or an Element.");
- }
- scriptHtml = options.templateIdOrEl.innerHTML;
- }
- scriptHtml = qq.trimStr(scriptHtml);
- tempTemplateEl = document.createElement("div");
- tempTemplateEl.appendChild(qq.toElement(scriptHtml));
- uploaderEl = qq(tempTemplateEl).getFirstByClass(selectorClasses.uploader);
- if (options.button) {
- defaultButton = qq(tempTemplateEl).getFirstByClass(selectorClasses.button);
- if (defaultButton) {
- qq(defaultButton).remove();
- }
- }
- if (!qq.DragAndDrop || !qq.supportedFeatures.fileDrop) {
- dropProcessing = qq(tempTemplateEl).getFirstByClass(selectorClasses.dropProcessing);
- if (dropProcessing) {
- qq(dropProcessing).remove();
- }
- }
- dropArea = qq(tempTemplateEl).getFirstByClass(selectorClasses.drop);
- if (dropArea && !qq.DragAndDrop) {
- log("DnD module unavailable.", "info");
- qq(dropArea).remove();
- }
- if (!qq.supportedFeatures.fileDrop) {
- uploaderEl.removeAttribute(DROPZPONE_TEXT_ATTR);
- if (dropArea && qq(dropArea).hasAttribute(HIDE_DROPZONE_ATTR)) {
- qq(dropArea).css({
- display: "none"
- });
- }
- } else if (qq(uploaderEl).hasAttribute(DROPZPONE_TEXT_ATTR) && dropArea) {
- dropTextEl = qq(dropArea).getFirstByClass(selectorClasses.dropText);
- dropTextEl && qq(dropTextEl).remove();
- }
- thumbnail = qq(tempTemplateEl).getFirstByClass(selectorClasses.thumbnail);
- if (!showThumbnails) {
- thumbnail && qq(thumbnail).remove();
- } else if (thumbnail) {
- thumbnailMaxSize = parseInt(thumbnail.getAttribute(THUMBNAIL_MAX_SIZE_ATTR));
- thumbnailMaxSize = thumbnailMaxSize > 0 ? thumbnailMaxSize : null;
- serverScale = qq(thumbnail).hasAttribute(THUMBNAIL_SERVER_SCALE_ATTR);
- }
- showThumbnails = showThumbnails && thumbnail;
- isEditElementsExist = qq(tempTemplateEl).getByClass(selectorClasses.editFilenameInput).length > 0;
- isRetryElementExist = qq(tempTemplateEl).getByClass(selectorClasses.retry).length > 0;
- fileListNode = qq(tempTemplateEl).getFirstByClass(selectorClasses.list);
- if (fileListNode == null) {
- throw new Error("Could not find the file list container in the template!");
- }
- fileListEl = fileListNode.children[0].cloneNode(true);
- fileListNode.innerHTML = "";
- if (tempTemplateEl.getElementsByTagName("DIALOG").length) {
- document.createElement("dialog");
- }
- log("Template parsing complete");
- return {
- template: tempTemplateEl,
- fileTemplate: fileListEl
- };
- }, prependFile = function(el, index, fileList) {
- var parentEl = fileList, beforeEl = parentEl.firstChild;
- if (index > 0) {
- beforeEl = qq(parentEl).children()[index].nextSibling;
- }
- parentEl.insertBefore(el, beforeEl);
- }, processNewQueuedPreviewRequest = function(queuedThumbRequest) {
- var id = queuedThumbRequest.id, optFileOrBlob = queuedThumbRequest.optFileOrBlob, relatedThumbnailId = optFileOrBlob && optFileOrBlob.qqThumbnailId, thumbnail = getThumbnail(id), spec = {
- customResizeFunction: queuedThumbRequest.customResizeFunction,
- maxSize: thumbnailMaxSize,
- orient: true,
- scale: true
- };
- if (qq.supportedFeatures.imagePreviews) {
- if (thumbnail) {
- if (options.limits.maxThumbs && options.limits.maxThumbs <= generatedThumbnails) {
- maybeSetDisplayNotAvailableImg(id, thumbnail);
- generateNextQueuedPreview();
- } else {
- displayWaitingImg(thumbnail).done(function() {
- previewGeneration[id] = new qq.Promise();
- previewGeneration[id].done(function() {
- setTimeout(generateNextQueuedPreview, options.limits.timeBetweenThumbs);
- });
- if (relatedThumbnailId != null) {
- useCachedPreview(id, relatedThumbnailId);
- } else {
- generateNewPreview(id, optFileOrBlob, spec);
- }
- });
- }
- } else {
- generateNextQueuedPreview();
- }
- } else if (thumbnail) {
- displayWaitingImg(thumbnail);
- generateNextQueuedPreview();
- }
- }, processUpdateQueuedPreviewRequest = function(queuedThumbRequest) {
- var id = queuedThumbRequest.id, thumbnailUrl = queuedThumbRequest.thumbnailUrl, showWaitingImg = queuedThumbRequest.showWaitingImg, thumbnail = getThumbnail(id), spec = {
- customResizeFunction: queuedThumbRequest.customResizeFunction,
- scale: serverScale,
- maxSize: thumbnailMaxSize
- };
- if (thumbnail) {
- if (thumbnailUrl) {
- if (options.limits.maxThumbs && options.limits.maxThumbs <= generatedThumbnails) {
- maybeSetDisplayNotAvailableImg(id, thumbnail);
- generateNextQueuedPreview();
- } else {
- if (showWaitingImg) {
- displayWaitingImg(thumbnail);
- }
- return options.imageGenerator.generate(thumbnailUrl, thumbnail, spec).then(function() {
- show(thumbnail);
- generatedThumbnails++;
- setTimeout(generateNextQueuedPreview, options.limits.timeBetweenThumbs);
- }, function() {
- maybeSetDisplayNotAvailableImg(id, thumbnail);
- setTimeout(generateNextQueuedPreview, options.limits.timeBetweenThumbs);
- });
- }
- } else {
- maybeSetDisplayNotAvailableImg(id, thumbnail);
- generateNextQueuedPreview();
- }
- }
- }, setProgressBarWidth = function(id, percent) {
- var bar = getProgress(id), progressBarSelector = id == null ? selectorClasses.totalProgressBar : selectorClasses.progressBar;
- if (bar && !qq(bar).hasClass(progressBarSelector)) {
- bar = qq(bar).getFirstByClass(progressBarSelector);
- }
- if (bar) {
- qq(bar).css({
- width: percent + "%"
- });
- bar.setAttribute("aria-valuenow", percent);
- }
- }, show = function(el) {
- el && qq(el).removeClass(options.classes.hide);
- }, useCachedPreview = function(targetThumbnailId, cachedThumbnailId) {
- var targetThumbnail = getThumbnail(targetThumbnailId), cachedThumbnail = getThumbnail(cachedThumbnailId);
- log(qq.format("ID {} is the same file as ID {}. Will use generated thumbnail from ID {} instead.", targetThumbnailId, cachedThumbnailId, cachedThumbnailId));
- previewGeneration[cachedThumbnailId].then(function() {
- generatedThumbnails++;
- previewGeneration[targetThumbnailId].success();
- log(qq.format("Now using previously generated thumbnail created for ID {} on ID {}.", cachedThumbnailId, targetThumbnailId));
- targetThumbnail.src = cachedThumbnail.src;
- show(targetThumbnail);
- }, function() {
- previewGeneration[targetThumbnailId].failure();
- if (!options.placeholders.waitUntilUpdate) {
- maybeSetDisplayNotAvailableImg(targetThumbnailId, targetThumbnail);
- }
- });
- };
- qq.extend(options, spec);
- log = options.log;
- if (!qq.supportedFeatures.imagePreviews) {
- options.limits.timeBetweenThumbs = 0;
- options.limits.maxThumbs = 0;
- }
- container = options.containerEl;
- showThumbnails = options.imageGenerator !== undefined;
- templateDom = parseAndGetTemplate();
- cacheThumbnailPlaceholders();
- qq.extend(this, {
- render: function() {
- log("Rendering template in DOM.");
- generatedThumbnails = 0;
- container.appendChild(templateDom.template.cloneNode(true));
- hide(getDropProcessing());
- this.hideTotalProgress();
- fileList = options.fileContainerEl || getTemplateEl(container, selectorClasses.list);
- log("Template rendering complete");
- },
- renderFailure: function(message) {
- var cantRenderEl = qq.toElement(message);
- container.innerHTML = "";
- container.appendChild(cantRenderEl);
- },
- reset: function() {
- this.render();
- },
- clearFiles: function() {
- fileList.innerHTML = "";
- },
- disableCancel: function() {
- isCancelDisabled = true;
- },
- addFile: function(id, name, prependInfo, hideForever, batch) {
- var fileEl = templateDom.fileTemplate.cloneNode(true), fileNameEl = getTemplateEl(fileEl, selectorClasses.file), uploaderEl = getTemplateEl(container, selectorClasses.uploader), fileContainer = batch ? fileBatch.content : fileList, thumb;
- if (batch) {
- fileBatch.map[id] = fileEl;
- }
- qq(fileEl).addClass(FILE_CLASS_PREFIX + id);
- uploaderEl.removeAttribute(DROPZPONE_TEXT_ATTR);
- if (fileNameEl) {
- qq(fileNameEl).setText(name);
- fileNameEl.setAttribute("title", name);
- }
- fileEl.setAttribute(FILE_ID_ATTR, id);
- if (prependInfo) {
- prependFile(fileEl, prependInfo.index, fileContainer);
- } else {
- fileContainer.appendChild(fileEl);
- }
- if (hideForever) {
- fileEl.style.display = "none";
- qq(fileEl).addClass(HIDDEN_FOREVER_CLASS);
- } else {
- hide(getProgress(id));
- hide(getSize(id));
- hide(getDelete(id));
- hide(getRetry(id));
- hide(getPause(id));
- hide(getContinue(id));
- if (isCancelDisabled) {
- this.hideCancel(id);
- }
- thumb = getThumbnail(id);
- if (thumb && !thumb.src) {
- cachedWaitingForThumbnailImg.then(function(waitingImg) {
- thumb.src = waitingImg.src;
- if (waitingImg.style.maxHeight && waitingImg.style.maxWidth) {
- qq(thumb).css({
- maxHeight: waitingImg.style.maxHeight,
- maxWidth: waitingImg.style.maxWidth
- });
- }
- show(thumb);
- });
- }
- }
- },
- addFileToCache: function(id, name, prependInfo, hideForever) {
- this.addFile(id, name, prependInfo, hideForever, true);
- },
- addCacheToDom: function() {
- fileList.appendChild(fileBatch.content);
- fileBatch.content = document.createDocumentFragment();
- fileBatch.map = {};
- },
- removeFile: function(id) {
- qq(getFile(id)).remove();
- },
- getFileId: function(el) {
- var currentNode = el;
- if (currentNode) {
- while (currentNode.getAttribute(FILE_ID_ATTR) == null) {
- currentNode = currentNode.parentNode;
- }
- return parseInt(currentNode.getAttribute(FILE_ID_ATTR));
- }
- },
- getFileList: function() {
- return fileList;
- },
- markFilenameEditable: function(id) {
- var filename = getFilename(id);
- filename && qq(filename).addClass(options.classes.editable);
- },
- updateFilename: function(id, name) {
- var filenameEl = getFilename(id);
- if (filenameEl) {
- qq(filenameEl).setText(name);
- filenameEl.setAttribute("title", name);
- }
- },
- hideFilename: function(id) {
- hide(getFilename(id));
- },
- showFilename: function(id) {
- show(getFilename(id));
- },
- isFileName: function(el) {
- return qq(el).hasClass(selectorClasses.file);
- },
- getButton: function() {
- return options.button || getTemplateEl(container, selectorClasses.button);
- },
- hideDropProcessing: function() {
- hide(getDropProcessing());
- },
- showDropProcessing: function() {
- show(getDropProcessing());
- },
- getDropZone: function() {
- return getTemplateEl(container, selectorClasses.drop);
- },
- isEditFilenamePossible: function() {
- return isEditElementsExist;
- },
- hideRetry: function(id) {
- hide(getRetry(id));
- },
- isRetryPossible: function() {
- return isRetryElementExist;
- },
- showRetry: function(id) {
- show(getRetry(id));
- },
- getFileContainer: function(id) {
- return getFile(id);
- },
- showEditIcon: function(id) {
- var icon = getEditIcon(id);
- icon && qq(icon).addClass(options.classes.editable);
- },
- isHiddenForever: function(id) {
- return qq(getFile(id)).hasClass(HIDDEN_FOREVER_CLASS);
- },
- hideEditIcon: function(id) {
- var icon = getEditIcon(id);
- icon && qq(icon).removeClass(options.classes.editable);
- },
- isEditIcon: function(el) {
- return qq(el).hasClass(selectorClasses.editNameIcon, true);
- },
- getEditInput: function(id) {
- return getTemplateEl(getFile(id), selectorClasses.editFilenameInput);
- },
- isEditInput: function(el) {
- return qq(el).hasClass(selectorClasses.editFilenameInput, true);
- },
- updateProgress: function(id, loaded, total) {
- var bar = getProgress(id), percent;
- if (bar && total > 0) {
- percent = Math.round(loaded / total * 100);
- if (percent === 100) {
- hide(bar);
- } else {
- show(bar);
- }
- setProgressBarWidth(id, percent);
- }
- },
- updateTotalProgress: function(loaded, total) {
- this.updateProgress(null, loaded, total);
- },
- hideProgress: function(id) {
- var bar = getProgress(id);
- bar && hide(bar);
- },
- hideTotalProgress: function() {
- this.hideProgress();
- },
- resetProgress: function(id) {
- setProgressBarWidth(id, 0);
- this.hideTotalProgress(id);
- },
- resetTotalProgress: function() {
- this.resetProgress();
- },
- showCancel: function(id) {
- if (!isCancelDisabled) {
- var cancel = getCancel(id);
- cancel && qq(cancel).removeClass(options.classes.hide);
- }
- },
- hideCancel: function(id) {
- hide(getCancel(id));
- },
- isCancel: function(el) {
- return qq(el).hasClass(selectorClasses.cancel, true);
- },
- allowPause: function(id) {
- show(getPause(id));
- hide(getContinue(id));
- },
- uploadPaused: function(id) {
- this.setStatusText(id, options.text.paused);
- this.allowContinueButton(id);
- hide(getSpinner(id));
- },
- hidePause: function(id) {
- hide(getPause(id));
- },
- isPause: function(el) {
- return qq(el).hasClass(selectorClasses.pause, true);
- },
- isContinueButton: function(el) {
- return qq(el).hasClass(selectorClasses.continueButton, true);
- },
- allowContinueButton: function(id) {
- show(getContinue(id));
- hide(getPause(id));
- },
- uploadContinued: function(id) {
- this.setStatusText(id, "");
- this.allowPause(id);
- show(getSpinner(id));
- },
- showDeleteButton: function(id) {
- show(getDelete(id));
- },
- hideDeleteButton: function(id) {
- hide(getDelete(id));
- },
- isDeleteButton: function(el) {
- return qq(el).hasClass(selectorClasses.deleteButton, true);
- },
- isRetry: function(el) {
- return qq(el).hasClass(selectorClasses.retry, true);
- },
- updateSize: function(id, text) {
- var size = getSize(id);
- if (size) {
- show(size);
- qq(size).setText(text);
- }
- },
- setStatusText: function(id, text) {
- var textEl = getTemplateEl(getFile(id), selectorClasses.statusText);
- if (textEl) {
- if (text == null) {
- qq(textEl).clearText();
- } else {
- qq(textEl).setText(text);
- }
- }
- },
- hideSpinner: function(id) {
- qq(getFile(id)).removeClass(IN_PROGRESS_CLASS);
- hide(getSpinner(id));
- },
- showSpinner: function(id) {
- qq(getFile(id)).addClass(IN_PROGRESS_CLASS);
- show(getSpinner(id));
- },
- generatePreview: function(id, optFileOrBlob, customResizeFunction) {
- if (!this.isHiddenForever(id)) {
- thumbGenerationQueue.push({
- id: id,
- customResizeFunction: customResizeFunction,
- optFileOrBlob: optFileOrBlob
- });
- !thumbnailQueueMonitorRunning && generateNextQueuedPreview();
- }
- },
- updateThumbnail: function(id, thumbnailUrl, showWaitingImg, customResizeFunction) {
- if (!this.isHiddenForever(id)) {
- thumbGenerationQueue.push({
- customResizeFunction: customResizeFunction,
- update: true,
- id: id,
- thumbnailUrl: thumbnailUrl,
- showWaitingImg: showWaitingImg
- });
- !thumbnailQueueMonitorRunning && generateNextQueuedPreview();
- }
- },
- hasDialog: function(type) {
- return qq.supportedFeatures.dialogElement && !!getDialog(type);
- },
- showDialog: function(type, message, defaultValue) {
- var dialog = getDialog(type), messageEl = getTemplateEl(dialog, selectorClasses.dialogMessage), inputEl = dialog.getElementsByTagName("INPUT")[0], cancelBtn = getTemplateEl(dialog, selectorClasses.dialogCancelButton), okBtn = getTemplateEl(dialog, selectorClasses.dialogOkButton), promise = new qq.Promise(), closeHandler = function() {
- cancelBtn.removeEventListener("click", cancelClickHandler);
- okBtn && okBtn.removeEventListener("click", okClickHandler);
- promise.failure();
- }, cancelClickHandler = function() {
- cancelBtn.removeEventListener("click", cancelClickHandler);
- dialog.close();
- }, okClickHandler = function() {
- dialog.removeEventListener("close", closeHandler);
- okBtn.removeEventListener("click", okClickHandler);
- dialog.close();
- promise.success(inputEl && inputEl.value);
- };
- dialog.addEventListener("close", closeHandler);
- cancelBtn.addEventListener("click", cancelClickHandler);
- okBtn && okBtn.addEventListener("click", okClickHandler);
- if (inputEl) {
- inputEl.value = defaultValue;
- }
- messageEl.textContent = message;
- dialog.showModal();
- return promise;
- }
- });
- };
- qq.UiEventHandler = function(s, protectedApi) {
- "use strict";
- var disposer = new qq.DisposeSupport(), spec = {
- eventType: "click",
- attachTo: null,
- onHandled: function(target, event) {}
- };
- qq.extend(this, {
- addHandler: function(element) {
- addHandler(element);
- },
- dispose: function() {
- disposer.dispose();
- }
- });
- function addHandler(element) {
- disposer.attach(element, spec.eventType, function(event) {
- event = event || window.event;
- var target = event.target || event.srcElement;
- spec.onHandled(target, event);
- });
- }
- qq.extend(protectedApi, {
- getFileIdFromItem: function(item) {
- return item.qqFileId;
- },
- getDisposeSupport: function() {
- return disposer;
- }
- });
- qq.extend(spec, s);
- if (spec.attachTo) {
- addHandler(spec.attachTo);
+ return [];
}
};
- qq.FileButtonsClickHandler = function(s) {
- "use strict";
- var inheritedInternalApi = {}, spec = {
- templating: null,
- log: function(message, lvl) {},
- onDeleteFile: function(fileId) {},
- onCancel: function(fileId) {},
- onRetry: function(fileId) {},
- onPause: function(fileId) {},
- onContinue: function(fileId) {},
- onGetName: function(fileId) {}
- }, buttonHandlers = {
- cancel: function(id) {
- spec.onCancel(id);
- },
- retry: function(id) {
- spec.onRetry(id);
- },
- deleteButton: function(id) {
- spec.onDeleteFile(id);
- },
- pause: function(id) {
- spec.onPause(id);
- },
- continueButton: function(id) {
- spec.onContinue(id);
- }
- };
- function examineEvent(target, event) {
- qq.each(buttonHandlers, function(buttonType, handler) {
- var firstLetterCapButtonType = buttonType.charAt(0).toUpperCase() + buttonType.slice(1), fileId;
- if (spec.templating["is" + firstLetterCapButtonType](target)) {
- fileId = spec.templating.getFileId(target);
- qq.preventDefault(event);
- spec.log(qq.format("Detected valid file button click event on file '{}', ID: {}.", spec.onGetName(fileId), fileId));
- handler(fileId);
- return false;
- }
- });
- }
- qq.extend(spec, s);
- spec.eventType = "click";
- spec.onHandled = examineEvent;
- spec.attachTo = spec.templating.getFileList();
- qq.extend(this, new qq.UiEventHandler(spec, inheritedInternalApi));
- };
- qq.FilenameClickHandler = function(s) {
- "use strict";
- var inheritedInternalApi = {}, spec = {
- templating: null,
- log: function(message, lvl) {},
- classes: {
- file: "qq-upload-file",
- editNameIcon: "qq-edit-filename-icon"
- },
- onGetUploadStatus: function(fileId) {},
- onGetName: function(fileId) {}
- };
- qq.extend(spec, s);
- function examineEvent(target, event) {
- if (spec.templating.isFileName(target) || spec.templating.isEditIcon(target)) {
- var fileId = spec.templating.getFileId(target), status = spec.onGetUploadStatus(fileId);
- if (status === qq.status.SUBMITTED) {
- spec.log(qq.format("Detected valid filename click event on file '{}', ID: {}.", spec.onGetName(fileId), fileId));
- qq.preventDefault(event);
- inheritedInternalApi.handleFilenameEdit(fileId, target, true);
- }
- }
- }
- spec.eventType = "click";
- spec.onHandled = examineEvent;
- qq.extend(this, new qq.FilenameEditHandler(spec, inheritedInternalApi));
- };
- qq.FilenameInputFocusInHandler = function(s, inheritedInternalApi) {
- "use strict";
- var spec = {
- templating: null,
- onGetUploadStatus: function(fileId) {},
- log: function(message, lvl) {}
- };
- if (!inheritedInternalApi) {
- inheritedInternalApi = {};
- }
- function handleInputFocus(target, event) {
- if (spec.templating.isEditInput(target)) {
- var fileId = spec.templating.getFileId(target), status = spec.onGetUploadStatus(fileId);
- if (status === qq.status.SUBMITTED) {
- spec.log(qq.format("Detected valid filename input focus event on file '{}', ID: {}.", spec.onGetName(fileId), fileId));
- inheritedInternalApi.handleFilenameEdit(fileId, target);
- }
- }
- }
- spec.eventType = "focusin";
- spec.onHandled = handleInputFocus;
- qq.extend(spec, s);
- qq.extend(this, new qq.FilenameEditHandler(spec, inheritedInternalApi));
- };
- qq.FilenameInputFocusHandler = function(spec) {
- "use strict";
- spec.eventType = "focus";
- spec.attachTo = null;
- qq.extend(this, new qq.FilenameInputFocusInHandler(spec, {}));
- };
- qq.FilenameEditHandler = function(s, inheritedInternalApi) {
- "use strict";
- var spec = {
- templating: null,
- log: function(message, lvl) {},
- onGetUploadStatus: function(fileId) {},
- onGetName: function(fileId) {},
- onSetName: function(fileId, newName) {},
- onEditingStatusChange: function(fileId, isEditing) {}
- };
- function getFilenameSansExtension(fileId) {
- var filenameSansExt = spec.onGetName(fileId), extIdx = filenameSansExt.lastIndexOf(".");
- if (extIdx > 0) {
- filenameSansExt = filenameSansExt.substr(0, extIdx);
- }
- return filenameSansExt;
- }
- function getOriginalExtension(fileId) {
- var origName = spec.onGetName(fileId);
- return qq.getExtension(origName);
- }
- function handleNameUpdate(newFilenameInputEl, fileId) {
- var newName = newFilenameInputEl.value, origExtension;
- if (newName !== undefined && qq.trimStr(newName).length > 0) {
- origExtension = getOriginalExtension(fileId);
- if (origExtension !== undefined) {
- newName = newName + "." + origExtension;
- }
- spec.onSetName(fileId, newName);
- }
- spec.onEditingStatusChange(fileId, false);
- }
- function registerInputBlurHandler(inputEl, fileId) {
- inheritedInternalApi.getDisposeSupport().attach(inputEl, "blur", function() {
- handleNameUpdate(inputEl, fileId);
- });
- }
- function registerInputEnterKeyHandler(inputEl, fileId) {
- inheritedInternalApi.getDisposeSupport().attach(inputEl, "keyup", function(event) {
- var code = event.keyCode || event.which;
- if (code === 13) {
- handleNameUpdate(inputEl, fileId);
- }
- });
- }
- qq.extend(spec, s);
- spec.attachTo = spec.templating.getFileList();
- qq.extend(this, new qq.UiEventHandler(spec, inheritedInternalApi));
- qq.extend(inheritedInternalApi, {
- handleFilenameEdit: function(id, target, focusInput) {
- var newFilenameInputEl = spec.templating.getEditInput(id);
- spec.onEditingStatusChange(id, true);
- newFilenameInputEl.value = getFilenameSansExtension(id);
- if (focusInput) {
- newFilenameInputEl.focus();
- }
- registerInputBlurHandler(newFilenameInputEl, id);
- registerInputEnterKeyHandler(newFilenameInputEl, id);
- }
- });
- };
-})(window);
-//# sourceMappingURL=fine-uploader.js.map
+
+ return api;
+};