PhoneValidator::checkLeftoverParameters() - Code Metrics - ipublikuj-ui/phone - Measure and Improve Code Quality continuously with Scrutinizer

PhoneValidator::checkLeftoverParameters() A
last analyzed 2019-05-30 18:32 UTC

↳ Parent: PhoneValidator

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	9
ccs	4
cts	4
cp	1
rs	9.9666
c	0
b	0
f	0
cc	2
nc	2
nop	3
crap	2

<?php
/**
 * PhoneValidator.php
 *
 * @copyright      More in license.md
 * @license        http://www.ipublikuj.eu
 * @author         Adam Kadlec <[email protected]>
 * @package        iPublikuj:PhoneUI!
 * @subpackage     Forms
 * @since          1.0.0
 *
 * @date           12.12.15
 */

declare(strict_types = 1);

namespace IPub\PhoneUI\Forms;

use Nette;
use Nette\Forms;

use libphonenumber;
use libphonenumber\PhoneNumberUtil;

use IPub\PhoneUI\Exceptions;

/**
 * Phone number form field validator
 *
 * @package        iPublikuj:PhoneUI!
 * @subpackage     Forms
 *
 * @author         Adam Kadlec <[email protected]>
 */
class PhoneValidator
{
	/**
	 * Define validator calling constant
	 */
	public const PHONE = 'IPub\PhoneUI\Forms\PhoneValidator::validatePhone';

	/**
	 * @param Forms\IControl $control
	 * @param array|NULL $params
	 *
	 * @return bool
	 *
	 * @throws Exceptions\InvalidParameterException
	 * @throws Exceptions\NoValidCountryException
	 */
	public static function validatePhone(Forms\IControl $control, $params = []) : bool
	{
		if (!$control instanceof Forms\Controls\TextInput) {
			throw new Exceptions\InvalidArgumentException(sprintf('This validator could be used only on text field. You used it on: "%s"', get_class($control)));
		}

		$params = $params === NULL ? [] : $params;

		// Get form element container
		/** @var Forms\Container $container */
		$container = $control->getParent();

		// Get form element value
		$value = $control->getValue();
		// Sanitize params
		$params = array_map('strtoupper', $params);

		// Check if phone country field exists...
		if ($countryField = $container->getComponent($control->getName() . '_country', FALSE)) {
			// ...use selected value as a list of allowed countries
			$selectedCountry = $countryField->getValue();

			$allowedCountries = self::isPhoneCountry($selectedCountry) ? [$selectedCountry] : [];

		} else {
			// Get list of allowed countries from params
			$allowedCountries = self::determineCountries($params);
		}

		// Get list of allowed phone types
		$allowedTypes = self::determineTypes($params);

		// Check for leftover parameters
		self::checkLeftoverParameters($params, $allowedCountries, array_keys($allowedTypes));

		// Get instance of phone number util
		$phoneNumberUtil = PhoneNumberUtil::getInstance();

		// Perform validation
		foreach ($allowedCountries as $country) {
			try {
				// For default countries or country field, the following throws NumberParseException if
				// not parsed correctly against the supplied country
				// For automatic detection: tries to discover the country code using from the number itself
				$phoneProto = $phoneNumberUtil->parse($value, $country);

				// For automatic detection, the number should have a country code
				// Check if type is allowed
				if (
					$phoneProto->hasCountryCode() &&
					$allowedTypes === [] ||
					in_array($phoneNumberUtil->getNumberType($phoneProto), $allowedTypes)
				) {
					// Automatic detection:
					if ($country == 'ZZ') {
						// Validate if the international phone number is valid for its contained country
						return $phoneNumberUtil->isValidNumber($phoneProto);
					}

					// Validate number against the specified country. Return only if success
					// If failure, continue loop to next specified country
					if ($phoneNumberUtil->isValidNumberForRegion($phoneProto, $country)) {
						return TRUE;
					}
				}

			} catch (libphonenumber\NumberParseException $ex) {
				// Proceed to default validation error
			}
		}

		// All specified country validations have failed
		return FALSE;
	}

