stagfe2/app/Http/Controllers/StatTreeLineController.php

<?php

namespace App\Http\Controllers;


use App\Models\Clause;
use App\Models\StatTreeLineClause;
use Illuminate\Http\Request;
use App\Models\StatTree;
use App\Models\StatTreeLine;
use App\Models\Client;
use App\Models\Pro;
use Illuminate\Support\Facades\DB;
use Ramsey\Uuid\Uuid;

class StatTreeLineController extends Controller
{
    public function list()
    {
        $statTreeLines = StatTreeLine::all();
        return view('app.stat-tree-lines.list', compact('statTreeLines'));
    }
    public function dashboard(StatTreeLine $statTreeLine)
    {
        $result = $this->applyStatTreeLineQueryClauses($statTreeLine);
        if (!$result) {
            $response = 'Invalid query or model/table name';
        } else {
            $response = [
                'type' => 'count',
                'sql' => $result->toSql(),
                'result' => $result->count()
            ];
        }

        return view('app.stat-tree.stat-tree-lines.single', compact('statTreeLine', 'response'));
    }

    public function reportColumns(Request $request, StatTreeLine $line)
    {
        return view('app.stat-tree.stat-tree-lines.report-columns', compact('line'));
    }

    public function columnSuggest(Request $request) {
        $term = $request->input('term') ? trim($request->input('term')) : '';
        if (empty($term)) return '';
        $table = $request->input('table') ? trim($request->input('table')) : '';
        if (empty($table)) return '';
        $table = strtolower($table);

        $tables = [];
        $columns = [];

        // if single-term without spaces, single table
        if(strpos($table, ' ') === FALSE) {
            $tables[] = $table;
        }
        else {
            $table = explode(" ", $table);
            $tables[] = $table[0];
            for ($i = 1; $i < count($table); $i++) {
                if($table[$i] == 'join' && $i < count($table) - 1) {
                    $tables[] = $table[$i+1];
                    $i++;
                }
            }
        }

        for ($i = 0; $i < count($tables); $i++) {
            $cols = DB::getSchemaBuilder()->getColumnListing($tables[$i]);
            sort($cols);
            $matches = array_filter($cols, function($_x) use ($term) {
                return strpos($_x, $term) !== FALSE;
            });
            $matches = array_map(function($_x) use ($tables, $i) {
                return [
                    "text" => $tables[$i] . '.' . $_x,
                    "label" => sanitize_state_name($_x)
                ];
            }, $matches);
            $columns = array_merge($columns, $matches);
        }

        $columns = array_values($columns);
        $columns = json_decode(json_encode($columns));
        // dd($matches);
        return json_encode([
            "success" => true,
            "data" => $columns
        ]);
    }

    public function refreshTreeCountQueries(Request $request)
    {
        $statTreeID = $request->get('statTreeID');
        if (!$statTreeID) return $this->fail('No specified stat tree!');

        $statTree = StatTree::where('id', $statTreeID)->first();
        if (!$statTree) return $this->fail('Invalid stat tree!');
        $lines = $statTree->lines;
        foreach ($lines as $line) {
            $query = $this->applyStatTreeLineQueryClauses($line);
            if ($query) {
                $line->last_refresh_count = $query[0]->count;
                $line->save();
            }
        }

        return $this->pass();
    }

    public function refreshCountQuery(Request $request)
    {
        $statTreeLineID = $request->get('statTreeLineID');
        if (!$statTreeLineID) return $this->fail('No specified stat tree line!');

        $statTreeLine = StatTreeLine::where('id', $statTreeLineID)->first();
        if (!$statTreeLine) return $this->fail('Invalid stat tree line!');
        $query = $this->applyStatTreeLineQueryClauses($statTreeLine);  
        if ($query) {
            $statTreeLine->last_refresh_count = $query[0]->count;
            $statTreeLine->save();
            return $this->pass($statTreeLine->last_refresh_count);
        }else{
            return $this->fail('Invalid query or model/table name');
        }
    }

    protected function applyStatTreeLineQueryClauses(StatTreeLine $statTreeLine)
    {

        $model = $statTreeLine->statTree->model;
        // $query = null;
        // if (strcasecmp($model, 'client') == 0) {
        //     $query = Client::query();
        // }
        // if (strcasecmp($model, 'pro') == 0) {
        //     $query = Pro::query();
        // }
        // if (!$query) return null;




        $clauses = [];
        foreach ($statTreeLine->lineClauses as $lineClause) {
            $clauseText = $lineClause->clause->clause_text;
            $isValid = $this->cleanupClause($clauseText);
            if ($isValid) {
                array_push($clauses, $clauseText);
            }
        }

        $query = 'SELECT COUNT(*) FROM '.$model.' WHERE '. implode(" AND ", $clauses);
        
        return DB::select($query);
    }

    protected function cleanupClause($clauseText)
    {
        //Dont include empty clauses, i.e ()
        preg_match('#\((.*?)\)#', $clauseText, $match);
        $content = @$match[1];
        if (!$content || empty($content)) return null;
        return $content;
    }

    // eps
    public function create(Request $request) {

        // stat tree line
        $statTreeLine = new StatTreeLine();
        $nextId = DB::select("select nextval('stat_tree_line_id_seq')");
        $statTreeLine->id = $nextId[0]->nextval;
        $statTreeLine->uid = Uuid::uuid4();
        $statTreeLine->stat_tree_id = $request->input('statTreeId');
        $statTreeLine->parent_stat_tree_line_id = $request->input('parentStatTreeLineId');
        $positionIndex = DB::select("select max(tree_order_position_index) from stat_tree_line where stat_tree_id = {$statTreeLine->stat_tree_id}" .
            ($statTreeLine->parent_stat_tree_line_id ? " AND parent_stat_tree_line_id = {$statTreeLine->parent_stat_tree_line_id}" : '')
        );
        $statTreeLine->tree_order_position_index = is_numeric($positionIndex[0]->max) ? $positionIndex[0]->max + 1 : 1;
        $statTreeLine->save();

        // stat tree line clauses (all of parent's clauses + own)
        if($statTreeLine->parent) {
            foreach($statTreeLine->parent->lineClauses as $lineClause) {
                $statTreeLineClause = new StatTreeLineClause();
                $nextId = DB::select("select nextval('stat_tree_line_clause_id_seq')");
                $statTreeLineClause->id = $nextId[0]->nextval;
                $statTreeLineClause->uid = Uuid::uuid4();
                $statTreeLineClause->stat_tree_line_id = $statTreeLine->id;
                $statTreeLineClause->clause_id = $lineClause->clause_id;
                $statTreeLineClause->clause_label = $lineClause->clause_label;
                $statTreeLineClause->save();
            }
        }
        $statTreeLineClause = new StatTreeLineClause();
        $nextId = DB::select("select nextval('stat_tree_line_clause_id_seq')");
        $statTreeLineClause->id = $nextId[0]->nextval;
        $statTreeLineClause->uid = Uuid::uuid4();
        $statTreeLineClause->stat_tree_line_id = $statTreeLine->id;
        $clause = Clause::where('id', $request->input('clauseId'))->first();
        $statTreeLineClause->clause_id = $clause->id;
        $statTreeLineClause->clause_label = $clause->label;
        $statTreeLineClause->save();

        return $this->pass();
    }
    public function remove(Request $request) {
        $statTreeLine = StatTreeLine::where('uid', $request->input('uid'))->first();
        if(!$statTreeLine) return $this->fail('Stat tree line not found!');
        // TODO: disallow if this has children
        DB::select("delete from stat_tree_line where id = {$statTreeLine->id}");
        return $this->pass();
    }
}