@beinformed/ui 1.65.12 → 1.65.14

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

@@ -1,44 +0,0 @@
-// @flow
-import type { IConstraintModel } from "../../types";
-
-/**
- */
-class PasswordLowerAndUpperCaseConstraint implements IConstraintModel {
-  /**
-   */
-  get id(): string {
-    return "Constraint.Password.LowerAndUpperCaseMandatory";
-  }
-
-  /**
-   */
-  hasValidation(): boolean {
-    return true;
-  }
-
-  /**
-   */
-  get defaultMessage(): string {
-    return "Must contain both upper and lowercase characters";
-  }
-
-  /**
-   */
-  get parameters(): { ... } {
-    return {};
-  }
-
-  /**
-   */
-  validate(value: string): boolean {
-    return /[a-z]/u.test(value) && /[A-Z]/u.test(value);
-  }
-
-  /**
-   */
-  get isMandatoryConstraint(): boolean {
-    return false;
-  }
-}
-
-export default PasswordLowerAndUpperCaseConstraint;

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

@@ -1,60 +0,0 @@
-// @flow
-import type { IConstraintModel } from "../../types";
-
-/**
- */
-class PasswordMinNumericCharactersConstraint implements IConstraintModel {
-  _minNumeric: number;
-
-  /**
-   */
-  constructor(minNumeric: number) {
-    this._minNumeric = minNumeric;
-  }
-
-  /**
-   */
-  get id(): string {
-    return "Constraint.Password.MinNumericCharactersMandatory";
-  }
-
-  /**
-   */
-  get minNumeric(): number {
-    return this._minNumeric;
-  }
-
-  /**
-   */
-  hasValidation(): boolean {
-    return true;
-  }
-
-  /**
-   */
-  get defaultMessage(): string {
-    return "Must contain ${min-numeric} or more numerical characters"; // NOSONAR
-  }
-
-  /**
-   */
-  get parameters(): { "min-numeric": number } {
-    return {
-      "min-numeric": this.minNumeric,
-    };
-  }
-
-  /**
-   */
-  validate(value: string): boolean {
-    return value.replace(/\D/gu, "").length >= this.minNumeric;
-  }
-
-  /**
-   */
-  get isMandatoryConstraint(): boolean {
-    return false;
-  }
-}
-
-export default PasswordMinNumericCharactersConstraint;

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

@@ -1,60 +0,0 @@
-// @flow
-import type { IConstraintModel } from "../../types";
-
-/**
- */
-class PasswordMinSpecialCharactersConstraint implements IConstraintModel {
-  _minSpecial: number;
-
-  /**
-   */
-  constructor(minSpecial: number) {
-    this._minSpecial = minSpecial;
-  }
-
-  /**
-   */
-  get id(): string {
-    return "Constraint.Password.MinSpecialCharactersMandatory";
-  }
-
-  /**
-   */
-  get minSpecial(): number {
-    return this._minSpecial;
-  }
-
-  /**
-   */
-  hasValidation(): boolean {
-    return true;
-  }
-
-  /**
-   */
-  get defaultMessage(): string {
-    return "Must contain ${min-special} or more special characters"; // NOSONAR
-  }
-
-  /**
-   */
-  get parameters(): { "min-special": number } {
-    return {
-      "min-special": this.minSpecial,
-    };
-  }
-
-  /**
-   */
-  validate(value: string): boolean {
-    return value.replace(/[\da-z]/giu, "").length >= this.minSpecial;
-  }
-
-  /**
-   */
-  get isMandatoryConstraint(): boolean {
-    return false;
-  }
-}
-
-export default PasswordMinSpecialCharactersConstraint;

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

