Items::prepare_attributes() - Code Metrics - Inspection of "Drop `password_hash` index and change its size to..." - nazar-pc/CleverStyle-Framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2676d9...a4ebee )

by Nazar

created 2016-02-23 21:26 UTC

Items::prepare_attributes() C

↳ Parent: Items

Complexity

Conditions	7
Paths	7

Size

Total Lines	43
Code Lines	33

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	43
rs	6.7272
cc	7
eloc	33
nc	7
nop	3

<?php
/**
 * @package   Shop
 * @category  modules
 * @author    Nazar Mokrynskyi <[email protected]>
 * @copyright Copyright (c) 2014-2016, Nazar Mokrynskyi
 * @license   MIT License, see license.txt
 */
namespace cs\modules\Shop;
use
	cs\Cache\Prefix,
	cs\Config,
	cs\Event,
	cs\Language,
	cs\User,
	cs\CRUD_helpers,
	cs\Singleton;

/**
 * Provides next events:<br>
 *  Shop/Items/get<code>
 *  [
 *   'data' => &$data
 *  ]</code>
 *
 *  Shop/Items/get_for_user<code>
 *  [
 *   'data' => &$data,
 *   'user' => $user
 *  ]</code>
 *
 *  Shop/Items/add<code>
 *  [
 *   'id' => $id
 *  ]</code>
 *
 *  Shop/Items/set<code>
 *  [
 *   'id' => $id
 *  ]</code>
 *
 *  Shop/Items/del<code>
 *  [
 *   'id' => $id
 *  ]</code>
 */
class Items {
	use CRUD_helpers {
		search as crud_search;
	}
	use
		Singleton;

	const DEFAULT_IMAGE = 'components/modules/Shop/includes/img/no-image.svg';

	protected $data_model                  = [
		'id'         => 'int',
		'date'       => 'int',
		'category'   => 'int',
		'price'      => 'float',
		'in_stock'   => 'int',
		'soon'       => 'int:0..1',
		'listed'     => 'int:0..1',
		'attributes' => [
			'data_model' => [
				'id'            => 'int',
				'attribute'     => 'int',
				'numeric_value' => 'float',
				'string_value'  => 'text',
				'text_value'    => 'html',
				'lang'          => 'text' // Some attributes are language-dependent, some aren't, so we'll handle that manually
			]
		],
		'images'     => [
			'data_model' => [
				'id'    => 'int',
				'image' => 'text'
			]
		],
		'videos'     => [
			'data_model' => [
				'id'     => 'int',
				'video'  => 'text',
				'poster' => 'text',
				'type'   => 'text'
			]
		],
		'tags'       => [
			'data_model'     => [
				'id'  => 'int',
				'tag' => 'html'
			],
			'language_field' => 'lang'
		]
	];
	protected $table                       = '[prefix]shop_items';
	protected $data_model_files_tag_prefix = 'Shop/items';
	/**
	 * @var Prefix
	 */
	protected $cache;

