@beinformed/ui 1.65.12 → 1.65.14

package/src/models/attributes/ChoiceAttributeModel.js

@@ -1,520 +0,0 @@
-// @flow
-import { klona } from "klona/full";
-
-import { has } from "../../utils/helpers/objects";
-
-import AttributeModel from "./AttributeModel";
-import ChoiceAttributeOptionCollection from "./ChoiceAttributeOptionCollection";
-import ChoiceAttributeOptionModel from "./ChoiceAttributeOptionModel";
-import CompositeAttributeModel from "./CompositeAttributeModel";
-import ContentConfigurationElements from "../contentconfiguration/ContentConfigurationElements";
-
-import {
-  RENDER_SECTION_LABEL,
-  SORT_OPTIONS,
-} from "../../constants/LayoutHints";
-import {
-  ATTRIBUTE_WIDTH,
-  PARAMETER_TYPES,
-  HTTP_METHODS,
-} from "../../constants";
-
-import type {
-  ModularUIModel,
-  AttributeType,
-  FormErrorAnchor,
-  ModelOptions,
-} from "../types";
-import type LinkModel from "../links/LinkModel";
-import type ErrorResponse from "../error/ErrorResponse";
-
-/**
- * Model for a choice attribute
- */
-export default class ChoiceAttributeModel extends AttributeModel {
-  _referenceDate: ISO_DATE;
-  _options: ChoiceAttributeOptionCollection;
-  _hasContentConfiguration: boolean;
-
-  /**
-   * Constructs a choice attribute
-   */
-  constructor(
-    attribute: Object,
-    attributeContributions: Object,
-    modelOptions?: ModelOptions,
-  ) {
-    super(attribute, attributeContributions, modelOptions);
-
-    this._referenceDate = this.getData(
-      "referenceDate",
-      new Date().toISOString().split("T")[0],
-    );
-    this._options = ChoiceAttributeOptionCollection.create(
-      attribute,
-      attributeContributions,
-      { ...modelOptions, referenceDate: this.referenceDate },
-    );
-
-    if (this.layouthint.has(SORT_OPTIONS)) {
-      this._options.sortOptions = true;
-    }
-  }
-
-  /**
-   */
-  static isApplicableModel(contributions: Object): boolean {
-    return (
-      contributions.type !== "composite" &&
-      contributions.type !== "boolean" &&
-      (contributions.type === "choice" ||
-        contributions.type === "array" ||
-        has(contributions, "enumerated") ||
-        has(contributions, "options"))
-    );
-  }
-
-  /**
-   */
-  get type(): string {
-    const optionMode = this.getContribution("optionMode", "");
-    const hasLookupLink = this.lookupLink || this.lookupListLink;
-
-    if (
-      optionMode === "lookup" ||
-      (optionMode === "dynamicWithThreshold" && hasLookupLink)
-    ) {
-      return "lookup";
-    }
-
-    return "choice";
-  }
-
-  /**
-   */
-  get optionType(): string {
-    return this.contributions?.optionType ?? "generic";
-  }
-
-  /**
-   */
-  get isUser(): boolean {
-    return this.optionType === "user";
-  }
-
-  /**
-   */
-  getInitialChildModelLinks(): Array<LinkModel> {
-    const links = [];
-
-    if (this.hasContentConfiguration) {
-      if (!this.hasContentFromData && this.conceptLink) {
-        links.push(this.conceptLink);
-      }
-
-      links.push(...this.options.getInitialChildModelLinks());
-    }
-
-    return links;
-  }
-
-  /**
-   */
-  setChildModels(models: Array<ModularUIModel>, errors: Array<ErrorResponse>) {
-    const conceptLinkHref = this.conceptLink?.href;
-    if (conceptLinkHref) {
-      this.concept = models.find(
-        (model) =>
-          model.type === "ConceptDetail" &&
-          model.selfhref.equalsWithParameters(conceptLinkHref),
-      );
-    }
-
-    this.options.setChildModels(models, errors);
-  }
-
-  /**
-   * Retrieve lookup service link
-   */
-  get lookupLink(): LinkModel | null {
-    const link = this.links.getLinkByKey("lookupOptions");
-    if (link && this.lookupParameterType === PARAMETER_TYPES.BODY) {
-      link.method = HTTP_METHODS.POST;
-    }
-    return link;
-  }
-
-  /**
-   * Indicate if the lookup must be done with POST or GET
-   */
-  get lookupParameterType(): $Values<typeof PARAMETER_TYPES> {
-    const parameterType = this.getContribution("parameterType");
-    switch (parameterType) {
-      case "bodyParameter":
-        return PARAMETER_TYPES.BODY;
-      default:
-        return PARAMETER_TYPES.QUERY;
-    }
-  }
-
-  /**
-   * Retrieve lookup service as list link
-   */
-  get lookupListLink(): LinkModel | null {
-    return this.links.getLinkByKey("lookupList");
-  }
-
-  /**
-   */
-  get lookupListLabel(): string {
-    return this.contributions.lookupList?.label ?? "";
-  }
-
-  /**
-   * Retrieve reference date of attribute which can be used as entryDate for content
-   */
-  get referenceDate(): ISO_DATE {
-    return this._referenceDate;
-  }
-
-  /**
-   * Set reference date for concepts and content
-   */
-  set referenceDate(date: string) {
-    this._referenceDate = date;
-
-    this.options.referenceDate = date;
-  }
-
-  /**
-   * Retrieve available choice options
-   */
-  get options(): ChoiceAttributeOptionCollection {
-    return this._options;
-  }
-
-  /**
-   * Getting all enabled options
-   */
-  get selected(): Array<string> {
-    // $FlowFixMe[incompatible-call]
-    return this.options.selected.map<string, ChoiceAttributeOptionModel>(
-      (option: ChoiceAttributeOptionModel) => option.code,
-    );
-  }
-
-  /**
-   * Flatten options and filter out the options that are not selected
-   */
-  get readonlyvalue(): string {
-    return this.options.selected.map((option) => option.label).join(", ");
-  }
-
-  /**
-   */
-  get initvalue(): any {
-    if (Array.isArray(this._initvalue) && this._initvalue.length === 0) {
-      return null;
-    }
-
-    return this._initvalue;
-  }
-
-  /**
-   * Retrieve list of selected options, joined with comma
-   */
-  getValue(): string | null {
-    return this.options.selected.length > 0
-      ? this.options.selected.map((option) => option.code).join(",")
-      : null;
-  }
-
-  /**
-   */
-  hasValue(): boolean {
-    return this.options.selected.length > 0;
-  }
-
-  /**
-   * Get input value of attribute
-   */
-  getInputValue(): string {
-    return this.selected.join(",");
-  }
-
-  /**
-   * Setting an option selected or unselected based on the current state
-   */
-  toggleOption(code: string) {
-    if (this.selected.includes(code)) {
-      this.disableOption(code);
-    } else {
-      this.enableOption(code);
-    }
-  }
-
-  /**
-   * Enable a option
-   */
-  enableOption(code: string) {
-    if (!this.isMultiple) {
-      this.options.deselectAll();
-    }
-
-    this.options.select(code);
-    this.inputvalue = this.getInputValue();
-  }
-
-  /**
-   * Disable a option
-   */
-  disableOption(code: string) {
-    this.options.deselect(code);
-    this.inputvalue = this.getInputValue();
-  }
-
-  /**
-   * Add a new option to the collection of lookup options
-   */
-  addOption(option: Object) {
-    if (!this.isMultiple) {
-      this.options.deselectAll();
-    }
-
-    if (this.options.find((opt) => opt.code === option.code) === null) {
-      this.options.addOption(option.code, option);
-    }
-  }
-
-  /**
-   * Getting the type of choice filter. For instance checkbox, radiobutton, combobox.
-   */
-  get choicetype():
-    | "checkbox"
-    | "radiobutton"
-    | "combobox"
-    | "list"
-    | "listview"
-    | "table"
-    | "longlist"
-    | "toggle" {
-    return (
-      [
-        "checkbox",
-        "radiobutton",
-        "combobox",
-        "list",
-        "listview",
-        "table",
-        "longlist",
-        "toggle",
-      ].find((hint) => this.layouthint.has(hint)) || "checkbox"
-    );
-  }
-
-  /**
-   * Can multiple options be selected
-   */
-  get isMultiple(): boolean {
-    return this.contributions.multiplechoice || this.choicetype === "checkbox";
-  }
-
-  /**
-   * Check if options need to be rendered as tree
-   */
-  get isTree(): boolean {
-    return (
-      has(this.contributions, "options") &&
-      this.contributions.options.some((option) => has(option, "children"))
-    );
-  }
-
-  /**
-   * Reset choice attribute to unselected list
-   */
-  reset() {
-    this.options.deselectAll();
-  }
-
-  /**
-   */
-  mergeAttribute(
-    oldAttribute: AttributeType,
-    addNotExistingOptions: boolean = false,
-    removeNotExistingOptions: boolean = false,
-  ) {
-    // when attribute is readonly, don't merge the options no modifications necessary
-    if (!this.readonly && oldAttribute instanceof ChoiceAttributeModel) {
-      this.concept = oldAttribute.concept;
-      this.options.mergeOptions(
-        oldAttribute.options,
-        addNotExistingOptions ?? this.type === "lookup",
-        removeNotExistingOptions,
-      );
-      this.options.deselectAll();
-
-      if (oldAttribute.isValid && oldAttribute.inputvalue !== null) {
-        this.update(oldAttribute.inputvalue);
-      }
-    }
-  }
-
-  /**
-   * Update attribute by name and value
-   */
-  update(value: any): ChoiceAttributeModel {
-    if (this.readonly) {
-      return this;
-    }
-
-    this.updateLastModification();
-
-    let values = [];
-
-    if (Array.isArray(value)) {
-      values = value;
-    } else if (typeof value === "string" && this.isMultiple) {
-      values = value.split(",");
-    } else if (value != null) {
-      values = [value];
-    }
-    values.forEach((val) => {
-      if (typeof val === "object" && val.isChoiceAttributeOptionModel) {
-        // option does not exist in existing options, add it. This can happen when lookup list has other options then lookup options
-        if (!this.options.some((option) => option.equals(val))) {
-          const newVal = klona(val);
-          newVal.selected = false;
-          this.options.add(newVal);
-        }
-        this.toggleOption(val.code);
-      } else if (
-        (typeof val === "number" ||
-          typeof val === "string" ||
-          typeof val === "boolean") &&
-        this.options.some((option) => option.code.toString() === val.toString())
-      ) {
-        this.toggleOption(val.toString());
-      }
-    });
-
-    return this;
-  }
-
-  /**
-   */
-  updateByAttribute(otherAttribute: AttributeType): void {
-    this.reset();
-    if (
-      otherAttribute instanceof ChoiceAttributeModel ||
-      otherAttribute instanceof CompositeAttributeModel
-    ) {
-      let otherValue;
-      if (otherAttribute instanceof ChoiceAttributeModel) {
-        otherValue = otherAttribute.options.selected;
-      } else if (otherAttribute instanceof CompositeAttributeModel) {
-        otherValue = otherAttribute.getChildrenIds();
-      }
-      if (otherValue !== null) {
-        this.update(otherValue);
-      }
-    } else {
-      console.error(
-        `update of choice attribute with ${otherAttribute.type} not supported`,
-      );
-    }
-  }
-
-  /**
-   * Registers a missing error that was received from the server
-   */
-  addMissingError(receivedAttribute?: AttributeType): void {
-    if (this.isChangedSince(0)) {
-      this._errorCollection.addServerError("Constraint.Missing");
-    }
-    // update choice options
-    if (receivedAttribute instanceof ChoiceAttributeModel) {
-      this.mergeAttribute(receivedAttribute, true, true);
-    }
-  }
-
-  /**
-   */
-  set hasContentConfiguration(hasContentConfiguration: boolean) {
-    this._hasContentConfiguration =
-      this.contentConfiguration !== null || hasContentConfiguration;
-  }
-
-  /**
-   */
-  get hasContentConfiguration(): boolean {
-    return this._hasContentConfiguration;
-  }
-
-  /**
-   * Get content configuration configured on the attribute.
-   * Only applicable for taxonomy element and knowledge codemaps,
-   * content configuration for instrument questions is available on the form object
-   */
-  get contentConfiguration(): ContentConfigurationElements | null {
-    if (
-      !this.contributions.content ||
-      !this.contributions.content.optionElements
-    ) {
-      return null;
-    }
-
-    // Add RENDER_SECTION_LABEL to all content configuration to make sure the label of a section is always rendered on taxonomy and knowlege codemaps
-    const optionElementConfig = this.contributions.content.optionElements.map(
-      (optionElement) => {
-        if ("contentElement" in optionElement) {
-          return {
-            contentElement: {
-              ...optionElement.contentElement,
-              layouthint: [RENDER_SECTION_LABEL],
-            },
-          };
-        }
-
-        return optionElement;
-      },
-    );
-
-    return new ContentConfigurationElements(optionElementConfig);
-  }
-
-  /**
-   * Get placeholder text
-   */
-  get placeholder(): string {
-    return this.getContribution("placeholder", "");
-  }
-
-  /**
-   * Registers an error that was received from a server response
-   */
-  addServerError(error: FormErrorAnchor) {
-    const { id, message, properties, layouthint } = error;
-
-    const ANSWER_OPTION_KEY = "answer-option-key";
-
-    if (properties && has(properties, ANSWER_OPTION_KEY)) {
-      const optionKey = properties[ANSWER_OPTION_KEY];
-      const foundOption = this.options.find(
-        (option) => option.code === optionKey,
-      );
-      if (foundOption) {
-        properties[ANSWER_OPTION_KEY] = foundOption.getContentConfiguredLabel(
-          this.contentConfiguration,
-        );
-      }
-    }
-
-    this._errorCollection.addServerError(id, message, properties, layouthint);
-  }
-
-  /**
-   */
-  get readonlyWidth(): $Keys<typeof ATTRIBUTE_WIDTH> {
-    return ATTRIBUTE_WIDTH.MEDIUM;
-  }
-}