samsoncms\api\query\Record

Complexity

Total Complexity

27

Size/Duplication

Total Lines	289
Duplicated Lines	12.11 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	8
Bugs	3	Features	1

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	2
A	select()	14	16	4
A	orderBy()	8	8	2
A	limit()	0	6	1
A	prepareQuery()	0	21	4
A	find()	0	12	1
A	primary()	0	4	1
A	where()	0	15	3
A	sortArrayByArray()	0	11	3
A	fields()	0	9	1
A	first()	0	12	1
A	count()	0	8	1
A	convertToDateTime()	0	4	1
A	applySorting()	13	13	2

<?php
/**
 * Created by PhpStorm.
 * User: nazarenko
 * Date: 29.03.2016
 * Time: 10:52
 */
namespace samsoncms\api\query;

use samson\activerecord\dbQuery;
use samsoncms\api\exception\WrongQueryConditionArgument;
use samsonframework\orm\ArgumentInterface;
use samsonframework\orm\Condition;
use samsonframework\orm\ConditionInterface;
use samsonframework\orm\QueryInterface;

/**
 * Generic real database entity query class.
 *
 * @package samsoncms\api\query
 */
class Record
{
    /** @var string Table class name */
    protected static $identifier;

    /** @var array Collection of all supported entity fields ids => names */
    protected static $fieldIDs = array();

    /** @var array Collection of all supported entity fields names => ids */
    protected static $fieldNames = array();

    /** @var string Table primary field name */
    protected static $primaryFieldName;

    /** @var QueryInterface Database query instance */
    protected $query;

    /** @var array Collection of entity fields to retrieved from database */
    protected $selectedFields;

    /** @var ConditionInterface Query conditions */
    protected $conditions;

    /** @var array Collection of ordering parameters */
    protected $orderBy = array();

    /** @var array Collection of limit parameters */
    protected $limit = array();

    /** @var array Collection of entity identifiers */
    protected $entityIDs = array();

    /**
     * Generic constructor.
     *
     * @param QueryInterface $query Database query instance
     */
    public function __construct(QueryInterface $query = null)
    {
        $this->query = null === $query ? new dbQuery() : $query;
        $this->conditions = new Condition();
    }

    /**
     * Select specified entity fields.
     * If this method is called then only selected entity fields
     * would be filled in entity instances.
     *
     * @param mixed $fieldNames Entity field name or collection of names
     *
     * @return $this Chaining
     */
    public function select($fieldNames)

This method seems to be duplicated in your project.

    {
        // TODO: Query has no implementation for selecting needed fields

        // Convert argument to array and iterate
        foreach ((!is_array($fieldNames) ? array($fieldNames) : $fieldNames) as $fieldName) {
            // Try to find entity additional field
            $pointer = &static::$fieldNames[$fieldName];
            if (null !== $pointer) {
                // Store selected additional field buy FieldID and Field name
                $this->selectedFields[$pointer] = $fieldName;
            }
        }

        return $this;
    }

    /**
     * Set field for sorting.
     *
     * @param string $fieldName Additional field name
     * @param string $order     Sorting order
     *
     * @return $this Chaining
     */
    public function orderBy($fieldName, $order = 'ASC')

This method seems to be duplicated in your project.

    {
        if (in_array($fieldName, static::$fieldIDs)) {
            $this->orderBy = array($fieldName, $order);
        }

        return $this;
    }

    /**
     * Set query results limitation.
     *
     * @param int $count Amount of entities to receive
     * @param int $offset Entities starting number
     *
     * @return $this Chaining
     */
    public function limit($count, $offset = 0)
    {
        $this->limit = array($offset, $count);

        return $this;
    }

    /**
     * Perform internal query preparation.
     */
    protected function prepareQuery()
    {
        $this->query->entity(static::$identifier);

        // Set entity primary keys if predefined
        if (count($this->entityIDs)) {
            $this->primary($this->entityIDs);

$this->entityIDs is of type array, but the function expects a string.

        }

        // Add query sorting
        if (count($this->orderBy) === 2) {
            $this->query->orderBy($this->orderBy[0], $this->orderBy[1]);
        }

        // Add query limitation
        if (count($this->limit) === 2) {
            $this->query->limit($this->limit[0], $this->limit[1]);
        }

        // TODO: Add grouping
    }

