RecordController::delete() - Code Metrics - Inspection of "Updated RecordController delete" - Codexshaper/laravel-database-manager - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( e31983...b05bb8 )

by CodexShaper
created 2020-01-03 10:59 UTC
RecordController::delete() B

↳ Parent: RecordController
Complexity

Conditions	8
Paths	11
Size

Total Lines	46
Code Lines	23
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	72
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
cc	8
eloc	23
c	2
b	0
f	0
nc	11
nop	1
dl	0
loc	46
ccs	0
cts	32
cp	0
crap	72
rs	8.4444
<?php

namespace CodexShaper\DBM\Http\Controllers;

use CodexShaper\DBM\Database\Drivers\MongoDB\Type;
use CodexShaper\DBM\Database\Schema\Table;
use CodexShaper\DBM\Facades\Driver;
use CodexShaper\DBM\Models\DBM_Collection;
use DBM;
filter:
    dependency_paths: ["lib/*"]
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Str;

class RecordController extends Controller
{

    public function index()
    {
        return view('dbm::app');
    }

    public function store(Request $request)
    {
        if ($request->ajax()) {

            if (($response = DBM::authorize('record.create')) !== true) {
                return $response;
            }

            $tableName       = $request->table;
            $originalColumns = Table::getColumnsName($tableName);
            $columns         = json_decode($request->columns);
            $fields          = json_decode($request->fields);

            // return response()->json(['columns' => $columns]);

            $errors = $this->validation($fields, $columns);

            if (count($errors) > 0) {
                return $this->generateError($errors);
            }

            $object = DBM::Object()->where('name', $tableName)->first();
            $model  = $object->model;

            if (!class_exists($model)) {
                return $this->generateError(["Model not found. Please create model first"]);
            }

            try {

                $table = DBM::model($model, $tableName);

                foreach ($columns as $column => $value) {
                    // $column = $field->name;
                    // $value  = $request->{$column};
                    if (in_array($column, $originalColumns)) {

                        if ($request->hasFile($column)) {
                            $files  = $request->file($column);
                            $values = [];
                            foreach ($files as $file) {
                                $fileName = Str::random(config('dbm.filesystem.random_length')) . '.' . $file->getClientOriginalExtension();
                                $path     = 'public/dbm/' . $tableName;
                                $file->storeAs($path, $fileName);
                                $values[] = $fileName;
                            }

                            // $value = json_encode($values);

                            if (count($values) > 1) {
                                $value = $values;
                                if (!Driver::isMongoDB()) {
                                    $value = is_array($values) ? json_encode($values) : $values;
                                }
                            } else if (count($values) == 1) {
                                $value = $values[0];
                            }
                        }

                        if (!Driver::isMongoDB()) {
                            if ($functionName = $this->hasFunction($fields, $column)) {
                                $value = $this->executeFunction($functionName, $value);
                            }
                        }

                        // if ($value != "" || !empty($value)) {

                        $table->{$column} = is_array($value) ? json_encode($value) : $value;

                        if (Driver::isMongoDB()) {

                            $fieldType = $this->getFieldType($tableName, $column);

                            if (!in_array($fieldType, Type::getTypes())) {
                                $this->generateError([$fieldType . " type not supported."]);
                            }

                            $table->{$column} = Type::$fieldType($value);

                        }
                        // }

                    }
                }

                if ($table->save()) {

                    foreach ($fields as $field) {

                        if (isset($field->relationship) && $field->relationship->relationType == "belongsToMany") {

                            $relationship = $field->relationship;

                            $localModel      = $relationship->localModel;
                            $localTable      = $relationship->localTable;
                            $foreignModel    = $relationship->foreignModel;
                            $pivotTable      = $relationship->pivotTable;
                            $parentPivotKey  = $relationship->parentPivotKey;
                            $relatedPivotKey = $relationship->relatedPivotKey;

                            $findColumn = $object->details['findColumn'];

                            $localObject = DBM::model($localModel, $localTable)::where($findColumn, $table->{$findColumn})->first();

                            DBM::Object()
                                ->setManyToManyRelation(
                                    $localObject,
                                    $foreignModel,
                                    $pivotTable,
                                    $parentPivotKey,
                                    $relatedPivotKey
                                )
                                ->belongs_to_many()
                                ->attach($columns->{$relatedPivotKey});

                        }

                        // else if (isset($field['relationship']) && $field['relationship']['relationType'] == "hasMany") {

                        //     $relationship = $field['relationship'];

                        //     $localModel   = $relationship['localModel'];
                        //     $findColumn   = $object->details['findColumn'];
                        //     $foreignModel = $relationship['foreignModel'];
                        //     $foreignKey   = $relationship['foreignKey'];
                        //     $localKey     = $relationship['localKey'];

                        //     $localObject = $localModel::where($findColumn, $table->{$findColumn})->first();

                        //     $items = [];

                        //     foreach ($columns[$foreignKey] as $key => $value) {
                        //         // return response()->json(['columns' => $columns['menu_id'], 'fields' => $value, 'model' => $foreignModel]);
                        //         $originalColumns    = Table::getColumnsName($relationship['foreignTable']);
                        //         $foreignTableFields = DBM::Object()->where('name', $relationship['foreignTable'])->first()->fields()->where('create', 1)->get();

                        //         $oldItem = $foreignModel::find($value);
                        //         $item    = new $foreignModel;

                        //         foreach ($foreignTableFields as $foreignTableField) {
                        //             if (in_array($foreignTableField->name, $originalColumns)) {
                        //                 if ($foreignTableField->name != $foreignKey) {
                        //                     $item->{$foreignTableField->name} = $oldItem->{$foreignTableField->name};
                        //                 }
                        //             }
                        //         }
                        //         DBM::Object()
                        //             ->setCommonRelation(
                        //                 $localObject,
                        //                 $foreignModel,
                        //                 $foreignKey,
                        //                 $localKey)
                        //             ->has_many()
                        //             ->save($item);
                        //     }

                        // }
                    }
                    return response()->json(['success' => true, 'object' => $object, 'table' => $table]);
                }

            } catch (\Exception $e) {
                return $this->generateError([$e->getMessage()]);
            }
        }

        return response()->json(['success' => false]);
    }

