william-andre
d8d47f9ff8
TLDR:
* invoices are implemented using computed methods instead of onchange
* the synchronization only happens when switching tabs in the Form view
to improve perfs.
_______________________________________________________________________
The whole engine of the synchronization of Invoices to the Journal
Entries has been refactored
* by using computed fields instead of onchange functions
* by synchronizing only from invoice to journal entry in `create` and
`write`
* by saving when switching tabs on the Invoice form, to synchronize
before showing the values
This comes with numerous advantages:
* no need to call the onchange methods manually
* no need to use the Form emulator to build invoices (i.e. EDI, OCR,
intercompany, ...)
* the performance for invoices with many lines improves drastically, going
from 2 minutes to 4 seconds to create an invoice with 500 lines
* the model is more declarative, we can now see how the values are computed
instead of having the values being copied from various places.
* remove the hack in `onchange` that disabled the recursivity of it,
which was unexpected and needed to be managed manually in all the
onchange methods
This means that:
* Some fields need to be exclusively computed on journal entries values
or invoice values, more specifically the Tax Summary widget.
It is now
- computed from entry lines, when opening the view
- computed from invoice lines when changing those, because the tax lines
will need to be recomputed anyways, erasing previously set values
- set with an inverse function when saving; after the sync has been done
* Some possible operations previously possible have been dropped.
(i.e. look at the removed test test_in_invoice_line_onchange_accounting_fields_1)
This is because such a behavior was undefined (how is changing the balance going
to affect the unit price? How is the amount currency going to affect it?)
_______________________________________________________________________
Implementation Details
----------------------
The "dynamic lines", meaning the payment terms and the tax lines are now
only created in the `create` and `write` functions.
In order to reduce code duplication, it has been implemented using
context managers used in both `account.move` and `account.move.line`
These context managers help comparing the values before/after, acting
like a local `onchange`, but getting benefit from the dirty flags from
the `compute` dependences.
This is relying on computed fields on the move (`needed_terms`) and on
the lines (`compute_all_tax`) which contain the values needed for the
related move.
Depending on the needed values and the existing values (`term_key` and
`tax_key`, respectively) the context manager will determine what needs
to be created/updated/deleted.
Some related changes are to produce a `dict` instead of a `str` for the
`tax_totals` (previously `tax_totals_json`) fields, by simplicity to
reduce the complexity of IO, and simplicity of debugging, because the
logic of the field needed to change (cannot be computed at the same time
anymore since it needed the lines to be synced)
By simplicity, and also because it makes more sense, some boolean fields
have been merged into `display_type`:
* `is_rounding_line`
* `exclude_from_invoice_tab`
* `is_anglo_saxon_line`
The `price_unit`, `quantity` and other "invoice fields" are now not set
anymore on lines that are not product lines since it didn't make any
sense to have it.
Performances
------------
You have to keep in mind that a simple `create` didn't compute a lot of
fields, for instance not taxes were set, no payment terms,...
Now it does.
```python
import random
from timeit import timeit
from odoo import Command
domain = [('company_id', 'in', (False, self.env.company.id))]
products = self.env['product.product'].search(domain).ids
partners = self.env['res.partner'].search(domain).ids
taxes = self.env['account.tax'].search(domain).ids
def create(nmove, nline):
self.env['account.move'].create([
{
'move_type': 'out_invoice',
'partner_id': random.choice(partners),
'invoice_line_ids': [
Command.create({
'name': f'line{i}',
'product_id': random.choice(products),
'tax_ids': [Command.set([random.choice(taxes)])],
})
for i in range(nline)
]
}
for j in range(nmove)
])
# After | Before
print(timeit("create(1, 1)", globals=globals(), number=1)) # 0.11 | 0.09
print(timeit("create(100, 1)", globals=globals(), number=1)) # 2.76 | 2.50
print(timeit("create(500, 1)", globals=globals(), number=1)) # 14.56 | 12.34
print(timeit("create(1, 100)", globals=globals(), number=1)) # 1.03 | 5.52
print(timeit("create(1, 500)", globals=globals(), number=1)) # 3.99 | 125.02
print(timeit("create(50, 50)", globals=globals(), number=1)) # 19.44 | 79.55
```
Another metric that can be used is running the test suite with
`--test-tags=/account` (only `account` installed)
* before: 404s, 267127 queries (366 tests)
* after: 318s, 232125 queries (362 tests)
Why this commit title?
----------------------
Someone told me that this was the perfect way of naming your commits.
c04065abd8
task-2711317
closes odoo/odoo#96134
Related: odoo/upgrade#3715
Related: odoo/enterprise#29758
Signed-off-by: Laurent Smet <las@odoo.com>
903 lines
45 KiB
Python
903 lines
45 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from collections import defaultdict
|
|
from random import randint
|
|
|
|
from markupsafe import Markup
|
|
|
|
from odoo import api, fields, models, _
|
|
from odoo.exceptions import UserError, ValidationError
|
|
from odoo.tools import float_compare, is_html_empty
|
|
|
|
|
|
class StockMove(models.Model):
|
|
_inherit = 'stock.move'
|
|
|
|
repair_id = fields.Many2one('repair.order', check_company=True)
|
|
|
|
|
|
class Repair(models.Model):
|
|
_name = 'repair.order'
|
|
_description = 'Repair Order'
|
|
_inherit = ['mail.thread', 'mail.activity.mixin']
|
|
_order = 'priority desc, create_date desc'
|
|
|
|
name = fields.Char(
|
|
'Repair Reference',
|
|
default='New', index='trigram',
|
|
copy=False, required=True,
|
|
readonly=True)
|
|
description = fields.Char('Repair Description')
|
|
product_id = fields.Many2one(
|
|
'product.product', string='Product to Repair',
|
|
domain="[('type', 'in', ['product', 'consu']), '|', ('company_id', '=', company_id), ('company_id', '=', False)]",
|
|
readonly=True, required=True, states={'draft': [('readonly', False)]}, check_company=True)
|
|
product_qty = fields.Float(
|
|
'Product Quantity',
|
|
default=1.0, digits='Product Unit of Measure',
|
|
readonly=True, required=True, states={'draft': [('readonly', False)]})
|
|
product_uom = fields.Many2one(
|
|
'uom.uom', 'Product Unit of Measure',
|
|
compute='_compute_product_uom', store=True, precompute=True,
|
|
readonly=True, required=True, states={'draft': [('readonly', False)]}, domain="[('category_id', '=', product_uom_category_id)]")
|
|
product_uom_category_id = fields.Many2one(related='product_id.uom_id.category_id')
|
|
partner_id = fields.Many2one(
|
|
'res.partner', 'Customer',
|
|
index=True, states={'confirmed': [('readonly', True)]}, check_company=True, change_default=True,
|
|
help='Choose partner for whom the order will be invoiced and delivered. You can find a partner by its Name, TIN, Email or Internal Reference.')
|
|
address_id = fields.Many2one(
|
|
'res.partner', 'Delivery Address',
|
|
domain="[('parent_id','=',partner_id)]", check_company=True,
|
|
states={'confirmed': [('readonly', True)]})
|
|
default_address_id = fields.Many2one('res.partner', compute='_compute_default_address_id')
|
|
state = fields.Selection([
|
|
('draft', 'Quotation'),
|
|
('confirmed', 'Confirmed'),
|
|
('ready', 'Ready to Repair'),
|
|
('under_repair', 'Under Repair'),
|
|
('2binvoiced', 'To be Invoiced'),
|
|
('done', 'Repaired'),
|
|
('cancel', 'Cancelled')], string='Status',
|
|
copy=False, default='draft', readonly=True, tracking=True,
|
|
help="* The \'Draft\' status is used when a user is encoding a new and unconfirmed repair order.\n"
|
|
"* The \'Confirmed\' status is used when a user confirms the repair order.\n"
|
|
"* The \'Ready to Repair\' status is used to start to repairing, user can start repairing only after repair order is confirmed.\n"
|
|
"* The \'Under Repair\' status is used when the repair is ongoing.\n"
|
|
"* The \'To be Invoiced\' status is used to generate the invoice before or after repairing done.\n"
|
|
"* The \'Done\' status is set when repairing is completed.\n"
|
|
"* The \'Cancelled\' status is used when user cancel repair order.")
|
|
schedule_date = fields.Date("Scheduled Date")
|
|
location_id = fields.Many2one(
|
|
'stock.location', 'Location',
|
|
compute="_compute_location_id", store=True, precompute=True,
|
|
index=True, readonly=True, required=True, check_company=True,
|
|
help="This is the location where the product to repair is located.",
|
|
states={'draft': [('readonly', False)], 'confirmed': [('readonly', True)]})
|
|
lot_id = fields.Many2one(
|
|
'stock.lot', 'Lot/Serial',
|
|
domain="[('product_id','=', product_id), ('company_id', '=', company_id)]", check_company=True,
|
|
help="Products repaired are all belonging to this lot")
|
|
guarantee_limit = fields.Date('Warranty Expiration', states={'confirmed': [('readonly', True)]})
|
|
operations = fields.One2many(
|
|
'repair.line', 'repair_id', 'Parts',
|
|
copy=True)
|
|
pricelist_id = fields.Many2one(
|
|
'product.pricelist', 'Pricelist',
|
|
default=lambda self: self.env['product.pricelist'].search([('company_id', 'in', [self.env.company.id, False])], limit=1).id,
|
|
help='Pricelist of the selected partner.', check_company=True)
|
|
currency_id = fields.Many2one(related='pricelist_id.currency_id')
|
|
partner_invoice_id = fields.Many2one('res.partner', 'Invoicing Address', check_company=True)
|
|
invoice_method = fields.Selection([
|
|
("none", "No Invoice"),
|
|
("b4repair", "Before Repair"),
|
|
("after_repair", "After Repair")], string="Invoice Method",
|
|
default='none', index=True, readonly=True, required=True,
|
|
states={'draft': [('readonly', False)]},
|
|
help='Selecting \'Before Repair\' or \'After Repair\' will allow you to generate invoice before or after the repair is done respectively. \'No invoice\' means you don\'t want to generate invoice for this repair order.')
|
|
invoice_id = fields.Many2one(
|
|
'account.move', 'Invoice',
|
|
copy=False, readonly=True, tracking=True,
|
|
domain=[('move_type', '=', 'out_invoice')])
|
|
move_id = fields.Many2one(
|
|
'stock.move', 'Inventory Move',
|
|
copy=False, readonly=True, tracking=True, check_company=True)
|
|
fees_lines = fields.One2many(
|
|
'repair.fee', 'repair_id', 'Operations',
|
|
copy=True, readonly=False)
|
|
internal_notes = fields.Html('Internal Notes')
|
|
quotation_notes = fields.Html('Quotation Notes')
|
|
user_id = fields.Many2one('res.users', string="Responsible", default=lambda self: self.env.user, check_company=True)
|
|
company_id = fields.Many2one(
|
|
'res.company', 'Company',
|
|
readonly=True, required=True, index=True,
|
|
default=lambda self: self.env.company)
|
|
sale_order_id = fields.Many2one(
|
|
'sale.order', 'Sale Order', check_company=True,
|
|
copy=False, help="Sale Order from which the product to be repaired comes from.")
|
|
picking_id = fields.Many2one(
|
|
'stock.picking', 'Return', check_company=True,
|
|
copy=False, help="Return Order from which the product to be repaired comes from.")
|
|
allowed_picking_type_ids = fields.Many2many('stock.picking.type', compute='_compute_allowed_picking_type_ids')
|
|
is_returned = fields.Boolean(
|
|
"Returned", compute='_compute_is_returned',
|
|
help="True if this repair is linked to a Return Order and the order is 'Done'. False otherwise.")
|
|
tag_ids = fields.Many2many('repair.tags', string="Tags")
|
|
invoiced = fields.Boolean('Invoiced', copy=False, readonly=True)
|
|
repaired = fields.Boolean('Repaired', copy=False, readonly=True)
|
|
amount_untaxed = fields.Float('Untaxed Amount', compute='_amount_untaxed', store=True)
|
|
amount_tax = fields.Float('Taxes', compute='_amount_tax', store=True)
|
|
amount_total = fields.Float('Total', compute='_amount_total', store=True)
|
|
tracking = fields.Selection(string='Product Tracking', related="product_id.tracking", readonly=False)
|
|
invoice_state = fields.Selection(string='Invoice State', related='invoice_id.state')
|
|
priority = fields.Selection([('0', 'Normal'), ('1', 'Urgent')], default='0', string="Priority")
|
|
|
|
def _compute_allowed_picking_type_ids(self):
|
|
'''
|
|
computes the ids of return picking types
|
|
'''
|
|
out_picking_types = self.env['stock.picking.type'].search_read(domain=[('code', '=', 'outgoing')],
|
|
fields=['return_picking_type_id'], load='')
|
|
self.allowed_picking_type_ids = [pick_type['return_picking_type_id'] for pick_type in out_picking_types]
|
|
|
|
@api.depends('partner_id')
|
|
def _compute_default_address_id(self):
|
|
for order in self:
|
|
if order.partner_id:
|
|
order.default_address_id = order.partner_id.address_get(['contact'])['contact']
|
|
|
|
@api.depends('picking_id', 'picking_id.state')
|
|
def _compute_is_returned(self):
|
|
self.is_returned = False
|
|
returned = self.filtered(lambda r: r.picking_id and r.picking_id.state == 'done')
|
|
returned.is_returned = True
|
|
|
|
@api.depends('operations.price_subtotal', 'invoice_method', 'fees_lines.price_subtotal', 'pricelist_id.currency_id')
|
|
def _amount_untaxed(self):
|
|
for order in self:
|
|
total = sum(operation.price_subtotal for operation in order.operations)
|
|
total += sum(fee.price_subtotal for fee in order.fees_lines)
|
|
currency = order.pricelist_id.currency_id or self.env.company.currency_id
|
|
order.amount_untaxed = currency.round(total)
|
|
|
|
@api.depends('operations.price_unit', 'operations.product_uom_qty', 'operations.product_id',
|
|
'fees_lines.price_unit', 'fees_lines.product_uom_qty', 'fees_lines.product_id',
|
|
'pricelist_id.currency_id', 'partner_id')
|
|
def _amount_tax(self):
|
|
for order in self:
|
|
val = 0.0
|
|
currency = order.pricelist_id.currency_id or self.env.company.currency_id
|
|
for operation in order.operations:
|
|
if operation.tax_id:
|
|
tax_calculate = operation.tax_id.compute_all(operation.price_unit, currency, operation.product_uom_qty, operation.product_id, order.partner_id)
|
|
for c in tax_calculate['taxes']:
|
|
val += c['amount']
|
|
for fee in order.fees_lines:
|
|
if fee.tax_id:
|
|
tax_calculate = fee.tax_id.compute_all(fee.price_unit, currency, fee.product_uom_qty, fee.product_id, order.partner_id)
|
|
for c in tax_calculate['taxes']:
|
|
val += c['amount']
|
|
order.amount_tax = val
|
|
|
|
@api.depends('amount_untaxed', 'amount_tax')
|
|
def _amount_total(self):
|
|
for order in self:
|
|
currency = order.pricelist_id.currency_id or self.env.company.currency_id
|
|
order.amount_total = currency.round(order.amount_untaxed + order.amount_tax)
|
|
|
|
_sql_constraints = [
|
|
('name', 'unique (name)', 'The name of the Repair Order must be unique!'),
|
|
]
|
|
|
|
@api.onchange('location_id', 'picking_id')
|
|
def _onchange_location_picking(self):
|
|
location_warehouse = self.location_id.warehouse_id
|
|
picking_warehouse = self.picking_id.location_dest_id.warehouse_id
|
|
if location_warehouse and picking_warehouse and location_warehouse != picking_warehouse:
|
|
return {
|
|
'warning': {'title': "Warning", 'message': "Note that the warehouse of the return and repair locations don't match!"},
|
|
}
|
|
|
|
@api.depends('product_id')
|
|
def _compute_product_uom(self):
|
|
for repair in self:
|
|
if repair.product_id:
|
|
repair.product_uom = repair.product_id.uom_id
|
|
|
|
@api.onchange('product_id')
|
|
def onchange_product_id(self):
|
|
self.guarantee_limit = False
|
|
if (self.product_id and self.lot_id and self.lot_id.product_id != self.product_id) or not self.product_id:
|
|
self.lot_id = False
|
|
|
|
@api.onchange('product_uom')
|
|
def onchange_product_uom(self):
|
|
res = {}
|
|
if not self.product_id or not self.product_uom:
|
|
return res
|
|
if self.product_uom.category_id != self.product_id.uom_id.category_id:
|
|
res['warning'] = {'title': _('Warning'), 'message': _('The product unit of measure you chose has a different category than the product unit of measure.')}
|
|
self.product_uom = self.product_id.uom_id.id
|
|
return res
|
|
|
|
@api.onchange('partner_id')
|
|
def onchange_partner_id(self):
|
|
self = self.with_company(self.company_id)
|
|
if not self.partner_id:
|
|
self.address_id = False
|
|
self.partner_invoice_id = False
|
|
self.pricelist_id = self.env['product.pricelist'].search([
|
|
('company_id', 'in', [self.env.company.id, False]),
|
|
], limit=1)
|
|
else:
|
|
addresses = self.partner_id.address_get(['delivery', 'invoice', 'contact'])
|
|
self.address_id = addresses['delivery'] or addresses['contact']
|
|
self.partner_invoice_id = addresses['invoice']
|
|
self.pricelist_id = self.partner_id.property_product_pricelist.id
|
|
|
|
@api.depends('company_id')
|
|
def _compute_location_id(self):
|
|
for order in self:
|
|
if order.company_id:
|
|
if order.location_id.company_id != order.company_id:
|
|
warehouse = self.env['stock.warehouse'].search([('company_id', '=', order.company_id.id)], limit=1)
|
|
order.location_id = warehouse.lot_stock_id
|
|
else:
|
|
order.location_id = False
|
|
|
|
@api.ondelete(at_uninstall=False)
|
|
def _unlink_except_confirmed(self):
|
|
for order in self:
|
|
if order.invoice_id and order.invoice_id.posted_before:
|
|
raise UserError(_('You can not delete a repair order which is linked to an invoice which has been posted once.'))
|
|
if order.state not in ('draft', 'cancel'):
|
|
raise UserError(_('You can not delete a repair order once it has been confirmed. You must first cancel it.'))
|
|
|
|
@api.model_create_multi
|
|
def create(self, vals_list):
|
|
# We generate a standard reference
|
|
for vals in vals_list:
|
|
vals['name'] = self.env['ir.sequence'].next_by_code('repair.order') or '/'
|
|
return super().create(vals_list)
|
|
|
|
def button_dummy(self):
|
|
# TDE FIXME: this button is very interesting
|
|
return True
|
|
|
|
def action_repair_cancel_draft(self):
|
|
if self.filtered(lambda repair: repair.state != 'cancel'):
|
|
raise UserError(_("Repair must be canceled in order to reset it to draft."))
|
|
self.mapped('operations').write({'state': 'draft'})
|
|
return self.write({'state': 'draft', 'invoice_id': False})
|
|
|
|
def action_validate(self):
|
|
self.ensure_one()
|
|
if self.filtered(lambda repair: any(op.product_uom_qty < 0 for op in repair.operations)):
|
|
raise UserError(_("You can not enter negative quantities."))
|
|
if self.product_id.type == 'consu':
|
|
return self.action_repair_confirm()
|
|
precision = self.env['decimal.precision'].precision_get('Product Unit of Measure')
|
|
available_qty_owner = self.env['stock.quant']._get_available_quantity(self.product_id, self.location_id, self.lot_id, owner_id=self.partner_id, strict=True)
|
|
available_qty_noown = self.env['stock.quant']._get_available_quantity(self.product_id, self.location_id, self.lot_id, strict=True)
|
|
repair_qty = self.product_uom._compute_quantity(self.product_qty, self.product_id.uom_id)
|
|
for available_qty in [available_qty_owner, available_qty_noown]:
|
|
if float_compare(available_qty, repair_qty, precision_digits=precision) >= 0:
|
|
return self.action_repair_confirm()
|
|
else:
|
|
return {
|
|
'name': self.product_id.display_name + _(': Insufficient Quantity To Repair'),
|
|
'view_mode': 'form',
|
|
'res_model': 'stock.warn.insufficient.qty.repair',
|
|
'view_id': self.env.ref('repair.stock_warn_insufficient_qty_repair_form_view').id,
|
|
'type': 'ir.actions.act_window',
|
|
'context': {
|
|
'default_product_id': self.product_id.id,
|
|
'default_location_id': self.location_id.id,
|
|
'default_repair_id': self.id,
|
|
'default_quantity': repair_qty,
|
|
'default_product_uom_name': self.product_id.uom_name
|
|
},
|
|
'target': 'new'
|
|
}
|
|
|
|
def action_repair_confirm(self):
|
|
""" Repair order state is set to 'To be invoiced' when invoice method
|
|
is 'Before repair' else state becomes 'Confirmed'.
|
|
@param *arg: Arguments
|
|
@return: True
|
|
"""
|
|
if self.filtered(lambda repair: repair.state != 'draft'):
|
|
raise UserError(_("Only draft repairs can be confirmed."))
|
|
self._check_company()
|
|
self.operations._check_company()
|
|
self.fees_lines._check_company()
|
|
before_repair = self.filtered(lambda repair: repair.invoice_method == 'b4repair')
|
|
before_repair.write({'state': '2binvoiced'})
|
|
to_confirm = self - before_repair
|
|
to_confirm_operations = to_confirm.mapped('operations')
|
|
to_confirm_operations.write({'state': 'confirmed'})
|
|
to_confirm.write({'state': 'confirmed'})
|
|
return True
|
|
|
|
def action_repair_cancel(self):
|
|
invoice_to_cancel = self.filtered(lambda repair: repair.invoice_id.state == 'draft').invoice_id
|
|
if invoice_to_cancel:
|
|
invoice_to_cancel.button_cancel()
|
|
self.mapped('operations').write({'state': 'cancel'})
|
|
return self.write({'state': 'cancel'})
|
|
|
|
def action_send_mail(self):
|
|
self.ensure_one()
|
|
template_id = self.env.ref('repair.mail_template_repair_quotation').id
|
|
ctx = {
|
|
'default_model': 'repair.order',
|
|
'default_res_id': self.id,
|
|
'default_use_template': bool(template_id),
|
|
'default_template_id': template_id,
|
|
'default_composition_mode': 'comment',
|
|
'default_email_layout_xmlid': 'mail.mail_notification_light',
|
|
}
|
|
return {
|
|
'type': 'ir.actions.act_window',
|
|
'view_mode': 'form',
|
|
'res_model': 'mail.compose.message',
|
|
'target': 'new',
|
|
'context': ctx,
|
|
}
|
|
|
|
def print_repair_order(self):
|
|
return self.env.ref('repair.action_report_repair_order').report_action(self)
|
|
|
|
def action_repair_invoice_create(self):
|
|
for repair in self:
|
|
repair._create_invoices()
|
|
if repair.invoice_method == 'b4repair':
|
|
repair.action_repair_ready()
|
|
elif repair.invoice_method == 'after_repair':
|
|
repair.write({'state': 'done'})
|
|
return True
|
|
|
|
def _create_invoices(self, group=False):
|
|
""" Creates invoice(s) for repair order.
|
|
@param group: It is set to true when group invoice is to be generated.
|
|
@return: Invoice Ids.
|
|
"""
|
|
grouped_invoices_vals = {}
|
|
repairs = self.filtered(lambda repair: repair.state not in ('draft', 'cancel')
|
|
and not repair.invoice_id
|
|
and repair.invoice_method != 'none')
|
|
for repair in repairs:
|
|
repair = repair.with_company(repair.company_id)
|
|
partner_invoice = repair.partner_invoice_id or repair.partner_id
|
|
if not partner_invoice:
|
|
raise UserError(_('You have to select an invoice address in the repair form.'))
|
|
|
|
narration = repair.quotation_notes
|
|
currency = repair.pricelist_id.currency_id
|
|
company = repair.env.company
|
|
|
|
if (partner_invoice.id, currency.id, company.id) not in grouped_invoices_vals:
|
|
grouped_invoices_vals[(partner_invoice.id, currency.id, company.id)] = []
|
|
current_invoices_list = grouped_invoices_vals[(partner_invoice.id, currency.id, company.id)]
|
|
|
|
if not group or len(current_invoices_list) == 0:
|
|
fpos = self.env['account.fiscal.position']._get_fiscal_position(partner_invoice, delivery=repair.address_id)
|
|
invoice_vals = {
|
|
'move_type': 'out_invoice',
|
|
'partner_id': partner_invoice.id,
|
|
'partner_shipping_id': repair.address_id.id,
|
|
'currency_id': currency.id,
|
|
'narration': narration if not is_html_empty(narration) else '',
|
|
'invoice_origin': repair.name,
|
|
'repair_ids': [(4, repair.id)],
|
|
'invoice_line_ids': [],
|
|
'fiscal_position_id': fpos.id
|
|
}
|
|
if partner_invoice.property_payment_term_id:
|
|
invoice_vals['invoice_payment_term_id'] = partner_invoice.property_payment_term_id.id
|
|
current_invoices_list.append(invoice_vals)
|
|
else:
|
|
# if group == True: concatenate invoices by partner and currency
|
|
invoice_vals = current_invoices_list[0]
|
|
invoice_vals['invoice_origin'] += ', ' + repair.name
|
|
invoice_vals['repair_ids'].append((4, repair.id))
|
|
if not is_html_empty(narration):
|
|
if is_html_empty(invoice_vals['narration']):
|
|
invoice_vals['narration'] = narration
|
|
else:
|
|
invoice_vals['narration'] += Markup('<br/>') + narration
|
|
|
|
# Create invoice lines from operations.
|
|
for operation in repair.operations.filtered(lambda op: op.type == 'add'):
|
|
if group:
|
|
name = repair.name + '-' + operation.name
|
|
else:
|
|
name = operation.name
|
|
|
|
account = operation.product_id.product_tmpl_id.get_product_accounts(fiscal_pos=fpos)['income']
|
|
if not account:
|
|
raise UserError(_('No account defined for product "%s".', operation.product_id.name))
|
|
|
|
invoice_line_vals = {
|
|
'name': name,
|
|
'account_id': account.id,
|
|
'quantity': operation.product_uom_qty,
|
|
'tax_ids': [(6, 0, operation.tax_id.ids)],
|
|
'product_uom_id': operation.product_uom.id,
|
|
'price_unit': operation.price_unit,
|
|
'product_id': operation.product_id.id,
|
|
'repair_line_ids': [(4, operation.id)],
|
|
}
|
|
|
|
if currency == company.currency_id:
|
|
balance = -(operation.product_uom_qty * operation.price_unit)
|
|
invoice_line_vals.update({
|
|
'debit': balance > 0.0 and balance or 0.0,
|
|
'credit': balance < 0.0 and -balance or 0.0,
|
|
})
|
|
else:
|
|
amount_currency = -(operation.product_uom_qty * operation.price_unit)
|
|
balance = currency._convert(amount_currency, company.currency_id, company, fields.Date.today())
|
|
invoice_line_vals.update({
|
|
'amount_currency': amount_currency,
|
|
'debit': balance > 0.0 and balance or 0.0,
|
|
'credit': balance < 0.0 and -balance or 0.0,
|
|
'currency_id': currency.id,
|
|
})
|
|
invoice_vals['invoice_line_ids'].append((0, 0, invoice_line_vals))
|
|
|
|
# Create invoice lines from fees.
|
|
for fee in repair.fees_lines:
|
|
if group:
|
|
name = repair.name + '-' + fee.name
|
|
else:
|
|
name = fee.name
|
|
|
|
if not fee.product_id:
|
|
raise UserError(_('No product defined on fees.'))
|
|
|
|
account = fee.product_id.product_tmpl_id.get_product_accounts(fiscal_pos=fpos)['income']
|
|
if not account:
|
|
raise UserError(_('No account defined for product "%s".', fee.product_id.name))
|
|
|
|
invoice_line_vals = {
|
|
'name': name,
|
|
'account_id': account.id,
|
|
'quantity': fee.product_uom_qty,
|
|
'tax_ids': [(6, 0, fee.tax_id.ids)],
|
|
'product_uom_id': fee.product_uom.id,
|
|
'price_unit': fee.price_unit,
|
|
'product_id': fee.product_id.id,
|
|
'repair_fee_ids': [(4, fee.id)],
|
|
}
|
|
|
|
if currency == company.currency_id:
|
|
balance = -(fee.product_uom_qty * fee.price_unit)
|
|
invoice_line_vals.update({
|
|
'debit': balance > 0.0 and balance or 0.0,
|
|
'credit': balance < 0.0 and -balance or 0.0,
|
|
})
|
|
else:
|
|
amount_currency = -(fee.product_uom_qty * fee.price_unit)
|
|
balance = currency._convert(amount_currency, company.currency_id, company,
|
|
fields.Date.today())
|
|
invoice_line_vals.update({
|
|
'amount_currency': amount_currency,
|
|
'debit': balance > 0.0 and balance or 0.0,
|
|
'credit': balance < 0.0 and -balance or 0.0,
|
|
'currency_id': currency.id,
|
|
})
|
|
invoice_vals['invoice_line_ids'].append((0, 0, invoice_line_vals))
|
|
|
|
# Create invoices.
|
|
invoices_vals_list_per_company = defaultdict(list)
|
|
for (partner_invoice_id, currency_id, company_id), invoices in grouped_invoices_vals.items():
|
|
for invoice in invoices:
|
|
invoices_vals_list_per_company[company_id].append(invoice)
|
|
|
|
for company_id, invoices_vals_list in invoices_vals_list_per_company.items():
|
|
# VFE TODO remove the default_company_id ctxt key ?
|
|
# Account fallbacks on self.env.company, which is correct with with_company
|
|
self.env['account.move'].with_company(company_id).with_context(default_company_id=company_id, default_move_type='out_invoice').create(invoices_vals_list)
|
|
|
|
repairs.write({'invoiced': True})
|
|
repairs.mapped('operations').filtered(lambda op: op.type == 'add').write({'invoiced': True})
|
|
repairs.mapped('fees_lines').write({'invoiced': True})
|
|
|
|
return dict((repair.id, repair.invoice_id.id) for repair in repairs)
|
|
|
|
def action_created_invoice(self):
|
|
self.ensure_one()
|
|
return {
|
|
'name': _('Invoice created'),
|
|
'type': 'ir.actions.act_window',
|
|
'view_mode': 'form',
|
|
'res_model': 'account.move',
|
|
'view_id': self.env.ref('account.view_move_form').id,
|
|
'target': 'current',
|
|
'res_id': self.invoice_id.id,
|
|
}
|
|
|
|
def action_repair_ready(self):
|
|
self.mapped('operations').write({'state': 'confirmed'})
|
|
return self.write({'state': 'ready'})
|
|
|
|
def action_repair_start(self):
|
|
""" Writes repair order state to 'Under Repair'
|
|
@return: True
|
|
"""
|
|
if self.filtered(lambda repair: repair.state not in ['confirmed', 'ready']):
|
|
raise UserError(_("Repair must be confirmed before starting reparation."))
|
|
self.mapped('operations').write({'state': 'confirmed'})
|
|
return self.write({'state': 'under_repair'})
|
|
|
|
def action_repair_end(self):
|
|
""" Writes repair order state to 'To be invoiced' if invoice method is
|
|
After repair else state is set to 'Ready'.
|
|
@return: True
|
|
"""
|
|
if self.filtered(lambda repair: repair.state != 'under_repair'):
|
|
raise UserError(_("Repair must be under repair in order to end reparation."))
|
|
self._check_product_tracking()
|
|
for repair in self:
|
|
repair.write({'repaired': True})
|
|
vals = {'state': 'done'}
|
|
vals['move_id'] = repair.action_repair_done().get(repair.id)
|
|
if not repair.invoice_id and repair.invoice_method == 'after_repair':
|
|
vals['state'] = '2binvoiced'
|
|
repair.write(vals)
|
|
return True
|
|
|
|
def action_repair_done(self):
|
|
""" Creates stock move for operation and stock move for final product of repair order.
|
|
@return: Move ids of final products
|
|
|
|
"""
|
|
if self.filtered(lambda repair: not repair.repaired):
|
|
raise UserError(_("Repair must be repaired in order to make the product moves."))
|
|
self._check_company()
|
|
self.operations._check_company()
|
|
self.fees_lines._check_company()
|
|
res = {}
|
|
precision = self.env['decimal.precision'].precision_get('Product Unit of Measure')
|
|
Move = self.env['stock.move']
|
|
for repair in self:
|
|
# Try to create move with the appropriate owner
|
|
owner_id = False
|
|
available_qty_owner = self.env['stock.quant']._get_available_quantity(repair.product_id, repair.location_id, repair.lot_id, owner_id=repair.partner_id, strict=True)
|
|
if float_compare(available_qty_owner, repair.product_qty, precision_digits=precision) >= 0:
|
|
owner_id = repair.partner_id.id
|
|
|
|
moves = self.env['stock.move']
|
|
for operation in repair.operations:
|
|
move = Move.create({
|
|
'name': repair.name,
|
|
'product_id': operation.product_id.id,
|
|
'product_uom_qty': operation.product_uom_qty,
|
|
'product_uom': operation.product_uom.id,
|
|
'partner_id': repair.address_id.id,
|
|
'location_id': operation.location_id.id,
|
|
'location_dest_id': operation.location_dest_id.id,
|
|
'repair_id': repair.id,
|
|
'origin': repair.name,
|
|
'company_id': repair.company_id.id,
|
|
})
|
|
|
|
# Best effort to reserve the product in a (sub)-location where it is available
|
|
product_qty = move.product_uom._compute_quantity(
|
|
operation.product_uom_qty, move.product_id.uom_id, rounding_method='HALF-UP')
|
|
available_quantity = self.env['stock.quant']._get_available_quantity(
|
|
move.product_id,
|
|
move.location_id,
|
|
lot_id=operation.lot_id,
|
|
strict=False,
|
|
)
|
|
move._update_reserved_quantity(
|
|
product_qty,
|
|
available_quantity,
|
|
move.location_id,
|
|
lot_id=operation.lot_id,
|
|
strict=False,
|
|
)
|
|
# Then, set the quantity done. If the required quantity was not reserved, negative
|
|
# quant is created in operation.location_id.
|
|
move._set_quantity_done(operation.product_uom_qty)
|
|
|
|
if operation.lot_id:
|
|
move.move_line_ids.lot_id = operation.lot_id
|
|
|
|
moves |= move
|
|
operation.write({'move_id': move.id, 'state': 'done'})
|
|
move = Move.create({
|
|
'name': repair.name,
|
|
'product_id': repair.product_id.id,
|
|
'product_uom': repair.product_uom.id or repair.product_id.uom_id.id,
|
|
'product_uom_qty': repair.product_qty,
|
|
'partner_id': repair.address_id.id,
|
|
'location_id': repair.location_id.id,
|
|
'location_dest_id': repair.location_id.id,
|
|
'move_line_ids': [(0, 0, {'product_id': repair.product_id.id,
|
|
'lot_id': repair.lot_id.id,
|
|
'reserved_uom_qty': 0, # bypass reservation here
|
|
'product_uom_id': repair.product_uom.id or repair.product_id.uom_id.id,
|
|
'qty_done': repair.product_qty,
|
|
'package_id': False,
|
|
'result_package_id': False,
|
|
'owner_id': owner_id,
|
|
'location_id': repair.location_id.id, #TODO: owner stuff
|
|
'company_id': repair.company_id.id,
|
|
'location_dest_id': repair.location_id.id,})],
|
|
'repair_id': repair.id,
|
|
'origin': repair.name,
|
|
'company_id': repair.company_id.id,
|
|
})
|
|
consumed_lines = moves.mapped('move_line_ids')
|
|
produced_lines = move.move_line_ids
|
|
moves |= move
|
|
moves._action_done()
|
|
produced_lines.write({'consume_line_ids': [(6, 0, consumed_lines.ids)]})
|
|
res[repair.id] = move.id
|
|
return res
|
|
|
|
def _check_product_tracking(self):
|
|
invalid_lines = self.operations.filtered(lambda x: x.tracking != 'none' and not x.lot_id)
|
|
if invalid_lines:
|
|
products = invalid_lines.product_id
|
|
raise ValidationError(_(
|
|
"Serial number is required for operation lines with products: %s",
|
|
", ".join(products.mapped('display_name')),
|
|
))
|
|
|
|
|
|
class RepairLine(models.Model):
|
|
_name = 'repair.line'
|
|
_description = 'Repair Line (parts)'
|
|
|
|
name = fields.Text('Description', required=True)
|
|
repair_id = fields.Many2one(
|
|
'repair.order', 'Repair Order Reference', required=True,
|
|
index=True, ondelete='cascade', check_company=True)
|
|
company_id = fields.Many2one(
|
|
related='repair_id.company_id', store=True, index=True)
|
|
currency_id = fields.Many2one(
|
|
related='repair_id.currency_id')
|
|
type = fields.Selection([
|
|
('add', 'Add'),
|
|
('remove', 'Remove')], 'Type', default='add', required=True)
|
|
product_id = fields.Many2one(
|
|
'product.product', 'Product', required=True, check_company=True,
|
|
domain="[('type', 'in', ['product', 'consu']), '|', ('company_id', '=', company_id), ('company_id', '=', False)]")
|
|
invoiced = fields.Boolean('Invoiced', copy=False, readonly=True)
|
|
price_unit = fields.Float('Unit Price', required=True, digits='Product Price')
|
|
price_subtotal = fields.Float('Subtotal', compute='_compute_price_total_and_subtotal', store=True, digits=0)
|
|
price_total = fields.Float('Total', compute='_compute_price_total_and_subtotal', store=True, digits=0)
|
|
tax_id = fields.Many2many(
|
|
'account.tax', 'repair_operation_line_tax', 'repair_operation_line_id', 'tax_id', 'Taxes',
|
|
domain="[('type_tax_use','=','sale'), ('company_id', '=', company_id)]", check_company=True)
|
|
product_uom_qty = fields.Float(
|
|
'Quantity', default=1.0,
|
|
digits='Product Unit of Measure', required=True)
|
|
product_uom = fields.Many2one(
|
|
'uom.uom', 'Product Unit of Measure',
|
|
compute='_compute_product_uom', store=True, readonly=False, precompute=True,
|
|
required=True, domain="[('category_id', '=', product_uom_category_id)]")
|
|
product_uom_category_id = fields.Many2one(related='product_id.uom_id.category_id')
|
|
invoice_line_id = fields.Many2one(
|
|
'account.move.line', 'Invoice Line',
|
|
copy=False, readonly=True, check_company=True)
|
|
location_id = fields.Many2one(
|
|
'stock.location', 'Source Location',
|
|
compute='_compute_location_id', store=True, readonly=False, precompute=True,
|
|
index=True, required=True, check_company=True)
|
|
location_dest_id = fields.Many2one(
|
|
'stock.location', 'Dest. Location',
|
|
compute='_compute_location_id', store=True, readonly=False, precompute=True,
|
|
index=True, required=True, check_company=True)
|
|
move_id = fields.Many2one(
|
|
'stock.move', 'Inventory Move',
|
|
copy=False, readonly=True)
|
|
lot_id = fields.Many2one(
|
|
'stock.lot', 'Lot/Serial',
|
|
domain="[('product_id','=', product_id), ('company_id', '=', company_id)]", check_company=True)
|
|
state = fields.Selection([
|
|
('draft', 'Draft'),
|
|
('confirmed', 'Confirmed'),
|
|
('done', 'Done'),
|
|
('cancel', 'Cancelled')], 'Status', default='draft',
|
|
copy=False, readonly=True, required=True,
|
|
help='The status of a repair line is set automatically to the one of the linked repair order.')
|
|
tracking = fields.Selection(string='Product Tracking', related="product_id.tracking")
|
|
|
|
@api.depends('price_unit', 'repair_id', 'product_uom_qty', 'product_id', 'tax_id', 'repair_id.invoice_method')
|
|
def _compute_price_total_and_subtotal(self):
|
|
for line in self:
|
|
taxes = line.tax_id.compute_all(line.price_unit, line.repair_id.pricelist_id.currency_id, line.product_uom_qty, line.product_id, line.repair_id.partner_id)
|
|
line.price_subtotal = taxes['total_excluded']
|
|
line.price_total = taxes['total_included']
|
|
|
|
@api.depends('product_id')
|
|
def _compute_product_uom(self):
|
|
for line in self:
|
|
line.product_uom = line.product_id.uom_id.id
|
|
|
|
@api.depends('type')
|
|
def _compute_location_id(self):
|
|
for line in self:
|
|
if not line.type:
|
|
line.location_id = False
|
|
line.location_dest_id = False
|
|
elif line.type == 'add':
|
|
args = line.repair_id.company_id and [('company_id', '=', line.repair_id.company_id.id)] or []
|
|
warehouse = line.env['stock.warehouse'].search(args, limit=1)
|
|
line.location_id = warehouse.lot_stock_id
|
|
line.location_dest_id = line.env['stock.location'].search([('usage', '=', 'production'), ('company_id', '=', line.repair_id.company_id.id)], limit=1)
|
|
else:
|
|
line.location_id = line.env['stock.location'].search([('usage', '=', 'production'), ('company_id', '=', line.repair_id.company_id.id)], limit=1).id
|
|
line.location_dest_id = line.env['stock.location'].search([('scrap_location', '=', True), ('company_id', 'in', [line.repair_id.company_id.id, False])], limit=1).id
|
|
|
|
@api.onchange('type')
|
|
def onchange_operation_type(self):
|
|
""" On change of operation type it sets source location, destination location
|
|
and to invoice field.
|
|
@param product: Changed operation type.
|
|
@param guarantee_limit: Guarantee limit of current record.
|
|
@return: Dictionary of values.
|
|
"""
|
|
if not self.type:
|
|
pass
|
|
elif self.type == 'add':
|
|
self.onchange_product_id()
|
|
else:
|
|
self.price_unit = 0.0
|
|
self.tax_id = False
|
|
|
|
@api.onchange('repair_id', 'product_id', 'product_uom_qty')
|
|
def onchange_product_id(self):
|
|
""" On change of product it sets product quantity, tax account, name,
|
|
uom of product, unit price and price subtotal. """
|
|
if not self.product_id or not self.product_uom_qty:
|
|
return
|
|
self = self.with_company(self.company_id)
|
|
partner = self.repair_id.partner_id
|
|
partner_invoice = self.repair_id.partner_invoice_id or partner
|
|
if partner:
|
|
self = self.with_context(lang=partner.lang)
|
|
product = self.product_id
|
|
self.name = product.display_name
|
|
if product.description_sale:
|
|
if partner:
|
|
self.name += '\n' + self.product_id.with_context(lang=partner.lang).description_sale
|
|
else:
|
|
self.name += '\n' + self.product_id.description_sale
|
|
if self.type != 'remove':
|
|
if partner:
|
|
fpos = self.env['account.fiscal.position']._get_fiscal_position(partner_invoice, delivery=self.repair_id.address_id)
|
|
taxes = self.product_id.taxes_id.filtered(lambda x: x.company_id == self.repair_id.company_id)
|
|
self.tax_id = fpos.map_tax(taxes)
|
|
warning = False
|
|
pricelist = self.repair_id.pricelist_id
|
|
if not pricelist:
|
|
warning = {
|
|
'title': _('No pricelist found.'),
|
|
'message':
|
|
_('You have to select a pricelist in the Repair form !\n Please set one before choosing a product.')}
|
|
return {'warning': warning}
|
|
else:
|
|
self._onchange_product_uom()
|
|
|
|
@api.onchange('product_uom')
|
|
def _onchange_product_uom(self):
|
|
pricelist = self.repair_id.pricelist_id
|
|
if pricelist and self.product_id and self.type != 'remove':
|
|
price = pricelist._get_product_price(self.product_id, self.product_uom_qty, uom=self.product_uom)
|
|
if price is False:
|
|
warning = {
|
|
'title': _('No valid pricelist line found.'),
|
|
'message':
|
|
_("Couldn't find a pricelist line matching this product and quantity.\nYou have to change either the product, the quantity or the pricelist.")}
|
|
return {'warning': warning}
|
|
else:
|
|
self.price_unit = price
|
|
|
|
|
|
class RepairFee(models.Model):
|
|
_name = 'repair.fee'
|
|
_description = 'Repair Fees'
|
|
|
|
repair_id = fields.Many2one(
|
|
'repair.order', 'Repair Order Reference',
|
|
index=True, ondelete='cascade', required=True)
|
|
company_id = fields.Many2one(
|
|
related="repair_id.company_id", index=True, store=True)
|
|
currency_id = fields.Many2one(
|
|
related="repair_id.currency_id")
|
|
name = fields.Text('Description', index=True, required=True)
|
|
product_id = fields.Many2one(
|
|
'product.product', 'Product', check_company=True,
|
|
domain="[('type', '=', 'service'), '|', ('company_id', '=', company_id), ('company_id', '=', False)]")
|
|
product_uom_qty = fields.Float('Quantity', digits='Product Unit of Measure', required=True, default=1.0)
|
|
price_unit = fields.Float('Unit Price', required=True, digits='Product Price')
|
|
product_uom = fields.Many2one('uom.uom', 'Product Unit of Measure', required=True, domain="[('category_id', '=', product_uom_category_id)]")
|
|
product_uom_category_id = fields.Many2one(related='product_id.uom_id.category_id')
|
|
price_subtotal = fields.Float('Subtotal', compute='_compute_price_total_and_subtotal', store=True, digits=0)
|
|
price_total = fields.Float('Total', compute='_compute_price_total_and_subtotal', store=True, digits=0)
|
|
tax_id = fields.Many2many(
|
|
'account.tax', 'repair_fee_line_tax', 'repair_fee_line_id', 'tax_id', 'Taxes',
|
|
domain="[('type_tax_use','=','sale'), ('company_id', '=', company_id)]", check_company=True)
|
|
invoice_line_id = fields.Many2one('account.move.line', 'Invoice Line', copy=False, readonly=True, check_company=True)
|
|
invoiced = fields.Boolean('Invoiced', copy=False, readonly=True)
|
|
|
|
@api.depends('price_unit', 'repair_id', 'product_uom_qty', 'product_id', 'tax_id')
|
|
def _compute_price_total_and_subtotal(self):
|
|
for fee in self:
|
|
taxes = fee.tax_id.compute_all(fee.price_unit, fee.repair_id.pricelist_id.currency_id, fee.product_uom_qty, fee.product_id, fee.repair_id.partner_id)
|
|
fee.price_subtotal = taxes['total_excluded']
|
|
fee.price_total = taxes['total_included']
|
|
|
|
@api.onchange('repair_id', 'product_id', 'product_uom_qty')
|
|
def onchange_product_id(self):
|
|
""" On change of product it sets product quantity, tax account, name,
|
|
uom of product, unit price and price subtotal. """
|
|
if not self.product_id:
|
|
return
|
|
|
|
self = self.with_company(self.company_id)
|
|
|
|
partner = self.repair_id.partner_id
|
|
partner_invoice = self.repair_id.partner_invoice_id or partner
|
|
pricelist = self.repair_id.pricelist_id
|
|
|
|
if partner and self.product_id:
|
|
fpos = self.env['account.fiscal.position']._get_fiscal_position(partner_invoice, delivery=self.repair_id.address_id)
|
|
taxes = self.product_id.taxes_id.filtered(lambda x: x.company_id == self.repair_id.company_id)
|
|
self.tax_id = fpos.map_tax(taxes)
|
|
if partner:
|
|
self.name = self.product_id.with_context(lang=partner.lang).display_name
|
|
else:
|
|
self.name = self.product_id.display_name
|
|
self.product_uom = self.product_id.uom_id.id
|
|
if self.product_id.description_sale:
|
|
if partner:
|
|
self.name += '\n' + self.product_id.with_context(lang=partner.lang).description_sale
|
|
else:
|
|
self.name += '\n' + self.product_id.description_sale
|
|
|
|
warning = False
|
|
if not pricelist:
|
|
warning = {
|
|
'title': _('No pricelist found.'),
|
|
'message':
|
|
_('You have to select a pricelist in the Repair form !\n Please set one before choosing a product.')}
|
|
return {'warning': warning}
|
|
else:
|
|
self._onchange_product_uom()
|
|
|
|
@api.onchange('product_uom')
|
|
def _onchange_product_uom(self):
|
|
pricelist = self.repair_id.pricelist_id
|
|
if pricelist and self.product_id:
|
|
price = pricelist._get_product_price(self.product_id, self.product_uom_qty, uom=self.product_uom)
|
|
if price is False:
|
|
warning = {
|
|
'title': _('No valid pricelist line found.'),
|
|
'message':
|
|
_("Couldn't find a pricelist line matching this product and quantity.\nYou have to change either the product, the quantity or the pricelist.")}
|
|
return {'warning': warning}
|
|
else:
|
|
self.price_unit = price
|
|
|
|
|
|
class RepairTags(models.Model):
|
|
""" Tags of Repair's tasks """
|
|
_name = "repair.tags"
|
|
_description = "Repair Tags"
|
|
|
|
def _get_default_color(self):
|
|
return randint(1, 11)
|
|
|
|
name = fields.Char('Tag Name', required=True)
|
|
color = fields.Integer(string='Color Index', default=_get_default_color)
|
|
|
|
_sql_constraints = [
|
|
('name_uniq', 'unique (name)', "Tag name already exists!"),
|
|
]
|