Tips:
diff --git a/addons/pos_adyen/static/src/js/models.js b/addons/pos_adyen/static/src/js/models.js
index 8cff0f1c6d4..95f07a7bf7f 100644
--- a/addons/pos_adyen/static/src/js/models.js
+++ b/addons/pos_adyen/static/src/js/models.js
@@ -14,7 +14,9 @@ patch(Payment.prototype, "pos_adyen.Payment", {
//@override
export_as_JSON() {
const json = this._super(...arguments);
- json.terminal_service_id = this.terminalServiceId;
+ if (json) {
+ json.terminal_service_id = this.terminalServiceId;
+ }
return json;
},
//@override
diff --git a/addons/pos_hr/static/src/js/PaymentScreen.js b/addons/pos_hr/static/src/js/PaymentScreen.js
index 8328c3b009a..52a484f3956 100644
--- a/addons/pos_hr/static/src/js/PaymentScreen.js
+++ b/addons/pos_hr/static/src/js/PaymentScreen.js
@@ -4,7 +4,7 @@ import { PaymentScreen } from "@point_of_sale/app/screens/payment_screen/payment
import { patch } from "@web/core/utils/patch";
patch(PaymentScreen.prototype, "pos_hr.PaymentScreen", {
- async _finalizeValidation() {
+ async validateOrder(isForceValidate) {
this.currentOrder.cashier = this.pos.get_cashier();
await this._super(...arguments);
},
diff --git a/addons/pos_mercury/static/src/js/pos_mercury.js b/addons/pos_mercury/static/src/js/pos_mercury.js
index d6c74f3c0de..c539a0d268f 100644
--- a/addons/pos_mercury/static/src/js/pos_mercury.js
+++ b/addons/pos_mercury/static/src/js/pos_mercury.js
@@ -103,7 +103,11 @@ patch(Payment.prototype, "pos_mercury.Payment", {
this.set_credit_card_name();
},
export_as_JSON() {
- return Object.assign(this._super(...arguments), {
+ const result = this._super(...arguments);
+ if (!result) {
+ return result;
+ }
+ return Object.assign(result, {
paid: this.paid,
mercury_card_number: this.mercury_card_number,
mercury_card_brand: this.mercury_card_brand,
diff --git a/addons/pos_online_payment/__init__.py b/addons/pos_online_payment/__init__.py
new file mode 100644
index 00000000000..7d34c7c054a
--- /dev/null
+++ b/addons/pos_online_payment/__init__.py
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from . import controllers
+from . import models
diff --git a/addons/pos_online_payment/__manifest__.py b/addons/pos_online_payment/__manifest__.py
new file mode 100644
index 00000000000..ed4df2632f5
--- /dev/null
+++ b/addons/pos_online_payment/__manifest__.py
@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+
+{
+ 'name': 'Point of Sale online payment',
+ 'depends': ['point_of_sale', 'account_payment'],
+ 'data': [
+ 'views/payment_transaction_views.xml',
+ 'views/pos_payment_views.xml',
+ 'views/pos_payment_method_views.xml',
+ 'views/payment_portal_templates.xml',
+ 'views/account_payment_views.xml',
+ ],
+ 'auto_install': True,
+ 'installable': True,
+ 'assets': {
+ 'point_of_sale.assets_prod': [
+ 'pos_online_payment/static/src/app/**/*',
+ 'pos_online_payment/static/src/css/**/*',
+ ],
+ 'web.assets_tests': [
+ 'pos_online_payment/static/tests/tours/**/*',
+ ],
+ },
+ 'license': 'LGPL-3',
+}
diff --git a/addons/pos_online_payment/controllers/__init__.py b/addons/pos_online_payment/controllers/__init__.py
new file mode 100644
index 00000000000..38f2f6a7f0f
--- /dev/null
+++ b/addons/pos_online_payment/controllers/__init__.py
@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from . import payment_portal
diff --git a/addons/pos_online_payment/controllers/payment_portal.py b/addons/pos_online_payment/controllers/payment_portal.py
new file mode 100644
index 00000000000..03e4e8b45e6
--- /dev/null
+++ b/addons/pos_online_payment/controllers/payment_portal.py
@@ -0,0 +1,291 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from werkzeug.urls import url_encode
+
+from odoo import _, http, tools
+from odoo.http import request
+from odoo.exceptions import AccessError, ValidationError, UserError
+from odoo.addons.payment.controllers.post_processing import PaymentPostProcessing
+from odoo.addons.payment.controllers import portal as payment_portal
+
+
+class PaymentPortal(payment_portal.PaymentPortal):
+
+ def _check_order_access(self, pos_order_id, access_token):
+ try:
+ order_sudo = self._document_check_access(
+ 'pos.order', pos_order_id, access_token)
+ except:
+ raise AccessError(
+ _("The provided order or access token is invalid."))
+
+ if order_sudo.state == "cancel":
+ raise ValidationError(_("The order has been canceled."))
+ return order_sudo
+
+ @staticmethod
+ def _ensure_session_open(pos_order_sudo):
+ if pos_order_sudo.session_id.state != 'opened':
+ raise AccessError(_("The POS session is not opened."))
+
+ def _get_partner_sudo(self, user_sudo):
+ partner_sudo = user_sudo.partner_id
+ if not partner_sudo and user_sudo._is_public():
+ partner_sudo = self.env.ref('base.public_user')
+ return partner_sudo
+
+ def _redirect_login(self):
+ return request.redirect('/web/login?' + url_encode({'redirect': request.httprequest.full_path}))
+
+ @staticmethod
+ def _get_amount_to_pay(order_to_pay_sudo):
+ if order_to_pay_sudo.state in ('paid', 'done', 'invoiced'):
+ return 0.0
+ amount = order_to_pay_sudo._get_checked_next_online_payment_amount()
+ if amount and PaymentPortal._is_valid_amount(amount, order_to_pay_sudo.currency_id):
+ return amount
+ else:
+ return order_to_pay_sudo.get_amount_unpaid()
+
+ @staticmethod
+ def _is_valid_amount(amount, currency):
+ return isinstance(amount, float) and tools.float_compare(amount, 0.0, precision_rounding=currency.rounding) > 0
+
+ def _get_allowed_providers_sudo(self, pos_order_sudo, partner_id, amount_to_pay):
+ payment_method = pos_order_sudo.online_payment_method_id
+ if not payment_method:
+ raise UserError(_("There is no online payment method configured for this Point of Sale order."))
+ compatible_providers_sudo = request.env['payment.provider'].sudo()._get_compatible_providers(
+ pos_order_sudo.company_id.id, partner_id, amount_to_pay, currency_id=pos_order_sudo.currency_id.id)
+ # In sudo mode to read the fields of providers and partner (if not logged in)
+ # Return the payment providers configured in the pos.payment.method that are compatible for the payment API
+ return compatible_providers_sudo & payment_method._get_online_payment_providers(pos_order_sudo.config_id.id, error_if_invalid=False)
+
+ @staticmethod
+ def _get_exit_route_arg(exit_route):
+ return '&' + url_encode({'exit_route': exit_route}) if exit_route else ''
+
+ @staticmethod
+ def _get_pay_route(pos_order_id, access_token, exit_route=None):
+ exit_route_arg = PaymentPortal._get_exit_route_arg(exit_route)
+ return f'/pos/pay/{pos_order_id}?access_token={access_token}{exit_route_arg}'
+
+ @staticmethod
+ def _get_landing_route(pos_order_id, access_token, exit_route_arg=None, tx_id=None):
+ tx_id_arg = f'&tx_id={tx_id}' if tx_id else ''
+ return f'/pos/pay/confirmation/{pos_order_id}?access_token={access_token}{exit_route_arg}{tx_id_arg}'
+
+ @http.route('/pos/pay/', type='http', methods=['GET'], auth='public', website=True, sitemap=False)
+ def pos_order_pay(self, pos_order_id, access_token=None, exit_route=None):
+ """ Behaves like payment.PaymentPortal.payment_pay but for POS online payment.
+
+ :param int pos_order_id: The POS order to pay, as a `pos.order` id
+ :param str access_token: The access token used to verify the user
+ :param str exit_route: The URL to open to leave the POS online payment flow
+
+ :return: The rendered payment form
+ :rtype: str
+ :raise: AccessError if the provided order or access token is invalid
+ :raise: ValidationError if data on the server prevents the payment
+ """
+ pos_order_sudo = self._check_order_access(pos_order_id, access_token)
+ self._ensure_session_open(pos_order_sudo)
+
+ user_sudo = request.env.user
+ logged_in = not user_sudo._is_public()
+ partner_sudo = self._get_partner_sudo(user_sudo)
+ if not partner_sudo:
+ return self._redirect_login()
+
+ kwargs = {
+ 'pos_order_id': pos_order_sudo.id,
+ }
+ exit_route_arg = self._get_exit_route_arg(exit_route)
+ rendering_context = {
+ **kwargs,
+ 'exit_route': exit_route,
+ 'reference_prefix': request.env['payment.transaction'].sudo()._compute_reference_prefix(provider_code=None, separator='-', **kwargs),
+ 'partner_id': partner_sudo.id,
+ 'access_token': access_token,
+ 'transaction_route': f'/pos/pay/transaction/{pos_order_sudo.id}?access_token={access_token}{exit_route_arg}',
+ 'landing_route': self._get_landing_route(pos_order_sudo.id, access_token, exit_route_arg=exit_route_arg),
+ **self._get_custom_rendering_context_values(**kwargs),
+ }
+
+ currency_id = pos_order_sudo.currency_id
+
+ if not currency_id.active:
+ rendering_context['currency'] = False
+ return self._render_pay(rendering_context)
+ rendering_context['currency'] = currency_id
+
+ amount_to_pay = self._get_amount_to_pay(pos_order_sudo)
+ if not self._is_valid_amount(amount_to_pay, currency_id):
+ rendering_context['amount'] = False
+ return self._render_pay(rendering_context)
+ rendering_context['amount'] = amount_to_pay
+
+ providers_sudo = self._get_allowed_providers_sudo(pos_order_sudo, partner_sudo.id, amount_to_pay)
+
+ # Compute the fees taken by providers supporting the feature
+ fees_by_provider = {
+ provider_sudo: provider_sudo._compute_fees(
+ amount_to_pay, currency_id, partner_sudo.country_id)
+ for provider_sudo in providers_sudo.filtered('fees_active')
+ }
+
+ if logged_in:
+ tokens_sudo = request.env['payment.token']._get_available_tokens(
+ providers_sudo.ids, partner_sudo.id)
+ show_tokenize_input = self._compute_show_tokenize_input_mapping(
+ providers_sudo, **kwargs)
+ else:
+ tokens_sudo = False
+ show_tokenize_input = dict.fromkeys(providers_sudo.ids, False)
+
+ rendering_context.update({
+ 'providers': providers_sudo,
+ 'tokens': tokens_sudo,
+ 'fees_by_provider': fees_by_provider,
+ 'show_tokenize_input': show_tokenize_input,
+ **self._get_custom_rendering_context_values(**kwargs),
+ })
+ return self._render_pay(rendering_context)
+
+ def _render_pay(self, rendering_context):
+ return request.render('pos_online_payment.pay', rendering_context)
+
+ @http.route('/pos/pay/transaction/', type='json', auth='public', website=True, sitemap=False)
+ def pos_order_pay_transaction(self, pos_order_id, access_token=None, **kwargs):
+ """ Behaves like payment.PaymentPortal.payment_transaction but for POS online payment.
+
+ :param int pos_order_id: The POS order to pay, as a `pos.order` id
+ :param str access_token: The access token used to verify the user
+ :param str exit_route: The URL to open to leave the POS online payment flow
+ :param dict kwargs: Data from payment module
+
+ :return: The mandatory values for the processing of the transaction
+ :rtype: dict
+ :raise: AccessError if the provided order or access token is invalid
+ :raise: ValidationError if data on the server prevents the payment
+ :raise: UserError if data provided by the user is invalid/missing
+ """
+ pos_order_sudo = self._check_order_access(pos_order_id, access_token)
+ self._ensure_session_open(pos_order_sudo)
+ exit_route = request.httprequest.args.get('exit_route')
+ user_sudo = request.env.user
+ logged_in = not user_sudo._is_public()
+ partner_sudo = self._get_partner_sudo(user_sudo)
+ if not partner_sudo:
+ return self._redirect_login()
+
+ if kwargs.get('is_validation'):
+ raise UserError(
+ _("A validation payment cannot be used for a Point of Sale online payment."))
+
+ if 'partner_id' in kwargs and kwargs['partner_id'] != partner_sudo.id:
+ raise UserError(
+ _("The provided partner_id is different than expected."))
+
+ # Don't allow passing arbitrary create values and avoid tokenization for
+ # the public user.
+ kwargs['custom_create_values'] = {
+ 'pos_order_id': pos_order_sudo.id
+ }
+ if not logged_in:
+ if kwargs.get('tokenization_requested') or kwargs.get('flow') == 'token':
+ raise UserError(
+ _("Tokenization is not available for logged off customers."))
+ kwargs['custom_create_values']['tokenize'] = False
+
+ currency_id = pos_order_sudo.currency_id
+ if not currency_id.active:
+ raise ValidationError(_("The currency is invalid."))
+ # Ignore the currency provided by the customer
+ kwargs['currency_id'] = currency_id.id
+
+ amount_to_pay = self._get_amount_to_pay(pos_order_sudo)
+ if not self._is_valid_amount(amount_to_pay, currency_id):
+ raise ValidationError(_("There is nothing to pay for this order."))
+ if tools.float_compare(kwargs['amount'], amount_to_pay, precision_rounding=currency_id.rounding) != 0:
+ raise ValidationError(
+ _("The amount to pay has changed. Please refresh the page."))
+
+ payment_option_id = kwargs.get('payment_option_id', None)
+ if not payment_option_id:
+ raise UserError(_("A payment option must be specified."))
+ flow = kwargs.get('flow')
+ if not (flow and flow in ['redirect', 'direct', 'token']):
+ raise UserError(_("The payment should either be direct, with redirection, or made by a token."))
+ providers_sudo = self._get_allowed_providers_sudo(pos_order_sudo, partner_sudo.id, amount_to_pay)
+ if flow == 'token':
+ tokens_sudo = request.env['payment.token']._get_available_tokens(
+ providers_sudo.ids, partner_sudo.id)
+ if payment_option_id not in tokens_sudo.ids:
+ raise UserError(_("The payment token is invalid."))
+ else:
+ if payment_option_id not in providers_sudo.ids:
+ raise UserError(_("The payment provider is invalid."))
+
+ kwargs['reference_prefix'] = None # Computed with pos_order_id
+ kwargs.pop('pos_order_id', None) # _create_transaction kwargs keys must be different than custom_create_values keys
+
+ tx_sudo = self._create_transaction(**kwargs)
+ tx_sudo.landing_route = self._get_landing_route(pos_order_sudo.id, access_token, exit_route_arg=self._get_exit_route_arg(exit_route), tx_id=tx_sudo.id)
+
+ return tx_sudo._get_processing_values()
+
+ @http.route('/pos/pay/confirmation/', type='http', methods=['GET'], auth='public', website=True, sitemap=False)
+ def pos_order_pay_confirmation(self, pos_order_id, tx_id=None, access_token=None, exit_route=None, **kwargs):
+ """ Behaves like payment.PaymentPortal.payment_confirm but for POS online payment.
+
+ :param int pos_order_id: The POS order to confirm, as a `pos.order` id
+ :param str tx_id: The transaction to confirm, as a `payment.transaction` id
+ :param str access_token: The access token used to verify the user
+ :param str exit_route: The URL to open to leave the POS online payment flow
+ :param dict kwargs: Data from payment module
+
+ :return: The rendered confirmation page
+ :rtype: str
+ :raise: AccessError if the provided order or access token is invalid
+ """
+ tx_id = self._cast_as_int(tx_id)
+ rendering_context = {
+ 'state': 'error',
+ 'exit_route': exit_route,
+ 'pay_route': self._get_pay_route(pos_order_id, access_token, exit_route)
+ }
+ if not tx_id or not pos_order_id:
+ return self._render_pay_confirmation(rendering_context)
+
+ pos_order_sudo = self._check_order_access(pos_order_id, access_token)
+
+ tx_sudo = request.env['payment.transaction'].sudo().search([('id', '=', tx_id)])
+ if tx_sudo.pos_order_id.id != pos_order_sudo.id:
+ return self._render_pay_confirmation(rendering_context)
+
+ rendering_context.update(
+ pos_order_id=pos_order_sudo.id,
+ order_reference=pos_order_sudo.pos_reference,
+ tx_reference=tx_sudo.reference,
+ amount=tx_sudo.amount,
+ currency=tx_sudo.currency_id,
+ provider_name=tx_sudo.provider_id.name,
+ tx=tx_sudo, # for the payment.transaction_status template
+ )
+
+ # Stop monitoring the transaction now that it reached a final state.
+ PaymentPostProcessing.remove_transactions(tx_sudo)
+
+ if tx_sudo.state not in ('authorized', 'done'):
+ rendering_context['state'] = 'tx_error'
+ return self._render_pay_confirmation(rendering_context)
+
+ tx_sudo._process_pos_online_payment()
+
+ rendering_context['state'] = 'success'
+ return self._render_pay_confirmation(rendering_context)
+
+ def _render_pay_confirmation(self, rendering_context):
+ return request.render('pos_online_payment.pay_confirmation', rendering_context)
diff --git a/addons/pos_online_payment/models/__init__.py b/addons/pos_online_payment/models/__init__.py
new file mode 100644
index 00000000000..b7b6a1abbd9
--- /dev/null
+++ b/addons/pos_online_payment/models/__init__.py
@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from . import pos_payment_method
+from . import pos_payment
+from . import account_payment
+from . import payment_transaction
+from . import pos_config
+from . import pos_order
+from . import pos_session
diff --git a/addons/pos_online_payment/models/account_payment.py b/addons/pos_online_payment/models/account_payment.py
new file mode 100644
index 00000000000..a5af8a2654e
--- /dev/null
+++ b/addons/pos_online_payment/models/account_payment.py
@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import _, fields, models
+
+
+class AccountPayment(models.Model):
+ _inherit = 'account.payment'
+
+ pos_order_id = fields.Many2one('pos.order', string='POS Order', help='The Point of Sale order linked to this payment', readonly=True)
+
+ def action_view_pos_order(self):
+ """ Return the action for the view of the pos order linked to the payment.
+ """
+ self.ensure_one()
+
+ action = {
+ 'name': _("POS Order"),
+ 'type': 'ir.actions.act_window',
+ 'res_model': 'pos.order',
+ 'target': 'current',
+ 'res_id': self.pos_order_id.id,
+ 'view_mode': 'form'
+ }
+ return action
diff --git a/addons/pos_online_payment/models/payment_transaction.py b/addons/pos_online_payment/models/payment_transaction.py
new file mode 100644
index 00000000000..7be95a6eed7
--- /dev/null
+++ b/addons/pos_online_payment/models/payment_transaction.py
@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import _, api, fields, models, tools
+from odoo.exceptions import ValidationError
+
+
+class PaymentTransaction(models.Model):
+ _inherit = 'payment.transaction'
+
+ pos_order_id = fields.Many2one('pos.order', string='POS Order', help='The Point of Sale order linked to the payment transaction', readonly=True)
+
+ @api.model
+ def _compute_reference_prefix(self, provider_code, separator, **values):
+ """ Override of payment to compute the reference prefix based on POS-specific values.
+
+ :return: The computed reference prefix if POS order id is found, the one of `super` otherwise
+ :rtype: str
+ """
+ pos_order_id = values.get('pos_order_id')
+ if pos_order_id:
+ pos_order = self.env['pos.order'].sudo().browse(pos_order_id).exists()
+ if pos_order:
+ return pos_order.pos_reference
+ return super()._compute_reference_prefix(provider_code, separator, **values)
+
+ def _set_authorized(self, state_message=None, **kwargs):
+ """ Override of payment to process POS online payments automatically. """
+ super()._set_authorized(state_message=state_message, **kwargs)
+ self._process_pos_online_payment()
+
+ def _reconcile_after_done(self):
+ """ Override of payment to process POS online payments automatically. """
+ super()._reconcile_after_done()
+ self._process_pos_online_payment()
+
+ def _process_pos_online_payment(self):
+ for tx in self:
+ if tx and tx.pos_order_id and tx.state in ('authorized', 'done') and not tx.payment_id.pos_order_id:
+ pos_order = tx.pos_order_id
+ if tools.float_compare(tx.amount, 0.0, precision_rounding=pos_order.currency_id.rounding) <= 0:
+ raise ValidationError(_('The payment transaction (%d) has a negative amount.', tx.id))
+
+ if not tx.payment_id: # the payment could already have been created by account_payment module
+ tx._create_payment()
+ if not tx.payment_id:
+ raise ValidationError(_('The POS online payment (tx.id=%d) could not be saved correctly', tx.id))
+
+ payment_method = pos_order.online_payment_method_id
+ if not payment_method:
+ pos_config = pos_order.config_id
+ payment_method = self.env['pos.payment.method'].sudo()._get_or_create_online_payment_method(pos_config.company_id.id, pos_config.id)
+ if not payment_method:
+ raise ValidationError(_('The POS online payment (tx.id=%d) could not be saved correctly because the online payment method could not be found', tx.id))
+
+ pos_order.add_payment({
+ 'amount': tx.amount,
+ 'payment_date': tx.last_state_change,
+ 'payment_method_id': payment_method.id,
+ 'online_account_payment_id': tx.payment_id.id,
+ 'pos_order_id': pos_order.id,
+ })
+ tx.payment_id.update({
+ 'pos_payment_method_id': payment_method.id,
+ 'pos_order_id': pos_order.id,
+ 'pos_session_id': pos_order.session_id.id,
+ })
+ if pos_order.state == 'draft' and pos_order._is_pos_order_paid():
+ pos_order._process_saved_order(False)
+ pos_order._send_online_payments_notification_via_bus()
+
+ def action_view_pos_order(self):
+ """ Return the action for the view of the pos order linked to the transaction.
+ """
+ self.ensure_one()
+
+ action = {
+ 'name': _("POS Order"),
+ 'type': 'ir.actions.act_window',
+ 'res_model': 'pos.order',
+ 'target': 'current',
+ 'res_id': self.pos_order_id.id,
+ 'view_mode': 'form'
+ }
+ return action
diff --git a/addons/pos_online_payment/models/pos_config.py b/addons/pos_online_payment/models/pos_config.py
new file mode 100644
index 00000000000..7cbee7b8161
--- /dev/null
+++ b/addons/pos_online_payment/models/pos_config.py
@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import models, api, _
+from odoo.exceptions import ValidationError
+
+
+class PosConfig(models.Model):
+ _inherit = 'pos.config'
+
+ @api.constrains('payment_method_ids')
+ def _check_online_payment_methods(self):
+ """ Checks the journal currency with _get_online_payment_providers(..., error_if_invalid=True)"""
+ for config in self:
+ opm_amount = 0
+ for pm in config.payment_method_ids:
+ if pm.is_online_payment:
+ opm_amount += 1
+ if opm_amount > 1:
+ raise ValidationError(_("A POS config cannot have more than one online payment method."))
+ if not pm._get_online_payment_providers(config.id, error_if_invalid=True):
+ raise ValidationError(_("To use an online payment method in a POS config, it must have at least one published payment provider supporting the currency of that POS config."))
+
+ def _get_cashier_online_payment_method(self):
+ self.ensure_one()
+ return self.payment_method_ids.filtered('is_online_payment')[:1]
diff --git a/addons/pos_online_payment/models/pos_order.py b/addons/pos_online_payment/models/pos_order.py
new file mode 100644
index 00000000000..b5d1810f67a
--- /dev/null
+++ b/addons/pos_online_payment/models/pos_order.py
@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import models, fields, api, tools
+
+
+class PosOrder(models.Model):
+ _inherit = 'pos.order'
+
+ online_payment_method_id = fields.Many2one('pos.payment.method', compute="_compute_online_payment_method_id")
+ next_online_payment_amount = fields.Float(string='Next online payment amount to pay', states={'draft': [('readonly', False)]}, readonly=True, digits=0, required=False) # unlimited precision
+
+ @api.depends('config_id.payment_method_ids')
+ def _compute_online_payment_method_id(self):
+ for order in self:
+ order.online_payment_method_id = order.config_id._get_cashier_online_payment_method()
+
+ def get_amount_unpaid(self):
+ self.ensure_one()
+ return self.currency_id.round(self._get_rounded_amount(self.amount_total) - self.amount_paid)
+
+ def _clean_payment_lines(self):
+ self.ensure_one()
+ order_payments = self.env['pos.payment'].search(['&', ('pos_order_id', '=', self.id), ('online_account_payment_id', '=', False)])
+ order_payments.unlink()
+
+ def get_and_set_online_payments_data(self, next_online_payment_amount=False):
+ """ Allows to update the amount to pay for the next online payment and
+ get online payments already made and how much remains to be paid.
+ If next_online_payment_amount is different than False, updates the
+ next online payment amount, otherwise, the next online payment amount
+ is unchanged.
+ If next_online_payment_amount is 0 and the order has no successful
+ online payment, is in draft state, is not a restaurant order and the
+ pos.config has no trusted config, then the order is deleted from the
+ database, because it was probably added for the online payment flow.
+ """
+ self.ensure_one()
+ is_paid = self.state in ('paid', 'done', 'invoiced')
+ if is_paid:
+ return {
+ 'id': self.id,
+ 'paid_order': self._export_for_ui(self)
+ }
+
+ online_payments = self.sudo().env['pos.payment'].search_read(domain=['&', ('pos_order_id', '=', self.id), ('online_account_payment_id', '!=', False)], fields=['payment_method_id', 'amount'], load=False)
+ return_data = {
+ 'id': self.id,
+ 'online_payments': online_payments,
+ 'amount_unpaid': self.get_amount_unpaid(),
+ }
+ if not isinstance(next_online_payment_amount, bool):
+ if tools.float_is_zero(next_online_payment_amount, precision_rounding=self.currency_id.rounding) and len(online_payments) == 0 and self.state == 'draft' and not self.config_id.module_pos_restaurant and len(self.config_id.trusted_config_ids) == 0:
+ self.sudo()._clean_payment_lines() # Needed to delete the order
+ self.sudo().unlink()
+ return_data['deleted'] = True
+ elif self._check_next_online_payment_amount(next_online_payment_amount):
+ self.next_online_payment_amount = next_online_payment_amount
+
+ return return_data
+
+ def _send_online_payments_notification_via_bus(self):
+ self.ensure_one()
+ # The bus communication is only protected by the name of the channel.
+ # Therefore, no sensitive information is sent through it, only a
+ # notification to invite the local browser to do a safe RPC to
+ # the server to check the new state of the order.
+ self.env['bus.bus']._sendone(self.session_id._get_bus_channel_name(), 'ONLINE_PAYMENTS_NOTIFICATION', {'id': self.id})
+
+ def _check_next_online_payment_amount(self, amount):
+ self.ensure_one()
+ return tools.float_compare(amount, 0.0, precision_rounding=self.currency_id.rounding) >= 0 and tools.float_compare(amount, self.get_amount_unpaid(), precision_rounding=self.currency_id.rounding) <= 0
+
+ def _get_checked_next_online_payment_amount(self):
+ self.ensure_one()
+ amount = self.next_online_payment_amount
+ return amount if self._check_next_online_payment_amount(amount) else False
diff --git a/addons/pos_online_payment/models/pos_payment.py b/addons/pos_online_payment/models/pos_payment.py
new file mode 100644
index 00000000000..230c520a939
--- /dev/null
+++ b/addons/pos_online_payment/models/pos_payment.py
@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import logging
+from odoo import api, fields, models
+from odoo.exceptions import UserError
+
+_logger = logging.getLogger(__name__)
+
+
+class PosPayment(models.Model):
+ _inherit = 'pos.payment'
+
+ online_account_payment_id = fields.Many2one('account.payment', string='Online accounting payment', readonly=True) # One2one
+
+ @api.model_create_multi
+ def create(self, vals_list):
+ online_account_payments_by_pm = {}
+ for vals in vals_list:
+ pm_id = vals['payment_method_id']
+ if pm_id not in online_account_payments_by_pm:
+ online_account_payments_by_pm[pm_id] = set()
+ online_account_payments_by_pm[pm_id].add(vals.get('online_account_payment_id'))
+
+ opms_read_id = self.env['pos.payment.method'].search_read(['&', ('id', 'in', list(online_account_payments_by_pm.keys())), ('is_online_payment', '=', True)], ["id"])
+ opms_id = {opm_read_id['id'] for opm_read_id in opms_read_id}
+ online_account_payments_to_check_id = set()
+
+ for pm_id, oaps_id in online_account_payments_by_pm.items():
+ if pm_id in opms_id:
+ if None in oaps_id:
+ raise UserError("Cannot create a POS online payment without an accounting payment.")
+ else:
+ online_account_payments_to_check_id.update(oaps_id)
+ elif any(oaps_id):
+ raise UserError("Cannot create a POS payment with a not online payment method and an online accounting payment.")
+
+ if online_account_payments_to_check_id:
+ valid_oap_amount = self.env['account.payment'].search_count([('id', 'in', list(online_account_payments_to_check_id))])
+ if valid_oap_amount != len(online_account_payments_to_check_id):
+ raise UserError("Cannot create a POS online payment without an accounting payment.")
+
+ return super().create(vals_list)
+
+ def write(self, vals):
+ if vals.keys() & ('amount', 'payment_date', 'payment_method_id', 'online_account_payment_id', 'pos_order_id') and any(payment.online_account_payment_id or payment.payment_method_id.is_online_payment for payment in self):
+ raise UserError("Cannot edit a POS online payment essential data.")
+ return super().write(vals)
+
+ @api.constrains('payment_method_id')
+ def _check_payment_method_id(self):
+ bypass_check_payments = self.filtered('payment_method_id.is_online_payment')
+ if any(payment.payment_method_id != payment.pos_order_id.online_payment_method_id for payment in bypass_check_payments):
+ # An online payment must always be saved for the POS, even if the online payment method is no longer configured/allowed in the pos.config, because in any case it is saved by account_payment and payment modules.
+ _logger.warning("Allow to save a POS online payment with an unexpected online payment method")
+
+ super(PosPayment, self - bypass_check_payments)._check_payment_method_id()
diff --git a/addons/pos_online_payment/models/pos_payment_method.py b/addons/pos_online_payment/models/pos_payment_method.py
new file mode 100644
index 00000000000..cd8841b902e
--- /dev/null
+++ b/addons/pos_online_payment/models/pos_payment_method.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, fields, models, _
+from odoo.exceptions import ValidationError
+
+
+class PosPaymentMethod(models.Model):
+ _inherit = "pos.payment.method"
+
+ is_online_payment = fields.Boolean(string="Online Payment", help="Use this payment method for online payments (payments made on a web page with online payment providers)", default=False)
+ online_payment_provider_ids = fields.Many2many('payment.provider', string="Allowed Providers", domain="[('is_published', '=', True), ('state', 'in', ['enabled', 'test'])]")
+ has_an_online_payment_provider = fields.Boolean(compute='_compute_has_an_online_payment_provider', readonly=True)
+ type = fields.Selection(selection_add=[('online', 'Online')])
+
+ @api.depends('is_online_payment')
+ def _compute_type(self):
+ opm = self.filtered('is_online_payment')
+ if opm:
+ opm.type = 'online'
+
+ super(PosPaymentMethod, self - opm)._compute_type()
+
+ def _get_online_payment_providers(self, pos_config_id=False, error_if_invalid=True):
+ self.ensure_one()
+ providers_sudo = self.sudo().online_payment_provider_ids
+ if not providers_sudo: # Empty = all published providers
+ providers_sudo = self.sudo().env['payment.provider'].search([('is_published', '=', True), ('state', 'in', ['enabled', 'test'])])
+
+ if not pos_config_id:
+ return providers_sudo
+
+ config_currency = self.sudo().env['pos.config'].browse(pos_config_id).currency_id
+ valid_providers = providers_sudo.filtered(lambda p: not p.journal_id.currency_id or p.journal_id.currency_id == config_currency)
+ if error_if_invalid and len(providers_sudo) != len(valid_providers):
+ raise ValidationError(_("All payment providers configured for an online payment method must use the same currency as the Sales Journal, or the company currency if that is not set, of the POS config."))
+ return valid_providers
+
+ @api.depends('is_online_payment', 'online_payment_provider_ids')
+ def _compute_has_an_online_payment_provider(self):
+ for pm in self:
+ if pm.is_online_payment:
+ pm.has_an_online_payment_provider = bool(pm._get_online_payment_providers())
+ else:
+ pm.has_an_online_payment_provider = False
+
+ def _is_write_forbidden(self, fields):
+ return super(PosPaymentMethod, self)._is_write_forbidden(fields - {'online_payment_provider_ids'})
+
+ @api.model_create_multi
+ def create(self, vals_list):
+ for vals in vals_list:
+ if vals.get('is_online_payment', False):
+ self._force_online_payment_values(vals)
+ return super().create(vals_list)
+
+ def write(self, vals):
+ if 'is_online_payment' in vals:
+ if vals['is_online_payment']:
+ self._force_online_payment_values(vals)
+ return super().write(vals)
+
+ opm = self.filtered('is_online_payment')
+ not_opm = self - opm
+
+ res = True
+ if opm:
+ forced_vals = vals.copy()
+ self._force_online_payment_values(forced_vals, True)
+ res = super(PosPaymentMethod, opm).write(forced_vals) and res
+ if not_opm:
+ res = super(PosPaymentMethod, not_opm).write(vals) and res
+
+ return res
+
+ @staticmethod
+ def _force_online_payment_values(vals, if_present=False):
+ if 'type' in vals:
+ vals['type'] = 'online'
+
+ disabled_fields_name = ('split_transactions', 'receivable_account_id', 'outstanding_account_id', 'journal_id', 'is_cash_count', 'use_payment_terminal')
+ if if_present:
+ for name in disabled_fields_name:
+ if name in vals:
+ vals[name] = False
+ else:
+ for name in disabled_fields_name:
+ vals[name] = False
+
+ def _get_payment_terminal_selection(self):
+ return super(PosPaymentMethod, self)._get_payment_terminal_selection() if not self.is_online_payment else []
+
+ @api.depends('type')
+ def _compute_hide_use_payment_terminal(self):
+ opm = self.filtered(lambda pm: pm.type == 'online')
+ if opm:
+ opm.hide_use_payment_terminal = True
+ super(PosPaymentMethod, self - opm)._compute_hide_use_payment_terminal()
+
+ @api.model
+ def _get_or_create_online_payment_method(self, company_id, pos_config_id):
+ """ Get the first online payment method compatible with the provided pos.config.
+ If there isn't any, try to find an existing one in the same company and return it without adding the pos.config to it.
+ If there is not, create a new one for the company and return it without adding the pos.config to it.
+ """
+ # Parameters are ids instead of a pos.config record because this method can be called from a web controller or internally
+ payment_method_id = self.env['pos.payment.method'].search([('is_online_payment', '=', True), ('company_id', '=', company_id), ('config_ids', 'in', pos_config_id)], limit=1).exists()
+ if not payment_method_id:
+ payment_method_id = self.env['pos.payment.method'].search([('is_online_payment', '=', True), ('company_id', '=', company_id)], limit=1).exists()
+ if not payment_method_id:
+ payment_method_id = self.env['pos.payment.method'].create({
+ 'name': 'Online Payment',
+ 'is_online_payment': True,
+ 'company_id': company_id,
+ })
+ if not payment_method_id:
+ raise ValidationError('Could not create an online payment method (company_id=%d, pos_config_id=%d)' % (company_id, pos_config_id))
+ return payment_method_id
diff --git a/addons/pos_online_payment/models/pos_session.py b/addons/pos_online_payment/models/pos_session.py
new file mode 100644
index 00000000000..2c8d015566f
--- /dev/null
+++ b/addons/pos_online_payment/models/pos_session.py
@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from collections import defaultdict
+from odoo import models, tools, _
+from odoo.exceptions import UserError
+
+
+class PosSession(models.Model):
+ _inherit = 'pos.session'
+
+ def _loader_params_pos_payment_method(self):
+ result = super()._loader_params_pos_payment_method()
+ result['search_params']['fields'].append('is_online_payment')
+ return result
+
+ def _accumulate_amounts(self, data):
+ data = super()._accumulate_amounts(data)
+ amounts = lambda: {'amount': 0.0, 'amount_converted': 0.0}
+
+ split_receivables_online = defaultdict(amounts)
+ currency_rounding = self.currency_id.rounding
+ for order in self.order_ids:
+ for payment in order.payment_ids:
+ amount = payment.amount
+ if tools.float_is_zero(amount, precision_rounding=currency_rounding):
+ continue
+ date = payment.payment_date
+ payment_method = payment.payment_method_id
+ payment_type = payment_method.type
+
+ if payment_type == 'online':
+ split_receivables_online[payment] = self._update_amounts(split_receivables_online[payment], {'amount': amount}, date)
+
+ data.update({'split_receivables_online': split_receivables_online,})
+ return data
+
+ def _create_bank_payment_moves(self, data):
+ data = super()._create_bank_payment_moves(data)
+
+ split_receivables_online = data.get('split_receivables_online')
+ MoveLine = data.get('MoveLine')
+
+ online_payment_to_receivable_lines = {}
+
+ for payment, amounts in split_receivables_online.items():
+ split_receivable_line = MoveLine.create(self._get_split_receivable_op_vals(payment, amounts['amount'], amounts['amount_converted']))
+ account_payment = payment.online_account_payment_id
+ payment_receivable_line = account_payment.move_id.line_ids.filtered(lambda line: line.account_id == account_payment.destination_account_id)
+ online_payment_to_receivable_lines[payment] = split_receivable_line | payment_receivable_line
+
+ data['online_payment_to_receivable_lines'] = online_payment_to_receivable_lines
+ return data
+
+ def _get_split_receivable_op_vals(self, payment, amount, amount_converted):
+ partner = payment.online_account_payment_id.partner_id
+ accounting_partner = self.env["res.partner"]._find_accounting_partner(partner)
+ if not accounting_partner:
+ raise UserError(_("The partner of the POS online payment (id=%d) could not be found") % (payment.id))
+ partial_vals = {
+ 'account_id': accounting_partner.property_account_receivable_id.id,
+ 'move_id': self.move_id.id,
+ 'partner_id': accounting_partner.id,
+ 'name': '%s - %s (%s)' % (self.name, payment.payment_method_id.name, payment.online_account_payment_id.payment_method_line_id.payment_provider_id.name),
+ }
+ return self._debit_amounts(partial_vals, amount, amount_converted)
+
+ def _reconcile_account_move_lines(self, data):
+ data = super()._reconcile_account_move_lines(data)
+ online_payment_to_receivable_lines = data.get('online_payment_to_receivable_lines')
+
+ for payment, lines in online_payment_to_receivable_lines.items():
+ if payment.online_account_payment_id.partner_id.property_account_receivable_id.reconcile:
+ lines.filtered(lambda line: not line.reconciled).reconcile()
+
+ return data
diff --git a/addons/pos_online_payment/static/src/app/bus/pos_bus_service.js b/addons/pos_online_payment/static/src/app/bus/pos_bus_service.js
new file mode 100644
index 00000000000..2bedd17b6a2
--- /dev/null
+++ b/addons/pos_online_payment/static/src/app/bus/pos_bus_service.js
@@ -0,0 +1,22 @@
+/** @odoo-module */
+
+import { patch } from "@web/core/utils/patch";
+import { PosBus } from "@point_of_sale/app/bus/pos_bus_service";
+
+patch(PosBus.prototype, "pos_online_payment.PosBus", {
+ //@override
+ dispatch(message) {
+ this._super(...arguments);
+
+ if (message.type === "ONLINE_PAYMENTS_NOTIFICATION") {
+ // The bus communication is only protected by the name of the channel.
+ // Therefore, no sensitive information is sent through it, only a
+ // notification to invite the local browser to do a safe RPC to
+ // the server to check the new state of the order.
+ const currentOrder = this.pos.get_order();
+ if (currentOrder && currentOrder.server_id === message.payload.id) {
+ currentOrder.update_online_payments_data_with_server(this.orm, false);
+ }
+ }
+ },
+});
diff --git a/addons/pos_online_payment/static/src/app/customer_display/customer_display_template.xml b/addons/pos_online_payment/static/src/app/customer_display/customer_display_template.xml
new file mode 100644
index 00000000000..8afa0fdc73f
--- /dev/null
+++ b/addons/pos_online_payment/static/src/app/customer_display/customer_display_template.xml
@@ -0,0 +1,42 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Please scan the QR code to open the payment page
+
+
+
+
+
+
+ Amount:
+
+
+
+ Order reference:
+
+
+
+ Order id:
+
+
+
+
+
+
+
+
Order Reference:
+
+
+
Order id:
+
+
+
+ Error: The currency is missing or invalid.
+
+ There is nothing to pay.
+
+
+ No suitable payment option could be found.
If you believe that it is an error, please contact the website administrator.
+
+ Amount:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Error: There was a problem during the payment process.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Processed by
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ pos.payment.method.tree.inherit.pos_online_payment
+ pos.payment.method
+
+
+
+ is_online_payment and not has_an_online_payment_provider
+
+
+
+
+
+
+
+
diff --git a/addons/pos_online_payment/views/pos_payment_views.xml b/addons/pos_online_payment/views/pos_payment_views.xml
new file mode 100644
index 00000000000..e9ad30217f8
--- /dev/null
+++ b/addons/pos_online_payment/views/pos_payment_views.xml
@@ -0,0 +1,13 @@
+
+
+
+ pos.payment.form
+ pos.payment
+
+
+
+
+
+
+
+
diff --git a/addons/pos_restaurant/models/pos_order.py b/addons/pos_restaurant/models/pos_order.py
index 372acd8af2f..9ab46c6289b 100644
--- a/addons/pos_restaurant/models/pos_order.py
+++ b/addons/pos_restaurant/models/pos_order.py
@@ -61,18 +61,15 @@ class PosOrder(models.Model):
self.send_table_count_notification(tables)
return order_ids
- @api.model
- def create_from_ui(self, orders, draft=False):
- orders = super().create_from_ui(orders, draft)
- order_ids = self.env['pos.order'].browse([order['id'] for order in orders])
- self.send_table_count_notification(order_ids.table_id)
- return orders
+ def _process_saved_order(self, draft):
+ order_id = super()._process_saved_order(draft)
+ self.send_table_count_notification(self.table_id)
+ return order_id
def send_table_count_notification(self, table_ids):
messages = []
for config in self.env['pos.config'].search([('floor_ids', 'in', table_ids.floor_id.ids)]):
config_cur_session = config.current_session_id
-
if config_cur_session:
order_count = config.get_tables_order_count_and_printing_changes()
messages.append((config_cur_session._get_bus_channel_name(), 'TABLE_ORDER_COUNT', order_count))