CrudController::store() - Code Metrics - Inspection of "Merge pull request #8 from eliurkis/develop" - eliurkis/crud - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (0d39ab)

by Eliurkis

created 2016-12-27 08:33 UTC

CrudController::store() A

↳ Parent: CrudController

Complexity

Conditions	3
Paths	3

Size

Total Lines	23
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
c	2
b	0
f	1
dl	0
loc	23
rs	9.0856
cc	3
eloc	16
nc	3
nop	1

<?php

namespace Eliurkis\Crud;

use DB;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Database\QueryException;

class CrudController extends Controller
{
    protected $route;
    protected $entity;
    protected $entityInstance = null;
    protected $fields = [];
    protected $columns = [];
    protected $buttons = [
        'create',
        'edit',
        'delete',
    ];
    protected $paginate = null;
    protected $searchable = [];
    protected $filters = [];
    protected $queryFilters = [];
    protected $filterRequire = [];
    protected $textsGeneral = [
        'list_title'   => 'Contents',
        'create_title' => '',
        'edit_title'   => '',
    ];
    protected $texts = [];
    protected $htmlFilters = [];
    protected $action = null;
    protected $formColsClasses = [
        'col-md-10 col-md-offset-1',
        'col-md-2',
        'col-md-10',
    ];
    protected $links = [];

    public function index(Request $request)
    {
        $entity = $this->entity;

        // Relation Fields
        $belongToFields = $this->getBelongToFields();
        if (count($belongToFields)) {
            $entity = $this->entity->with($belongToFields);
        }

        // Filters
        $entity = $this->filters($entity, $request);

        // Search
        $entity = $this->search($entity, $request);

        // Pagination
        $rows = $this->paginate > 0 ? $this->paginate($entity, $request) : $entity->get();

        // HTML Filters
        $this->htmlFilters();

        return view('crud::list', compact('rows'))
            ->with('fields', $this->fields)
            ->with('columns', $this->columns)
            ->with('searchable', $this->searchable)
            ->with('buttons', $this->buttons)
            ->with('paginate', $this->paginate)
            ->with('t', $this->texts)
            ->with('htmlFilters', $this->htmlFilters)
            ->with('links', $this->prepareLinks())
            ->with('request', $request)
            ->with('route', $this->route);
    }

    public function create()
    {
        $this->prepareFields();

        return view('crud::create')
            ->with('type', 'create')
            ->with('route', $this->route)
            ->with('t', $this->texts)
            ->with('formColsClasses', $this->formColsClasses)
            ->with('links', $this->prepareLinks())
            ->with('fields', $this->fields);
    }

    public function store(Request $request)
    {
        $this->validateRequest($request);

        DB::beginTransaction();

        try {
            $row = $this->entity->create(array_merge($request->all(), $this->queryFilters));
            $this->updateForeignRelations($row, $request);
        } catch (QueryException $e) {
            return redirect()
                ->back()
                ->with('error', 'Ha ocurrido un error, intente nuevamente');
        }

        DB::commit();

        return redirect()
            ->route($this->route.'.index')
            ->with('success', isset($this->textsGeneral['save_action'])
                ? $this->textsGeneral['save_action']
                : trans('eliurkis::crud.save_action'));
    }

    public function edit($id)
    {
        if (! $this->entityInstance) {
            $this->entityInstance = $this->entity->findOrFail($id);
        }

        $this->prepareFields();

        return view('crud::create')
            ->with('type', 'edit')
            ->with('route', $this->route)
            ->with('t', $this->texts)
            ->with('fields', $this->fields)
            ->with('formColsClasses', $this->formColsClasses)
            ->with('links', $this->prepareLinks())
            ->with('data', $this->entityInstance);
    }

    public function update(Request $request, $id)
    {
        $this->validateRequest($request);

        DB::beginTransaction();

        try {
            $row = $this->entity->findOrFail($id);
            $row->update(
                array_merge(
                    $request->all(),
                    $this->queryFilters
                )
            );
            $this->updateForeignRelations($row, $request);
        } catch (QueryException $e) {
            return redirect()
                ->back()
                ->with('error', 'Ha ocurrido un error, intente nuevamente');
        }

        DB::commit();

        return redirect()
            ->route($this->route.'.index', $this->getParamsFilters($row))
            ->with('success', isset($this->textsGeneral['save_action'])
                ? $this->textsGeneral['save_action']
                : trans('eliurkis::crud.save_action'));
    }

