@beinformed/ui 1.65.13 → 1.65.14

package/src/models/form/__tests__/FormModel.unknown-repeat.spec.js

@@ -1,52 +0,0 @@
-import ModularUIResponse from "../../../modularui/ModularUIResponse";
-import FormModel from "../FormModel";
-
-import FormContributionsJSON from "./FormContributionsUnknownRepeat.json";
-
-describe("formModel with unknown repeats", () => {
-  it("can handle form configurations with unknown repeats", () => {
-    const firstMissingJSON = {
-      formresponse: {
-        _links: {
-          self: {
-            href: "/unit-tests/tasks/create-book-with-unknown-forehand-number-of-editions",
-          },
-          api_doc: {
-            href: "/api-docs/v3/unit-tests/tasks/create-book-with-unknown-forehand-number-of-editions",
-          },
-          contributions: {
-            href: "/contributions/unit-tests/tasks/create-book-with-unknown-forehand-number-of-editions",
-          },
-        },
-        missing: {
-          anchors: [
-            {
-              objectid: "Editions",
-              elements: [
-                { elementid: "Edition" },
-                { elementid: "PublishedIn" },
-                { elementid: "NumberOfBooks" },
-              ],
-            },
-          ],
-        },
-      },
-    };
-
-    const formData = ModularUIResponse.create({
-      data: firstMissingJSON,
-      contributions: FormContributionsJSON,
-    });
-
-    const form = new FormModel(formData);
-
-    expect(form.currentFormObject.isRepeatable).toBe(true);
-    expect(form.currentFormObject.hasFixedNrOfRepeats).toBe(false);
-
-    expect(form.isValid).toBe(true);
-    expect(form.formdata).toBe('{"objects":[]}');
-
-    form.setUseClientsideValidation(false);
-    expect(form.formdata).toBe('{"objects":[]}');
-  });
-});

package/src/models/form/__tests__/FormObjectModel.spec.js

