ModelDataTranslator::determineConditionsQueryParameterValue() - Code Metrics - Inspection of "Daily Inspection: update documentation and rest ap..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Branch — FET/simplify-rest-api-passing-... (d968c1)

unknown
created 2018-11-14 21:51 UTC
determineConditionsQueryParameterValue() F

↳ Parent: ModelDataTranslator
Complexity

Conditions	35
Paths	56
Size

Total Lines
189
Duplication

Lines	56
Ratio	29.63 %
Importance

Changes
Metric	Value
cc	35
nc	56
nop	7
dl	56
loc	189
rs	3.3333
c	0
b	0
f	0
How to fix Long Method Complexity

<?php

namespace EventEspresso\core\libraries\rest_api;

use DomainException;
use EE_Capabilities;
use EE_Datetime_Field;
use EE_Error;
use EE_Infinite_Integer_Field;
use EE_Maybe_Serialized_Simple_HTML_Field;
use EE_Model_Field_Base;
use EE_Serialized_Text_Field;
use EEM_Base;

/**
 * Class Model_Data_Translator
 * Class for translating data between the EE4 models and JSON.
 * Some of this class needs to interpret an incoming array of query params from
 * the REST API and prepare it for use by the models. Some of this code seems duplicated
 * from the models but it's anticipated to diverge (because providing parameters
 * in the REST API is sometimes more difficult than in PHP directly. Eg, providing an array like
 * array( 'where' => array( 'EVT_ID' => array( '<', 100 ) ) ) in PHP is easy, but in a query string it needs to look
 * like
 * "where[EVT_ID][]=<&where[EVT_ID][]=100" is less intuitive, so we may want
 * to allow REST API query parameters to diverge from the format accepted by models)
 *
 * @package               Event Espresso
 * @subpackage
 * @author                Mike Nelson
 * @since                 4.8.36
 */
class ModelDataTranslator
{

    /**
     * We used to use -1 for infinity in the rest api, but that's ambiguous for
     * fields that COULD contain -1; so we use null
     */
    const EE_INF_IN_REST = null;


    /**
     * Prepares a possible array of input values from JSON for use by the models
     *
     * @param EE_Model_Field_Base $field_obj
     * @param mixed               $original_value_maybe_array
     * @param string              $requested_version
     * @param string              $timezone_string treat values as being in this timezone
     * @return mixed
     * @throws RestException
     */
    public static function prepareFieldValuesFromJson(
        $field_obj,
        $original_value_maybe_array,
        $requested_version,
        $timezone_string = 'UTC'
    ) {
        if (is_array($original_value_maybe_array)
            && ! $field_obj instanceof EE_Serialized_Text_Field
        ) {
            $new_value_maybe_array = array();
            foreach ($original_value_maybe_array as $array_key => $array_item) {
                $new_value_maybe_array[ $array_key ] = ModelDataTranslator::prepareFieldValueFromJson(
                    $field_obj,
                    $array_item,
                    $requested_version,
                    $timezone_string
                );
            }
        } else {
            $new_value_maybe_array = ModelDataTranslator::prepareFieldValueFromJson(
                $field_obj,
                $original_value_maybe_array,
                $requested_version,
                $timezone_string
            );
        }
        return $new_value_maybe_array;
    }


    /**
     * Prepares an array of field values FOR use in JSON/REST API
     *
     * @param EE_Model_Field_Base $field_obj
     * @param mixed               $original_value_maybe_array
     * @param string              $request_version (eg 4.8.36)
     * @return array
     */
    public static function prepareFieldValuesForJson($field_obj, $original_value_maybe_array, $request_version)
    {
        if (is_array($original_value_maybe_array)) {
            $new_value = array();
            foreach ($original_value_maybe_array as $key => $value) {
                $new_value[ $key ] = ModelDataTranslator::prepareFieldValuesForJson(
                    $field_obj,
                    $value,
                    $request_version
                );
            }
        } else {
            $new_value = ModelDataTranslator::prepareFieldValueForJson(
                $field_obj,
                $original_value_maybe_array,
                $request_version
            );
        }
        return $new_value;
    }


