ActiveRecordsTrait::deleteByParams() - Code Metrics - Inspection of "small fixes" - bytic/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 470d43...3f2648 )

by Gabriel
created 2018-11-20 09:29 UTC
ActiveRecordsTrait::deleteByParams() A

↳ Parent: ActiveRecordsTrait
Complexity

Conditions	6
Paths	12
Size

Total Lines	28
Code Lines	15
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	42
Importance

Changes
Metric	Value
cc	6
eloc	15
nc	12
nop	1
dl	0
loc	28
ccs	0
cts	15
cp	0
crap	42
rs	9.2222
c	0
b	0
f	0
<?php

namespace Nip\Records\Traits\ActiveRecord;

use Nip\Container\Container;
use Nip\Database\Connections\Connection;
use Nip\Database\Query\AbstractQuery as Query;
use Nip\Database\Query\Delete as DeleteQuery;
use Nip\Database\Query\Insert as InsertQuery;
use Nip\Database\Query\Select as SelectQuery;
use Nip\Database\Query\Update as UpdateQuery;
use Nip\Database\Result;
use Nip\Paginator;
filter:
    dependency_paths: ["lib/*"]
use Nip\Records\AbstractModels\Record;
use Nip\Records\Collections\Collection as RecordCollection;
use Nip\Records\Traits\Unique\RecordsTrait as UniqueRecordsTrait;
use Nip\Records\Traits\HasForeignKey\RecordsTrait as HasForeignKeyTrait;

/**
 * Class ActiveRecordsTrait
 * @package Nip\Records\Traits\ActiveRecord
 */
trait ActiveRecordsTrait
{
    use UniqueRecordsTrait;
    use HasForeignKeyTrait;

    /**
     * @var Connection
     */
    protected $connection = null;

    /**
     * @var null|string
     */
    protected $table = null;

    protected $tableStructure = null;

    /**
     * @var null|string
     */
    protected $primaryKey = null;
    protected $fields = null;

    /**
     * @return SelectQuery
     */
    public function newSelectQuery()
    {
        return $this->newQuery('select');
    }

    /**
     * Factory
     * @param string $type
     * @return Query|SelectQuery|InsertQuery|DeleteQuery|UpdateQuery
     */
    public function newQuery($type = 'select')
    {
        $query = $this->getDB()->newQuery($type);
        $query->cols("`" . $this->getTable() . "`.*");
        $query->cols(/** @scrutinizer ignore-type */ "`" . $this->getTable() . "`.*");
        $query->from($this->getFullNameTable());
        $query->from(/** @scrutinizer ignore-type */ $this->getFullNameTable());
        $query->table($this->getTable());
        $query->table(/** @scrutinizer ignore-type */ $this->getTable());

        return $query;
    }

    /**
     * @return Connection
     */
    public function getDB()
    {
        if ($this->connection == null) {
            $this->initDB();
        }

        $this->checkDB();

        return $this->connection;
    }

    protected function initDB()
    {
        $this->setDB($this->newDbConnection());
    }

    /**
     * @param Connection $connection
     * @return $this
     */
    public function setDB($connection)
    {
        $this->connection = $connection;

        return $this;
    }

    /**
     * @return Connection
     */
    protected function newDbConnection()
    {
        if (function_exists('app')) {
            return app('db.connection');
        }
        return Container::getInstance()->get('db.connection');
    }

    public function checkDB()
    {
        if (!$this->hasDB()) {
            trigger_error("Database connection missing for [" . get_class($this) . "]", E_USER_ERROR);
        }
    }

    /**
     * @return bool
     */
    public function hasDB()
    {
        return $this->connection instanceof Connection;
    }

    /**
     * @return string
     */
    public function getTable()
    {
        if ($this->table === null) {
            $this->initTable();
        }

        return $this->table;
    }

    /**
     * @param string $table
     */
    public function setTable($table)
    {
        $this->table = $table;
    }

    protected function initTable()
    {
        $this->setTable($this->generateTable());
    }

