Request::isWordPressHeartbeat() - Code Metrics - Inspection of "Daily Inspection: Merge branch 'master' into FET/r..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — FET/remove-bot-trap-timestamp (248d53)

unknown

created 2018-12-20 21:10 UTC

Request::isWordPressHeartbeat() A

↳ Parent: Request

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace EventEspresso\core\services\request;

use EventEspresso\core\domain\services\contexts\RequestTypeContextCheckerInterface;
use EventEspresso\core\interfaces\InterminableInterface;
use EventEspresso\core\interfaces\ReservedInstanceInterface;

/**
 * Class Request
 * Representation of an incoming, server-side HTTP request
 *
 * @package EventEspresso\core\services\request
 * @author  Brent Christensen
 * @since   4.9.53
 */
class Request implements InterminableInterface, RequestInterface, ReservedInstanceInterface
{

    /**
     * $_GET parameters
     *
     * @var array $get
     */
    private $get;

    /**
     * $_POST parameters
     *
     * @var array $post
     */
    private $post;

    /**
     * $_COOKIE parameters
     *
     * @var array $cookie
     */
    private $cookie;

    /**
     * $_SERVER parameters
     *
     * @var array $server
     */
    private $server;

    /**
     * $_REQUEST parameters
     *
     * @var array $request
     */
    private $request;

    /**
     * @var RequestTypeContextCheckerInterface
     */
    private $request_type;

    /**
     * IP address for request
     *
     * @var string $ip_address
     */
    private $ip_address;

    /**
     * @var string $user_agent
     */
    private $user_agent;

    /**
     * true if current user appears to be some kind of bot
     *
     * @var bool $is_bot
     */
    private $is_bot;


    /**
     * @param array $get
     * @param array $post
     * @param array $cookie
     * @param array $server
     */
    public function __construct(array $get, array $post, array $cookie, array $server)
    {
        // grab request vars
        $this->get = $get;
        $this->post = $post;
        $this->cookie = $cookie;
        $this->server = $server;
        $this->request = array_merge($this->get, $this->post);
        $this->ip_address = $this->visitorIp();
    }


    /**
     * @param RequestTypeContextCheckerInterface $type
     */
    public function setRequestTypeContextChecker(RequestTypeContextCheckerInterface $type)
    {
        $this->request_type = $type;
    }


    /**
     * @return array
     */
    public function getParams()
    {
        return $this->get;
    }


    /**
     * @return array
     */
    public function postParams()
    {
        return $this->post;
    }


    /**
     * @return array
     */
    public function cookieParams()
    {
        return $this->cookie;
    }


    /**
     * @return array
     */
    public function serverParams()
    {
        return $this->server;
    }


    /**
     * returns contents of $_REQUEST
     *
     * @return array
     */
    public function requestParams()
    {
        return $this->request;
    }


    /**
     * @param      $key
     * @param      $value
     * @param bool $override_ee
     * @return    void
     */
    public function setRequestParam($key, $value, $override_ee = false)
    {
        // don't allow "ee" to be overwritten unless explicitly instructed to do so
        if ($key !== 'ee'
            || ($key === 'ee' && empty($this->request['ee']))
            || ($key === 'ee' && ! empty($this->request['ee']) && $override_ee)
        ) {
            $this->request[ $key ] = $value;
        }
    }


    /**
     * returns   the value for a request param if the given key exists
     *
     * @param       $key
     * @param null  $default
     * @return mixed
     */
    public function getRequestParam($key, $default = null)
    {
        return $this->requestParameterDrillDown($key, $default, 'get');
    }


    /**
     * check if param exists
     *
     * @param       $key
     * @return bool
     */
    public function requestParamIsSet($key)
    {
        return $this->requestParameterDrillDown($key);
    }


