Base - Code Metrics - Inspection of "Daily Inspection: [touch:10738]{t:20}resolved a we..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — BUG-10738-inconsistency-in-ses... (cda363)

unknown

created 2017-09-22 21:14 UTC

Base B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	350
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	350
rs	8.2769
wmc	41
lcom	1
cbo	4

12 Methods

Rating	Name	Size	Complexity
A	__construct()	6	2
A	setRequestedVersion()	4	1
A	setDebugInfo()	4	1
A	setResponseHeader()	11	4
A	getResponseHeaders()	9	1
A	addEeErrorsToResponse()	13	3
D	sendResponse()	32	9
C	createRestResponseFromWpError()	26	7
B	getHeadersFromEeNotices()	23	4
A	getRequestedVersion()	16	3
B	parseRoute()	22	5
A	getBodyParams()	13	1

How to fix Complexity

<?php
namespace EventEspresso\core\libraries\rest_api\controllers;

use Exception;
use WP_Error;
use WP_REST_Response;
use EventEspresso\core\libraries\rest_api\RestException;

use EE_Error;
use EED_Core_Rest_Api;
use EEH_Inflector;

if (! defined('EVENT_ESPRESSO_VERSION')) {
    exit('No direct script access allowed');
}



/**
 * Base
 * Base controller for EE REST API
 *
 * @package               Event Espresso
 * @subpackage
 * @author                Mike Nelson
 */
class Base
{

    /**
     * @deprecated use all-caps version
     */
    // @codingStandardsIgnoreStart
    const header_prefix_for_ee = 'X-EE-';
    // @codingStandardsIgnoreEnd

    const HEADER_PREFIX_FOR_EE = 'X-EE-';

    /**
     * @deprecated use all-caps version instead
     */
    // @codingStandardsIgnoreStart
    const header_prefix_for_wp = 'X-WP-';
    // @codingStandardsIgnoreEnd

    const HEADER_PREFIX_FOR_WP = 'X-WP-';

    /**
     * Contains debug info we'll send back in the response headers
     *
     * @var array
     */
    protected $debug_info = array();

    /**
     * Indicates whether or not the API is in debug mode
     *
     * @var boolean
     */
    protected $debug_mode = false;

    /**
     * Indicates the version that was requested
     *
     * @var string
     */
    protected $requested_version;

    /**
     * flat array of headers to send in the response
     *
     * @var array
     */
    protected $response_headers = array();



    public function __construct()
    {
        $this->debug_mode = defined('EE_REST_API_DEBUG_MODE') ? EE_REST_API_DEBUG_MODE : false;
        //we are handling a REST request. Don't show a fancy HTML error message is any error comes up
        add_filter('FHEE__EE_Error__get_error__show_normal_exceptions', '__return_true');
    }



    /**
     * Sets the version the user requested
     *
     * @param string $version eg '4.8'
     */
    public function setRequestedVersion($version)
    {
        $this->requested_version = $version;
    }



    /**
     * Sets some debug info that we'll send back in headers
     *
     * @param string       $key
     * @param string|array $info
     */
    protected function setDebugInfo($key, $info)
    {
        $this->debug_info[$key] = $info;
    }



    /**
     * Sets headers for the response
     *
     * @param string       $header_key    , excluding the "X-EE-" part
     * @param array|string $value         if an array, multiple headers will be added, one
     *                                    for each key in the array
     * @param boolean      $use_ee_prefix whether to use the EE prefix on the header, or fallback to
     *                                    the standard WP one
     */
    protected function setResponseHeader($header_key, $value, $use_ee_prefix = true)
    {
        if (is_array($value)) {
            foreach ($value as $value_key => $value_value) {
                $this->setResponseHeader($header_key . '[' . $value_key . ']', $value_value);
            }
        } else {
            $prefix = $use_ee_prefix ? Base::HEADER_PREFIX_FOR_EE : Base::HEADER_PREFIX_FOR_WP;
            $this->response_headers[$prefix . $header_key] = $value;
        }
    }