    /**
     * @return string
     */
    protected function generateTable()
    {
        return str_replace('-', '_', $this->getController());
        return str_replace('-', '_', $this->/** @scrutinizer ignore-call */ getController());
    }

    /**
     * @return string
     */
    public function getFullNameTable()
    {
        $database = $this->getDB()->getDatabase();

        return $database ? $database . '.' . $this->getTable() : $this->getTable();
    }

    /**
     * @return null
     */
    public function getFields()
    {
        if ($this->fields === null) {
            $this->initFields();
        }

        return $this->fields;
    }

    public function initFields()
    {
        $structure = $this->getTableStructure();
        $this->fields = array_keys($structure['fields']);
    }

    /**
     * @return mixed
     */
    protected function getTableStructure()
    {
        if ($this->tableStructure == null) {
            $this->initTableStructure();
        }

        return $this->tableStructure;
    }

    /**
     * @param null $tableStructure

     */
    public function setTableStructure($tableStructure)
    {
        $this->tableStructure = $tableStructure;
    }

    protected function initTableStructure()
    {
        $this->setTableStructure($this->getDB()->getMetadata()->describeTable($this->getTable()));
    }

    /**
     * @return InsertQuery
     */
    public function newInsertQuery()
    {
        return $this->newQuery('insert');
    }

    /**
     * Updates a Record's database entry
     * @param Record $model
     * @return bool|Result
     */
    public function update(Record $model)
    {
        $query = $this->updateQuery($model);

        if ($query) {
            return $query->execute();
        }

        return false;
    }

    /**
     * @param Record $model
     * @return bool|UpdateQuery
     */
    public function updateQuery(Record $model)
    {
        $pk = $this->getPrimaryKey();
        if (!is_array($pk)) {

            $pk = [$pk];
        }

        $data = $this->getQueryModelData($model);
        $data = $this->getQueryModelData($model);

        if ($data) {
            $query = $this->newUpdateQuery();
            $query->data($data);

            foreach ($pk as $key) {
                $query->where("$key = ?", $model->{$key});
            }

            return $query;
        }

        return false;
    }

    /**
     * @return string
     */
    public function getPrimaryKey()
    {
        if ($this->primaryKey === null) {
            $this->initPrimaryKey();
        }

        return $this->primaryKey;
    }

    /**
     * @param null|string $primaryKey
     */
    public function setPrimaryKey($primaryKey)
    {
        $this->primaryKey = $primaryKey;
    }

    protected function initPrimaryKey()
    {
        $this->setPrimaryKey($this->generatePrimaryKey());
    }

    /**
     * @return string
     */
    public function generatePrimaryKey()
    {
        $structure = $this->getTableStructure();
        $primaryKey = false;
        if (is_array($structure) && isset($structure['indexes']['PRIMARY']['fields'])) {
            $primaryKey = $structure['indexes']['PRIMARY']['fields'];
            if (count($primaryKey) == 1) {
                $primaryKey = reset($primaryKey);
            }
        }

        return $primaryKey;
    }

    /**
     * @return UpdateQuery
     */
    public function newUpdateQuery()
    {
        return $this->newQuery('update');
    }

    /**
     * Saves a Record's database entry
     * @param Record $model
     * @return mixed
     */
    public function save(Record $model)
    {
        $pk = $this->getPrimaryKey();

        if (isset($model->{$pk})) {
            $model->update();

            return $model->{$pk};
        } else {
            /** @var Record $previous */
            $previous = $model->exists();

            if ($previous) {

                $data = $model->toArray();

                if ($data) {
                    $previous->writeData($model->toArray());
                }
                $previous->update();

                $model->writeData($previous->toArray());

                return $model->getPrimaryKey();
            }
        }

        $model->insert();

        return $model->getPrimaryKey();
    }

    /**
     * Delete a Record's database entry
     *
     * @param Record $input
     */
    public function delete($input)
    {
        $pk = $this->getPrimaryKey();

        if ($input instanceof $this->model) {
            $primary = $input->getPrimaryKey();
        } else {
            $primary = $input;
        }

        $query = $this->newDeleteQuery();
        $query->where("$pk = ?", $primary);
        $query->limit(1);

        $this->getDB()->execute($query);
    }

