@foreverrbum/ethsign/dist/helpers/download.js

This package will allow you to electronically sign documents within your application

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isFileWithPassword = exports.getFileArray = exports.getCommentArrs = exports.downloadFile = exports.downloadBlob = exports.default = exports.createAndDownloadBlobFile = void 0;

var _cryptoJs = _interopRequireDefault(require("crypto-js"));

var _fleekStorageJs = _interopRequireDefault(require("@fleekhq/fleek-storage-js"));

var _dashboard = require("./dashboard");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var isFileWithPassword = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(fileHash) {
    var myFile, decryptedDataArray;
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (fileHash) {
              _context.next = 2;
              break;
            }

            return _context.abrupt("return", false);

          case 2:
            _context.next = 4;
            return _fleekStorageJs.default.getFileFromHash({
              hash: fileHash
            });

          case 4:
            myFile = _context.sent;
            _context.prev = 5;
            decryptedDataArray = decryptDataArrayFromStringAES(myFile, "");
            _context.next = 12;
            break;

          case 9:
            _context.prev = 9;
            _context.t0 = _context["catch"](5);
            return _context.abrupt("return", true);

          case 12:
            return _context.abrupt("return", false);

          case 13:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[5, 9]]);
  }));

  return function isFileWithPassword(_x) {
    return _ref.apply(this, arguments);
  };
}();

exports.isFileWithPassword = isFileWithPassword;

var getFileArrayFL = /*#__PURE__*/function () {
  var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(password, fileHash, returnPromise, formatMessage) {
    var myFile, decryptedDataArray;
    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _context2.next = 2;
            return _fleekStorageJs.default.getFileFromHash({
              hash: fileHash
            });

          case 2:
            myFile = _context2.sent;
            _context2.prev = 3;
            decryptedDataArray = decryptDataArrayFromStringAES(myFile, password);
            _context2.next = 11;
            break;

          case 7:
            _context2.prev = 7;
            _context2.t0 = _context2["catch"](3);
            (0, _dashboard.storeNotif)(formatMessage({
              id: 'INVALID_PASSWORD'
            }), formatMessage({
              id: 'PASSWORD_ENTERED_UNABLE_TO_DECRYPT'
            }), 'danger');
            return _context2.abrupt("return", false);

          case 11:
            if (!returnPromise) {
              _context2.next = 15;
              break;
            }

            return _context2.abrupt("return", Promise.resolve(decryptedDataArray));

          case 15:
            return _context2.abrupt("return", decryptedDataArray);

          case 16:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2, null, [[3, 7]]);
  }));

  return function getFileArrayFL(_x2, _x3, _x4, _x5) {
    return _ref2.apply(this, arguments);
  };
}();

var getFileArray = /*#__PURE__*/function () {
  var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(password, fileHash, storageProvider, returnPromise, formatMessage) {
    var decryptedDataArray;
    return regeneratorRuntime.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            if (fileHash) {
              _context3.next = 2;
              break;
            }

            return _context3.abrupt("return", false);

          case 2:
            if (!(storageProvider = 'FL')) {
              _context3.next = 9;
              break;
            }

            _context3.next = 5;
            return getFileArrayFL(password, fileHash, returnPromise, formatMessage);

          case 5:
            decryptedDataArray = _context3.sent;
            return _context3.abrupt("return", decryptedDataArray);

          case 9:
            if (!(storageProvider == 'IP')) {
              _context3.next = 12;
              break;
            }

            _context3.next = 14;
            break;

          case 12:
            (0, _dashboard.storeNotif)(formatMessage({
              id: 'ERROR'
            }), formatMessage({
              id: 'NO_DOCUMENT_FOUND'
            }), 'danger');
            return _context3.abrupt("return", false);

          case 14:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3);
  }));

  return function getFileArray(_x6, _x7, _x8, _x9, _x10) {
    return _ref3.apply(this, arguments);
  };
}();

exports.getFileArray = getFileArray;

var getCommentArrs = /*#__PURE__*/function () {
  var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(commentData, password, formatMessage) {
    return regeneratorRuntime.wrap(function _callee4$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            return _context4.abrupt("return", Promise.all(commentData.map(function (comment) {
              return getFileArray(password, comment.commentHash, comment.provider, true, formatMessage);
            })));

          case 1:
          case "end":
            return _context4.stop();
        }
      }
    }, _callee4);
  }));

  return function getCommentArrs(_x11, _x12, _x13) {
    return _ref4.apply(this, arguments);
  };
}();

exports.getCommentArrs = getCommentArrs;

var downloadFile = /*#__PURE__*/function () {
  var _ref5 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(password, fileHash, name, close, storageProvider, formatMessage) {
    var decryptedDataArray;
    return regeneratorRuntime.wrap(function _callee5$(_context5) {
      while (1) {
        switch (_context5.prev = _context5.next) {
          case 0:
            _context5.next = 2;
            return getFileArray(password, fileHash, storageProvider, false, formatMessage);

          case 2:
            decryptedDataArray = _context5.sent;

            if (!(decryptedDataArray != false)) {
              _context5.next = 9;
              break;
            }

            createAndDownloadBlobFile(decryptedDataArray, name);
            (0, _dashboard.storeNotif)(formatMessage({
              id: 'DOWNLOAD'
            }), formatMessage({
              id: 'DOWNLOAD_STARTING'
            }), 'info');
            close();
            _context5.next = 10;
            break;

          case 9:
            return _context5.abrupt("return", false);

          case 10:
          case "end":
            return _context5.stop();
        }
      }
    }, _callee5);
  }));

  return function downloadFile(_x14, _x15, _x16, _x17, _x18, _x19) {
    return _ref5.apply(this, arguments);
  };
}();

exports.downloadFile = downloadFile;

function decryptDataArrayFromStringAES(encryptedString, password) {
  if (password == undefined) password = "";

  var bytes = _cryptoJs.default.AES.decrypt(encryptedString, password);

  var decrypted = JSON.parse(bytes.toString(_cryptoJs.default.enc.Utf8));
  var decryptedDataArray = new Uint8Array(decrypted.data);
  return decryptedDataArray;
}

var createAndDownloadBlobFile = function createAndDownloadBlobFile(body, fileName) {
  var blob = new Blob([body]);
  downloadBlob(blob, fileName);
};

exports.createAndDownloadBlobFile = createAndDownloadBlobFile;

var downloadBlob = function downloadBlob(blob, fileName) {
  if (navigator.msSaveBlob) {
    // IE 10+
    navigator.msSaveBlob(blob, fileName);
  } else {
    var link = document.createElement('a'); // Browsers that support HTML5 download attribute

    if (link.download !== undefined) {
      var url = URL.createObjectURL(blob);
      link.setAttribute('href', url); // link.setAttribute('download', fileName);

      link.setAttribute('target', '_blank');
      link.style.visibility = 'hidden';
      document.body.appendChild(link);
      link.click();
      document.body.removeChild(link);
    }
  }
};

exports.downloadBlob = downloadBlob;
var _default = {
  downloadFile: downloadFile,
  getFileArray: getFileArray,
  isFileWithPassword: isFileWithPassword,
  downloadBlob: downloadBlob
};
exports.default = _default;