dbxValidator.class.php

Go to the documentation of this file.

<?php
 
class dbxValidator {
 
    private array $errorMessages = [];
 
    private static array $ruleCache = [];
 
 
    /* =====================================================
       DB TYPE LIMITS
       ===================================================== */
 
    private const INT_RANGE = [
 
        'tinyint'   => [-128,127],
        'smallint'  => [-32768,32767],
        'mediumint' => [-8388608,8388607],
        'int'       => [-2147483648,2147483647]
 
        // 🔥 bigint entfernt → wird separat geprüft
 
    ];
 
    private const TEXT_LIMIT = [
 
        'tinytext'   => 255,
        'text'       => 65535,
        'mediumtext' => 16777215,
        'longtext'   => 4294967295
 
    ];
 
    private const BLOB_PASS = [
 
        'blob'=>true,
        'tinyblob'=>true,
        'mediumblob'=>true,
        'longblob'=>true
 
    ];
 
 
    /* =====================================================
       TYPE ALIAS
       ===================================================== */
 
    private const TYPE_ALIAS = [
 
        'integer'=>'int',
        'numeric'=>'decimal',
        'double'=>'float',
        'real'=>'float',
 
        'varchar2'=>'varchar',
        'bool'=>'boolean'
 
    ];
 
 
    /* =====================================================
       REGEX
       ===================================================== */
 
    private const REGEX = [
 
        'parameter'  => '/^[a-zA-Z0-9._\-|]+$/',
        'parameters' => '/^[a-zA-Z0-9._\/&=\-|]+$/',
        'datetime'   => '/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(\.\d{1,6})?$/',
 
        'word'       => '/^[\p{L}\p{M}\p{N}@._,:;-]+$/u',
        'words'      => '/^[\p{L}\p{M}\p{N}\s@._,:;-]+$/u',
        'sqlsearch'  => '/^[\p{L}\p{M}\p{N}\s@._,:;\/\-]+$/u',
 
        'alphanum'   => '/^[\p{L}\p{M}0-9@_ .,:-]+$/u',
 
        'email'      => '/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/',
        'phone'      => '/^\+?[0-9\/\- ]+$/'
 
    ];
 
 
    /* =====================================================
       RULE PARSER
       ===================================================== */
 
    private function parseRule(string $rules): array {
 
        if (isset(self::$ruleCache[$rules])) {
            return self::$ruleCache[$rules];
        }
 
        $r=[
 
            'base'=>'',
            'extra'=>'',
            'min'=>null,
            'max'=>null
 
        ];
 
        foreach(explode('|',$rules) as $p){
 
            if (strpos($p,'=')!==false){
 
                [$k,$v]=explode('=',$p,2);
 
                if ($k==='min') $r['min']=(int)$v;
                elseif ($k==='max') $r['max']=(int)$v;
 
                continue;
            }
 
            if (($pos=strpos($p,'+'))!==false){
 
                $r['base']=substr($p,0,$pos);
                $r['extra']=substr($p,$pos+1);
 
            } else {
 
                $r['base']=$p;
            }
        }
 
        $r['base']=strtolower($r['base']);
 
        if (isset(self::TYPE_ALIAS[$r['base']])) {
            $r['base']=self::TYPE_ALIAS[$r['base']];
        }
 
        self::$ruleCache[$rules]=$r;
 
        return $r;
    }
 
 
    /* =====================================================
       LENGTH
       ===================================================== */
 
    private function lengthOK(string $v,$min,$max): bool {
 
        $l=strlen($v);
 
        if ($min!==null && $l<$min) return false;
        if ($max!==null && $l>$max) return false;
 
        return true;
    }
 
 
    /* =====================================================
       EXTRA STRIP
       ===================================================== */
 
    private function stripExtra(string $v,string $extra): string {
 
        if ($extra==='') return $v;
 
        return str_replace(str_split($extra),'',$v);
    }
 
 
    /* =====================================================
       DATE / TIME
       ===================================================== */
 
    private function validateDate(string $v): bool {
 
        if (!preg_match('/^\d{4}-\d{2}-\d{2}$/',$v)) return false;
 
        [$y,$m,$d]=explode('-',$v);
 
        return checkdate((int)$m,(int)$d,(int)$y);
    }
 
    private function validateTime(string $v): bool {
 
        return (bool)preg_match('/^([01]\d|2[0-3]):[0-5]\d(:[0-5]\d)?$/',$v);
    }
 
    private function validateTimestamp(string $v): bool {
 
        if (!preg_match('/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/',$v,$m))
            return false;
 
        return checkdate((int)$m[2],(int)$m[3],(int)$m[1]);
    }
 
 
    /* =====================================================
       INT VALIDATION
       ===================================================== */
 
