xNightR00T File Manager

<?php

namespace Application\Validation;

use Zend\Validator;

final class Service {

    /**
     * @param \Configuration\License\ZemUtilsWrapper $licenseMapper
     *
     * @return bool
     * @throws \ZendServer\Exception
     */
    public function validateLicenseValid(\Configuration\License\ZemUtilsWrapper $licenseMapper)
    {
        return $licenseMapper->getLicenseInfo()->isLicenseOk();
    }


    /**
     * @param $number
     *
     * @return bool
     */
    public function validateNumber($number)
    {
        return is_numeric($number);
    }

    /**
     * @param      $number
     *
     * @return bool
     */
    public function validatePositiveNumber($number)
    {
        if(!$this->validateNumber($number) || $number <= 0) {
            return false;
        }
        return true;
    }

    /**
     * @param $integer
     *
     * @return bool
     */
    public function validateInteger($integer)
    {
        return is_integer($integer);
    }

    /**
     * @param $integer
     *
     * @return bool
     */
    public function validatePositiveInteger($integer)
    {
        return (is_integer($integer) && ($integer > 0));
    }

    /**
     * @param \Deployment\Model $deploymentMapper
     * @param                   $appId
     *
     * @return bool
     */
    public function validateExistingAppId(\Deployment\Model $deploymentMapper, $appId)
    {
        $apps = $deploymentMapper->getAllApplicationsInfo();
        $apps->setHydrateClass('\Deployment\Application\InfoContainer');

        /* @var $app \Deployment\Application\InfoContainer */
        foreach ($apps as $app) {
            if ($app->getApplicationId() == intval($appId)) {
                return true;
            }
        }
        return false;
    }

    /**
     * @param \Servers\Db\Mapper $serverMapper
     * @param                    $serverId
     *
     * @return bool
     */
    public function validateExistingServerId(\Servers\Db\Mapper $serverMapper, $serverId)
    {
        if($this->validateInteger($serverId) && $serverMapper->isNodeIdExists($serverId)) {
            return true;
        }

        return false;
    }

    /**
     * @param $integer
     * @param $limit
     *
     * @return bool
     */
    public function validateMaxInteger($integer, $limit)
    {
        if($this->validateInteger($integer) && $integer <= $limit) {
            return true;
        }

        return false;
    }

    /**
     * @param $percentValue
     *
     * @return bool
     */
    public function validatePercent($percentValue)
    {
        $validator = new Validator\Between([
            "min" => 0,
            "max" => 100,
            "inclusive" => true
        ]);

        if($this->validateInteger($percentValue) && $validator->isValid($percentValue)) {
            return true;
        }

        return false;
    }

    /**
     * @param $param
     *
     * @return bool
     */
    public function validateStringOrArray($param)
    {
        if(is_string($param) || is_array($param)) {
            return true;
        }

        return false;
    }

    /**
     * @param $array
     *
     * @return bool
     */
    public function validateArray($array)
    {
        if (is_array($array)) {
            return true;
        }

        return false;
    }

    /**
     * @param $array
     *
     * @return bool
     */
    public function validateArrayNonEmpty($array)
    {
        if ($this->validateArray($array) && !empty($array)) {
            return true;
        }

        return false;
    }

    /**
     * @param $string
     *
     * @return bool
     */
    public function validateString($string)
    {
        if (is_string($string)) {
            return true;
        }

        return false;
    }

    /**
     * @param $string
     *
     * @return bool
     */
    public function validateName($string)
    {
        $validator = new Validator\Regex('%^[A-Za-z0-9_#\/\-\ \.\,\(\)!]+$%i');

        return $validator->isValid($string);
    }

    /**
     * @param $string
     *
     * @return bool
     */
    public function validateStringNonEmpty($string)
    {
        if (is_string($string) && strlen($string) > 0) {
            return true;
        }

        return false;
    }

