Nip\Records\Traits\Searchable\SearchableRecordsTrait

Complexity

Total Complexity

29

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Test Coverage

Coverage

2.5%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	injectParams()	0	2	1
A	paginate()	0	15	1
A	findLast()	0	4	1
A	findOneByParams()	0	9	2
A	findOneByQuery()	0	9	2
A	findAll()	0	3	1
A	findByField()	0	5	2
A	findOne()	0	20	5
A	findByParams()	0	5	1
B	findByPrimary()	0	29	7
A	findByQuery()	0	22	6

<?php

namespace Nip\Records\Traits\Searchable;

use Nip\Database\Query\AbstractQuery as Query;
use Nip\Records\Navigator\Pagination\Paginator;
use Nip\Records\AbstractModels\Record;
use Nip\Records\Collections\Collection as RecordCollection;

/**
 * Trait SearchableRecordsTrait
 * @package Nip\Records\Traits\Searchable
 */
trait SearchableRecordsTrait
{

    /**
     * Returns paginated results
     * @param Paginator $paginator
     * @param array $params
     * @return mixed
     */
    public function paginate(Paginator $paginator, $params = [])
    {
        $query = $this->paramsToQuery($params);

It seems like paramsToQuery() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $countQuery = $this->getDB()->newSelect();

It seems like getDB() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $countQuery->count(['*', 'count']);
        $countQuery->from([$query, 'tbl']);
        $results = $countQuery->execute()->fetchResults();
        $count = $results[0]['count'];

        $paginator->setCount($count);

The method setCount() does not exist on Nip\Records\Navigator\Pagination\Paginator.

        $params['limit'] = $paginator->getLimits();

The method getLimits() does not exist on Nip\Records\Navigator\Pagination\Paginator. Did you maybe mean getLimitStart()?

        return $this->findByParams($params);
    }

    /**
     * @param array $params
     */
    protected function injectParams(&$params = [])

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

    {
    }

    /**
     * @return RecordCollection
     */
    public function findAll()
    {
        return $this->findByParams();
    }

    /**
     * @param int $count
     * @return RecordCollection
     */
    public function findLast($count = 9)
    {
        return $this->findByParams([
            'limit' => $count,
        ]);
    }

    /**
     * Checks the registry before fetching from the database
     * @param mixed $primary
     * @return Record
     */
    public function findOne($primary)
    {
        $item = $this->getRegistry()->get($primary);

It seems like getRegistry() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        if (!$item) {
            $all = $this->getRegistry()->get("all");
            if ($all) {
                $item = $all[$primary];
            }
            if (!$item) {
                $params['where'][] = ["`{$this->getTable()}`.`{$this->getPrimaryKey()}` = ?", $primary];

It seems like getTable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

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

It seems like getPrimaryKey() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                $item = $this->findOneByParams($params);

Are you sure the assignment to $item is correct as $this->findOneByParams($params) targeting Nip\Records\Traits\Searchable\SearchableRecordsTrait::findOneByParams() seems to always return null.

                if ($item) {

$item is of type null, thus it always evaluated to false.

                    $this->getRegistry()->set($primary, $item);
                }

                return $item;
            }
        }

        return $item;
    }

    /**
     * When searching by primary key, look for items in current registry before
     * fetching them from the database
     *
     * @param array $pk_list
     * @return RecordCollection
     */
    public function findByPrimary($pk_list = [])
    {
        $pk = $this->getPrimaryKey();
        $return = $this->newCollection();

It seems like newCollection() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        if ($pk_list) {

The expression $pk_list 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.

            $pk_list = array_unique($pk_list);
            foreach ($pk_list as $key => $value) {
                $item = $this->getRegistry()->get($value);
                if ($item) {
                    unset($pk_list[$key]);
                    $return[$item->{$pk}] = $item;
                }
            }
            if ($pk_list) {

The expression $pk_list 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.

                $query = $this->paramsToQuery();
                $query->where("$pk IN ?", $pk_list);
                $items = $this->findByQuery($query);

                if (count($items)) {
                    foreach ($items as $item) {
                        $this->getRegistry()->set($item->{$pk}, $item);
                        $return[$item->{$pk}] = $item;
                    }
                }
            }
        }

        return $return;
    }


    /**
     * Finds one Record using params array
     *
     * @param array $params
     * @return Record|null
     */
    public function findOneByParams(array $params = [])
    {
        $params['limit'] = 1;
        $records = $this->findByParams($params);
        if (count($records) > 0) {
            return $records->rewind();

Are you sure the usage of $records->rewind() targeting Nip\Collections\AbstractCollection::rewind() seems to always return null.

The expression return $records->rewind() returns the type void which is incompatible with the documented return type Nip\Records\AbstractModels\Record|null.

        }

        return null;
    }

    /**
     * Finds Records using params array
     *
     * @param array $params
     * @return RecordCollection
     */
    public function findByParams($params = [])
    {
        $query = $this->paramsToQuery($params);

        return $this->findByQuery($query, $params);
    }

    /**
     * @param Query $query
     * @param array $params
     * @return bool
     */
    public function findOneByQuery($query, $params = [])
    {
        $query->limit(1);
        $return = $this->findByQuery($query, $params);
        if (count($return) > 0) {
            return $return->rewind();

The expression return $return->rewind() returns the type void which is incompatible with the documented return type boolean.

Are you sure the usage of $return->rewind() targeting Nip\Collections\AbstractCollection::rewind() seems to always return null.

        }

        return null;
    }

    /**
     * @param $field
     * @param $value
     * @return mixed
     */
    public function findByField($field, $value)
    {
        $params['where'][] = ["$field " . (is_array($value) ? "IN" : "=") . " ?", $value];

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

        return $this->findByParams($params);
    }

    /**
     * @param Query $query
     * @param array $params
     * @return RecordCollection
     */
    public function findByQuery($query, $params = [])
    {
        $return = $this->newCollection();

        $results = $this->getDB()->execute($query);
        if ($results->numRows() > 0) {
            $pk = $this->getPrimaryKey();
            /** @noinspection PhpAssignmentInConditionInspection */
            while ($row = $results->fetchResult()) {
                $item = $this->getNew($row);

It seems like getNew() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                if (is_string($pk)) {
                    $this->getRegistry()->set($item->getPrimaryKey(), $item);
                }
                if (isset($params['indexKey']) && !empty($params['indexKey'])) {
                    $return->add($item, $params['indexKey']);
                } else {
                    $return->add($item);
                }
            }
        }

        return $return;
    }
}