def _compute_quantities_dict(self, lot_id, owner_id, package_id, from_date=False, to_date=False): domain_quant_loc, domain_move_in_loc, domain_move_out_loc = self._get_domain_locations() domain_quant = [('product_id', 'in', self.ids)] + domain_quant_loc dates_in_the_past = False if to_date and to_date < fields.Datetime.now(): #Only to_date as to_date will correspond to qty_available dates_in_the_past = True domain_move_in = [('product_id', 'in', self.ids)] + domain_move_in_loc domain_move_out = [('product_id', 'in', self.ids)] + domain_move_out_loc if lot_id is not None: domain_quant += [('lot_id', '=', lot_id)] if owner_id is not None: domain_quant += [('owner_id', '=', owner_id)] domain_move_in += [('restrict_partner_id', '=', owner_id)] domain_move_out += [('restrict_partner_id', '=', owner_id)] if package_id is not None: domain_quant += [('package_id', '=', package_id)] if dates_in_the_past: domain_move_in_done = list(domain_move_in) domain_move_out_done = list(domain_move_out) if from_date: domain_move_in += [('date', '>=', from_date)] domain_move_out += [('date', '>=', from_date)] if to_date: domain_move_in += [('date', '<=', to_date)] domain_move_out += [('date', '<=', to_date)] Move = self.env['stock.move'] Quant = self.env['stock.quant'] domain_move_in_todo = [('state', 'not in', ('done', 'cancel', 'draft'))] + domain_move_in domain_move_out_todo = [('state', 'not in', ('done', 'cancel', 'draft'))] + domain_move_out moves_in_res = dict((item['product_id'][0], item['product_qty']) for item in Move.read_group(domain_move_in_todo, ['product_id', 'product_qty'], ['product_id'], orderby='id')) moves_out_res = dict((item['product_id'][0], item['product_qty']) for item in Move.read_group(domain_move_out_todo, ['product_id', 'product_qty'], ['product_id'], orderby='id')) quants_res = dict((item['product_id'][0], item['quantity']) for item in Quant.read_group(domain_quant, ['product_id', 'quantity'], ['product_id'], orderby='id')) if dates_in_the_past: # Calculate the moves that were done before now to calculate back in time (as most questions will be recent ones) domain_move_in_done = [('state', '=', 'done'), ('date', '>', to_date)] + domain_move_in_done domain_move_out_done = [('state', '=', 'done'), ('date', '>', to_date)] + domain_move_out_done moves_in_res_past = dict((item['product_id'][0], item['product_qty']) for item in Move.read_group(domain_move_in_done, ['product_id', 'product_qty'], ['product_id'], orderby='id')) moves_out_res_past = dict((item['product_id'][0], item['product_qty']) for item in Move.read_group(domain_move_out_done, ['product_id', 'product_qty'], ['product_id'], orderby='id')) res = dict() for product in self.with_context(prefetch_fields=False): product_id = product.id rounding = product.uom_id.rounding res[product_id] = {} if dates_in_the_past: qty_available = quants_res.get(product_id, 0.0) - moves_in_res_past.get(product_id, 0.0) + moves_out_res_past.get(product_id, 0.0) else: qty_available = quants_res.get(product_id, 0.0) res[product_id]['qty_available'] = float_round(qty_available, precision_rounding=rounding) res[product_id]['incoming_qty'] = float_round(moves_in_res.get(product_id, 0.0), precision_rounding=rounding) res[product_id]['outgoing_qty'] = float_round(moves_out_res.get(product_id, 0.0), precision_rounding=rounding) res[product_id]['virtual_available'] = float_round( qty_available + res[product_id]['incoming_qty'] - res[product_id]['outgoing_qty'], precision_rounding=rounding) return res
def _compute_duration_display(self): for allocation in self: allocation.duration_display = '%g %s' % ( (float_round(allocation.number_of_hours_display, precision_digits=2) if allocation.type_request_unit == 'hour' else float_round( allocation.number_of_days_display, precision_digits=2)), _('hours') if allocation.type_request_unit == 'hour' else _('days'))
def trans_rec_get(self): context = self._context or {} credit = debit = 0 lines = self.env['account.move.line'].browse(context.get('active_ids', [])) for line in lines: if line.amount_residual < 0.0: credit += abs(line.amount_residual) elif line.amount_residual > 0.0: debit += line.amount_residual precision = self.env.user.company_id.currency_id.decimal_places writeoff = float_round(debit - credit, precision_digits=precision) + 0.0 #remove -0.0 result credit = float_round(credit, precision_digits=precision) debit = float_round(debit, precision_digits=precision) return {'trans_nbr': len(lines), 'credit': credit, 'debit': debit, 'writeoff': writeoff}
def get_opening_move_differences(self, opening_move_lines): currency = self.currency_id balancing_move_line = opening_move_lines.filtered(lambda x: x.account_id == self.get_unaffected_earnings_account()) debits_sum = credits_sum = 0.0 for line in opening_move_lines: if line != balancing_move_line: #skip the autobalancing move line debits_sum += line.debit credits_sum += line.credit difference = abs(debits_sum - credits_sum) debit_diff = (debits_sum > credits_sum) and float_round(difference, precision_rounding=currency.rounding) or 0.0 credit_diff = (debits_sum < credits_sum) and float_round(difference, precision_rounding=currency.rounding) or 0.0 return debit_diff, credit_diff
def _create_stripe_charge(self, acquirer_ref=None, tokenid=None, email=None): api_url_charge = 'https://%s/charges' % ( self.acquirer_id._get_stripe_api_url()) charge_params = { 'amount': int(self.amount if self.currency_id.name in INT_CURRENCIES else float_round(self.amount * 100, 2)), 'currency': self.currency_id.name, 'metadata[reference]': self.reference, 'description': self.reference, } if acquirer_ref: charge_params['customer'] = acquirer_ref if tokenid: charge_params['card'] = str(tokenid) if email: charge_params['receipt_email'] = email.strip() r = requests.post(api_url_charge, auth=(self.acquirer_id.stripe_secret_key, ''), params=charge_params, headers=STRIPE_HEADERS) return r.json()
def _get_price_unit(self): """ Returns the unit price for the move""" self.ensure_one() if self.purchase_line_id and self.product_id.id == self.purchase_line_id.product_id.id: price_unit_prec = self.env['decimal.precision'].precision_get( 'Product Price') line = self.purchase_line_id order = line.order_id price_unit = line.price_unit if line.taxes_id: qty = line.product_qty or 1 price_unit = line.taxes_id.with_context( round=False).compute_all( price_unit, currency=line.order_id.currency_id, quantity=qty)['total_void'] price_unit = float_round(price_unit / qty, precision_digits=price_unit_prec) if line.product_uom.id != line.product_id.uom_id.id: price_unit *= line.product_uom.factor / line.product_id.uom_id.factor if order.currency_id != order.company_id.currency_id: # The date must be today, and not the date of the move since the move move is still # in assigned state. However, the move date is the scheduled date until move is # done, then date of actual move processing. See: # https://github.com/flectra/flectra/blob/2f789b6863407e63f90b3a2d4cc3be09815f7002/addons/stock/models/stock_move.py#L36 price_unit = order.currency_id._convert( price_unit, order.company_id.currency_id, order.company_id, fields.Date.context_today(self), round=False) return price_unit return super(StockMove, self)._get_price_unit()
def _set_inventory_quantity(self): """ Inverse method to create stock move when `inventory_quantity` is set (`inventory_quantity` is only accessible in inventory mode). """ if not self._is_inventory_mode(): return for quant in self: # Get the quantity to create a move for. rounding = quant.product_id.uom_id.rounding diff = float_round(quant.inventory_quantity - quant.quantity, precision_rounding=rounding) diff_float_compared = float_compare(diff, 0, precision_rounding=rounding) # Create and vaidate a move so that the quant matches its `inventory_quantity`. if diff_float_compared == 0: continue elif diff_float_compared > 0: move_vals = quant._get_inventory_move_values( diff, quant.product_id.with_company( quant.company_id).property_stock_inventory, quant.location_id) else: move_vals = quant._get_inventory_move_values( -diff, quant.location_id, quant.product_id.with_company( quant.company_id).property_stock_inventory, out=True) move = quant.env['stock.move'].with_context( inventory_mode=False).create(move_vals) move._action_done()
def stripe_form_generate_values(self, tx_values): self.ensure_one() base_url = self.get_base_url() stripe_session_data = { "payment_method_types[]": "card", "line_items[][amount]": int(tx_values["amount"] if tx_values["currency"].name in INT_CURRENCIES else float_round(tx_values["amount"] * 100, 2)), "line_items[][currency]": tx_values["currency"].name, "line_items[][quantity]": 1, "line_items[][name]": tx_values["reference"], "client_reference_id": tx_values["reference"], "payment_intent_data[description]": tx_values["reference"], "success_url": urls.url_join(base_url, StripeController._success_url) + "?reference=%s&return_url=%s" % (tx_values["reference"], tx_values.get('return_url')), "cancel_url": urls.url_join(base_url, StripeController._cancel_url) + "?reference=%s&return_url=%s" % (tx_values["reference"], tx_values.get('return_url')), "customer_email": tx_values["partner_email"] or tx_values["billing_partner_email"], } tx_values["session_id"] = self._create_stripe_session( stripe_session_data) return tx_values
def _compute_mrp_product_qty(self): for template in self: template.mrp_product_qty = float_round( sum( template.mapped('product_variant_ids').mapped( 'mrp_product_qty')), precision_rounding=template.uom_id.rounding)
def _put_in_pack(self): package = False for pick in self: operations = pick.move_line_ids.filtered(lambda o: o.qty_done > 0 and not o.result_package_id) operation_ids = self.env['stock.move.line'] if operations: package = self.env['stock.quant.package'].create({}) for operation in operations: if float_compare(operation.qty_done, operation.product_uom_qty, precision_rounding=operation.product_uom_id.rounding) >= 0: operation_ids |= operation else: quantity_left_todo = float_round( operation.product_uom_qty - operation.qty_done, precision_rounding=operation.product_uom_id.rounding, rounding_method='UP') done_to_keep = operation.qty_done new_operation = operation.copy( default={'product_uom_qty': 0, 'qty_done': operation.qty_done}) operation.write({'product_uom_qty': quantity_left_todo, 'qty_done': 0.0}) new_operation.write({'product_uom_qty': done_to_keep}) operation_ids |= new_operation operation_ids.write({'result_package_id': package.id}) else: raise UserError(_('Please process some quantities to put in the pack first!')) return package
def _prepare_mrp_move_data_from_forecast(self, estimate, product_mrp_area, date): mrp_type = 'd' origin = 'fc' daily_qty = float_round( estimate.daily_qty, precision_rounding=product_mrp_area.product_id.uom_id.rounding, rounding_method='HALF-UP') return { 'mrp_area_id': product_mrp_area.mrp_area_id.id, 'product_id': product_mrp_area.product_id.id, 'product_mrp_area_id': product_mrp_area.id, 'production_id': None, 'purchase_order_id': None, 'purchase_line_id': None, 'stock_move_id': None, 'mrp_qty': -daily_qty * product_mrp_area.group_estimate_days, 'current_qty': -daily_qty, 'mrp_date': date, 'current_date': date, 'mrp_type': mrp_type, 'mrp_origin': origin, 'mrp_order_number': None, 'parent_product_id': None, 'name': 'Forecast', 'state': 'confirmed', }
def _get_stock_move_price_unit(self): self.ensure_one() line = self[0] order = line.order_id price_unit = line.price_unit price_unit_prec = self.env['decimal.precision'].precision_get( 'Product Price') if line.taxes_id: qty = line.product_qty or 1 price_unit = line.taxes_id.with_context(round=False).compute_all( price_unit, currency=line.order_id.currency_id, quantity=qty, product=line.product_id, partner=line.order_id.partner_id)['total_void'] price_unit = float_round(price_unit / qty, precision_digits=price_unit_prec) if line.product_uom.id != line.product_id.uom_id.id: price_unit *= line.product_uom.factor / line.product_id.uom_id.factor if order.currency_id != order.company_id.currency_id: price_unit = order.currency_id._convert( price_unit, order.company_id.currency_id, self.company_id, self.date_order or fields.Date.today(), round=False) return price_unit
def value_to_html(self, value, options): if 'decimal_precision' in options: precision = self.env['decimal.precision'].search([ ('name', '=', options['decimal_precision']) ]).digits else: precision = options['precision'] if precision is None: fmt = '%f' else: value = float_utils.float_round(value, precision_digits=precision) fmt = '%.{precision}f'.format(precision=precision) formatted = self.user_lang().format(fmt, value, grouping=True).replace( r'-', u'-\N{ZERO WIDTH NO-BREAK SPACE}') # %f does not strip trailing zeroes. %g does but its precision causes # it to switch to scientific notation starting at a million *and* to # strip decimals. So use %f and if no precision was specified manually # strip trailing 0. if precision is None: formatted = re.sub(r'(?:(0|\d+?)0+)$', r'\1', formatted) return pycompat.to_text(formatted)
def _compute_sales_count(self): r = {} self.sales_count = 0 if not self.user_has_groups('sales_team.group_sale_salesman'): return r date_from = fields.Datetime.to_string( fields.datetime.combine( fields.datetime.now() - timedelta(days=365), time.min)) done_states = self.env['sale.report']._get_done_states() domain = [ ('state', 'in', done_states), ('product_id', 'in', self.ids), ('date', '>=', date_from), ] for group in self.env['sale.report'].read_group( domain, ['product_id', 'product_uom_qty'], ['product_id']): r[group['product_id'][0]] = group['product_uom_qty'] for product in self: if not product.id: product.sales_count = 0.0 continue product.sales_count = float_round( r.get(product.id, 0), precision_rounding=product.uom_id.rounding) return r
def _compute_sales_count(self): for product in self: product.sales_count = float_round( sum([ p.sales_count for p in product.with_context( active_test=False).product_variant_ids ]), precision_rounding=product.uom_id.rounding)
def _compute_purchased_product_qty(self): for template in self: template.purchased_product_qty = float_round( sum([ p.purchased_product_qty for p in template.product_variant_ids ]), precision_rounding=template.uom_id.rounding)
def name_get(self): if not self._context.get('employee_id'): # leave counts is based on employee_id, would be inaccurate if not based on correct employee return super(HolidaysType, self).name_get() res = [] for record in self: name = record.name if record.allocation_type != 'no': name = "%(name)s (%(count)s)" % { 'name': name, 'count': _('%g remaining out of %g') % ( float_round(record.virtual_remaining_leaves, precision_digits=2) or 0.0, float_round(record.max_leaves, precision_digits=2) or 0.0, ) + (_(' hours') if record.request_unit == 'hour' else _(' days')) } res.append((record.id, name)) return res
def _get_margin_value(self, value, previous_value=0.0): margin = 0.0 if (value != previous_value) and (value != 0.0 and previous_value != 0.0): margin = float_round( (float(value - previous_value) / previous_value or 1) * 100, precision_digits=2) return margin
def default_get(self, fields): if len(self.env.context.get('active_ids', list())) > 1: raise UserError("You may only return one picking at a time!") res = super(ReturnPicking, self).default_get(fields) move_dest_exists = False product_return_moves = [] picking = self.env['stock.picking'].browse( self.env.context.get('active_id')) if picking: res.update({'picking_id': picking.id}) if picking.state != 'done': raise UserError(_("You may only return Done pickings")) for move in picking.move_lines: if move.state == 'cancel': continue if move.scrapped: continue if move.move_dest_ids: move_dest_exists = True quantity = move.product_qty - sum(move.move_dest_ids.filtered(lambda m: m.state in ['partially_available', 'assigned', 'done']).\ mapped('move_line_ids').mapped('product_qty')) quantity = float_round( quantity, precision_rounding=move.product_uom.rounding) product_return_moves.append((0, 0, { 'product_id': move.product_id.id, 'quantity': quantity, 'move_id': move.id, 'uom_id': move.product_id.uom_id.id })) if not product_return_moves: raise UserError( _("No products to return (only lines in Done state and not fully returned yet can be returned)!" )) if 'product_return_moves' in fields: res.update({'product_return_moves': product_return_moves}) if 'move_dest_exists' in fields: res.update({'move_dest_exists': move_dest_exists}) if 'parent_location_id' in fields and picking.location_id.usage == 'internal': res.update({ 'parent_location_id': picking.picking_type_id.warehouse_id and picking.picking_type_id.warehouse_id.view_location_id.id or picking.location_id.location_id.id }) if 'original_location_id' in fields: res.update({'original_location_id': picking.location_id.id}) if 'location_id' in fields: location_id = picking.location_id.id if picking.picking_type_id.return_picking_type_id.default_location_dest_id.return_location: location_id = picking.picking_type_id.return_picking_type_id.default_location_dest_id.id res['location_id'] = location_id return res
def _free_reservation(self, product_id, location_id, quantity, lot_id=None, package_id=None, owner_id=None, ml_to_ignore=None): """ When editing a done move line or validating one with some forced quantities, it is possible to impact quants that were not reserved. It is therefore necessary to edit or unlink the move lines that reserved a quantity now unavailable. :param ml_to_ignore: recordset of `stock.move.line` that should NOT be unreserved """ self.ensure_one() if ml_to_ignore is None: ml_to_ignore = self.env['stock.move.line'] ml_to_ignore |= self # Check the available quantity, with the `strict` kw set to `True`. If the available # quantity is greather than the quantity now unavailable, there is nothing to do. available_quantity = self.env['stock.quant']._get_available_quantity( product_id, location_id, lot_id=lot_id, package_id=package_id, owner_id=owner_id, strict=True ) if quantity > available_quantity: # We now have to find the move lines that reserved our now unavailable quantity. We # take care to exclude ourselves and the move lines were work had already been done. oudated_move_lines_domain = [ ('move_id.state', 'not in', ['done', 'cancel']), ('product_id', '=', product_id.id), ('lot_id', '=', lot_id.id if lot_id else False), ('location_id', '=', location_id.id), ('owner_id', '=', owner_id.id if owner_id else False), ('package_id', '=', package_id.id if package_id else False), ('product_qty', '>', 0.0), ('id', 'not in', ml_to_ignore.ids), ] oudated_candidates = self.env['stock.move.line'].search(oudated_move_lines_domain) # As the move's state is not computed over the move lines, we'll have to manually # recompute the moves which we adapted their lines. move_to_recompute_state = self.env['stock.move'] rounding = self.product_uom_id.rounding for candidate in oudated_candidates: if float_compare(candidate.product_qty, quantity, precision_rounding=rounding) <= 0: quantity -= candidate.product_qty move_to_recompute_state |= candidate.move_id if candidate.qty_done: candidate.product_uom_qty = 0.0 else: candidate.unlink() else: # split this move line and assign the new part to our extra move quantity_split = float_round( candidate.product_qty - quantity, precision_rounding=self.product_uom_id.rounding, rounding_method='UP') candidate.product_uom_qty = self.product_id.uom_id._compute_quantity(quantity_split, candidate.product_uom_id, rounding_method='HALF-UP') quantity -= quantity_split move_to_recompute_state |= candidate.move_id if quantity == 0.0: break move_to_recompute_state._recompute_state()
def _compute_remaining_leaves(self): remaining = {} if self.ids: remaining = self._get_remaining_leaves() for employee in self: value = float_round(remaining.get(employee.id, 0.0), precision_digits=2) employee.leaves_count = value employee.remaining_leaves = value
def trans_rec_get(self): context = self._context or {} credit = debit = 0 lines = self.env['account.move.line'].browse( context.get('active_ids', [])) for line in lines: if not line.full_reconcile_id: credit += line.credit debit += line.debit precision = self.env.user.company_id.currency_id.decimal_places writeoff = float_round(debit - credit, precision_digits=precision) credit = float_round(credit, precision_digits=precision) debit = float_round(debit, precision_digits=precision) return { 'trans_nbr': len(lines), 'credit': credit, 'debit': debit, 'writeoff': writeoff }
def _compute_mrp_product_qty(self): date_from = fields.Datetime.to_string(fields.datetime.now() - timedelta(days=365)) #TODO: state = done? domain = [('state', '=', 'done'), ('product_id', 'in', self.ids), ('date_planned_start', '>', date_from)] read_group_res = self.env['mrp.production'].read_group(domain, ['product_id', 'product_uom_qty'], ['product_id']) mapped_data = dict([(data['product_id'][0], data['product_uom_qty']) for data in read_group_res]) for product in self: if not product.id: product.mrp_product_qty = 0.0 continue product.mrp_product_qty = float_round(mapped_data.get(product.id, 0), precision_rounding=product.uom_id.rounding)
def _onchange_secondary_uom(self): if not self.secondary_uom_id: return factor = self.secondary_uom_id.factor * self.product_id.uom_id.factor qty = float_round(self.secondary_uom_qty * factor, precision_rounding=self.product_id.uom_id.rounding) if float_compare( self.units_included, qty, precision_rounding=self.product_id.uom_id.rounding) != 0: self.units_included = qty
def _onchange_units_included_purchase_order_secondary_unit(self): if not self.secondary_uom_id: return factor = self.secondary_uom_id.factor * self.product_id.uom_id.factor qty = float_round( self.units_included / (factor or 1.0), precision_rounding=self.secondary_uom_id.uom_id.rounding) if float_compare( self.secondary_uom_qty, qty, precision_rounding=self.secondary_uom_id.uom_id.rounding) != 0: self.secondary_uom_qty = qty
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 _compute_allocation_count(self): data = self.env['hr.leave.allocation'].read_group([ ('employee_id', 'in', self.ids), ('holiday_status_id.active', '=', True), ('state', '=', 'validate'), ], ['number_of_days:sum', 'employee_id'], ['employee_id']) rg_results = dict( (d['employee_id'][0], d['number_of_days']) for d in data) for employee in self: employee.allocation_count = float_round(rg_results.get( employee.id, 0.0), precision_digits=2) employee.allocation_display = "%g" % employee.allocation_count
def _create_stripe_refund(self): refund_params = { 'charge': self.acquirer_reference, 'amount': int(float_round(self.amount * 100, 2)), # by default, stripe refund the full amount (we don't really need to specify the value) 'metadata[reference]': self.reference, } _logger.info('_create_stripe_refund: Sending values to stripe URL, values:\n%s', pprint.pformat(refund_params)) res = self.acquirer_id._stripe_request('refunds', refund_params) _logger.info('_create_stripe_refund: Values received:\n%s', pprint.pformat(res)) return res
def create(self, vals): move = self.env['stock.move'].browse(vals.get('move_id', False)) if move.secondary_uom_id: uom = self.env['product.uom'].browse(vals['product_uom_id']) factor = move.secondary_uom_id.factor * uom.factor move_line_qty = vals.get('product_uom_qty', vals.get('qty_done', 0.0)) qty = float_round( move_line_qty / (factor or 1.0), precision_rounding=move.secondary_uom_id.uom_id.factor) vals.update({ 'secondary_uom_qty': qty, 'secondary_uom_id': move.secondary_uom_id.id, }) return super().create(vals)
def _stripe_form_get_invalid_parameters(self, data): invalid_parameters = [] if data.get("amount") != int( self.amount if self.currency_id.name in INT_CURRENCIES else float_round(self.amount * 100, 2)): invalid_parameters.append( ("Amount", data.get("amount"), self.amount * 100)) if data.get("currency").upper() != self.currency_id.name: invalid_parameters.append( ("Currency", data.get("currency"), self.currency_id.name)) if data.get("payment_intent") and data.get( "payment_intent") != self.stripe_payment_intent: invalid_parameters.append( ("Payment Intent", data.get("payment_intent"), self.stripe_payment_intent)) return invalid_parameters