    /**
     * Prepares incoming data from the json or $_REQUEST parameters for the models'
     * "$query_params".
     *
     * @param EE_Model_Field_Base $field_obj
     * @param mixed               $original_value
     * @param string              $requested_version
     * @param string              $timezone_string treat values as being in this timezone
     * @return mixed
     * @throws RestException
     * @throws DomainException
     * @throws EE_Error
     */
    public static function prepareFieldValueFromJson(
        $field_obj,
        $original_value,
        $requested_version,
        $timezone_string = 'UTC' // UTC
    ) {
        // check if they accidentally submitted an error value. If so throw an exception
        if (is_array($original_value)
            && isset($original_value['error_code'], $original_value['error_message'])) {
            throw new RestException(
                'rest_submitted_error_value',
                sprintf(
                    esc_html__(
                        'You tried to submit a JSON error object as a value for %1$s. That\'s not allowed.',
                        'event_espresso'
                    ),
                    $field_obj->get_name()
                ),
                array(
                    'status' => 400,
                )
            );
        }
        // double-check for serialized PHP. We never accept serialized PHP. No way Jose.
        ModelDataTranslator::throwExceptionIfContainsSerializedData($original_value);
        $timezone_string = $timezone_string !== '' ? $timezone_string : get_option('timezone_string', '');
        $new_value = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        // walk through the submitted data and double-check for serialized PHP. We never accept serialized PHP. No
        // way Jose.
        ModelDataTranslator::throwExceptionIfContainsSerializedData($original_value);
        if ($field_obj instanceof EE_Infinite_Integer_Field
            && in_array($original_value, array(null, ''), true)
        ) {
            $new_value = EE_INF;
        } elseif ($field_obj instanceof EE_Datetime_Field) {
            $new_value = rest_parse_date(
                self::getTimestampWithTimezoneOffset($original_value, $field_obj, $timezone_string)
            );
            if ($new_value === false) {
                throw new RestException(
                    'invalid_format_for_timestamp',
                    sprintf(
                        esc_html__(
                            'Timestamps received on a request as the value for Date and Time fields must be in %1$s/%2$s format.  The timestamp provided (%3$s) is not that format.',
                            'event_espresso'
                        ),
                        'RFC3339',
                        'ISO8601',
                        $original_value
                    ),
                    array(
                        'status' => 400,
                    )
                );
            }
        } else {
            $new_value = $original_value;
        }
        return $new_value;
    }


    /**
     * This checks if the incoming timestamp has timezone information already on it and if it doesn't then adds timezone
     * information via details obtained from the host site.
     *
     * @param string            $original_timestamp
     * @param EE_Datetime_Field $datetime_field
     * @param                   $timezone_string
     * @return string
     * @throws DomainException
     */
    private static function getTimestampWithTimezoneOffset(
        $original_timestamp,
        EE_Datetime_Field $datetime_field,
        $timezone_string
    ) {
        // already have timezone information?
        if (preg_match('/Z|(\+|\-)(\d{2}:\d{2})/', $original_timestamp)) {
            // yes, we're ignoring the timezone.
            return $original_timestamp;
        }
        // need to append timezone
        list($offset_sign, $offset_secs) = self::parseTimezoneOffset(
            $datetime_field->get_timezone_offset(
                new \DateTimeZone($timezone_string),
                $original_timestamp
            )
        );
        $offset_string =
            str_pad(
                floor($offset_secs / HOUR_IN_SECONDS),
                2,
                '0',
                STR_PAD_LEFT
            )
            . ':'
            . str_pad(
                ($offset_secs % HOUR_IN_SECONDS) / MINUTE_IN_SECONDS,
                2,
                '0',
                STR_PAD_LEFT
            );
        return $original_timestamp . $offset_sign . $offset_string;
    }


    /**
     * Throws an exception if $data is a serialized PHP string (or somehow an actually PHP object, although I don't
     * think that can happen). If $data is an array, recurses into its keys and values
     *
     * @param mixed $data
     * @throws RestException
     * @return void
     */
    public static function throwExceptionIfContainsSerializedData($data)
    {
        if (is_array($data)) {
            foreach ($data as $key => $value) {
                ModelDataTranslator::throwExceptionIfContainsSerializedData($key);
                ModelDataTranslator::throwExceptionIfContainsSerializedData($value);
            }
        } else {
            if (is_serialized($data) || is_object($data)) {
                throw new RestException(
                    'serialized_data_submission_prohibited',
                    esc_html__(
                    // @codingStandardsIgnoreStart
                        'You tried to submit a string of serialized text. Serialized PHP is prohibited over the EE4 REST API.',
                        // @codingStandardsIgnoreEnd
                        'event_espresso'
                    )
                );
            }
        }
    }


