@beinformed/ui 1.65.12 → 1.65.14

package/src/models/attributes/__tests__/createAttributeComposite.spec.js

@@ -1,151 +0,0 @@
-import createAttribute from "../_createAttribute";
-
-describe("createAttributeComposite", () => {
-  it("should be able to create a composite attribute from a simple JSON structure", () => {
-    const composite = createAttribute(
-      "composite",
-      {
-        ControleDBC: ["OperatieMammatumorPassend"],
-        DiagnoseBehandelCombinatie: "n020107057",
-        GeenVereisten: true,
-      },
-      {
-        type: "composite",
-        label: "results",
-        children: [
-          {
-            ControleDBC: {
-              type: "string",
-              label: "Controle DBC",
-              optionMode: "static",
-              falseAllowed: true,
-              multiplechoice: true,
-              _links: {
-                concept: {
-                  href: "/concepts/DBC controle/Business design/DBC controle.bixml/ControleDBC",
-                },
-              },
-              layouthint: ["checkbox"],
-              enumerated: true,
-              options: [
-                {
-                  code: "OperatieMammatumorPassend",
-                  label: "Hersteloperatie van borst met prothese passend",
-                  _links: {
-                    concept: {
-                      href: "/concepts/DBC controle/Business design/Hersteloperatie van borst/Controle hersteloperatie van borst met prothese.bixml/HersteloperatieVanBorstMetProthesePassend",
-                    },
-                  },
-                },
-              ],
-            },
-          },
-          {
-            GeenVereisten: {
-              type: "boolean",
-              label: "Geen vereisten",
-              _links: {
-                concept: {
-                  href: "/concepts/Zorgactiviteiten/Business design/Zorgactiviteiten.bixml/GeenVereisten",
-                },
-              },
-              layouthint: ["radiobutton"],
-            },
-          },
-        ],
-      },
-    );
-
-    expect(composite.children.all[0].value).toBe("OperatieMammatumorPassend");
-  });
-
-  it("should be able to create a composite attribute from a form JSON structure", () => {
-    const composite = createAttribute(
-      "BookRelationWithPublisher",
-      [
-        {
-          elementid: "BookRelationWithPublisher",
-          elements: [
-            {
-              elementid: "BookDateFromA",
-              suggestion: "2020-01-01",
-            },
-            {
-              elementid: "BookDateTo",
-            },
-          ],
-        },
-      ],
-      {
-        type: "range",
-        label: "Book relation with publisher",
-        mandatory: true,
-        children: [
-          {
-            BookDateFromA: {
-              type: "date",
-              label: "Date from",
-              mandatory: true,
-              formatlabel: "dd-mm-jjjj",
-              format: "dd-MM-yyyy",
-            },
-          },
-          {
-            BookDateTo: {
-              type: "date",
-              label: "Date to",
-              mandatory: false,
-              formatlabel: "dd-mm-jjjj",
-              format: "dd-MM-yyyy",
-            },
-          },
-        ],
-      },
-    );
-
-    expect(composite.children).toHaveLength(2);
-    expect(composite.children.first.value).toBe("2020-01-01");
-    expect(composite.children.last.value).toBeNull();
-  });
-
-  it("should be able to create a composite attribute from a list JSON structure", () => {
-    const composite = createAttribute(
-      "DateRange",
-      {
-        DateRange: {
-          StartDate: "2020-01-01T12:00:00.000",
-          EndDate: "2020-01-01T13:00:00.000",
-        },
-      },
-      {
-        type: "range",
-        label: "Time",
-        readonly: true,
-        children: [
-          {
-            StartDate: {
-              type: "timestamp",
-              label: "Start",
-              readonly: true,
-              format: "dd-MM-yyyy HH:mm",
-              placeholder: "dd-mm-yyyy hh:mm",
-            },
-          },
-          {
-            EndDate: {
-              type: "timestamp",
-              label: "End",
-              readonly: true,
-              format: "dd-MM-yyyy HH:mm",
-              placeholder: "dd-mm-yyyy hh:mm",
-            },
-          },
-        ],
-      },
-    );
-
-    expect(composite.children).toHaveLength(2);
-    expect(composite.children.first.value).toBe("2020-01-01T12:00:00.000");
-    expect(composite.children.last.value).toBe("2020-01-01T13:00:00.000");
-  });
-});

package/src/models/attributes/__tests__/createAttributeDynamicSchema.spec.js