    /**
     * check if a request parameter exists whose key that matches the supplied wildcard pattern
     * and return the value for the first match found
     * wildcards can be either of the following:
     *      ? to represent a single character of any type
     *      * to represent one or more characters of any type
     *
     * @param string     $pattern
     * @param null|mixed $default
     * @return mixed
     */
    public function getMatch($pattern, $default = null)
    {
        return $this->requestParameterDrillDown($pattern, $default, 'match');
    }


    /**
     * check if a request parameter exists whose key matches the supplied wildcard pattern
     * wildcards can be either of the following:
     *      ? to represent a single character of any type
     *      * to represent one or more characters of any type
     * returns true if a match is found or false if not
     *
     * @param string $pattern
     * @return bool
     */
    public function matches($pattern)
    {
        return $this->requestParameterDrillDown($pattern, null, 'match') !== null;
    }


    /**
     * @see https://stackoverflow.com/questions/6163055/php-string-matching-with-wildcard
     * @param string $pattern               A string including wildcards to be converted to a regex pattern
     *                                      and used to search through the current request's parameter keys
     * @param array  $request_params        The array of request parameters to search through
     * @param mixed  $default               [optional] The value to be returned if no match is found.
     *                                      Default is null
     * @param string $return                [optional] Controls what kind of value is returned.
     *                                      Options are:
     *                                      'bool' will return true or false if match is found or not
     *                                      'key' will return the first key found that matches the supplied pattern
     *                                      'value' will return the value for the first request parameter
     *                                      whose key matches the supplied pattern
     *                                      Default is 'value'
     * @return boolean|string
     */
    private function match($pattern, array $request_params, $default = null, $return = 'value')
    {
        $return = in_array($return, array('bool', 'key', 'value'), true)
            ? $return
            : 'is_set';
        // replace wildcard chars with regex chars
        $pattern = str_replace(
            array("\*", "\?"),
            array('.*', '.'),
            preg_quote($pattern, '/')
        );
        foreach ($request_params as $key => $request_param) {
            if (preg_match('/^' . $pattern . '$/is', $key)) {
                // return value for request param
                if ($return === 'value') {
                    return $request_params[ $key ];
                }
                // or actual key or true just to indicate it was found
                return $return === 'key' ? $key : true;
            }
        }
        // match not found so return default value or false
        return $return === 'value' ? $default : false;
    }


    /**
     * the supplied key can be a simple string to represent a "top-level" request parameter
     * or represent a key for a request parameter that is nested deeper within the request parameter array,
     * by using square brackets to surround keys for deeper array elements.
     * For example :
     * if the supplied $key was: "first[second][third]"
     * then this will attempt to drill down into the request parameter array to find a value.
     * Given the following request parameters:
     *  array(
     *      'first' => array(
     *          'second' => array(
     *              'third' => 'has a value'
     *          )
     *      )
     *  )
     * would return true if default parameters were set
     *
     * @param string $callback
     * @param        $key
     * @param null   $default
     * @param array  $request_params
     * @return bool|mixed|null
     */
    private function requestParameterDrillDown(
        $key,
        $default = null,
        $callback = 'is_set',
        array $request_params = array()
    ) {
        $callback = in_array($callback, array('is_set', 'get', 'match'), true)
            ? $callback
            : 'is_set';
        $request_params = ! empty($request_params)
            ? $request_params
            : $this->request;
        // does incoming key represent an array like 'first[second][third]'  ?
        if (strpos($key, '[') !== false) {
            // turn it into an actual array
            $key = str_replace(']', '', $key);
            $keys = explode('[', $key);
            $key = array_shift($keys);
            if ($callback === 'match') {
                $real_key = $this->match($key, $request_params, $default, 'key');
                $key = $real_key ? $real_key : $key;
            }
            // check if top level key exists
            if (isset($request_params[ $key ])) {
                // build a new key to pass along like: 'second[third]'
                // or just 'second' depending on depth of keys
                $key_string = array_shift($keys);
                if (! empty($keys)) {
                    $key_string .= '[' . implode('][', $keys) . ']';
                }
                return $this->requestParameterDrillDown(
                    $key_string,
                    $default,
                    $callback,
                    $request_params[ $key ]
                );
            }
        }
        if ($callback === 'is_set') {
            return isset($request_params[ $key ]);
        }
        if ($callback === 'match') {
            return $this->match($key, $request_params, $default);
        }
        return isset($request_params[ $key ])
            ? $request_params[ $key ]
            : $default;
    }