@@ -1,72 +0,0 @@
-// @flow
-import type { IConstraintModel } from "../../types";
-
-/**
- */
-class PasswordThreeConsecutiveCharactersNotAllowedConstraint implements IConstraintModel {
-  _maxSequence: number;
-
-  /**
-   */
-  constructor(maxSequence: number = 2) {
-    this._maxSequence = maxSequence;
-  }
-
-  /**
-   */
-  get id(): string {
-    return "Constraint.Password.ThreeConsecutiveCharactersNotAllowed";
-  }
-
-  /**
-   */
-  get maxSequence(): number {
-    return this._maxSequence;
-  }
-
-  /**
-   */
-  hasValidation(): boolean {
-    return true;
-  }
-
-  /**
-   */
-  get defaultMessage(): string {
-    return "Must not contain any character more than twice consecutively";
-  }
-
-  /**
-   */
-  get parameters(): { "max-sequence": number } {
-    return {
-      "max-sequence": this.maxSequence,
-    };
-  }
-
-  /**
-   */
-  hasNoSequenceOfIdenticalCharacters(value: string): boolean {
-    return !value
-      .split("")
-      .filter((char, i) => value.indexOf(char) === i)
-      .some((char) => {
-        const sequence = char.repeat(this.maxSequence + 1);
-        return value.includes(sequence);
-      });
-  }
-
-  /**
-   */
-  validate(value: string): boolean {
-    return this.hasNoSequenceOfIdenticalCharacters(value);
-  }
-
-  /**
-   */
-  get isMandatoryConstraint(): boolean {
-    return false;
-  }
-}
-
-export default PasswordThreeConsecutiveCharactersNotAllowedConstraint;

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

@@ -1,161 +0,0 @@
-// @flow
-import {
-  DateUtil,
-  DateTimeUtil,
-  TimestampUtil,
-  TimeUtil,
-} from "../../../utils/datetime/DateTimeUtil";
-
-import type { AttributeType } from "../../types";
-import type { IConstraintModel } from "../../types";
-
-/**
- */
-class RangeConstraint implements IConstraintModel {
-  _start: AttributeType;
-  _end: AttributeType;
-
-  /**
-   */
-  constructor(startAttribute: AttributeType, endAttribute: AttributeType) {
-    this._start = startAttribute;
-    this._end = endAttribute;
-  }
-
-  /**
-   */
-  get id(): string {
-    const id = this.hasInclusiveBounds
-      ? "InvalidRangeInclusive"
-      : "InvalidRange";
-
-    switch (this.rangeType) {
-      case "time":
-        return `Constraint.TimeRange.${id}`;
-      case "date":
-        return `Constraint.DateRange.${id}`;
-      case "datetime":
-        return `Constraint.DateTimeRange.${id}`;
-      case "timestamp":
-        return `Constraint.TimeStampRange.${id}`;
-      default:
-        return `Constraint.NumberRange.${id}`;
-    }
-  }
-
-  /**
-   */
-  get defaultMessage(): string {
-    const inclusivePart = this.hasInclusiveBounds ? " or equal to the" : "";
-
-    switch (this.rangeType) {
-      case "time":
-        return `Start time must be before${inclusivePart} end time`;
-      case "date":
-        return `Start date must be before${inclusivePart} end date`;
-      case "datetime":
-        return `Start value must be before${inclusivePart} end value`;
-      case "timestamp":
-        return `Start value must be before${inclusivePart} end value`;
-      default:
-        return `Start value must be less than${inclusivePart} the end value`;
-    }
-  }
-
-  /**
-   */
-  hasValidation(): boolean {
-    return true;
-  }
-
-  /**
-   */
-  get parameters(): { ... } {
-    return {};
-  }
-
-  /**
-   */
-  get start(): AttributeType {
-    return this._start;
-  }
-
-  /**
-   */
-  get end(): AttributeType {
-    return this._end;
-  }
-
-  /**
-   */
-  get rangeType(): string {
-    return this.start.type;
-  }
-
-  /**
-   */
-  get hasInclusiveBounds(): boolean {
-    return (
-      this.start.operator === "greaterThanOrEqualTo" &&
-      this.end.operator === "lessThanOrEqualTo"
-    );
-  }
-
-  /**
-   */
-  get util():
-    | typeof TimeUtil
-    | typeof DateUtil
-    | typeof DateTimeUtil
-    | typeof TimestampUtil
-    | null {
-    switch (this.rangeType) {
-      case "time":
-        return TimeUtil;
-      case "date":
-        return DateUtil;
-      case "datetime":
-        return DateTimeUtil;
-      case "timestamp":
-        return TimestampUtil;
-      default:
-        return null;
-    }
-  }
-
-  /**
-   */
-  doValidate(startValue: string, endValue: string): boolean {
-    if (this.hasInclusiveBounds) {
-      if (!this.util) {
-        return startValue <= endValue;
-      }
-      return this.util.isSameOrBefore(startValue, endValue);
-    }
-
-    if (!this.util) {
-      return startValue < endValue;
-    }
-
-    return this.util.isBefore(startValue, endValue);
-  }
-
-  /**
-   */
-  validate(): boolean {
-    // only validate range when both attributes are valid
-    if (this.start.inError() || this.end.inError()) {
-      return true;
-    }
-
-    return this.doValidate(this.start.value, this.end.value);
-  }
-
-  /**
-   */
-  get isMandatoryConstraint(): boolean {
-    return false;
-  }
-}
-
-export default RangeConstraint;

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

