SimplePHP\Model\SimplePHP

Complexity

Total Complexity

60

Size/Duplication

Total Lines	405
Duplicated Lines	0 %

Importance

Changes

0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	limit()	0	4	1
A	__get()	0	3	1
A	debugQuery()	0	3	1
A	__isset()	0	3	1
A	useTable()	0	4	1
A	where()	0	10	4
A	__callStatic()	0	2	1
A	orderBy()	0	8	2
A	only()	0	4	1
A	whereRaw()	0	4	1
A	destroy()	0	8	2
B	execute()	0	14	7
A	__call()	0	15	5
A	find()	0	5	2
A	deny()	0	5	4
A	count()	0	4	1
A	setRealTable()	0	4	1
A	orWhere()	0	10	4
A	except()	0	4	1
A	writeLog()	0	11	2
A	__construct()	0	9	3
A	save()	0	16	4
A	request()	0	4	1
A	setRealPrimary()	0	4	1
A	groupBy()	0	8	2
A	__set()	0	7	2
A	create()	0	11	2
A	offset()	0	4	1
A	findByPrimary()	0	5	1

<?php

namespace SimplePHP\Model;

use SimplePHP\Root\{
    Connection,
    Functions
};
use SimplePHP\Traits\Properties;
use SimplePHP\Model\ChildSimplePHP;
use PDO,
    PDOException,
    stdClass;
use SimplePHP\Model\CRUD as Actions;
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

/**
 * Class SimplePHP
 * @package NicollasSilva\SimplePHP
 */
class SimplePHP extends Connection {
    use Actions, Functions, Properties;

The trait SimplePHP\Traits\Properties requires the property $primaryKey which is not provided by SimplePHP\Model\SimplePHP.

    /** @var string */
    protected $sentence = '';

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

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

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

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

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

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

    /** @var object|null */
    protected $data;

    /** @var bool */
    protected $type;

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

    /** @var array */
    protected $request = [];

    /** @var array */
    protected $excepts = [];

    /** @var bool */
    protected $count = false;

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

    /** @var object|null */
    protected $childClass;

    /** @var array */
    private static $reservedWords = ['where', 'find', 'by'];

    /**
     * Get tablename of children model
     * @param string|null $tableName
     */
    function __construct(String $tableName = null, String $primaryKey = null)
    {
        $this->setRealTable()->setRealPrimary();

        $this->childClass = new ChildSimplePHP(get_called_class());

        if($tableName) $this->table = $tableName;

        if($primaryKey) $this->primary = $primaryKey;
    }

    private function setRealTable() : ?SimplePHP
    {
        $this->table = $this->getTable() ?? strtolower($this->childClass->realName) . 's';
        return $this;
    }

    private function setRealPrimary() : ?SimplePHP
    {
        $this->primary = $this->getPrimary() ?? 'id';
        return $this;
    }

    /**
     * @param int|null $id
     * @return SimplePHP|null
     */
    public function find(int $id = null): ?SimplePHP
    {
        is_int($id) ? $this->where([[$this->primary, '=', $id]]) : null;

        return $this;
    }

    /**
     * @param array $where
     * @param string $condition = 'AND'
     * @return SimplePHP|null
     */
    public function where(Array $where, String $condition = 'AND'): ?SimplePHP
    {
        $this->where = '';
        foreach($where as $enclosures) {
            $split = isset($enclosures[3]) && !$enclosures[3] ? $enclosures[2] : "'".$enclosures[2]."'";
            $this->where .= $enclosures[0]." ".$enclosures[1]." ".$split." {$condition} ";
        }
        $this->where = "WHERE " . rtrim($this->where, " {$condition} ");

        return $this;
    }

    /**
     * @param array $where
     * @return SimplePHP|null
     */
    public function whereRaw(String $where): ?SimplePHP
    {
        $this->where = "WHERE " . $where;
        return $this;
    }