    /**
     * remove param
     *
     * @param      $key
     * @param bool $unset_from_global_too
     */
    public function unSetRequestParam($key, $unset_from_global_too = false)
    {
        unset($this->request[ $key ]);
        if ($unset_from_global_too) {
            unset($_REQUEST[ $key ]);
        }
    }


    /**
     * @return string
     */
    public function ipAddress()
    {
        return $this->ip_address;
    }


    /**
     * attempt to get IP address of current visitor from server
     * plz see: http://stackoverflow.com/a/2031935/1475279
     *
     * @access public
     * @return string
     */
    private function visitorIp()
    {
        $visitor_ip = '0.0.0.0';
        $server_keys = array(
            'HTTP_CLIENT_IP',
            'HTTP_X_FORWARDED_FOR',
            'HTTP_X_FORWARDED',
            'HTTP_X_CLUSTER_CLIENT_IP',
            'HTTP_FORWARDED_FOR',
            'HTTP_FORWARDED',
            'REMOTE_ADDR',
        );
        foreach ($server_keys as $key) {
            if (isset($this->server[ $key ])) {
                foreach (array_map('trim', explode(',', $this->server[ $key ])) as $ip) {
                    if ($ip === '127.0.0.1' || filter_var($ip, FILTER_VALIDATE_IP) !== false) {
                        $visitor_ip = $ip;
                    }
                }
            }
        }
        return $visitor_ip;
    }


    /**
     * @return string
     */
    public function requestUri()
    {
        $request_uri = filter_input(
            INPUT_SERVER,
            'REQUEST_URI',
            FILTER_SANITIZE_URL,
            FILTER_NULL_ON_FAILURE
        );
        if (empty($request_uri)) {
            // fallback sanitization if the above fails
            $request_uri = wp_sanitize_redirect($this->server['REQUEST_URI']);
        }
        return $request_uri;
    }


    /**
     * @return string
     */
    public function userAgent()
    {
        return $this->user_agent;
    }


    /**
     * @param string $user_agent
     */
    public function setUserAgent($user_agent = '')
    {
        if ($user_agent === '' || ! is_string($user_agent)) {
            $user_agent = isset($_SERVER['HTTP_USER_AGENT']) ? (string) esc_attr($_SERVER['HTTP_USER_AGENT']) : '';
        }
        $this->user_agent = $user_agent;
    }


    /**
     * @return bool
     */
    public function isBot()
    {
        return $this->is_bot;
    }


    /**
     * @param bool $is_bot
     */
    public function setIsBot($is_bot)
    {
        $this->is_bot = filter_var($is_bot, FILTER_VALIDATE_BOOLEAN);
    }


    /**
     * @return bool
     */
    public function isActivation()
    {
        return $this->request_type->isActivation();
    }


    /**
     * @param $is_activation
     * @return bool
     */
    public function setIsActivation($is_activation)
    {
        return $this->request_type->setIsActivation($is_activation);
    }


    /**
     * @return bool
     */
    public function isAdmin()
    {
        return $this->request_type->isAdmin();
    }


    /**
     * @return bool
     */
    public function isAdminAjax()
    {
        return $this->request_type->isAdminAjax();
    }


    /**
     * @return bool
     */
    public function isAjax()
    {
        return $this->request_type->isAjax();
    }


    /**
     * @return bool
     */
    public function isEeAjax()
    {
        return $this->request_type->isEeAjax();
    }


    /**
     * @return bool
     */
    public function isOtherAjax()
    {
        return $this->request_type->isOtherAjax();
    }


    /**
     * @return bool
     */
    public function isApi()
    {
        return $this->request_type->isApi();
    }


