Source\Core\Model

Complexity

Total Complexity

42

Size/Duplication

Total Lines	329
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	rawQuery()	0	4	1
A	data()	0	3	1
A	fetch()	0	18	4
A	count()	0	6	1
A	find()	0	11	2
A	__construct()	0	5	1
A	findById()	0	5	1
A	findAll()	0	24	5
A	message()	0	3	1
A	__isset()	0	3	1
A	offset()	0	5	1
A	__get()	0	3	1
A	delete()	0	11	2
A	create()	0	13	2
A	update()	0	16	3
A	__set()	0	7	2
A	fail()	0	3	1
A	order()	0	5	1
A	limit()	0	5	1
A	safe()	0	9	2
A	filter()	0	8	3
A	required()	0	11	3
A	getRequired()	0	8	2

<?php

namespace Source\Core;

abstract class Model
{
    /** @var object|null */
    protected $data;

    /** @var \PDOException|null */
    protected $fail;

    /** @var string|null */
    protected $error;

    /** @var string */

    protected $query;
    /** @var string */

    protected $params;
    /** @var string */

    /** @var string */
    protected $order;

    /** @var int */
    protected $limit;

    /** @var int */
    protected $offset;

    /** @var string $entity database table */
    protected static $entity;

    /** @var array $protected no update or create */
    protected static $protected;

    /** @var array $entity database table */
    protected static $required;

    /**
     * Model constructor.
     * @param string $entity database table name
     * @param array $protected table protected columns
     * @param array $required table required columns
     */
    public function __construct(string $entity, array $protected, array $required)
    {
        self::$entity = $entity;
        self::$protected = array_merge($protected, ['created_at', "updated_at"]);
        self::$required = $required;
    }

    /**
     * @param $name
     * @param $value
     */
    public function __set($name, $value)
    {
        if (empty($this->data)) {
            $this->data = new \stdClass();
        }

        $this->data->$name = $value;
    }

    /**
     * @param $name
     * @return bool
     */
    public function __isset($name)
    {
        return isset($this->data->$name);
    }

    /**
     * @param $name
     * @return null
     */
    public function __get($name)
    {
        return ($this->data->$name ?? null);
    }

    /**
     * @return null|object
     */
    public function data(): ?object
    {
        return $this->data;
    }

    /**
     * @return \PDOException
     */
    public function fail(): ?\PDOException
    {
        return $this->fail;
    }

    /**
     * @return null|string
     */
    public function message(): ?string
    {
        return $this->error;
    }

    /**
     * @param
     * @return Model|mixed
     */

The doc comment @return at position 0 could not be parsed: Unknown type name '@return' at position 0 in @return.

    public function find(?string $terms = null, ?string $params = null, string $columns = "*")
    {
        if ($terms) {
            $this->query = "SELECT {$columns} FROM " . static::$entity . " WHERE {$terms}";

            parse_str($params, $this->params);

$this->params of type string is incompatible with the type array expected by parameter $result of parse_str().

It seems like $params can also be of type null; however, parameter $string of parse_str() does only seem to accept string, maybe add an additional type check?

            return $this;
        }

        $this->query = "SELECT {$columns} FROM " . static::$entity;
        return $this;
    }

    /**
     * @param int $id
     * @param string $columns
     * @return null|mixed|Model
     */
    public function findById(int $id, string $columns = "*"): ?Model
    {
        $find = $this->find("id = :id", "id={$id}", $columns);

        return $find->fetch();
    }

    public function findAll(int $limit = null, int $offset = null): ?array
    {
        $find = $this->find();

        if (!empty($limit)) {
            $find = $find->limit($limit);
        }

        if (!empty($offset)) {
            $find = $find->offset($offset);
        }

        $find = $find->fetch(true);

        if (empty($find)) {
            return null;
        }

        $return = [];
        foreach ($find as $key => $value) {
            $return[] = $value->data();
        }

        return $return;
    }

    public function order(string $columnOrder): Model
    {
        $this->order = " ORDER BY {$columnOrder}";

        return $this;
    }

