|
...
|
...
|
@@ -0,0 +1,1438 @@ |
|
|
1
|
+/* |
|
|
2
|
+ * jQuery File Upload Plugin 5.40.3 |
|
|
3
|
+ * https://github.com/blueimp/jQuery-File-Upload |
|
|
4
|
+ * |
|
|
5
|
+ * Copyright 2010, Sebastian Tschan |
|
|
6
|
+ * https://blueimp.net |
|
|
7
|
+ * |
|
|
8
|
+ * Licensed under the MIT license: |
|
|
9
|
+ * http://www.opensource.org/licenses/MIT |
|
|
10
|
+ */ |
|
|
11
|
+ |
|
|
12
|
+/* jshint nomen:false */ |
|
|
13
|
+/* global define, window, document, location, Blob, FormData */ |
|
|
14
|
+ |
|
|
15
|
+(function (factory) { |
|
|
16
|
+ 'use strict'; |
|
|
17
|
+ if (typeof define === 'function' && define.amd) { |
|
|
18
|
+ // Register as an anonymous AMD module: |
|
|
19
|
+ define([ |
|
|
20
|
+ 'jquery', |
|
|
21
|
+ 'jquery.ui.widget' |
|
|
22
|
+ ], factory); |
|
|
23
|
+ } else { |
|
|
24
|
+ // Browser globals: |
|
|
25
|
+ factory(window.jQuery); |
|
|
26
|
+ } |
|
|
27
|
+}(function ($) { |
|
|
28
|
+ 'use strict'; |
|
|
29
|
+ |
|
|
30
|
+ // Detect file input support, based on |
|
|
31
|
+ // http://viljamis.com/blog/2012/file-upload-support-on-mobile/ |
|
|
32
|
+ $.support.fileInput = !(new RegExp( |
|
|
33
|
+ // Handle devices which give false positives for the feature detection: |
|
|
34
|
+ '(Android (1\\.[0156]|2\\.[01]))' + |
|
|
35
|
+ '|(Windows Phone (OS 7|8\\.0))|(XBLWP)|(ZuneWP)|(WPDesktop)' + |
|
|
36
|
+ '|(w(eb)?OSBrowser)|(webOS)' + |
|
|
37
|
+ '|(Kindle/(1\\.0|2\\.[05]|3\\.0))' |
|
|
38
|
+ ).test(window.navigator.userAgent) || |
|
|
39
|
+ // Feature detection for all other devices: |
|
|
40
|
+ $('<input type="file">').prop('disabled')); |
|
|
41
|
+ |
|
|
42
|
+ // The FileReader API is not actually used, but works as feature detection, |
|
|
43
|
+ // as some Safari versions (5?) support XHR file uploads via the FormData API, |
|
|
44
|
+ // but not non-multipart XHR file uploads. |
|
|
45
|
+ // window.XMLHttpRequestUpload is not available on IE10, so we check for |
|
|
46
|
+ // window.ProgressEvent instead to detect XHR2 file upload capability: |
|
|
47
|
+ $.support.xhrFileUpload = !!(window.ProgressEvent && window.FileReader); |
|
|
48
|
+ $.support.xhrFormDataFileUpload = !!window.FormData; |
|
|
49
|
+ |
|
|
50
|
+ // Detect support for Blob slicing (required for chunked uploads): |
|
|
51
|
+ $.support.blobSlice = window.Blob && (Blob.prototype.slice || |
|
|
52
|
+ Blob.prototype.webkitSlice || Blob.prototype.mozSlice); |
|
|
53
|
+ |
|
|
54
|
+ // The fileupload widget listens for change events on file input fields defined |
|
|
55
|
+ // via fileInput setting and paste or drop events of the given dropZone. |
|
|
56
|
+ // In addition to the default jQuery Widget methods, the fileupload widget |
|
|
57
|
+ // exposes the "add" and "send" methods, to add or directly send files using |
|
|
58
|
+ // the fileupload API. |
|
|
59
|
+ // By default, files added via file input selection, paste, drag & drop or |
|
|
60
|
+ // "add" method are uploaded immediately, but it is possible to override |
|
|
61
|
+ // the "add" callback option to queue file uploads. |
|
|
62
|
+ $.widget('blueimp.fileupload', { |
|
|
63
|
+ |
|
|
64
|
+ options: { |
|
|
65
|
+ // The drop target element(s), by the default the complete document. |
|
|
66
|
+ // Set to null to disable drag & drop support: |
|
|
67
|
+ dropZone: $(document), |
|
|
68
|
+ // The paste target element(s), by the default the complete document. |
|
|
69
|
+ // Set to null to disable paste support: |
|
|
70
|
+ pasteZone: $(document), |
|
|
71
|
+ // The file input field(s), that are listened to for change events. |
|
|
72
|
+ // If undefined, it is set to the file input fields inside |
|
|
73
|
+ // of the widget element on plugin initialization. |
|
|
74
|
+ // Set to null to disable the change listener. |
|
|
75
|
+ fileInput: undefined, |
|
|
76
|
+ // By default, the file input field is replaced with a clone after |
|
|
77
|
+ // each input field change event. This is required for iframe transport |
|
|
78
|
+ // queues and allows change events to be fired for the same file |
|
|
79
|
+ // selection, but can be disabled by setting the following option to false: |
|
|
80
|
+ replaceFileInput: true, |
|
|
81
|
+ // The parameter name for the file form data (the request argument name). |
|
|
82
|
+ // If undefined or empty, the name property of the file input field is |
|
|
83
|
+ // used, or "files[]" if the file input name property is also empty, |
|
|
84
|
+ // can be a string or an array of strings: |
|
|
85
|
+ paramName: undefined, |
|
|
86
|
+ // By default, each file of a selection is uploaded using an individual |
|
|
87
|
+ // request for XHR type uploads. Set to false to upload file |
|
|
88
|
+ // selections in one request each: |
|
|
89
|
+ singleFileUploads: true, |
|
|
90
|
+ // To limit the number of files uploaded with one XHR request, |
|
|
91
|
+ // set the following option to an integer greater than 0: |
|
|
92
|
+ limitMultiFileUploads: undefined, |
|
|
93
|
+ // The following option limits the number of files uploaded with one |
|
|
94
|
+ // XHR request to keep the request size under or equal to the defined |
|
|
95
|
+ // limit in bytes: |
|
|
96
|
+ limitMultiFileUploadSize: undefined, |
|
|
97
|
+ // Multipart file uploads add a number of bytes to each uploaded file, |
|
|
98
|
+ // therefore the following option adds an overhead for each file used |
|
|
99
|
+ // in the limitMultiFileUploadSize configuration: |
|
|
100
|
+ limitMultiFileUploadSizeOverhead: 512, |
|
|
101
|
+ // Set the following option to true to issue all file upload requests |
|
|
102
|
+ // in a sequential order: |
|
|
103
|
+ sequentialUploads: false, |
|
|
104
|
+ // To limit the number of concurrent uploads, |
|
|
105
|
+ // set the following option to an integer greater than 0: |
|
|
106
|
+ limitConcurrentUploads: undefined, |
|
|
107
|
+ // Set the following option to true to force iframe transport uploads: |
|
|
108
|
+ forceIframeTransport: false, |
|
|
109
|
+ // Set the following option to the location of a redirect url on the |
|
|
110
|
+ // origin server, for cross-domain iframe transport uploads: |
|
|
111
|
+ redirect: undefined, |
|
|
112
|
+ // The parameter name for the redirect url, sent as part of the form |
|
|
113
|
+ // data and set to 'redirect' if this option is empty: |
|
|
114
|
+ redirectParamName: undefined, |
|
|
115
|
+ // Set the following option to the location of a postMessage window, |
|
|
116
|
+ // to enable postMessage transport uploads: |
|
|
117
|
+ postMessage: undefined, |
|
|
118
|
+ // By default, XHR file uploads are sent as multipart/form-data. |
|
|
119
|
+ // The iframe transport is always using multipart/form-data. |
|
|
120
|
+ // Set to false to enable non-multipart XHR uploads: |
|
|
121
|
+ multipart: true, |
|
|
122
|
+ // To upload large files in smaller chunks, set the following option |
|
|
123
|
+ // to a preferred maximum chunk size. If set to 0, null or undefined, |
|
|
124
|
+ // or the browser does not support the required Blob API, files will |
|
|
125
|
+ // be uploaded as a whole. |
|
|
126
|
+ maxChunkSize: undefined, |
|
|
127
|
+ // When a non-multipart upload or a chunked multipart upload has been |
|
|
128
|
+ // aborted, this option can be used to resume the upload by setting |
|
|
129
|
+ // it to the size of the already uploaded bytes. This option is most |
|
|
130
|
+ // useful when modifying the options object inside of the "add" or |
|
|
131
|
+ // "send" callbacks, as the options are cloned for each file upload. |
|
|
132
|
+ uploadedBytes: undefined, |
|
|
133
|
+ // By default, failed (abort or error) file uploads are removed from the |
|
|
134
|
+ // global progress calculation. Set the following option to false to |
|
|
135
|
+ // prevent recalculating the global progress data: |
|
|
136
|
+ recalculateProgress: true, |
|
|
137
|
+ // Interval in milliseconds to calculate and trigger progress events: |
|
|
138
|
+ progressInterval: 100, |
|
|
139
|
+ // Interval in milliseconds to calculate progress bitrate: |
|
|
140
|
+ bitrateInterval: 500, |
|
|
141
|
+ // By default, uploads are started automatically when adding files: |
|
|
142
|
+ autoUpload: true, |
|
|
143
|
+ |
|
|
144
|
+ // Error and info messages: |
|
|
145
|
+ messages: { |
|
|
146
|
+ uploadedBytes: 'Uploaded bytes exceed file size' |
|
|
147
|
+ }, |
|
|
148
|
+ |
|
|
149
|
+ // Translation function, gets the message key to be translated |
|
|
150
|
+ // and an object with context specific data as arguments: |
|
|
151
|
+ i18n: function (message, context) { |
|
|
152
|
+ message = this.messages[message] || message.toString(); |
|
|
153
|
+ if (context) { |
|
|
154
|
+ $.each(context, function (key, value) { |
|
|
155
|
+ message = message.replace('{' + key + '}', value); |
|
|
156
|
+ }); |
|
|
157
|
+ } |
|
|
158
|
+ return message; |
|
|
159
|
+ }, |
|
|
160
|
+ |
|
|
161
|
+ // Additional form data to be sent along with the file uploads can be set |
|
|
162
|
+ // using this option, which accepts an array of objects with name and |
|
|
163
|
+ // value properties, a function returning such an array, a FormData |
|
|
164
|
+ // object (for XHR file uploads), or a simple object. |
|
|
165
|
+ // The form of the first fileInput is given as parameter to the function: |
|
|
166
|
+ formData: function (form) { |
|
|
167
|
+ return form.serializeArray(); |
|
|
168
|
+ }, |
|
|
169
|
+ |
|
|
170
|
+ // The add callback is invoked as soon as files are added to the fileupload |
|
|
171
|
+ // widget (via file input selection, drag & drop, paste or add API call). |
|
|
172
|
+ // If the singleFileUploads option is enabled, this callback will be |
|
|
173
|
+ // called once for each file in the selection for XHR file uploads, else |
|
|
174
|
+ // once for each file selection. |
|
|
175
|
+ // |
|
|
176
|
+ // The upload starts when the submit method is invoked on the data parameter. |
|
|
177
|
+ // The data object contains a files property holding the added files |
|
|
178
|
+ // and allows you to override plugin options as well as define ajax settings. |
|
|
179
|
+ // |
|
|
180
|
+ // Listeners for this callback can also be bound the following way: |
|
|
181
|
+ // .bind('fileuploadadd', func); |
|
|
182
|
+ // |
|
|
183
|
+ // data.submit() returns a Promise object and allows to attach additional |
|
|
184
|
+ // handlers using jQuery's Deferred callbacks: |
|
|
185
|
+ // data.submit().done(func).fail(func).always(func); |
|
|
186
|
+ add: function (e, data) { |
|
|
187
|
+ if (e.isDefaultPrevented()) { |
|
|
188
|
+ return false; |
|
|
189
|
+ } |
|
|
190
|
+ if (data.autoUpload || (data.autoUpload !== false && |
|
|
191
|
+ $(this).fileupload('option', 'autoUpload'))) { |
|
|
192
|
+ data.process().done(function () { |
|
|
193
|
+ data.submit(); |
|
|
194
|
+ }); |
|
|
195
|
+ } |
|
|
196
|
+ }, |
|
|
197
|
+ |
|
|
198
|
+ // Other callbacks: |
|
|
199
|
+ |
|
|
200
|
+ // Callback for the submit event of each file upload: |
|
|
201
|
+ // submit: function (e, data) {}, // .bind('fileuploadsubmit', func); |
|
|
202
|
+ |
|
|
203
|
+ // Callback for the start of each file upload request: |
|
|
204
|
+ // send: function (e, data) {}, // .bind('fileuploadsend', func); |
|
|
205
|
+ |
|
|
206
|
+ // Callback for successful uploads: |
|
|
207
|
+ // done: function (e, data) {}, // .bind('fileuploaddone', func); |
|
|
208
|
+ |
|
|
209
|
+ // Callback for failed (abort or error) uploads: |
|
|
210
|
+ // fail: function (e, data) {}, // .bind('fileuploadfail', func); |
|
|
211
|
+ |
|
|
212
|
+ // Callback for completed (success, abort or error) requests: |
|
|
213
|
+ // always: function (e, data) {}, // .bind('fileuploadalways', func); |
|
|
214
|
+ |
|
|
215
|
+ // Callback for upload progress events: |
|
|
216
|
+ // progress: function (e, data) {}, // .bind('fileuploadprogress', func); |
|
|
217
|
+ |
|
|
218
|
+ // Callback for global upload progress events: |
|
|
219
|
+ // progressall: function (e, data) {}, // .bind('fileuploadprogressall', func); |
|
|
220
|
+ |
|
|
221
|
+ // Callback for uploads start, equivalent to the global ajaxStart event: |
|
|
222
|
+ // start: function (e) {}, // .bind('fileuploadstart', func); |
|
|
223
|
+ |
|
|
224
|
+ // Callback for uploads stop, equivalent to the global ajaxStop event: |
|
|
225
|
+ // stop: function (e) {}, // .bind('fileuploadstop', func); |
|
|
226
|
+ |
|
|
227
|
+ // Callback for change events of the fileInput(s): |
|
|
228
|
+ // change: function (e, data) {}, // .bind('fileuploadchange', func); |
|
|
229
|
+ |
|
|
230
|
+ // Callback for paste events to the pasteZone(s): |
|
|
231
|
+ // paste: function (e, data) {}, // .bind('fileuploadpaste', func); |
|
|
232
|
+ |
|
|
233
|
+ // Callback for drop events of the dropZone(s): |
|
|
234
|
+ // drop: function (e, data) {}, // .bind('fileuploaddrop', func); |
|
|
235
|
+ |
|
|
236
|
+ // Callback for dragover events of the dropZone(s): |
|
|
237
|
+ // dragover: function (e) {}, // .bind('fileuploaddragover', func); |
|
|
238
|
+ |
|
|
239
|
+ // Callback for the start of each chunk upload request: |
|
|
240
|
+ // chunksend: function (e, data) {}, // .bind('fileuploadchunksend', func); |
|
|
241
|
+ |
|
|
242
|
+ // Callback for successful chunk uploads: |
|
|
243
|
+ // chunkdone: function (e, data) {}, // .bind('fileuploadchunkdone', func); |
|
|
244
|
+ |
|
|
245
|
+ // Callback for failed (abort or error) chunk uploads: |
|
|
246
|
+ // chunkfail: function (e, data) {}, // .bind('fileuploadchunkfail', func); |
|
|
247
|
+ |
|
|
248
|
+ // Callback for completed (success, abort or error) chunk upload requests: |
|
|
249
|
+ // chunkalways: function (e, data) {}, // .bind('fileuploadchunkalways', func); |
|
|
250
|
+ |
|
|
251
|
+ // The plugin options are used as settings object for the ajax calls. |
|
|
252
|
+ // The following are jQuery ajax settings required for the file uploads: |
|
|
253
|
+ processData: false, |
|
|
254
|
+ contentType: false, |
|
|
255
|
+ cache: false |
|
|
256
|
+ }, |
|
|
257
|
+ |
|
|
258
|
+ // A list of options that require reinitializing event listeners and/or |
|
|
259
|
+ // special initialization code: |
|
|
260
|
+ _specialOptions: [ |
|
|
261
|
+ 'fileInput', |
|
|
262
|
+ 'dropZone', |
|
|
263
|
+ 'pasteZone', |
|
|
264
|
+ 'multipart', |
|
|
265
|
+ 'forceIframeTransport' |
|
|
266
|
+ ], |
|
|
267
|
+ |
|
|
268
|
+ _blobSlice: $.support.blobSlice && function () { |
|
|
269
|
+ var slice = this.slice || this.webkitSlice || this.mozSlice; |
|
|
270
|
+ return slice.apply(this, arguments); |
|
|
271
|
+ }, |
|
|
272
|
+ |
|
|
273
|
+ _BitrateTimer: function () { |
|
|
274
|
+ this.timestamp = ((Date.now) ? Date.now() : (new Date()).getTime()); |
|
|
275
|
+ this.loaded = 0; |
|
|
276
|
+ this.bitrate = 0; |
|
|
277
|
+ this.getBitrate = function (now, loaded, interval) { |
|
|
278
|
+ var timeDiff = now - this.timestamp; |
|
|
279
|
+ if (!this.bitrate || !interval || timeDiff > interval) { |
|
|
280
|
+ this.bitrate = (loaded - this.loaded) * (1000 / timeDiff) * 8; |
|
|
281
|
+ this.loaded = loaded; |
|
|
282
|
+ this.timestamp = now; |
|
|
283
|
+ } |
|
|
284
|
+ return this.bitrate; |
|
|
285
|
+ }; |
|
|
286
|
+ }, |
|
|
287
|
+ |
|
|
288
|
+ _isXHRUpload: function (options) { |
|
|
289
|
+ return !options.forceIframeTransport && |
|
|
290
|
+ ((!options.multipart && $.support.xhrFileUpload) || |
|
|
291
|
+ $.support.xhrFormDataFileUpload); |
|
|
292
|
+ }, |
|
|
293
|
+ |
|
|
294
|
+ _getFormData: function (options) { |
|
|
295
|
+ var formData; |
|
|
296
|
+ if ($.type(options.formData) === 'function') { |
|
|
297
|
+ return options.formData(options.form); |
|
|
298
|
+ } |
|
|
299
|
+ if ($.isArray(options.formData)) { |
|
|
300
|
+ return options.formData; |
|
|
301
|
+ } |
|
|
302
|
+ if ($.type(options.formData) === 'object') { |
|
|
303
|
+ formData = []; |
|
|
304
|
+ $.each(options.formData, function (name, value) { |
|
|
305
|
+ formData.push({name: name, value: value}); |
|
|
306
|
+ }); |
|
|
307
|
+ return formData; |
|
|
308
|
+ } |
|
|
309
|
+ return []; |
|
|
310
|
+ }, |
|
|
311
|
+ |
|
|
312
|
+ _getTotal: function (files) { |
|
|
313
|
+ var total = 0; |
|
|
314
|
+ $.each(files, function (index, file) { |
|
|
315
|
+ total += file.size || 1; |
|
|
316
|
+ }); |
|
|
317
|
+ return total; |
|
|
318
|
+ }, |
|
|
319
|
+ |
|
|
320
|
+ _initProgressObject: function (obj) { |
|
|
321
|
+ var progress = { |
|
|
322
|
+ loaded: 0, |
|
|
323
|
+ total: 0, |
|
|
324
|
+ bitrate: 0 |
|
|
325
|
+ }; |
|
|
326
|
+ if (obj._progress) { |
|
|
327
|
+ $.extend(obj._progress, progress); |
|
|
328
|
+ } else { |
|
|
329
|
+ obj._progress = progress; |
|
|
330
|
+ } |
|
|
331
|
+ }, |
|
|
332
|
+ |
|
|
333
|
+ _initResponseObject: function (obj) { |
|
|
334
|
+ var prop; |
|
|
335
|
+ if (obj._response) { |
|
|
336
|
+ for (prop in obj._response) { |
|
|
337
|
+ if (obj._response.hasOwnProperty(prop)) { |
|
|
338
|
+ delete obj._response[prop]; |
|
|
339
|
+ } |
|
|
340
|
+ } |
|
|
341
|
+ } else { |
|
|
342
|
+ obj._response = {}; |
|
|
343
|
+ } |
|
|
344
|
+ }, |
|
|
345
|
+ |
|
|
346
|
+ _onProgress: function (e, data) { |
|
|
347
|
+ if (e.lengthComputable) { |
|
|
348
|
+ var now = ((Date.now) ? Date.now() : (new Date()).getTime()), |
|
|
349
|
+ loaded; |
|
|
350
|
+ if (data._time && data.progressInterval && |
|
|
351
|
+ (now - data._time < data.progressInterval) && |
|
|
352
|
+ e.loaded !== e.total) { |
|
|
353
|
+ return; |
|
|
354
|
+ } |
|
|
355
|
+ data._time = now; |
|
|
356
|
+ loaded = Math.floor( |
|
|
357
|
+ e.loaded / e.total * (data.chunkSize || data._progress.total) |
|
|
358
|
+ ) + (data.uploadedBytes || 0); |
|
|
359
|
+ // Add the difference from the previously loaded state |
|
|
360
|
+ // to the global loaded counter: |
|
|
361
|
+ this._progress.loaded += (loaded - data._progress.loaded); |
|
|
362
|
+ this._progress.bitrate = this._bitrateTimer.getBitrate( |
|
|
363
|
+ now, |
|
|
364
|
+ this._progress.loaded, |
|
|
365
|
+ data.bitrateInterval |
|
|
366
|
+ ); |
|
|
367
|
+ data._progress.loaded = data.loaded = loaded; |
|
|
368
|
+ data._progress.bitrate = data.bitrate = data._bitrateTimer.getBitrate( |
|
|
369
|
+ now, |
|
|
370
|
+ loaded, |
|
|
371
|
+ data.bitrateInterval |
|
|
372
|
+ ); |
|
|
373
|
+ // Trigger a custom progress event with a total data property set |
|
|
374
|
+ // to the file size(s) of the current upload and a loaded data |
|
|
375
|
+ // property calculated accordingly: |
|
|
376
|
+ this._trigger( |
|
|
377
|
+ 'progress', |
|
|
378
|
+ $.Event('progress', {delegatedEvent: e}), |
|
|
379
|
+ data |
|
|
380
|
+ ); |
|
|
381
|
+ // Trigger a global progress event for all current file uploads, |
|
|
382
|
+ // including ajax calls queued for sequential file uploads: |
|
|
383
|
+ this._trigger( |
|
|
384
|
+ 'progressall', |
|
|
385
|
+ $.Event('progressall', {delegatedEvent: e}), |
|
|
386
|
+ this._progress |
|
|
387
|
+ ); |
|
|
388
|
+ } |
|
|
389
|
+ }, |
|
|
390
|
+ |
|
|
391
|
+ _initProgressListener: function (options) { |
|
|
392
|
+ var that = this, |
|
|
393
|
+ xhr = options.xhr ? options.xhr() : $.ajaxSettings.xhr(); |
|
|
394
|
+ // Accesss to the native XHR object is required to add event listeners |
|
|
395
|
+ // for the upload progress event: |
|
|
396
|
+ if (xhr.upload) { |
|
|
397
|
+ $(xhr.upload).bind('progress', function (e) { |
|
|
398
|
+ var oe = e.originalEvent; |
|
|
399
|
+ // Make sure the progress event properties get copied over: |
|
|
400
|
+ e.lengthComputable = oe.lengthComputable; |
|
|
401
|
+ e.loaded = oe.loaded; |
|
|
402
|
+ e.total = oe.total; |
|
|
403
|
+ that._onProgress(e, options); |
|
|
404
|
+ }); |
|
|
405
|
+ options.xhr = function () { |
|
|
406
|
+ return xhr; |
|
|
407
|
+ }; |
|
|
408
|
+ } |
|
|
409
|
+ }, |
|
|
410
|
+ |
|
|
411
|
+ _isInstanceOf: function (type, obj) { |
|
|
412
|
+ // Cross-frame instanceof check |
|
|
413
|
+ return Object.prototype.toString.call(obj) === '[object ' + type + ']'; |
|
|
414
|
+ }, |
|
|
415
|
+ |
|
|
416
|
+ _initXHRData: function (options) { |
|
|
417
|
+ var that = this, |
|
|
418
|
+ formData, |
|
|
419
|
+ file = options.files[0], |
|
|
420
|
+ // Ignore non-multipart setting if not supported: |
|
|
421
|
+ multipart = options.multipart || !$.support.xhrFileUpload, |
|
|
422
|
+ paramName = $.type(options.paramName) === 'array' ? |
|
|
423
|
+ options.paramName[0] : options.paramName; |
|
|
424
|
+ options.headers = $.extend({}, options.headers); |
|
|
425
|
+ if (options.contentRange) { |
|
|
426
|
+ options.headers['Content-Range'] = options.contentRange; |
|
|
427
|
+ } |
|
|
428
|
+ if (!multipart || options.blob || !this._isInstanceOf('File', file)) { |
|
|
429
|
+ options.headers['Content-Disposition'] = 'attachment; filename="' + |
|
|
430
|
+ encodeURI(file.name) + '"'; |
|
|
431
|
+ } |
|
|
432
|
+ if (!multipart) { |
|
|
433
|
+ options.contentType = file.type || 'application/octet-stream'; |
|
|
434
|
+ options.data = options.blob || file; |
|
|
435
|
+ } else if ($.support.xhrFormDataFileUpload) { |
|
|
436
|
+ if (options.postMessage) { |
|
|
437
|
+ // window.postMessage does not allow sending FormData |
|
|
438
|
+ // objects, so we just add the File/Blob objects to |
|
|
439
|
+ // the formData array and let the postMessage window |
|
|
440
|
+ // create the FormData object out of this array: |
|
|
441
|
+ formData = this._getFormData(options); |
|
|
442
|
+ if (options.blob) { |
|
|
443
|
+ formData.push({ |
|
|
444
|
+ name: paramName, |
|
|
445
|
+ value: options.blob |
|
|
446
|
+ }); |
|
|
447
|
+ } else { |
|
|
448
|
+ $.each(options.files, function (index, file) { |
|
|
449
|
+ formData.push({ |
|
|
450
|
+ name: ($.type(options.paramName) === 'array' && |
|
|
451
|
+ options.paramName[index]) || paramName, |
|
|
452
|
+ value: file |
|
|
453
|
+ }); |
|
|
454
|
+ }); |
|
|
455
|
+ } |
|
|
456
|
+ } else { |
|
|
457
|
+ if (that._isInstanceOf('FormData', options.formData)) { |
|
|
458
|
+ formData = options.formData; |
|
|
459
|
+ } else { |
|
|
460
|
+ formData = new FormData(); |
|
|
461
|
+ $.each(this._getFormData(options), function (index, field) { |
|
|
462
|
+ formData.append(field.name, field.value); |
|
|
463
|
+ }); |
|
|
464
|
+ } |
|
|
465
|
+ if (options.blob) { |
|
|
466
|
+ formData.append(paramName, options.blob, file.name); |
|
|
467
|
+ } else { |
|
|
468
|
+ $.each(options.files, function (index, file) { |
|
|
469
|
+ // This check allows the tests to run with |
|
|
470
|
+ // dummy objects: |
|
|
471
|
+ if (that._isInstanceOf('File', file) || |
|
|
472
|
+ that._isInstanceOf('Blob', file)) { |
|
|
473
|
+ formData.append( |
|
|
474
|
+ ($.type(options.paramName) === 'array' && |
|
|
475
|
+ options.paramName[index]) || paramName, |
|
|
476
|
+ file, |
|
|
477
|
+ file.uploadName || file.name |
|
|
478
|
+ ); |
|
|
479
|
+ } |
|
|
480
|
+ }); |
|
|
481
|
+ } |
|
|
482
|
+ } |
|
|
483
|
+ options.data = formData; |
|
|
484
|
+ } |
|
|
485
|
+ // Blob reference is not needed anymore, free memory: |
|
|
486
|
+ options.blob = null; |
|
|
487
|
+ }, |
|
|
488
|
+ |
|
|
489
|
+ _initIframeSettings: function (options) { |
|
|
490
|
+ var targetHost = $('<a></a>').prop('href', options.url).prop('host'); |
|
|
491
|
+ // Setting the dataType to iframe enables the iframe transport: |
|
|
492
|
+ options.dataType = 'iframe ' + (options.dataType || ''); |
|
|
493
|
+ // The iframe transport accepts a serialized array as form data: |
|
|
494
|
+ options.formData = this._getFormData(options); |
|
|
495
|
+ // Add redirect url to form data on cross-domain uploads: |
|
|
496
|
+ if (options.redirect && targetHost && targetHost !== location.host) { |
|
|
497
|
+ options.formData.push({ |
|
|
498
|
+ name: options.redirectParamName || 'redirect', |
|
|
499
|
+ value: options.redirect |
|
|
500
|
+ }); |
|
|
501
|
+ } |
|
|
502
|
+ }, |
|
|
503
|
+ |
|
|
504
|
+ _initDataSettings: function (options) { |
|
|
505
|
+ if (this._isXHRUpload(options)) { |
|
|
506
|
+ if (!this._chunkedUpload(options, true)) { |
|
|
507
|
+ if (!options.data) { |
|
|
508
|
+ this._initXHRData(options); |
|
|
509
|
+ } |
|
|
510
|
+ this._initProgressListener(options); |
|
|
511
|
+ } |
|
|
512
|
+ if (options.postMessage) { |
|
|
513
|
+ // Setting the dataType to postmessage enables the |
|
|
514
|
+ // postMessage transport: |
|
|
515
|
+ options.dataType = 'postmessage ' + (options.dataType || ''); |
|
|
516
|
+ } |
|
|
517
|
+ } else { |
|
|
518
|
+ this._initIframeSettings(options); |
|
|
519
|
+ } |
|
|
520
|
+ }, |
|
|
521
|
+ |
|
|
522
|
+ _getParamName: function (options) { |
|
|
523
|
+ var fileInput = $(options.fileInput), |
|
|
524
|
+ paramName = options.paramName; |
|
|
525
|
+ if (!paramName) { |
|
|
526
|
+ paramName = []; |
|
|
527
|
+ fileInput.each(function () { |
|
|
528
|
+ var input = $(this), |
|
|
529
|
+ name = input.prop('name') || 'files[]', |
|
|
530
|
+ i = (input.prop('files') || [1]).length; |
|
|
531
|
+ while (i) { |
|
|
532
|
+ paramName.push(name); |
|
|
533
|
+ i -= 1; |
|
|
534
|
+ } |
|
|
535
|
+ }); |
|
|
536
|
+ if (!paramName.length) { |
|
|
537
|
+ paramName = [fileInput.prop('name') || 'files[]']; |
|
|
538
|
+ } |
|
|
539
|
+ } else if (!$.isArray(paramName)) { |
|
|
540
|
+ paramName = [paramName]; |
|
|
541
|
+ } |
|
|
542
|
+ return paramName; |
|
|
543
|
+ }, |
|
|
544
|
+ |
|
|
545
|
+ _initFormSettings: function (options) { |
|
|
546
|
+ // Retrieve missing options from the input field and the |
|
|
547
|
+ // associated form, if available: |
|
|
548
|
+ if (!options.form || !options.form.length) { |
|
|
549
|
+ options.form = $(options.fileInput.prop('form')); |
|
|
550
|
+ // If the given file input doesn't have an associated form, |
|
|
551
|
+ // use the default widget file input's form: |
|
|
552
|
+ if (!options.form.length) { |
|
|
553
|
+ options.form = $(this.options.fileInput.prop('form')); |
|
|
554
|
+ } |
|
|
555
|
+ } |
|
|
556
|
+ options.paramName = this._getParamName(options); |
|
|
557
|
+ if (!options.url) { |
|
|
558
|
+ options.url = options.form.prop('action') || location.href; |
|
|
559
|
+ } |
|
|
560
|
+ // The HTTP request method must be "POST" or "PUT": |
|
|
561
|
+ options.type = (options.type || |
|
|
562
|
+ ($.type(options.form.prop('method')) === 'string' && |
|
|
563
|
+ options.form.prop('method')) || '' |
|
|
564
|
+ ).toUpperCase(); |
|
|
565
|
+ if (options.type !== 'POST' && options.type !== 'PUT' && |
|
|
566
|
+ options.type !== 'PATCH') { |
|
|
567
|
+ options.type = 'POST'; |
|
|
568
|
+ } |
|
|
569
|
+ if (!options.formAcceptCharset) { |
|
|
570
|
+ options.formAcceptCharset = options.form.attr('accept-charset'); |
|
|
571
|
+ } |
|
|
572
|
+ }, |
|
|
573
|
+ |
|
|
574
|
+ _getAJAXSettings: function (data) { |
|
|
575
|
+ var options = $.extend({}, this.options, data); |
|
|
576
|
+ this._initFormSettings(options); |
|
|
577
|
+ this._initDataSettings(options); |
|
|
578
|
+ return options; |
|
|
579
|
+ }, |
|
|
580
|
+ |
|
|
581
|
+ // jQuery 1.6 doesn't provide .state(), |
|
|
582
|
+ // while jQuery 1.8+ removed .isRejected() and .isResolved(): |
|
|
583
|
+ _getDeferredState: function (deferred) { |
|
|
584
|
+ if (deferred.state) { |
|
|
585
|
+ return deferred.state(); |
|
|
586
|
+ } |
|
|
587
|
+ if (deferred.isResolved()) { |
|
|
588
|
+ return 'resolved'; |
|
|
589
|
+ } |
|
|
590
|
+ if (deferred.isRejected()) { |
|
|
591
|
+ return 'rejected'; |
|
|
592
|
+ } |
|
|
593
|
+ return 'pending'; |
|
|
594
|
+ }, |
|
|
595
|
+ |
|
|
596
|
+ // Maps jqXHR callbacks to the equivalent |
|
|
597
|
+ // methods of the given Promise object: |
|
|
598
|
+ _enhancePromise: function (promise) { |
|
|
599
|
+ promise.success = promise.done; |
|
|
600
|
+ promise.error = promise.fail; |
|
|
601
|
+ promise.complete = promise.always; |
|
|
602
|
+ return promise; |
|
|
603
|
+ }, |
|
|
604
|
+ |
|
|
605
|
+ // Creates and returns a Promise object enhanced with |
|
|
606
|
+ // the jqXHR methods abort, success, error and complete: |
|
|
607
|
+ _getXHRPromise: function (resolveOrReject, context, args) { |
|
|
608
|
+ var dfd = $.Deferred(), |
|
|
609
|
+ promise = dfd.promise(); |
|
|
610
|
+ context = context || this.options.context || promise; |
|
|
611
|
+ if (resolveOrReject === true) { |
|
|
612
|
+ dfd.resolveWith(context, args); |
|
|
613
|
+ } else if (resolveOrReject === false) { |
|
|
614
|
+ dfd.rejectWith(context, args); |
|
|
615
|
+ } |
|
|
616
|
+ promise.abort = dfd.promise; |
|
|
617
|
+ return this._enhancePromise(promise); |
|
|
618
|
+ }, |
|
|
619
|
+ |
|
|
620
|
+ // Adds convenience methods to the data callback argument: |
|
|
621
|
+ _addConvenienceMethods: function (e, data) { |
|
|
622
|
+ var that = this, |
|
|
623
|
+ getPromise = function (args) { |
|
|
624
|
+ return $.Deferred().resolveWith(that, args).promise(); |
|
|
625
|
+ }; |
|
|
626
|
+ data.process = function (resolveFunc, rejectFunc) { |
|
|
627
|
+ if (resolveFunc || rejectFunc) { |
|
|
628
|
+ data._processQueue = this._processQueue = |
|
|
629
|
+ (this._processQueue || getPromise([this])).pipe( |
|
|
630
|
+ function () { |
|
|
631
|
+ if (data.errorThrown) { |
|
|
632
|
+ return $.Deferred() |
|
|
633
|
+ .rejectWith(that, [data]).promise(); |
|
|
634
|
+ } |
|
|
635
|
+ return getPromise(arguments); |
|
|
636
|
+ } |
|
|
637
|
+ ).pipe(resolveFunc, rejectFunc); |
|
|
638
|
+ } |
|
|
639
|
+ return this._processQueue || getPromise([this]); |
|
|
640
|
+ }; |
|
|
641
|
+ data.submit = function () { |
|
|
642
|
+ if (this.state() !== 'pending') { |
|
|
643
|
+ data.jqXHR = this.jqXHR = |
|
|
644
|
+ (that._trigger( |
|
|
645
|
+ 'submit', |
|
|
646
|
+ $.Event('submit', {delegatedEvent: e}), |
|
|
647
|
+ this |
|
|
648
|
+ ) !== false) && that._onSend(e, this); |
|
|
649
|
+ } |
|
|
650
|
+ return this.jqXHR || that._getXHRPromise(); |
|
|
651
|
+ }; |
|
|
652
|
+ data.abort = function () { |
|
|
653
|
+ if (this.jqXHR) { |
|
|
654
|
+ return this.jqXHR.abort(); |
|
|
655
|
+ } |
|
|
656
|
+ this.errorThrown = 'abort'; |
|
|
657
|
+ that._trigger('fail', null, this); |
|
|
658
|
+ return that._getXHRPromise(false); |
|
|
659
|
+ }; |
|
|
660
|
+ data.state = function () { |
|
|
661
|
+ if (this.jqXHR) { |
|
|
662
|
+ return that._getDeferredState(this.jqXHR); |
|
|
663
|
+ } |
|
|
664
|
+ if (this._processQueue) { |
|
|
665
|
+ return that._getDeferredState(this._processQueue); |
|
|
666
|
+ } |
|
|
667
|
+ }; |
|
|
668
|
+ data.processing = function () { |
|
|
669
|
+ return !this.jqXHR && this._processQueue && that |
|
|
670
|
+ ._getDeferredState(this._processQueue) === 'pending'; |
|
|
671
|
+ }; |
|
|
672
|
+ data.progress = function () { |
|
|
673
|
+ return this._progress; |
|
|
674
|
+ }; |
|
|
675
|
+ data.response = function () { |
|
|
676
|
+ return this._response; |
|
|
677
|
+ }; |
|
|
678
|
+ }, |
|
|
679
|
+ |
|
|
680
|
+ // Parses the Range header from the server response |
|
|
681
|
+ // and returns the uploaded bytes: |
|
|
682
|
+ _getUploadedBytes: function (jqXHR) { |
|
|
683
|
+ var range = jqXHR.getResponseHeader('Range'), |
|
|
684
|
+ parts = range && range.split('-'), |
|
|
685
|
+ upperBytesPos = parts && parts.length > 1 && |
|
|
686
|
+ parseInt(parts[1], 10); |
|
|
687
|
+ return upperBytesPos && upperBytesPos + 1; |
|
|
688
|
+ }, |
|
|
689
|
+ |
|
|
690
|
+ // Uploads a file in multiple, sequential requests |
|
|
691
|
+ // by splitting the file up in multiple blob chunks. |
|
|
692
|
+ // If the second parameter is true, only tests if the file |
|
|
693
|
+ // should be uploaded in chunks, but does not invoke any |
|
|
694
|
+ // upload requests: |
|
|
695
|
+ _chunkedUpload: function (options, testOnly) { |
|
|
696
|
+ options.uploadedBytes = options.uploadedBytes || 0; |
|
|
697
|
+ var that = this, |
|
|
698
|
+ file = options.files[0], |
|
|
699
|
+ fs = file.size, |
|
|
700
|
+ ub = options.uploadedBytes, |
|
|
701
|
+ mcs = options.maxChunkSize || fs, |
|
|
702
|
+ slice = this._blobSlice, |
|
|
703
|
+ dfd = $.Deferred(), |
|
|
704
|
+ promise = dfd.promise(), |
|
|
705
|
+ jqXHR, |
|
|
706
|
+ upload; |
|
|
707
|
+ if (!(this._isXHRUpload(options) && slice && (ub || mcs < fs)) || |
|
|
708
|
+ options.data) { |
|
|
709
|
+ return false; |
|
|
710
|
+ } |
|
|
711
|
+ if (testOnly) { |
|
|
712
|
+ return true; |
|
|
713
|
+ } |
|
|
714
|
+ if (ub >= fs) { |
|
|
715
|
+ file.error = options.i18n('uploadedBytes'); |
|
|
716
|
+ return this._getXHRPromise( |
|
|
717
|
+ false, |
|
|
718
|
+ options.context, |
|
|
719
|
+ [null, 'error', file.error] |
|
|
720
|
+ ); |
|
|
721
|
+ } |
|
|
722
|
+ // The chunk upload method: |
|
|
723
|
+ upload = function () { |
|
|
724
|
+ // Clone the options object for each chunk upload: |
|
|
725
|
+ var o = $.extend({}, options), |
|
|
726
|
+ currentLoaded = o._progress.loaded; |
|
|
727
|
+ o.blob = slice.call( |
|
|
728
|
+ file, |
|
|
729
|
+ ub, |
|
|
730
|
+ ub + mcs, |
|
|
731
|
+ file.type |
|
|
732
|
+ ); |
|
|
733
|
+ // Store the current chunk size, as the blob itself |
|
|
734
|
+ // will be dereferenced after data processing: |
|
|
735
|
+ o.chunkSize = o.blob.size; |
|
|
736
|
+ // Expose the chunk bytes position range: |
|
|
737
|
+ o.contentRange = 'bytes ' + ub + '-' + |
|
|
738
|
+ (ub + o.chunkSize - 1) + '/' + fs; |
|
|
739
|
+ // Process the upload data (the blob and potential form data): |
|
|
740
|
+ that._initXHRData(o); |
|
|
741
|
+ // Add progress listeners for this chunk upload: |
|
|
742
|
+ that._initProgressListener(o); |
|
|
743
|
+ jqXHR = ((that._trigger('chunksend', null, o) !== false && $.ajax(o)) || |
|
|
744
|
+ that._getXHRPromise(false, o.context)) |
|
|
745
|
+ .done(function (result, textStatus, jqXHR) { |
|
|
746
|
+ ub = that._getUploadedBytes(jqXHR) || |
|
|
747
|
+ (ub + o.chunkSize); |
|
|
748
|
+ // Create a progress event if no final progress event |
|
|
749
|
+ // with loaded equaling total has been triggered |
|
|
750
|
+ // for this chunk: |
|
|
751
|
+ if (currentLoaded + o.chunkSize - o._progress.loaded) { |
|
|
752
|
+ that._onProgress($.Event('progress', { |
|
|
753
|
+ lengthComputable: true, |
|
|
754
|
+ loaded: ub - o.uploadedBytes, |
|
|
755
|
+ total: ub - o.uploadedBytes |
|
|
756
|
+ }), o); |
|
|
757
|
+ } |
|
|
758
|
+ options.uploadedBytes = o.uploadedBytes = ub; |
|
|
759
|
+ o.result = result; |
|
|
760
|
+ o.textStatus = textStatus; |
|
|
761
|
+ o.jqXHR = jqXHR; |
|
|
762
|
+ that._trigger('chunkdone', null, o); |
|
|
763
|
+ that._trigger('chunkalways', null, o); |
|
|
764
|
+ if (ub < fs) { |
|
|
765
|
+ // File upload not yet complete, |
|
|
766
|
+ // continue with the next chunk: |
|
|
767
|
+ upload(); |
|
|
768
|
+ } else { |
|
|
769
|
+ dfd.resolveWith( |
|
|
770
|
+ o.context, |
|
|
771
|
+ [result, textStatus, jqXHR] |
|
|
772
|
+ ); |
|
|
773
|
+ } |
|
|
774
|
+ }) |
|
|
775
|
+ .fail(function (jqXHR, textStatus, errorThrown) { |
|
|
776
|
+ o.jqXHR = jqXHR; |
|
|
777
|
+ o.textStatus = textStatus; |
|
|
778
|
+ o.errorThrown = errorThrown; |
|
|
779
|
+ that._trigger('chunkfail', null, o); |
|
|
780
|
+ that._trigger('chunkalways', null, o); |
|
|
781
|
+ dfd.rejectWith( |
|
|
782
|
+ o.context, |
|
|
783
|
+ [jqXHR, textStatus, errorThrown] |
|
|
784
|
+ ); |
|
|
785
|
+ }); |
|
|
786
|
+ }; |
|
|
787
|
+ this._enhancePromise(promise); |
|
|
788
|
+ promise.abort = function () { |
|
|
789
|
+ return jqXHR.abort(); |
|
|
790
|
+ }; |
|
|
791
|
+ upload(); |
|
|
792
|
+ return promise; |
|
|
793
|
+ }, |
|
|
794
|
+ |
|
|
795
|
+ _beforeSend: function (e, data) { |
|
|
796
|
+ if (this._active === 0) { |
|
|
797
|
+ // the start callback is triggered when an upload starts |
|
|
798
|
+ // and no other uploads are currently running, |
|
|
799
|
+ // equivalent to the global ajaxStart event: |
|
|
800
|
+ this._trigger('start'); |
|
|
801
|
+ // Set timer for global bitrate progress calculation: |
|
|
802
|
+ this._bitrateTimer = new this._BitrateTimer(); |
|
|
803
|
+ // Reset the global progress values: |
|
|
804
|
+ this._progress.loaded = this._progress.total = 0; |
|
|
805
|
+ this._progress.bitrate = 0; |
|
|
806
|
+ } |
|
|
807
|
+ // Make sure the container objects for the .response() and |
|
|
808
|
+ // .progress() methods on the data object are available |
|
|
809
|
+ // and reset to their initial state: |
|
|
810
|
+ this._initResponseObject(data); |
|
|
811
|
+ this._initProgressObject(data); |
|
|
812
|
+ data._progress.loaded = data.loaded = data.uploadedBytes || 0; |
|
|
813
|
+ data._progress.total = data.total = this._getTotal(data.files) || 1; |
|
|
814
|
+ data._progress.bitrate = data.bitrate = 0; |
|
|
815
|
+ this._active += 1; |
|
|
816
|
+ // Initialize the global progress values: |
|
|
817
|
+ this._progress.loaded += data.loaded; |
|
|
818
|
+ this._progress.total += data.total; |
|
|
819
|
+ }, |
|
|
820
|
+ |
|
|
821
|
+ _onDone: function (result, textStatus, jqXHR, options) { |
|
|
822
|
+ var total = options._progress.total, |
|
|
823
|
+ response = options._response; |
|
|
824
|
+ if (options._progress.loaded < total) { |
|
|
825
|
+ // Create a progress event if no final progress event |
|
|
826
|
+ // with loaded equaling total has been triggered: |
|
|
827
|
+ this._onProgress($.Event('progress', { |
|
|
828
|
+ lengthComputable: true, |
|
|
829
|
+ loaded: total, |
|
|
830
|
+ total: total |
|
|
831
|
+ }), options); |
|
|
832
|
+ } |
|
|
833
|
+ response.result = options.result = result; |
|
|
834
|
+ response.textStatus = options.textStatus = textStatus; |
|
|
835
|
+ response.jqXHR = options.jqXHR = jqXHR; |
|
|
836
|
+ this._trigger('done', null, options); |
|
|
837
|
+ }, |
|
|
838
|
+ |
|
|
839
|
+ _onFail: function (jqXHR, textStatus, errorThrown, options) { |
|
|
840
|
+ var response = options._response; |
|
|
841
|
+ if (options.recalculateProgress) { |
|
|
842
|
+ // Remove the failed (error or abort) file upload from |
|
|
843
|
+ // the global progress calculation: |
|
|
844
|
+ this._progress.loaded -= options._progress.loaded; |
|
|
845
|
+ this._progress.total -= options._progress.total; |
|
|
846
|
+ } |
|
|
847
|
+ response.jqXHR = options.jqXHR = jqXHR; |
|
|
848
|
+ response.textStatus = options.textStatus = textStatus; |
|
|
849
|
+ response.errorThrown = options.errorThrown = errorThrown; |
|
|
850
|
+ this._trigger('fail', null, options); |
|
|
851
|
+ }, |
|
|
852
|
+ |
|
|
853
|
+ _onAlways: function (jqXHRorResult, textStatus, jqXHRorError, options) { |
|
|
854
|
+ // jqXHRorResult, textStatus and jqXHRorError are added to the |
|
|
855
|
+ // options object via done and fail callbacks |
|
|
856
|
+ this._trigger('always', null, options); |
|
|
857
|
+ }, |
|
|
858
|
+ |
|
|
859
|
+ _onSend: function (e, data) { |
|
|
860
|
+ if (!data.submit) { |
|
|
861
|
+ this._addConvenienceMethods(e, data); |
|
|
862
|
+ } |
|
|
863
|
+ var that = this, |
|
|
864
|
+ jqXHR, |
|
|
865
|
+ aborted, |
|
|
866
|
+ slot, |
|
|
867
|
+ pipe, |
|
|
868
|
+ options = that._getAJAXSettings(data), |
|
|
869
|
+ send = function () { |
|
|
870
|
+ that._sending += 1; |
|
|
871
|
+ // Set timer for bitrate progress calculation: |
|
|
872
|
+ options._bitrateTimer = new that._BitrateTimer(); |
|
|
873
|
+ jqXHR = jqXHR || ( |
|
|
874
|
+ ((aborted || that._trigger( |
|
|
875
|
+ 'send', |
|
|
876
|
+ $.Event('send', {delegatedEvent: e}), |
|
|
877
|
+ options |
|
|
878
|
+ ) === false) && |
|
|
879
|
+ that._getXHRPromise(false, options.context, aborted)) || |
|
|
880
|
+ that._chunkedUpload(options) || $.ajax(options) |
|
|
881
|
+ ).done(function (result, textStatus, jqXHR) { |
|
|
882
|
+ that._onDone(result, textStatus, jqXHR, options); |
|
|
883
|
+ }).fail(function (jqXHR, textStatus, errorThrown) { |
|
|
884
|
+ that._onFail(jqXHR, textStatus, errorThrown, options); |
|
|
885
|
+ }).always(function (jqXHRorResult, textStatus, jqXHRorError) { |
|
|
886
|
+ that._onAlways( |
|
|
887
|
+ jqXHRorResult, |
|
|
888
|
+ textStatus, |
|
|
889
|
+ jqXHRorError, |
|
|
890
|
+ options |
|
|
891
|
+ ); |
|
|
892
|
+ that._sending -= 1; |
|
|
893
|
+ that._active -= 1; |
|
|
894
|
+ if (options.limitConcurrentUploads && |
|
|
895
|
+ options.limitConcurrentUploads > that._sending) { |
|
|
896
|
+ // Start the next queued upload, |
|
|
897
|
+ // that has not been aborted: |
|
|
898
|
+ var nextSlot = that._slots.shift(); |
|
|
899
|
+ while (nextSlot) { |
|
|
900
|
+ if (that._getDeferredState(nextSlot) === 'pending') { |
|
|
901
|
+ nextSlot.resolve(); |
|
|
902
|
+ break; |
|
|
903
|
+ } |
|
|
904
|
+ nextSlot = that._slots.shift(); |
|
|
905
|
+ } |
|
|
906
|
+ } |
|
|
907
|
+ if (that._active === 0) { |
|
|
908
|
+ // The stop callback is triggered when all uploads have |
|
|
909
|
+ // been completed, equivalent to the global ajaxStop event: |
|
|
910
|
+ that._trigger('stop'); |
|
|
911
|
+ } |
|
|
912
|
+ }); |
|
|
913
|
+ return jqXHR; |
|
|
914
|
+ }; |
|
|
915
|
+ this._beforeSend(e, options); |
|
|
916
|
+ if (this.options.sequentialUploads || |
|
|
917
|
+ (this.options.limitConcurrentUploads && |
|
|
918
|
+ this.options.limitConcurrentUploads <= this._sending)) { |
|
|
919
|
+ if (this.options.limitConcurrentUploads > 1) { |
|
|
920
|
+ slot = $.Deferred(); |
|
|
921
|
+ this._slots.push(slot); |
|
|
922
|
+ pipe = slot.pipe(send); |
|
|
923
|
+ } else { |
|
|
924
|
+ this._sequence = this._sequence.pipe(send, send); |
|
|
925
|
+ pipe = this._sequence; |
|
|
926
|
+ } |
|
|
927
|
+ // Return the piped Promise object, enhanced with an abort method, |
|
|
928
|
+ // which is delegated to the jqXHR object of the current upload, |
|
|
929
|
+ // and jqXHR callbacks mapped to the equivalent Promise methods: |
|
|
930
|
+ pipe.abort = function () { |
|
|
931
|
+ aborted = [undefined, 'abort', 'abort']; |
|
|
932
|
+ if (!jqXHR) { |
|
|
933
|
+ if (slot) { |
|
|
934
|
+ slot.rejectWith(options.context, aborted); |
|
|
935
|
+ } |
|
|
936
|
+ return send(); |
|
|
937
|
+ } |
|
|
938
|
+ return jqXHR.abort(); |
|
|
939
|
+ }; |
|
|
940
|
+ return this._enhancePromise(pipe); |
|
|
941
|
+ } |
|
|
942
|
+ return send(); |
|
|
943
|
+ }, |
|
|
944
|
+ |
|
|
945
|
+ _onAdd: function (e, data) { |
|
|
946
|
+ var that = this, |
|
|
947
|
+ result = true, |
|
|
948
|
+ options = $.extend({}, this.options, data), |
|
|
949
|
+ files = data.files, |
|
|
950
|
+ filesLength = files.length, |
|
|
951
|
+ limit = options.limitMultiFileUploads, |
|
|
952
|
+ limitSize = options.limitMultiFileUploadSize, |
|
|
953
|
+ overhead = options.limitMultiFileUploadSizeOverhead, |
|
|
954
|
+ batchSize = 0, |
|
|
955
|
+ paramName = this._getParamName(options), |
|
|
956
|
+ paramNameSet, |
|
|
957
|
+ paramNameSlice, |
|
|
958
|
+ fileSet, |
|
|
959
|
+ i, |
|
|
960
|
+ j = 0; |
|
|
961
|
+ if (limitSize && (!filesLength || files[0].size === undefined)) { |
|
|
962
|
+ limitSize = undefined; |
|
|
963
|
+ } |
|
|
964
|
+ if (!(options.singleFileUploads || limit || limitSize) || |
|
|
965
|
+ !this._isXHRUpload(options)) { |
|
|
966
|
+ fileSet = [files]; |
|
|
967
|
+ paramNameSet = [paramName]; |
|
|
968
|
+ } else if (!(options.singleFileUploads || limitSize) && limit) { |
|
|
969
|
+ fileSet = []; |
|
|
970
|
+ paramNameSet = []; |
|
|
971
|
+ for (i = 0; i < filesLength; i += limit) { |
|
|
972
|
+ fileSet.push(files.slice(i, i + limit)); |
|
|
973
|
+ paramNameSlice = paramName.slice(i, i + limit); |
|
|
974
|
+ if (!paramNameSlice.length) { |
|
|
975
|
+ paramNameSlice = paramName; |
|
|
976
|
+ } |
|
|
977
|
+ paramNameSet.push(paramNameSlice); |
|
|
978
|
+ } |
|
|
979
|
+ } else if (!options.singleFileUploads && limitSize) { |
|
|
980
|
+ fileSet = []; |
|
|
981
|
+ paramNameSet = []; |
|
|
982
|
+ for (i = 0; i < filesLength; i = i + 1) { |
|
|
983
|
+ batchSize += files[i].size + overhead; |
|
|
984
|
+ if (i + 1 === filesLength || |
|
|
985
|
+ ((batchSize + files[i + 1].size + overhead) > limitSize) || |
|
|
986
|
+ (limit && i + 1 - j >= limit)) { |
|
|
987
|
+ fileSet.push(files.slice(j, i + 1)); |
|
|
988
|
+ paramNameSlice = paramName.slice(j, i + 1); |
|
|
989
|
+ if (!paramNameSlice.length) { |
|
|
990
|
+ paramNameSlice = paramName; |
|
|
991
|
+ } |
|
|
992
|
+ paramNameSet.push(paramNameSlice); |
|
|
993
|
+ j = i + 1; |
|
|
994
|
+ batchSize = 0; |
|
|
995
|
+ } |
|
|
996
|
+ } |
|
|
997
|
+ } else { |
|
|
998
|
+ paramNameSet = paramName; |
|
|
999
|
+ } |
|
|
1000
|
+ data.originalFiles = files; |
|
|
1001
|
+ $.each(fileSet || files, function (index, element) { |
|
|
1002
|
+ var newData = $.extend({}, data); |
|
|
1003
|
+ newData.files = fileSet ? element : [element]; |
|
|
1004
|
+ newData.paramName = paramNameSet[index]; |
|
|
1005
|
+ that._initResponseObject(newData); |
|
|
1006
|
+ that._initProgressObject(newData); |
|
|
1007
|
+ that._addConvenienceMethods(e, newData); |
|
|
1008
|
+ result = that._trigger( |
|
|
1009
|
+ 'add', |
|
|
1010
|
+ $.Event('add', {delegatedEvent: e}), |
|
|
1011
|
+ newData |
|
|
1012
|
+ ); |
|
|
1013
|
+ return result; |
|
|
1014
|
+ }); |
|
|
1015
|
+ return result; |
|
|
1016
|
+ }, |
|
|
1017
|
+ |
|
|
1018
|
+ _replaceFileInput: function (input) { |
|
|
1019
|
+ var inputClone = input.clone(true); |
|
|
1020
|
+ $('<form></form>').append(inputClone)[0].reset(); |
|
|
1021
|
+ // Detaching allows to insert the fileInput on another form |
|
|
1022
|
+ // without loosing the file input value: |
|
|
1023
|
+ input.after(inputClone).detach(); |
|
|
1024
|
+ // Avoid memory leaks with the detached file input: |
|
|
1025
|
+ $.cleanData(input.unbind('remove')); |
|
|
1026
|
+ // Replace the original file input element in the fileInput |
|
|
1027
|
+ // elements set with the clone, which has been copied including |
|
|
1028
|
+ // event handlers: |
|
|
1029
|
+ this.options.fileInput = this.options.fileInput.map(function (i, el) { |
|
|
1030
|
+ if (el === input[0]) { |
|
|
1031
|
+ return inputClone[0]; |
|
|
1032
|
+ } |
|
|
1033
|
+ return el; |
|
|
1034
|
+ }); |
|
|
1035
|
+ // If the widget has been initialized on the file input itself, |
|
|
1036
|
+ // override this.element with the file input clone: |
|
|
1037
|
+ if (input[0] === this.element[0]) { |
|
|
1038
|
+ this.element = inputClone; |
|
|
1039
|
+ } |
|
|
1040
|
+ }, |
|
|
1041
|
+ |
|
|
1042
|
+ _handleFileTreeEntry: function (entry, path) { |
|
|
1043
|
+ var that = this, |
|
|
1044
|
+ dfd = $.Deferred(), |
|
|
1045
|
+ errorHandler = function (e) { |
|
|
1046
|
+ if (e && !e.entry) { |
|
|
1047
|
+ e.entry = entry; |
|
|
1048
|
+ } |
|
|
1049
|
+ // Since $.when returns immediately if one |
|
|
1050
|
+ // Deferred is rejected, we use resolve instead. |
|
|
1051
|
+ // This allows valid files and invalid items |
|
|
1052
|
+ // to be returned together in one set: |
|
|
1053
|
+ dfd.resolve([e]); |
|
|
1054
|
+ }, |
|
|
1055
|
+ successHandler = function (entries) { |
|
|
1056
|
+ that._handleFileTreeEntries( |
|
|
1057
|
+ entries, |
|
|
1058
|
+ path + entry.name + '/' |
|
|
1059
|
+ ).done(function (files) { |
|
|
1060
|
+ dfd.resolve(files); |
|
|
1061
|
+ }).fail(errorHandler); |
|
|
1062
|
+ }, |
|
|
1063
|
+ readEntries = function () { |
|
|
1064
|
+ dirReader.readEntries(function (results) { |
|
|
1065
|
+ if (!results.length) { |
|
|
1066
|
+ successHandler(entries); |
|
|
1067
|
+ } else { |
|
|
1068
|
+ entries = entries.concat(results); |
|
|
1069
|
+ readEntries(); |
|
|
1070
|
+ } |
|
|
1071
|
+ }, errorHandler); |
|
|
1072
|
+ }, |
|
|
1073
|
+ dirReader, entries = []; |
|
|
1074
|
+ path = path || ''; |
|
|
1075
|
+ if (entry.isFile) { |
|
|
1076
|
+ if (entry._file) { |
|
|
1077
|
+ // Workaround for Chrome bug #149735 |
|
|
1078
|
+ entry._file.relativePath = path; |
|
|
1079
|
+ dfd.resolve(entry._file); |
|
|
1080
|
+ } else { |
|
|
1081
|
+ entry.file(function (file) { |
|
|
1082
|
+ file.relativePath = path; |
|
|
1083
|
+ dfd.resolve(file); |
|
|
1084
|
+ }, errorHandler); |
|
|
1085
|
+ } |
|
|
1086
|
+ } else if (entry.isDirectory) { |
|
|
1087
|
+ dirReader = entry.createReader(); |
|
|
1088
|
+ readEntries(); |
|
|
1089
|
+ } else { |
|
|
1090
|
+ // Return an empy list for file system items |
|
|
1091
|
+ // other than files or directories: |
|
|
1092
|
+ dfd.resolve([]); |
|
|
1093
|
+ } |
|
|
1094
|
+ return dfd.promise(); |
|
|
1095
|
+ }, |
|
|
1096
|
+ |
|
|
1097
|
+ _handleFileTreeEntries: function (entries, path) { |
|
|
1098
|
+ var that = this; |
|
|
1099
|
+ return $.when.apply( |
|
|
1100
|
+ $, |
|
|
1101
|
+ $.map(entries, function (entry) { |
|
|
1102
|
+ return that._handleFileTreeEntry(entry, path); |
|
|
1103
|
+ }) |
|
|
1104
|
+ ).pipe(function () { |
|
|
1105
|
+ return Array.prototype.concat.apply( |
|
|
1106
|
+ [], |
|
|
1107
|
+ arguments |
|
|
1108
|
+ ); |
|
|
1109
|
+ }); |
|
|
1110
|
+ }, |
|
|
1111
|
+ |
|
|
1112
|
+ _getDroppedFiles: function (dataTransfer) { |
|
|
1113
|
+ dataTransfer = dataTransfer || {}; |
|
|
1114
|
+ var items = dataTransfer.items; |
|
|
1115
|
+ if (items && items.length && (items[0].webkitGetAsEntry || |
|
|
1116
|
+ items[0].getAsEntry)) { |
|
|
1117
|
+ return this._handleFileTreeEntries( |
|
|
1118
|
+ $.map(items, function (item) { |
|
|
1119
|
+ var entry; |
|
|
1120
|
+ if (item.webkitGetAsEntry) { |
|
|
1121
|
+ entry = item.webkitGetAsEntry(); |
|
|
1122
|
+ if (entry) { |
|
|
1123
|
+ // Workaround for Chrome bug #149735: |
|
|
1124
|
+ entry._file = item.getAsFile(); |
|
|
1125
|
+ } |
|
|
1126
|
+ return entry; |
|
|
1127
|
+ } |
|
|
1128
|
+ return item.getAsEntry(); |
|
|
1129
|
+ }) |
|
|
1130
|
+ ); |
|
|
1131
|
+ } |
|
|
1132
|
+ return $.Deferred().resolve( |
|
|
1133
|
+ $.makeArray(dataTransfer.files) |
|
|
1134
|
+ ).promise(); |
|
|
1135
|
+ }, |
|
|
1136
|
+ |
|
|
1137
|
+ _getSingleFileInputFiles: function (fileInput) { |
|
|
1138
|
+ fileInput = $(fileInput); |
|
|
1139
|
+ var entries = fileInput.prop('webkitEntries') || |
|
|
1140
|
+ fileInput.prop('entries'), |
|
|
1141
|
+ files, |
|
|
1142
|
+ value; |
|
|
1143
|
+ if (entries && entries.length) { |
|
|
1144
|
+ return this._handleFileTreeEntries(entries); |
|
|
1145
|
+ } |
|
|
1146
|
+ files = $.makeArray(fileInput.prop('files')); |
|
|
1147
|
+ if (!files.length) { |
|
|
1148
|
+ value = fileInput.prop('value'); |
|
|
1149
|
+ if (!value) { |
|
|
1150
|
+ return $.Deferred().resolve([]).promise(); |
|
|
1151
|
+ } |
|
|
1152
|
+ // If the files property is not available, the browser does not |
|
|
1153
|
+ // support the File API and we add a pseudo File object with |
|
|
1154
|
+ // the input value as name with path information removed: |
|
|
1155
|
+ files = [{name: value.replace(/^.*\\/, '')}]; |
|
|
1156
|
+ } else if (files[0].name === undefined && files[0].fileName) { |
|
|
1157
|
+ // File normalization for Safari 4 and Firefox 3: |
|
|
1158
|
+ $.each(files, function (index, file) { |
|
|
1159
|
+ file.name = file.fileName; |
|
|
1160
|
+ file.size = file.fileSize; |
|
|
1161
|
+ }); |
|
|
1162
|
+ } |
|
|
1163
|
+ return $.Deferred().resolve(files).promise(); |
|
|
1164
|
+ }, |
|
|
1165
|
+ |
|
|
1166
|
+ _getFileInputFiles: function (fileInput) { |
|
|
1167
|
+ if (!(fileInput instanceof $) || fileInput.length === 1) { |
|
|
1168
|
+ return this._getSingleFileInputFiles(fileInput); |
|
|
1169
|
+ } |
|
|
1170
|
+ return $.when.apply( |
|
|
1171
|
+ $, |
|
|
1172
|
+ $.map(fileInput, this._getSingleFileInputFiles) |
|
|
1173
|
+ ).pipe(function () { |
|
|
1174
|
+ return Array.prototype.concat.apply( |
|
|
1175
|
+ [], |
|
|
1176
|
+ arguments |
|
|
1177
|
+ ); |
|
|
1178
|
+ }); |
|
|
1179
|
+ }, |
|
|
1180
|
+ |
|
|
1181
|
+ _onChange: function (e) { |
|
|
1182
|
+ var that = this, |
|
|
1183
|
+ data = { |
|
|
1184
|
+ fileInput: $(e.target), |
|
|
1185
|
+ form: $(e.target.form) |
|
|
1186
|
+ }; |
|
|
1187
|
+ this._getFileInputFiles(data.fileInput).always(function (files) { |
|
|
1188
|
+ data.files = files; |
|
|
1189
|
+ if (that.options.replaceFileInput) { |
|
|
1190
|
+ that._replaceFileInput(data.fileInput); |
|
|
1191
|
+ } |
|
|
1192
|
+ if (that._trigger( |
|
|
1193
|
+ 'change', |
|
|
1194
|
+ $.Event('change', {delegatedEvent: e}), |
|
|
1195
|
+ data |
|
|
1196
|
+ ) !== false) { |
|
|
1197
|
+ that._onAdd(e, data); |
|
|
1198
|
+ } |
|
|
1199
|
+ }); |
|
|
1200
|
+ }, |
|
|
1201
|
+ |
|
|
1202
|
+ _onPaste: function (e) { |
|
|
1203
|
+ var items = e.originalEvent && e.originalEvent.clipboardData && |
|
|
1204
|
+ e.originalEvent.clipboardData.items, |
|
|
1205
|
+ data = {files: []}; |
|
|
1206
|
+ if (items && items.length) { |
|
|
1207
|
+ $.each(items, function (index, item) { |
|
|
1208
|
+ var file = item.getAsFile && item.getAsFile(); |
|
|
1209
|
+ if (file) { |
|
|
1210
|
+ data.files.push(file); |
|
|
1211
|
+ } |
|
|
1212
|
+ }); |
|
|
1213
|
+ if (this._trigger( |
|
|
1214
|
+ 'paste', |
|
|
1215
|
+ $.Event('paste', {delegatedEvent: e}), |
|
|
1216
|
+ data |
|
|
1217
|
+ ) !== false) { |
|
|
1218
|
+ this._onAdd(e, data); |
|
|
1219
|
+ } |
|
|
1220
|
+ } |
|
|
1221
|
+ }, |
|
|
1222
|
+ |
|
|
1223
|
+ _onDrop: function (e) { |
|
|
1224
|
+ e.dataTransfer = e.originalEvent && e.originalEvent.dataTransfer; |
|
|
1225
|
+ var that = this, |
|
|
1226
|
+ dataTransfer = e.dataTransfer, |
|
|
1227
|
+ data = {}; |
|
|
1228
|
+ if (dataTransfer && dataTransfer.files && dataTransfer.files.length) { |
|
|
1229
|
+ e.preventDefault(); |
|
|
1230
|
+ this._getDroppedFiles(dataTransfer).always(function (files) { |
|
|
1231
|
+ data.files = files; |
|
|
1232
|
+ if (that._trigger( |
|
|
1233
|
+ 'drop', |
|
|
1234
|
+ $.Event('drop', {delegatedEvent: e}), |
|
|
1235
|
+ data |
|
|
1236
|
+ ) !== false) { |
|
|
1237
|
+ that._onAdd(e, data); |
|
|
1238
|
+ } |
|
|
1239
|
+ }); |
|
|
1240
|
+ } |
|
|
1241
|
+ }, |
|
|
1242
|
+ |
|
|
1243
|
+ _onDragOver: function (e) { |
|
|
1244
|
+ e.dataTransfer = e.originalEvent && e.originalEvent.dataTransfer; |
|
|
1245
|
+ var dataTransfer = e.dataTransfer; |
|
|
1246
|
+ if (dataTransfer && $.inArray('Files', dataTransfer.types) !== -1 && |
|
|
1247
|
+ this._trigger( |
|
|
1248
|
+ 'dragover', |
|
|
1249
|
+ $.Event('dragover', {delegatedEvent: e}) |
|
|
1250
|
+ ) !== false) { |
|
|
1251
|
+ e.preventDefault(); |
|
|
1252
|
+ dataTransfer.dropEffect = 'copy'; |
|
|
1253
|
+ } |
|
|
1254
|
+ }, |
|
|
1255
|
+ |
|
|
1256
|
+ _initEventHandlers: function () { |
|
|
1257
|
+ if (this._isXHRUpload(this.options)) { |
|
|
1258
|
+ this._on(this.options.dropZone, { |
|
|
1259
|
+ dragover: this._onDragOver, |
|
|
1260
|
+ drop: this._onDrop |
|
|
1261
|
+ }); |
|
|
1262
|
+ this._on(this.options.pasteZone, { |
|
|
1263
|
+ paste: this._onPaste |
|
|
1264
|
+ }); |
|
|
1265
|
+ } |
|
|
1266
|
+ if ($.support.fileInput) { |
|
|
1267
|
+ this._on(this.options.fileInput, { |
|
|
1268
|
+ change: this._onChange |
|
|
1269
|
+ }); |
|
|
1270
|
+ } |
|
|
1271
|
+ }, |
|
|
1272
|
+ |
|
|
1273
|
+ _destroyEventHandlers: function () { |
|
|
1274
|
+ this._off(this.options.dropZone, 'dragover drop'); |
|
|
1275
|
+ this._off(this.options.pasteZone, 'paste'); |
|
|
1276
|
+ this._off(this.options.fileInput, 'change'); |
|
|
1277
|
+ }, |
|
|
1278
|
+ |
|
|
1279
|
+ _setOption: function (key, value) { |
|
|
1280
|
+ var reinit = $.inArray(key, this._specialOptions) !== -1; |
|
|
1281
|
+ if (reinit) { |
|
|
1282
|
+ this._destroyEventHandlers(); |
|
|
1283
|
+ } |
|
|
1284
|
+ this._super(key, value); |
|
|
1285
|
+ if (reinit) { |
|
|
1286
|
+ this._initSpecialOptions(); |
|
|
1287
|
+ this._initEventHandlers(); |
|
|
1288
|
+ } |
|
|
1289
|
+ }, |
|
|
1290
|
+ |
|
|
1291
|
+ _initSpecialOptions: function () { |
|
|
1292
|
+ var options = this.options; |
|
|
1293
|
+ if (options.fileInput === undefined) { |
|
|
1294
|
+ options.fileInput = this.element.is('input[type="file"]') ? |
|
|
1295
|
+ this.element : this.element.find('input[type="file"]'); |
|
|
1296
|
+ } else if (!(options.fileInput instanceof $)) { |
|
|
1297
|
+ options.fileInput = $(options.fileInput); |
|
|
1298
|
+ } |
|
|
1299
|
+ if (!(options.dropZone instanceof $)) { |
|
|
1300
|
+ options.dropZone = $(options.dropZone); |
|
|
1301
|
+ } |
|
|
1302
|
+ if (!(options.pasteZone instanceof $)) { |
|
|
1303
|
+ options.pasteZone = $(options.pasteZone); |
|
|
1304
|
+ } |
|
|
1305
|
+ }, |
|
|
1306
|
+ |
|
|
1307
|
+ _getRegExp: function (str) { |
|
|
1308
|
+ var parts = str.split('/'), |
|
|
1309
|
+ modifiers = parts.pop(); |
|
|
1310
|
+ parts.shift(); |
|
|
1311
|
+ return new RegExp(parts.join('/'), modifiers); |
|
|
1312
|
+ }, |
|
|
1313
|
+ |
|
|
1314
|
+ _isRegExpOption: function (key, value) { |
|
|
1315
|
+ return key !== 'url' && $.type(value) === 'string' && |
|
|
1316
|
+ /^\/.*\/[igm]{0,3}$/.test(value); |
|
|
1317
|
+ }, |
|
|
1318
|
+ |
|
|
1319
|
+ _initDataAttributes: function () { |
|
|
1320
|
+ var that = this, |
|
|
1321
|
+ options = this.options, |
|
|
1322
|
+ clone = $(this.element[0].cloneNode(false)); |
|
|
1323
|
+ // Initialize options set via HTML5 data-attributes: |
|
|
1324
|
+ $.each( |
|
|
1325
|
+ clone.data(), |
|
|
1326
|
+ function (key, value) { |
|
|
1327
|
+ var dataAttributeName = 'data-' + |
|
|
1328
|
+ // Convert camelCase to hyphen-ated key: |
|
|
1329
|
+ key.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase(); |
|
|
1330
|
+ if (clone.attr(dataAttributeName)) { |
|
|
1331
|
+ if (that._isRegExpOption(key, value)) { |
|
|
1332
|
+ value = that._getRegExp(value); |
|
|
1333
|
+ } |
|
|
1334
|
+ options[key] = value; |
|
|
1335
|
+ } |
|
|
1336
|
+ } |
|
|
1337
|
+ ); |
|
|
1338
|
+ }, |
|
|
1339
|
+ |
|
|
1340
|
+ _create: function () { |
|
|
1341
|
+ this._initDataAttributes(); |
|
|
1342
|
+ this._initSpecialOptions(); |
|
|
1343
|
+ this._slots = []; |
|
|
1344
|
+ this._sequence = this._getXHRPromise(true); |
|
|
1345
|
+ this._sending = this._active = 0; |
|
|
1346
|
+ this._initProgressObject(this); |
|
|
1347
|
+ this._initEventHandlers(); |
|
|
1348
|
+ }, |
|
|
1349
|
+ |
|
|
1350
|
+ // This method is exposed to the widget API and allows to query |
|
|
1351
|
+ // the number of active uploads: |
|
|
1352
|
+ active: function () { |
|
|
1353
|
+ return this._active; |
|
|
1354
|
+ }, |
|
|
1355
|
+ |
|
|
1356
|
+ // This method is exposed to the widget API and allows to query |
|
|
1357
|
+ // the widget upload progress. |
|
|
1358
|
+ // It returns an object with loaded, total and bitrate properties |
|
|
1359
|
+ // for the running uploads: |
|
|
1360
|
+ progress: function () { |
|
|
1361
|
+ return this._progress; |
|
|
1362
|
+ }, |
|
|
1363
|
+ |
|
|
1364
|
+ // This method is exposed to the widget API and allows adding files |
|
|
1365
|
+ // using the fileupload API. The data parameter accepts an object which |
|
|
1366
|
+ // must have a files property and can contain additional options: |
|
|
1367
|
+ // .fileupload('add', {files: filesList}); |
|
|
1368
|
+ add: function (data) { |
|
|
1369
|
+ var that = this; |
|
|
1370
|
+ if (!data || this.options.disabled) { |
|
|
1371
|
+ return; |
|
|
1372
|
+ } |
|
|
1373
|
+ if (data.fileInput && !data.files) { |
|
|
1374
|
+ this._getFileInputFiles(data.fileInput).always(function (files) { |
|
|
1375
|
+ data.files = files; |
|
|
1376
|
+ that._onAdd(null, data); |
|
|
1377
|
+ }); |
|
|
1378
|
+ } else { |
|
|
1379
|
+ data.files = $.makeArray(data.files); |
|
|
1380
|
+ this._onAdd(null, data); |
|
|
1381
|
+ } |
|
|
1382
|
+ }, |
|
|
1383
|
+ |
|
|
1384
|
+ // This method is exposed to the widget API and allows sending files |
|
|
1385
|
+ // using the fileupload API. The data parameter accepts an object which |
|
|
1386
|
+ // must have a files or fileInput property and can contain additional options: |
|
|
1387
|
+ // .fileupload('send', {files: filesList}); |
|
|
1388
|
+ // The method returns a Promise object for the file upload call. |
|
|
1389
|
+ send: function (data) { |
|
|
1390
|
+ if (data && !this.options.disabled) { |
|
|
1391
|
+ if (data.fileInput && !data.files) { |
|
|
1392
|
+ var that = this, |
|
|
1393
|
+ dfd = $.Deferred(), |
|
|
1394
|
+ promise = dfd.promise(), |
|
|
1395
|
+ jqXHR, |
|
|
1396
|
+ aborted; |
|
|
1397
|
+ promise.abort = function () { |
|
|
1398
|
+ aborted = true; |
|
|
1399
|
+ if (jqXHR) { |
|
|
1400
|
+ return jqXHR.abort(); |
|
|
1401
|
+ } |
|
|
1402
|
+ dfd.reject(null, 'abort', 'abort'); |
|
|
1403
|
+ return promise; |
|
|
1404
|
+ }; |
|
|
1405
|
+ this._getFileInputFiles(data.fileInput).always( |
|
|
1406
|
+ function (files) { |
|
|
1407
|
+ if (aborted) { |
|
|
1408
|
+ return; |
|
|
1409
|
+ } |
|
|
1410
|
+ if (!files.length) { |
|
|
1411
|
+ dfd.reject(); |
|
|
1412
|
+ return; |
|
|
1413
|
+ } |
|
|
1414
|
+ data.files = files; |
|
|
1415
|
+ jqXHR = that._onSend(null, data); |
|
|
1416
|
+ jqXHR.then( |
|
|
1417
|
+ function (result, textStatus, jqXHR) { |
|
|
1418
|
+ dfd.resolve(result, textStatus, jqXHR); |
|
|
1419
|
+ }, |
|
|
1420
|
+ function (jqXHR, textStatus, errorThrown) { |
|
|
1421
|
+ dfd.reject(jqXHR, textStatus, errorThrown); |
|
|
1422
|
+ } |
|
|
1423
|
+ ); |
|
|
1424
|
+ } |
|
|
1425
|
+ ); |
|
|
1426
|
+ return this._enhancePromise(promise); |
|
|
1427
|
+ } |
|
|
1428
|
+ data.files = $.makeArray(data.files); |
|
|
1429
|
+ if (data.files.length) { |
|
|
1430
|
+ return this._onSend(null, data); |
|
|
1431
|
+ } |
|
|
1432
|
+ } |
|
|
1433
|
+ return this._getXHRPromise(false, data && data.context); |
|
|
1434
|
+ } |
|
|
1435
|
+ |
|
|
1436
|
+ }); |
|
|
1437
|
+ |
|
|
1438
|
+})); |
...
|
...
|
|