	protected function construct () {
		$this->cache = new Prefix('Shop/items');
	}
	/**
	 * Returns database index
	 *
	 * @return int
	 */
	protected function cdb () {
		return Config::instance()->module('Shop')->db('shop');
	}
	/**
	 * Get item
	 *
	 * @param int|int[] $id
	 *
	 * @return array|false
	 */
	function get ($id) {
		if (is_array($id)) {
			foreach ($id as &$i) {
				$i = $this->get($i);
			}
			return $id;
		}
		$L    = Language::instance();
		$id   = (int)$id;
		$data = $this->cache->get(
			"$id/$L->clang",
			function () use ($id, $L) {
				$data = $this->read($id);
				if (!$data) {
					return false;
				}
				$data['attributes']  = $this->read_attributes_processing($data['attributes'], $L->clang);
				$category            = Categories::instance()->get($data['category']);
				$data['title']       = $data['attributes'][$category['title_attribute']];
				$data['description'] = @$data['attributes'][$category['description_attribute']] ?: '';
				$data['tags']        = $this->read_tags_processing($data['tags']);
				return $data;
			}
		);
		if (!Event::instance()->fire(
			'Shop/Items/get',
			[
				'data' => &$data
			]
		)
		) {
			return false;
		}
		return $data;
	}
	/**
	 * Transform normalized attributes structure back into simple initial structure
	 *
	 * @param array  $attributes
	 * @param string $clang
	 *
	 * @return array
	 */
	protected function read_attributes_processing ($attributes, $clang) {
		/**
		 * Select language-independent attributes and ones that are set for current language
		 */
		$filtered_attributes = array_filter(
			$attributes,
			function ($attribute) use ($clang) {
				return !$attribute['lang'] || $attribute['lang'] == $clang;
			}
		);
		$existing_attributes = array_column($filtered_attributes, 'attribute');
		/**
		 * Now fill other existing attributes that are missing for current language
		 */
		foreach ($attributes as $attribute) {
			if (!in_array($attribute['attribute'], $existing_attributes)) {
				$existing_attributes[] = $attribute['attribute'];
				$filtered_attributes[] = $attribute;
			}
		}
		/**
		 * We have attributes of different types, so, here is normalization for that
		 */
		$Attributes = Attributes::instance();
		foreach ($filtered_attributes as &$value) {
			$attribute = $Attributes->get($value['attribute']);
			if ($attribute) {
				$value['value'] = $value[$this->attribute_type_to_value_field($attribute['type'])];
			} else {
				$value['value'] = $value['text_value'];
				if (!strlen($value['value'])) {
					$value['value'] = $value['string_value'];
				}
				if (!strlen($value['value'])) {
					$value['value'] = $value['numeric_value'];
				}
			}
		}
		return array_column($filtered_attributes, 'value', 'attribute');
	}
	/**
	 * Transform tags ids back into array of strings
	 *
	 * @param int[] $tags
	 *
	 * @return string[]
	 */
	protected function read_tags_processing ($tags) {
		return array_column(Tags::instance()->get($tags) ?: [], 'text');
	}
	/**
	 * Get item data for specific user (price might be adjusted, some items may be restricted and so on)
	 *
	 * @param int|int[] $id
	 * @param bool|int  $user
	 *
	 * @return array|false
	 */
	function get_for_user ($id, $user = false) {
		if (is_array($id)) {
			foreach ($id as $index => &$i) {
				$i = $this->get_for_user($i, $user);
				if ($i === false) {
					unset($id[$index]);
				}
			}
			return $id;
		}
		$user = (int)$user ?: User::instance()->id;
		$data = $this->get($id);
		if (!Event::instance()->fire(
			'Shop/Items/get_for_user',
			[
				'data' => &$data,
				'user' => $user
			]
		)
		) {
			return false;
		}
		return $data;
	}
	/**
	 * Get array of all items
	 *
	 * @return int[] Array of items ids
	 */
	function get_all () {
		return $this->cache->get(
			'all',
			function () {
				return $this->db()->qfas(
					"SELECT `id`
				FROM `$this->table`"
				) ?: [];
			}
		);
	}
	/**
	 * Items search
	 *
	 * @param mixed[] $search_parameters Array in form [attribute => value], [attribute => [value, value]], [attribute => [from => value, to => value]],
	 *                                   [property => value], [tag] or mixed; if `total_count => 1` element is present - total number of found rows will be
	 *                                   returned instead of rows themselves
	 * @param int     $page
	 * @param int     $count
	 * @param string  $order_by
	 * @param bool    $asc
	 *
	 * @return array|false|string

	 */
	function search ($search_parameters = [], $page = 1, $count = 20, $order_by = 'id', $asc = false) {
		if (!isset($this->data_model[$order_by])) {
			return false;
		}
		$Attributes   = Attributes::instance();
		$L            = Language::instance();
		$joins        = '';
		$join_params  = [];
		$join_index   = 0;
		$where        = [];
		$where_params = [];
		foreach ($search_parameters as $key => $details) {
			if (isset($this->data_model[$key])) { // Property
				$where[]        = "`i`.`$key` = '%s'";
				$where_params[] = $details;
			} elseif (is_numeric($key)) { // Tag
				$joins .=
					"INNER JOIN `{$this->table}_tags` AS `t`
					ON
						`i`.`id`	= `t`.`id` AND
						`t`.`tag`	= '%s'";
				$where_params[] = $details;
			} else { // Attribute
				$field = @$this->attribute_type_to_value_field($Attributes->get($key)['type']);
				if (!$field || empty($details)) {
					continue;
				}
				$join_params[] = $key;
				++$join_index;
				$joins .=
					"INNER JOIN `{$this->table}_attributes` AS `a$join_index`
					ON
						`i`.`id`					= `a$join_index`.`id` AND
						`a$join_index`.`attribute`	= '%s' AND
						(
							`a$join_index`.`lang`	= '$L->clang' OR
							`a$join_index`.`lang`	= ''
						)";
				if (is_array($details)) {
					if (isset($details['from']) || isset($details['to'])) {
						/** @noinspection NotOptimalIfConditionsInspection */
						if (isset($details['from'])) {
							$joins .= "AND `a$join_index`.`$field`	>= '%s'";
							$join_params[] = $details['from'];
						}
						/** @noinspection NotOptimalIfConditionsInspection */
						if (isset($details['to'])) {
							$joins .= "AND `a$join_index`.`$field`	<= '%s'";
							$join_params[] = $details['to'];
						}
					} else {
						$on = [];
						foreach ($details as $d) {
							$on[]          = "`a$join_index`.`$field` = '%s'";
							$join_params[] = $d;
						}
						$on = implode(' OR ', $on);
						$joins .= "AND ($on)";
						unset($on, $d);
					}
				} else {
					switch ($field) {
						case 'numeric_value':
							$joins .= "AND `a$join_index`.`$field` = '%s'";
							break;
						case 'string_value':
							$joins .= "AND `a$join_index`.`$field` LIKE '%s%%'";
							break;
						default:
							$joins .= "AND MATCH (`a$join_index`.`$field`) AGAINST ('%s' IN BOOLEAN MODE) > 0";
					}
					$join_params[] = $details;
				}
			}
		}
		return $this->search_do('i', @$search_parameters['total_count'], $where, $where_params, $joins, $join_params, $page, $count, $order_by, $asc);
	}
	/**
	 * @param int $type
	 *
	 * @return string

	 */
	protected function attribute_type_to_value_field ($type) {
		switch ($type) {
			/**
			 * For numeric values and value sets (each value have its own index in set and does not depend on language) value is stored in numeric
			 * column for faster search
			 */
			case Attributes::TYPE_INT_SET:
			case Attributes::TYPE_INT_RANGE:
			case Attributes::TYPE_FLOAT_SET:
			case Attributes::TYPE_FLOAT_RANGE:
			case Attributes::TYPE_SWITCH:
			case Attributes::TYPE_STRING_SET:
			case Attributes::TYPE_COLOR_SET:
				return 'numeric_value';
			case Attributes::TYPE_STRING:
				return 'string_value';
			case Attributes::TYPE_TEXT:
				return 'text_value';
			default:
				return false;
		}
	}
	/**
	 * Add new item
	 *
	 * @param int      $category
	 * @param float    $price
	 * @param int      $in_stock
	 * @param int      $soon
	 * @param int      $listed
	 * @param array    $attributes
	 * @param string[] $images
	 * @param array[]  $videos
	 * @param string[] $tags
	 *
	 * @return false|int Id of created item on success of <b>false</> on failure

	 */
	function add ($category, $price, $in_stock, $soon, $listed, $attributes, $images, $videos, $tags) {
		$L  = Language::instance();
		$id = $this->create(
			[
				time(),
				$category,
				$price,
				$in_stock,
				$soon && !$in_stock ? 1 : 0,
				$listed,
				$this->prepare_attributes($attributes, $category, $L->clang),
				$this->prepare_images($images),
				$this->prepare_videos($videos),
				$this->prepare_tags($tags)
			]
		);
		if ($id) {
			unset($this->cache->all);
			Event::instance()->fire(
				'Shop/Items/add',
				[
					'id' => $id
				]
			);
		}
		return $id;
	}
	/**
	 * Normalize attributes array structure
	 *
	 * @param array  $attributes
	 * @param int    $category
	 * @param string $clang
	 *
	 * @return array
	 */
	protected function prepare_attributes ($attributes, $category, $clang) {
		$Attributes      = Attributes::instance();
		$title_attribute = Categories::instance()->get($category)['title_attribute'];
		foreach ($attributes as $attribute => &$value) {
			$attribute_data = $Attributes->get($attribute);
			if (!$attribute_data) {
				unset($attributes[$attribute]);
				continue;
			}
			$value_type = [
				'numeric' => 0,
				'string'  => '',
				'text'    => ''
			];
			$lang       = '';
			switch ($this->attribute_type_to_value_field($attribute_data['type'])) {
				case 'numeric_value':
					$value_type['numeric'] = $value;
					break;
				case 'string_value':
					$value_type['string'] = xap($value);
					/**
					 * Multilingual feature only for title attribute
					 */
					if ($attribute_data['id'] == $title_attribute) {
						$lang = $clang;
					}
					break;
				case 'text_value':
					$value_type['text'] = xap($value, true, true);
					$lang               = $clang;
					break;
			}
			$value = [
				$attribute_data['id'],
				$value_type['numeric'],
				$value_type['string'],
				$value_type['text'],
				$lang
			];
		}
		return array_values($attributes);
	}
	/**
	 * Filter images to remove non-URL elements
	 *
	 * @param array $images
	 *
	 * @return array
	 */
	protected function prepare_images ($images) {
		return array_filter(
			$images,
			function ($image) {
				return filter_var($image, FILTER_VALIDATE_URL);
			}
		);
	}
	/**
	 * Normalize videos array structure
	 *
	 * @param array[] $videos
	 *
	 * @return array[]
	 */
	protected function prepare_videos ($videos) {
		if (!$videos || !is_array($videos)) {
			return [];
		}
		$videos = array_flip_3d($videos);
		foreach ($videos as $i => &$video) {
			if (!@$video['video']) {
				unset($videos[$i]);
			}
			if (
				$video['type'] == 'iframe' &&
				preg_match('#(http[s]?:)?//[^\s"\'>]+#ims', $video['video'], $match)
			) {
				$video['video'] = $match[0];
			}
			$video = [
				$video['video'],
				$video['poster'],
				$video['type']
			];
		}
		return $videos;
	}
	/**
	 * Transform array of string tags into array of their ids
	 *
	 * @param string[] $tags
	 *
	 * @return int[]
	 */
	protected function prepare_tags ($tags) {
		return Tags::instance()->add($tags) ?: [];
	}
	/**
	 * Set data of specified item
	 *
	 * @param int      $id
	 * @param int      $category
	 * @param float    $price
	 * @param int      $in_stock
	 * @param int      $soon
	 * @param int      $listed
	 * @param array    $attributes
	 * @param string[] $images
	 * @param array[]  $videos
	 * @param string[] $tags
	 *
	 * @return bool
	 */
	function set ($id, $category, $price, $in_stock, $soon, $listed, $attributes, $images, $videos, $tags) {
		$id   = (int)$id;
		$data = $this->get($id);
		if (!$data) {
			return false;
		}
		$L      = Language::instance();
		$result = $this->update(
			[
				$id,
				$data['date'],
				$category,
				$price,
				$in_stock,
				$soon && !$in_stock ? 1 : 0,
				$listed,
				$this->prepare_attributes($attributes, $category, $L->clang),
				$this->prepare_images($images),
				$this->prepare_videos($videos),
				$this->prepare_tags($tags)
			]
		);
		if ($result) {
			/**
			 * Attributes processing
			 */
			unset(
				$this->cache->{"$id/$L->clang"},
				$this->cache->all
			);
			Event::instance()->fire(
				'Shop/Items/set',
				[
					'id' => $id
				]
			);
		}
		return $result;
	}
	/**
	 * Delete specified item
	 *
	 * @param int $id
	 *
	 * @return bool
	 */
	function del ($id) {
		$id     = (int)$id;
		$result = $this->delete($id);
		if ($result) {
			unset(
				$this->cache->$id,
				$this->cache->all
			);
			Event::instance()->fire(
				'Shop/Items/del',
				[
					'id' => $id
				]
			);
		}
		return $result;
	}
}


