RecordTrait::removeRelationshipKeyForBelongsTo() - Code Metrics - Inspection of "Fixed scrutinizer issue" - Codexshaper/laravel-database-manager - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fbf6ba...24a065 )

by CodexShaper

created 2020-01-06 04:25 UTC

RecordTrait::removeRelationshipKeyForBelongsTo() A

↳ Parent: RecordTrait

Complexity

Conditions	3
Paths	3

Size

Total Lines	13
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	7
c	1
b	0
f	0
nc	3
nop	2
dl	0
loc	13
ccs	0
cts	11
cp	0
crap	12
rs	10

<?php

namespace CodexShaper\DBM\Traits;

use CodexShaper\DBM\Database\Drivers\MongoDB\Type;
use CodexShaper\DBM\Facades\Driver;
use CodexShaper\DBM\Facades\Manager as DBM;
use CodexShaper\DBM\Models\DBM_Collection;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Str;

trait RecordTrait
{
    protected $name;
    protected $function_name;
    protected $localModel;
    protected $create;
    protected $relatedPivotKey;
    protected $parentPivotKey;
    protected $relationType;
    protected $details;
    protected $rules;
    protected $update;
    protected $type;
    protected $settings;
    protected $validation;
    protected $pivotTable;
    protected $foreignModel;
    protected $localTable;

    public function saveFiles($request, $column, $tableName)
    {
        $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;
        }

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

        return $value;

    }

    public function prepareStoreField($value, $tableName, $column)
    {
        $value = 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."]);
            }

            if ($fieldType != 'timestamp') {
                $value = Type::$fieldType($value);
            }

        }

        return $value;
    }

    public function prepareRecordFields($fields)
    {
        foreach ($fields as $key => $field) {

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

                $relationship            = $field->settings;
                $foreignModel            = $relationship['foreignModel'];
                $foreignKey              = $relationship['foreignKey'];
                $fields                  = $this->removeRelationshipKeyForBelongsTo($fields, $foreignKey);
                $field->foreignTableData = $foreignModel::all();
                $field->relationship     = $relationship;
                continue;
            }

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

        return $fields;
    }

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

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

        return $results;
    }

    public function prepareJsonFieldData($records, $fields, $object, $findValue)
    {
        $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 ($findValue && $record->{$object->details['findColumn']} == $findValue) {
                $newRecord = $record;
            }

            $newRecords[] = $record;
        }

        return [
            "records" => $newRecords,
            "record"  => $newRecord,
        ];
    }

    public 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 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;
                $rules              = $this->prepareRules($columns, $action, $validationSettings);
                $data               = [$name => $columns->{$name}];
                $validator          = Validator::make($data, [$name => $rules]);
                if ($validator->fails()) {
                    foreach ($validator->errors()->all() as $error) {
                        $errors[] = $error;
                    }
                }
            }
        }

        return $errors;
    }

    public function prepareRules($columns, $action, $settings)
    {
        $rules = '';

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

        return $rules;
    }

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

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

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

    public 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;
    }

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

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

        return $result;
    }
}


