Model.php

<?php
/**
 * Created by PhpStorm.
 * User: qasim
 * Date: 2022-03-30
 * Time: 10:18 PM
 */

namespace qasimlearner\laravelclone;


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

	// for php 7.4
//	public array $errors = [];
	public $errors = [];

	abstract function rules() : array;

	public function labels()
	{
		return [];
	}

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

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

	public function validate()
	{
		foreach ($this->rules() as $attribute=> $rules)
		{
			$value = $this->{$attribute};

			foreach ($rules as $rule)
			{
				$ruleName = $rule;

				if(!is_string($ruleName))
				{
					$ruleName = $ruleName[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_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_MATCH && $value !== $this->{$rule['match']})
				{
					$rule['match'] = $this->getLabel($rule['match']);
					$this->addErrorForRule($attribute, self::RULE_MATCH, $rule);
				}

				if($ruleName === self::RULE_UNIQUE)
				{
					$className = $rule['class'];
					$uniqueAttribute = $rule['attribute'] ?? $attribute;
					$tableName = $className::tableName();

					$statement = Application::$app->db->prepare("SELECT * FROM {$tableName} WHERE $uniqueAttribute = :attr LIMIT 1");
					$statement->bindValue(':attr', $value);
					$statement->execute();
					$record = $statement->fetchObject();

					if($record) {
						$this->addErrorForRule($attribute, self::RULE_UNIQUE,
							['field'=> $this->getLabel($attribute)]);
					}
				}
			}
		}

		return empty($this->errors);
	}

	public function addError(string $attribute, string $message)
	{
		$this->errors[$attribute][] = $message;
	}

	private function addErrorForRule(string $attribute, string $rule, $params = [])
	{
		$message = $this->errorMessages()[$rule] ?? '';

		foreach ($params as $key=> $value)
		{
			$message = str_replace("{{$key}}", $value, $message);
		}

		$this->errors[$attribute][] = $message;
	}

	public function errorMessages()
	{
		return [
			self::RULE_REQUIRED => 'This field is required!',
			self::RULE_EMAIL    => 'This field must be valid email address!',
			self::RULE_MIN      => 'Min length of this field must be {min}-characters!',
			self::RULE_MAX      => 'Max length of this field must be within {max}-characters!',
			self::RULE_MATCH    => 'This field must be the same as {match}!',
			self::RULE_UNIQUE   => 'Record with this {field} already exists!',
		];
	}

	public function hasError($attribute)
	{
		return isset($this->errors[$attribute]);
	}

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