@@ -1,134 +0,0 @@
-import createAttribute from "../_createAttribute";
-
-describe("createAttribute With Dynamicschema", () => {
-  it("should be able to create a choice attribute with dynamicschema inside a composite", () => {
-    const composite = createAttribute(
-      "results",
-      {
-        dynamicschema: {
-          "results.PeriodOfInterestRate": [
-            {
-              code: "n2YearsRepaymentMortgage",
-              label: "2 years",
-            },
-            {
-              code: "n3YearsRepaymentMortgage",
-              label: "3 years",
-            },
-          ],
-        },
-        results: {
-          PeriodOfInterestRate: "n5YearsRepaymentMortgage",
-        },
-      },
-      {
-        type: "composite",
-        label: "results",
-        children: [
-          {
-            PeriodOfInterestRate: {
-              type: "string",
-              label: "Period of interest rate",
-              optionMode: "dynamic",
-              falseAllowed: true,
-              multiplechoice: false,
-              layouthint: ["combobox"],
-              dynamicschemaId: "results.PeriodOfInterestRate",
-              enumerated: true,
-            },
-          },
-        ],
-      },
-    );
-
-    expect(composite.type).toBe("composite");
-    expect(composite.children).toHaveLength(1);
-
-    const periodOfInterest = composite.children.first;
-    expect(periodOfInterest.type).toBe("choice");
-    expect(periodOfInterest.key).toBe("PeriodOfInterestRate");
-    expect(periodOfInterest.options).toHaveLength(2);
-  });
-
-  it("should be able to create a choice attribute where an other attribute has a dynamicschema", () => {
-    const composite = createAttribute(
-      "DocumentType",
-      {
-        Creator: "1",
-        DocumentType: "eBook",
-        dynamicschema: {
-          Creator: [
-            {
-              code: "1",
-              label: "Arnold",
-            },
-          ],
-        },
-      },
-      {
-        type: "string",
-        label: "Document type",
-        optionMode: "static",
-        readonly: true,
-        multiplechoice: false,
-        layouthint: ["combobox"],
-        enumerated: true,
-        options: [
-          {
-            code: "eBook",
-            label: "eBook",
-          },
-        ],
-      },
-    );
-
-    expect(composite.type).toBe("choice");
-    expect(composite.options).toHaveLength(1);
-  });
-
-  it("should create a choice attribute with dynamischema on a form", () => {
-    const choice = createAttribute(
-      "Person",
-      [
-        {
-          elementid: "Person",
-          dynamicschema: [
-            {
-              code: "1",
-              label: "Stephen King",
-            },
-            {
-              code: "2",
-              label: "Douglas Coupland",
-            },
-          ],
-        },
-        {
-          elementid: "BelowCodemapsAreAllWithLargeOn",
-          static: true,
-          value: "Below codemaps are all with large on",
-        },
-        {
-          elementid: "FruitStaticSingle",
-          _links: {
-            lookupOptions: {
-              href: "/lookupOptions?lookupToken=da9fe2ee-a0da-46b7-8e0e-1909fd2d0ce2",
-            },
-          },
-        },
-      ],
-      {
-        type: "string",
-        label: "Person",
-        mandatory: false,
-        optionMode: "dynamicWithThreshold",
-        multiplechoice: false,
-        layouthint: ["combobox"],
-        enumerated: true,
-      },
-    );
-
-    expect(choice.type).toBe("choice");
-    expect(choice.options).toHaveLength(2);
-  });
-});

package/src/models/attributes/_createAttribute.js