    /**
     * determines what's going on with them timezone strings
     *
     * @param int $timezone_offset
     * @return array
     */
    private static function parseTimezoneOffset($timezone_offset)
    {
        $first_char = substr((string) $timezone_offset, 0, 1);
        if ($first_char === '+' || $first_char === '-') {
            $offset_sign = $first_char;
            $offset_secs = substr((string) $timezone_offset, 1);
        } else {
            $offset_sign = '+';
            $offset_secs = $timezone_offset;
        }
        return array($offset_sign, $offset_secs);
    }


    /**
     * Prepares a field's value for display in the API
     *
     * @param EE_Model_Field_Base $field_obj
     * @param mixed               $original_value
     * @param string              $requested_version
     * @return mixed
     */
    public static function prepareFieldValueForJson($field_obj, $original_value, $requested_version)
    {
        if ($original_value === EE_INF) {
            $new_value = ModelDataTranslator::EE_INF_IN_REST;
        } elseif ($field_obj instanceof EE_Datetime_Field) {
            if (is_string($original_value)) {
                // did they submit a string of a unix timestamp?
                if (is_numeric($original_value)) {
                    $datetime_obj = new \DateTime();
                    $datetime_obj->setTimestamp((int) $original_value);
                } else {
                    // first, check if its a MySQL timestamp in GMT
                    $datetime_obj = \DateTime::createFromFormat('Y-m-d H:i:s', $original_value);
                }
                if (! $datetime_obj instanceof \DateTime) {
                    // so it's not a unix timestamp or a MySQL timestamp. Maybe its in the field's date/time format?
                    $datetime_obj = $field_obj->prepare_for_set($original_value);
                }
                $original_value = $datetime_obj;
            }
            if ($original_value instanceof \DateTime) {
                $new_value = $original_value->format('Y-m-d H:i:s');
            } elseif (is_int($original_value) || is_float($original_value)) {
                $new_value = date('Y-m-d H:i:s', $original_value);
            } elseif ($original_value === null || $original_value === '') {
                $new_value = null;
            } else {
                // so it's not a datetime object, unix timestamp (as string or int),
                // MySQL timestamp, or even a string in the field object's format. So no idea what it is
                throw new \EE_Error(
                    sprintf(
                        esc_html__(
                        // @codingStandardsIgnoreStart
                            'The value "%1$s" for the field "%2$s" on model "%3$s" could not be understood. It should be a PHP DateTime, unix timestamp, MySQL date, or string in the format "%4$s".',
                            // @codingStandardsIgnoreEnd
                            'event_espresso'
                        ),
                        $original_value,
                        $field_obj->get_name(),
                        $field_obj->get_model_name(),
                        $field_obj->get_time_format() . ' ' . $field_obj->get_time_format()
                    )
                );
            }
            if ($new_value !== null) {
                $new_value = mysql_to_rfc3339($new_value);
            }
        } else {
            $new_value = $original_value;
        }
        // are we about to send an object? just don't. We have no good way to represent it in JSON.
        // can't just check using is_object() because that missed PHP incomplete objects
        if (! ModelDataTranslator::isRepresentableInJson($new_value)) {
            $new_value = array(
                'error_code'    => 'php_object_not_return',
                'error_message' => esc_html__(
                    'The value of this field in the database is a PHP object, which can\'t be represented in JSON.',
                    'event_espresso'
                ),
            );
        }
        return apply_filters(
            'FHEE__EventEspresso\core\libraries\rest_api\Model_Data_Translator__prepare_field_for_rest_api',
            $new_value,
            $field_obj,
            $original_value,
            $requested_version
        );
    }


