bruce-models 1.8.0 → 1.8.1

package/dist/bruce-models.umd.js

@@ -4596,6 +4596,68 @@
         EntityAttribute.GetAttribute = GetAttribute;
     })(exports.EntityAttribute || (exports.EntityAttribute = {}));
 
+    (function (Uploader) {
+        Uploader.MIN_LARGE_FILE_SIZE = 100000000; // 100MB.
+        function DoMultiPartUpload(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { file, api, urlSuffix: url, req, onProgress } = params;
+                const FILE_PORTION_SIZE = 100000000; // 100MB.
+                let fileSize = file.size;
+                let fileOffset = 0;
+                let filePartsCount = fileSize / FILE_PORTION_SIZE;
+                let t = Math.trunc(filePartsCount);
+                filePartsCount = filePartsCount > t ? t + 1 : t;
+                let filePartIndex = 1;
+                let uploadToken = exports.ObjectUtils.UId();
+                let data;
+                while (fileOffset < fileSize) {
+                    let partSize = Math.min(FILE_PORTION_SIZE, fileSize - fileOffset);
+                    let retryCount = 5;
+                    let retryWait = 1000;
+                    while (retryCount > 0) {
+                        try {
+                            const blob = file.slice(fileOffset, fileOffset + partSize);
+                            const formData = new FormData();
+                            formData.append("originalFileName", file.name);
+                            formData.append("token", uploadToken);
+                            formData.append("count", "" + filePartsCount);
+                            formData.append("part", "" + filePartIndex);
+                            formData.append("file", blob);
+                            const reqParams = exports.Api.PrepReqParams(req);
+                            reqParams.formData = formData;
+                            reqParams.onProgress = (progress) => {
+                                const sofar = fileOffset + progress.loaded;
+                                const percent = Math.round((sofar / file.size) * 100);
+                                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                                    percent: percent,
+                                    uploaded: false
+                                });
+                            };
+                            data = yield api.UPLOAD(url, blob, reqParams);
+                            retryCount = 0;
+                        }
+                        catch (up) {
+                            retryCount -= 1;
+                            if (retryCount <= 0) {
+                                throw up;
+                            }
+                            yield new Promise((res) => setTimeout(res, retryWait));
+                            retryWait = retryWait * 2;
+                        }
+                    }
+                    fileOffset += partSize;
+                    filePartIndex++;
+                }
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    percent: 100,
+                    uploaded: true
+                });
+                return data;
+            });
+        }
+        Uploader.DoMultiPartUpload = DoMultiPartUpload;
+    })(exports.Uploader || (exports.Uploader = {}));
+
     (function (ClientFile) {
         function GetCacheKey(fileId) {
             return `${exports.Api.ECacheKey.ClientFile}${exports.Api.ECacheKey.Id}${fileId}`;
@@ -4657,33 +4719,67 @@
         ClientFile.Delete = Delete;
         function Upload(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                const { api, file, purpose, req } = params;
+                const { api, file, purpose, req, onProgress } = params;
                 if (!file) {
                     throw ("File is required.");
                 }
-                let formData = null;
-                if (purpose) {
-                    formData = {
-                        "Purpose": purpose
-                    };
+                const size = file === null || file === void 0 ? void 0 : file.size;
+                if (!size) {
+                    throw ("You cannot upload a 0byte sized file.");
                 }
-                const reqParams = exports.Api.PrepReqParams(req);
-                reqParams.formData = formData;
-                const prom = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const data = yield api.UPLOAD("file/uploadNew", file, reqParams);
-                        res({
-                            clientFile: data
+                let clientFile;
+                if (size > exports.Uploader.MIN_LARGE_FILE_SIZE) {
+                    clientFile = yield exports.Uploader.DoMultiPartUpload({
+                        api,
+                        file,
+                        urlSuffix: "fileUpload",
+                        req,
+                        onProgress
+                    });
+                }
+                else {
+                    const reqParams = exports.Api.PrepReqParams(Object.assign({}, req));
+                    reqParams.onProgress = (progress) => {
+                        const percent = Math.round((progress.loaded / file.size) * 100);
+                        onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                            percent: percent,
+                            uploaded: false
                         });
-                    }
-                    catch (e) {
-                        rej(e);
-                    }
-                }));
-                return prom;
+                    };
+                    clientFile = yield api.UPLOAD("file/uploadNew", file, req);
+                }
+                if ((clientFile === null || clientFile === void 0 ? void 0 : clientFile.ID) && purpose) {
+                    yield UpdatePurpose({
+                        api,
+                        fileId: clientFile.ID,
+                        purpose,
+                        req
+                    });
+                }
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    percent: 100,
+                    uploaded: true
+                });
+                return {
+                    clientFile
+                };
             });
         }
         ClientFile.Upload = Upload;
