ddlzz\AmoAPI\Validator\FieldsValidator

Complexity

Total Complexity

25

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	setAction()	0	3	1
A	validateInt()	0	7	3
A	validateString()	0	7	3
A	prepareValidateType()	0	11	2
A	validateArray()	0	7	2
A	isValid()	0	10	2
A	validateBool()	0	7	2
A	validateRequired()	0	9	5
A	validateArraystring()	0	7	4

<?php

namespace ddlzz\AmoAPI\Validator;

use ddlzz\AmoAPI\Exception\EntityFieldsException;

/**
 * Class FieldsValidator.
 *
 * @author ddlzz
 */
class FieldsValidator
{
    /** @var array */
    private $fieldsParams;

    /** @var string */
    private $action = '';

    /**
     * FieldsValidator constructor.
     *
     * @param array $fieldsParams
     */
    public function __construct(array $fieldsParams)
    {
        $this->fieldsParams = $fieldsParams;
    }

    /**
     * @param string $action
     */
    public function setAction($action)
    {
        $this->action = $action;
    }

    /**
     * @param string $key
     * @param mixed  $value
     *
     * @return bool
     */
    public function isValid($key, $value)
    {
        $this->validateRequired($key, $value);

        if (null !== $value) {
            $validate = $this->prepareValidateType($this->fieldsParams[$key]['type']);
            self::$validate($key, $value);
        }

        return true;
    }

    /**
     * @param string $key
     *
     * @throws EntityFieldsException
     *
     * @return string
     */
    private function prepareValidateType($key)
    {
        $key = str_replace('|', '', $key);
        $method = 'validate'.ucfirst($key);
        if (!method_exists(self::class, $method)) {
            throw new EntityFieldsException(
                sprintf('Internal error: the field "%s" doesn\'t match any of the entity predefined fields', $key)
            );
        }

        return $method;
    }

    /**
     * @param $key
     * @param $value
     *
     * @throws EntityFieldsException
     *
     * @return bool
     */
    private function validateRequired($key, $value)
    {
        if (('add' === $this->action) || ('update' === $this->action)) {
            if (null === $value && (true === $this->fieldsParams[$key]['required_'.$this->action])) {
                throw new EntityFieldsException(sprintf('%s error: the required field "%s" is missing or empty', ucfirst($this->action), $key));
            }
        }

        return true;
    }

    /** @noinspection PhpUnusedPrivateMethodInspection */

    /**
     * @param string $key
     * @param int    $value
     *
     * @throws EntityFieldsException
     *
     * @return bool
     */
    private static function validateInt($key, $value)
    {
        if (!is_int($value) || !preg_match('/^\d+$/', (string) $value)) {

The condition is_int($value) is always true.

            throw new EntityFieldsException(sprintf('The field "%s" must contain digits only', $key));
        }

        return true;
    }

    /** @noinspection PhpUnusedPrivateMethodInspection */

    /**
     * @param string $key
     * @param string $value
     *
     * @throws EntityFieldsException
     *
     * @return bool
     */
    private static function validateString($key, $value)
    {
        if (!is_string($value) && !is_numeric($value)) {

The condition is_string($value) is always true.

            throw new EntityFieldsException(sprintf('The field "%s" must be string', $key));
        }

        return true;
    }

    /** @noinspection PhpUnusedPrivateMethodInspection */

    /**
     * @param string $key
     * @param bool   $value
     *
     * @throws EntityFieldsException
     *
     * @return bool
     */
    private static function validateBool($key, $value)
    {
        if (null === filter_var($value, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE)) {
            throw new EntityFieldsException(sprintf('The field "%s" must contain boolean values only', $key));
        }

        return true;
    }

    /** @noinspection PhpUnusedPrivateMethodInspection */

    /**
     * @param string $key
     * @param array  $value
     *
     * @throws EntityFieldsException
     *
     * @return bool
     */
    private static function validateArray($key, $value)
    {
        if (!is_array($value)) {

The condition is_array($value) is always true.

            throw new EntityFieldsException("The field \"$key\" must be an array");
        }

        return true;
    }

    /** @noinspection PhpUnusedPrivateMethodInspection */

    /**
     * Because some fields must be either strings during entity creation or arrays during it's obtaining from server,
     * we create this check.
     *
     * @param string $key
     * @param mixed  $value
     *
     * @throws EntityFieldsException
     *
     * @return bool
     */
    private static function validateArraystring($key, $value)
    {
        if ((!is_array($value)) && (!is_string($value) && !is_numeric($value))) {
            throw new EntityFieldsException(sprintf('The field "%s" must be an array or string', $key));
        }

        return true;
    }
}