AbstractData::get()

Completed

Push — master ( 747ecc...c2e4f8 )

by Philip

created 2017-06-29 14:05 UTC

↳ Parent: AbstractData

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	1
ccs	0
cts	0
cp	0
c	0
b	0
f	0
nc	1

<?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 League\Flysystem\FilesystemInterface;

/**
 * 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 filesystem.
     * @var FilesystemInterface
     */
    protected $filesystem;

    /**
     * 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(true);
        $entity     = new Entity($this->definition);
        foreach ($fieldNames as $fieldName) {
            $entity->set($fieldName, $row[$fieldName]);
        }
        return $entity;
    }

    /**
     * Enriches an entity with metadata:
     * id, version, created_at, updated_at
     *
     * @param mixed $id
     * the id of the entity to enrich
     * @param Entity $entity
     * the entity to enrich
     */
    protected function enrichEntityWithMetaData($id, Entity $entity) {
        $entity->set('id', $id);
        $createdEntity = $this->get($entity->get('id'));
        $entity->set('version', $createdEntity->get('version'));
        $entity->set('created_at', $createdEntity->get('created_at'));
        $entity->set('updated_at', $createdEntity->get('updated_at'));
    }

    /**
     * Gets the many-to-many fields.
     *
     * @return array|\string[]
     * the many-to-many fields
     */
    protected function getManyFields() {
        $fields = $this->definition->getFieldNames(true);
        return array_filter($fields, function($field) {
            return $this->definition->getType($field) === 'many';
        });
    }

    /**
     * Gets all form fields including the many-to-many-ones.
     *
     * @return array
     * all form fields
     */
    protected function getFormFields() {
        $manyFields = $this->getManyFields();
        $formFields = [];
        foreach ($this->definition->getEditableFieldNames() as $field) {
            if (!in_array($field, $manyFields)) {
                $formFields[] = $field;
            }
        }
        return $formFields;
    }

    /**
     * Performs the cascading children deletion.
     *
     * @param integer $id
     * the current entities id
     * @param boolean $deleteCascade
     * whether to delete children and sub children
     *
     * @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
     */
    protected function deleteChildren($id, $deleteCascade) {
        foreach ($this->definition->getChildren() as $childArray) {
            $childData = $this->definition->getServiceProvider()->getData($childArray[2]);
            $children  = $childData->listEntries([$childArray[1] => $id]);
            foreach ($children as $child) {
                $result = $childData->shouldExecuteEvents($child, 'before', 'delete');
                if (!$result) {
                    return static::DELETION_FAILED_EVENT;
                }
                $childData->doDelete($child, $deleteCascade);
                $childData->shouldExecuteEvents($child, 'after', 'delete');
            }
        }
        return static::DELETION_SUCCESS;
    }

    /**
     * Gets an array of reference ids for the given entities.
     *
     * @param array $entities
     * the entities to extract the ids
     * @param string $field
     * the reference field
     *
     * @return array
     * the extracted ids
     */
    protected function getReferenceIds(array $entities, $field) {
        $ids = array_map(function(Entity $entity) use ($field) {
            $id = $entity->get($field);
            return is_array($id) ? $id['id'] : $id;
        }, $entities);
        return $ids;
    }

    /**
     * Performs the persistence of the given entity as new entry in the datasource.
     *
     * @param Entity $entity
     * the entity to persist
     *
     * @return boolean
     * true on successful creation
     */
    abstract protected function doCreate(Entity $entity);


    /**
     * Performs the updates of an existing entry in the datasource having the same id.
     *
     * @param Entity $entity
     * the entity with the new data
     *
     * @return boolean
     * true on successful update
     */
    abstract protected function doUpdate(Entity $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)
     */
    public 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;
    }

    /**
     * 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 \Closure $function
     * the event function to be called if set
     */
    public function pushEvent($moment, $action, \Closure $function) {
        $events                            = isset($this->events[$moment.'.'.$action]) ? $this->events[$moment.'.'.$action] : [];
        $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 \Closure|null
     * 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 $filterOperators = [], $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
     */
    public function create(Entity $entity) {

        $result = $this->shouldExecuteEvents($entity, 'before', 'create');
        if (!$result) {
            return false;
        }
        $result = $this->doCreate($entity);
        $this->shouldExecuteEvents($entity, 'after', 'create');
        return $result;
    }

    /**
     * Updates an existing entry in the datasource having the same id.
     *
     * @param Entity $entity
     * the entity with the new data
     *
     * @return boolean
     * true on successful update
     */
    public function update(Entity $entity) {

        if (!$this->shouldExecuteEvents($entity, 'before', 'update')) {
            return false;
        }
        $result = $this->doUpdate($entity);
        $this->shouldExecuteEvents($entity, 'after', 'update');
        return $result;
    }

    /**
     * Deletes an entry from the datasource.
     *
     * @param Entity $entity
     * the entity 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) {
        $result = $this->shouldExecuteEvents($entity, 'before', 'delete');
        if (!$result) {
            return static::DELETION_FAILED_EVENT;
        }
        $result = $this->doDelete($entity, $this->definition->isDeleteCascade());
        $this->shouldExecuteEvents($entity, 'after', 'delete');
        return $result;
    }

    /**
     * Gets ids and names of a table. Used for building up the dropdown box of
     * reference type fields for example.
     *
     * @param string $entity
     * the entity
     * @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 getIdToNameMap($entity, $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);

    /**
     * Checks whether a given set of ids is assigned to any entity exactly
     * like it is given (no subset, no superset).
     *
     * @param string $field
     * the many field
     * @param array $thatIds
     * the id set to check
     * @param string|null $excludeId
     * one optional own id to exclude from the check
     *
     * @return boolean
     * true if the set of ids exists for an entity
     */
    abstract public function hasManySet($field, array $thatIds, $excludeId = 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->getField($field, 'value');
            }
            $entity->set($field, $value);
        }
        $entity->set('id', null);
        return $entity;
    }


}


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 League\Flysystem\FilesystemInterface;
15
16			/**
17			* The abstract class for reading and writing data.
18			*/
19			abstract class AbstractData {
20
21			/**
22			* Return value on successful deletion.
23			*/
24			const DELETION_SUCCESS = 0;
25
26			/**
27			* Return value on failed deletion due to existing references.
28			*/
29			const DELETION_FAILED_STILL_REFERENCED = 1;
30
31			/**
32			* Return value on failed deletion due to a failed before delete event.
33			*/
34			const DELETION_FAILED_EVENT = 2;
35
36			/**
37			* Holds the {@see EntityDefinition} entity definition.
38			*/
39			protected $definition;
40
41			/**
42			* Holds the filesystem.
43			* @var FilesystemInterface
44			*/
45			protected $filesystem;
46
47			/**
48			* Holds the events.
49			*/
50			protected $events;
51
52			/**
53			* Performs the actual deletion.
54			*
55			* @param Entity $entity
56			* the id of the entry to delete
57			* @param boolean $deleteCascade
58			* whether to delete children and subchildren
59			*
60			* @return integer
61			* true on successful deletion
62			*/
63			abstract protected function doDelete(Entity $entity, $deleteCascade);
64
65			/**
66			* Creates an {@see Entity} from the raw data array with the field name
67			* as keys and field values as values.
68			*
69			* @param array $row
70			* the array with the raw data
71			*
72			* @return Entity
73			* the entity containing the array data then
74			*/
75			protected function hydrate(array $row) {
76			$fieldNames = $this->definition->getFieldNames(true);
77	34		$entity = new Entity($this->definition);
78	34		foreach ($fieldNames as $fieldName) {
79	34		$entity->set($fieldName, $row[$fieldName]);
80	34		}
81	34		return $entity;
82			}
83	34
84			/**
85			* Enriches an entity with metadata:
86			* id, version, created_at, updated_at
87			*
88			* @param mixed $id
89			* the id of the entity to enrich
90			* @param Entity $entity
91			* the entity to enrich
92			*/
93			protected function enrichEntityWithMetaData($id, Entity $entity) {
94			$entity->set('id', $id);
95			$createdEntity = $this->get($entity->get('id'));
96			$entity->set('version', $createdEntity->get('version'));
97			$entity->set('created_at', $createdEntity->get('created_at'));
98			$entity->set('updated_at', $createdEntity->get('updated_at'));
99			}
100	34
101	34		/**
102	33		* Gets the many-to-many fields.
103			*
104	7		* @return array\|\string[]
105	7		* the many-to-many fields
106	7		*/
107	7		protected function getManyFields() {
108			$fields = $this->definition->getFieldNames(true);
109			return array_filter($fields, function($field) {
110	6		return $this->definition->getType($field) === 'many';
111			});
112			}
113
114			/**
115			* Gets all form fields including the many-to-many-ones.
116			*
117			* @return array
118			* all form fields
119			*/
120			protected function getFormFields() {
121			$manyFields = $this->getManyFields();
122			$formFields = [];
123	8		foreach ($this->definition->getEditableFieldNames() as $field) {
124	8		if (!in_array($field, $manyFields)) {
125	8		$formFields[] = $field;
126	8		}
127	8		}
128			return $formFields;
129			}
130	8
131			/**
132			* Performs the cascading children deletion.
133			*
134			* @param integer $id
135			* the current entities id
136			* @param boolean $deleteCascade
137			* whether to delete children and sub children
138			*
139			* @return integer
140			* returns one of:
141			* - AbstractData::DELETION_SUCCESS -> successful deletion
142	34		* - AbstractData::DELETION_FAILED_STILL_REFERENCED -> failed deletion due to existing references
143	34		* - AbstractData::DELETION_FAILED_EVENT -> failed deletion due to a failed before delete event
144	34		*/
145	34		protected function deleteChildren($id, $deleteCascade) {
146	34		foreach ($this->definition->getChildren() as $childArray) {
147	34		$childData = $this->definition->getServiceProvider()->getData($childArray[2]);
148	34		$children = $childData->listEntries([$childArray[1] => $id]);
149			foreach ($children as $child) {
150			$result = $childData->shouldExecuteEvents($child, 'before', 'delete');
151			if (!$result) {
152			return static::DELETION_FAILED_EVENT;
153			}
154			$childData->doDelete($child, $deleteCascade);
155			$childData->shouldExecuteEvents($child, 'after', 'delete');
156	35		}
157	35		}
158			return static::DELETION_SUCCESS;
159	35		}
160	35
161			/**
162			* Gets an array of reference ids for the given entities.
163			*
164			* @param array $entities
165			* the entities to extract the ids
166			* @param string $field
167			* the reference field
168			*
169	34		* @return array
170	34		* the extracted ids
171	34		*/
172	34		protected function getReferenceIds(array $entities, $field) {
173	34		$ids = array_map(function(Entity $entity) use ($field) {
174	34		$id = $entity->get($field);
175			return is_array($id) ? $id['id'] : $id;
176			}, $entities);
177	34		return $ids;
178			}
179
180			/**
181			* Performs the persistence of the given entity as new entry in the datasource.
182			*
183			* @param Entity $entity
184			* the entity to persist
185			*
186			* @return boolean
187			* true on successful creation
188	3		*/
189	3		abstract protected function doCreate(Entity $entity);
			0 ignored issues – show Coding Style introduced 2017-06-02 13:10 UTC by Report Bug Copy Issue Report `function doCreate()` 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...
190	3
191	3		/**
192	3		* Performs the updates of an existing entry in the datasource having the same id.
193	2		*
194	2		* @param Entity $entity
195			* the entity with the new data
196			*
197	2		* @return boolean
198	3		* true on successful update
199			*/
200			abstract protected function doUpdate(Entity $entity);
			0 ignored issues – show Coding Style introduced 2017-06-02 13:10 UTC by Report Bug Copy Issue Report `function doUpdate()` 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...
201	3
202			/**
203			* Executes the event chain of an entity.
204			*
205			* @param Entity $entity
206			* the entity having the event chain to execute
207			* @param string $moment
208			* the "moment" of the event, can be either "before" or "after"
209			* @param string $action
210			* the "action" of the event, can be either "create", "update" or "delete"
211			*
212			* @return boolean
213			* true on successful execution of the full chain or false if it broke at
214	21		* any point (and stopped the execution)
215			*/
216	21		public function shouldExecuteEvents(Entity $entity, $moment, $action) {
217	21		if (!isset($this->events[$moment.'.'.$action])) {
218	21		return true;
219	21		}
220			foreach ($this->events[$moment.'.'.$action] as $event) {
221			$result = $event($entity);
222			if (!$result) {
223			return false;
224			}
225			}
226			return true;
227			}
228
229			/**
230			* Adds an event to fire for the given parameters. The event function must
231			* have this signature:
232			* function (Entity $entity)
233			* and has to return true or false.
234			* The events are executed one after another in the added order as long as
235			* they return "true". The first event returning "false" will stop the
236	7		* process.
237	7		*
238			* @param string $moment
239			* the "moment" of the event, can be either "before" or "after"
240			* @param string $action
241			* the "action" of the event, can be either "create", "update" or "delete"
242			* @param \Closure $function
243			* the event function to be called if set
244			*/
245			public function pushEvent($moment, $action, \Closure $function) {
246			$events = isset($this->events[$moment.'.'.$action]) ? $this->events[$moment.'.'.$action] : [];
247			$events[] = $function;
248			$this->events[$moment.'.'.$action] = $events;
249			}
250
251
252			/**
253			* Removes and returns the latest event for the given parameters.
254			*
255	6		* @param string $moment
256	6		* the "moment" of the event, can be either "before" or "after"
257	6		* @param string $action
258	2		* the "action" of the event, can be either "create", "update" or "delete"
259			*
260	6		* @return \Closure\|null
261			* the popped event or null if no event was available.
262	6		*/
263	6		public function popEvent($moment, $action) {
264	6		if (array_key_exists($moment.'.'.$action, $this->events)) {
265	6		return array_pop($this->events[$moment.'.'.$action]);
266	6		}
267	3		return null;
268			}
269	6
270	6
271	6		/**
272			* Gets the entity with the given id.
273	6		*
274	6		* @param string $id
275	6		* the id
276			*
277			* @return Entity
278			* the entity belonging to the id or null if not existant
279			*
280			* @return void
281			*/
282			abstract public function get($id);
283
284			/**
285			* Gets a list of entities fullfilling the given filter or all if no
286			* selection was given.
287			*
288			* @param array $filter
289			* the filter all resulting entities must fulfill, the keys as field names
290			* @param array $filterOperators
291			* the operators of the filter like "=" defining the full condition of the field
292			* @param integer\|null $skip
293			* if given and not null, it specifies the amount of rows to skip
294			* @param integer\|null $amount
295			* if given and not null, it specifies the maximum amount of rows to retrieve
296			* @param string\|null $sortField
297			* if given and not null, it specifies the field to sort the entries
298			* @param boolean\|null $sortAscending
299			* if given and not null, it specifies that the sort order is ascending,
300			* descending else
301			*
302			* @return Entity[]
303			* the entities fulfilling the filter or all if no filter was given
304			*/
305			abstract public function listEntries(array $filter = [], array $filterOperators = [], $skip = null, $amount = null, $sortField = null, $sortAscending = null);
306
307			/**
308			* Persists the given entity as new entry in the datasource.
309			*
310			* @param Entity $entity
311			* the entity to persist
312			*
313			* @return boolean
314			* true on successful creation
315			*/
316	8	View Code Duplication	public function create(Entity $entity) {
			0 ignored issues – show Coding Style introduced 2017-06-02 13:10 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... Duplication introduced 2017-06-02 13:10 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...
317	8		$result = $this->shouldExecuteEvents($entity, 'before', 'create');
318	8		if (!$result) {
319	8		return false;
320	8		}
321			$result = $this->doCreate($entity);
322			$this->shouldExecuteEvents($entity, 'after', 'create');
323			return $result;
324			}
325
326			/**
327			* Updates an existing entry in the datasource having the same id.
328			*
329			* @param Entity $entity
330			* the entity with the new data
331			*
332			* @return boolean
333			* true on successful update
334	8		*/
335	8	View Code Duplication	public function update(Entity $entity) {
			0 ignored issues – show Coding Style introduced 2017-06-02 13:10 UTC by Report Bug Copy Issue Report `function update()` 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 2017-06-02 13:10 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...
336	8		if (!$this->shouldExecuteEvents($entity, 'before', 'update')) {
337			return false;
338	1		}
339			$result = $this->doUpdate($entity);
340			$this->shouldExecuteEvents($entity, 'after', 'update');
341			return $result;
342			}
343
344			/**
345			* Deletes an entry from the datasource.
346			*
347			* @param Entity $entity
348			* the entity to delete
349			*
350			* @return integer
351			* returns one of:
352			* - AbstractData::DELETION_SUCCESS -> successful deletion
353			* - AbstractData::DELETION_FAILED_STILL_REFERENCED -> failed deletion due to existing references
354			* - AbstractData::DELETION_FAILED_EVENT -> failed deletion due to a failed before delete event
355			*/
356			public function delete($entity) {
357			$result = $this->shouldExecuteEvents($entity, 'before', 'delete');
358			if (!$result) {
359			return static::DELETION_FAILED_EVENT;
360			}
361			$result = $this->doDelete($entity, $this->definition->isDeleteCascade());
362			$this->shouldExecuteEvents($entity, 'after', 'delete');
363			return $result;
364			}
365
366			/**
367			* Gets ids and names of a table. Used for building up the dropdown box of
368			* reference type fields for example.
369			*
370			* @param string $entity
371			* the entity
372			* @param string $nameField
373			* the field defining the name of the rows
374			*
375			* @return array
376			* an array with the ids as key and the names as values
377			*/
378			abstract public function getIdToNameMap($entity, $nameField);
379
380			/**
381			* Retrieves the amount of entities in the datasource fulfilling the given
382			* parameters.
383			*
384			* @param string $table
385			* the table to count in
386			* @param array $params
387	34		* an array with the field names as keys and field values as values
388	34		* @param array $paramsOperators
389	34		* the operators of the parameters like "=" defining the full condition of the field
390	2		* @param boolean $excludeDeleted
391			* false, if soft deleted entries in the datasource should be counted, too
392	34		*
393	34		* @return integer
394	34		* the count fulfilling the given parameters
395			*/
396			abstract public function countBy($table, array $params, array $paramsOperators, $excludeDeleted);
397
398			/**
399			* Checks whether a given set of ids is assigned to any entity exactly
400			* like it is given (no subset, no superset).
401			*
402			* @param string $field
403			* the many field
404			* @param array $thatIds
405			* the id set to check
406	13		* @param string\|null $excludeId
407	13		* one optional own id to exclude from the check
408	2		*
409			* @return boolean
410	13		* true if the set of ids exists for an entity
411	13		*/
412	13		abstract public function hasManySet($field, array $thatIds, $excludeId = null);
413
414			/**
415			* Gets the {@see EntityDefinition} instance.
416			*
417			* @return EntityDefinition
418			* the definition instance
419			*/
420			public function getDefinition() {
421			return $this->definition;
422			}
423
424			/**
425			* Creates a new, empty entity instance having all fields prefilled with
426			* null or the defined value in case of fixed fields.
427	4		*
428	4		* @return Entity
429	4		* the newly created entity
430	2		*/
431			public function createEmpty() {
432	4		$entity = new Entity($this->definition);
433	4		$fields = $this->definition->getEditableFieldNames();
434	4		foreach ($fields as $field) {
435			$value = null;
436			if ($this->definition->getType($field) == 'fixed') {
437			$value = $this->definition->getField($field, 'value');
438			}
439			$entity->set($field, $value);
440			}
441			$entity->set('id', null);
442			return $entity;
443			}
444
445
446			}
447

philiplb / CRUDlex

Push — master ( 747ecc...c2e4f8 )

AbstractData::get()

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like