    /**
     * Returns a flat array of headers to be added to the response
     *
     * @return array
     */
    protected function getResponseHeaders()
    {
        return apply_filters(
            'FHEE__EventEspresso\core\libraries\rest_api\controllers\Base___get_response_headers',
            $this->response_headers,
            $this,
            $this->requested_version
        );
    }



    /**
     * Adds error notices from EE_Error onto the provided \WP_Error
     *
     * @param WP_Error $wp_error_response
     * @return WP_Error
     */
    protected function addEeErrorsToResponse(WP_Error $wp_error_response)
    {
        $notices_during_checkin = EE_Error::get_raw_notices();
        if (! empty($notices_during_checkin['errors'])) {
            foreach ($notices_during_checkin['errors'] as $error_code => $error_message) {
                $wp_error_response->add(
                    sanitize_key($error_code),
                    strip_tags($error_message)
                );
            }
        }
        return $wp_error_response;
    }



    /**
     * Sends a response, but also makes sure to attach headers that
     * are handy for debugging.
     * Specifically, we assume folks will want to know what exactly was the DB query that got run,
     * what exactly was the Models query that got run, what capabilities came into play, what fields were omitted from
     * the response, others?
     *
     * @param array|WP_Error|Exception|RestException $response
     * @return WP_REST_Response
     */
    public function sendResponse($response)
    {
        if ($response instanceof RestException) {
            $response = new WP_Error($response->getStringCode(), $response->getMessage(), $response->getData());
        }
        if ($response instanceof Exception) {
            $code = $response->getCode() ? $response->getCode() : 'error_occurred';
            $response = new WP_Error($code, $response->getMessage());
        }
        if ($response instanceof WP_Error) {

            $response = $this->addEeErrorsToResponse($response);
            $rest_response = $this->createRestResponseFromWpError($response);
        } else {
            $rest_response = new WP_REST_Response($response, 200);
        }
        $headers = array();
        if ($this->debug_mode && is_array($this->debug_info)) {
            foreach ($this->debug_info as $debug_key => $debug_info) {
                if (is_array($debug_info)) {
                    $debug_info = wp_json_encode($debug_info);
                }
                $headers['X-EE4-Debug-' . ucwords($debug_key)] = $debug_info;
            }
        }
        $headers = array_merge(
            $headers,
            $this->getResponseHeaders(),
            $this->getHeadersFromEeNotices()
        );
        $rest_response->set_headers($headers);
        return $rest_response;
    }



    /**
     * Converts the \WP_Error into `WP_REST_Response.
     * Mostly this is just a copy-and-paste from \WP_REST_Server::error_to_response
     * (which is protected)
     *
     * @param WP_Error $wp_error
     * @return WP_REST_Response
     */
    protected function createRestResponseFromWpError(WP_Error $wp_error)
    {
        $error_data = $wp_error->get_error_data();
        if (is_array($error_data) && isset($error_data['status'])) {
            $status = $error_data['status'];
        } else {
            $status = 500;
        }
        $errors = array();
        foreach ((array)$wp_error->errors as $code => $messages) {
            foreach ((array)$messages as $message) {
                $errors[] = array(
                    'code'    => $code,
                    'message' => $message,
                    'data'    => $wp_error->get_error_data($code),
                );
            }
        }
        $data = isset($errors[0]) ? $errors[0] : array();
        if (count($errors) > 1) {
            // Remove the primary error.
            array_shift($errors);
            $data['additional_errors'] = $errors;
        }
        return new WP_REST_Response($data, $status);
    }



    /**
     * Array of headers derived from EE success, attention, and error messages
     *
     * @return array
     */
    protected function getHeadersFromEeNotices()
    {
        $headers = array();
        $notices = EE_Error::get_raw_notices();
        foreach ($notices as $notice_type => $sub_notices) {
            if (! is_array($sub_notices)) {
                continue;
            }
            foreach ($sub_notices as $notice_code => $sub_notice) {
                $headers['X-EE4-Notices-'
                         . EEH_Inflector::humanize($notice_type)
                         . '['
                         . $notice_code
                         . ']'] = strip_tags($sub_notice);
            }
        }
        return apply_filters(
            'FHEE__EventEspresso\core\libraries\rest_api\controllers\Base___get_headers_from_ee_notices__return',
            $headers,
            $this->requested_version,
            $notices
        );
    }