    private function validateInt(string $v,string $type): bool {
 
        if (!preg_match('/^-?\d+$/',$v)) return false;
 
        // 🔥 SIMPLE BIGINT (max 19 digits)
        if ($type === 'bigint') {
 
            $digits = ltrim($v, '-');
 
            return strlen($digits) <= 19;
        }
 
        if (!isset(self::INT_RANGE[$type])) return true;
 
        [$min,$max]=self::INT_RANGE[$type];
 
        $i=(int)$v;
 
        return ($i>=$min && $i<=$max);
    }
 
 
    /* =====================================================
       SCALAR VALIDATION
       ===================================================== */
 
    private function validateScalar($value,array $rule,string $rulestr): bool {
 
        $base=$rule['base'];
        $extra=$rule['extra'];
        $min=$rule['min'];
        $max=$rule['max'];
 
        if ($value===null) $value='';
 
        $orig=$value;
 
        $value=(string)$value;
 
        if (!$this->lengthOK($value,$min,$max)){
            return false;
        }
 
        if ($orig===null || $orig==='' || $orig==='0' || $orig==='1' || $orig===0 || $orig===1){
            return true;
        }
 
        $value=$this->stripExtra($value,$extra);
 
        if ($value === '') {
            return true;
        }
 
        switch($base){
 
            case '*':
                $ok=true;
                break;
 
            case 'int':
            case 'tinyint':
            case 'smallint':
            case 'mediumint':
            case 'bigint':
                $ok=$this->validateInt($value,$base);
                break;
 
            case 'decimal':
            case 'float':
                $ok=is_numeric($value);
                break;
 
            case 'date':
                $ok=$this->validateDate($value);
                break;
 
            case 'time':
                $ok=$this->validateTime($value);
                break;
 
            case 'datetime':
            case 'timestamp':
                $ok=$this->validateTimestamp($value);
                break;
 
            case 'varchar':
            case 'char':
                $ok=true;
                break;
 
            case 'boolean':
                $ok=($value==='0'||$value==='1'||$value==='true'||$value==='false');
                break;
 
            case 'json':
                json_decode($value);
                $ok=(json_last_error()===JSON_ERROR_NONE);
                break;
 
            case 'year':
                $ok=preg_match('/^\d{4}$/',$value);
                break;
 
            default:
 
                if (isset(self::TEXT_LIMIT[$base])){
                    $ok=strlen($value)<=self::TEXT_LIMIT[$base];
                    break;
                }
 
                if (isset(self::BLOB_PASS[$base])){
                    $ok=true;
                    break;
                }
 
                if (isset(self::REGEX[$base])){
                    $ok=preg_match(self::REGEX[$base],$value);
                    break;
                }
 
                return false;
        }
 
        return (bool)$ok;
    }
 
 
    /* =====================================================
       PUBLIC VALIDATE (STRICT)
       ===================================================== */
 
    public function validate($value,$rules='parameter',$name='-undef-'): bool {
        
        $this->errorMessages=[];
 
        if ($rules== '*' ) return true;
 
        $parts = explode('|', (string)$rules);
        $arrayRule = in_array('array', $parts, true);
 
        if ($arrayRule) {
            if ($value === null || $value === '') {
                return true;
            }
 
            if (!is_array($value)) {
                return false;
            }
 
            $itemRules = implode('|', array_values(array_filter($parts, static function ($part) {
                return $part !== 'array';
            })));
 
            if ($itemRules === '') {
                $itemRules = '*';
            }
 
            if ($itemRules === '*') {
                return true;
            }
 
            $rule = $this->parseRule($itemRules);
 
            foreach ($value as $item) {
                if (is_array($item) || is_object($item) || is_resource($item) || (!is_scalar($item) && $item !== null)) {
                    return false;
                }
 
                if (!$this->validateScalar($item, $rule, $itemRules)) {
                    return false;
                }
            }
 
            return true;
        }
 
        $rule=$this->parseRule($rules);
 
        if (is_array($value))    return false;
        if (is_object($value))   return false;
        if (is_resource($value)) return false;
        if (!is_scalar($value) && $value !== null) return false;
 
        return $this->validateScalar($value,$rule,$rules);
    }
 
 
    /* =====================================================
       CLEAN
       ===================================================== */
 
    public function clean($value,$rules,$length=-1,$name='-undef-'){
 
        if (!is_scalar($value) && $value !== null) return '';
 
        if ($value===null) $value='';
        $value = (string)$value;
        $length = (int)$length;
 
        if ($length>0 && strlen($value)>$length)
            $value=substr($value,0,$length);
 
        return $value;
    }
 
 
    /* =====================================================
       UTIL
       ===================================================== */
 
    public function getErrorMessages(): array {
        return $this->errorMessages;
    }
 
    public function clearErrors(): void {
        $this->errorMessages=[];
    }
 
    public function get_rule_val($rules,$rule=''){
 
        if (is_string($rules)) $rules=explode('|',$rules);
 
        if (!is_array($rules)) return '';
 
        foreach ($rules as $r){
 
            if ($rule==='rule' && strpos($r,'=')===false)
                return $r;
 
            if (strpos($r,'=')!==false){
 
                [$k,$v]=explode('=',$r,2);
 
                if ($k===$rule)
                    return $v;
            }
        }
 
        return '';
    }
 
}