@beinformed/ui 1.65.12 → 1.65.14

package/src/models/attributes/AttributeCollection.js

@@ -1,306 +0,0 @@
-// @flow
-import { has } from "../../utils/helpers/objects";
-
-import ResourceCollection from "../base/ResourceCollection";
-
-import createAttribute from "./_createAttribute";
-import ChoiceAttributeModel from "./ChoiceAttributeModel";
-import CompositeAttributeModel from "./CompositeAttributeModel";
-
-import ContentConfiguration from "../contentconfiguration/ContentConfiguration";
-
-import { ConfigurationException } from "../../exceptions";
-
-import type { AttributeType, FormErrorAnchor, ModelOptions } from "../types";
-
-type AttributeCollectionOptions = {
-  ...ModelOptions,
-  isReadonly: boolean,
-};
-
-/**
- * Collection of attributes
- */
-class AttributeCollection extends ResourceCollection<AttributeType> {
-  constructor(
-    data: Object | Array<Object> = {},
-    contributions: Array<Object> = [],
-    modelOptions?: AttributeCollectionOptions,
-  ) {
-    super();
-
-    if (contributions) {
-      contributions.forEach((contribution) => {
-        const [key] = Object.keys(contribution);
-
-        const attribute = createAttribute(key, data, contribution[key], {
-          origin: modelOptions?.origin,
-          contextPath: modelOptions?.contextPath,
-        });
-
-        if (attribute !== null) {
-          // when readonly is not explicitly set in the contributions, follow argument
-          if (modelOptions?.isReadonly && !has(contribution[key], "readonly")) {
-            attribute.readonly = true;
-          }
-
-          this.collection.push(attribute);
-        }
-      });
-
-      this.processLayoutHintRules();
-    }
-  }
-
-  /**
-   * Retrieve all attributes in this collection<br>
-   * This getter processes layout hints, this is different from the standard {@link BaseCollection#all} property
-   * @returns {Array<AttributeType>}
-   */
-  get attributes(): Array<AttributeType> {
-    this.processLayoutHintRules();
-    return this.all;
-  }
-
-  /**
-   * Replace attributes with a new array of attributes
-   */
-  set attributes(attributes: Array<AttributeType>) {
-    this.collection = attributes;
-  }
-
-  /**
-   */
-  processLayoutHintRules(): void {
-    this.all.forEach((attribute) => {
-      attribute.processLayoutHintRules(this);
-    });
-  }
-
-  /**
-   * Retrieve only visible attributes from the collection
-   */
-  get visible(): Array<AttributeType> {
-    // Let flow know that this is a AttributeCollection
-    if (this instanceof AttributeCollection) {
-      return this.attributes.filter((attribute) => !attribute.isHidden);
-    }
-
-    return [];
-  }
-
-  /**
-   */
-  get questions(): Array<AttributeType> {
-    return this.visible.filter((attribute) => !attribute.isResult);
-  }
-
-  /**
-   */
-  get results(): Array<AttributeType> {
-    return this.visible.filter((attribute) => attribute.isResult);
-  }
-
-  /**
-   */
-  getAttributeByAttribute(attribute: AttributeType): AttributeType | null {
-    return this.find((attr) => {
-      if (attr.equals(attribute)) {
-        return true;
-      } else if (attribute instanceof CompositeAttributeModel) {
-        return attribute.getChildByAttribute(attribute);
-      }
-
-      return false;
-    });
-  }
-
-  /**
-   * Get a single attribute by it's key
-   */
-  getAttributeByKey(key: string): AttributeType | null {
-    return this.find((attribute) => {
-      if (attribute.key === key) {
-        return true;
-      } else if (attribute instanceof CompositeAttributeModel) {
-        return attribute.getChildByKey(key);
-      }
-
-      return false;
-    });
-  }
-
-  /**
-   * Indicates if attribute with key exists in collection
-   */
-  hasAttributeByKey(key: string): boolean {
-    return this.getAttributeByKey(key) !== null;
-  }
-
-  /**
-   * Getting the first attribute having the supplied layout hint
-   */
-  getAttributeByLayoutHint(...hints: Array<string>): AttributeType | null {
-    return this.find((attribute) => attribute.layouthint.has(...hints)) || null;
-  }
-
-  /**
-   * Getting a choice attribute by layouthint, returns null when not found or not a choice attribute
-   */
-  getChoiceAttributeByLayoutHint(
-    layoutHint: string,
-  ): ChoiceAttributeModel | null {
-    const attribute = this.getAttributeByLayoutHint(layoutHint);
-
-    return attribute instanceof ChoiceAttributeModel ? attribute : null;
-  }
-
-  /**
-   * Getting all attributes having the supplied layout hint
-   */
-  getAttributesByLayoutHint(...hints: Array<string>): Array<AttributeType> {
-    return this.filter((attribute) => attribute.layouthint.has(...hints));
-  }
-
-  /**
-   * Replace an attribute instance in the collection with a new attribute instance
-   */
-  replace(oldAttribute: AttributeType, newAttribute: AttributeType): void {
-    this.replaceByKey(oldAttribute.key, newAttribute);
-  }
-
-  /**
-   * Replace an attribute by the key of the attribute
-   */
-  replaceByKey(key: string, newAttribute: AttributeType): void {
-    this.forEach((attribute, index) => {
-      if (attribute.key === key) {
-        this.collection[index] = newAttribute;
-      }
-    });
-  }
-
-  /**
-   * Set reference date by replacing an old attribute with a new attribute with a reference Date
-   * Date is a string in ISO format yyyy-MM-dd
-   */
-  setReferenceDate(date: string): void {
-    this.forEach((attribute) => {
-      const newAttribute = attribute.clone();
-
-      newAttribute.referenceDate = date;
-
-      this.replace(attribute, newAttribute);
-    });
-  }
-
-  /**
-   */
-  hasServerErrors(): boolean {
-    return this.collection.some((attribute) => attribute.hasServerErrors());
-  }
-
-  /**
-   */
-  addServerError(error: FormErrorAnchor): void {
-    const elementid = error?.anchor?.elementid;
-
-    if (elementid) {
-      const attribute = this.getAttributeByKey(elementid);
-      if (attribute) {
-        attribute.addServerError(error);
-      } else {
-        throw new ConfigurationException(
-          `Could not add error to missing attribute with id ${elementid}`,
-        );
-      }
-    }
-  }
-
-  /**
-   */
-  hasErrors(): boolean {
-    return this.visible.some((attribute) => attribute.hasErrors());
-  }
-
-  /**
-   */
-  updateValidations(errors: Array<Object>): AttributeCollection {
-    this.all
-      .filter((attribute) => attribute.hasDynamicValidationData)
-      .forEach((attribute) => {
-        const attributeErrors = errors.filter(
-          (error) => error.anchor?.elementid === attribute.key,
-        );
-        attribute.updateValidations(attributeErrors);
-
-        if (attribute instanceof CompositeAttributeModel) {
-          const compositeChildErrors = errors.filter((error) => {
-            const elementId = error.anchor?.elementid;
-            return elementId && elementId.startsWith(`${attribute.key}.`);
-          });
-
-          attribute.children.updateValidations(
-            `${attribute.key}.`,
-            compositeChildErrors,
-          );
-        }
-      });
-
-    return this;
-  }
-
-  /**
-   */
-  indicateContentConfiguration(
-    contentConfiguration: ContentConfiguration,
-  ): void {
-    if (contentConfiguration) {
-      this.all.forEach((attribute) => {
-        attribute.indicateContentConfiguration(contentConfiguration);
-      });
-    }
-  }
-
-  /**
-   * Generate formdata object for current collection based on formdata of attributes
-   * Skip attributes that are readonly, the confirmation password or null
-   */
-  get formdata(): { [string]: any } | null {
-    return this.getFormData(false);
-  }
-
-  /**
-   */
-  getFormData(validationData: boolean = false): { [string]: any } | null {
-    const attributesFormData = this.attributes
-      .filter(
-        (attribute) =>
-          attribute.formdata !== null &&
-          !attribute.readonly &&
-          (!validationData || attribute.hasDynamicValidationData),
-      )
-      .map((attribute) => {
-        // make attribute empty when it is not (or no longer) visible
-        if (attribute.isVisible) {
-          return attribute.formdata;
-        }
-
-        return attribute.getEmptyFormData();
-      });
-
-    let data = {};
-    attributesFormData.forEach((attributeFormData) => {
-      // $FlowIgnore[cannot-spread-indexer]
-      // $FlowIgnore[exponential-spread]
-      data = {
-        ...data,
-        ...attributeFormData,
-      };
-    });
-
-    return data;
-  }
-}
-
-export default AttributeCollection;

