Protoqol\Prequel\Http\Controllers\DatabaseController

Complexity

Total Complexity

9

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	findInTable()	0	20	4
A	countTableRecords()	0	8	1
A	getTableData()	0	19	3

<?php

declare(strict_types = 1);

namespace Protoqol\Prequel\Http\Controllers;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Routing\Controller;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Route;
use Protoqol\Prequel\Classes\Database\DatabaseTraverser;
use Protoqol\Prequel\Http\Requests\PrequelDatabaseRequest;

/**
 * Class DatabaseActionController
 *
 * @package Protoqol\Prequel\Http\Controllers
 */
class DatabaseController extends Controller
{

    /**
     * Qualified table name; 'database.table'
     *
     * @var string $qualifiedName
     */
    public $qualifiedName;

    /**
     * Table name
     *
     * @var string $tableName
     */
    public $tableName;

    /**
     * Database name
     *
     * @var string $databaseName
     */
    public $databaseName;

    /**
     * Holds model for given table if one exists.
     *
     * @var Model $model
     */
    public $model;

    /**
     * DatabaseActionController's constructor
     *
     * @param  \Protoqol\Prequel\Http\Requests\PrequelDatabaseRequest  $request
     */
    public function __construct(PrequelDatabaseRequest $request)
    {
        $this->tableName     = $request->table;
        $this->databaseName  = $request->database;
        $this->qualifiedName = $request->qualifiedName;
        $this->model         = $request->model;
    }

    /**
     * Get table data, table structure and its qualified name
     *
     * @return mixed
     */
    public function getTableData()
    {
        if ($this->model
            && $this->databaseName
            === config('database.connections.mysql.database')
        ) {
            $tableData = $this->model->paginate(100);
        } else {
            $tableData = DB::table($this->qualifiedName)->paginate(100);
        }

//        dd($tableData);
        return [
            "table"     => $this->qualifiedName,
            "structure" => app(DatabaseTraverser::class)->getTableStructure(
                $this->databaseName,
                $this->tableName
            ),
            "data"      => $tableData,
        ];
    }

    /**
     * Get count of rows in table
     *
     * @return array
     */
    public function countTableRecords() :array
    {
        $count = DB::table($this->qualifiedName)
            ->count('id');

        return [
            "table" => $this->qualifiedName,
            "count" => $count,
        ];
    }

    /**
     * Try to find input in each column in table.
     *
     * @TODO Prefetch if possible with ID
     * @TODO Clean up, this is nowhere near production ready
     * @return mixed
     */
    public function findInTable()
    {
        $column    = Route::current()->parameter('column');
        $value     = Route::current()->parameter('value');
        $queryType = Route::current()->parameter('type');

        if ($queryType === 'LIKE') {
            return $this->model
                ? $this->model->where($column, 'LIKE', '%'.$value.'%')

Are you sure $value of type object|string can be used in concatenation?

                    ->paginate(100)
                : DB::table($this->qualifiedName)
                    ->where($column, 'LIKE', '%'.$value.'%')
                    ->paginate(100);
        }

        return $this->model
            ? $this->model->where($column, $queryType, $value)
                ->paginate(100)
            : DB::table($this->qualifiedName)
                ->where($column, $queryType, $value)->paginate(100);
    }
}