CRUD::update_internal() - Code Metrics - Inspection of "Added tests for `cs\Config` class." - nazar-pc/CleverStyle-Framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5de713...fdfecd )

by Nazar

created 2016-07-02 14:55 UTC

CRUD::update_internal() B

↳ Parent: CRUD

Complexity

Conditions	4
Paths	4

Size

Total Lines	35
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	21
CRAP Score	4.0015

Importance

Changes

Metric	Value
cc	4
eloc	26
nc	4
nop	4
dl	0
loc	35
ccs	21
cts	22
cp	0.9545
crap	4.0015
rs	8.5806
c	0
b	0
f	0

<?php
/**
 * @package   CleverStyle Framework
 * @author    Nazar Mokrynskyi <[email protected]>
 * @copyright Copyright (c) 2013-2016, Nazar Mokrynskyi
 * @license   MIT License, see license.txt
 */
namespace cs;
use
	cs\DB\Accessor,
	cs\CRUD\Data_model_processing;

/**
 * CRUD trait
 *
 * Provides create/read/update/delete methods for faster development
 */
trait CRUD {
	use
		Accessor,
		Data_model_processing;
	/**
	 * Create item
	 *
	 * @param array $arguments First element `id` can be omitted if it is autoincrement field
	 *
	 * @return false|int|string Id of created item on success, `false` otherwise
	 */
	protected function create (...$arguments) {
		if (count($arguments) == 1 && !is_array(array_values($this->data_model)[1])) {
			$arguments = $arguments[0];
		}
		/** @noinspection ExceptionsAnnotatingAndHandlingInspection */
		$this->db_prime()->transaction(
			function () use (&$id, $arguments) {
				$id = $this->create_internal($this->table, $this->data_model, $arguments);
			}
		);
		return $id;
	}
	/**
	 * Create item
	 *
	 * @param string              $table
	 * @param callable[]|string[] $data_model
	 * @param array               $arguments First element `id` can be omitted if it is autoincrement field
	 *
	 * @return false|int|string Id of created item on success (or specified primary key), `false` otherwise
	 */
	private function create_internal ($table, $data_model, $arguments) {
		$arguments = $this->fix_arguments_order($data_model, $arguments);
		$insert_id = count($data_model) == count($arguments) ? $arguments[0] : false;
		list($prepared_arguments, $joined_tables) = $this->crud_arguments_preparation(
			$insert_id !== false ? $data_model : array_slice($data_model, 1),
			$arguments,
			$insert_id,
			$update_needed
		);
		$columns = "`".implode("`,`", array_keys($prepared_arguments))."`";
		$values  = implode(',', array_fill(0, count($prepared_arguments), "'%s'"));
		$return  = $this->db_prime()->q(
			"INSERT IGNORE INTO `$table`
				(
					$columns
				) VALUES (
					$values
				)",
			$prepared_arguments
		);
		$id      = $insert_id !== false ? $insert_id : $this->db_prime()->id();
		/**
		 * Id might be 0 if insertion failed or if we insert duplicate entry (which is fine since we use 'INSERT IGNORE'
		 */
		if (!$return || $id === 0) {
			return false;
		}
		$this->update_joined_tables($id, $joined_tables);
		$this->find_update_files_tags($id, [], $arguments);
		/**
		 * If on creation request without specified primary key and multilingual fields present - update needed
		 * after creation (there is no id before creation)
		 */
		if ($update_needed) {
			$this->update_internal(
				$table,
				array_filter(
					$data_model,
					function ($item) {
						return !is_array($item) || !isset($item['data_model']);
					}
				),
				array_merge([array_keys($data_model)[0] => $id], $prepared_arguments),
				false
			);
		}
		return $id;
	}
	/**
	 * @param int|string $id
	 * @param array      $joined_tables
	 */
	private function update_joined_tables ($id, $joined_tables) {
		$clang = $this->db_prime()->s(Language::instance()->clang, false);
		/**
		 * At first we remove all old data
		 */
		foreach ($this->data_model as $table => $model) {
			if (!is_array($model) || !isset($model['data_model'])) {
				continue;
			}
			$id_field                 = array_keys($model['data_model'])[0];
			$language_field_condition = isset($model['language_field'])
				? "AND `$model[language_field]` = '$clang'"
				: '';
			$this->db_prime()->q(
				"DELETE FROM `{$this->table}_$table`
				WHERE
					`$id_field`	= '%s'
					$language_field_condition",
				$id
			);
		}
		$id = $this->db_prime()->s($id, false);
		/**
		 * Now walk through all tables and insert new valued
		 */
		foreach ($joined_tables as $table => $model) {
			if (!@$model['data']) {
				continue;
			}
			$fields = "`$model[id_field]`, ";
			/** @noinspection DisconnectedForeachInstructionInspection */
			$values = "'$id'";
			if (isset($model['language_field'])) {
				$fields .= "`$model[language_field]`, ";
				$values .= ",'$clang'";
			}
			$fields .= '`'.implode('`,`', array_keys($model['fields'])).'`';
			$values .= str_repeat(",'%s'", count($model['fields']));
			$this->db_prime()->insert(
				"INSERT INTO `{$this->table}_$table`
					(
						$fields
					) VALUES (
						$values
					)",
				$model['data']
			);
		}
	}
	/**
	 * Read item
	 *
	 * @param int|int[]|string|string[] $id
	 *
	 * @return array|false
	 */
	protected function read ($id) {
		/** @noinspection ExceptionsAnnotatingAndHandlingInspection */
		$this->db()->transaction(
			function () use (&$result, $id) {
				$result = $this->read_internal($this->table, $this->data_model, $id);
			}
		);
		return $result;
	}
	/**
	 * Read item
	 *
	 * @param string                    $table
	 * @param callable[]|string[]       $data_model
	 * @param int|int[]|string|string[] $id
	 *
	 * @return array|false
	 */
	private function read_internal ($table, $data_model, $id) {
		if (is_array($id)) {
			foreach ($id as &$i) {
				$i = $this->read_internal($table, $data_model, $i);
			}
			return $id;
		}
		$columns      = array_filter(
			$data_model,
			function ($column) {
				return !is_array($column) || !isset($column['data_model']);
			}
		);
		$columns      = "`".implode("`,`", array_keys($columns))."`";
		$first_column = array_keys($data_model)[0];
		$data         = $this->db()->qf(
			"SELECT $columns
			FROM `$table`
			WHERE `$first_column` = '%s'
			LIMIT 1",
			$id
		);
		if (!$data) {
			return false;
		}
		foreach ($this->data_model as $field => $model) {
			if (is_array($model) && isset($model['data_model'])) {
				$data[$field] = $this->read_joined_table($id, $field, $model);
			} else {
				if (is_string($model)) {
					/**
					 * Handle multilingual fields automatically
					 */
					if (strpos($model, 'ml:') === 0) {
						$data[$field] = Text::instance()->process($this->cdb(), $data[$field], true);
					}
				}
				$data[$field] = $this->read_field_post_processing($data[$field], $model);
			}
		}
		return $data;
	}
	/**
	 * @param false|string|string[] $value
	 * @param string                $model
	 *
	 * @return array|false|float|int|string
	 */
	private function read_field_post_processing ($value, $model) {
		if (is_callable($model)) {
			return $model($value);
		}
		/**
		 * Decode JSON fields
		 */
		if (in_array($model, ['json', 'ml:json'])) {
			return _json_decode($value);
		}
		if (strpos($model, 'int') === 0) {
			return _int($value);
		}
		if (strpos($model, 'float') === 0) {
			return _float($value);
		}
		return $value;
	}
	/**
	 * @param int|string  $id
	 * @param string      $table
	 * @param array       $model
	 * @param null|string $force_clang
	 *
	 * @return array
	 */
	private function read_joined_table ($id, $table, $model, $force_clang = null) {
		$clang                    = $force_clang ?: $this->db()->s(Language::instance()->clang, false);
		$id_field                 = array_keys($model['data_model'])[0];
		$language_field_condition = isset($model['language_field'])
			? "AND `$model[language_field]` = '$clang'"
			: '';
		$fields                   = '`'.implode('`,`', array_keys($model['data_model'])).'`';
		$rows                     = $this->db_prime()->qfa(
			"SELECT $fields
			FROM `{$this->table}_$table`
			WHERE
				`$id_field`	= '%s'
				$language_field_condition",
			$id
		) ?: [];
		$language_field           = isset($model['language_field']) ? $model['language_field'] : null;
		/**
		 * If no rows found for current language - find another language that should contain some rows
		 */
		if (!$rows && $language_field !== null) {
			$new_clang = $this->db_prime()->qfs(
				"SELECT `$language_field`
				FROM `{$this->table}_$table`
				WHERE `$id_field`	= '%s'
				LIMIT 1",
				$id
			);
			if ($new_clang && $new_clang != $clang) {
				return $this->read_joined_table($id, $table, $model, $new_clang);
			}
			return [];
		}
		foreach ($rows as &$row) {
			/**
			 * Drop language and id field since they are used internally, not specified by user
			 */
			unset(
				$row[$language_field],
				$row[$id_field]
			);
			foreach ($row as $field => &$value) {
				$value = $this->read_field_post_processing($value, $model['data_model'][$field]);
			}
			/**
			 * If row is array that contains only one item - lets make resulting array flat
			 */
			if (count($row) == 1) {
				$row = array_pop($row);
			}
		}
		return $rows;
	}
	/**
	 * Update item
	 *
	 * @param array $arguments
	 *
	 * @return bool
	 */
	protected function update (...$arguments) {
		if (count($arguments) == 1) {
			$arguments = $arguments[0];
		}
		/** @noinspection ExceptionsAnnotatingAndHandlingInspection */
		$this->db_prime()->transaction(
			function () use (&$result, $arguments) {
				$result = $this->update_internal($this->table, $this->data_model, $arguments);
			}
		);
		return $result;
	}
	/**
	 * Update item
	 *
	 * @param string              $table
	 * @param callable[]|string[] $data_model
	 * @param array               $arguments
	 * @param bool                $files_update
	 *
	 * @return bool
	 */
	private function update_internal ($table, $data_model, $arguments, $files_update = true) {
		$arguments          = $this->fix_arguments_order($data_model, $arguments);
		$prepared_arguments = $arguments;
		$id                 = array_shift($prepared_arguments);
		$data               = $this->read_internal($table, $data_model, $id);
		if (!$data) {
			return false;
		}
		list($prepared_arguments, $joined_tables) = $this->crud_arguments_preparation(array_slice($data_model, 1), $prepared_arguments, $id);
		$columns              = implode(
			',',
			array_map(
				function ($column) {
					return "`$column` = '%s'";
				},
				array_keys($prepared_arguments)
			)
		);
		$prepared_arguments[] = $id;
		$first_column         = array_keys($data_model)[0];
		if (!$this->db_prime()->q(
			"UPDATE `$table`
			SET $columns
			WHERE `$first_column` = '%s'",
			$prepared_arguments
		)
		) {
			return false;
		}
		if ($files_update) {
			$this->update_joined_tables($id, $joined_tables);
			$this->find_update_files_tags($id, $data, $arguments);
		}
		return true;
	}
	/**
	 * Delete item
	 *
	 * @param int|int[]|string|string[] $id
	 *
	 * @return bool
	 */
	protected function delete ($id) {
		/** @noinspection ExceptionsAnnotatingAndHandlingInspection */
		$this->db_prime()->transaction(
			function () use (&$result, $id) {
				$result = $this->delete_internal($this->table, $this->data_model, $id);
			}
		);
		return $result;
	}
	/**
	 * Delete item
	 *
	 * @param string                    $table
	 * @param callable[]|string[]       $data_model
	 * @param int|int[]|string|string[] $id
	 *
	 * @return bool
	 */
	private function delete_internal ($table, $data_model, $id) {
		$id           = (array)$id;
		$result       = true;
		$multilingual = $this->is_multilingual();
		$first_column = array_keys($data_model)[0];
		foreach ($id as $i) {
			$result =
				$result &&
				$this->read_internal($table, $data_model, $i) &&
				$this->db_prime()->q(
					"DELETE FROM `$table`
					WHERE `$first_column` = '%s'",
					$i
				);
			/**
			 * If there are multilingual fields - handle multilingual deleting of fields automatically
			 */
			if ($multilingual) {
				foreach (array_keys($this->data_model) as $field) {
					if (is_string($this->data_model[$field]) && strpos($this->data_model[$field], 'ml:') === 0) {
						Text::instance()->del($this->cdb(), "$this->data_model_ml_group/$field", $i);
					}
				}
			}
			$this->update_joined_tables($i, []);
			$this->delete_files_tags($i);
		}
		return $result;
	}
}