    /**
     * Finds which version of the API was requested given the route, and returns it.
     * eg in a request to "mysite.com/wp-json/ee/v4.8.29/events/123" this would return
     * "4.8.29".
     * We should know hte requested version in this model though, so if no route is
     * provided just use what we set earlier
     *
     * @param string $route
     * @return string
     */
    public function getRequestedVersion($route = null)
    {
        if ($route === null) {
            return $this->requested_version;
        }
        $matches = $this->parseRoute(
            $route,
            '~' . EED_Core_Rest_Api::ee_api_namespace_for_regex . '~',
            array('version')
        );
        if (isset($matches['version'])) {
            return $matches['version'];
        } else {
            return EED_Core_Rest_Api::latest_rest_api_version();

        }
    }



    /**
     * Applies the regex to the route, then creates an array using the values of
     * $match_keys as keys (but ignores the full pattern match). Returns the array of matches.
     * For example, if you call
     * parse_route( '/ee/v4.8/events', '~\/ee\/v([^/]*)\/(.*)~', array( 'version', 'model' ) )
     * it will return array( 'version' => '4.8', 'model' => 'events' )
     *
     * @param string $route
     * @param string $regex
     * @param array  $match_keys EXCLUDING matching the entire regex
     * @return array where  $match_keys are the keys (the first value of $match_keys
     *                           becomes the first key of the return value, etc. Eg passing in $match_keys of
     *                           array( 'model', 'id' ), will, if the regex is successful, will return
     *                           array( 'model' => 'foo', 'id' => 'bar' )
     * @throws EE_Error if it couldn't be parsed
     */
    public function parseRoute($route, $regex, $match_keys)
    {
        $indexed_matches = array();
        $success = preg_match($regex, $route, $matches);
        if (is_array($matches)) {
            //skip the overall regex match. Who cares
            for ($i = 1; $i <= count($match_keys); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                if (! isset($matches[$i])) {
                    $success = false;
                } else {
                    $indexed_matches[$match_keys[$i - 1]] = $matches[$i];
                }
            }
        }
        if (! $success) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            throw new EE_Error(
                __('We could not parse the URL. Please contact Event Espresso Support', 'event_espresso'),
                'endpoint_parsing_error'
            );
        }
        return $indexed_matches;
    }



    /**
     * Gets the body's params (either from JSON or parsed body), which EXCLUDES the GET params and URL params
     *
     * @param \WP_REST_Request $request
     * @return array
     */
    protected function getBodyParams(\WP_REST_Request $request)
    {
        //$request->get_params();
        return array_merge(
            (array)$request->get_body_params(),
            (array)$request->get_json_params()
        );
        // return array_diff_key(
        //    $request->get_params(),
        //     $request->get_url_params(),
        //     $request->get_query_params()
        // );
    }
}

// End of file Base.php


