AbstractData::shouldExecuteEvents() - Code Metrics - Inspection of "reduced complexity" - philiplb/CRUDlex - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (e704c9)

by Philip

created 2016-04-15 18:48 UTC

AbstractData::shouldExecuteEvents() A

↳ Parent: AbstractData

Complexity

Conditions	4
Paths	4

Size

Total Lines	12
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	12
rs	9.2
cc	4
eloc	8
nc	4
nop	3

<?php

/*
 * This file is part of the CRUDlex package.
 *
 * (c) Philip Lehmann-Böhm <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace CRUDlex;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

use CRUDlex\EntityDefinition;
use CRUDlex\Entity;

/**
 * The abstract class for reading and writing data.
 */
abstract class AbstractData {

    /**
     * Return value on successful deletion.
     */
    const DELETION_SUCCESS = 0;

    /**
     * Return value on failed deletion due to existing references.
     */
    const DELETION_FAILED_STILL_REFERENCED = 1;

    /**
     * Return value on failed deletion due to a failed before delete event.
     */
    const DELETION_FAILED_EVENT = 2;

    /**
     * Holds the {@see EntityDefinition} entity definition.
     */
    protected $definition;

    /**
     * Holds the {@see FileProcessorInterface} file processor.
     */
    protected $fileProcessor;

    /**
     * Holds the events.
     */
    protected $events;

    /**
     * Performs the actual deletion.
     *
     * @param Entity $entity
     * the id of the entry to delete
     * @param boolean $deleteCascade
     * whether to delete children and subchildren
     *
     * @return integer
     * true on successful deletion
     */
    abstract protected function doDelete(Entity $entity, $deleteCascade);

    /**
     * Creates an {@see Entity} from the raw data array with the field name
     * as keys and field values as values.
     *
     * @param array $row
     * the array with the raw data
     *
     * @return Entity
     * the entity containing the array data then
     */
    protected function hydrate(array $row) {
        $fieldNames = $this->definition->getFieldNames();
        $entity = new Entity($this->definition);
        foreach ($fieldNames as $fieldName) {
            $entity->set($fieldName, $row[$fieldName]);
        }
        return $entity;
    }

    /**
     * Executes the event chain of an entity.
     *
     * @param Entity $entity
     * the entity having the event chain to execute
     * @param string $moment
     * the "moment" of the event, can be either "before" or "after"
     * @param string $action
     * the "action" of the event, can be either "create", "update" or "delete"
     *
     * @return boolean
     * true on successful execution of the full chain or false if it broke at
     * any point (and stopped the execution)
     */
    protected function shouldExecuteEvents(Entity $entity, $moment, $action) {
        if (!isset($this->events[$moment.'.'.$action])) {
            return true;
        }
        foreach ($this->events[$moment.'.'.$action] as $event) {
            $result = $event($entity);
            if (!$result) {
                return false;
            }
        }
        return true;
    }

    /**
     * Executes a function for each file field of this entity.
     *
     * @param Entity $entity
     * the just created entity
     * @param string $entityName
     * the name of the entity as this class here is not aware of it
     * @param \Closure $function
     * the function to perform, takes $entity, $entityName and $field as parameter
     */
    protected function performOnFiles(Entity $entity, $entityName, $function) {
        $fields = $this->definition->getEditableFieldNames();
        foreach ($fields as $field) {
            if ($this->definition->getType($field) == 'file') {
                $function($entity, $entityName, $field);
            }
        }
    }

    /**
     * Adds an event to fire for the given parameters. The event function must
     * have this signature:
     * function (Entity $entity)
     * and has to return true or false.
     * The events are executed one after another in the added order as long as
     * they return "true". The first event returning "false" will stop the
     * process.
     *
     * @param string $moment
     * the "moment" of the event, can be either "before" or "after"
     * @param string $action
     * the "action" of the event, can be either "create", "update" or "delete"
     * @param anonymous function $function
     * the event function to be called if set
     */
    public function pushEvent($moment, $action, $function) {
        $events = isset($this->events[$moment.'.'.$action]) ? $this->events[$moment.'.'.$action] : array();
        $events[] = $function;
        $this->events[$moment.'.'.$action] = $events;
    }


    /**
     * Removes and returns the latest event for the given parameters.
     *
     * @param string $moment
     * the "moment" of the event, can be either "before" or "after"
     * @param string $action
     * the "action" of the event, can be either "create", "update" or "delete"
     *
     * @return anonymous function
     * the popped event or null if no event was available.
     */
    public function popEvent($moment, $action) {
        if (array_key_exists($moment.'.'.$action, $this->events)) {
            return array_pop($this->events[$moment.'.'.$action]);
        }
        return null;
    }


