Model::isSoftDeletes() - Code Metrics - Inspection of "Upload files to Model" - anavel/crud - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ce3c4a...56e2be )

unknown

created 2016-02-18 12:41 UTC

Model::isSoftDeletes() A

↳ Parent: Model

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	4
ccs	0
cts	2
cp	0
rs	10
c	1
b	0
f	0
cc	2
eloc	2
nc	2
nop	0
crap	6

<?php
namespace Anavel\Crud\Abstractor\Eloquent;

use Anavel\Crud\Abstractor\Eloquent\Traits\ModelFields;
use Anavel\Crud\Contracts\Abstractor\Model as ModelAbstractorContract;
use Anavel\Crud\Abstractor\ConfigurationReader;
use Anavel\Crud\Contracts\Abstractor\Relation;
use Anavel\Crud\Contracts\Abstractor\RelationFactory as RelationFactoryContract;
use Anavel\Crud\Contracts\Abstractor\FieldFactory as FieldFactoryContract;
use ANavallaSuiza\Laravel\Database\Contracts\Dbal\AbstractionLayer;
use FormManager\ElementInterface;
use Illuminate\Database\Eloquent\Model as LaravelModel;
use App;
use Anavel\Crud\Contracts\Form\Generator as FormGenerator;
use Anavel\Crud\Abstractor\Exceptions\AbstractorException;
use Illuminate\Http\Request;
use Illuminate\Support\Collection;
use League\Flysystem\Adapter\Local;
use League\Flysystem\Filesystem;

class Model implements ModelAbstractorContract
{
    use ConfigurationReader;
    use ModelFields;

    protected $dbal;
    protected $relationFactory;
    protected $fieldFactory;
    protected $generator;

    protected $model;
    protected $config;

    protected $slug;
    protected $name;
    protected $instance;

    public function __construct(
        $config,
        AbstractionLayer $dbal,
        RelationFactoryContract $relationFactory,
        FieldFactoryContract $fieldFactory,
        FormGenerator $generator
    ) {
        if (is_array($config)) {
            $this->model = $config['model'];
            $this->config = $config;
        } else {
            $this->model = $config;
            $this->config = [];
        }

        $this->dbal = $dbal;
        $this->relationFactory = $relationFactory;
        $this->fieldFactory = $fieldFactory;
        $this->generator = $generator;
    }

    public function setSlug($slug)
    {
        $this->slug = $slug;

        return $this;
    }

    public function setName($name)
    {
        $this->name = $name;

        return $this;
    }

    public function setInstance($instance)
    {
        $this->instance = $instance;

        return $this;
    }

    public function getSlug()
    {
        return $this->slug;
    }

    public function getName()
    {
        return transcrud($this->name);
    }

    public function getModel()
    {
        return $this->model;
    }

    public function getInstance()
    {
        return $this->instance;
    }

    public function isSoftDeletes()
    {
        return $this->getConfigValue('soft_deletes') ? true : false;
    }

    public function getColumns($action, $withForeignKeys = false)
    {
        $tableColumns = $this->dbal->getTableColumns();

        $filteredColumns = [];
        foreach ($tableColumns as $name => $column) {
            $filteredColumns[str_replace('`', '', $name)] = $column;
        }
        $tableColumns = $filteredColumns;


        $foreignKeysName = [];
        if ($withForeignKeys === false) {
            $foreignKeys = $this->dbal->getTableForeignKeys();

            foreach ($foreignKeys as $foreignKey) {
                foreach ($foreignKey->getColumns() as $columnName) {
                    $foreignKeysName[] = $columnName;
                }
            }
        }

        $customDisplayedColumns = $this->getConfigValue($action, 'display');
        $customHiddenColumns = $this->getConfigValue($action, 'hide') ? : [];

        $columns = array();
        if (! empty($customDisplayedColumns) && is_array($customDisplayedColumns)) {
            foreach ($customDisplayedColumns as $customColumn) {
                if (! array_key_exists($customColumn, $tableColumns)) {
                    throw new AbstractorException("Column " . $customColumn . " does not exist on " . $this->getModel());
                }

                $columns[$customColumn] = $tableColumns[$customColumn];
            }
        } else {
            foreach ($tableColumns as $name => $column) {
                if (in_array($name, $customHiddenColumns)) {
                    continue;
                }

                if (in_array($name, $foreignKeysName)) {
                    continue;
                }

                $columns[$name] = $column;
            }
        }

        return $columns;
    }