@@ -1,147 +0,0 @@
-// @flow
-import { klona } from "klona/full";
-
-import { has, isPlainObject } from "../../utils/helpers/objects";
-
-import LayoutHintRuleCollection from "./layouthint-rules/LayoutHintRuleCollection";
-
-import CaptchaAttributeModel from "./CaptchaAttributeModel";
-import ChoiceAttributeModel from "./ChoiceAttributeModel";
-import DatetimeAttributeModel from "./DatetimeAttributeModel";
-import HelptextAttributeModel from "./HelptextAttributeModel";
-import LabelAttributeModel from "./LabelAttributeModel";
-import MemoAttributeModel from "./MemoAttributeModel";
-import MoneyAttributeModel from "./MoneyAttributeModel";
-import NumberAttributeModel from "./NumberAttributeModel";
-import PasswordAttributeModel from "./PasswordAttributeModel";
-import CompositeAttributeModel from "./CompositeAttributeModel";
-import StringAttributeModel from "./StringAttributeModel";
-import UploadAttributeModel from "./UploadAttributeModel";
-import XMLAttributeModel from "./XMLAttributeModel";
-import BooleanAttributeModel from "./BooleanAttributeModel";
-
-import AttributeDataHelper from "./AttributeDataHelper";
-
-import type { AttributeType, ModelOptions } from "../types";
-
-/**
- * @private
- */
-const getChildrenKeys = (children: Array<Object>): Array<Object> => {
-  if (children) {
-    return children.map((child) => {
-      const [childKey] = Object.keys(child);
-      const isComposite =
-        child[childKey].type === "range" ||
-        child[childKey].type === "composite";
-
-      return {
-        key: childKey,
-        dynamicschemaId: child[childKey]?.dynamicschemaId || undefined,
-        children: isComposite ? getChildrenKeys(child[childKey]?.children) : [],
-      };
-    });
-  }
-
-  return [];
-};
-
-/**
- * @private
- */
-const getAttributeModel = (contributions: Object): ?Class<AttributeType> => {
-  const ATTRIBUTE_MODELS = [
-    ChoiceAttributeModel,
-    BooleanAttributeModel,
-
-    HelptextAttributeModel,
-    LabelAttributeModel,
-
-    XMLAttributeModel,
-    MemoAttributeModel,
-    StringAttributeModel,
-
-    DatetimeAttributeModel,
-
-    MoneyAttributeModel,
-    NumberAttributeModel,
-    PasswordAttributeModel,
-
-    UploadAttributeModel,
-    CompositeAttributeModel,
-    CaptchaAttributeModel,
-  ];
-
-  return ATTRIBUTE_MODELS.find((model) =>
-    model.isApplicableModel(contributions),
-  );
-};
-
-/**
- * @private
- */
-const updateContributions = (
-  key: string,
-  data: Object,
-  contributions: Object,
-): Object => {
-  const isComposite =
-    contributions.type === "array" &&
-    has(contributions, "children") &&
-    isPlainObject(data) &&
-    Array.isArray(data[key]);
-
-  return {
-    ...contributions,
-    type: isComposite ? "composite" : contributions.type,
-  };
-};
-
-/**
- * @private
- */
-const updateData = (
-  key: string,
-  data: Object,
-  contributions: Object,
-): Object => {
-  const newData = klona(data);
-
-  if (contributions.dynamicschemaId) {
-    newData.dynamicschemaId = contributions.dynamicschemaId;
-  }
-
-  return newData;
-};
-
-/**
- * Create an attribute based on data and contributions
- */
-const createAttribute = (
-  key: string,
-  data: Object | Array<Object>,
-  contributions: Object,
-  modelOptions?: ModelOptions,
-): AttributeType => {
-  const updatedContributions = updateContributions(key, data, contributions);
-  const updatedData = updateData(key, data, contributions);
-
-  const Model = getAttributeModel(updatedContributions);
-
-  if (!Model) {
-    throw new Error("Could not find model");
-  }
-
-  const childrenKeys = getChildrenKeys(updatedContributions.children ?? []);
-  const dataHelper = new AttributeDataHelper(
-    updatedData,
-    key,
-    childrenKeys,
-  ).getData();
-
-  const attribute = new Model(dataHelper, updatedContributions, modelOptions);
-
-  return LayoutHintRuleCollection.setLayoutHintRules(attribute);
-};
-
-export default createAttribute;

package/src/models/attributes/input-constraints/BSNConstraint.js

@@ -1,80 +0,0 @@
-// @flow
-import type { IConstraintModel } from "../../types";
-
-/**
- */
-class BSNConstraint implements IConstraintModel {
-  /**
-   */
-  get id(): string {
-    return "Constraint.BSN.InvalidFormat";
-  }
-
-  /**
-   */
-  hasValidation(): boolean {
-    return true;
-  }
-
-  /**
-   */
-  get defaultMessage(): string {
-    return "Must be a valid BSN";
-  }
-
-  /**
-   */
-  get parameters(): { ... } {
-    return {};
-  }
-
-  /**
-   */
-  isValidBSN(bsn: string): boolean {
-    // if remove invalid characters and check if this is still the same length to find out if unwanted characters are used
-    // valid characters are: numbers
-    if (bsn.replace(/[^\d]/gu, "").length !== bsn.length) {
-      return false;
-    }
-
-    const bsnNumber = bsn.replace(/\D/gu, "");
-
-    const bsnLength = bsnNumber.length;
-    const MINBSNLENGTH = 8;
-    const MAXBSNLENGTH = 9;
-
-    if (
-      bsnLength < MINBSNLENGTH ||
-      bsnLength > MAXBSNLENGTH ||
-      isNaN(bsnNumber)
-    ) {
-      return false;
-    }
-
-    let pos = 0;
-    let result = 0;
-
-    for (let i = bsnLength; i > 0; i--) {
-      const digit = parseInt(bsnNumber.charAt(pos), 10);
-
-      result += i === 1 ? digit * -1 : digit * i;
-      pos += 1;
-    }
-
-    return result % 11 === 0;
-  }
-
-  /**
-   */
-  validate(value: string): boolean {
-    return this.isValidBSN(value);
-  }
-
-  /**
-   */
-  get isMandatoryConstraint(): boolean {
-    return false;
-  }
-}
-
-export default BSNConstraint;

