Pyjac\ORM\Model

Complexity

Total Complexity

29

Size/Duplication

Total Lines	216
Duplicated Lines	100 %

Coupling/Cohesion

Components	1
Dependencies	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	5	5	1
A	__set()	4	4	1
A	__get()	4	4	1
A	getProperties()	4	4	1
A	getTableName()	6	6	1
A	find()	5	5	1
A	get()	11	11	2
A	getAll()	5	5	1
A	all()	9	9	1
B	update()	24	24	6
B	create()	30	30	5
A	getConnection()	7	7	2
A	save()	8	8	2
A	destroy()	12	12	3
A	__callStatic()	7	7	1

<?php 

namespace Pyjac\ORM;

abstract class Model implements ModelInterface

This class seems to be duplicated in your project.

{

   
    protected  $properties = [];

    /**
     * Store instance of database connection used.
    * @var [type]
    */
    protected  $databaseConnection;

     public function __construct()
    {
        $this->databaseConnection = DatabaseConnection::getInstance()->databaseConnection;
        //$databaseConnection->databaseConnection->connect();

75% of this comment could be valid code. Did you maybe forget this after debugging?

    }
    /**
    * @param string $key rep column name
    * @param string $val rep column value
    * sets into $propertie the $key => $value pairs
    */
    public  function __set($key, $val)
    {
        $this->properties[$key] = $val;
    }
    /**
    * @param string $key reps the column name
    * @return $key and $value

The doc-type $key could not be parsed: Unknown type name "$key" at position 0. (view supported doc-types)

    */
    public function __get($key)
    {
        return $this->properties[$key];
    }
    /**
     * Get all the model properties
     *
     * @return array
     */
     public function getProperties()
     {
         return $this->properties;
     }
    /**
    * Gets the name of the child class only
    * without the namespace
    * @var $className
    * @var $table
    * @return $table

The doc-type $table could not be parsed: Unknown type name "$table" at position 0. (view supported doc-types)

    */
    public function getTableName()
    {
        $className = explode('\\', get_called_class());
        $table = strtolower(end($className) .'s');
        return $table;
    }
    /**
    * returns a particular record
    * @param $id reps the record id
    * @param $connection initialised to null
    * @return object
    */
    public static function find($id)
    {
        $model = new static;
        return $model->get($id); 
    }
    /**
    * returns a particular record
    * @param $id reps the record id
    * @param $connection initialised to null
    * @return object
    */
    public function get($id)
    {
        $sql = "SELECT * FROM {$this->getTableName()} WHERE id={$id}";
        $sqlStatement = $this->databaseConnection->prepare($sql);
        $sqlStatement->setFetchMode($this->databaseConnection::FETCH_CLASS, get_called_class());
        $sqlStatement->execute();
        if($sqlStatement->rowCount() < 1){
            throw new ModelNotFoundException($id);
        }
        return $sqlStatement->fetch();
    }
    
    public static function getAll()
    {
        $model = new static;
        return $model->all();
    }

    public function all()
    {
        $sql = "SELECT * FROM {$this->getTableName()}";
        $row = $this->databaseConnection->prepare($sql);
        $row->execute();
       
        return $row->fetchAll($this->databaseConnection::FETCH_CLASS);

    }
    /** update table with instance properties
    *
    */
    private function update()
    {
        $connection = $this->getConnection();
        $columnNames = "";

$columnNames is not used, you could remove the assignment.

        $columnValues = "";

$columnValues is not used, you could remove the assignment.

        $count = 0;
        $update = "UPDATE " . $this->getTableName() . " SET " ;
        foreach ($this->properties as $key => $val) {
            $count++;
            if(($key == 'id')) continue;
            $update .= "$key = '$val'";
            if ($count < count($this->properties) )
            {
                $update .=",";
            }
        }
        $update .= " WHERE id = " . $this->properties['id'];
        $stmt = $connection->prepare($update);
            foreach ($this->properties as $key => $val) {
                if($key == 'id') continue;
            }
        $stmt->execute();
        return $stmt->rowCount();
    }
    /**
    * insert instance data into the table
    */
    private function create()
    {
        $connection = $this->getConnection();
        $columnNames = "";
        $columnValues = "";
        $count = 0;
        $create = "INSERT" . " INTO " . $this->getTableName()." (";
            foreach ($this->properties as $key => $val) {
                $columnNames .= $key;
                $columnValues .= ':' . $key;
                $count++;
                if ($count < count($this->properties))
                {
                    $columnNames .= ', ';
                    $columnValues .= ', ';
                }
            }
        $create .= $columnNames.') VALUES (' .$columnValues.')';
        $stmt = $connection->prepare($create);
            foreach ($this->properties as $key => $val) {
                $stmt->bindValue(':'.$key, $val);
            }
            try {
                // if prop returned and props from db differ throw exception
                $stmt->execute();
            } catch(PDOException $e){

The class Pyjac\ORM\PDOException does not exist. Did you forget a USE statement, or did you not list all dependencies?

                return $e->getExceptionMessage();
            }
        return $stmt->rowCount();
    }
    /**
    * get db connection
    */
    public function getConnection($connection = null)
    {
        if(is_null($connection))
        {
            return new Connection();
        }
    }
    /**
    * checks if the id exists
    * update if exist
    * create if not exist
    */
    public function save()
    {
        if ($this->id) {

The property id does not exist on object<Pyjac\ORM\Model>. Since you implemented __get, maybe consider adding a @property annotation.

            $this->update();
        } else {
            $this->create();
        }
    }
    /**
    * @param row reps record id
    * @param $connection initialised to null
    * @return boolean
    */
    public static function destroy($id)
    {
        
        $sql = "DELETE" . " FROM " . self::getTableName()." WHERE id = ". $id;
        $delete = $connection->prepare($sql);

The variable $connection does not exist. Did you forget to declare it?

        $delete->execute();
        $count = $delete->rowCount();
        if ($count < 1) {
            throw new RecordNotFoundException('Record with id ' . $id . ' does not exist.');
        }
        return ($count > 0) ? true : false;
    }

    /**
     * Handle dynamic static method calls into the method.
     *
     * @param  string  $method
     * @param  array  $parameters
     * @return mixed
     */
    public static function __callStatic($method, $parameters)

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

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

    {
        exit("HERE");
        $instance = new static;

$instance = new static(); does not seem to be reachable.

        return call_user_func_array([$instance, $method], $parameters);
    }   
}