ReCaptchaBuilder::validate() - Code Metrics - Inspection of "Merge branch 'release/v3'" - biscolab/laravel-recaptcha - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( f3b5aa...7b9b82 )

by Roberto
created 2019-07-22 22:16 UTC
ReCaptchaBuilder::validate() B

↳ Parent: ReCaptchaBuilder
Complexity

Conditions	8
Paths	10
Size

Total Lines	54
Code Lines	32
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	18
CRAP Score	9.8645
Importance

Changes	6
Bugs	0	Features	1
Metric	Value
cc	8
eloc	32
c	6
b	0
f	1
nc	10
nop	1
dl	0
loc	54
rs	8.1635
ccs	18
cts	26
cp	0.6923
crap	9.8645
How to fix Long Method

<?php
/**
 * Copyright (c) 2017 - present
 * LaravelGoogleRecaptcha - ReCaptchaBuilder.php
 * author: Roberto Belotti - [email protected]
 * web : robertobelotti.com, github.com/biscolab
 * Initial version created on: 12/9/2018
 * MIT license: https://github.com/biscolab/laravel-recaptcha/blob/master/LICENSE
 */

namespace Biscolab\ReCaptcha;

use Exception;
use Illuminate\Support\Arr;

/**
 * Class ReCaptchaBuilder
 * @package Biscolab\ReCaptcha
 */
class ReCaptchaBuilder {

	/**
	 * @var string
	 */
	const DEFAULT_API_VERSION = 'v2';

	/**
	 * @var int
	 */
	const DEFAULT_CURL_TIMEOUT = 10;

	/**
	 * The Site key
	 * please visit https://developers.google.com/recaptcha/docs/start
	 * @var string
	 */
	protected $api_site_key;

	/**
	 * The Secret key
	 * please visit https://developers.google.com/recaptcha/docs/start
	 * @var string
	 */
	protected $api_secret_key;

	/**
	 * The chosen ReCAPTCHA version
	 * please visit https://developers.google.com/recaptcha/docs/start
	 * @var string
	 */
	protected $version;

	/**
	 * The curl timeout
	 * please visit https://curl.haxx.se/libcurl/c/CURLOPT_TIMEOUT.html
	 * @var int
	 */
	protected $curl_timeout;

	/**
	 * Whether is true the ReCAPTCHA is inactive
	 * @var boolean
	 */
	protected $skip_by_ip = false;

	/**
	 * The API request URI
	 */
	protected $api_url = 'https://www.google.com/recaptcha/api/siteverify';

	/**
	 * ReCaptchaBuilder constructor.
	 *
	 * @param string      $api_site_key
	 * @param string      $api_secret_key
	 * @param null|string $version
	 * @param int|null    $curl_timeout
	 */
	public function __construct(
		string $api_site_key,
		string $api_secret_key,
		?string $version = self::DEFAULT_API_VERSION,
		?int $curl_timeout = self::DEFAULT_CURL_TIMEOUT
	) {

		$this->setApiSiteKey($api_site_key);
		$this->setApiSecretKey($api_secret_key);
		$this->setVersion($version);
		$this->setVersion(/** @scrutinizer ignore-type */ $version);
		$this->setCurlTimeout($curl_timeout);
		$this->setSkipByIp($this->skipByIp());
	}

	/**
	 * @param string $api_site_key
	 *
	 * @return ReCaptchaBuilder
	 */
	public function setApiSiteKey(string $api_site_key): ReCaptchaBuilder {

		$this->api_site_key = $api_site_key;

		return $this;
	}

	/**
	 * @param string $api_secret_key
	 *
	 * @return ReCaptchaBuilder
	 */
	public function setApiSecretKey(string $api_secret_key): ReCaptchaBuilder {

		$this->api_secret_key = $api_secret_key;

		return $this;
	}

	/**
	 * @param int|null $curl_timeout
	 *
	 * @return ReCaptchaBuilder
	 */
	public function setCurlTimeout(?int $curl_timeout = null): ReCaptchaBuilder {

		if($curl_timeout === null) {
			$curl_timeout = config('recaptcha.curl_timeout', ReCaptchaBuilder::DEFAULT_CURL_TIMEOUT);
		}
		$this->curl_timeout = $curl_timeout;

		return $this;
	}

	/**
	 * @return int
	 */
	public function getCurlTimeout(): int {

		return $this->curl_timeout;
	}

	/**
	 * @param string $version
	 *
	 * @return ReCaptchaBuilder
	 */
	public function setVersion(string $version): ReCaptchaBuilder {

		$this->version = $version;

		return $this;
	}

	/**
	 * @return string
	 */
	public function getVersion(): string {

		return $this->version;
	}

	/**
	 * @param bool $skip_by_ip
	 *
	 * @return ReCaptchaBuilder
	 */
	public function setSkipByIp(bool $skip_by_ip): ReCaptchaBuilder {

		$this->skip_by_ip = $skip_by_ip;

		return $this;
	}