    /**
     * Prepares condition-query-parameters (like what's in where and having) from
     * the format expected in the API to use in the models
     *
     * @param array $inputted_query_params_of_this_type
     * @param EEM_Base $model
     * @param string $requested_version
     * @param boolean $writing whether this data will be written to the DB, or if we're just building a query.
     *                          If we're writing to the DB, we don't expect any operators, or any logic query
     *                          parameters, and we also won't accept serialized data unless the current user has
     *                          unfiltered_html.
     * @return array
     * @throws DomainException
     * @throws EE_Error
     * @throws RestException
     * @throws \EventEspresso\core\exceptions\InvalidDataTypeException
     * @throws \EventEspresso\core\exceptions\InvalidInterfaceException
     * @throws \InvalidArgumentException
     */
    public static function prepareConditionsQueryParamsForModels(
        $inputted_query_params_of_this_type,
        EEM_Base $model,
        $requested_version,
        $writing = false
    ) {
        $query_param_for_models = array();
        foreach ($inputted_query_params_of_this_type as $query_param_key => $query_param_value) {
            list(
                $field,
                $query_param_key,
                $query_param_sans_stars,
                $timezone,
                $is_gmt_datetime_field
                ) = self::determineFieldAndTimezone(
                    $model,
                    $query_param_key
                );
            if ($field instanceof EE_Model_Field_Base) {
                $translated_value = self::determineConditionsQueryParameterValue(
                    $model,
                    $field,
                    $requested_version,
                    $timezone,
                    $query_param_key,
                    $query_param_value,
                    $writing
                );
                if ((isset($query_param_for_models[ $query_param_key ]) && $is_gmt_datetime_field)
                    || $translated_value === null
                ) {
                    // they have already provided a non-gmt field, ignore the gmt one. That's what WP core
                    // currently does (they might change it though). See https://core.trac.wordpress.org/ticket/39954
                    // OR we couldn't create a translated value from their input
                    continue;
                }
                $query_param_for_models[ $query_param_key ] = $translated_value;
            } else {
                $nested_query_params = self::determineNestedConditionQueryParameters(
                    $model,
                    $query_param_key,
                    $query_param_sans_stars,
                    $query_param_value,
                    $requested_version,
                    $writing
                );
                if ($nested_query_params) {
                    $query_param_for_models[$query_param_key] = $nested_query_params;
                }
            }
        }
        return $query_param_for_models;
    }

    /**
     * If the query param isn't for a field, it must be a nested query parameter which requires different logic.
     * @since $VID:$
     * @param EEM_Base $model
     * @param $query_param_key
     * @param $query_param_sans_stars
     * @param $query_param_value
     * @param $requested_version
     * @param $writing
     * @return array
     * @throws DomainException
     * @throws EE_Error
     * @throws RestException
     */
    private static function determineNestedConditionQueryParameters(
        EEM_Base $model,
        $query_param_key,
        $query_param_sans_stars,
        $query_param_value,
        $requested_version,
        $writing
    ) {

        // so this param doesn't correspond to a field eh?
        if ($writing) {
            // always tell API clients about invalid parameters when they're creating data. Otherwise,
            // they are probably going to create invalid data
            throw new RestException(
                'invalid_field',
                sprintf(
                    /* translators: 1: variable name */
                    esc_html__('You have provided an invalid parameter: "%1$s"', 'event_espresso'),
                    $query_param_key
                )
            );
        } else {
            // so it's not for a field, is it a logic query param key?
            if (in_array(
                $query_param_sans_stars,
                $model->logic_query_param_keys()
            )) {
                return ModelDataTranslator::prepareConditionsQueryParamsForModels(
                    $query_param_value,
                    $model,
                    $requested_version
                );
            } elseif (defined('EE_REST_API_DEBUG_MODE') && EE_REST_API_DEBUG_MODE) {
                // only tell API clients they got it wrong if we're in debug mode
                // otherwise try our best ot fulfill their request by ignoring this invalid data
                throw new RestException(
                    'invalid_parameter',
                    sprintf(
                        /* translators: 1: variable name */
                        esc_html__(
                            'You provided an invalid parameter, with key "%1$s"',
                            'event_espresso'
                        ),
                        $query_param_key
                    ),
                    array(
                        'status' => 400,
                    )
                );
            }
        }
        return null;
    }