@@ -1,72 +0,0 @@
-// @flow
-import type { IConstraintModel } from "../../types";
-
-export type RegexObject = {
-  messageKey: string,
-  defaultMessage: string | null,
-  regex: string | RegExp,
-};
-
-/**
- */
-class RegexConstraint implements IConstraintModel {
-  _regexConstraint: Object;
-
-  /**
-   */
-  constructor(regexConstraint: RegexObject) {
-    this._regexConstraint = regexConstraint;
-  }
-
-  /**
-   */
-  get id(): any {
-    return this.regexConstraint.messageKey;
-  }
-
-  /**
-   */
-  get regexConstraint(): any {
-    return this._regexConstraint;
-  }
-
-  /**
-   */
-  hasValidation(): boolean {
-    return true;
-  }
-
-  /**
-   */
-  get defaultMessage(): any {
-    return (
-      this.regexConstraint.defaultMessage || this.regexConstraint.messageKey
-    );
-  }
-
-  /**
-   */
-  get parameters(): { regex: any } {
-    return {
-      regex: this.regexConstraint.regex,
-    };
-  }
-
-  /**
-   */
-  validate(value: string): boolean {
-    if (this.regexConstraint.regex instanceof RegExp) {
-      return this.regexConstraint.regex.test(value);
-    }
-
-    return new RegExp(this.regexConstraint.regex).test(value);
-  }
-
-  /**
-   */
-  get isMandatoryConstraint(): boolean {
-    return false;
-  }
-}
-
-export default RegexConstraint;

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

