9c4b0cb4c84e7d6de6ec6a9dce3e1c513840abcb
[moodle.git] / payment / classes / helper.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Contains helper class for the payment subsystem.
19  *
20  * @package    core_payment
21  * @copyright  2019 Shamim Rezaie <shamim@moodle.com>
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 namespace core_payment;
27 defined('MOODLE_INTERNAL') || die();
29 /**
30  * Helper class for the payment subsystem.
31  *
32  * @copyright  2019 Shamim Rezaie <shamim@moodle.com>
33  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
34  */
35 class helper {
37     /**
38      * Returns an accumulated list of supported currencies by all payment gateways.
39      *
40      * @return string[] An array of the currency codes in the three-character ISO-4217 format
41      */
42     public static function get_supported_currencies(): array {
43         $currencies = [];
45         $plugins = \core_plugin_manager::instance()->get_enabled_plugins('pg');
46         foreach ($plugins as $plugin) {
47             /** @var \pg_paypal\gateway $classname */
48             $classname = '\pg_' . $plugin . '\gateway';
50             $currencies += component_class_callback($classname, 'get_supported_currencies', [], []);
51         }
53         $currencies = array_unique($currencies);
55         return $currencies;
56     }
58     /**
59      * Returns the list of gateways that can process payments in the given currency.
60      *
61      * @param string $component
62      * @param int $componentid
63      * @return string[]
64      */
65     public static function get_gateways_for_currency(string $component, int $componentid): array {
66         $gateways = [];
68         [
69             'amount' => $amount,
70             'currency' => $currency,
71             'accountid' => $accountid,
72         ] = self::get_cost($component, $componentid);
73         $account = new account($accountid);
74         if (!$account->get('id') || !$account->get('enabled')) {
75             return $gateways;
76         }
78         foreach ($account->get_gateways() as $plugin => $gateway) {
79             if (!$gateway->get('enabled')) {
80                 continue;
81             }
82             /** @var gateway $classname */
83             $classname = '\pg_' . $plugin . '\gateway';
85             $currencies = component_class_callback($classname, 'get_supported_currencies', [], []);
86             if (in_array($currency, $currencies)) {
87                 $gateways[] = $plugin;
88             }
89         }
91         return $gateways;
92     }
94     /**
95      * Calculates the cost with the surcharge
96      *
97      * @param float $amount amount in the currency units
98      * @param float $surcharge surcharge in percents
99      * @param string $currency currency, used for calculating the number of fractional digits
100      * @return float
101      */
102     public static function get_cost_with_surcharge(float $amount, float $surcharge, string $currency): float {
103         return round($amount + $amount * $surcharge / 100, 2); // TODO number of digits depends on currency.
104     }
106     /**
107      * Returns human-readable amount with fixed number of fractional digits and currency indicator
108      *
109      * @param float $amount
110      * @param string $currency
111      * @return string
112      * @throws \coding_exception
113      */
114     public static function get_cost_as_string(float $amount, string $currency): string {
115         if (class_exists('NumberFormatter') && function_exists('numfmt_format_currency')) {
116             $locale = get_string('localecldr', 'langconfig');
117             $fmt = \NumberFormatter::create($locale, \NumberFormatter::CURRENCY);
118             $localisedcost = numfmt_format_currency($fmt, $amount, $currency);
119         } else {
120             $localisedcost = sprintf("%.2f %s", $amount, $currency); // TODO number of digits depends on currency.
121         }
123         return $localisedcost;
124     }
126     /**
127      * Returns the percentage of surcharge that is applied when using a gateway
128      *
129      * @param string $gateway Name of the gateway
130      * @return float
131      */
132     public static function get_gateway_surcharge(string $gateway): float {
133         return (float)get_config('pg_' . $gateway, 'surcharge');
134     }
136     /**
137      * Returns the attributes to place on a pay button.
138      *
139      * @param string $component Name of the component that the componentid belongs to
140      * @param int $componentid An internal identifier that is used by the component
141      * @param string $description Description of the payment
142      * @return array
143      */
144     public static function gateways_modal_link_params(string $component, int $componentid, string $description): array {
145         [
146             'amount' => $amount,
147             'currency' => $currency
148         ] = self::get_cost($component, $componentid);
150         return [
151             'id' => 'gateways-modal-trigger',
152             'role' => 'button',
153             'data-component' => $component,
154             'data-componentid' => $componentid,
155             'data-cost' => self::get_cost_as_string($amount, $currency),
156             'data-description' => $description,
157         ];
158     }
160     /**
161      * Asks the cost from the related component.
162      *
163      * @param string $component Name of the component that the componentid belongs to
164      * @param int $componentid An internal identifier that is used by the component
165      * @return array['amount' => float, 'currency' => string, 'accountid' => int]
166      * @throws \moodle_exception
167      */
168     public static function get_cost(string $component, int $componentid): array {
169         $cost = component_class_callback("$component\\payment\\provider", 'get_cost', [$componentid]);
171         if ($cost === null || !is_array($cost) || !array_key_exists('amount', $cost)
172                 || !array_key_exists('currency', $cost) || !array_key_exists('accountid', $cost) ) {
173             throw new \moodle_exception('callbacknotimplemented', 'core_payment', '', $component);
174         }
176         return $cost;
177     }
179     /**
180      * Returns the gateway configuration for given component and gateway
181      *
182      * @param string $component
183      * @param int $componentid
184      * @param string $gatewayname
185      * @return array
186      * @throws \moodle_exception
187      */
188     public static function get_gateway_configuration(string $component, int $componentid, string $gatewayname): array {
189         $x = self::get_cost($component, $componentid);
190         $gateway = null;
191         $account = new account($x['accountid']);
192         if ($account && $account->get('enabled')) {
193             $gateway = $account->get_gateways()[$gatewayname] ?? null;
194         }
195         if (!$gateway) {
196             throw new \moodle_exception('gatewaynotfound', 'payment');
197         }
198         return $gateway->get_configuration();
199     }
201     /**
202      * Delivers what the user paid for.
203      *
204      * @uses \core_payment\local\callback\provider::deliver_order()
205      *
206      * @param string $component Name of the component that the componentid belongs to
207      * @param int $componentid An internal identifier that is used by the component
208      * @param int $paymentid payment id as inserted into the 'payments' table, if needed for reference
209      * @return bool Whether successful or not
210      */
211     public static function deliver_order(string $component, int $componentid, int $paymentid): bool {
212         $result = component_class_callback("$component\\payment\\provider", 'deliver_order', [$componentid, $paymentid]);
214         if ($result === null) {
215             throw new \moodle_exception('callbacknotimplemented', 'core_payment', '', $component);
216         }
218         return $result;
219     }
221     /**
222      * Stores essential information about the payment and returns the "id" field of the payment record in DB.
223      * Each payment gateway may then store the additional information their way.
224      *
225      * @param int $accountid Account id
226      * @param string $component Name of the component that the componentid belongs to
227      * @param int $componentid An internal identifier that is used by the component
228      * @param int $userid Id of the user who is paying
229      * @param float $amount Amount of payment
230      * @param string $currency Currency of payment
231      * @param string $gateway The gateway that is used for the payment
232      * @return int
233      */
234     public static function save_payment(int $accountid, string $component, int $componentid, int $userid, float $amount, string $currency,
235             string $gateway): int {
236         global $DB;
238         $record = new \stdClass();
239         $record->component = $component;
240         $record->componentid = $componentid;
241         $record->userid = $userid;
242         $record->amount = $amount;
243         $record->currency = $currency;
244         $record->gateway = $gateway;
245         $record->accountid = $accountid;
246         $record->timecreated = $record->timemodified = time();
248         $id = $DB->insert_record('payments', $record);
250         return $id;
251     }
253     /**
254      * This functions adds the settings that are common for all payment gateways.
255      *
256      * @param \admin_settingpage $settings The settings object
257      * @param string $gateway The gateway name prefic with pg_
258      */
259     public static function add_common_gateway_settings(\admin_settingpage $settings, string $gateway): void {
260         $settings->add(new \admin_setting_configtext($gateway . '/surcharge', get_string('surcharge', 'core_payment'),
261                 get_string('surcharge_desc', 'core_payment'), 0, PARAM_INT));
263     }
265     /**
266      * Save a new or edited payment account (used in management interface)
267      *
268      * @param \stdClass $data
269      */
270     public static function save_payment_account(\stdClass $data) {
272         if (empty($data->id)) {
273             $account = new account(0, $data);
274         } else {
275             $account = new account($data->id);
276             $account->from_record($data);
277         }
279         $account->save();
280         // TODO trigger event.
281     }
283     /**
284      * Delete a payment account (used in management interface)
285      *
286      * @param account $account
287      */
288     public static function delete_payment_account(account $account) {
289         foreach ($account->get_gateways(false) as $gateway) {
290             if ($gateway->get('id')) {
291                 $gateway->delete();
292             }
293         }
294         $account->delete();
295         // TODO trigger event.
296     }
298     /**
299      * Save a payment gateway linked to an existing account (used in management interface)
300      *
301      * @param \stdClass $data
302      */
303     public static function save_payment_gateway(\stdClass $data) {
304         if (empty($data->id)) {
305             $gateway = new account_gateway(0, $data);
306         } else {
307             $gateway = new account_gateway($data->id);
308             unset($data->accountid, $data->gateway, $data->id);
309             $gateway->from_record($data);
310         }
312         $gateway->save();
313         // TODO trigger event.
314     }
316     /**
317      * Returns the list of payment accounts in the given context (used in management interface)
318      *
319      * @param \context $context
320      * @return account[]
321      */
322     public static function get_payment_accounts_to_manage(\context $context): array {
323         return account::get_records(['contextid' => $context->id]);
324     }
326     /**
327      * Get list of accounts available in the given context
328      *
329      * @param \context $context
330      * @return array
331      */
332     public static function get_payment_accounts_menu(\context $context): array {
333         global $DB;
334         [$sql, $params] = $DB->get_in_or_equal($context->get_parent_context_ids(true));
335         $accounts = array_filter(account::get_records_select('contextid '.$sql, $params), function($account) {
336             return $account->is_available();
337         });
338         return array_map(function($account) {
339             return $account->get_formatted_name();
340         }, $accounts);
341     }