    /**
     * Gets the entity with the given id.
     *
     * @param string $id
     * the id
     *
     * @return Entity
     * the entity belonging to the id or null if not existant
     *
     * @return void
     */
    abstract public function get($id);

    /**
     * Gets a list of entities fullfilling the given filter or all if no
     * selection was given.
     *
     * @param array $filter
     * the filter all resulting entities must fulfill, the keys as field names
     * @param array $filterOperators
     * the operators of the filter like "=" defining the full condition of the field
     * @param integer|null $skip
     * if given and not null, it specifies the amount of rows to skip
     * @param integer|null $amount
     * if given and not null, it specifies the maximum amount of rows to retrieve
     * @param string|null $sortField
     * if given and not null, it specifies the field to sort the entries
     * @param boolean|null $sortAscending
     * if given and not null, it specifies that the sort order is ascending,
     * descending else
     *
     * @return Entity[]
     * the entities fulfilling the filter or all if no filter was given
     */
    abstract public function listEntries(array $filter = array(), array $filterOperators = array(), $skip = null, $amount = null, $sortField = null, $sortAscending = null);

    /**
     * Persists the given entity as new entry in the datasource.
     *
     * @param Entity $entity
     * the entity to persist
     *
     * @return boolean
     * true on successful creation
     */
    abstract public function create(Entity $entity);


    /**
     * Updates an existing entry in the datasource having the same id.
     *
     * @param Entity $entity
     * the entity with the new data
     *
     * @return void
     */
    abstract public function update(Entity $entity);

    /**
     * Deletes an entry from the datasource having the given id.
     *
     * @param Entity $entity
     * the id of the entry to delete
     *
     * @return integer
     * returns one of:
     * - AbstractData::DELETION_SUCCESS -> successful deletion
     * - AbstractData::DELETION_FAILED_STILL_REFERENCED -> failed deletion due to existing references
     * - AbstractData::DELETION_FAILED_EVENT -> failed deletion due to a failed before delete event
     */
    public function delete($entity) {
        return $this->doDelete($entity, $this->definition->isDeleteCascade());
    }

    /**
     * Gets ids and names of a table. Used for building up the dropdown box of
     * reference type fields.
     *
     * @param string $table
     * the table
     * @param string nameField
     * the field defining the name of the rows
     *
     * @return array
     * an array with the ids as key and the names as values
     */
    abstract public function getReferences($table, $nameField);

    /**
     * Retrieves the amount of entities in the datasource fulfilling the given
     * parameters.
     *
     * @param string $table
     * the table to count in
     * @param array $params
     * an array with the field names as keys and field values as values
     * @param array $paramsOperators
     * the operators of the parameters like "=" defining the full condition of the field
     * @param boolean $excludeDeleted
     * false, if soft deleted entries in the datasource should be counted, too
     *
     * @return integer
     * the count fulfilling the given parameters
     */
    abstract public function countBy($table, array $params, array $paramsOperators, $excludeDeleted);

    /**
     * Adds the id and name of referenced entities to the given entities. Each
     * reference field is before the raw id of the referenced entity and after
     * the fetch, it's an array with the keys id and name.
     *
     * @param Entity[] &$entities
     * the entities to fetch the references for
     *
     * @return void
     */
    abstract public function fetchReferences(array &$entities = null);

    /**
     * Gets the {@see EntityDefinition} instance.
     *
     * @return EntityDefinition
     * the definition instance
     */
    public function getDefinition() {
        return $this->definition;
    }

    /**
     * Creates a new, empty entity instance having all fields prefilled with
     * null or the defined value in case of fixed fields.
     *
     * @return Entity
     * the newly created entity
     */
    public function createEmpty() {
        $entity = new Entity($this->definition);
        $fields = $this->definition->getEditableFieldNames();
        foreach ($fields as $field) {
            $value = null;
            if ($this->definition->getType($field) == 'fixed') {
                $value = $this->definition->getFixedValue($field);
            }
            $entity->set($field, $value);
        }
        $entity->set('id', null);
        return $entity;
    }