1			<?php
2			namespace EventEspresso\core\libraries\rest_api\controllers;
3
4			use Exception;
5			use WP_Error;
6			use WP_REST_Response;
7			use EventEspresso\core\libraries\rest_api\RestException;
8
9			use EE_Error;
10			use EED_Core_Rest_Api;
11			use EEH_Inflector;
12
13			if (! defined('EVENT_ESPRESSO_VERSION')) {
14			exit('No direct script access allowed');
15			}
16
17
18
19			/**
20			* Base
21			* Base controller for EE REST API
22			*
23			* @package Event Espresso
24			* @subpackage
25			* @author Mike Nelson
26			*/
27			class Base
28			{
29
30			/**
31			* @deprecated use all-caps version
32			*/
33			// @codingStandardsIgnoreStart
34			const header_prefix_for_ee = 'X-EE-';
35			// @codingStandardsIgnoreEnd
36
37			const HEADER_PREFIX_FOR_EE = 'X-EE-';
38
39			/**
40			* @deprecated use all-caps version instead
41			*/
42			// @codingStandardsIgnoreStart
43			const header_prefix_for_wp = 'X-WP-';
44			// @codingStandardsIgnoreEnd
45
46			const HEADER_PREFIX_FOR_WP = 'X-WP-';
47
48			/**
49			* Contains debug info we'll send back in the response headers
50			*
51			* @var array
52			*/
53			protected $debug_info = array();
54
55			/**
56			* Indicates whether or not the API is in debug mode
57			*
58			* @var boolean
59			*/
60			protected $debug_mode = false;
61
62			/**
63			* Indicates the version that was requested
64			*
65			* @var string
66			*/
67			protected $requested_version;
68
69			/**
70			* flat array of headers to send in the response
71			*
72			* @var array
73			*/
74			protected $response_headers = array();
75
76
77
78			public function __construct()
79			{
80			$this->debug_mode = defined('EE_REST_API_DEBUG_MODE') ? EE_REST_API_DEBUG_MODE : false;
81			//we are handling a REST request. Don't show a fancy HTML error message is any error comes up
82			add_filter('FHEE__EE_Error__get_error__show_normal_exceptions', '__return_true');
83			}
84
85
86
87			/**
88			* Sets the version the user requested
89			*
90			* @param string $version eg '4.8'
91			*/
92			public function setRequestedVersion($version)
93			{
94			$this->requested_version = $version;
95			}
96
97
98
99			/**
100			* Sets some debug info that we'll send back in headers
101			*
102			* @param string $key
103			* @param string\|array $info
104			*/
105			protected function setDebugInfo($key, $info)
106			{
107			$this->debug_info[$key] = $info;
108			}
109
110
111
112			/**
113			* Sets headers for the response
114			*
115			* @param string $header_key , excluding the "X-EE-" part
116			* @param array\|string $value if an array, multiple headers will be added, one
117			* for each key in the array
118			* @param boolean $use_ee_prefix whether to use the EE prefix on the header, or fallback to
119			* the standard WP one
120			*/
121			protected function setResponseHeader($header_key, $value, $use_ee_prefix = true)
122			{
123			if (is_array($value)) {
124			foreach ($value as $value_key => $value_value) {
125			$this->setResponseHeader($header_key . '[' . $value_key . ']', $value_value);
126			}
127			} else {
128			$prefix = $use_ee_prefix ? Base::HEADER_PREFIX_FOR_EE : Base::HEADER_PREFIX_FOR_WP;
129			$this->response_headers[$prefix . $header_key] = $value;
130			}
131			}
132
133
134
135			/**
136			* Returns a flat array of headers to be added to the response
137			*
138			* @return array
139			*/
140			protected function getResponseHeaders()
141			{
142			return apply_filters(
143			'FHEE__EventEspresso\core\libraries\rest_api\controllers\Base___get_response_headers',
144			$this->response_headers,
145			$this,
146			$this->requested_version
147			);
148			}
149
150
151
152			/**
153			* Adds error notices from EE_Error onto the provided \WP_Error
154			*
155			* @param WP_Error $wp_error_response
156			* @return WP_Error
157			*/
158			protected function addEeErrorsToResponse(WP_Error $wp_error_response)
159			{
160			$notices_during_checkin = EE_Error::get_raw_notices();
161			if (! empty($notices_during_checkin['errors'])) {
162			foreach ($notices_during_checkin['errors'] as $error_code => $error_message) {
163			$wp_error_response->add(
164			sanitize_key($error_code),
165			strip_tags($error_message)
166			);
167			}
168			}
169			return $wp_error_response;
170			}
171
172
173
174			/**
175			* Sends a response, but also makes sure to attach headers that
176			* are handy for debugging.
177			* Specifically, we assume folks will want to know what exactly was the DB query that got run,
178			* what exactly was the Models query that got run, what capabilities came into play, what fields were omitted from
179			* the response, others?
180			*
181			* @param array\|WP_Error\|Exception\|RestException $response
182			* @return WP_REST_Response
183			*/
184			public function sendResponse($response)
185			{
186			if ($response instanceof RestException) {
187			$response = new WP_Error($response->getStringCode(), $response->getMessage(), $response->getData());
188			}
189			if ($response instanceof Exception) {
190			$code = $response->getCode() ? $response->getCode() : 'error_occurred';
191			$response = new WP_Error($code, $response->getMessage());
192			}
193			if ($response instanceof WP_Error) {
			0 ignored issues – show Bug introduced 2017-03-21 22:07 UTC by Report Bug Copy Issue Report The class `WP_Error` does not exist. Is this class maybe located in a folder that is not analyzed, or in a newer version of your dependencies than listed in your composer.lock/composer.json? Loading history...
194			$response = $this->addEeErrorsToResponse($response);
195			$rest_response = $this->createRestResponseFromWpError($response);
196			} else {
197			$rest_response = new WP_REST_Response($response, 200);
198			}
199			$headers = array();
200			if ($this->debug_mode && is_array($this->debug_info)) {
201			foreach ($this->debug_info as $debug_key => $debug_info) {
202			if (is_array($debug_info)) {
203			$debug_info = wp_json_encode($debug_info);
204			}
205			$headers['X-EE4-Debug-' . ucwords($debug_key)] = $debug_info;
206			}
207			}
208			$headers = array_merge(
209			$headers,
210			$this->getResponseHeaders(),
211			$this->getHeadersFromEeNotices()
212			);
213			$rest_response->set_headers($headers);
214			return $rest_response;
215			}
216
217
218
219			/**
220			* Converts the \WP_Error into `WP_REST_Response.
221			* Mostly this is just a copy-and-paste from \WP_REST_Server::error_to_response
222			* (which is protected)
223			*
224			* @param WP_Error $wp_error
225			* @return WP_REST_Response
226			*/
227			protected function createRestResponseFromWpError(WP_Error $wp_error)
228			{
229			$error_data = $wp_error->get_error_data();
230			if (is_array($error_data) && isset($error_data['status'])) {
231			$status = $error_data['status'];
232			} else {
233			$status = 500;
234			}
235			$errors = array();
236			foreach ((array)$wp_error->errors as $code => $messages) {
237			foreach ((array)$messages as $message) {
238			$errors[] = array(
239			'code' => $code,
240			'message' => $message,
241			'data' => $wp_error->get_error_data($code),
242			);
243			}
244			}
245			$data = isset($errors[0]) ? $errors[0] : array();
246			if (count($errors) > 1) {
247			// Remove the primary error.
248			array_shift($errors);
249			$data['additional_errors'] = $errors;
250			}
251			return new WP_REST_Response($data, $status);
252			}
253
254
255
256			/**
257			* Array of headers derived from EE success, attention, and error messages
258			*
259			* @return array
260			*/
261			protected function getHeadersFromEeNotices()
262			{
263			$headers = array();
264			$notices = EE_Error::get_raw_notices();
265			foreach ($notices as $notice_type => $sub_notices) {
266			if (! is_array($sub_notices)) {
267			continue;
268			}
269			foreach ($sub_notices as $notice_code => $sub_notice) {
270			$headers['X-EE4-Notices-'
271			. EEH_Inflector::humanize($notice_type)
272			. '['
273			. $notice_code
274			. ']'] = strip_tags($sub_notice);
275			}
276			}
277			return apply_filters(
278			'FHEE__EventEspresso\core\libraries\rest_api\controllers\Base___get_headers_from_ee_notices__return',
279			$headers,
280			$this->requested_version,
281			$notices
282			);
283			}
284
285
286
287			/**
288			* Finds which version of the API was requested given the route, and returns it.
289			* eg in a request to "mysite.com/wp-json/ee/v4.8.29/events/123" this would return
290			* "4.8.29".
291			* We should know hte requested version in this model though, so if no route is
292			* provided just use what we set earlier
293			*
294			* @param string $route
295			* @return string
296			*/
297			public function getRequestedVersion($route = null)
298			{
299			if ($route === null) {
300			return $this->requested_version;
301			}
302			$matches = $this->parseRoute(
303			$route,
304			'~' . EED_Core_Rest_Api::ee_api_namespace_for_regex . '~',
305			array('version')
306			);
307			if (isset($matches['version'])) {
308			return $matches['version'];
309			} else {
310			return EED_Core_Rest_Api::latest_rest_api_version();
			0 ignored issues – show Comprehensibility Best Practice introduced 2017-03-21 22:07 UTC by Report Bug Copy Issue Report The expression `\EED_Core_Rest_Api::latest_rest_api_version();` of type `integer\|string\|false` adds `false` to the return on line 310 which is incompatible with the return type documented by `EventEspresso\core\libra...se::getRequestedVersion` of type `string`. It seems like you forgot to handle an error condition. Loading history...
311			}
312			}
313
314
315
316			/**
317			* Applies the regex to the route, then creates an array using the values of
318			* $match_keys as keys (but ignores the full pattern match). Returns the array of matches.
319			* For example, if you call
320			* parse_route( '/ee/v4.8/events', '~\/ee\/v([^/])\/(.)~', array( 'version', 'model' ) )
321			* it will return array( 'version' => '4.8', 'model' => 'events' )
322			*
323			* @param string $route
324			* @param string $regex
325			* @param array $match_keys EXCLUDING matching the entire regex
326			* @return array where $match_keys are the keys (the first value of $match_keys
327			* becomes the first key of the return value, etc. Eg passing in $match_keys of
328			* array( 'model', 'id' ), will, if the regex is successful, will return
329			* array( 'model' => 'foo', 'id' => 'bar' )
330			* @throws EE_Error if it couldn't be parsed
331			*/
332			public function parseRoute($route, $regex, $match_keys)
333			{
334			$indexed_matches = array();
335			$success = preg_match($regex, $route, $matches);
336			if (is_array($matches)) {
337			//skip the overall regex match. Who cares
338			for ($i = 1; $i <= count($match_keys); $i++) {
			0 ignored issues – show Performance Best Practice introduced 2015-12-12 07:26 UTC by Report Bug Copy Issue Report It seems like you are calling the size function `count()` as part of the test condition. You might want to compute the size beforehand, and not on each iteration. If the size of the collection does not change during the iteration, it is generally a good practice to compute it beforehand, and not on each iteration: for ($i=0; $i<count($array); $i++) { // calls count() on each iteration } // Better for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once } Loading history...
339			if (! isset($matches[$i])) {
340			$success = false;
341			} else {
342			$indexed_matches[$match_keys[$i - 1]] = $matches[$i];
343			}
344			}
345			}
346			if (! $success) {
			0 ignored issues – show Bug Best Practice introduced 2015-12-12 07:26 UTC by Report Bug Copy Issue Report The expression `$success` of type `integer\|false` is loosely compared to `false`; this is ambiguous if the integer can be zero. You might want to explicitly use `=== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
347			throw new EE_Error(
348			__('We could not parse the URL. Please contact Event Espresso Support', 'event_espresso'),
349			'endpoint_parsing_error'
350			);
351			}
352			return $indexed_matches;
353			}
354
355
356
357			/**
358			* Gets the body's params (either from JSON or parsed body), which EXCLUDES the GET params and URL params
359			*
360			* @param \WP_REST_Request $request
361			* @return array
362			*/
363			protected function getBodyParams(\WP_REST_Request $request)
364			{
365			//$request->get_params();
366			return array_merge(
367			(array)$request->get_body_params(),
368			(array)$request->get_json_params()
369			);
370			// return array_diff_key(
371			// $request->get_params(),
372			// $request->get_url_params(),
373			// $request->get_query_params()
374			// );
375			}
376			}
377
378			// End of file Base.php
379

eventespresso / event-espresso-core

Branch — BUG-10738-inconsistency-in-ses... (cda363)

Base B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

12 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like