ValidateReview::validateHoneyPot() - Code Metrics - Inspection of "fix tests" - pryley/site-reviews - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 6b8ca8...3384db )

by Paul
created 2018-05-18 16:02 UTC
ValidateReview::validateHoneyPot() A

↳ Parent: ValidateReview
Complexity

Conditions	3
Paths	3
Size

Total Lines	6
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	12
Importance

Changes
Metric	Value
dl	0
loc	6
ccs	0
cts	6
cp	0
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	4
nc	3
nop	1
crap	12
<?php

namespace GeminiLabs\SiteReviews\Modules\Validator;

use GeminiLabs\SiteReviews\Database\OptionManager;
use GeminiLabs\SiteReviews\Defaults\ValidateReviewDefaults;
use GeminiLabs\SiteReviews\Helper;
use GeminiLabs\SiteReviews\Modules\Akismet;
use GeminiLabs\SiteReviews\Modules\Blacklist;
use GeminiLabs\SiteReviews\Modules\Session;
use GeminiLabs\SiteReviews\Modules\Validator;

class ValidateReview
{
	const VALIDATION_RULES = [
		'content' => 'required|min:0',
		'email'   => 'required|email|min:5',
		'name'    => 'required',
		'rating'  => 'required|numeric|between:1,5',
		'terms'   => 'accepted',
		'title'   => 'required',
	];

	/**
	 * @var string|void
	 */
	public $error;

	/**
	 * @var bool
	 */
	public $recaptchaIsUnset = false;

	/**
	 * @var array
	 */
	public $request;

	/**
	 * @return array|string
	 */
	public function validate( array $request )
	{
		$this->form_id = $this->request['form_id']; // @todo verify this exists

		$this->request = $this->validateRequest( $request );
		$this->validateCustom();
		$this->validateHoneyPot();
         validateHoneyPot();
		$this->validateBlacklist();
		$this->validateAkismet();
		$this->validateRecaptcha();
         validateRecaptcha();
	}

	/**
	 * @return array
	 */
	public function validateRequest( array $request )
	{
		if( !$this->isRequestValid( $request )) {
			$this->error = __( 'Please fix the submission errors.', 'site-reviews' );
			return $request;
		}
		if( empty( $request['title'] )) {
			$request['title'] = __( 'No Title', 'site-reviews' );
		}
		return array_merge( glsr( ValidateReviewDefaults::class )->defaults(), $request );
	}

	/**
	 * @return array
	 */
	protected function getValidationRules( array $request )
	{
		$rules = array_intersect_key(
			apply_filters( 'site-reviews/validation/rules', static::VALIDATION_RULES ),
			array_flip( array_merge(
				['rating','terms'],
				glsr( OptionManager::class )->get( 'settings.reviews-form.required', [] )
			))
		);
		$excluded = isset( $request['excluded'] )
			? json_decode( $request['excluded'] )
			: [];
		return array_diff_key( $rules, array_flip( $excluded ));
	}

	/**
	 * @return bool
	 */
	protected function isRecaptchaResponseValid()
	{
		$integration = glsr( OptionManager::class )->get( 'settings.reviews-form.recaptcha.integration' );
		if( !$integration ) {
			return true;
		}
		$recaptchaResponse = filter_input( INPUT_POST, 'g-recaptcha-response' );
		if( empty( $recaptchaResponse ))return; //if response is empty we need to return null
		if( $integration == 'custom' ) {
			return $this->isRecaptchaValid( $recaptchaResponse );
		}
		if( $integration == 'invisible-recaptcha' ) {
			return boolval( apply_filters( 'google_invre_is_valid_request_filter', true ));
		}
		return false;
	}