@@ -1,180 +0,0 @@
-import FormObjectModel from "../FormObjectModel";
-import { IllegalArgumentException } from "../../../exceptions";
-
-const data = {
-  objectid: "Person",
-  elements: [
-    {
-      elementid: "Name",
-    },
-    {
-      elementid: "DateOfBirth",
-    },
-    {
-      elementid: "DateOfDeath",
-    },
-  ],
-};
-
-const contributions = {
-  repeatable: false,
-  label: "Create person",
-  text: { id: "IntroTextID", message: "This is introtext" },
-  attributes: [
-    {
-      Name: {
-        type: "string",
-        label: "Name",
-        mandatory: true,
-        displaysize: 50,
-      },
-    },
-    {
-      DateOfBirth: {
-        type: "date",
-        label: "Date of birth",
-        mandatory: false,
-        format: "dd-MM-yyyy",
-        formatlabel: "dd-mm-jjjj",
-      },
-    },
-    {
-      DateOfDeath: {
-        type: "date",
-        label: "Date of death",
-        mandatory: false,
-        format: "dd-MM-yyyy",
-        formatlabel: "dd-mm-jjjj",
-      },
-    },
-  ],
-};
-
-describe("formObjectModel", () => {
-  it("should be able to create an empty FormObjectModel object", () => {
-    const formObject = new FormObjectModel();
-
-    expect(formObject).toBeInstanceOf(FormObjectModel);
-  });
-
-  it("should be able to create an empty FormObjectModel object with static method", () => {
-    expect(() => {
-      FormObjectModel.createEmpty();
-    }).toThrow(IllegalArgumentException);
-
-    const formObject = new FormObjectModel(data, contributions);
-    const emptyFormObject = FormObjectModel.createEmpty(formObject);
-
-    expect(emptyFormObject).toBeInstanceOf(FormObjectModel);
-    expect(emptyFormObject.label).toBe(formObject.label);
-  });
-
-  it("creates a form object from data and contributions", () => {
-    const formObject = new FormObjectModel(data, contributions);
-
-    expect(formObject.key).toBe("Person");
-    expect(formObject.label).toBe("Create person");
-    expect(formObject.introText).toBe("This is introtext");
-    expect(formObject.assistent).toBeUndefined();
-
-    expect(formObject.equals(formObject)).toBe(true);
-    expect(formObject.hasAttributeByKey("Name")).toBe(true);
-
-    expect(formObject.getAttributeByKey("Name").key).toBe("Name");
-    const nameAttribute = formObject.getAttributeByKey("Name");
-
-    expect(formObject.getAttributeByAttribute(nameAttribute).key).toBe("Name");
-    expect(formObject.getElements()).toHaveLength(3);
-
-    expect(formObject.getApplicableAttributeContributions()).toHaveLength(3);
-    expect(formObject.hasEndResultConfiguration).toBe(false);
-    expect(formObject.isDynamic).toBe(false);
-    expect(formObject.hasDynamicValidations).toBe(false);
-    expect(formObject.isRepeatable).toBe(false);
-    expect(formObject.repeatIndex).toBe(1);
-    expect(formObject.maxRepeats).toBe(1);
-    expect(formObject.hasFixedNrOfRepeats).toBe(true);
-    expect(formObject.isRepeatWithUnknownTotal).toBe(false);
-    expect(formObject.isLastRepeat).toBe(true);
-    expect(formObject.repeatIndexLabel).toBeNull();
-    expect(formObject.buttonLabels).toStrictEqual({});
-    expect(formObject.attributeCollection).toHaveLength(3);
-    expect(formObject.isChangedSince(Date.now())).toBe(false);
-
-    expect(formObject.formdata).toStrictEqual({
-      DateOfBirth: null,
-      DateOfDeath: null,
-      Name: null,
-    });
-    expect(formObject.getFormData(true)).toStrictEqual({
-      DateOfBirth: null,
-      DateOfDeath: null,
-      Name: null,
-    });
-    expect(formObject.getFormData(false)).toStrictEqual({
-      DateOfBirth: null,
-      DateOfDeath: null,
-      Name: null,
-    });
-  });
-
-  it("can handle introtext formats", () => {
-    const contributions2 = {
-      repeatable: false,
-      label: "Create person",
-      attributes: [],
-    };
-
-    const data2 = {};
-
-    const formObject = new FormObjectModel(data2, {
-      ...contributions2,
-      text: { id: "IntroTextID", message: "This is new introtext" },
-    });
-    expect(formObject.introText).toBe("This is new introtext");
-
-    const formObject2 = new FormObjectModel(data2, {
-      ...contributions2,
-      introText: "This is old introtext",
-    });
-    expect(formObject2.introText).toBe("This is old introtext");
-  });
-
-  it("can handle new text contributions", () => {
-    const contributions2 = {
-      repeatable: false,
-      label: "Create person",
-      text: { id: "IntroTextID", message: "This is new text" },
-      attributes: [],
-    };
-
-    const data2 = {};
-
-    const formObject = new FormObjectModel(data2, contributions2);
-    expect(formObject.introText).toBe("This is new text");
-  });
-
-  it("can handle new text in data", () => {
-    const contributions2 = {
-      repeatable: false,
-      label: "Create person",
-      text: { id: "IntroTextID", message: "This is new text ${USER.ID}" },
-      attributes: [],
-    };
-
-    const data2 = {
-      content: {
-        text: {
-          id: "IntroTextID",
-          message: "This is new text 1",
-          properties: {
-            "USER.ID": "1",
-          },
-        },
-      },
-    };
-
-    const formObject = new FormObjectModel(data2, contributions2);
-    expect(formObject.introText).toBe("This is new text 1");
-  });
-});

package/src/models/form/__tests__/FormResultData.spec.js

