def _sale_get_invoice_price(self, order):
""" Based on the current move line, compute the price to reinvoice the analytic line that is going to be created (so the
price of the sale line).
"""
self.ensure_one()
unit_amount = self.quantity
amount = (self.credit or 0.0) - (self.debit or 0.0)
if self.product_id.expense_policy == 'sales_price':
return self.product_id.with_context(
partner=order.partner_id.id,
date_order=order.date_order,
pricelist=order.pricelist_id.id,
uom=self.product_uom_id.id).price
uom_precision_digits = self.env['decimal.precision'].precision_get(
'Product Unit of Measure')
if float_is_zero(unit_amount, precision_digits=uom_precision_digits):
return 0.0
# Prevent unnecessary currency conversion that could be impacted by exchange rate
# fluctuations
if self.company_id.currency_id and amount and self.company_id.currency_id == order.currency_id:
return abs(amount / unit_amount)
price_unit = abs(amount / unit_amount)
currency_id = self.company_id.currency_id
if currency_id and currency_id != order.currency_id:
price_unit = currency_id._convert(
price_unit, order.currency_id, order.company_id,
order.date_order or fields.Date.today())
return price_unit
def _search_difference_qty(self, operator, value):
if operator == '=':
result = True
elif operator == '!=':
result = False
else:
raise NotImplementedError()
lines = self.search([('inventory_id', '=', self.env.context.get('default_inventory_id'))])
line_ids = lines.filtered(lambda line: float_is_zero(line.difference_qty, line.product_id.uom_id.rounding) == result).ids
return [('id', 'in', line_ids)]
def test_rounding_invalid(self):
""" verify that invalid parameters are forbidden """
with self.assertRaises(AssertionError):
float_is_zero(0.01, precision_digits=3, precision_rounding=0.01)
with self.assertRaises(AssertionError):
float_is_zero(0.0, precision_rounding=0.0)
with self.assertRaises(AssertionError):
float_is_zero(0.0, precision_rounding=-0.1)
with self.assertRaises(AssertionError):
float_compare(0.01,
0.02,
precision_digits=3,
precision_rounding=0.01)
with self.assertRaises(AssertionError):
float_compare(1.0, 1.0, precision_rounding=0.0)
with self.assertRaises(AssertionError):
float_compare(1.0, 1.0, precision_rounding=-0.1)
with self.assertRaises(AssertionError):
float_round(0.01, precision_digits=3, precision_rounding=0.01)
with self.assertRaises(AssertionError):
float_round(1.25, precision_rounding=0.0)
with self.assertRaises(AssertionError):
float_round(1.25, precision_rounding=-0.1)
def _generate_moves(self):
vals_list = []
for line in self:
virtual_location = line._get_virtual_location()
rounding = line.product_id.uom_id.rounding
if float_is_zero(line.difference_qty, precision_rounding=rounding):
continue
if line.difference_qty > 0: # found more than expected
vals = line._get_move_values(line.difference_qty, virtual_location.id, line.location_id.id, False)
else:
vals = line._get_move_values(abs(line.difference_qty), line.location_id.id, virtual_location.id, True)
vals_list.append(vals)
return self.env['stock.move'].create(vals_list)
def is_zero(self, amount):
"""Returns true if ``amount`` is small enough to be treated as
zero according to current currency's rounding rules.
Warning: ``is_zero(amount1-amount2)`` is not always equivalent to
``compare_amounts(amount1,amount2) == 0``, as the former will round after
computing the difference, while the latter will round before, giving
different results for e.g. 0.006 and 0.002 at 2 digits precision.
:param float amount: amount to compare with currency's zero
With the new API, call it like: ``currency.is_zero(amount)``.
"""
self.ensure_one()
return tools.float_is_zero(amount, precision_rounding=self.rounding)
def _costs_generate(self):
""" Calculates total costs at the end of the production.
"""
self.ensure_one()
AccountAnalyticLine = self.env['account.analytic.line'].sudo()
for wc_line in self.workorder_ids.filtered(
'workcenter_id.costs_hour_account_id'):
vals = self._prepare_wc_analytic_line(wc_line)
precision_rounding = wc_line.workcenter_id.costs_hour_account_id.currency_id.rounding
if not float_is_zero(vals.get('amount', 0.0),
precision_rounding=precision_rounding):
# we use SUPERUSER_ID as we do not guarantee an mrp user
# has access to account analytic lines but still should be
# able to produce orders
AccountAnalyticLine.create(vals)
def _onchange_qty_done(self):
""" When the user is encoding a produce line for a tracked product, we apply some logic to
help him. This onchange will warn him if he set `qty_done` to a non-supported value.
"""
res = {}
if self.product_id.tracking == 'serial' and not float_is_zero(
self.qty_done, self.product_uom_id.rounding):
if float_compare(
self.qty_done,
1.0,
precision_rounding=self.product_uom_id.rounding) != 0:
message = _(
'You can only process 1.0 %s of products with unique serial number.'
) % self.product_id.uom_id.name
res['warning'] = {'title': _('Warning'), 'message': message}
return res
def summary(self):
res = super(EventRegistration, self).summary()
if self.event_ticket_id.product_id.image_128:
res['image'] = '/web/image/product.product/%s/image_128' % self.event_ticket_id.product_id.id
information = res.setdefault('information', {})
information.append((_('Name'), self.name))
information.append((_('Ticket'), self.event_ticket_id.name
or _('None')))
order = self.sale_order_id.sudo()
order_line = self.sale_order_line_id.sudo()
if not order or float_is_zero(
order_line.price_total,
precision_digits=order.currency_id.rounding):
payment_status = _('Free')
elif not order.invoice_ids or any(invoice.state != 'paid'
for invoice in order.invoice_ids):
payment_status = _('To pay')
res['alert'] = _('The registration must be paid')
else:
payment_status = _('Paid')
information.append((_('Payment'), payment_status))
return res
def _get_invoiced_lot_values(self):
""" Get and prepare data to show a table of invoiced lot on the invoice's report. """
self.ensure_one()
if self.state == 'draft':
return []
sale_orders = self.mapped('invoice_line_ids.sale_line_ids.order_id')
stock_move_lines = sale_orders.mapped(
'picking_ids.move_lines.move_line_ids')
# Get the other customer invoices and refunds.
ordered_invoice_ids = sale_orders.mapped('invoice_ids')\
.filtered(lambda i: i.state not in ['draft', 'cancel'])\
.sorted(lambda i: (i.invoice_date, i.id))
# Get the position of self in other customer invoices and refunds.
self_index = None
i = 0
for invoice in ordered_invoice_ids:
if invoice.id == self.id:
self_index = i
break
i += 1
# Get the previous invoice if any.
previous_invoices = ordered_invoice_ids[:self_index]
last_invoice = previous_invoices[-1] if len(
previous_invoices) else None
# Get the incoming and outgoing sml between self.invoice_date and the previous invoice (if any).
self_datetime = max(self.invoice_line_ids.mapped(
'write_date')) if self.invoice_line_ids else None
last_invoice_datetime = max(
last_invoice.invoice_line_ids.mapped(
'write_date')) if last_invoice else None
def _filter_incoming_sml(ml):
if ml.state == 'done' and ml.location_id.usage == 'customer' and ml.lot_id:
if last_invoice_datetime:
return last_invoice_datetime <= ml.date <= self_datetime
else:
return ml.date <= self_datetime
return False
def _filter_outgoing_sml(ml):
if ml.state == 'done' and ml.location_dest_id.usage == 'customer' and ml.lot_id:
if last_invoice_datetime:
return last_invoice_datetime <= ml.date <= self_datetime
else:
return ml.date <= self_datetime
return False
incoming_sml = stock_move_lines.filtered(_filter_incoming_sml)
outgoing_sml = stock_move_lines.filtered(_filter_outgoing_sml)
# Prepare and return lot_values
qties_per_lot = defaultdict(lambda: 0)
if self.type == 'out_refund':
for ml in outgoing_sml:
qties_per_lot[
ml.lot_id] -= ml.product_uom_id._compute_quantity(
ml.qty_done, ml.product_id.uom_id)
for ml in incoming_sml:
qties_per_lot[
ml.lot_id] += ml.product_uom_id._compute_quantity(
ml.qty_done, ml.product_id.uom_id)
else:
for ml in outgoing_sml:
qties_per_lot[
ml.lot_id] += ml.product_uom_id._compute_quantity(
ml.qty_done, ml.product_id.uom_id)
for ml in incoming_sml:
qties_per_lot[
ml.lot_id] -= ml.product_uom_id._compute_quantity(
ml.qty_done, ml.product_id.uom_id)
lot_values = []
for lot_id, qty in qties_per_lot.items():
if float_is_zero(
qty, precision_rounding=lot_id.product_id.uom_id.rounding):
continue
lot_values.append({
'product_name': lot_id.product_id.name,
'quantity': qty,
'uom_name': lot_id.product_uom_id.name,
'lot_name': lot_id.name,
})
return lot_values
def test_invoice(self):
""" Test create and invoice from the SO, and check qty invoice/to invoice, and the related amounts """
# lines are in draft
for line in self.sale_order.order_line:
self.assertTrue(
float_is_zero(line.untaxed_amount_to_invoice,
precision_digits=2),
"The amount to invoice should be zero, as the line is in draf state"
)
self.assertTrue(
float_is_zero(line.untaxed_amount_invoiced,
precision_digits=2),
"The invoiced amount should be zero, as the line is in draft state"
)
# Confirm the SO
self.sale_order.action_confirm()
# Check ordered quantity, quantity to invoice and invoiced quantity of SO lines
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
self.assertEquals(
line.qty_to_invoice, 0.0,
'Quantity to invoice should be same as ordered quantity')
self.assertEquals(
line.qty_invoiced, 0.0,
'Invoiced quantity should be zero as no any invoice created for SO'
)
self.assertEquals(
line.untaxed_amount_to_invoice, 0.0,
"The amount to invoice should be zero, as the line based on delivered quantity"
)
self.assertEquals(
line.untaxed_amount_invoiced, 0.0,
"The invoiced amount should be zero, as the line based on delivered quantity"
)
else:
self.assertEquals(
line.qty_to_invoice, line.product_uom_qty,
'Quantity to invoice should be same as ordered quantity')
self.assertEquals(
line.qty_invoiced, 0.0,
'Invoiced quantity should be zero as no any invoice created for SO'
)
self.assertEquals(
line.untaxed_amount_to_invoice,
line.product_uom_qty * line.price_unit,
"The amount to invoice should the total of the line, as the line is confirmed"
)
self.assertEquals(
line.untaxed_amount_invoiced, 0.0,
"The invoiced amount should be zero, as the line is confirmed"
)
# Let's do an invoice with invoiceable lines
payment = self.env['sale.advance.payment.inv'].with_context(
self.context).create({'advance_payment_method': 'delivered'})
payment.create_invoices()
invoice = self.sale_order.invoice_ids[0]
# Update quantity of an invoice lines
move_form = Form(invoice)
with move_form.invoice_line_ids.edit(0) as line_form:
line_form.quantity = 3.0
with move_form.invoice_line_ids.edit(1) as line_form:
line_form.quantity = 2.0
invoice = move_form.save()
# amount to invoice / invoiced should not have changed (amounts take only confirmed invoice into account)
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
self.assertEquals(line.qty_to_invoice, 0.0,
"Quantity to invoice should be zero")
self.assertEquals(
line.qty_invoiced, 0.0,
"Invoiced quantity should be zero as delivered lines are not delivered yet"
)
self.assertEquals(
line.untaxed_amount_to_invoice, 0.0,
"The amount to invoice should be zero, as the line based on delivered quantity (no confirmed invoice)"
)
self.assertEquals(
line.untaxed_amount_invoiced, 0.0,
"The invoiced amount should be zero, as no invoice are validated for now"
)
else:
if line == self.sol_prod_order:
self.assertEquals(
self.sol_prod_order.qty_to_invoice, 2.0,
"Changing the quantity on draft invoice update the qty to invoice on SO lines"
)
self.assertEquals(
self.sol_prod_order.qty_invoiced, 3.0,
"Changing the quantity on draft invoice update the invoiced qty on SO lines"
)
else:
self.assertEquals(
self.sol_serv_order.qty_to_invoice, 1.0,
"Changing the quantity on draft invoice update the qty to invoice on SO lines"
)
self.assertEquals(
self.sol_serv_order.qty_invoiced, 2.0,
"Changing the quantity on draft invoice update the invoiced qty on SO lines"
)
self.assertEquals(
line.untaxed_amount_to_invoice,
line.product_uom_qty * line.price_unit,
"The amount to invoice should the total of the line, as the line is confirmed (no confirmed invoice)"
)
self.assertEquals(
line.untaxed_amount_invoiced, 0.0,
"The invoiced amount should be zero, as no invoice are validated for now"
)
invoice.post()
# Check quantity to invoice on SO lines
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
self.assertEquals(
line.qty_to_invoice, 0.0,
"Quantity to invoice should be same as ordered quantity")
self.assertEquals(
line.qty_invoiced, 0.0,
"Invoiced quantity should be zero as no any invoice created for SO"
)
self.assertEquals(
line.untaxed_amount_to_invoice, 0.0,
"The amount to invoice should be zero, as the line based on delivered quantity"
)
self.assertEquals(
line.untaxed_amount_invoiced, 0.0,
"The invoiced amount should be zero, as the line based on delivered quantity"
)
else:
if line == self.sol_prod_order:
self.assertEquals(
line.qty_to_invoice, 2.0,
"The ordered sale line are totally invoiced (qty to invoice is zero)"
)
self.assertEquals(
line.qty_invoiced, 3.0,
"The ordered (prod) sale line are totally invoiced (qty invoiced come from the invoice lines)"
)
else:
self.assertEquals(
line.qty_to_invoice, 1.0,
"The ordered sale line are totally invoiced (qty to invoice is zero)"
)
self.assertEquals(
line.qty_invoiced, 2.0,
"The ordered (serv) sale line are totally invoiced (qty invoiced = the invoice lines)"
)
self.assertEquals(
line.untaxed_amount_to_invoice,
line.price_unit * line.qty_to_invoice,
"Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products"
)
self.assertEquals(
line.untaxed_amount_invoiced,
line.price_unit * line.qty_invoiced,
"Amount invoiced is now set as qty invoiced * unit price since no price change on invoice, for ordered products"
)
def test_invoice_with_discount(self):
""" Test invoice with a discount and check discount applied on both SO lines and an invoice lines """
# Update discount and delivered quantity on SO lines
self.sol_prod_order.write({'discount': 20.0})
self.sol_serv_deliver.write({'discount': 20.0, 'qty_delivered': 4.0})
self.sol_serv_order.write({'discount': -10.0})
self.sol_prod_deliver.write({'qty_delivered': 2.0})
for line in self.sale_order.order_line.filtered(lambda l: l.discount):
product_price = line.price_unit * line.product_uom_qty
self.assertEquals(line.discount,
(product_price - line.price_subtotal) /
product_price * 100,
'Discount should be applied on order line')
# lines are in draft
for line in self.sale_order.order_line:
self.assertTrue(
float_is_zero(line.untaxed_amount_to_invoice,
precision_digits=2),
"The amount to invoice should be zero, as the line is in draf state"
)
self.assertTrue(
float_is_zero(line.untaxed_amount_invoiced,
precision_digits=2),
"The invoiced amount should be zero, as the line is in draft state"
)
self.sale_order.action_confirm()
for line in self.sale_order.order_line:
self.assertTrue(
float_is_zero(line.untaxed_amount_invoiced,
precision_digits=2),
"The invoiced amount should be zero, as the line is in draft state"
)
self.assertEquals(self.sol_serv_order.untaxed_amount_to_invoice, 297,
"The untaxed amount to invoice is wrong")
self.assertEquals(
self.sol_serv_deliver.untaxed_amount_to_invoice,
self.sol_serv_deliver.qty_delivered *
self.sol_serv_deliver.price_reduce,
"The untaxed amount to invoice should be qty deli * price reduce, so 4 * (180 - 36)"
)
self.assertEquals(
self.sol_prod_deliver.untaxed_amount_to_invoice, 140,
"The untaxed amount to invoice should be qty deli * price reduce, so 4 * (180 - 36)"
)
# Let's do an invoice with invoiceable lines
payment = self.env['sale.advance.payment.inv'].with_context(
self.context).create({'advance_payment_method': 'delivered'})
payment.create_invoices()
invoice = self.sale_order.invoice_ids[0]
invoice.post()
# Check discount appeared on both SO lines and invoice lines
for line, inv_line in zip(self.sale_order.order_line,
invoice.invoice_line_ids):
self.assertEquals(
line.discount, inv_line.discount,
'Discount on lines of order and invoice should be same')
def change_prod_qty(self):
precision = self.env['decimal.precision'].precision_get(
'Product Unit of Measure')
for wizard in self:
production = wizard.mo_id
produced = sum(
production.move_finished_ids.filtered(
lambda m: m.product_id == production.product_id).mapped(
'quantity_done'))
if wizard.product_qty < produced:
format_qty = '%.{precision}f'.format(precision=precision)
raise UserError(
_("You have already processed %s. Please input a quantity higher than %s "
) % (format_qty % produced, format_qty % produced))
old_production_qty = production.product_qty
production.write({'product_qty': wizard.product_qty})
done_moves = production.move_finished_ids.filtered(
lambda x: x.state == 'done' and x.product_id == production.
product_id)
qty_produced = production.product_id.uom_id._compute_quantity(
sum(done_moves.mapped('product_qty')),
production.product_uom_id)
factor = production.product_uom_id._compute_quantity(
production.product_qty - qty_produced, production.bom_id.
product_uom_id) / production.bom_id.product_qty
boms, lines = production.bom_id.explode(
production.product_id,
factor,
picking_type=production.bom_id.picking_type_id)
documents = {}
for line, line_data in lines:
if line.child_bom_id and line.child_bom_id.type == 'phantom' or\
line.product_id.type not in ['product', 'consu']:
continue
move = production.move_raw_ids.filtered(
lambda x: x.bom_line_id.id == line.id and x.state not in
('done', 'cancel'))
if move:
move = move[0]
old_qty = move.product_uom_qty
else:
old_qty = 0
iterate_key = production._get_document_iterate_key(move)
if iterate_key:
document = self.env[
'stock.picking']._log_activity_get_documents(
{move: (line_data['qty'], old_qty)}, iterate_key,
'UP')
for key, value in document.items():
if documents.get(key):
documents[key] += [value]
else:
documents[key] = [value]
production._update_raw_move(line, line_data)
production._log_manufacture_exception(documents)
operation_bom_qty = {}
for bom, bom_data in boms:
for operation in bom.routing_id.operation_ids:
operation_bom_qty[operation.id] = bom_data['qty']
finished_moves_modification = self._update_finished_moves(
production, production.product_qty - qty_produced,
old_production_qty)
production._log_downside_manufactured_quantity(
finished_moves_modification)
moves = production.move_raw_ids.filtered(lambda x: x.state not in
('done', 'cancel'))
moves._action_assign()
for wo in production.workorder_ids:
operation = wo.operation_id
if operation_bom_qty.get(operation.id):
cycle_number = float_round(
operation_bom_qty[operation.id] /
operation.workcenter_id.capacity,
precision_digits=0,
rounding_method='UP')
wo.duration_expected = (
operation.workcenter_id.time_start +
operation.workcenter_id.time_stop +
cycle_number * operation.time_cycle * 100.0 /
operation.workcenter_id.time_efficiency)
quantity = wo.qty_production - wo.qty_produced
if production.product_id.tracking == 'serial':
quantity = 1.0 if not float_is_zero(
quantity, precision_digits=precision) else 0.0
else:
quantity = quantity if (quantity > 0) else 0
if float_is_zero(quantity, precision_digits=precision):
wo.finished_lot_id = False
wo._workorder_line_ids().unlink()
wo.qty_producing = quantity
if wo.qty_produced < wo.qty_production and wo.state == 'done':
wo.state = 'progress'
if wo.qty_produced == wo.qty_production and wo.state == 'progress':
wo.state = 'done'
# assign moves; last operation receive all unassigned moves
# TODO: following could be put in a function as it is similar as code in _workorders_create
# TODO: only needed when creating new moves
moves_raw = production.move_raw_ids.filtered(
lambda move: move.operation_id == operation and move.state
not in ('done', 'cancel'))
if wo == production.workorder_ids[-1]:
moves_raw |= production.move_raw_ids.filtered(
lambda move: not move.operation_id)
moves_finished = production.move_finished_ids.filtered(
lambda move: move.operation_id == operation
) #TODO: code does nothing, unless maybe by_products?
moves_raw.mapped('move_line_ids').write(
{'workorder_id': wo.id})
(moves_finished + moves_raw).write({'workorder_id': wo.id})
if wo.state not in ('done', 'cancel'):
line_values = wo._update_workorder_lines()
wo._workorder_line_ids().create(line_values['to_create'])
if line_values['to_delete']:
line_values['to_delete'].unlink()
for line, vals in line_values['to_update'].items():
line.write(vals)
return {}
def test_timesheet_manual(self):
""" Test timesheet invoicing with 'invoice on delivery' timetracked products
"""
# create SO and confirm it
sale_order = self.env['sale.order'].create({
'partner_id':
self.partner_customer_usd.id,
'partner_invoice_id':
self.partner_customer_usd.id,
'partner_shipping_id':
self.partner_customer_usd.id,
'pricelist_id':
self.pricelist_usd.id,
})
so_line_manual_global_project = self.env['sale.order.line'].create({
'name':
self.product_delivery_manual2.name,
'product_id':
self.product_delivery_manual2.id,
'product_uom_qty':
50,
'product_uom':
self.product_delivery_manual2.uom_id.id,
'price_unit':
self.product_delivery_manual2.list_price,
'order_id':
sale_order.id,
})
so_line_manual_only_project = self.env['sale.order.line'].create({
'name':
self.product_delivery_manual4.name,
'product_id':
self.product_delivery_manual4.id,
'product_uom_qty':
20,
'product_uom':
self.product_delivery_manual4.uom_id.id,
'price_unit':
self.product_delivery_manual4.list_price,
'order_id':
sale_order.id,
})
# confirm SO
sale_order.action_confirm()
self.assertTrue(sale_order.project_ids,
"Sales Order should have create a project")
self.assertEqual(
sale_order.invoice_status, 'no',
'Sale Timesheet: manually product should not need to be invoiced on so confirmation'
)
project_serv2 = so_line_manual_only_project.project_id
self.assertTrue(
project_serv2,
"A second project is created when selling 'project only' after SO confirmation."
)
self.assertEqual(
sale_order.analytic_account_id, project_serv2.analytic_account_id,
"The created project should be linked to the analytic account of the SO"
)
# let's log some timesheets (on task and project)
timesheet1 = self.env['account.analytic.line'].create({
'name':
'Test Line',
'project_id':
self.project_global.id, # global project
'task_id':
so_line_manual_global_project.task_id.id,
'unit_amount':
6,
'employee_id':
self.employee_manager.id,
})
timesheet2 = self.env['account.analytic.line'].create({
'name':
'Test Line',
'project_id':
self.project_global.id, # global project
'unit_amount':
3,
'employee_id':
self.employee_manager.id,
})
self.assertEqual(
len(sale_order.project_ids), 2,
"One project should have been created by the SO, when confirmed + the one coming from SO line 1 'task in global project'."
)
self.assertEqual(
so_line_manual_global_project.task_id.sale_line_id,
so_line_manual_global_project,
"Task from a milestone product should be linked to its SO line too"
)
self.assertEqual(
timesheet1.timesheet_invoice_type, 'billable_fixed',
"Milestone timesheet goes in billable fixed category")
self.assertTrue(
float_is_zero(so_line_manual_global_project.qty_delivered,
precision_digits=2),
"Milestone Timesheeting should not incremented the delivered quantity on the SO line"
)
self.assertEqual(
so_line_manual_global_project.qty_to_invoice, 0.0,
"Manual service should not be affected by timesheet on their created task."
)
self.assertEqual(
so_line_manual_only_project.qty_to_invoice, 0.0,
"Manual service should not be affected by timesheet on their created project."
)
self.assertEqual(
sale_order.invoice_status, 'no',
'Sale Timesheet: "invoice on delivery" should not need to be invoiced on so confirmation'
)
self.assertEqual(
timesheet1.timesheet_invoice_type, 'billable_fixed',
"Timesheets linked to SO line with ordered product shoulbe be billable fixed since it is a milestone"
)
self.assertEqual(
timesheet2.timesheet_invoice_type, 'non_billable_project',
"Timesheets without task shoulbe be 'no project found'")
self.assertFalse(timesheet1.timesheet_invoice_id,
"The timesheet1 should not be linked to the invoice")
self.assertFalse(timesheet2.timesheet_invoice_id,
"The timesheet2 should not be linked to the invoice")
# invoice SO
sale_order.order_line.write({'qty_delivered': 5})
invoice1 = sale_order._create_invoices()
for invoice_line in invoice1.invoice_line_ids:
self.assertEqual(
invoice_line.quantity, 5,
"The invoiced quantity should be 5, as manually set on SO lines"
)
self.assertFalse(
timesheet1.timesheet_invoice_id,
"The timesheet1 should not be linked to the invoice, since timesheets are used for time tracking in milestone"
)
self.assertFalse(
timesheet2.timesheet_invoice_id,
"The timesheet2 should not be linked to the invoice, since timesheets are used for time tracking in milestone"
)
# validate the invoice
invoice1.post()
self.assertFalse(
timesheet1.timesheet_invoice_id,
"The timesheet1 should not be linked to the invoice, even after invoice validation"
)
self.assertFalse(
timesheet2.timesheet_invoice_id,
"The timesheet2 should not be linked to the invoice, even after invoice validation"
)
def test_timesheet_delivery(self):
""" Test timesheet invoicing with 'invoice on delivery' timetracked products
1. Create SO and confirm it
2. log timesheet
3. create invoice
4. log other timesheet
5. create a second invoice
6. add new SO line (delivered service)
"""
# create SO and confirm it
sale_order = self.env['sale.order'].create({
'partner_id':
self.partner_customer_usd.id,
'partner_invoice_id':
self.partner_customer_usd.id,
'partner_shipping_id':
self.partner_customer_usd.id,
'pricelist_id':
self.pricelist_usd.id,
})
so_line_deliver_global_project = self.env['sale.order.line'].create({
'name':
self.product_delivery_timesheet2.name,
'product_id':
self.product_delivery_timesheet2.id,
'product_uom_qty':
50,
'product_uom':
self.product_delivery_timesheet2.uom_id.id,
'price_unit':
self.product_delivery_timesheet2.list_price,
'order_id':
sale_order.id,
})
so_line_deliver_task_project = self.env['sale.order.line'].create({
'name':
self.product_delivery_timesheet3.name,
'product_id':
self.product_delivery_timesheet3.id,
'product_uom_qty':
20,
'product_uom':
self.product_delivery_timesheet3.uom_id.id,
'price_unit':
self.product_delivery_timesheet3.list_price,
'order_id':
sale_order.id,
})
so_line_deliver_global_project.product_id_change()
so_line_deliver_task_project.product_id_change()
# confirm SO
sale_order.action_confirm()
task_serv1 = self.env['project.task'].search([
('sale_line_id', '=', so_line_deliver_global_project.id)
])
task_serv2 = self.env['project.task'].search([
('sale_line_id', '=', so_line_deliver_task_project.id)
])
project_serv2 = self.env['project.project'].search([
('sale_line_id', '=', so_line_deliver_task_project.id)
])
self.assertEqual(
task_serv1.project_id, self.project_global,
"Sale Timesheet: task should be created in global project")
self.assertTrue(
task_serv1,
"Sale Timesheet: on SO confirmation, a task should have been created in global project"
)
self.assertTrue(
task_serv2,
"Sale Timesheet: on SO confirmation, a task should have been created in a new project"
)
self.assertEqual(
sale_order.invoice_status, 'no',
'Sale Timesheet: "invoice on delivery" should not need to be invoiced on so confirmation'
)
self.assertEqual(sale_order.analytic_account_id,
task_serv2.project_id.analytic_account_id,
"SO should have create a project")
self.assertEqual(
sale_order.tasks_count, 2,
"Two tasks (1 per SO line) should have been created on SO confirmation"
)
self.assertEqual(
len(sale_order.project_ids), 2,
"One project should have been created by the SO, when confirmed + the one from SO line 1 'task in global project'"
)
self.assertEqual(
sale_order.analytic_account_id, project_serv2.analytic_account_id,
"The created project should be linked to the analytic account of the SO"
)
# let's log some timesheets
timesheet1 = self.env['account.analytic.line'].create({
'name':
'Test Line',
'project_id':
task_serv1.project_id.id, # global project
'task_id':
task_serv1.id,
'unit_amount':
10.5,
'employee_id':
self.employee_manager.id,
})
self.assertEqual(
so_line_deliver_global_project.invoice_status, 'to invoice',
'Sale Timesheet: "invoice on delivery" timesheets should set the so line in "to invoice" status when logged'
)
self.assertEqual(
so_line_deliver_task_project.invoice_status, 'no',
'Sale Timesheet: so line invoice status should not change when no timesheet linked to the line'
)
self.assertEqual(
sale_order.invoice_status, 'to invoice',
'Sale Timesheet: "invoice on delivery" timesheets should set the so in "to invoice" status when logged'
)
self.assertEqual(
timesheet1.timesheet_invoice_type, 'billable_time',
"Timesheets linked to SO line with delivered product shoulbe be billable time"
)
self.assertFalse(
timesheet1.timesheet_invoice_id,
"The timesheet1 should not be linked to the invoice yet")
# invoice SO
invoice1 = sale_order._create_invoices()
self.assertTrue(
float_is_zero(invoice1.amount_total -
so_line_deliver_global_project.price_unit * 10.5,
precision_digits=2),
'Sale: invoice generation on timesheets product is wrong')
self.assertEqual(
timesheet1.timesheet_invoice_id, invoice1,
"The timesheet1 should not be linked to the invoice 1, as we are in delivered quantity (even if invoice is in draft"
)
with self.assertRaises(
UserError
): # We can not modify timesheet linked to invoice (even draft ones)
timesheet1.write({'unit_amount': 42})
# log some timesheets again
timesheet2 = self.env['account.analytic.line'].create({
'name':
'Test Line',
'project_id':
task_serv1.project_id.id, # global project
'task_id':
task_serv1.id,
'unit_amount':
39.5,
'employee_id':
self.employee_user.id,
})
self.assertEqual(
so_line_deliver_global_project.invoice_status, 'to invoice',
'Sale Timesheet: "invoice on delivery" timesheets should set the so line in "to invoice" status when logged'
)
self.assertEqual(
so_line_deliver_task_project.invoice_status, 'no',
'Sale Timesheet: so line invoice status should not change when no timesheet linked to the line'
)
self.assertEqual(
sale_order.invoice_status, 'to invoice',
'Sale Timesheet: "invoice on delivery" timesheets should not modify the invoice_status of the so'
)
self.assertEqual(
timesheet2.timesheet_invoice_type, 'billable_time',
"Timesheets linked to SO line with delivered product shoulbe be billable time"
)
self.assertFalse(
timesheet2.timesheet_invoice_id,
"The timesheet2 should not be linked to the invoice yet")
# create a second invoice
invoice2 = sale_order._create_invoices()[0]
self.assertEqual(
len(sale_order.invoice_ids), 2,
"A second invoice should have been created from the SO")
self.assertEqual(
so_line_deliver_global_project.invoice_status, 'invoiced',
'Sale Timesheet: "invoice on delivery" timesheets should set the so line in "to invoice" status when logged'
)
self.assertEqual(
sale_order.invoice_status, 'no',
'Sale Timesheet: "invoice on delivery" timesheets should be invoiced completely by now'
)
self.assertEqual(
timesheet2.timesheet_invoice_id, invoice2,
"The timesheet2 should not be linked to the invoice 2")
with self.assertRaises(
UserError
): # We can not modify timesheet linked to invoice (even draft ones)
timesheet2.write({'unit_amount': 42})
# add a line on SO
so_line_deliver_only_project = self.env['sale.order.line'].create({
'name':
self.product_delivery_timesheet4.name,
'product_id':
self.product_delivery_timesheet4.id,
'product_uom_qty':
5,
'product_uom':
self.product_delivery_timesheet4.uom_id.id,
'price_unit':
self.product_delivery_timesheet4.list_price,
'order_id':
sale_order.id,
})
self.assertEqual(
len(sale_order.project_ids), 2,
"No new project should have been created by the SO, when selling 'project only' product, since it reuse the one from 'new task in new project'."
)
# let's log some timesheets on the project
timesheet3 = self.env['account.analytic.line'].create({
'name':
'Test Line',
'project_id':
project_serv2.id,
'unit_amount':
7,
'employee_id':
self.employee_user.id,
})
self.assertTrue(
float_is_zero(so_line_deliver_only_project.qty_delivered,
precision_digits=2),
"Timesheeting on project should not incremented the delivered quantity on the SO line"
)
self.assertEqual(
sale_order.invoice_status, 'no',
'Sale Timesheet: "invoice on delivery" timesheets should be invoiced completely by now'
)
self.assertEqual(
timesheet3.timesheet_invoice_type, 'non_billable_project',
"Timesheets without task shoulbe be 'no project found'")
self.assertFalse(
timesheet3.timesheet_invoice_id,
"The timesheet3 should not be linked to the invoice yet")
# let's log some timesheets on the task (new task/new project)
timesheet4 = self.env['account.analytic.line'].create({
'name':
'Test Line 4',
'project_id':
task_serv2.project_id.id,
'task_id':
task_serv2.id,
'unit_amount':
7,
'employee_id':
self.employee_user.id,
})
self.assertFalse(
timesheet4.timesheet_invoice_id,
"The timesheet4 should not be linked to the invoice yet")
# modify a non invoiced timesheet
timesheet4.write({'unit_amount': 42})
self.assertFalse(
timesheet4.timesheet_invoice_id,
"The timesheet4 should not still be linked to the invoice")
# validate the second invoice
invoice2.post()
self.assertEqual(
timesheet1.timesheet_invoice_id, invoice1,
"The timesheet1 should not be linked to the invoice 1, even after validation"
)
self.assertEqual(
timesheet2.timesheet_invoice_id, invoice2,
"The timesheet2 should not be linked to the invoice 1, even after validation"
)
self.assertFalse(
timesheet3.timesheet_invoice_id,
"The timesheet3 should not be linked to the invoice, since we are in ordered quantity"
)
self.assertFalse(
timesheet4.timesheet_invoice_id,
"The timesheet4 should not be linked to the invoice, since we are in ordered quantity"
)
def test_timesheet_order(self):
""" Test timesheet invoicing with 'invoice on order' timetracked products
1. create SO with 2 ordered product and confirm
2. create invoice
3. log timesheet
4. add new SO line (ordered service)
5. create new invoice
"""
# create SO and confirm it
sale_order = self.env['sale.order'].create({
'partner_id':
self.partner_customer_usd.id,
'partner_invoice_id':
self.partner_customer_usd.id,
'partner_shipping_id':
self.partner_customer_usd.id,
'pricelist_id':
self.pricelist_usd.id,
})
so_line_ordered_project_only = self.env['sale.order.line'].create({
'name':
self.product_order_timesheet4.name,
'product_id':
self.product_order_timesheet4.id,
'product_uom_qty':
10,
'product_uom':
self.product_order_timesheet4.uom_id.id,
'price_unit':
self.product_order_timesheet4.list_price,
'order_id':
sale_order.id,
})
so_line_ordered_global_project = self.env['sale.order.line'].create({
'name':
self.product_order_timesheet2.name,
'product_id':
self.product_order_timesheet2.id,
'product_uom_qty':
50,
'product_uom':
self.product_order_timesheet2.uom_id.id,
'price_unit':
self.product_order_timesheet2.list_price,
'order_id':
sale_order.id,
})
so_line_ordered_project_only.product_id_change()
so_line_ordered_global_project.product_id_change()
sale_order.action_confirm()
task_serv2 = self.env['project.task'].search([
('sale_line_id', '=', so_line_ordered_global_project.id)
])
project_serv1 = self.env['project.project'].search([
('sale_line_id', '=', so_line_ordered_project_only.id)
])
self.assertEqual(
sale_order.tasks_count, 1,
"One task should have been created on SO confirmation")
self.assertEqual(
len(sale_order.project_ids), 2,
"One project should have been created by the SO, when confirmed + the one from SO line 2 'task in global project'"
)
self.assertEqual(
sale_order.analytic_account_id, project_serv1.analytic_account_id,
"The created project should be linked to the analytic account of the SO"
)
# create invoice
invoice1 = sale_order._create_invoices()[0]
# let's log some timesheets (on the project created by so_line_ordered_project_only)
timesheet1 = self.env['account.analytic.line'].create({
'name':
'Test Line',
'project_id':
task_serv2.project_id.id,
'task_id':
task_serv2.id,
'unit_amount':
10.5,
'employee_id':
self.employee_user.id,
})
self.assertEqual(
so_line_ordered_global_project.qty_delivered, 10.5,
'Timesheet directly on project does not increase delivered quantity on so line'
)
self.assertEqual(
sale_order.invoice_status, 'invoiced',
'Sale Timesheet: "invoice on order" timesheets should not modify the invoice_status of the so'
)
self.assertEqual(
timesheet1.timesheet_invoice_type, 'billable_fixed',
"Timesheets linked to SO line with ordered product shoulbe be billable fixed"
)
self.assertFalse(
timesheet1.timesheet_invoice_id,
"The timesheet1 should not be linked to the invoice, since we are in ordered quantity"
)
timesheet2 = self.env['account.analytic.line'].create({
'name':
'Test Line',
'project_id':
task_serv2.project_id.id,
'task_id':
task_serv2.id,
'unit_amount':
39.5,
'employee_id':
self.employee_user.id,
})
self.assertEqual(
so_line_ordered_global_project.qty_delivered, 50,
'Sale Timesheet: timesheet does not increase delivered quantity on so line'
)
self.assertEqual(
sale_order.invoice_status, 'invoiced',
'Sale Timesheet: "invoice on order" timesheets should not modify the invoice_status of the so'
)
self.assertEqual(
timesheet2.timesheet_invoice_type, 'billable_fixed',
"Timesheets linked to SO line with ordered product shoulbe be billable fixed"
)
self.assertFalse(
timesheet2.timesheet_invoice_id,
"The timesheet should not be linked to the invoice, since we are in ordered quantity"
)
timesheet3 = self.env['account.analytic.line'].create({
'name':
'Test Line',
'project_id':
task_serv2.project_id.id,
'unit_amount':
10,
'employee_id':
self.employee_user.id,
})
self.assertEqual(
so_line_ordered_project_only.qty_delivered, 0.0,
'Timesheet directly on project does not increase delivered quantity on so line'
)
self.assertEqual(
timesheet3.timesheet_invoice_type, 'non_billable_project',
"Timesheets without task shoulbe be 'no project found'")
self.assertFalse(
timesheet3.timesheet_invoice_id,
"The timesheet should not be linked to the invoice, since we are in ordered quantity"
)
# log timesheet on task in global project (higher than the initial ordrered qty)
timesheet4 = self.env['account.analytic.line'].create({
'name':
'Test Line',
'project_id':
task_serv2.project_id.id,
'task_id':
task_serv2.id,
'unit_amount':
5,
'employee_id':
self.employee_user.id,
})
self.assertEqual(
sale_order.invoice_status, 'upselling',
'Sale Timesheet: "invoice on order" timesheets should not modify the invoice_status of the so'
)
self.assertFalse(
timesheet4.timesheet_invoice_id,
"The timesheet should not be linked to the invoice, since we are in ordered quantity"
)
# add so line with produdct "create task in new project".
so_line_ordered_task_in_project = self.env['sale.order.line'].create({
'name':
self.product_order_timesheet3.name,
'product_id':
self.product_order_timesheet3.id,
'product_uom_qty':
3,
'product_uom':
self.product_order_timesheet3.uom_id.id,
'price_unit':
self.product_order_timesheet3.list_price,
'order_id':
sale_order.id,
})
self.assertEqual(
sale_order.invoice_status, 'to invoice',
'Sale Timesheet: Adding a new service line (so line) should put the SO in "to invocie" state.'
)
self.assertEqual(
sale_order.tasks_count, 2,
"Two tasks (1 per SO line) should have been created on SO confirmation"
)
self.assertEqual(
len(sale_order.project_ids), 2,
"No new project should have been created by the SO, when selling 'new task in new project' product, since it reuse the one from 'project only'."
)
# get first invoice line of sale line linked to timesheet1
invoice_line_1 = so_line_ordered_global_project.invoice_lines.filtered(
lambda line: line.move_id == invoice1)
self.assertEqual(
so_line_ordered_global_project.product_uom_qty,
invoice_line_1.quantity,
"The invoice (ordered) quantity should not change when creating timesheet"
)
# timesheet can be modified
timesheet1.write({'unit_amount': 12})
self.assertEqual(
so_line_ordered_global_project.product_uom_qty,
invoice_line_1.quantity,
"The invoice (ordered) quantity should not change when modifying timesheet"
)
# create second invoice
invoice2 = sale_order._create_invoices()[0]
self.assertEqual(
len(sale_order.invoice_ids), 2,
"A second invoice should have been created from the SO")
self.assertTrue(
float_is_zero(invoice2.amount_total -
so_line_ordered_task_in_project.price_unit * 3,
precision_digits=2),
'Sale: invoice generation on timesheets product is wrong')
self.assertFalse(
timesheet1.timesheet_invoice_id,
"The timesheet1 should not be linked to the invoice, since we are in ordered quantity"
)
self.assertFalse(
timesheet2.timesheet_invoice_id,
"The timesheet2 should not be linked to the invoice, since we are in ordered quantity"
)
self.assertFalse(
timesheet3.timesheet_invoice_id,
"The timesheet3 should not be linked to the invoice, since we are in ordered quantity"
)
self.assertFalse(
timesheet4.timesheet_invoice_id,
"The timesheet4 should not be linked to the invoice, since we are in ordered quantity"
)
# validate the first invoice
invoice1.post()
self.assertEqual(
so_line_ordered_global_project.product_uom_qty,
invoice_line_1.quantity,
"The invoice (ordered) quantity should not change when modifying timesheet"
)
self.assertFalse(
timesheet1.timesheet_invoice_id,
"The timesheet1 should not be linked to the invoice, since we are in ordered quantity"
)
self.assertFalse(
timesheet2.timesheet_invoice_id,
"The timesheet2 should not be linked to the invoice, since we are in ordered quantity"
)
self.assertFalse(
timesheet3.timesheet_invoice_id,
"The timesheet3 should not be linked to the invoice, since we are in ordered quantity"
)
self.assertFalse(
timesheet4.timesheet_invoice_id,
"The timesheet4 should not be linked to the invoice, since we are in ordered quantity"
)
# timesheet can still be modified
timesheet1.write({'unit_amount': 13})
def _get_partner_move_lines(self, account_type, date_from, target_move,
period_length):
# This method can receive the context key 'include_nullified_amount' {Boolean}
# Do an invoice and a payment and unreconcile. The amount will be nullified
# By default, the partner wouldn't appear in this report.
# The context key allow it to appear
# In case of a period_length of 30 days as of 2019-02-08, we want the following periods:
# Name Stop Start
# 1 - 30 : 2019-02-07 - 2019-01-09
# 31 - 60 : 2019-01-08 - 2018-12-10
# 61 - 90 : 2018-12-09 - 2018-11-10
# 91 - 120 : 2018-11-09 - 2018-10-11
# +120 : 2018-10-10
ctx = self._context
periods = {}
date_from = fields.Date.from_string(date_from)
start = date_from
for i in range(5)[::-1]:
stop = start - relativedelta(days=period_length)
period_name = str((5 - (i + 1)) * period_length + 1) + '-' + str(
(5 - i) * period_length)
period_stop = (start - relativedelta(days=1)).strftime('%Y-%m-%d')
if i == 0:
period_name = '+' + str(4 * period_length)
periods[str(i)] = {
'name': period_name,
'stop': period_stop,
'start': (i != 0 and stop.strftime('%Y-%m-%d') or False),
}
start = stop
res = []
total = []
partner_clause = ''
cr = self.env.cr
user_company = self.env.company
user_currency = user_company.currency_id
company_ids = self._context.get('company_ids') or [user_company.id]
move_state = ['draft', 'posted']
if target_move == 'posted':
move_state = ['posted']
arg_list = (
tuple(move_state),
tuple(account_type),
date_from,
date_from,
)
if ctx.get('partner_ids'):
partner_clause = 'AND (l.partner_id IN %s)'
arg_list += (tuple(ctx['partner_ids'].ids), )
if ctx.get('partner_categories'):
partner_clause += 'AND (l.partner_id IN %s)'
partner_ids = self.env['res.partner'].search([
('category_id', 'in', ctx['partner_categories'].ids)
]).ids
arg_list += (tuple(partner_ids or [0]), )
arg_list += (date_from, tuple(company_ids))
query = '''
SELECT DISTINCT l.partner_id, res_partner.name AS name, UPPER(res_partner.name) AS UPNAME, CASE WHEN prop.value_text IS NULL THEN 'normal' ELSE prop.value_text END AS trust
FROM account_move_line AS l
LEFT JOIN res_partner ON l.partner_id = res_partner.id
LEFT JOIN ir_property prop ON (prop.res_id = 'res.partner,'||res_partner.id AND prop.name='trust' AND prop.company_id=%s),
account_account, account_move am
WHERE (l.account_id = account_account.id)
AND (l.move_id = am.id)
AND (am.state IN %s)
AND (account_account.internal_type IN %s)
AND (
l.reconciled IS FALSE
OR l.id IN(
SELECT credit_move_id FROM account_partial_reconcile where max_date > %s
UNION ALL
SELECT debit_move_id FROM account_partial_reconcile where max_date > %s
)
)
''' + partner_clause + '''
AND (l.date <= %s)
AND l.company_id IN %s
ORDER BY UPPER(res_partner.name)'''
arg_list = (self.env.company.id, ) + arg_list
cr.execute(query, arg_list)
partners = cr.dictfetchall()
# put a total of 0
for i in range(7):
total.append(0)
# Build a string like (1,2,3) for easy use in SQL query
partner_ids = [
partner['partner_id'] for partner in partners
if partner['partner_id']
]
lines = dict(
(partner['partner_id'] or False, []) for partner in partners)
if not partner_ids:
return [], [], {}
# Use one query per period and store results in history (a list variable)
# Each history will contain: history[1] = {'<partner_id>': <partner_debit-credit>}
history = []
for i in range(5):
args_list = (
tuple(move_state),
tuple(account_type),
tuple(partner_ids),
)
dates_query = '(COALESCE(l.date_maturity,l.date)'
if periods[str(i)]['start'] and periods[str(i)]['stop']:
dates_query += ' BETWEEN %s AND %s)'
args_list += (periods[str(i)]['start'],
periods[str(i)]['stop'])
elif periods[str(i)]['start']:
dates_query += ' >= %s)'
args_list += (periods[str(i)]['start'], )
else:
dates_query += ' <= %s)'
args_list += (periods[str(i)]['stop'], )
args_list += (date_from, tuple(company_ids))
query = '''SELECT l.id
FROM account_move_line AS l, account_account, account_move am
WHERE (l.account_id = account_account.id) AND (l.move_id = am.id)
AND (am.state IN %s)
AND (account_account.internal_type IN %s)
AND ((l.partner_id IN %s) OR (l.partner_id IS NULL))
AND ''' + dates_query + '''
AND (l.date <= %s)
AND l.company_id IN %s
ORDER BY COALESCE(l.date_maturity, l.date)'''
cr.execute(query, args_list)
partners_amount = {}
aml_ids = cr.fetchall()
aml_ids = aml_ids and [x[0] for x in aml_ids] or []
for line in self.env['account.move.line'].browse(
aml_ids).with_context(prefetch_fields=False):
partner_id = line.partner_id.id or False
if partner_id not in partners_amount:
partners_amount[partner_id] = 0.0
line_amount = line.company_id.currency_id._convert(
line.balance, user_currency, user_company, date_from)
if user_currency.is_zero(line_amount):
continue
for partial_line in line.matched_debit_ids:
if partial_line.max_date <= date_from:
line_amount += partial_line.company_id.currency_id._convert(
partial_line.amount, user_currency, user_company,
date_from)
for partial_line in line.matched_credit_ids:
if partial_line.max_date <= date_from:
line_amount -= partial_line.company_id.currency_id._convert(
partial_line.amount, user_currency, user_company,
date_from)
if not self.env.company.currency_id.is_zero(line_amount):
partners_amount[partner_id] += line_amount
lines.setdefault(partner_id, [])
lines[partner_id].append({
'line': line,
'amount': line_amount,
'period': i + 1,
})
history.append(partners_amount)
# This dictionary will store the not due amount of all partners
undue_amounts = {}
query = '''SELECT l.id
FROM account_move_line AS l, account_account, account_move am
WHERE (l.account_id = account_account.id) AND (l.move_id = am.id)
AND (am.state IN %s)
AND (account_account.internal_type IN %s)
AND (COALESCE(l.date_maturity,l.date) >= %s)\
AND ((l.partner_id IN %s) OR (l.partner_id IS NULL))
AND (l.date <= %s)
AND l.company_id IN %s
ORDER BY COALESCE(l.date_maturity, l.date)'''
cr.execute(query, (tuple(move_state), tuple(account_type), date_from,
tuple(partner_ids), date_from, tuple(company_ids)))
aml_ids = cr.fetchall()
aml_ids = aml_ids and [x[0] for x in aml_ids] or []
for line in self.env['account.move.line'].browse(aml_ids):
partner_id = line.partner_id.id or False
if partner_id not in undue_amounts:
undue_amounts[partner_id] = 0.0
line_amount = line.company_id.currency_id._convert(
line.balance, user_currency, user_company, date_from)
if user_currency.is_zero(line_amount):
continue
for partial_line in line.matched_debit_ids:
if partial_line.max_date <= date_from:
line_amount += partial_line.company_id.currency_id._convert(
partial_line.amount, user_currency, user_company,
date_from)
for partial_line in line.matched_credit_ids:
if partial_line.max_date <= date_from:
line_amount -= partial_line.company_id.currency_id._convert(
partial_line.amount, user_currency, user_company,
date_from)
if not self.env.company.currency_id.is_zero(line_amount):
undue_amounts[partner_id] += line_amount
lines.setdefault(partner_id, [])
lines[partner_id].append({
'line': line,
'amount': line_amount,
'period': 6,
})
for partner in partners:
if partner['partner_id'] is None:
partner['partner_id'] = False
at_least_one_amount = False
values = {}
undue_amt = 0.0
if partner[
'partner_id'] in undue_amounts: # Making sure this partner actually was found by the query
undue_amt = undue_amounts[partner['partner_id']]
total[6] = total[6] + undue_amt
values['direction'] = undue_amt
if not float_is_zero(
values['direction'],
precision_rounding=self.env.company.currency_id.rounding):
at_least_one_amount = True
for i in range(5):
during = False
if partner['partner_id'] in history[i]:
during = [history[i][partner['partner_id']]]
# Adding counter
total[(i)] = total[(i)] + (during and during[0] or 0)
values[str(i)] = during and during[0] or 0.0
if not float_is_zero(values[str(i)],
precision_rounding=self.env.company.
currency_id.rounding):
at_least_one_amount = True
values['total'] = sum([values['direction']] +
[values[str(i)] for i in range(5)])
# Add for total
total[(i + 1)] += values['total']
values['partner_id'] = partner['partner_id']
if partner['partner_id']:
values['name'] = len(partner['name']) >= 45 and partner[
'name'][0:40] + '...' or partner['name']
values['trust'] = partner['trust']
else:
values['name'] = _('Unknown Partner')
values['trust'] = False
if at_least_one_amount or (
self._context.get('include_nullified_amount')
and lines[partner['partner_id']]):
res.append(values)
return res, total, lines
def try_zero(amount, expected):
self.assertEqual(float_is_zero(amount,
precision_digits=3), expected,
"Rounding error: %s should be zero!" % amount)