    /**
     * Determines what field, query param name, and query param name without stars, and timezone to use.
     * @since $VID:$
     * @param EEM_Base $model
     * @param $query_param_sans_stars
     * @return array {
     * @type EE_Model_Field_Base $field
     * @type string $query_param_key
     * @type string $query_param_sans_stars
     * @type string $timezone
     * @type boolean $is_gmt_datetime_field
     * }
     * @throws EE_Error
     * @throws \EventEspresso\core\exceptions\InvalidDataTypeException
     * @throws \EventEspresso\core\exceptions\InvalidInterfaceException
     * @throws \InvalidArgumentException
     */
    private static function determineFieldAndTimezone(EEM_Base $model, $query_param_key)
    {
        $query_param_sans_stars = ModelDataTranslator::removeStarsAndAnythingAfterFromConditionQueryParamKey(
            $query_param_key
        );
        $is_gmt_datetime_field = false;
        $field = ModelDataTranslator::deduceFieldFromQueryParam(
            $query_param_sans_stars,
            $model
        );
        // double-check is it a *_gmt field?
        if (! $field instanceof EE_Model_Field_Base
            && ModelDataTranslator::isGmtDateFieldName($query_param_sans_stars)
        ) {
            // yep, take off '_gmt', and find the field
            $query_param_key = ModelDataTranslator::removeGmtFromFieldName($query_param_sans_stars);
            $field = ModelDataTranslator::deduceFieldFromQueryParam(
                $query_param_key,
                $model
            );
            $timezone = 'UTC';
            $is_gmt_datetime_field = true;
        } elseif ($field instanceof EE_Datetime_Field) {
            // so it's not a GMT field. Set the timezone on the model to the default
            $timezone = \EEH_DTT_Helper::get_valid_timezone_string();
        } else {
            // just keep using what's already set for the timezone
            $timezone = $model->get_timezone();
        }
        return array(
            $field,
            $query_param_key,
            $query_param_sans_stars,
            $timezone,
            $is_gmt_datetime_field
        );
    }