    /**
     * @param array $orWhere
     * @param string $condition = 'AND'
     * @return SimplePHP|null
     */
    public function orWhere(Array $orWhere, String $condition = 'AND'): ?SimplePHP
    {
        $moreWhere = '';
        foreach($orWhere as $enclosures) {
            $split = isset($enclosures[3]) && !$enclosures[3] ? $enclosures[2] : "'".$enclosures[2]."'";
            $moreWhere .= $enclosures[0]." ".$enclosures[1]." ".$split." {$condition} ";
        }
        $this->where .= " OR " . rtrim($moreWhere, " {$condition} ");

        return $this;
    }

    /**
     * @param array $params
     * @return SimplePHP|null
     */
    public function only(Array $params): ?SimplePHP
    {
        $this->params = implode(',', $params);
        return $this;
    }

    /**
     * @param int $limit
     * @return SimplePHP|null
     */
    public function limit(int $limit): ?SimplePHP
    {
        $this->limit = "LIMIT $limit";
        return $this;
    }

    /**
     * @param int $offset
     * @return SimplePHP|null
     */
    public function offset(int $offset): ?SimplePHP
    {
        $this->offset = "OFFSET $offset";
        return $this;
    }

    /**
     * @param string $order
     * @param string $ordenation = 'ASC'
     * @return SimplePHP|null
     */
    public function orderBy(String $prop, String $ordenation = 'ASC'): ?SimplePHP
    {
        if(mb_strlen($this->order) < 9) {
            $this->order = "ORDER BY {$prop} {$ordenation}";
        } else {
            $this->order .= ", {$prop} {$ordenation}";
        }
        return $this;
    }

    /**
     * @param string $prop
     * @return SimplePHP|null
     */
    public function groupBy(String $prop): ?SimplePHP
    {
        if(mb_strlen($this->group) < 9) {
            $this->group = "GROUP BY {$prop}";
        } else {
            $this->group .= ", {$prop}";
        }
        return $this;
    }

    /**
     * @param string $name
     * @param mixed $arguments
     * @return Array|Null|SimplePHP
     */
    public function __call(String $name, $arguments)
    {
        if($name === 'skip')
            return $this->offset($arguments[0]);

        if($name === 'take')
            return $this->limit($arguments[0]);

        if($name === 'get')
            return $this->execute();

The expression return $this->execute() also could return the type integer which is incompatible with the documented return type SimplePHP\Model\SimplePHP|array|null.

        if($name === 'first')
            return $this->execute(true);

The expression return $this->execute(true) also could return the type integer which is incompatible with the documented return type SimplePHP\Model\SimplePHP|array|null.

        return $this->writeLog("This method does not exist at the SimplePHP: \"<b>{$name}</b>\".");

Are you sure the usage of $this->writeLog('This method does not exist at the SimplePHP: \"<b>'.$name.'</b>\".') targeting SimplePHP\Model\SimplePHP::writeLog() seems to always return null.

The expression return $this->writeLog('This method does not exist at the SimplePHP: \"<b>'.$name.'</b>\".') returns the type void which is incompatible with the documented return type SimplePHP\Model\SimplePHP|array|null.

    }

    /**
     * @param array $deniable
     * @return SimplePHP|null
     */
    public function except(Array $deniable): ?SimplePHP
    {
        $this->excepts = $deniable;
        return $this;
    }

    /**
     * @return null
     */
    private function deny()
    {
        if (!empty($this->excepts)) {
            foreach ($this->excepts as $except) {
                if (isset($this->data[$except])) unset($this->data[$except]);
            }
        }
    }

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

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

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

    /**
     * @param $prop
     * @return string|null
     */
    public function __get($prop): ?String
    {
        return $this->data->$prop ?? null;
    }

    public function count(): SimplePHP
    {
        $this->count = true;
        return $this;
    }

    /**
     * @return array|object|int|null
     */
    public function execute(bool $type = false)
    {
        $this->type = $type;
        try {
            if(!is_object(Connection::getConnection())) 
                return $this->writeLog("Connection failed. Check your connection config and try again.", true);

Are you sure the usage of $this->writeLog('Connection failed. Check your connection config and try again.', true) targeting SimplePHP\Model\SimplePHP::writeLog() seems to always return null.

            
            $execute = Connection::getConnection()->query("SELECT {$this->params} FROM {$this->table} {$this->where} {$this->group} {$this->order} {$this->limit} {$this->offset}");
            $execute->rowCount() > 1 ? 
                    $this->data = ($this->type ? $execute->fetchAll(PDO::FETCH_CLASS, static::class) : $execute->fetchAll(PDO::FETCH_ASSOC)) : $this->data = ($this->type ? $execute->fetchObject(static::class) : $execute->fetch(PDO::FETCH_ASSOC));
        $this->deny();
        return !$this->count ? $this->data : $execute->rowCount();
        } catch (PDOException $exc) {
            return $this->writeLog($exc->getMessage(), true);

Are you sure the usage of $this->writeLog($exc->getMessage(), true) targeting SimplePHP\Model\SimplePHP::writeLog() seems to always return null.

        }
    }

