BaseModelController::validate() - Code Metrics - Inspection of "= minor refactor" - marcmascarell/laravel-artificer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev ( 7b74bc...6a9580 )

by Marc

created 2016-08-13 19:34 UTC

BaseModelController::validate() A

↳ Parent: BaseModelController

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	1

<?php namespace Mascame\Artificer\Controllers;

use App;
use Auth;
use File;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Support\Str;
use Illuminate\Support\Facades\Input;
use Mascame\Artificer\Fields\FieldFactory;
use Mascame\Formality\Parser\Parser;
use Mascame\Artificer\Permit\ModelPermit;
use Redirect;
use Route;
use Session;
use Validator;
use View;


class BaseModelController extends BaseController
{

    /**
     * The Eloquent model instance
     * @var \Eloquent
     */
    protected $model;

    /**
     *
     */
    public function __construct()
    {
        parent::__construct();

        // Todo: Do Sth with this
        if (false) {
            if (! Auth::check() || ! ModelPermit::access()) {
                App::abort('403', 'Forbidden access');
            }
        }

        $this->model = $this->modelObject->model;


        $this->checkPermissions();
    }

    /**
     *
     */
    protected function checkPermissions()
    {
        $permit = array(
            'read' => ModelPermit::to('read'),
            'create' => ModelPermit::to('create'),
            'update' => ModelPermit::to('update'),
            'delete' => ModelPermit::to('delete'),
        );

        ModelPermit::routeAction(Route::currentRouteName());

        View::share('permit', $permit);
    }

    /**
     * @param $data
     */
    protected function handleData($data)
    {
        $this->data = $data;

        $this->getFields($data);

        View::share('data', $this->data);
    }

    /**
     * @param $data
     * @return null
     */
    protected function getFields($data)

    {
        if ($this->fields) return $this->fields;

        /**
         * @var $data Collection
         */
        $modelFields = $this->modelObject->getOption('fields');
        $types = config('admin.fields.types');
        $fields = [];

        foreach ($this->modelObject->columns as $column) {
            $options = [];

            if (isset($modelFields[$column])) $options = $modelFields[$column];

            $fields[$column] = $options;
        }

        $fieldFactory = new FieldFactory(new Parser($types), $types, $fields, config('admin.fields.classmap'));
        $this->fields = $fieldFactory->makeFields();

        View::share('fields', $this->fields);

        return $this->fields;
    }

    // Prepares fields for factory
//    protected function prepareFields($data) {
//        $fields = [];
//
//        foreach ($data as $key => $item) {
//            foreach ($this->modelObject->columns as $column) {
//                $fields[$key][$column] = $item->$column;
//            }
//        }
//
//        return $fields;
//    }

    /**
     * @return array
     */
    protected function getSort()
    {
        return [
            'column' =>  Input::get('sort_by', 'id'),
            'direction' =>  Input::get('direction', 'asc'),
        ];
    }

    /**
     * @return array
     */
    protected function getRules()
    {
        if (isset($this->options['rules'])) {
            return $this->options['rules'];
        } else {
            if (isset($this->model->rules)) {
                return $this->model->rules;
            }
        }

        return array();
    }

    /**
     * @param $items
     * @return null
     */
    public static function getCurrentModelId($items)
    {
        return (isset($items->id)) ? $items->id : null;
    }

    /**
     *
     *
     * @return array|mixed
     */
    protected function filterInputData()
    {
        $input = Input::all();

        if ($this->modelObject->hasGuarded()) {
            $filteredInput = [];

            foreach ($input as $key => $value) {
                if (in_array($key, $this->modelObject->columns)) {
                    $filteredInput[$key] = $value;
                }
            }

            return $this->except($this->modelObject->getGuarded(), $filteredInput);
        }

        return $input;
    }

    /**
     * @param $keys
     * @param $values
     * @return mixed
     */
    protected function except($keys, $values)
    {
        $keys = is_array($keys) ? $keys : func_get_args();

        $results = $values;

        array_forget($results, $keys);

        return $results;
    }