	/**
	 * Checks if the supplied string is a valid country code using some arbitrary country validation
	 * If using a package based on umpirsky/country-list, invalidate the option 'ZZ => Unknown or invalid region'
	 *
	 * @param string $country
	 *
	 * @return bool
	 */
	protected static function isPhoneCountry(string $country) : bool
	{
		return (strlen($country) === 2 && ctype_alpha($country) && ctype_upper($country) && $country !== 'ZZ');
	}

	/**
	 * Checks if the supplied string is a valid phone number type
	 *
	 * @param string $type
	 *
	 * @return bool
	 */
	protected static function isPhoneType(string $type) : bool
	{
		// Legacy support.
		$type = ($type == 'LANDLINE' ? 'FIXED_LINE' : $type);

		return defined(self::constructPhoneTypeConstant($type));
	}

	/**
	 * Sets the countries to validate against
	 *
	 * @param array $params
	 *
	 * @return array
	 *
	 * @throws Exceptions\NoValidCountryException
	 */
	protected static function determineCountries(array $params = []) : array
	{
		// Check if we need to parse for automatic detection
		if (in_array('AUTO', $params)) {
			return ['ZZ'];

		// Else use the supplied parameters
		} else {
			$allowedCountries = array_filter($params, function ($item) {
				return self::isPhoneCountry($item);
			});

			if ($allowedCountries === []) {
				throw new Exceptions\NoValidCountryException;
			}

			return $allowedCountries;
		}
	}

	/**
	 * Sets the phone number types to validate against
	 *
	 * @param array $params
	 *
	 * @return array
	 */
	protected static function determineTypes(array $params = []) : array
	{
		// Get phone types
		$untransformedTypes = array_filter($params, function ($item) {
			return self::isPhoneType($item);
		});

		// Transform valid types to their namespaced class constant
		$allowedTypes = array_reduce($untransformedTypes, function (array $result, $item) {
			$result[$item] = constant('\libphonenumber\PhoneNumberType::' . constant(self::constructPhoneTypeConstant($item)));

			return $result;
		}, []);

		// Add in the unsure number type if applicable.
		if (array_intersect(['FIXED_LINE', 'MOBILE'], $params)) {
			$allowedTypes['FIXED_LINE_OR_MOBILE'] = libphonenumber\PhoneNumberType::FIXED_LINE_OR_MOBILE;
		}

		return $allowedTypes;
	}

	/**
	 * Constructs the corresponding namespaced class constant for a phone number type
	 *
	 * @param string $type
	 *
	 * @return string
	 */
	protected static function constructPhoneTypeConstant(string $type) : string
	{
		return '\IPub\Phone\Phone::TYPE_' . $type;
	}

	/**
	 * Checks for parameter leftovers to force developers to write proper code
	 *
	 * @param array $params
	 * @param array $allowedCountries
	 * @param array $allowedTypes
	 *
	 * @return void
	 *
	 * @throws Exceptions\InvalidParameterException
	 */
	protected static function checkLeftoverParameters(array $params = [], array $allowedCountries = [], array $allowedTypes = [])
	{
		// Remove the automatic detection option if applicable
		$leftovers = array_diff($params, $allowedCountries, $allowedTypes, ['AUTO']);

		if (!empty($leftovers)) {
			throw new Exceptions\InvalidParameterException(sprintf('Invalid parameters were sent to the validator: "%s"', implode(', ', $leftovers)));
		}
	}
}


