@availity/upload-core/lib/upload.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _tusJsClient = _interopRequireDefault(require("tus-js-client"));

var _resolveUrl = _interopRequireDefault(require("@availity/resolve-url"));

// https://stackoverflow.com/questions/6122571/simple-non-secure-hash-function-for-javascript/8831937#8831937
var hashCode = function hashCode(str) {
  var hash = 0;
  if (str.length === 0) return hash;

  for (var i = 0; i < str.length; i++) {
    var _char = str.charCodeAt(i);

    hash = (hash << 5) - hash + _char; // eslint-disable-line no-bitwise
    // eslint-disable-next-line operator-assignment

    hash = hash & hash; // eslint-disable-line no-bitwise
  }

  return hash;
};

var defaultOptions = {
  endpoint: '/ms/api/availity/internal/core/vault/upload/v1/resumable',
  chunkSize: 3e6,
  // 3MB
  removeFingerprintOnSuccess: true,
  pollingTime: 5000,
  retryDelays: [0, 1000, 3000, 5000],
  stripFileNamePathSegments: true,
  fingerprint: function fingerprint(file) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    var callback = arguments.length > 2 ? arguments[2] : undefined;
    var attributes = [file.name, file.type, file.size, file.lastModified];
    var attributesKey = 'tus-';

    for (var i = 0; i < attributes.length; i++) {
      if (attributes[i]) {
        attributesKey += "".concat(attributes[i], "-");
      }
    }

    var keys = Object.keys(options.metadata || {}).map(function (key) {
      return options.metadata[key];
    });
    var signature = [attributes.toString().replace(/,/g, ''), options.endpoint, keys].join('');
    var print = Math.abs(hashCode(signature));

    if (callback) {
      return callback(null, "".concat(attributesKey).concat(print));
    }

    return "".concat(attributesKey).concat(print);
  }
};

