Ibonly\PotatoORM\Model

Complexity

Total Complexity

21

Size/Duplication

Total Lines	194
Duplicated Lines	12.89 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	30
Bugs	0	Features	2

11 Methods

Rating	Name	Duplication	Size	Complexity
A	stripclassName()	0	7	1
A	tableName()	0	7	2
A	fields()	0	10	3
A	getClassName()	0	8	2
A	getTableName()	0	4	1
A	getALL()	0	13	2
A	where()	0	14	2
A	find()	0	16	2
A	save()	13	13	2
A	update()	12	12	2
A	destroy()	0	13	2

<?php
/**
 * PotatoORM manages the persistence of database CRUD operations.
 *
 * @package Ibonly\PotatoORM\Model
 * @author  Ibraheem ADENIYI <ibonly01@gmail.com>
 * @license MIT <https://opensource.org/licenses/MIT>
 */

namespace Ibonly\PotatoORM;

use PDO;
use Exception;
use PDOException;
use Ibonly\PotatoORM\GetData;
use Ibonly\PotatoORM\DatabaseQuery;
use Ibonly\PotatoORM\ModelInterface;
use Ibonly\PotatoORM\DataNotFoundException;
use Ibonly\PotatoORM\EmptyDatabaseException;
use Ibonly\PotatoORM\ColumnNotExistExeption;
use Ibonly\PotatoORM\DataAlreadyExistException;
use Ibonly\PotatoORM\InvalidConnectionException;

class Model extends DatabaseQuery implements ModelInterface
{
    //Inject the inflector trait
    use Inflector;

    /**
     * stripclassName()
     *
     * @return string
     */
    public static function stripclassName()
    {
        $className = strtolower(get_called_class());
        $nameOfClass = explode("\\", $className);

        return end($nameOfClass);
    }

    /**
     * Get the table name if defined in the model
     * 
     * @return string
     */
    public function tableName()
    {
        if(isset($this->table)) {
            return $this->table;

The property table does not exist. Did you maybe forget to declare it?

        }
        return null;
    }

    /**
     * Get the fields to be fillables defined in the model
     * 
     * @return string
     */
    public function fields()
    {
        if (isset($this->fillables)) {
            if (sizeof($this->fillables) > 0) {
                return implode(", ", $this->fillables);

The property fillables does not exist. Did you maybe forget to declare it?

            }
            return '*';
        }
        return '*';
    }

    /**
     * getClassName()
     *
     * @return string
     */
    public function getClassName()
    {
        if ($this->tableName() === null) {
            return self::pluralize(self::stripclassName());
        } else {
            return $this->tableName();
        }
    }

    /**
     * getTableName()
     *
     * @return string
     */
    public function getTableName($connection)
    {
        return DatabaseQuery::checkTableName($this->getClassName(), $connection);
    }

    /**
     * getALL()
     * Get all record from the database
     *
     * @return object
     */
    public function getALL($dbConnection = NULL)
    {
        $connection = DatabaseQuery::checkConnection($dbConnection);

        $sqlQuery = DatabaseQuery::selectAllQuery(self::getTableName($connection), self::fields());
        $query = $connection->prepare($sqlQuery);

The method prepare cannot be called on $connection (of type string).

        $query->execute();
        if ( $query->rowCount() )
        {
            return new GetData($query->fetchAll($connection::FETCH_ASSOC));
        }
        throw new EmptyDatabaseException();
    }

    /**
     * where($data, $condition)
     * Get data from database where $data = $condition
     *
     * @return object
     */
    public function where($data, $condition = NULL, $dbConnection = NULL)
    {
        $databaseQuery = new DatabaseQuery();
        $connection = $databaseQuery->checkConnection($dbConnection);

        $sqlQuery = $databaseQuery->selectQuery(self::getTableName($connection), $data, $condition, $connection);
        $query = $connection->prepare($sqlQuery);

The method prepare cannot be called on $connection (of type string).

        $query->execute();
        if ( $query->rowCount() )
        {
            return new GetData($query->fetchAll($connection::FETCH_ASSOC));
        }
        throw new DataNotFoundException();
    }

    /**
     * find($value)
     * Find data from database where id = $value
     *
     * @return array
     */
    public static function find($value, $dbConnection = NULL)
    {
        $connection = DatabaseQuery::checkConnection($dbConnection);

        $sqlQuery = DatabaseQuery::selectQuery(self::getTableName($connection), ['id' => $value], NULL, $connection);
        $query = $connection->prepare($sqlQuery);

The method prepare cannot be called on $connection (of type string).

        $query->execute();
        if ( $query->rowCount() )
        {
            $found = new static;
            $found->id = $value;

The property id does not exist. Did you maybe forget to declare it?

            $found->data = $query->fetchAll($connection::FETCH_ASSOC);

The property data does not exist. Did you maybe forget to declare it?

            return $found;
        }
        throw new DataNotFoundException();
    }

    /**
     * save()
     * Insert data into database
     *
     * @return bool
     */
    public function save($dbConnection = NULL)

This method seems to be duplicated in your project.

    {
        $connection = DatabaseQuery::checkConnection($dbConnection);

        $query = $this->insertQuery(self::getTableName($connection));
        $statement = $connection->prepare($query);

The method prepare cannot be called on $connection (of type string).

        if( $statement->execute() )
        {
            return true;
        }
        throw new  DataAlreadyExistException();

    }

    /**
     * update()
     * Update details in database after ::find(2)
     *
     * @return bool
     */
    public function update($dbConnection = NULL)

This method seems to be duplicated in your project.

    {
        $connection = DatabaseQuery::checkConnection($dbConnection);

        $updateQuery = $this->updateQuery(self::getTableName($connection));
        $statement = $connection->prepare($updateQuery);

The method prepare cannot be called on $connection (of type string).

        if( $statement->execute() )
        {
            return true;
        }
        throw new  DataAlreadyExistException();
    }

    /**
     * destroy($value)
     * Delete data from database
     *
     * @return bool
     */
    public function destroy($value, $dbConnection = NULL)
    {
        $connection = DatabaseQuery::checkConnection($dbConnection);

        $query = $connection->prepare('DELETE FROM ' . self::getTableName($connection) . ' WHERE id = '.$value);

The method prepare cannot be called on $connection (of type string).

        $query->execute();
        $check = $query->rowCount();
        if ($check)
        {
            return true;
        }
        throw new DataNotFoundException;
    }
}