QueryBuilder::getFlatArray() - Code Metrics - sfneal/models - Measure and Improve Code Quality continuously with Scrutinizer

QueryBuilder::getFlatArray() A
last analyzed 2024-10-02 16:44 UTC

↳ Parent: QueryBuilder
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0
<?php

namespace Sfneal\Builders;

use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Query\Builder;
use Illuminate\Support\Facades\DB;
use Sfneal\Builders\Traits\CountAndPaginate;
use Sfneal\Models\Model;

class QueryBuilder extends EloquentBuilder
{
    use CountAndPaginate;

    /**
     * @var string Declare a custom MySQL select string to be used by selectRawJson()
     */
    protected $selectRawJson;

    /**
     * @var Model
     */
    protected $targetModel;

    /**
     * @var string Name of the User model's table
     */
    protected $tableName;

    /**
     * @var string Name of the User model's primary key
     */
    protected $primaryKeyName;

    /**
     * UserBuilder constructor.
     *
     * @param  Builder  $query
     */
    public function __construct(Builder $query)
    {
        $this->setTableAndKeyNames();
        parent::__construct($query);
    }

    /**
     * Set the $tableName & $primaryKeyName properties.
     *
     * @return void
     */
    private function setTableAndKeyNames(): void
    {
        // Only declare table & pk if the target model is declared
        if (isset($this->targetModel)) {
            $this->tableName = $this->targetModel::getTableName();
            $this->primaryKeyName = $this->targetModel::getPrimaryKeyName();
        }
    }

    /**
     * Retrieve a concatenation string that combines two columns in a table into a single column.
     *
     * @param  string  $column1
     * @param  string  $column2
     * @param  string  $delimiter
     * @return string
     */
    protected function concatColumns(string $column1, string $column2, string $delimiter = ' '): string
    {
        // Prepend table name if it's been declared
        $column1 = (isset($this->tableName)) ? "{$this->tableName}.{$column1}" : $column1;
        $column2 = (isset($this->tableName)) ? "{$this->tableName}.{$column2}" : $column2;

        // Use Sqlite syntax
        if (DB::connection()->getDatabaseName() == ':memory:') {
            return "{$column1} || '{$delimiter}' || {$column2}";
        }

        // Use standard syntax
        else {
            return "concat({$column1}, '{$delimiter}', {$column2})";
        }
    }

    /**
     * Retrieve a MySQL if statement that can be used within a query.
     *
     * @param  string  $condition
     * @param  string  $expr_true
     * @param  string  $expr_false
     * @return string
     */
    protected function ifStatement(string $condition, string $expr_true, string $expr_false): string
    {
        // Use Sqlite syntax
        if (DB::connection()->getDatabaseName() == ':memory:') {
            return "CASE WHEN {$condition} THEN {$expr_true} ELSE {$expr_false} END";
        }

        // Use standard syntax
        else {
            return "if({$condition}, {$expr_true}, {$expr_false})";
        }
    }

    /**
     * Wildcard where like query to determine if any part of the value is found.
     *
     * @param  string  $column
     * @param  $value
     * @param  bool  $leadingWildcard
     * @param  bool  $trailingWildcard
     * @param  string  $boolean
     * @return $this
     */
    public function whereLike(string $column,
                                     $value,
                              bool $leadingWildcard = true,
                              bool $trailingWildcard = true,
                              string $boolean = 'and'): self
    {
        $this->where(
            $column,
            'LIKE',
            ($leadingWildcard ? '%' : '').$value.($trailingWildcard ? '%' : ''),
            $boolean
        );

        return $this;
    }

    /**
     * Wildcard or where like query to determine if any part of the value is found.
     *
     * @param  string  $column
     * @param  $value
     * @param  bool  $leadingWildcard
     * @param  bool  $trailingWildcard
     * @return $this
     */
    public function orWhereLike(string $column, $value, bool $leadingWildcard = true, bool $trailingWildcard = true): self
    {
        $this->orWhere(
            $column,
            'LIKE',
            ($leadingWildcard ? '%' : '').$value.($trailingWildcard ? '%' : '')
        );

        return $this;
    }

    /**
     * Retrieve a flat, single-dimensional array of results without keys.
     *
     * @param  string  $column
     * @return array
     */
    public function getFlatArray(string $column): array
    {
        return $this->distinct()->pluck($column)->toArray();
        return $this->/** @scrutinizer ignore-call */ distinct()->pluck($column)->toArray();
    }

    /**
     * Retrieve raw query results formatted for Ajax select2 form inputs.
     *
     * @param  string|null  $raw
     * @return $this
     */
    public function selectRawJson(string $raw = null): self
    {
        $this->withoutGlobalScopes();
        $this->selectRaw($raw ?? $this->selectRawJson);
               selectRaw($raw ?? $this->selectRawJson);

        return $this;
    }

    /**
     * Order query results by the 'created_at' column.
     *
     * @param  string  $direction
     * @return $this
     */
    public function orderByCreatedAt(string $direction = 'desc'): self
    {
        $this->orderBy('created_at', $direction);
               orderBy('created_at', $direction);

        return $this;
    }

    /**
     * Retrieve the 'next' Model in the database.
     *
     * @param  int|null  $model_id
     * @return QueryBuilder|Collection|Model|null
     */
    public function getNextModel(int $model_id = null)
    {
        return $this->find($this->getNextModelId($model_id));
    }

    /**
     * Retrieve the 'previous' Model in the database.
     *
     * @param  int|null  $model_id
     * @return QueryBuilder|Collection|Model|null
     */
    public function getPreviousModel(int $model_id = null)
    {
        return $this->find($this->getPreviousModelId($model_id));
    }

    /**
     * Retrieve the 'next' Model's ID.
     *
     * @param  int|null  $model_id
     * @return mixed
     */
    public function getNextModelId(int $model_id = null)
    {
        return $this
            ->where($this->model->getKeyName(), '>', $model_id ?? $this->model->getKey())
            ->min($this->model->getKeyName());
            ->/** @scrutinizer ignore-call */ min($this->model->getKeyName());
    }

    /**
     * Retrieve the 'previous' Model's ID.
     *
     * @param  int|null  $model_id
     * @return mixed
     */
    public function getPreviousModelId(int $model_id = null)
    {
        return $this
            ->where($this->model->getKeyName(), '<', $model_id ?? $this->model->getKey())
            ->max($this->model->getKeyName());
            ->/** @scrutinizer ignore-call */ max($this->model->getKeyName());
    }
}

sfneal / models

QueryBuilder::getFlatArray() A last analyzed 2024-10-02 16:44 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

QueryBuilder::getFlatArray() A
last analyzed 2024-10-02 16:44 UTC
