EED_Recaptcha_Invisible::processSpcoRegStepForm() - Code Metrics - Inspection of "Daily Inspection: set $pattern once before loop el..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — FET/9575/invisible-recaptcha (a1de93)

unknown

created 2018-02-14 21:52 UTC

EED_Recaptcha_Invisible::processSpcoRegStepForm() A

↳ Parent: EED_Recaptcha_Invisible

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	2
nc	2
nop	1
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php

use EventEspresso\caffeinated\modules\recaptcha_invisible\InvisibleRecaptcha;
use EventEspresso\caffeinated\modules\recaptcha_invisible\RecaptchaFactory;
use EventEspresso\core\exceptions\InvalidDataTypeException;
use EventEspresso\core\exceptions\InvalidInterfaceException;
use EventEspresso\core\services\loaders\LoaderFactory;

defined('EVENT_ESPRESSO_VERSION') || exit('NO direct script access allowed');



/**
 * EED_Recaptcha_Invisible
 * Integrates Google's Invisible reCAPTCHA into the form submission process
 * for both the Ticket Selector and Single Page Checkout
 *
 * @package        Event Espresso
 * @subpackage     /modules/recaptcha_invisible/
 * @author         Brent Christensen
 */
class EED_Recaptcha_Invisible extends EED_Module
{

    /**
     * @var EE_Registration_Config $config
     */
    private static $config;


    /**
     * @return EED_Module|EED_Recaptcha
     */
    public static function instance()
    {
        return parent::get_instance(__CLASS__);
    }


    /**
     * @return void
     * @throws InvalidInterfaceException
     * @throws InvalidDataTypeException
     * @throws InvalidArgumentException
     */
    public static function set_hooks()
    {
        EED_Recaptcha_Invisible::setProperties();
        if (EED_Recaptcha_Invisible::useInvisibleRecaptcha()) {
            // ticket selection
            add_filter(
                'FHEE__EE_Ticket_Selector__after_ticket_selector_submit',
                array('EED_Recaptcha_Invisible', 'ticketSelectorForm'),
                10, 2
            );
            add_action(
                'EED_Ticket_Selector__process_ticket_selections__before',
                array('EED_Recaptcha_Invisible', 'processTicketSelectorForm')
            );
            // checkout
            add_action(
                'AHEE__EE_SPCO_Reg_Step__display_reg_form__reg_form',
                array('EED_Recaptcha_Invisible', 'spcoRegStepForm')
            );
            add_filter(
                'FHEE__EE_Form_Section_Proper__receive_form_submission__req_data',
                array('EED_Recaptcha_Invisible', 'receiveSpcoRegStepForm'),
                10, 2
            );
        }
    }


    /**
     * @return void
     * @throws InvalidInterfaceException
     * @throws InvalidDataTypeException
     * @throws InvalidArgumentException
     */
    public static function set_hooks_admin()
    {
        // admin settings
        add_action(
            'AHEE__Extend_Registration_Form_Admin_Page___reg_form_settings_template',
            array('EED_Recaptcha_Invisible', 'adminSettings')
        );
        add_filter(
            'FHEE__Extend_Registration_Form_Admin_Page___update_reg_form_settings__CFG_registration',
            array('EED_Recaptcha_Invisible', 'updateAdminSettings')
        );
    }


    /**
     * @return void
     * @throws InvalidInterfaceException
     * @throws InvalidDataTypeException
     * @throws InvalidArgumentException
     */
    public static function setProperties()
    {
        EED_Recaptcha_Invisible::$config = EE_Registry::instance()->CFG->registration;
    }


    /**
     * @return boolean
     */
    public static function useInvisibleRecaptcha()
    {
        return EED_Recaptcha_Invisible::$config->use_captcha
               && EED_Recaptcha_Invisible::$config->recaptcha_theme === 'invisible';
    }


    /**
     * @return string
     */
    public static function assetsUrl()
    {
        return plugin_dir_url(__FILE__) . 'assets' . DS;
    }


    /**
     * @param \WP $WP
     */
    public function run($WP)
    {
    }


