BWC\Share\Data\BaseRepository

Complexity

Total Complexity

35

Size/Duplication

Total Lines	226
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
	_getTableName()	0	1	?
	_getClassName()	0	1	?
A	__construct()	0	3	1
A	_getPrimaryKeyColumnName()	0	3	1
A	_isAutoincrement()	0	3	1
A	hydrateObject()	0	9	2
A	_getNonDbFields()	0	3	1
A	getClassFields()	0	11	3
A	getFields()	0	9	2
A	hasClassField()	0	4	1
A	hydrateArray()	0	7	2
A	getCommonSelect()	0	3	1
A	_getByID()	0	7	2
B	_getAllBy()	0	28	7
B	_save()	0	23	7
A	_getObjectData()	0	4	1
A	select()	0	3	1
A	deleteByID()	0	3	1
A	transactional()	0	3	1

<?php

namespace BWC\Share\Data;

use BWC\Share\Object\ObjectHelper;
use Doctrine\DBAL\Connection;


abstract class BaseRepository
{
    /** @var \Doctrine\DBAL\Connection */
    protected $_con;

    /** @var int */
    public $totalRows = 0;


    /** @var array */
    private $_classFields = null;



    function __construct(Connection $connection) {

It is generally recommended to explicitly declare the visibility for methods.

        $this->_con = $connection;
    }


    protected function _getPrimaryKeyColumnName() {
        return 'id';
    }

    protected function _isAutoincrement() {
        return true;
    }

    abstract function _getTableName();

It is generally recommended to explicitly declare the visibility for methods.

    abstract function _getClassName();

It is generally recommended to explicitly declare the visibility for methods.

    /**
     * @param object|array|null $row
     * @param string $prefix
     * @return object|null
     */
    function hydrateObject($row, $prefix = '') {

It is generally recommended to explicitly declare the visibility for methods.

        $result = null;
        if ($row) {
            $class = $this->_getClassName();
            $result = new $class();
            ObjectHelper::copyExistingProperties($row, $result, $prefix);
        }
        return $result;
    }


    protected function _getNonDbFields() {
        return array();
    }


    /**
     * @return array   field=>defaultValue
     */
    protected function getClassFields() {
        if ($this->_classFields === null) {
            $this->_classFields = get_class_vars($this->_getClassName());
            $nonDbFields = $this->_getNonDbFields();
            foreach ($nonDbFields as $f) {
                unset($this->_classFields[$f]);
            }
        }

        return $this->_classFields;
    }


    /**
     * @return string[]
     */
    function getFields() {

It is generally recommended to explicitly declare the visibility for methods.

        $result = array();
        $arr = $this->getClassFields();
        $arr = array_keys($arr);
        foreach ($arr as $field) {
            $result[] = $field;
        }
        return $result;
    }


    /**
     * @param string $fieldName
     * @return bool
     */
    protected function hasClassField($fieldName) {
        $result = array_key_exists((string)$fieldName, $this->getClassFields());
        return $result;
    }

    /**
     * @param array $array
     * @param string $prefix
     * @return object[]
     */
    function hydrateArray(array $array, $prefix = '') {

It is generally recommended to explicitly declare the visibility for methods.

        $result = array();
        foreach ($array as $row) {
            $result[] = $this->hydrateObject($row, $prefix);
        }
        return $result;
    }



    /**
     * @return \BWC\Share\Data\Select
     */
    protected function getCommonSelect() {
        return $this->select();
    }


    /**
     * @param int $id
     * @return object|null
     */
    protected function _getByID($id) {
        $select = $this->getCommonSelect();
        $alias = $select->getAlias();
        $name = $alias ? $alias.'.id' : 'id';
        $row = $this->getCommonSelect()->where($name, $id)->getRow();
        return $this->hydrateObject($row, '');
    }


    /**
     * @param array $filter   column=>value
     * @param int $pageNum
     * @param int $pageSize
     * @param array|string|null $orderBy
     * @throws \InvalidArgumentException
     * @return object[]
     */
    protected function _getAllBy(array $filter = null, $pageNum = 0, $pageSize = 0, $orderBy = null) {
        $arrWhere = array();
        $arrKeys = array();
        if ($filter) {
            foreach ($filter as $key=>$value) {
                if (!$this->hasClassField($key)) {
                    throw new \InvalidArgumentException($key);
                }
                $arrWhere[] = "`{$key}`=:{$key}";
                $arrKeys[":{$key}"] = $value;
            }
        }
        $pageSize = intval($pageSize);
        $select = $this->getCommonSelect();
        if ($arrWhere) {

The expression $arrWhere of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $select->where($filter);

It seems like $filter defined by parameter $filter on line 147 can also be of type null; however, BWC\Share\Data\Select::where() does only seem to accept array|string, maybe add an additional type check?

        }
        if ($orderBy) {
            $select->sort($orderBy);
        }
        if ($pageSize) {
            $select->paging($pageNum, $pageSize);
        }
        $pr = $select->pagedResult();
        $this->totalRows = $pr->totalRows;
        $result = $this->hydrateArray($pr->data);
        return $result;
    }



    /**
     * @param object $object Entity to save
     * @param array|null $unsetColumns
     * @return int Affected rows
     */
    protected function _save($object, array $unsetColumns = null) {
        $data = $this->_getObjectData($object);
        if ($unsetColumns) {
            foreach ($unsetColumns as $col) {
                unset($data[$col]);
            }
        }
        foreach ($this->_getNonDbFields() as $col) {
            unset($data[$col]);
        }
        $pk = $this->_getPrimaryKeyColumnName();
        if (isset($object->$pk) && $object->$pk) {
            $arrID = array($pk=>$object->$pk);
            unset($data[$pk]);
            $affectedRows = $this->_con->update($this->_getTableName(), $data, $arrID);
        } else {
            $affectedRows = $this->_con->insert($this->_getTableName(), $data);
            if ($this->_isAutoincrement()) {
                $object->$pk = $this->_con->lastInsertId();
            }
        }
        return $affectedRows;
    }

    protected function _getObjectData($object)
    {
        return get_object_vars($object);
    }

    /**
     * @param null|array|string $columns
     * @param null|string $alias
     * @return Select
     */
    function select($columns = null, $alias = null) {

It is generally recommended to explicitly declare the visibility for methods.

        return new Select($this->_getTableName(), $this->_con, $columns, $alias);
    }


    /**
     * @param $id
     * @return int  affected rows
     */
    function deleteByID($id) {

It is generally recommended to explicitly declare the visibility for methods.

        return $this->_con->delete($this->_getTableName(), array($this->_getPrimaryKeyColumnName() => $id));
    }


    function transactional(\Closure $func) {

It is generally recommended to explicitly declare the visibility for methods.

        $this->_con->transactional($func);
    }
}