    /**
     * Given a ton of input, determines the value to use for the models.
     * @since $VID:$
     * @param EEM_Base $model
     * @param EE_Model_Field_Base $field
     * @param $requested_version
     * @param $timezone
     * @param $query_param_key
     * @param $query_param_value
     * @param bool $writing
     * @return array|null
     * @throws DomainException
     * @throws EE_Error
     * @throws RestException
     */
    private static function determineConditionsQueryParameterValue(
        EEM_Base $model,
        EE_Model_Field_Base $field,
        $requested_version,
        $timezone,
        $query_param_key,
        $query_param_value,
        $writing = false
    ) {
        if (! $writing && is_array($query_param_value)) {
            if (! \EEH_Array::is_array_numerically_and_sequentially_indexed($query_param_value)) {
                if (is_array($query_param_value)
                    && count($query_param_value) === 1
                    && array_key_exists(
                        key($query_param_value),
                        $model->valid_operators()
                    )
                ) {
                    $sub_array_value =  reset($query_param_value);
                    $sub_array_key = key($query_param_value);
                    // they're doing something like "&where[EVT_ID][IN]=1,2,3" or "&where[EVT_ID][>]=5"
                    if (array_key_exists(
                        $sub_array_key,
                        array_merge(
                            $model->valid_in_style_operators(),
                            $model->valid_between_style_operators()
                        )
                    )) {
                        // the value should be JSON or CSV
                        $values = json_decode($sub_array_value);
                        if (! is_array($values)) {
                            $values = array_filter(
                                array_map(
                                    'trim',
                                    explode(
                                        ',',
                                        $sub_array_value
                                    )
                                )
                            );
                        }
                        $query_param_value = array(
                            $sub_array_key,
                            $values
                        );
                    } elseif (array_key_exists(
                        $sub_array_key,
                        $model->valid_null_style_operators()
                    )) {
                        $query_param_value = array($sub_array_key);
                    } else {
                        $query_param_value = array($sub_array_key, $sub_array_value);
                    }
                } elseif (defined('EE_REST_API_DEBUG_MODE') && EE_REST_API_DEBUG_MODE) {
                    throw new RestException(
                        'numerically_indexed_array_of_values_only',
                        sprintf(
                            /* translators: 1: variable name*/
                            esc_html__(
                                'The array provided for the parameter "%1$s" should be numerically indexed.',
                                'event_espresso'
                            ),
                            $query_param_key
                        ),
                        array(
                            'status' => 400,
                        )
                    );
                }
            }
            $valid_operators = $model->valid_operators();
            // did they specify an operator?
            if (isset($query_param_value[0])
                && isset($valid_operators[ $query_param_value[0] ])
            ) {
                $sub_array_key = $query_param_value[0];
                $translated_value = array($sub_array_key);
                if (array_key_exists($sub_array_key, $model->valid_in_style_operators())
                    && isset($query_param_value[1])
                    && ! isset($query_param_value[2])
                ) {
                    $translated_value[] = ModelDataTranslator::prepareFieldValuesFromJson(
                        $field,
                        $query_param_value[1],
                        $requested_version,
                        $timezone
                    );
                } elseif (array_key_exists($sub_array_key, $model->valid_between_style_operators())
                    && isset($query_param_value[1])
                    && is_array($query_param_value[1])
                    && isset($query_param_key[1][0], $query_param_value[1][1])
                    && ! isset($query_param_value[1][2])
                    && ! isset($query_param_value[2])
                ) {
                    $translated_value[] = array(
                        ModelDataTranslator::prepareFieldValuesFromJson(
                            $field,
                            $query_param_value[1][0],
                            $requested_version,
                            $timezone
                        ),
                        ModelDataTranslator::prepareFieldValuesFromJson(
                            $field,
                            $query_param_value[1][1],
                            $requested_version,
                            $timezone
                        )
                    );
                } elseif (array_key_exists($sub_array_key, $model->valid_like_style_operators())
                    && isset($query_param_value[1])
                    && ! isset($query_param_value[2])
                ) {
                    // we want to leave this value mostly-as-is (eg don't force it to be a float
                    // or a boolean or an enum value. Leave it as-is with wildcards etc)
                    // but do verify it at least doesn't have any serialized data
                    ModelDataTranslator::throwExceptionIfContainsSerializedData($query_param_value[1]);
                    $translated_value[] = $query_param_value[1];
                } elseif (array_key_exists($sub_array_key, $model->valid_null_style_operators())
                    && ! isset($query_param_value[1])) {
                    // no arguments should have been provided, so don't look for any
                } elseif (isset($query_param_value[1])
                    && ! isset($query_param_value[2])
                    && ! array_key_exists(
                        $sub_array_key,
                        array_merge(
                            $model->valid_in_style_operators(),
                            $model->valid_null_style_operators(),
                            $model->valid_like_style_operators(),
                            $model->valid_between_style_operators()
                        )
                    )
                ) {
                    // it's a valid operator, but none of the exceptions. Treat it normally.
                    $translated_value[] = ModelDataTranslator::prepareFieldValuesFromJson(
                        $field,
                        $query_param_value[1],
                        $requested_version,
                        $timezone
                    );
                } else {
                    // so they provided a valid operator, but wrong number of arguments
                    if (defined('EE_REST_API_DEBUG_MODE') && EE_REST_API_DEBUG_MODE) {
                        throw new RestException(
                            'wrong_number_of_arguments',
                            sprintf(
                                esc_html__(
                                    'The operator you provided, "%1$s" had the wrong number of arguments',
                                    'event_espresso'
                                ),
                                $sub_array_key
                            ),
                            array(
                                'status' => 400,
                            )
                        );
                    }
                    $translated_value = null;
                }
            } else {
                // so they didn't provide a valid operator
                if (defined('EE_REST_API_DEBUG_MODE') && EE_REST_API_DEBUG_MODE) {
                    throw new RestException(
                        'invalid_operator',
                        sprintf(
                            esc_html__(
                                'You provided an invalid parameter, with key "%1$s" and value "%2$s"',
                                'event_espresso'
                            ),
                            $query_param_key,
                            $query_param_value
                        ),
                        array(
                            'status' => 400,
                        )
                    );
                }
                // if we aren't in debug mode, then just try our best to fulfill the user's request
                $translated_value = null;
            }
        } else {
            $translated_value = ModelDataTranslator::prepareFieldValueFromJson(
                $field,
                $query_param_value,
                $requested_version,
                $timezone
            );
        }
        return $translated_value;
    }


