EEM_Payment_Method::scopes() - Code Metrics - Inspection of "Daily Inspection: use esc_html__(), fix formatting..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — BUG/add-foreign-key-alias (17fa63)

unknown

created 2020-08-17 21:37 UTC

EEM_Payment_Method::scopes() A

↳ Parent: EEM_Payment_Method

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	0
dl	0
loc	13
rs	9.8333
c	0
b	0
f	0

<?php

use EventEspresso\core\domain\entities\notifications\PersistentAdminNotice;
use EventEspresso\core\exceptions\InvalidDataTypeException;

/**
 * Payment Method Model
 * For storing all payment methods (things that interact between EE and gateways).
 * As of 4.3, payment methods are NOT singletons so there can be multiple instances of payment methods
 * of the same type, with different details. Eg, multiple paypal standard gateways so different
 * events can have their proceeds going to different paypal accounts
 *
 * @package    Event Espresso
 * @subpackage includes/models/EEM_Checkin.model.php
 * @author     Mike Nelson
 */
class EEM_Payment_Method extends EEM_Base
{

    const scope_cart = 'CART';

    const scope_admin = 'ADMIN';

    const scope_api = 'API';

    /**
     * @type EEM_Payment_Method
     */
    protected static $_instance = null;


    /**
     * private constructor to prevent direct creation
     *
     * @param null $timezone
     * @throws EE_Error
     */
    protected function __construct($timezone = null)
    {
        $this->singular_item = esc_html__('Payment Method', 'event_espresso');
        $this->plural_item = esc_html__('Payment Methods', 'event_espresso');
        $this->_tables = [
            'Payment_Method' => new EE_Primary_Table('esp_payment_method', 'PMD_ID'),
        ];
        $this->_fields = [
            'Payment_Method' => [
                'PMD_ID'              => new EE_Primary_Key_Int_Field(
                    'PMD_ID',
                    esc_html__('ID', 'event_espresso')
                ),
                'PMD_type'            => new EE_Plain_Text_Field(
                    'PMD_type',
                    esc_html__('Payment Method Type', 'event_espresso'),
                    false,
                    'Admin_Only'
                ),
                'PMD_name'            => new EE_Plain_Text_Field(
                    'PMD_name',
                    esc_html__('Name', 'event_espresso'),
                    false
                ),
                'PMD_desc'            => new EE_Post_Content_Field(
                    'PMD_desc',
                    esc_html__('Description', 'event_espresso'),
                    false,
                    ''
                ),
                'PMD_admin_name'      => new EE_Plain_Text_Field(
                    'PMD_admin_name',
                    esc_html__('Admin-Only Name', 'event_espresso'),
                    true
                ),
                'PMD_admin_desc'      => new EE_Post_Content_Field(
                    'PMD_admin_desc',
                    esc_html__('Admin-Only Description', 'event_espresso'),
                    true
                ),
                'PMD_slug'            => new EE_Slug_Field(
                    'PMD_slug',
                    esc_html__('Slug', 'event_espresso'),
                    false
                ),
                'PMD_order'           => new EE_Integer_Field(
                    'PMD_order',
                    esc_html__('Order', 'event_espresso'),
                    false,
                    0
                ),
                'PMD_debug_mode'      => new EE_Boolean_Field(
                    'PMD_debug_mode',
                    esc_html__('Debug Mode On?', 'event_espresso'),
                    false,
                    false
                ),
                'PMD_wp_user'         => new EE_WP_User_Field(
                    'PMD_wp_user',
                    esc_html__('Payment Method Creator ID', 'event_espresso'),
                    false
                ),
                'PMD_open_by_default' => new EE_Boolean_Field(
                    'PMD_open_by_default',
                    esc_html__('Open by Default?', 'event_espresso'),
                    false,
                    false
                ),
                'PMD_button_url'      => new EE_Plain_Text_Field(
                    'PMD_button_url',
                    esc_html__('Button URL', 'event_espresso'),
                    true,
                    ''
                ),
                'PMD_scope'           => new EE_Serialized_Text_Field(
                    'PMD_scope',
                    esc_html__('Usable From?', 'event_espresso'),
                    false,
                    []// possible values currently are 'CART','ADMIN','API'
                ),
            ],
        ];
        $this->_model_relations = [
            'Payment'     => new EE_Has_Many_Relation(),
            'Currency'    => new EE_HABTM_Relation('Currency_Payment_Method'),
            'Transaction' => new EE_Has_Many_Relation(),
            'WP_User'     => new EE_Belongs_To_Relation(),
        ];
        parent::__construct($timezone);
    }


