@beinformed/ui 1.59.22 → 1.60.0

package/lib/modularui/ModularUIRequest.js

@@ -0,0 +1,716 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/json/stringify"));
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/promise"));
+var _find = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/find"));
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/defineProperty"));
+var _deepmerge = _interopRequireDefault(require("deepmerge"));
+var _Constants = require("../constants/Constants");
+var _LayoutHints = require("../constants/LayoutHints");
+var _Settings = require("../constants/Settings");
+var _Href = _interopRequireDefault(require("../models/href/Href"));
+var _universalFetch = _interopRequireDefault(require("../utils/fetch/universalFetch"));
+var _resolveModel = _interopRequireDefault(require("../models/resolveModel"));
+var _FormModel = _interopRequireDefault(require("../models/form/FormModel"));
+var _ContentModel = _interopRequireDefault(require("../models/content/ContentModel"));
+var _ErrorResponse = _interopRequireDefault(require("../models/error/ErrorResponse"));
+var _ModularUIResponse = _interopRequireDefault(require("./ModularUIResponse"));
+var _ModularUIError = _interopRequireDefault(require("./ModularUIError"));
+var _exceptions = require("../exceptions");
+var _objects = require("../utils/helpers/objects");
+/**
+ * Helper for fetching data and contributions from the Be Informed modular ui
+ * and merge it into a target or resolvable model.
+ */
+class ModularUIRequest {
+  /**
+   */
+  constructor(href) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    (0, _defineProperty2.default)(this, "_response", void 0);
+    (0, _defineProperty2.default)(this, "_href", void 0);
+    (0, _defineProperty2.default)(this, "_options", void 0);
+    (0, _defineProperty2.default)(this, "_targetModel", void 0);
+    (0, _defineProperty2.default)(this, "_forceTargetModel", false);
+    (0, _defineProperty2.default)(this, "_contributionsHref", void 0);
+    (0, _defineProperty2.default)(this, "_locale", void 0);
+    (0, _defineProperty2.default)(this, "_method", _Constants.HTTP_METHODS.GET);
+    (0, _defineProperty2.default)(this, "_progressEvent", void 0);
+    (0, _defineProperty2.default)(this, "_origin", "");
+    (0, _defineProperty2.default)(this, "_contextPath", (0, _Settings.getBasePathModularUI)());
+    if (!href) {
+      throw new _exceptions.IllegalArgumentException("You must pass a href to the resource that is requested");
+    }
+    this.options = options;
+    this._response = new _ModularUIResponse.default();
+    this.href = typeof href === "string" ? new _Href.default(href) : href;
+    this.locale = this.getRequestLocale(options.locale);
+
+    // copy request parameters to response, to be able to use them in the models
+    // self links are missing the request parameters
+    this._response.parameters = this.href.parameters;
+    if (options.contextPath) {
+      this.contextPath = options.contextPath;
+    } else if (this.href.contextPath) {
+      this.contextPath = this.href.contextPath;
+    }
+    if (options.origin) {
+      this.origin = options.origin;
+    } else if (this.href.origin) {
+      this.origin = this.href.origin;
+    }
+    if (options.targetModel) {
+      this.targetModel = options.targetModel;
+    }
+    if (options.method) {
+      this.method = options.method;
+    } else {
+      this.method = this.href.method;
+    }
+  }
+
+  /**
+   * Retrieve the preferred language for this request, falls back to the browser language or english
+   */
+  getRequestLocale(optionLocale) {
+    if (optionLocale) {
+      return optionLocale;
+    }
+    if (typeof navigator !== "undefined" && navigator?.language) {
+      return navigator.language.split("-")[0] || "en";
+    }
+    return "en";
+  }
+
+  /**
+   */
+  get origin() {
+    return this._origin;
+  }
+
+  /**
+   */
+  set origin(origin) {
+    this._origin = origin ?? "";
+    this._response.origin = origin ?? "";
+  }
+
+  /**
+   */
+  get contextPath() {
+    return this._contextPath;
+  }
+
+  /**
+   */
+  set contextPath(contextPath) {
+    this._contextPath = contextPath ?? (0, _Settings.getBasePathModularUI)();
+    this._response.contextPath = contextPath ?? (0, _Settings.getBasePathModularUI)();
+  }
+
+  /**
+   */
+  get contributionsHref() {
+    return this._contributionsHref;
+  }
+
+  /**
+   */
+  set contributionsHref(contributionsHref) {
+    this._contributionsHref = contributionsHref;
+  }
+
+  /**
+   */
+  set locale(locale) {
+    this._locale = locale;
+    this._response.locale = locale;
+  }
+
+  /**
+   */
+  get locale() {
+    return this._locale;
+  }
+
+  /**
+   */
+  get response() {
+    return this._response;
+  }
+
+  /**
+   */
+  set href(href) {
+    this._href = href;
+  }
+
+  /**
+   */
+  get href() {
+    return this._href;
+  }
+
+  /**
+   */
+  set method(method) {
+    this._method = method;
+  }
+
+  /**
+   */
+  get method() {
+    return this._method;
+  }
+
+  /**
+   */
+  get options() {
+    return {
+      ...this._options,
+      locale: this.locale,
+      method: this.method
+    };
+  }
+
+  /**
+   */
+  get requestOptions() {
+    /* eslint-disable no-unused-vars */
+    const {
+      targetModel,
+      forceTargetModel,
+      updateHandler,
+      childmodels,
+      isValidationRequest,
+      removeOnUnmount,
+      ...requestOptions
+    } = this.options;
+    /* eslint-enable no-unused-vars */
+    return requestOptions;
+  }
+
+  /**
+   */
+  set options(options) {
+    this._options = options;
+  }
+
+  /**
+   */
+  get withChildModels() {
+    return !("childmodels" in this.options) || this.options.childmodels === true;
+  }
+
+  /**
+   */
+  set targetModel(targetModel) {
+    this._targetModel = targetModel;
+  }
+
+  /**
+   */
+  get targetModel() {
+    return this._targetModel;
+  }
+
+  /**
+   */
+  set forceTargetModel(forceTargetModel) {
+    this._forceTargetModel = forceTargetModel ?? false;
+  }
+
+  /**
+   */
+  get forceTargetModel() {
+    return this._forceTargetModel;
+  }
+
+  /**
+   */
+  resolveModel() {
+    let availableModels;
+    if (this.targetModel) {
+      availableModels = Array.isArray(this.targetModel) ? [...this.targetModel] : [this.targetModel];
+      if (this.forceTargetModel) {
+        return availableModels[0];
+      }
+    }
+    const Model = (0, _resolveModel.default)(this.response, availableModels);
+    if (Model && Model.isApplicableModel) {
+      return Model;
+    }
+    if (availableModels) {
+      throw new _exceptions.IllegalStateException(`data for ${this.href.toString()} is not applicable for model(s): ${(0, _map.default)(availableModels).call(availableModels, m => m.modelName).join(", ")}, received response: ${(0, _stringify.default)(this.response)}`);
+    }
+    throw new _exceptions.IllegalStateException(`no javascript model is applicable for received request of ${this.href.toString()}, with response: ${(0, _stringify.default)(this.response)}`);
+  }
+
+  /**
+   */
+  createModel() {
+    const Model = this.resolveModel();
+    return new Model(this.response);
+  }
+
+  /**
+   */
+  processContributionsService(contributionsData) {
+    if (!(0, _objects.isPlainObject)(contributionsData)) {
+      throw new _exceptions.IllegalArgumentException("Missing contributions data or contributions is not JSON");
+    }
+    const [contributionsKey] = (0, _keys.default)(contributionsData);
+    if (contributionsData.error && contributionsKey === "error") {
+      this.handleContributionsError(contributionsData.error);
+    }
+
+    // The key of the data service is different from the contributions service for forms
+    if (!(this.response.key in contributionsData)) {
+      this.response.key = contributionsKey;
+    }
+    this.response.contributions = contributionsData[this.response.key];
+  }
+
+  /**
+   */
+  handleContributionsError(error) {
+    const errorMessage = error.properties?.message ?? "Error in contribution";
+    throw new _ModularUIError.default(errorMessage, error, this.contributionsHref);
+  }
+
+  /**
+   */
+  handleDataError(error) {
+    if (error.properties) {
+      const errorMessage = error.properties?.message ?? "Error in data";
+      throw new _ModularUIError.default(errorMessage, error, this.href.absolutepath.toString());
+    }
+    throw new _exceptions.IllegalArgumentException(error);
+  }
+
+  /**
+   */
+  handleData(key, data) {
+    this.response.key = key;
+    this.response.data = data;
+    const links = data._links;
+    if (links && links.contributions) {
+      this.contributionsHref = links.contributions.href;
+    } else if (Array.isArray(links) && links[0].contributions) {
+      this.contributionsHref = links[0].contributions.href;
+    } else {
+      throw new _exceptions.IllegalArgumentException(`Contributions link not found for data with key ${key}`);
+    }
+  }
+
+  /**
+   */
+  processDataService(data) {
+    if (!(0, _objects.isPlainObject)(data)) {
+      throw new _exceptions.IllegalArgumentException("Missing data or data is not JSON");
+    }
+    if (data.error) {
+      this.handleDataError(data.error);
+    } else {
+      const [key] = (0, _keys.default)(data);
+      this.handleData(key, data[key]);
+    }
+  }
+
+  /**
+   */
+  fetchContributionsService() {
+    if (!this.contributionsHref) {
+      throw new _exceptions.IllegalStateException("Missing a contributions href");
+    }
+    return (0, _universalFetch.default)({
+      url: `${this.origin}${this.contextPath}${this.contributionsHref}`,
+      cache: true,
+      locale: this.options.locale
+    });
+  }
+
+  /**
+   */
+  fetchDataService() {
+    return (0, _universalFetch.default)({
+      ...this.requestOptions,
+      url: `${this.origin}${this.contextPath}${this.href.path}`,
+      params: this.href.getQuerystringForModularUI(),
+      locale: this.options.locale,
+      onProgress: this.onProgress
+    });
+  }
+
+  /**
+   * Check if links contain a 'hide-when-empty' layout hint and remove the link from
+   * the component when it exists and no results are available
+   */
+  async processAsyncLayoutHints() {
+    if ((0, _Settings.getSetting)("ALLOW_HIDE_WHEN_EMPTY_ON_TABS")) {
+      await this.processApplicationLinks();
+      await this.processTabLinks();
+    }
+    await this.processPanelLinks();
+    return _promise.default.resolve();
+  }
+
+  /**
+   * hide application links<br>
+   * _links on application data contains an extra level of tab links
+   */
+  processApplicationLinks() {
+    const contributionLinks = this.response.contributions._links;
+    const dataLinks = this.response.data._links;
+    if (!contributionLinks || !dataLinks) {
+      return _promise.default.resolve();
+    }
+    if ("tab" in contributionLinks && "tab" in dataLinks) {
+      for (const contributionTabLink of contributionLinks.tab) {
+        if ("components" in contributionTabLink) {
+          var _context;
+          const dataTabLinks = (0, _find.default)(_context = dataLinks.tab).call(_context, dataLink => dataLink.name === contributionTabLink.name);
+          if (dataTabLinks && "components" in dataTabLinks) {
+            return this.processLinks(dataTabLinks.components, contributionTabLink.components).then(newLinks => this.replaceApplicationLinks(contributionTabLink.name, newLinks));
+          }
+        }
+      }
+    }
+    return _promise.default.resolve();
+  }
+
+  /**
+   * Replace hidden link in application link tree
+   */
+  replaceApplicationLinks(tabName, newLinks) {
+    var _context2;
+    this.response.data._links.tab = (0, _map.default)(_context2 = this.response.data._links.tab).call(_context2, tabLink => {
+      const key = tabLink.name;
+      if (tabName === key) {
+        tabLink.components = newLinks;
+      }
+      return tabLink;
+    });
+  }
+
+  /**
+   */
+  processTabLinks() {
+    const contributionLinks = this.response.contributions._links;
+    if (!contributionLinks) {
+      return _promise.default.resolve();
+    }
+    if ("component" in contributionLinks) {
+      return this.processLinks(this.response.data._links.component, contributionLinks.component).then(newLinks => {
+        this.response.data._links.component = newLinks;
+      });
+    }
+    return _promise.default.resolve();
+  }
+
+  /**
+   */
+  processPanelLinks() {
+    const contributionLinks = this.response.contributions._links;
+    if (!contributionLinks) {
+      return _promise.default.resolve();
+    }
+    if ("panel" in contributionLinks) {
+      return this.processLinks(this.response.data._links, contributionLinks.panel).then(newLinks => {
+        this.response.data._links = newLinks;
+      });
+    }
+    return _promise.default.resolve();
+  }
+
+  /**
+   * Retrieve an object of key: link
+   */
+  dataLinksPerName(dataLinks) {
+    if (Array.isArray(dataLinks)) {
+      const links = {};
+      for (const dataLink of dataLinks) {
+        links[dataLink.name] = dataLink;
+      }
+      return links;
+    }
+    return dataLinks;
+  }
+
+  /**
+   * Check if links are empty and hide them when hide-when-empty hint exists
+   */
+  processLinks(dataLinks, contributionLinks) {
+    const linksPerName = this.dataLinksPerName(dataLinks);
+    const hideWhenEmptyLinks = (0, _filter.default)(contributionLinks).call(contributionLinks, contributionLink => contributionLink.layouthint?.includes(_LayoutHints.HIDE_WHEN_EMPTY));
+    const isHiddenListChecks = [];
+    for (const contributionLink of hideWhenEmptyLinks) {
+      const dataLink = linksPerName[contributionLink.name];
+      if (dataLink?.href) {
+        isHiddenListChecks.push(this.isHiddenList(contributionLink.name, dataLink.href));
+      }
+    }
+    return _promise.default.all(isHiddenListChecks).then(hiddenLinks => {
+      if (Array.isArray(dataLinks)) {
+        return (0, _filter.default)(dataLinks).call(dataLinks, dataLink => !(0, _includes.default)(hiddenLinks).call(hiddenLinks, dataLink.name));
+      }
+      const newDataLinks = {};
+      for (const dataLinkKey in dataLinks) {
+        if (!(0, _includes.default)(hiddenLinks).call(hiddenLinks, dataLinkKey)) {
+          newDataLinks[dataLinkKey] = dataLinks[dataLinkKey];
+        }
+      }
+      return newDataLinks;
+    });
+  }
+
+  /**
+   */
+  isHiddenList(name, href) {
+    const HIDE_WHEN_EMPTY_IGNORE_TASKS = (0, _Settings.getSetting)("HIDE_WHEN_EMPTY_IGNORE_TASKS", false);
+    return (0, _universalFetch.default)({
+      ...this.requestOptions,
+      url: `${this.origin}${this.contextPath}${href}`
+    }).then(response => {
+      if ((0, _objects.isPlainObject)(response)) {
+        const [key] = (0, _keys.default)(response);
+        const {
+          _embedded,
+          actions
+        } = response[key];
+        const noListItems = _embedded === null;
+        const noActions = actions == null || HIDE_WHEN_EMPTY_IGNORE_TASKS;
+        const isHidden = noListItems && noActions;
+        if (isHidden) {
+          return name;
+        }
+      }
+      return "";
+    }).catch(() => {
+      return "";
+    });
+  }
+
+  /**
+   */
+  set onProgress(progressEvent) {
+    this._progressEvent = progressEvent;
+  }
+
+  /**
+   */
+  get onProgress() {
+    return this._progressEvent || null;
+  }
+
+  /**
+   * Combine previous send request data with new validation data to create a complete request object
+   * The received model is new FormModel containing ONLY the current question, not the previously entered questions
+   * to create a complete request we append the originally send form objects
+   */
+  getDynamicValidationData(model) {
+    const prevData = typeof this.options.data === "string" ? JSON.parse(this.options.data) : this.options.data;
+    if (model instanceof _FormModel.default) {
+      const newData = JSON.parse(model.validationData);
+      // $FlowFixMe incompatible-call
+      return (0, _stringify.default)((0, _deepmerge.default)(prevData || {}, newData));
+    }
+    return (0, _stringify.default)(prevData) ?? "{}";
+  }
+
+  /**
+   * First load of dynamic values when a form is loaded
+   */
+  loadDynamicValidations(model) {
+    if (!this.options.isValidationRequest && (0, _Settings.getSetting)("USE_INSTANT_SERVER_VALIDATION") && model instanceof _FormModel.default && model.currentFormObject && model.currentFormObject.hasDynamicValidations) {
+      const validationHref = this.href.setParameter("commit", "false");
+      return (0, _universalFetch.default)({
+        ...this.requestOptions,
+        url: `${this.origin}${this.contextPath}${this.href.path}`,
+        params: validationHref.getQuerystringForModularUI(),
+        data: this.getDynamicValidationData(model)
+      }).then(data => {
+        if (data == null || typeof data !== "object") {
+          return model;
+        }
+        const [key] = (0, _keys.default)(data);
+        return model.updateValidations(data[key]);
+      });
+    }
+    return _promise.default.resolve(model);
+  }
+
+  /**
+   */
+  fetch() {
+    return this.fetchDataService().then(data => {
+      if (data == null) {
+        throw new Error(`No data received for ${this.href.toString()}`);
+      }
+      this.processDataService(data);
+      return this.fetchContributionsService();
+    }).then(contributionsData => {
+      if (contributionsData == null) {
+        throw new Error(`No contributions data received for ${this.contributionsHref}`);
+      }
+      this.processContributionsService(contributionsData);
+      return this.processAsyncLayoutHints();
+    }).then(() => _promise.default.resolve(this.createModel())).then(model => this.loadDynamicValidations(model)).then(model => {
+      if (this.withChildModels) {
+        return this.fetchChildModels(model);
+      }
+      return _promise.default.resolve(model);
+    });
+  }
+
+  /**
+   */
+  fetchFromCache() {
+    this.options = {
+      ...this.options,
+      cache: true
+    };
+    return this.fetch();
+  }
+
+  /**
+   */
+  fetchChildModels(model) {
+    const childModelLinks = model.getInitialChildModelLinks();
+    const childModelRequests = (0, _map.default)(childModelLinks).call(childModelLinks, childModelLink => {
+      const request = new ModularUIRequest(childModelLink.href, {
+        locale: this.locale
+      });
+      if (childModelLink.targetModel) {
+        request.targetModel = childModelLink.targetModel;
+      }
+      if (childModelLink.isCacheable) {
+        return request.fetchFromCache();
+      }
+      return request.fetch();
+    });
+    return _promise.default.allSettled(childModelRequests).then(childModels => {
+      const resolvedChildModels = [];
+      const errorChildModels = [];
+      childModels.forEach(childModel => {
+        if (childModel.status === "rejected") {
+          const {
+            reason
+          } = childModel;
+          if (reason.name !== "Error.ChangePasswordRequired") {
+            // eslint-disable-next-line no-console
+            console.debug("Unexpected error when retrieving child model:", reason);
+          }
+          errorChildModels.push(new _ErrorResponse.default(reason, "", {
+            origin: this.origin,
+            contextPath: this.contextPath
+          }));
+        } else {
+          resolvedChildModels.push(childModel.value);
+        }
+      });
+      model.addChildModels(resolvedChildModels, errorChildModels);
+      return model;
+    });
+  }
+
+  /**
+   */
+  fetchContent(withChildSections) {
+    return this.fetchFromCache().then(model => {
+      if (withChildSections && model instanceof _ContentModel.default && model.childSectionLinks.length > 0) {
+        return this.fetchContentChildSections(model);
+      }
+      return _promise.default.resolve(model);
+    });
+  }
+
+  /**
+   * Recursively return child sections defined on the content model
+   */
+  fetchContentChildSections(contentModel) {
+    var _context3;
+    const newContentModel = contentModel.clone();
+    return _promise.default.all((0, _map.default)(_context3 = contentModel.childSectionLinks).call(_context3, childSectionLink => {
+      const contentHrefWithEntryDate = childSectionLink.selfhref.addParameter(_Constants.TIMEVERSION_FILTER_NAME, contentModel.entryDate);
+      const request = new ModularUIRequest(contentHrefWithEntryDate, {
+        locale: this.locale
+      });
+      return request.fetchContent(true);
+    })).then(sectionModels => {
+      newContentModel.childSections = sectionModels;
+      return newContentModel;
+    });
+  }
+
+  /**
+   * Make a post request with optionally data to send
+   * @param data
+   */
+  post(data) {
+    this.method = _Constants.HTTP_METHODS.POST;
+    this.options = {
+      ...this.options,
+      data
+    };
+    return this.fetch();
+  }
+
+  /**
+   * Make a POST request using the form, an updated form is returned (merge of old and new form)
+   * @param form
+   * @returns {Promise<FormModel>}
+   */
+  postForm(form) {
+    this.method = _Constants.HTTP_METHODS.POST;
+    this.options = {
+      ...this.options,
+      data: form.formdata
+    };
+    return this.fetch().then(response => {
+      return form.update(response);
+    });
+  }
+
+  /**
+   * Simplified synchronous version of fetch (returns the model, not a Promise)
+   * This can be used on the server to retrieve a model. It only loads the request url and it's child models
+   */
+  fetchSync() {
+    const options = {
+      headers: {
+        "Accept-Language": this.locale
+      }
+    };
+    const dataString = dataFetcher.fetch(this.href.toString(), options);
+    if (dataString == null) {
+      throw new Error(`No data received for ${this.href.toString()}`);
+    }
+    this.processDataService(JSON.parse(dataString));
+    const contributionsString = dataFetcher.fetch(this.contributionsHref.toString(), options);
+    if (contributionsString == null) {
+      throw new Error(`No constributions received for ${this.contributionsHref.toString()}`);
+    }
+    this.processContributionsService(JSON.parse(contributionsString));
+    const model = this.createModel();
+    const childModelLinks = model.getInitialChildModelLinks();
+    const childModels = (0, _map.default)(childModelLinks).call(childModelLinks, childModelLink => {
+      return new ModularUIRequest(childModelLink.href, {
+        locale: this.locale
+      }).fetchSync();
+    });
+    model.addChildModels(childModels, []);
+    return model;
+  }
+}
+var _default = exports.default = ModularUIRequest;
+//# sourceMappingURL=ModularUIRequest.js.map