Model.php

<?php
namespace assaad\core;

abstract class Model
{
    const RULE_REQUIRED = 'required';
    const RULE_EMAIL = 'email';
    const RULE_MAX = 'max';
    const RULE_MIN = 'min';
    const RULE_MATCH = 'match';
    const RULE_UNIQUE = 'unique';
    public array $errors = [];

    public function loadData(array $data)
    {
        foreach ($data as $key => $value) {
            if(property_exists($this,$key))
            {
                $this->{$key} = $value;
            }
        }
    }
    abstract public function rules() : array;

    public function validate()
    {
        foreach ($this->rules() as $attribute => $rules) {
            $value = $this->{$attribute};
            foreach ($rules as $rule) {
                $ruleName = $rule;
                if(!is_string($ruleName))
                {
                    $ruleName = $rule[0];
                }
                if($ruleName === self::RULE_REQUIRED && !$value){
                    $this->addErrorForRule($attribute,self::RULE_REQUIRED);
                }
                if($ruleName === self::RULE_EMAIL && !filter_var($value,FILTER_VALIDATE_EMAIL)){
                    $this->addErrorForRule($attribute,self::RULE_EMAIL);
                }
                if($ruleName === self::RULE_MATCH && !($value === $this->{$rule['match']})){
                    $rule['match'] = $this->getLabels($rule['match']);
                    $this->addErrorForRule($attribute,self::RULE_MATCH,$rule);
                }
                if($ruleName === self::RULE_MIN && (strlen($value) < $rule['min'])){
                    $this->addErrorForRule($attribute,self::RULE_MIN,$rule);
                }
                if($ruleName === self::RULE_MAX && (strlen($value) > $rule['max'])){
                    $this->addErrorForRule($attribute,self::RULE_MAX,$rule);
                }
                if($ruleName === self::RULE_UNIQUE)
                {
                    $className = $rule['class'];
                    $uniqueAttr = $rule['attribute'] ?? $attribute;
                    $tableName = $className::tableName();
                    $statement = Application::$app->db->prepare("SELECT * FROM $tableName WHERE $uniqueAttr = :attr");
                    $statement->bindValue(':attr',$value);
                    $statement->execute();
                    $record = $statement->fetchObject();
                    if($record){
                        $this->addErrorForRule($attribute,self::RULE_UNIQUE,['field'=>$this->getLabels($attribute)]);
                    }
                }
            }
        }
        return empty($this->errors);
    }

    private function addErrorForRule(string $attribute, string $rule, $params = [])
    {
        $message = $this->errorMessage()[$rule] ?? '';
        foreach ($params as $key => $value) {
            $message = str_replace("{{$key}}",$value,$message);
        }
        $this->errors[$attribute][] = $message;
    }
    public function addError(string $attribute, string $message)
    {
        $this->errors[$attribute][] = $message;
    }

    private function errorMessage() : array
    {
        return [
            self::RULE_REQUIRED => "This field is required",
            self::RULE_MAX => "Max length of this field must be {max}",
            self::RULE_MIN=>"Min length of this field must be {min}",
            self::RULE_EMAIL=>"This field must be valid email address",
            self::RULE_MATCH => "This field must be same as {match}",
            self::RULE_UNIQUE => "Record with this {field} already exists"
        ];
    }


    public function hasErrors($attribute)
    {
        return $this->errors[$attribute] ?? false;
    }

    public function getFirstError(string $attribute)
    {
        return $this->errors[$attribute][0] ?? " ";
    }

    public function getLabels($attribute)
    {
        return $this->labels()[$attribute] ?? $attribute;
    }
    public function labels() : array
    {
        return [];
    }
}