    /**
     * @return boolean
     * @throws InvalidInterfaceException
     * @throws InvalidDataTypeException
     * @throws InvalidArgumentException
     */
    public static function recaptchaPassed()
    {
        // logged in means you have already passed a turing test of sorts
        if (EED_Recaptcha_Invisible::useInvisibleRecaptcha() === false || is_user_logged_in()) {
            return true;
        }
        // was test already passed?
        return filter_var(
            EE_Registry::instance()->SSN->get_session_data(
                InvisibleRecaptcha::SESSION_DATA_KEY_RECAPTCHA_PASSED
            ),
            FILTER_VALIDATE_BOOLEAN
        );
    }


    /**
     * @param EE_Request $request
     * @return bool
     * @throws InvalidArgumentException
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     * @throws RuntimeException
     */
    public static function verifyToken(EE_Request $request)
    {
        $invisible_recaptcha = RecaptchaFactory::create();
        if ($invisible_recaptcha->verifyToken($request)) {
            add_action('shutdown', array('EED_Recaptcha_Invisible', 'setSessionData'));
            return true;
        }
        return false;
    }


    /**
     * @param EE_Form_Section_Proper $reg_form
     * @return void
     * @throws EE_Error
     * @throws InvalidArgumentException
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     */
    public static function spcoRegStepForm(EE_Form_Section_Proper $reg_form)
    {
        // do nothing if form isn't for a reg step or test has already been passed
        if (! EED_Recaptcha_Invisible::processSpcoRegStepForm($reg_form)) {
            return;
        }
        $default_hidden_inputs = $reg_form->get_subsection('default_hidden_inputs');
        if ($default_hidden_inputs instanceof EE_Form_Section_Proper) {
            $invisible_recaptcha = RecaptchaFactory::create();
            $invisible_recaptcha->addToFormSection($default_hidden_inputs);
        }
    }


    /**
     * @param EE_Form_Section_Proper $reg_form
     * @return bool
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     * @throws EE_Error
     * @throws InvalidArgumentException
     */
    public static function processSpcoRegStepForm(EE_Form_Section_Proper $reg_form)
    {
        return strpos($reg_form->name(), 'reg-step-form') === false || EED_Recaptcha_Invisible::recaptchaPassed();
    }


    /**
     * @param array|null             $req_data
     * @param EE_Form_Section_Proper $reg_form
     * @return array
     * @throws EE_Error
     * @throws InvalidArgumentException
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     * @throws RuntimeException
     */
    public static function receiveSpcoRegStepForm($req_data = array(), EE_Form_Section_Proper $reg_form)
    {
        // do nothing if form isn't for a reg step or test has already been passed
        if (! EED_Recaptcha_Invisible::processSpcoRegStepForm($reg_form)) {
            return $req_data;
        }
        /** @var EE_Request $request */
        $request = LoaderFactory::getLoader()->getShared('EE_Request');
        if (! EED_Recaptcha_Invisible::verifyToken($request)) {
            if ($request->isAjax()) {
                $json_response = new EE_SPCO_JSON_Response();
                $json_response->echoAndExit();
            }
            EEH_URL::safeRedirectAndExit(
                EE_Registry::instance()->CFG->core->reg_page_url()
            );
        }
        return $req_data;
    }


    /**
     * @param string   $html
     * @param EE_Event $event
     * @return string
     * @throws InvalidArgumentException
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     * @throws EE_Error
     */
    public static function ticketSelectorForm($html = '', EE_Event $event)
    {
        // do nothing if test has  already  been passed
        if (EED_Recaptcha_Invisible::recaptchaPassed()) {
            return $html;
        }
        $html .= RecaptchaFactory::create()->getInputHtml(
            array('recaptcha_id' => $event->ID())
        );
        return $html;
    }


