choerodon-ui/pro/es/stores/LookupCodeStore.js

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

import _objectSpread from "@babel/runtime/helpers/objectSpread2";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import { __decorate } from "tslib";
import { action } from 'mobx';
import isString from 'lodash/isString';
import { getConfig } from '../../../es/configure';
import axios from '../axios';
import lovCodeStore from './LovCodeStore';
import { FieldType } from '../data-set/enum';
import { generateResponseData } from '../data-set/utils';
import { getLovPara, processAxiosConfig } from './utils';
import cacheAdapterEnhancer from '../axios/cacheAdapterEnhancer';
import throttleAdapterEnhancer from '../axios/throttleAdapterEnhancer';
import PromiseMerger from '../_util/PromiseMerger';
var adapter = throttleAdapterEnhancer(cacheAdapterEnhancer(axios.defaults.adapter));
var noCacheAdapter = throttleAdapterEnhancer(axios.defaults.adapter);
export var LookupCodeStore =
/*#__PURE__*/
function () {
  function LookupCodeStore() {
    var _this = this;

    _classCallCheck(this, LookupCodeStore);

    this.batchCallback = function (codes, args) {
      if (args) {
        var _args = _slicedToArray(args, 1),
            lookupBatchAxiosConfig = _args[0];

        if (lookupBatchAxiosConfig) {
          return _this.axios(lookupBatchAxiosConfig(codes));
        }
      }

      return Promise.resolve({});
    };

    this.merger = new PromiseMerger(this.batchCallback, getConfig('lookupCache'));
  }

  _createClass(LookupCodeStore, [{
    key: "fetchLookupData",
    value: function fetchLookupData(key) {
      var axiosConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var config = {};

      if (isString(key)) {
        config = _objectSpread({}, axiosConfig, {
          url: key,
          method: axiosConfig.method || getConfig('lookupAxiosMethod') || 'post'
        });
      } else {
        config = key;
      }

      if (config.url) {
        // SSR do not fetch the lookup
        if (typeof window !== 'undefined') {
          return this.axios(config).then(function (result) {
            if (result) {
              return generateResponseData(result, getConfig('dataKey'));
            }
          });
        }
      }

      return Promise.resolve(undefined);
    }
  }, {
    key: "fetchLookupDataInBatch",
    value: function fetchLookupDataInBatch(code, lookupBatchAxiosConfig) {
      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]);
    }
  }, {
    key: "getAxiosConfig",
    value: function getAxiosConfig(field, noCache) {
      var lookupAxiosConfig = field.get('lookupAxiosConfig') || getConfig('lookupAxiosConfig');
      var record = field.record;
      var params = getLovPara(field, record);
      var config = processAxiosConfig(lookupAxiosConfig, {
        dataSet: field.dataSet,
        record: record,
        params: params,
        lookupCode: field.get('lookupCode')
      });
      return _objectSpread({}, config, {
        adapter: config.adapter || (noCache ? noCacheAdapter : adapter),
        url: config.url || this.getUrl(field),
        method: config.method || getConfig('lookupAxiosMethod') || 'post',
        params: config.params || params
      });
    }
  }, {
    key: "getUrl",
    value: function getUrl(field) {
      var type = field.get('type');
      var lovCode = field.get('lovCode');
      var lookupUrl = field.get('lookupUrl');
      var lookupCode = field.get('lookupCode');

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

      if (isString(lookupUrl)) {
        return lookupUrl;
      }

      if (lovCode && type !== FieldType.object) {
        return lovCodeStore.getQueryAxiosConfig(lovCode, field)({
          dataSet: field.dataSet
        }).url;
      }
    } // @deprecate

  }, {
    key: "clearCache",
    value: function clearCache() {}
  }, {
    key: "axios",
    get: function get() {
      return getConfig('axios') || axios;
    }
  }]);

  return LookupCodeStore;
}();

__decorate([action], LookupCodeStore.prototype, "clearCache", null);

export default new LookupCodeStore();
//# sourceMappingURL=LookupCodeStore.js.map