    /**
     * Perform SamsonCMS query and get entities collection.
     *
     * @return \samsoncms\api\Entity[] Collection of found entities
     */
    public function find()
    {
        $this->prepareQuery();

        // Proxy to regular database query
        $return = $this->query
            ->whereCondition($this->conditions)
            ->exec();

        // Reorder if entity identifiers collection was defined
        return $this->sortArrayByArray($return, $this->entityIDs);

It seems like $return defined by $this->query->whereCondition($this->conditions)->exec() on line 158 can also be of type boolean; however, samsoncms\api\query\Record::sortArrayByArray() does only seem to accept array, maybe add an additional type check?

    }

    /**
     * Add primary field query condition.
     *
     * @param string $value Field value
     * @param string $fieldRelation
     *
     * @return $this Chaining
     * @see Material::where()
     */
    public function primary($value, $fieldRelation = ArgumentInterface::EQUAL)
    {
        return $this->where(static::$primaryFieldName, $value, $fieldRelation);
    }

    /**
     * Add condition to current query.
     *
     * @param string $fieldName Entity field name
     * @param mixed $fieldValue Value
     * @param string $fieldRelation
     *
     * @return $this Chaining
     *
     * @throws WrongQueryConditionArgument
     */
    public function where($fieldName, $fieldValue = null, $fieldRelation = ArgumentInterface::EQUAL)
    {
        // Ignore objects
        if (!is_object($fieldValue)) {
            // Get real table field name
            if (array_key_exists($fieldName, static::$fieldNames)) {
                $fieldName = static::$fieldNames[$fieldName];
            }
            $this->conditions->add($fieldName, $fieldValue, $fieldRelation);
        } else {
            throw new WrongQueryConditionArgument('Object is passed to condition');
        }

        return $this;
    }

    /**
     * Reorder elements in one array according to keys of another.
     *
     * @param array $array Source array
     * @param array $orderArray Ideal array
     * @return array Ordered array
     */
    protected function sortArrayByArray(array $array, array $orderArray)
    {
        $ordered = array();
        foreach ($orderArray as $key) {
            if (array_key_exists($key, $array)) {
                $ordered[$key] = $array[$key];
                unset($array[$key]);
            }
        }
        return array_merge($ordered, $array);
    }

    /**
     * Perform SamsonCMS query and get collection of entities fields.
     *
     * @param string $fieldName Entity field name
     *
     * @return array Collection of entity fields
     */
    public function fields($fieldName)
    {
        $this->prepareQuery();

        // Proxy to regular database query
        return $this->query
            ->whereCondition($this->conditions)
            ->fields($fieldName);
    }

    /**
     * Perform SamsonCMS query and get first matching entity.
     *
     * @return \samsoncms\api\Entity First matching entity
     */
    public function first()
    {
        $this->prepareQuery();

        // Proxy to regular database query
        $return = $this->query
            ->limit(1)
            ->whereCondition($this->conditions)
            ->exec();

        return array_shift($return);
    }

    /**
     * Perform SamsonCMS query and get amount resulting entities.
     *
     * @return int Amount of resulting entities
     */
    public function count()
    {
        // Proxy to regular database query
        return $this->query
            ->entity(static::$identifier)
            ->whereCondition($this->conditions)
            ->count();
    }

    /**
     * Convert date value to database format.
     * TODO: Must implement at database layer
     *
     * @param string $date Date value for conversion
     *
     * @return string Converted date to correct format
     */
    protected function convertToDateTime($date)
    {
        return date('Y-m-d H:i:s', strtotime($date));
    }

    /**
     * Add sorting to entity identifiers.
     *
     * @param array  $entityIDs
     * @param string $fieldName Additional field name for sorting
     * @param string $order     Sorting order(ASC|DESC)
     *
     * @return array Collection of entity identifiers ordered by additional field value
     */
    protected function applySorting(array $entityIDs, $fieldName, $order = 'ASC')

This method seems to be duplicated in your project.

    {
        if (array_key_exists($fieldName, static::$fieldIDs)) {
            // Order by parent fields
            return $this->query
                ->entity(static::$identifier)
                ->where(static::$primaryFieldName, $entityIDs)
                ->orderBy($fieldName, $order)
                ->fields(static::$primaryFieldName);
        } else { // Nothing is changed
            return $entityIDs;
        }
    }
}