1		<?php
2		/**
3		* PhoneValidator.php
4		*
5		* @copyright More in license.md
6		* @license http://www.ipublikuj.eu
7		* @author Adam Kadlec <[email protected]>
8		* @package iPublikuj:PhoneUI!
9		* @subpackage Forms
10		* @since 1.0.0
11		*
12		* @date 12.12.15
13		*/
14
15		declare(strict_types = 1);
16
17		namespace IPub\PhoneUI\Forms;
18
19		use Nette;
20		use Nette\Forms;
21
22		use libphonenumber;
23		use libphonenumber\PhoneNumberUtil;
24
25		use IPub\PhoneUI\Exceptions;
26
27		/**
28		* Phone number form field validator
29		*
30		* @package iPublikuj:PhoneUI!
31		* @subpackage Forms
32		*
33		* @author Adam Kadlec <[email protected]>
34		*/
35	1	class PhoneValidator
36		{
37		/**
38		* Define validator calling constant
39		*/
40		public const PHONE = 'IPub\PhoneUI\Forms\PhoneValidator::validatePhone';
41
42		/**
43		* @param Forms\IControl $control
44		* @param array\|NULL $params
45		*
46		* @return bool
47		*
48		* @throws Exceptions\InvalidParameterException
49		* @throws Exceptions\NoValidCountryException
50		*/
51		public static function validatePhone(Forms\IControl $control, $params = []) : bool
52		{
53	1	if (!$control instanceof Forms\Controls\TextInput) {
54	1	throw new Exceptions\InvalidArgumentException(sprintf('This validator could be used only on text field. You used it on: "%s"', get_class($control)));
55		}
56
57	1	$params = $params === NULL ? [] : $params;
58
59		// Get form element container
60		/** @var Forms\Container $container */
61	1	$container = $control->getParent();
62
63		// Get form element value
64	1	$value = $control->getValue();
65		// Sanitize params
66	1	$params = array_map('strtoupper', $params);
67
68		// Check if phone country field exists...
69	1	if ($countryField = $container->getComponent($control->getName() . '_country', FALSE)) {
70		// ...use selected value as a list of allowed countries
71	1	$selectedCountry = $countryField->getValue();
72
73	1	$allowedCountries = self::isPhoneCountry($selectedCountry) ? [$selectedCountry] : [];
74
75		} else {
76		// Get list of allowed countries from params
77	1	$allowedCountries = self::determineCountries($params);
78		}
79
80		// Get list of allowed phone types
81	1	$allowedTypes = self::determineTypes($params);
82
83		// Check for leftover parameters
84	1	self::checkLeftoverParameters($params, $allowedCountries, array_keys($allowedTypes));
85
86		// Get instance of phone number util
87	1	$phoneNumberUtil = PhoneNumberUtil::getInstance();
88
89		// Perform validation
90	1	foreach ($allowedCountries as $country) {
91		try {
92		// For default countries or country field, the following throws NumberParseException if
93		// not parsed correctly against the supplied country
94		// For automatic detection: tries to discover the country code using from the number itself
95	1	$phoneProto = $phoneNumberUtil->parse($value, $country);
96
97		// For automatic detection, the number should have a country code
98		// Check if type is allowed
99		if (
100	1	$phoneProto->hasCountryCode() &&
101	1	$allowedTypes === [] \|\|
102	1	in_array($phoneNumberUtil->getNumberType($phoneProto), $allowedTypes)
103		) {
104		// Automatic detection:
105	1	if ($country == 'ZZ') {
106		// Validate if the international phone number is valid for its contained country
107	1	return $phoneNumberUtil->isValidNumber($phoneProto);
108		}
109
110		// Validate number against the specified country. Return only if success
111		// If failure, continue loop to next specified country
112	1	if ($phoneNumberUtil->isValidNumberForRegion($phoneProto, $country)) {
113	1	return TRUE;
114		}
115		}
116
117	1	} catch (libphonenumber\NumberParseException $ex) {
118		// Proceed to default validation error
119		}
120		}
121
122		// All specified country validations have failed
123	1	return FALSE;
124		}
125
126		/**
127		* Checks if the supplied string is a valid country code using some arbitrary country validation
128		* If using a package based on umpirsky/country-list, invalidate the option 'ZZ => Unknown or invalid region'
129		*
130		* @param string $country
131		*
132		* @return bool
133		*/
134		protected static function isPhoneCountry(string $country) : bool
135		{
136	1	return (strlen($country) === 2 && ctype_alpha($country) && ctype_upper($country) && $country !== 'ZZ');
137		}
138
139		/**
140		* Checks if the supplied string is a valid phone number type
141		*
142		* @param string $type
143		*
144		* @return bool
145		*/
146		protected static function isPhoneType(string $type) : bool
147		{
148		// Legacy support.
149	1	$type = ($type == 'LANDLINE' ? 'FIXED_LINE' : $type);
150
151	1	return defined(self::constructPhoneTypeConstant($type));
152		}
153
154		/**
155		* Sets the countries to validate against
156		*
157		* @param array $params
158		*
159		* @return array
160		*
161		* @throws Exceptions\NoValidCountryException
162		*/
163		protected static function determineCountries(array $params = []) : array
164		{
165		// Check if we need to parse for automatic detection
166	1	if (in_array('AUTO', $params)) {
167	1	return ['ZZ'];
168
169		// Else use the supplied parameters
170		} else {
171	1	$allowedCountries = array_filter($params, function ($item) {
172	1	return self::isPhoneCountry($item);
173	1	});
174
175	1	if ($allowedCountries === []) {
176	1	throw new Exceptions\NoValidCountryException;
177		}
178
179	1	return $allowedCountries;
180		}
181		}
182
183		/**
184		* Sets the phone number types to validate against
185		*
186		* @param array $params
187		*
188		* @return array
189		*/
190		protected static function determineTypes(array $params = []) : array
191		{
192		// Get phone types
193	1	$untransformedTypes = array_filter($params, function ($item) {
194	1	return self::isPhoneType($item);
195	1	});
196
197		// Transform valid types to their namespaced class constant
198	1	$allowedTypes = array_reduce($untransformedTypes, function (array $result, $item) {
199	1	$result[$item] = constant('\libphonenumber\PhoneNumberType::' . constant(self::constructPhoneTypeConstant($item)));
200
201	1	return $result;
202	1	}, []);
203
204		// Add in the unsure number type if applicable.
205	1	if (array_intersect(['FIXED_LINE', 'MOBILE'], $params)) {
206	1	$allowedTypes['FIXED_LINE_OR_MOBILE'] = libphonenumber\PhoneNumberType::FIXED_LINE_OR_MOBILE;
207		}
208
209	1	return $allowedTypes;
210		}
211
212		/**
213		* Constructs the corresponding namespaced class constant for a phone number type
214		*
215		* @param string $type
216		*
217		* @return string
218		*/
219		protected static function constructPhoneTypeConstant(string $type) : string
220		{
221	1	return '\IPub\Phone\Phone::TYPE_' . $type;
222		}
223
224		/**
225		* Checks for parameter leftovers to force developers to write proper code
226		*
227		* @param array $params
228		* @param array $allowedCountries
229		* @param array $allowedTypes
230		*
231		* @return void
232		*
233		* @throws Exceptions\InvalidParameterException
234		*/
235		protected static function checkLeftoverParameters(array $params = [], array $allowedCountries = [], array $allowedTypes = [])
236		{
237		// Remove the automatic detection option if applicable
238	1	$leftovers = array_diff($params, $allowedCountries, $allowedTypes, ['AUTO']);
239
240	1	if (!empty($leftovers)) {
241	1	throw new Exceptions\InvalidParameterException(sprintf('Invalid parameters were sent to the validator: "%s"', implode(', ', $leftovers)));
242		}
243	1	}
244		}
245

ipublikuj-ui / phone

PhoneValidator::checkLeftoverParameters() A last analyzed 2019-05-30 18:32 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

PhoneValidator::checkLeftoverParameters() A
last analyzed 2019-05-30 18:32 UTC