qdp-odoo
01216345e2
It was very confusing for the user to distinct account.payment and payment.transaction. From now on, the transactions are technical objects and, in the backend, we only refer to it in log messages (Front end will be adapted in the same fashion later on). They are hidden in debug mode in accounting\configuration\payments as their purpose is now purely technical/log This commit also aims to reduce the gap between the accounting app and the transactions: account.payment objects are created/validated upon completion of transaction. To ease the capture/voiding of pending transactions, the related buttons are now displayed directly on the SO/invoice instead of the transactions. Was task: https://www.odoo.com/web#id=35857&view_type=form&model=project.task&action=333&active_id=967&menu_id=4720 Was PR #24043 [FIX] add domain based on journal to payment tokens Was opw: https://www.odoo.com/web?debug#id=1828206&view_type=form&model=project.task&menu_id=5200
223 lines
11 KiB
Python
223 lines
11 KiB
Python
# coding: utf-8
|
|
|
|
import json
|
|
import logging
|
|
|
|
import dateutil.parser
|
|
import pytz
|
|
from werkzeug import urls
|
|
|
|
from odoo import api, fields, models, _
|
|
from odoo.addons.payment.models.payment_acquirer import ValidationError
|
|
from odoo.addons.payment_paypal.controllers.main import PaypalController
|
|
from odoo.tools.float_utils import float_compare
|
|
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class AcquirerPaypal(models.Model):
|
|
_inherit = 'payment.acquirer'
|
|
|
|
provider = fields.Selection(selection_add=[('paypal', 'Paypal')])
|
|
paypal_email_account = fields.Char('Paypal Email ID', required_if_provider='paypal', groups='base.group_user')
|
|
paypal_seller_account = fields.Char(
|
|
'Paypal Merchant ID', groups='base.group_user',
|
|
help='The Merchant ID is used to ensure communications coming from Paypal are valid and secured.')
|
|
paypal_use_ipn = fields.Boolean('Use IPN', default=True, help='Paypal Instant Payment Notification', groups='base.group_user')
|
|
paypal_pdt_token = fields.Char(string='Paypal PDT Token', required_if_provider='paypal', help='Payment Data Transfer allows you to receive notification of successful payments as they are made.', groups='base.group_user')
|
|
# Server 2 server
|
|
paypal_api_enabled = fields.Boolean('Use Rest API', default=False)
|
|
paypal_api_username = fields.Char('Rest API Username', groups='base.group_user')
|
|
paypal_api_password = fields.Char('Rest API Password', groups='base.group_user')
|
|
paypal_api_access_token = fields.Char('Access Token', groups='base.group_user')
|
|
paypal_api_access_token_validity = fields.Datetime('Access Token Validity', groups='base.group_user')
|
|
# Default paypal fees
|
|
fees_dom_fixed = fields.Float(default=0.35)
|
|
fees_dom_var = fields.Float(default=3.4)
|
|
fees_int_fixed = fields.Float(default=0.35)
|
|
fees_int_var = fields.Float(default=3.9)
|
|
|
|
def _get_feature_support(self):
|
|
"""Get advanced feature support by provider.
|
|
|
|
Each provider should add its technical in the corresponding
|
|
key for the following features:
|
|
* fees: support payment fees computations
|
|
* authorize: support authorizing payment (separates
|
|
authorization and capture)
|
|
* tokenize: support saving payment data in a payment.tokenize
|
|
object
|
|
"""
|
|
res = super(AcquirerPaypal, self)._get_feature_support()
|
|
res['fees'].append('paypal')
|
|
return res
|
|
|
|
@api.model
|
|
def _get_paypal_urls(self, environment):
|
|
""" Paypal URLS """
|
|
if environment == 'prod':
|
|
return {
|
|
'paypal_form_url': 'https://www.paypal.com/cgi-bin/webscr',
|
|
'paypal_rest_url': 'https://api.paypal.com/v1/oauth2/token',
|
|
}
|
|
else:
|
|
return {
|
|
'paypal_form_url': 'https://www.sandbox.paypal.com/cgi-bin/webscr',
|
|
'paypal_rest_url': 'https://api.sandbox.paypal.com/v1/oauth2/token',
|
|
}
|
|
|
|
@api.multi
|
|
def paypal_compute_fees(self, amount, currency_id, country_id):
|
|
""" Compute paypal fees.
|
|
|
|
:param float amount: the amount to pay
|
|
:param integer country_id: an ID of a res.country, or None. This is
|
|
the customer's country, to be compared to
|
|
the acquirer company country.
|
|
:return float fees: computed fees
|
|
"""
|
|
if not self.fees_active:
|
|
return 0.0
|
|
country = self.env['res.country'].browse(country_id)
|
|
if country and self.company_id.country_id.id == country.id:
|
|
percentage = self.fees_dom_var
|
|
fixed = self.fees_dom_fixed
|
|
else:
|
|
percentage = self.fees_int_var
|
|
fixed = self.fees_int_fixed
|
|
fees = (percentage / 100.0 * amount + fixed) / (1 - percentage / 100.0)
|
|
return fees
|
|
|
|
@api.multi
|
|
def paypal_form_generate_values(self, values):
|
|
base_url = self.env['ir.config_parameter'].sudo().get_param('web.base.url')
|
|
|
|
paypal_tx_values = dict(values)
|
|
paypal_tx_values.update({
|
|
'cmd': '_xclick',
|
|
'business': self.paypal_email_account,
|
|
'item_name': '%s: %s' % (self.company_id.name, values['reference']),
|
|
'item_number': values['reference'],
|
|
'amount': values['amount'],
|
|
'currency_code': values['currency'] and values['currency'].name or '',
|
|
'address1': values.get('partner_address'),
|
|
'city': values.get('partner_city'),
|
|
'country': values.get('partner_country') and values.get('partner_country').code or '',
|
|
'state': values.get('partner_state') and (values.get('partner_state').code or values.get('partner_state').name) or '',
|
|
'email': values.get('partner_email'),
|
|
'zip_code': values.get('partner_zip'),
|
|
'first_name': values.get('partner_first_name'),
|
|
'last_name': values.get('partner_last_name'),
|
|
'paypal_return': urls.url_join(base_url, PaypalController._return_url),
|
|
'notify_url': urls.url_join(base_url, PaypalController._notify_url),
|
|
'cancel_return': urls.url_join(base_url, PaypalController._cancel_url),
|
|
'handling': '%.2f' % paypal_tx_values.pop('fees', 0.0) if self.fees_active else False,
|
|
'custom': json.dumps({'return_url': '%s' % paypal_tx_values.pop('return_url')}) if paypal_tx_values.get('return_url') else False,
|
|
})
|
|
return paypal_tx_values
|
|
|
|
@api.multi
|
|
def paypal_get_form_action_url(self):
|
|
return self._get_paypal_urls(self.environment)['paypal_form_url']
|
|
|
|
|
|
class TxPaypal(models.Model):
|
|
_inherit = 'payment.transaction'
|
|
|
|
paypal_txn_type = fields.Char('Transaction type')
|
|
|
|
# --------------------------------------------------
|
|
# FORM RELATED METHODS
|
|
# --------------------------------------------------
|
|
|
|
@api.model
|
|
def _paypal_form_get_tx_from_data(self, data):
|
|
reference, txn_id = data.get('item_number'), data.get('txn_id')
|
|
if not reference or not txn_id:
|
|
error_msg = _('Paypal: received data with missing reference (%s) or txn_id (%s)') % (reference, txn_id)
|
|
_logger.info(error_msg)
|
|
raise ValidationError(error_msg)
|
|
|
|
# find tx -> @TDENOTE use txn_id ?
|
|
txs = self.env['payment.transaction'].search([('reference', '=', reference)])
|
|
if not txs or len(txs) > 1:
|
|
error_msg = 'Paypal: received data for reference %s' % (reference)
|
|
if not txs:
|
|
error_msg += '; no order found'
|
|
else:
|
|
error_msg += '; multiple order found'
|
|
_logger.info(error_msg)
|
|
raise ValidationError(error_msg)
|
|
return txs[0]
|
|
|
|
@api.multi
|
|
def _paypal_form_get_invalid_parameters(self, data):
|
|
invalid_parameters = []
|
|
_logger.info('Received a notification from Paypal with IPN version %s', data.get('notify_version'))
|
|
if data.get('test_ipn'):
|
|
_logger.warning(
|
|
'Received a notification from Paypal using sandbox'
|
|
),
|
|
|
|
# TODO: txn_id: shoudl be false at draft, set afterwards, and verified with txn details
|
|
if self.acquirer_reference and data.get('txn_id') != self.acquirer_reference:
|
|
invalid_parameters.append(('txn_id', data.get('txn_id'), self.acquirer_reference))
|
|
# check what is buyed
|
|
if float_compare(float(data.get('mc_gross', '0.0')), (self.amount + self.fees), 2) != 0:
|
|
invalid_parameters.append(('mc_gross', data.get('mc_gross'), '%.2f' % self.amount)) # mc_gross is amount + fees
|
|
if data.get('mc_currency') != self.currency_id.name:
|
|
invalid_parameters.append(('mc_currency', data.get('mc_currency'), self.currency_id.name))
|
|
if 'handling_amount' in data and float_compare(float(data.get('handling_amount')), self.fees, 2) != 0:
|
|
invalid_parameters.append(('handling_amount', data.get('handling_amount'), self.fees))
|
|
# check buyer
|
|
if self.payment_token_id and data.get('payer_id') != self.payment_token_id.acquirer_ref:
|
|
invalid_parameters.append(('payer_id', data.get('payer_id'), self.payment_token_id.acquirer_ref))
|
|
# check seller
|
|
if data.get('receiver_id') and self.acquirer_id.paypal_seller_account and data['receiver_id'] != self.acquirer_id.paypal_seller_account:
|
|
invalid_parameters.append(('receiver_id', data.get('receiver_id'), self.acquirer_id.paypal_seller_account))
|
|
if not data.get('receiver_id') or not self.acquirer_id.paypal_seller_account:
|
|
# Check receiver_email only if receiver_id was not checked.
|
|
# In Paypal, this is possible to configure as receiver_email a different email than the business email (the login email)
|
|
# In Odoo, there is only one field for the Paypal email: the business email. This isn't possible to set a receiver_email
|
|
# different than the business email. Therefore, if you want such a configuration in your Paypal, you are then obliged to fill
|
|
# the Merchant ID in the Paypal payment acquirer in Odoo, so the check is performed on this variable instead of the receiver_email.
|
|
# At least one of the two checks must be done, to avoid fraudsters.
|
|
if data.get('receiver_email') != self.acquirer_id.paypal_email_account:
|
|
invalid_parameters.append(('receiver_email', data.get('receiver_email'), self.acquirer_id.paypal_email_account))
|
|
|
|
return invalid_parameters
|
|
|
|
@api.multi
|
|
def _paypal_form_validate(self, data):
|
|
status = data.get('payment_status')
|
|
res = {
|
|
'acquirer_reference': data.get('txn_id'),
|
|
'paypal_txn_type': data.get('payment_type'),
|
|
}
|
|
if status in ['Completed', 'Processed']:
|
|
_logger.info('Validated Paypal payment for tx %s: set as done' % (self.reference))
|
|
try:
|
|
# dateutil and pytz don't recognize abbreviations PDT/PST
|
|
tzinfos = {
|
|
'PST': -8 * 3600,
|
|
'PDT': -7 * 3600,
|
|
}
|
|
date = dateutil.parser.parse(data.get('payment_date'), tzinfos=tzinfos).astimezone(pytz.utc)
|
|
except:
|
|
date = fields.Datetime.now()
|
|
res.update(date=date)
|
|
self._set_transaction_done()
|
|
return self.write(res)
|
|
elif status in ['Pending', 'Expired']:
|
|
_logger.info('Received notification for Paypal payment %s: set as pending' % (self.reference))
|
|
res.update(state_message=data.get('pending_reason', ''))
|
|
self._set_transaction_pending()
|
|
return self.write(res)
|
|
else:
|
|
error = 'Received unrecognized status for Paypal payment %s: %s, set as error' % (self.reference, status)
|
|
_logger.info(error)
|
|
res.update(state_message=error)
|
|
self._set_transaction_cancel()
|
|
return self.write(res)
|