@beinformed/ui 1.27.5 → 1.28.0

package/src/models/attributes/ChoiceAttributeOptionModel.js

@@ -66,8 +66,8 @@ class ChoiceAttributeOptionModel
     const option = new ChoiceAttributeOptionModel();
 
     option.code = listitem.id.toString();
-    option.attributeCollection = listitem.attributeCollection;
-    option.links = listitem.links;
+    option.attributeCollection = listitem.attributeCollection.clone();
+    option.links = listitem.links.clone();
 
     return option;
   }

package/src/models/attributes/DatetimeAttributeModel.js

@@ -17,14 +17,9 @@ import DatetimeFormatConstraint from "./input-constraints/DatetimeFormatConstrai
 import DateBoundaryConstraint from "./input-constraints/DateBoundaryConstraint";
 
 import { ATTRIBUTE_WIDTH, ISO_DATE_FORMAT } from "../../constants";
-import { getSetting } from "../../constants/Settings";
-import { IGNORE_FORMAT_SETTING } from "../../constants/LayoutHints";
 
 import type { FormErrorAnchor, IConstraintModel } from "../types";
 
-// date format of default
-const PRODUCT_DEFAULT_DATE_FORMAT = "dd-MM-yyyy";
-
 /**
  */
 class DatetimeAttributeModel extends StringAttributeModel {
@@ -239,22 +234,9 @@ class DatetimeAttributeModel extends StringAttributeModel {
       return "";
     }
 
-    // setting for date input
-    const ignoreFormatSetting = this.layouthint.has(IGNORE_FORMAT_SETTING);
-    if (!ignoreFormatSetting) {
-      const dateInputFormatSetting = getSetting("DATE_INPUT_FORMAT", "");
-      if (dateInputFormatSetting) {
-        return dateInputFormatSetting;
-      }
-    }
-
-    let format = this.format;
-
-    let dateFormat = this.hasTime
-      ? format.replace(this.timeInputFormat, "").trim()
-      : format;
-
-    return dateFormat;
+    return this.hasTime
+      ? this.format.replace(this.timeInputFormat, "").trim()
+      : this.format;
   }
 
   /**
@@ -264,35 +246,19 @@ class DatetimeAttributeModel extends StringAttributeModel {
       return "";
     }
 
-    let format = this.format;
-
-    let dateFormat = this.hasTime
-      ? format.replace(this.timeInputFormat, "").trim()
-      : format;
-
-    const readonlyFormatSetting = getSetting("DATE_READONLY_FORMAT", "");
-
-    if (dateFormat === PRODUCT_DEFAULT_DATE_FORMAT && readonlyFormatSetting) {
-      dateFormat = readonlyFormatSetting;
-    }
-
-    return dateFormat;
+    return this.hasTime
+      ? this.format.replace(this.timeInputFormat, "").trim()
+      : this.format;
   }
 
   /**
-   * return attribute placeholder or, if DATE_INPUT_FORMAT setting is used, lowercased setting, otherwise return formatlabel without time input format from contributions
+   * return attribute placeholder or return formatlabel without time input format from contributions
    */
   get placeholder(): string {
     if (this._placeholder !== "") {
       return this._placeholder;
     }
 
-    const dateInputFormatSetting = getSetting("DATE_INPUT_FORMAT", "");
-
-    if (dateInputFormatSetting) {
-      return dateInputFormatSetting.toLowerCase();
-    }
-
     const formatLabel = this.getContribution("formatlabel", "");
 
     if (this.hasDate && this.hasTime && formatLabel.includes(" ")) {

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

@@ -1,12 +1,7 @@
 import DatetimeAttributeModel from "../DatetimeAttributeModel";
-import { setSettings } from "../../../constants/Settings";
 
 describe("dateAttributeModel", () => {
   describe("with date related settings set", () => {
-    beforeAll(() => {
-      setSettings({ DATE_INPUT_FORMAT: "dd-MM-yyyy" });
-      setSettings({ DATE_READONLY_FORMAT: "dd-MM-yyyy" });
-    });
     it("should be able to create an empty Attribute object", () => {
       const attribute = new DatetimeAttributeModel();
 
@@ -51,7 +46,7 @@ describe("dateAttributeModel", () => {
 
     it("can set input", () => {
       const attribute = new DatetimeAttributeModel({});
-      attribute.inputvalue = "10-12-2010";
+      attribute.inputvalue = "2010-12-10";
 
       expect(attribute.readonlyvalue).toBe("2010-12-10");
 
@@ -65,36 +60,7 @@ describe("dateAttributeModel", () => {
     });
   });
 
-  describe("with non default date related settings configured", () => {
-    beforeAll(() => {
-      setSettings({ DATE_INPUT_FORMAT: "MM/dd/yyyy" });
-      setSettings({ DATE_READONLY_FORMAT: "mm/dd/yyyy" });
-    });
-
-    it("returns the right date formats", () => {
-      const attribute = new DatetimeAttributeModel(
-        {},
-        {
-          label: "Date of birth",
-          type: "date",
-          format: "dd-MM-yyyy",
-          formatlabel: "dd-mm-yyyy",
-        }
-      );
-
-      // expect date input and readonly format to match the settings
-      expect(attribute.format).toBe("dd-MM-yyyy");
-      expect(attribute.dateInputFormat).toBe("MM/dd/yyyy");
-      expect(attribute.dateReadonlyFormat).toBe("mm/dd/yyyy");
-    });
-  });
-
   describe("without date input and date readonly settings defined", () => {
-    beforeAll(() => {
-      // explicitly clear setting
-      setSettings({ DATE_INPUT_FORMAT: "" });
-      setSettings({ DATE_READONLY_FORMAT: "" });
-    });
     it("should be able to return contributions format as date input format", () => {
       const attribute = new DatetimeAttributeModel(
         {},

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

@@ -1,226 +1,168 @@
 import DatetimeAttributeModel from "../DatetimeAttributeModel";
-import { setSettings } from "../../../constants/Settings";
 import { ATTRIBUTE_WIDTH } from "../../../constants";
 
 describe("datetimeAttributeModel", () => {
-  describe("with date readonly format in product default format", () => {
-    beforeAll(() => {
-      // using product default format
-      setSettings({ DATE_READONLY_FORMAT: "dd-MM-yyyy" });
-      setSettings({ DATE_INPUT_FORMAT: "dd-MM-yyyy" });
-    });
-
-    it("should be able to create an empty DatetimeAttribute object", () => {
-      const attribute = new DatetimeAttributeModel({}, { type: "datetime" });
-
-      expect(attribute).toBeInstanceOf(DatetimeAttributeModel);
-
-      expect(attribute.type).toBe("datetime");
-      expect(attribute.format).toBe("yyyy-MM-dd'T'HH:mm:ss");
-      expect(attribute.getInputValue()).toBe("");
-      expect(attribute.inputvalue).toBe("");
-      expect(attribute.readonlyvalue).toBe("");
-
-      attribute.addConstraints();
-      expect(attribute.constraintCollection).toHaveLength(1);
-    });
-
-    it("should be able to update", () => {
-      const attribute = new DatetimeAttributeModel(
-        {},
-        {
-          type: "datetime",
-          format: "dd-MM-yyyy HH:mm",
-        }
-      );
-
-      attribute.update("18-08-2016 13:45");
-      expect(attribute.getInputValue()).toBe("18-08-2016 13:45");
-      expect(attribute.getInitialInputValue("2016-08-18T13:45:23")).toBe(
-        "18-08-2016 13:45"
-      );
-
-      expect(attribute.readonlyvalue).toBe("18-08-2016 13:45");
-
-      attribute.update(null);
-      expect(attribute.getInputValue()).toBe("");
-
-      attribute.update("");
-      expect(attribute.value).toBeNull();
-
-      attribute.update("aaaa");
-      expect(attribute.value).toBe("Invalid Date");
-    });
-
-    it("should be able to handle min and max date in only date format and renders in format", () => {
-      const attribute = new DatetimeAttributeModel(
-        {},
-        {
-          type: "datetime",
-          format: "dd-MM-yyyy HH:mm",
-          mindate: "2010-10-01T00:00:00",
-          maxdate: "2010-10-31T23:59:59",
-        }
-      );
-
-      attribute.update("18-08-2016 13:45");
-
-      expect(attribute.isValid).toBe(false);
-      expect(attribute.formatValue(attribute.mindate)).toBe("01-10-2010 00:00");
-      expect(attribute.formatValue(attribute.maxdate)).toBe("31-10-2010 23:59");
-    });
+  it("should be able to create an empty DatetimeAttribute object", () => {
+    const attribute = new DatetimeAttributeModel({}, { type: "datetime" });
+
+    expect(attribute).toBeInstanceOf(DatetimeAttributeModel);
+
+    expect(attribute.type).toBe("datetime");
+    expect(attribute.format).toBe("yyyy-MM-dd'T'HH:mm:ss");
+    expect(attribute.getInputValue()).toBe("");
+    expect(attribute.inputvalue).toBe("");
+    expect(attribute.readonlyvalue).toBe("");
+
+    attribute.addConstraints();
+    expect(attribute.constraintCollection).toHaveLength(1);
   });
 
-  describe("with customized readonly format for dates", () => {
-    beforeAll(() => {
-      // readonly format in non product default format
-      setSettings({ DATE_READONLY_FORMAT: "MM-dd-yyyy" });
-    });
-
-    it("should show datetime readonly value in custom date format", () => {
-      const attribute = new DatetimeAttributeModel(
-        {},
-        {
-          type: "datetime",
-          format: "dd-MM-yyyy HH:mm",
-        }
-      );
-
-      attribute.update("18-08-2016 13:45");
-      expect(attribute.readonlyvalue).toBe("08-18-2016 13:45");
-    });
-
-    it("should show date only value according in custom date format", () => {
-      const attribute = new DatetimeAttributeModel(
-        { value: "2017-07-29" },
-        {
-          type: "date",
-          format: "dd-MM-yyyy",
-        }
-      );
-
-      expect(attribute.readonlyvalue).toBe("07-29-2017");
-    });
-
-    it("should show custom format with am/pm in custom date format", () => {
-      const attribute = new DatetimeAttributeModel(
-        { value: "2031-12-21T17:41:21" },
-        { type: "datetime", format: "dd-MM-yyyy hh:mm:ss a" }
-      );
-
-      expect(attribute.readonlyvalue).toBe("12-21-2031 05:41:21 PM");
-    });
-
-    it("should return AttributeWidth for dates", () => {
-      const attribute = new DatetimeAttributeModel(
-        {},
-        {
-          type: "date",
-        }
-      );
-      expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.SMALL);
-    });
-
-    it("should return AttributeWidth for times", () => {
-      const attribute = new DatetimeAttributeModel(
-        {},
-        {
-          type: "time",
-        }
-      );
-      expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.SMALL);
-    });
-
-    it("should return AttributeWidth for datetime", () => {
-      const attribute = new DatetimeAttributeModel(
-        {},
-        {
-          type: "datetime",
-        }
-      );
-      expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.MEDIUM);
-    });
-
-    it("can validate datetime with datetime format", () => {
-      const datetimeFormat = new DatetimeAttributeModel(
-        {},
-        {
-          type: "datetime",
-          format: "dd-MM-yyyy HH:mm",
-        }
-      );
-
-      expect(datetimeFormat.validate("19-10-2010 1:45")).toBe(true);
-      expect(datetimeFormat.validate("19-10-2010 13:45")).toBe(true);
-
-      expect(datetimeFormat.validate("19-10-2010")).toBe(false);
-      expect(datetimeFormat.validate("13:45")).toBe(false);
-      expect(datetimeFormat.validate("19-10-2010 1:45 am")).toBe(false);
-    });
-
-    it("can validate datetime with only date format", () => {
-      const dateFormat = new DatetimeAttributeModel(
-        {},
-        {
-          type: "datetime",
-          format: "dd-MM-yyyy",
-        }
-      );
-
-      expect(dateFormat.validate("19-10-2010")).toBe(true);
-
-      expect(dateFormat.validate("19-10-2010 1:45")).toBe(false);
-      expect(dateFormat.validate("13:45")).toBe(false);
-      expect(dateFormat.validate("19-10-2010 1:45 am")).toBe(false);
-    });
-
-    it("can validate datetime with datetime am/pm format", () => {
-      const datetimeAmPmFormat = new DatetimeAttributeModel(
-        {},
-        {
-          type: "datetime",
-          format: "dd-MM-yyyy hh:mm a",
-        }
-      );
-
-      expect(datetimeAmPmFormat.validate("19-10-2010 1:45 am")).toBe(true);
-      expect(datetimeAmPmFormat.validate("19-10-2010 1:45 pm")).toBe(true);
-
-      expect(datetimeAmPmFormat.validate("19-10-2010 1:45")).toBe(false);
-      expect(datetimeAmPmFormat.validate("19-10-2010 13:45")).toBe(false);
-    });
-
-    it("can handle old datetime format with ms", () => {
-      const attribute = new DatetimeAttributeModel(
-        { value: "2031-12-21T17:41:21.000" },
-        {
-          type: "datetime",
-          format: "dd-MM-yyyy HH:mm",
-        }
-      );
-
-      expect(attribute.readonlyvalue).toBe("12-21-2031 17:41");
-    });
+  it("should be able to update", () => {
+    const attribute = new DatetimeAttributeModel(
+      {},
+      {
+        type: "datetime",
+        format: "dd-MM-yyyy HH:mm",
+      }
+    );
+
+    attribute.update("18-08-2016 13:45");
+    expect(attribute.getInputValue()).toBe("18-08-2016 13:45");
+    expect(attribute.getInitialInputValue("2016-08-18T13:45:23")).toBe(
+      "18-08-2016 13:45"
+    );
+
+    expect(attribute.readonlyvalue).toBe("18-08-2016 13:45");
+
+    attribute.update(null);
+    expect(attribute.getInputValue()).toBe("");
+
+    attribute.update("");
+    expect(attribute.value).toBeNull();
+
+    attribute.update("aaaa");
+    expect(attribute.value).toBe("Invalid Date");
+  });
+
+  it("should be able to handle min and max date in only date format and renders in format", () => {
+    const attribute = new DatetimeAttributeModel(
+      {},
+      {
+        type: "datetime",
+        format: "dd-MM-yyyy HH:mm",
+        mindate: "2010-10-01T00:00:00",
+        maxdate: "2010-10-31T23:59:59",
+      }
+    );
+
+    attribute.update("18-08-2016 13:45");
+
+    expect(attribute.isValid).toBe(false);
+    expect(attribute.formatValue(attribute.mindate)).toBe("01-10-2010 00:00");
+    expect(attribute.formatValue(attribute.maxdate)).toBe("31-10-2010 23:59");
+  });
+
+  it("should return AttributeWidth for dates", () => {
+    const attribute = new DatetimeAttributeModel(
+      {},
+      {
+        type: "date",
+      }
+    );
+    expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.SMALL);
+  });
+
+  it("should return AttributeWidth for times", () => {
+    const attribute = new DatetimeAttributeModel(
+      {},
+      {
+        type: "time",
+      }
+    );
+    expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.SMALL);
+  });
+
+  it("should return AttributeWidth for datetime", () => {
+    const attribute = new DatetimeAttributeModel(
+      {},
+      {
+        type: "datetime",
+      }
+    );
+    expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.MEDIUM);
+  });
+
+  it("can validate datetime with datetime format", () => {
+    const datetimeFormat = new DatetimeAttributeModel(
+      {},
+      {
+        type: "datetime",
+        format: "dd-MM-yyyy HH:mm",
+      }
+    );
+
+    expect(datetimeFormat.validate("19-10-2010 1:45")).toBe(true);
+    expect(datetimeFormat.validate("19-10-2010 13:45")).toBe(true);
+
+    expect(datetimeFormat.validate("19-10-2010")).toBe(false);
+    expect(datetimeFormat.validate("13:45")).toBe(false);
+    expect(datetimeFormat.validate("19-10-2010 1:45 am")).toBe(false);
+  });
+
+  it("can validate datetime with only date format", () => {
+    const dateFormat = new DatetimeAttributeModel(
+      {},
+      {
+        type: "datetime",
+        format: "dd-MM-yyyy",
+      }
+    );
+
+    expect(dateFormat.validate("19-10-2010")).toBe(true);
+
+    expect(dateFormat.validate("19-10-2010 1:45")).toBe(false);
+    expect(dateFormat.validate("13:45")).toBe(false);
+    expect(dateFormat.validate("19-10-2010 1:45 am")).toBe(false);
+  });
+
+  it("can validate datetime with datetime am/pm format", () => {
+    const datetimeAmPmFormat = new DatetimeAttributeModel(
+      {},
+      {
+        type: "datetime",
+        format: "dd-MM-yyyy hh:mm a",
+      }
+    );
+
+    expect(datetimeAmPmFormat.validate("19-10-2010 1:45 am")).toBe(true);
+    expect(datetimeAmPmFormat.validate("19-10-2010 1:45 pm")).toBe(true);
+
+    expect(datetimeAmPmFormat.validate("19-10-2010 1:45")).toBe(false);
+    expect(datetimeAmPmFormat.validate("19-10-2010 13:45")).toBe(false);
+  });
+
+  it("can handle old datetime format with ms", () => {
+    const attribute = new DatetimeAttributeModel(
+      { value: "2031-12-21T17:41:21.000" },
+      {
+        type: "datetime",
+        format: "dd-MM-yyyy HH:mm",
+      }
+    );
+
+    expect(attribute.readonlyvalue).toBe("21-12-2031 17:41");
   });
 
-  describe("without date input and date readonly settings defined", () => {
-    beforeAll(() => {
-      // explicitly clear setting
-      setSettings({ DATE_INPUT_FORMAT: "" });
-      setSettings({ DATE_READONLY_FORMAT: "" });
-    });
-
-    it("returns date part of formatlabel as placeholder if attribute has date and time", () => {
-      const attribute = new DatetimeAttributeModel(
-        {},
-        {
-          type: "datetime",
-          format: "dd-MM-yyyy HH:mm",
-          formatlabel: "dd-MM-yyyy HH:mm",
-        }
-      );
-
-      expect(attribute.placeholder).toBe("dd-MM-yyyy");
-    });
+  it("returns date part of formatlabel as placeholder if attribute has date and time", () => {
+    const attribute = new DatetimeAttributeModel(
+      {},
+      {
+        type: "datetime",
+        format: "dd-MM-yyyy HH:mm",
+        formatlabel: "dd-MM-yyyy HH:mm",
+      }
+    );
+
+    expect(attribute.placeholder).toBe("dd-MM-yyyy");
   });
 });

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

@@ -1,10 +1,5 @@
 import DatetimeAttributeModel from "../DatetimeAttributeModel";
-import { setSettings } from "../../../constants/Settings";
-
 describe("timestampAttributeModel", () => {
-  beforeAll(() => {
-    setSettings({ DATE_INPUT_FORMAT: "dd-MM-yyyy" });
-  });
   it("should be able to create an empty TimestampAttribute object", () => {
     const attribute = new DatetimeAttributeModel({}, { type: "timestamp" });
 

package/src/react-client/Init.js

@@ -14,7 +14,7 @@ import type { Props as FallbackProps } from "../react/ErrorBoundaryFallback";
 
 export type Props = {
   +store: ReduxStore,
-  +history: RouterHistory,
+  +routerHistory: RouterHistory,
   +contextPath: string,
   +theme?: Theme | Array<Theme>,
   +children: ?Node,
@@ -25,7 +25,7 @@ export type Props = {
  */
 const Init = ({
   store,
-  history,
+  routerHistory,
   contextPath,
   theme,
   children,
@@ -35,7 +35,7 @@ const Init = ({
     <ThemeProvider theme={theme}>
       <HelmetProvider>
         <ErrorBoundary FallbackComponent={ErrorFallbackComponent}>
-          <Router history={history} basename={contextPath}>
+          <Router history={routerHistory} basename={contextPath}>
             {children}
           </Router>
         </ErrorBoundary>