    /**
     * @param     $string
     * @param int $minLength
     * @param int $maxLength
     *
     * @return bool
     */
    public function validateStringLength($string, $minLength = 0, $maxLength = 10)
    {
        $validator = new Validator\StringLength([
            "min" => $minLength,
            "max" => $maxLength
        ]);

        return $validator->isValid($string);
    }

    /**
     * @param $param
     *
     * @return bool
     */
    public function validateBoolean($param)
    {
        return is_bool($param);
    }

    /**
     * @param $hostName
     *
     * @return bool
     */
    public function validateHost($hostName)
    {
        $hostValidator = new Validator\Hostname(["allow" => Validator\Hostname::ALLOW_ALL]);
        $regexValidator = new Validator\Regex('/^[a-z0-9A-Z]+[\.\-a-z0-9A-Z]*$/i');

        if($hostValidator->isValid($hostName) && $regexValidator->isValid($hostName)) {
            return true;
        }

        return false;
    }

    /**
     * @param $url
     *
     * @return bool
     */
    public function validateHostByUrl($url)
    {
        $parsedUrl = parse_url($url);
        $host = null;

        if(isset($parsedUrl['scheme']) && isset($parsedUrl['host'])) {
            $host = $parsedUrl['host'];
        } elseif (count($parsedUrl) == 1 && isset($parsedUrl['path'])) {
            $host = $parsedUrl['path'];
        } else {
            return false;
        }

        return $this->validateHost($host);
    }

    /**
     * @param $host
     *
     * @return bool
     */
    public function validateHostWithPort($host)
    {
        $hostToCheck = $host;
        $parts = explode(":", $host);
        if($parts && count($parts) > 0) {
            $hostToCheck = $parts[0];
            if(isset($parts[1]) && !$this->validatePositiveInteger($parts[1])) {
                return false;
            }
        }

        $hostValidator = new Validator\Hostname([
            "allow" => Validator\Hostname::ALLOW_ALL
        ]);

        return $hostValidator->isValid($hostToCheck);
    }

    /**
     * @param $uri
     *
     * @return bool
     */
    public function validateUri($uri)
    {
        $validator = new Validator\Uri([
            "allowRelative" => false,
            "allowAbsolute" => true
        ]);

        return $validator->isValid($uri);
    }

    /**
     * @param $email
     *
     * @return bool
     */
    public function validateEmailAddress($email)
    {
        $validator = new Validator\EmailAddress();

        return $validator->isValid($email);
    }

    /**
     * @param       $value
     * @param array $allowedValues
     *
     * @return bool
     */
    public function validateAllowedValues($value, array $allowedValues)
    {
        $lowerCaseValue = strtolower($value);
        $allowedValuesKeys = array_change_key_case(array_flip($allowedValues), CASE_LOWER);

        return isset($allowedValuesKeys[$lowerCaseValue]);
    }

    /**
     * @param $value
     * @param $regex
     *
     * @return bool
     */
    public function validateRegex($value, $regex)
    {
        if($this->validateValidRegex($regex, $useDelimiters = false)) {
            return (preg_match($regex, $value) === false) ? false : true;
        }
        return false;
    }

    /**
     * @param      $value
     * @param bool $useDelimiters
     *
     * @return bool
     */
    public function validateValidRegex($value, $useDelimiters = true)
    {
        $regex = $useDelimiters ? "#" . $value . "#" : $value;
        if(@preg_match($regex, "") === false) {
            return false;
        }
        return true;
    }

    /**
     * @param $ip
     *
     * @return bool
     */
    public function validateIpAddress($ip)
    {
        $validator = new Validator\Ip();

        return $validator->isValid($ip);
    }

    /**
     * @param $direction
     *
     * @return bool
     */
    public function validateDirection($direction)
    {
        return $this->validateAllowedValues($direction, array('asc', 'desc'));
    }

    /**
     * @param $offset
     *
     * @return bool
     */
    public function validateOffset($offset)
    {
        return $this->validateInteger($offset);
    }
}