package/src/models/attributes/input-constraints/ConstraintCollection.js

@@ -1,65 +0,0 @@
-// @flow
-import BaseCollection from "../../base/BaseCollection";
-import ConstraintModel from "./ConstraintModel";
-
-import { getSetting } from "../../../constants/Settings";
-
-import type { IConstraintModel } from "../../types";
-
-/**
- * Attribute constraints
- */
-export default class ConstraintCollection extends BaseCollection<IConstraintModel> {
-  /**
-   * Add constraint
-   */
-  addConstraint(
-    id: string,
-    validateMethod: ?Function,
-    defaultMessage: ?string,
-    data: ?Object,
-    useClientsideValidation: boolean = getSetting("USE_CLIENTSIDE_VALIDATION"),
-  ) {
-    this.add(
-      new ConstraintModel(
-        id,
-        validateMethod,
-        defaultMessage,
-        data,
-        useClientsideValidation,
-      ),
-    );
-  }
-
-  /**
-   * Validate if complete collection is valid
-   */
-  validate(value: any): boolean {
-    return (
-      this.isEmpty ||
-      this.collection.every((constraint) => constraint.validate(value))
-    );
-  }
-
-  /**
-   * Indicates if a mandatory constraint exists in the collection
-   */
-  hasMandatoryConstraint(): boolean {
-    return this.collection.some(
-      (constraint) => constraint.isMandatoryConstraint,
-    );
-  }
-
-  /**
-   * Retrieve all invalid constraints
-   */
-  invalidConstraints(value: any): Array<IConstraintModel> {
-    if (value === "" && !this.hasMandatoryConstraint()) {
-      return [];
-    }
-
-    return this.collection.filter(
-      (constraint) => constraint.validate(value) === false,
-    );
-  }
-}

package/src/models/attributes/input-constraints/ConstraintModel.js

@@ -1,76 +0,0 @@
-// @flow
-import { getSetting } from "../../../constants/Settings";
-
-import type { IConstraintModel } from "../../types";
-
-/**
- */
-export default class ConstraintModel implements IConstraintModel {
-  _id: string;
-  _validateMethod: ?(value: any) => boolean;
-  _defaultMessage: ?string;
-  _parameters: ?Object;
-  _useClientsideValidation: boolean;
-
-  /**
-   */
-  constructor(
-    id: string,
-    validateMethod: ?Function,
-    defaultMessage: ?string,
-    parameters: ?Object,
-    useClientsideValidation: boolean = getSetting("USE_CLIENTSIDE_VALIDATION"),
-  ) {
-    this._id = id;
-    this._validateMethod = validateMethod;
-    this._defaultMessage = defaultMessage;
-    this._parameters = parameters;
-    this._useClientsideValidation = useClientsideValidation;
-  }
-
-  /**
-   * Retreive type of constraint
-   */
-  get id(): string {
-    return this._id;
-  }
-
-  /**
-   */
-  get defaultMessage(): string {
-    return this._defaultMessage || "Missing default message";
-  }
-
-  /**
-   * Returns available data for constraint
-   */
-  get parameters(): ?Object {
-    return this._parameters;
-  }
-
-  /**
-   * Inidicates if validation message is present
-   */
-  hasValidation(): boolean {
-    return this._validateMethod != null;
-  }
-
-  /**
-   * Validate constraint with value
-   */
-  validate(value: any): boolean {
-    const validateMethod = this._validateMethod;
-
-    if (this._useClientsideValidation && validateMethod) {
-      return validateMethod(value);
-    }
-
-    return true;
-  }
-
-  /**
-   */
-  get isMandatoryConstraint(): boolean {
-    return this._id === "mandatory" || this._id === "Constraint.Mandatory";
-  }
-}