<?php
|
namespace JVBase\meta;
|
|
use DateTime;
|
|
if (!defined('ABSPATH')) {
|
exit; // Exit if accessed directly
|
}
|
/**
|
* Handles meta value validation
|
*/
|
class Validator
|
{
|
protected array $errors = [];
|
|
public static function validate(mixed $value, array $config): bool|array
|
{
|
$errors = [];
|
$type = $config['type'];
|
$name = $config['name'] ?? 'field';
|
|
// Required field check
|
if (!empty($config['required']) && static::isEmpty($value)) {
|
return [$name => __('This field is required', 'jvb')];
|
}
|
|
// Skip validation for empty optional fields
|
if (static::isEmpty($value)) {
|
return true;
|
}
|
|
// Type-specific validation
|
$method = 'validate' . str_replace('_', '', ucwords($type, '_'));
|
if (method_exists(static::class, $method)) {
|
$result = static::$method($value, $config);
|
if ($result !== true) {
|
return is_array($result) ? $result : [$name => $result];
|
}
|
}
|
|
return true;
|
}
|
|
protected static function isEmpty(mixed $value): bool
|
{
|
if ($value === null || $value === '' || $value === []) {
|
return true;
|
}
|
if (is_array($value) && empty(array_filter($value))) {
|
return true;
|
}
|
return false;
|
}
|
|
protected static function validateText(string $value, array $config): bool|string
|
{
|
if (isset($config['limit']) && strlen($value) > $config['limit']) {
|
return sprintf(__('Must not exceed %d characters', 'jvb'), $config['limit']);
|
}
|
|
if (isset($config['pattern']) && !preg_match($config['pattern'], $value)) {
|
return __('Invalid format', 'jvb');
|
}
|
|
return true;
|
}
|
|
protected static function validateTextarea(string $value, array $config): bool|string
|
{
|
return static::validateText($value, $config);
|
}
|
|
protected static function validateNumber(mixed $value, array $config): bool|string
|
{
|
if (!is_numeric($value)) {
|
return __('Must be a number', 'jvb');
|
}
|
|
if (isset($config['min']) && $value < $config['min']) {
|
return sprintf(__('Must be at least %s', 'jvb'), $config['min']);
|
}
|
|
if (isset($config['max']) && $value > $config['max']) {
|
return sprintf(__('Must not exceed %s', 'jvb'), $config['max']);
|
}
|
|
return true;
|
}
|
|
protected static function validateEmail(string $value, array $config): bool|string
|
{
|
if (!is_email($value)) {
|
return __('Invalid email address', 'jvb');
|
}
|
return true;
|
}
|
|
protected static function validateUrl(string $value, array $config): bool|string
|
{
|
if (filter_var($value, FILTER_VALIDATE_URL) === false) {
|
return __('Must be a valid URL', 'jvb');
|
}
|
return true;
|
}
|
|
protected static function validateDate(string $value, array $config): bool|string
|
{
|
$timestamp = strtotime($value);
|
if ($timestamp === false) {
|
return __('Invalid date format', 'jvb');
|
}
|
|
if (isset($config['min_date']) && $timestamp < strtotime($config['min_date'])) {
|
return sprintf(__('Date must be after %s', 'jvb'), $config['min_date']);
|
}
|
|
if (isset($config['max_date']) && $timestamp > strtotime($config['max_date'])) {
|
return sprintf(__('Date must be before %s', 'jvb'), $config['max_date']);
|
}
|
|
return true;
|
}
|
|
|
protected static function validateDatetime(string $value, array $config): bool|string
|
{
|
$date = DateTime::createFromFormat('Y-m-d H:i:s', $value);
|
if (!$date) {
|
$formats = ['Y-m-d\TH:i:s', 'Y-m-d\TH:i', 'Y-m-d H:i'];
|
foreach ($formats as $format) {
|
$date = DateTime::createFromFormat($format, $value);
|
if ($date) break;
|
}
|
}
|
|
if (!$date) {
|
return __('Invalid datetime format', 'jvb');
|
}
|
|
$timestamp = $date->getTimestamp();
|
|
if (isset($config['min_datetime']) && $timestamp < strtotime($config['min_datetime'])) {
|
return sprintf(__('DateTime must be after %s', 'jvb'), $config['min_datetime']);
|
}
|
|
if (isset($config['max_datetime']) && $timestamp > strtotime($config['max_datetime'])) {
|
return sprintf(__('DateTime must be before %s', 'jvb'), $config['max_datetime']);
|
}
|
|
return true;
|
}
|
|
protected static function validateTime(string $value, array $config): bool|string
|
{
|
if (!preg_match('/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/', $value)) {
|
return __('Time must be in HH:MM format', 'jvb');
|
}
|
|
if (isset($config['min_time']) && strtotime($value) < strtotime($config['min_time'])) {
|
return sprintf(__('Time must be after %s', 'jvb'), $config['min_time']);
|
}
|
|
if (isset($config['max_time']) && strtotime($value) > strtotime($config['max_time'])) {
|
return sprintf(__('Time must be before %s', 'jvb'), $config['max_time']);
|
}
|
|
return true;
|
}
|
|
protected static function validateSelect(string $value, array $config): bool|string
|
{
|
if (!isset($config['options']) || !array_key_exists($value, $config['options'])) {
|
return __('Invalid selection', 'jvb');
|
}
|
return true;
|
}
|
|
protected static function validateRadio(string $value, array $config): bool|string
|
{
|
return static::validateSelect($value, $config);
|
}
|
|
protected static function validateSet(array|string $value, array $config): bool|string
|
{
|
if (!is_array($value)) {
|
$value = explode(',', $value);
|
}
|
|
if (!isset($config['options'])) {
|
return true;
|
}
|
|
$invalid = array_diff($value, array_keys($config['options']));
|
if (!empty($invalid)) {
|
return __('Invalid selections', 'jvb');
|
}
|
|
return true;
|
}
|
|
protected static function validateCheckbox(array|string $value, array $config): bool|string
|
{
|
return static::validateSet($value, $config);
|
}
|
|
protected static function validateImage(int $value, array $config): bool|string
|
{
|
if (!wp_attachment_is_image($value)) {
|
return __('Invalid image', 'jvb');
|
}
|
return true;
|
}
|
|
protected static function validateGallery(array|string $value, array $config): bool|string
|
{
|
$ids = is_array($value) ? $value : explode(',', $value);
|
|
if (!empty($config['max_images']) && count($ids) > $config['max_images']) {
|
return sprintf(__('Maximum of %d images allowed', 'jvb'), $config['max_images']);
|
}
|
|
foreach ($ids as $id) {
|
if (absint($id) <= 0 || !wp_attachment_is_image(absint($id))) {
|
return __('One or more invalid images', 'jvb');
|
}
|
}
|
|
return true;
|
}
|
|
protected static function validateTaxonomy(array|string $value, array $config): bool|string
|
{
|
if (!is_array($value)) {
|
$value = explode(',', $value);
|
}
|
|
$taxonomy = (str_starts_with($config['taxonomy'], BASE))
|
? $config['taxonomy']
|
: BASE . $config['taxonomy'];
|
|
foreach ($value as $term_id) {
|
if (!term_exists((int)$term_id, $taxonomy)) {
|
return __('Invalid term selected', 'jvb');
|
}
|
}
|
|
return true;
|
}
|
|
protected static function validateUser(array|string $value, array $config): bool|string
|
{
|
if (!is_array($value)) {
|
$value = explode(',', $value);
|
}
|
|
foreach ($value as $user_id) {
|
if (!get_userdata((int)$user_id)) {
|
return __('Invalid user selected', 'jvb');
|
}
|
}
|
|
return true;
|
}
|
|
protected static function validateLocation(array $value, array $config): bool|string
|
{
|
if (!is_array($value)) {
|
return __('Location must be an array', 'jvb');
|
}
|
|
$required_fields = ['lat', 'lng'];
|
foreach ($required_fields as $field) {
|
if (!isset($value[$field]) || !is_numeric($value[$field])) {
|
return __('Invalid location coordinates', 'jvb');
|
}
|
}
|
|
return true;
|
}
|
|
protected static function validateRepeater(array $value, array $config): bool|string
|
{
|
if (!is_array($value)) {
|
return __('Invalid repeater data', 'jvb');
|
}
|
|
if (isset($config['min_rows']) && count($value) < $config['min_rows']) {
|
return sprintf(__('Minimum of %d rows required', 'jvb'), $config['min_rows']);
|
}
|
|
if (isset($config['max_rows']) && count($value) > $config['max_rows']) {
|
return sprintf(__('Maximum of %d rows allowed', 'jvb'), $config['max_rows']);
|
}
|
|
foreach ($value as $row) {
|
foreach ($config['fields'] as $field_name => $field_config) {
|
if (!isset($row[$field_name])) {
|
continue;
|
}
|
$field_config['name'] = $field_name;
|
$result = static::validate($row[$field_name], $field_config);
|
if ($result !== true) {
|
return is_array($result) ? array_values($result)[0] : $result;
|
}
|
}
|
}
|
|
return true;
|
}
|
|
protected static function validateGroup(array $value, array $config): bool|string
|
{
|
if (!is_array($value)) {
|
return __('Invalid group data', 'jvb');
|
}
|
|
if (!empty($config['fields']) && is_array($config['fields'])) {
|
foreach ($config['fields'] as $field_name => $field_config) {
|
if (isset($value[$field_name])) {
|
$field_config['name'] = $field_name;
|
$result = static::validate($value[$field_name], $field_config);
|
if ($result !== true) {
|
return is_array($result) ? array_values($result)[0] : $result;
|
}
|
}
|
}
|
}
|
|
return true;
|
}
|
|
protected static function validateTagList(array $value, array $config): bool|string
|
{
|
if (!is_array($value)) {
|
return __('Invalid data format', 'jvb');
|
}
|
|
if (isset($config['min_items']) && count($value) < $config['min_items']) {
|
return sprintf(__('Minimum of %d items required', 'jvb'), $config['min_items']);
|
}
|
|
if (isset($config['max_items']) && count($value) > $config['max_items']) {
|
return sprintf(__('Maximum of %d items allowed', 'jvb'), $config['max_items']);
|
}
|
|
if (!isset($config['fields']) || !is_array($config['fields'])) {
|
return true;
|
}
|
|
foreach ($value as $row) {
|
if (!is_array($row)) {
|
continue;
|
}
|
|
foreach ($config['fields'] as $field_name => $field_config) {
|
if (!isset($row[$field_name])) {
|
continue;
|
}
|
|
$field_config['name'] = $field_name;
|
$result = static::validate($row[$field_name], $field_config);
|
if ($result !== true) {
|
return is_array($result) ? array_values($result)[0] : $result;
|
}
|
}
|
}
|
|
return true;
|
}
|
|
protected static function validateTrueFalse(mixed $value, array $config): bool
|
{
|
return true; // Boolean values are always valid after sanitization
|
}
|
}
|
