choerodon-ui/dataset/uploader/Uploader.js

An enterprise-class UI design language and React-based implementation

"use strict";

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

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

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

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

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

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

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

var _mobx = require("mobx");

var _utils = require("./utils");

var _configure = require("../configure");

var _UploadError = _interopRequireDefault(require("./UploadError"));

var Uploader = /*#__PURE__*/function () {
  function Uploader(props) {
    var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
      getConfig: _configure.getConfig
    };
    (0, _classCallCheck2["default"])(this, Uploader);
    this.props = props;
    this.context = context;
  }

  (0, _createClass2["default"])(Uploader, [{
    key: "setProps",
    value: function setProps(props) {
      (0, _extends2["default"])(this.props, props);
    }
  }, {
    key: "upload",
    value: function () {
      var _upload = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(attachment, attachments, tempAttachmentUUID) {
        var _attachment$attachmen, attachmentUUID, context, props, globalConfig, _props$chunkSize, chunkSize, useChunk, result, resp, response;

        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _attachment$attachmen = attachment.attachmentUUID, attachmentUUID = _attachment$attachmen === void 0 ? tempAttachmentUUID : _attachment$attachmen;

                if (!(attachment.status === 'success' || attachment.invalid || !attachmentUUID)) {
                  _context.next = 3;
                  break;
                }

                return _context.abrupt("return");

              case 3:
                context = this.context, props = this.props;
                globalConfig = context.getConfig('attachment');
                _props$chunkSize = props.chunkSize, chunkSize = _props$chunkSize === void 0 ? globalConfig.defaultChunkSize : _props$chunkSize;
                useChunk = props.useChunk && chunkSize > 0 && attachment.size > chunkSize;
                _context.next = 9;
                return (0, _utils.beforeUploadFile)(props, context, attachment, attachments, useChunk);

              case 9:
                result = _context.sent;

                if (!(result === true)) {
                  _context.next = 26;
                  break;
                }

                _context.prev = 11;
                _context.next = 14;
                return (0, _utils.uploadFile)(props, attachment, attachmentUUID, context, chunkSize, useChunk);

              case 14:
                resp = _context.sent;
                (0, _mobx.runInAction)(function () {
                  attachment.status = 'success';
                  var handleUploadSuccess = globalConfig.onUploadSuccess;

                  if (handleUploadSuccess) {
                    handleUploadSuccess(resp, attachment, {
                      useChunk: useChunk,
                      bucketName: props.bucketName,
                      bucketDirectory: props.bucketDirectory,
                      storageCode: props.storageCode,
                      isPublic: props.isPublic
                    });
                  }

                  var onUploadSuccess = props.onUploadSuccess;

                  if (onUploadSuccess) {
                    onUploadSuccess(resp, attachment, useChunk);
                  }
                });
                return _context.abrupt("return", resp);

              case 19:
                _context.prev = 19;
                _context.t0 = _context["catch"](11);

                if (!(_context.t0 instanceof _UploadError["default"])) {
                  _context.next = 25;
                  break;
                }

                response = _context.t0.response;
                (0, _mobx.runInAction)(function () {
                  var onUploadError = props.onUploadError;
                  var handleUploadError = globalConfig.onUploadError;
                  attachment.status = 'error';
                  attachment.error = _context.t0;
                  var message = _context.t0.message;

                  if (handleUploadError) {
                    handleUploadError(_context.t0, attachment);
                  }

                  attachment.errorMessage = message || attachment.errorMessage;

                  if (onUploadError) {
                    onUploadError(_context.t0, response, attachment);
                  }
                });
                return _context.abrupt("return", response);

              case 25:
                throw _context.t0;

              case 26:
                return _context.abrupt("return", result);

              case 27:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this, [[11, 19]]);
      }));

      function upload(_x, _x2, _x3) {
        return _upload.apply(this, arguments);
      }

      return upload;
    }()
  }]);
  return Uploader;
}();

exports["default"] = Uploader;
//# sourceMappingURL=Uploader.js.map