453 lines
18 KiB
Python
453 lines
18 KiB
Python
import logging
|
|
import requests
|
|
import hashlib
|
|
import json
|
|
from odoo import models, fields
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class PaymentTransaction(models.Model):
|
|
_inherit = 'payment.transaction'
|
|
|
|
def _paydunya_assign_transaction_payment_method_line(self):
|
|
"""Ensure transaction has a valid journal/payment method line for account payment."""
|
|
self.ensure_one()
|
|
if 'payment_method_line_id' not in self._fields:
|
|
return False
|
|
if self.payment_method_line_id:
|
|
return True
|
|
|
|
journal = False
|
|
if 'journal_id' in self._fields and self.journal_id:
|
|
journal = self.journal_id
|
|
if not journal:
|
|
journal = self.env['account.journal'].search([
|
|
('company_id', '=', self.company_id.id),
|
|
('type', 'in', ['bank', 'cash']),
|
|
('inbound_payment_method_line_ids', '!=', False),
|
|
], limit=1)
|
|
|
|
method_line = journal.inbound_payment_method_line_ids[:1] if journal else False
|
|
if not method_line:
|
|
return False
|
|
|
|
vals = {'payment_method_line_id': method_line.id}
|
|
if 'journal_id' in self._fields and journal:
|
|
vals['journal_id'] = journal.id
|
|
self.write(vals)
|
|
return True
|
|
|
|
def _paydunya_extract_sale_order_id(self, payload):
|
|
"""Extract a sale order id from return/callback payload."""
|
|
if not isinstance(payload, dict):
|
|
return None
|
|
|
|
candidates = []
|
|
for key in ('sale_order_id', 'order_id'):
|
|
value = payload.get(key)
|
|
if value:
|
|
candidates.append(value)
|
|
|
|
custom_data = payload.get('custom_data')
|
|
if isinstance(custom_data, dict):
|
|
for key in ('odoo_sale_order_id', 'sale_order_id', 'order_id'):
|
|
value = custom_data.get(key)
|
|
if value:
|
|
candidates.append(value)
|
|
|
|
for value in candidates:
|
|
try:
|
|
return int(value)
|
|
except (TypeError, ValueError):
|
|
continue
|
|
return None
|
|
|
|
def _paydunya_extract_tx_id(self, payload):
|
|
"""Extract an Odoo transaction id from return/callback payload."""
|
|
if not isinstance(payload, dict):
|
|
return None
|
|
|
|
candidates = []
|
|
for key in ('tx_id', 'transaction_id'):
|
|
value = payload.get(key)
|
|
if value:
|
|
candidates.append(value)
|
|
|
|
custom_data = payload.get('custom_data')
|
|
if isinstance(custom_data, dict):
|
|
value = custom_data.get('odoo_tx_id')
|
|
if value:
|
|
candidates.append(value)
|
|
|
|
for value in candidates:
|
|
try:
|
|
return int(value)
|
|
except (TypeError, ValueError):
|
|
continue
|
|
return None
|
|
|
|
def _paydunya_get_related_sale_order(self, sale_order_id=None):
|
|
"""Locate the sale order linked to this transaction."""
|
|
self.ensure_one()
|
|
if 'sale.order' not in self.env:
|
|
return False
|
|
|
|
sale_order = self.env['sale.order']
|
|
if sale_order_id:
|
|
sale_order = self.env['sale.order'].sudo().browse(int(sale_order_id))
|
|
if sale_order.exists():
|
|
return sale_order
|
|
|
|
if hasattr(self, 'sale_order_ids') and self.sale_order_ids:
|
|
return self.sale_order_ids[0].sudo()
|
|
|
|
ref = (self.reference or '').strip()
|
|
if ref:
|
|
possible_names = [ref]
|
|
for separator in ('-', '_'):
|
|
if separator in ref:
|
|
possible_names.append(ref.split(separator, 1)[0])
|
|
sale_order = self.env['sale.order'].sudo().search([('name', 'in', list(set(possible_names)))], limit=1)
|
|
if sale_order:
|
|
return sale_order
|
|
return self.env['sale.order']
|
|
|
|
def _paydunya_finalize_sale_order(self, sale_order_id=None):
|
|
"""Confirm sale order and create/post invoice when transaction is paid."""
|
|
self.ensure_one()
|
|
if 'sale.order' not in self.env:
|
|
return False
|
|
sale_order = self._paydunya_get_related_sale_order(sale_order_id=sale_order_id)
|
|
if not sale_order:
|
|
_logger.info('PayDunya: no sale order linked to transaction %s', self.reference)
|
|
return False
|
|
|
|
if sale_order.state in ('draft', 'sent'):
|
|
sale_order.action_confirm()
|
|
|
|
invoices = sale_order.invoice_ids.filtered(lambda inv: inv.state != 'cancel')
|
|
if not invoices:
|
|
invoices = sale_order._create_invoices()
|
|
|
|
draft_invoices = invoices.filtered(lambda inv: inv.state == 'draft')
|
|
if draft_invoices:
|
|
draft_invoices.action_post()
|
|
|
|
posted_invoices = invoices.filtered(lambda inv: inv.state == 'posted' and inv.amount_residual > 0)
|
|
if posted_invoices and 'account.payment.register' in self.env:
|
|
try:
|
|
register_ctx = {
|
|
'active_model': 'account.move',
|
|
'active_ids': posted_invoices.ids,
|
|
}
|
|
wizard = self.env['account.payment.register'].with_context(**register_ctx).create({
|
|
'payment_date': fields.Date.context_today(self),
|
|
})
|
|
|
|
# Force a valid journal/method line to avoid
|
|
# "Please define a payment method line on your payment."
|
|
if not wizard.journal_id:
|
|
company = posted_invoices[:1].company_id
|
|
journal = self.env['account.journal'].search([
|
|
('company_id', '=', company.id),
|
|
('type', 'in', ['bank', 'cash']),
|
|
('inbound_payment_method_line_ids', '!=', False),
|
|
], limit=1)
|
|
if journal:
|
|
wizard.journal_id = journal
|
|
|
|
if not wizard.payment_method_line_id:
|
|
method_line = (
|
|
wizard.available_payment_method_line_ids[:1]
|
|
or wizard.journal_id.inbound_payment_method_line_ids[:1]
|
|
)
|
|
if method_line:
|
|
wizard.payment_method_line_id = method_line.id
|
|
|
|
wizard._create_payments()
|
|
except Exception:
|
|
_logger.exception(
|
|
'PayDunya: failed to auto-register invoice payment for transaction %s',
|
|
self.reference,
|
|
)
|
|
|
|
_logger.info(
|
|
'PayDunya: finalized sale order %s for transaction %s',
|
|
sale_order.name,
|
|
self.reference,
|
|
)
|
|
return True
|
|
|
|
def _normalize_paydunya_notification_data(self, data):
|
|
"""Normalize PayDunya notification payload across callback and confirm formats."""
|
|
payload = data
|
|
if not isinstance(payload, dict):
|
|
return {}
|
|
|
|
# Callback can send {"data": "<json>"} or {"data": {...}}
|
|
if 'data' in payload:
|
|
wrapped = payload.get('data')
|
|
if isinstance(wrapped, str):
|
|
try:
|
|
payload = json.loads(wrapped)
|
|
except Exception:
|
|
payload = payload
|
|
elif isinstance(wrapped, dict):
|
|
payload = wrapped
|
|
|
|
# Confirm endpoint can send {"response_data": {...}}
|
|
if isinstance(payload, dict) and isinstance(payload.get('response_data'), dict):
|
|
payload = payload['response_data']
|
|
|
|
return payload if isinstance(payload, dict) else {}
|
|
|
|
def _get_paydunya_channel(self, processing_values):
|
|
"""Return the PayDunya channel to force based on selected payment method."""
|
|
self.ensure_one()
|
|
|
|
selected_code = (
|
|
processing_values.get('payment_method_code')
|
|
or processing_values.get('payment_method')
|
|
or getattr(getattr(self, 'payment_method_id', False), 'code', False)
|
|
)
|
|
|
|
# Odoo checkout often sends only payment_method_id; resolve it to code.
|
|
if not selected_code:
|
|
pm_id = processing_values.get('payment_method_id')
|
|
if pm_id:
|
|
try:
|
|
payment_method = self.env['payment.method'].browse(int(pm_id))
|
|
if payment_method.exists():
|
|
selected_code = payment_method.code
|
|
except (TypeError, ValueError):
|
|
selected_code = None
|
|
|
|
if not selected_code:
|
|
return None
|
|
|
|
channel_map = {
|
|
'wave-senegal': 'wave-senegal',
|
|
'orange-money-senegal': 'orange-money-senegal',
|
|
'om': 'orange-money-senegal',
|
|
'orange-money': 'orange-money-senegal',
|
|
'wave': 'wave-senegal',
|
|
'card': 'card',
|
|
}
|
|
return channel_map.get(str(selected_code).lower())
|
|
|
|
def _get_specific_rendering_values(self, processing_values):
|
|
"""Create invoice on PayDunya and return rendering values for redirection."""
|
|
self.ensure_one()
|
|
provider = False
|
|
# try common fields used across Odoo versions
|
|
provider = getattr(self, 'provider_id', False) or getattr(self, 'acquirer_id', False)
|
|
if not provider:
|
|
provider = self.env['payment.provider'].search([('code', '=', 'paydunya')], limit=1)
|
|
if not provider:
|
|
return {}
|
|
|
|
base = provider._get_paydunya_api_base()
|
|
create_url = base + '/checkout-invoice/create'
|
|
sale_order = self._paydunya_get_related_sale_order()
|
|
sale_order_id = sale_order.id if sale_order else False
|
|
|
|
base_url = self.env['ir.config_parameter'].sudo().get_param('web.base.url')
|
|
query = '?tx_id={}'.format(self.id)
|
|
if sale_order_id:
|
|
query += '&sale_order_id={}'.format(sale_order_id)
|
|
return_url = base_url + '/payment/paydunya/return' + query
|
|
cancel_url = base_url + '/payment/paydunya/cancel' + query
|
|
callback_url = base_url + '/payment/paydunya/callback' + query
|
|
|
|
# Build payload according to PayDunya documentation
|
|
# Required: invoice.total_amount, store.name
|
|
payload = {
|
|
'invoice': {
|
|
'total_amount': int(self.amount),
|
|
'description': self.reference or self.name or 'Payment',
|
|
},
|
|
'store': {
|
|
'name': self.env.company.name or 'Store',
|
|
},
|
|
'actions': {
|
|
'return_url': return_url,
|
|
'cancel_url': cancel_url,
|
|
'callback_url': callback_url,
|
|
},
|
|
'custom_data': {
|
|
'odoo_tx_id': str(self.id),
|
|
'odoo_sale_order_id': str(sale_order_id or ''),
|
|
'odoo_reference': self.reference or '',
|
|
},
|
|
}
|
|
|
|
# Add customer info if available
|
|
if self.partner_id:
|
|
payload['invoice']['customer'] = {
|
|
'name': self.partner_id.name or '',
|
|
'email': self.partner_id.email or '',
|
|
'phone': self.partner_id.phone or '',
|
|
}
|
|
|
|
channel = self._get_paydunya_channel(processing_values or {})
|
|
if channel:
|
|
# Force a single payment channel so PayDunya redirects to the selected operator flow.
|
|
payload['invoice']['channels'] = [channel]
|
|
_logger.info(
|
|
'PayDunya checkout channel: selected=%s resolved=%s',
|
|
processing_values.get('payment_method_code')
|
|
or processing_values.get('payment_method')
|
|
or processing_values.get('payment_method_id'),
|
|
channel,
|
|
)
|
|
|
|
# Authentication headers
|
|
headers = {
|
|
'Content-Type': 'application/json',
|
|
'PAYDUNYA-MASTER-KEY': provider.paydunya_master_key or '',
|
|
'PAYDUNYA-PRIVATE-KEY': provider.paydunya_private_key or '',
|
|
'PAYDUNYA-TOKEN': provider.paydunya_token or ''
|
|
}
|
|
|
|
try:
|
|
resp = requests.post(create_url, json=payload, headers=headers, timeout=15)
|
|
data = resp.json()
|
|
|
|
# Check response_code (success = '00')
|
|
response_code = data.get('response_code')
|
|
if response_code != '00':
|
|
_logger.warning('PayDunya API error: %s - %s', response_code, data.get('response_text'))
|
|
return {}
|
|
|
|
# Extract token from response
|
|
token = data.get('token')
|
|
# response_text is the checkout URL
|
|
redirect_url = data.get('response_text')
|
|
|
|
if token:
|
|
# store reference to match notifications
|
|
self.provider_reference = token
|
|
_logger.info('PayDunya invoice created: token=%s, url=%s', token, redirect_url)
|
|
# Return the rendering values expected by the redirect form template.
|
|
return {
|
|
'api_url': redirect_url,
|
|
'token': token,
|
|
}
|
|
else:
|
|
_logger.warning('PayDunya: no token in response: %s', data)
|
|
except Exception as e:
|
|
_logger.exception('Error creating PayDunya invoice: %s', e)
|
|
|
|
return {}
|
|
|
|
def _get_tx_from_notification(self, data):
|
|
"""Find the transaction corresponding to a PayDunya notification payload."""
|
|
invoice_data = self._normalize_paydunya_notification_data(data)
|
|
tx_id = self._paydunya_extract_tx_id(invoice_data)
|
|
if not tx_id and isinstance(data, dict):
|
|
tx_id = self._paydunya_extract_tx_id(data)
|
|
if tx_id:
|
|
tx = self.search([('id', '=', tx_id)], limit=1)
|
|
if tx:
|
|
return tx
|
|
|
|
token = invoice_data.get('invoice', {}).get('token') or invoice_data.get('token')
|
|
if not token and isinstance(data, dict):
|
|
token = data.get('token') or data.get('invoice_token')
|
|
if not token:
|
|
return None
|
|
tx = self.search([('provider_reference', '=', token)], limit=1)
|
|
return tx or None
|
|
|
|
def _handle_notification_data(self, data):
|
|
"""Handle PayDunya notification payload and update transaction state.
|
|
|
|
Validates the hash according to PayDunya documentation (SHA-512 of MASTER-KEY).
|
|
PayDunya sends data as application/x-www-form-urlencoded with key 'data' containing JSON.
|
|
"""
|
|
invoice_data = self._normalize_paydunya_notification_data(data)
|
|
if not invoice_data:
|
|
_logger.warning('PayDunya: invalid notification payload: %s', data)
|
|
return False
|
|
|
|
# Verify hash to ensure the callback is from PayDunya
|
|
provided_hash = invoice_data.get('hash')
|
|
if not provided_hash and isinstance(data, dict):
|
|
provided_hash = data.get('hash')
|
|
if provided_hash:
|
|
provider = self.env['payment.provider'].search([('code', '=', 'paydunya')], limit=1)
|
|
if provider and provider.paydunya_master_key:
|
|
expected_hash = hashlib.sha512(
|
|
provider.paydunya_master_key.encode()
|
|
).hexdigest()
|
|
if str(provided_hash).lower() != expected_hash:
|
|
_logger.warning('PayDunya: Hash mismatch! Possible security issue. Expected %s, got %s',
|
|
expected_hash, provided_hash)
|
|
return False
|
|
|
|
tx = self._get_tx_from_notification(data)
|
|
if not tx:
|
|
_logger.warning('PayDunya: no transaction found for notification: %s', invoice_data)
|
|
return False
|
|
|
|
# Extract status (valid values: pending, completed, cancelled, failed)
|
|
status = invoice_data.get('status') or (
|
|
invoice_data.get('invoice', {}).get('status')
|
|
)
|
|
|
|
if not status:
|
|
_logger.warning('PayDunya: notification without status: %s', invoice_data)
|
|
return False
|
|
|
|
status = str(status).lower()
|
|
if status == 'completed':
|
|
sale_order_id = self._paydunya_extract_sale_order_id(invoice_data)
|
|
tx._paydunya_assign_transaction_payment_method_line()
|
|
if hasattr(tx, '_set_done'):
|
|
tx._set_done()
|
|
elif hasattr(tx, '_set_transaction_done'):
|
|
tx._set_transaction_done()
|
|
else:
|
|
tx.state = 'done'
|
|
if hasattr(tx, '_post_process'):
|
|
try:
|
|
tx._post_process()
|
|
except Exception:
|
|
_logger.exception(
|
|
'PayDunya: _post_process failed for transaction %s; keeping done state',
|
|
tx.reference,
|
|
)
|
|
if 'is_post_processed' in tx._fields:
|
|
tx.is_post_processed = True
|
|
tx._paydunya_finalize_sale_order(sale_order_id=sale_order_id)
|
|
_logger.info('PayDunya: Transaction %s marked as done', tx.reference)
|
|
return True
|
|
if status in ('cancelled', 'failed'):
|
|
if hasattr(tx, '_set_canceled'):
|
|
tx._set_canceled()
|
|
elif hasattr(tx, '_set_transaction_cancel'):
|
|
tx._set_transaction_cancel()
|
|
else:
|
|
tx.state = 'cancel'
|
|
if hasattr(tx, '_post_process'):
|
|
try:
|
|
tx._post_process()
|
|
except Exception:
|
|
_logger.exception(
|
|
'PayDunya: _post_process failed for cancelled/failed transaction %s',
|
|
tx.reference,
|
|
)
|
|
_logger.info('PayDunya: Transaction %s marked as cancelled/failed', tx.reference)
|
|
return True
|
|
|
|
# fallback: mark as pending
|
|
if hasattr(tx, '_set_pending'):
|
|
tx._set_pending()
|
|
elif hasattr(tx, '_set_transaction_pending'):
|
|
tx._set_transaction_pending()
|
|
else:
|
|
tx.state = 'pending'
|
|
_logger.info('PayDunya: Transaction %s marked as pending', tx.reference)
|
|
return True
|