choerodon-ui/dataset/stores/LookupCodeStore.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"] = exports.LookupCodeStore = void 0;

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

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

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

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

var _tslib = require("tslib");

var _mobx = require("mobx");

var _isString = _interopRequireDefault(require("lodash/isString"));

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

var _axios = _interopRequireDefault(require("../axios"));

var _LovCodeStore = _interopRequireDefault(require("./LovCodeStore"));

var _enum = require("../data-set/enum");

var _utils = require("../data-set/utils");

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

var _cacheAdapterEnhancer = _interopRequireDefault(require("../axios/cacheAdapterEnhancer"));

var _throttleAdapterEnhancer = _interopRequireDefault(require("../axios/throttleAdapterEnhancer"));

var _promiseMerger = _interopRequireDefault(require("../promise-merger"));

var adapter = (0, _throttleAdapterEnhancer["default"])((0, _cacheAdapterEnhancer["default"])(_axios["default"].defaults.adapter));
var noCacheAdapter = (0, _throttleAdapterEnhancer["default"])(_axios["default"].defaults.adapter);

var LookupCodeStore = /*#__PURE__*/function () {
  function LookupCodeStore() {
    var _this = this;

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

    this.batchCallback = function (codes, args) {
      if (args) {
        var _args = (0, _slicedToArray2["default"])(args, 2),
            lookupBatchAxiosConfig = _args[0],
            field = _args[1];

        if (lookupBatchAxiosConfig) {
          return _this.getAxios(field)(lookupBatchAxiosConfig(codes));
        }
      }

      return Promise.resolve({});
    };

    this.merger = new _promiseMerger["default"](this.batchCallback, (0, _configure.getConfig)('lookupCache'));
  }

  (0, _createClass2["default"])(LookupCodeStore, [{
    key: "getAxios",
    value: function getAxios(field) {
      return (0, _utils2.getGlobalConfig)('axios', field) || _axios["default"];
    }
  }, {
    key: "fetchLookupData",
    value: function fetchLookupData(key) {
      var axiosConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var field = arguments.length > 2 ? arguments[2] : undefined;
      var config = {};

      if ((0, _isString["default"])(key)) {
        config = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, axiosConfig), {}, {
          url: key,
          method: axiosConfig.method || (0, _utils2.getGlobalConfig)('lookupAxiosMethod', field) || 'post'
        });
      } else {
        config = key;
      }

      if (config.url) {
        // SSR do not fetch the lookup
        if (typeof window !== 'undefined') {
          return this.getAxios(field)(config).then(function (result) {
            if (result) {
              return (0, _utils.generateResponseData)(result, (0, _utils2.getGlobalConfig)('dataKey', field));
            }
          });
        }
      }

      return Promise.resolve(undefined);
    }
  }, {
    key: "fetchLookupDataInBatch",
    value: function fetchLookupDataInBatch(code, lookupBatchAxiosConfig, field) {
      var getBatchKey = function getBatchKey(defaultKey) {
        var _lookupBatchAxiosConf = lookupBatchAxiosConfig([code]),
            url = _lookupBatchAxiosConf.url;

        return url ? url.split('?')[0] : defaultKey;
      };

      return this.merger.add(code, getBatchKey, [lookupBatchAxiosConfig, field]);
    }
  }, {
    key: "getAxiosConfig",
    value: function getAxiosConfig(field, record, noCache) {
      var lookupAxiosConfig = field.get('lookupAxiosConfig', record) || field.dataSet.getConfig('lookupAxiosConfig');
      var params = (0, _utils2.getLovPara)(field, record);
      var config = (0, _utils2.processAxiosConfig)(lookupAxiosConfig, {
        dataSet: field.dataSet,
        record: record,
        params: params,
        lookupCode: field.get('lookupCode', record)
      });
      return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, config), {}, {
        adapter: config.adapter || (noCache ? noCacheAdapter : adapter),
        url: config.url || this.getUrl(field, record),
        method: config.method || field.dataSet.getConfig('lookupAxiosMethod') || 'post',
        params: config.params || params
      });
    }
  }, {
    key: "getUrl",
    value: function getUrl(field, record) {
      var type = field.get('type', record);
      var lovCode = field.get('lovCode', record);
      var lookupUrl = field.get('lookupUrl', record);
      var lookupCode = field.get('lookupCode', record);

      if (typeof lookupUrl === 'function' && lookupCode) {
        return lookupUrl(lookupCode);
      }

      if ((0, _isString["default"])(lookupUrl)) {
        return lookupUrl;
      }

      if (lovCode && type !== _enum.FieldType.object) {
        return _LovCodeStore["default"].getQueryAxiosConfig(lovCode, field, undefined, record)({
          dataSet: field.dataSet
        }).url;
      }
    }
    /** @deprecated */

  }, {
    key: "clearCache",
    value: function clearCache() {// noop
    }
  }]);
  return LookupCodeStore;
}();

exports.LookupCodeStore = LookupCodeStore;
(0, _tslib.__decorate)([_mobx.action], LookupCodeStore.prototype, "clearCache", null);

var _default = new LookupCodeStore();

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