https://www.antiqueromanpalace.com/ScriptResource.axd?d=uPFS3ID8cg…6FlnVR8BvlzpJKgGLV6NApJ0&t=ffffffffcda035a6

1// Name:        AjaxFileUpload.AjaxFileUpload.ProcessorHtml5.debug.js
2// Assembly:    AjaxControlToolkit
3// Version:     3.5.7.1213
4// FileVersion: 3.5.7.1213
5Type.registerNamespace("Sys.Extended.UI.AjaxFileUpload");
6Type.registerNamespace("AjaxFileUpload");
7
8Sys.Extended.UI.AjaxFileUpload.ProcessorHtml5 = function (control, elements) {
9
10    var utils = new Sys.Extended.UI.AjaxFileUpload.Utils(),
11        chunkSize = control.get_chunkSize() * 1000,
12        tmpXhrLoaded = 0,
13        xhrReq = null;
14
15    this.initialize = function () {
16        $common.setVisible(elements.dropZone, true);
17        elements.dropZone.innerHTML = Sys.Extended.UI.Resources.AjaxFileUpload_DropFiles;
18
19        this.attachEvents();
20    };
21
22    this.attachEvents = function () {
23        
24        this.onFileDropped$delegate = Function.createDelegate(this, this.onFileDroppedHandler);
25        this.onFileDragOver$delegate = Function.createDelegate(this, this.onFileDragOverHandler);
26        this.onFileSelected$delegate = Function.createDelegate(this, this.onFileSelectedHandler);
27        
28        elements.inputFile.addEventListener("change", this.onFileSelected$delegate, false);
29        elements.dropZone.addEventListener("drop", this.onFileDropped$delegate, false);
30        elements.dropZone.addEventListener("dragover", this.onFileDragOver$delegate, false);
31
32    };
33    
34
35    this.onFileDroppedHandler = function (e) {
36        e.stopPropagation();
37        e.preventDefault();
38        this.addFilesToQueue(e.dataTransfer.files);
39    };
40    
41    this.onFileDragOverHandler = function (e) {
42        e.stopPropagation();
43        e.preventDefault();
44    };
45
46    this.onFileSelectedHandler = function (e) {
47        this.addFilesToQueue(e.target.files);
48    };
49    
50    
51
52
53    this.addFilesToQueue = function (files) {
54        /// <summary>
55        /// Validate and generate file item from HTML5 files.
56        /// </summary>
57        /// <param name="files">HTML5 files.</param>
58        
59        for (var i = 0; i < files.length; i++) {
60
61            var blob = files[i],
62                slices = 0;
63            
64            if (blob.size > chunkSize) {
65                slices = Math.ceil(blob.size / chunkSize);
66            }
67
68            var fileItem = {
69                    id: utils.generateGuid(),
70                    value: files[i],
71                    type: utils.getFileType(files[i]),
72                    uploaded: false,
73                    slices: slices
74                };
75            
76            if (control.fileTypeIsValid(fileItem.type)) {
77                if (!control.addFileToQueue(fileItem))
78                    break;
79            } else {
80                control.confirmFileIsInvalid(fileItem);
81            }
82        }
83
84        elements.inputFile.value = null;
85    };
86    
87    this.cancelUpload = function () {
88        
89        if (xhrReq) xhrReq.abort();
90        
91        control.cancelUpload();
92    },
93
94    this.startUpload = function () {
95        /// <summary>
96        /// Get un-uploaded file on the top from queue and start upload it.
97        /// </summary>
98        
99        var fileItem = control.getNextFile();
100        
101        if (fileItem) {
102            if (fileItem._sliceIndex === 0)
103                control.setPercent(0);
104            $common.setVisible(elements.progressBarContainer, true);
105            this.upload(fileItem);
106        } else {
107            control._currentFileId = null;
108            control.setPercent(0);
109            $common.setVisible(elements.progressBarContainer, false);
110            control.done();
111        }
112    };
113
114    this.upload = function (fileItem) {
115        /// <summary>
116        /// Process file item for uploading.
117        /// </summary>
118        /// <param name="fileItem">file item to be uploaded</param>
119        
120        if (!control._isUploading)
121            return;
122
123        $common.setVisible(elements.progressBar, true);
124        
125        control.setAsUploading(fileItem);
126
127        var blob = fileItem.get_inputElementValue(),
128            fileName = fileItem._fileName,
129            chunked = fileItem._slices && (fileItem._slices > 0),
130            firstChunk = fileItem._sliceIndex == 0;
131        
132        if (chunked) {
133            var start = fileItem._sliceIndex * chunkSize,
134                stop = start + chunkSize;            
135            blob = blob.slice(start, stop > blob.size ? blob.size : stop);
136        } 
137
138        var form = new FormData(),
139            id = control._currentFileId = fileItem._id,
140            xhrReq = new XMLHttpRequest(),
141            self = this,
142            xhrDelegate = function (method) { return function (e) { method.call(self, id, e); }; };
143        
144        xhrReq.upload.addEventListener("progress", xhrDelegate(this.onProgressHandler), false);
145        xhrReq.addEventListener("load", xhrDelegate(this.onUploadCompleteHandler), false);
146        xhrReq.addEventListener("error", xhrDelegate(this.onUploadFailedHandler), false);
147        xhrReq.addEventListener("abort", xhrDelegate(this.onUploadCanceledHandler), false);
148        xhrReq.open("POST", control._uploadUrl + '?contextKey=' + control._contextKey + '&fileId=' + id + '&fileName=' + fileName + '&chunked=' + (chunked ? "true" : "false") + '&firstChunk=' + firstChunk + '&storeToAzure=' + control.get_storeToAzure() + '&acn='+control.get_azureContainerName(), true);
149        form.append("act-file-data", blob);
150        xhrReq.send(form);
151    };
152
153    this.onProgressHandler = function (id, xhr) {
154        /// <summary>
155        /// if lengthComputable is available, then let's provide progress bar animation.
156        /// </summary>
157        /// <param name="id">fileId</param>
158        /// <param name="xhr"></param>
159        
160
161        if (!control._isUploading)
162            return;
163        
164
165        if (xhr.lengthComputable) {
166

167            tmpXhrLoaded = xhr.loaded;
168            
169            var fileItem = control.getFileItem(id),
170                slices = fileItem._slices,
171                
172                allBytesUploaded = fileItem._bytesUploaded + tmpXhrLoaded,
173                
174                calculatedFileSize =
175                    slices - fileItem._sliceIndex == 1
176                        ? allBytesUploaded
177                        : xhr.total * slices,
178
179                percentComplete =
180                    slices == 0 
181                        ? (xhr.loaded * 100 / xhr.total).toFixed(2)
182                        : ((allBytesUploaded / calculatedFileSize) * 100).toFixed(2);
183            
184            control.setPercent(percentComplete);
185        }
186    };
187
188    this.onUploadCompleteHandler = function (id, xhr) {
189        /// <summary>
190        /// This handler invoked once all stream are uploaded.
191        /// </summary>
192        /// <param name="id">File Id</param>
193        /// <param name="xhr">XHR sender</param>
194        
195        var self = this,
196            fileItem = control.getFileItem(id),
197            file = fileItem.get_inputElementValue();
198        
199        
200        if (fileItem._slices && fileItem._slices > 0 && fileItem._sliceIndex + 1 < fileItem._slices) {
201            
202            fileItem._sliceIndex++;
203            fileItem._bytesUploaded += tmpXhrLoaded;
204            tmpXhrLoaded = 0;
205            self.startUpload();
206            
207        } else {
208            
209            fileItem.hide();
210            
211            fileItem.setStatus('uploaded', Sys.Extended.UI.Resources.AjaxFileUpload_Uploaded);
212            control.setStatusMessage(String.format(Sys.Extended.UI.Resources.AjaxFileUpload_UploadingHtml5File,
213                file.name, utils.sizeToString(file.size)));
214
215            control.doneAndUploadNextFile(fileItem);
216        }
217    };
218
219    this.onUploadFailedHandler = function (id, xhr) {
220        /// <summary>
221        /// Event handler when ajax request for upload is error.
222        /// </summary>
223        /// <param name="id">file id</param>
224        /// <param name="xhr">xhr</param>
225        var fileItem = control.getFileItem(id);
226        fileItem._isUploading = false;
227        control.setFileStatus(id, 'error', Sys.Extended.UI.Resources.AjaxFileUpload_error);
228        control.raiseUploadError(xhr);
229    };
230
231    this.onUploadCanceledHandler = function (id, xhr) {
232        /// <summary>
233        /// Event handler when ajax request for upload is aborted.
234        /// </summary>
235        /// <param name="id">file id</param>
236        /// <param name="xhr">xhr</param>
237        var fileItem = control.getFileItem(id);
238        fileItem._isUploading = false;
239        control.setFileStatus(fileItem, 'canceled', Sys.Extended.UI.Resources.AjaxFileUpload_Canceled);
240    };
241
242    
243};
244
245if(typeof(Sys)!=='undefined')Sys.Application.notifyScriptLoaded();