    /**
     * Gets one by the slug provided
     *
     * @param string $slug
     * @return EE_Base_Class|EE_Payment_Method|EE_Soft_Delete_Base_Class|NULL
     * @throws EE_Error
     */
    public function get_one_by_slug($slug)
    {
        return $this->get_one([['PMD_slug' => $slug]]);
    }


    /**
     * Gets all the acceptable scopes for payment methods.
     * Keys are their names as store din the DB, and values are nice names for displaying them
     *
     * @return array
     */
    public function scopes()
    {
        return apply_filters(
            'FHEE__EEM_Payment_Method__scopes',
            [
                EEM_Payment_Method::scope_cart  => esc_html__('Front-end Registration Page', 'event_espresso'),
                EEM_Payment_Method::scope_admin => esc_html__(
                    'Admin Registration Page (no online processing)',
                    'event_espresso'
                ),
            ]
        );
    }


    /**
     * Determines if this is an valid scope
     *
     * @param string $scope like one of EEM_Payment_Method::instance()->scopes()
     * @return boolean
     */
    public function is_valid_scope($scope)
    {
        $scopes = $this->scopes();
        if (isset($scopes[ $scope ])) {
            return true;
        }
        return false;
    }


    /**
     * Gets all active payment methods
     *
     * @param string $scope one of
     * @param array  $query_params
     * @return EE_Base_Class[]|EE_Payment_Method[]
     * @throws EE_Error
     */
    public function get_all_active($scope = null, $query_params = [])
    {
        if (! isset($query_params['order_by']) && ! isset($query_params['order'])) {
            $query_params['order_by'] = ['PMD_order' => 'ASC', 'PMD_ID' => 'ASC'];
        }
        return $this->get_all($this->_get_query_params_for_all_active($scope, $query_params));
    }


    /**
     * Counts all active gateways in the specified scope
     *
     * @param string $scope one of EEM_Payment_Method::scope_*
     * @param array  $query_params
     * @return int
     * @throws EE_Error
     */
    public function count_active($scope = null, $query_params = [])
    {
        return $this->count($this->_get_query_params_for_all_active($scope, $query_params));
    }