    /**
     * @return \Illuminate\Support\Collection
     */
    public function getRelations()
    {
        $configRelations = $this->getConfigValue('relations');

        $relations = collect();

        if (! empty($configRelations)) {
            foreach ($configRelations as $relationName => $configRelation) {
                if (is_int($relationName)) {
                    $relationName = $configRelation;
                }

                $config = [];
                if ($configRelation !== $relationName) {
                    if (! is_array($configRelation)) {
                        $config['type'] = $configRelation;
                    } else {
                        $config = $configRelation;
                    }
                }

                /** @var Relation $relation */
                $relation = $this->relationFactory->setModel($this->instance)
                    ->setConfig($config)
                    ->get($relationName);

                $secondaryRelations = $relation->getSecondaryRelations();


                if (! $secondaryRelations->isEmpty()) {
                    $relations->put($relationName,
                        collect(['relation' => $relation, 'secondaryRelations' => $secondaryRelations]));
                } else {
                    $relations->put($relationName, $relation);
                }

            }
        }

        return $relations;
    }

    /**
     * @param string|null $arrayKey
     * @return array
     * @throws AbstractorException
     */
    public function getListFields($arrayKey = 'main')

    {
        $columns = $this->getColumns('list');

        $fieldsPresentation = $this->getConfigValue('fields_presentation') ? : [];

        $fields = array();
        foreach ($columns as $name => $column) {
            $presentation = null;
            if (array_key_exists($name, $fieldsPresentation)) {
                $presentation = $fieldsPresentation[$name];
            }

            $config = [
                'name'         => $name,
                'presentation' => $presentation,
                'form_type'    => null,
                'validation'   => null,
                'functions'    => null
            ];

            $fields[$arrayKey][] = $this->fieldFactory
                ->setColumn($column)
                ->setConfig($config)
                ->get();
        }

        return $fields;
    }

    /**
     * @param string|null $arrayKey
     * @return array
     * @throws AbstractorException
     */
    public function getDetailFields($arrayKey = 'main')

    {
        $columns = $this->getColumns('detail');

        $fieldsPresentation = $this->getConfigValue('fields_presentation') ? : [];

        $fields = array();
        foreach ($columns as $name => $column) {
            $presentation = null;
            if (array_key_exists($name, $fieldsPresentation)) {
                $presentation = $fieldsPresentation[$name];
            }

            $config = [
                'name'         => $name,
                'presentation' => $presentation,
                'form_type'    => null,
                'validation'   => null,
                'functions'    => null
            ];

            $fields[$arrayKey][] = $this->fieldFactory
                ->setColumn($column)
                ->setConfig($config)
                ->get();
        }

        return $fields;
    }