@@ -1,86 +0,0 @@
-import ModularUIResponse from "../../../modularui/ModularUIResponse";
-import FormModel from "../FormModel";
-
-describe("formModel with result data", () => {
-  it("should be able to create a FormModel with result data", () => {
-    const data = ModularUIResponse.create({
-      data: {
-        formresponse: {
-          _links: {
-            self: { href: "/rebuild-db/database-actions/rebuild-db-server" },
-            api_doc: {
-              href: "/api-docs/v3/rebuild-db/database-actions/rebuild-db-server",
-            },
-            contributions: {
-              href: "/contributions/rebuild-db/database-actions/rebuild-db-server",
-            },
-          },
-          success: { redirect: "/", data: { out: { money: 10 } } },
-        },
-      },
-      contributions: {
-        RebuildDBServer: {
-          label: "Rebuild DB server",
-          resourcetype: "Form",
-          actiontype: "form",
-          objects: {
-            AttributeSet: {
-              dynamicObject: false,
-              repeatable: false,
-              dynamicValidations: false,
-              label: "Rebuild DB",
-              mandatory: false,
-              attributes: [
-                {
-                  Dummy: {
-                    type: "string",
-                    label: "Dummy (not visible)",
-                    mandatory: false,
-                    readonly: true,
-                    layouthint: ["label"],
-                  },
-                },
-              ],
-            },
-          },
-          resultdata: {
-            out: {
-              repeatable: false,
-              label: "Result data",
-              introText: {
-                id: "out.Introtext",
-                message: "<p>uit</p>",
-              },
-              attributes: [
-                {
-                  money: {
-                    type: "number",
-                    label: "Money",
-                    mandatory: false,
-                    decimalSeparator: ",",
-                    layouthint: ["money"],
-                    format: "#,##0.00",
-                    groupingSeparator: ".",
-                    currencySymbol: "€",
-                  },
-                },
-              ],
-            },
-          },
-        },
-      },
-    });
-
-    const form = new FormModel(data);
-
-    const resultData = form.getResultData();
-    expect(resultData.out.key).toBe("out");
-    expect(resultData.out.label).toBe("Result data");
-    expect(resultData.out.attributeCollection.size).toBe(1);
-    expect(resultData.out.attributeCollection.first.label).toBe("Money");
-    expect(resultData.out.attributeCollection.first.readonlyvalue).toBe(
-      "10,00",
-    );
-    expect(resultData.out.attributeCollection.first.currencySymbol).toBe("€");
-  });
-});

package/src/models/form/__tests__/FormValidation.spec.js