    /**
     * Creates the $query_params that can be passed into any EEM_Payment_Method as their $query_params
     * argument to get all active for a given scope
     *
     * @param string $scope one of the constants EEM_Payment_Method::scope_*
     * @param array  $query_params
     * @return array
     * @throws EE_Error
     * @see https://github.com/eventespresso/event-espresso-core/tree/master/docs/G--Model-System/model-query-params.md
     */
    protected function _get_query_params_for_all_active($scope = null, $query_params = [])
    {
        if ($scope) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            if ($this->is_valid_scope($scope)) {
                return array_replace_recursive([['PMD_scope' => ['LIKE', "%$scope%"]]], $query_params);
            }
            throw new EE_Error(
                sprintf(
                    esc_html__("'%s' is not a valid scope for a payment method", 'event_espresso'),
                    $scope
                )
            );
        }
        $acceptable_scopes = [];
        $count = 0;
        foreach ($this->scopes() as $scope_name => $desc) {
            $count++;
            $acceptable_scopes[ 'PMD_scope*' . $count ] = ['LIKE', '%' . $scope_name . '%'];
        }
        return array_replace_recursive([['OR*active_scope' => $acceptable_scopes]], $query_params);
    }


    /**
     * Creates the $query_params that can be passed into any EEM_Payment_Method as their $query_params
     * argument to get all active for a given scope
     *
     * @param string $scope one of the constants EEM_Payment_Method::scope_*
     * @param array  $query_params
     * @return array
     * @throws EE_Error
     * @see https://github.com/eventespresso/event-espresso-core/tree/master/docs/G--Model-System/model-query-params.md
     */
    public function get_query_params_for_all_active($scope = null, $query_params = [])
    {
        return $this->_get_query_params_for_all_active($scope, $query_params);
    }


    /**
     * Gets one active payment method. see @get_all_active for documentation
     *
     * @param string $scope
     * @param array  $query_params
     * @return EE_Base_Class|EE_Payment_Method|EE_Soft_Delete_Base_Class|NULL
     * @throws EE_Error
     */
    public function get_one_active($scope = null, $query_params = [])
    {
        return $this->get_one($this->_get_query_params_for_all_active($scope, $query_params));
    }


    /**
     * Gets one payment method of that type, regardless of whether its active or not
     *
     * @param string $type
     * @return EE_Base_Class|EE_Payment_Method|EE_Soft_Delete_Base_Class|NULL
     * @throws EE_Error
     */
    public function get_one_of_type($type)
    {
        return $this->get_one([['PMD_type' => $type]]);
    }


    /**
     * Overrides parent ot also check by the slug
     *
     * @param string|int|EE_Payment_Method $base_class_obj_or_id
     * @param boolean                      $ensure_is_in_db
     * @return EE_Base_Class|EE_Payment_Method|EE_Soft_Delete_Base_Class|int|string
     * @throws EE_Error
     * @see EEM_Base::ensure_is_obj()
     */
    public function ensure_is_obj($base_class_obj_or_id, $ensure_is_in_db = false)
    {
        // first: check if it's a slug
        if (is_string($base_class_obj_or_id)) {
            $obj = $this->get_one_by_slug($base_class_obj_or_id);
            if ($obj) {
                return $obj;
            }
        }
        // ok so it wasn't a slug we were passed. try the usual then (ie, it's an object or an ID)
        try {
            return parent::ensure_is_obj($base_class_obj_or_id, $ensure_is_in_db);
        } catch (EE_Error $e) {
            // handle it outside the catch
        }
        throw new EE_Error(
            sprintf(
                esc_html__("'%s' is neither a Payment Method ID, slug, nor object.", 'event_espresso'),
                $base_class_obj_or_id
            )
        );
    }


    /**
     * Gets the ID of this object, or if its a string finds the object's id
     * associated with that slug
     *
     * @param mixed $base_obj_or_id_or_slug
     * @return int
     * @throws EE_Error
     */
    public function ensure_is_ID($base_obj_or_id_or_slug)
    {
        if (is_string($base_obj_or_id_or_slug)) {
            // assume it's a slug
            $base_obj_or_id_or_slug = $this->get_one_by_slug($base_obj_or_id_or_slug);
        }
        return parent::ensure_is_ID($base_obj_or_id_or_slug);
    }


    /**
     * Verifies the button urls on all the passed payment methods have a valid button url.
     * If not, resets them to their default.
     *
     * @param EE_Payment_Method[] $payment_methods if NULL, defaults to all payment methods active in the cart
     * @throws EE_Error
     * @throws ReflectionException
     */
    public function verify_button_urls($payment_methods = null)
    {
        $payment_methods = is_array($payment_methods)
            ? $payment_methods
            : $this->get_all_active(EEM_Payment_Method::scope_cart);
        foreach ($payment_methods as $payment_method) {
            try {
                // If there is really no button URL at all, or if the button URLs still point to decaf folder even
                // though this is a caffeinated install, reset it to the default.
                $current_button_url = $payment_method->button_url();
                if (empty($current_button_url)
                    || (
                        strpos($current_button_url, 'decaf') !== false
                        && strpos($payment_method->type_obj()->default_button_url(), 'decaf') === false
                    )
                ) {
                    $payment_method->save(
                        [
                            'PMD_button_url' => $payment_method->type_obj()->default_button_url(),
                        ]
                    );
                }
            } catch (EE_Error $e) {
                $payment_method->deactivate();
            }
        }
    }


    /**
     * Overrides parent to not only turn wpdb results into EE_Payment_Method objects,
     * but also verifies the payment method type of each is a usable object. If not,
     * deactivate it, sets a notification, and deactivates it
     *
     * @param array $rows
     * @return EE_Payment_Method[]
     * @throws EE_Error
     * @throws InvalidDataTypeException
     * @throws ReflectionException
     */
    protected function _create_objects($rows = [])
    {
        EE_Registry::instance()->load_lib('Payment_Method_Manager');
        $payment_methods = parent::_create_objects($rows);
        /* @var $payment_methods EE_Payment_Method[] */
        $usable_payment_methods = [];
        foreach ($payment_methods as $key => $payment_method) {
            if (EE_Payment_Method_Manager::instance()->payment_method_type_exists($payment_method->type())) {
                $usable_payment_methods[ $key ] = $payment_method;
                // some payment methods enqueue their scripts in EE_PMT_*::__construct
                // which is kinda a no-no (just because it's being constructed doesn't mean we need to enqueue
                // its scripts). but for backwards-compat we should continue to do that
                $payment_method->type_obj();
            } elseif ($payment_method->active()) {
                // only deactivate and notify the admin if the payment is active somewhere
                $payment_method->deactivate();
                $payment_method->save();
                do_action(
                    'AHEE__EEM_Payment_Method___create_objects_auto_deactivated_payment_method',
                    $payment_method
                );
                new PersistentAdminNotice(
                    'auto-deactivated-' . $payment_method->type(),
                    sprintf(
                        esc_html__(
                            'The payment method %1$s was automatically deactivated because it appears its associated Event Espresso Addon was recently deactivated.%2$sIt can be reactivated on the %3$sPlugins admin page%4$s, then you can reactivate the payment method.',
                            'event_espresso'
                        ),
                        $payment_method->admin_name(),
                        '<br />',
                        '<a href="' . admin_url('plugins.php') . '">',
                        '</a>'
                    ),
                    true
                );
            }
        }
        return $usable_payment_methods;
    }


    /**
     * Gets all the payment methods which can be used for transaction
     * (according to the relations between payment methods and events, and
     * the currencies used for the transaction and their relation to payment methods)
     *
     * @param EE_Transaction $transaction
     * @param string         $scope @see EEM_Payment_Method::get_all_for_events
     * @return EE_Payment_Method[]
     * @throws EE_Error
     */
    public function get_all_for_transaction($transaction, $scope)
    {
        // give addons a chance to override what payment methods are chosen based on the transaction
        return apply_filters(
            'FHEE__EEM_Payment_Method__get_all_for_transaction__payment_methods',
            $this->get_all_active($scope, ['group_by' => 'PMD_type']),
            $transaction,
            $scope
        );
    }


    /**
     * Returns the payment method used for the last payment made for a registration.
     * Note: if an offline payment method was selected on the related transaction then this will have no payment
     * methods returned. It will ONLY return a payment method for a PAYMENT recorded against the registration.
     *
     * @param EE_Registration|int $registration_or_reg_id Either the EE_Registration object or the id for the
     *                                                    registration.
     * @return EE_Payment|null
     * @throws EE_Error
     */
    public function get_last_used_for_registration($registration_or_reg_id)
    {
        $registration_id = EEM_Registration::instance()->ensure_is_ID($registration_or_reg_id);

        $query_params = [
            0          => [
                'Payment.Registration.REG_ID' => $registration_id,
            ],
            'order_by' => ['Payment.PAY_ID' => 'DESC'],
        ];
        return $this->get_one($query_params);
    }
}


