def appoint_pay_token(self, appoint_id, pm_id=None, **kwargs):
error_url = kwargs.get('error_url', '/my')
success_url = kwargs.get('success_url', '/my')
access_token = kwargs.get('access_token')
params = {}
if access_token:
params['access_token'] = access_token
appoint_sudo = request.env['appointment'].sudo().browse(appoint_id).exists()
if not appoint_sudo:
params['error'] = 'pay_appoint_invalid_doc'
return request.redirect(_build_url_w_params(error_url, params))
try:
token = request.env['payment.token'].sudo().browse(int(pm_id))
except (ValueError, TypeError):
token = False
token_owner = appoint_sudo.customer if request.env.user._is_public() else request.env.user.partner_id
if not token or token.partner_id != token_owner:
params['error'] = 'pay_invoice_invalid_token'
return request.redirect(_build_url_w_params(error_url, params))
vals = {
'payment_token_id': token.id,
'type': 'server2server',
'return_url': success_url,
}
tx = appoint_sudo._create_payment_transaction(vals)
PaymentProcessing.add_payment_transaction(tx)
params['success'] = 'pay_invoice'
return request.redirect(_build_url_w_params(success_url, params))
def payment_token(self, pm_id=None, **kwargs):
""" Method that handles payment using saved tokens
:param int pm_id: id of the payment.token that we want to use to pay.
"""
order = request.website.sale_get_order()
# do not crash if the user has already paid and try to pay again
if not order:
return request.redirect('/shop/?error=no_order')
assert order.partner_id.id != request.website.partner_id.id
try:
pm_id = int(pm_id)
except ValueError:
return request.redirect('/shop/?error=invalid_token_id')
# We retrieve the token the user want to use to pay
if not request.env['payment.token'].sudo().search_count([('id', '=', pm_id)]):
return request.redirect('/shop/?error=token_not_found')
# Create transaction
vals = {'payment_token_id': pm_id, 'return_url': '/shop/payment/validate'}
tx = order._create_payment_transaction(vals)
PaymentProcessing.add_payment_transaction(tx)
return request.redirect('/payment/process')
def payment_token(self, pm_id=None, **kwargs):
""" Method that handles payment using saved tokens
:param int pm_id: id of the payment.token that we want to use to pay.
"""
order = request.website.sale_get_order()
# do not crash if the user has already paid and try to pay again
if not order:
return request.redirect('/shop/?error=no_order')
assert order.partner_id.id != request.website.partner_id.id
try:
pm_id = int(pm_id)
except ValueError:
return request.redirect('/shop/?error=invalid_token_id')
# We retrieve the token the user want to use to pay
if not request.env['payment.token'].sudo().search_count([('id', '=', pm_id)]):
return request.redirect('/shop/?error=token_not_found')
# Create transaction
vals = {'payment_token_id': pm_id, 'return_url': '/shop/payment/validate'}
tx = order._create_payment_transaction(vals)
pm_ids = request.env['payment.token'].browse(pm_id)
if pm_ids.acquirer_id.provider == 'cxpay':
if isinstance(tx, dict):
url = '/payment_method/add?url=' + tx.get('url') + '&token=' + str(pm_id)
return request.redirect(url)
PaymentProcessing.add_payment_transaction(tx)
return request.redirect('/payment/process')
def hyperpay_shopper_result(self, **post):
acq = request.env['payment.acquirer'].sudo().search([('provider', '=',
'hyperpay')])
if acq.state == 'enabled':
url = live_domain
else:
url = test_domain
url += '/' + post.get(
'resourcePath') + "?entityId=%s" % (acq.hyperpay_merchant_id)
headers = {
"Authorization": "Bearer " + acq.hyperpay_authorization,
}
resp = requests.get(url=url, headers=headers).json()
_logger.info(
"-----/payment/hyperpay/result-----response------------%r----",
resp)
payment = request.env['payment.transaction'].sudo()
tx = payment.search([('hyperpay_checkout_id', '=', post.get('id',
''))])
tx = resp.get('customParameters',
{}).get('SHOPPER_tx_id') or tx and tx.id or ''
resp.update({'tx_id': tx})
if tx:
PaymentProcessing.add_payment_transaction(payment.browse(int(tx)))
res = payment.form_feedback(resp, 'hyperpay')
return werkzeug.utils.redirect('/payment/process')
def stripe_create_charge(self, **post):
""" Create a payment transaction
Expects the result from the user input from checkout.js popup"""
TX = request.env['payment.transaction']
tx = None
if post.get('tx_ref'):
tx = TX.sudo().search([('reference', '=', post['tx_ref'])])
if not tx:
tx_id = (post.get('tx_id') or request.session.get('sale_transaction_id') or
request.session.get('website_payment_tx_id'))
tx = TX.sudo().browse(int(tx_id))
if not tx:
raise werkzeug.exceptions.NotFound()
stripe_token = post['token']
response = None
if tx.type == 'form_save' and tx.partner_id:
payment_token_id = request.env['payment.token'].sudo().create({
'acquirer_id': tx.acquirer_id.id,
'partner_id': tx.partner_id.id,
'stripe_token': stripe_token
})
tx.payment_token_id = payment_token_id
response = tx._create_stripe_charge(acquirer_ref=payment_token_id.acquirer_ref, email=stripe_token['email'])
else:
response = tx._create_stripe_charge(tokenid=stripe_token['id'], email=stripe_token['email'])
_logger.info('Stripe: entering form_feedback with post data %s', pprint.pformat(response))
if response:
request.env['payment.transaction'].sudo().with_context(lang=None).form_feedback(response, 'stripe')
# add the payment transaction into the session to let the page /payment/process to handle it
PaymentProcessing.add_payment_transaction(tx)
return "/payment/process"
def stripe_create_charge(self, **post):
""" Create a payment transaction
Expects the result from the user input from checkout.js popup"""
TX = request.env['payment.transaction']
tx = None
if post.get('tx_ref'):
tx = TX.sudo().search([('reference', '=', post['tx_ref'])])
if not tx:
tx_id = (post.get('tx_id') or request.session.get('sale_transaction_id') or
request.session.get('website_payment_tx_id'))
tx = TX.sudo().browse(int(tx_id))
if not tx:
raise werkzeug.exceptions.NotFound()
stripe_token = post['token']
response = None
if tx.type == 'form_save' and tx.partner_id:
payment_token_id = request.env['payment.token'].sudo().create({
'acquirer_id': tx.acquirer_id.id,
'partner_id': tx.partner_id.id,
'stripe_token': stripe_token
})
tx.payment_token_id = payment_token_id
response = tx._create_stripe_charge(acquirer_ref=payment_token_id.acquirer_ref, email=stripe_token['email'])
else:
response = tx._create_stripe_charge(tokenid=stripe_token['id'], email=stripe_token['email'])
_logger.info('Stripe: entering form_feedback with post data %s', pprint.pformat(response))
if response:
request.env['payment.transaction'].sudo().with_context(lang=None).form_feedback(response, 'stripe')
# add the payment transaction into the session to let the page /payment/process to handle it
PaymentProcessing.add_payment_transaction(tx)
return "/payment/process"
def payment_token(self, pm_id=None, **kwargs):
""" Method that handles payment using saved tokens
:param int pm_id: id of the payment.token that we want to use to pay.
"""
order = request.website.sale_get_order()
# do not crash if the user has already paid and try to pay again
if not order:
return request.redirect('/shop/?error=no_order')
assert order.partner_id.id != request.website.partner_id.id
try:
pm_id = int(pm_id)
except ValueError:
return request.redirect('/shop/?error=invalid_token_id')
# We retrieve the token the user want to use to pay
if not request.env['payment.token'].sudo().search_count(
[('id', '=', pm_id)]):
return request.redirect('/shop/?error=token_not_found')
# Create transaction
vals = {
'payment_token_id': pm_id,
'return_url': '/shop/payment/validate'
}
t_x = order._create_payment_transaction(vals)
order.write({'payment_tx_id': t_x.id})
PaymentProcessing.add_payment_transaction(t_x)
return request.redirect('/payment/process')
def invoice_pay_token(self, invoice_id, pm_id=None, **kwargs):
""" Use a token to perform a s2s transaction """
error_url = kwargs.get('error_url', '/my')
success_url = kwargs.get('success_url', '/my')
access_token = kwargs.get('access_token')
params = {}
if access_token:
params['access_token'] = access_token
invoice_sudo = request.env['account.invoice'].sudo().browse(invoice_id).exists()
if not invoice_sudo:
params['error'] = 'pay_invoice_invalid_doc'
return request.redirect(_build_url_w_params(error_url, params))
try:
token = request.env['payment.token'].sudo().browse(int(pm_id))
except (ValueError, TypeError):
token = False
token_owner = invoice_sudo.partner_id if request.env.user._is_public() else request.env.user.partner_id
if not token or token.partner_id != token_owner:
params['error'] = 'pay_invoice_invalid_token'
return request.redirect(_build_url_w_params(error_url, params))
vals = {
'payment_token_id': token.id,
'type': 'server2server',
'return_url': success_url,
}
tx = invoice_sudo._create_payment_transaction(vals)
PaymentProcessing.add_payment_transaction(tx)
params['success'] = 'pay_invoice'
return request.redirect(_build_url_w_params(success_url, params))
def appoint_pay_form(self, acquirer_id, appoint_id, save_token=False, access_token=None, **kwargs):
success_url = kwargs.get('success_url', '/my/appointments')
# callback_method = kwargs.get('callback_method', '')
appoint_sudo = request.env['appointment'].sudo().browse(appoint_id)
if not appoint_sudo:
return False
try:
acquirer = int(acquirer_id)
except:
return False
if request.env.user._is_public():
save_token = False # we avoid to create a token for the public user
vals = {
'acquirer_id': acquirer_id,
'return_url': success_url,
}
if save_token:
vals['type'] = 'form_save'
transaction = appoint_sudo._create_payment_transaction(vals)
PaymentProcessing.add_payment_transaction(transaction)
return transaction.render_appoint_button(
appoint_sudo,
submit_txt=_('Pay & Confirm'),
render_values={
'type': 'form_save' if save_token else 'form',
'alias_usage': _('If we store your payment information on our server, subscription payments will be made automatically.'),
}
)
def ogone_s2s_create(self, **post):
error = ''
acq = request.env['payment.acquirer'].browse(
int(post.get('acquirer_id')))
try:
token = acq.s2s_process(post)
except Exception as e:
# synthax error: 'CHECK ERROR: |Not a valid date\n\n50001111: None'
token = False
error = str(e).splitlines()[0].split('|')[-1] or ''
if token and post.get('verify_validity'):
baseurl = request.env['ir.config_parameter'].sudo().get_param(
'web.base.url')
params = {
'accept_url': baseurl + '/payment/ogone/validate/accept',
'decline_url': baseurl + '/payment/ogone/validate/decline',
'exception_url': baseurl + '/payment/ogone/validate/exception',
'return_url': post.get('return_url', baseurl)
}
tx = token.validate(**params)
if tx and tx.html_3ds:
return tx.html_3ds
# add the payment transaction into the session to let the page /payment/process to handle it
PaymentProcessing.add_payment_transaction(tx)
return werkzeug.utils.redirect("/payment/process")
def cx_pay_paymment_approve(self, payment_id=False, token_id=False, **kwargs):
payment_id = request.env['payment.transaction'].sudo().browse(payment_id)
if kwargs.get('token-id'):
payment_id.token_id = kwargs.get('token-id')
payment_id.cxpay_s2s_do_transaction_verify()
payment_id.payment_token_id.cvv_no = False
PaymentProcessing.add_payment_transaction(payment_id)
return http.redirect_with_hash('/payment/process')
def payment_transaction(self, acquirer_id, save_token=False, so_id=None, access_token=None, token=None, **kwargs):
""" Json method that creates a payment.transaction, used to create a
transaction when the user clicks on 'pay now' button. After having
created the transaction, the event continues and the user is redirected
to the acquirer website.
:param int acquirer_id: id of a payment.acquirer record. If not set the
user is redirected to the checkout page
"""
# Ensure a payment acquirer is selected
if not acquirer_id:
return False
try:
acquirer_id = int(acquirer_id)
except:
return False
# Retrieve the sale order
if so_id:
env = request.env['sale.order']
domain = [('id', '=', so_id)]
if access_token:
env = env.sudo()
domain.append(('access_token', '=', access_token))
order = env.search(domain, limit=1)
else:
order = request.website.sale_get_order()
# Ensure there is something to proceed
if not order or (order and not order.order_line):
return False
assert order.partner_id.id != request.website.partner_id.id
# Create transaction
vals = {'acquirer_id': acquirer_id,
'return_url': '/shop/payment/validate'}
if save_token:
vals['type'] = 'form_save'
if token:
vals['payment_token_id'] = int(token)
transaction = order._create_payment_transaction(vals)
# store the new transaction into the transaction list and if there's an old one, we remove it
# until the day the ecommerce supports multiple orders at the same time
last_tx_id = request.session.get('__website_sale_last_tx_id')
last_tx = request.env['payment.transaction'].browse(last_tx_id).sudo().exists()
if last_tx:
PaymentProcessing.remove_payment_transaction(last_tx)
PaymentProcessing.add_payment_transaction(transaction)
request.session['__website_sale_last_tx_id'] = transaction.id
return transaction.render_sale_button(order)
def payment_transaction(self, acquirer_id, save_token=False, so_id=None, access_token=None, token=None, **kwargs):
""" Json method that creates a payment.transaction, used to create a
transaction when the user clicks on 'pay now' button. After having
created the transaction, the event continues and the user is redirected
to the acquirer website.
:param int acquirer_id: id of a payment.acquirer record. If not set the
user is redirected to the checkout page
"""
# Ensure a payment acquirer is selected
if not acquirer_id:
return False
try:
acquirer_id = int(acquirer_id)
except:
return False
# Retrieve the sale order
if so_id:
env = request.env['sale.order']
domain = [('id', '=', so_id)]
if access_token:
env = env.sudo()
domain.append(('access_token', '=', access_token))
order = env.search(domain, limit=1)
else:
order = request.website.sale_get_order()
# Ensure there is something to proceed
if not order or (order and not order.order_line):
return False
assert order.partner_id.id != request.website.partner_id.id
# Create transaction
vals = {'acquirer_id': acquirer_id,
'return_url': '/shop/payment/validate'}
if save_token:
vals['type'] = 'form_save'
if token:
vals['payment_token_id'] = int(token)
transaction = order._create_payment_transaction(vals)
# store the new transaction into the transaction list and if there's an old one, we remove it
# until the day the ecommerce supports multiple orders at the same time
last_tx_id = request.session.get('__website_sale_last_tx_id')
last_tx = request.env['payment.transaction'].browse(last_tx_id).sudo().exists()
if last_tx:
PaymentProcessing.remove_payment_transaction(last_tx)
PaymentProcessing.add_payment_transaction(transaction)
request.session['__website_sale_last_tx_id'] = transaction.id
return transaction.render_sale_button(order)
def invoice_pay_form(self,
acquirer_id,
invoice_id,
save_token=False,
access_token=None,
**kwargs):
""" Json method that creates a payment.transaction, used to create a
transaction when the user clicks on 'pay now' button on the payment
form.
:return html: form containing all values related to the acquirer to
redirect customers to the acquirer website """
invoice_sudo = request.env['account.move'].sudo().browse(invoice_id)
if not invoice_sudo:
return False
try:
acquirer_id = int(acquirer_id)
except:
return False
if request.env.user._is_public():
save_token = False # we avoid to create a token for the public user
success_url = kwargs.get(
'success_url', "%s?%s" %
(invoice_sudo.access_url, url_encode(
{'access_token': access_token}) if access_token else ''))
vals = {
'acquirer_id': acquirer_id,
'return_url': success_url,
}
if save_token:
vals['type'] = 'form_save'
transaction = invoice_sudo._create_payment_transaction(vals)
PaymentProcessing.add_payment_transaction(transaction)
return transaction.render_invoice_button(
invoice_sudo,
submit_txt=_('Pay & Confirm'),
render_values={
'type':
'form_save' if save_token else 'form',
'alias_usage':
_('If we store your payment information on our server, subscription payments will be made automatically.'
),
})
def stripe_checkout_do_payment(self,
acquirer_id=None,
order_id=None,
invoice_id=None,
token=None,
**kwargs):
order = request.website.sale_get_order()
acquirer = request.env['payment.acquirer'].browse(int(acquirer_id))
assert order.partner_id.id != request.website.partner_id.id
# tx_obj => object that will use to create transcation record can be sale order or account invoice
tx_obj = order
vals = {
'payment_token_id': int(token) if token else None,
'return_url': '/shop/payment/validate',
'type': 'server2server'
}
if not token:
vals['acquirer_id'] = int(acquirer_id)
if order_id:
tx_obj, data = self._get_order_tx_vals(order_id, **kwargs)
vals.update(data)
elif invoice_id:
tx_obj, data = self._get_invoice_tx_vals(invoice_id, **kwargs)
vals.update(data)
if not token:
vals['acquirer_id'] = int(acquirer_id)
if not tx_obj:
return {
'status': False,
'message':
_("Error occurred while processing your transaction.")
}
transaction = tx_obj._create_payment_transaction(vals)
last_tx_id = request.session.get('__website_sale_last_tx_id')
last_tx = request.env['payment.transaction'].browse(
last_tx_id).sudo().exists()
if last_tx:
PaymentProcessing.remove_payment_transaction(last_tx)
PaymentProcessing.add_payment_transaction(transaction)
request.session['__website_sale_last_tx_id'] = transaction.id
res = transaction.create_payment(kwargs)
return res
def payment_transaction_token(self,
acquirer_id,
order_id,
save_token=False,
access_token=None,
**kwargs):
""" Json method that creates a payment.transaction, used to create a
transaction when the user clicks on 'pay now' button. After having
created the transaction, the event continues and the user is redirected
to the acquirer website.
:param int acquirer_id: id of a payment.acquirer record. If not set the
user is redirected to the checkout page
"""
# Ensure a payment acquirer is selected
if not acquirer_id:
return False
try:
acquirer_id = int(acquirer_id)
except:
return False
order = request.env['sale.order'].sudo().browse(order_id)
if not order or not order.order_line or not order.has_to_be_paid():
return False
# Create transaction
vals = {
'acquirer_id': acquirer_id,
'type': order._get_payment_type(),
'return_url': order.get_portal_url(),
}
transaction = order._create_payment_transaction(vals)
PaymentProcessing.add_payment_transaction(transaction)
return transaction.render_sale_button(
order,
submit_txt=_('Pay & Confirm'),
render_values={
'type':
order._get_payment_type(),
'alias_usage':
_('If we store your payment information on our server, subscription payments will be made automatically.'
),
})
def api_payment_transaction(self, acquirer_id, **kwargs):
""" Json method that creates a payment.transaction, used to create a
transaction when the user clicks on 'pay now' button. After having
created the transaction, the event continues and the user is redirected
to the acquirer website.
:param int acquirer_id: id of a payment.acquirer record. If not set the
user is redirected to the checkout page
"""
# Ensure a payment acquirer is selected
if not acquirer_id:
return False
try:
acquirer_id = int(acquirer_id)
except:
return False
order = request.website.sale_get_order()
# Ensure there is something to proceed
if not order or (order and not order.order_line):
return False
assert order.partner_id.id != request.website.partner_id.id
# Create transaction
vals = {
'acquirer_id': acquirer_id,
'return_url': '/shop/payment/validate'
}
transaction = order._create_payment_transaction(vals)
# store the new transaction into the transaction list and if there's an old one, we remove it
# until the day the ecommerce supports multiple orders at the same time
last_tx_id = request.session.get('__website_sale_last_tx_id')
last_tx = request.env['payment.transaction'].browse(
last_tx_id).sudo().exists()
if last_tx:
PaymentProcessing.remove_payment_transaction(last_tx)
PaymentProcessing.add_payment_transaction(transaction)
request.session['__website_sale_last_tx_id'] = transaction.id
return transaction.render_sale_api_values(order)
def payment(self, account_id, uuid=None, **kw):
account_res = request.env['sale.subscription']
invoice_res = request.env['account.move']
get_param = ''
if uuid:
account = account_res.sudo().browse(account_id)
if uuid != account.uuid:
raise NotFound()
else:
account = account_res.browse(account_id)
# no change
if int(kw.get('pm_id', 0)) > 0:
account.payment_token_id = int(kw['pm_id'])
# if no payment has been selected for this account, then we display redirect to /my/subscription with an error message
if len(account.payment_token_id) == 0:
get_param = 'message=No payment method have been selected for this subscription.&message_class=alert-danger'
return request.redirect('/my/subscription/%s/%s?%s' %
(account.id, account.uuid, get_param))
# we can't call _recurring_invoice because we'd miss 3DS, redoing the whole payment here
payment_token = account.payment_token_id
if payment_token:
invoice_values = account.sudo()._prepare_invoice()
new_invoice = invoice_res.sudo().create(invoice_values)
tx = account.sudo().with_context(off_session=False)._do_payment(
payment_token, new_invoice)[0]
PaymentProcessing.add_payment_transaction(tx)
if tx.html_3ds:
return tx.html_3ds
get_param = self.payment_succes_msg if tx.renewal_allowed else self.payment_fail_msg
if tx.renewal_allowed:
account.send_success_mail(tx, new_invoice)
msg_body = 'Manual payment succeeded. Payment reference: <a href=# data-oe-model=payment.transaction data-oe-id=%d>%s</a>; Amount: %s. Invoice <a href=# data-oe-model=account.move data-oe-id=%d>View Invoice</a>.' % (
tx.id, tx.reference, tx.amount, new_invoice.id)
account.message_post(body=msg_body)
elif tx.state != 'pending':
# a pending status might indicate that the customer has to authenticate, keep the invoice for post-processing
# NOTE: this might cause a lot of draft invoices to stay alive; i'm afraid this can't be helped
# since the payment flow is divided in 2 in that case and the draft invoice must survive after the request
new_invoice.unlink()
return request.redirect('/payment/process')
def yoco_verify_charge(self, **post):
""" Verify a payment transaction
Expects the result from the user input from flwpbf-inline.js popup"""
TX = request.env['payment.transaction']
tx = None
data = {
'acquirer_id': post.get('acquirer_id'),
'token': post.get('token'),
'amount': round(post.get('amount'), 2),
'currency': post.get('currency')
}
if post.get('tx_ref'):
tx = TX.sudo().search([('reference', '=', post.get('tx_ref'))])
if not tx:
tx_id = (post.get('id')
or request.session.get('sale_transaction_id')
or request.session.get('website_payment_tx_id'))
tx = TX.sudo().browse(int(tx_id))
if not tx:
raise werkzeug.exceptions.NotFound()
if tx.type == 'form_save' and tx.partner_id:
payment_token_id = request.env['payment.token'].sudo().create({
'acquirer_id':
tx.acquirer_id.id,
'partner_id':
tx.partner_id.id,
})
tx.payment_token_id = payment_token_id
response = tx._yoco_verify_charge(data)
else:
response = tx._yoco_verify_charge(data)
_logger.info('Yoco: entering form_feedback with post data %s',
pprint.pformat(response))
if response:
request.env['payment.transaction'].sudo().with_context(
lang=None).form_feedback(post, 'yoco')
# add the payment transaction into the session to let the page /payment/process to handle it
PaymentProcessing.add_payment_transaction(tx)
return "/payment/process"
def invoice_pay_form(self, acquirer_id, invoice_id, save_token=False, access_token=None, **kwargs):
""" Json method that creates a payment.transaction, used to create a
transaction when the user clicks on 'pay now' button on the payment
form.
:return html: form containing all values related to the acquirer to
redirect customers to the acquirer website """
success_url = kwargs.get('success_url', '/my')
invoice_sudo = request.env['account.invoice'].sudo().browse(invoice_id)
if not invoice_sudo:
return False
try:
acquirer_id = int(acquirer_id)
except:
return False
if request.env.user._is_public():
save_token = False # we avoid to create a token for the public user
vals = {
'acquirer_id': acquirer_id,
'return_url': success_url,
}
if save_token:
vals['type'] = 'form_save'
transaction = invoice_sudo._create_payment_transaction(vals)
PaymentProcessing.add_payment_transaction(transaction)
return transaction.render_invoice_button(
invoice_sudo,
submit_txt=_('Pay & Confirm'),
render_values={
'type': 'form_save' if save_token else 'form',
'alias_usage': _('If we store your payment information on our server, subscription payments will be made automatically.'),
}
)
def payment_transaction_token(self, acquirer_id, order_id, save_token=False, access_token=None, **kwargs):
""" Json method that creates a payment.transaction, used to create a
transaction when the user clicks on 'pay now' button. After having
created the transaction, the event continues and the user is redirected
to the acquirer website.
:param int acquirer_id: id of a payment.acquirer record. If not set the
user is redirected to the checkout page
"""
# Ensure a payment acquirer is selected
if not acquirer_id:
return False
try:
acquirer_id = int(acquirer_id)
except:
return False
order = request.env['sale.order'].sudo().browse(order_id)
if not order or not order.order_line or not order.has_to_be_paid():
return False
# Create transaction
vals = {
'acquirer_id': acquirer_id,
'type': order._get_payment_type(),
'return_url': order.get_portal_url(),
}
transaction = order._create_payment_transaction(vals)
PaymentProcessing.add_payment_transaction(transaction)
return transaction.render_sale_button(
order,
submit_txt=_('Pay & Confirm'),
render_values={
'type': order._get_payment_type(),
'alias_usage': _('If we store your payment information on our server, subscription payments will be made automatically.'),
}
)
def invoice_pay_token(self, invoice_id, pm_id=None, **kwargs):
""" Use a token to perform a s2s transaction """
error_url = kwargs.get('error_url', '/my')
access_token = kwargs.get('access_token')
params = {}
if access_token:
params['access_token'] = access_token
invoice_sudo = request.env['account.move'].sudo().browse(
invoice_id).exists()
if not invoice_sudo:
params['error'] = 'pay_invoice_invalid_doc'
return request.redirect(_build_url_w_params(error_url, params))
success_url = kwargs.get(
'success_url', "%s?%s" %
(invoice_sudo.access_url, url_encode(
{'access_token': access_token}) if access_token else ''))
try:
token = request.env['payment.token'].sudo().browse(int(pm_id))
except (ValueError, TypeError):
token = False
token_owner = invoice_sudo.partner_id if request.env.user._is_public(
) else request.env.user.partner_id
if not token or token.partner_id != token_owner:
params['error'] = 'pay_invoice_invalid_token'
return request.redirect(_build_url_w_params(error_url, params))
vals = {
'payment_token_id': token.id,
'type': 'server2server',
'return_url': _build_url_w_params(success_url, params),
}
tx = invoice_sudo._create_payment_transaction(vals)
PaymentProcessing.add_payment_transaction(tx)
params['success'] = 'pay_invoice'
return request.redirect('/payment/process')
def ogone_s2s_create(self, **post):
error = ''
acq = request.env['payment.acquirer'].browse(int(post.get('acquirer_id')))
try:
token = acq.s2s_process(post)
except Exception as e:
# synthax error: 'CHECK ERROR: |Not a valid date\n\n50001111: None'
token = False
error = str(e).splitlines()[0].split('|')[-1] or ''
if token and post.get('verify_validity'):
baseurl = request.env['ir.config_parameter'].sudo().get_param('web.base.url')
params = {
'accept_url': baseurl + '/payment/ogone/validate/accept',
'decline_url': baseurl + '/payment/ogone/validate/decline',
'exception_url': baseurl + '/payment/ogone/validate/exception',
'return_url': post.get('return_url', baseurl)
}
tx = token.validate(**params)
if tx and tx.html_3ds:
return tx.html_3ds
# add the payment transaction into the session to let the page /payment/process to handle it
PaymentProcessing.add_payment_transaction(tx)
return werkzeug.utils.redirect("/payment/process")
def payment_token(self, order_id, pm_id=None, **kwargs):
order = request.env['sale.order'].sudo().browse(order_id)
if not order:
return request.redirect("/my/orders")
if not order.order_line or pm_id is None or not order.has_to_be_paid():
return request.redirect(order.get_portal_url())
# try to convert pm_id into an integer, if it doesn't work redirect the user to the quote
try:
pm_id = int(pm_id)
except ValueError:
return request.redirect(order.get_portal_url())
# Create transaction
vals = {
'payment_token_id': pm_id,
'type': 'server2server',
'return_url': order.get_portal_url(),
}
tx = order._create_payment_transaction(vals)
PaymentProcessing.add_payment_transaction(tx)
return request.redirect('/payment/process')
def payment_token(self, order_id, pm_id=None, **kwargs):
order = request.env['sale.order'].sudo().browse(order_id)
if not order:
return request.redirect("/my/orders")
if not order.order_line or pm_id is None or not order.has_to_be_paid():
return request.redirect(order.get_portal_url())
# try to convert pm_id into an integer, if it doesn't work redirect the user to the quote
try:
pm_id = int(pm_id)
except ValueError:
return request.redirect(order.get_portal_url())
# Create transaction
vals = {
'payment_token_id': pm_id,
'type': 'server2server',
'return_url': order.get_portal_url(),
}
tx = order._create_payment_transaction(vals)
PaymentProcessing.add_payment_transaction(tx)
return request.redirect('/payment/process')
def transaction(self,
acquirer_id,
reference,
amount,
currency_id,
partner_id=False,
**kwargs):
acquirer = request.env['payment.acquirer'].browse(acquirer_id)
order_id = kwargs.get('order_id')
reference_values = order_id and {
'sale_order_ids': [(4, order_id)]
} or {}
reference = request.env['payment.transaction']._compute_reference(
values=reference_values, prefix=reference)
values = {
'acquirer_id':
int(acquirer_id),
'reference':
reference,
'amount':
float(amount),
'currency_id':
int(currency_id),
'partner_id':
partner_id,
'type':
'form_save'
if acquirer.save_token != 'none' and partner_id else 'form',
}
if order_id:
values['sale_order_ids'] = [(6, 0, [order_id])]
reference_values = order_id and {
'sale_order_ids': [(4, order_id)]
} or {}
reference_values.update(acquirer_id=int(acquirer_id))
values['reference'] = request.env[
'payment.transaction']._compute_reference(values=reference_values,
prefix=reference)
tx = request.env['payment.transaction'].sudo().with_context(
lang=None).create(values)
secret = request.env['ir.config_parameter'].sudo().get_param(
'database.secret')
token_str = '%s%s%s' % (
tx.id, tx.reference,
float_repr(tx.amount,
precision_digits=tx.currency_id.decimal_places))
token = hmac.new(secret.encode('utf-8'), token_str.encode('utf-8'),
hashlib.sha256).hexdigest()
tx.return_url = '/website_payment/confirm?tx_id=%d&access_token=%s' % (
tx.id, token)
PaymentProcessing.add_payment_transaction(tx)
render_values = {
'partner_id': partner_id,
}
if not order_id:
acquirer = acquirer.with_context(stripe_fees=True)
return acquirer.sudo().render(tx.reference,
float(amount),
int(currency_id),
values=render_values)
def transaction(self,
acquirer_id,
reference,
amount,
currency_id,
partner_id=False,
**kwargs):
acquirer = request.env["payment.acquirer"].browse(acquirer_id)
order_id = kwargs.get("order_id")
# BizzAppDev Customization Start
invoice_id = kwargs.get("invoice_id")
# BizzAppDev Customization End
reference_values = (order_id and {
"sale_order_ids": [(4, order_id)]
} or {})
# BizzAppDev Customization Start
if invoice_id:
reference_values.update({"invoice_ids": [(4, int(invoice_id))]})
# BizzAppDev Customization End
reference = request.env["payment.transaction"]._compute_reference(
values=reference_values, prefix=reference)
values = {
"acquirer_id":
int(acquirer_id),
"reference":
reference,
"amount":
float(amount),
"currency_id":
int(currency_id),
"partner_id":
partner_id,
"type":
"form_save"
if acquirer.save_token != "none" and partner_id else "form",
}
if order_id:
values["sale_order_ids"] = [(6, 0, [order_id])]
# BizzAppDev Customization Start
if invoice_id:
values["invoice_ids"] = [(6, 0, [invoice_id])]
# BizzAppDev Customization End
reference_values = (order_id and {
"sale_order_ids": [(4, order_id)]
} or {})
if invoice_id:
reference_values.update({"invoice_ids": [(4, int(invoice_id))]})
reference_values.update(acquirer_id=int(acquirer_id))
values["reference"] = request.env[
"payment.transaction"]._compute_reference(values=reference_values,
prefix=reference)
tx = (request.env["payment.transaction"].sudo().with_context(
lang=None).create(values))
tx = request.env["payment.transaction"].sudo().browse(tx.id)
secret = (request.env["ir.config_parameter"].sudo().get_param(
"database.secret"))
token_str = "%s%s%s" % (
tx.id,
tx.reference,
round(tx.amount, tx.currency_id.decimal_places),
)
token = hmac.new(secret.encode("utf-8"), token_str.encode("utf-8"),
hashlib.sha256).hexdigest()
tx.return_url = "/website_payment/confirm?tx_id=%d&access_token=%s" % (
tx.id,
token,
)
PaymentProcessing.add_payment_transaction(tx)
render_values = {
"partner_id": partner_id,
}
return acquirer.sudo().render(tx.reference,
float(amount),
int(currency_id),
values=render_values)
def payment_token(self, pm_id=None, **kwargs):
""" OVERRIDING METHOD FROM odoo/addons/website_sale/controllers/main.py
Method that handles payment using saved tokens
:param int pm_id: id of the payment.token that we want to use to pay.
This route is requested after payment submission :
/shop/payment/solana/submit - it's only called if the buyer doesn't provide an existing payment token
"""
# order already created, get it
sales_order = request.website.sale_get_order()
_logger.info(f'received token for sales_order: {sales_order.id}')
_logger.info(f'processing token for sales_order: {sales_order.id}')
# do not crash if the user has already paid and try to pay again
if not sales_order:
_logger.error('no order found')
return request.redirect('/shop/?error=no_order')
# see overriden method
assert sales_order.partner_id.id != request.website.partner_id.id
try:
# pm_id is passed, make sure it's a valid int
pm_id = int(pm_id)
except ValueError:
_logger.error('invalid token id')
return request.redirect('/shop/?error=invalid_token_id')
# payment token already created, get it
token = request.env['payment.token'].sudo().browse(pm_id)
if not token:
return request.redirect('/shop/?error=token_not_found')
# has the transaction already been created?
tx_id = request.session["__website_sale_last_tx_id"]
if tx_id:
# transaction was already established in /shop/payment/solana/submit
transaction = request.env['payment.transaction'].sudo().browse(
tx_id)
PaymentProcessing.add_payment_transaction(transaction)
# clear the tx in session, because we're done with it
request.session["__website_sale_last_tx_id"] = None
return request.redirect('/shop/payment/validate')
else:
# transaction hasn't been created
tx_val = {
'payment_token_id': pm_id,
'return_url': '/shop/payment/validate'
}
transaction = sales_order._create_payment_transaction(tx_val)
_logger.info(
f'created transaction: {transaction.id} for payment token: {token.id}'
)
_logger.info(f'token.acquirer_ref = {token.acquirer_ref}')
if transaction.acquirer_id.is_cryptocurrency:
_logger.info(
f'Processing cryptocurrency payment acquirer: {transaction.acquirer_id.name}'
)
_logger.info(
f'setting sales_order state to "sent" for sales_order: {sales_order.id}'
)
sales_order.sudo().update({'state': 'sent'})
_logger.info(
f'setting transaction state to "pending" for sales_order: {sales_order.id}'
)
transaction.sudo().update({'state': 'pending'})
PaymentProcessing.add_payment_transaction(transaction)
return request.redirect('/shop/payment/validate')
PaymentProcessing.add_payment_transaction(transaction)
return request.redirect('/payment/process')
def solana_transaction(self, verify_validity=False, **kwargs):
"""
Function creates a transaction and payment token using the sessions sales order
Calls SolanaSalesOrder.salesorder_payment_sync()
:param verify_validity:
:param kwargs:
:return:
"""
sales_order = request.website.sale_get_order()
_logger.info(f'received sales_order: {sales_order.id}')
_logger.info(f'processing sales_order: {sales_order.id}')
# Ensure there is something to proceed
if not sales_order or (sales_order and not sales_order.order_line):
return False
assert sales_order.partner_id.id != request.website.partner_id.id
payment_acquirer_id = int(kwargs.get('acquirer_id'))
payment_partner_id = int(kwargs.get('partner_id'))
# TODO verify the wallet_address is a valid solana address
# TODO verify that the specified address has the needed amount in it
source_wallet_address = kwargs.get('wallet_address')
# define payment token
payment_token = {
'name':
str(source_wallet_address).strip() + ' - ' + kwargs.get('type'),
# name = 'source_wallet_address' + ' - payment_type'; eg: ejh98hja... - SOL/BTC/USDC/ETH
'partner_id':
payment_partner_id, # partner_id creating sales order
'active': True,
'acquirer_id':
payment_acquirer_id, # surrogate key for payment acquirer
'acquirer_ref': 'cryptocurrency' # this should be the tx hash?
}
# TODO reuse token
_logger.info(
f'creating payment token for sales_order: {sales_order.id}')
token = request.env['payment.token'].sudo().create(payment_token)
token_id = token.id
token_short_name = token.short_name
# assign values for transaction creation
tx_val = {
'amount': sales_order.amount_total,
'reference': sales_order.name,
'currency_id': sales_order.currency_id.id,
'partner_id':
sales_order.partner_id.id, # Referencing the Sale Order Partner ID
'payment_token_id': token_id, # Associating the Payment Token ID.
'acquirer_id': payment_acquirer_id, # Payment Acquirer - Solana
'state':
'pending', # tx is pending, because the customer will know the address to send the tx to,
# but hasn't yet sent it
}
_logger.info(
f'getting the transaction for sales_order: {sales_order.id}')
# transaction = sales_order._create_payment_transaction(tx_val)
transaction = sales_order.get_portal_last_transaction()
if transaction.id is False:
transaction = sales_order._create_payment_transaction(tx_val)
_logger.info(f'created transaction: {transaction.id}')
else:
_logger.info(f'retrieved transaction: {transaction.id}')
# store the new transaction into the transaction list and if there's an old one, we remove it
# until the day the ecommerce supports multiple orders at the same time
last_tx_id = request.session.get('__website_sale_last_tx_id')
last_tx = request.env['payment.transaction'].browse(
last_tx_id).sudo().exists()
if last_tx:
PaymentProcessing.remove_payment_transaction(last_tx)
PaymentProcessing.add_payment_transaction(transaction)
request.session['__website_sale_last_tx_id'] = transaction.id
# Sale Order is quotation sent
# , so the state should be set to "sent"
# , until the transaction has been verified
_logger.info(
f'setting sales_order state to "sent" for sales_order: {sales_order.id}'
)
request.env.user.sale_order_ids.sudo().update({'state': 'sent'})
if transaction:
res = {
'result': True,
'id': token_id,
'short_name': token_short_name,
'3d_secure': False,
'verified': False,
}
if verify_validity != False:
token.validate()
res['verified'] = token.verified
return res
def monero_transaction(self, verify_validity=False, **kwargs):
"""
Function creates a transaction and
payment token using the sessions sales order
Calls MoneroSalesOrder.salesorder_payment_sync()
:param verify_validity:
:param kwargs:
:return:
"""
sales_order = request.website.sale_get_order()
_logger.info(f"received sales_order: {sales_order.id}")
_logger.info(f"processing sales_order: {sales_order.id}")
# Ensure there is something to proceed
if not sales_order or (sales_order and not sales_order.order_line):
return False
assert sales_order.partner_id.id != request.website.partner_id.id
# at this time the sales order has to be in xmr
# the user cannot use a fiat pricelist when checking out
# this won't be fixed until after a job is added to automatically
# update res.currency.rate
currency = request.env["res.currency"].sudo().browse(
sales_order.currency_id.id)
if currency.name != "XMR":
raise Exception(
"This pricelist is not supported, go back and select the "
"Monero Pricelist")
payment_acquirer_id = int(kwargs.get("acquirer_id"))
payment_partner_id = int(kwargs.get("partner_id"))
wallet_sub_address = SubAddress(kwargs.get("wallet_address"))
# define payment token
payment_token = {
"name": wallet_sub_address.__repr__(),
"partner_id": payment_partner_id,
# partner_id creating sales order
"active": False,
# token shoudn't be active, the subaddress shouldn't be reused
"acquirer_id": payment_acquirer_id,
# surrogate key for payment acquirer
"acquirer_ref": "payment.payment_acquirer_monero_rpc",
}
_logger.info(f"creating payment token "
f"for sales_order: {sales_order.id}")
token = request.env["payment.token"].sudo().create(payment_token)
token_id = token.id
token_short_name = token.short_name
# assign values for transaction creation
tx_val = {
"amount": sales_order.amount_total,
"reference": sales_order.name,
"currency_id": sales_order.currency_id.id,
"partner_id": sales_order.partner_id.id,
# Referencing the Sale Order Partner ID
"payment_token_id": token_id, # Associating the Payment Token ID.
"acquirer_id": payment_acquirer_id, # Payment Acquirer - Monero
"state": "pending",
# tx is pending,
# because the customer will know the address to send the tx to,
# but hasn't yet sent it
}
_logger.info(f"getting the transaction "
f"for sales_order: {sales_order.id}")
# transaction = sales_order._create_payment_transaction(tx_val)
transaction = sales_order.get_portal_last_transaction()
if transaction.id is False:
transaction = sales_order._create_payment_transaction(tx_val)
_logger.info(f"created transaction: {transaction.id}")
else:
_logger.info(f"retrieved transaction: {transaction.id}")
# store the new transaction into
# the transaction list and if there's an old one, we remove it
# until the day the ecommerce supports multiple orders at the same time
last_tx_id = request.session.get("__website_sale_last_tx_id")
last_tx = request.env["payment.transaction"].browse(
last_tx_id).sudo().exists()
if last_tx:
PaymentProcessing.remove_payment_transaction(last_tx)
PaymentProcessing.add_payment_transaction(transaction)
request.session["__website_sale_last_tx_id"] = transaction.id
# Sale Order is quotation sent
# , so the state should be set to "sent"
# , until the transaction has been verified
_logger.info(f'setting sales_order state to "sent" '
f"for sales_order: {sales_order.id}")
request.env.user.sale_order_ids.sudo().update({
"require_payment": "true",
"state": "sent"
})
payment_acquirer = (
request.env["payment.acquirer"].sudo().browse(payment_acquirer_id))
# set queue channel and max_retries settings
# for queue depending on num conf settings
num_conf_req = int(payment_acquirer.num_confirmation_required)
if num_conf_req == 0:
queue_channel = "monero_zeroconf_processing"
queue_max_retries = 44
else:
queue_channel = "monero_secure_processing"
queue_max_retries = num_conf_req * 25
# Add payment token and sale order to transaction processing queue
sales_order.with_delay(
channel=queue_channel,
max_retries=queue_max_retries).process_transaction(
transaction, token, num_conf_req)
if transaction:
res = {
"result": True,
"id": token_id,
"short_name": token_short_name,
"3d_secure": False,
"verified": False,
}
if verify_validity is not False:
token.validate()
res["verified"] = token.verified
return res
def payment_token(self, pm_id=None, **kwargs):
"""OVERRIDING METHOD FROM odoo/addons/website_sale/controllers/main.py
Method that handles payment using saved tokens
:param int pm_id: id of the payment.token that we want to use to pay.
This route is requested after payment submission :
/shop/payment/monero/submit - it's called everytime,
since we will use monero sub addresses
as one time addresses
"""
# order already created, get it
sales_order = request.website.sale_get_order()
_logger.info(f"received token for sales_order: {sales_order.id}")
_logger.info(f"processing token for sales_order: {sales_order.id}")
# do not crash if the user has already paid and try to pay again
if not sales_order:
_logger.error("no order found")
return request.redirect("/shop/?error=no_order")
# see overriden method
assert sales_order.partner_id.id != request.website.partner_id.id
try:
# pm_id is passed, make sure it's a valid int
pm_id = int(pm_id)
except ValueError:
_logger.error("invalid token id")
return request.redirect("/shop/?error=invalid_token_id")
# payment token already created, get it
token = request.env["payment.token"].sudo().browse(pm_id)
if not token:
return request.redirect("/shop/?error=token_not_found")
# has the transaction already been created?
tx_id = request.session["__website_sale_last_tx_id"]
if tx_id:
# transaction was already
# established in /shop/payment/monero/submit
transaction = request.env["payment.transaction"].sudo().browse(
tx_id)
PaymentProcessing.add_payment_transaction(transaction)
# clear the tx in session, because we're done with it
request.session["__website_sale_last_tx_id"] = None
return request.redirect("/shop/payment/validate")
else:
# transaction hasn't been created
tx_val = {
"payment_token_id": pm_id,
"return_url": "/shop/payment/validate"
}
transaction = sales_order._create_payment_transaction(tx_val)
_logger.info(f"created transaction: {transaction.id} "
f"for payment token: {token.id}")
if transaction.acquirer_id.is_cryptocurrency:
_logger.info(
f"Processing cryptocurrency "
f"payment acquirer: {transaction.acquirer_id.name}")
_logger.info(f"setting sales_order state to "
f'"sent" for sales_order: {sales_order.id}')
sales_order.sudo().update({"state": "sent"})
_logger.info(f"setting transaction state to "
f'"pending" for sales_order: {sales_order.id}')
transaction.sudo().update({"state": "pending"})
PaymentProcessing.add_payment_transaction(transaction)
return request.redirect("/shop/payment/validate")
PaymentProcessing.add_payment_transaction(transaction)
return request.redirect("/payment/process")