    public function update(Request $request)
    {
        if ($request->ajax()) {

            if (($response = DBM::authorize('record.update')) !== true) {
                return $response;
            }

            $tableName       = $request->table;
            $originalColumns = Table::getColumnsName($tableName);
            $columns         = json_decode($request->columns);
            $fields          = json_decode($request->fields);

            // return response()->json(['columns' => $columns->multiple_dropdown]);

            $errors = $this->validation($fields, $columns, 'update');

            if (count($errors) > 0) {
                return $this->generateError($errors);
            }

            $object  = DBM::Object()->where('name', $tableName)->first();
            $model   = $object->model;
            $details = $object->details;
            $key     = $details['findColumn'];

            if (!class_exists($model)) {
                return $this->generateError(["Model not found. Please create model first"]);
            }

            try {

                $table = DBM::model($model, $tableName)->where($key, $columns->{$key})->first();

                // return response()->json(['details' => $table, 'key' => $key]);

                foreach ($columns as $column => $value) {
                    // $column = $field->name;
                    // $value = $request->{$column};

                    if (in_array($column, $originalColumns)) {

                        if ($request->hasFile($column)) {
                            $files  = $request->file($column);
                            $values = [];
                            foreach ($files as $file) {
                                $fileName = Str::random(config('dbm.filesystem.random_length')) . '.' . $file->getClientOriginalExtension();
                                $path     = 'public/dbm/' . $tableName;
                                $file->storeAs($path, $fileName);
                                $values[] = $fileName;
                            }

                            // $value = json_encode($values);

                            if (count($values) > 1) {
                                $value = $values;
                                if (!Driver::isMongoDB()) {
                                    $value = is_array($values) ? json_encode($values) : $value;
                                }
                            } else if (count($values) == 1) {
                                $value = $values[0];
                            }
                        }

                        if ($value !== null && $value !== "") {

                            if (!Driver::isMongoDB()) {
                                if ($functionName = $this->hasFunction($fields, $column)) {

                                    $value = $this->executeFunction($functionName, $value);
                                }
                            }

                            $table->{$column} = is_array($value) ? json_encode($value) : $value;

                            if (Driver::isMongoDB()) {

                                $fieldType = $this->getFieldType($tableName, $column);

                                if (!in_array($fieldType, Type::getTypes())) {
                                    $this->generateError([$fieldType . " type not supported."]);
                                }

                                $table->{$column} = Type::$fieldType($value);

                            }
                        }
                    }
                }

                if ($table->update()) {

                    foreach ($fields as $field) {

                        // return response()->json(['fields' => $fields]);

                        if (isset($field->relationship)) {

                            $relationship = $field->relationship;

                            $localModel   = $relationship->localModel;
                            $localTable   = $relationship->localTable;
                            $foreignModel = $relationship->foreignModel;

                            if ($field->relationship->relationType == "belongsToMany") {
                                $pivotTable      = $relationship->pivotTable;
                                $parentPivotKey  = $relationship->parentPivotKey;
                                $relatedPivotKey = $relationship->relatedPivotKey;

                                $findColumn = $object->details['findColumn'];

                                $localObject = DBM::model($localModel, $localTable)->where($findColumn, $table->{$findColumn})->first();

                                DBM::Object()
                                    ->setManyToManyRelation(
                                        $localObject,
                                        $foreignModel,
                                        $pivotTable,
                                        $parentPivotKey,
                                        $relatedPivotKey
                                    )
                                    ->belongs_to_many()
                                    ->sync($columns->{$relatedPivotKey});
                            }

                        }
                    }

                    return response()->json(['success' => true]);
                }

            } catch (\Exception $e) {
                return $this->generateError([$e->getMessage()]);
            }
        }

        return response()->json(['success' => false]);
    }

