@beinformed/ui 1.59.22 → 1.60.0

package/lib/models/attributes/AttributeModel.js

@@ -0,0 +1,824 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+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 _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));
+var _endsWith = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/ends-with"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/defineProperty"));
+var _objects = require("../../utils/helpers/objects");
+var _BaseModel = _interopRequireDefault(require("../base/BaseModel"));
+var _ConstraintCollection = _interopRequireDefault(require("./input-constraints/ConstraintCollection"));
+var _ErrorCollection = _interopRequireDefault(require("../error/ErrorCollection"));
+var _LinkCollection = _interopRequireDefault(require("../links/LinkCollection"));
+var _StringLengthConstraint = _interopRequireDefault(require("./input-constraints/StringLengthConstraint"));
+var _MandatoryConstraint = _interopRequireDefault(require("./input-constraints/MandatoryConstraint"));
+var _ConceptDetailModel = _interopRequireDefault(require("../concepts/ConceptDetailModel"));
+var _LayoutHints = require("../../constants/LayoutHints");
+var _Constants = require("../../constants/Constants");
+var _Settings = require("../../constants/Settings");
+var _exceptions = require("../../exceptions");
+var _AttributeContent = _interopRequireDefault(require("./AttributeContent"));
+/**
+ * Attribute model, base model for all kind of attributes
+ */
+class AttributeModel extends _BaseModel.default {
+  /**
+   */
+  constructor(attribute, attributeContributions, modelOptions) {
+    super(attribute, attributeContributions, modelOptions);
+    (0, _defineProperty2.default)(this, "_label", void 0);
+    (0, _defineProperty2.default)(this, "_lastModification", 0);
+    (0, _defineProperty2.default)(this, "_initvalue", void 0);
+    (0, _defineProperty2.default)(this, "_inputvalue", void 0);
+    (0, _defineProperty2.default)(this, "_value", void 0);
+    (0, _defineProperty2.default)(this, "_errorCollection", void 0);
+    (0, _defineProperty2.default)(this, "_serverConstraints", new _ConstraintCollection.default());
+    (0, _defineProperty2.default)(this, "_useClientsideValidation", (0, _Settings.getSetting)("USE_CLIENTSIDE_VALIDATION"));
+    (0, _defineProperty2.default)(this, "_isValid", true);
+    (0, _defineProperty2.default)(this, "_validatedValue", void 0);
+    (0, _defineProperty2.default)(this, "_isEditable", false);
+    (0, _defineProperty2.default)(this, "_concept", null);
+    (0, _defineProperty2.default)(this, "_referenceDate", void 0);
+    (0, _defineProperty2.default)(this, "_isResult", void 0);
+    (0, _defineProperty2.default)(this, "_isHidden", false);
+    (0, _defineProperty2.default)(this, "_readonly", void 0);
+    (0, _defineProperty2.default)(this, "_disabled", false);
+    (0, _defineProperty2.default)(this, "_mandatory", void 0);
+    (0, _defineProperty2.default)(this, "_links", void 0);
+    (0, _defineProperty2.default)(this, "_parentKey", void 0);
+    (0, _defineProperty2.default)(this, "_hasContentConfiguration", void 0);
+    (0, _defineProperty2.default)(this, "_layoutHintRules", void 0);
+    if (this.hasContentFromData && this.content.label) {
+      this._label = this.content.label;
+    } else {
+      this._label = this.contributions.label;
+    }
+    this._initvalue = this.data.value;
+    this._inputvalue = this.getInitialInputValue(this.data.value);
+    this._value = this.data.value;
+    this._disabled = this.layouthint.has(_LayoutHints.DISABLED);
+    this._errorCollection = new _ErrorCollection.default("attribute");
+    if (attribute && attribute.message) {
+      this._errorCollection.addServerError(attribute.message.id, attribute.message.message, attribute.message.parameters, attribute.message.layouthint);
+    }
+    this._referenceDate = this.getData("referenceDate", new Date().toISOString().split("T")[0]);
+    this._isResult = this.getData("isResult", false);
+    this._mandatory = this.layouthint.has(_LayoutHints.MANDATORY) || this.contributions.mandatory;
+    this._links = new _LinkCollection.default(this.data._links, this.contributions._links, modelOptions);
+  }
+
+  /**
+   */
+  static isApplicableModel(contributions) {
+    if (!(0, _objects.isPlainObject)(contributions)) {
+      throw new _exceptions.IllegalArgumentException("Given argument for isApplicableModel is not a contributions object");
+    }
+    return false;
+  }
+
+  /**
+   * Retrieve initial input value
+   */
+  getInitialInputValue(value) {
+    return value;
+  }
+
+  /**
+   */
+  getInitialChildModelLinks() {
+    if (!this.hasContentFromData && this.hasContentConfiguration && this.conceptLink) {
+      return [this.conceptLink];
+    }
+    return [];
+  }
+
+  /**
+   */
+  setChildModels(models, errors // eslint-disable-line no-unused-vars
+  ) {
+    const conceptHref = this.conceptLink?.href;
+    if (conceptHref) {
+      this.concept = (0, _find.default)(models).call(models, model => model.selfhref.equalsWithParameters(conceptHref));
+    }
+  }
+
+  /**
+   * Getting the attribute key
+   */
+  get key() {
+    return this.data.key;
+  }
+
+  /**
+   */
+  get parentKey() {
+    return this._parentKey || "";
+  }
+
+  /**
+   */
+  set parentKey(parentKey) {
+    this._parentKey = parentKey;
+  }
+
+  /**
+   * Getting the attribute name
+   */
+  get name() {
+    return this.key;
+  }
+
+  /**
+   * Getting the type of the attribute
+   */
+  get type() {
+    return this.contributions.type;
+  }
+
+  /**
+   * Getting the label of the attribute
+   */
+  get label() {
+    return this._label || "";
+  }
+
+  /**
+   * Set the label of this attribute
+   */
+  set label(label) {
+    this._label = label;
+  }
+
+  /**
+   */
+  set hasContentConfiguration(hasContentConfiguration) {
+    this._hasContentConfiguration = hasContentConfiguration;
+  }
+
+  /**
+   */
+  get hasContentConfiguration() {
+    return this._hasContentConfiguration || false;
+  }
+
+  /**
+   */
+  indicateContentConfiguration(contentConfiguration) {
+    if (contentConfiguration) {
+      const hasQuestionConfig = contentConfiguration.questions?.hasConfig();
+      const hasEndResultConfig = contentConfiguration.isConfiguredEndResultAttribute(this.key);
+      const hasIntermediateResultConfig = contentConfiguration.isConfiguredIntermediateResultAttribute(this.key);
+      this.hasContentConfiguration = hasQuestionConfig || hasEndResultConfig || hasIntermediateResultConfig;
+    }
+  }
+
+  /**
+   * Retrieve the first permitted label to render when a concept and contentConfiguration is available
+   * Be aware that permission could be in place for labels from a concept.
+   */
+  getContentConfiguredLabel(contentConfiguration) {
+    if (this.hasContentFromData) {
+      return this.content.label ?? this.label;
+    }
+    const configuredLabelProperties = contentConfiguration && contentConfiguration.labelConfig.length > 0 ? contentConfiguration.labelConfig[0].types : [];
+    if (this.concept && configuredLabelProperties.length > 0) {
+      var _context;
+      const configuredLabels = (0, _filter.default)(_context = this.concept.getLabelElementByIds(configuredLabelProperties)).call(_context, configuredLabel => configuredLabel.value && configuredLabel.value !== "");
+      if (configuredLabels.length > 0) {
+        var _context2;
+        const [firstConfiguredLabel] = (0, _map.default)(_context2 = (0, _filter.default)(configuredLabelProperties).call(configuredLabelProperties, configuredLabelProperty => configuredLabels.some(configuredLabel => configuredLabel._id === configuredLabelProperty))).call(_context2, configuredLabelProperty => (0, _find.default)(configuredLabels).call(configuredLabels, configuredLabel => configuredLabel._id === configuredLabelProperty));
+        if (firstConfiguredLabel) {
+          return firstConfiguredLabel.value;
+        }
+      }
+    }
+    return this.label;
+  }
+
+  /**
+   */
+  get defaultAlignment() {
+    return "left";
+  }
+
+  /**
+   * Handles layout hint align-left, align-center and align-right
+   */
+  get alignment() {
+    const alignmentHints = this.layouthint.getByLayoutHint("align-");
+
+    // return alignment based on layouthint or the default alignment for the attribute
+    const alignment = alignmentHints ? alignmentHints.substring("align-".length) : this.defaultAlignment;
+    if (alignment === "left" || alignment === "center" || alignment === "right") {
+      return alignment;
+    }
+    return this.defaultAlignment;
+  }
+
+  /**
+   * Retrieve links of attribute
+   */
+  get links() {
+    if (!this._links) {
+      this._links = new _LinkCollection.default(this.data._links, this.contributions._links);
+    }
+    return this._links;
+  }
+
+  /**
+   * Retrieve link of attribute when available
+   */
+  get downloadLink() {
+    const downloadLink = this.links.getLinksByGroup("download").first;
+    if (downloadLink && downloadLink.key === this.key) {
+      return downloadLink;
+    }
+    return null;
+  }
+
+  /**
+   * Retrieve concept link of attribute when available
+   */
+  get conceptLink() {
+    const conceptLink = this.links.getLinkByKey("concept");
+    if (conceptLink !== null) {
+      conceptLink.href = conceptLink.href.addParameter(_Constants.TIMEVERSION_FILTER_NAME, this.referenceDate);
+      conceptLink.isCacheable = true;
+    }
+    return conceptLink;
+  }
+
+  /**
+   * Get concept information
+   */
+  get concept() {
+    return this._concept ?? null;
+  }
+
+  /**
+   * Set the concept
+   */
+  set concept(concept) {
+    this._concept = concept instanceof _ConceptDetailModel.default ? concept : null;
+  }
+
+  /**
+   * Retrieve reference date of attribute which can be used as entryDate for content
+   * to get information in correct time version
+   */
+  get referenceDate() {
+    return this._referenceDate;
+  }
+
+  /**
+   * Set reference date for concepts and content
+   */
+  set referenceDate(date) {
+    this._referenceDate = date;
+  }
+
+  /**
+   * Initial value received from the modular ui service
+   */
+  get initvalue() {
+    return this._initvalue;
+  }
+
+  /**
+   * Retrieve input value
+   */
+  getInputValue() {
+    const inputvalue = this._inputvalue;
+    return inputvalue ? inputvalue.toString() : "";
+  }
+
+  /**
+   * Returns the value as entered by the user. This can differ from the internal iso value that is stored
+   */
+  get inputvalue() {
+    return this.getInputValue();
+  }
+
+  /**
+   * Value that is used when retrieving an error collection of this attribute
+   * Mostly this is the input value, but sometimes a different value is needed,
+   * for example iban and postcode need to validate length without spaces
+   */
+  get validateValue() {
+    return this.inputvalue;
+  }
+
+  /**
+   * Sets the input value to the value entered by the user
+   */
+  set inputvalue(value) {
+    this._inputvalue = value;
+    this.value = value;
+    this.validate(value);
+  }
+
+  /**
+   */
+  hasValue() {
+    return this._value != null && this._value !== "";
+  }
+
+  /**
+   * Getting the value of the attribute
+   */
+  getValue() {
+    return this.hasValue() ? this._value : null;
+  }
+
+  /**
+   * Getting data ready to be send to the modular ui
+   * Returns null when the attribute should not be send to the server
+   */
+  getFormData() {
+    if (this.inError()) {
+      return null;
+    }
+    return {
+      [this.name]: this.value
+    };
+  }
+
+  /**
+   */
+  get formdata() {
+    return this.getFormData();
+  }
+
+  /**
+   */
+  getEmptyFormData() {
+    return {
+      [this.name]: null
+    };
+  }
+
+  /**
+   * Getting the value of the attribute
+   */
+  get value() {
+    return this.getValue();
+  }
+
+  /**
+   * Setting a value in the element
+   */
+  set value(value) {
+    this.updateLastModification();
+    this._value = value;
+  }
+
+  /**
+   */
+  formatValue(value) {
+    return value;
+  }
+
+  /**
+   * Getting the readonly value, iso value converted for human reading
+   */
+  get readonlyvalue() {
+    return this.value ? this.value.toString() : "";
+  }
+
+  /**
+   * Getting mandatory status of attribute
+   */
+  get mandatory() {
+    return this._mandatory || false;
+  }
+
+  /**
+   */
+  get configuredMandatory() {
+    return this.layouthint.has(_LayoutHints.MANDATORY) || this.contributions.mandatory;
+  }
+
+  /**
+   * Set mandatory status of attribute
+   */
+  set mandatory(mandatory) {
+    if (mandatory !== this._mandatory) {
+      this._validatedValue = null;
+    }
+    this._mandatory = mandatory;
+  }
+
+  /**
+   */
+  get readonly() {
+    return this._readonly || this.contributions.readonly === true || this.data.static === true || this.isResult === true;
+  }
+
+  /**
+   */
+  set readonly(readonly) {
+    this._readonly = readonly;
+  }
+
+  /**
+   */
+  get disabled() {
+    return this._disabled;
+  }
+
+  /**
+   */
+  set disabled(disabled) {
+    this._disabled = disabled;
+  }
+
+  /**
+   */
+  get isResult() {
+    return this._isResult;
+  }
+
+  /**
+   */
+  set isResult(isResult) {
+    this._isResult = isResult;
+  }
+
+  /**
+   * Getting the display and input format of a attribute
+   */
+  get format() {
+    return this.getContribution("format");
+  }
+
+  /**
+   */
+  get formatLabel() {
+    return this.format || "";
+  }
+
+  /**
+   * Get minimum string length
+   */
+  get minLength() {
+    return this.getContribution("minLength");
+  }
+
+  /**
+   * Get maximum string length
+   */
+  get maxLength() {
+    return this.getContribution("maxLength");
+  }
+
+  /**
+   */
+  get operator() {
+    return this.getContribution("operator", "");
+  }
+
+  /**
+   * Get assistant message
+   */
+  get assistantMessage() {
+    return this.getContribution("assistant");
+  }
+
+  /**
+   * Get valid status
+   */
+  get isValid() {
+    return this.validate(this.validateValue);
+  }
+
+  /**
+   * Retrieve applicable constraint for this attribute
+   */
+  get constraintCollection() {
+    const constraints = new _ConstraintCollection.default();
+    constraints.add(this._serverConstraints);
+
+    // Mandatory constraint
+    if (this.mandatory) {
+      constraints.add(new _MandatoryConstraint.default());
+    }
+    if (this.minLength || this.maxLength) {
+      constraints.add(new _StringLengthConstraint.default(this.minLength, this.maxLength));
+    }
+    constraints.add(this.addConstraints());
+    return constraints;
+  }
+
+  /**
+   * Template method for class extending this model to add extra constraints
+   * @abstract
+   */
+  addConstraints() {
+    return new _ConstraintCollection.default();
+  }
+
+  /**
+   * Used to programmatically overwrite the setting USE_CLIENTSIDE_VALIDATION
+   */
+  setUseClientsideValidation(enabled) {
+    this._useClientsideValidation = enabled;
+  }
+
+  /**
+   * Indicates if client side validation is enabled
+   * @returns {boolean}
+   */
+  useClientsideValidation() {
+    return this._useClientsideValidation ?? true;
+  }
+
+  /**
+   * Validate input on client side constraint
+   */
+  validate(value) {
+    // when client side validation is disabled, this attribute is always valid
+    if (!this.useClientsideValidation()) {
+      return true;
+    }
+    if (this.isOptionalAndEmpty(value)) {
+      this._isValid = true;
+    } else if (this._validatedValue !== value) {
+      this._isValid = this.constraintCollection.validate(value);
+    }
+    this._validatedValue = value;
+    return this._isValid;
+  }
+
+  /**
+   * Indicates if attribute is optional and empty
+   */
+  isOptionalAndEmpty(value) {
+    if (value === undefined) {
+      throw new _exceptions.IllegalArgumentException("isOptionalAndEmpty method needs value argument");
+    }
+    return !this.mandatory && value === "";
+  }
+
+  /**
+   * Retrieve error messages of this attribute
+   */
+  get errorCollection() {
+    const collection = new _ErrorCollection.default("attribute", this._errorCollection);
+    collection.addConstraints(this.constraintCollection.invalidConstraints(this.validateValue));
+    return collection;
+  }
+
+  /**
+   * Check if attribute is in error
+   */
+  inError() {
+    return !this._isValid && this.isChangedSince(0);
+  }
+
+  /**
+   * Reset static error messages on attribute
+   */
+  resetErrors() {
+    this._errorCollection = new _ErrorCollection.default("attribute");
+  }
+
+  /**
+   * Registers an error that was received from a server response
+   */
+  addServerError(error) {
+    this._errorCollection.addServerError(error.id, error.message, error.properties, error.layouthint);
+  }
+
+  /**
+   */
+  removeServerError(id) {
+    this._errorCollection.removeServerError(id);
+  }
+
+  /**
+   */
+  hasServerErrors() {
+    return this.errorCollection.serverErrors.length > 0;
+  }
+
+  /**
+   */
+  hasErrors() {
+    return this.errorCollection.hasItems;
+  }
+
+  /**
+   * Registers a missing error that was received from the server
+   */
+  // eslint-disable-next-line no-unused-vars
+  addMissingError(receivedAttribute) {
+    this._errorCollection.addServerError("Constraint.Missing");
+  }
+
+  /**
+   */
+  removeMissingError() {
+    this.removeServerError("Constraint.Missing");
+  }
+
+  /**
+   */
+  addServerConstraint(id, defaultMessage, parameters) {
+    this._serverConstraints.addConstraint(id, null, defaultMessage, parameters, this.useClientsideValidation());
+  }
+
+  /**
+   */
+  formatParameters(parameters) {
+    if (parameters == null) {
+      return {};
+    }
+    const params = {};
+    (0, _keys.default)(parameters).forEach(paramKey => {
+      const paramValue = parameters[paramKey];
+      if ((0, _endsWith.default)(paramKey).call(paramKey, "-number") || (0, _endsWith.default)(paramKey).call(paramKey, "-date")) {
+        params[paramKey] = this.formatValue(paramValue);
+      } else {
+        params[paramKey] = paramValue;
+      }
+    });
+    return params;
+  }
+
+  /**
+   */
+  get hasDynamicValidationData() {
+    return true;
+  }
+
+  /**
+   */
+  updateValidations(errors) {
+    if (errors.some(error => error.id === "Constraint.Mandatory") || this.layouthint.has(_LayoutHints.MANDATORY)) {
+      this.mandatory = true;
+    } else if (!this.hasValue()) {
+      this.mandatory = false;
+    }
+    this._serverConstraints = new _ConstraintCollection.default();
+    this.resetErrors();
+    (0, _filter.default)(errors).call(errors, error => error.id !== "Constraint.Mandatory" || !this.hasValue()).forEach(error => {
+      if (this.hasValue()) {
+        this._errorCollection.addServerError(error.id, error.message, this.formatParameters(error.properties), error.layouthint);
+      } else {
+        this.addServerConstraint(error.id, error.message, this.formatParameters(error.properties));
+      }
+    });
+  }
+
+  /**
+   * Set last modification to current timestamp
+   */
+  updateLastModification() {
+    this._lastModification = Date.now();
+  }
+
+  /**
+   * Inidicates if attribute is changed since a given timestamp (Date.now)
+   */
+  isChangedSince(timestamp) {
+    return this._lastModification > timestamp;
+  }
+
+  /**
+   * Abstract reset method which should be implemented on each attribute that has this attribute as a base class.
+   *
+   * @abstract
+   */
+  reset() {
+    throw new _exceptions.UnsupportedOperationException(`Reset method not implemented for ${this.type}`);
+  }
+
+  /**
+   * Merge old attribute with the attribute from the server.
+   * Readonly attributes always need to show the value from the server
+   */
+  mergeAttribute(oldAttribute) {
+    this.concept = oldAttribute.concept;
+    if (!oldAttribute.readonly && oldAttribute.isValid && oldAttribute.inputvalue !== null) {
+      this.update(oldAttribute.inputvalue);
+    }
+  }
+
+  /**
+   * Abstract update method which should be implemented on each attribute that has this attribute as a base class.
+   * @abstract
+   */
+  // eslint-disable-next-line no-unused-vars
+  update(value, changedAttribute) {
+    throw new _exceptions.UnsupportedOperationException(`Update method not implemented for ${this.type}`);
+  }
+
+  /**
+   * Abstract updateByAttribute method which should be implemented on each attribute that has this attribute as a base class.
+   * @abstract
+   */
+  // eslint-disable-next-line no-unused-vars
+  updateByAttribute(otherAttribute) {
+    console.error("update of " + this.type + " with " + otherAttribute.type + " not supported");
+  }
+
+  /**
+   * Indicate if attribute is editable
+   */
+  set isEditable(isEditable) {
+    this._isEditable = isEditable;
+  }
+
+  /**
+   * Retrieve if attribute is editable
+   */
+  get isEditable() {
+    return this._isEditable;
+  }
+
+  /**
+   * Indicates if the attribute is visible
+   */
+  get isVisible() {
+    return !this._isHidden;
+  }
+
+  /**
+   */
+  get isHidden() {
+    return this._isHidden;
+  }
+
+  /**
+   */
+  set isHidden(isHidden) {
+    this._isHidden = isHidden;
+  }
+
+  /**
+   * Explicitly toggle visibility of this attribute
+   */
+  show() {
+    this.isHidden = false;
+  }
+
+  /**
+   */
+  hide() {
+    this.isHidden = true;
+  }
+
+  /**
+   */
+  equals(otherAttribute) {
+    return this.key === otherAttribute.key && this.parentKey === otherAttribute.parentKey;
+  }
+
+  /**
+   * Readonly attribute width indicates the proposed width of this attribute
+   */
+  get readonlyWidth() {
+    return _Constants.ATTRIBUTE_WIDTH.MEDIUM;
+  }
+
+  /**
+   */
+  get layoutHintRules() {
+    return this._layoutHintRules;
+  }
+
+  /**
+   */
+  set layoutHintRules(rules) {
+    this._layoutHintRules = rules;
+  }
+
+  /**
+   */
+  processLayoutHintRules(attributes) {
+    if (this._layoutHintRules) {
+      this.layoutHintRules.process(this, attributes);
+    }
+  }
+
+  /**
+   * Indicates if content comes from the data service
+   */
+  get hasContentFromData() {
+    return (0, _Settings.hasAllContentInData)();
+  }
+
+  /**
+   */
+  get content() {
+    return new _AttributeContent.default(this.data.content);
+  }
+}
+exports.default = AttributeModel;
+//# sourceMappingURL=AttributeModel.js.map