var Upload = /*#__PURE__*/function () {
  function Upload(file, options) {
    var _this = this;

    (0, _classCallCheck2["default"])(this, Upload);

    if (!file) {
      throw new Error('[options.file] must be defined and of type File(s)');
    }

    if (!options || !options.bucketId) {
      throw new Error('[options.bucketId] must be defined');
    }

    if (!options.customerId) {
      throw new Error('[options.customerId] must be defined');
    }

    if (!options.clientId) {
      throw new Error('[options.clientId] must be defined');
    }

    this.file = file;
    this.options = (0, _objectSpread2["default"])({}, defaultOptions, {}, options);
    this.options.endpoint = (0, _resolveUrl["default"])({
      relative: this.options.endpoint
    });
    this.percentage = 0;
    this.onError = [];
    this.onSuccess = [];
    this.onProgress = [];
    this.bytesTotal = 0;
    this.bytesSent = 0;
    this.bytesScanned = 0;
    this.errorMessage = null;
    this.status = 'pending';
    this.timeoutID = undefined;
    this.error = null;
    this.waitForPassword = true;
    var fileName = this.trimFileName(file.name);
    var metadata = {
      'availity-filename': fileName,
      'availity-content-type': file.type,
      'availity-attachment-name': 'N/A'
    };
    Object.assign(metadata, this.options.metadata);
    var upload = new _tusJsClient["default"].Upload(this.file, {
      resume: true,
      endpoint: "".concat(this.options.endpoint, "/").concat(this.options.bucketId, "/"),
      chunkSize: this.options.chunkSize,
      retryDelays: this.options.retryDelays,
      removeFingerprintOnSuccess: this.options.removeFingerprintOnSuccess,
      fingerprint: this.options.fingerprint,
      metadata: metadata,
      headers: {
        'X-XSRF-TOKEN': this.getToken(),
        'X-Availity-Customer-ID': this.options.customerId,
        'X-Client-ID': this.options.clientId
      },
      onError: function onError(err) {
        _this.setError('rejected', 'Network Error', err);

        _this.error = err;
      },
      onProgress: function onProgress(bytesSent, bytesTotal) {
        _this.bytesSent = bytesSent;
        _this.bytesTotal = bytesTotal;
        _this.percentage = _this.getPercentage();

        _this.onProgress.forEach(function (cb) {
          return cb();
        });
      },
      onSuccess: function onSuccess() {
        var xhr = _this.upload._xhr;
        _this.bytesScanned = parseInt(xhr.getResponseHeader('AV-Scan-Bytes'), 10) || 0;
        _this.percentage = _this.getPercentage();

        var result = _this.getResult(xhr);

        if (result.status === 'accepted') {
          _this.percentage = 100;
          _this.status = result.status;
          _this.errorMessage = null;
          var references = xhr.getResponseHeader('references');

          if (references) {
            _this.references = JSON.parse(references);
          }

          _this.onSuccess.forEach(function (cb) {
            return cb();
          });

          return;
        }

        if (result.status === 'rejected') {
          _this.setError(result.status, result.message);

          return;
        }

        _this.scan();
      }
    });
    this.upload = upload;
    this.id = this.generateId();
  }

  (0, _createClass2["default"])(Upload, [{
    key: "inStatusCategory",
    value: function inStatusCategory(status, category) {
      return status >= category && status < category + 100;
    }
  }, {
    key: "scan",
    value: function scan(data) {
      var _this2 = this;

      clearTimeout(this.timeoutID);
      var xhr = new window.XMLHttpRequest();
      xhr.open('HEAD', this.upload.url, true);
      xhr.setRequestHeader('Tus-Resumable', '1.0.0');
      xhr.setRequestHeader('X-Client-ID', this.options.clientId);
      xhr.setRequestHeader('X-Availity-Customer-ID', this.options.customerId);
      xhr.setRequestHeader('X-XSRF-TOKEN', this.getToken());

      if (data) {
        xhr.setRequestHeader(data.header, data.value);
      } // eslint-disable-next-line unicorn/prefer-add-event-listener


      xhr.onload = function () {
        if (!_this2.inStatusCategory(xhr.status, 200)) {
          _this2.setError('rejected', "Invalid status returned: ".concat(xhr.status), xhr);

          return;
        }

        _this2.bytesScanned = parseInt(xhr.getResponseHeader('AV-Scan-Bytes'), 10);
        _this2.percentage = _this2.getPercentage();

        var result = _this2.getResult(xhr);

        if (result.status === 'rejected') {
          _this2.setError(result.status, result.message);

          return;
        }

        if (result.status === 'encrypted') {
          if (_this2.waitForPassword) {
            _this2.setError(result.status, result.message);

            clearTimeout(_this2.timeoutId);
            return;
          }
        }

        if (result.status === 'accepted') {
          _this2.percentage = 100;
          _this2.status = result.status;
          _this2.errorMessage = null;
          var references = xhr.getResponseHeader('references');

          if (references) {
            _this2.references = JSON.parse(references);
          }

          _this2.onSuccess.forEach(function (cb) {
            return cb();
          });

          return;
        }

        if (result.status === 'decrypting') {
          _this2.setError(result.status, result.message);
        }

        _this2.onProgress.forEach(function (cb) {
          return cb();
        });

        _this2.timeoutId = setTimeout(function () {
          _this2.scan();
        }, _this2.options.pollingTime);
      }; // eslint-disable-next-line unicorn/prefer-add-event-listener


      xhr.onerror = function (err) {
        _this2.setError('rejected', 'Network Error', err);

        _this2.error = err;
      };

      xhr.send(null);
    }
  }, {
    key: "getPercentage",
    value: function getPercentage() {
      var processedBytes = this.bytesSent + this.bytesScanned;
      var combinedTotalBytes = this.bytesTotal * 2;
      return processedBytes / combinedTotalBytes * 100;
    }
  }, {
    key: "getToken",
    value: function getToken() {
      return document.cookie.replace(/(?:(?:^|.*;\s*)XSRF-TOKEN\s*=\s*([^;]*).*$)|^.*$/, '$1');
    }
  }, {
    key: "start",
    value: function start() {
      if (!this.isValidFile()) {
        return;
      }

      this.upload.start();
    }
  }, {
    key: "generateId",
    value: function generateId() {
      var fingerprint = this.options.fingerprint;
      return fingerprint(this.file, this.options).replace(/[^a-zA-Z0-9-]/g, '');
    }
  }, {
    key: "fingerprint",
    value: function fingerprint(file) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var callback = arguments.length > 2 ? arguments[2] : undefined;
      var attributes = [file.name, file.type, file.size, file.lastModified];
      var attributesKey = 'tus-';

      for (var i = 0; i < attributes.length; i++) {
        if (attributes[i]) {
          attributesKey += "".concat(attributes[i], "-");
        }
      }

      var keys = Object.keys(options.metadata || {}).map(function (key) {
        return options.metadata[key];
      });
      var signature = [attributes.toString().replace(/,/g, ''), options.endpoint, keys].join('');
      var print = Math.abs(hashCode(signature));

      if (callback) {
        return callback(null, "".concat(attributesKey).concat(print));
      }

      return "".concat(attributesKey).concat(print);
    }
  }, {
    key: "sendPassword",
    value: function sendPassword(pw) {
      this.waitForPassword = false;
      this.scan({
        header: 'Encryption-Password',
        value: pw
      });
    }
  }, {
    key: "isValidSize",
    value: function isValidSize() {
      if (this.options.maxSize) {
        if (this.file.size > this.options.maxSize) {
          this.setError('rejected', 'Document is too large');
          return false;
        }
      }

      return true;
    }
  }, {
    key: "isAllowedFileTypes",
    value: function isAllowedFileTypes() {
      if (this.options.fileTypes) {
        if (!this.file.name) {
          return false;
        }

        var fileName = this.file.name;
        var fileExt = fileName.substring(fileName.lastIndexOf('.')).toLowerCase();

        for (var i = 0; i < this.options.fileTypes.length; i++) {
          this.options.fileTypes[i] = this.options.fileTypes[i].toLowerCase();
        }

        if (this.options.fileTypes.indexOf(fileExt) < 0) {
          this.setError('rejected', "Document type ".concat(fileExt, " is not allowed"));
          return false;
        }
      }

      return true;
    }
  }, {
    key: "isAllowedFileNameCharacters",
    value: function isAllowedFileNameCharacters() {
      if (this.options.allowedFileNameCharacters) {
        var fileName = this.file.name.substring(0, this.file.name.lastIndexOf('.'));
        var regExp = new RegExp("([^".concat(this.options.allowedFileNameCharacters, "])"), 'g');

        if (fileName && fileName.match(regExp) !== null) {
          this.setError('rejected', 'File name contains characters not allowed');
          return false;
        }
      }

      return true;
    }
  }, {
    key: "isValidFile",
    value: function isValidFile() {
      return this.isAllowedFileNameCharacters() && this.isAllowedFileTypes() && this.isValidSize();
    }
  }, {
    key: "trimFileName",
    value: function trimFileName(fileName) {
      if (this.options.stripFileNamePathSegments) {
        fileName = fileName.substring(fileName.lastIndexOf('\\') + 1);
        fileName = fileName.substring(fileName.lastIndexOf('/') + 1);
      }

      return fileName;
    }
  }, {
    key: "getResult",
    value: function getResult(xhr) {
      var scanResult = xhr.getResponseHeader('AV-Scan-Result');
      var uploadResult = xhr.getResponseHeader('Upload-Result');
      var decryptResult = xhr.getResponseHeader('Decryption-Result');
      var msg = xhr.getResponseHeader('Upload-Message');

      if (scanResult === 'rejected') {
        return {
          status: scanResult,
          message: msg || 'Failed AV scan'
        };
      }

      if (uploadResult === 'rejected') {
        this.waitForPassword = true;

        if (decryptResult === 'rejected') {
          return {
            status: uploadResult,
            message: msg || 'Maximum password attempts reached'
          };
        }

        return {
          status: uploadResult,
          message: msg || 'File upload rejected'
        };
      }

      if (uploadResult === 'encrypted') {
        // needs pw, isDecrypting, isScanning
        if (!this.waitForPassword && (decryptResult === null || decryptResult === 'pending')) {
          return {
            status: 'decrypting',
            message: msg || 'Decrypting file'
          };
        }

        if (decryptResult === 'rejected') {
          this.waitForPassword = true;
          return {
            status: uploadResult,
            message: msg || 'Incorrect password'
          };
        }

        return {
          status: uploadResult,
          message: msg || 'Encrypted files require a password'
        };
      }

      if (scanResult === 'accepted' && uploadResult === 'accepted') {
        return {
          status: 'accepted',
          message: msg || ''
        };
      }

      return {
        status: 'pending',
        message: msg || ''
      };
    }
  }, {
    key: "setError",
    value: function setError(status, message, err) {
      var _this3 = this;

      this.status = status;

      try {
        this.parseErrorMessage(message, err);
      } catch (error) {
        /* the error callback should always be called */
      }

      this.onError.forEach(function (cb) {
        return cb(err || new Error(_this3.errorMessage));
      });
    }
  }, {
    key: "parseErrorMessage",
    value: function parseErrorMessage(message, err) {
      if (err) {
        var msg = err.originalRequest.getResponseHeader('Upload-Message');

        if (!msg) {
          var temp = err.message.match(/response\Wtext:\W(.*)\)/);

          if (temp && temp.length === 2) {
            var _temp = (0, _slicedToArray2["default"])(temp, 2);

            msg = _temp[1];
          }
        }

        if (!msg) {
          msg = message;
        }

        this.errorMessage = msg;
      } else {
        this.errorMessage = message;
      }
    }
  }, {
    key: "abort",
    value: function abort() {
      if (this.upload) {
        this.upload.abort();
      }
    }
  }]);
  return Upload;
}();

var _default = Upload;
exports["default"] = _default;