Read - Code Metrics - Inspection of "Daily Inspection: [touch:9625]{t:10}also pass paym..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Branch — BUG-9625-better-us-phone-valid... (e0ce21)

unknown
created 2016-06-04 21:37 UTC
Read F

↳ Parent: Project
Complexity

Total Complexity
113
Size/Duplication

Total Lines	921
Duplicated Lines	10.53 %
Coupling/Cohesion

Components	1
Dependencies	16
Importance

Changes	3
Bugs	1	Features	0
Metric	Value
wmc	113
c	3
b	1
f	0
lcom	1
cbo	16
dl	97
loc	921
rs	1.0434
23 Methods

Rating	Name	Duplication	Size	Complexity
B	handle_request_get_all()	31	31	3
B	handle_request_get_one()	30	30	3
B	get_entities_from_model()	0	29	4
C	get_entities_from_relation()	0	80	10
B	_set_headers_from_query_params()	0	25	4
C	_include_requested_models()	0	51	9
A	__construct()	0	5	1
B	handle_request_get_related()	0	51	5
B	create_entity_from_wpdb_result()	0	43	3
B	_create_bare_entity_from_wpdb_results()	0	38	6
A	_add_extra_fields()	0	6	2
B	_get_entity_links()	0	46	6
A	_remove_model_names_from_array()	0	3	1
B	_get_entity_calculations()	0	31	3
A	get_versioned_link_to()	0	8	1
A	get_related_entity_name()	0	7	2
B	get_entity_from_model()	0	41	4
A	validate_context()	0	11	3
A	prepare_rest_query_params_key_for_models()	11	11	3
A	prepare_rest_query_params_values_for_models()	11	11	3
C	explode_and_get_items_prefixed_with()	0	34	8
C	extract_includes_for_this_model()	0	35	11
F	create_model_query_params()	14	72	18
How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class
Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.
Complex classes like Read often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use Read, and based on these observations, apply Extract Interface, too.
<?php
namespace EventEspresso\core\libraries\rest_api\controllers\model;

use EventEspresso\core\libraries\rest_api\Capabilities;
use EventEspresso\core\libraries\rest_api\Calculated_Model_Fields;
use EventEspresso\core\libraries\rest_api\Rest_Exception;
use EventEspresso\core\libraries\rest_api\Model_Data_Translator;

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

/**
 *
 * Read controller for models
 *
 * Handles requests relating to GET-ting model information
 *
 * @package			Event Espresso
 * @subpackage
 * @author				Mike Nelson
 *
 */
class Read extends Base {



	/**
	 *
	 * @var Calculated_Model_Fields
	 */
	protected $_fields_calculator;



	/**
	 * Read constructor.
	 */
	public function __construct() {
		parent::__construct();
		\EE_Registry::instance()->load_helper( 'Inflector' );
		$this->_fields_calculator = new Calculated_Model_Fields();
	}

	/**
	 * Handles requests to get all (or a filtered subset) of entities for a particular model
	 * @param \WP_REST_Request $request
	 * @return \WP_REST_Response|\WP_Error
	 */
	public static function handle_request_get_all( \WP_REST_Request $request) {

		$controller = new Read();
		try{
			$matches = $controller->parse_route(
				$request->get_route(),
				'~' . \EED_Core_Rest_Api::ee_api_namespace_for_regex . '(.*)~',
				array( 'version', 'model' )
			);
			$controller->set_requested_version( $matches[ 'version' ] );
			$model_name_singular = \EEH_Inflector::singularize_and_upper( $matches[ 'model' ] );
			if ( ! $controller->get_model_version_info()->is_model_name_in_this_version( $model_name_singular ) ) {
				return $controller->send_response(
					new \WP_Error(
						'endpoint_parsing_error',
						sprintf(
							__( 'There is no model for endpoint %s. Please contact event espresso support', 'event_espresso' ),
							$model_name_singular
						)
					)
				);
			}
			return $controller->send_response(
					$controller->get_entities_from_model(
							$controller->get_model_version_info()->load_model( $model_name_singular ),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
							$request
					)
			);
		} catch( \Exception $e ) {
			return $controller->send_response( $e );
		}
	}

	/**
	 * Gets a single entity related to the model indicated in the path and its id
	 *
	 * @param \WP_REST_Request $request
	 * @return \WP_REST_Response|\WP_Error
	 */
	public static function handle_request_get_one( \WP_REST_Request $request ) {

		$controller = new Read();
		try{
			$matches = $controller->parse_route(
				$request->get_route(),
				'~' . \EED_Core_Rest_Api::ee_api_namespace_for_regex . '(.*)/(.*)~',
				array( 'version', 'model', 'id' ) );
			$controller->set_requested_version( $matches[ 'version' ] );
			$model_name_singular = \EEH_Inflector::singularize_and_upper( $matches[ 'model' ] );
			if ( ! $controller->get_model_version_info()->is_model_name_in_this_version( $model_name_singular ) ) {
				return $controller->send_response(
					new \WP_Error(
						'endpoint_parsing_error',
						sprintf(
							__( 'There is no model for endpoint %s. Please contact event espresso support', 'event_espresso' ),
							$model_name_singular
						)
					)
				);
			}
			return $controller->send_response(
					$controller->get_entity_from_model(
							$controller->get_model_version_info()->load_model( $model_name_singular ),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
							$request
						)
				);
		} catch( \Exception $e ) {
			return $controller->send_response( $e );
		}
	}