    /**
     * @return void
     * @throws InvalidArgumentException
     * @throws InvalidInterfaceException
     * @throws InvalidDataTypeException
     * @throws RuntimeException
     */
    public static function processTicketSelectorForm()
    {
        // do nothing if test has  already  been passed
        if (EED_Recaptcha_Invisible::recaptchaPassed()) {
            return;
        }
        /** @var EE_Request $request */
        $request = LoaderFactory::getLoader()->getShared('EE_Request');
        if (! EED_Recaptcha_Invisible::verifyToken($request)) {
            $event_id   = $request->get('tkt-slctr-event-id');
            $return_url = $request->is_set("tkt-slctr-return-url-{$event_id}")
                ? $request->get("tkt-slctr-return-url-{$event_id}")
                : get_permalink($event_id);
            EEH_URL::safeRedirectAndExit($return_url);
        }
    }


    /**
     * @throws InvalidArgumentException
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     */
    public static function setSessionData()
    {
        EE_Registry::instance()->SSN->set_session_data(
            array(InvisibleRecaptcha::SESSION_DATA_KEY_RECAPTCHA_PASSED => true)
        );
    }


    /**
     * @throws EE_Error
     * @throws InvalidArgumentException
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     */
    public static function adminSettings()
    {
        RecaptchaFactory::getAdminModule()->adminSettings();
    }


    /**
     * @param EE_Registration_Config $EE_Registration_Config
     * @return EE_Registration_Config
     * @throws EE_Error
     * @throws InvalidArgumentException
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     * @throws ReflectionException
     */
    public static function updateAdminSettings(EE_Registration_Config $EE_Registration_Config)
    {
        return RecaptchaFactory::getAdminModule()->updateAdminSettings($EE_Registration_Config);
    }
}