    /**
     * @param $data
     * @return array
     */
    protected function handleFiles($data)
    {
        $newData = [];
        $fields = $this->getFields($data);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();

        if (!is_null($fields)) {
            foreach ($fields as $field) {
                if ($this->isFileInput($field->type)) {
                    if (Input::hasFile($field->name)) {
                        $newData[$field->name] = $this->uploadFile($field->name);
                    } else {
                        unset($data[$field->name]);
                    }
                }
            }
        }

        return array_merge($data, $newData);
    }

    /**
     * @param $type
     * @return bool
     */
    protected function isFileInput($type)
    {
        return ($type == 'file' || $type == 'image');
    }

    /**
     * This is used for simple upload (no plugins)
     *
     * @param $fieldName
     * @param null $path
     * @return string
     */
    protected function uploadFile($fieldName, $path = null)
    {
        if (!$path) {
            $path = public_path() . '/uploads/';
        }

        $file = Input::file($fieldName);

        if (!file_exists($path)) {
            File::makeDirectory($path);
        }

        $name = uniqid() . '-' . Str::slug($file->getFilename()) . '.' . $file->guessExtension();

        $file->move($path, $name);

        return $name;
    }

    /**
     * @param $modelName
     * @param $id
     * @param $field
     * @return null
     */
    protected function getRelatedFieldOutput($modelName, $id, $field)

    {
        if ($id != 0) {
            $this->handleData($this->model->with($this->modelObject->getRelations())->findOrFail($id));
        } else {
            if (Session::has('_set_relation_on_create_' . $this->modelObject->name)) {
                $relateds = Session::get('_set_relation_on_create_' . $this->modelObject->name);
                $related_ids = array();
                foreach ($relateds as $related) {
                    $related_ids[] = $related['id'];
                }

                $data = $relateds[0]['modelClass']::whereIn('id', $related_ids)->get();

                $this->handleData($data);
            } else {
                return null;
            }
        }

        return $this->fields[$field]->output();
    }

    /**
     * @param $validator
     * @param $route
     * @param null $id
     * @return Redirect
     */
    protected function redirect($validator, $route, $id = null)
    {
        if (Input::has('_standalone')) {
            $routeParams = array('slug' => Input::get('_standalone'));

            if ($id) {
                $routeParams['id'] = $id;
            }

            return Redirect::route($route, $routeParams)

                ->withErrors($validator)
                ->withInput();
        }

        return Redirect::back()->withErrors($validator)->withInput();

    }

    /**
     * @param $data
     * @return \Illuminate\Validation\Validator
     */
    protected function validate($data)
    {
        return Validator::make($data, ['name' => 'required']);
    }

    /**
     * @param $modelName
     * @param null $data
     * @param $sort
     * @return $this
     */
    protected function all($modelName, $data = null, $sort)
    {
        $this->handleData($data);

        return View::make($this->getView('all'))
            ->with('items', $this->data)
            ->with('sort', $sort);
    }
}