	/**
	 *
	 * Gets all the related entities (or if its a belongs-to relation just the one)
	 * to the item with the given id
	 *
	 * @param \WP_REST_Request $request
	 * @return \WP_REST_Response|\WP_Error
	 */
	public static function handle_request_get_related( \WP_REST_Request $request ) {
		$controller = new Read();
		try{
			$matches = $controller->parse_route(
				$request->get_route(),
				'~' . \EED_Core_Rest_Api::ee_api_namespace_for_regex . '(.*)/(.*)/(.*)~',
				array( 'version', 'model', 'id', 'related_model' )
			);
			$controller->set_requested_version( $matches[ 'version' ] );
			$main_model_name_singular = \EEH_Inflector::singularize_and_upper( $matches[ 'model' ] );
			if ( ! $controller->get_model_version_info()->is_model_name_in_this_version( $main_model_name_singular ) ) {
				return $controller->send_response(
					new \WP_Error(
						'endpoint_parsing_error',
						sprintf(
							__( 'There is no model for endpoint %s. Please contact event espresso support', 'event_espresso' ),
							$main_model_name_singular
						)
					)
				);
			}
			$main_model = $controller->get_model_version_info()->load_model( $main_model_name_singular );
			//assume the related model name is plural and try to find the model's name
			$related_model_name_singular = \EEH_Inflector::singularize_and_upper( $matches[ 'related_model' ] );
			if ( ! $controller->get_model_version_info()->is_model_name_in_this_version( $related_model_name_singular ) ) {
				//so the word didn't singularize well. Maybe that's just because it's a singular word?
				$related_model_name_singular = \EEH_Inflector::humanize( $matches[ 'related_model' ] );
			}
			if ( ! $controller->get_model_version_info()->is_model_name_in_this_version( $related_model_name_singular ) ) {
				return $controller->send_response(
					new \WP_Error(
						'endpoint_parsing_error',
						sprintf(
							__( 'There is no model for endpoint %s. Please contact event espresso support', 'event_espresso' ),
							$related_model_name_singular
						)
					)
				);
			}

			return $controller->send_response(
					$controller->get_entities_from_relation(
						$request->get_param( 'id' ),
						$main_model->related_settings_for( $related_model_name_singular ) ,

						$request
					)
				);
		} catch( \Exception $e ) {
			return $controller->send_response( $e );
		}
	}



	/**
	 * Gets a collection for the given model and filters
	 *
	 * @param \EEM_Base $model
	 * @param \WP_REST_Request $request
	 * @return array
	 */
	public function get_entities_from_model( $model, $request) {
		$query_params = $this->create_model_query_params( $model, $request->get_params() );
		if( ! Capabilities::current_user_has_partial_access_to( $model, $query_params[ 'caps' ] ) ) {
			$model_name_plural = \EEH_Inflector::pluralize_and_lower( $model->get_this_model_name() );
			return new \WP_Error(
				sprintf( 'rest_%s_cannot_list', $model_name_plural ),
				sprintf(
					__( 'Sorry, you are not allowed to list %1$s. Missing permissions: %2$s', 'event_espresso' ),
					$model_name_plural,
					Capabilities::get_missing_permissions_string( $model, $query_params[ 'caps' ] )
				),
				array( 'status' => 403 )
			);
		}
		if( ! $request->get_header( 'no_rest_headers' ) ) {
			$this->_set_headers_from_query_params( $model, $query_params );
		}
		/** @type array $results */
		$results = $model->get_all_wpdb_results( $query_params );
		$nice_results = array( );
		foreach ( $results as $result ) {
			$nice_results[ ] = $this->create_entity_from_wpdb_result(
					$model,
					$result,
					$request
				);
		}
		return $nice_results;
	}