    /**
     * @param bool|null $withForeignKeys
     * @param string|null $arrayKey
     * @return array
     * @throws AbstractorException
     */
    public function getEditFields($withForeignKeys = false, $arrayKey = 'main')
    {
        $columns = $this->getColumns('edit', $withForeignKeys);


        $this->readConfig('edit');

        $fields = array();
        foreach ($columns as $name => $column) {
            if (! in_array($name, $this->getReadOnlyColumns())) {
                $presentation = null;
                if (array_key_exists($name, $this->fieldsPresentation)) {
                    $presentation = $this->fieldsPresentation[$name];
                }

                $config = [
                    'name'         => $name,
                    'presentation' => $presentation,
                    'form_type'    => null,
                    'validation'   => null,
                    'functions'    => null
                ];

                $config = $this->setConfig($config, $name);

                $field = $this->fieldFactory
                    ->setColumn($column)
                    ->setConfig($config)
                    ->get();

                if (! empty($this->instance) && ! empty($this->instance->getAttribute($name))) {
                    $field->setValue($this->instance->getAttribute($name));
                }

                $fields[$arrayKey][] = $field;

                if (! empty($config['form_type']) && $config['form_type'] === 'file') {
                    $field = $this->fieldFactory
                        ->setColumn($column)
                        ->setConfig([
                            'name'         => $name . '__delete',
                            'presentation' => null,
                            'form_type'    => 'checkbox',
                            'validation'   => null,
                            'functions'    => null
                        ])
                        ->get();
                    $fields[$arrayKey][] = $field;
                }
            }
        }

        return $fields;
    }

    protected function getReadOnlyColumns()
    {
        $columns = [LaravelModel::CREATED_AT, LaravelModel::UPDATED_AT];

        $columns[] = $this->dbal->getModel()->getKeyName();

        return $columns;
    }

    /**
     * @param string $action
     * @return ElementInterface
     */
    public function getForm($action)
    {
        $this->generator->setModelFields($this->getEditFields());
        $this->generator->setRelatedModelFields($this->getRelations());

        return $this->generator->getForm($action);
    }

    /**
     * @param array $requestForm
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return mixed
     */
    public function persist(Request $request)
    {
        /** @var \ANavallaSuiza\Laravel\Database\Contracts\Manager\ModelManager $modelManager */
        $modelManager = App::make('ANavallaSuiza\Laravel\Database\Contracts\Manager\ModelManager');
        if (! empty($this->instance)) {
            $item = $this->instance;
        } else {
            $item = $modelManager->getModelInstance($this->getModel());
        }


        $fields = $this->getEditFields(true);
        if (empty($fields['main']) && empty($this->getRelations())) {
            return;
        }

        if (! empty($fields['main'])) {
            $skipNext = false;
            foreach ($fields['main'] as $key => $field) {
                if ($skipNext === true) {
                    continue;
                }
                $fieldName = $field->getName();
                $requestValue = $request->input("main.{$fieldName}");

                if (get_class($field->getFormField()) === \FormManager\Fields\File::class) {
                    $modelFolder = $this->slug . DIRECTORY_SEPARATOR;
                    $basePath = base_path(config('anavel-crud.uploads_path'));
                    $modelPath = $basePath . $modelFolder;
                    if (! empty($fields['main'][$key + 1]) && $fields['main'][$key + 1]->getName() === $fieldName . '__delete') {
                        //We never want to save this field, it doesn't exist in the DB
                        $skipNext = true;

                        //If user wants to delete the existing file
                        if (! empty($request->input("main.{$fieldName}__delete"))) {
                            $adapter = new Local($basePath);
                            $filesystem = new Filesystem($adapter);
                            if ($filesystem->has($item->$fieldName)) {
                                $filesystem->delete($item->$fieldName);
                            }


                            $item->setAttribute(
                                $fieldName,
                                null
                            );
                            continue;
                        }
                    }
                    if ($request->hasFile('main.'.$fieldName)) {
                        $fileName = uniqid() . '.' . $request->file('main.'.$fieldName)->getClientOriginalExtension();


                        $request->file('main.'.$fieldName)->move(
                            $modelPath,
                            $fileName
                        );

                        $requestValue = $modelFolder . $fileName;
                    } elseif (! $request->file('main.'.$fieldName)->isValid()) {
                        throw new \Exception($request->file('main.'.$fieldName)->getErrorMessage());
                    }

                }

                if (! $field->saveIfEmpty() && empty($requestValue)) {
                    continue;
                }

                if (! empty($requestValue)) {
                    $item->setAttribute(
                        $fieldName,
                        $field->applyFunctions($requestValue)
                    );
                }
            }
        }

        $item->save();

        $this->setInstance($item);


        if (! empty($relations = $this->getRelations())) {
            foreach ($relations as $relationKey => $relation) {
                if ($relation instanceof Collection) {
                    $input = $request->input($relationKey);
                    $relation->get('relation')->persist($input);
                } else {
                    $relation->persist($request->input($relationKey));
                }
            }
        }

        return $item;
    }

