def _compute_draft_quantity_count(self, product_template_ids,
product_variant_ids, wh_location_ids):
""" Overrides to computes the valuations of the stock. """
res = super()._compute_draft_quantity_count(product_template_ids,
product_variant_ids,
wh_location_ids)
domain = self._product_domain(product_template_ids,
product_variant_ids)
company = self.env['stock.location'].browse(wh_location_ids).mapped(
'company_id')
svl = self.env['stock.valuation.layer'].search(domain +
[('company_id', '=',
company.id)])
currency = svl.currency_id or self.env.company.currency_id
total_quantity = sum(svl.mapped('quantity'))
# Because we can have negative quantities, `total_quantity` may be equal to zero even if the warehouse's `quantity` is positive.
if svl and not float_is_zero(
total_quantity,
precision_rounding=svl.product_id.uom_id.rounding):
def filter_on_locations(layer):
return layer.stock_move_id.location_dest_id.id in wh_location_ids or layer.stock_move_id.location_id.id in wh_location_ids
quantity = sum(
svl.filtered(filter_on_locations).mapped('quantity'))
value = sum(svl.mapped('value')) * (quantity / total_quantity)
else:
value = 0
value = float_repr(value, precision_digits=currency.decimal_places)
if currency.position == 'after':
value = '%s %s' % (value, currency.symbol)
else:
value = '%s %s' % (currency.symbol, value)
res['value'] = value
return res
def confirm(self, **kw):
tx_id = int(kw.get('tx_id', 0))
access_token = kw.get('access_token')
if tx_id:
if access_token:
tx = request.env['payment.transaction'].sudo().browse(tx_id)
secret = request.env['ir.config_parameter'].sudo().get_param('database.secret')
valid_token_str = '%s%s%s' % (tx.id, tx.reference, float_repr(tx.amount, precision_digits=tx.currency_id.decimal_places))
valid_token = hmac.new(secret.encode('utf-8'), valid_token_str.encode('utf-8'), hashlib.sha256).hexdigest()
if not consteq(ustr(valid_token), access_token):
raise werkzeug.exceptions.NotFound
else:
tx = request.env['payment.transaction'].browse(tx_id)
if tx.state in ['done', 'authorized']:
status = 'success'
message = tx.acquirer_id.done_msg
elif tx.state == 'pending':
status = 'warning'
message = tx.acquirer_id.pending_msg
else:
status = 'danger'
message = tx.state_message or _('An error occured during the processing of this payment')
PaymentProcessing.remove_payment_transaction(tx)
return request.render('payment.confirm', {'tx': tx, 'status': status, 'message': message})
else:
return request.redirect('/my/home')
def payment_token(self, pm_id, reference, amount, currency_id, partner_id=False, return_url=None, **kwargs):
token = request.env['payment.token'].browse(int(pm_id))
order_id = kwargs.get('order_id')
if not token:
return request.redirect('/website_payment/pay?error_msg=%s' % _('Cannot setup the payment.'))
values = {
'acquirer_id': token.acquirer_id.id,
'reference': reference,
'amount': float(amount),
'currency_id': int(currency_id),
'partner_id': int(partner_id),
'payment_token_id': int(pm_id),
'type': 'server2server',
'return_url': return_url,
}
if order_id:
values['sale_order_ids'] = [(6, 0, [int(order_id)])]
tx = request.env['payment.transaction'].sudo().with_context(lang=None).create(values)
PaymentProcessing.add_payment_transaction(tx)
try:
tx.s2s_do_transaction()
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 = return_url or '/website_payment/confirm?tx_id=%d&access_token=%s' % (tx.id, token)
except Exception as e:
_logger.exception(e)
return request.redirect('/payment/process')
def ogone_form_generate_values(self, values):
base_url = self.env['ir.config_parameter'].sudo().get_param(
'web.base.url')
ogone_tx_values = dict(values)
param_plus = {'return_url': ogone_tx_values.pop('return_url', False)}
temp_ogone_tx_values = {
'PSPID':
self.ogone_pspid,
'ORDERID':
values['reference'],
'AMOUNT':
float_repr(float_round(values['amount'], 2) * 100, 0),
'CURRENCY':
values['currency'] and values['currency'].name or '',
'LANGUAGE':
values.get('partner_lang'),
'CN':
values.get('partner_name'),
'EMAIL':
values.get('partner_email'),
'OWNERZIP':
values.get('partner_zip'),
'OWNERADDRESS':
values.get('partner_address'),
'OWNERTOWN':
values.get('partner_city'),
'OWNERCTY':
values.get('partner_country')
and values.get('partner_country').code or '',
'OWNERTELNO':
values.get('partner_phone'),
'ACCEPTURL':
urls.url_join(base_url, OgoneController._accept_url),
'DECLINEURL':
urls.url_join(base_url, OgoneController._decline_url),
'EXCEPTIONURL':
urls.url_join(base_url, OgoneController._exception_url),
'CANCELURL':
urls.url_join(base_url, OgoneController._cancel_url),
'PARAMPLUS':
url_encode(param_plus),
}
if self.save_token in ['ask', 'always']:
temp_ogone_tx_values.update({
'ALIAS':
'FLECTRA-NEW-ALIAS-%s' % time.time(), # something unique,
'ALIASUSAGE':
values.get('alias_usage') or self.ogone_alias_usage,
})
shasign = self._ogone_generate_shasign('in', temp_ogone_tx_values)
temp_ogone_tx_values['SHASIGN'] = shasign
ogone_tx_values.update(temp_ogone_tx_values)
return ogone_tx_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')
invoice_id = kwargs.get('invoice_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])]
elif invoice_id:
values['invoice_ids'] = [(6, 0, [invoice_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,
}
return acquirer.sudo().render(tx.reference, float(amount), int(currency_id), values=render_values)
def authorize_form_generate_values(self, values):
self.ensure_one()
# State code is only supported in US, use state name by default
# See https://developer.authorize.net/api/reference/
state = values['partner_state'].name if values.get(
'partner_state') else ''
if values.get('partner_country') and values.get(
'partner_country') == self.env.ref('base.us', False):
state = values['partner_state'].code if values.get(
'partner_state') else ''
billing_state = values['billing_partner_state'].name if values.get(
'billing_partner_state') else ''
if values.get('billing_partner_country') and values.get(
'billing_partner_country') == self.env.ref('base.us', False):
billing_state = values['billing_partner_state'].code if values.get(
'billing_partner_state') else ''
base_url = self.env['ir.config_parameter'].get_param('web.base.url')
authorize_tx_values = dict(values)
temp_authorize_tx_values = {
'x_login':
self.authorize_login,
'x_trans_key':
self.authorize_transaction_key,
'x_amount':
float_repr(
values['amount'], values['currency'].decimal_places
if values['currency'] else 2),
'x_show_form':
'PAYMENT_FORM',
'x_type':
'AUTH_CAPTURE' if not self.capture_manually else 'AUTH_ONLY',
'x_method':
'CC',
'x_fp_sequence':
'%s%s' % (self.id, int(time.time())),
'x_version':
'3.1',
'x_relay_response':
'TRUE',
'x_fp_timestamp':
str(int(time.time())),
'x_relay_url':
urls.url_join(base_url, AuthorizeController._return_url),
'x_cancel_url':
urls.url_join(base_url, AuthorizeController._cancel_url),
'x_currency_code':
values['currency'] and values['currency'].name or '',
'address':
values.get('partner_address'),
'city':
values.get('partner_city'),
'country':
values.get('partner_country')
and values.get('partner_country').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'),
'phone':
values.get('partner_phone'),
'state':
state,
'billing_address':
values.get('billing_partner_address'),
'billing_city':
values.get('billing_partner_city'),
'billing_country':
values.get('billing_partner_country')
and values.get('billing_partner_country').name or '',
'billing_email':
values.get('billing_partner_email'),
'billing_zip_code':
values.get('billing_partner_zip'),
'billing_first_name':
values.get('billing_partner_first_name'),
'billing_last_name':
values.get('billing_partner_last_name'),
'billing_phone':
values.get('billing_partner_phone'),
'billing_state':
billing_state,
}
temp_authorize_tx_values['returndata'] = authorize_tx_values.pop(
'return_url', '')
temp_authorize_tx_values[
'x_fp_hash'] = self._authorize_generate_hashing(
temp_authorize_tx_values)
authorize_tx_values.update(temp_authorize_tx_values)
return authorize_tx_values