    /**
     * @return DeleteQuery
     */
    public function newDeleteQuery()
    {
        return $this->newQuery('delete');
    }

    /**
     * Delete a Record's database entry
     * @param array $params
     * @return $this
     */
    public function deleteByParams($params = [])
    {
        extract($params);

        $query = $this->newDeleteQuery();

        if (isset($where)) {
            if (is_array($where)) {
                foreach ($where as $condition) {
                    $condition = (array)$condition;
                    $query->where($condition[0], $condition[1]);
                }
            } else {
                call_user_func_array([$query, 'where'], $where);
            }
        }

        if (isset($order)) {
            call_user_func_array([$query, 'order'], $order);
        }

        if (isset($limit)) {
            call_user_func_array([$query, 'limit'], $limit);
        }

        $this->getDB()->execute($query);

        return $this;
    }

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

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

        $paginator->setCount($count);

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

        return $this->findByParams($params);
        return $this->/** @scrutinizer ignore-call */ findByParams($params);
    }

    /**
     * @param array $params
     * @return SelectQuery
     */
    public function paramsToQuery($params = [])
    {
        $this->injectParams($params);

        $query = $this->newQuery('select');
        $query->addParams($params);

        return $query;
    }

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

    /**
     * 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];

                $item = $this->findOneByParams($params);
                $item = $this->findOneByParams($params);
                if ($item) {
                    $this->getRegistry()->set($primary, $item);
                }

                return $item;
            }
        }

        return $item;
    }

    /**
     * @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 Query $query
     * @param array $params
     * @return RecordCollection
     */
    public function findByQuery($query, $params = [])
    {
        $return = $this->newCollection();
        $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;
    }

    /**
     * @param bool|array $where
     * @return int
     */
    public function count($where = false)
    {
        return $this->countByParams(["where" => $where]);
    }

    /**
     * Counts all the Record entries in the database
     * @param array $params
     * @return int
     */
    public function countByParams($params = [])
    {
        $this->injectParams($params);
        $query = $this->newQuery('select');
        $query->addParams($params);

        return $this->countByQuery($query);
    }

    /**
     * Counts all the Record entries in the database
     * @param Query $query
     * @return int
     */
    public function countByQuery($query)
    {
        $queryCount = clone $query;
        $queryCount->setCols('count(*) as count');
        $queryCount->setCols(/** @scrutinizer ignore-type */ 'count(*) as count');
        $result = $this->getDB()->execute($queryCount);

        if ($result->numRows()) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $row = $result->fetchResult();

            return (int)$row['count'];
        }

        return false;

    }

    /**
     * @param $data
     * @return mixed
     */
    public function cleanData($data)
    {
        return $this->getDB()->getAdapter()->cleanData($data);
    }

    /**
     * @param string $name
     * @param $arguments
     * @return RecordCollection|false
     */
    protected function isCallDatabaseOperation($name, $arguments)
    {
        $operations = ["find", "delete", "count"];
        foreach ($operations as $operation) {
            if (strpos($name, $operation . "By") !== false || strpos($name, $operation . "OneBy") !== false) {
                $params = [];
                if (count($arguments) > 1) {
                    $params = end($arguments);
                }

                $match = str_replace([$operation . "By", $operation . "OneBy"], "", $name);
                $field = inflector()->underscore($match);

                if ($field == $this->getPrimaryKey()) {
                    return $this->findByPrimary($arguments[0]);
                    return $this->/** @scrutinizer ignore-call */ findByPrimary($arguments[0]);
                }

                $params['where'][] = ["$field " . (is_array($arguments[0]) ? "IN" : "=") . " ?", $arguments[0]];

                $operation = str_replace($match, "", $name) . "Params";

                $results = $this->$operation($params);
                // RETURN NULL TO DISTINCT FROM FALSE THAT MEANS NOT A DATABASE OPERATION
                return ($results) ? $results : null;
            }
        }

        return false;
    }
}

bytic / orm

Push — master ( 470d43...3f2648 )

ActiveRecordsTrait::deleteByParams() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