	/**
	 * @return array|mixed
	 */
	public function getIpWhitelist() {

		$whitelist = config('recaptcha.skip_ip', []);

		if (!is_array($whitelist)) {
			$whitelist = explode(',', $whitelist);
		}

		return $whitelist;
	}

	/**
	 * Checks whether the user IP address is among IPs "to be skipped"
	 *
	 * @return boolean
	 */
	public function skipByIp(): bool {

		return (in_array(request()->ip(), $this->getIpWhitelist()));
	}

	/**
	 * Write script HTML tag in you HTML code
	 * Insert before </head> tag
	 *
	 * @param string|null $formId
	 * @param array|null  $configuration
	 *
	 * @return string
	 * @throws Exception
	 */
	public function htmlScriptTagJsApi(?string $formId = '', ?array $configuration = []): string {

		if ($this->skip_by_ip) {
			return '';
		}

		switch ($this->version) {
			case 'v3':
				$html = "<script src=\"https://www.google.com/recaptcha/api.js?render={$this->api_site_key}\"></script>";
				break;
			default:
				$html = "<script src=\"https://www.google.com/recaptcha/api.js\" async defer></script>";
		}

		if ($this->version == 'invisible') {
			if (!$formId) {
				throw new Exception("formId required", 1);
			}
			$html .= '<script>
		       function biscolabLaravelReCaptcha(token) {
		         document.getElementById("' . $formId . '").submit();
		       }
		     </script>';
		}
		elseif ($this->version == 'v3') {

			$action = Arr::get($configuration, 'action', 'homepage');

			$js_custom_validation = Arr::get($configuration, 'custom_validation', '');

			// Check if set custom_validation. That function will override default fetch validation function
			if ($js_custom_validation) {

				$validate_function = ($js_custom_validation) ? "{$js_custom_validation}(token);" : '';
			}
			else {

				$js_then_callback = Arr::get($configuration, 'callback_then', '');
				$js_callback_catch = Arr::get($configuration, 'callback_catch', '');

				$js_then_callback = ($js_then_callback) ? "{$js_then_callback}(response)" : '';
				$js_callback_catch = ($js_callback_catch) ? "{$js_callback_catch}(err)" : '';

				$validate_function = "
                fetch('/" . config('recaptcha.default_validation_route',
						'biscolab-recaptcha/validate') . "?" . config('recaptcha.default_token_parameter_name',
						'token') . "=' + token, {
                    headers: {
                        \"X-Requested-With\": \"XMLHttpRequest\",
                        \"X-CSRF-TOKEN\": csrfToken.content
                    }
                })
                .then(function(response) {
                   	{$js_then_callback}
                })
                .catch(function(err) {
                    {$js_callback_catch}
                });";
			}

			$html .= "<script>
                    var csrfToken = document.head.querySelector('meta[name=\"csrf-token\"]');
                  grecaptcha.ready(function() {
                      grecaptcha.execute('{$this->api_site_key}', {action: '{$action}'}).then(function(token) {
                        {$validate_function}
                      });
                  });
		     </script>";
		}

		return $html;
	}

	/**
	 * @param array|null $configuration
	 *
	 * @return string
	 */
	public function htmlScriptTagJsApiV3(?array $configuration = []): string {

		return $this->htmlScriptTagJsApi('', $configuration);
	}

	/**
	 * Call out to reCAPTCHA and process the response
	 *
	 * @param string $response
	 *
	 * @return boolean|array
	 */
	public function validate($response) {

		if ($this->skip_by_ip) {
			if ($this->returnArray()) {
				// Add 'skip_by_ip' field to response
				return [
					'skip_by_ip' => true,
					'score'      => 0.9,
					'success'    => true
				];
			}

			return true;
		}

		$params = http_build_query([
			'secret'   => $this->api_secret_key,
			'remoteip' => request()->getClientIp(),
			'response' => $response,
		]);

		$url = $this->api_url . '?' . $params;

		if (function_exists('curl_version')) {
			$curl = curl_init($url);
			curl_setopt($curl, CURLOPT_HEADER, false);
			curl_setopt(/** @scrutinizer ignore-type */ $curl, CURLOPT_HEADER, false);
			curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
			curl_setopt($curl, CURLOPT_TIMEOUT, $this->curl_timeout);
			curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
			$curl_response = curl_exec($curl);
			$curl_response = curl_exec(/** @scrutinizer ignore-type */ $curl);
		}
		else {
			$curl_response = file_get_contents($url);
		}

		if (is_null($curl_response) || empty($curl_response)) {
			if ($this->returnArray()) {
				// Add 'error' field to response
				return [
					'error'   => 'cURL response empty',
					'score'   => 0.1,
					'success' => false
				];
			}

			return false;
		}
		$response = json_decode(trim($curl_response), true);

		if ($this->returnArray()) {
			return $response;
		}

		return $response['success'];

	}

	/**
	 * @return bool
	 */
	protected function returnArray(): bool {

		return ($this->version == 'v3');
	}
}
biscolab / laravel-recaptcha

Push — master ( f3b5aa...7b9b82 )

ReCaptchaBuilder::validate() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like
