ENH Use FieldValidators for FormField validation

src/Core/Validation/FieldValidation/DateFieldValidator.php

@@ -2,29 +2,113 @@
 
 namespace SilverStripe\Core\Validation\FieldValidation;
 
+use Exception;
+use InvalidArgumentException;
 use SilverStripe\Core\Validation\FieldValidation\FieldValidator;
 use SilverStripe\Core\Validation\ValidationResult;
 
 /**
  * Validates that a value is a valid date, which means that it follows the equivalent formats:
  * - PHP date format Y-m-d
- * - SO format y-MM-dd i.e. DBDate::ISO_DATE
+ * - ISO format y-MM-dd i.e. DBDate::ISO_DATE
  *
  * Blank string values are allowed
  */
 class DateFieldValidator extends FieldValidator
 {
+    /**
+     * Minimum value as a date string
+     */
+    private ?string $minValue;
+
+    /**
+     * Minimum value as a unix timestamp
+     */
+    private ?int $minTimestamp;
+
+    /**
+     * Maximum value as a date string
+     */
+    private ?string $maxValue;
+
+    /**
+     * Maximum value as a unix timestamp
+     */
+    private ?int $maxTimestamp;
+
+    /**
+     * Converter to convert date strings to another format for display in error messages
+     *
+     * @var callable
+     */
+    private $converter;
+
+    public function __construct(
+        string $name,
+        mixed $value,
+        ?int $minValue = null,
+        ?int $maxValue = null,
+        ?callable $converter = null,
+    ) {
+        // Convert Y-m-d args to timestamps
+        // Intermiediate variables are used to prevent "must not be accessed before initialization" PHP errors
+        // when reading properties in the constructor
+        $minTimestamp = null;
+        $maxTimestamp = null;
+        if (!is_null($minValue)) {
+            $minTimestamp = $this->dateToTimestamp($minValue);
+        }
+        if (!is_null($maxValue)) {
+            $maxTimestamp = $this->dateToTimestamp($maxValue);
+        }
+        if (!is_null($minTimestamp) && !is_null($maxTimestamp) && $minTimestamp < $maxTimestamp) {
+            throw new InvalidArgumentException('maxValue cannot be less than minValue');
+        }
+        $this->minValue = $minValue;
+        $this->maxValue = $maxValue;
+        $this->minTimestamp = $minTimestamp;
+        $this->maxTimestamp = $maxTimestamp;
+        $this->converter = $converter;
+        parent::__construct($name, $value);
+    }
+
     protected function validateValue(): ValidationResult
     {
         $result = ValidationResult::create();
         // Allow empty strings
         if ($this->value === '') {
             return $result;
         }
-        // Not using symfony/validator because it was allowing d-m-Y format strings
-        $date = date_parse_from_format($this->getFormat(), $this->value ?? '');
-        if ($date === false || $date['error_count'] > 0 || $date['warning_count'] > 0) {
+        // Validate value is a valid date
+        try {
+            $timestamp = $this->dateToTimestamp($this->value ?? '');
+        } catch (Exception) {
             $result->addFieldError($this->name, $this->getMessage());
+            return $result;
+        }
+        // Validate value is within range
+        if (!is_null($this->minTimestamp) && $timestamp < $this->minTimestamp) {
+            $minValue = $this->minValue;
+            if (!is_null($this->converter)) {
+                $minValue = call_user_func($this->converter, $this->minValue) ?: $this->minValue;
+            }
+            $message = _t(
+                __CLASS__ . '.TOOSMALL',
+                'Value cannot be less than {minValue}',
+                ['minValue' => $minValue]
+            );
+            $result->addFieldError($this->name, $message);
+        } elseif (!is_null($this->maxTimestamp) && $timestamp > $this->maxTimestamp) {
+            $maxValue = $this->maxValue;
+            if (!is_null($this->converter)) {
+                $maxValue = call_user_func($this->converter, $this->maxValue) ?: $this->maxValue;
+            }
+            $message = _t(
+                __CLASS__ . '.TOOLARGE',
+                'Value cannot be greater than {maxValue}',
+                ['maxValue' => $maxValue]
+            );
+            $result->addFieldError($this->name, $message);
         }
         return $result;
     }
@@ -38,4 +122,17 @@ protected function getMessage(): string
     {
         return _t(__CLASS__ . '.INVALID', 'Invalid date');
     }
+
+    /**
+     * Parse a date string into a unix timestamp using the format specified by getFormat()
+     */
+    private function dateToTimestamp(string $date): int
+    {
+        // Not using symfony/validator because it was allowing d-m-Y format strings
+        $date = date_parse_from_format($this->getFormat(), $date);
+        if ($date === false || $date['error_count'] > 0 || $date['warning_count'] > 0) {
+            throw new InvalidArgumentException('Invalid date');
+        }
+        return mktime($date['hour'], $date['minute'], $date['second'], $date['month'], $date['day'], $date['year']);
+    }
 }

src/Forms/CompositeField.php

@@ -3,6 +3,7 @@
 namespace SilverStripe\Forms;
 
 use SilverStripe\Dev\Debug;
+use SilverStripe\Core\Validation\ValidationResult;
 
 /**
  * Base class for all fields that contain other fields.
@@ -120,7 +121,7 @@ public function getChildren()
      * If the CompositeField doesn't have a name, but we still want the ID/name to be set.
      * This code generates the ID from the nested children.
      */
-    public function getName()
+    public function getName(): string
     {
         if ($this->name) {
             return $this->name;
@@ -523,18 +524,18 @@ public function debug(): string
         return $result;
     }
 
-    /**
-     * Validate this field
-     *
-     * @param Validator $validator
-     * @return bool
-     */
-    public function validate($validator)
+    // TODO: replace with CompositeFieldValidator ?
+    public function validate(): ValidationResult
     {
-        $valid = true;
-        foreach ($this->children as $child) {
-            $valid = ($child && $child->validate($validator) && $valid);
-        }
-        return $this->extendValidationResult($valid, $validator);
+        $result = ValidationResult::create();
+        $this->beforeExtending('updateValidate', function () use ($result) {
+            foreach ($this->children as $child) {
+                if (!$child) {
+                    continue;
+                }
+                $result->combineAnd($child->validate());
+            }
+        });
+        return $result->combineAnd(parent::validate());
     }
 }