1			<?php namespace Mascame\Artificer\Controllers;
2
3			use App;
4			use Auth;
5			use File;
6			use Illuminate\Database\Eloquent\Collection;
7			use Illuminate\Support\Str;
8			use Illuminate\Support\Facades\Input;
9			use Mascame\Artificer\Fields\FieldFactory;
10			use Mascame\Formality\Parser\Parser;
11			use Mascame\Artificer\Permit\ModelPermit;
12			use Redirect;
13			use Route;
14			use Session;
15			use Validator;
16			use View;
17
18
19			class BaseModelController extends BaseController
20			{
21
22			/**
23			* The Eloquent model instance
24			* @var \Eloquent
25			*/
26			protected $model;
27
28			/**
29			*
30			*/
31			public function __construct()
32			{
33			parent::__construct();
34
35			// Todo: Do Sth with this
36			if (false) {
37			if (! Auth::check() \|\| ! ModelPermit::access()) {
38			App::abort('403', 'Forbidden access');
39			}
40			}
41
42			$this->model = $this->modelObject->model;
			0 ignored issues – show Documentation Bug introduced 2016-04-02 22:07 UTC by Report Bug Copy Issue Report It seems like `$this->modelObject->model` of type `object<Illuminate\Database\Eloquent\Model>` is incompatible with the declared type `object<Eloquent>` of property `$model`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
43
44			$this->checkPermissions();
45			}
46
47			/**
48			*
49			*/
50			protected function checkPermissions()
51			{
52			$permit = array(
53			'read' => ModelPermit::to('read'),
54			'create' => ModelPermit::to('create'),
55			'update' => ModelPermit::to('update'),
56			'delete' => ModelPermit::to('delete'),
57			);
58
59			ModelPermit::routeAction(Route::currentRouteName());
60
61			View::share('permit', $permit);
62			}
63
64			/**
65			* @param $data
66			*/
67			protected function handleData($data)
68			{
69			$this->data = $data;
70
71			$this->getFields($data);
72
73			View::share('data', $this->data);
74			}
75
76			/**
77			* @param $data
78			* @return null
79			*/
80			protected function getFields($data)
			0 ignored issues – show Unused Code introduced 2016-03-29 06:13 UTC by Report Bug Copy Issue Report The parameter `$data` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
81			{
82			if ($this->fields) return $this->fields;
83
84			/**
85			* @var $data Collection
86			*/
87			$modelFields = $this->modelObject->getOption('fields');
88			$types = config('admin.fields.types');
89			$fields = [];
90
91			foreach ($this->modelObject->columns as $column) {
92			$options = [];
93
94			if (isset($modelFields[$column])) $options = $modelFields[$column];
95
96			$fields[$column] = $options;
97			}
98
99			$fieldFactory = new FieldFactory(new Parser($types), $types, $fields, config('admin.fields.classmap'));
100			$this->fields = $fieldFactory->makeFields();
101
102			View::share('fields', $this->fields);
103
104			return $this->fields;
105			}
106
107			// Prepares fields for factory
108			// protected function prepareFields($data) {
109			// $fields = [];
110			//
111			// foreach ($data as $key => $item) {
112			// foreach ($this->modelObject->columns as $column) {
113			// $fields[$key][$column] = $item->$column;
114			// }
115			// }
116			//
117			// return $fields;
118			// }
119
120			/**
121			* @return array
122			*/
123			protected function getSort()
124			{
125			return [
126			'column' => Input::get('sort_by', 'id'),
127			'direction' => Input::get('direction', 'asc'),
128			];
129			}
130
131			/**
132			* @return array
133			*/
134			protected function getRules()
135			{
136			if (isset($this->options['rules'])) {
137			return $this->options['rules'];
138			} else {
139			if (isset($this->model->rules)) {
140			return $this->model->rules;
141			}
142			}
143
144			return array();
145			}
146
147			/**
148			* @param $items
149			* @return null
150			*/
151			public static function getCurrentModelId($items)
152			{
153			return (isset($items->id)) ? $items->id : null;
154			}
155
156			/**
157			*
158			*
159			* @return array\|mixed
160			*/
161			protected function filterInputData()
162			{
163			$input = Input::all();
164
165			if ($this->modelObject->hasGuarded()) {
166			$filteredInput = [];
167
168			foreach ($input as $key => $value) {
169			if (in_array($key, $this->modelObject->columns)) {
170			$filteredInput[$key] = $value;
171			}
172			}
173
174			return $this->except($this->modelObject->getGuarded(), $filteredInput);
175			}
176
177			return $input;
178			}
179
180			/**
181			* @param $keys
182			* @param $values
183			* @return mixed
184			*/
185			protected function except($keys, $values)
186			{
187			$keys = is_array($keys) ? $keys : func_get_args();
188
189			$results = $values;
190
191			array_forget($results, $keys);
192
193			return $results;
194			}
195
196			/**
197			* @param $data
198			* @return array
199			*/
200			protected function handleFiles($data)
201			{
202			$newData = [];
203			$fields = $this->getFields($data);
			0 ignored issues – show Bug introduced 2016-08-06 09:29 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$fields` is correct as `$this->getFields($data)` (which targets `Mascame\Artificer\Contro...Controller::getFields()`) seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
204
205			if (!is_null($fields)) {
206			foreach ($fields as $field) {
207			if ($this->isFileInput($field->type)) {
208			if (Input::hasFile($field->name)) {
209			$newData[$field->name] = $this->uploadFile($field->name);
210			} else {
211			unset($data[$field->name]);
212			}
213			}
214			}
215			}
216
217			return array_merge($data, $newData);
218			}
219
220			/**
221			* @param $type
222			* @return bool
223			*/
224			protected function isFileInput($type)
225			{
226			return ($type == 'file' \|\| $type == 'image');
227			}
228
229			/**
230			* This is used for simple upload (no plugins)
231			*
232			* @param $fieldName
233			* @param null $path
234			* @return string
235			*/
236			protected function uploadFile($fieldName, $path = null)
237			{
238			if (!$path) {
239			$path = public_path() . '/uploads/';
240			}
241
242			$file = Input::file($fieldName);
243
244			if (!file_exists($path)) {
245			File::makeDirectory($path);
246			}
247
248			$name = uniqid() . '-' . Str::slug($file->getFilename()) . '.' . $file->guessExtension();
249
250			$file->move($path, $name);
251
252			return $name;
253			}
254
255			/**
256			* @param $modelName
257			* @param $id
258			* @param $field
259			* @return null
260			*/
261			protected function getRelatedFieldOutput($modelName, $id, $field)
			0 ignored issues – show Unused Code introduced 2016-02-25 21:36 UTC by Report Bug Copy Issue Report The parameter `$modelName` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
262			{
263			if ($id != 0) {
264			$this->handleData($this->model->with($this->modelObject->getRelations())->findOrFail($id));
265			} else {
266			if (Session::has('_set_relation_on_create_' . $this->modelObject->name)) {
267			$relateds = Session::get('_set_relation_on_create_' . $this->modelObject->name);
268			$related_ids = array();
269			foreach ($relateds as $related) {
270			$related_ids[] = $related['id'];
271			}
272
273			$data = $relateds[0]['modelClass']::whereIn('id', $related_ids)->get();
274
275			$this->handleData($data);
276			} else {
277			return null;
278			}
279			}
280
281			return $this->fields[$field]->output();
282			}
283
284			/**
285			* @param $validator
286			* @param $route
287			* @param null $id
288			* @return Redirect
289			*/
290			protected function redirect($validator, $route, $id = null)
291			{
292			if (Input::has('_standalone')) {
293			$routeParams = array('slug' => Input::get('_standalone'));
294
295			if ($id) {
296			$routeParams['id'] = $id;
297			}
298
299			return Redirect::route($route, $routeParams)
			0 ignored issues – show Bug introduced 2016-02-25 21:36 UTC by Report Bug Copy Issue Report The method `route()` does not seem to exist on `object<redirect>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
300			->withErrors($validator)
301			->withInput();
302			}
303
304			return Redirect::back()->withErrors($validator)->withInput();
			0 ignored issues – show Bug introduced 2016-02-25 21:36 UTC by Report Bug Copy Issue Report The method `back()` does not seem to exist on `object<redirect>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
305			}
306
307			/**
308			* @param $data
309			* @return \Illuminate\Validation\Validator
310			*/
311			protected function validate($data)
312			{
313			return Validator::make($data, ['name' => 'required']);
314			}
315
316			/**
317			* @param $modelName
318			* @param null $data
319			* @param $sort
320			* @return $this
321			*/
322			protected function all($modelName, $data = null, $sort)
323			{
324			$this->handleData($data);
325
326			return View::make($this->getView('all'))
327			->with('items', $this->data)
328			->with('sort', $sort);
329			}
330			}

marcmascarell / laravel-artificer

Push — dev ( 7b74bc...6a9580 )

BaseModelController::validate() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like