// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* Contain the logic for the gateways modal.
*
* @module core_payment/gateways_modal
* @copyright 2019 Shamim Rezaie <shamim@moodle.com>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
import Templates from 'core/templates';
import {getString} from 'core/str';
import {getAvailableGateways} from './repository';
import Selectors from './selectors';
import ModalEvents from 'core/modal_events';
import PaymentEvents from 'core_payment/events';
import {add as addToast, addToastRegion} from 'core/toast';
import Notification from 'core/notification';
import ModalGateways from './modal_gateways';
/**
* Register event listeners for the module.
*/
const registerEventListeners = () => {
document.addEventListener('click', e => {
const gatewayTrigger = e.target.closest('[data-action="core_payment/triggerPayment"]');
if (gatewayTrigger) {
e.preventDefault();
show(gatewayTrigger, {focusOnClose: e.target});
}
});
};
/**
* Shows the gateway selector modal.
*
* @param {HTMLElement} rootNode
* @param {Object} options - Additional options
* @param {HTMLElement} options.focusOnClose The element to focus on when the modal is closed.
*/
const show = async(rootNode, {
focusOnClose = null,
} = {}) => {
// Load upfront, so we don't try to inject the internal content into a possibly-not-yet-resolved promise.
const body = await Templates.render('core_payment/gateways_modal', {});
const modal = await ModalGateways.create({
title: getString('selectpaymenttype', 'core_payment'),
body: body,
show: true,
removeOnClose: true,
});
const rootElement = modal.getRoot()[0];
addToastRegion(rootElement);
modal.getRoot().on(ModalEvents.hidden, () => {
focusOnClose?.focus();
});
modal.getRoot().on(PaymentEvents.proceed, async(e) => {
e.preventDefault();
const gateway = (rootElement.querySelector(Selectors.values.gateway) || {value: ''}).value;
if (gateway) {
processPayment(
gateway,
rootNode.dataset.component,
rootNode.dataset.paymentarea,
rootNode.dataset.itemid,
rootNode.dataset.description
).then((message) => {
modal.hide();
Notification.addNotification({
message,
type: 'success',
});
location.href = rootNode.dataset.successurl;
return;
}).catch(message => Notification.alert('', message));
} else {
// We cannot use await in the following line.
// The reason is that we are preventing the default action of the save event being triggered,
// therefore we cannot define the event handler function asynchronous.
addToast(getString('nogatewayselected', 'core_payment'), {
type: 'warning',
});
}
});
// Re-calculate the cost when gateway is changed.
rootElement.addEventListener('change', e => {
if (e.target.matches(Selectors.elements.gateways)) {
updateCostRegion(rootElement, rootNode.dataset.cost);
}
});
const gateways = await getAvailableGateways(rootNode.dataset.component, rootNode.dataset.paymentarea, rootNode.dataset.itemid);
const context = {
gateways
};
const {html, js} = await Templates.renderForPromise('core_payment/gateways', context);
Templates.replaceNodeContents(rootElement.querySelector(Selectors.regions.gatewaysContainer), html, js);
selectSingleGateway(rootElement);
await updateCostRegion(rootElement, rootNode.dataset.cost);
};
/**
* Auto-select the gateway if there is only one gateway.
*
* @param {HTMLElement} root An HTMLElement that contains the cost region
*/
const selectSingleGateway = root => {
const gateways = root.querySelectorAll(Selectors.elements.gateways);
if (gateways.length == 1) {
gateways[0].checked = true;
}
};
/**
* Shows the cost of the item the user is purchasing in the cost region.
*
* @param {HTMLElement} root An HTMLElement that contains the cost region
* @param {string} defaultCost The default cost that is going to be displayed if no gateway is selected
* @returns {Promise<void>}
*/
const updateCostRegion = async(root, defaultCost = '') => {
const gatewayElement = root.querySelector(Selectors.values.gateway);
const surcharge = parseInt((gatewayElement || {dataset: {surcharge: 0}}).dataset.surcharge);
const cost = (gatewayElement || {dataset: {cost: defaultCost}}).dataset.cost;
const valueStr = surcharge ? await getString('feeincludesurcharge', 'core_payment', {fee: cost, surcharge: surcharge}) : cost;
const surchargeStr = await getString('labelvalue', 'core',
{
label: await getString('cost', 'core'),
value: valueStr
}
);
const {html, js} = await Templates.renderForPromise('core_payment/fee_breakdown', {surchargestr: surchargeStr});
Templates.replaceNodeContents(root.querySelector(Selectors.regions.costContainer), html, js);
};
/**
* Process payment using the selected gateway.
*
* @param {string} gateway The gateway to be used for payment
* @param {string} component Name of the component that the itemId belongs to
* @param {string} paymentArea Name of the area in the component that the itemId belongs to
* @param {number} itemId An internal identifier that is used by the component
* @param {string} description Description of the payment
* @returns {Promise<string>}
*/
const processPayment = async(gateway, component, paymentArea, itemId, description) => {
const paymentMethod = await import(`paygw_${gateway}/gateways_modal`);
return paymentMethod.process(component, paymentArea, itemId, description);
};
/**
* Set up the payment actions.
*/
export const init = () => {
if (!init.initialised) {
// Event listeners should only be registered once.
init.initialised = true;
registerEventListeners();
}
};
/**
* Whether the init function was called before.
*
* @static
* @type {boolean}
*/
init.initialised = false;