@trap_stevo/legendarybuilderproreact-ui
Version:
The legendary UI & utility API that makes your application a legendary application. ~ Created by Steven Compton
379 lines • 14.9 kB
JavaScript
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _regeneratorRuntime from "@babel/runtime/regenerator";
import { HUDUniversalHUDUtilityManager, Base64ToArrayBuffer } from "./HUDUniversalHUDUtilityManager.js";
function getMetadata(_x, _x2, _x3) {
return _getMetadata.apply(this, arguments);
}
function _getMetadata() {
_getMetadata = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(hudBucket, bucketName, fileRef) {
return _regeneratorRuntime.wrap(function _callee9$(_context9) {
while (1) switch (_context9.prev = _context9.next) {
case 0:
return _context9.abrupt("return", new Promise(function (resolve, reject) {
hudBucket.headObject({
Bucket: bucketName,
Key: fileRef
}, function (error, metadata) {
if (error) {
resolve(null);
return;
}
resolve(metadata);
return;
});
}));
case 1:
case "end":
return _context9.stop();
}
}, _callee9);
}));
return _getMetadata.apply(this, arguments);
}
;
function GetFileData(_x4, _x5, _x6) {
return _GetFileData.apply(this, arguments);
}
function _GetFileData() {
_GetFileData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10(hudBucket, bucketName, fileRef) {
var fileDownloadURL, itemData, fileName, underscoreIndex, fileNameI, fileNameP;
return _regeneratorRuntime.wrap(function _callee10$(_context10) {
while (1) switch (_context10.prev = _context10.next) {
case 0:
_context10.prev = 0;
_context10.next = 3;
return hudBucket.getSignedUrl('getObject', {
Bucket: bucketName,
Key: fileRef,
Expires: 3600
});
case 3:
fileDownloadURL = _context10.sent;
_context10.next = 6;
return getMetadata(hudBucket, bucketName, fileRef);
case 6:
itemData = _context10.sent;
if (!(itemData === null)) {
_context10.next = 10;
break;
}
console.log("Did not get file metadata...");
return _context10.abrupt("return", null);
case 10:
fileName = fileRef.name;
underscoreIndex = fileName.indexOf("_");
if (!(underscoreIndex !== -1)) {
_context10.next = 16;
break;
}
fileNameI = fileName.substring(0, underscoreIndex);
fileNameP = fileName.substring(underscoreIndex + 1);
return _context10.abrupt("return", {
contentType: itemData.contentType,
size: parseInt(itemData.size),
status: "Uploaded",
name: fileNameP,
id: fileName,
dateCreated: HUDUniversalHUDUtilityManager.ConvertUTCDateToDateDisplay(parseInt(fileNameI), true),
originPath: fileRef,
url: fileDownloadURL
});
case 16:
return _context10.abrupt("return", null);
case 19:
_context10.prev = 19;
_context10.t0 = _context10["catch"](0);
console.log("Error getting file data: ", _context10.t0);
return _context10.abrupt("return", null);
case 23:
case "end":
return _context10.stop();
}
}, _callee10, null, [[0, 19]]);
}));
return _GetFileData.apply(this, arguments);
}
;
var HUDUniversalFileBucketManager = {
UploadFiles: function () {
var _UploadFiles = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(hudBucket, files, bucketName, directoryPath, onProgress) {
return _regeneratorRuntime.wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
return _context.abrupt("return", Promise.all(files.map(function (file, index) {
return HUDUniversalFileBucketManager.UploadFile(hudBucket, file, bucketName, directoryPath + file.id, function (loaded, total) {
if (onProgress) {
onProgress(index, loaded, total);
}
});
})));
case 1:
case "end":
return _context.stop();
}
}, _callee);
}));
function UploadFiles(_x7, _x8, _x9, _x10, _x11) {
return _UploadFiles.apply(this, arguments);
}
return UploadFiles;
}(),
UploadFile: function () {
var _UploadFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(hudBucket, file, bucketName, filePath, onProgress) {
var fileBlob, options, currentUpload;
return _regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) switch (_context2.prev = _context2.next) {
case 0:
_context2.prev = 0;
fileBlob = new Blob([Base64ToArrayBuffer(file.data)], {
type: file.type
});
options = {
Bucket: bucketName,
Key: filePath,
Body: fileBlob
};
currentUpload = hudBucket.upload(options);
currentUpload.on('httpUploadProgress', function (progress) {
if (onProgress) {
onProgress(progress.loaded, progress.total);
}
});
return _context2.abrupt("return", new Promise(function (resolve, reject) {
currentUpload.send(function (error, data) {
if (error) {
console.log("Did not upload file: ", error);
resolve({});
return;
}
console.log("Upload successful!");
hudBucket.getSignedUrl('getObject', {
Bucket: bucketName,
Key: file.id,
Expires: 3600
}, function (error, fileDownloadURL) {
if (error) {
console.log("Did not get file url after upload: ", error);
resolve({});
return;
}
file.contentType = file.type;
file.status = "Uploaded";
file.url = fileDownloadURL;
resolve(file);
});
});
}));
case 8:
_context2.prev = 8;
_context2.t0 = _context2["catch"](0);
console.log("Did not prepare file for upload: ", _context2.t0);
return _context2.abrupt("return", {});
case 12:
case "end":
return _context2.stop();
}
}, _callee2, null, [[0, 8]]);
}));
function UploadFile(_x12, _x13, _x14, _x15, _x16) {
return _UploadFile.apply(this, arguments);
}
return UploadFile;
}(),
GetFiles: function () {
var _GetFiles = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(hudBucket, bucketName, directoryPath) {
return _regeneratorRuntime.wrap(function _callee5$(_context5) {
while (1) switch (_context5.prev = _context5.next) {
case 0:
return _context5.abrupt("return", new Promise(function (resolve, reject) {
hudBucket.listObjectsV2({
Bucket: bucketName
}, /*#__PURE__*/function () {
var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(error, data) {
var files;
return _regeneratorRuntime.wrap(function _callee4$(_context4) {
while (1) switch (_context4.prev = _context4.next) {
case 0:
if (!error) {
_context4.next = 4;
break;
}
console.log("Did not list files: ", error);
resolve([]);
return _context4.abrupt("return");
case 4:
_context4.prev = 4;
_context4.next = 7;
return Promise.all(data.Contents.map( /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(file) {
var currentFile;
return _regeneratorRuntime.wrap(function _callee3$(_context3) {
while (1) switch (_context3.prev = _context3.next) {
case 0:
_context3.next = 2;
return HUDUniversalFileBucketManager.GetFile(hudBucket, bucketName, file.Key);
case 2:
currentFile = _context3.sent;
return _context3.abrupt("return", currentFile);
case 4:
case "end":
return _context3.stop();
}
}, _callee3);
}));
return function (_x22) {
return _ref2.apply(this, arguments);
};
}()));
case 7:
files = _context4.sent;
resolve(files);
return _context4.abrupt("return");
case 12:
_context4.prev = 12;
_context4.t0 = _context4["catch"](4);
console.log("Did not get files: ", _context4.t0);
resolve([]);
return _context4.abrupt("return");
case 17:
case "end":
return _context4.stop();
}
}, _callee4, null, [[4, 12]]);
}));
return function (_x20, _x21) {
return _ref.apply(this, arguments);
};
}());
}));
case 1:
case "end":
return _context5.stop();
}
}, _callee5);
}));
function GetFiles(_x17, _x18, _x19) {
return _GetFiles.apply(this, arguments);
}
return GetFiles;
}(),
GetFile: function () {
var _GetFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(hudBucket, bucketName, filePath) {
var currentFile;
return _regeneratorRuntime.wrap(function _callee6$(_context6) {
while (1) switch (_context6.prev = _context6.next) {
case 0:
_context6.prev = 0;
_context6.next = 3;
return GetFileData(hudBucket, bucketName, filePath);
case 3:
currentFile = _context6.sent;
return _context6.abrupt("return", currentFile);
case 7:
_context6.prev = 7;
_context6.t0 = _context6["catch"](0);
console.log("Did not get file " + filePath, _context6.t0);
return _context6.abrupt("return", null);
case 11:
case "end":
return _context6.stop();
}
}, _callee6, null, [[0, 7]]);
}));
function GetFile(_x23, _x24, _x25) {
return _GetFile.apply(this, arguments);
}
return GetFile;
}(),
DeleteFiles: function () {
var _DeleteFiles = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(hudBucket, bucketName, filePaths) {
var fileRefs;
return _regeneratorRuntime.wrap(function _callee7$(_context7) {
while (1) switch (_context7.prev = _context7.next) {
case 0:
_context7.prev = 0;
fileRefs = filePaths.map(function (filePath) {
return {
Key: filePath
};
});
return _context7.abrupt("return", new Promise(function (resolve, reject) {
var options = {
Bucket: bucketName,
Delete: {
Objects: fileRefs,
Quiet: false
}
};
hudBucket.deleteObjects(options, function (error, data) {
if (error) {
console.log("Did not delete file: ", error);
resolve(false);
return;
}
if (data.Errors && data.Errors.length > 0) {
console.log("Did not delete some files: ", data.Errors);
resolve(false);
return;
}
console.log("Deleted files successfully!");
resolve(true);
return;
});
}));
case 5:
_context7.prev = 5;
_context7.t0 = _context7["catch"](0);
console.log("Did not delete files: ", _context7.t0);
return _context7.abrupt("return", false);
case 9:
case "end":
return _context7.stop();
}
}, _callee7, null, [[0, 5]]);
}));
function DeleteFiles(_x26, _x27, _x28) {
return _DeleteFiles.apply(this, arguments);
}
return DeleteFiles;
}(),
DeleteFile: function () {
var _DeleteFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(hudBucket, bucketName, filePath) {
return _regeneratorRuntime.wrap(function _callee8$(_context8) {
while (1) switch (_context8.prev = _context8.next) {
case 0:
_context8.prev = 0;
return _context8.abrupt("return", new Promise(function (resolve, reject) {
var options = {
Bucket: bucketName,
Key: filePath
};
hudBucket.deleteObject(options, function (error, data) {
if (error) {
console.log("Did not delete file: ", error);
resolve(false);
return;
}
console.log("Deleted file successfully!");
resolve(true);
return;
});
}));
case 4:
_context8.prev = 4;
_context8.t0 = _context8["catch"](0);
console.log("Did not delete file " + filePath + ": ", _context8.t0);
return _context8.abrupt("return", false);
case 8:
case "end":
return _context8.stop();
}
}, _callee8, null, [[0, 4]]);
}));
function DeleteFile(_x29, _x30, _x31) {
return _DeleteFile.apply(this, arguments);
}
return DeleteFile;
}()
};
export { HUDUniversalFileBucketManager };