@@ -1,79 +0,0 @@
-import { ModularUIResponse } from "../../../modularui";
-
-import initialData from "./FormValidationDataInitial.json";
-import contributions from "./FormValidationContributions.json";
-import updateData from "./FormValidationDataUpdate1.json";
-import updateData2 from "./FormValidationDataUpdate2.json";
-
-import FormModel from "../FormModel";
-
-describe("Form validation update", () => {
-  it("should be able to update the validations of a form", () => {
-    const response = ModularUIResponse.create({
-      key: "Form",
-      data: initialData,
-      contributions: contributions,
-    });
-
-    const form = new FormModel(response);
-    const formModel = form.currentFormObject;
-
-    const validation = formModel.getAttributeByKey("Validation");
-    const compareWith = formModel.getAttributeByKey("CompareWith");
-    const optional = formModel.getAttributeByKey("ThisOneIsOptional");
-
-    expect(validation.mandatory).toBe(true);
-    expect(compareWith.mandatory).toBe(true);
-    expect(optional.mandatory).toBe(false);
-
-    const newForm = form.clone();
-    newForm.currentFormObject.updateAttribute(validation, "test");
-
-    expect(validation.mandatory).toBe(true);
-    expect(compareWith.mandatory).toBe(true);
-    expect(optional.mandatory).toBe(false);
-
-    const updateResponse = ModularUIResponse.create({
-      key: "Form",
-      data: updateData,
-      contributions: contributions,
-    });
-    const updateForm = new FormModel(updateResponse);
-
-    newForm.updateValidations(updateForm.data);
-
-    expect(
-      newForm.currentFormObject.getAttributeByKey("Validation").mandatory,
-    ).toBe(true);
-    expect(
-      newForm.currentFormObject.getAttributeByKey("CompareWith").mandatory,
-    ).toBe(true);
-    expect(
-      newForm.currentFormObject.getAttributeByKey("ThisOneIsOptional")
-        .mandatory,
-    ).toBe(false);
-
-    const newForm2 = form.clone();
-    newForm2.currentFormObject.updateAttribute(validation, "");
-
-    const update2Response = ModularUIResponse.create({
-      key: "Form",
-      data: updateData2,
-      contributions: contributions,
-    });
-    const update2Form = new FormModel(update2Response);
-
-    newForm.updateValidations(update2Form.data);
-
-    expect(
-      newForm.currentFormObject.getAttributeByKey("Validation").mandatory,
-    ).toBe(true);
-    expect(
-      newForm.currentFormObject.getAttributeByKey("CompareWith").mandatory,
-    ).toBe(true);
-    expect(
-      newForm.currentFormObject.getAttributeByKey("ThisOneIsOptional")
-        .mandatory,
-    ).toBe(false);
-  });
-});

package/src/models/form/__tests__/FormValidationContributions.json

@@ -1,45 +0,0 @@
-{
-  "ValidationMakesItOptional": {
-    "label": "Validation makes it optional",
-    "resourcetype": "Form",
-    "actiontype": "form",
-    "objects": {
-      "ValidationMakesItOptional": {
-        "dynamicObject": false,
-        "repeatable": false,
-        "dynamicValidations": true,
-        "label": "Validation makes it optional",
-        "mandatory": true,
-        "attributes": [
-          {
-            "Validation": {
-              "type": "string",
-              "label": "Validation",
-              "mandatory": true,
-              "displaysize": 50,
-              "maxLength": 255
-            }
-          },
-          {
-            "CompareWith": {
-              "type": "string",
-              "label": "Compare with",
-              "mandatory": true,
-              "displaysize": 50,
-              "maxLength": 255
-            }
-          },
-          {
-            "ThisOneIsOptional": {
-              "type": "string",
-              "label": "This one is optional",
-              "mandatory": false,
-              "displaysize": 50,
-              "maxLength": 255
-            }
-          }
-        ]
-      }
-    }
-  }
-}

package/src/models/form/__tests__/FormValidationDataInitial.json

@@ -1,33 +0,0 @@
-{
-  "formresponse": {
-    "_links": {
-      "self": {
-        "href": "/all-cases/validation-makes/validation-makes-it-optional"
-      },
-      "api_doc": {
-        "href": "/api-docs/v3/all-cases/validation-makes/validation-makes-it-optional"
-      },
-      "contributions": {
-        "href": "/contributions/all-cases/validation-makes/validation-makes-it-optional"
-      }
-    },
-    "missing": {
-      "anchors": [
-        {
-          "objectid": "ValidationMakesItOptional",
-          "elements": [
-            {
-              "elementid": "Validation"
-            },
-            {
-              "elementid": "CompareWith"
-            },
-            {
-              "elementid": "ThisOneIsOptional"
-            }
-          ]
-        }
-      ]
-    }
-  }
-}

package/src/models/form/__tests__/FormValidationDataUpdate1.json