    /**
     * Creates the uploaded files of a newly created entity.
     *
     * @param Request $request
     * the HTTP request containing the file data
     * @param Entity $entity
     * the just created entity
     * @param string $entityName
     * the name of the entity as this class here is not aware of it
     */
    public function createFiles(Request $request, Entity $entity, $entityName) {

        $result = $this->shouldExecuteEvents($entity, 'before', 'createFiles');
        if (!$result) {
            return false;
        }
        $fileProcessor = $this->fileProcessor;
        $this->performOnFiles($entity, $entityName, function($entity, $entityName, $field) use ($fileProcessor, $request) {
            $fileProcessor->createFile($request, $entity, $entityName, $field);
        });
        $this->shouldExecuteEvents($entity, 'after', 'createFiles');
        return true;
    }

    /**
     * Updates the uploaded files of an updated entity.
     *
     * @param Request $request
     * the HTTP request containing the file data
     * @param Entity $entity
     * the updated entity
     * @param string $entityName
     * the name of the entity as this class here is not aware of it
     *
     * @return boolean
     * true on successful update
     */
    public function updateFiles(Request $request, Entity $entity, $entityName) {

        $result = $this->shouldExecuteEvents($entity, 'before', 'updateFiles');
        if (!$result) {
            return false;
        }
        $fileProcessor = $this->fileProcessor;
        $this->performOnFiles($entity, $entityName, function($entity, $entityName, $field) use ($fileProcessor, $request) {
            $fileProcessor->updateFile($request, $entity, $entityName, $field);
        });
        $this->shouldExecuteEvents($entity, 'after', 'updateFiles');
        return true;
    }

    /**
     * Deletes a specific file from an existing entity.
     *
     * @param Entity $entity
     * the entity to delete the file from
     * @param string $entityName
     * the name of the entity as this class here is not aware of it
     * @param string $field
     * the field of the entity containing the file to be deleted
     *
     * @return boolean
     * true on successful deletion
     */
    public function deleteFile(Entity $entity, $entityName, $field) {

        $result = $this->shouldExecuteEvents($entity, 'before', 'deleteFile');
        if (!$result) {
            return false;
        }
        $this->fileProcessor->deleteFile($entity, $entityName, $field);
        $this->shouldExecuteEvents($entity, 'after', 'deleteFile');
        return true;
    }

    /**
     * Deletes all files of an existing entity.
     *
     * @param Entity $entity
     * the entity to delete the files from
     * @param string $entityName
     * the name of the entity as this class here is not aware of it
     *
     * @return boolean
     * true on successful deletion
     */
    public function deleteFiles(Entity $entity, $entityName) {

        $result = $this->shouldExecuteEvents($entity, 'before', 'deleteFiles');
        if (!$result) {
            return false;
        }
        $fileProcessor = $this->fileProcessor;
        $this->performOnFiles($entity, $entityName, function($entity, $entityName, $field) use ($fileProcessor) {
            $fileProcessor->deleteFile($entity, $entityName, $field);
        });
        $this->shouldExecuteEvents($entity, 'after', 'deleteFiles');
        return true;
    }

    /**
     * Renders (outputs) a file of an entity. This includes setting headers
     * like the file size, mimetype and name, too.
     *
     * @param Entity $entity
     * the entity to render the file from
     * @param string $entityName
     * the name of the entity as this class here is not aware of it
     * @param string $field
     * the field of the entity containing the file to be rendered
     *
     * @return Response
     * the HTTP response, likely to be a streamed one
     */
    public function renderFile(Entity $entity, $entityName, $field) {
        return $this->fileProcessor->renderFile($entity, $entityName, $field);
    }

}


