Odoo18-Base/addons/sale/models/payment_transaction.py
2025-01-06 10:57:38 +07:00

238 lines
11 KiB
Python

# Part of Odoo. See LICENSE file for full copyright and licensing details.
from datetime import datetime
from dateutil import relativedelta
from odoo import _, api, Command, fields, models, SUPERUSER_ID
from odoo.tools import str2bool
class PaymentTransaction(models.Model):
_inherit = 'payment.transaction'
sale_order_ids = fields.Many2many('sale.order', 'sale_order_transaction_rel', 'transaction_id', 'sale_order_id',
string='Sales Orders', copy=False, readonly=True)
sale_order_ids_nbr = fields.Integer(compute='_compute_sale_order_ids_nbr', string='# of Sales Orders')
def _compute_sale_order_reference(self, order):
self.ensure_one()
if self.provider_id.so_reference_type == 'so_name':
order_reference = order.name
elif self.provider_id.so_reference_type == 'partner':
identification_number = order.partner_id.id
order_reference = '%s/%s' % ('CUST', str(identification_number % 97).rjust(2, '0'))
else:
# self.provider_id.so_reference_type is empty
order_reference = False
invoice_journal = self.env['account.journal'].search([('type', '=', 'sale'), ('company_id', '=', self.env.company.id)], limit=1)
if invoice_journal:
order_reference = invoice_journal._process_reference_for_sale_order(order_reference)
return order_reference
@api.depends('sale_order_ids')
def _compute_sale_order_ids_nbr(self):
for trans in self:
trans.sale_order_ids_nbr = len(trans.sale_order_ids)
def _post_process(self):
""" Override of `payment` to add Sales-specific logic to the post-processing.
In particular, for pending transactions, we send the quotation by email; for authorized
transactions, we confirm the quotation; for confirmed transactions, we automatically confirm
the quotation and generate invoices.
"""
for pending_tx in self.filtered(lambda tx: tx.state == 'pending'):
super(PaymentTransaction, pending_tx)._post_process()
sales_orders = pending_tx.sale_order_ids.filtered(
lambda so: so.state in ['draft', 'sent']
)
sales_orders.filtered(
lambda so: so.state == 'draft'
).with_context(tracking_disable=True).action_quotation_sent()
if pending_tx.provider_id.code == 'custom':
for order in pending_tx.sale_order_ids:
order.reference = pending_tx._compute_sale_order_reference(order)
if pending_tx.operation == 'validation':
continue
# Send the payment status email.
# The transactions are manually cached while in a sudoed environment to prevent an
# AccessError: In some circumstances, sending the mail would generate the report assets
# during the rendering of the mail body, causing a cursor commit, a flush, and forcing
# the re-computation of the pending computed fields of the `mail.compose.message`,
# including part of the template. Since that template reads the order's transactions and
# the re-computation of the field is not done with the same environment, reading fields
# that were not already available in the cache could trigger an AccessError (e.g., if
# the payment was initiated by a public user).
sales_orders.mapped('transaction_ids')
sales_orders._send_payment_succeeded_for_order_mail()
for authorized_tx in self.filtered(lambda tx: tx.state == 'authorized'):
super(PaymentTransaction, authorized_tx)._post_process()
confirmed_orders = authorized_tx._check_amount_and_confirm_order()
if authorized_tx.operation == 'validation':
continue
if remaining_orders := (authorized_tx.sale_order_ids - confirmed_orders):
remaining_orders._send_payment_succeeded_for_order_mail()
super(PaymentTransaction, self.filtered(
lambda tx: tx.state not in ['pending', 'authorized', 'done'])
)._post_process()
for done_tx in self.filtered(lambda tx: tx.state == 'done'):
confirmed_orders = done_tx._check_amount_and_confirm_order()
if done_tx.operation == 'validation':
continue
(done_tx.sale_order_ids - confirmed_orders)._send_payment_succeeded_for_order_mail()
auto_invoice = str2bool(
self.env['ir.config_parameter'].sudo().get_param('sale.automatic_invoice')
)
if auto_invoice:
# Invoice the sales orders of confirmed transactions instead of only confirmed
# orders to create the invoice even if only a partial payment was made.
done_tx._invoice_sale_orders()
super(PaymentTransaction, done_tx)._post_process() # Post the invoices.
if auto_invoice:
self._send_invoice()
def _check_amount_and_confirm_order(self):
""" Confirm the sales order based on the amount of a transaction.
Confirm the sales orders only if the transaction amount (or the sum of the partial
transaction amounts) is equal to or greater than the required amount for order confirmation
Grouped payments (paying multiple sales orders in one transaction) are not supported.
:return: The confirmed sales orders.
:rtype: a `sale.order` recordset
"""
confirmed_orders = self.env['sale.order']
for tx in self:
# We only support the flow where exactly one quotation is linked to a transaction.
if len(tx.sale_order_ids) == 1:
quotation = tx.sale_order_ids.filtered(lambda so: so.state in ('draft', 'sent'))
if quotation and quotation._is_confirmation_amount_reached():
quotation.with_context(send_email=True).action_confirm()
confirmed_orders |= quotation
return confirmed_orders
def _log_message_on_linked_documents(self, message):
""" Override of payment to log a message on the sales orders linked to the transaction.
Note: self.ensure_one()
:param str message: The message to be logged
:return: None
"""
super()._log_message_on_linked_documents(message)
author = self.env.user.partner_id if self.env.uid == SUPERUSER_ID else self.partner_id
for order in self.sale_order_ids or self.source_transaction_id.sale_order_ids:
order.message_post(body=message, author_id=author.id)
def _send_invoice(self):
for tx in self:
tx = tx.with_company(tx.company_id).with_context(
company_id=tx.company_id.id,
)
invoice_to_send = tx.invoice_ids.filtered(
lambda i: not i.is_move_sent and i.state == 'posted' and i._is_ready_to_be_sent()
)
invoice_to_send.is_move_sent = True # Mark invoice as sent
self.env['account.move.send'].with_user(SUPERUSER_ID)._generate_and_send_invoices(
invoice_to_send,
allow_raising=False,
allow_fallback_pdf=True,
)
def _cron_send_invoice(self):
"""
Cron to send invoice that where not ready to be send directly after posting
"""
if not self.env['ir.config_parameter'].sudo().get_param('sale.automatic_invoice'):
return
# No need to retrieve old transactions
retry_limit_date = datetime.now() - relativedelta.relativedelta(days=2)
# Retrieve all transactions matching the criteria for post-processing
self.search([
('state', '=', 'done'),
('is_post_processed', '=', True),
('invoice_ids', 'in', self.env['account.move']._search([
('is_move_sent', '=', False),
('state', '=', 'posted'),
])),
('sale_order_ids.state', '=', 'sale'),
('last_state_change', '>=', retry_limit_date),
])._send_invoice()
def _invoice_sale_orders(self):
for tx in self.filtered(lambda tx: tx.sale_order_ids):
tx = tx.with_company(tx.company_id)
confirmed_orders = tx.sale_order_ids.filtered(lambda so: so.state == 'sale')
if confirmed_orders:
# Filter orders between those fully paid and those partially paid.
fully_paid_orders = confirmed_orders.filtered(lambda so: so._is_paid())
# Create a down payment invoice for partially paid orders
downpayment_invoices = (
confirmed_orders - fully_paid_orders
)._generate_downpayment_invoices()
# For fully paid orders create a final invoice.
fully_paid_orders._force_lines_to_invoice_policy_order()
final_invoices = fully_paid_orders.with_context(
raise_if_nothing_to_invoice=False
)._create_invoices(final=True)
invoices = downpayment_invoices + final_invoices
# Setup access token in advance to avoid serialization failure between
# edi postprocessing of invoice and displaying the sale order on the portal
for invoice in invoices:
invoice._portal_ensure_token()
tx.invoice_ids = [Command.set(invoices.ids)]
@api.model
def _compute_reference_prefix(self, provider_code, separator, **values):
""" Override of payment to compute the reference prefix based on Sales-specific values.
If the `values` parameter has an entry with 'sale_order_ids' as key and a list of (4, id, O)
or (6, 0, ids) X2M command as value, the prefix is computed based on the sales order name(s)
Otherwise, the computation is delegated to the super method.
:param str provider_code: The code of the provider handling the transaction
:param str separator: The custom separator used to separate data references
:param dict values: The transaction values used to compute the reference prefix. It should
have the structure {'sale_order_ids': [(X2M command), ...], ...}.
:return: The computed reference prefix if order ids are found, the one of `super` otherwise
:rtype: str
"""
command_list = values.get('sale_order_ids')
if command_list:
# Extract sales order id(s) from the X2M commands
order_ids = self._fields['sale_order_ids'].convert_to_cache(command_list, self)
orders = self.env['sale.order'].browse(order_ids).exists()
if len(orders) == len(order_ids): # All ids are valid
return separator.join(orders.mapped('name'))
return super()._compute_reference_prefix(provider_code, separator, **values)
def action_view_sales_orders(self):
action = {
'name': _('Sales Order(s)'),
'type': 'ir.actions.act_window',
'res_model': 'sale.order',
'target': 'current',
}
sale_order_ids = self.sale_order_ids.ids
if len(sale_order_ids) == 1:
action['res_id'] = sale_order_ids[0]
action['view_mode'] = 'form'
else:
action['view_mode'] = 'list,form'
action['domain'] = [('id', 'in', sale_order_ids)]
return action