@@ -1,25 +0,0 @@
-{
-  "formresponse": {
-    "_links": {
-      "self": {
-        "href": "/all-cases/validation-makes/validation-makes-it-optional"
-      },
-      "api_doc": {
-        "href": "/api-docs/v3/all-cases/validation-makes/validation-makes-it-optional"
-      },
-      "contributions": {
-        "href": "/contributions/all-cases/validation-makes/validation-makes-it-optional"
-      }
-    },
-    "errors": [
-      {
-        "anchor": {
-          "objectid": "ValidationMakesItOptional",
-          "elementid": "CompareWith"
-        },
-        "id": "Constraint.Mandatory",
-        "message": "Field is mandatory"
-      }
-    ]
-  }
-}

package/src/models/form/__tests__/FormValidationDataUpdate2.json

@@ -1,33 +0,0 @@
-{
-  "formresponse": {
-    "_links": {
-      "self": {
-        "href": "/all-cases/validation-makes/validation-makes-it-optional"
-      },
-      "api_doc": {
-        "href": "/api-docs/v3/all-cases/validation-makes/validation-makes-it-optional"
-      },
-      "contributions": {
-        "href": "/contributions/all-cases/validation-makes/validation-makes-it-optional"
-      }
-    },
-    "missing": {
-      "anchors": [
-        {
-          "objectid": "ValidationMakesItOptional",
-          "elementid": "Validation"
-        }
-      ]
-    },
-    "errors": [
-      {
-        "anchor": {
-          "objectid": "ValidationMakesItOptional",
-          "elementid": "CompareWith"
-        },
-        "id": "Constraint.Mandatory",
-        "message": "Field is mandatory"
-      }
-    ]
-  }
-}

package/src/models/form/__tests__/FormWithContent.spec.js

@@ -1,71 +0,0 @@
-import ModularUIResponse from "../../../modularui/ModularUIResponse";
-
-import FormWithContentData from "./FormWithContentData.json";
-import FormWithContentContributions from "./FormWithContentContributions.json";
-
-import FormModel from "../FormModel";
-
-describe("forms with content in data service", () => {
-  it("should be able to create an empty FormModel object", () => {
-    const response = ModularUIResponse.create({
-      data: FormWithContentData,
-      contributions: FormWithContentContributions,
-    });
-    const form = new FormModel(response);
-
-    expect(form.label).toBe("Beslis noodzaak onderzoek (alle elementen)");
-
-    expect(form.currentFormObject.label).toBe("Beslis noodzaak onderzoek");
-
-    const attribute = form.currentFormObject.getAttributeByKey(
-      "UitslagBlaastestType",
-    );
-
-    expect(attribute.hasContentFromData).toBe(true);
-    expect(attribute.content.fromData).toBe(true);
-
-    expect(attribute.label).toBe("Uitslag blaastest label");
-    expect(attribute.content.properties).toStrictEqual([
-      {
-        type: "MeestGekozen",
-        label: "Meest gekozen",
-        value: "Pass",
-      },
-    ]);
-    expect(attribute.content.textfragments).toStrictEqual([
-      {
-        text: "Dit is een text fragment",
-        label: "Description",
-        type: "Description",
-      },
-    ]);
-    expect(attribute.content.sections[0].body).toBe(
-      "<p>Vul hier de code in die het testapparaat op het display heeft getoond</p>",
-    );
-
-    const firstOption = attribute.options.first;
-    expect(firstOption.code).toBe("BlaastestPass");
-
-    expect(firstOption.hasContentFromData).toBe(true);
-    expect(firstOption.content.fromData).toBe(true);
-
-    expect(firstOption.label).toBe("Blaastest geslaagd");
-    expect(firstOption.content.properties).toStrictEqual([
-      {
-        type: "Gemiddelde",
-        label: "Gemiddelde",
-        value: "80%",
-      },
-    ]);
-    expect(firstOption.content.textfragments).toStrictEqual([
-      {
-        text: "Dit is een text fragment",
-        label: "Description",
-        type: "Description",
-      },
-    ]);
-    expect(firstOption.content.sections[0].body).toBe(
-      "<p>De blaastest heeft geen alcohol constateerd (versie 2017)</p>",
-    );
-  });
-});