    public function delete(Request $request)
    {
        if ($request->ajax()) {

            if (($response = DBM::authorize('record.delete')) !== true) {
                return $response;
            }

            $tableName = $request->table;
            // $originalColumns = Table::getColumnsName($tableName);
            $columns = json_decode($request->columns);
            $fields  = $request->fields;

            $object  = DBM::Object()->where('name', $tableName)->first();
            $model   = $object->model;
            $details = $object->details;
            $key     = $details['findColumn'];

            if (!class_exists($model)) {
                return $this->generateError(["Model not found. Please create model first"]);
            }

            try {

                $table = DBM::model($model, $tableName)->where($key, $columns->{$key})->first();

                if ($table) {

                    foreach ($fields as $field) {

                        $field = json_decode($field);

                        $this->removeRelationshipData($field);
                    }

                    if ($table->delete()) {
                        return response()->json(['success' => true]);
                    }
                }

            } catch (\Exception $e) {
                return $this->generateError([$e->getMessage()]);
            }
        }

        return response()->json(['success' => false]);
    }

    public function removeRelationshipData($field)
    {
        if ($field->type == 'relationship') {

            $relationship = $field->settings;

            $localModel   = $relationship->localModel;
            $foreignModel = $relationship->foreignModel;

            $findColumn = $object->details['findColumn'];


            $localObject = $localModel::where($findColumn, $table->{$findColumn})->first();


            if ($relationship->relationType == 'belongsToMany') {

                $pivotTable      = $relationship->pivotTable;
                $parentPivotKey  = $relationship->parentPivotKey;
                $relatedPivotKey = $relationship->relatedPivotKey;

                DBM::Object()
                    ->setManyToManyRelation(
                        $localObject,
                        $foreignModel,
                        $pivotTable,
                        $parentPivotKey,
                        $relatedPivotKey
                    )
                    ->belongs_to_many()
                    ->detach();
            } else if ($relationship->relationType == 'hasMany') {

                $foreignKey = $relationship->foreignKey;
                $localKey   = $relationship->localKey;

                DBM::Object()
                    ->setCommonRelation(
                        $localObject,
                        $foreignModel,
                        $foreignKey,
                        $localKey)
                    ->has_many()
                    ->delete();
            }

        }
    }

    protected function getSettingOptions($field)
    {
        $options = $field->settings['options'];
        if (isset($options['controller'])) {
            $partials       = explode('@', $options['controller']);
            $controllerName = $partials[0];
            $methodName     = $partials[1];

            return app($controllerName)->{$methodName}();
        }
    }

