Laztopaz\PotatoORM\DatabaseHandler

Complexity

Total Complexity

34

Size/Duplication

Total Lines	281
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	1
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	2
A	create()	0	20	3
B	insertRecord()	0	24	3
B	update()	0	41	6
B	read()	0	24	4
A	delete()	0	17	3
A	filterClassAttributes()	0	13	3
A	prepareUpdateQuery()	0	11	1
B	findAndWhere()	0	24	6
A	getColumnNames()	0	23	3

<?php

/**
 * @package  Laztopaz\potato-ORM
 * @author   Temitope Olotin <temitope.olotin@andela.com>
 * @license  <https://opensource.org/license/MIT> MIT
 */

namespace Laztopaz\PotatoORM;

use PDO;
use Laztopaz\PotatoORM\DatabaseHelper;
use Laztopaz\PotatoORM\TableFieldUndefinedException;
use Laztopaz\PotatoORM\EmptyArrayException;
use Laztopaz\PotatoORM\NoRecordDeletionException;
use Laztopaz\PotatoORM\NoRecordInsertionException;
use Laztopaz\PotatoORM\NoRecordUpdateException;

class DatabaseHandler {

    private $tableFields;

The property $tableFields is not used and could be removed.

    private $dbHelperInstance;

The property $dbHelperInstance is not used and could be removed.

    private $dbConnection;
    private $model;
    
    /**
     * This is a constructor; a default method  that will be called automatically during class instantiation
     */
    public function __construct($modelClassName, $dbConn = Null) 
    {
        if (is_null($dbConn)) {
            $this->dbConnection = new DatabaseConnection();

        } else {
            $this->dbConnection = $dbConn;

        }
        
        $this->model = $modelClassName;
     }
     
    /**
     * This method create a record and store it in a table row
     * @params associative array, string tablename
     * @return boolean true or false
     */
    public function create($associative1DArray, $tableName, $dbConn = Null) 
    {
        $tableFields = $this->getColumnNames($this->model, $this->dbConnection);

        $unexpectedFields = self::filterClassAttributes($tableFields, $associative1DArray);
      
        if (count($unexpectedFields) > 0) {
            throw TableFieldUndefinedException::create($unexpectedFields,"needs to be created as a table field");
        }

        unset($associative1DArray[0]);

        if (is_null($dbConn)) {
            $dbConn = $this->dbConnection;

        }

        return $this->insertRecord($dbConn, $tableName, $associative1DArray);

    }
    
    /**
     * This method runs the insertion query
     * @param  $dbConn           
     * @param  $tableName          
     * @param  $associative1DArray 
     * @return boolean true         
     */
    private function  insertRecord($dbConn, $tableName, $associative1DArray) 
    {
        $insertQuery = 'INSERT INTO '.$tableName;

        $TableValues = implode(',',array_keys($associative1DArray));

        foreach ($associative1DArray as $field => $value) {
            $FormValues[] = "'".trim(addslashes($value))."'";

$FormValues was never initialized. Although not strictly required by PHP, it is generally a good practice to add $FormValues = array(); before regardless.

        }

        $splittedTableValues = implode(',', $FormValues);

The variable $FormValues does not seem to be defined for all execution paths leading up to this point.

        $insertQuery.= ' ('.$TableValues.')';
        $insertQuery.= ' VALUES ('.$splittedTableValues.')';

        $executeQuery = $dbConn->exec($insertQuery);

        if ($executeQuery) {
            return true;
        }

        return false;

      }

    /**
     * This method updates any table by supplying 3 parameter
     * @params: $updateParams, $tableName, $associative1DArray
     * @return boolean true or false
     */
    public function update(array $updateParams, $tableName, $associative1DArray, $dbConn = null)
    {
        $sql = "";

        if (is_null($dbConn)) {
            $dbConn = $this->dbConnection;

        }

        $updateSql = "UPDATE `$tableName` SET ";

        unset($associative1DArray['id']);

        $unexpectedFields = self::filterClassAttributes($this->getColumnNames($this->model, $this->dbConnection), $associative1DArray);

        if (count($unexpectedFields) > 0) {
            throw TableFieldUndefinedException::create($unexpectedFields, "needs to be created as a table field");
        }

        foreach ($associative1DArray as $field => $value) {
            $sql .= "`$field` = '$value'".",";
        }

        $updateSql .= $this->prepareUpdateQuery($sql);

        foreach ($updateParams as $key => $val) {
            $updateSql .= " WHERE $key = $val";
        }

        $stmt = $dbConn->prepare($updateSql);

        $boolResponse = $stmt->execute();

        if ($boolResponse) {
            return true;

        }

        return false;

    }
    