	/**
	 * Gets the collection for given relation object
	 *
	 * The same as Read::get_entities_from_model(), except if the relation
	 * is a HABTM relation, in which case it merges any non-foreign-key fields from
	 * the join-model-object into the results
	 *
	 * @param string $id the ID of the thing we are fetching related stuff from
	 * @param \EE_Model_Relation_Base $relation
	 * @param \WP_REST_Request $request
	 * @return array
	 */
	public function get_entities_from_relation( $id,  $relation, $request ) {
		$context = $this->validate_context( $request->get_param( 'caps' ));
		$model = $relation->get_this_model();
		$related_model = $relation->get_other_model();
		//check if they can access the 1st model object
		$query_params = array( array( $model->primary_key_name() => $id ),'limit' => 1 );

		if( $model instanceof \EEM_Soft_Delete_Base ){
			$query_params = $model->alter_query_params_so_deleted_and_undeleted_items_included($query_params);
		}
		$restricted_query_params = $query_params;
		$restricted_query_params[ 'caps' ] = $context;
		$this->_set_debug_info( 'main model query params', $restricted_query_params );
		$this->_set_debug_info( 'missing caps', Capabilities::get_missing_permissions_string( $related_model, $context ) );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

		if(
			! (
				Capabilities::current_user_has_partial_access_to( $related_model, $context )
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
				&& $model->exists( $restricted_query_params )

			)
		){
			if( $relation instanceof \EE_Belongs_To_Relation ) {
				$related_model_name_maybe_plural = strtolower( $related_model->get_this_model_name() );

			}else{
				$related_model_name_maybe_plural = \EEH_Inflector::pluralize_and_lower( $related_model->get_this_model_name() );

			}
			return new \WP_Error(
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
				sprintf( 'rest_%s_cannot_list', $related_model_name_maybe_plural ),
				sprintf(
					__(	'Sorry, you are not allowed to list %1$s related to %2$s. Missing permissions: %3$s', 'event_espresso' ),
					$related_model_name_maybe_plural,
					$relation->get_this_model()->get_this_model_name(),

					implode(
						',',
						array_keys(
							Capabilities::get_missing_permissions( $related_model, $context )
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
						)
					)
				),
				array( 'status' => 403 )
			);
		}
		$query_params = $this->create_model_query_params( $relation->get_other_model(), $request->get_params() );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$query_params[0][ $relation->get_this_model()->get_this_model_name() . '.' . $relation->get_this_model()->primary_key_name() ] = $id;

		$query_params[ 'default_where_conditions' ] = 'none';
		$query_params[ 'caps' ] = $context;
		if( ! $request->get_header( 'no_rest_headers' ) ) {
			$this->_set_headers_from_query_params( $relation->get_other_model(), $query_params );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		}
		/** @type array $results */
		$results = $relation->get_other_model()->get_all_wpdb_results( $query_params );

		$nice_results = array();
		foreach( $results as $result ) {
			$nice_result = $this->create_entity_from_wpdb_result(
				$relation->get_other_model(),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
				$result,
				$request
			);
			if( $relation instanceof \EE_HABTM_Relation ) {
				//put the unusual stuff (properties from the HABTM relation) first, and make sure
				//if there are conflicts we prefer the properties from the main model
				$join_model_result = $this->create_entity_from_wpdb_result(
					$relation->get_join_model(),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
					$result,
					$request
				);
				$joined_result = array_merge( $nice_result, $join_model_result );
				//but keep the meta stuff from the main model
				if( isset( $nice_result['meta'] ) ){
					$joined_result['meta'] = $nice_result['meta'];
				}
				$nice_result = $joined_result;
			}
			$nice_results[] = $nice_result;
		}
		if( $relation instanceof \EE_Belongs_To_Relation ){
			return array_shift( $nice_results );
		}else{
			return $nice_results;
		}
	}

	/**
	 * Sets the headers that are based on the model and query params,
	 * like the total records. This should only be called on the original request
	 * from the client, not on subsequent internal
	 * @param \EEM_Base $model
	 * @param array $query_params
	 * @return void
	 */
	protected function _set_headers_from_query_params( $model, $query_params ) {
		$this->_set_debug_info( 'model query params', $query_params );
		$this->_set_debug_info( 'missing caps', Capabilities::get_missing_permissions_string( $model, $query_params[ 'caps' ] ) );
		//normally the limit to a 2-part array, where the 2nd item is the limit
		if( ! isset( $query_params[ 'limit' ] ) ) {
			$query_params[ 'limit' ] = \EED_Core_Rest_Api::get_default_query_limit();
		}
		if( is_array( $query_params[ 'limit' ] )  ) {
			$limit_parts = $query_params[ 'limit' ];
		} else {
			$limit_parts = explode(',', $query_params[ 'limit' ] );
			if( count( $limit_parts ) == 1 ){
				$limit_parts = array(0, $limit_parts[ 0 ] );
			}
		}
		//remove the group by and having parts of the query, as those will
		//make the sql query return an array of values, instead of just a single value
		unset( $query_params[ 'group_by' ], $query_params[ 'having' ], $query_params[ 'limit' ] );
		$count = $model->count( $query_params, null, true );

		$pages = $count / $limit_parts[ 1 ];
		$this->_set_response_header( 'Total', $count, false );
		$this->_set_response_header( 'PageSize', $limit_parts[ 1 ], false );
		$this->_set_response_header( 'TotalPages', ceil( $pages ), false );
	}