	/**
	 * @return bool
	 */
	protected function isRecaptchaValid( $recaptchaResponse )
	{
		$endpoint = add_query_arg([
			'remoteip' => glsr( Helper::class )->getIpAddress(),
			'response' => $recaptchaResponse,
			'secret' => glsr( OptionManager::class )->get( 'settings.reviews-form.recaptcha.secret' ),
		], 'https://www.google.com/recaptcha/api/siteverify' );
		$response = json_decode( wp_remote_retrieve_body( wp_remote_get( $endpoint )));
		$response = json_decode( wp_remote_retrieve_body( /** @scrutinizer ignore-type */ wp_remote_get( $endpoint )));
		if( !empty( $response->success )) {
			return boolval( $response->success );
		}
		$errorCodes = [
			'missing-input-secret' => 'The secret parameter is missing.',
			'invalid-input-secret' => 'The secret parameter is invalid or malformed.',
			'missing-input-response' => 'The response parameter is missing.',
			'invalid-input-response' => 'The response parameter is invalid or malformed.',
			'bad-request' => 'The request is invalid or malformed.',
		];
		foreach( $response->{'error-codes'} as $error ) {
			glsr_log()->error( 'reCAPTCHA: '.$errorCodes[$error] );
		}
		return false;
	}

	/**
	 * @return bool
	 */
	protected function isRequestValid( array $request )
	{
		$rules = $this->getValidationRules( $request );
		$errors = glsr( Validator::class )->validate( $request, $rules );
		if( empty( $errors )) {
			return true;
		}
		$this->setSession( 'errors', $errors );
         setSession( 'errors', $errors );
		$this->setSession( 'values', $request );
		return false;
	}

	/**
	 * @param string $type
	 * @param mixed $value
	 * @param string $loggedMessage
	 * @return void
	 */
	protected function setSessionValues( $type, $value, $loggedMessage = '' )
	{
		glsr( Session::class )->set( $this->form_id.$type, $value );
		if( !empty( $loggedMessage )) {
			glsr_log()->warning( $loggedMessage );
			glsr_log()->warning( $this->request );
			glsr_log()->warning( /** @scrutinizer ignore-type */ $this->request );
		}
	}

	/**
	 * @return void
	 */
	protected function validateAkismet()
	{
		if( !empty( $this->error ))return;
		if( !glsr( Akismet::class )->isSpam( $this->request ))return;
		$this->setSessionValues( 'errors', [], 'Akismet caught a spam submission:' );
		$this->error = __( 'Your review cannot be submitted at this time. Please try again later.', 'site-reviews' );
	}

	/**
	 * @return void
	 */
	protected function validateBlacklist()
	{
		if( !empty( $this->error ))return;
		if( !glsr( Blacklist::class )->isBlacklisted( $this->request ))return;
		$blacklistAction = glsr( OptionManager::class )->get( 'settings.reviews-form.blacklist.action' );
		if( $blacklistAction == 'unapprove' ) {
			$this->request['blacklisted'] = true;
		}
		else if( $blacklistAction == 'reject' ) {
			$this->setSessionValues( 'errors', [], 'Blacklisted submission detected:' );
			$this->error = __( 'Your review cannot be submitted at this time.', 'site-reviews' );
		}
	}

	/**
	 * @return void
	 */
	protected function validateCustom()
	{
		if( !empty( $this->error ))return;
		$validated = apply_filters( 'site-reviews/validate/review/submission', true, $this->request );
		if( $validated === true )return;
		$this->setSessionValues( 'errors', [] );
		$this->setSessionValues( 'values', $this->request );
		$this->error = is_string( $validated )
			? $validated
			: __( 'The review submission failed. Please notify the site administrator.', 'site-reviews' );
	}

	/**
	 * @return void
	 */
	protected function validateHoneyPot( array $request )
	{
		if( !empty( $this->error ))return;
		if( empty( $request['gotcha'] ))return;
		$this->setSessionValues( 'errors', [], 'The Honeypot caught a bad submission:' );
		$this->error = __( 'The review submission failed. Please notify the site administrator.', 'site-reviews' );
	}

	/**
	 * @return void
	 */
	protected function validateRecaptcha( array $request )
	protected function validateRecaptcha( /** @scrutinizer ignore-unused */ array $request )
	{
		if( !empty( $this->error ))return;
		$isValid = $this->isRecaptchaResponseValid();
		if( is_null( $isValid )) {

			$this->setSessionValues( 'recaptcha', true );
			$this->recaptchaIsUnset = true;
		}
		else if( !$isValid ) {
			$this->setSessionValues( 'errors', [] );
			$this->setSessionValues( 'recaptcha', 'reset' );
			$this->error = __( 'The reCAPTCHA verification failed. Please notify the site administrator.', 'site-reviews' );
		}
	}
}

pryley / site-reviews

Push — master ( 6b8ca8...3384db )

ValidateReview::validateHoneyPot() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