1			<?php
2
3			namespace CodexShaper\DBM\Traits;
4
5			use CodexShaper\DBM\Database\Drivers\MongoDB\Type;
6			use CodexShaper\DBM\Facades\Driver;
7			use CodexShaper\DBM\Facades\Manager as DBM;
8			use CodexShaper\DBM\Models\DBM_Collection;
9			use Illuminate\Support\Facades\DB;
10			use Illuminate\Support\Facades\Validator;
11			use Illuminate\Support\Str;
12
13			trait RecordTrait
14			{
15			protected $name;
16			protected $function_name;
17			protected $localModel;
18			protected $create;
19			protected $relatedPivotKey;
20			protected $parentPivotKey;
21			protected $relationType;
22			protected $details;
23			protected $rules;
24			protected $update;
25			protected $type;
26			protected $settings;
27			protected $validation;
28			protected $pivotTable;
29			protected $foreignModel;
30			protected $localTable;
31
32			public function saveFiles($request, $column, $tableName)
33			{
34			$files = $request->file($column);
35			$values = [];
36			foreach ($files as $file) {
37			$fileName = Str::random(config('dbm.filesystem.random_length')) . '.' . $file->getClientOriginalExtension();
38			$path = 'public/dbm/' . $tableName;
39			$file->storeAs($path, $fileName);
40			$values[] = $fileName;
41			}
42
43			if (count($values) > 1) {
44			$value = $values;
45			if (!Driver::isMongoDB()) {
46			$value = json_encode($values);
47			}
48			} else if (count($values) == 1) {
49			$value = $values[0];
50			}
51
52			return $value;
			0 ignored issues – show Comprehensibility Best Practice introduced 2020-01-03 15:43 UTC by Report Bug Copy Issue Report The variable `$value` does not seem to be defined for all execution paths leading up to this point. Loading history...
53			}
54
55			public function prepareStoreField($value, $tableName, $column)
56			{
57			$value = is_array($value) ? json_encode($value) : $value;
58
59			if (Driver::isMongoDB()) {
60
61			$fieldType = $this->getFieldType($tableName, $column);
62
63			if (!in_array($fieldType, Type::getTypes())) {
64			$this->generateError([$fieldType . " type not supported."]);
65			}
66
67			if ($fieldType != 'timestamp') {
68			$value = Type::$fieldType($value);
69			}
70
71			}
72
73			return $value;
74			}
75
76			public function prepareRecordFields($fields)
77			{
78			foreach ($fields as $key => $field) {
79
80			if ($field->type == 'relationship') {
81
82			$relationship = $field->settings;
83			$foreignModel = $relationship['foreignModel'];
84			$foreignKey = $relationship['foreignKey'];
85			$fields = $this->removeRelationshipKeyForBelongsTo($fields, $foreignKey);
86			$field->foreignTableData = $foreignModel::all();
87			$field->relationship = $relationship;
88			continue;
89			}
90
91			if (isset($field->settings['options'])) {
92			$options = $this->getSettingOptions($field);
93			if (is_array($options)) {
94			$fields[$key]->options = $options;
95			}
96			}
97			}
98
99			return $fields;
100			}
101
102			public function removeRelationshipKeyForBelongsTo($fields, $foreignKey)
103			{
104			$results = [];
105
106			foreach ($fields as $key => $field) {
107			if ($field->name == $foreignKey) {
108			unset($fields[$key]);
109			continue;
110			}
111			$results[] = $field;
112			}
113
114			return $results;
115			}
116
117			public function prepareJsonFieldData($records, $fields, $object, $findValue)
118			{
119			$newRecords = [];
120			$newRecord = new \stdClass();
121
122			foreach ($records as $item => $record) {
123
124			foreach ($fields as $key => &$field) {
125
126			if (isset($record->{$field->name})) {
127
128			$record->{$field->name} = is_json($record->{$field->name}) ? json_decode($record->{$field->name}, true) : $record->{$field->name};
129			}
130			}
131
132			if ($findValue && $record->{$object->details['findColumn']} == $findValue) {
133			$newRecord = $record;
134			}
135
136			$newRecords[] = $record;
137			}
138
139			return [
140			"records" => $newRecords,
141			"record" => $newRecord,
142			];
143			}
144
145			public function getSettingOptions($field)
146			{
147			$options = $field->settings['options'];
148			if (isset($options['controller'])) {
149			$partials = explode('@', $options['controller']);
150			$controllerName = $partials[0];
151			$methodName = $partials[1];
152
153			return app($controllerName)->{$methodName}();
154			}
155			}
156
157			public function validation($fields, $columns, $action = "create")
158			{
159			$errors = [];
160			foreach ($fields as $field) {
161			$name = $field->name;
162
163			if (is_object($field->settings) && property_exists($field->settings, 'validation') !== false) {
164
165			$validationSettings = $field->settings->validation;
166			$rules = $this->prepareRules($columns, $action, $validationSettings);
167			$data = [$name => $columns->{$name}];
168			$validator = Validator::make($data, [$name => $rules]);
169			if ($validator->fails()) {
170			foreach ($validator->errors()->all() as $error) {
171			$errors[] = $error;
172			}
173			}
174			}
175			}
176
177			return $errors;
178			}
179
180			public function prepareRules($columns, $action, $settings)
181			{
182			$rules = '';
183
184			if (is_string($settings)) {
185			$rules = $settings;
186			} else if ($action == 'create' && isset($settings->create)) {
187			$createSettings = $settings->create;
188			$rules = $createSettings->rules;
189			} else if ($action == 'update' && isset($settings->update)) {
190			$updateSettings = $settings->update;
191			$localKey = $updateSettings->localKey;
192			$rules = $updateSettings->rules . ',' . $columns->{$localKey};
193			}
194
195			return $rules;
196			}
197
198			public function getFieldType($collectionName, $fieldName)
199			{
200			$collection = DBM_Collection::where('name', $collectionName)->first();
201
202			return $collection->fields()->where('name', $fieldName)->first()->type;
203			}
204
205			public function generateError($errors)
206			{
207			return response()->json([
208			'success' => false,
209			'errors' => $errors,
210			], 400);
211			}
212
213			public function hasFunction($fields, $column)
214			{
215			foreach ($fields as $field) {
216			if ($field->name == $column && ($field->function_name != null \|\| $field->function_name != "")) {
217			return $field->function_name;
218			}
219			}
220
221			return false;
222			}
223
224			public function executeFunction($functionName, $value = null)
225			{
226			$signature = ($value != null) ? "{$functionName}('{$value}')" : "{$functionName}()";
227
228			$result = DB::raw("{$signature}");
229
230			return $result;
231			}
232			}
233

Codexshaper / laravel-database-manager

Push — master ( fbf6ba...24a065 )

RecordTrait::removeRelationshipKeyForBelongsTo() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like