    public function getTableDetails(Request $request)
    {
        if ($request->ajax()) {

            if (($response = DBM::authorize('record.browse')) !== true) {
                return $response;
            }

            $tableName = $request->table;
            $object    = DBM::Object()->where('name', $tableName)->first();

            if (!$object) {
                return response()->json([
                    'success' => false,
                    'errors'  => ["There is no Object details"],
                ], 400);
            }

            $createFields     = $object->createFields();
            $browseFields     = $object->readFields();
            $editFields       = $object->editFields();
            $deleteFields     = $object->deleteFields();
            $fields           = $object->allFields();
            $foreignTableData = [];

            // return response()->json(['createFields' => auth()->user()]);

            foreach ($createFields as $key => $field) {

                if ($field->type == 'relationship') {

                    $relationship = $field->settings;
                    // $relationshipType = $relationship['relationType'];
                    // $localModel       = $relationship['localModel'];
                    // $localKey         = $relationship['localKey'];
                    $foreignModel = $relationship['foreignModel'];
                    $foreignKey   = $relationship['foreignKey'];
                    // $relationshipType = $relationship['relationType'];

                    // if ($relationshipType == 'belongsTo') {
                    $createFields            = $this->removeRelationshipKeyForBelongsTo($createFields, $foreignKey);
                    $field->foreignTableData = $foreignModel::all();
                    $field->relationship     = $relationship;
                    // } else {
                    //     unset($fields[$key]);
                    // }
                } else {
                    if (isset($field->settings['options'])) {
                        $options = $this->getSettingOptions($field);
                        if (is_array($options)) {
                            $createFields[$key]->options = $options;
                        }
                    }

                }
            }

            foreach ($editFields as $key => $field) {

                if ($field->type == 'relationship') {

                    $relationship = $field->settings;
                    // $relationshipType = $relationship['relationType'];
                    // $localModel       = $relationship['localModel'];
                    // $localKey         = $relationship['localKey'];
                    $foreignModel = $relationship['foreignModel'];
                    $foreignKey   = $relationship['foreignKey'];
                    // $relationshipType = $relationship['relationType'];

                    // if ($relationshipType == 'belongsTo') {
                    $editFields              = $this->removeRelationshipKeyForBelongsTo($editFields, $foreignKey);
                    $field->foreignTableData = $foreignModel::all();
                    $field->relationship     = $relationship;
                    // } else {
                    //     unset($fields[$key]);
                    // }
                    continue;
                }

                if (isset($field->settings['options'])) {
                    $options = $this->getSettingOptions($field);
                    if (is_array($options)) {
                        $editFields[$key]->options = $options;
                    }
                }
            }
            $model = $object->model;

            if (!class_exists($model)) {
                return $this->generateError(["Model not found. Please create model first"]);
            }

            $perPage = (int) $request->perPage;
            $query   = $request->q;

            $searchColumn = $object->details['searchColumn'];

            $records = DBM::model($model, $tableName)->paginate($perPage);

            // return response()->json(['success' => $perPage]);

            if (!empty($query) && !empty($searchColumn)) {
                $records = DBM::model($model, $tableName)
                    ->where($searchColumn, 'LIKE', '%' . $query . '%')
                    ->paginate($perPage);
            }

            foreach ($records as $item => $record) {

                foreach ($browseFields as $field) {

                    if ($field->type == 'relationship') {

                        $relationship = $field->settings;

                        $findColumn = $object->details['findColumn'];

                        $localModel       = $relationship['localModel'];
                        $localKey         = $relationship['localKey'];
                        $foreignModel     = $relationship['foreignModel'];
                        $foreignKey       = $relationship['foreignKey'];
                        $relationshipType = $relationship['relationType'];
                        $displayLabel     = $relationship['displayLabel'];

                        if ($relationshipType == 'belongsTo') {

                            $localObject = $localModel::where($findColumn, $record->{$findColumn})->first();

                            $datas = DBM::Object()->setCommonRelation($localObject, $foreignModel, $foreignKey, $localKey)->belongs_to;

                            $record->{$field->name}  = $datas;
                            $field->displayLabel     = $displayLabel;
                            $field->localKey         = $localKey;
                            $field->foreignKey       = $foreignKey;
                            $field->relationshipType = $relationshipType;

                        } else if ($relationshipType == 'hasMany') {

                            $localObject = $localModel::where($findColumn, $record->{$findColumn})->first();
                            $datas       = DBM::Object()->setCommonRelation($localObject, $foreignModel, $foreignKey, $localKey)->has_many;

                            $record->{$field->name}  = $datas;
                            $field->displayLabel     = $displayLabel;
                            $field->localKey         = $localKey;
                            $field->foreignKey       = $foreignKey;
                            $field->relationshipType = $relationshipType;

                        } else if ($relationshipType == 'belongsToMany') {

                            $pivotTable      = $relationship['pivotTable'];
                            $parentPivotKey  = $relationship['parentPivotKey'];
                            $relatedPivotKey = $relationship['relatedPivotKey'];

                            $localObject = $localModel::where($findColumn, $record->{$findColumn})->first();

                            $datas = DBM::Object()->setManyToManyRelation($localObject, $foreignModel, $pivotTable, $parentPivotKey, $relatedPivotKey)->belongs_to_many;

                            $record->{$field->name}  = $datas;
                            $field->displayLabel     = $displayLabel;
                            $field->localKey         = $localKey;
                            $field->foreignKey       = $foreignKey;
                            $field->relationshipType = $relationshipType;
                        }
                    }
                }
            }

            $newRecords = [];
            $newRecord  = new \stdClass;

            foreach ($records as $item => $record) {

                foreach ($fields as $key => &$field) {

                    if (isset($record->{$field->name})) {

                        $record->{$field->name} = is_json($record->{$field->name}) ? json_decode($record->{$field->name}, true) : $record->{$field->name};
                    }
                }

                if ($request->findValue && $record->{$object->details['findColumn']} == $request->findValue) {
                    $newRecord = $record;
                }

                $newRecords[] = $record;
            }

            $objectDetails            = $object->details;
            $objectDetails['perPage'] = $perPage;

            return response()->json([
                'success'          => true,
                'object'           => $object,
                'objectDetails'    => $objectDetails,
                'createFields'     => $createFields,
                'browseFields'     => $browseFields,
                'editFields'       => $editFields,
                'deleteFields'     => $deleteFields,
                'records'          => $newRecords,
                'record'           => $newRecord,
                'foreignTableData' => $foreignTableData,
                'userPermissions'  => DBM::userPermissions(),
                'pagination'       => $records,
            ]);
        }

        return response()->json(['success' => false]);
    }