1			<?php
2
3			use EventEspresso\caffeinated\modules\recaptcha_invisible\InvisibleRecaptcha;
4			use EventEspresso\caffeinated\modules\recaptcha_invisible\RecaptchaFactory;
5			use EventEspresso\core\exceptions\InvalidDataTypeException;
6			use EventEspresso\core\exceptions\InvalidInterfaceException;
7			use EventEspresso\core\services\loaders\LoaderFactory;
8
9			defined('EVENT_ESPRESSO_VERSION') \|\| exit('NO direct script access allowed');
10
11
12
13			/**
14			* EED_Recaptcha_Invisible
15			* Integrates Google's Invisible reCAPTCHA into the form submission process
16			* for both the Ticket Selector and Single Page Checkout
17			*
18			* @package Event Espresso
19			* @subpackage /modules/recaptcha_invisible/
20			* @author Brent Christensen
21			*/
22			class EED_Recaptcha_Invisible extends EED_Module
23			{
24
25			/**
26			* @var EE_Registration_Config $config
27			*/
28			private static $config;
29
30
31			/**
32			* @return EED_Module\|EED_Recaptcha
33			*/
34			public static function instance()
35			{
36			return parent::get_instance(__CLASS__);
37			}
38
39
40			/**
41			* @return void
42			* @throws InvalidInterfaceException
43			* @throws InvalidDataTypeException
44			* @throws InvalidArgumentException
45			*/
46			public static function set_hooks()
47			{
48			EED_Recaptcha_Invisible::setProperties();
49			if (EED_Recaptcha_Invisible::useInvisibleRecaptcha()) {
50			// ticket selection
51			add_filter(
52			'FHEE__EE_Ticket_Selector__after_ticket_selector_submit',
53			array('EED_Recaptcha_Invisible', 'ticketSelectorForm'),
54			10, 2
55			);
56			add_action(
57			'EED_Ticket_Selector__process_ticket_selections__before',
58			array('EED_Recaptcha_Invisible', 'processTicketSelectorForm')
59			);
60			// checkout
61			add_action(
62			'AHEE__EE_SPCO_Reg_Step__display_reg_form__reg_form',
63			array('EED_Recaptcha_Invisible', 'spcoRegStepForm')
64			);
65			add_filter(
66			'FHEE__EE_Form_Section_Proper__receive_form_submission__req_data',
67			array('EED_Recaptcha_Invisible', 'receiveSpcoRegStepForm'),
68			10, 2
69			);
70			}
71			}
72
73
74			/**
75			* @return void
76			* @throws InvalidInterfaceException
77			* @throws InvalidDataTypeException
78			* @throws InvalidArgumentException
79			*/
80			public static function set_hooks_admin()
81			{
82			// admin settings
83			add_action(
84			'AHEE__Extend_Registration_Form_Admin_Page___reg_form_settings_template',
85			array('EED_Recaptcha_Invisible', 'adminSettings')
86			);
87			add_filter(
88			'FHEE__Extend_Registration_Form_Admin_Page___update_reg_form_settings__CFG_registration',
89			array('EED_Recaptcha_Invisible', 'updateAdminSettings')
90			);
91			}
92
93
94			/**
95			* @return void
96			* @throws InvalidInterfaceException
97			* @throws InvalidDataTypeException
98			* @throws InvalidArgumentException
99			*/
100			public static function setProperties()
101			{
102			EED_Recaptcha_Invisible::$config = EE_Registry::instance()->CFG->registration;
103			}
104
105
106			/**
107			* @return boolean
108			*/
109			public static function useInvisibleRecaptcha()
110			{
111			return EED_Recaptcha_Invisible::$config->use_captcha
112			&& EED_Recaptcha_Invisible::$config->recaptcha_theme === 'invisible';
113			}
114
115
116			/**
117			* @return string
118			*/
119			public static function assetsUrl()
120			{
121			return plugin_dir_url(__FILE__) . 'assets' . DS;
122			}
123
124
125			/**
126			* @param \WP $WP
127			*/
128			public function run($WP)
129			{
130			}
131
132
133			/**
134			* @return boolean
135			* @throws InvalidInterfaceException
136			* @throws InvalidDataTypeException
137			* @throws InvalidArgumentException
138			*/
139			public static function recaptchaPassed()
140			{
141			// logged in means you have already passed a turing test of sorts
142			if (EED_Recaptcha_Invisible::useInvisibleRecaptcha() === false \|\| is_user_logged_in()) {
143			return true;
144			}
145			// was test already passed?
146			return filter_var(
147			EE_Registry::instance()->SSN->get_session_data(
148			InvisibleRecaptcha::SESSION_DATA_KEY_RECAPTCHA_PASSED
149			),
150			FILTER_VALIDATE_BOOLEAN
151			);
152			}
153
154
155			/**
156			* @param EE_Request $request
157			* @return bool
158			* @throws InvalidArgumentException
159			* @throws InvalidDataTypeException
160			* @throws InvalidInterfaceException
161			* @throws RuntimeException
162			*/
163			public static function verifyToken(EE_Request $request)
164			{
165			$invisible_recaptcha = RecaptchaFactory::create();
166			if ($invisible_recaptcha->verifyToken($request)) {
167			add_action('shutdown', array('EED_Recaptcha_Invisible', 'setSessionData'));
168			return true;
169			}
170			return false;
171			}
172
173
174			/**
175			* @param EE_Form_Section_Proper $reg_form
176			* @return void
177			* @throws EE_Error
178			* @throws InvalidArgumentException
179			* @throws InvalidDataTypeException
180			* @throws InvalidInterfaceException
181			*/
182			public static function spcoRegStepForm(EE_Form_Section_Proper $reg_form)
183			{
184			// do nothing if form isn't for a reg step or test has already been passed
185			if (! EED_Recaptcha_Invisible::processSpcoRegStepForm($reg_form)) {
186			return;
187			}
188			$default_hidden_inputs = $reg_form->get_subsection('default_hidden_inputs');
189			if ($default_hidden_inputs instanceof EE_Form_Section_Proper) {
190			$invisible_recaptcha = RecaptchaFactory::create();
191			$invisible_recaptcha->addToFormSection($default_hidden_inputs);
192			}
193			}
194
195
196			/**
197			* @param EE_Form_Section_Proper $reg_form
198			* @return bool
199			* @throws InvalidDataTypeException
200			* @throws InvalidInterfaceException
201			* @throws EE_Error
202			* @throws InvalidArgumentException
203			*/
204			public static function processSpcoRegStepForm(EE_Form_Section_Proper $reg_form)
205			{
206			return strpos($reg_form->name(), 'reg-step-form') === false \|\| EED_Recaptcha_Invisible::recaptchaPassed();
207			}
208
209
210			/**
211			* @param array\|null $req_data
212			* @param EE_Form_Section_Proper $reg_form
213			* @return array
214			* @throws EE_Error
215			* @throws InvalidArgumentException
216			* @throws InvalidDataTypeException
217			* @throws InvalidInterfaceException
218			* @throws RuntimeException
219			*/
220			public static function receiveSpcoRegStepForm($req_data = array(), EE_Form_Section_Proper $reg_form)
221			{
222			// do nothing if form isn't for a reg step or test has already been passed
223			if (! EED_Recaptcha_Invisible::processSpcoRegStepForm($reg_form)) {
224			return $req_data;
225			}
226			/** @var EE_Request $request */
227			$request = LoaderFactory::getLoader()->getShared('EE_Request');
228			if (! EED_Recaptcha_Invisible::verifyToken($request)) {
229			if ($request->isAjax()) {
230			$json_response = new EE_SPCO_JSON_Response();
231			$json_response->echoAndExit();
232			}
233			EEH_URL::safeRedirectAndExit(
234			EE_Registry::instance()->CFG->core->reg_page_url()
235			);
236			}
237			return $req_data;
238			}
239
240
241			/**
242			* @param string $html
243			* @param EE_Event $event
244			* @return string
245			* @throws InvalidArgumentException
246			* @throws InvalidDataTypeException
247			* @throws InvalidInterfaceException
248			* @throws EE_Error
249			*/
250			public static function ticketSelectorForm($html = '', EE_Event $event)
251			{
252			// do nothing if test has already been passed
253			if (EED_Recaptcha_Invisible::recaptchaPassed()) {
254			return $html;
255			}
256			$html .= RecaptchaFactory::create()->getInputHtml(
257			array('recaptcha_id' => $event->ID())
258			);
259			return $html;
260			}
261
262
263			/**
264			* @return void
265			* @throws InvalidArgumentException
266			* @throws InvalidInterfaceException
267			* @throws InvalidDataTypeException
268			* @throws RuntimeException
269			*/
270			public static function processTicketSelectorForm()
271			{
272			// do nothing if test has already been passed
273			if (EED_Recaptcha_Invisible::recaptchaPassed()) {
274			return;
275			}
276			/** @var EE_Request $request */
277			$request = LoaderFactory::getLoader()->getShared('EE_Request');
278			if (! EED_Recaptcha_Invisible::verifyToken($request)) {
279			$event_id = $request->get('tkt-slctr-event-id');
280			$return_url = $request->is_set("tkt-slctr-return-url-{$event_id}")
281			? $request->get("tkt-slctr-return-url-{$event_id}")
282			: get_permalink($event_id);
283			EEH_URL::safeRedirectAndExit($return_url);
284			}
285			}
286
287
288			/**
289			* @throws InvalidArgumentException
290			* @throws InvalidDataTypeException
291			* @throws InvalidInterfaceException
292			*/
293			public static function setSessionData()
294			{
295			EE_Registry::instance()->SSN->set_session_data(
296			array(InvisibleRecaptcha::SESSION_DATA_KEY_RECAPTCHA_PASSED => true)
297			);
298			}
299
300
301			/**
302			* @throws EE_Error
303			* @throws InvalidArgumentException
304			* @throws InvalidDataTypeException
305			* @throws InvalidInterfaceException
306			*/
307			public static function adminSettings()
308			{
309			RecaptchaFactory::getAdminModule()->adminSettings();
310			}
311
312
313			/**
314			* @param EE_Registration_Config $EE_Registration_Config
315			* @return EE_Registration_Config
316			* @throws EE_Error
317			* @throws InvalidArgumentException
318			* @throws InvalidDataTypeException
319			* @throws InvalidInterfaceException
320			* @throws ReflectionException
321			*/
322			public static function updateAdminSettings(EE_Registration_Config $EE_Registration_Config)
323			{
324			return RecaptchaFactory::getAdminModule()->updateAdminSettings($EE_Registration_Config);
325			}
326			}
327

eventespresso / event-espresso-core

Branch — FET/9575/invisible-recaptcha (a1de93)

EED_Recaptcha_Invisible::processSpcoRegStepForm() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like