@@ -1,179 +0,0 @@
-// @flow
-import type { IConstraintModel } from "../../types";
-
-const INVALID_LENGTH_ID = "Constraint.InvalidLengthExact";
-const INVALID_LENGTH_BETWEEN_ID = "Constraint.InvalidLengthBetween";
-const INVALID_LENGTH_TOO_SHORT_ID = "Constraint.InvalidLengthTooShort";
-const INVALID_LENGTH_TOO_LONG_ID = "Constraint.InvalidLengthTooLong";
-
-/**
- */
-class StringLengthConstraint implements IConstraintModel {
-  _minLength: number | null;
-  _maxLength: number | null;
-
-  /**
-   */
-  constructor(minLength: number | null, maxLength: number | null) {
-    this._minLength = minLength;
-    this._maxLength = maxLength;
-  }
-
-  /**
-   */
-  get id(): string {
-    if (this.minLength && this.maxLength && this.minLength === this.maxLength) {
-      return INVALID_LENGTH_ID;
-    } else if (this.minLength && this.maxLength) {
-      return INVALID_LENGTH_BETWEEN_ID;
-    } else if (this.minLength) {
-      return INVALID_LENGTH_TOO_SHORT_ID;
-    } else if (this.maxLength) {
-      return INVALID_LENGTH_TOO_LONG_ID;
-    }
-
-    return "Constraint.NoLengthConstraint";
-  }
-
-  /**
-   */
-  get minLength(): null | number {
-    return this._minLength;
-  }
-
-  /**
-   */
-  get maxLength(): null | number {
-    return this._maxLength;
-  }
-
-  /**
-   */
-  hasValidation(): boolean {
-    return true;
-  }
-
-  /**
-   */
-  isExactLength(value: string): boolean {
-    if (typeof value !== "string") {
-      throw new TypeError("isExactLength: Not comparing to string");
-    }
-
-    if (this.minLength === null) {
-      throw new Error("isExactLength: Min and max length not set");
-    }
-
-    return value.length === this.minLength;
-  }
-
-  /**
-   */
-  isBetween(value: string): boolean {
-    if (typeof value !== "string") {
-      throw new TypeError("isBetween: Not comparing to string");
-    }
-
-    if (this.minLength === null || this.maxLength === null) {
-      throw new Error("isBetween: Min or max length not set");
-    }
-
-    return this.isLongEnough(value) && this.isSmallEnough(value);
-  }
-
-  /**
-   */
-  isLongEnough(value: string): boolean {
-    if (typeof value !== "string") {
-      throw new TypeError("isLongEnough: Not comparing to string");
-    }
-
-    if (this.minLength === null) {
-      throw new Error("isLongEnough: Min length not set");
-    }
-
-    return value.length >= this.minLength;
-  }
-
-  /**
-   */
-  isSmallEnough(value: string): boolean {
-    if (typeof value !== "string") {
-      throw new TypeError("isSmallEnough: Not comparing to string");
-    }
-
-    if (this.maxLength === null) {
-      throw new Error("isSmallEnough: Max length not set");
-    }
-
-    return value.length <= this.maxLength;
-  }
-
-  /**
-   */
-  get defaultMessage(): string {
-    switch (this.id) {
-      case INVALID_LENGTH_ID:
-        return "Length must be precisely ${length} characters"; // NOSONAR
-      case INVALID_LENGTH_BETWEEN_ID:
-        return "Length must be between ${min-length} and ${max-length} characters"; // NOSONAR
-      case INVALID_LENGTH_TOO_SHORT_ID:
-        return "The length of the value  must be larger than ${min-length}"; // NOSONAR
-      case INVALID_LENGTH_TOO_LONG_ID:
-        return "The length of the value must be smaller than ${max-length}"; // NOSONAR
-      default:
-        return "";
-    }
-  }
-
-  /**
-   */
-  get parameters(): { ... } {
-    switch (this.id) {
-      case INVALID_LENGTH_ID:
-        return {
-          length: this.minLength,
-        };
-      case INVALID_LENGTH_BETWEEN_ID:
-        return {
-          "min-length": this.minLength,
-          "max-length": this.maxLength,
-        };
-      case INVALID_LENGTH_TOO_SHORT_ID:
-        return {
-          "min-length": this.minLength,
-        };
-      case INVALID_LENGTH_TOO_LONG_ID:
-        return {
-          "max-length": this.maxLength,
-        };
-      default:
-        return {};
-    }
-  }
-
-  /**
-   */
-  validate(value: string): boolean {
-    switch (this.id) {
-      case INVALID_LENGTH_ID:
-        return this.isExactLength(value);
-      case INVALID_LENGTH_BETWEEN_ID:
-        return this.isBetween(value);
-      case INVALID_LENGTH_TOO_SHORT_ID:
-        return this.isLongEnough(value);
-      case INVALID_LENGTH_TOO_LONG_ID:
-        return this.isSmallEnough(value);
-      default:
-        return true;
-    }
-  }
-
-  /**
-   */
-  get isMandatoryConstraint(): boolean {
-    return false;
-  }
-}
-
-export default StringLengthConstraint;

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

@@ -1,62 +0,0 @@
-// @flow
-import type { IConstraintModel } from "../../types";
-
-/**
- */
-class XMLConstraint implements IConstraintModel {
-  /**
-   */
-  get id(): string {
-    return "Constraint.XML.InvalidFormat";
-  }
-
-  /**
-   */
-  hasValidation(): boolean {
-    return true;
-  }
-
-  /**
-   */
-  get defaultMessage(): string {
-    return "Must be well-formed XML";
-  }
-
-  /**
-   */
-  get parameters(): { ... } {
-    return {};
-  }
-
-  /**
-   */
-  isValidXML(value: string): boolean {
-    const oParser = new DOMParser();
-
-    try {
-      const oDom = oParser.parseFromString(value, "text/xml");
-
-      if (oDom.querySelectorAll("parsererror").length > 0) {
-        return false;
-      }
-    } catch (error) {
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   */
-  validate(value: string): boolean {
-    return this.isValidXML(value);
-  }
-
-  /**
-   */
-  get isMandatoryConstraint(): boolean {
-    return false;
-  }
-}
-
-export default XMLConstraint;