    public function removeRelationshipKeyForBelongsTo($fields, $foreignKey)
    {
        $results = [];

        foreach ($fields as $key => $field) {
            if ($field->name == $foreignKey) {
                unset($fields[$key]);
                continue;
            }
            $results[] = $field;
        }

        return $results;
    }

    protected function validation($fields, $columns, $action = "create")
    {
        $errors = [];
        foreach ($fields as $field) {
            $name = $field->name;

            if (is_object($field->settings) && property_exists($field->settings, 'validation') !== false) {
                $validationSettings = $field->settings->validation;

                if ($action == 'create' && isset($validationSettings->create)) {
                    $createSettings = $validationSettings->create;
                    $rules          = $createSettings->rules;
                } else if ($action == 'update' && isset($validationSettings->update)) {
                    $updateSettings = $validationSettings->update;
                    $localKey       = $updateSettings->localKey;
                    $rules          = $updateSettings->rules . ',' . $columns->{$localKey};
                } else if (isset($field->settings->validation) && is_string($validationSettings)) {
                    $rules = $validationSettings;
                } else {
                    $rules = '';
                }

                $data      = [$name => $columns->{$name}];
                $validator = Validator::make($data, [
                    $name => $rules,
                ]);

                if ($validator->fails()) {

                    foreach ($validator->errors()->all() as $error) {
                        $errors[] = $error;
                    }
                }
            }
        }

        return $errors;
    }

    protected function getFieldType($collectionName, $fieldName)
    {
        $collection = DBM_Collection::where('name', $collectionName)->first();

        return $collection->fields()->where('name', $fieldName)->first()->type;
    }

    protected function generateError($errors)
    {
        return response()->json([
            'success' => false,
            'errors'  => $errors,
        ], 400);
    }

    protected function hasFunction($fields, $column)
    {
        foreach ($fields as $field) {
            if ($field->name == $column && ($field->function_name != null || $field->function_name != "")) {
                return $field->function_name;
            }
        }

        return false;
    }

    protected function executeFunction($functionName, $value = null)
    {
        $signature = ($value != null) ? "{$functionName}('{$value}')" : "{$functionName}()";

        $result = DB::raw("{$signature}");

        return $result;
    }
}

Codexshaper / laravel-database-manager

Push — master ( e31983...b05bb8 )

RecordController::delete() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