    /**
     * @return null|bool
     */
    public function destroy(): ?bool
    {
        $primary = $this->primary;
        if (!isset($this->data->$primary)) {
            return $this->writeLog("The primary index was not found.");

Are you sure the usage of $this->writeLog('The primary index was not found.') targeting SimplePHP\Model\SimplePHP::writeLog() seems to always return null.

The expression return $this->writeLog('The primary index was not found.') returns the type void which is incompatible with the type-hinted return boolean|null.

        }

        return $this->delete($this->data->$primary);
    }

    /**
     * @return null|bool
     */
    public function save()
    {
        $primary = $this->primary;
        $data = json_decode(json_encode($this->data), true);
        if (empty($primary) || !isset($data[$primary])) {
            return $this->writeLog("The primary index was not found.");

The expression return $this->writeLog('The primary index was not found.') returns the type void which is incompatible with the documented return type boolean|null.

Are you sure the usage of $this->writeLog('The primary index was not found.') targeting SimplePHP\Model\SimplePHP::writeLog() seems to always return null.

        } else if (!$this->find($data[$primary])->execute()) {
            return $this->writeLog("The primary index was not found in the database.");

Are you sure the usage of $this->writeLog('The primary index was not found in the database.') targeting SimplePHP\Model\SimplePHP::writeLog() seems to always return null.

The expression return $this->writeLog('The primary index was not found in the database.') returns the type void which is incompatible with the documented return type boolean|null.

        }

        $otherPrimary = $data[$primary];
        unset($data[$primary]);
        $parameters = implode(',', array_keys($data));
        $values = array_values($data);

        return $this->update($parameters, $values, $otherPrimary);
    }

    /**
     * @return SimplePHP|null
     */
    public function request(Array $request): ?SimplePHP
    {
        $this->request = $request;
        return $this;
    }

    /**
     * @return null|bool
     */
    public function create(): ?bool
    {
        $request = $this->request;
        if (empty($request)) {
            return $this->writeLog("No information was passed to record.");

Are you sure the usage of $this->writeLog('No information was passed to record.') targeting SimplePHP\Model\SimplePHP::writeLog() seems to always return null.

The expression return $this->writeLog('No information was passed to record.') returns the type void which is incompatible with the type-hinted return boolean|null.

        }

        $parameters = implode(',', array_keys($request));
        $values = array_values($request);
        
        return $this->insert($parameters, $values);
    }

    /**
     * @param string $message
     * @return null|Logger
     */
    protected function writeLog($message, $pdo = false): void
    {
        $log = new Logger('SimplePHP');
        $log->pushHandler(new StreamHandler(self::$config["pathLog"], Logger::WARNING));

        if($pdo) {
            $log->error($message);
            return;
        }

        $log->warning($message);
    }

    /**
     * @param string $table
     * @return SimplePHP|null
     */
    public function useTable(String $table): ?SimplePHP
    {
        $this->table = $table;
        return $this;
    }

    /**
     * @return string
     */
    public function debugQuery(): String
    {
        return "SELECT {$this->params} FROM {$this->table} {$this->where} {$this->group} {$this->order} {$this->limit} {$this->offset}";
    }

    /**
     * @return SimplePHP|null
     */
    public static function __callStatic($name, $arguments)
    {
        // if($name === 'find')
        //     return (new Static)->find($arguments[0])->execute(true);
    }

    /**
     * @return SimplePHP|null
     */
    public static function findByPrimary(Int $id) : ?SimplePHP
    {
        return (
            new static()
        )->find($id);
    }
}