	/**
	 * Changes database results into REST API entities
	 * @param \EEM_Base $model
	 * @param array $db_row like results from $wpdb->get_results()
	 * @param \WP_REST_Request $rest_request
	 * @param string $deprecated no longer used
	 * @return array ready for being converted into json for sending to client
	 */
	public function create_entity_from_wpdb_result( $model, $db_row, $rest_request, $deprecated = null ) {
		if( ! $rest_request instanceof \WP_REST_Request ) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
			//ok so this was called in the old style, where the 3rd arg was
			//$include, and the 4th arg was $context
			//now setup the request just to avoid fatal errors, although we won't be able
			//to truly make use of it because it's kinda devoid of info
			$rest_request = new \WP_REST_Request();
			$rest_request->set_param( 'include', $rest_request );
			$rest_request->set_param( 'caps', $deprecated );
		}
		if( $rest_request->get_param( 'caps' ) == null ) {
			$rest_request->set_param( 'caps', \EEM_Base::caps_read );
		}
		$entity_array = $this->_create_bare_entity_from_wpdb_results( $model, $db_row );
		$entity_array = $this->_add_extra_fields( $model, $db_row, $entity_array );
		$entity_array[ '_links' ] = $this->_get_entity_links( $model, $db_row, $entity_array );
		$entity_array[ '_calculated_fields'] = $this->_get_entity_calculations( $model, $db_row, $rest_request );
		$entity_array = $this->_include_requested_models( $model, $rest_request, $entity_array );
		$entity_array = apply_filters(
			'FHEE__Read__create_entity_from_wpdb_results__entity_before_inaccessible_field_removal',
			$entity_array,
			$model,
			$rest_request->get_param( 'caps' ),
			$rest_request,
			$this
		);
		$result_without_inaccessible_fields = Capabilities::filter_out_inaccessible_entity_fields(
			$entity_array,
			$model,
			$rest_request->get_param( 'caps' ),
			$this->get_model_version_info()
		);
		$this->_set_debug_info(
			'inaccessible fields',
			array_keys( array_diff_key( $entity_array, $result_without_inaccessible_fields ) )
		);
		return apply_filters(
			'FHEE__Read__create_entity_from_wpdb_results__entity_return',
			$result_without_inaccessible_fields,
			$model,
			$rest_request->get_param( 'caps' )
		);
	}

	/**
	 * Creates a REST entity array (JSON object we're going to return in the response, but
	 * for now still a PHP array, but soon enough we'll call json_encode on it, don't worry),
	 * from $wpdb->get_row( $sql, ARRAY_A)
	 * @param \EEM_Base $model
	 * @param array $db_row
	 * @return array entity mostly ready for converting to JSON and sending in the response
	 */
	protected function _create_bare_entity_from_wpdb_results( \EEM_Base $model, $db_row ) {
		$result = $model->deduce_fields_n_values_from_cols_n_values( $db_row );
		$result = array_intersect_key( $result, $this->get_model_version_info()->fields_on_model_in_this_version( $model ) );
		foreach( $result as $field_name => $raw_field_value ) {
			$field_obj = $model->field_settings_for($field_name);
			$field_value = $field_obj->prepare_for_set_from_db( $raw_field_value );
			if( $this->is_subclass_of_one(  $field_obj, $this->get_model_version_info()->fields_ignored() ) ){
				unset( $result[ $field_name ] );
			}elseif(
				$this->is_subclass_of_one( $field_obj, $this->get_model_version_info()->fields_that_have_rendered_format() )
			){
				$result[ $field_name ] = array(
					'raw' => $field_obj->prepare_for_get( $field_value ),
					'rendered' => $field_obj->prepare_for_pretty_echoing( $field_value )
				);
			}elseif(
				$this->is_subclass_of_one( $field_obj, $this->get_model_version_info()->fields_that_have_pretty_format() )
			){
				$result[ $field_name ] = array(
					'raw' => $field_obj->prepare_for_get( $field_value ),
					'pretty' => $field_obj->prepare_for_pretty_echoing( $field_value )
				);
			} elseif ( $field_obj instanceof \EE_Datetime_Field ) {
				$result[ $field_name ] = Model_Data_Translator::prepare_field_value_for_json(
					$field_obj,
					$field_value,
					$this->get_model_version_info()->requested_version()
				);
			} else {
				$result[ $field_name ] = Model_Data_Translator::prepare_field_value_for_json(
					$field_obj,
					$field_obj->prepare_for_get( $field_value ),
					$this->get_model_version_info()->requested_version()
				);
			}
		}
		return $result;
	}

	/**
	 * Adds a few extra fields to the entity response
	 * @param \EEM_Base $model
	 * @param array $db_row
	 * @param array $entity_array
	 * @return array modified entity
	 */
	protected function _add_extra_fields( \EEM_Base $model, $db_row, $entity_array ) {
		if( $model instanceof \EEM_CPT_Base ) {
			$entity_array[ 'link' ] = get_permalink( $db_row[ $model->get_primary_key_field()->get_qualified_column() ] );
		}
		return $entity_array;
	}

	/**
	 * Gets links we want to add to the response
	 *
*@global \WP_REST_Server $wp_rest_server
	 * @param \EEM_Base $model
	 * @param array $db_row
	 * @param array $entity_array
	 * @return array the _links item in the entity
	 */
	protected function _get_entity_links( $model, $db_row, $entity_array ) {
		//add basic links
		$links = array(
			'self' => array(
				array(
					'href' => $this->get_versioned_link_to(
						\EEH_Inflector::pluralize_and_lower( $model->get_this_model_name() ) . '/' . $entity_array[ $model->primary_key_name() ]
					)
				)
			),
			'collection' => array(
				array(
					'href' => $this->get_versioned_link_to(
						\EEH_Inflector::pluralize_and_lower( $model->get_this_model_name() )
					)
				)
			),
		);

		//add link to the wp core endpoint, if wp api is active
		global $wp_rest_server;
		if( $model instanceof \EEM_CPT_Base &&
			$wp_rest_server instanceof \WP_REST_Server &&
if ($x instanceof DoesNotExist) {
    // Do something.
}
			$wp_rest_server->get_route_options( '/wp/v2/posts' ) ) {
			$links[ \EED_Core_Rest_Api::ee_api_link_namespace . 'self_wp_post' ] = array(
				array(
					'href' => rest_url( '/wp/v2/posts/' . $db_row[ $model->get_primary_key_field()->get_qualified_column() ] ),
					'single' => true
				)
			);
		}

		//add links to related models
		foreach( $this->get_model_version_info()->relation_settings( $model ) as $relation_name => $relation_obj ) {
			$related_model_part = Read::get_related_entity_name( $relation_name, $relation_obj );
			$links[ \EED_Core_Rest_Api::ee_api_link_namespace . $related_model_part ] = array(
				array(
					'href' => $this->get_versioned_link_to(
						\EEH_Inflector::pluralize_and_lower( $model->get_this_model_name() ) . '/' . $entity_array[ $model->primary_key_name() ] . '/' . $related_model_part
					),
					'single' => $relation_obj instanceof \EE_Belongs_To_Relation ? true : false
				)
			);
		}
		return $links;
	}

	/**
	 * Adds the included models indicated in the request to the entity provided
	 * @param \EEM_Base $model
	 * @param \WP_REST_Request $rest_request
	 * @param array $entity_array
	 * @return array the modified entity
	 */
	protected function _include_requested_models( \EEM_Base $model, \WP_REST_Request $rest_request, $entity_array ) {
		$includes_for_this_model = $this->explode_and_get_items_prefixed_with( $rest_request->get_param( 'include' ), '' );
		$includes_for_this_model = $this->_remove_model_names_from_array( $includes_for_this_model );
		//if they passed in * or didn't specify any includes, return everything
		if( ! in_array( '*', $includes_for_this_model )
			&& ! empty( $includes_for_this_model ) ) {
			if( $model->has_primary_key_field() ) {
				//always include the primary key. ya just gotta know that at least
				$includes_for_this_model[] = $model->primary_key_name();
			}
			if( $this->explode_and_get_items_prefixed_with( $rest_request->get_param( 'calculate' ), '' ) ) {
				$includes_for_this_model[] = '_calculated_fields';
			}
			$entity_array = array_intersect_key( $entity_array, array_flip( $includes_for_this_model ) );
		}
		$relation_settings = $this->get_model_version_info()->relation_settings( $model );
		foreach( $relation_settings as $relation_name => $relation_obj ) {
			$related_fields_to_include = $this->explode_and_get_items_prefixed_with(
				$rest_request->get_param( 'include' ),
				$relation_name
			);
			$related_fields_to_calculate = $this->explode_and_get_items_prefixed_with(
				$rest_request->get_param( 'calculate' ),
				$relation_name
			);
			//did they specify they wanted to include a related model, or
			//specific fields from a related model?
			//or did they specify to calculate a field from a related model?
			if( $related_fields_to_include || $related_fields_to_calculate ) {

				//if so, we should include at least some part of the related model
				$pretend_related_request = new \WP_REST_Request();
				$pretend_related_request->set_query_params(
					array(
						'caps' => $rest_request->get_param( 'caps' ),
						'include' => $related_fields_to_include,
						'calculate' => $related_fields_to_calculate,
					)
				);
				$pretend_related_request->add_header( 'no_rest_headers', true );
				$related_results = $this->get_entities_from_relation(
					$entity_array[ $model->primary_key_name() ],
					$relation_obj,
					$pretend_related_request
				);
				$entity_array[ Read::get_related_entity_name( $relation_name, $relation_obj ) ] = $related_results instanceof \WP_Error
if ($x instanceof DoesNotExist) {
    // Do something.
}
					? null
					: $related_results;
			}
		}
		return $entity_array;
	}

	/**
	 * Returns a new array with all the names of models removed. Eg
	 * array( 'Event', 'Datetime.*', 'foobar' ) would become array( 'Datetime.*', 'foobar' )
	 * @param array $arr
	 * @return array
	 */
	private function _remove_model_names_from_array( $arr ) {
		return array_diff( $arr, array_keys( \EE_Registry::instance()->non_abstract_db_models ) );
	}
	/**
	 * Gets the calculated fields for the response
	 *
	 * @param \EEM_Base        $model
	 * @param array            $wpdb_row
	 * @param \WP_REST_Request $rest_request
	 * @return array the _calculations item in the entity
	 */
	protected function _get_entity_calculations( $model, $wpdb_row, $rest_request ) {
		$calculated_fields = $this->explode_and_get_items_prefixed_with(
			$rest_request->get_param( 'calculate' ),
			''
		);
		//note: setting calculate=* doesn't do anything
		$calculated_fields_to_return = new \stdClass();
		foreach( $calculated_fields as $field_to_calculate ) {
			try{
				$calculated_fields_to_return->$field_to_calculate = Model_Data_Translator::prepare_field_value_for_json(
					null,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
					$this->_fields_calculator->retrieve_calculated_field_value(
						$model,
						$field_to_calculate,
						$wpdb_row,
						$rest_request,
						$this
					),
					$this->get_model_version_info()->requested_version()
				);
			} catch( Rest_Exception $e ) {
				//if we don't have permission to read it, just leave it out. but let devs know about the problem
				$this->_set_response_header(
					'Notices-Field-Calculation-Errors[' . $e->get_string_code() . '][' . $model->get_this_model_name() . '][' . $field_to_calculate . ']',
					$e->getMessage(),
					true
				);
			}
		}
		return $calculated_fields_to_return;
	}

	/**
	 * Gets the full URL to the resource, taking the requested version into account
	 * @param string $link_part_after_version_and_slash eg "events/10/datetimes"
	 * @return string url eg "http://mysite.com/wp-json/ee/v4.6/events/10/datetimes"
	 */
	public function get_versioned_link_to( $link_part_after_version_and_slash ) {
		return rest_url(
			\EED_Core_Rest_Api::ee_api_namespace
			. $this->get_model_version_info()->requested_version()
			. '/'
			. $link_part_after_version_and_slash
		);
	}

	/**
	 * Gets the correct lowercase name for the relation in the API according
	 * to the relation's type
	 * @param string $relation_name
	 * @param \EE_Model_Relation_Base $relation_obj
	 * @return string
	 */
	public static function get_related_entity_name( $relation_name, $relation_obj ){
		if( $relation_obj instanceof \EE_Belongs_To_Relation ) {
			return strtolower( $relation_name );
		}else{
			return \EEH_Inflector::pluralize_and_lower( $relation_name );
		}
	}