    /**
     * @return bool
     */
    public function isCli()
    {
        return $this->request_type->isCli();
    }


    /**
     * @return bool
     */
    public function isCron()
    {
        return $this->request_type->isCron();
    }


    /**
     * @return bool
     */
    public function isFeed()
    {
        return $this->request_type->isFeed();
    }


    /**
     * @return bool
     */
    public function isFrontend()
    {
        return $this->request_type->isFrontend();
    }


    /**
     * @return bool
     */
    public function isFrontAjax()
    {
        return $this->request_type->isFrontAjax();
    }


    /**
     * @return bool
     */
    public function isIframe()
    {
        return $this->request_type->isIframe();
    }


    /**
     * @return bool
     */
    public function isWordPressApi()
    {
        return $this->request_type->isWordPressApi();
    }



    /**
     * @return bool
     */
    public function isWordPressHeartbeat()
    {
        return $this->request_type->isWordPressHeartbeat();
    }



    /**
     * @return bool
     */
    public function isWordPressScrape()
    {
        return $this->request_type->isWordPressScrape();
    }


    /**
     * @return string
     */
    public function slug()
    {
        return $this->request_type->slug();
    }
}


1			<?php
2
3			namespace EventEspresso\core\services\request;
4
5			use EventEspresso\core\domain\services\contexts\RequestTypeContextCheckerInterface;
6			use EventEspresso\core\interfaces\InterminableInterface;
7			use EventEspresso\core\interfaces\ReservedInstanceInterface;
8
9			/**
10			* Class Request
11			* Representation of an incoming, server-side HTTP request
12			*
13			* @package EventEspresso\core\services\request
14			* @author Brent Christensen
15			* @since 4.9.53
16			*/
17			class Request implements InterminableInterface, RequestInterface, ReservedInstanceInterface
18			{
19
20			/**
21			* $_GET parameters
22			*
23			* @var array $get
24			*/
25			private $get;
26
27			/**
28			* $_POST parameters
29			*
30			* @var array $post
31			*/
32			private $post;
33
34			/**
35			* $_COOKIE parameters
36			*
37			* @var array $cookie
38			*/
39			private $cookie;
40
41			/**
42			* $_SERVER parameters
43			*
44			* @var array $server
45			*/
46			private $server;
47
48			/**
49			* $_REQUEST parameters
50			*
51			* @var array $request
52			*/
53			private $request;
54
55			/**
56			* @var RequestTypeContextCheckerInterface
57			*/
58			private $request_type;
59
60			/**
61			* IP address for request
62			*
63			* @var string $ip_address
64			*/
65			private $ip_address;
66
67			/**
68			* @var string $user_agent
69			*/
70			private $user_agent;
71
72			/**
73			* true if current user appears to be some kind of bot
74			*
75			* @var bool $is_bot
76			*/
77			private $is_bot;
78
79
80			/**
81			* @param array $get
82			* @param array $post
83			* @param array $cookie
84			* @param array $server
85			*/
86			public function __construct(array $get, array $post, array $cookie, array $server)
87			{
88			// grab request vars
89			$this->get = $get;
90			$this->post = $post;
91			$this->cookie = $cookie;
92			$this->server = $server;
93			$this->request = array_merge($this->get, $this->post);
94			$this->ip_address = $this->visitorIp();
95			}
96
97
98			/**
99			* @param RequestTypeContextCheckerInterface $type
100			*/
101			public function setRequestTypeContextChecker(RequestTypeContextCheckerInterface $type)
102			{
103			$this->request_type = $type;
104			}
105
106
107			/**
108			* @return array
109			*/
110			public function getParams()
111			{
112			return $this->get;
113			}
114
115
116			/**
117			* @return array
118			*/
119			public function postParams()
120			{
121			return $this->post;
122			}
123
124
125			/**
126			* @return array
127			*/
128			public function cookieParams()
129			{
130			return $this->cookie;
131			}
132
133
134			/**
135			* @return array
136			*/
137			public function serverParams()
138			{
139			return $this->server;
140			}
141
142
143			/**
144			* returns contents of $_REQUEST
145			*
146			* @return array
147			*/
148			public function requestParams()
149			{
150			return $this->request;
151			}
152
153
154			/**
155			* @param $key
156			* @param $value
157			* @param bool $override_ee
158			* @return void
159			*/
160			public function setRequestParam($key, $value, $override_ee = false)
161			{
162			// don't allow "ee" to be overwritten unless explicitly instructed to do so
163			if ($key !== 'ee'
164			\|\| ($key === 'ee' && empty($this->request['ee']))
165			\|\| ($key === 'ee' && ! empty($this->request['ee']) && $override_ee)
166			) {
167			$this->request[ $key ] = $value;
168			}
169			}
170
171
172			/**
173			* returns the value for a request param if the given key exists
174			*
175			* @param $key
176			* @param null $default
177			* @return mixed
178			*/
179			public function getRequestParam($key, $default = null)
180			{
181			return $this->requestParameterDrillDown($key, $default, 'get');
182			}
183
184
185			/**
186			* check if param exists
187			*
188			* @param $key
189			* @return bool
190			*/
191			public function requestParamIsSet($key)
192			{
193			return $this->requestParameterDrillDown($key);
194			}
195
196
197			/**
198			* check if a request parameter exists whose key that matches the supplied wildcard pattern
199			* and return the value for the first match found
200			* wildcards can be either of the following:
201			* ? to represent a single character of any type
202			* * to represent one or more characters of any type
203			*
204			* @param string $pattern
205			* @param null\|mixed $default
206			* @return mixed
207			*/
208			public function getMatch($pattern, $default = null)
209			{
210			return $this->requestParameterDrillDown($pattern, $default, 'match');
211			}
212
213
214			/**
215			* check if a request parameter exists whose key matches the supplied wildcard pattern
216			* wildcards can be either of the following:
217			* ? to represent a single character of any type
218			* * to represent one or more characters of any type
219			* returns true if a match is found or false if not
220			*
221			* @param string $pattern
222			* @return bool
223			*/
224			public function matches($pattern)
225			{
226			return $this->requestParameterDrillDown($pattern, null, 'match') !== null;
227			}
228
229
230			/**
231			* @see https://stackoverflow.com/questions/6163055/php-string-matching-with-wildcard
232			* @param string $pattern A string including wildcards to be converted to a regex pattern
233			* and used to search through the current request's parameter keys
234			* @param array $request_params The array of request parameters to search through
235			* @param mixed $default [optional] The value to be returned if no match is found.
236			* Default is null
237			* @param string $return [optional] Controls what kind of value is returned.
238			* Options are:
239			* 'bool' will return true or false if match is found or not
240			* 'key' will return the first key found that matches the supplied pattern
241			* 'value' will return the value for the first request parameter
242			* whose key matches the supplied pattern
243			* Default is 'value'
244			* @return boolean\|string
245			*/
246			private function match($pattern, array $request_params, $default = null, $return = 'value')
247			{
248			$return = in_array($return, array('bool', 'key', 'value'), true)
249			? $return
250			: 'is_set';
251			// replace wildcard chars with regex chars
252			$pattern = str_replace(
253			array("\*", "\?"),
254			array('.*', '.'),
255			preg_quote($pattern, '/')
256			);
257			foreach ($request_params as $key => $request_param) {
258			if (preg_match('/^' . $pattern . '$/is', $key)) {
259			// return value for request param
260			if ($return === 'value') {
261			return $request_params[ $key ];
262			}
263			// or actual key or true just to indicate it was found
264			return $return === 'key' ? $key : true;
265			}
266			}
267			// match not found so return default value or false
268			return $return === 'value' ? $default : false;
269			}
270
271
272			/**
273			* the supplied key can be a simple string to represent a "top-level" request parameter
274			* or represent a key for a request parameter that is nested deeper within the request parameter array,
275			* by using square brackets to surround keys for deeper array elements.
276			* For example :
277			* if the supplied $key was: "first[second][third]"
278			* then this will attempt to drill down into the request parameter array to find a value.
279			* Given the following request parameters:
280			* array(
281			* 'first' => array(
282			* 'second' => array(
283			* 'third' => 'has a value'
284			* )
285			* )
286			* )
287			* would return true if default parameters were set
288			*
289			* @param string $callback
290			* @param $key
291			* @param null $default
292			* @param array $request_params
293			* @return bool\|mixed\|null
294			*/
295			private function requestParameterDrillDown(
296			$key,
297			$default = null,
298			$callback = 'is_set',
299			array $request_params = array()
300			) {
301			$callback = in_array($callback, array('is_set', 'get', 'match'), true)
302			? $callback
303			: 'is_set';
304			$request_params = ! empty($request_params)
305			? $request_params
306			: $this->request;
307			// does incoming key represent an array like 'first[second][third]' ?
308			if (strpos($key, '[') !== false) {
309			// turn it into an actual array
310			$key = str_replace(']', '', $key);
311			$keys = explode('[', $key);
312			$key = array_shift($keys);
313			if ($callback === 'match') {
314			$real_key = $this->match($key, $request_params, $default, 'key');
315			$key = $real_key ? $real_key : $key;
316			}
317			// check if top level key exists
318			if (isset($request_params[ $key ])) {
319			// build a new key to pass along like: 'second[third]'
320			// or just 'second' depending on depth of keys
321			$key_string = array_shift($keys);
322			if (! empty($keys)) {
323			$key_string .= '[' . implode('][', $keys) . ']';
324			}
325			return $this->requestParameterDrillDown(
326			$key_string,
327			$default,
328			$callback,
329			$request_params[ $key ]
330			);
331			}
332			}
333			if ($callback === 'is_set') {
334			return isset($request_params[ $key ]);
335			}
336			if ($callback === 'match') {
337			return $this->match($key, $request_params, $default);
338			}
339			return isset($request_params[ $key ])
340			? $request_params[ $key ]
341			: $default;
342			}
343
344
345			/**
346			* remove param
347			*
348			* @param $key
349			* @param bool $unset_from_global_too
350			*/
351			public function unSetRequestParam($key, $unset_from_global_too = false)
352			{
353			unset($this->request[ $key ]);
354			if ($unset_from_global_too) {
355			unset($_REQUEST[ $key ]);
356			}
357			}
358
359
360			/**
361			* @return string
362			*/
363			public function ipAddress()
364			{
365			return $this->ip_address;
366			}
367
368
369			/**
370			* attempt to get IP address of current visitor from server
371			* plz see: http://stackoverflow.com/a/2031935/1475279
372			*
373			* @access public
374			* @return string
375			*/
376			private function visitorIp()
377			{
378			$visitor_ip = '0.0.0.0';
379			$server_keys = array(
380			'HTTP_CLIENT_IP',
381			'HTTP_X_FORWARDED_FOR',
382			'HTTP_X_FORWARDED',
383			'HTTP_X_CLUSTER_CLIENT_IP',
384			'HTTP_FORWARDED_FOR',
385			'HTTP_FORWARDED',
386			'REMOTE_ADDR',
387			);
388			foreach ($server_keys as $key) {
389			if (isset($this->server[ $key ])) {
390			foreach (array_map('trim', explode(',', $this->server[ $key ])) as $ip) {
391			if ($ip === '127.0.0.1' \|\| filter_var($ip, FILTER_VALIDATE_IP) !== false) {
392			$visitor_ip = $ip;
393			}
394			}
395			}
396			}
397			return $visitor_ip;
398			}
399
400
401			/**
402			* @return string
403			*/
404			public function requestUri()
405			{
406			$request_uri = filter_input(
407			INPUT_SERVER,
408			'REQUEST_URI',
409			FILTER_SANITIZE_URL,
410			FILTER_NULL_ON_FAILURE
411			);
412			if (empty($request_uri)) {
413			// fallback sanitization if the above fails
414			$request_uri = wp_sanitize_redirect($this->server['REQUEST_URI']);
415			}
416			return $request_uri;
417			}
418
419
420			/**
421			* @return string
422			*/
423			public function userAgent()
424			{
425			return $this->user_agent;
426			}
427
428
429			/**
430			* @param string $user_agent
431			*/
432			public function setUserAgent($user_agent = '')
433			{
434			if ($user_agent === '' \|\| ! is_string($user_agent)) {
435			$user_agent = isset($_SERVER['HTTP_USER_AGENT']) ? (string) esc_attr($_SERVER['HTTP_USER_AGENT']) : '';
436			}
437			$this->user_agent = $user_agent;
438			}
439
440
441			/**
442			* @return bool
443			*/
444			public function isBot()
445			{
446			return $this->is_bot;
447			}
448
449
450			/**
451			* @param bool $is_bot
452			*/
453			public function setIsBot($is_bot)
454			{
455			$this->is_bot = filter_var($is_bot, FILTER_VALIDATE_BOOLEAN);
456			}
457
458
459			/**
460			* @return bool
461			*/
462			public function isActivation()
463			{
464			return $this->request_type->isActivation();
465			}
466
467
468			/**
469			* @param $is_activation
470			* @return bool
471			*/
472			public function setIsActivation($is_activation)
473			{
474			return $this->request_type->setIsActivation($is_activation);
475			}
476
477
478			/**
479			* @return bool
480			*/
481			public function isAdmin()
482			{
483			return $this->request_type->isAdmin();
484			}
485
486
487			/**
488			* @return bool
489			*/
490			public function isAdminAjax()
491			{
492			return $this->request_type->isAdminAjax();
493			}
494
495
496			/**
497			* @return bool
498			*/
499			public function isAjax()
500			{
501			return $this->request_type->isAjax();
502			}
503
504
505			/**
506			* @return bool
507			*/
508			public function isEeAjax()
509			{
510			return $this->request_type->isEeAjax();
511			}
512
513
514			/**
515			* @return bool
516			*/
517			public function isOtherAjax()
518			{
519			return $this->request_type->isOtherAjax();
520			}
521
522
523			/**
524			* @return bool
525			*/
526			public function isApi()
527			{
528			return $this->request_type->isApi();
529			}
530
531
532			/**
533			* @return bool
534			*/
535			public function isCli()
536			{
537			return $this->request_type->isCli();
538			}
539
540
541			/**
542			* @return bool
543			*/
544			public function isCron()
545			{
546			return $this->request_type->isCron();
547			}
548
549
550			/**
551			* @return bool
552			*/
553			public function isFeed()
554			{
555			return $this->request_type->isFeed();
556			}
557
558
559			/**
560			* @return bool
561			*/
562			public function isFrontend()
563			{
564			return $this->request_type->isFrontend();
565			}
566
567
568			/**
569			* @return bool
570			*/
571			public function isFrontAjax()
572			{
573			return $this->request_type->isFrontAjax();
574			}
575
576
577			/**
578			* @return bool
579			*/
580			public function isIframe()
581			{
582			return $this->request_type->isIframe();
583			}
584
585
586			/**
587			* @return bool
588			*/
589			public function isWordPressApi()
590			{
591			return $this->request_type->isWordPressApi();
592			}
593
594
595
596			/**
597			* @return bool
598			*/
599			public function isWordPressHeartbeat()
600			{
601			return $this->request_type->isWordPressHeartbeat();
602			}
603
604
605
606			/**
607			* @return bool
608			*/
609			public function isWordPressScrape()
610			{
611			return $this->request_type->isWordPressScrape();
612			}
613
614
615			/**
616			* @return string
617			*/
618			public function slug()
619			{
620			return $this->request_type->slug();
621			}
622			}
623

eventespresso / event-espresso-core

Branch — FET/remove-bot-trap-timestamp (248d53)

Request::isWordPressHeartbeat() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like