1		<?php
2
3		/*
4		* This file is part of the CRUDlex package.
5		*
6		* (c) Philip Lehmann-Böhm <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace CRUDlex;
13
14		use Symfony\Component\HttpFoundation\Request;
15		use Symfony\Component\HttpFoundation\Response;
16
17		use CRUDlex\EntityDefinition;
18		use CRUDlex\Entity;
19
20		/**
21		* The abstract class for reading and writing data.
22		*/
23		abstract class AbstractData {
24
25		/**
26		* Return value on successful deletion.
27		*/
28		const DELETION_SUCCESS = 0;
29
30		/**
31		* Return value on failed deletion due to existing references.
32		*/
33		const DELETION_FAILED_STILL_REFERENCED = 1;
34
35		/**
36		* Return value on failed deletion due to a failed before delete event.
37		*/
38		const DELETION_FAILED_EVENT = 2;
39
40		/**
41		* Holds the {@see EntityDefinition} entity definition.
42		*/
43		protected $definition;
44
45		/**
46		* Holds the {@see FileProcessorInterface} file processor.
47		*/
48		protected $fileProcessor;
49
50		/**
51		* Holds the events.
52		*/
53		protected $events;
54
55		/**
56		* Performs the actual deletion.
57		*
58		* @param Entity $entity
59		* the id of the entry to delete
60		* @param boolean $deleteCascade
61		* whether to delete children and subchildren
62		*
63		* @return integer
64		* true on successful deletion
65		*/
66		abstract protected function doDelete(Entity $entity, $deleteCascade);
67
68		/**
69		* Creates an {@see Entity} from the raw data array with the field name
70		* as keys and field values as values.
71		*
72		* @param array $row
73		* the array with the raw data
74		*
75		* @return Entity
76		* the entity containing the array data then
77		*/
78		protected function hydrate(array $row) {
79		$fieldNames = $this->definition->getFieldNames();
80		$entity = new Entity($this->definition);
81		foreach ($fieldNames as $fieldName) {
82		$entity->set($fieldName, $row[$fieldName]);
83		}
84		return $entity;
85		}
86
87		/**
88		* Executes the event chain of an entity.
89		*
90		* @param Entity $entity
91		* the entity having the event chain to execute
92		* @param string $moment
93		* the "moment" of the event, can be either "before" or "after"
94		* @param string $action
95		* the "action" of the event, can be either "create", "update" or "delete"
96		*
97		* @return boolean
98		* true on successful execution of the full chain or false if it broke at
99		* any point (and stopped the execution)
100		*/
101		protected function shouldExecuteEvents(Entity $entity, $moment, $action) {
102		if (!isset($this->events[$moment.'.'.$action])) {
103		return true;
104		}
105		foreach ($this->events[$moment.'.'.$action] as $event) {
106		$result = $event($entity);
107		if (!$result) {
108		return false;
109		}
110		}
111		return true;
112		}
113
114		/**
115		* Executes a function for each file field of this entity.
116		*
117		* @param Entity $entity
118		* the just created entity
119		* @param string $entityName
120		* the name of the entity as this class here is not aware of it
121		* @param \Closure $function
122		* the function to perform, takes $entity, $entityName and $field as parameter
123		*/
124		protected function performOnFiles(Entity $entity, $entityName, $function) {
125		$fields = $this->definition->getEditableFieldNames();
126		foreach ($fields as $field) {
127		if ($this->definition->getType($field) == 'file') {
128		$function($entity, $entityName, $field);
129		}
130		}
131		}
132
133		/**
134		* Adds an event to fire for the given parameters. The event function must
135		* have this signature:
136		* function (Entity $entity)
137		* and has to return true or false.
138		* The events are executed one after another in the added order as long as
139		* they return "true". The first event returning "false" will stop the
140		* process.
141		*
142		* @param string $moment
143		* the "moment" of the event, can be either "before" or "after"
144		* @param string $action
145		* the "action" of the event, can be either "create", "update" or "delete"
146		* @param anonymous function $function
147		* the event function to be called if set
148		*/
149		public function pushEvent($moment, $action, $function) {
150		$events = isset($this->events[$moment.'.'.$action]) ? $this->events[$moment.'.'.$action] : array();
151		$events[] = $function;
152		$this->events[$moment.'.'.$action] = $events;
153		}
154
155
156		/**
157		* Removes and returns the latest event for the given parameters.
158		*
159		* @param string $moment
160		* the "moment" of the event, can be either "before" or "after"
161		* @param string $action
162		* the "action" of the event, can be either "create", "update" or "delete"
163		*
164		* @return anonymous function
165		* the popped event or null if no event was available.
166		*/
167		public function popEvent($moment, $action) {
168		if (array_key_exists($moment.'.'.$action, $this->events)) {
169		return array_pop($this->events[$moment.'.'.$action]);
170		}
171		return null;
172		}
173
174
175		/**
176		* Gets the entity with the given id.
177		*
178		* @param string $id
179		* the id
180		*
181		* @return Entity
182		* the entity belonging to the id or null if not existant
183		*
184		* @return void
185		*/
186		abstract public function get($id);
187
188		/**
189		* Gets a list of entities fullfilling the given filter or all if no
190		* selection was given.
191		*
192		* @param array $filter
193		* the filter all resulting entities must fulfill, the keys as field names
194		* @param array $filterOperators
195		* the operators of the filter like "=" defining the full condition of the field
196		* @param integer\|null $skip
197		* if given and not null, it specifies the amount of rows to skip
198		* @param integer\|null $amount
199		* if given and not null, it specifies the maximum amount of rows to retrieve
200		* @param string\|null $sortField
201		* if given and not null, it specifies the field to sort the entries
202		* @param boolean\|null $sortAscending
203		* if given and not null, it specifies that the sort order is ascending,
204		* descending else
205		*
206		* @return Entity[]
207		* the entities fulfilling the filter or all if no filter was given
208		*/
209		abstract public function listEntries(array $filter = array(), array $filterOperators = array(), $skip = null, $amount = null, $sortField = null, $sortAscending = null);
210
211		/**
212		* Persists the given entity as new entry in the datasource.
213		*
214		* @param Entity $entity
215		* the entity to persist
216		*
217		* @return boolean
218		* true on successful creation
219		*/
220		abstract public function create(Entity $entity);
		0 ignored issues – show Coding Style introduced 2016-04-12 21:06 UTC by Report Bug Copy Issue Report `function create()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
221
222		/**
223		* Updates an existing entry in the datasource having the same id.
224		*
225		* @param Entity $entity
226		* the entity with the new data
227		*
228		* @return void
229		*/
230		abstract public function update(Entity $entity);
231
232		/**
233		* Deletes an entry from the datasource having the given id.
234		*
235		* @param Entity $entity
236		* the id of the entry to delete
237		*
238		* @return integer
239		* returns one of:
240		* - AbstractData::DELETION_SUCCESS -> successful deletion
241		* - AbstractData::DELETION_FAILED_STILL_REFERENCED -> failed deletion due to existing references
242		* - AbstractData::DELETION_FAILED_EVENT -> failed deletion due to a failed before delete event
243		*/
244		public function delete($entity) {
245		return $this->doDelete($entity, $this->definition->isDeleteCascade());
246		}
247
248		/**
249		* Gets ids and names of a table. Used for building up the dropdown box of
250		* reference type fields.
251		*
252		* @param string $table
253		* the table
254		* @param string nameField
255		* the field defining the name of the rows
256		*
257		* @return array
258		* an array with the ids as key and the names as values
259		*/
260		abstract public function getReferences($table, $nameField);
261
262		/**
263		* Retrieves the amount of entities in the datasource fulfilling the given
264		* parameters.
265		*
266		* @param string $table
267		* the table to count in
268		* @param array $params
269		* an array with the field names as keys and field values as values
270		* @param array $paramsOperators
271		* the operators of the parameters like "=" defining the full condition of the field
272		* @param boolean $excludeDeleted
273		* false, if soft deleted entries in the datasource should be counted, too
274		*
275		* @return integer
276		* the count fulfilling the given parameters
277		*/
278		abstract public function countBy($table, array $params, array $paramsOperators, $excludeDeleted);
279
280		/**
281		* Adds the id and name of referenced entities to the given entities. Each
282		* reference field is before the raw id of the referenced entity and after
283		* the fetch, it's an array with the keys id and name.
284		*
285		* @param Entity[] &$entities
286		* the entities to fetch the references for
287		*
288		* @return void
289		*/
290		abstract public function fetchReferences(array &$entities = null);
291
292		/**
293		* Gets the {@see EntityDefinition} instance.
294		*
295		* @return EntityDefinition
296		* the definition instance
297		*/
298		public function getDefinition() {
299		return $this->definition;
300		}
301
302		/**
303		* Creates a new, empty entity instance having all fields prefilled with
304		* null or the defined value in case of fixed fields.
305		*
306		* @return Entity
307		* the newly created entity
308		*/
309		public function createEmpty() {
310		$entity = new Entity($this->definition);
311		$fields = $this->definition->getEditableFieldNames();
312		foreach ($fields as $field) {
313		$value = null;
314		if ($this->definition->getType($field) == 'fixed') {
315		$value = $this->definition->getFixedValue($field);
316		}
317		$entity->set($field, $value);
318		}
319		$entity->set('id', null);
320		return $entity;
321		}
322
323		/**
324		* Creates the uploaded files of a newly created entity.
325		*
326		* @param Request $request
327		* the HTTP request containing the file data
328		* @param Entity $entity
329		* the just created entity
330		* @param string $entityName
331		* the name of the entity as this class here is not aware of it
332		*/
333	View Code Duplication	public function createFiles(Request $request, Entity $entity, $entityName) {
		0 ignored issues – show Coding Style introduced 2016-04-12 21:06 UTC by Report Bug Copy Issue Report `function createFiles()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history... Duplication introduced 2016-01-26 22:04 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...
334		$result = $this->shouldExecuteEvents($entity, 'before', 'createFiles');
335		if (!$result) {
336		return false;
337		}
338		$fileProcessor = $this->fileProcessor;
339		$this->performOnFiles($entity, $entityName, function($entity, $entityName, $field) use ($fileProcessor, $request) {
340		$fileProcessor->createFile($request, $entity, $entityName, $field);
341		});
342		$this->shouldExecuteEvents($entity, 'after', 'createFiles');
343		return true;
344		}
345
346		/**
347		* Updates the uploaded files of an updated entity.
348		*
349		* @param Request $request
350		* the HTTP request containing the file data
351		* @param Entity $entity
352		* the updated entity
353		* @param string $entityName
354		* the name of the entity as this class here is not aware of it
355		*
356		* @return boolean
357		* true on successful update
358		*/
359	View Code Duplication	public function updateFiles(Request $request, Entity $entity, $entityName) {
		0 ignored issues – show Coding Style introduced 2016-04-12 21:06 UTC by Report Bug Copy Issue Report `function updateFiles()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history... Duplication introduced 2016-01-26 22:04 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...
360		$result = $this->shouldExecuteEvents($entity, 'before', 'updateFiles');
361		if (!$result) {
362		return false;
363		}
364		$fileProcessor = $this->fileProcessor;
365		$this->performOnFiles($entity, $entityName, function($entity, $entityName, $field) use ($fileProcessor, $request) {
366		$fileProcessor->updateFile($request, $entity, $entityName, $field);
367		});
368		$this->shouldExecuteEvents($entity, 'after', 'updateFiles');
369		return true;
370		}
371
372		/**
373		* Deletes a specific file from an existing entity.
374		*
375		* @param Entity $entity
376		* the entity to delete the file from
377		* @param string $entityName
378		* the name of the entity as this class here is not aware of it
379		* @param string $field
380		* the field of the entity containing the file to be deleted
381		*
382		* @return boolean
383		* true on successful deletion
384		*/
385		public function deleteFile(Entity $entity, $entityName, $field) {
		0 ignored issues – show Coding Style introduced 2016-04-12 21:06 UTC by Report Bug Copy Issue Report `function deleteFile()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
386		$result = $this->shouldExecuteEvents($entity, 'before', 'deleteFile');
387		if (!$result) {
388		return false;
389		}
390		$this->fileProcessor->deleteFile($entity, $entityName, $field);
391		$this->shouldExecuteEvents($entity, 'after', 'deleteFile');
392		return true;
393		}
394
395		/**
396		* Deletes all files of an existing entity.
397		*
398		* @param Entity $entity
399		* the entity to delete the files from
400		* @param string $entityName
401		* the name of the entity as this class here is not aware of it
402		*
403		* @return boolean
404		* true on successful deletion
405		*/
406	View Code Duplication	public function deleteFiles(Entity $entity, $entityName) {
		0 ignored issues – show Coding Style introduced 2016-04-12 21:06 UTC by Report Bug Copy Issue Report `function deleteFiles()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history... Duplication introduced 2016-01-26 22:04 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...
407		$result = $this->shouldExecuteEvents($entity, 'before', 'deleteFiles');
408		if (!$result) {
409		return false;
410		}
411		$fileProcessor = $this->fileProcessor;
412		$this->performOnFiles($entity, $entityName, function($entity, $entityName, $field) use ($fileProcessor) {
413		$fileProcessor->deleteFile($entity, $entityName, $field);
414		});
415		$this->shouldExecuteEvents($entity, 'after', 'deleteFiles');
416		return true;
417		}
418
419		/**
420		* Renders (outputs) a file of an entity. This includes setting headers
421		* like the file size, mimetype and name, too.
422		*
423		* @param Entity $entity
424		* the entity to render the file from
425		* @param string $entityName
426		* the name of the entity as this class here is not aware of it
427		* @param string $field
428		* the field of the entity containing the file to be rendered
429		*
430		* @return Response
431		* the HTTP response, likely to be a streamed one
432		*/
433		public function renderFile(Entity $entity, $entityName, $field) {
434		return $this->fileProcessor->renderFile($entity, $entityName, $field);
435		}
436
437		}
438

philiplb / CRUDlex

Branch — master (e704c9)

AbstractData::shouldExecuteEvents() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like