@truedat/df 8.13.5 → 8.13.6

package/src/templates/components/templateForm/contentValidation.js

@@ -1,7 +1,183 @@
 import _ from "lodash/fp";
+import {
+  resolveRestrictions,
+  checkValuesAgainstBounds,
+} from "../../utils/dateRestrictions";
 
 const arrayAnd = (list) => _.indexOf(true)(list) >= 0;
 
+const isDateField = (field) =>
+  field.type === "date" || field.type === "datetime";
+
+const RESTRICTION_UNITS = ["days", "weeks", "months", "years"];
+const RESTRICTION_ERRORS = {
+  required: "template.field.restrictions.validation.required",
+  invalidDate: "template.field.restrictions.validation.invalid_date",
+  invalidAmount: "template.field.restrictions.validation.invalid_amount",
+  invalidUnit: "template.field.restrictions.validation.invalid_unit",
+  invalidOrder: "template.field.restrictions.validation.invalid_order",
+  invalidMode: "template.field.restrictions.validation.invalid_mode",
+};
+
+const isInteger = (value) =>
+  Number.isInteger(value) ||
+  (typeof value === "string" && /^-?\d+$/.test(value.trim()));
+
+const isValidCalendarDate = (value, allowDateTime) => {
+  if (typeof value !== "string" || !value) return false;
+  const match =
+    /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/.exec(
+      value,
+    );
+  if (!match || (!allowDateTime && match[4] !== undefined)) return false;
+
+  const [, rawYear, rawMonth, rawDay, rawHour, rawMinute, rawSecond] = match;
+  const year = Number(rawYear);
+  const month = Number(rawMonth);
+  const day = Number(rawDay);
+  const hour = rawHour === undefined ? 0 : Number(rawHour);
+  const minute = rawMinute === undefined ? 0 : Number(rawMinute);
+  const second = rawSecond === undefined ? 0 : Number(rawSecond);
+  const offset = match[7];
+  const offsetMatch = offset && /^[+-](\d{2}):?(\d{2})$/.exec(offset);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const daysInMonth = [
+    31,
+    leap ? 29 : 28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31,
+  ];
+
+  return (
+    month >= 1 &&
+    month <= 12 &&
+    day >= 1 &&
+    day <= daysInMonth[month - 1] &&
+    hour <= 23 &&
+    minute <= 59 &&
+    second <= 59 &&
+    (!offsetMatch ||
+      (Number(offsetMatch[1]) <= 23 && Number(offsetMatch[2]) <= 59))
+  );
+};
+
+const validateStaticSide = (value, fieldType) =>
+  typeof value !== "string" || !value.trim()
+    ? RESTRICTION_ERRORS.required
+    : isValidCalendarDate(value, fieldType === "datetime")
+      ? null
+      : RESTRICTION_ERRORS.invalidDate;
+
+const validateDynamicSide = (side) => ({
+  amount:
+    !side || !isInteger(side.amount) ? RESTRICTION_ERRORS.invalidAmount : null,
+  unit:
+    !side || !RESTRICTION_UNITS.includes(side.unit)
+      ? RESTRICTION_ERRORS.invalidUnit
+      : null,
+});
+
+const betweenOrderIsInvalid = (between, fieldType) => {
+  const { min, max } = resolveRestrictions({ between }, fieldType);
+  return Boolean(min && max && min > max);
+};
+
+export const validateDateRestrictions = (field) => {
+  if (!isDateField(field) || _.isEmpty(field.restrictions)) return {};
+
+  const restrictions = field.restrictions;
+  const between = restrictions.between;
+  const legacyBetween =
+    !between &&
+    (restrictions.between_start !== undefined ||
+      restrictions.between_end !== undefined);
+
+  const restrictionErrors = ["min_date", "max_date"].flatMap((key) => {
+    const side = restrictions[key];
+    if (!side) return [];
+
+    if (side.mode === "dynamic") {
+      const sideErrors = validateDynamicSide(side);
+      return [
+        [`${key}.amount`, sideErrors.amount],
+        [`${key}.unit`, sideErrors.unit],
+      ];
+    }
+
+    return side.mode === "static"
+      ? [[`${key}.value`, validateStaticSide(side.value, field.type)]]
+      : [["mode", RESTRICTION_ERRORS.invalidMode]];
+  });
+
+  const betweenErrors =
+    between?.mode === "dynamic"
+      ? (() => {
+          const fromErrors = validateDynamicSide(between.from);
+          const toErrors = validateDynamicSide(between.to);
+          const hasInvalidSides =
+            Object.values(fromErrors).some(Boolean) ||
+            Object.values(toErrors).some(Boolean);
+          const orderError =
+            !hasInvalidSides && betweenOrderIsInvalid(between, field.type)
+              ? RESTRICTION_ERRORS.invalidOrder
+              : null;
+
+          return [
+            ["between.from.amount", fromErrors.amount],
+            ["between.from.unit", fromErrors.unit],
+            ["between.to.amount", toErrors.amount],
+            ["between.to.unit", toErrors.unit],
+            ["between.to.amount", orderError],
+          ];
+        })()
+      : between?.mode === "static" || legacyBetween
+        ? (() => {
+            const start = legacyBetween
+              ? restrictions.between_start
+              : between.start;
+            const end = legacyBetween ? restrictions.between_end : between.end;
+            const startError = validateStaticSide(start, field.type);
+            const endError = validateStaticSide(end, field.type);
+            const orderError =
+              !startError &&
+              !endError &&
+              betweenOrderIsInvalid({ mode: "static", start, end }, field.type)
+                ? RESTRICTION_ERRORS.invalidOrder
+                : null;
+
+            return [
+              ["between.start", startError],
+              ["between.end", endError || orderError],
+            ];
+          })()
+        : between
+          ? [["mode", RESTRICTION_ERRORS.invalidMode]]
+          : [];
+
+  return Object.fromEntries(
+    [...restrictionErrors, ...betweenErrors].filter(([, error]) => error),
+  );
+};
+
+export const defaultValueOutOfRange = (field) => {
+  if (!isDateField(field)) return false;
+  if (_.isEmpty(field.restrictions)) return false;
+
+  const value = _.pathOr(null, ["default", "value"])(field);
+  if (value === null || value === undefined || value === "") return false;
+
+  const { min, max } = resolveRestrictions(field.restrictions, field.type);
+  return checkValuesAgainstBounds(value, { min, max }) !== "ok";
+};
+
 const reduceField = (field) => {
   if (field.type === "dynamic_table") {
     const tableColumns = _.defaultTo([])(field?.values?.table_columns);
@@ -103,6 +279,10 @@ export const parseContentValidation = (content) => {
         !_.isEmpty(field.mandatory.on) &&
         _.isEmpty(field.mandatory.to_be);
 
+      const defaultOutOfRange = defaultValueOutOfRange(field);
+      const restrictions = validateDateRestrictions(field);
+      const restrictionsInvalid = !_.isEmpty(restrictions);
+
       const hasErrors = arrayAnd([
         nameDuplicated,
         nameEmpty,
@@ -111,10 +291,14 @@ export const parseContentValidation = (content) => {
         tableColumnEmpty,
         conditionalVisibilityValueEmpty,
         mandatoryDependingOnValueEmpty,
+        defaultOutOfRange,
+        restrictionsInvalid,
       ]);
       const errors = {
         hasErrors,
         nameDuplicated,
+        defaultOutOfRange,
+        restrictions,
       };
 
       if (field?.type === "dynamic_table") {