  /**
   * This method retrieves record from a table
   * @params int id, string tableName
   * @return array
   */
   public static function read($id, $tableName, $dbConn = null)
   {
       $tableData = [];

       if (is_null($dbConn)) {
           $dbConn = new DatabaseConnection();
       }

       $sql = $id ? 'SELECT * FROM '.$tableName.' WHERE id = '.$id : 'SELECT * FROM '.$tableName;

       $stmt = $dbConn->prepare($sql);
       $stmt->bindValue(':table', $tableName);
       $stmt->bindValue(':id', $id);
       $stmt->execute();

       $results = $stmt->fetchAll(PDO::FETCH_ASSOC);

       foreach ($results as $result) {
           array_push($tableData, $result);
       }

       return $tableData;

   }
   
  /**
   * This method deletes a record  from a table row
   * @params int id, string tableName
   * @return boolean true or false
   */
  public static function delete($id, $tableName, $dbConn = null)
  {
      if (is_null($dbConn)) {
          $dbConn = new DatabaseConnection();
      }

      $sql = 'DELETE FROM '.$tableName.' WHERE id = '.$id;

      $boolResponse = $dbConn->exec($sql);

      if ($boolResponse) {
          return true;

      }

      throw NoRecordDeletionException::create("Record deletion unsuccessful because id does not match any record");
  }
  
  /**
   * This method checks if the magic setters array is the same as the table columns
   * @param array $tableColumn
   * @param array $userSetterArray
   * @return array $unexpectedFields
   */
  public static function filterClassAttributes(array $tableColumn, array $userSetterArray)
  {
      $unexpectedFields = [];

      foreach ($userSetterArray as $key => $val) {
          if (! in_array($key, $tableColumn)) {
              $unexpectedFields[] = $key;
          }
      }

      return $unexpectedFields;

  }
  
  /**
   * This method returns sql query
   * @param $sql
   * @return string
   */
  public function prepareUpdateQuery($sql)
  {
      $splittedQuery = explode(",",$sql);

      array_pop($splittedQuery);

      $mergeData = implode(",",$splittedQuery);

      return $mergeData;

  }
  
  /**
   * @param array $params
   * @param $tableName
   * @param $dbConn
   * @return bool
   * @throws EmptyArrayException
   */
  public function findAndWhere($params, $tableName, $dbConn = null)
  {
      if (is_null($dbConn)) {
          $dbConn = $this->dbConnection;
      }

      if (is_array($params) && !empty($params)) {
          $sql = "SELECT * FROM ".$tableName;

          foreach ($params as $key => $val) {
              $sql .= " WHERE `$key` = '$val'";
          }

          $statement = $dbConn->prepare($sql);
          $statement->execute();

          $returnedRowNumbers = $statement->rowCount();
          
          return $returnedRowNumbers ? true : false;

      }

      throw EmptyArrayException::create("Array Expected: parameter passed to this function is not an array");
  }
  
  /**
   * This method returns column fields of a particular table
   * @param $table
   * @param $conn
   * @return array
   */
  public function getColumnNames($table, $dbConn = null) 
  {
      $tableFields = [];
     
      if (is_null($dbConn)) {
         $dbConn = $this->dbConnection;
      }

      $sql = "SHOW COLUMNS FROM ".$table;
     
      $stmt = $dbConn->prepare($sql);
      $stmt->bindValue(':table', $table, PDO::PARAM_STR);
      $stmt->execute();

      $results = $stmt->fetchAll(PDO::FETCH_ASSOC);
     
      foreach ($results as $result) {
          array_push($tableFields, $result['Field']);
      }

      return $tableFields;
     
  }

}