1		<?php
2		/**
3		* @package CleverStyle Framework
4		* @author Nazar Mokrynskyi <[email protected]>
5		* @copyright Copyright (c) 2013-2016, Nazar Mokrynskyi
6		* @license MIT License, see license.txt
7		*/
8		namespace cs;
9		use
10		cs\DB\Accessor,
11		cs\CRUD\Data_model_processing;
12
13		/**
14		* CRUD trait
15		*
16		* Provides create/read/update/delete methods for faster development
17		*/
18		trait CRUD {
19		use
20		Accessor,
21		Data_model_processing;
22		/**
23		* Create item
24		*
25		* @param array $arguments First element `id` can be omitted if it is autoincrement field
26		*
27		* @return false\|int\|string Id of created item on success, `false` otherwise
28		*/
29	26	protected function create (...$arguments) {
30	26	if (count($arguments) == 1 && !is_array(array_values($this->data_model)[1])) {
31	20	$arguments = $arguments[0];
32		}
33		/** @noinspection ExceptionsAnnotatingAndHandlingInspection */
34	26	$this->db_prime()->transaction(
35		function () use (&$id, $arguments) {
36		$id = $this->create_internal($this->table, $this->data_model, $arguments);
37	26	}
38		);
39	26	return $id;
40		}
41		/**
42		* Create item
43		*
44		* @param string $table
45		* @param callable[]\|string[] $data_model
46		* @param array $arguments First element `id` can be omitted if it is autoincrement field
47		*
48		* @return false\|int\|string Id of created item on success (or specified primary key), `false` otherwise
49		*/
50	26	private function create_internal ($table, $data_model, $arguments) {
51	26	$arguments = $this->fix_arguments_order($data_model, $arguments);
52	26	$insert_id = count($data_model) == count($arguments) ? $arguments[0] : false;
53	26	list($prepared_arguments, $joined_tables) = $this->crud_arguments_preparation(
54	26	$insert_id !== false ? $data_model : array_slice($data_model, 1),
55		$arguments,
56		$insert_id,
57		$update_needed
58		);
59	26	$columns = "`".implode("`,`", array_keys($prepared_arguments))."`";
60	26	$values = implode(',', array_fill(0, count($prepared_arguments), "'%s'"));
61	26	$return = $this->db_prime()->q(
62	26	"INSERT IGNORE INTO `$table`
63		(
64	26	$columns
65		) VALUES (
66	26	$values
67	26	)",
68		$prepared_arguments
69		);
70	26	$id = $insert_id !== false ? $insert_id : $this->db_prime()->id();
71		/**
72		* Id might be 0 if insertion failed or if we insert duplicate entry (which is fine since we use 'INSERT IGNORE'
73		*/
74	26	if (!$return \|\| $id === 0) {
75		return false;
76		}
77	26	$this->update_joined_tables($id, $joined_tables);
78	26	$this->find_update_files_tags($id, [], $arguments);
79		/**
80		* If on creation request without specified primary key and multilingual fields present - update needed
81		* after creation (there is no id before creation)
82		*/
83	26	if ($update_needed) {
84	2	$this->update_internal(
85		$table,
86		array_filter(
87		$data_model,
88		function ($item) {
89		return !is_array($item) \|\| !isset($item['data_model']);
90	2	}
91		),
92	2	array_merge([array_keys($data_model)[0] => $id], $prepared_arguments),
93	2	false
94		);
95		}
96	26	return $id;
97		}
98		/**
99		* @param int\|string $id
100		* @param array $joined_tables
101		*/
102	28	private function update_joined_tables ($id, $joined_tables) {
103	28	$clang = $this->db_prime()->s(Language::instance()->clang, false);
104		/**
105		* At first we remove all old data
106		*/
107	28	foreach ($this->data_model as $table => $model) {
108	28	if (!is_array($model) \|\| !isset($model['data_model'])) {
109	28	continue;
110		}
111	4	$id_field = array_keys($model['data_model'])[0];
112	4	$language_field_condition = isset($model['language_field'])
113	2	? "AND `$model[language_field]` = '$clang'"
114	4	: '';
115	4	$this->db_prime()->q(
116	4	"DELETE FROM `{$this->table}_$table`
117		WHERE
118	4	`$id_field` = '%s'
119	4	$language_field_condition",
120		$id
121		);
122		}
123	28	$id = $this->db_prime()->s($id, false);
124		/**
125		* Now walk through all tables and insert new valued
126		*/
127	28	foreach ($joined_tables as $table => $model) {
128	4	if (!@$model['data']) {
129	2	continue;
130		}
131	4	$fields = "`$model[id_field]`, ";
132		/** @noinspection DisconnectedForeachInstructionInspection */
133	4	$values = "'$id'";
134	4	if (isset($model['language_field'])) {
135	2	$fields .= "`$model[language_field]`, ";
136	2	$values .= ",'$clang'";
137		}
138	4	$fields .= '`'.implode('`,`', array_keys($model['fields'])).'`';
139	4	$values .= str_repeat(",'%s'", count($model['fields']));
140	4	$this->db_prime()->insert(
141	4	"INSERT INTO `{$this->table}_$table`
142		(
143	4	$fields
144		) VALUES (
145	4	$values
146	4	)",
147	4	$model['data']
148		);
149		}
150	28	}
151		/**
152		* Read item
153		*
154		* @param int\|int[]\|string\|string[] $id
155		*
156		* @return array\|false
157		*/
158	16	protected function read ($id) {
159		/** @noinspection ExceptionsAnnotatingAndHandlingInspection */
160	16	$this->db()->transaction(
161		function () use (&$result, $id) {
162		$result = $this->read_internal($this->table, $this->data_model, $id);
163	16	}
164		);
165	16	return $result;
166		}
167		/**
168		* Read item
169		*
170		* @param string $table
171		* @param callable[]\|string[] $data_model
172		* @param int\|int[]\|string\|string[] $id
173		*
174		* @return array\|false
175		*/
176	24	private function read_internal ($table, $data_model, $id) {
177	24	if (is_array($id)) {
178	8	foreach ($id as &$i) {
179	8	$i = $this->read_internal($table, $data_model, $i);
180		}
181	8	return $id;
182		}
183	24	$columns = array_filter(
184		$data_model,
185		function ($column) {
186		return !is_array($column) \|\| !isset($column['data_model']);
187	24	}
188		);
189	24	$columns = "`".implode("`,`", array_keys($columns))."`";
190	24	$first_column = array_keys($data_model)[0];
191	24	$data = $this->db()->qf(
192	24	"SELECT $columns
193	24	FROM `$table`
194	24	WHERE `$first_column` = '%s'
195	24	LIMIT 1",
196		$id
197		);
198	24	if (!$data) {
199	8	return false;
200		}
201	24	foreach ($this->data_model as $field => $model) {
202	24	if (is_array($model) && isset($model['data_model'])) {
203	4	$data[$field] = $this->read_joined_table($id, $field, $model);
204		} else {
205	24	if (is_string($model)) {
206		/**
207		* Handle multilingual fields automatically
208		*/
209	24	if (strpos($model, 'ml:') === 0) {
210	2	$data[$field] = Text::instance()->process($this->cdb(), $data[$field], true);
211		}
212		}
213	24	$data[$field] = $this->read_field_post_processing($data[$field], $model);
214		}
215		}
216	24	return $data;
217		}
218		/**
219		* @param false\|string\|string[] $value
220		* @param string $model
221		*
222		* @return array\|false\|float\|int\|string
223		*/
224	24	private function read_field_post_processing ($value, $model) {
225	24	if (is_callable($model)) {
226	4	return $model($value);
227		}
228		/**
229		* Decode JSON fields
230		*/
231	24	if (in_array($model, ['json', 'ml:json'])) {
232	14	return _json_decode($value);
233		}
234	24	if (strpos($model, 'int') === 0) {
235	20	return _int($value);
236		}
237	24	if (strpos($model, 'float') === 0) {
238		return _float($value);
239		}
240	24	return $value;
241		}
242		/**
243		* @param int\|string $id
244		* @param string $table
245		* @param array $model
246		* @param null\|string $force_clang
247		*
248		* @return array
249		*/
250	4	private function read_joined_table ($id, $table, $model, $force_clang = null) {
251	4	$clang = $force_clang ?: $this->db()->s(Language::instance()->clang, false);
252	4	$id_field = array_keys($model['data_model'])[0];
253	4	$language_field_condition = isset($model['language_field'])
254	2	? "AND `$model[language_field]` = '$clang'"
255	4	: '';
256	4	$fields = '`'.implode('`,`', array_keys($model['data_model'])).'`';
257	4	$rows = $this->db_prime()->qfa(
258	4	"SELECT $fields
259	4	FROM `{$this->table}_$table`
260		WHERE
261	4	`$id_field` = '%s'
262	4	$language_field_condition",
263		$id
264	4	) ?: [];
265	4	$language_field = isset($model['language_field']) ? $model['language_field'] : null;
266		/**
267		* If no rows found for current language - find another language that should contain some rows
268		*/
269	4	if (!$rows && $language_field !== null) {
270	2	$new_clang = $this->db_prime()->qfs(
271	2	"SELECT `$language_field`
272	2	FROM `{$this->table}_$table`
273	2	WHERE `$id_field` = '%s'
274	2	LIMIT 1",
275		$id
276		);
277	2	if ($new_clang && $new_clang != $clang) {
278	2	return $this->read_joined_table($id, $table, $model, $new_clang);
279		}
280		return [];
281		}
282	4	foreach ($rows as &$row) {
283		/**
284		* Drop language and id field since they are used internally, not specified by user
285		*/
286		unset(
287	4	$row[$language_field],
288	4	$row[$id_field]
289		);
290	4	foreach ($row as $field => &$value) {
291	4	$value = $this->read_field_post_processing($value, $model['data_model'][$field]);
292		}
293		/**
294		* If row is array that contains only one item - lets make resulting array flat
295		*/
296	4	if (count($row) == 1) {
297	4	$row = array_pop($row);
298		}
299		}
300	4	return $rows;
301		}
302		/**
303		* Update item
304		*
305		* @param array $arguments
306		*
307		* @return bool
308		*/
309	10	protected function update (...$arguments) {
310	10	if (count($arguments) == 1) {
311	4	$arguments = $arguments[0];
312		}
313		/** @noinspection ExceptionsAnnotatingAndHandlingInspection */
314	10	$this->db_prime()->transaction(
315		function () use (&$result, $arguments) {
316		$result = $this->update_internal($this->table, $this->data_model, $arguments);
317	10	}
318		);
319	10	return $result;
320		}
321		/**
322		* Update item
323		*
324		* @param string $table
325		* @param callable[]\|string[] $data_model
326		* @param array $arguments
327		* @param bool $files_update
328		*
329		* @return bool
330		*/
331	10	private function update_internal ($table, $data_model, $arguments, $files_update = true) {
332	10	$arguments = $this->fix_arguments_order($data_model, $arguments);
333	10	$prepared_arguments = $arguments;
334	10	$id = array_shift($prepared_arguments);
335	10	$data = $this->read_internal($table, $data_model, $id);
336	10	if (!$data) {
337	2	return false;
338		}
339	10	list($prepared_arguments, $joined_tables) = $this->crud_arguments_preparation(array_slice($data_model, 1), $prepared_arguments, $id);
340	10	$columns = implode(
341	10	',',
342		array_map(
343		function ($column) {
344		return "`$column` = '%s'";
345	10	},
346		array_keys($prepared_arguments)
347		)
348		);
349	10	$prepared_arguments[] = $id;
350	10	$first_column = array_keys($data_model)[0];
351	10	if (!$this->db_prime()->q(
352	10	"UPDATE `$table`
353	10	SET $columns
354	10	WHERE `$first_column` = '%s'",
355		$prepared_arguments
356		)
357		) {
358		return false;
359		}
360	10	if ($files_update) {
361	10	$this->update_joined_tables($id, $joined_tables);
362	10	$this->find_update_files_tags($id, $data, $arguments);
363		}
364	10	return true;
365		}
366		/**
367		* Delete item
368		*
369		* @param int\|int[]\|string\|string[] $id
370		*
371		* @return bool
372		*/
373	12	protected function delete ($id) {
374		/** @noinspection ExceptionsAnnotatingAndHandlingInspection */
375	12	$this->db_prime()->transaction(
376	12	function () use (&$result, $id) {
377		$result = $this->delete_internal($this->table, $this->data_model, $id);
378	12	}
379		);
380	12	return $result;
381		}
382		/**
383		* Delete item
384		*
385		* @param string $table
386		* @param callable[]\|string[] $data_model
387		* @param int\|int[]\|string\|string[] $id
388		*
389		* @return bool
390		*/
391	12	private function delete_internal ($table, $data_model, $id) {
392	12	$id = (array)$id;
393	12	$result = true;
394	12	$multilingual = $this->is_multilingual();
395	12	$first_column = array_keys($data_model)[0];
396	12	foreach ($id as $i) {
397		$result =
398	12	$result &&
399	12	$this->read_internal($table, $data_model, $i) &&
400	12	$this->db_prime()->q(
401	12	"DELETE FROM `$table`
402	12	WHERE `$first_column` = '%s'",
403		$i
404		);
405		/**
406		* If there are multilingual fields - handle multilingual deleting of fields automatically
407		*/
408	12	if ($multilingual) {
409	2	foreach (array_keys($this->data_model) as $field) {
410	2	if (is_string($this->data_model[$field]) && strpos($this->data_model[$field], 'ml:') === 0) {
411	2	Text::instance()->del($this->cdb(), "$this->data_model_ml_group/$field", $i);
412		}
413		}
414		}
415	12	$this->update_joined_tables($i, []);
416	12	$this->delete_files_tags($i);
417		}
418	12	return $result;
419		}
420		}
421

nazar-pc / CleverStyle-Framework

Push — master ( 5de713...fdfecd )

CRUD::update_internal() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like