//	public function


	/**
	 * Gets the one model object with the specified id for the specified model
	 * @param \EEM_Base $model
	 * @param \WP_REST_Request $request
	 * @return array
	 */
	public function get_entity_from_model( $model, $request ) {
		$query_params = array( array( $model->primary_key_name() => $request->get_param( 'id' ) ),'limit' => 1);
		if( $model instanceof \EEM_Soft_Delete_Base ){
			$query_params = $model->alter_query_params_so_deleted_and_undeleted_items_included($query_params);
		}
		$restricted_query_params = $query_params;
		$restricted_query_params[ 'caps' ] =  $this->validate_context(  $request->get_param( 'caps' ) );
		$this->_set_debug_info( 'model query params', $restricted_query_params );
		$model_rows = $model->get_all_wpdb_results( $restricted_query_params );
		if ( ! empty ( $model_rows ) ) {
			return $this->create_entity_from_wpdb_result(
				$model,
				array_shift( $model_rows ),
				$request );
		} else {
			//ok let's test to see if we WOULD have found it, had we not had restrictions from missing capabilities
			$lowercase_model_name = strtolower( $model->get_this_model_name() );
			$model_rows_found_sans_restrictions = $model->get_all_wpdb_results( $query_params );
			if( ! empty( $model_rows_found_sans_restrictions ) ) {
				//you got shafted- it existed but we didn't want to tell you!
				return new \WP_Error(
					'rest_user_cannot_read',
					sprintf(
						__( 'Sorry, you cannot read this %1$s. Missing permissions are: %2$s', 'event_espresso' ),
						strtolower( $model->get_this_model_name() ),
						Capabilities::get_missing_permissions_string(
							$model,
							$this->validate_context( $request->get_param( 'caps' ) ) )
					),
					array( 'status' => 403 )
				);
			} else {
				//it's not you. It just doesn't exist
				return new \WP_Error(
					sprintf( 'rest_%s_invalid_id', $lowercase_model_name ),
					sprintf( __( 'Invalid %s ID.', 'event_espresso' ), $lowercase_model_name ),
					array( 'status' => 404 )
				);
			}
		}
	}

	/**
	 * If a context is provided which isn't valid, maybe it was added in a future
	 * version so just treat it as a default read
	 *
	 * @param string $context
	 * @return string array key of EEM_Base::cap_contexts_to_cap_action_map()
	 */
	public function validate_context( $context ) {
		if( ! $context ) {
			$context = \EEM_Base::caps_read;
		}
		$valid_contexts = \EEM_Base::valid_cap_contexts();
		if( in_array( $context, $valid_contexts )  ){
			return $context;
		}else{
			return \EEM_Base::caps_read;
		}
	}



	/**
	 * Translates API filter get parameter into $query_params array used by EEM_Base::get_all().
	 * Note: right now the query parameter keys for fields (and related fields)
	 * can be left as-is, but it's quite possible this will change someday.
	 * Also, this method's contents might be candidate for moving to Model_Data_Translator
	 *
	 * @param \EEM_Base $model
	 * @param array     $query_parameters from $_GET parameter @see Read:handle_request_get_all
	 * @return array like what EEM_Base::get_all() expects or FALSE to indicate
	 *                          that absolutely no results should be returned
	 * @throws \EE_Error
	 */
	public function create_model_query_params( $model, $query_parameters ) {
		$model_query_params = array( );
		if ( isset( $query_parameters[ 'where' ] ) ) {
			$model_query_params[ 0 ] = Model_Data_Translator::prepare_conditions_query_params_for_models(
				$query_parameters[ 'where' ],
				$model,
				$this->get_model_version_info()->requested_version()
			);
		}
		if ( isset( $query_parameters[ 'order_by' ] ) ) {
			$order_by = $query_parameters[ 'order_by' ];
		} elseif ( isset( $query_parameters[ 'orderby' ] ) ) {
			$order_by = $query_parameters[ 'orderby' ];
		}else{
			$order_by = null;
		}
		if( $order_by !== null ){
			$model_query_params[ 'order_by' ] =  $order_by;
		}
		if ( isset( $query_parameters[ 'group_by' ] ) ) {
			$group_by = $query_parameters[ 'group_by' ];
		} elseif ( isset( $query_parameters[ 'groupby' ] ) ) {
			$group_by = $query_parameters[ 'groupby' ];
		}else{
			$group_by = array_keys( $model->get_combined_primary_key_fields() );
		}
		if( $group_by !== null ){
			$model_query_params[ 'group_by' ] = $group_by;
		}
		if ( isset( $query_parameters[ 'having' ] ) ) {
			$model_query_params[ 'having' ] = Model_Data_Translator::prepare_conditions_query_params_for_models(
				$query_parameters[ 'having' ],
				$model,
				$this->get_model_version_info()->requested_version()
			);
		}
		if ( isset( $query_parameters[ 'order' ] ) ) {
			$model_query_params[ 'order' ] = $query_parameters[ 'order' ];
		}
		if ( isset( $query_parameters[ 'mine' ] ) ){
			$model_query_params = $model->alter_query_params_to_only_include_mine( $model_query_params );
		}
		if( isset( $query_parameters[ 'limit' ] ) ) {
			//limit should be either a string like '23' or '23,43', or an array with two items in it
			if( ! is_array( $query_parameters[ 'limit' ] ) ) {
				$limit_array = explode(',', (string)$query_parameters['limit']);
			}else {
				$limit_array = $query_parameters[ 'limit' ];
			}
			$sanitized_limit = array();
			foreach( $limit_array as $key => $limit_part ) {
				if( $this->_debug_mode && ( ! is_numeric( $limit_part ) || count( $sanitized_limit ) > 2 ) ) {
					throw new \EE_Error(
						sprintf(
							__( 'An invalid limit filter was provided. It was: %s. If the EE4 JSON REST API weren\'t in debug mode, this message would not appear.', 'event_espresso' ),
							json_encode( $query_parameters[ 'limit' ] )
						)
					);
				}
				$sanitized_limit[] = (int)$limit_part;
			}
			$model_query_params[ 'limit' ] = implode( ',', $sanitized_limit );
		}else{
			$model_query_params[ 'limit' ] = \EED_Core_Rest_Api::get_default_query_limit();
		}
		if( isset( $query_parameters[ 'caps' ] ) ) {
			$model_query_params[ 'caps' ] = $this->validate_context( $query_parameters[ 'caps' ] );
		}else{
			$model_query_params[ 'caps' ] = \EEM_Base::caps_read;
		}
		return apply_filters( 'FHEE__Read__create_model_query_params', $model_query_params, $query_parameters, $model );
	}



	/**
	 * Changes the REST-style query params for use in the models
	 * @deprecated
	 * @param \EEM_Base $model
	 * @param array     $query_params sub-array from @see EEM_Base::get_all()
	 * @return array
	 */
	public function prepare_rest_query_params_key_for_models( $model,  $query_params ) {

		$model_ready_query_params = array();
		foreach( $query_params as $key => $value ) {
			if( is_array( $value ) ) {
				$model_ready_query_params[ $key ] = $this->prepare_rest_query_params_key_for_models( $model, $value );

			}else{
				$model_ready_query_params[ $key ] = $value;
			}
		}
		return $model_ready_query_params;
	}



	/**
	 * @deprecated
	 * @param $model
	 * @param $query_params
	 * @return array
	 */
	public function prepare_rest_query_params_values_for_models( $model, $query_params ) {

		$model_ready_query_params = array();
		foreach( $query_params as $key => $value ) {
			if( is_array( $value ) ) {
				$model_ready_query_params[ $key ] = $this->prepare_rest_query_params_values_for_models( $model, $value );

			} else {
				$model_ready_query_params[ $key ] = $value;
			}
		}
		return $model_ready_query_params;
	}

	/**
	 * Explodes the string on commas, and only returns items with $prefix followed by a period.
	 * If no prefix is specified, returns items with no period.
	 * @param string|array $string_to_explode eg "jibba,jabba, blah, blaabla" or array('jibba', 'jabba' )
	 * @param string $prefix "Event" or "foobar"
	 * @return array $string_to_exploded exploded on COMMAS, and if a prefix was specified
	 * we only return strings starting with that and a period; if no prefix was specified
	 * we return all items containing NO periods
	 */
	public function explode_and_get_items_prefixed_with( $string_to_explode, $prefix ) {
		if( is_string( $string_to_explode ) ) {
			$exploded_contents = explode( ',', $string_to_explode );
		} else if( is_array( $string_to_explode ) ) {
			$exploded_contents = $string_to_explode;
		} else {
			$exploded_contents = array();
		}
		//if the string was empty, we want an empty array
		$exploded_contents = array_filter( $exploded_contents );
		$contents_with_prefix = array();
		foreach( $exploded_contents as $item ) {
			$item = trim( $item );
			//if no prefix was provided, so we look for items with no "." in them
			if( ! $prefix ) {
				//does this item have a period?
				if( strpos( $item, '.' ) === false ) {
					//if not, then its what we're looking for
					$contents_with_prefix[] = $item;
				}
			} else if( strpos( $item, $prefix . '.' ) === 0 ) {
				//this item has the prefix and a period, grab it
				$contents_with_prefix[] = substr(
					$item,
					strpos( $item, $prefix . '.' ) + strlen( $prefix . '.' )
					);
			} else if( $item === $prefix ) {
				//this item is JUST the prefix
				//so let's grab everything after, which is a blank string
				$contents_with_prefix[] = '';
			}
		}
		return $contents_with_prefix;
	}

	/**
	 * @deprecated since 4.8.36.rc.001 You should instead use Read::explode_and_get_items_prefixed_with.
	 * Deprecated because its return values were really quite confusing- sometimes it returned
	 * an empty array (when the include string was blank or '*') or sometimes it returned
	 * array('*') (when you provided a model and a model of that kind was found).
	 * Parses the $include_string so we fetch all the field names relating to THIS model
	 * (ie have NO period in them), or for the provided model (ie start with the model
	 * name and then a period).
	 * @param string $include_string @see Read:handle_request_get_all
	 * @param string $model_name
	 * @return array of fields for this model. If $model_name is provided, then
	 * the fields for that model, with the model's name removed from each.
	 * If $include_string was blank or '*' returns an empty array
	 */
	public function extract_includes_for_this_model( $include_string, $model_name = null ) {
		if( is_array( $include_string ) ) {
			$include_string = implode( ',', $include_string );
		}
		if( $include_string === '*' || $include_string === '' ) {
			return array();
		}
		$includes = explode( ',', $include_string );
		$extracted_fields_to_include = array();
		if( $model_name ){
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
			foreach( $includes as $field_to_include ) {
				$field_to_include = trim( $field_to_include );
				if( strpos( $field_to_include, $model_name . '.' ) === 0 ) {
					//found the model name at the exact start
					$field_sans_model_name = str_replace( $model_name . '.', '', $field_to_include );
					$extracted_fields_to_include[] = $field_sans_model_name;
				}elseif( $field_to_include == $model_name ){
					$extracted_fields_to_include[] = '*';
				}
			}
		}else{
			//look for ones with no period
			foreach( $includes as $field_to_include ) {
				$field_to_include = trim( $field_to_include );
				if (
					strpos( $field_to_include, '.' ) === false
					&& ! $this->get_model_version_info()->is_model_name_in_this_version( $field_to_include )
				) {
					$extracted_fields_to_include[] = $field_to_include;
				}
			}
		}
		return $extracted_fields_to_include;

	}
}


// End of file Read.php
Branch — BUG-9625-better-us-phone-valid... (e0ce21)

Read F

Complexity

Size/Duplication

Coupling/Cohesion

Importance

23 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

eventespresso / event-espresso-core

Branch — BUG-9625-better-us-phone-valid... (e0ce21)

Read F

Complexity

Size/Duplication

Coupling/Cohesion

Importance

23 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like