    /**
     * Mostly checks if the last 4 characters are "_gmt", indicating its a
     * gmt date field name
     *
     * @param string $field_name
     * @return boolean
     */
    public static function isGmtDateFieldName($field_name)
    {
        return substr(
            ModelDataTranslator::removeStarsAndAnythingAfterFromConditionQueryParamKey($field_name),
            -4,
            4
        ) === '_gmt';
    }


    /**
     * Removes the last "_gmt" part of a field name (and if there is no "_gmt" at the end, leave it alone)
     *
     * @param string $field_name
     * @return string
     */
    public static function removeGmtFromFieldName($field_name)
    {
        if (! ModelDataTranslator::isGmtDateFieldName($field_name)) {
            return $field_name;
        }
        $query_param_sans_stars = ModelDataTranslator::removeStarsAndAnythingAfterFromConditionQueryParamKey(
            $field_name
        );
        $query_param_sans_gmt_and_sans_stars = substr(
            $query_param_sans_stars,
            0,
            strrpos(
                $field_name,
                '_gmt'
            )
        );
        return str_replace($query_param_sans_stars, $query_param_sans_gmt_and_sans_stars, $field_name);
    }


    /**
     * Takes a field name from the REST API and prepares it for the model querying
     *
     * @param string $field_name
     * @return string
     */
    public static function prepareFieldNameFromJson($field_name)
    {
        if (ModelDataTranslator::isGmtDateFieldName($field_name)) {
            return ModelDataTranslator::removeGmtFromFieldName($field_name);
        }
        return $field_name;
    }


    /**
     * Takes array of field names from REST API and prepares for models
     *
     * @param array $field_names
     * @return array of field names (possibly include model prefixes)
     */
    public static function prepareFieldNamesFromJson(array $field_names)
    {
        $new_array = array();
        foreach ($field_names as $key => $field_name) {
            $new_array[ $key ] = ModelDataTranslator::prepareFieldNameFromJson($field_name);
        }
        return $new_array;
    }


    /**
     * Takes array where array keys are field names (possibly with model path prefixes)
     * from the REST API and prepares them for model querying
     *
     * @param array $field_names_as_keys
     * @return array
     */
    public static function prepareFieldNamesInArrayKeysFromJson(array $field_names_as_keys)
    {
        $new_array = array();
        foreach ($field_names_as_keys as $field_name => $value) {
            $new_array[ ModelDataTranslator::prepareFieldNameFromJson($field_name) ] = $value;
        }
        return $new_array;
    }


    /**
     * Prepares an array of model query params for use in the REST API
     *
     * @param array    $model_query_params
     * @param EEM_Base $model
     * @param string   $requested_version  eg "4.8.36". If null is provided, defaults to the latest release of the EE4
     *                                     REST API
     * @return array which can be passed into the EE4 REST API when querying a model resource
     * @throws EE_Error
     */
    public static function prepareQueryParamsForRestApi(
        array $model_query_params,
        EEM_Base $model,
        $requested_version = null
    ) {
        if ($requested_version === null) {
            $requested_version = \EED_Core_Rest_Api::latest_rest_api_version();
        }
        $rest_query_params = $model_query_params;
        if (isset($model_query_params[0])) {
            $rest_query_params['where'] = ModelDataTranslator::prepareConditionsQueryParamsForRestApi(
                $model_query_params[0],
                $model,
                $requested_version
            );
            unset($rest_query_params[0]);
        }
        if (isset($model_query_params['having'])) {
            $rest_query_params['having'] = ModelDataTranslator::prepareConditionsQueryParamsForRestApi(
                $model_query_params['having'],
                $model,
                $requested_version
            );
        }
        return apply_filters(
            'FHEE__EventEspresso\core\libraries\rest_api\Model_Data_Translator__prepare_query_params_for_rest_api',
            $rest_query_params,
            $model_query_params,
            $model,
            $requested_version
        );
    }