    public function limit(int $limit): Model
    {
        $this->limit = " LIMIT {$limit}";

The property $limit was declared of type integer, but ' LIMIT '.$limit is of type string. Maybe add a type cast?

        return $this;
    }

    public function offset(int $offset): Model
    {
        $this->offset = " OFFSET {$offset}";

The property $offset was declared of type integer, but ' OFFSET '.$offset is of type string. Maybe add a type cast?

        return $this;
    }

    public function fetch(bool $all = false)
    {
        try {
            $stmt = Connect::getInstance()->prepare($this->query . $this->order . $this->limit . $this->offset);
            $stmt->execute($this->params);

$this->params of type string is incompatible with the type array expected by parameter $params of PDOStatement::execute().

            if (!$stmt->rowCount()) {
                return null;
            }

            if ($all) {
                return $stmt->fetchAll(\PDO::FETCH_CLASS, static::class);
            }

            return $stmt->fetchObject(static::class);
        } catch (\PDOException $exception) {
            $this->fail = $exception;
            return null;
        }
    }

    public function count(string $key = "id"): int

The parameter $key is not used and could be removed.

    {
        $stmt = Connect::getInstance()->prepare($this->query);
        $stmt->execute($this->params);

$this->params of type string is incompatible with the type array expected by parameter $params of PDOStatement::execute().

        return $stmt->rowCount();
    }

    public function rawQuery(string $query): self
    {
        $this->query = $query;
        return $this;
    }

    /**
     * @param string $entity
     * @param array $data
     * @return int|null
     */
    protected function create(array $data): ?int
    {
        try {
            $columns = implode(", ", array_keys($data));
            $values = ":" . implode(", :", array_keys($data));

            $stmt = Connect::getInstance()->prepare("INSERT INTO " . static::$entity . " ({$columns}) VALUES ({$values})");
            $stmt->execute($this->filter($data));

            return Connect::getInstance()->lastInsertId();
        } catch (\PDOException $exception) {
            $this->fail = $exception;
            return null;
        }
    }

    /**
     * @param string $entity
     * @param array $data
     * @param string $terms
     * @param string $params
     * @return int|null
     */
    protected function update(array $data, string $terms, string $params): ?int
    {
        try {
            $dateSet = [];
            foreach ($data as $bind => $value) {
                $dateSet[] = "{$bind} = :{$bind}";
            }
            $dateSet = implode(", ", $dateSet);
            parse_str($params, $params);

$params of type string is incompatible with the type array expected by parameter $result of parse_str().

            $stmt = Connect::getInstance()->prepare("UPDATE " . static::$entity . " SET {$dateSet} WHERE {$terms}");
            $stmt->execute($this->filter(array_merge($data, $params)));
            return ($stmt->rowCount() ?? 1);
        } catch (\PDOException $exception) {
            $this->fail = $exception;
            return null;
        }
    }

    public function delete(string $key, string $value): bool
    {
        try {
            $stmt = Connect::getInstance()->prepare("DELETE FROM " . static::$entity . " WHERE {$key} = :key");
            $stmt->bindValue("key", $value, \PDO::PARAM_STR);
            $stmt->execute();

            return true;
        } catch (\PDOException $exception) {
            $this->fail = $exception;
            return false;
        }
    }

    /**
     * @return array|null
     */
    protected function safe(): ?array
    {
        $safe = (array) $this->data;

        foreach (static::$protected as $unset) {
            unset($safe[$unset]);
        }

        return $safe;
    }

    /**
     * @param array $data
     * @return array|null
     */
    private function filter(array $data): ?array
    {
        $filter = [];
        foreach ($data as $key => $value) {
            $filter[$key] = (is_null($value) ? null : filter_var($value, FILTER_DEFAULT));
        }

        return $filter;
    }

    /**
     * @return bool
     */
    protected function required(): bool
    {
        $data = (array) $this->data();

        foreach (static::$required as $field) {
            if (empty($data[$field])) {
                return false;
            }
        }

        return true;
    }

    public function getRequired(): array
    {
        $data = [];
        foreach (static::$required as $field) {
            $data[] = $field;
        }

        return $data;
    }
}