1			<?php
2
3			use EventEspresso\core\domain\entities\notifications\PersistentAdminNotice;
4			use EventEspresso\core\exceptions\InvalidDataTypeException;
5
6			/**
7			* Payment Method Model
8			* For storing all payment methods (things that interact between EE and gateways).
9			* As of 4.3, payment methods are NOT singletons so there can be multiple instances of payment methods
10			* of the same type, with different details. Eg, multiple paypal standard gateways so different
11			* events can have their proceeds going to different paypal accounts
12			*
13			* @package Event Espresso
14			* @subpackage includes/models/EEM_Checkin.model.php
15			* @author Mike Nelson
16			*/
17			class EEM_Payment_Method extends EEM_Base
18			{
19
20			const scope_cart = 'CART';
21
22			const scope_admin = 'ADMIN';
23
24			const scope_api = 'API';
25
26			/**
27			* @type EEM_Payment_Method
28			*/
29			protected static $_instance = null;
30
31
32			/**
33			* private constructor to prevent direct creation
34			*
35			* @param null $timezone
36			* @throws EE_Error
37			*/
38			protected function __construct($timezone = null)
39			{
40			$this->singular_item = esc_html__('Payment Method', 'event_espresso');
41			$this->plural_item = esc_html__('Payment Methods', 'event_espresso');
42			$this->_tables = [
43			'Payment_Method' => new EE_Primary_Table('esp_payment_method', 'PMD_ID'),
44			];
45			$this->_fields = [
46			'Payment_Method' => [
47			'PMD_ID' => new EE_Primary_Key_Int_Field(
48			'PMD_ID',
49			esc_html__('ID', 'event_espresso')
50			),
51			'PMD_type' => new EE_Plain_Text_Field(
52			'PMD_type',
53			esc_html__('Payment Method Type', 'event_espresso'),
54			false,
55			'Admin_Only'
56			),
57			'PMD_name' => new EE_Plain_Text_Field(
58			'PMD_name',
59			esc_html__('Name', 'event_espresso'),
60			false
61			),
62			'PMD_desc' => new EE_Post_Content_Field(
63			'PMD_desc',
64			esc_html__('Description', 'event_espresso'),
65			false,
66			''
67			),
68			'PMD_admin_name' => new EE_Plain_Text_Field(
69			'PMD_admin_name',
70			esc_html__('Admin-Only Name', 'event_espresso'),
71			true
72			),
73			'PMD_admin_desc' => new EE_Post_Content_Field(
74			'PMD_admin_desc',
75			esc_html__('Admin-Only Description', 'event_espresso'),
76			true
77			),
78			'PMD_slug' => new EE_Slug_Field(
79			'PMD_slug',
80			esc_html__('Slug', 'event_espresso'),
81			false
82			),
83			'PMD_order' => new EE_Integer_Field(
84			'PMD_order',
85			esc_html__('Order', 'event_espresso'),
86			false,
87			0
88			),
89			'PMD_debug_mode' => new EE_Boolean_Field(
90			'PMD_debug_mode',
91			esc_html__('Debug Mode On?', 'event_espresso'),
92			false,
93			false
94			),
95			'PMD_wp_user' => new EE_WP_User_Field(
96			'PMD_wp_user',
97			esc_html__('Payment Method Creator ID', 'event_espresso'),
98			false
99			),
100			'PMD_open_by_default' => new EE_Boolean_Field(
101			'PMD_open_by_default',
102			esc_html__('Open by Default?', 'event_espresso'),
103			false,
104			false
105			),
106			'PMD_button_url' => new EE_Plain_Text_Field(
107			'PMD_button_url',
108			esc_html__('Button URL', 'event_espresso'),
109			true,
110			''
111			),
112			'PMD_scope' => new EE_Serialized_Text_Field(
113			'PMD_scope',
114			esc_html__('Usable From?', 'event_espresso'),
115			false,
116			[]// possible values currently are 'CART','ADMIN','API'
117			),
118			],
119			];
120			$this->_model_relations = [
121			'Payment' => new EE_Has_Many_Relation(),
122			'Currency' => new EE_HABTM_Relation('Currency_Payment_Method'),
123			'Transaction' => new EE_Has_Many_Relation(),
124			'WP_User' => new EE_Belongs_To_Relation(),
125			];
126			parent::__construct($timezone);
127			}
128
129
130			/**
131			* Gets one by the slug provided
132			*
133			* @param string $slug
134			* @return EE_Base_Class\|EE_Payment_Method\|EE_Soft_Delete_Base_Class\|NULL
135			* @throws EE_Error
136			*/
137			public function get_one_by_slug($slug)
138			{
139			return $this->get_one([['PMD_slug' => $slug]]);
140			}
141
142
143			/**
144			* Gets all the acceptable scopes for payment methods.
145			* Keys are their names as store din the DB, and values are nice names for displaying them
146			*
147			* @return array
148			*/
149			public function scopes()
150			{
151			return apply_filters(
152			'FHEE__EEM_Payment_Method__scopes',
153			[
154			EEM_Payment_Method::scope_cart => esc_html__('Front-end Registration Page', 'event_espresso'),
155			EEM_Payment_Method::scope_admin => esc_html__(
156			'Admin Registration Page (no online processing)',
157			'event_espresso'
158			),
159			]
160			);
161			}
162
163
164			/**
165			* Determines if this is an valid scope
166			*
167			* @param string $scope like one of EEM_Payment_Method::instance()->scopes()
168			* @return boolean
169			*/
170			public function is_valid_scope($scope)
171			{
172			$scopes = $this->scopes();
173			if (isset($scopes[ $scope ])) {
174			return true;
175			}
176			return false;
177			}
178
179
180			/**
181			* Gets all active payment methods
182			*
183			* @param string $scope one of
184			* @param array $query_params
185			* @return EE_Base_Class[]\|EE_Payment_Method[]
186			* @throws EE_Error
187			*/
188			public function get_all_active($scope = null, $query_params = [])
189			{
190			if (! isset($query_params['order_by']) && ! isset($query_params['order'])) {
191			$query_params['order_by'] = ['PMD_order' => 'ASC', 'PMD_ID' => 'ASC'];
192			}
193			return $this->get_all($this->_get_query_params_for_all_active($scope, $query_params));
194			}
195
196
197			/**
198			* Counts all active gateways in the specified scope
199			*
200			* @param string $scope one of EEM_Payment_Method::scope_*
201			* @param array $query_params
202			* @return int
203			* @throws EE_Error
204			*/
205			public function count_active($scope = null, $query_params = [])
206			{
207			return $this->count($this->_get_query_params_for_all_active($scope, $query_params));
208			}
209
210
211			/**
212			* Creates the $query_params that can be passed into any EEM_Payment_Method as their $query_params
213			* argument to get all active for a given scope
214			*
215			* @param string $scope one of the constants EEM_Payment_Method::scope_*
216			* @param array $query_params
217			* @return array
218			* @throws EE_Error
219			* @see https://github.com/eventespresso/event-espresso-core/tree/master/docs/G--Model-System/model-query-params.md
220			*/
221			protected function _get_query_params_for_all_active($scope = null, $query_params = [])
222			{
223			if ($scope) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-23 01:20 UTC by Report Bug Copy Issue Report The expression `$scope` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
224			if ($this->is_valid_scope($scope)) {
225			return array_replace_recursive([['PMD_scope' => ['LIKE', "%$scope%"]]], $query_params);
226			}
227			throw new EE_Error(
228			sprintf(
229			esc_html__("'%s' is not a valid scope for a payment method", 'event_espresso'),
230			$scope
231			)
232			);
233			}
234			$acceptable_scopes = [];
235			$count = 0;
236			foreach ($this->scopes() as $scope_name => $desc) {
237			$count++;
238			$acceptable_scopes[ 'PMD_scope*' . $count ] = ['LIKE', '%' . $scope_name . '%'];
239			}
240			return array_replace_recursive([['OR*active_scope' => $acceptable_scopes]], $query_params);
241			}
242
243
244			/**
245			* Creates the $query_params that can be passed into any EEM_Payment_Method as their $query_params
246			* argument to get all active for a given scope
247			*
248			* @param string $scope one of the constants EEM_Payment_Method::scope_*
249			* @param array $query_params
250			* @return array
251			* @throws EE_Error
252			* @see https://github.com/eventespresso/event-espresso-core/tree/master/docs/G--Model-System/model-query-params.md
253			*/
254			public function get_query_params_for_all_active($scope = null, $query_params = [])
255			{
256			return $this->_get_query_params_for_all_active($scope, $query_params);
257			}
258
259
260			/**
261			* Gets one active payment method. see @get_all_active for documentation
262			*
263			* @param string $scope
264			* @param array $query_params
265			* @return EE_Base_Class\|EE_Payment_Method\|EE_Soft_Delete_Base_Class\|NULL
266			* @throws EE_Error
267			*/
268			public function get_one_active($scope = null, $query_params = [])
269			{
270			return $this->get_one($this->_get_query_params_for_all_active($scope, $query_params));
271			}
272
273
274			/**
275			* Gets one payment method of that type, regardless of whether its active or not
276			*
277			* @param string $type
278			* @return EE_Base_Class\|EE_Payment_Method\|EE_Soft_Delete_Base_Class\|NULL
279			* @throws EE_Error
280			*/
281			public function get_one_of_type($type)
282			{
283			return $this->get_one([['PMD_type' => $type]]);
284			}
285
286
287			/**
288			* Overrides parent ot also check by the slug
289			*
290			* @param string\|int\|EE_Payment_Method $base_class_obj_or_id
291			* @param boolean $ensure_is_in_db
292			* @return EE_Base_Class\|EE_Payment_Method\|EE_Soft_Delete_Base_Class\|int\|string
293			* @throws EE_Error
294			* @see EEM_Base::ensure_is_obj()
295			*/
296			public function ensure_is_obj($base_class_obj_or_id, $ensure_is_in_db = false)
297			{
298			// first: check if it's a slug
299			if (is_string($base_class_obj_or_id)) {
300			$obj = $this->get_one_by_slug($base_class_obj_or_id);
301			if ($obj) {
302			return $obj;
303			}
304			}
305			// ok so it wasn't a slug we were passed. try the usual then (ie, it's an object or an ID)
306			try {
307			return parent::ensure_is_obj($base_class_obj_or_id, $ensure_is_in_db);
308			} catch (EE_Error $e) {
309			// handle it outside the catch
310			}
311			throw new EE_Error(
312			sprintf(
313			esc_html__("'%s' is neither a Payment Method ID, slug, nor object.", 'event_espresso'),
314			$base_class_obj_or_id
315			)
316			);
317			}
318
319
320			/**
321			* Gets the ID of this object, or if its a string finds the object's id
322			* associated with that slug
323			*
324			* @param mixed $base_obj_or_id_or_slug
325			* @return int
326			* @throws EE_Error
327			*/
328			public function ensure_is_ID($base_obj_or_id_or_slug)
329			{
330			if (is_string($base_obj_or_id_or_slug)) {
331			// assume it's a slug
332			$base_obj_or_id_or_slug = $this->get_one_by_slug($base_obj_or_id_or_slug);
333			}
334			return parent::ensure_is_ID($base_obj_or_id_or_slug);
335			}
336
337
338			/**
339			* Verifies the button urls on all the passed payment methods have a valid button url.
340			* If not, resets them to their default.
341			*
342			* @param EE_Payment_Method[] $payment_methods if NULL, defaults to all payment methods active in the cart
343			* @throws EE_Error
344			* @throws ReflectionException
345			*/
346			public function verify_button_urls($payment_methods = null)
347			{
348			$payment_methods = is_array($payment_methods)
349			? $payment_methods
350			: $this->get_all_active(EEM_Payment_Method::scope_cart);
351			foreach ($payment_methods as $payment_method) {
352			try {
353			// If there is really no button URL at all, or if the button URLs still point to decaf folder even
354			// though this is a caffeinated install, reset it to the default.
355			$current_button_url = $payment_method->button_url();
356			if (empty($current_button_url)
357			\|\| (
358			strpos($current_button_url, 'decaf') !== false
359			&& strpos($payment_method->type_obj()->default_button_url(), 'decaf') === false
360			)
361			) {
362			$payment_method->save(
363			[
364			'PMD_button_url' => $payment_method->type_obj()->default_button_url(),
365			]
366			);
367			}
368			} catch (EE_Error $e) {
369			$payment_method->deactivate();
370			}
371			}
372			}
373
374
375			/**
376			* Overrides parent to not only turn wpdb results into EE_Payment_Method objects,
377			* but also verifies the payment method type of each is a usable object. If not,
378			* deactivate it, sets a notification, and deactivates it
379			*
380			* @param array $rows
381			* @return EE_Payment_Method[]
382			* @throws EE_Error
383			* @throws InvalidDataTypeException
384			* @throws ReflectionException
385			*/
386			protected function _create_objects($rows = [])
387			{
388			EE_Registry::instance()->load_lib('Payment_Method_Manager');
389			$payment_methods = parent::_create_objects($rows);
390			/* @var $payment_methods EE_Payment_Method[] */
391			$usable_payment_methods = [];
392			foreach ($payment_methods as $key => $payment_method) {
393			if (EE_Payment_Method_Manager::instance()->payment_method_type_exists($payment_method->type())) {
394			$usable_payment_methods[ $key ] = $payment_method;
395			// some payment methods enqueue their scripts in EE_PMT_*::__construct
396			// which is kinda a no-no (just because it's being constructed doesn't mean we need to enqueue
397			// its scripts). but for backwards-compat we should continue to do that
398			$payment_method->type_obj();
399			} elseif ($payment_method->active()) {
400			// only deactivate and notify the admin if the payment is active somewhere
401			$payment_method->deactivate();
402			$payment_method->save();
403			do_action(
404			'AHEE__EEM_Payment_Method___create_objects_auto_deactivated_payment_method',
405			$payment_method
406			);
407			new PersistentAdminNotice(
408			'auto-deactivated-' . $payment_method->type(),
409			sprintf(
410			esc_html__(
411			'The payment method %1$s was automatically deactivated because it appears its associated Event Espresso Addon was recently deactivated.%2$sIt can be reactivated on the %3$sPlugins admin page%4$s, then you can reactivate the payment method.',
412			'event_espresso'
413			),
414			$payment_method->admin_name(),
415			'<br />',
416			'<a href="' . admin_url('plugins.php') . '">',
417			'</a>'
418			),
419			true
420			);
421			}
422			}
423			return $usable_payment_methods;
424			}
425
426
427			/**
428			* Gets all the payment methods which can be used for transaction
429			* (according to the relations between payment methods and events, and
430			* the currencies used for the transaction and their relation to payment methods)
431			*
432			* @param EE_Transaction $transaction
433			* @param string $scope @see EEM_Payment_Method::get_all_for_events
434			* @return EE_Payment_Method[]
435			* @throws EE_Error
436			*/
437			public function get_all_for_transaction($transaction, $scope)
438			{
439			// give addons a chance to override what payment methods are chosen based on the transaction
440			return apply_filters(
441			'FHEE__EEM_Payment_Method__get_all_for_transaction__payment_methods',
442			$this->get_all_active($scope, ['group_by' => 'PMD_type']),
443			$transaction,
444			$scope
445			);
446			}
447
448
449			/**
450			* Returns the payment method used for the last payment made for a registration.
451			* Note: if an offline payment method was selected on the related transaction then this will have no payment
452			* methods returned. It will ONLY return a payment method for a PAYMENT recorded against the registration.
453			*
454			* @param EE_Registration\|int $registration_or_reg_id Either the EE_Registration object or the id for the
455			* registration.
456			* @return EE_Payment\|null
457			* @throws EE_Error
458			*/
459			public function get_last_used_for_registration($registration_or_reg_id)
460			{
461			$registration_id = EEM_Registration::instance()->ensure_is_ID($registration_or_reg_id);
462
463			$query_params = [
464			0 => [
465			'Payment.Registration.REG_ID' => $registration_id,
466			],
467			'order_by' => ['Payment.PAY_ID' => 'DESC'],
468			];
469			return $this->get_one($query_params);
470			}
471			}
472

eventespresso / event-espresso-core

Branch — BUG/add-foreign-key-alias (17fa63)

EEM_Payment_Method::scopes() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like