+        function UpdatePurpose(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, fileId, purpose, req: reqParams } = params;
+                if (!purpose) {
+                    purpose = "";
+                }
+                yield api.POST("file/updatepurpose/" + fileId + "/?Purpose=" + purpose, {
+                    Purpose: purpose
+                }, exports.Api.PrepReqParams(reqParams));
+                const cacheKey = GetCacheKey(fileId);
+                api.Cache.RemoveByContains(cacheKey);
+            });
+        }
+        ClientFile.UpdatePurpose = UpdatePurpose;
         /**
          * Uploads a temp file.
          * This will return a temp file id which can be used in various endpoints.
@@ -4692,23 +4788,41 @@
          */
         function UploadTemp(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                const { api, file, req } = params;
+                const { api, file, req, onProgress } = params;
                 if (!file) {
                     throw ("File is required.");
                 }
-                const prom = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const reqParams = exports.Api.PrepReqParams(req);
-                        const data = yield api.UPLOAD("file/uploadTemp", file, reqParams);
-                        res({
-                            tempFileId: data["TempFile.ID"]
+                const size = file === null || file === void 0 ? void 0 : file.size;
+                if (!size) {
+                    throw ("You cannot upload a 0byte sized file.");
+                }
+                let tempFile;
+                if (size > exports.Uploader.MIN_LARGE_FILE_SIZE) {
+                    tempFile = yield exports.Uploader.DoMultiPartUpload({
+                        api,
+                        file,
+                        urlSuffix: "tempFileUpload",
+                        req,
+                        onProgress
+                    });
+                }
+                else {
+                    req.onProgress = (progress) => {
+                        const percent = Math.round((progress.loaded / file.size) * 100);
+                        onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                            percent: percent,
+                            uploaded: false
                         });
-                    }
-                    catch (e) {
-                        rej(e);
-                    }
-                }));
-                return prom;
+                    };
+                    tempFile = yield api.UPLOAD("file/uploadTemp", file, req);
+                }
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    percent: 100,
+                    uploaded: true
+                });
+                return {
+                    tempFileId: tempFile["TempFile.ID"]
+                };
             });
         }
         ClientFile.UploadTemp = UploadTemp;
@@ -5022,11 +5136,38 @@
         Tileset.Update = Update;
         function UploadFile(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                const { api, tilesetId, file, req: reqParams } = params;
+                const { api, file, req, tilesetId, onProgress } = params;
                 if (!tilesetId || !file) {
                     throw ("Tileset ID and file are required.");
                 }
-                return api.UPLOAD(`tileset/uploadFile/${tilesetId}/files`, file, exports.Api.PrepReqParams(reqParams));
+                const size = file === null || file === void 0 ? void 0 : file.size;
+                if (!size) {
+                    throw ("You cannot upload a 0byte sized file.");
+                }
+                if (size > exports.Uploader.MIN_LARGE_FILE_SIZE) {
+                    yield exports.Uploader.DoMultiPartUpload({
+                        api,
+                        file,
+                        urlSuffix: `tileset/uploadFileEx/${tilesetId}/add`,
+                        req,
+                        onProgress
+                    });
+                }
+                else {
+                    req.onProgress = (progress) => {
+                        const percent = Math.round((progress.loaded / file.size) * 100);
+                        onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                            percent: percent,
+                            uploaded: false
+                        });
+                    };
+                    yield api.UPLOAD(`tileset/uploadFile/${tilesetId}/files`, file, req);
+                }
+                api.Cache.Remove(GetCacheKey(tilesetId, true));
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    percent: 100,
+                    uploaded: true
+                });
             });
         }
         Tileset.UploadFile = UploadFile;
@@ -5043,12 +5184,39 @@
         Tileset.DeleteFile = DeleteFile;
         function UploadSrcFile(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                const { api, tilesetId, file, req: reqParams } = params;
+                const { api, file, req, tilesetId, onProgress } = params;
                 if (!tilesetId || !file) {
                     throw ("Tileset ID and file are required.");
                 }
-                yield api.UPLOAD(`tileset/uploadFile/${tilesetId}/src`, file, exports.Api.PrepReqParams(reqParams));
+                const size = file === null || file === void 0 ? void 0 : file.size;
+                if (!size) {
+                    throw ("You cannot upload a 0byte sized file.");
+                }
+                if (size > exports.Uploader.MIN_LARGE_FILE_SIZE) {
+                    yield exports.Uploader.DoMultiPartUpload({
+                        api,
+                        file,
+                        urlSuffix: `tileset/uploadFileEx/${tilesetId}/src`,
+                        req,
+                        onProgress
+                    });
+                }
+                else {
+                    req.onProgress = (progress) => {
+                        const percent = Math.round((progress.loaded / file.size) * 100);
+                        onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                            percent: percent,
+                            uploaded: false
+                        });
+                    };
+                    yield api.UPLOAD(`tileset/uploadFile/${tilesetId}/src`, file, req);
+                }
                 api.Cache.Remove(GetCacheKey(tilesetId, true));
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    percent: 100,
+                    uploaded: true
+                });
+                return;
             });
         }
         Tileset.UploadSrcFile = UploadSrcFile;