Model::find() - Code Metrics - MuriloChianfa/Redstore-Microservice-Based - Measure and Improve Code Quality continuously with Scrutinizer

Model::find() A
last analyzed 2023-05-24 06:00 UTC

↳ Parent: Model
Complexity

Conditions	2
Paths	2
Size

Total Lines	11
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	6
dl	0
loc	11
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	3
<?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
     */

    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);
            parse_str(/** @scrutinizer ignore-type */ $params, $this->params);
            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}";
$answer = 42;

$correct = false;

$correct = (bool) $answer;

        return $this;
    }

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

$correct = false;

$correct = (bool) $answer;

        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);
            $stmt->execute(/** @scrutinizer ignore-type */ $this->params);

            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
    public function count(/** @scrutinizer ignore-unused */ string $key = "id"): int
    {
        $stmt = Connect::getInstance()->prepare($this->query);
        $stmt->execute($this->params);
        $stmt->execute(/** @scrutinizer ignore-type */ $this->params);

        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);
            parse_str($params, /** @scrutinizer ignore-type */ $params);

            $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;
    }
}

MuriloChianfa / Redstore-Microservice-Based

Model::find() A last analyzed 2023-05-24 06:00 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Model::find() A
last analyzed 2023-05-24 06:00 UTC
