Hello!
I have tried to implement Echelon Payment Gateway into odoo.
I would like to implement the inline payment.
I have created the method and provider and when comes to the payment page, when pay is clicked, it says template is required. But in sandbox, the call has been captured. So basically i need the payment success page of odoo
line 804, in _get_template
assert template not in (False, None, ""), "template is required"
AssertionError: template is required
this is my controller. I dont actually want to redirect but i think the error is about redirecting.
"""echelon"""
# -*- coding: utf-8 -*-
import hmac
import logging
import pprint
import requests
from werkzeug.exceptions import Forbidden
from werkzeug.utils import redirect
from odoo import http, _
from odoo.exceptions import AccessError, MissingError, ValidationError, UserError
from odoo.http import request, route
from odoo.addons.payment import utils as payment_utils
from odoo.addons.payment.controllers import portal as payment_portal
_logger = logging.getLogger(__name__)
class PaymentPortal(payment_portal.PaymentPortal):
@route('/invoice/transaction/<int:invoice_id>', type='json', auth='public')
def invoice_transaction(self, invoice_id, access_token, **kwargs):
""" Create a draft transaction and return its processing values.
:param int invoice_id: The invoice to pay, as an `account.move` id
:param str access_token: The access token used to authenticate the request
: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 invoice id or the access token is invalid
"""
# Check the invoice id and the access token
try:
invoice_sudo = self._document_check_access('account.move', invoice_id, access_token)
except MissingError as error:
raise error
except AccessError:
raise ValidationError(_("The access token is invalid."))
logged_in = not request.env.user._is_public()
partner_sudo = request.env.user.partner_id if logged_in else invoice_sudo.partner_id
self._validate_transaction_kwargs(kwargs, additional_allowed_keys={
'name_next_installment',
'partner_id',
'card_number',
'expiry_month',
'expiry_year',
'cvv_number',
})
return self._process_transaction(partner_sudo.id, invoice_sudo.currency_id.id, [invoice_id], False, **kwargs)
class EchelonController(http.Controller):
@http.route('/payment/echelon', type='json', auth='public')
def echelon_payment(self, **post):
card_number = post.get('card_number')
expiry_month = post.get('expiry_month')
cvv_number = post.get('cvv_number')
expiry_year = post.get('expiry_year')
amount = post.get('amount')
partner_id = request.env['res.partner'].browse(int(post.get('partner_id')))
invoice_id = request.env['account.move'].browse(int(post.get('invoice_id')))
provider_id = request.env['payment.provider'].browse(int(post.get('provider_id')))
landing_route = post.get('landing_route')
payloads = {
"expiry_month": int(expiry_month),
"expiry_year": int(expiry_year),
"name": partner_id.name,
"card": card_number,
"amount": amount,
"transaction_details": {
"description": invoice_id.name,
"invoice_number": invoice_id.name,
"order_number": "123"
},
"capture": True,
"save_card": False
}
headers = {
"Content-Type": "application/json",
"Authorization": "Basic "
}
url = 'https://api.sandbox.echelonsecure.app/api/v2/transactions/charge'
response = requests.post(url, json=payloads, headers=headers, auth=(provider_id.api_key, provider_id.pin))
response_json = response.json()
_logger.info("Echelon charge API response: %s", pprint.pformat(response_json))
print('Echelon response:', response_json)
flow = post.get('flow')
is_validation = post.get('is_validation')
token_id = post.get('token_id')
tokenize = False
# Always create transaction record regardless of success/failure
tx_sudo = request.env['payment.transaction'].sudo().create({
'provider_id': provider_id.id,
'payment_method_id': provider_id.payment_method_ids.id,
'reference': invoice_id.name,
'amount': amount,
'currency_id': invoice_id.currency_id.id,
'partner_id': partner_id.id,
'token_id': token_id,
'operation': f'online_{flow}' if not is_validation else 'validation',
'tokenize': tokenize,
'landing_route': landing_route,
'invoice_ids': [(6, 0, [invoice_id.id])],
'state': 'pending'
})
if response.status_code == 200 and response_json.get('status') == 'Approved':
# Payment was approved
payment = request.env['account.payment'].sudo().create({
'payment_type': 'inbound',
'partner_type': 'customer',
'partner_id': partner_id.id,
'amount': amount,
'state': 'in_process',
'invoice_ids': [(6, 0, [invoice_id.id])],
'payment_transaction_id': tx_sudo.id,
'currency_id': invoice_id.currency_id.id,
'journal_id': provider_id.journal_id.id,
})
tx_sudo.write({'state': 'done'})
else:
# Log error and keep transaction pending or mark as error
_logger.error("Echelon charge failed: %s", pprint.pformat(response_json))
tx_sudo.write({'state': 'error'})
# Common rendering values
processing_values = {
'provider_id': provider_id.id,
'provider_code': provider_id.code,
'reference': invoice_id.name,
'amount': amount,
'currency_id': invoice_id.currency_id.id,
'partner_id': partner_id.id,
}
rendering_values = dict()
redirect_form_view = provider_id._get_redirect_form_view()
redirect_form_html = request.env['ir.qweb']._render(redirect_form_view.id, rendering_values)
processing_values.update(redirect_form_html=redirect_form_html)
return processing_values