Laztopaz\potatoORM\DatabaseHandler

Complexity

Total Complexity

34

Size/Duplication

Total Lines	264
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	23
Bugs	1	Features	7

9 Methods

Rating	Name	Duplication	Size	Complexity
A	checkIfMagicSetterContainsIsSameAsClassModel()	0	14	3
A	__construct()	0	9	2
B	create()	0	33	5
B	update()	0	39	6
B	read()	0	31	5
A	delete()	0	14	3
A	prepareUpdateQuery()	0	10	1
B	findAndWhere()	0	27	6
A	getColumnNames()	0	22	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;

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)
	{
		$unexpectedFields = self::checkIfMagicSetterContainsIsSameAsClassModel($this->getColumnNames($this->model, $this->dbConnection),$associative1DArray);

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

		unset($this->getColumnNames($this->model, $this->dbConnection)[0]);

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

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

		return $executeQuery ? : 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::checkIfMagicSetterContainsIsSameAsClassModel($this->getColumnNames($this->model, $this->dbConnection),$associative1DArray);

		if (count($unexpectedFields) > 0) {

			throw TableFieldUndefinedException::fieldsNotDefinedException($unexpectedFields,"needs to be created as 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();

		return $boolResponse ?  : false;
	}

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

		if (is_null($dbConn)) {

			$dbConn = new DatabaseConnection();

		}

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

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

		} catch (PDOException $e) {

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

			return  $e->getMessage();
		}
		$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);

		return $boolResponse ? : false;
	}

	/**
	 * 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 checkIfMagicSetterContainsIsSameAsClassModel(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)
	{
		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::checkEmptyArrayException("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;

		}


}