    /**
     * @return array
     */
    public function getValidationRules()
    {
        return $this->generator->getValidationRules();
    }
}


1			<?php
2			namespace Anavel\Crud\Abstractor\Eloquent;
3
4			use Anavel\Crud\Abstractor\Eloquent\Traits\ModelFields;
5			use Anavel\Crud\Contracts\Abstractor\Model as ModelAbstractorContract;
6			use Anavel\Crud\Abstractor\ConfigurationReader;
7			use Anavel\Crud\Contracts\Abstractor\Relation;
8			use Anavel\Crud\Contracts\Abstractor\RelationFactory as RelationFactoryContract;
9			use Anavel\Crud\Contracts\Abstractor\FieldFactory as FieldFactoryContract;
10			use ANavallaSuiza\Laravel\Database\Contracts\Dbal\AbstractionLayer;
11			use FormManager\ElementInterface;
12			use Illuminate\Database\Eloquent\Model as LaravelModel;
13			use App;
14			use Anavel\Crud\Contracts\Form\Generator as FormGenerator;
15			use Anavel\Crud\Abstractor\Exceptions\AbstractorException;
16			use Illuminate\Http\Request;
17			use Illuminate\Support\Collection;
18			use League\Flysystem\Adapter\Local;
19			use League\Flysystem\Filesystem;
20
21			class Model implements ModelAbstractorContract
22			{
23			use ConfigurationReader;
24			use ModelFields;
25
26			protected $dbal;
27			protected $relationFactory;
28			protected $fieldFactory;
29			protected $generator;
30
31			protected $model;
32			protected $config;
33
34			protected $slug;
35			protected $name;
36			protected $instance;
37
38	17		public function __construct(
39			$config,
40			AbstractionLayer $dbal,
41			RelationFactoryContract $relationFactory,
42			FieldFactoryContract $fieldFactory,
43			FormGenerator $generator
44			) {
45	17		if (is_array($config)) {
46	17		$this->model = $config['model'];
47	17		$this->config = $config;
48	17		} else {
49			$this->model = $config;
50			$this->config = [];
51			}
52
53	17		$this->dbal = $dbal;
54	17		$this->relationFactory = $relationFactory;
55	17		$this->fieldFactory = $fieldFactory;
56	17		$this->generator = $generator;
57	17		}
58
59	3		public function setSlug($slug)
60			{
61	3		$this->slug = $slug;
62
63	3		return $this;
64			}
65
66	2		public function setName($name)
67			{
68	2		$this->name = $name;
69
70	2		return $this;
71			}
72
73	5		public function setInstance($instance)
74			{
75	5		$this->instance = $instance;
76
77	5		return $this;
78			}
79
80			public function getSlug()
81			{
82			return $this->slug;
83			}
84
85			public function getName()
86			{
87			return transcrud($this->name);
88			}
89
90	1		public function getModel()
91			{
92	1		return $this->model;
93			}
94
95			public function getInstance()
96			{
97			return $this->instance;
98			}
99
100			public function isSoftDeletes()
101			{
102			return $this->getConfigValue('soft_deletes') ? true : false;
103			}
104
105	9		public function getColumns($action, $withForeignKeys = false)
106			{
107	9		$tableColumns = $this->dbal->getTableColumns();
108
109	9		$filteredColumns = [];
110	9		foreach ($tableColumns as $name => $column) {
111	9		$filteredColumns[str_replace('`', '', $name)] = $column;
112	9		}
113	9		$tableColumns = $filteredColumns;
114
115
116	9		$foreignKeysName = [];
117	9		if ($withForeignKeys === false) {
118	8		$foreignKeys = $this->dbal->getTableForeignKeys();
119
120	8		foreach ($foreignKeys as $foreignKey) {
121			foreach ($foreignKey->getColumns() as $columnName) {
122			$foreignKeysName[] = $columnName;
123			}
124	8		}
125	8		}
126
127	9		$customDisplayedColumns = $this->getConfigValue($action, 'display');
128	9		$customHiddenColumns = $this->getConfigValue($action, 'hide') ? : [];
129
130	9		$columns = array();
131	9		if (! empty($customDisplayedColumns) && is_array($customDisplayedColumns)) {
132	9		foreach ($customDisplayedColumns as $customColumn) {
133	9		if (! array_key_exists($customColumn, $tableColumns)) {
134			throw new AbstractorException("Column " . $customColumn . " does not exist on " . $this->getModel());
135			}
136
137	9		$columns[$customColumn] = $tableColumns[$customColumn];
138	9		}
139	9		} else {
140			foreach ($tableColumns as $name => $column) {
141			if (in_array($name, $customHiddenColumns)) {
142			continue;
143			}
144
145			if (in_array($name, $foreignKeysName)) {
146			continue;
147			}
148
149			$columns[$name] = $column;
150			}
151			}
152
153	9		return $columns;
154			}
155
156			/**
157			* @return \Illuminate\Support\Collection
158			*/
159	5		public function getRelations()
160			{
161	5		$configRelations = $this->getConfigValue('relations');
162
163	5		$relations = collect();
164
165	5		if (! empty($configRelations)) {
166	5		foreach ($configRelations as $relationName => $configRelation) {
167	5		if (is_int($relationName)) {
168			$relationName = $configRelation;
169			}
170
171	5		$config = [];
172	5		if ($configRelation !== $relationName) {
173	5		if (! is_array($configRelation)) {
174			$config['type'] = $configRelation;
175			} else {
176	5		$config = $configRelation;
177			}
178	5		}
179
180			/** @var Relation $relation */
181	5		$relation = $this->relationFactory->setModel($this->instance)
182	5		->setConfig($config)
183	5		->get($relationName);
184
185	5		$secondaryRelations = $relation->getSecondaryRelations();
186
187
188	5		if (! $secondaryRelations->isEmpty()) {
189	1		$relations->put($relationName,
190	1		collect(['relation' => $relation, 'secondaryRelations' => $secondaryRelations]));
191	1		} else {
192	4		$relations->put($relationName, $relation);
193			}
194
195	5		}
196	5		}
197
198	5		return $relations;
199			}
200
201			/**
202			* @param string\|null $arrayKey
203			* @return array
204			* @throws AbstractorException
205			*/
206	2	View Code Duplication	public function getListFields($arrayKey = 'main')
			0 ignored issues – show Duplication introduced 2016-02-12 13:12 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
207			{
208	2		$columns = $this->getColumns('list');
209
210	2		$fieldsPresentation = $this->getConfigValue('fields_presentation') ? : [];
211
212	2		$fields = array();
213	2		foreach ($columns as $name => $column) {
214	2		$presentation = null;
215	2		if (array_key_exists($name, $fieldsPresentation)) {
216	2		$presentation = $fieldsPresentation[$name];
217	2		}
218
219			$config = [
220	2		'name' => $name,
221	2		'presentation' => $presentation,
222	2		'form_type' => null,
223	2		'validation' => null,
224			'functions' => null
225	2		];
226
227	2		$fields[$arrayKey][] = $this->fieldFactory
228	2		->setColumn($column)
229	2		->setConfig($config)
230	2		->get();
231	2		}
232
233	2		return $fields;
234			}
235
236			/**
237			* @param string\|null $arrayKey
238			* @return array
239			* @throws AbstractorException
240			*/
241	2	View Code Duplication	public function getDetailFields($arrayKey = 'main')
			0 ignored issues – show Duplication introduced 2016-02-12 13:12 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
242			{
243	2		$columns = $this->getColumns('detail');
244
245	2		$fieldsPresentation = $this->getConfigValue('fields_presentation') ? : [];
246
247	2		$fields = array();
248	2		foreach ($columns as $name => $column) {
249	2		$presentation = null;
250	2		if (array_key_exists($name, $fieldsPresentation)) {
251	2		$presentation = $fieldsPresentation[$name];
252	2		}
253
254			$config = [
255	2		'name' => $name,
256	2		'presentation' => $presentation,
257	2		'form_type' => null,
258	2		'validation' => null,
259			'functions' => null
260	2		];
261
262	2		$fields[$arrayKey][] = $this->fieldFactory
263	2		->setColumn($column)
264	2		->setConfig($config)
265	2		->get();
266	2		}
267
268	2		return $fields;
269			}
270
271			/**
272			* @param bool\|null $withForeignKeys
273			* @param string\|null $arrayKey
274			* @return array
275			* @throws AbstractorException
276			*/
277	5		public function getEditFields($withForeignKeys = false, $arrayKey = 'main')
278			{
279	5		$columns = $this->getColumns('edit', $withForeignKeys);
			0 ignored issues – show Bug introduced 2016-02-12 13:12 UTC by Report Bug Copy Issue Report It seems like `$withForeignKeys` defined by parameter `$withForeignKeys` on line 277 can also be of type `null`; however, `Anavel\Crud\Abstractor\E...ent\Model::getColumns()` does only seem to accept `boolean`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
280
281	5		$this->readConfig('edit');
282
283	5		$fields = array();
284	5		foreach ($columns as $name => $column) {
285	5		if (! in_array($name, $this->getReadOnlyColumns())) {
286	5		$presentation = null;
287	5		if (array_key_exists($name, $this->fieldsPresentation)) {
288			$presentation = $this->fieldsPresentation[$name];
289			}
290
291			$config = [
292	5		'name' => $name,
293	5		'presentation' => $presentation,
294	5		'form_type' => null,
295	5		'validation' => null,
296			'functions' => null
297	5		];
298
299	5		$config = $this->setConfig($config, $name);
300
301	5		$field = $this->fieldFactory
302	5		->setColumn($column)
303	5		->setConfig($config)
304	5		->get();
305
306	5		if (! empty($this->instance) && ! empty($this->instance->getAttribute($name))) {
307			$field->setValue($this->instance->getAttribute($name));
308			}
309
310	5		$fields[$arrayKey][] = $field;
311
312	5		if (! empty($config['form_type']) && $config['form_type'] === 'file') {
313	5		$field = $this->fieldFactory
314	5		->setColumn($column)
315	5		->setConfig([
316	5		'name' => $name . '__delete',
317	5		'presentation' => null,
318	5		'form_type' => 'checkbox',
319	5		'validation' => null,
320			'functions' => null
321	5		])
322	5		->get();
323	5		$fields[$arrayKey][] = $field;
324	5		}
325	5		}
326	5		}
327
328	5		return $fields;
329			}
330
331	5		protected function getReadOnlyColumns()
332			{
333	5		$columns = [LaravelModel::CREATED_AT, LaravelModel::UPDATED_AT];
334
335	5		$columns[] = $this->dbal->getModel()->getKeyName();
336
337	5		return $columns;
338			}
339
340			/**
341			* @param string $action
342			* @return ElementInterface
343			*/
344	2		public function getForm($action)
345			{
346	2		$this->generator->setModelFields($this->getEditFields());
347	2		$this->generator->setRelatedModelFields($this->getRelations());
348
349	2		return $this->generator->getForm($action);
350			}
351
352			/**
353			* @param array $requestForm
			0 ignored issues – show Documentation introduced 2016-02-12 13:12 UTC by Report Bug Copy Issue Report There is no parameter named `$requestForm`. Did you maybe mean `$request`? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. It has, however, found a similar but not annotated parameter which might be a good fit. Consider the following example. The parameter `$ireland` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $ireland */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was changed, but the annotation was not. Loading history...
354			* @return mixed
355			*/
356	1		public function persist(Request $request)
357			{
358			/** @var \ANavallaSuiza\Laravel\Database\Contracts\Manager\ModelManager $modelManager */
359	1		$modelManager = App::make('ANavallaSuiza\Laravel\Database\Contracts\Manager\ModelManager');
360	1		if (! empty($this->instance)) {
361			$item = $this->instance;
362			} else {
363	1		$item = $modelManager->getModelInstance($this->getModel());
364			}
365
366
367	1		$fields = $this->getEditFields(true);
368	1		if (empty($fields['main']) && empty($this->getRelations())) {
369			return;
370			}
371
372	1		if (! empty($fields['main'])) {
373	1		$skipNext = false;
374	1		foreach ($fields['main'] as $key => $field) {
375	1		if ($skipNext === true) {
376			continue;
377			}
378	1		$fieldName = $field->getName();
379	1		$requestValue = $request->input("main.{$fieldName}");
380
381	1		if (get_class($field->getFormField()) === \FormManager\Fields\File::class) {
382			$modelFolder = $this->slug . DIRECTORY_SEPARATOR;
383			$basePath = base_path(config('anavel-crud.uploads_path'));
384			$modelPath = $basePath . $modelFolder;
385			if (! empty($fields['main'][$key + 1]) && $fields['main'][$key + 1]->getName() === $fieldName . '__delete') {
386			//We never want to save this field, it doesn't exist in the DB
387			$skipNext = true;
388
389			//If user wants to delete the existing file
390			if (! empty($request->input("main.{$fieldName}__delete"))) {
391			$adapter = new Local($basePath);
392			$filesystem = new Filesystem($adapter);
393			if ($filesystem->has($item->$fieldName)) {
394			$filesystem->delete($item->$fieldName);
395			}
396
397
398			$item->setAttribute(
399			$fieldName,
400			null
401			);
402			continue;
403			}
404			}
405			if ($request->hasFile('main.'.$fieldName)) {
406			$fileName = uniqid() . '.' . $request->file('main.'.$fieldName)->getClientOriginalExtension();
407
408
409			$request->file('main.'.$fieldName)->move(
410			$modelPath,
411			$fileName
412			);
413
414			$requestValue = $modelFolder . $fileName;
415			} elseif (! $request->file('main.'.$fieldName)->isValid()) {
416			throw new \Exception($request->file('main.'.$fieldName)->getErrorMessage());
417			}
418
419			}
420
421	1		if (! $field->saveIfEmpty() && empty($requestValue)) {
422			continue;
423			}
424
425	1		if (! empty($requestValue)) {
426			$item->setAttribute(
427			$fieldName,
428			$field->applyFunctions($requestValue)
429			);
430			}
431	1		}
432	1		}
433
434	1		$item->save();
435
436	1		$this->setInstance($item);
437
438
439	1		if (! empty($relations = $this->getRelations())) {
440	1		foreach ($relations as $relationKey => $relation) {
441	1		if ($relation instanceof Collection) {
442			$input = $request->input($relationKey);
443			$relation->get('relation')->persist($input);
444			} else {
445	1		$relation->persist($request->input($relationKey));
446			}
447	1		}
448	1		}
449
450	1		return $item;
451			}
452
453			/**
454			* @return array
455			*/
456	1		public function getValidationRules()
457			{
458	1		return $this->generator->getValidationRules();
459			}
460			}
461

anavel / crud

Push — master ( ce3c4a...56e2be )

Model::isSoftDeletes() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like