package/src/models/attributes/AttributeContent.js

@@ -1,233 +0,0 @@
-// @flow
-import { retrieveText } from "../../utils/helpers/text";
-import { hasAllContentInData } from "../../constants/Settings";
-import SectionModel from "../content/SectionModel";
-
-import LayoutHintCollection from "../layouthint/LayoutHintCollection";
-import { isPlainObject } from "../../utils";
-
-import type {
-  ContentData,
-  ContentElementMapped,
-  PropertyData,
-  PropertyElementMapped,
-  TextFragmentData,
-  TextFragmentElementMapped,
-  ContentAll,
-} from "../types";
-import type SubSectionModel from "../content/SubSectionModel";
-
-/**
- */
-class AttributeContent {
-  _content: ?ContentData;
-
-  constructor(content: ?ContentData) {
-    this._content = content;
-  }
-
-  /**
-   */
-  get fromData(): boolean {
-    return hasAllContentInData();
-  }
-
-  /**
-   */
-  get header(): {
-    label: ?string,
-    description: ?string,
-  } {
-    let headerLabel = null;
-    let headerDescription = null;
-
-    const label = this._content?.header?.label;
-    if (label) {
-      headerLabel = label;
-    }
-
-    const description = this._content?.header?.description;
-    if (description) {
-      if (isPlainObject(description) && "message" in description) {
-        headerDescription = description.message;
-      } else if (typeof description === "string") {
-        headerDescription = description;
-      }
-    }
-
-    return { label: headerLabel, description: headerDescription };
-  }
-
-  /**
-   */
-  get elements(): ContentAll {
-    if (this._content?.elements) {
-      return this._content.elements
-        .filter((element) => element !== null)
-        .map((element) => {
-          if (element.propertyElement) {
-            const { label, layouthint, properties } = element.propertyElement;
-
-            return {
-              propertyElement: {
-                label,
-                layouthint: new LayoutHintCollection(layouthint),
-                properties,
-              },
-            };
-          }
-
-          if (element.textFragmentElement) {
-            const { label, layouthint, textfragments } =
-              element.textFragmentElement;
-            return {
-              textFragmentElement: {
-                label,
-                layouthint: new LayoutHintCollection(layouthint),
-                textfragments: textfragments.map((textfragment) => ({
-                  ...textfragment,
-                  text: retrieveText(textfragment.text) || "",
-                })),
-              },
-            };
-          }
-
-          if (element.contentElement) {
-            const { label, layouthint, sections } = element.contentElement;
-            return {
-              contentElement: {
-                label,
-                layouthint: new LayoutHintCollection(layouthint),
-                sections: sections.map(
-                  (section) => new SectionModel(section, null),
-                ),
-              },
-            };
-          }
-
-          // $FlowIssue
-          return element;
-        });
-    }
-
-    return [];
-  }
-
-  /**
-   */
-  get label(): ?string {
-    return this._content?.label;
-  }
-
-  /**
-   */
-  getContentElements<T>(elementName: string): Array<T> {
-    // $FlowIssue incompatible-return
-    return this.elements.filter((element) => elementName in element);
-  }
-
-  /**
-   */
-  getContentElementCollections<T>(
-    elementName: string,
-    collectionName: string,
-  ): Array<T> {
-    return this.getContentElements(elementName)
-      .map((element) => element[elementName][collectionName])
-      .flat();
-  }
-
-  /**
-   */
-  getContentElementCollectionByLabels<T, U>(
-    elementName: string,
-    collectionName: string,
-    labels: Array<string>,
-  ): Array<U> {
-    return (
-      this.getContentElements<T>(elementName)
-        // $FlowIssue incompatible-use
-        .filter((element) => labels.includes(element[elementName].label))
-        // $FlowIssue incompatible-use
-        .map((element) => element[elementName][collectionName])
-        .flat()
-    );
-  }
-
-  /**
-   */
-  get properties(): Array<PropertyData> {
-    return this.getContentElementCollections<PropertyData>(
-      "propertyElement",
-      "properties",
-    );
-  }
-
-  /**
-   * Get concept properties by property element label
-   */
-  getConceptPropertiesByLabels(labels: Array<string>): Array<PropertyData> {
-    return this.getContentElementCollectionByLabels<
-      PropertyElementMapped,
-      PropertyData,
-    >("propertyElement", "properties", labels);
-  }
-
-  /**
-   */
-  get textfragments(): Array<TextFragmentData> {
-    return this.getContentElementCollections<TextFragmentData>(
-      "textFragmentElement",
-      "textfragments",
-    );
-  }
-
-  /**
-   * Get concept text fragments by text fragment element label
-   */
-  getTextFragmentsByLabels(labels: Array<string>): Array<TextFragmentData> {
-    return this.getContentElementCollectionByLabels<
-      TextFragmentElementMapped,
-      TextFragmentData,
-    >("textFragmentElement", "textfragments", labels);
-  }
-
-  /**
-   */
-  get sections(): Array<SectionModel> {
-    return this.getContentElementCollections<SectionModel>(
-      "contentElement",
-      "sections",
-    );
-  }
-
-  /**
-   */
-  getSectionsByType(types: Array<string>): Array<SectionModel> {
-    return this.sections.filter((section) => types.includes(section.type));
-  }
-
-  /**
-   * Get concept text fragments by text fragment element label
-   */
-  getSectionsByLabels(labels: Array<string>): Array<SectionModel> {
-    return this.getContentElementCollectionByLabels<
-      ContentElementMapped,
-      SectionModel,
-    >("contentElement", "sections", labels);
-  }
-
-  /**
-   */
-  getReferredSections(): Array<SectionModel | SubSectionModel> {
-    const referredSections = [];
-
-    for (const section of this.sections) {
-      referredSections.push(...section.getReferredSections());
-    }
-
-    return referredSections;
-  }
-}
-
-export default AttributeContent;