1			<?php
2			/**
3			* @package Shop
4			* @category modules
5			* @author Nazar Mokrynskyi <[email protected]>
6			* @copyright Copyright (c) 2014-2016, Nazar Mokrynskyi
7			* @license MIT License, see license.txt
8			*/
9			namespace cs\modules\Shop;
10			use
11			cs\Cache\Prefix,
12			cs\Config,
13			cs\Event,
14			cs\Language,
15			cs\User,
16			cs\CRUD_helpers,
17			cs\Singleton;
18
19			/**
20			* Provides next events:<br>
21			* Shop/Items/get<code>
22			* [
23			* 'data' => &$data
24			* ]</code>
25			*
26			* Shop/Items/get_for_user<code>
27			* [
28			* 'data' => &$data,
29			* 'user' => $user
30			* ]</code>
31			*
32			* Shop/Items/add<code>
33			* [
34			* 'id' => $id
35			* ]</code>
36			*
37			* Shop/Items/set<code>
38			* [
39			* 'id' => $id
40			* ]</code>
41			*
42			* Shop/Items/del<code>
43			* [
44			* 'id' => $id
45			* ]</code>
46			*/
47			class Items {
48			use CRUD_helpers {
49			search as crud_search;
50			}
51			use
52			Singleton;
53
54			const DEFAULT_IMAGE = 'components/modules/Shop/includes/img/no-image.svg';
55
56			protected $data_model = [
57			'id' => 'int',
58			'date' => 'int',
59			'category' => 'int',
60			'price' => 'float',
61			'in_stock' => 'int',
62			'soon' => 'int:0..1',
63			'listed' => 'int:0..1',
64			'attributes' => [
65			'data_model' => [
66			'id' => 'int',
67			'attribute' => 'int',
68			'numeric_value' => 'float',
69			'string_value' => 'text',
70			'text_value' => 'html',
71			'lang' => 'text' // Some attributes are language-dependent, some aren't, so we'll handle that manually
72			]
73			],
74			'images' => [
75			'data_model' => [
76			'id' => 'int',
77			'image' => 'text'
78			]
79			],
80			'videos' => [
81			'data_model' => [
82			'id' => 'int',
83			'video' => 'text',
84			'poster' => 'text',
85			'type' => 'text'
86			]
87			],
88			'tags' => [
89			'data_model' => [
90			'id' => 'int',
91			'tag' => 'html'
92			],
93			'language_field' => 'lang'
94			]
95			];
96			protected $table = '[prefix]shop_items';
97			protected $data_model_files_tag_prefix = 'Shop/items';
98			/**
99			* @var Prefix
100			*/
101			protected $cache;
102
103			protected function construct () {
104			$this->cache = new Prefix('Shop/items');
105			}
106			/**
107			* Returns database index
108			*
109			* @return int
110			*/
111			protected function cdb () {
112			return Config::instance()->module('Shop')->db('shop');
113			}
114			/**
115			* Get item
116			*
117			* @param int\|int[] $id
118			*
119			* @return array\|false
120			*/
121			function get ($id) {
122			if (is_array($id)) {
123			foreach ($id as &$i) {
124			$i = $this->get($i);
125			}
126			return $id;
127			}
128			$L = Language::instance();
129			$id = (int)$id;
130			$data = $this->cache->get(
131			"$id/$L->clang",
132			function () use ($id, $L) {
133			$data = $this->read($id);
134			if (!$data) {
135			return false;
136			}
137			$data['attributes'] = $this->read_attributes_processing($data['attributes'], $L->clang);
138			$category = Categories::instance()->get($data['category']);
139			$data['title'] = $data['attributes'][$category['title_attribute']];
140			$data['description'] = @$data['attributes'][$category['description_attribute']] ?: '';
141			$data['tags'] = $this->read_tags_processing($data['tags']);
142			return $data;
143			}
144			);
145			if (!Event::instance()->fire(
146			'Shop/Items/get',
147			[
148			'data' => &$data
149			]
150			)
151			) {
152			return false;
153			}
154			return $data;
155			}
156			/**
157			* Transform normalized attributes structure back into simple initial structure
158			*
159			* @param array $attributes
160			* @param string $clang
161			*
162			* @return array
163			*/
164			protected function read_attributes_processing ($attributes, $clang) {
165			/**
166			* Select language-independent attributes and ones that are set for current language
167			*/
168			$filtered_attributes = array_filter(
169			$attributes,
170			function ($attribute) use ($clang) {
171			return !$attribute['lang'] \|\| $attribute['lang'] == $clang;
172			}
173			);
174			$existing_attributes = array_column($filtered_attributes, 'attribute');
175			/**
176			* Now fill other existing attributes that are missing for current language
177			*/
178			foreach ($attributes as $attribute) {
179			if (!in_array($attribute['attribute'], $existing_attributes)) {
180			$existing_attributes[] = $attribute['attribute'];
181			$filtered_attributes[] = $attribute;
182			}
183			}
184			/**
185			* We have attributes of different types, so, here is normalization for that
186			*/
187			$Attributes = Attributes::instance();
188			foreach ($filtered_attributes as &$value) {
189			$attribute = $Attributes->get($value['attribute']);
190			if ($attribute) {
191			$value['value'] = $value[$this->attribute_type_to_value_field($attribute['type'])];
192			} else {
193			$value['value'] = $value['text_value'];
194			if (!strlen($value['value'])) {
195			$value['value'] = $value['string_value'];
196			}
197			if (!strlen($value['value'])) {
198			$value['value'] = $value['numeric_value'];
199			}
200			}
201			}
202			return array_column($filtered_attributes, 'value', 'attribute');
203			}
204			/**
205			* Transform tags ids back into array of strings
206			*
207			* @param int[] $tags
208			*
209			* @return string[]
210			*/
211			protected function read_tags_processing ($tags) {
212			return array_column(Tags::instance()->get($tags) ?: [], 'text');
213			}
214			/**
215			* Get item data for specific user (price might be adjusted, some items may be restricted and so on)
216			*
217			* @param int\|int[] $id
218			* @param bool\|int $user
219			*
220			* @return array\|false
221			*/
222			function get_for_user ($id, $user = false) {
223			if (is_array($id)) {
224			foreach ($id as $index => &$i) {
225			$i = $this->get_for_user($i, $user);
226			if ($i === false) {
227			unset($id[$index]);
228			}
229			}
230			return $id;
231			}
232			$user = (int)$user ?: User::instance()->id;
233			$data = $this->get($id);
234			if (!Event::instance()->fire(
235			'Shop/Items/get_for_user',
236			[
237			'data' => &$data,
238			'user' => $user
239			]
240			)
241			) {
242			return false;
243			}
244			return $data;
245			}
246			/**
247			* Get array of all items
248			*
249			* @return int[] Array of items ids
250			*/
251			function get_all () {
252			return $this->cache->get(
253			'all',
254			function () {
255			return $this->db()->qfas(
256			"SELECT `id`
257			FROM `$this->table`"
258			) ?: [];
259			}
260			);
261			}
262			/**
263			* Items search
264			*
265			* @param mixed[] $search_parameters Array in form [attribute => value], [attribute => [value, value]], [attribute => [from => value, to => value]],
266			* [property => value], [tag] or mixed; if `total_count => 1` element is present - total number of found rows will be
267			* returned instead of rows themselves
268			* @param int $page
269			* @param int $count
270			* @param string $order_by
271			* @param bool $asc
272			*
273			* @return array\|false\|string
			0 ignored issues – show Documentation introduced 2015-11-21 02:31 UTC by Report Bug Copy Issue Report Should the return type not be `false\|array[]\|integer\|integer[]\|string\|string[]`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
274			*/
275			function search ($search_parameters = [], $page = 1, $count = 20, $order_by = 'id', $asc = false) {
276			if (!isset($this->data_model[$order_by])) {
277			return false;
278			}
279			$Attributes = Attributes::instance();
280			$L = Language::instance();
281			$joins = '';
282			$join_params = [];
283			$join_index = 0;
284			$where = [];
285			$where_params = [];
286			foreach ($search_parameters as $key => $details) {
287			if (isset($this->data_model[$key])) { // Property
288			$where[] = "`i`.`$key` = '%s'";
289			$where_params[] = $details;
290			} elseif (is_numeric($key)) { // Tag
291			$joins .=
292			"INNER JOIN `{$this->table}_tags` AS `t`
293			ON
294			`i`.`id` = `t`.`id` AND
295			`t`.`tag` = '%s'";
296			$where_params[] = $details;
297			} else { // Attribute
298			$field = @$this->attribute_type_to_value_field($Attributes->get($key)['type']);
299			if (!$field \|\| empty($details)) {
300			continue;
301			}
302			$join_params[] = $key;
303			++$join_index;
304			$joins .=
305			"INNER JOIN `{$this->table}_attributes` AS `a$join_index`
306			ON
307			`i`.`id` = `a$join_index`.`id` AND
308			`a$join_index`.`attribute` = '%s' AND
309			(
310			`a$join_index`.`lang` = '$L->clang' OR
311			`a$join_index`.`lang` = ''
312			)";
313			if (is_array($details)) {
314			if (isset($details['from']) \|\| isset($details['to'])) {
315			/** @noinspection NotOptimalIfConditionsInspection */
316			if (isset($details['from'])) {
317			$joins .= "AND `a$join_index`.`$field` >= '%s'";
318			$join_params[] = $details['from'];
319			}
320			/** @noinspection NotOptimalIfConditionsInspection */
321			if (isset($details['to'])) {
322			$joins .= "AND `a$join_index`.`$field` <= '%s'";
323			$join_params[] = $details['to'];
324			}
325			} else {
326			$on = [];
327			foreach ($details as $d) {
328			$on[] = "`a$join_index`.`$field` = '%s'";
329			$join_params[] = $d;
330			}
331			$on = implode(' OR ', $on);
332			$joins .= "AND ($on)";
333			unset($on, $d);
334			}
335			} else {
336			switch ($field) {
337			case 'numeric_value':
338			$joins .= "AND `a$join_index`.`$field` = '%s'";
339			break;
340			case 'string_value':
341			$joins .= "AND `a$join_index`.`$field` LIKE '%s%%'";
342			break;
343			default:
344			$joins .= "AND MATCH (`a$join_index`.`$field`) AGAINST ('%s' IN BOOLEAN MODE) > 0";
345			}
346			$join_params[] = $details;
347			}
348			}
349			}
350			return $this->search_do('i', @$search_parameters['total_count'], $where, $where_params, $joins, $join_params, $page, $count, $order_by, $asc);
351			}
352			/**
353			* @param int $type
354			*
355			* @return string
			0 ignored issues – show Documentation introduced 2015-11-21 02:31 UTC by Report Bug Copy Issue Report Should the return type not be `string\|false`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
356			*/
357			protected function attribute_type_to_value_field ($type) {
358			switch ($type) {
359			/**
360			* For numeric values and value sets (each value have its own index in set and does not depend on language) value is stored in numeric
361			* column for faster search
362			*/
363			case Attributes::TYPE_INT_SET:
364			case Attributes::TYPE_INT_RANGE:
365			case Attributes::TYPE_FLOAT_SET:
366			case Attributes::TYPE_FLOAT_RANGE:
367			case Attributes::TYPE_SWITCH:
368			case Attributes::TYPE_STRING_SET:
369			case Attributes::TYPE_COLOR_SET:
370			return 'numeric_value';
371			case Attributes::TYPE_STRING:
372			return 'string_value';
373			case Attributes::TYPE_TEXT:
374			return 'text_value';
375			default:
376			return false;
377			}
378			}
379			/**
380			* Add new item
381			*
382			* @param int $category
383			* @param float $price
384			* @param int $in_stock
385			* @param int $soon
386			* @param int $listed
387			* @param array $attributes
388			* @param string[] $images
389			* @param array[] $videos
390			* @param string[] $tags
391			*
392			* @return false\|int Id of created item on success of <b>false</> on failure
			1 ignored issue – show Documentation introduced 2015-11-21 02:31 UTC by Report Bug Copy Issue Report Should the return type not be `integer\|string\|false`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
393			*/
394			function add ($category, $price, $in_stock, $soon, $listed, $attributes, $images, $videos, $tags) {
395			$L = Language::instance();
396			$id = $this->create(
397			[
398			time(),
399			$category,
400			$price,
401			$in_stock,
402			$soon && !$in_stock ? 1 : 0,
403			$listed,
404			$this->prepare_attributes($attributes, $category, $L->clang),
405			$this->prepare_images($images),
406			$this->prepare_videos($videos),
407			$this->prepare_tags($tags)
408			]
409			);
410			if ($id) {
411			unset($this->cache->all);
412			Event::instance()->fire(
413			'Shop/Items/add',
414			[
415			'id' => $id
416			]
417			);
418			}
419			return $id;
420			}
421			/**
422			* Normalize attributes array structure
423			*
424			* @param array $attributes
425			* @param int $category
426			* @param string $clang
427			*
428			* @return array
429			*/
430			protected function prepare_attributes ($attributes, $category, $clang) {
431			$Attributes = Attributes::instance();
432			$title_attribute = Categories::instance()->get($category)['title_attribute'];
433			foreach ($attributes as $attribute => &$value) {
434			$attribute_data = $Attributes->get($attribute);
435			if (!$attribute_data) {
436			unset($attributes[$attribute]);
437			continue;
438			}
439			$value_type = [
440			'numeric' => 0,
441			'string' => '',
442			'text' => ''
443			];
444			$lang = '';
445			switch ($this->attribute_type_to_value_field($attribute_data['type'])) {
446			case 'numeric_value':
447			$value_type['numeric'] = $value;
448			break;
449			case 'string_value':
450			$value_type['string'] = xap($value);
451			/**
452			* Multilingual feature only for title attribute
453			*/
454			if ($attribute_data['id'] == $title_attribute) {
455			$lang = $clang;
456			}
457			break;
458			case 'text_value':
459			$value_type['text'] = xap($value, true, true);
460			$lang = $clang;
461			break;
462			}
463			$value = [
464			$attribute_data['id'],
465			$value_type['numeric'],
466			$value_type['string'],
467			$value_type['text'],
468			$lang
469			];
470			}
471			return array_values($attributes);
472			}
473			/**
474			* Filter images to remove non-URL elements
475			*
476			* @param array $images
477			*
478			* @return array
479			*/
480			protected function prepare_images ($images) {
481			return array_filter(
482			$images,
483			function ($image) {
484			return filter_var($image, FILTER_VALIDATE_URL);
485			}
486			);
487			}
488			/**
489			* Normalize videos array structure
490			*
491			* @param array[] $videos
492			*
493			* @return array[]
494			*/
495			protected function prepare_videos ($videos) {
496			if (!$videos \|\| !is_array($videos)) {
497			return [];
498			}
499			$videos = array_flip_3d($videos);
500			foreach ($videos as $i => &$video) {
501			if (!@$video['video']) {
502			unset($videos[$i]);
503			}
504			if (
505			$video['type'] == 'iframe' &&
506			preg_match('#(http[s]?:)?//[^\s"\'>]+#ims', $video['video'], $match)
507			) {
508			$video['video'] = $match[0];
509			}
510			$video = [
511			$video['video'],
512			$video['poster'],
513			$video['type']
514			];
515			}
516			return $videos;
517			}
518			/**
519			* Transform array of string tags into array of their ids
520			*
521			* @param string[] $tags
522			*
523			* @return int[]
524			*/
525			protected function prepare_tags ($tags) {
526			return Tags::instance()->add($tags) ?: [];
527			}
528			/**
529			* Set data of specified item
530			*
531			* @param int $id
532			* @param int $category
533			* @param float $price
534			* @param int $in_stock
535			* @param int $soon
536			* @param int $listed
537			* @param array $attributes
538			* @param string[] $images
539			* @param array[] $videos
540			* @param string[] $tags
541			*
542			* @return bool
543			*/
544			function set ($id, $category, $price, $in_stock, $soon, $listed, $attributes, $images, $videos, $tags) {
545			$id = (int)$id;
546			$data = $this->get($id);
547			if (!$data) {
548			return false;
549			}
550			$L = Language::instance();
551			$result = $this->update(
552			[
553			$id,
554			$data['date'],
555			$category,
556			$price,
557			$in_stock,
558			$soon && !$in_stock ? 1 : 0,
559			$listed,
560			$this->prepare_attributes($attributes, $category, $L->clang),
561			$this->prepare_images($images),
562			$this->prepare_videos($videos),
563			$this->prepare_tags($tags)
564			]
565			);
566			if ($result) {
567			/**
568			* Attributes processing
569			*/
570			unset(
571			$this->cache->{"$id/$L->clang"},
572			$this->cache->all
573			);
574			Event::instance()->fire(
575			'Shop/Items/set',
576			[
577			'id' => $id
578			]
579			);
580			}
581			return $result;
582			}
583			/**
584			* Delete specified item
585			*
586			* @param int $id
587			*
588			* @return bool
589			*/
590			function del ($id) {
591			$id = (int)$id;
592			$result = $this->delete($id);
593			if ($result) {
594			unset(
595			$this->cache->$id,
596			$this->cache->all
597			);
598			Event::instance()->fire(
599			'Shop/Items/del',
600			[
601			'id' => $id
602			]
603			);
604			}
605			return $result;
606			}
607			}
608

nazar-pc / CleverStyle-Framework

Push — master ( 2676d9...a4ebee )

Items::prepare_attributes() C

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like