    public function destroy($id)
    {
        $this->entity->destroy($id);

        return redirect()
            ->route($this->route.'.index')
            ->with('success', isset($this->textsGeneral['delete_action'])
                ? $this->textsGeneral['delete_action']
                : trans('eliurkis::crud.delete_action'));
    }

    /* Private Actions */

    /**
     * @param $entity
     * @param Request $request
     *
     * @return mixed
     */
    protected function filters($entity, $request)
    {
        if ($request->query('filter')) {
            foreach ($request->query('filter') as $field => $value) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                $entity = $entity->where($field, $value);
            }
        }

        if (count($this->queryFilters)) {
            foreach ($this->queryFilters as $field => $value) {
                $entity = $entity->where($field, $value);
            }
        }

        return $entity;
    }

    protected function htmlFilters()
    {
        $this->htmlFilters = [];
        if (count($this->filters)) {
            foreach ($this->filters as $filter) {
                // Build params
                $urlParams = \Input::query();

                // Default Value
                $this->fields[$filter]['config']['default_value'] = isset($urlParams['filter'][$filter])
                    ? $urlParams['filter'][$filter]
                    : null;

                // Create URL
                if (isset($urlParams['filter'][$filter])) {
                    unset($urlParams['filter'][$filter]);
                }
                $this->fields[$filter]['attributes']['data-filter-url'] = route($this->route.'.index', $urlParams)
                    .(count($urlParams) ? '&' : '?');

                // Create array
                $this->action = 'list';
                $this->htmlFilters[$filter] = $this->prepareField($filter);
            }
        }
    }

    /**
     * @param $entity
     * @param Request $request
     *
     * @return mixed
     */
    protected function paginate($entity, $request)
    {
        $rows = $entity->paginate($this->paginate);

        if ($request->get('q') != '') {
            $rows->appends(['q' => $request->get('q')]);
        }

        if ($request->get('filter')) {
            foreach ($request->get('filter') as $field => $value) {
                $rows->appends(['filter['.$field.']' => $value]);
            }
        }

        return $rows;
    }

    /**
     * @param $entity
     * @param Request $request
     *
     * @return mixed
     */
    protected function search($entity, $request)
    {
        if ($request->get('q') != '') {
            $searchableCols = isset($this->searchable['columns']) ? $this->searchable['columns'] : $this->searchable;

            $entity = $entity->where(function ($query) use ($request, $searchableCols) {
                foreach ($searchableCols as $field) {
                    $query->orWhere($field, 'like', '%'.$request->get('q').'%');
                }
            });

            if (isset($this->searchable['joins'])) {
                foreach ($this->searchable['joins'] as $table => $joinFields) {
                    $entity = $entity->join($table, $joinFields[0], '=', $joinFields[1]);
                }
            }
        }

        return $entity;
    }

    protected function getForeignRelationsFields()
    {
        $foreignRelations = [];
        foreach ($this->fields as $field => $options) {
            if ($options['type'] === 'foreign') {
                $foreignRelations[] = $field;
            }
        }

        return $foreignRelations;
    }

    protected function getBelongToFields()
    {
        $fields = [];
        foreach ($this->fields as $field => $options) {
            if ($options['type'] === 'select' && isset($options['config']['rel'])) {
                $fields[] = $options['config']['rel'];
            }
        }

        return $fields;
    }

    /**
     * @param object $row
     * @param Request $request
     */
    protected function updateForeignRelations($row, $request)
    {
        $foreignRelations = $this->getForeignRelationsFields();

        foreach ($foreignRelations as $foreignRelation) {
            $values = $request->get($foreignRelation);
            $row->$foreignRelation()->sync((array) $values);
        }
    }

    protected function getParamsFilters($row)
    {
        $params = [];

        if (count($this->filterRequire)) {
            $params['filter'] = [];

            foreach ($this->filterRequire as $field) {
                $params['filter'][$field] = $row->$field;
            }
        }

        return $params;
    }

    protected function prepareLinks()
    {
        $links = ['index', 'create', 'store'];

        foreach ($links as $link) {
            if (! isset($this->links[$link])) {
                $this->links[$link] = route($this->route.'.'.$link);
            }
        }

        return $this->links;
    }

    /**
     * @param Request $request
     */
    protected function validateRequest($request)
    {
        $validations = [
            'rules'            => [],
            'messages'         => [],
            'customAttributes' => [],
        ];

        foreach ($this->fields as $field => $options) {
            if (isset($options['validation'])) {
                $validations['rules'][$field] = $options['validation'];
                $validations['customAttributes'][$field] = $options['label'];
            }
        }

        if ($validations['rules']) {
            $this->validate(
                $request,
                $validations['rules'],
                $validations['messages'],
                $validations['customAttributes']
            );
        }
    }

    protected function prepareRelationalFields($name)
    {
        // Default values
        $config = isset($this->fields[$name]['config']) ? $this->fields[$name]['config'] : [];
        $config['options'] = isset($config['options']) ? $config['options'] : [];
        $config['cols'] = isset($config['cols']) ? $config['cols'] : 1;

        // Get foreign values
        if (! count($config['options']) && isset($config['entity'])) {
            $config['options'] = $config['entity']::get()
                ->lists($config['field_value'], $config['field_key'])
                ->toArray();
        }

        // No selection for filters
        if ($this->action == 'list' && isset($config['filter_no_selection'])) {
            $config['options'] = array_merge([
                '-1' => $config['filter_no_selection'],
            ], $config['options']);
        }

        $this->fields[$name]['config'] = $config;

        return $this->fields[$name];
    }

    protected function prepareFields()
    {
        if ($this->entityInstance) {
            \Form::model($this->entityInstance);
        }

        foreach ($this->fields as $name => $properties) {
            $this->fields[$name]['html'] = $this->prepareField($name, $properties);
        }
    }

    protected function prepareField($name, $properties = [])
    {
        // Init
        if (! $properties) {

            $properties = $this->fields[$name];
        }

        $this->fields[$name]['config'] = isset($properties['config']) ? $properties['config'] : [];
        $this->fields[$name]['attributes'] = isset($properties['attributes']) ? $properties['attributes'] : [];
        $this->fields[$name]['attributes']['class'] = 'form-control';
        $this->fields[$name]['html'] = null;

        $config = $this->fields[$name]['config'];

        $value = $this->entityInstance
            ? $this->entityInstance->$name
            : (isset($config['default_value']) ? $config['default_value'] : null);

        // Define field type class namespace
        $className = '\Eliurkis\Crud\FieldTypes\\'.ucfirst($properties['type']);
        if (! class_exists($className)) {
            return;
        }

        if ($properties['type'] == 'foreign' || $properties['type'] == 'select') {
            $properties = $this->prepareRelationalFields($name);

            if ($properties['type'] == 'foreign' && $this->entityInstance) {
                $value = $this->entityInstance->{$config['rel']}->lists('id')->toArray();
            }

            if ($properties['type'] == 'select') {
                $properties['attributes']['class'] = 'form-control chosen-select-width';
            }

            return $className::prepare(
                $name,
                $properties['config']['options'],
                $value,
                $properties
            );
        }

        return $className::prepare(
            $name,
            $value,
            $this->fields[$name]
        );
    }
}


