SearchableRecordsTrait::findByParams() - Code Metrics - Inspection of "Merge branch '0.9' into develop" - bytic/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 9060a9...8d9a79 )

by Gabriel
created 2019-03-27 08:15 UTC
SearchableRecordsTrait::findByParams() A

↳ Parent: SearchableRecordsTrait
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
cc	1
eloc	2
nc	1
nop	1
dl	0
loc	5
ccs	0
cts	3
cp	0
crap	2
rs	10
c	0
b	0
f	0
<?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);
        $query = $this->paramsToQuery($params);

        $countQuery = $this->getDB()->newSelect();
        $countQuery = $this->/** @scrutinizer ignore-call */ getDB()->newSelect();
        $countQuery->count(['*', 'count']);
        $countQuery->from([$query, 'tbl']);
        $results = $countQuery->execute()->fetchResults();
        $count = $results[0]['count'];

        $paginator->setCount($count);
                    setCount($count);

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

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

    /**
     * @param array $params
     */
    protected function injectParams(&$params = [])
    protected function injectParams(/** @scrutinizer ignore-unused */ &$params = [])
    {
    }

    /**
     * @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);
        $item = $this->/** @scrutinizer ignore-call */ getRegistry()->get($primary);
        if (!$item) {
            $all = $this->getRegistry()->get("all");
            if ($all) {
                $item = $all[$primary];
            }
            if (!$item) {
                $params['where'][] = ["`{$this->getTable()}`.`{$this->getPrimaryKey()}` = ?", $primary];
                $params['where'][] = ["`{$this->getTable()}`.`{$this->/** @scrutinizer ignore-call */ getPrimaryKey()}` = ?", $primary];
                $item = $this->findOneByParams($params);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                if ($item) {

                    $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();
        $return = $this->newCollection();

        if ($pk_list) {

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

                $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();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        }

        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();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        }

        return null;
    }

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


        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);
                $item = $this->getNew($row);
                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;
    }
}

bytic / orm

Push — master ( 9060a9...8d9a79 )

SearchableRecordsTrait::findByParams() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
