Antoine Vandevenne (anv)
b7181334a9
The alert block content and style for the transaction status after payment were computed in two different places: In the dedicated `payment.transaction_status` QWeb template, and in the /payment/confirmation` route's controller which, for some reason, was re-inventing the wheel instead of relying on the dedicated template. This commit combines the slightly different behaviors in the template and gets rid of the duplicated logic in the controller to: - Handle the states 'draft' and 'error'. - Always show the transaction's state message, and not only when the transaction was in a state for which there exists no pre-defined message (`draft` and `error`). task-2924873 closes odoo/odoo#96348 Signed-off-by: Antoine Vandevenne (anv) <anv@odoo.com>
464 lines
23 KiB
Python
464 lines
23 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import urllib.parse
|
|
import werkzeug
|
|
|
|
from odoo import _, http
|
|
from odoo.exceptions import AccessError, UserError, ValidationError
|
|
from odoo.fields import Command
|
|
from odoo.http import request
|
|
|
|
from odoo.addons.payment import utils as payment_utils
|
|
from odoo.addons.payment.controllers.post_processing import PaymentPostProcessing
|
|
from odoo.addons.portal.controllers import portal
|
|
|
|
|
|
class PaymentPortal(portal.CustomerPortal):
|
|
|
|
""" This controller contains the foundations for online payments through the portal.
|
|
|
|
It allows to complete a full payment flow without the need of going though a document-based flow
|
|
made available by another module's controller.
|
|
|
|
Such controllers should extend this one to gain access to the _create_transaction static method
|
|
that implements the creation of a transaction before its processing, or to override specific
|
|
routes and change their behavior globally (e.g. make the /pay route handle sale orders).
|
|
|
|
The following routes are exposed:
|
|
- `/payment/pay` allows for arbitrary payments.
|
|
- `/my/payment_method` allows the user to create and delete tokens. It's its own `landing_route`
|
|
- `/payment/transaction` is the `transaction_route` for the standard payment flow. It creates a
|
|
draft transaction, and return the processing values necessary for the completion of the
|
|
transaction.
|
|
- `/payment/confirmation` is the `landing_route` for the standard payment flow. It displays the
|
|
payment confirmation page to the user when the transaction is validated.
|
|
"""
|
|
|
|
@http.route(
|
|
'/payment/pay', type='http', methods=['GET'], auth='public', website=True, sitemap=False,
|
|
)
|
|
def payment_pay(
|
|
self, reference=None, amount=None, currency_id=None, partner_id=None, company_id=None,
|
|
acquirer_id=None, access_token=None, invoice_id=None, **kwargs
|
|
):
|
|
""" Display the payment form with optional filtering of payment options.
|
|
|
|
The filtering takes place on the basis of provided parameters, if any. If a parameter is
|
|
incorrect or malformed, it is skipped to avoid preventing the user from making the payment.
|
|
|
|
In addition to the desired filtering, a second one ensures that none of the following
|
|
rules is broken:
|
|
- Public users are not allowed to save their payment method as a token.
|
|
- Payments made by public users should either *not* be made on behalf of a specific
|
|
partner or have an access token validating the partner, amount and currency.
|
|
We let access rights and security rules do their job for logged in users.
|
|
|
|
:param str reference: The custom prefix to compute the full reference
|
|
:param str amount: The amount to pay
|
|
:param str currency_id: The desired currency, as a `res.currency` id
|
|
:param str partner_id: The partner making the payment, as a `res.partner` id
|
|
:param str company_id: The related company, as a `res.company` id
|
|
:param str acquirer_id: The desired acquirer, as a `payment.acquirer` id
|
|
:param str access_token: The access token used to authenticate the partner
|
|
:param str invoice_id: The account move for which a payment id made, as a `account.move` id
|
|
:param dict kwargs: Optional data passed to helper methods.
|
|
:return: The rendered checkout form
|
|
:rtype: str
|
|
:raise: werkzeug.exceptions.NotFound if the access token is invalid
|
|
"""
|
|
# Cast numeric parameters as int or float and void them if their str value is malformed
|
|
currency_id, acquirer_id, partner_id, company_id, invoice_id = tuple(map(
|
|
self._cast_as_int, (currency_id, acquirer_id, partner_id, company_id, invoice_id)
|
|
))
|
|
amount = self._cast_as_float(amount)
|
|
|
|
# Raise an HTTP 404 if a partner is provided with an invalid access token
|
|
if partner_id:
|
|
if not payment_utils.check_access_token(access_token, partner_id, amount, currency_id):
|
|
raise werkzeug.exceptions.NotFound # Don't leak info about the existence of an id
|
|
|
|
user_sudo = request.env.user
|
|
logged_in = not user_sudo._is_public()
|
|
# If the user is logged in, take their partner rather than the partner set in the params.
|
|
# This is something that we want, since security rules are based on the partner, and created
|
|
# tokens should not be assigned to the public user. This should have no impact on the
|
|
# transaction itself besides making reconciliation possibly more difficult (e.g. The
|
|
# transaction and invoice partners are different).
|
|
partner_is_different = False
|
|
if logged_in:
|
|
partner_is_different = partner_id and partner_id != user_sudo.partner_id.id
|
|
partner_sudo = user_sudo.partner_id
|
|
else:
|
|
partner_sudo = request.env['res.partner'].sudo().browse(partner_id).exists()
|
|
if not partner_sudo:
|
|
return request.redirect(
|
|
# Escape special characters to avoid loosing original params when redirected
|
|
f'/web/login?redirect={urllib.parse.quote(request.httprequest.full_path)}'
|
|
)
|
|
|
|
# Instantiate transaction values to their default if not set in parameters
|
|
reference = reference or payment_utils.singularize_reference_prefix(prefix='tx')
|
|
amount = amount or 0.0 # If the amount is invalid, set it to 0 to stop the payment flow
|
|
company_id = company_id or partner_sudo.company_id.id or user_sudo.company_id.id
|
|
company = request.env['res.company'].sudo().browse(company_id)
|
|
currency_id = currency_id or company.currency_id.id
|
|
|
|
if invoice_id:
|
|
invoice_sudo = request.env['account.move'].sudo().browse(invoice_id).exists()
|
|
if not invoice_sudo:
|
|
raise ValidationError(_("The provided parameters are invalid."))
|
|
|
|
# Interrupt the payment flow if the invoice has been canceled.
|
|
if invoice_sudo.state == 'cancel':
|
|
amount = 0.0
|
|
|
|
# Make sure that the company passed as parameter matches the partner's company.
|
|
PaymentPortal._ensure_matching_companies(partner_sudo, company)
|
|
|
|
# Make sure that the currency exists and is active
|
|
currency = request.env['res.currency'].browse(currency_id).exists()
|
|
if not currency or not currency.active:
|
|
raise werkzeug.exceptions.NotFound # The currency must exist and be active
|
|
|
|
# Select all acquirers and tokens that match the constraints
|
|
acquirers_sudo = request.env['payment.acquirer'].sudo()._get_compatible_acquirers(
|
|
company_id, partner_sudo.id, amount, currency_id=currency.id, **kwargs
|
|
) # In sudo mode to read the fields of acquirers and partner (if not logged in)
|
|
if acquirer_id in acquirers_sudo.ids: # Only keep the desired acquirer if it's suitable
|
|
acquirers_sudo = acquirers_sudo.browse(acquirer_id)
|
|
payment_tokens = request.env['payment.token'].search(
|
|
[('acquirer_id', 'in', acquirers_sudo.ids), ('partner_id', '=', partner_sudo.id)]
|
|
) if logged_in else request.env['payment.token']
|
|
|
|
# Compute the fees taken by acquirers supporting the feature
|
|
fees_by_acquirer = {
|
|
acq_sudo: acq_sudo._compute_fees(amount, currency, partner_sudo.country_id)
|
|
for acq_sudo in acquirers_sudo.filtered('fees_active')
|
|
}
|
|
|
|
# Generate a new access token in case the partner id or the currency id was updated
|
|
access_token = payment_utils.generate_access_token(partner_sudo.id, amount, currency.id)
|
|
|
|
rendering_context = {
|
|
'acquirers': acquirers_sudo,
|
|
'tokens': payment_tokens,
|
|
'fees_by_acquirer': fees_by_acquirer,
|
|
'show_tokenize_input': self._compute_show_tokenize_input_mapping(
|
|
acquirers_sudo, logged_in=logged_in, **kwargs
|
|
),
|
|
'reference_prefix': reference,
|
|
'amount': amount,
|
|
'currency': currency,
|
|
'partner_id': partner_sudo.id,
|
|
'access_token': access_token,
|
|
'transaction_route': '/payment/transaction',
|
|
'landing_route': '/payment/confirmation',
|
|
'res_company': company, # Display the correct logo in a multi-company environment
|
|
'partner_is_different': partner_is_different,
|
|
'invoice_id': invoice_id,
|
|
**self._get_custom_rendering_context_values(**kwargs),
|
|
}
|
|
return request.render(self._get_payment_page_template_xmlid(**kwargs), rendering_context)
|
|
|
|
@staticmethod
|
|
def _compute_show_tokenize_input_mapping(acquirers_sudo, logged_in=False, **kwargs):
|
|
""" Determine for each acquirer whether the tokenization input should be shown or not.
|
|
|
|
:param recordset acquirers_sudo: The acquirers for which to determine whether the
|
|
tokenization input should be shown or not, as a sudoed
|
|
`payment.acquirer` recordset.
|
|
:param bool logged_in: Whether the user is logged in or not.
|
|
:param dict kwargs: The optional data passed to the helper methods.
|
|
:return: The mapping of the computed value for each acquirer id.
|
|
:rtype: dict
|
|
"""
|
|
show_tokenize_input_mapping = {}
|
|
for acquirer_sudo in acquirers_sudo:
|
|
show_tokenize_input = acquirer_sudo.allow_tokenization \
|
|
and not acquirer_sudo._is_tokenization_required(**kwargs) \
|
|
and logged_in
|
|
show_tokenize_input_mapping[acquirer_sudo.id] = show_tokenize_input
|
|
return show_tokenize_input_mapping
|
|
|
|
def _get_payment_page_template_xmlid(self, **kwargs):
|
|
return 'payment.pay'
|
|
|
|
@http.route('/my/payment_method', type='http', methods=['GET'], auth='user', website=True)
|
|
def payment_method(self, **kwargs):
|
|
""" Display the form to manage payment methods.
|
|
|
|
:param dict kwargs: Optional data. This parameter is not used here
|
|
:return: The rendered manage form
|
|
:rtype: str
|
|
"""
|
|
partner_sudo = request.env.user.partner_id # env.user is always sudoed
|
|
acquirers_sudo = request.env['payment.acquirer'].sudo()._get_compatible_acquirers(
|
|
request.env.company.id,
|
|
partner_sudo.id,
|
|
0., # There is no amount to pay with validation transactions.
|
|
force_tokenization=True,
|
|
is_validation=True,
|
|
)
|
|
|
|
# Get all partner's tokens for which acquirers are not disabled.
|
|
tokens_sudo = request.env['payment.token'].sudo().search([
|
|
('partner_id', 'in', [partner_sudo.id, partner_sudo.commercial_partner_id.id]),
|
|
('acquirer_id.state', 'in', ['enabled', 'test']),
|
|
])
|
|
|
|
access_token = payment_utils.generate_access_token(partner_sudo.id, None, None)
|
|
rendering_context = {
|
|
'acquirers': acquirers_sudo,
|
|
'tokens': tokens_sudo,
|
|
'reference_prefix': payment_utils.singularize_reference_prefix(prefix='V'),
|
|
'partner_id': partner_sudo.id,
|
|
'access_token': access_token,
|
|
'transaction_route': '/payment/transaction',
|
|
'landing_route': '/my/payment_method',
|
|
**self._get_custom_rendering_context_values(**kwargs),
|
|
}
|
|
return request.render('payment.payment_methods', rendering_context)
|
|
|
|
def _get_custom_rendering_context_values(self, **kwargs):
|
|
""" Return a dict of additional rendering context values.
|
|
|
|
:param dict kwargs: Optional data. This parameter is not used here
|
|
:return: The dict of additional rendering context values
|
|
:rtype: dict
|
|
"""
|
|
return {}
|
|
|
|
@http.route('/payment/transaction', type='json', auth='public')
|
|
def payment_transaction(self, amount, currency_id, partner_id, access_token, **kwargs):
|
|
""" Create a draft transaction and return its processing values.
|
|
|
|
:param float|None amount: The amount to pay in the given currency.
|
|
None if in a payment method validation operation
|
|
:param int|None currency_id: The currency of the transaction, as a `res.currency` id.
|
|
None if in a payment method validation operation
|
|
:param int partner_id: The partner making the payment, as a `res.partner` id
|
|
:param str access_token: The access token used to authenticate the partner
|
|
:param dict kwargs: Locally unused data passed to `_create_transaction`
|
|
:return: The mandatory values for the processing of the transaction
|
|
:rtype: dict
|
|
:raise: ValidationError if the access token is invalid
|
|
"""
|
|
# Check the access token against the transaction values
|
|
amount = amount and float(amount) # Cast as float in case the JS stripped the '.0'
|
|
if not payment_utils.check_access_token(access_token, partner_id, amount, currency_id):
|
|
raise ValidationError(_("The access token is invalid."))
|
|
|
|
kwargs.pop('custom_create_values', None) # Don't allow passing arbitrary create values
|
|
tx_sudo = self._create_transaction(
|
|
amount=amount, currency_id=currency_id, partner_id=partner_id, **kwargs
|
|
)
|
|
self._update_landing_route(tx_sudo, access_token) # Add the required parameters to the route
|
|
return tx_sudo._get_processing_values()
|
|
|
|
def _create_transaction(
|
|
self, payment_option_id, reference_prefix, amount, currency_id, partner_id, flow,
|
|
tokenization_requested, landing_route, is_validation=False, invoice_id=None,
|
|
custom_create_values=None, **kwargs
|
|
):
|
|
""" Create a draft transaction based on the payment context and return it.
|
|
|
|
:param int payment_option_id: The payment option handling the transaction, as a
|
|
`payment.acquirer` id or a `payment.token` id
|
|
:param str reference_prefix: The custom prefix to compute the full reference
|
|
:param float|None amount: The amount to pay in the given currency.
|
|
None if in a payment method validation operation
|
|
:param int|None currency_id: The currency of the transaction, as a `res.currency` id.
|
|
None if in a payment method validation operation
|
|
:param int partner_id: The partner making the payment, as a `res.partner` id
|
|
:param str flow: The online payment flow of the transaction: 'redirect', 'direct' or 'token'
|
|
:param bool tokenization_requested: Whether the user requested that a token is created
|
|
:param str landing_route: The route the user is redirected to after the transaction
|
|
:param bool is_validation: Whether the operation is a validation
|
|
:param int invoice_id: The account move for which a payment id made, as an `account.move` id
|
|
:param dict custom_create_values: Additional create values overwriting the default ones
|
|
:param dict kwargs: Locally unused data passed to `_is_tokenization_required` and
|
|
`_compute_reference`
|
|
:return: The sudoed transaction that was created
|
|
:rtype: recordset of `payment.transaction`
|
|
:raise: UserError if the flow is invalid
|
|
"""
|
|
# Prepare create values
|
|
if flow in ['redirect', 'direct']: # Direct payment or payment with redirection
|
|
acquirer_sudo = request.env['payment.acquirer'].sudo().browse(payment_option_id)
|
|
token_id = None
|
|
tokenize = bool(
|
|
# Don't tokenize if the user tried to force it through the browser's developer tools
|
|
acquirer_sudo.allow_tokenization
|
|
# Token is only created if required by the flow or requested by the user
|
|
and (acquirer_sudo._is_tokenization_required(**kwargs) or tokenization_requested)
|
|
)
|
|
elif flow == 'token': # Payment by token
|
|
token_sudo = request.env['payment.token'].sudo().browse(payment_option_id)
|
|
|
|
# Prevent from paying with a token that doesn't belong to the current partner (either
|
|
# the current user's partner if logged in, or the partner on behalf of whom the payment
|
|
# is being made).
|
|
partner_sudo = request.env['res.partner'].sudo().browse(partner_id)
|
|
if partner_sudo.commercial_partner_id != token_sudo.partner_id.commercial_partner_id:
|
|
raise AccessError(_("You do not have access to this payment token."))
|
|
|
|
acquirer_sudo = token_sudo.acquirer_id
|
|
token_id = payment_option_id
|
|
tokenize = False
|
|
else:
|
|
raise UserError(
|
|
_("The payment should either be direct, with redirection, or made by a token.")
|
|
)
|
|
|
|
if invoice_id:
|
|
if custom_create_values is None:
|
|
custom_create_values = {}
|
|
custom_create_values['invoice_ids'] = [Command.set([int(invoice_id)])]
|
|
|
|
reference = request.env['payment.transaction']._compute_reference(
|
|
acquirer_sudo.provider,
|
|
prefix=reference_prefix,
|
|
**(custom_create_values or {}),
|
|
**kwargs
|
|
)
|
|
if is_validation: # Acquirers determine the amount and currency in validation operations
|
|
amount = acquirer_sudo._get_validation_amount()
|
|
currency_id = acquirer_sudo._get_validation_currency().id
|
|
|
|
# Create the transaction
|
|
tx_sudo = request.env['payment.transaction'].sudo().create({
|
|
'acquirer_id': acquirer_sudo.id,
|
|
'reference': reference,
|
|
'amount': amount,
|
|
'currency_id': currency_id,
|
|
'partner_id': partner_id,
|
|
'token_id': token_id,
|
|
'operation': f'online_{flow}' if not is_validation else 'validation',
|
|
'tokenize': tokenize,
|
|
'landing_route': landing_route,
|
|
**(custom_create_values or {}),
|
|
}) # In sudo mode to allow writing on callback fields
|
|
|
|
if flow == 'token':
|
|
tx_sudo._send_payment_request() # Payments by token process transactions immediately
|
|
else:
|
|
tx_sudo._log_sent_message()
|
|
|
|
# Monitor the transaction to make it available in the portal
|
|
PaymentPostProcessing.monitor_transactions(tx_sudo)
|
|
|
|
return tx_sudo
|
|
|
|
@staticmethod
|
|
def _update_landing_route(tx_sudo, access_token):
|
|
""" Add the mandatory parameters to the route and recompute the access token if needed.
|
|
|
|
The generic landing route requires the tx id and access token to be provided since there is
|
|
no document to rely on. The access token is recomputed in case we are dealing with a
|
|
validation transaction (acquirer-specific amount and currency).
|
|
|
|
:param recordset tx_sudo: The transaction whose landing routes to update, as a
|
|
`payment.transaction` record.
|
|
:param str access_token: The access token used to authenticate the partner
|
|
:return: None
|
|
"""
|
|
if tx_sudo.operation == 'validation':
|
|
access_token = payment_utils.generate_access_token(
|
|
tx_sudo.partner_id.id, tx_sudo.amount, tx_sudo.currency_id.id
|
|
)
|
|
tx_sudo.landing_route = f'{tx_sudo.landing_route}' \
|
|
f'?tx_id={tx_sudo.id}&access_token={access_token}'
|
|
|
|
@http.route('/payment/confirmation', type='http', methods=['GET'], auth='public', website=True)
|
|
def payment_confirm(self, tx_id, access_token, **kwargs):
|
|
""" Display the payment confirmation page to the user.
|
|
|
|
: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 dict kwargs: Optional data. This parameter is not used here
|
|
:raise: werkzeug.exceptions.NotFound if the access token is invalid
|
|
"""
|
|
tx_id = self._cast_as_int(tx_id)
|
|
if tx_id:
|
|
tx_sudo = request.env['payment.transaction'].sudo().browse(tx_id)
|
|
|
|
# Raise an HTTP 404 if the access token is invalid
|
|
if not payment_utils.check_access_token(
|
|
access_token, tx_sudo.partner_id.id, tx_sudo.amount, tx_sudo.currency_id.id
|
|
):
|
|
raise werkzeug.exceptions.NotFound # Don't leak info about existence of an id
|
|
|
|
# Stop monitoring the transaction now that it reached a final state.
|
|
PaymentPostProcessing.remove_transactions(tx_sudo)
|
|
|
|
# Display the payment confirmation page to the user
|
|
return request.render('payment.confirm', qcontext={'tx': tx_sudo})
|
|
else:
|
|
# Display the portal homepage to the user
|
|
return request.redirect('/my/home')
|
|
|
|
@http.route('/payment/archive_token', type='json', auth='user')
|
|
def archive_token(self, token_id):
|
|
""" Check that a user has write access on a token and archive the token if so.
|
|
|
|
:param int token_id: The token to archive, as a `payment.token` id
|
|
:return: None
|
|
"""
|
|
partner_sudo = request.env.user.partner_id
|
|
token_sudo = request.env['payment.token'].sudo().search([
|
|
('id', '=', token_id),
|
|
# Check that the user owns the token before letting them archive anything
|
|
('partner_id', 'in', [partner_sudo.id, partner_sudo.commercial_partner_id.id])
|
|
])
|
|
if token_sudo:
|
|
token_sudo.active = False
|
|
|
|
@staticmethod
|
|
def _cast_as_int(str_value):
|
|
""" Cast a string as an `int` and return it.
|
|
|
|
If the conversion fails, `None` is returned instead.
|
|
|
|
:param str str_value: The value to cast as an `int`
|
|
:return: The casted value, possibly replaced by None if incompatible
|
|
:rtype: int|None
|
|
"""
|
|
try:
|
|
return int(str_value)
|
|
except (TypeError, ValueError, OverflowError):
|
|
return None
|
|
|
|
@staticmethod
|
|
def _cast_as_float(str_value):
|
|
""" Cast a string as a `float` and return it.
|
|
|
|
If the conversion fails, `None` is returned instead.
|
|
|
|
:param str str_value: The value to cast as a `float`
|
|
:return: The casted value, possibly replaced by None if incompatible
|
|
:rtype: float|None
|
|
"""
|
|
try:
|
|
return float(str_value)
|
|
except (TypeError, ValueError, OverflowError):
|
|
return None
|
|
|
|
@staticmethod
|
|
def _ensure_matching_companies(partner, document_company):
|
|
""" Check that the partner's company is the same as the document's company.
|
|
|
|
If the partner company is not set, the check passes. If the companies don't match, a
|
|
`UserError` is raised.
|
|
|
|
:param recordset partner: The partner on behalf on which the payment is made, as a
|
|
`res.partner` record.
|
|
:param recordset document_company: The company of the document being paid, as a
|
|
`res.company` record.
|
|
:return: None
|
|
:raise UserError: If the companies don't match.
|
|
"""
|
|
if partner.company_id and partner.company_id != document_company:
|
|
raise UserError(
|
|
_("Please switch to company '%s' to make this payment.", document_company.name)
|
|
)
|