1			<?php
2
3			namespace Eliurkis\Crud;
4
5			use DB;
6			use Illuminate\Http\Request;
7			use App\Http\Controllers\Controller;
8			use Illuminate\Database\QueryException;
9
10			class CrudController extends Controller
11			{
12			protected $route;
13			protected $entity;
14			protected $entityInstance = null;
15			protected $fields = [];
16			protected $columns = [];
17			protected $buttons = [
18			'create',
19			'edit',
20			'delete',
21			];
22			protected $paginate = null;
23			protected $searchable = [];
24			protected $filters = [];
25			protected $queryFilters = [];
26			protected $filterRequire = [];
27			protected $textsGeneral = [
28			'list_title' => 'Contents',
29			'create_title' => '',
30			'edit_title' => '',
31			];
32			protected $texts = [];
33			protected $htmlFilters = [];
34			protected $action = null;
35			protected $formColsClasses = [
36			'col-md-10 col-md-offset-1',
37			'col-md-2',
38			'col-md-10',
39			];
40			protected $links = [];
41
42			public function index(Request $request)
43			{
44			$entity = $this->entity;
45
46			// Relation Fields
47			$belongToFields = $this->getBelongToFields();
48			if (count($belongToFields)) {
49			$entity = $this->entity->with($belongToFields);
50			}
51
52			// Filters
53			$entity = $this->filters($entity, $request);
54
55			// Search
56			$entity = $this->search($entity, $request);
57
58			// Pagination
59			$rows = $this->paginate > 0 ? $this->paginate($entity, $request) : $entity->get();
60
61			// HTML Filters
62			$this->htmlFilters();
63
64			return view('crud::list', compact('rows'))
65			->with('fields', $this->fields)
66			->with('columns', $this->columns)
67			->with('searchable', $this->searchable)
68			->with('buttons', $this->buttons)
69			->with('paginate', $this->paginate)
70			->with('t', $this->texts)
71			->with('htmlFilters', $this->htmlFilters)
72			->with('links', $this->prepareLinks())
73			->with('request', $request)
74			->with('route', $this->route);
75			}
76
77			public function create()
78			{
79			$this->prepareFields();
80
81			return view('crud::create')
82			->with('type', 'create')
83			->with('route', $this->route)
84			->with('t', $this->texts)
85			->with('formColsClasses', $this->formColsClasses)
86			->with('links', $this->prepareLinks())
87			->with('fields', $this->fields);
88			}
89
90			public function store(Request $request)
91			{
92			$this->validateRequest($request);
93
94			DB::beginTransaction();
95
96			try {
97			$row = $this->entity->create(array_merge($request->all(), $this->queryFilters));
98			$this->updateForeignRelations($row, $request);
99			} catch (QueryException $e) {
100			return redirect()
101			->back()
102			->with('error', 'Ha ocurrido un error, intente nuevamente');
103			}
104
105			DB::commit();
106
107			return redirect()
108			->route($this->route.'.index')
109			->with('success', isset($this->textsGeneral['save_action'])
110			? $this->textsGeneral['save_action']
111			: trans('eliurkis::crud.save_action'));
112			}
113
114			public function edit($id)
115			{
116			if (! $this->entityInstance) {
117			$this->entityInstance = $this->entity->findOrFail($id);
118			}
119
120			$this->prepareFields();
121
122			return view('crud::create')
123			->with('type', 'edit')
124			->with('route', $this->route)
125			->with('t', $this->texts)
126			->with('fields', $this->fields)
127			->with('formColsClasses', $this->formColsClasses)
128			->with('links', $this->prepareLinks())
129			->with('data', $this->entityInstance);
130			}
131
132			public function update(Request $request, $id)
133			{
134			$this->validateRequest($request);
135
136			DB::beginTransaction();
137
138			try {
139			$row = $this->entity->findOrFail($id);
140			$row->update(
141			array_merge(
142			$request->all(),
143			$this->queryFilters
144			)
145			);
146			$this->updateForeignRelations($row, $request);
147			} catch (QueryException $e) {
148			return redirect()
149			->back()
150			->with('error', 'Ha ocurrido un error, intente nuevamente');
151			}
152
153			DB::commit();
154
155			return redirect()
156			->route($this->route.'.index', $this->getParamsFilters($row))
157			->with('success', isset($this->textsGeneral['save_action'])
158			? $this->textsGeneral['save_action']
159			: trans('eliurkis::crud.save_action'));
160			}
161
162			public function destroy($id)
163			{
164			$this->entity->destroy($id);
165
166			return redirect()
167			->route($this->route.'.index')
168			->with('success', isset($this->textsGeneral['delete_action'])
169			? $this->textsGeneral['delete_action']
170			: trans('eliurkis::crud.delete_action'));
171			}
172
173			/* Private Actions */
174
175			/**
176			* @param $entity
177			* @param Request $request
178			*
179			* @return mixed
180			*/
181			protected function filters($entity, $request)
182			{
183			if ($request->query('filter')) {
184			foreach ($request->query('filter') as $field => $value) {
			0 ignored issues – show Bug introduced 2016-12-27 08:35 UTC by Report Bug Copy Issue Report The expression `$request->query('filter')` of type `string\|array` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
185			$entity = $entity->where($field, $value);
186			}
187			}
188
189			if (count($this->queryFilters)) {
190			foreach ($this->queryFilters as $field => $value) {
191			$entity = $entity->where($field, $value);
192			}
193			}
194
195			return $entity;
196			}
197
198			protected function htmlFilters()
199			{
200			$this->htmlFilters = [];
201			if (count($this->filters)) {
202			foreach ($this->filters as $filter) {
203			// Build params
204			$urlParams = \Input::query();
205
206			// Default Value
207			$this->fields[$filter]['config']['default_value'] = isset($urlParams['filter'][$filter])
208			? $urlParams['filter'][$filter]
209			: null;
210
211			// Create URL
212			if (isset($urlParams['filter'][$filter])) {
213			unset($urlParams['filter'][$filter]);
214			}
215			$this->fields[$filter]['attributes']['data-filter-url'] = route($this->route.'.index', $urlParams)
216			.(count($urlParams) ? '&' : '?');
217
218			// Create array
219			$this->action = 'list';
220			$this->htmlFilters[$filter] = $this->prepareField($filter);
221			}
222			}
223			}
224
225			/**
226			* @param $entity
227			* @param Request $request
228			*
229			* @return mixed
230			*/
231			protected function paginate($entity, $request)
232			{
233			$rows = $entity->paginate($this->paginate);
234
235			if ($request->get('q') != '') {
236			$rows->appends(['q' => $request->get('q')]);
237			}
238
239			if ($request->get('filter')) {
240			foreach ($request->get('filter') as $field => $value) {
241			$rows->appends(['filter['.$field.']' => $value]);
242			}
243			}
244
245			return $rows;
246			}
247
248			/**
249			* @param $entity
250			* @param Request $request
251			*
252			* @return mixed
253			*/
254			protected function search($entity, $request)
255			{
256			if ($request->get('q') != '') {
257			$searchableCols = isset($this->searchable['columns']) ? $this->searchable['columns'] : $this->searchable;
258
259			$entity = $entity->where(function ($query) use ($request, $searchableCols) {
260			foreach ($searchableCols as $field) {
261			$query->orWhere($field, 'like', '%'.$request->get('q').'%');
262			}
263			});
264
265			if (isset($this->searchable['joins'])) {
266			foreach ($this->searchable['joins'] as $table => $joinFields) {
267			$entity = $entity->join($table, $joinFields[0], '=', $joinFields[1]);
268			}
269			}
270			}
271
272			return $entity;
273			}
274
275			protected function getForeignRelationsFields()
276			{
277			$foreignRelations = [];
278			foreach ($this->fields as $field => $options) {
279			if ($options['type'] === 'foreign') {
280			$foreignRelations[] = $field;
281			}
282			}
283
284			return $foreignRelations;
285			}
286
287			protected function getBelongToFields()
288			{
289			$fields = [];
290			foreach ($this->fields as $field => $options) {
291			if ($options['type'] === 'select' && isset($options['config']['rel'])) {
292			$fields[] = $options['config']['rel'];
293			}
294			}
295
296			return $fields;
297			}
298
299			/**
300			* @param object $row
301			* @param Request $request
302			*/
303			protected function updateForeignRelations($row, $request)
304			{
305			$foreignRelations = $this->getForeignRelationsFields();
306
307			foreach ($foreignRelations as $foreignRelation) {
308			$values = $request->get($foreignRelation);
309			$row->$foreignRelation()->sync((array) $values);
310			}
311			}
312
313			protected function getParamsFilters($row)
314			{
315			$params = [];
316
317			if (count($this->filterRequire)) {
318			$params['filter'] = [];
319
320			foreach ($this->filterRequire as $field) {
321			$params['filter'][$field] = $row->$field;
322			}
323			}
324
325			return $params;
326			}
327
328			protected function prepareLinks()
329			{
330			$links = ['index', 'create', 'store'];
331
332			foreach ($links as $link) {
333			if (! isset($this->links[$link])) {
334			$this->links[$link] = route($this->route.'.'.$link);
335			}
336			}
337
338			return $this->links;
339			}
340
341			/**
342			* @param Request $request
343			*/
344			protected function validateRequest($request)
345			{
346			$validations = [
347			'rules' => [],
348			'messages' => [],
349			'customAttributes' => [],
350			];
351
352			foreach ($this->fields as $field => $options) {
353			if (isset($options['validation'])) {
354			$validations['rules'][$field] = $options['validation'];
355			$validations['customAttributes'][$field] = $options['label'];
356			}
357			}
358
359			if ($validations['rules']) {
360			$this->validate(
361			$request,
362			$validations['rules'],
363			$validations['messages'],
364			$validations['customAttributes']
365			);
366			}
367			}
368
369			protected function prepareRelationalFields($name)
370			{
371			// Default values
372			$config = isset($this->fields[$name]['config']) ? $this->fields[$name]['config'] : [];
373			$config['options'] = isset($config['options']) ? $config['options'] : [];
374			$config['cols'] = isset($config['cols']) ? $config['cols'] : 1;
375
376			// Get foreign values
377			if (! count($config['options']) && isset($config['entity'])) {
378			$config['options'] = $config['entity']::get()
379			->lists($config['field_value'], $config['field_key'])
380			->toArray();
381			}
382
383			// No selection for filters
384			if ($this->action == 'list' && isset($config['filter_no_selection'])) {
385			$config['options'] = array_merge([
386			'-1' => $config['filter_no_selection'],
387			], $config['options']);
388			}
389
390			$this->fields[$name]['config'] = $config;
391
392			return $this->fields[$name];
393			}
394
395			protected function prepareFields()
396			{
397			if ($this->entityInstance) {
398			\Form::model($this->entityInstance);
399			}
400
401			foreach ($this->fields as $name => $properties) {
402			$this->fields[$name]['html'] = $this->prepareField($name, $properties);
403			}
404			}
405
406			protected function prepareField($name, $properties = [])
407			{
408			// Init
409			if (! $properties) {
			0 ignored issues – show Bug Best Practice introduced 2016-12-27 07:41 UTC by Report Bug Copy Issue Report The expression `$properties` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
410			$properties = $this->fields[$name];
411			}
412
413			$this->fields[$name]['config'] = isset($properties['config']) ? $properties['config'] : [];
414			$this->fields[$name]['attributes'] = isset($properties['attributes']) ? $properties['attributes'] : [];
415			$this->fields[$name]['attributes']['class'] = 'form-control';
416			$this->fields[$name]['html'] = null;
417
418			$config = $this->fields[$name]['config'];
419
420			$value = $this->entityInstance
421			? $this->entityInstance->$name
422			: (isset($config['default_value']) ? $config['default_value'] : null);
423
424			// Define field type class namespace
425			$className = '\Eliurkis\Crud\FieldTypes\\'.ucfirst($properties['type']);
426			if (! class_exists($className)) {
427			return;
428			}
429
430			if ($properties['type'] == 'foreign' \|\| $properties['type'] == 'select') {
431			$properties = $this->prepareRelationalFields($name);
432
433			if ($properties['type'] == 'foreign' && $this->entityInstance) {
434			$value = $this->entityInstance->{$config['rel']}->lists('id')->toArray();
435			}
436
437			if ($properties['type'] == 'select') {
438			$properties['attributes']['class'] = 'form-control chosen-select-width';
439			}
440
441			return $className::prepare(
442			$name,
443			$properties['config']['options'],
444			$value,
445			$properties
446			);
447			}
448
449			return $className::prepare(
450			$name,
451			$value,
452			$this->fields[$name]
453			);
454			}
455			}
456

eliurkis / crud

Branch — master (0d39ab)

CrudController::store() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like