eventespresso / event-espresso-core

core/domain/services/graphql/connection_resolvers/CountryConnectionResolver.php

Spacing +8 added lines, -8 removed lines

@@ -94,7 +94,7 @@ 
          * Collect the input_fields and sanitize them to prepare them for sending to the Query
          */
         $input_fields = [];
-        if (! empty($this->args['where'])) {
+        if ( ! empty($this->args['where'])) {
             $input_fields = $this->sanitizeInputFields($this->args['where']);
 
             // Since we do not have any falsy values in query params
@@ -102,10 +102,10 @@ 
             $input_fields = array_filter($input_fields);
 
             // Use the proper operator.
-            if (! empty($input_fields['CNT_ISO']) && is_array($input_fields['CNT_ISO'])) {
+            if ( ! empty($input_fields['CNT_ISO']) && is_array($input_fields['CNT_ISO'])) {
                 $input_fields['CNT_ISO'] = ['IN', $input_fields['CNT_ISO']];
             }
-            if (! empty($input_fields['CNT_ISO3']) && is_array($input_fields['CNT_ISO3'])) {
+            if ( ! empty($input_fields['CNT_ISO3']) && is_array($input_fields['CNT_ISO3'])) {
                 $input_fields['CNT_ISO3'] = ['IN', $input_fields['CNT_ISO3']];
             }
         }
@@ -113,12 +113,12 @@ 
         /**
          * Merge the input_fields with the default query_args
          */
-        if (! empty($input_fields)) {
+        if ( ! empty($input_fields)) {
             $where_params = array_merge($where_params, $input_fields);
         }
 
         // limit to active countries by default.
-        if (!isset($this->args['where']['activeOnly']) || $this->args['where']['activeOnly']) {
+        if ( ! isset($this->args['where']['activeOnly']) || $this->args['where']['activeOnly']) {
             $where_params['CNT_active'] = true;
         }
 
@@ -133,11 +133,11 @@ 
 
         $search = $this->getSearchKeywords($this->args['where']);
 
-        if (! empty($search)) {
+        if ( ! empty($search)) {
             // use OR operator to search in any of the fields
             $where_params['OR'] = array(
-                'CNT_name' => array('LIKE', '%' . $search . '%'),
-                'CNT_ISO'  => array('LIKE', '%' . $search . '%'),
+                'CNT_name' => array('LIKE', '%'.$search.'%'),
+                'CNT_ISO'  => array('LIKE', '%'.$search.'%'),
             );
         }
 

Indentation +166 added lines, -166 removed lines

@@ -16,170 +16,170 @@
  */
 class CountryConnectionResolver extends AbstractConnectionResolver
 {
-    // phpcs:ignore PSR1.Methods.CamelCapsMethodName.NotCamelCaps
-    public function get_loader_name(): string
-    {
-        return 'espresso_country';
-    }
-
-    /**
-     * @return EEM_Country
-     * @throws EE_Error
-     * @throws InvalidArgumentException
-     * @throws InvalidDataTypeException
-     * @throws InvalidInterfaceException
-     * @throws ReflectionException
-     */
-    // phpcs:ignore PSR1.Methods.CamelCapsMethodName.NotCamelCaps
-    public function get_query(): EEM_Country
-    {
-        return EEM_Country::instance();
-    }
-
-
-    /**
-     * Return an array of item IDs from the query
-     *
-     * @return array
-     */
-    // phpcs:ignore PSR1.Methods.CamelCapsMethodName.NotCamelCaps
-    public function get_ids(): array
-    {
-        $results = $this->query->get_col($this->query_args);
-
-        return ! empty($results) ? $results : [];
-    }
-
-    /**
-     * Get_query_amount
-     *
-     * Returns the max between what was requested and what is defined as the $max_query_amount to
-     * ensure that queries don't exceed unwanted limits when querying data.
-     *
-     * @return int
-     * @throws Exception
-     */
-    // phpcs:ignore PSR1.Methods.CamelCapsMethodName.NotCamelCaps
-    public function get_query_amount()
-    {
-        // Override the default limit (100) for countries
-        return 500;
-    }
-
-
-    /**
-     * Here, we map the args from the input, then we make sure that we're only querying
-     * for IDs. The IDs are then passed down the resolve tree, and deferred resolvers
-     * handle batch resolution of the posts.
-     *
-     * @return array
-     * @throws InvalidArgumentException
-     * @throws InvalidDataTypeException
-     * @throws InvalidInterfaceException
-     */
-    // phpcs:ignore PSR1.Methods.CamelCapsMethodName.NotCamelCaps
-    public function get_query_args(): array
-    {
-        $where_params = [];
-        $query_args   = [];
-
-        $query_args['limit'] = $this->getLimit();
-
-        // Avoid multiple entries by join.
-        $query_args['group_by'] = 'CNT_ISO';
-
-        $query_args['default_where_conditions'] = 'minimum';
-
-        /**
-         * Collect the input_fields and sanitize them to prepare them for sending to the Query
-         */
-        $input_fields = [];
-        if (! empty($this->args['where'])) {
-            $input_fields = $this->sanitizeInputFields($this->args['where']);
-
-            // Since we do not have any falsy values in query params
-            // Lets get rid of empty values
-            $input_fields = array_filter($input_fields);
-
-            // Use the proper operator.
-            if (! empty($input_fields['CNT_ISO']) && is_array($input_fields['CNT_ISO'])) {
-                $input_fields['CNT_ISO'] = ['IN', $input_fields['CNT_ISO']];
-            }
-            if (! empty($input_fields['CNT_ISO3']) && is_array($input_fields['CNT_ISO3'])) {
-                $input_fields['CNT_ISO3'] = ['IN', $input_fields['CNT_ISO3']];
-            }
-        }
-
-        /**
-         * Merge the input_fields with the default query_args
-         */
-        if (! empty($input_fields)) {
-            $where_params = array_merge($where_params, $input_fields);
-        }
-
-        // limit to active countries by default.
-        if (!isset($this->args['where']['activeOnly']) || $this->args['where']['activeOnly']) {
-            $where_params['CNT_active'] = true;
-        }
-
-        [$query_args, $where_params] = $this->mapOrderbyInputArgs($query_args, $where_params, 'CNT_ISO');
-
-        if (empty($query_args['order_by'])) {
-            // set order_by to 'name' by default
-            $query_args['order_by'] = [
-                'CNT_name' => 'ASC',
-            ];
-        }
-
-        $search = $this->getSearchKeywords($this->args['where']);
-
-        if (! empty($search)) {
-            // use OR operator to search in any of the fields
-            $where_params['OR'] = array(
-                'CNT_name' => array('LIKE', '%' . $search . '%'),
-                'CNT_ISO'  => array('LIKE', '%' . $search . '%'),
-            );
-        }
-
-        $where_params = apply_filters(
-            'FHEE__EventEspresso_core_domain_services_graphql_connection_resolvers__country_where_params',
-            $where_params,
-            $this->source,
-            $this->args
-        );
-
-        $query_args[] = $where_params;
-
-        /**
-         * Return the $query_args
-         */
-        return apply_filters(
-            'FHEE__EventEspresso_core_domain_services_graphql_connection_resolvers__country_query_args',
-            $query_args,
-            $this->source,
-            $this->args
-        );
-    }
-
-
-    /**
-     * This sets up the "allowed" args, and translates the GraphQL-friendly keys to model
-     * friendly keys.
-     *
-     * @param array $where_args
-     * @return array
-     */
-    public function sanitizeInputFields(array $where_args): array
-    {
-        $arg_mapping = [
-            'isoIn'  => 'CNT_ISO',
-            'in'     => 'CNT_ISO',
-            'iso3In' => 'CNT_ISO3',
-        ];
-        return $this->sanitizeWhereArgsForInputFields(
-            $where_args,
-            $arg_mapping,
-            ['in']
-        );
-    }
+	// phpcs:ignore PSR1.Methods.CamelCapsMethodName.NotCamelCaps
+	public function get_loader_name(): string
+	{
+		return 'espresso_country';
+	}
+
+	/**
+	 * @return EEM_Country
+	 * @throws EE_Error
+	 * @throws InvalidArgumentException
+	 * @throws InvalidDataTypeException
+	 * @throws InvalidInterfaceException
+	 * @throws ReflectionException
+	 */
+	// phpcs:ignore PSR1.Methods.CamelCapsMethodName.NotCamelCaps
+	public function get_query(): EEM_Country
+	{
+		return EEM_Country::instance();
+	}
+
+
+	/**
+	 * Return an array of item IDs from the query
+	 *
+	 * @return array
+	 */
+	// phpcs:ignore PSR1.Methods.CamelCapsMethodName.NotCamelCaps
+	public function get_ids(): array
+	{
+		$results = $this->query->get_col($this->query_args);
+
+		return ! empty($results) ? $results : [];
+	}
+
+	/**
+	 * Get_query_amount
+	 *
+	 * Returns the max between what was requested and what is defined as the $max_query_amount to
+	 * ensure that queries don't exceed unwanted limits when querying data.
+	 *
+	 * @return int
+	 * @throws Exception
+	 */
+	// phpcs:ignore PSR1.Methods.CamelCapsMethodName.NotCamelCaps
+	public function get_query_amount()
+	{
+		// Override the default limit (100) for countries
+		return 500;
+	}
+
+
+	/**
+	 * Here, we map the args from the input, then we make sure that we're only querying
+	 * for IDs. The IDs are then passed down the resolve tree, and deferred resolvers
+	 * handle batch resolution of the posts.
+	 *
+	 * @return array
+	 * @throws InvalidArgumentException
+	 * @throws InvalidDataTypeException
+	 * @throws InvalidInterfaceException
+	 */
+	// phpcs:ignore PSR1.Methods.CamelCapsMethodName.NotCamelCaps
+	public function get_query_args(): array
+	{
+		$where_params = [];
+		$query_args   = [];
+
+		$query_args['limit'] = $this->getLimit();
+
+		// Avoid multiple entries by join.
+		$query_args['group_by'] = 'CNT_ISO';
+
+		$query_args['default_where_conditions'] = 'minimum';
+
+		/**
+		 * Collect the input_fields and sanitize them to prepare them for sending to the Query
+		 */
+		$input_fields = [];
+		if (! empty($this->args['where'])) {
+			$input_fields = $this->sanitizeInputFields($this->args['where']);
+
+			// Since we do not have any falsy values in query params
+			// Lets get rid of empty values
+			$input_fields = array_filter($input_fields);
+
+			// Use the proper operator.
+			if (! empty($input_fields['CNT_ISO']) && is_array($input_fields['CNT_ISO'])) {
+				$input_fields['CNT_ISO'] = ['IN', $input_fields['CNT_ISO']];
+			}
+			if (! empty($input_fields['CNT_ISO3']) && is_array($input_fields['CNT_ISO3'])) {
+				$input_fields['CNT_ISO3'] = ['IN', $input_fields['CNT_ISO3']];
+			}
+		}
+
+		/**
+		 * Merge the input_fields with the default query_args
+		 */
+		if (! empty($input_fields)) {
+			$where_params = array_merge($where_params, $input_fields);
+		}
+
+		// limit to active countries by default.
+		if (!isset($this->args['where']['activeOnly']) || $this->args['where']['activeOnly']) {
+			$where_params['CNT_active'] = true;
+		}
+
+		[$query_args, $where_params] = $this->mapOrderbyInputArgs($query_args, $where_params, 'CNT_ISO');
+
+		if (empty($query_args['order_by'])) {
+			// set order_by to 'name' by default
+			$query_args['order_by'] = [
+				'CNT_name' => 'ASC',
+			];
+		}
+
+		$search = $this->getSearchKeywords($this->args['where']);
+
+		if (! empty($search)) {
+			// use OR operator to search in any of the fields
+			$where_params['OR'] = array(
+				'CNT_name' => array('LIKE', '%' . $search . '%'),
+				'CNT_ISO'  => array('LIKE', '%' . $search . '%'),
+			);
+		}
+
+		$where_params = apply_filters(
+			'FHEE__EventEspresso_core_domain_services_graphql_connection_resolvers__country_where_params',
+			$where_params,
+			$this->source,
+			$this->args
+		);
+
+		$query_args[] = $where_params;
+
+		/**
+		 * Return the $query_args
+		 */
+		return apply_filters(
+			'FHEE__EventEspresso_core_domain_services_graphql_connection_resolvers__country_query_args',
+			$query_args,
+			$this->source,
+			$this->args
+		);
+	}
+
+
+	/**
+	 * This sets up the "allowed" args, and translates the GraphQL-friendly keys to model
+	 * friendly keys.
+	 *
+	 * @param array $where_args
+	 * @return array
+	 */
+	public function sanitizeInputFields(array $where_args): array
+	{
+		$arg_mapping = [
+			'isoIn'  => 'CNT_ISO',
+			'in'     => 'CNT_ISO',
+			'iso3In' => 'CNT_ISO3',
+		];
+		return $this->sanitizeWhereArgsForInputFields(
+			$where_args,
+			$arg_mapping,
+			['in']
+		);
+	}
 }

core/domain/services/graphql/types/Datetime.php

Spacing +16 added lines, -16 removed lines

@@ -45,7 +45,7 @@ 
      */
     public function __construct(EEM_Datetime $datetime_model)
     {
-        $this->setName($this->namespace . 'Datetime');
+        $this->setName($this->namespace.'Datetime');
         $this->setDescription(__('An event date', 'event_espresso'));
         $this->setIsCustomPostType(false);
         parent::__construct($datetime_model);
@@ -98,7 +98,7 @@ 
             ),
             new GraphQLOutputField(
                 'event',
-                $this->namespace . 'Event',
+                $this->namespace.'Event',
                 null,
                 esc_html__('Event of the datetime.', 'event_espresso')
             ),
@@ -206,7 +206,7 @@ 
             ),
             new GraphQLOutputField(
                 'status',
-                $this->namespace . 'DatetimeStatusEnum',
+                $this->namespace.'DatetimeStatusEnum',
                 'get_active_status',
                 esc_html__('Datetime status', 'event_espresso')
             ),
@@ -226,7 +226,7 @@ 
                 null,
                 esc_html__('Datetime venue ID', 'event_espresso'),
                 null,
-                function (EE_Datetime $source) {
+                function(EE_Datetime $source) {
                     $venue_ID = $source->venue_ID();
                     return $venue_ID
                         // Since venue is a CPT, $type will be 'post'
@@ -320,14 +320,14 @@ 
     public function registerMutations(array $inputFields)
     {
         register_graphql_input_type(
-            'Update' .  $this->name() . 'BaseInput',
+            'Update'.$this->name().'BaseInput',
             [
                 'fields' => $inputFields,
             ]
         );
         // Register mutation to update an entity.
         register_graphql_mutation(
-            'update' . $this->name(),
+            'update'.$this->name(),
             [
                 'inputFields'         => $inputFields,
                 'outputFields'        => [
@@ -339,10 +339,10 @@ 
                 'mutateAndGetPayload' => DatetimeUpdate::mutateAndGetPayload($this->model, $this),
             ]
         );
-        $base_input = 'Update' .  $this->name() . 'BaseInput';
+        $base_input = 'Update'.$this->name().'BaseInput';
         // Register mutation to update an entity.
         register_graphql_mutation(
-            'bulkUpdate' . $this->name(),
+            'bulkUpdate'.$this->name(),
             array_merge(
                 Datetime::bulkUpdateBaseConfig($base_input),
                 [
@@ -353,7 +353,7 @@ 
 
         // Register mutation to update an entity.
         register_graphql_mutation(
-            'bulkDelete' . $this->namespace . 'Entities',
+            'bulkDelete'.$this->namespace.'Entities',
             [
                 'inputFields'         => [
                     'entityIds'  => [
@@ -364,7 +364,7 @@ 
                     ],
                     'entityType' => [
                         'type'        => [
-                            'non_null' => $this->namespace . 'ModelNameEnum',
+                            'non_null' => $this->namespace.'ModelNameEnum',
                         ],
                         'description' => esc_html__('The entity type for the IDs', 'event_espresso'),
                     ],
@@ -386,7 +386,7 @@ 
         );
         // Register mutation to delete an entity.
         register_graphql_mutation(
-            'delete' . $this->name(),
+            'delete'.$this->name(),
             [
                 'inputFields'         => [
                     'id'                => $inputFields['id'],
@@ -399,7 +399,7 @@ 
                     lcfirst($this->name()) => [
                         'type'        => $this->name(),
                         'description' => esc_html__('The object before it was deleted', 'event_espresso'),
-                        'resolve'     => static function ($payload) {
+                        'resolve'     => static function($payload) {
                             $deleted = (object) $payload['deleted'];
 
                             return ! empty($deleted) ? $deleted : null;
@@ -414,7 +414,7 @@ 
         unset($inputFields['id']);
         // Register mutation to update an entity.
         register_graphql_mutation(
-            'create' . $this->name(),
+            'create'.$this->name(),
             [
                 'inputFields'         => $inputFields,
                 'outputFields'        => [
@@ -429,7 +429,7 @@ 
 
         // Register mutation to update an entity.
         register_graphql_mutation(
-            'reorder' . $this->namespace . 'Entities',
+            'reorder'.$this->namespace.'Entities',
             [
                 'inputFields'         => [
                     'entityIds'  => [
@@ -440,7 +440,7 @@ 
                     ],
                     'entityType' => [
                         'type'        => [
-                            'non_null' => $this->namespace . 'ModelNameEnum',
+                            'non_null' => $this->namespace.'ModelNameEnum',
                         ],
                         'description' => esc_html__('The entity type for the IDs', 'event_espresso'),
                     ],
@@ -448,7 +448,7 @@ 
                 'outputFields'        => [
                     'ok' => [
                         'type'    => 'Boolean',
-                        'resolve' => function ($payload) {
+                        'resolve' => function($payload) {
                             return (bool) $payload['ok'];
                         },
                     ],

Indentation +407 added lines, -407 removed lines

@@ -37,423 +37,423 @@
  */
 class Datetime extends TypeBase
 {
-    /**
-     * EventDate constructor.
-     *
-     * @param EEM_Datetime $datetime_model
-     */
-    public function __construct(EEM_Datetime $datetime_model)
-    {
-        $this->setName($this->namespace . 'Datetime');
-        $this->setDescription(__('An event date', 'event_espresso'));
-        $this->setIsCustomPostType(false);
-        parent::__construct($datetime_model);
-    }
+	/**
+	 * EventDate constructor.
+	 *
+	 * @param EEM_Datetime $datetime_model
+	 */
+	public function __construct(EEM_Datetime $datetime_model)
+	{
+		$this->setName($this->namespace . 'Datetime');
+		$this->setDescription(__('An event date', 'event_espresso'));
+		$this->setIsCustomPostType(false);
+		parent::__construct($datetime_model);
+	}
 
 
-    /**
-     * @return GraphQLFieldInterface[]
-     */
-    public function getFields(): array
-    {
-        $fields = [
-            new GraphQLField(
-                'id',
-                ['non_null' => 'ID'],
-                null,
-                esc_html__('The globally unique ID for the object.', 'event_espresso')
-            ),
-            new GraphQLOutputField(
-                'dbId',
-                ['non_null' => 'Int'],
-                'ID',
-                esc_html__('The datetime ID.', 'event_espresso')
-            ),
-            new GraphQLOutputField(
-                'cacheId',
-                ['non_null' => 'String'],
-                null,
-                esc_html__('The cache ID of the object.', 'event_espresso')
-            ),
-            new GraphQLField(
-                'capacity',
-                'Int',
-                'reg_limit',
-                esc_html__('Registration Limit for this time', 'event_espresso'),
-                [$this, 'parseInfiniteValue']
-            ),
-            new GraphQLField(
-                'description',
-                'String',
-                'description',
-                esc_html__('Description for Datetime', 'event_espresso')
-            ),
-            new GraphQLField(
-                'endDate',
-                'String',
-                'end_date_and_time',
-                esc_html__('End date and time of the Event', 'event_espresso'),
-                [$this, 'formatDatetime']
-            ),
-            new GraphQLOutputField(
-                'event',
-                $this->namespace . 'Event',
-                null,
-                esc_html__('Event of the datetime.', 'event_espresso')
-            ),
-            new GraphQLInputField(
-                'event',
-                'ID',
-                null,
-                esc_html__('Globally unique event ID of the datetime.', 'event_espresso')
-            ),
-            new GraphQLInputField(
-                'eventId',
-                'Int',
-                null,
-                esc_html__('Event ID of the datetime.', 'event_espresso')
-            ),
-            new GraphQLOutputField(
-                'isActive',
-                'Boolean',
-                'is_active',
-                esc_html__('Flag indicating datetime is active', 'event_espresso')
-            ),
-            new GraphQLOutputField(
-                'isExpired',
-                'Boolean',
-                'is_expired',
-                esc_html__('Flag indicating datetime is expired or not', 'event_espresso')
-            ),
-            new GraphQLField(
-                'isPrimary',
-                'Boolean',
-                'is_primary',
-                esc_html__('Flag indicating datetime is primary one for event', 'event_espresso')
-            ),
-            new GraphQLOutputField(
-                'isSoldOut',
-                'Boolean',
-                'sold_out',
-                esc_html__(
-                    'Flag indicating whether the tickets sold for this datetime, met or exceed the registration limit',
-                    'event_espresso'
-                )
-            ),
-            new GraphQLField(
-                'isTrashed',
-                'Boolean',
-                null,
-                esc_html__('Flag indicating datetime has been trashed.', 'event_espresso'),
-                null,
-                [$this, 'getIsTrashed']
-            ),
-            new GraphQLOutputField(
-                'isUpcoming',
-                'Boolean',
-                'is_upcoming',
-                esc_html__('Whether the date is upcoming', 'event_espresso')
-            ),
-            new GraphQLOutputField(
-                'length',
-                'Int',
-                'length',
-                esc_html__('The length of the event (start to end time) in seconds', 'event_espresso')
-            ),
-            new GraphQLField(
-                'name',
-                'String',
-                'name',
-                esc_html__('Datetime Name', 'event_espresso')
-            ),
-            new GraphQLField(
-                'order',
-                'Int',
-                'order',
-                esc_html__('The order in which the Datetime is displayed', 'event_espresso')
-            ),
-            new GraphQLOutputField(
-                'parent',
-                $this->name(),
-                null,
-                esc_html__('The parent datetime of the current datetime', 'event_espresso')
-            ),
-            new GraphQLInputField(
-                'parent',
-                'ID',
-                null,
-                esc_html__('The parent datetime ID', 'event_espresso')
-            ),
-            new GraphQLField(
-                'reserved',
-                'Int',
-                'reserved',
-                esc_html__('Quantity of tickets reserved, but not yet fully purchased', 'event_espresso')
-            ),
-            new GraphQLField(
-                'startDate',
-                'String',
-                'start_date_and_time',
-                esc_html__('Start date and time of the Event', 'event_espresso'),
-                [$this, 'formatDatetime']
-            ),
-            new GraphQLField(
-                'sold',
-                'Int',
-                'sold',
-                esc_html__('How many sales for this Datetime that have occurred', 'event_espresso')
-            ),
-            new GraphQLOutputField(
-                'status',
-                $this->namespace . 'DatetimeStatusEnum',
-                'get_active_status',
-                esc_html__('Datetime status', 'event_espresso')
-            ),
-            new GraphQLInputField(
-                'tickets',
-                ['list_of' => 'ID'],
-                null,
-                sprintf(
-                    '%1$s %2$s',
-                    esc_html__('Globally unique IDs of the tickets related to the datetime.', 'event_espresso'),
-                    esc_html__('Ignored if empty.', 'event_espresso')
-                )
-            ),
-            new GraphQLField(
-                'venue',
-                'String',
-                null,
-                esc_html__('Datetime venue ID', 'event_espresso'),
-                null,
-                function (EE_Datetime $source) {
-                    $venue_ID = $source->venue_ID();
-                    return $venue_ID
-                        // Since venue is a CPT, $type will be 'post'
-                        ? Relay::toGlobalId('post', $venue_ID)
-                        : null;
-                }
-            ),
-        ];
+	/**
+	 * @return GraphQLFieldInterface[]
+	 */
+	public function getFields(): array
+	{
+		$fields = [
+			new GraphQLField(
+				'id',
+				['non_null' => 'ID'],
+				null,
+				esc_html__('The globally unique ID for the object.', 'event_espresso')
+			),
+			new GraphQLOutputField(
+				'dbId',
+				['non_null' => 'Int'],
+				'ID',
+				esc_html__('The datetime ID.', 'event_espresso')
+			),
+			new GraphQLOutputField(
+				'cacheId',
+				['non_null' => 'String'],
+				null,
+				esc_html__('The cache ID of the object.', 'event_espresso')
+			),
+			new GraphQLField(
+				'capacity',
+				'Int',
+				'reg_limit',
+				esc_html__('Registration Limit for this time', 'event_espresso'),
+				[$this, 'parseInfiniteValue']
+			),
+			new GraphQLField(
+				'description',
+				'String',
+				'description',
+				esc_html__('Description for Datetime', 'event_espresso')
+			),
+			new GraphQLField(
+				'endDate',
+				'String',
+				'end_date_and_time',
+				esc_html__('End date and time of the Event', 'event_espresso'),
+				[$this, 'formatDatetime']
+			),
+			new GraphQLOutputField(
+				'event',
+				$this->namespace . 'Event',
+				null,
+				esc_html__('Event of the datetime.', 'event_espresso')
+			),
+			new GraphQLInputField(
+				'event',
+				'ID',
+				null,
+				esc_html__('Globally unique event ID of the datetime.', 'event_espresso')
+			),
+			new GraphQLInputField(
+				'eventId',
+				'Int',
+				null,
+				esc_html__('Event ID of the datetime.', 'event_espresso')
+			),
+			new GraphQLOutputField(
+				'isActive',
+				'Boolean',
+				'is_active',
+				esc_html__('Flag indicating datetime is active', 'event_espresso')
+			),
+			new GraphQLOutputField(
+				'isExpired',
+				'Boolean',
+				'is_expired',
+				esc_html__('Flag indicating datetime is expired or not', 'event_espresso')
+			),
+			new GraphQLField(
+				'isPrimary',
+				'Boolean',
+				'is_primary',
+				esc_html__('Flag indicating datetime is primary one for event', 'event_espresso')
+			),
+			new GraphQLOutputField(
+				'isSoldOut',
+				'Boolean',
+				'sold_out',
+				esc_html__(
+					'Flag indicating whether the tickets sold for this datetime, met or exceed the registration limit',
+					'event_espresso'
+				)
+			),
+			new GraphQLField(
+				'isTrashed',
+				'Boolean',
+				null,
+				esc_html__('Flag indicating datetime has been trashed.', 'event_espresso'),
+				null,
+				[$this, 'getIsTrashed']
+			),
+			new GraphQLOutputField(
+				'isUpcoming',
+				'Boolean',
+				'is_upcoming',
+				esc_html__('Whether the date is upcoming', 'event_espresso')
+			),
+			new GraphQLOutputField(
+				'length',
+				'Int',
+				'length',
+				esc_html__('The length of the event (start to end time) in seconds', 'event_espresso')
+			),
+			new GraphQLField(
+				'name',
+				'String',
+				'name',
+				esc_html__('Datetime Name', 'event_espresso')
+			),
+			new GraphQLField(
+				'order',
+				'Int',
+				'order',
+				esc_html__('The order in which the Datetime is displayed', 'event_espresso')
+			),
+			new GraphQLOutputField(
+				'parent',
+				$this->name(),
+				null,
+				esc_html__('The parent datetime of the current datetime', 'event_espresso')
+			),
+			new GraphQLInputField(
+				'parent',
+				'ID',
+				null,
+				esc_html__('The parent datetime ID', 'event_espresso')
+			),
+			new GraphQLField(
+				'reserved',
+				'Int',
+				'reserved',
+				esc_html__('Quantity of tickets reserved, but not yet fully purchased', 'event_espresso')
+			),
+			new GraphQLField(
+				'startDate',
+				'String',
+				'start_date_and_time',
+				esc_html__('Start date and time of the Event', 'event_espresso'),
+				[$this, 'formatDatetime']
+			),
+			new GraphQLField(
+				'sold',
+				'Int',
+				'sold',
+				esc_html__('How many sales for this Datetime that have occurred', 'event_espresso')
+			),
+			new GraphQLOutputField(
+				'status',
+				$this->namespace . 'DatetimeStatusEnum',
+				'get_active_status',
+				esc_html__('Datetime status', 'event_espresso')
+			),
+			new GraphQLInputField(
+				'tickets',
+				['list_of' => 'ID'],
+				null,
+				sprintf(
+					'%1$s %2$s',
+					esc_html__('Globally unique IDs of the tickets related to the datetime.', 'event_espresso'),
+					esc_html__('Ignored if empty.', 'event_espresso')
+				)
+			),
+			new GraphQLField(
+				'venue',
+				'String',
+				null,
+				esc_html__('Datetime venue ID', 'event_espresso'),
+				null,
+				function (EE_Datetime $source) {
+					$venue_ID = $source->venue_ID();
+					return $venue_ID
+						// Since venue is a CPT, $type will be 'post'
+						? Relay::toGlobalId('post', $venue_ID)
+						: null;
+				}
+			),
+		];
 
-        return apply_filters(
-            'FHEE__EventEspresso_core_domain_services_graphql_types__datetime_fields',
-            $fields,
-            $this->name,
-            $this->model
-        );
-    }
+		return apply_filters(
+			'FHEE__EventEspresso_core_domain_services_graphql_types__datetime_fields',
+			$fields,
+			$this->name,
+			$this->model
+		);
+	}
 
 
-    /**
-     * @param EE_Datetime   $source  The source that's passed down the GraphQL queries
-     * @param array       $args    The inputArgs on the field
-     * @param AppContext  $context The AppContext passed down the GraphQL tree
-     * @param ResolveInfo $info    The ResolveInfo passed down the GraphQL tree
-     * @return bool
-     * @throws Exception
-     * @throws InvalidArgumentException
-     * @throws InvalidDataTypeException
-     * @throws InvalidInterfaceException
-     * @throws ReflectionException
-     * @throws UserError
-     * @throws UnexpectedEntityException
-     */
-    public function getIsTrashed(EE_Datetime $source, array $args, AppContext $context, ResolveInfo $info): bool
-    {
-        return (bool) $source->get('DTT_deleted');
-    }
+	/**
+	 * @param EE_Datetime   $source  The source that's passed down the GraphQL queries
+	 * @param array       $args    The inputArgs on the field
+	 * @param AppContext  $context The AppContext passed down the GraphQL tree
+	 * @param ResolveInfo $info    The ResolveInfo passed down the GraphQL tree
+	 * @return bool
+	 * @throws Exception
+	 * @throws InvalidArgumentException
+	 * @throws InvalidDataTypeException
+	 * @throws InvalidInterfaceException
+	 * @throws ReflectionException
+	 * @throws UserError
+	 * @throws UnexpectedEntityException
+	 */
+	public function getIsTrashed(EE_Datetime $source, array $args, AppContext $context, ResolveInfo $info): bool
+	{
+		return (bool) $source->get('DTT_deleted');
+	}
 
-    /**
-     * Return the base mutation config for bulk update.
-     *
-     * @param string $base_input
-     * @return array
-     */
-    public static function bulkUpdateBaseConfig(string $base_input): array
-    {
-        return [
-            'inputFields'     => [
-                /**
-                 * represents the input that is unique for each entity
-                 * e.g. dates may be unique for datetimes and tickets
-                 */
-                'uniqueInputs' => [
-                    'type'        => [
-                        'non_null' => ['list_of' => $base_input],
-                    ],
-                    'description' => esc_html__(
-                        'List of unique inputs for each entity in bulk update',
-                        'event_espresso'
-                    ),
-                ],
-                /**
-                 * represents the common input for all entities
-                 * e.g. capacity or quantity may be same for all dates/tickets
-                 */
-                'sharedInput' => [
-                    'type'        => $base_input,
-                    'description' => esc_html__(
-                        'Shared input for all entities in bulk update',
-                        'event_espresso'
-                    ),
-                ],
-            ],
-            'outputFields'        => [
-                'updated' => [
-                    'type' => ['list_of' => 'ID'],
-                ],
-                'failed' => [
-                    'type' => ['list_of' => 'ID'],
-                ],
-            ],
-        ];
-    }
+	/**
+	 * Return the base mutation config for bulk update.
+	 *
+	 * @param string $base_input
+	 * @return array
+	 */
+	public static function bulkUpdateBaseConfig(string $base_input): array
+	{
+		return [
+			'inputFields'     => [
+				/**
+				 * represents the input that is unique for each entity
+				 * e.g. dates may be unique for datetimes and tickets
+				 */
+				'uniqueInputs' => [
+					'type'        => [
+						'non_null' => ['list_of' => $base_input],
+					],
+					'description' => esc_html__(
+						'List of unique inputs for each entity in bulk update',
+						'event_espresso'
+					),
+				],
+				/**
+				 * represents the common input for all entities
+				 * e.g. capacity or quantity may be same for all dates/tickets
+				 */
+				'sharedInput' => [
+					'type'        => $base_input,
+					'description' => esc_html__(
+						'Shared input for all entities in bulk update',
+						'event_espresso'
+					),
+				],
+			],
+			'outputFields'        => [
+				'updated' => [
+					'type' => ['list_of' => 'ID'],
+				],
+				'failed' => [
+					'type' => ['list_of' => 'ID'],
+				],
+			],
+		];
+	}
 
 
-    /**
-     * @param array $inputFields The mutation input fields.
-     * @throws InvalidArgumentException
-     * @throws ReflectionException
-     * @throws Exception
-     */
-    public function registerMutations(array $inputFields)
-    {
-        register_graphql_input_type(
-            'Update' .  $this->name() . 'BaseInput',
-            [
-                'fields' => $inputFields,
-            ]
-        );
-        // Register mutation to update an entity.
-        register_graphql_mutation(
-            'update' . $this->name(),
-            [
-                'inputFields'         => $inputFields,
-                'outputFields'        => [
-                    lcfirst($this->name()) => [
-                        'type'    => $this->name(),
-                        'resolve' => [$this, 'resolveFromPayload'],
-                    ],
-                ],
-                'mutateAndGetPayload' => DatetimeUpdate::mutateAndGetPayload($this->model, $this),
-            ]
-        );
-        $base_input = 'Update' .  $this->name() . 'BaseInput';
-        // Register mutation to update an entity.
-        register_graphql_mutation(
-            'bulkUpdate' . $this->name(),
-            array_merge(
-                Datetime::bulkUpdateBaseConfig($base_input),
-                [
-                    'mutateAndGetPayload' => DatetimeBulkUpdate::mutateAndGetPayload($this->model, $this),
-                ]
-            )
-        );
+	/**
+	 * @param array $inputFields The mutation input fields.
+	 * @throws InvalidArgumentException
+	 * @throws ReflectionException
+	 * @throws Exception
+	 */
+	public function registerMutations(array $inputFields)
+	{
+		register_graphql_input_type(
+			'Update' .  $this->name() . 'BaseInput',
+			[
+				'fields' => $inputFields,
+			]
+		);
+		// Register mutation to update an entity.
+		register_graphql_mutation(
+			'update' . $this->name(),
+			[
+				'inputFields'         => $inputFields,
+				'outputFields'        => [
+					lcfirst($this->name()) => [
+						'type'    => $this->name(),
+						'resolve' => [$this, 'resolveFromPayload'],
+					],
+				],
+				'mutateAndGetPayload' => DatetimeUpdate::mutateAndGetPayload($this->model, $this),
+			]
+		);
+		$base_input = 'Update' .  $this->name() . 'BaseInput';
+		// Register mutation to update an entity.
+		register_graphql_mutation(
+			'bulkUpdate' . $this->name(),
+			array_merge(
+				Datetime::bulkUpdateBaseConfig($base_input),
+				[
+					'mutateAndGetPayload' => DatetimeBulkUpdate::mutateAndGetPayload($this->model, $this),
+				]
+			)
+		);
 
-        // Register mutation to update an entity.
-        register_graphql_mutation(
-            'bulkDelete' . $this->namespace . 'Entities',
-            [
-                'inputFields'         => [
-                    'entityIds'  => [
-                        'type'        => [
-                            'non_null' => ['list_of' => 'ID'],
-                        ],
-                        'description' => esc_html__('The list of GUIDs of the entities to be deleted.', 'event_espresso'),
-                    ],
-                    'entityType' => [
-                        'type'        => [
-                            'non_null' => $this->namespace . 'ModelNameEnum',
-                        ],
-                        'description' => esc_html__('The entity type for the IDs', 'event_espresso'),
-                    ],
-                    'deletePermanently' => [
-                        'type'        => 'Boolean',
-                        'description' => esc_html__('Whether to delete the entities permanently.', 'event_espresso'),
-                    ],
-                ],
-                'outputFields'        => [
-                    'deleted' => [
-                        'type' => ['list_of' => 'ID'],
-                    ],
-                    'failed' => [
-                        'type' => ['list_of' => 'ID'],
-                    ],
-                ],
-                'mutateAndGetPayload' => BulkEntityDelete::mutateAndGetPayload(),
-            ]
-        );
-        // Register mutation to delete an entity.
-        register_graphql_mutation(
-            'delete' . $this->name(),
-            [
-                'inputFields'         => [
-                    'id'                => $inputFields['id'],
-                    'deletePermanently' => [
-                        'type'        => 'Boolean',
-                        'description' => esc_html__('Whether to delete the entity permanently.', 'event_espresso'),
-                    ],
-                ],
-                'outputFields'        => [
-                    lcfirst($this->name()) => [
-                        'type'        => $this->name(),
-                        'description' => esc_html__('The object before it was deleted', 'event_espresso'),
-                        'resolve'     => static function ($payload) {
-                            $deleted = (object) $payload['deleted'];
+		// Register mutation to update an entity.
+		register_graphql_mutation(
+			'bulkDelete' . $this->namespace . 'Entities',
+			[
+				'inputFields'         => [
+					'entityIds'  => [
+						'type'        => [
+							'non_null' => ['list_of' => 'ID'],
+						],
+						'description' => esc_html__('The list of GUIDs of the entities to be deleted.', 'event_espresso'),
+					],
+					'entityType' => [
+						'type'        => [
+							'non_null' => $this->namespace . 'ModelNameEnum',
+						],
+						'description' => esc_html__('The entity type for the IDs', 'event_espresso'),
+					],
+					'deletePermanently' => [
+						'type'        => 'Boolean',
+						'description' => esc_html__('Whether to delete the entities permanently.', 'event_espresso'),
+					],
+				],
+				'outputFields'        => [
+					'deleted' => [
+						'type' => ['list_of' => 'ID'],
+					],
+					'failed' => [
+						'type' => ['list_of' => 'ID'],
+					],
+				],
+				'mutateAndGetPayload' => BulkEntityDelete::mutateAndGetPayload(),
+			]
+		);
+		// Register mutation to delete an entity.
+		register_graphql_mutation(
+			'delete' . $this->name(),
+			[
+				'inputFields'         => [
+					'id'                => $inputFields['id'],
+					'deletePermanently' => [
+						'type'        => 'Boolean',
+						'description' => esc_html__('Whether to delete the entity permanently.', 'event_espresso'),
+					],
+				],
+				'outputFields'        => [
+					lcfirst($this->name()) => [
+						'type'        => $this->name(),
+						'description' => esc_html__('The object before it was deleted', 'event_espresso'),
+						'resolve'     => static function ($payload) {
+							$deleted = (object) $payload['deleted'];
 
-                            return ! empty($deleted) ? $deleted : null;
-                        },
-                    ],
-                ],
-                'mutateAndGetPayload' => DatetimeDelete::mutateAndGetPayload($this->model, $this),
-            ]
-        );
+							return ! empty($deleted) ? $deleted : null;
+						},
+					],
+				],
+				'mutateAndGetPayload' => DatetimeDelete::mutateAndGetPayload($this->model, $this),
+			]
+		);
 
-        // remove primary key from input.
-        unset($inputFields['id']);
-        // Register mutation to update an entity.
-        register_graphql_mutation(
-            'create' . $this->name(),
-            [
-                'inputFields'         => $inputFields,
-                'outputFields'        => [
-                    lcfirst($this->name()) => [
-                        'type'    => $this->name(),
-                        'resolve' => [$this, 'resolveFromPayload'],
-                    ],
-                ],
-                'mutateAndGetPayload' => DatetimeCreate::mutateAndGetPayload($this->model, $this),
-            ]
-        );
+		// remove primary key from input.
+		unset($inputFields['id']);
+		// Register mutation to update an entity.
+		register_graphql_mutation(
+			'create' . $this->name(),
+			[
+				'inputFields'         => $inputFields,
+				'outputFields'        => [
+					lcfirst($this->name()) => [
+						'type'    => $this->name(),
+						'resolve' => [$this, 'resolveFromPayload'],
+					],
+				],
+				'mutateAndGetPayload' => DatetimeCreate::mutateAndGetPayload($this->model, $this),
+			]
+		);
 
-        // Register mutation to update an entity.
-        register_graphql_mutation(
-            'reorder' . $this->namespace . 'Entities',
-            [
-                'inputFields'         => [
-                    'entityIds'  => [
-                        'type'        => [
-                            'non_null' => ['list_of' => 'ID'],
-                        ],
-                        'description' => esc_html__('The reordered list of entity GUIDs.', 'event_espresso'),
-                    ],
-                    'entityType' => [
-                        'type'        => [
-                            'non_null' => $this->namespace . 'ModelNameEnum',
-                        ],
-                        'description' => esc_html__('The entity type for the IDs', 'event_espresso'),
-                    ],
-                ],
-                'outputFields'        => [
-                    'ok' => [
-                        'type'    => 'Boolean',
-                        'resolve' => function ($payload) {
-                            return (bool) $payload['ok'];
-                        },
-                    ],
-                ],
-                'mutateAndGetPayload' => EntityReorder::mutateAndGetPayload(),
-            ]
-        );
-    }
+		// Register mutation to update an entity.
+		register_graphql_mutation(
+			'reorder' . $this->namespace . 'Entities',
+			[
+				'inputFields'         => [
+					'entityIds'  => [
+						'type'        => [
+							'non_null' => ['list_of' => 'ID'],
+						],
+						'description' => esc_html__('The reordered list of entity GUIDs.', 'event_espresso'),
+					],
+					'entityType' => [
+						'type'        => [
+							'non_null' => $this->namespace . 'ModelNameEnum',
+						],
+						'description' => esc_html__('The entity type for the IDs', 'event_espresso'),
+					],
+				],
+				'outputFields'        => [
+					'ok' => [
+						'type'    => 'Boolean',
+						'resolve' => function ($payload) {
+							return (bool) $payload['ok'];
+						},
+					],
+				],
+				'mutateAndGetPayload' => EntityReorder::mutateAndGetPayload(),
+			]
+		);
+	}
 }

core/libraries/plugin_api/EE_Register_Message_Type.lib.php

Spacing +8 added lines, -8 removed lines

@@ -60,7 +60,7 @@ 
         }
 
         // make sure we don't register twice
-        if (isset(self::$_ee_message_type_registry[ $addon_name ])) {
+        if (isset(self::$_ee_message_type_registry[$addon_name])) {
             return true;
         }
 
@@ -82,7 +82,7 @@ 
             );
         }
         // setup $__ee_message_type_registry array from incoming values.
-        self::$_ee_message_type_registry[ $addon_name ] = [
+        self::$_ee_message_type_registry[$addon_name] = [
             /**
              * The file name for the message type being registered.
              * Required.
@@ -263,7 +263,7 @@ 
      */
     public static function deregister(string $addon_name = '')
     {
-        if (! empty(self::$_ee_message_type_registry[ $addon_name ])) {
+        if ( ! empty(self::$_ee_message_type_registry[$addon_name])) {
             // let's make sure that we remove any place this message type was made active
             /** @var EE_Message_Resource_Manager $Message_Resource_Manager */
             $Message_Resource_Manager = EE_Registry::instance()->load_lib('Message_Resource_Manager');
@@ -275,7 +275,7 @@ 
             );
             $Message_Resource_Manager->deactivate_message_type($addon_name, false);
         }
-        unset(self::$_ee_message_type_registry[ $addon_name ]);
+        unset(self::$_ee_message_type_registry[$addon_name]);
     }
 
 
@@ -311,7 +311,7 @@ 
     public static function register_msgs_autoload_paths(array $paths): array
     {
         $autoload_paths = [];
-        if (! empty(self::$_ee_message_type_registry)) {
+        if ( ! empty(self::$_ee_message_type_registry)) {
             foreach (self::$_ee_message_type_registry as $mt_reg) {
                 if (empty($mt_reg['autoloadpaths'])) {
                     continue;
@@ -400,7 +400,7 @@ 
                 continue;
             }
             foreach ($mt_reg['messengers_supporting_default_template_pack_with'] as $messenger_slug) {
-                $supports[ $messenger_slug ][] = $addon_name;
+                $supports[$messenger_slug][] = $addon_name;
             }
         }
         return $supports;
@@ -472,7 +472,7 @@ 
         string $file_extension,
         EE_Messages_Template_Pack $template_pack
     ): string {
-        if (! $template_pack instanceof EE_Messages_Template_Pack_Default) {
+        if ( ! $template_pack instanceof EE_Messages_Template_Pack_Default) {
             return $base_path_or_url;
         }
         foreach (self::$_ee_message_type_registry as $addon_name => $mt_reg) {
@@ -480,7 +480,7 @@ 
                 if ($url && ! empty($mt_reg['base_url_for_default_variation'])) {
                     return $mt_reg['base_url_for_default_variation'];
                 }
-                if (! $url && ! empty($mt_reg['base_path_for_default_variation'])) {
+                if ( ! $url && ! empty($mt_reg['base_path_for_default_variation'])) {
                     return $mt_reg['base_path_for_default_variation'];
                 }
             }

Indentation +453 added lines, -453 removed lines

@@ -10,485 +10,485 @@
  */
 class EE_Register_Message_Type implements EEI_Plugin_API
 {
-    /**
-     * Holds values for registered message types
-     *
-     * @var array
-     */
-    protected static $_ee_message_type_registry = [];
+	/**
+	 * Holds values for registered message types
+	 *
+	 * @var array
+	 */
+	protected static $_ee_message_type_registry = [];
 
 
-    /**
-     * Method for registering new message types in the EE_messages system.
-     * Note:  All message types must have the following files in order to work:
-     * Template files for default templates getting setup.
-     * See /core/libraries/messages/defaults/default/ for examples
-     * (note that template files match a specific naming schema).
-     * These templates will need to be registered with the default template pack.
-     * - EE_Messages_Validator extended class(es).  See /core/libraries/messages/validators/email/
-     *      for examples.  Note for any new message types, there will need to be a validator for each
-     *      messenger combo this message type can activate with.
-     * - And of course the main EE_{Message_Type_Name}_message_type class that defines the new
-     *      message type and its properties.
-     *
-     * @param string $addon_name    Whatever is defined for the $name property of
-     *                              the message type you are registering (eg.
-     *                              declined_registration). Required.
-     * @param array  $setup_args    An array of arguments provided for registering the message type.
-     * @throws EE_Error
-     *                              }
-     * @see      inline docs in the register method for what can be passed in as arguments.
-     * @since    4.3.0
-     */
-    public static function register(string $addon_name = '', array $setup_args = []): bool
-    {
-        // required fields MUST be present, so let's make sure they are.
-        if (
-            ! isset($addon_name)
-            || ! is_array($setup_args)
-            || empty($setup_args['mtfilename'])
-            || empty($setup_args['autoloadpaths'])
-        ) {
-            throw new EE_Error(
-                esc_html__(
-                    'In order to register a message type with EE_Register_Message_Type::register, you must include a unique name for the message type, plus an array containing the following keys: "mtfilename", "autoloadpaths"',
-                    'event_espresso'
-                )
-            );
-        }
+	/**
+	 * Method for registering new message types in the EE_messages system.
+	 * Note:  All message types must have the following files in order to work:
+	 * Template files for default templates getting setup.
+	 * See /core/libraries/messages/defaults/default/ for examples
+	 * (note that template files match a specific naming schema).
+	 * These templates will need to be registered with the default template pack.
+	 * - EE_Messages_Validator extended class(es).  See /core/libraries/messages/validators/email/
+	 *      for examples.  Note for any new message types, there will need to be a validator for each
+	 *      messenger combo this message type can activate with.
+	 * - And of course the main EE_{Message_Type_Name}_message_type class that defines the new
+	 *      message type and its properties.
+	 *
+	 * @param string $addon_name    Whatever is defined for the $name property of
+	 *                              the message type you are registering (eg.
+	 *                              declined_registration). Required.
+	 * @param array  $setup_args    An array of arguments provided for registering the message type.
+	 * @throws EE_Error
+	 *                              }
+	 * @see      inline docs in the register method for what can be passed in as arguments.
+	 * @since    4.3.0
+	 */
+	public static function register(string $addon_name = '', array $setup_args = []): bool
+	{
+		// required fields MUST be present, so let's make sure they are.
+		if (
+			! isset($addon_name)
+			|| ! is_array($setup_args)
+			|| empty($setup_args['mtfilename'])
+			|| empty($setup_args['autoloadpaths'])
+		) {
+			throw new EE_Error(
+				esc_html__(
+					'In order to register a message type with EE_Register_Message_Type::register, you must include a unique name for the message type, plus an array containing the following keys: "mtfilename", "autoloadpaths"',
+					'event_espresso'
+				)
+			);
+		}
 
-        // make sure we don't register twice
-        if (isset(self::$_ee_message_type_registry[ $addon_name ])) {
-            return true;
-        }
+		// make sure we don't register twice
+		if (isset(self::$_ee_message_type_registry[ $addon_name ])) {
+			return true;
+		}
 
-        // make sure this was called in the right place!
-        if (
-            ! did_action('EE_Brewing_Regular___messages_caf')
-            || did_action('AHEE__EE_System__perform_activations_upgrades_and_migrations')
-        ) {
-            EE_Error::doing_it_wrong(
-                __METHOD__,
-                sprintf(
-                    esc_html__(
-                        'A message type named "%s" has been attempted to be registered with the EE Messages System.  It may or may not work because it should be only called on the "EE_Brewing_Regular___messages_caf" hook.',
-                        'event_espresso'
-                    ),
-                    $addon_name
-                ),
-                '4.3.0'
-            );
-        }
-        // setup $__ee_message_type_registry array from incoming values.
-        self::$_ee_message_type_registry[ $addon_name ] = [
-            /**
-             * The file name for the message type being registered.
-             * Required.
-             *
-             * @type string
-             */
-            'mtfilename'                                       => (string) $setup_args['mtfilename'],
-            /**
-             * Autoload paths for classes used by the message type.
-             * Required.
-             *
-             * @type array
-             */
-            'autoloadpaths'                                    => (array) $setup_args['autoloadpaths'],
-            /**
-             * Messengers that the message type should be able to activate with.
-             * Use messenger slugs.
-             *
-             * @type array
-             */
-            'messengers_to_activate_with'                      => ! empty($setup_args['messengers_to_activate_with'])
-                ? (array) $setup_args['messengers_to_activate_with']
-                : [],
-            /**
-             * Messengers that the message type should validate with.
-             * Use messenger slugs.
-             *
-             * @type array
-             */
-            'messengers_to_validate_with'                      => ! empty($setup_args['messengers_to_validate_with'])
-                ? (array) $setup_args['messengers_to_validate_with']
-                : [],
-            /**
-             * Whether to force activate this message type the first time it is registered.
-             *
-             * @type bool   False means its not activated by default and left up to the end user to activate.
-             */
-            'force_activation'                                 => ! empty($setup_args['force_activation'])
-                                                                  && $setup_args['force_activation'],
-            /**
-             * What messengers this message type supports the default template pack for.
-             * Note: If you do not set this (or any of the following template pack/variation related arguments) to true,
-             * then it is expected that the message type being registered is doing its own custom default template
-             * pack/variation registration.
-             *
-             * If this is set and has values, then it is expected that the following arguments are also set in the incoming options
-             * $setup_arguments array as well:
-             * - 'base_path_for_default_templates'
-             *
-             * @type array   Expect an array of messengers this supports default template packs for.
-             */
-            'messengers_supporting_default_template_pack_with' => isset($setup_args['messengers_supporting_default_template_pack_with'])
-                ? (array) $setup_args['messengers_supporting_default_template_pack_with']
-                : [],
-            /**
-             * The base path where the default templates for this message type can be found.
-             *
-             * @type string
-             */
-            'base_path_for_default_templates'                  => $setup_args['base_path_for_default_templates'] ?? '',
-            /**
-             * The base path where the default variations for this message type can be found.
-             *
-             * @type string
-             */
-            'base_path_for_default_variation'                  => $setup_args['base_path_for_default_variation'] ?? '',
-            /**
-             * The base url for the default variations for this message type.
-             *
-             * @type string
-             */
-            'base_url_for_default_variation'                   => $setup_args['base_url_for_default_variation'] ?? '',
-        ];
-        // add filters but only if they haven't already been set (these filters only need to be registered ONCE because
-        // the callback handles all registered message types.
-        if (
-            has_filter(
-                'FHEE__EED_Messages___set_messages_paths___MSG_PATHS',
-                ['EE_Register_Message_Type', 'register_msgs_autoload_paths']
-            ) === false
-        ) {
-            add_filter(
-                'FHEE__EED_Messages___set_messages_paths___MSG_PATHS',
-                ['EE_Register_Message_Type', 'register_msgs_autoload_paths'],
-                10
-            );
-            add_filter(
-                'FHEE__EE_messages__get_installed__messagetype_files',
-                ['EE_Register_Message_Type', 'register_messagetype_files'],
-                10,
-                1
-            );
-            add_filter(
-                'FHEE__EE_messenger__get_default_message_types__default_types',
-                ['EE_Register_Message_Type', 'register_messengers_to_activate_mt_with'],
-                10,
-                2
-            );
-            add_filter(
-                'FHEE__EE_messenger__get_valid_message_types__valid_types',
-                ['EE_Register_Message_Type', 'register_messengers_to_validate_mt_with'],
-                10,
-                2
-            );
-            // actions
-            add_action(
-                'AHEE__EE_Addon__initialize_default_data__begin',
-                ['EE_Register_Message_Type', 'set_defaults']
-            );
+		// make sure this was called in the right place!
+		if (
+			! did_action('EE_Brewing_Regular___messages_caf')
+			|| did_action('AHEE__EE_System__perform_activations_upgrades_and_migrations')
+		) {
+			EE_Error::doing_it_wrong(
+				__METHOD__,
+				sprintf(
+					esc_html__(
+						'A message type named "%s" has been attempted to be registered with the EE Messages System.  It may or may not work because it should be only called on the "EE_Brewing_Regular___messages_caf" hook.',
+						'event_espresso'
+					),
+					$addon_name
+				),
+				'4.3.0'
+			);
+		}
+		// setup $__ee_message_type_registry array from incoming values.
+		self::$_ee_message_type_registry[ $addon_name ] = [
+			/**
+			 * The file name for the message type being registered.
+			 * Required.
+			 *
+			 * @type string
+			 */
+			'mtfilename'                                       => (string) $setup_args['mtfilename'],
+			/**
+			 * Autoload paths for classes used by the message type.
+			 * Required.
+			 *
+			 * @type array
+			 */
+			'autoloadpaths'                                    => (array) $setup_args['autoloadpaths'],
+			/**
+			 * Messengers that the message type should be able to activate with.
+			 * Use messenger slugs.
+			 *
+			 * @type array
+			 */
+			'messengers_to_activate_with'                      => ! empty($setup_args['messengers_to_activate_with'])
+				? (array) $setup_args['messengers_to_activate_with']
+				: [],
+			/**
+			 * Messengers that the message type should validate with.
+			 * Use messenger slugs.
+			 *
+			 * @type array
+			 */
+			'messengers_to_validate_with'                      => ! empty($setup_args['messengers_to_validate_with'])
+				? (array) $setup_args['messengers_to_validate_with']
+				: [],
+			/**
+			 * Whether to force activate this message type the first time it is registered.
+			 *
+			 * @type bool   False means its not activated by default and left up to the end user to activate.
+			 */
+			'force_activation'                                 => ! empty($setup_args['force_activation'])
+																  && $setup_args['force_activation'],
+			/**
+			 * What messengers this message type supports the default template pack for.
+			 * Note: If you do not set this (or any of the following template pack/variation related arguments) to true,
+			 * then it is expected that the message type being registered is doing its own custom default template
+			 * pack/variation registration.
+			 *
+			 * If this is set and has values, then it is expected that the following arguments are also set in the incoming options
+			 * $setup_arguments array as well:
+			 * - 'base_path_for_default_templates'
+			 *
+			 * @type array   Expect an array of messengers this supports default template packs for.
+			 */
+			'messengers_supporting_default_template_pack_with' => isset($setup_args['messengers_supporting_default_template_pack_with'])
+				? (array) $setup_args['messengers_supporting_default_template_pack_with']
+				: [],
+			/**
+			 * The base path where the default templates for this message type can be found.
+			 *
+			 * @type string
+			 */
+			'base_path_for_default_templates'                  => $setup_args['base_path_for_default_templates'] ?? '',
+			/**
+			 * The base path where the default variations for this message type can be found.
+			 *
+			 * @type string
+			 */
+			'base_path_for_default_variation'                  => $setup_args['base_path_for_default_variation'] ?? '',
+			/**
+			 * The base url for the default variations for this message type.
+			 *
+			 * @type string
+			 */
+			'base_url_for_default_variation'                   => $setup_args['base_url_for_default_variation'] ?? '',
+		];
+		// add filters but only if they haven't already been set (these filters only need to be registered ONCE because
+		// the callback handles all registered message types.
+		if (
+			has_filter(
+				'FHEE__EED_Messages___set_messages_paths___MSG_PATHS',
+				['EE_Register_Message_Type', 'register_msgs_autoload_paths']
+			) === false
+		) {
+			add_filter(
+				'FHEE__EED_Messages___set_messages_paths___MSG_PATHS',
+				['EE_Register_Message_Type', 'register_msgs_autoload_paths'],
+				10
+			);
+			add_filter(
+				'FHEE__EE_messages__get_installed__messagetype_files',
+				['EE_Register_Message_Type', 'register_messagetype_files'],
+				10,
+				1
+			);
+			add_filter(
+				'FHEE__EE_messenger__get_default_message_types__default_types',
+				['EE_Register_Message_Type', 'register_messengers_to_activate_mt_with'],
+				10,
+				2
+			);
+			add_filter(
+				'FHEE__EE_messenger__get_valid_message_types__valid_types',
+				['EE_Register_Message_Type', 'register_messengers_to_validate_mt_with'],
+				10,
+				2
+			);
+			// actions
+			add_action(
+				'AHEE__EE_Addon__initialize_default_data__begin',
+				['EE_Register_Message_Type', 'set_defaults']
+			);
 
-            // default template packs and variations related
-            add_filter(
-                'FHEE__EE_Messages_Template_Pack_Default__get_supports',
-                ['EE_Register_Message_Type', 'register_default_template_pack_supports']
-            );
-            add_filter(
-                'FHEE__EE_Template_Pack___get_specific_template__filtered_base_path',
-                ['EE_Register_Message_Type', 'register_base_template_path'],
-                10,
-                6
-            );
-            add_filter(
-                'FHEE__EE_Messages_Template_Pack__get_variation__base_path_or_url',
-                ['EE_Register_Message_Type', 'register_variation_base_path_or_url'],
-                10,
-                8
-            );
-            add_filter(
-                'FHEE__EE_Messages_Template_Pack__get_variation__base_path',
-                ['EE_Register_Message_Type', 'register_variation_base_path_or_url'],
-                10,
-                8
-            );
-        }
-        return true;
-    }
+			// default template packs and variations related
+			add_filter(
+				'FHEE__EE_Messages_Template_Pack_Default__get_supports',
+				['EE_Register_Message_Type', 'register_default_template_pack_supports']
+			);
+			add_filter(
+				'FHEE__EE_Template_Pack___get_specific_template__filtered_base_path',
+				['EE_Register_Message_Type', 'register_base_template_path'],
+				10,
+				6
+			);
+			add_filter(
+				'FHEE__EE_Messages_Template_Pack__get_variation__base_path_or_url',
+				['EE_Register_Message_Type', 'register_variation_base_path_or_url'],
+				10,
+				8
+			);
+			add_filter(
+				'FHEE__EE_Messages_Template_Pack__get_variation__base_path',
+				['EE_Register_Message_Type', 'register_variation_base_path_or_url'],
+				10,
+				8
+			);
+		}
+		return true;
+	}
 
 
-    /**
-     * This just ensures that when an addon registers a message type that on initial activation/reactivation the
-     * defaults the addon sets are taken care of.
-     *
-     * @throws EE_Error
-     * @throws ReflectionException
-     */
-    public static function set_defaults()
-    {
-        /** @type EE_Message_Resource_Manager $message_resource_manager */
-        $message_resource_manager = EE_Registry::instance()->load_lib('Message_Resource_Manager');
+	/**
+	 * This just ensures that when an addon registers a message type that on initial activation/reactivation the
+	 * defaults the addon sets are taken care of.
+	 *
+	 * @throws EE_Error
+	 * @throws ReflectionException
+	 */
+	public static function set_defaults()
+	{
+		/** @type EE_Message_Resource_Manager $message_resource_manager */
+		$message_resource_manager = EE_Registry::instance()->load_lib('Message_Resource_Manager');
 
-        // for any message types with force activation, let's ensure they are activated
-        foreach (self::$_ee_message_type_registry as $addon_name => $settings) {
-            if ($settings['force_activation']) {
-                foreach ($settings['messengers_to_activate_with'] as $messenger) {
-                    // DO not force activation if this message type has already been activated in the system
-                    if (
-                        ! $message_resource_manager->has_message_type_been_activated_for_messenger(
-                            $addon_name,
-                            $messenger
-                        )
-                    ) {
-                        $message_resource_manager->ensure_message_type_is_active($addon_name, $messenger);
-                    }
-                }
-            }
-        }
-    }
+		// for any message types with force activation, let's ensure they are activated
+		foreach (self::$_ee_message_type_registry as $addon_name => $settings) {
+			if ($settings['force_activation']) {
+				foreach ($settings['messengers_to_activate_with'] as $messenger) {
+					// DO not force activation if this message type has already been activated in the system
+					if (
+						! $message_resource_manager->has_message_type_been_activated_for_messenger(
+							$addon_name,
+							$messenger
+						)
+					) {
+						$message_resource_manager->ensure_message_type_is_active($addon_name, $messenger);
+					}
+				}
+			}
+		}
+	}
 
 
-    /**
-     * This deregisters a message type that was previously registered with a specific message_type_name.
-     *
-     * @param string $addon_name the name for the message type that was previously registered
-     * @return void
-     * @throws EE_Error
-     * @throws ReflectionException
-     * @since    4.3.0
-     */
-    public static function deregister(string $addon_name = '')
-    {
-        if (! empty(self::$_ee_message_type_registry[ $addon_name ])) {
-            // let's make sure that we remove any place this message type was made active
-            /** @var EE_Message_Resource_Manager $Message_Resource_Manager */
-            $Message_Resource_Manager = EE_Registry::instance()->load_lib('Message_Resource_Manager');
-            // ensures that if this message type is registered again that it retains its previous active state vs
-            // remaining inactive.
-            $Message_Resource_Manager->remove_message_type_has_been_activated_from_all_messengers(
-                $addon_name,
-                true
-            );
-            $Message_Resource_Manager->deactivate_message_type($addon_name, false);
-        }
-        unset(self::$_ee_message_type_registry[ $addon_name ]);
-    }
+	/**
+	 * This deregisters a message type that was previously registered with a specific message_type_name.
+	 *
+	 * @param string $addon_name the name for the message type that was previously registered
+	 * @return void
+	 * @throws EE_Error
+	 * @throws ReflectionException
+	 * @since    4.3.0
+	 */
+	public static function deregister(string $addon_name = '')
+	{
+		if (! empty(self::$_ee_message_type_registry[ $addon_name ])) {
+			// let's make sure that we remove any place this message type was made active
+			/** @var EE_Message_Resource_Manager $Message_Resource_Manager */
+			$Message_Resource_Manager = EE_Registry::instance()->load_lib('Message_Resource_Manager');
+			// ensures that if this message type is registered again that it retains its previous active state vs
+			// remaining inactive.
+			$Message_Resource_Manager->remove_message_type_has_been_activated_from_all_messengers(
+				$addon_name,
+				true
+			);
+			$Message_Resource_Manager->deactivate_message_type($addon_name, false);
+		}
+		unset(self::$_ee_message_type_registry[ $addon_name ]);
+	}
 
 
-    /**
-     * callback for FHEE__EE_messages__get_installed__messagetype_files filter.
-     *
-     * @param array $messagetype_files The current array of message type file names
-     * @return  array                                 Array of message type file names
-     * @since   4.3.0
-     */
-    public static function register_messagetype_files(array $messagetype_files): array
-    {
-        if (empty(self::$_ee_message_type_registry)) {
-            return $messagetype_files;
-        }
-        foreach (self::$_ee_message_type_registry as $mt_reg) {
-            if (empty($mt_reg['mtfilename'])) {
-                continue;
-            }
-            $messagetype_files[] = $mt_reg['mtfilename'];
-        }
-        return $messagetype_files;
-    }
+	/**
+	 * callback for FHEE__EE_messages__get_installed__messagetype_files filter.
+	 *
+	 * @param array $messagetype_files The current array of message type file names
+	 * @return  array                                 Array of message type file names
+	 * @since   4.3.0
+	 */
+	public static function register_messagetype_files(array $messagetype_files): array
+	{
+		if (empty(self::$_ee_message_type_registry)) {
+			return $messagetype_files;
+		}
+		foreach (self::$_ee_message_type_registry as $mt_reg) {
+			if (empty($mt_reg['mtfilename'])) {
+				continue;
+			}
+			$messagetype_files[] = $mt_reg['mtfilename'];
+		}
+		return $messagetype_files;
+	}
 
 
-    /**
-     * callback for FHEE__EED_Messages___set_messages_paths___MSG_PATHS filter.
-     *
-     * @param array $paths array of paths to be checked by EE_messages autoloader.
-     * @return array
-     * @since    4.3.0
-     */
-    public static function register_msgs_autoload_paths(array $paths): array
-    {
-        $autoload_paths = [];
-        if (! empty(self::$_ee_message_type_registry)) {
-            foreach (self::$_ee_message_type_registry as $mt_reg) {
-                if (empty($mt_reg['autoloadpaths'])) {
-                    continue;
-                }
-                $autoload_paths[] = $mt_reg['autoloadpaths'];
-            }
-        }
-        return array_merge($paths, ...$autoload_paths);
-    }
+	/**
+	 * callback for FHEE__EED_Messages___set_messages_paths___MSG_PATHS filter.
+	 *
+	 * @param array $paths array of paths to be checked by EE_messages autoloader.
+	 * @return array
+	 * @since    4.3.0
+	 */
+	public static function register_msgs_autoload_paths(array $paths): array
+	{
+		$autoload_paths = [];
+		if (! empty(self::$_ee_message_type_registry)) {
+			foreach (self::$_ee_message_type_registry as $mt_reg) {
+				if (empty($mt_reg['autoloadpaths'])) {
+					continue;
+				}
+				$autoload_paths[] = $mt_reg['autoloadpaths'];
+			}
+		}
+		return array_merge($paths, ...$autoload_paths);
+	}
 
 
-    /**
-     * callback for FHEE__EE_messenger__get_default_message_types__default_types filter.
-     *
-     * @param array        $default_types   array of message types activated with messenger (
-     *                                      corresponds to the $name property of message type)
-     * @param EE_messenger $messenger       The EE_messenger the filter is called from.
-     * @return array
-     * @since  4.3.0
-     */
-    public static function register_messengers_to_activate_mt_with(array $default_types, EE_messenger $messenger): array
-    {
-        if (empty(self::$_ee_message_type_registry)) {
-            return $default_types;
-        }
-        foreach (self::$_ee_message_type_registry as $addon_name => $mt_reg) {
-            if (empty($mt_reg['messengers_to_activate_with']) || empty($mt_reg['mtfilename'])) {
-                continue;
-            }
-            // loop through each of the messengers and if it matches the loaded class
-            // then we add this message type to the
-            foreach ($mt_reg['messengers_to_activate_with'] as $msgr) {
-                if ($messenger->name == $msgr) {
-                    $default_types[] = $addon_name;
-                }
-            }
-        }
+	/**
+	 * callback for FHEE__EE_messenger__get_default_message_types__default_types filter.
+	 *
+	 * @param array        $default_types   array of message types activated with messenger (
+	 *                                      corresponds to the $name property of message type)
+	 * @param EE_messenger $messenger       The EE_messenger the filter is called from.
+	 * @return array
+	 * @since  4.3.0
+	 */
+	public static function register_messengers_to_activate_mt_with(array $default_types, EE_messenger $messenger): array
+	{
+		if (empty(self::$_ee_message_type_registry)) {
+			return $default_types;
+		}
+		foreach (self::$_ee_message_type_registry as $addon_name => $mt_reg) {
+			if (empty($mt_reg['messengers_to_activate_with']) || empty($mt_reg['mtfilename'])) {
+				continue;
+			}
+			// loop through each of the messengers and if it matches the loaded class
+			// then we add this message type to the
+			foreach ($mt_reg['messengers_to_activate_with'] as $msgr) {
+				if ($messenger->name == $msgr) {
+					$default_types[] = $addon_name;
+				}
+			}
+		}
 
-        return $default_types;
-    }
+		return $default_types;
+	}
 
 
-    /**
-     * callback for FHEE__EE_messenger__get_valid_message_types__default_types filter.
-     *
-     * @param array        $valid_types     array of message types valid with messenger (
-     *                                      corresponds to the $name property of message type)
-     * @param EE_messenger $messenger       The EE_messenger the filter is called from.
-     * @return  array
-     * @since   4.3.0
-     */
-    public static function register_messengers_to_validate_mt_with(array $valid_types, EE_messenger $messenger): array
-    {
-        if (empty(self::$_ee_message_type_registry)) {
-            return $valid_types;
-        }
-        foreach (self::$_ee_message_type_registry as $addon_name => $mt_reg) {
-            if (empty($mt_reg['messengers_to_validate_with']) || empty($mt_reg['mtfilename'])) {
-                continue;
-            }
-            // loop through each of the messengers and if it matches the loaded class
-            // then we add this message type to the
-            foreach ($mt_reg['messengers_to_validate_with'] as $msgr) {
-                if ($messenger->name == $msgr) {
-                    $valid_types[] = $addon_name;
-                }
-            }
-        }
+	/**
+	 * callback for FHEE__EE_messenger__get_valid_message_types__default_types filter.
+	 *
+	 * @param array        $valid_types     array of message types valid with messenger (
+	 *                                      corresponds to the $name property of message type)
+	 * @param EE_messenger $messenger       The EE_messenger the filter is called from.
+	 * @return  array
+	 * @since   4.3.0
+	 */
+	public static function register_messengers_to_validate_mt_with(array $valid_types, EE_messenger $messenger): array
+	{
+		if (empty(self::$_ee_message_type_registry)) {
+			return $valid_types;
+		}
+		foreach (self::$_ee_message_type_registry as $addon_name => $mt_reg) {
+			if (empty($mt_reg['messengers_to_validate_with']) || empty($mt_reg['mtfilename'])) {
+				continue;
+			}
+			// loop through each of the messengers and if it matches the loaded class
+			// then we add this message type to the
+			foreach ($mt_reg['messengers_to_validate_with'] as $msgr) {
+				if ($messenger->name == $msgr) {
+					$valid_types[] = $addon_name;
+				}
+			}
+		}
 
-        return $valid_types;
-    }
+		return $valid_types;
+	}
 
 
-    /**
-     * Callback for `FHEE__EE_Messages_Template_Pack_Default__get_supports` filter to register this message type as
-     * supporting the default template pack
-     *
-     * @param array $supports
-     *
-     * @return array
-     */
-    public static function register_default_template_pack_supports(array $supports): array
-    {
-        foreach (self::$_ee_message_type_registry as $addon_name => $mt_reg) {
-            if (empty($mt_reg['messengers_supporting_default_template_pack_with'])) {
-                continue;
-            }
-            foreach ($mt_reg['messengers_supporting_default_template_pack_with'] as $messenger_slug) {
-                $supports[ $messenger_slug ][] = $addon_name;
-            }
-        }
-        return $supports;
-    }
+	/**
+	 * Callback for `FHEE__EE_Messages_Template_Pack_Default__get_supports` filter to register this message type as
+	 * supporting the default template pack
+	 *
+	 * @param array $supports
+	 *
+	 * @return array
+	 */
+	public static function register_default_template_pack_supports(array $supports): array
+	{
+		foreach (self::$_ee_message_type_registry as $addon_name => $mt_reg) {
+			if (empty($mt_reg['messengers_supporting_default_template_pack_with'])) {
+				continue;
+			}
+			foreach ($mt_reg['messengers_supporting_default_template_pack_with'] as $messenger_slug) {
+				$supports[ $messenger_slug ][] = $addon_name;
+			}
+		}
+		return $supports;
+	}
 
 
-    /**
-     * Callback for FHEE__EE_Template_Pack___get_specific_template__filtered_base_path
-     *
-     * @param string                    $base_path The original base path for message templates
-     * @param EE_messenger              $messenger
-     * @param EE_message_type           $message_type
-     * @param string                    $field     The field requesting a template
-     * @param string                    $context   The context requesting a template
-     * @param EE_Messages_Template_Pack $template_pack
-     *
-     * @return string
-     */
-    public static function register_base_template_path(
-        string $base_path,
-        EE_messenger $messenger,
-        EE_message_type $message_type,
-        string $field,
-        string $context,
-        EE_Messages_Template_Pack $template_pack
-    ): string {
-        if (
-            ! $template_pack instanceof EE_Messages_Template_Pack_Default
-            || ! $message_type instanceof EE_message_type
-        ) {
-            return $base_path;
-        }
-        foreach (self::$_ee_message_type_registry as $addon_name => $mt_reg) {
-            if (
-                $message_type->name === $addon_name
-                && ! empty($mt_reg['base_path_for_default_templates'])
-            ) {
-                return $mt_reg['base_path_for_default_templates'];
-            }
-        }
-        return $base_path;
-    }
+	/**
+	 * Callback for FHEE__EE_Template_Pack___get_specific_template__filtered_base_path
+	 *
+	 * @param string                    $base_path The original base path for message templates
+	 * @param EE_messenger              $messenger
+	 * @param EE_message_type           $message_type
+	 * @param string                    $field     The field requesting a template
+	 * @param string                    $context   The context requesting a template
+	 * @param EE_Messages_Template_Pack $template_pack
+	 *
+	 * @return string
+	 */
+	public static function register_base_template_path(
+		string $base_path,
+		EE_messenger $messenger,
+		EE_message_type $message_type,
+		string $field,
+		string $context,
+		EE_Messages_Template_Pack $template_pack
+	): string {
+		if (
+			! $template_pack instanceof EE_Messages_Template_Pack_Default
+			|| ! $message_type instanceof EE_message_type
+		) {
+			return $base_path;
+		}
+		foreach (self::$_ee_message_type_registry as $addon_name => $mt_reg) {
+			if (
+				$message_type->name === $addon_name
+				&& ! empty($mt_reg['base_path_for_default_templates'])
+			) {
+				return $mt_reg['base_path_for_default_templates'];
+			}
+		}
+		return $base_path;
+	}
 
 
-    /**
-     * Callback for FHEE__EE_Messages_Template_Pack__get_variation__base_path and
-     * FHEE__EE_Messages_Template_Pack__get_variation__base_path_or_url hooks
-     *
-     * @param string                    $base_path_or_url  The original incoming base url or path
-     * @param string                    $messenger_slug    The slug of the messenger the template is being generated
-     *                                                     for.
-     * @param string                    $message_type_slug The slug of the message type the template is being generated
-     *                                                     for.
-     * @param string                    $type              The "type" of css being requested.
-     * @param string                    $variation         The variation being requested.
-     * @param bool                      $url               whether a url or path is being requested.
-     * @param string                    $file_extension    What file extension is expected for the variation file.
-     * @param EE_Messages_Template_Pack $template_pack
-     *
-     * @return string
-     */
-    public static function register_variation_base_path_or_url(
-        string $base_path_or_url,
-        string $messenger_slug,
-        string $message_type_slug,
-        string $type,
-        string $variation,
-        bool $url,
-        string $file_extension,
-        EE_Messages_Template_Pack $template_pack
-    ): string {
-        if (! $template_pack instanceof EE_Messages_Template_Pack_Default) {
-            return $base_path_or_url;
-        }
-        foreach (self::$_ee_message_type_registry as $addon_name => $mt_reg) {
-            if ($addon_name === $message_type_slug) {
-                if ($url && ! empty($mt_reg['base_url_for_default_variation'])) {
-                    return $mt_reg['base_url_for_default_variation'];
-                }
-                if (! $url && ! empty($mt_reg['base_path_for_default_variation'])) {
-                    return $mt_reg['base_path_for_default_variation'];
-                }
-            }
-        }
-        return $base_path_or_url;
-    }
+	/**
+	 * Callback for FHEE__EE_Messages_Template_Pack__get_variation__base_path and
+	 * FHEE__EE_Messages_Template_Pack__get_variation__base_path_or_url hooks
+	 *
+	 * @param string                    $base_path_or_url  The original incoming base url or path
+	 * @param string                    $messenger_slug    The slug of the messenger the template is being generated
+	 *                                                     for.
+	 * @param string                    $message_type_slug The slug of the message type the template is being generated
+	 *                                                     for.
+	 * @param string                    $type              The "type" of css being requested.
+	 * @param string                    $variation         The variation being requested.
+	 * @param bool                      $url               whether a url or path is being requested.
+	 * @param string                    $file_extension    What file extension is expected for the variation file.
+	 * @param EE_Messages_Template_Pack $template_pack
+	 *
+	 * @return string
+	 */
+	public static function register_variation_base_path_or_url(
+		string $base_path_or_url,
+		string $messenger_slug,
+		string $message_type_slug,
+		string $type,
+		string $variation,
+		bool $url,
+		string $file_extension,
+		EE_Messages_Template_Pack $template_pack
+	): string {
+		if (! $template_pack instanceof EE_Messages_Template_Pack_Default) {
+			return $base_path_or_url;
+		}
+		foreach (self::$_ee_message_type_registry as $addon_name => $mt_reg) {
+			if ($addon_name === $message_type_slug) {
+				if ($url && ! empty($mt_reg['base_url_for_default_variation'])) {
+					return $mt_reg['base_url_for_default_variation'];
+				}
+				if (! $url && ! empty($mt_reg['base_path_for_default_variation'])) {
+					return $mt_reg['base_path_for_default_variation'];
+				}
+			}
+		}
+		return $base_path_or_url;
+	}
 
 
-    public static function reset(): void
-    {
-        self::$_ee_message_type_registry = [];
-    }
+	public static function reset(): void
+	{
+		self::$_ee_message_type_registry = [];
+	}
 }

core/services/encryption/EncryptionMethodInterface.php

Indentation +42 added lines, -42 removed lines

@@ -12,46 +12,46 @@
  */
 interface EncryptionMethodInterface
 {
-    /**
-     * returns true if the encryption method is cryptographically secure
-     *
-     * @return bool
-     */
-    public function isCryptographicallySecure();
-
-
-    /**
-     * returns true if the method can be used on the current server
-     *
-     * @return bool
-     */
-    public function canUse();
-
-
-    /**
-     * returns a message explaining why the encryption method in question can or can not be used
-     *
-     * @return string
-     */
-    public function canUseNotice();
-
-
-    /**
-     * encrypts data
-     *
-     * @param string $text_to_encrypt           - the text to be encrypted
-     * @param string $encryption_key_identifier - name of the encryption key to use
-     * @return string
-     */
-    public function encrypt($text_to_encrypt, $encryption_key_identifier = '');
-
-
-    /**
-     * decrypts data
-     *
-     * @param string $encrypted_text            - the text to be decrypted
-     * @param string $encryption_key_identifier - name of the encryption key to use
-     * @return string
-     */
-    public function decrypt($encrypted_text, $encryption_key_identifier = '');
+	/**
+	 * returns true if the encryption method is cryptographically secure
+	 *
+	 * @return bool
+	 */
+	public function isCryptographicallySecure();
+
+
+	/**
+	 * returns true if the method can be used on the current server
+	 *
+	 * @return bool
+	 */
+	public function canUse();
+
+
+	/**
+	 * returns a message explaining why the encryption method in question can or can not be used
+	 *
+	 * @return string
+	 */
+	public function canUseNotice();
+
+
+	/**
+	 * encrypts data
+	 *
+	 * @param string $text_to_encrypt           - the text to be encrypted
+	 * @param string $encryption_key_identifier - name of the encryption key to use
+	 * @return string
+	 */
+	public function encrypt($text_to_encrypt, $encryption_key_identifier = '');
+
+
+	/**
+	 * decrypts data
+	 *
+	 * @param string $encrypted_text            - the text to be decrypted
+	 * @param string $encryption_key_identifier - name of the encryption key to use
+	 * @return string
+	 */
+	public function decrypt($encrypted_text, $encryption_key_identifier = '');
 }

core/services/encryption/openssl/OpenSSL.php

Spacing +2 added lines, -2 removed lines

@@ -120,7 +120,7 @@ 
      */
     public function canUseNotice()
     {
-        if (! $this->openssl_installed) {
+        if ( ! $this->openssl_installed) {
             return esc_html__(
                 'The PHP openssl server extension is required to use Openssl encryption. Please contact your hosting provider regarding this issue.',
                 'event_espresso'
@@ -219,7 +219,7 @@ 
      */
     protected function getHashAlgorithm()
     {
-        if (! $this->hash_algorithm) {
+        if ( ! $this->hash_algorithm) {
             // get installed hashing algorithms
             $hash_algorithms = hash_algos();
             // filter array for "sha" algorithms

Indentation +262 added lines, -262 removed lines

@@ -17,266 +17,266 @@
  */
 abstract class OpenSSL implements EncryptionMethodInterface
 {
-    /**
-     * the default OPENSSL digest method to use
-     */
-    const DEFAULT_DIGEST_METHOD = 'sha512';
-
-    /**
-     * separates the encrypted text from the initialization vector
-     */
-    const IV_DELIMITER = ':iv:';
-
-    /**
-     * @var Base64Encoder
-     */
-    protected $base64_encoder;
-
-    /**
-     * @var CipherMethod
-     */
-    protected $cipher_method;
-
-    /**
-     * @var array $digest_methods
-     */
-    private $digest_methods = [];
-
-    /**
-     * @var EncryptionKeyManagerInterface
-     */
-    protected $encryption_key_manager;
-
-    /**
-     * @var boolean
-     */
-    private $openssl_installed;
-
-    /**
-     * @var string
-     */
-    private $min_php_version;
-
-    /**
-     * @var string
-     */
-    private $hash_algorithm;
-
-
-    /**
-     * To use custom a cipher method and/or encryption keys:
-     *  - extend this class
-     *  - configure a new CipherMethod / EncryptionKeyManager in the constructor
-     *  - pass those to this constructor, like so:
-     *
-     *      public function __construct(Base64Encoder $base64_encoder) {
-     *          parent::__construct(
-     *              $base64_encoder,
-     *              new CipherMethod(CIPHER_METHOD, CIPHER_METHOD_OPTION_NAME)
-     *              new EncryptionKeyManager(CUSTOM_KEY_ID, CUSTOM_KEYS_OPTION_NAME)
-     *          );
-     *      }
-     *
-     * @param Base64Encoder                      $base64_encoder
-     * @param CipherMethod                       $cipher_method
-     * @param EncryptionKeyManagerInterface|null $encryption_key_manager
-     * @param string                             $min_php_version
-     */
-    protected function __construct(
-        Base64Encoder $base64_encoder,
-        CipherMethod $cipher_method,
-        EncryptionKeyManagerInterface $encryption_key_manager,
-        $min_php_version
-    ) {
-        $this->base64_encoder         = $base64_encoder;
-        $this->cipher_method          = $cipher_method;
-        $this->encryption_key_manager = $encryption_key_manager;
-        $this->min_php_version        = $min_php_version;
-        $this->openssl_installed      = extension_loaded('openssl');
-    }
-
-
-    /**
-     * @return bool
-     */
-    public function isCryptographicallySecure()
-    {
-        return true;
-    }
-
-
-    /**
-     * @return bool
-     */
-    public function canUse()
-    {
-        return $this->openssl_installed && version_compare(PHP_VERSION, $this->min_php_version, '>=');
-    }
-
-
-    /**
-     * @return string
-     */
-    public function canUseNotice()
-    {
-        if (! $this->openssl_installed) {
-            return esc_html__(
-                'The PHP openssl server extension is required to use Openssl encryption. Please contact your hosting provider regarding this issue.',
-                'event_espresso'
-            );
-        }
-        if (version_compare(PHP_VERSION, $this->min_php_version, '<')) {
-            return sprintf(
-                esc_html__(
-                    'PHP version %1$s or greater is required to use Openssl encryption. Please contact your hosting provider regarding this issue.',
-                    'event_espresso'
-                ),
-                $this->min_php_version
-            );
-        }
-        return sprintf(
-            esc_html__('OpenSSL v1 encryption using %1$s is available for use.', 'event_espresso'),
-            OpenSSLv1::CIPHER_METHOD
-        );
-    }
-
-
-    /**
-     * Computes the digest hash value using the specified digest method.
-     * If that digest method fails to produce a valid hash value,
-     * then we'll grab the next digest method and recursively try again until something works.
-     *
-     * @param string $encryption_key
-     * @param string $digest_method
-     * @param bool   $return_raw_data
-     * @return string
-     * @throws RuntimeException
-     */
-    protected function getDigestHashValue(
-        $encryption_key,
-        $digest_method = OpenSSL::DEFAULT_DIGEST_METHOD,
-        $return_raw_data = false
-    ) {
-        $digest_hash_value = openssl_digest($encryption_key, $digest_method, $return_raw_data);
-        if ($digest_hash_value === false) {
-            return $this->getDigestHashValue($this->getDigestMethod());
-        }
-        return $digest_hash_value;
-    }
-
-
-    /**
-     * Returns the NEXT element in the $digest_methods array.
-     * If the $digest_methods array is empty, then we populate it
-     * with the available values returned from openssl_get_md_methods().
-     *
-     * @return string
-     * @throws RuntimeException
-     */
-    private function getDigestMethod()
-    {
-        $digest_method = prev($this->digest_methods);
-        if (empty($this->digest_methods)) {
-            $this->digest_methods = openssl_get_md_methods();
-            $digest_method        = end($this->digest_methods);
-        }
-        if ($digest_method === false) {
-            throw new RuntimeException(
-                esc_html__(
-                    'OpenSSL support appears to be enabled on the server, but no digest methods are available. Please contact the server administrator.',
-                    'event_espresso'
-                )
-            );
-        }
-        return $digest_method;
-    }
-
-
-    /**
-     * @param string $encryption_key
-     * @return int
-     */
-    protected function calculateHashLength($encryption_key)
-    {
-        // get existing key length
-        $prev_key_length = $this->encryption_key_manager->keyLength();
-        // set it to something HUGE
-        $this->encryption_key_manager->setKeyLength(512);
-        // generate a new weak key, which should just be a really long random string
-        $test_text = $this->encryption_key_manager->generateEncryptionKey(false);
-        // generate a hash using our test string and our real $encryption_key
-        $hash = hash_hmac($this->getHashAlgorithm(), $test_text, $encryption_key, true);
-        // reset key length back to original value
-        $this->encryption_key_manager->setKeyLength($prev_key_length);
-        // return the length of the hash
-        return strlen($hash);
-    }
-
-
-    /**
-     * @return string
-     */
-    protected function getHashAlgorithm()
-    {
-        if (! $this->hash_algorithm) {
-            // get installed hashing algorithms
-            $hash_algorithms = hash_algos();
-            // filter array for "sha" algorithms
-            $hash_algorithms = preg_grep('/^sha\d{3}$/i', $hash_algorithms);
-            // if no sha algorithms are installed, then just use md5
-            if (empty($hash_algorithms)) {
-                $this->hash_algorithm = 'md5';
-                return $this->hash_algorithm;
-            }
-            // sort ascending using "natural ordering"
-            sort($hash_algorithms, SORT_NATURAL);
-            // return last item from array, which should be the strongest installed sha hash
-            $this->hash_algorithm = array_pop($hash_algorithms);
-        }
-        return $this->hash_algorithm;
-    }
-
-
-    /**
-     * @param string $encrypted_text
-     * @throws RuntimeException
-     */
-    protected function validateEncryption($encrypted_text)
-    {
-        if ($encrypted_text === false) {
-            throw new RuntimeException(
-                sprintf(
-                    esc_html__('The following error occurred during OpenSSL encryption: %1$s', 'event_espresso'),
-                    $this->getOpenSslError()
-                )
-            );
-        }
-    }
-
-
-    /**
-     * @return false|string
-     */
-    private function getOpenSslError()
-    {
-        $error = openssl_error_string();
-        return $error ?: esc_html__('Unknown Error', 'event_espresso');
-    }
-
-
-    /**
-     * @param string $encrypted_text
-     * @throws RuntimeException
-     */
-    protected function validateDecryption($encrypted_text)
-    {
-        if ($encrypted_text === false) {
-            throw new RuntimeException(
-                sprintf(
-                    esc_html__('OpenSSL decryption failed for the following reason: %1$s', 'event_espresso'),
-                    $this->getOpenSslError()
-                )
-            );
-        }
-    }
+	/**
+	 * the default OPENSSL digest method to use
+	 */
+	const DEFAULT_DIGEST_METHOD = 'sha512';
+
+	/**
+	 * separates the encrypted text from the initialization vector
+	 */
+	const IV_DELIMITER = ':iv:';
+
+	/**
+	 * @var Base64Encoder
+	 */
+	protected $base64_encoder;
+
+	/**
+	 * @var CipherMethod
+	 */
+	protected $cipher_method;
+
+	/**
+	 * @var array $digest_methods
+	 */
+	private $digest_methods = [];
+
+	/**
+	 * @var EncryptionKeyManagerInterface
+	 */
+	protected $encryption_key_manager;
+
+	/**
+	 * @var boolean
+	 */
+	private $openssl_installed;
+
+	/**
+	 * @var string
+	 */
+	private $min_php_version;
+
+	/**
+	 * @var string
+	 */
+	private $hash_algorithm;
+
+
+	/**
+	 * To use custom a cipher method and/or encryption keys:
+	 *  - extend this class
+	 *  - configure a new CipherMethod / EncryptionKeyManager in the constructor
+	 *  - pass those to this constructor, like so:
+	 *
+	 *      public function __construct(Base64Encoder $base64_encoder) {
+	 *          parent::__construct(
+	 *              $base64_encoder,
+	 *              new CipherMethod(CIPHER_METHOD, CIPHER_METHOD_OPTION_NAME)
+	 *              new EncryptionKeyManager(CUSTOM_KEY_ID, CUSTOM_KEYS_OPTION_NAME)
+	 *          );
+	 *      }
+	 *
+	 * @param Base64Encoder                      $base64_encoder
+	 * @param CipherMethod                       $cipher_method
+	 * @param EncryptionKeyManagerInterface|null $encryption_key_manager
+	 * @param string                             $min_php_version
+	 */
+	protected function __construct(
+		Base64Encoder $base64_encoder,
+		CipherMethod $cipher_method,
+		EncryptionKeyManagerInterface $encryption_key_manager,
+		$min_php_version
+	) {
+		$this->base64_encoder         = $base64_encoder;
+		$this->cipher_method          = $cipher_method;
+		$this->encryption_key_manager = $encryption_key_manager;
+		$this->min_php_version        = $min_php_version;
+		$this->openssl_installed      = extension_loaded('openssl');
+	}
+
+
+	/**
+	 * @return bool
+	 */
+	public function isCryptographicallySecure()
+	{
+		return true;
+	}
+
+
+	/**
+	 * @return bool
+	 */
+	public function canUse()
+	{
+		return $this->openssl_installed && version_compare(PHP_VERSION, $this->min_php_version, '>=');
+	}
+
+
+	/**
+	 * @return string
+	 */
+	public function canUseNotice()
+	{
+		if (! $this->openssl_installed) {
+			return esc_html__(
+				'The PHP openssl server extension is required to use Openssl encryption. Please contact your hosting provider regarding this issue.',
+				'event_espresso'
+			);
+		}
+		if (version_compare(PHP_VERSION, $this->min_php_version, '<')) {
+			return sprintf(
+				esc_html__(
+					'PHP version %1$s or greater is required to use Openssl encryption. Please contact your hosting provider regarding this issue.',
+					'event_espresso'
+				),
+				$this->min_php_version
+			);
+		}
+		return sprintf(
+			esc_html__('OpenSSL v1 encryption using %1$s is available for use.', 'event_espresso'),
+			OpenSSLv1::CIPHER_METHOD
+		);
+	}
+
+
+	/**
+	 * Computes the digest hash value using the specified digest method.
+	 * If that digest method fails to produce a valid hash value,
+	 * then we'll grab the next digest method and recursively try again until something works.
+	 *
+	 * @param string $encryption_key
+	 * @param string $digest_method
+	 * @param bool   $return_raw_data
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	protected function getDigestHashValue(
+		$encryption_key,
+		$digest_method = OpenSSL::DEFAULT_DIGEST_METHOD,
+		$return_raw_data = false
+	) {
+		$digest_hash_value = openssl_digest($encryption_key, $digest_method, $return_raw_data);
+		if ($digest_hash_value === false) {
+			return $this->getDigestHashValue($this->getDigestMethod());
+		}
+		return $digest_hash_value;
+	}
+
+
+	/**
+	 * Returns the NEXT element in the $digest_methods array.
+	 * If the $digest_methods array is empty, then we populate it
+	 * with the available values returned from openssl_get_md_methods().
+	 *
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	private function getDigestMethod()
+	{
+		$digest_method = prev($this->digest_methods);
+		if (empty($this->digest_methods)) {
+			$this->digest_methods = openssl_get_md_methods();
+			$digest_method        = end($this->digest_methods);
+		}
+		if ($digest_method === false) {
+			throw new RuntimeException(
+				esc_html__(
+					'OpenSSL support appears to be enabled on the server, but no digest methods are available. Please contact the server administrator.',
+					'event_espresso'
+				)
+			);
+		}
+		return $digest_method;
+	}
+
+
+	/**
+	 * @param string $encryption_key
+	 * @return int
+	 */
+	protected function calculateHashLength($encryption_key)
+	{
+		// get existing key length
+		$prev_key_length = $this->encryption_key_manager->keyLength();
+		// set it to something HUGE
+		$this->encryption_key_manager->setKeyLength(512);
+		// generate a new weak key, which should just be a really long random string
+		$test_text = $this->encryption_key_manager->generateEncryptionKey(false);
+		// generate a hash using our test string and our real $encryption_key
+		$hash = hash_hmac($this->getHashAlgorithm(), $test_text, $encryption_key, true);
+		// reset key length back to original value
+		$this->encryption_key_manager->setKeyLength($prev_key_length);
+		// return the length of the hash
+		return strlen($hash);
+	}
+
+
+	/**
+	 * @return string
+	 */
+	protected function getHashAlgorithm()
+	{
+		if (! $this->hash_algorithm) {
+			// get installed hashing algorithms
+			$hash_algorithms = hash_algos();
+			// filter array for "sha" algorithms
+			$hash_algorithms = preg_grep('/^sha\d{3}$/i', $hash_algorithms);
+			// if no sha algorithms are installed, then just use md5
+			if (empty($hash_algorithms)) {
+				$this->hash_algorithm = 'md5';
+				return $this->hash_algorithm;
+			}
+			// sort ascending using "natural ordering"
+			sort($hash_algorithms, SORT_NATURAL);
+			// return last item from array, which should be the strongest installed sha hash
+			$this->hash_algorithm = array_pop($hash_algorithms);
+		}
+		return $this->hash_algorithm;
+	}
+
+
+	/**
+	 * @param string $encrypted_text
+	 * @throws RuntimeException
+	 */
+	protected function validateEncryption($encrypted_text)
+	{
+		if ($encrypted_text === false) {
+			throw new RuntimeException(
+				sprintf(
+					esc_html__('The following error occurred during OpenSSL encryption: %1$s', 'event_espresso'),
+					$this->getOpenSslError()
+				)
+			);
+		}
+	}
+
+
+	/**
+	 * @return false|string
+	 */
+	private function getOpenSslError()
+	{
+		$error = openssl_error_string();
+		return $error ?: esc_html__('Unknown Error', 'event_espresso');
+	}
+
+
+	/**
+	 * @param string $encrypted_text
+	 * @throws RuntimeException
+	 */
+	protected function validateDecryption($encrypted_text)
+	{
+		if ($encrypted_text === false) {
+			throw new RuntimeException(
+				sprintf(
+					esc_html__('OpenSSL decryption failed for the following reason: %1$s', 'event_espresso'),
+					$this->getOpenSslError()
+				)
+			);
+		}
+	}
 }

core/services/json/JsonDataNodeHandler.php

Spacing +5 added lines, -5 removed lines

@@ -78,7 +78,7 @@ 
                 if ($child_node instanceof PrimaryJsonDataNode || $depth > 512) {
                     continue;
                 }
-                $data[ $child_node_name ] = $child_node instanceof JsonDataNode
+                $data[$child_node_name] = $child_node instanceof JsonDataNode
                     // feed data node back into this function
                     ? $this->initializeDataNodes($child_node, $depth)
                     // or assign data directly
@@ -94,15 +94,15 @@ 
      */
     public function printDataNode()
     {
-        if (!$this->primary_data_node instanceof PrimaryJsonDataNode) {
+        if ( ! $this->primary_data_node instanceof PrimaryJsonDataNode) {
             return;
         }
         // validate that the domain, node name, and target script are set
         $domain = $this->primary_data_node->domain();
         $node_name = $this->primary_data_node->nodeName();
-        $data_valid =  $this->validator->validateCriticalProperty($domain, 'domain route', false)
+        $data_valid = $this->validator->validateCriticalProperty($domain, 'domain route', false)
                        && $this->validator->validateCriticalProperty($node_name, 'node name', false);
-        if (! $data_valid) {
+        if ( ! $data_valid) {
             return;
         }
         // initialize and parse data from primary data node
@@ -132,7 +132,7 @@ 
             $this->setPrimaryDataNode($data_node);
         }
         // and don't allow other nodes to be set until a primary is set
-        if (! $this->primary_data_node instanceof PrimaryJsonDataNode) {
+        if ( ! $this->primary_data_node instanceof PrimaryJsonDataNode) {
             throw new DomainException(
                 esc_html__(
                     'A PrimaryJsonDataNode needs to be set before data nodes can be added.',

Indentation +123 added lines, -123 removed lines

@@ -17,127 +17,127 @@
  */
 class JsonDataNodeHandler
 {
-    /**
-     * @var PrimaryJsonDataNode $primary_data_node
-     */
-    private $primary_data_node;
-
-    /**
-     * @var JsonDataNodeValidator $validator
-     */
-    private $validator;
-
-
-    /**
-     * @param JsonDataNodeValidator $validator
-     */
-    public function __construct(JsonDataNodeValidator $validator)
-    {
-        $this->validator = $validator;
-    }
-
-
-    /**
-     * @param JsonDataNode $data_node
-     * @throws DomainException
-     */
-    public function addDataNode(JsonDataNode $data_node)
-    {
-        if ($data_node->isNotInitialized()) {
-            $this->validatePrimaryDataNode($data_node);
-            $this->primary_data_node->addDataNode($data_node);
-        }
-    }
-
-
-    /**
-     * @param PrimaryJsonDataNode $primary_data_node
-     */
-    public function setPrimaryDataNode(PrimaryJsonDataNode $primary_data_node)
-    {
-        $this->primary_data_node = $primary_data_node;
-    }
-
-
-    /**
-     * @param JsonDataNode $data_node
-     * @param int                $depth
-     * @return array
-     */
-    private function initializeDataNodes(JsonDataNode $data_node, int $depth = 0): array
-    {
-        $depth++;
-        $data = [];
-        // initialize the data node if not done already
-        if ($data_node->isNotInitialized()) {
-            $data_node->initialize();
-            // loop thru the data node's data array
-            foreach ($data_node->data(true) as $child_node_name => $child_node) {
-                // don't parse node if it's the primary, OR if depth has exceeded wp_json_encode() limit
-                if ($child_node instanceof PrimaryJsonDataNode || $depth > 512) {
-                    continue;
-                }
-                $data[ $child_node_name ] = $child_node instanceof JsonDataNode
-                    // feed data node back into this function
-                    ? $this->initializeDataNodes($child_node, $depth)
-                    // or assign data directly
-                    : $child_node;
-            }
-        }
-        return $data;
-    }
-
-
-    /**
-     * @throws DomainException
-     */
-    public function printDataNode()
-    {
-        if (!$this->primary_data_node instanceof PrimaryJsonDataNode) {
-            return;
-        }
-        // validate that the domain, node name, and target script are set
-        $domain = $this->primary_data_node->domain();
-        $node_name = $this->primary_data_node->nodeName();
-        $data_valid =  $this->validator->validateCriticalProperty($domain, 'domain route', false)
-                       && $this->validator->validateCriticalProperty($node_name, 'node name', false);
-        if (! $data_valid) {
-            return;
-        }
-        // initialize and parse data from primary data node
-        $data = $this->initializeDataNodes($this->primary_data_node);
-        // this prepends the current domain "use case" to the front of the array
-        $data = ['domain' => $domain] + $data;
-        // add legacy i18n strings
-        $data['eei18n'] = EE_Registry::sanitize_i18n_js_strings();
-        // and finally, print the JSON encoded data to the DOM
-        printf(
-            "<script type='text/javascript' id='%s'>\nvar %s = %s\n</script>\n",
-            $node_name,
-            $node_name,
-            json_encode($data)
-        );
-    }
-
-
-    /**
-     * @param JsonDataNode $data_node
-     * @throws DomainException
-     */
-    private function validatePrimaryDataNode(JsonDataNode $data_node)
-    {
-        // set primary data node if that's what the incoming node is
-        if ($data_node instanceof PrimaryJsonDataNode) {
-            $this->setPrimaryDataNode($data_node);
-        }
-        // and don't allow other nodes to be set until a primary is set
-        if (! $this->primary_data_node instanceof PrimaryJsonDataNode) {
-            throw new DomainException(
-                esc_html__(
-                    'A PrimaryJsonDataNode needs to be set before data nodes can be added.',
-                    'event_espresso'
-                )
-            );
-        }
-    }
+	/**
+	 * @var PrimaryJsonDataNode $primary_data_node
+	 */
+	private $primary_data_node;
+
+	/**
+	 * @var JsonDataNodeValidator $validator
+	 */
+	private $validator;
+
+
+	/**
+	 * @param JsonDataNodeValidator $validator
+	 */
+	public function __construct(JsonDataNodeValidator $validator)
+	{
+		$this->validator = $validator;
+	}
+
+
+	/**
+	 * @param JsonDataNode $data_node
+	 * @throws DomainException
+	 */
+	public function addDataNode(JsonDataNode $data_node)
+	{
+		if ($data_node->isNotInitialized()) {
+			$this->validatePrimaryDataNode($data_node);
+			$this->primary_data_node->addDataNode($data_node);
+		}
+	}
+
+
+	/**
+	 * @param PrimaryJsonDataNode $primary_data_node
+	 */
+	public function setPrimaryDataNode(PrimaryJsonDataNode $primary_data_node)
+	{
+		$this->primary_data_node = $primary_data_node;
+	}
+
+
+	/**
+	 * @param JsonDataNode $data_node
+	 * @param int                $depth
+	 * @return array
+	 */
+	private function initializeDataNodes(JsonDataNode $data_node, int $depth = 0): array
+	{
+		$depth++;
+		$data = [];
+		// initialize the data node if not done already
+		if ($data_node->isNotInitialized()) {
+			$data_node->initialize();
+			// loop thru the data node's data array
+			foreach ($data_node->data(true) as $child_node_name => $child_node) {
+				// don't parse node if it's the primary, OR if depth has exceeded wp_json_encode() limit
+				if ($child_node instanceof PrimaryJsonDataNode || $depth > 512) {
+					continue;
+				}
+				$data[ $child_node_name ] = $child_node instanceof JsonDataNode
+					// feed data node back into this function
+					? $this->initializeDataNodes($child_node, $depth)
+					// or assign data directly
+					: $child_node;
+			}
+		}
+		return $data;
+	}
+
+
+	/**
+	 * @throws DomainException
+	 */
+	public function printDataNode()
+	{
+		if (!$this->primary_data_node instanceof PrimaryJsonDataNode) {
+			return;
+		}
+		// validate that the domain, node name, and target script are set
+		$domain = $this->primary_data_node->domain();
+		$node_name = $this->primary_data_node->nodeName();
+		$data_valid =  $this->validator->validateCriticalProperty($domain, 'domain route', false)
+					   && $this->validator->validateCriticalProperty($node_name, 'node name', false);
+		if (! $data_valid) {
+			return;
+		}
+		// initialize and parse data from primary data node
+		$data = $this->initializeDataNodes($this->primary_data_node);
+		// this prepends the current domain "use case" to the front of the array
+		$data = ['domain' => $domain] + $data;
+		// add legacy i18n strings
+		$data['eei18n'] = EE_Registry::sanitize_i18n_js_strings();
+		// and finally, print the JSON encoded data to the DOM
+		printf(
+			"<script type='text/javascript' id='%s'>\nvar %s = %s\n</script>\n",
+			$node_name,
+			$node_name,
+			json_encode($data)
+		);
+	}
+
+
+	/**
+	 * @param JsonDataNode $data_node
+	 * @throws DomainException
+	 */
+	private function validatePrimaryDataNode(JsonDataNode $data_node)
+	{
+		// set primary data node if that's what the incoming node is
+		if ($data_node instanceof PrimaryJsonDataNode) {
+			$this->setPrimaryDataNode($data_node);
+		}
+		// and don't allow other nodes to be set until a primary is set
+		if (! $this->primary_data_node instanceof PrimaryJsonDataNode) {
+			throw new DomainException(
+				esc_html__(
+					'A PrimaryJsonDataNode needs to be set before data nodes can be added.',
+					'event_espresso'
+				)
+			);
+		}
+	}
 }

core/services/encryption/openssl/OpenSSLv1.php

Spacing +1 added lines, -1 removed lines

@@ -122,7 +122,7 @@
         // hash the raw encrypted text
         $hmac = hash_hmac($this->getHashAlgorithm(), $encrypted_text, $key, true);
         // concatenate everything into one big string and encode it again
-        return $this->base64_encoder->encodeString($iv . $hmac . $encrypted_text);
+        return $this->base64_encoder->encodeString($iv.$hmac.$encrypted_text);
     }
 
 

Indentation +142 added lines, -142 removed lines

@@ -17,155 +17,155 @@
  */
 class OpenSSLv1 extends OpenSSL
 {
-    /**
-     * name used for a default encryption key in case no others are set
-     */
-    const DEFAULT_ENCRYPTION_KEY_ID = 'default_openssl_v1_key';
+	/**
+	 * name used for a default encryption key in case no others are set
+	 */
+	const DEFAULT_ENCRYPTION_KEY_ID = 'default_openssl_v1_key';
 
-    /**
-     * name used for saving encryption keys to the wp_options table
-     */
-    const ENCRYPTION_KEYS_OPTION_NAME = 'ee_openssl_v1_encryption_keys';
+	/**
+	 * name used for saving encryption keys to the wp_options table
+	 */
+	const ENCRYPTION_KEYS_OPTION_NAME = 'ee_openssl_v1_encryption_keys';
 
-    /**
-     * the OPENSSL cipher method used
-     */
-    const CIPHER_METHOD = 'aes-128-cbc';
+	/**
+	 * the OPENSSL cipher method used
+	 */
+	const CIPHER_METHOD = 'aes-128-cbc';
 
-    /**
-     * WP "options_name" used to store a verified available cipher method
-     */
-    const CIPHER_METHOD_OPTION_NAME = 'ee_openssl_v1_cipher_method';
+	/**
+	 * WP "options_name" used to store a verified available cipher method
+	 */
+	const CIPHER_METHOD_OPTION_NAME = 'ee_openssl_v1_cipher_method';
 
 
-    /**
-     * To use custom a cipher method and/or encryption keys and/or minimum PHP version:
-     *  - extend this class
-     *  - configure a new CipherMethod / EncryptionKeyManager in the constructor
-     *  - pass those to this constructor, like so:
-     *
-     *      public function __construct(Base64Encoder $base64_encoder) {
-     *          parent::__construct(
-     *              $base64_encoder,
-     *              new CipherMethod(CIPHER_METHOD, CIPHER_METHOD_OPTION_NAME),
-     *              new EncryptionKeyManager(CUSTOM_KEY_ID, CUSTOM_KEYS_OPTION_NAME),
-     *              '7.1.0'
-     *          );
-     *      }
-     *
-     * @param Base64Encoder                      $base64_encoder
-     * @param CipherMethod|null                  $cipher_method
-     * @param EncryptionKeyManagerInterface|null $encryption_key_manager
-     * @param string                             $min_php_version defaults to 5.3.0 (when openssl added)
-     */
-    public function __construct(
-        Base64Encoder $base64_encoder,
-        CipherMethod $cipher_method = null,
-        EncryptionKeyManagerInterface $encryption_key_manager = null,
-        $min_php_version = '5.3.0'
-    ) {
-        parent::__construct(
-            $base64_encoder,
-            $cipher_method instanceof CipherMethod
-                ? $cipher_method
-                : new CipherMethod(
-                    OpenSSLv1::CIPHER_METHOD,
-                    OpenSSLv1::CIPHER_METHOD_OPTION_NAME
-                ),
-            $encryption_key_manager instanceof EncryptionKeyManager
-                ? $encryption_key_manager
-                : new EncryptionKeyManager(
-                    $base64_encoder,
-                    OpenSSLv1::DEFAULT_ENCRYPTION_KEY_ID,
-                    OpenSSLv1::ENCRYPTION_KEYS_OPTION_NAME
-                ),
-            $min_php_version
-        );
-    }
+	/**
+	 * To use custom a cipher method and/or encryption keys and/or minimum PHP version:
+	 *  - extend this class
+	 *  - configure a new CipherMethod / EncryptionKeyManager in the constructor
+	 *  - pass those to this constructor, like so:
+	 *
+	 *      public function __construct(Base64Encoder $base64_encoder) {
+	 *          parent::__construct(
+	 *              $base64_encoder,
+	 *              new CipherMethod(CIPHER_METHOD, CIPHER_METHOD_OPTION_NAME),
+	 *              new EncryptionKeyManager(CUSTOM_KEY_ID, CUSTOM_KEYS_OPTION_NAME),
+	 *              '7.1.0'
+	 *          );
+	 *      }
+	 *
+	 * @param Base64Encoder                      $base64_encoder
+	 * @param CipherMethod|null                  $cipher_method
+	 * @param EncryptionKeyManagerInterface|null $encryption_key_manager
+	 * @param string                             $min_php_version defaults to 5.3.0 (when openssl added)
+	 */
+	public function __construct(
+		Base64Encoder $base64_encoder,
+		CipherMethod $cipher_method = null,
+		EncryptionKeyManagerInterface $encryption_key_manager = null,
+		$min_php_version = '5.3.0'
+	) {
+		parent::__construct(
+			$base64_encoder,
+			$cipher_method instanceof CipherMethod
+				? $cipher_method
+				: new CipherMethod(
+					OpenSSLv1::CIPHER_METHOD,
+					OpenSSLv1::CIPHER_METHOD_OPTION_NAME
+				),
+			$encryption_key_manager instanceof EncryptionKeyManager
+				? $encryption_key_manager
+				: new EncryptionKeyManager(
+					$base64_encoder,
+					OpenSSLv1::DEFAULT_ENCRYPTION_KEY_ID,
+					OpenSSLv1::ENCRYPTION_KEYS_OPTION_NAME
+				),
+			$min_php_version
+		);
+	}
 
 
-    /**
-     * encrypts data
-     *
-     * @param string $text_to_encrypt           - the text to be encrypted
-     * @param string $encryption_key_identifier - cryptographically secure passphrase. will generate if necessary
-     * @return string
-     */
-    public function encrypt($text_to_encrypt, $encryption_key_identifier = '')
-    {
-        $cipher_method  = $this->cipher_method->getCipherMethod();
-        $encryption_key = $this->encryption_key_manager->getEncryptionKey($encryption_key_identifier);
-        // get initialization vector size
-        $iv_length = openssl_cipher_iv_length($cipher_method);
-        // generate initialization vector.
-        // The second parameter ("crypto_strong") is passed by reference,
-        // and is used to determines if the algorithm used was "cryptographically strong"
-        // openssl_random_pseudo_bytes() will toggle it to either true or false
-        $iv = openssl_random_pseudo_bytes($iv_length, $is_strong);
-        if ($iv === false || $is_strong === false) {
-            throw new RuntimeException(
-                esc_html__('Failed to generate OpenSSL initialization vector.', 'event_espresso')
-            );
-        }
-        $key = $this->getDigestHashValue($encryption_key);
-        // encrypt it
-        $encrypted_text = openssl_encrypt(
-            $this->base64_encoder->encodeString($text_to_encrypt), // encode to remove special characters
-            $cipher_method,
-            $key,
-            0,
-            $iv
-        );
-        $this->validateEncryption($encrypted_text);
-        $encrypted_text = trim($encrypted_text);
-        // hash the raw encrypted text
-        $hmac = hash_hmac($this->getHashAlgorithm(), $encrypted_text, $key, true);
-        // concatenate everything into one big string and encode it again
-        return $this->base64_encoder->encodeString($iv . $hmac . $encrypted_text);
-    }
+	/**
+	 * encrypts data
+	 *
+	 * @param string $text_to_encrypt           - the text to be encrypted
+	 * @param string $encryption_key_identifier - cryptographically secure passphrase. will generate if necessary
+	 * @return string
+	 */
+	public function encrypt($text_to_encrypt, $encryption_key_identifier = '')
+	{
+		$cipher_method  = $this->cipher_method->getCipherMethod();
+		$encryption_key = $this->encryption_key_manager->getEncryptionKey($encryption_key_identifier);
+		// get initialization vector size
+		$iv_length = openssl_cipher_iv_length($cipher_method);
+		// generate initialization vector.
+		// The second parameter ("crypto_strong") is passed by reference,
+		// and is used to determines if the algorithm used was "cryptographically strong"
+		// openssl_random_pseudo_bytes() will toggle it to either true or false
+		$iv = openssl_random_pseudo_bytes($iv_length, $is_strong);
+		if ($iv === false || $is_strong === false) {
+			throw new RuntimeException(
+				esc_html__('Failed to generate OpenSSL initialization vector.', 'event_espresso')
+			);
+		}
+		$key = $this->getDigestHashValue($encryption_key);
+		// encrypt it
+		$encrypted_text = openssl_encrypt(
+			$this->base64_encoder->encodeString($text_to_encrypt), // encode to remove special characters
+			$cipher_method,
+			$key,
+			0,
+			$iv
+		);
+		$this->validateEncryption($encrypted_text);
+		$encrypted_text = trim($encrypted_text);
+		// hash the raw encrypted text
+		$hmac = hash_hmac($this->getHashAlgorithm(), $encrypted_text, $key, true);
+		// concatenate everything into one big string and encode it again
+		return $this->base64_encoder->encodeString($iv . $hmac . $encrypted_text);
+	}
 
 
-    /**
-     * decrypts data
-     *
-     * @param string $encrypted_text            - the text to be decrypted
-     * @param string $encryption_key_identifier - cryptographically secure passphrase. will use default if necessary
-     * @return string
-     */
-    public function decrypt($encrypted_text, $encryption_key_identifier = '')
-    {
-        $cipher_method  = $this->cipher_method->getCipherMethod();
-        $encryption_key = $this->encryption_key_manager->getEncryptionKey($encryption_key_identifier);
-        $key            = $this->getDigestHashValue($encryption_key);
-        // decode our concatenated string
-        $encrypted_text = $this->base64_encoder->decodeString($encrypted_text);
-        // get the string lengths used for the hash and iv
-        $hash_length = $this->calculateHashLength($encryption_key);
-        $iv_length   = openssl_cipher_iv_length($cipher_method);
-        // use the above lengths to snip the required values from the decoded string
-        $iv                 = substr($encrypted_text, 0, $iv_length);
-        $hmac               = substr($encrypted_text, $iv_length, $hash_length);
-        $encrypted_text_raw = substr($encrypted_text, $iv_length + $hash_length);
-        // rehash the original raw encrypted text
-        $rehash_mac = hash_hmac($this->getHashAlgorithm(), $encrypted_text_raw, $key, true);
-        // timing attack safe comparison to determine if anything has changed
-        if (hash_equals($hmac, $rehash_mac)) {
-            // looks good, decrypt it, trim it, and return it
-            $decrypted_text = openssl_decrypt(
-                $encrypted_text_raw,
-                $this->cipher_method->getCipherMethod(),
-                $key,
-                0,
-                $iv
-            );
-            $this->validateDecryption($decrypted_text);
-            return trim($this->base64_encoder->decodeString($decrypted_text));
-        }
-        throw new RuntimeException(
-            esc_html__(
-                'Decryption failed because a hash comparison of the original text and the decrypted text was not the same, meaning something in the system or the encrypted data has changed.',
-                'event_espresso'
-            )
-        );
-    }
+	/**
+	 * decrypts data
+	 *
+	 * @param string $encrypted_text            - the text to be decrypted
+	 * @param string $encryption_key_identifier - cryptographically secure passphrase. will use default if necessary
+	 * @return string
+	 */
+	public function decrypt($encrypted_text, $encryption_key_identifier = '')
+	{
+		$cipher_method  = $this->cipher_method->getCipherMethod();
+		$encryption_key = $this->encryption_key_manager->getEncryptionKey($encryption_key_identifier);
+		$key            = $this->getDigestHashValue($encryption_key);
+		// decode our concatenated string
+		$encrypted_text = $this->base64_encoder->decodeString($encrypted_text);
+		// get the string lengths used for the hash and iv
+		$hash_length = $this->calculateHashLength($encryption_key);
+		$iv_length   = openssl_cipher_iv_length($cipher_method);
+		// use the above lengths to snip the required values from the decoded string
+		$iv                 = substr($encrypted_text, 0, $iv_length);
+		$hmac               = substr($encrypted_text, $iv_length, $hash_length);
+		$encrypted_text_raw = substr($encrypted_text, $iv_length + $hash_length);
+		// rehash the original raw encrypted text
+		$rehash_mac = hash_hmac($this->getHashAlgorithm(), $encrypted_text_raw, $key, true);
+		// timing attack safe comparison to determine if anything has changed
+		if (hash_equals($hmac, $rehash_mac)) {
+			// looks good, decrypt it, trim it, and return it
+			$decrypted_text = openssl_decrypt(
+				$encrypted_text_raw,
+				$this->cipher_method->getCipherMethod(),
+				$key,
+				0,
+				$iv
+			);
+			$this->validateDecryption($decrypted_text);
+			return trim($this->base64_encoder->decodeString($decrypted_text));
+		}
+		throw new RuntimeException(
+			esc_html__(
+				'Decryption failed because a hash comparison of the original text and the decrypted text was not the same, meaning something in the system or the encrypted data has changed.',
+				'event_espresso'
+			)
+		);
+	}
 }

core/services/encryption/openssl/OpenSSLv2.php

Spacing +2 added lines, -2 removed lines

@@ -143,7 +143,7 @@ 
         );
         $this->validateEncryption($encrypted_text);
         // concatenate everything into one big string
-        return $iv . $tag . $encrypted_text;
+        return $iv.$tag.$encrypted_text;
     }
 
 
@@ -165,7 +165,7 @@ 
         );
         $this->validateEncryption($encrypted_text);
         // prepend the initialization vector
-        return $iv . $encrypted_text;
+        return $iv.$encrypted_text;
     }
 
 

Indentation +217 added lines, -217 removed lines

@@ -23,221 +23,221 @@
  */
 class OpenSSLv2 extends OpenSSL
 {
-    /**
-     * name used for a default encryption key in case no others are set
-     */
-    const DEFAULT_ENCRYPTION_KEY_ID = 'default_openssl_v2_key';
-
-    /**
-     * name used for saving encryption keys to the wp_options table
-     */
-    const ENCRYPTION_KEYS_OPTION_NAME = 'ee_openssl_v2_encryption_keys';
-
-    /**
-     * the OPENSSL cipher method used
-     */
-    const CIPHER_METHOD = 'aes-256-gcm';
-
-    /**
-     * WP "options_name" used to store a verified available cipher method
-     */
-    const CIPHER_METHOD_OPTION_NAME = 'ee_openssl_v2_cipher_method';
-
-    /**
-     * The length of the authentication tag. Its value can be between 4 and 16 for GCM mode.
-     */
-    const AUTH_TAG_LENGTH = 16;
-
-
-    /**
-     * To use custom a cipher method and/or encryption keys and/or minimum PHP version:
-     *  - extend this class
-     *  - configure a new CipherMethod / EncryptionKeyManager in the constructor
-     *  - pass those to this constructor, like so:
-     *
-     *      public function __construct(Base64Encoder $base64_encoder) {
-     *          parent::__construct(
-     *              $base64_encoder,
-     *              new CipherMethod(CIPHER_METHOD, CIPHER_METHOD_OPTION_NAME),
-     *              new EncryptionKeyManager(CUSTOM_KEY_ID, CUSTOM_KEYS_OPTION_NAME),
-     *              '7.1.0'
-     *          );
-     *      }
-     *
-     * @param Base64Encoder                      $base64_encoder
-     * @param CipherMethod|null                  $cipher_method
-     * @param EncryptionKeyManagerInterface|null $encryption_key_manager
-     * @param string                             $min_php_version defaults to 7.1.0
-     *                                                            (when openssl auth tag and random_bytes() were added)
-     */
-    public function __construct(
-        Base64Encoder $base64_encoder,
-        CipherMethod $cipher_method = null,
-        EncryptionKeyManagerInterface $encryption_key_manager = null,
-        $min_php_version = '7.1.0'
-    ) {
-        parent::__construct(
-            $base64_encoder,
-            $cipher_method instanceof CipherMethod
-                ? $cipher_method
-                : new CipherMethod(
-                    OpenSSLv2::CIPHER_METHOD,
-                    OpenSSLv2::CIPHER_METHOD_OPTION_NAME
-                ),
-            $encryption_key_manager instanceof EncryptionKeyManager
-                ? $encryption_key_manager
-                : new EncryptionKeyManager(
-                    $base64_encoder,
-                    OpenSSLv2::DEFAULT_ENCRYPTION_KEY_ID,
-                    OpenSSLv2::ENCRYPTION_KEYS_OPTION_NAME
-                ),
-            $min_php_version
-        );
-    }
-
-
-    /**
-     * encrypts data
-     *
-     * @param string $text_to_encrypt           - the text to be encrypted
-     * @param string $encryption_key_identifier - [optional] cryptographically secure passphrase. generated if not set
-     * @param string $aad                       - [optional] additional authentication data
-     * @return string
-     * @throws Exception
-     */
-    public function encrypt($text_to_encrypt, $encryption_key_identifier = '', $aad = '')
-    {
-        $cipher_method  = $this->cipher_method->getCipherMethod();
-        $encryption_key = $this->encryption_key_manager->getEncryptionKey($encryption_key_identifier);
-        // generate initialization vector for the cipher method.
-        $iv = random_bytes(openssl_cipher_iv_length($cipher_method));
-        // encrypt it (encode to remove special characters)
-        $text_to_encrypt = $this->base64_encoder->encodeString($text_to_encrypt);
-        $encrypted_text  = $this->cipher_method->usesAuthenticatedEncryptionMode()
-            ? $this->authenticatedEncrypt($text_to_encrypt, $cipher_method, $encryption_key, $iv, $aad)
-            : $this->nonAuthenticatedEncrypt($text_to_encrypt, $cipher_method, $encryption_key, $iv);
-        return $this->base64_encoder->encodeString($encrypted_text);
-    }
-
-
-    /**
-     * @param string $text_to_encrypt - the text to be encrypted
-     * @param string $cipher_method   - the OpenSSL cipher method used during encryption
-     * @param string $encryption_key  - cryptographically secure passphrase uses default if not set
-     * @param string $iv              - the initialization vector
-     * @param string $aad             - additional authentication data
-     * @return string
-     */
-    private function authenticatedEncrypt($text_to_encrypt, $cipher_method, $encryption_key, $iv, $aad)
-    {
-        $encrypted_text = openssl_encrypt(
-            $text_to_encrypt,
-            $cipher_method,
-            $this->getDigestHashValue($encryption_key, OpenSSL::DEFAULT_DIGEST_METHOD, OPENSSL_RAW_DATA),
-            0,
-            $iv,
-            $tag,
-            $aad,
-            OpenSSLv2::AUTH_TAG_LENGTH
-        );
-        $this->validateEncryption($encrypted_text);
-        // concatenate everything into one big string
-        return $iv . $tag . $encrypted_text;
-    }
-
-
-    /**
-     * @param string $text_to_encrypt - the text to be encrypted
-     * @param string $cipher_method   - the OpenSSL cipher method used during encryption
-     * @param string $encryption_key  - cryptographically secure passphrase uses default if not set
-     * @param string $iv              - the initialization vector
-     * @return string
-     */
-    private function nonAuthenticatedEncrypt($text_to_encrypt, $cipher_method, $encryption_key, $iv)
-    {
-        $encrypted_text = openssl_encrypt(
-            $text_to_encrypt,
-            $cipher_method,
-            $this->getDigestHashValue($encryption_key),
-            0,
-            $iv
-        );
-        $this->validateEncryption($encrypted_text);
-        // prepend the initialization vector
-        return $iv . $encrypted_text;
-    }
-
-
-    /**
-     * decrypts data
-     *
-     * @param string $encrypted_text            - the text to be decrypted
-     * @param string $encryption_key_identifier - [optional] cryptographically secure passphrase uses default if not set
-     * @param string $aad                       - [optional] additional authentication data
-     * @return string
-     */
-    public function decrypt($encrypted_text, $encryption_key_identifier = '', $aad = '')
-    {
-        $cipher_method  = $this->cipher_method->getCipherMethod();
-        $encryption_key = $this->encryption_key_manager->getEncryptionKey($encryption_key_identifier);
-        // maybe decode
-        $encrypted_text = $this->base64_encoder->decodeString($encrypted_text);
-        $iv_length      = openssl_cipher_iv_length($cipher_method);
-        // use the iv length to snip it from the decoded string
-        $iv = substr($encrypted_text, 0, $iv_length);
-        // then remove it from the rest of the decoded string
-        $encrypted_text = substr($encrypted_text, $iv_length);
-        // decrypt it
-        $decrypted_text = $this->cipher_method->usesAuthenticatedEncryptionMode()
-            ? $this->authenticatedDecrypt($encrypted_text, $cipher_method, $encryption_key, $iv, $aad)
-            : $this->nonAuthenticatedDecrypt($encrypted_text, $cipher_method, $encryption_key, $iv);
-
-        $this->validateDecryption($decrypted_text);
-        return trim($this->base64_encoder->decodeString($decrypted_text));
-    }
-
-
-    /**
-     * @param string $encrypted_text - the text to be decrypted
-     * @param string $cipher_method  - the OpenSSL cipher method used during encryption
-     * @param string $encryption_key - cryptographically secure passphrase uses default if not set
-     * @param string $iv             - the initialization vector
-     * @param string $aad            - additional authentication data
-     * @return string|false
-     */
-    private function authenticatedDecrypt($encrypted_text, $cipher_method, $encryption_key, $iv, $aad)
-    {
-        // use the tag length to snip it from the decoded string
-        $tag = substr($encrypted_text, 0, OpenSSLv2::AUTH_TAG_LENGTH);
-        // then remove it from the rest of the decoded string
-        $encrypted_text = substr($encrypted_text, OpenSSLv2::AUTH_TAG_LENGTH);
-        return openssl_decrypt(
-            $encrypted_text,
-            $cipher_method,
-            $this->getDigestHashValue($encryption_key, OpenSSL::DEFAULT_DIGEST_METHOD, OPENSSL_RAW_DATA),
-            0,
-            $iv,
-            $tag,
-            $aad
-        );
-    }
-
-
-    /**
-     * @param string $encrypted_text - the text to be decrypted
-     * @param string $cipher_method  - the OpenSSL cipher method used during encryption
-     * @param string $encryption_key - cryptographically secure passphrase uses default if not set
-     * @param string $iv             - the initialization vector
-     * @return string|false
-     */
-    private function nonAuthenticatedDecrypt($encrypted_text, $cipher_method, $encryption_key, $iv)
-    {
-        return openssl_decrypt(
-            $encrypted_text,
-            $cipher_method,
-            $this->getDigestHashValue($encryption_key),
-            0,
-            $iv
-        );
-    }
+	/**
+	 * name used for a default encryption key in case no others are set
+	 */
+	const DEFAULT_ENCRYPTION_KEY_ID = 'default_openssl_v2_key';
+
+	/**
+	 * name used for saving encryption keys to the wp_options table
+	 */
+	const ENCRYPTION_KEYS_OPTION_NAME = 'ee_openssl_v2_encryption_keys';
+
+	/**
+	 * the OPENSSL cipher method used
+	 */
+	const CIPHER_METHOD = 'aes-256-gcm';
+
+	/**
+	 * WP "options_name" used to store a verified available cipher method
+	 */
+	const CIPHER_METHOD_OPTION_NAME = 'ee_openssl_v2_cipher_method';
+
+	/**
+	 * The length of the authentication tag. Its value can be between 4 and 16 for GCM mode.
+	 */
+	const AUTH_TAG_LENGTH = 16;
+
+
+	/**
+	 * To use custom a cipher method and/or encryption keys and/or minimum PHP version:
+	 *  - extend this class
+	 *  - configure a new CipherMethod / EncryptionKeyManager in the constructor
+	 *  - pass those to this constructor, like so:
+	 *
+	 *      public function __construct(Base64Encoder $base64_encoder) {
+	 *          parent::__construct(
+	 *              $base64_encoder,
+	 *              new CipherMethod(CIPHER_METHOD, CIPHER_METHOD_OPTION_NAME),
+	 *              new EncryptionKeyManager(CUSTOM_KEY_ID, CUSTOM_KEYS_OPTION_NAME),
+	 *              '7.1.0'
+	 *          );
+	 *      }
+	 *
+	 * @param Base64Encoder                      $base64_encoder
+	 * @param CipherMethod|null                  $cipher_method
+	 * @param EncryptionKeyManagerInterface|null $encryption_key_manager
+	 * @param string                             $min_php_version defaults to 7.1.0
+	 *                                                            (when openssl auth tag and random_bytes() were added)
+	 */
+	public function __construct(
+		Base64Encoder $base64_encoder,
+		CipherMethod $cipher_method = null,
+		EncryptionKeyManagerInterface $encryption_key_manager = null,
+		$min_php_version = '7.1.0'
+	) {
+		parent::__construct(
+			$base64_encoder,
+			$cipher_method instanceof CipherMethod
+				? $cipher_method
+				: new CipherMethod(
+					OpenSSLv2::CIPHER_METHOD,
+					OpenSSLv2::CIPHER_METHOD_OPTION_NAME
+				),
+			$encryption_key_manager instanceof EncryptionKeyManager
+				? $encryption_key_manager
+				: new EncryptionKeyManager(
+					$base64_encoder,
+					OpenSSLv2::DEFAULT_ENCRYPTION_KEY_ID,
+					OpenSSLv2::ENCRYPTION_KEYS_OPTION_NAME
+				),
+			$min_php_version
+		);
+	}
+
+
+	/**
+	 * encrypts data
+	 *
+	 * @param string $text_to_encrypt           - the text to be encrypted
+	 * @param string $encryption_key_identifier - [optional] cryptographically secure passphrase. generated if not set
+	 * @param string $aad                       - [optional] additional authentication data
+	 * @return string
+	 * @throws Exception
+	 */
+	public function encrypt($text_to_encrypt, $encryption_key_identifier = '', $aad = '')
+	{
+		$cipher_method  = $this->cipher_method->getCipherMethod();
+		$encryption_key = $this->encryption_key_manager->getEncryptionKey($encryption_key_identifier);
+		// generate initialization vector for the cipher method.
+		$iv = random_bytes(openssl_cipher_iv_length($cipher_method));
+		// encrypt it (encode to remove special characters)
+		$text_to_encrypt = $this->base64_encoder->encodeString($text_to_encrypt);
+		$encrypted_text  = $this->cipher_method->usesAuthenticatedEncryptionMode()
+			? $this->authenticatedEncrypt($text_to_encrypt, $cipher_method, $encryption_key, $iv, $aad)
+			: $this->nonAuthenticatedEncrypt($text_to_encrypt, $cipher_method, $encryption_key, $iv);
+		return $this->base64_encoder->encodeString($encrypted_text);
+	}
+
+
+	/**
+	 * @param string $text_to_encrypt - the text to be encrypted
+	 * @param string $cipher_method   - the OpenSSL cipher method used during encryption
+	 * @param string $encryption_key  - cryptographically secure passphrase uses default if not set
+	 * @param string $iv              - the initialization vector
+	 * @param string $aad             - additional authentication data
+	 * @return string
+	 */
+	private function authenticatedEncrypt($text_to_encrypt, $cipher_method, $encryption_key, $iv, $aad)
+	{
+		$encrypted_text = openssl_encrypt(
+			$text_to_encrypt,
+			$cipher_method,
+			$this->getDigestHashValue($encryption_key, OpenSSL::DEFAULT_DIGEST_METHOD, OPENSSL_RAW_DATA),
+			0,
+			$iv,
+			$tag,
+			$aad,
+			OpenSSLv2::AUTH_TAG_LENGTH
+		);
+		$this->validateEncryption($encrypted_text);
+		// concatenate everything into one big string
+		return $iv . $tag . $encrypted_text;
+	}
+
+
+	/**
+	 * @param string $text_to_encrypt - the text to be encrypted
+	 * @param string $cipher_method   - the OpenSSL cipher method used during encryption
+	 * @param string $encryption_key  - cryptographically secure passphrase uses default if not set
+	 * @param string $iv              - the initialization vector
+	 * @return string
+	 */
+	private function nonAuthenticatedEncrypt($text_to_encrypt, $cipher_method, $encryption_key, $iv)
+	{
+		$encrypted_text = openssl_encrypt(
+			$text_to_encrypt,
+			$cipher_method,
+			$this->getDigestHashValue($encryption_key),
+			0,
+			$iv
+		);
+		$this->validateEncryption($encrypted_text);
+		// prepend the initialization vector
+		return $iv . $encrypted_text;
+	}
+
+
+	/**
+	 * decrypts data
+	 *
+	 * @param string $encrypted_text            - the text to be decrypted
+	 * @param string $encryption_key_identifier - [optional] cryptographically secure passphrase uses default if not set
+	 * @param string $aad                       - [optional] additional authentication data
+	 * @return string
+	 */
+	public function decrypt($encrypted_text, $encryption_key_identifier = '', $aad = '')
+	{
+		$cipher_method  = $this->cipher_method->getCipherMethod();
+		$encryption_key = $this->encryption_key_manager->getEncryptionKey($encryption_key_identifier);
+		// maybe decode
+		$encrypted_text = $this->base64_encoder->decodeString($encrypted_text);
+		$iv_length      = openssl_cipher_iv_length($cipher_method);
+		// use the iv length to snip it from the decoded string
+		$iv = substr($encrypted_text, 0, $iv_length);
+		// then remove it from the rest of the decoded string
+		$encrypted_text = substr($encrypted_text, $iv_length);
+		// decrypt it
+		$decrypted_text = $this->cipher_method->usesAuthenticatedEncryptionMode()
+			? $this->authenticatedDecrypt($encrypted_text, $cipher_method, $encryption_key, $iv, $aad)
+			: $this->nonAuthenticatedDecrypt($encrypted_text, $cipher_method, $encryption_key, $iv);
+
+		$this->validateDecryption($decrypted_text);
+		return trim($this->base64_encoder->decodeString($decrypted_text));
+	}
+
+
+	/**
+	 * @param string $encrypted_text - the text to be decrypted
+	 * @param string $cipher_method  - the OpenSSL cipher method used during encryption
+	 * @param string $encryption_key - cryptographically secure passphrase uses default if not set
+	 * @param string $iv             - the initialization vector
+	 * @param string $aad            - additional authentication data
+	 * @return string|false
+	 */
+	private function authenticatedDecrypt($encrypted_text, $cipher_method, $encryption_key, $iv, $aad)
+	{
+		// use the tag length to snip it from the decoded string
+		$tag = substr($encrypted_text, 0, OpenSSLv2::AUTH_TAG_LENGTH);
+		// then remove it from the rest of the decoded string
+		$encrypted_text = substr($encrypted_text, OpenSSLv2::AUTH_TAG_LENGTH);
+		return openssl_decrypt(
+			$encrypted_text,
+			$cipher_method,
+			$this->getDigestHashValue($encryption_key, OpenSSL::DEFAULT_DIGEST_METHOD, OPENSSL_RAW_DATA),
+			0,
+			$iv,
+			$tag,
+			$aad
+		);
+	}
+
+
+	/**
+	 * @param string $encrypted_text - the text to be decrypted
+	 * @param string $cipher_method  - the OpenSSL cipher method used during encryption
+	 * @param string $encryption_key - cryptographically secure passphrase uses default if not set
+	 * @param string $iv             - the initialization vector
+	 * @return string|false
+	 */
+	private function nonAuthenticatedDecrypt($encrypted_text, $cipher_method, $encryption_key, $iv)
+	{
+		return openssl_decrypt(
+			$encrypted_text,
+			$cipher_method,
+			$this->getDigestHashValue($encryption_key),
+			0,
+			$iv
+		);
+	}
 }

core/EE_Encryption.core.php

Spacing +13 added lines, -13 removed lines

@@ -103,7 +103,7 @@ 
      */
     protected function __construct()
     {
-        if (! defined('ESPRESSO_ENCRYPT')) {
+        if ( ! defined('ESPRESSO_ENCRYPT')) {
             define('ESPRESSO_ENCRYPT', true);
         }
         if (extension_loaded('openssl')) {
@@ -125,7 +125,7 @@ 
     public static function instance()
     {
         // check if class object is instantiated
-        if (! EE_Encryption::$_instance instanceof EE_Encryption) {
+        if ( ! EE_Encryption::$_instance instanceof EE_Encryption) {
             EE_Encryption::$_instance = new self();
         }
         return EE_Encryption::$_instance;
@@ -332,7 +332,7 @@ 
             $iv
         );
         // append the initialization vector
-        $encrypted_text .= EE_Encryption::OPENSSL_IV_DELIMITER . $iv;
+        $encrypted_text .= EE_Encryption::OPENSSL_IV_DELIMITER.$iv;
         // trim and maybe encode
         return $this->_use_base64_encode
             ? trim(base64_encode($encrypted_text))
@@ -515,7 +515,7 @@ 
         if (empty($text_string)) {
             return $text_string;
         }
-        $key_bits    = str_split(
+        $key_bits = str_split(
             str_pad(
                 '',
                 strlen($text_string),
@@ -525,8 +525,8 @@ 
         );
         $string_bits = str_split($text_string);
         foreach ($string_bits as $k => $v) {
-            $temp              = ord($v) + ord($key_bits[ $k ]);
-            $string_bits[ $k ] = chr($temp > 255 ? ($temp - 256) : $temp);
+            $temp              = ord($v) + ord($key_bits[$k]);
+            $string_bits[$k] = chr($temp > 255 ? ($temp - 256) : $temp);
         }
         $encrypted_text = implode('', $string_bits);
         $encrypted_text .= EE_Encryption::ACME_ENCRYPTION_FLAG;
@@ -568,10 +568,10 @@ 
                 STR_PAD_RIGHT
             )
         );
-        $string_bits    = str_split($encrypted_text);
+        $string_bits = str_split($encrypted_text);
         foreach ($string_bits as $k => $v) {
-            $temp              = ord($v) - ord($key_bits[ $k ]);
-            $string_bits[ $k ] = chr($temp < 0 ? ($temp + 256) : $temp);
+            $temp              = ord($v) - ord($key_bits[$k]);
+            $string_bits[$k] = chr($temp < 0 ? ($temp + 256) : $temp);
         }
         return implode('', $string_bits);
     }
@@ -585,16 +585,16 @@ 
     protected function valid_base_64($string)
     {
         // ensure data is a string
-        if (! is_string($string) || ! $this->_use_base64_encode) {
+        if ( ! is_string($string) || ! $this->_use_base64_encode) {
             return false;
         }
         $decoded = base64_decode($string, true);
         // Check if there is no invalid character in string
-        if (! preg_match('/^[a-zA-Z0-9\/\r\n+]*={0,2}$/', $string)) {
+        if ( ! preg_match('/^[a-zA-Z0-9\/\r\n+]*={0,2}$/', $string)) {
             return false;
         }
         // Decode the string in strict mode and send the response
-        if (! base64_decode($string, true)) {
+        if ( ! base64_decode($string, true)) {
             return false;
         }
         // Encode and compare it to original one
@@ -614,7 +614,7 @@ 
         $iterations    = ceil($length / 40);
         $random_string = '';
         for ($i = 0; $i < $iterations; $i++) {
-            $random_string .= sha1(microtime(true) . mt_rand(10000, 90000));
+            $random_string .= sha1(microtime(true).mt_rand(10000, 90000));
         }
         $random_string = substr($random_string, 0, $length);
         return $random_string;

Indentation +578 added lines, -578 removed lines

@@ -25,582 +25,582 @@
  */
 class EE_Encryption implements InterminableInterface
 {
-    /**
-     * key used for saving the encryption key to the wp_options table
-     */
-    const ENCRYPTION_OPTION_KEY = 'ee_encryption_key';
-
-    /**
-     * the OPENSSL cipher method used
-     */
-    const OPENSSL_CIPHER_METHOD = 'AES-128-CBC';
-
-    /**
-     * WP "options_name" used to store a verified available cipher method
-     */
-    const OPENSSL_CIPHER_METHOD_OPTION_NAME = 'ee_openssl_cipher_method';
-
-    /**
-     * the OPENSSL digest method used
-     */
-    const OPENSSL_DIGEST_METHOD = 'sha512';
-
-    /**
-     * separates the encrypted text from the initialization vector
-     */
-    const OPENSSL_IV_DELIMITER = ':iv:';
-
-    /**
-     * appended to text encrypted using the acme encryption
-     */
-    const ACME_ENCRYPTION_FLAG = '::ae';
-
-
-    /**
-     * instance of the EE_Encryption object
-     */
-    protected static $_instance;
-
-    /**
-     * @var string $_encryption_key
-     */
-    protected $_encryption_key;
-
-    /**
-     * @var string $cipher_method
-     */
-    private $cipher_method = '';
-
-    /**
-     * @var array $cipher_methods
-     */
-    private $cipher_methods = [];
-
-    /**
-     * @var array $digest_methods
-     */
-    private $digest_methods = [];
-
-    /**
-     * @var boolean $_use_openssl_encrypt
-     */
-    protected $_use_openssl_encrypt = false;
-
-    /**
-     * @var boolean $_use_base64_encode
-     */
-    protected $_use_base64_encode = false;
-
-
-    /**
-     * protected constructor to prevent direct creation
-     */
-    protected function __construct()
-    {
-        if (! defined('ESPRESSO_ENCRYPT')) {
-            define('ESPRESSO_ENCRYPT', true);
-        }
-        if (extension_loaded('openssl')) {
-            $this->_use_openssl_encrypt = true;
-        }
-        if (function_exists('base64_encode')) {
-            $this->_use_base64_encode = true;
-        }
-        EE_Error::doing_it_wrong(__METHOD__, esc_html__('Usage is deprecated.', 'event_espresso'), '5.0.8.p');
-    }
-
-
-    /**
-     * singleton method used to instantiate class object
-     *
-     * @return EE_Encryption
-     */
-    public static function instance()
-    {
-        // check if class object is instantiated
-        if (! EE_Encryption::$_instance instanceof EE_Encryption) {
-            EE_Encryption::$_instance = new self();
-        }
-        return EE_Encryption::$_instance;
-    }
-
-
-    /**
-     * get encryption key
-     *
-     * @return string
-     */
-    public function get_encryption_key()
-    {
-        // if encryption key has not been set
-        if (empty($this->_encryption_key)) {
-            // retrieve encryption_key from db
-            $this->_encryption_key = get_option(EE_Encryption::ENCRYPTION_OPTION_KEY, '');
-            // WHAT?? No encryption_key in the db ??
-            if ($this->_encryption_key === '') {
-                // let's make one. And md5 it to make it just the right size for a key
-                $new_key = md5($this->generate_random_string());
-                // now save it to the db for later
-                add_option(EE_Encryption::ENCRYPTION_OPTION_KEY, $new_key);
-                // here's the key - FINALLY !
-                $this->_encryption_key = $new_key;
-            }
-        }
-        return $this->_encryption_key;
-    }
-
-
-    /**
-     * encrypts data
-     *
-     * @param string $text_string - the text to be encrypted
-     * @return string
-     * @throws RuntimeException
-     */
-    public function encrypt($text_string = '')
-    {
-        // you give me nothing??? GET OUT !
-        if (empty($text_string)) {
-            return $text_string;
-        }
-        if ($this->_use_openssl_encrypt) {
-            $encrypted_text = $this->openssl_encrypt($text_string);
-        } else {
-            $encrypted_text = $this->acme_encrypt($text_string);
-        }
-        return $encrypted_text;
-    }
-
-
-    /**
-     * decrypts data
-     *
-     * @param string $encrypted_text - the text to be decrypted
-     * @return string
-     * @throws RuntimeException
-     */
-    public function decrypt($encrypted_text = '')
-    {
-        // you give me nothing??? GET OUT !
-        if (empty($encrypted_text)) {
-            return $encrypted_text;
-        }
-        // if PHP's mcrypt functions are installed then we'll use them
-        if ($this->_use_openssl_encrypt) {
-            $decrypted_text = $this->openssl_decrypt($encrypted_text);
-        } else {
-            $decrypted_text = $this->acme_decrypt($encrypted_text);
-        }
-        return $decrypted_text;
-    }
-
-
-    /**
-     * encodes string with PHP's base64 encoding
-     *
-     * @see http://php.net/manual/en/function.base64-encode.php
-     * @param string $text_string the text to be encoded
-     * @return string
-     */
-    public function base64_string_encode($text_string = '')
-    {
-        // you give me nothing??? GET OUT !
-        if (empty($text_string) || ! $this->_use_base64_encode) {
-            return $text_string;
-        }
-        // encode
-        return base64_encode($text_string);
-    }
-
-
-    /**
-     * decodes string that has been encoded with PHP's base64 encoding
-     *
-     * @see http://php.net/manual/en/function.base64-encode.php
-     * @param string $encoded_string the text to be decoded
-     * @return string
-     * @throws RuntimeException
-     */
-    public function base64_string_decode($encoded_string = '')
-    {
-        // you give me nothing??? GET OUT !
-        if (empty($encoded_string) || ! $this->valid_base_64($encoded_string)) {
-            return $encoded_string;
-        }
-        // decode
-        $decoded_string = base64_decode($encoded_string);
-        if ($decoded_string === false) {
-            throw new RuntimeException(
-                esc_html__('Base 64 decoding failed.', 'event_espresso')
-            );
-        }
-        return $decoded_string;
-    }
-
-
-    /**
-     * encodes  url string with PHP's base64 encoding
-     *
-     * @see http://php.net/manual/en/function.base64-encode.php
-     * @param string $text_string the text to be encoded
-     * @return string
-     */
-    public function base64_url_encode($text_string = '')
-    {
-        // you give me nothing??? GET OUT !
-        if (empty($text_string) || ! $this->_use_base64_encode) {
-            return $text_string;
-        }
-        // encode
-        $encoded_string = base64_encode($text_string);
-        // remove chars to make encoding more URL friendly
-        return strtr($encoded_string, '+/=', '-_,');
-    }
-
-
-    /**
-     * decodes  url string that has been encoded with PHP's base64 encoding
-     *
-     * @see http://php.net/manual/en/function.base64-encode.php
-     * @param string $encoded_string the text to be decoded
-     * @return string
-     * @throws RuntimeException
-     */
-    public function base64_url_decode($encoded_string = '')
-    {
-        // replace previously removed characters
-        $encoded_string = strtr($encoded_string, '-_,', '+/=');
-        // you give me nothing??? GET OUT !
-        if (empty($encoded_string) || ! $this->valid_base_64($encoded_string)) {
-            return $encoded_string;
-        }
-        // decode
-        $decoded_string = base64_decode($encoded_string);
-        if ($decoded_string === false) {
-            throw new RuntimeException(
-                esc_html__('Base 64 decoding failed.', 'event_espresso')
-            );
-        }
-        return $decoded_string;
-    }
-
-
-    /**
-     * encrypts data using PHP's openssl functions
-     *
-     * @param string $text_string the text to be encrypted
-     * @param string $cipher_method
-     * @param string $encryption_key
-     * @return string
-     * @throws RuntimeException
-     */
-    protected function openssl_encrypt(
-        $text_string = '',
-        $cipher_method = EE_Encryption::OPENSSL_CIPHER_METHOD,
-        $encryption_key = ''
-    ) {
-        // you give me nothing??? GET OUT !
-        if (empty($text_string)) {
-            return $text_string;
-        }
-        $this->cipher_method = $this->getCipherMethod($cipher_method);
-        // get initialization vector size
-        $iv_size = openssl_cipher_iv_length($this->cipher_method);
-        // generate initialization vector.
-        // The second parameter ("crypto_strong") is passed by reference,
-        // and is used to determines if the algorithm used was "cryptographically strong"
-        // openssl_random_pseudo_bytes() will toggle it to either true or false
-        $iv = openssl_random_pseudo_bytes($iv_size, $is_strong);
-        if ($iv === false || $is_strong === false) {
-            throw new RuntimeException(
-                esc_html__('Failed to generate OpenSSL initialization vector.', 'event_espresso')
-            );
-        }
-        // encrypt it
-        $encrypted_text = openssl_encrypt(
-            $text_string,
-            $this->cipher_method,
-            $this->getDigestHashValue(EE_Encryption::OPENSSL_DIGEST_METHOD, $encryption_key),
-            0,
-            $iv
-        );
-        // append the initialization vector
-        $encrypted_text .= EE_Encryption::OPENSSL_IV_DELIMITER . $iv;
-        // trim and maybe encode
-        return $this->_use_base64_encode
-            ? trim(base64_encode($encrypted_text))
-            : trim($encrypted_text);
-    }
-
-
-    /**
-     * Returns a cipher method that has been verified to work.
-     * First checks if the cached cipher has been set already and if so, returns that.
-     * Then tests the incoming default and returns that if it's good.
-     * If not, then it retrieves the previously tested and saved cipher method.
-     * But if that doesn't exist, then calls getAvailableCipherMethod()
-     * to see what is available on the server, and returns the results.
-     *
-     * @param string $cipher_method
-     * @return string
-     * @throws RuntimeException
-     */
-    protected function getCipherMethod($cipher_method = EE_Encryption::OPENSSL_CIPHER_METHOD)
-    {
-        if ($this->cipher_method !== '') {
-            return $this->cipher_method;
-        }
-        // verify that the default cipher method can produce an initialization vector
-        if (openssl_cipher_iv_length($cipher_method) === false) {
-            // nope? okay let's get what we found in the past to work
-            $cipher_method = get_option(EE_Encryption::OPENSSL_CIPHER_METHOD_OPTION_NAME, '');
-            // oops... haven't tested available cipher methods yet
-            if ($cipher_method === '' || openssl_cipher_iv_length($cipher_method) === false) {
-                $cipher_method = $this->getAvailableCipherMethod($cipher_method);
-            }
-        }
-        return $cipher_method;
-    }
-
-
-    /**
-     * @param string $cipher_method
-     * @return string
-     * @throws \RuntimeException
-     */
-    protected function getAvailableCipherMethod($cipher_method)
-    {
-        // verify that the incoming cipher method can produce an initialization vector
-        if (openssl_cipher_iv_length($cipher_method) === false) {
-            // nope? then check the next cipher in the list of available cipher methods
-            $cipher_method = next($this->cipher_methods);
-            // what? there's no list? then generate that list and cache it,
-            if (empty($this->cipher_methods)) {
-                $this->cipher_methods = openssl_get_cipher_methods();
-                // then grab the first item from the list
-                $cipher_method = reset($this->cipher_methods);
-            }
-            if ($cipher_method === false) {
-                throw new RuntimeException(
-                    esc_html__(
-                        'OpenSSL support appears to be enabled on the server, but no cipher methods are available. Please contact the server administrator.',
-                        'event_espresso'
-                    )
-                );
-            }
-            // verify that the next cipher method works
-            return $this->getAvailableCipherMethod($cipher_method);
-        }
-        // if we've gotten this far, then we found an available cipher method that works
-        // so save that for next time
-        update_option(
-            EE_Encryption::OPENSSL_CIPHER_METHOD_OPTION_NAME,
-            $cipher_method
-        );
-        return $cipher_method;
-    }
-
-
-    /**
-     * decrypts data that has been encrypted with PHP's openssl functions
-     *
-     * @param string $encrypted_text the text to be decrypted
-     * @param string $cipher_method
-     * @param string $encryption_key
-     * @return string
-     * @throws RuntimeException
-     */
-    protected function openssl_decrypt(
-        $encrypted_text = '',
-        $cipher_method = EE_Encryption::OPENSSL_CIPHER_METHOD,
-        $encryption_key = ''
-    ) {
-        // you give me nothing??? GET OUT !
-        if (empty($encrypted_text)) {
-            return $encrypted_text;
-        }
-        // decode
-        $encrypted_text       = $this->valid_base_64($encrypted_text)
-            ? $this->base64_url_decode($encrypted_text)
-            : $encrypted_text;
-        $encrypted_components = explode(
-            EE_Encryption::OPENSSL_IV_DELIMITER,
-            $encrypted_text,
-            2
-        );
-        // decrypt it
-        $decrypted_text = openssl_decrypt(
-            $encrypted_components[0],
-            $this->getCipherMethod($cipher_method),
-            $this->getDigestHashValue(EE_Encryption::OPENSSL_DIGEST_METHOD, $encryption_key),
-            0,
-            $encrypted_components[1]
-        );
-        $decrypted_text = trim($decrypted_text);
-        return $decrypted_text;
-    }
-
-
-    /**
-     * Computes the digest hash value using the specified digest method.
-     * If that digest method fails to produce a valid hash value,
-     * then we'll grab the next digest method and recursively try again until something works.
-     *
-     * @param string $digest_method
-     * @param string $encryption_key
-     * @return string
-     * @throws RuntimeException
-     */
-    protected function getDigestHashValue($digest_method = EE_Encryption::OPENSSL_DIGEST_METHOD, $encryption_key = '')
-    {
-        $encryption_key    = $encryption_key !== ''
-            ? $encryption_key
-            : $this->get_encryption_key();
-        $digest_hash_value = openssl_digest($encryption_key, $digest_method);
-        if ($digest_hash_value === false) {
-            return $this->getDigestHashValue($this->getDigestMethod());
-        }
-        return $digest_hash_value;
-    }
-
-
-    /**
-     * Returns the NEXT element in the $digest_methods array.
-     * If the $digest_methods array is empty, then we populate it
-     * with the available values returned from openssl_get_md_methods().
-     *
-     * @return string
-     * @throws \RuntimeException
-     */
-    protected function getDigestMethod()
-    {
-        $digest_method = prev($this->digest_methods);
-        if (empty($this->digest_methods)) {
-            $this->digest_methods = openssl_get_md_methods();
-            $digest_method        = end($this->digest_methods);
-        }
-        if ($digest_method === false) {
-            throw new RuntimeException(
-                esc_html__(
-                    'OpenSSL support appears to be enabled on the server, but no digest methods are available. Please contact the server administrator.',
-                    'event_espresso'
-                )
-            );
-        }
-        return $digest_method;
-    }
-
-
-    /**
-     * encrypts data for acme servers that didn't bother to install PHP mcrypt
-     *
-     * @see http://stackoverflow.com/questions/800922/how-to-encrypt-string-without-mcrypt-library-in-php
-     * @param string $text_string the text to be decrypted
-     * @return string
-     */
-    protected function acme_encrypt($text_string = '')
-    {
-        // you give me nothing??? GET OUT !
-        if (empty($text_string)) {
-            return $text_string;
-        }
-        $key_bits    = str_split(
-            str_pad(
-                '',
-                strlen($text_string),
-                $this->get_encryption_key(),
-                STR_PAD_RIGHT
-            )
-        );
-        $string_bits = str_split($text_string);
-        foreach ($string_bits as $k => $v) {
-            $temp              = ord($v) + ord($key_bits[ $k ]);
-            $string_bits[ $k ] = chr($temp > 255 ? ($temp - 256) : $temp);
-        }
-        $encrypted_text = implode('', $string_bits);
-        $encrypted_text .= EE_Encryption::ACME_ENCRYPTION_FLAG;
-        return $this->_use_base64_encode
-            ? base64_encode($encrypted_text)
-            : $encrypted_text;
-    }
-
-
-    /**
-     * decrypts data for acme servers that didn't bother to install PHP mcrypt
-     *
-     * @see http://stackoverflow.com/questions/800922/how-to-encrypt-string-without-mcrypt-library-in-php
-     * @param string $encrypted_text the text to be decrypted
-     * @return string
-     * @throws RuntimeException
-     */
-    protected function acme_decrypt($encrypted_text = '')
-    {
-        // you give me nothing??? GET OUT !
-        if (empty($encrypted_text)) {
-            return $encrypted_text;
-        }
-        // decode the data ?
-        $encrypted_text = $this->valid_base_64($encrypted_text)
-            ? $this->base64_url_decode($encrypted_text)
-            : $encrypted_text;
-        $encrypted_text = substr($encrypted_text, 0, -4);
-        $key_bits       = str_split(
-            str_pad(
-                '',
-                strlen($encrypted_text),
-                $this->get_encryption_key(),
-                STR_PAD_RIGHT
-            )
-        );
-        $string_bits    = str_split($encrypted_text);
-        foreach ($string_bits as $k => $v) {
-            $temp              = ord($v) - ord($key_bits[ $k ]);
-            $string_bits[ $k ] = chr($temp < 0 ? ($temp + 256) : $temp);
-        }
-        return implode('', $string_bits);
-    }
-
-
-    /**
-     * @see http://stackoverflow.com/questions/2556345/detect-base64-encoding-in-php#30231906
-     * @param $string
-     * @return bool
-     */
-    protected function valid_base_64($string)
-    {
-        // ensure data is a string
-        if (! is_string($string) || ! $this->_use_base64_encode) {
-            return false;
-        }
-        $decoded = base64_decode($string, true);
-        // Check if there is no invalid character in string
-        if (! preg_match('/^[a-zA-Z0-9\/\r\n+]*={0,2}$/', $string)) {
-            return false;
-        }
-        // Decode the string in strict mode and send the response
-        if (! base64_decode($string, true)) {
-            return false;
-        }
-        // Encode and compare it to original one
-        return base64_encode($decoded) === $string;
-    }
-
-
-    /**
-     * generate random string
-     *
-     * @see http://stackoverflow.com/questions/637278/what-is-the-best-way-to-generate-a-random-key-within-php
-     * @param int $length number of characters for random string
-     * @return string
-     */
-    public function generate_random_string($length = 40)
-    {
-        $iterations    = ceil($length / 40);
-        $random_string = '';
-        for ($i = 0; $i < $iterations; $i++) {
-            $random_string .= sha1(microtime(true) . mt_rand(10000, 90000));
-        }
-        $random_string = substr($random_string, 0, $length);
-        return $random_string;
-    }
+	/**
+	 * key used for saving the encryption key to the wp_options table
+	 */
+	const ENCRYPTION_OPTION_KEY = 'ee_encryption_key';
+
+	/**
+	 * the OPENSSL cipher method used
+	 */
+	const OPENSSL_CIPHER_METHOD = 'AES-128-CBC';
+
+	/**
+	 * WP "options_name" used to store a verified available cipher method
+	 */
+	const OPENSSL_CIPHER_METHOD_OPTION_NAME = 'ee_openssl_cipher_method';
+
+	/**
+	 * the OPENSSL digest method used
+	 */
+	const OPENSSL_DIGEST_METHOD = 'sha512';
+
+	/**
+	 * separates the encrypted text from the initialization vector
+	 */
+	const OPENSSL_IV_DELIMITER = ':iv:';
+
+	/**
+	 * appended to text encrypted using the acme encryption
+	 */
+	const ACME_ENCRYPTION_FLAG = '::ae';
+
+
+	/**
+	 * instance of the EE_Encryption object
+	 */
+	protected static $_instance;
+
+	/**
+	 * @var string $_encryption_key
+	 */
+	protected $_encryption_key;
+
+	/**
+	 * @var string $cipher_method
+	 */
+	private $cipher_method = '';
+
+	/**
+	 * @var array $cipher_methods
+	 */
+	private $cipher_methods = [];
+
+	/**
+	 * @var array $digest_methods
+	 */
+	private $digest_methods = [];
+
+	/**
+	 * @var boolean $_use_openssl_encrypt
+	 */
+	protected $_use_openssl_encrypt = false;
+
+	/**
+	 * @var boolean $_use_base64_encode
+	 */
+	protected $_use_base64_encode = false;
+
+
+	/**
+	 * protected constructor to prevent direct creation
+	 */
+	protected function __construct()
+	{
+		if (! defined('ESPRESSO_ENCRYPT')) {
+			define('ESPRESSO_ENCRYPT', true);
+		}
+		if (extension_loaded('openssl')) {
+			$this->_use_openssl_encrypt = true;
+		}
+		if (function_exists('base64_encode')) {
+			$this->_use_base64_encode = true;
+		}
+		EE_Error::doing_it_wrong(__METHOD__, esc_html__('Usage is deprecated.', 'event_espresso'), '5.0.8.p');
+	}
+
+
+	/**
+	 * singleton method used to instantiate class object
+	 *
+	 * @return EE_Encryption
+	 */
+	public static function instance()
+	{
+		// check if class object is instantiated
+		if (! EE_Encryption::$_instance instanceof EE_Encryption) {
+			EE_Encryption::$_instance = new self();
+		}
+		return EE_Encryption::$_instance;
+	}
+
+
+	/**
+	 * get encryption key
+	 *
+	 * @return string
+	 */
+	public function get_encryption_key()
+	{
+		// if encryption key has not been set
+		if (empty($this->_encryption_key)) {
+			// retrieve encryption_key from db
+			$this->_encryption_key = get_option(EE_Encryption::ENCRYPTION_OPTION_KEY, '');
+			// WHAT?? No encryption_key in the db ??
+			if ($this->_encryption_key === '') {
+				// let's make one. And md5 it to make it just the right size for a key
+				$new_key = md5($this->generate_random_string());
+				// now save it to the db for later
+				add_option(EE_Encryption::ENCRYPTION_OPTION_KEY, $new_key);
+				// here's the key - FINALLY !
+				$this->_encryption_key = $new_key;
+			}
+		}
+		return $this->_encryption_key;
+	}
+
+
+	/**
+	 * encrypts data
+	 *
+	 * @param string $text_string - the text to be encrypted
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	public function encrypt($text_string = '')
+	{
+		// you give me nothing??? GET OUT !
+		if (empty($text_string)) {
+			return $text_string;
+		}
+		if ($this->_use_openssl_encrypt) {
+			$encrypted_text = $this->openssl_encrypt($text_string);
+		} else {
+			$encrypted_text = $this->acme_encrypt($text_string);
+		}
+		return $encrypted_text;
+	}
+
+
+	/**
+	 * decrypts data
+	 *
+	 * @param string $encrypted_text - the text to be decrypted
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	public function decrypt($encrypted_text = '')
+	{
+		// you give me nothing??? GET OUT !
+		if (empty($encrypted_text)) {
+			return $encrypted_text;
+		}
+		// if PHP's mcrypt functions are installed then we'll use them
+		if ($this->_use_openssl_encrypt) {
+			$decrypted_text = $this->openssl_decrypt($encrypted_text);
+		} else {
+			$decrypted_text = $this->acme_decrypt($encrypted_text);
+		}
+		return $decrypted_text;
+	}
+
+
+	/**
+	 * encodes string with PHP's base64 encoding
+	 *
+	 * @see http://php.net/manual/en/function.base64-encode.php
+	 * @param string $text_string the text to be encoded
+	 * @return string
+	 */
+	public function base64_string_encode($text_string = '')
+	{
+		// you give me nothing??? GET OUT !
+		if (empty($text_string) || ! $this->_use_base64_encode) {
+			return $text_string;
+		}
+		// encode
+		return base64_encode($text_string);
+	}
+
+
+	/**
+	 * decodes string that has been encoded with PHP's base64 encoding
+	 *
+	 * @see http://php.net/manual/en/function.base64-encode.php
+	 * @param string $encoded_string the text to be decoded
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	public function base64_string_decode($encoded_string = '')
+	{
+		// you give me nothing??? GET OUT !
+		if (empty($encoded_string) || ! $this->valid_base_64($encoded_string)) {
+			return $encoded_string;
+		}
+		// decode
+		$decoded_string = base64_decode($encoded_string);
+		if ($decoded_string === false) {
+			throw new RuntimeException(
+				esc_html__('Base 64 decoding failed.', 'event_espresso')
+			);
+		}
+		return $decoded_string;
+	}
+
+
+	/**
+	 * encodes  url string with PHP's base64 encoding
+	 *
+	 * @see http://php.net/manual/en/function.base64-encode.php
+	 * @param string $text_string the text to be encoded
+	 * @return string
+	 */
+	public function base64_url_encode($text_string = '')
+	{
+		// you give me nothing??? GET OUT !
+		if (empty($text_string) || ! $this->_use_base64_encode) {
+			return $text_string;
+		}
+		// encode
+		$encoded_string = base64_encode($text_string);
+		// remove chars to make encoding more URL friendly
+		return strtr($encoded_string, '+/=', '-_,');
+	}
+
+
+	/**
+	 * decodes  url string that has been encoded with PHP's base64 encoding
+	 *
+	 * @see http://php.net/manual/en/function.base64-encode.php
+	 * @param string $encoded_string the text to be decoded
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	public function base64_url_decode($encoded_string = '')
+	{
+		// replace previously removed characters
+		$encoded_string = strtr($encoded_string, '-_,', '+/=');
+		// you give me nothing??? GET OUT !
+		if (empty($encoded_string) || ! $this->valid_base_64($encoded_string)) {
+			return $encoded_string;
+		}
+		// decode
+		$decoded_string = base64_decode($encoded_string);
+		if ($decoded_string === false) {
+			throw new RuntimeException(
+				esc_html__('Base 64 decoding failed.', 'event_espresso')
+			);
+		}
+		return $decoded_string;
+	}
+
+
+	/**
+	 * encrypts data using PHP's openssl functions
+	 *
+	 * @param string $text_string the text to be encrypted
+	 * @param string $cipher_method
+	 * @param string $encryption_key
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	protected function openssl_encrypt(
+		$text_string = '',
+		$cipher_method = EE_Encryption::OPENSSL_CIPHER_METHOD,
+		$encryption_key = ''
+	) {
+		// you give me nothing??? GET OUT !
+		if (empty($text_string)) {
+			return $text_string;
+		}
+		$this->cipher_method = $this->getCipherMethod($cipher_method);
+		// get initialization vector size
+		$iv_size = openssl_cipher_iv_length($this->cipher_method);
+		// generate initialization vector.
+		// The second parameter ("crypto_strong") is passed by reference,
+		// and is used to determines if the algorithm used was "cryptographically strong"
+		// openssl_random_pseudo_bytes() will toggle it to either true or false
+		$iv = openssl_random_pseudo_bytes($iv_size, $is_strong);
+		if ($iv === false || $is_strong === false) {
+			throw new RuntimeException(
+				esc_html__('Failed to generate OpenSSL initialization vector.', 'event_espresso')
+			);
+		}
+		// encrypt it
+		$encrypted_text = openssl_encrypt(
+			$text_string,
+			$this->cipher_method,
+			$this->getDigestHashValue(EE_Encryption::OPENSSL_DIGEST_METHOD, $encryption_key),
+			0,
+			$iv
+		);
+		// append the initialization vector
+		$encrypted_text .= EE_Encryption::OPENSSL_IV_DELIMITER . $iv;
+		// trim and maybe encode
+		return $this->_use_base64_encode
+			? trim(base64_encode($encrypted_text))
+			: trim($encrypted_text);
+	}
+
+
+	/**
+	 * Returns a cipher method that has been verified to work.
+	 * First checks if the cached cipher has been set already and if so, returns that.
+	 * Then tests the incoming default and returns that if it's good.
+	 * If not, then it retrieves the previously tested and saved cipher method.
+	 * But if that doesn't exist, then calls getAvailableCipherMethod()
+	 * to see what is available on the server, and returns the results.
+	 *
+	 * @param string $cipher_method
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	protected function getCipherMethod($cipher_method = EE_Encryption::OPENSSL_CIPHER_METHOD)
+	{
+		if ($this->cipher_method !== '') {
+			return $this->cipher_method;
+		}
+		// verify that the default cipher method can produce an initialization vector
+		if (openssl_cipher_iv_length($cipher_method) === false) {
+			// nope? okay let's get what we found in the past to work
+			$cipher_method = get_option(EE_Encryption::OPENSSL_CIPHER_METHOD_OPTION_NAME, '');
+			// oops... haven't tested available cipher methods yet
+			if ($cipher_method === '' || openssl_cipher_iv_length($cipher_method) === false) {
+				$cipher_method = $this->getAvailableCipherMethod($cipher_method);
+			}
+		}
+		return $cipher_method;
+	}
+
+
+	/**
+	 * @param string $cipher_method
+	 * @return string
+	 * @throws \RuntimeException
+	 */
+	protected function getAvailableCipherMethod($cipher_method)
+	{
+		// verify that the incoming cipher method can produce an initialization vector
+		if (openssl_cipher_iv_length($cipher_method) === false) {
+			// nope? then check the next cipher in the list of available cipher methods
+			$cipher_method = next($this->cipher_methods);
+			// what? there's no list? then generate that list and cache it,
+			if (empty($this->cipher_methods)) {
+				$this->cipher_methods = openssl_get_cipher_methods();
+				// then grab the first item from the list
+				$cipher_method = reset($this->cipher_methods);
+			}
+			if ($cipher_method === false) {
+				throw new RuntimeException(
+					esc_html__(
+						'OpenSSL support appears to be enabled on the server, but no cipher methods are available. Please contact the server administrator.',
+						'event_espresso'
+					)
+				);
+			}
+			// verify that the next cipher method works
+			return $this->getAvailableCipherMethod($cipher_method);
+		}
+		// if we've gotten this far, then we found an available cipher method that works
+		// so save that for next time
+		update_option(
+			EE_Encryption::OPENSSL_CIPHER_METHOD_OPTION_NAME,
+			$cipher_method
+		);
+		return $cipher_method;
+	}
+
+
+	/**
+	 * decrypts data that has been encrypted with PHP's openssl functions
+	 *
+	 * @param string $encrypted_text the text to be decrypted
+	 * @param string $cipher_method
+	 * @param string $encryption_key
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	protected function openssl_decrypt(
+		$encrypted_text = '',
+		$cipher_method = EE_Encryption::OPENSSL_CIPHER_METHOD,
+		$encryption_key = ''
+	) {
+		// you give me nothing??? GET OUT !
+		if (empty($encrypted_text)) {
+			return $encrypted_text;
+		}
+		// decode
+		$encrypted_text       = $this->valid_base_64($encrypted_text)
+			? $this->base64_url_decode($encrypted_text)
+			: $encrypted_text;
+		$encrypted_components = explode(
+			EE_Encryption::OPENSSL_IV_DELIMITER,
+			$encrypted_text,
+			2
+		);
+		// decrypt it
+		$decrypted_text = openssl_decrypt(
+			$encrypted_components[0],
+			$this->getCipherMethod($cipher_method),
+			$this->getDigestHashValue(EE_Encryption::OPENSSL_DIGEST_METHOD, $encryption_key),
+			0,
+			$encrypted_components[1]
+		);
+		$decrypted_text = trim($decrypted_text);
+		return $decrypted_text;
+	}
+
+
+	/**
+	 * Computes the digest hash value using the specified digest method.
+	 * If that digest method fails to produce a valid hash value,
+	 * then we'll grab the next digest method and recursively try again until something works.
+	 *
+	 * @param string $digest_method
+	 * @param string $encryption_key
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	protected function getDigestHashValue($digest_method = EE_Encryption::OPENSSL_DIGEST_METHOD, $encryption_key = '')
+	{
+		$encryption_key    = $encryption_key !== ''
+			? $encryption_key
+			: $this->get_encryption_key();
+		$digest_hash_value = openssl_digest($encryption_key, $digest_method);
+		if ($digest_hash_value === false) {
+			return $this->getDigestHashValue($this->getDigestMethod());
+		}
+		return $digest_hash_value;
+	}
+
+
+	/**
+	 * Returns the NEXT element in the $digest_methods array.
+	 * If the $digest_methods array is empty, then we populate it
+	 * with the available values returned from openssl_get_md_methods().
+	 *
+	 * @return string
+	 * @throws \RuntimeException
+	 */
+	protected function getDigestMethod()
+	{
+		$digest_method = prev($this->digest_methods);
+		if (empty($this->digest_methods)) {
+			$this->digest_methods = openssl_get_md_methods();
+			$digest_method        = end($this->digest_methods);
+		}
+		if ($digest_method === false) {
+			throw new RuntimeException(
+				esc_html__(
+					'OpenSSL support appears to be enabled on the server, but no digest methods are available. Please contact the server administrator.',
+					'event_espresso'
+				)
+			);
+		}
+		return $digest_method;
+	}
+
+
+	/**
+	 * encrypts data for acme servers that didn't bother to install PHP mcrypt
+	 *
+	 * @see http://stackoverflow.com/questions/800922/how-to-encrypt-string-without-mcrypt-library-in-php
+	 * @param string $text_string the text to be decrypted
+	 * @return string
+	 */
+	protected function acme_encrypt($text_string = '')
+	{
+		// you give me nothing??? GET OUT !
+		if (empty($text_string)) {
+			return $text_string;
+		}
+		$key_bits    = str_split(
+			str_pad(
+				'',
+				strlen($text_string),
+				$this->get_encryption_key(),
+				STR_PAD_RIGHT
+			)
+		);
+		$string_bits = str_split($text_string);
+		foreach ($string_bits as $k => $v) {
+			$temp              = ord($v) + ord($key_bits[ $k ]);
+			$string_bits[ $k ] = chr($temp > 255 ? ($temp - 256) : $temp);
+		}
+		$encrypted_text = implode('', $string_bits);
+		$encrypted_text .= EE_Encryption::ACME_ENCRYPTION_FLAG;
+		return $this->_use_base64_encode
+			? base64_encode($encrypted_text)
+			: $encrypted_text;
+	}
+
+
+	/**
+	 * decrypts data for acme servers that didn't bother to install PHP mcrypt
+	 *
+	 * @see http://stackoverflow.com/questions/800922/how-to-encrypt-string-without-mcrypt-library-in-php
+	 * @param string $encrypted_text the text to be decrypted
+	 * @return string
+	 * @throws RuntimeException
+	 */
+	protected function acme_decrypt($encrypted_text = '')
+	{
+		// you give me nothing??? GET OUT !
+		if (empty($encrypted_text)) {
+			return $encrypted_text;
+		}
+		// decode the data ?
+		$encrypted_text = $this->valid_base_64($encrypted_text)
+			? $this->base64_url_decode($encrypted_text)
+			: $encrypted_text;
+		$encrypted_text = substr($encrypted_text, 0, -4);
+		$key_bits       = str_split(
+			str_pad(
+				'',
+				strlen($encrypted_text),
+				$this->get_encryption_key(),
+				STR_PAD_RIGHT
+			)
+		);
+		$string_bits    = str_split($encrypted_text);
+		foreach ($string_bits as $k => $v) {
+			$temp              = ord($v) - ord($key_bits[ $k ]);
+			$string_bits[ $k ] = chr($temp < 0 ? ($temp + 256) : $temp);
+		}
+		return implode('', $string_bits);
+	}
+
+
+	/**
+	 * @see http://stackoverflow.com/questions/2556345/detect-base64-encoding-in-php#30231906
+	 * @param $string
+	 * @return bool
+	 */
+	protected function valid_base_64($string)
+	{
+		// ensure data is a string
+		if (! is_string($string) || ! $this->_use_base64_encode) {
+			return false;
+		}
+		$decoded = base64_decode($string, true);
+		// Check if there is no invalid character in string
+		if (! preg_match('/^[a-zA-Z0-9\/\r\n+]*={0,2}$/', $string)) {
+			return false;
+		}
+		// Decode the string in strict mode and send the response
+		if (! base64_decode($string, true)) {
+			return false;
+		}
+		// Encode and compare it to original one
+		return base64_encode($decoded) === $string;
+	}
+
+
+	/**
+	 * generate random string
+	 *
+	 * @see http://stackoverflow.com/questions/637278/what-is-the-best-way-to-generate-a-random-key-within-php
+	 * @param int $length number of characters for random string
+	 * @return string
+	 */
+	public function generate_random_string($length = 40)
+	{
+		$iterations    = ceil($length / 40);
+		$random_string = '';
+		for ($i = 0; $i < $iterations; $i++) {
+			$random_string .= sha1(microtime(true) . mt_rand(10000, 90000));
+		}
+		$random_string = substr($random_string, 0, $length);
+		return $random_string;
+	}
 }