    /**
     * Prepares all the sub-conditions query parameters (eg having or where conditions) for use in the rest api
     *
     * @param array    $inputted_query_params_of_this_type  eg like the "where" or "having" conditions query params
     *                                                      passed into EEM_Base::get_all()
     * @param EEM_Base $model
     * @param string   $requested_version                   eg "4.8.36"
     * @return array ready for use in the rest api query params
     * @throws EE_Error
     * @throws ObjectDetectedException if somehow a PHP object were in the query params' values,
     *                                                      (which would be really unusual)
     */
    public static function prepareConditionsQueryParamsForRestApi(
        $inputted_query_params_of_this_type,
        EEM_Base $model,
        $requested_version
    ) {
        $query_param_for_models = array();
        foreach ($inputted_query_params_of_this_type as $query_param_key => $query_param_value) {
            $field = ModelDataTranslator::deduceFieldFromQueryParam(
                ModelDataTranslator::removeStarsAndAnythingAfterFromConditionQueryParamKey($query_param_key),
                $model
            );
            if ($field instanceof EE_Model_Field_Base) {
                // did they specify an operator?
                if (is_array($query_param_value)) {
                    $op = $query_param_value[0];
                    $translated_value = array($op);
                    if (isset($query_param_value[1])) {
                        $value = $query_param_value[1];
                        $translated_value[1] = ModelDataTranslator::prepareFieldValuesForJson(
                            $field,
                            $value,
                            $requested_version
                        );
                    }
                } else {
                    $translated_value = ModelDataTranslator::prepareFieldValueForJson(
                        $field,
                        $query_param_value,
                        $requested_version
                    );
                }
                $query_param_for_models[ $query_param_key ] = $translated_value;
            } else {
                // so it's not for a field, assume it's a logic query param key
                $query_param_for_models[ $query_param_key ] = ModelDataTranslator::prepareConditionsQueryParamsForRestApi(
                    $query_param_value,
                    $model,
                    $requested_version
                );
            }
        }
        return $query_param_for_models;
    }


    /**
     * @param $condition_query_param_key
     * @return string
     */
    public static function removeStarsAndAnythingAfterFromConditionQueryParamKey($condition_query_param_key)
    {
        $pos_of_star = strpos($condition_query_param_key, '*');
        if ($pos_of_star === false) {
            return $condition_query_param_key;
        } else {
            $condition_query_param_sans_star = substr($condition_query_param_key, 0, $pos_of_star);
            return $condition_query_param_sans_star;
        }
    }


    /**
     * Takes the input parameter and finds the model field that it indicates.
     *
     * @param string   $query_param_name like Registration.Transaction.TXN_ID, Event.Datetime.start_time, or REG_ID
     * @param EEM_Base $model
     * @return EE_Model_Field_Base
     * @throws EE_Error
     */
    public static function deduceFieldFromQueryParam($query_param_name, EEM_Base $model)
    {
        // ok, now proceed with deducing which part is the model's name, and which is the field's name
        // which will help us find the database table and column
        $query_param_parts = explode('.', $query_param_name);
        if (empty($query_param_parts)) {
            throw new EE_Error(
                sprintf(
                    __(
                        '_extract_column_name is empty when trying to extract column and table name from %s',
                        'event_espresso'
                    ),
                    $query_param_name
                )
            );
        }
        $number_of_parts = count($query_param_parts);
        $last_query_param_part = $query_param_parts[ count($query_param_parts) - 1 ];
        if ($number_of_parts === 1) {
            $field_name = $last_query_param_part;
        } else {// $number_of_parts >= 2
            // the last part is the column name, and there are only 2parts. therefore...
            $field_name = $last_query_param_part;
            $model = \EE_Registry::instance()->load_model($query_param_parts[ $number_of_parts - 2 ]);
        }
        try {
            return $model->field_settings_for($field_name, false);
function someFunction(A $objectMaybe = null)
{
    if ($objectMaybe instanceof A) {
        $objectMaybe->doSomething();
    }
}
        } catch (EE_Error $e) {
            return null;
        }
    }


    /**
     * Returns true if $data can be easily represented in JSON.
     * Basically, objects and resources can't be represented in JSON easily.
     *
     * @param mixed $data
     * @return bool
     */
    protected static function isRepresentableInJson($data)
    {
        return is_scalar($data)
               || is_array($data)
               || is_null($data);
    }
}

eventespresso / event-espresso-core

Branch — FET/simplify-rest-api-passing-... (d968c1)

determineConditionsQueryParameterValue() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
