mirror of
https://github.com/OCA/contract.git
synced 2025-02-13 17:57:24 +02:00
a12f0497f9
Previous related field was not accurated nor editable. Now the field is got properly from a computed field. Reviewing this, as the currency was taken (and it continues being taken) from the partner pricelist if no pricelist is explicitly set, automatic price should use the same logic for using partner pricelist.
563 lines
20 KiB
Python
563 lines
20 KiB
Python
# Copyright 2004-2010 OpenERP SA
|
|
# Copyright 2014 Angel Moya <angel.moya@domatix.com>
|
|
# Copyright 2015 Pedro M. Baeza <pedro.baeza@tecnativa.com>
|
|
# Copyright 2016-2018 Carlos Dauden <carlos.dauden@tecnativa.com>
|
|
# Copyright 2016-2017 LasLabs Inc.
|
|
# Copyright 2018 ACSONE SA/NV
|
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
|
|
|
|
from odoo import api, fields, models
|
|
from odoo.exceptions import ValidationError, UserError
|
|
from odoo.tools.translate import _
|
|
|
|
|
|
class ContractContract(models.Model):
|
|
_name = 'contract.contract'
|
|
_description = "Contract"
|
|
_order = 'code, name asc'
|
|
_inherit = [
|
|
'mail.thread',
|
|
'mail.activity.mixin',
|
|
'contract.abstract.contract',
|
|
]
|
|
|
|
active = fields.Boolean(
|
|
default=True,
|
|
)
|
|
code = fields.Char(
|
|
string="Reference",
|
|
)
|
|
group_id = fields.Many2one(
|
|
string="Group",
|
|
comodel_name='account.analytic.account',
|
|
ondelete='restrict',
|
|
)
|
|
currency_id = fields.Many2one(
|
|
compute="_compute_currency_id",
|
|
comodel_name="res.currency",
|
|
string="Currency",
|
|
readonly=True,
|
|
)
|
|
contract_template_id = fields.Many2one(
|
|
string='Contract Template', comodel_name='contract.template'
|
|
)
|
|
contract_line_ids = fields.One2many(
|
|
string='Contract lines',
|
|
comodel_name='contract.line',
|
|
inverse_name='contract_id',
|
|
copy=True,
|
|
)
|
|
|
|
user_id = fields.Many2one(
|
|
comodel_name='res.users',
|
|
string='Responsible',
|
|
index=True,
|
|
default=lambda self: self.env.user,
|
|
)
|
|
create_invoice_visibility = fields.Boolean(
|
|
compute='_compute_create_invoice_visibility'
|
|
)
|
|
recurring_next_date = fields.Date(
|
|
compute='_compute_recurring_next_date',
|
|
string='Date of Next Invoice',
|
|
store=True,
|
|
)
|
|
date_end = fields.Date(
|
|
compute='_compute_date_end', string='Date End', store=True
|
|
)
|
|
payment_term_id = fields.Many2one(
|
|
comodel_name='account.payment.term', string='Payment Terms', index=True
|
|
)
|
|
invoice_count = fields.Integer(compute="_compute_invoice_count")
|
|
fiscal_position_id = fields.Many2one(
|
|
comodel_name='account.fiscal.position',
|
|
string='Fiscal Position',
|
|
ondelete='restrict',
|
|
)
|
|
invoice_partner_id = fields.Many2one(
|
|
string="Invoicing contact",
|
|
comodel_name='res.partner',
|
|
ondelete='restrict',
|
|
)
|
|
partner_id = fields.Many2one(
|
|
comodel_name='res.partner',
|
|
inverse='_inverse_partner_id',
|
|
required=True
|
|
)
|
|
|
|
commercial_partner_id = fields.Many2one(
|
|
'res.partner',
|
|
related='partner_id.commercial_partner_id',
|
|
store=True,
|
|
string='Commercial Entity',
|
|
index=True
|
|
)
|
|
tag_ids = fields.Many2many(comodel_name="contract.tag", string="Tags")
|
|
note = fields.Text(string="Notes")
|
|
is_terminated = fields.Boolean(
|
|
string="Terminated", readonly=True, copy=False
|
|
)
|
|
terminate_reason_id = fields.Many2one(
|
|
comodel_name="contract.terminate.reason",
|
|
string="Termination Reason",
|
|
ondelete="restrict",
|
|
readonly=True,
|
|
copy=False,
|
|
track_visibility="onchange",
|
|
)
|
|
terminate_comment = fields.Text(
|
|
string="Termination Comment",
|
|
readonly=True,
|
|
copy=False,
|
|
track_visibility="onchange",
|
|
)
|
|
terminate_date = fields.Date(
|
|
string="Termination Date",
|
|
readonly=True,
|
|
copy=False,
|
|
track_visibility="onchange",
|
|
)
|
|
|
|
@api.multi
|
|
def _inverse_partner_id(self):
|
|
for rec in self:
|
|
if not rec.invoice_partner_id:
|
|
rec.invoice_partner_id = rec.partner_id.address_get(
|
|
['invoice']
|
|
)['invoice']
|
|
|
|
@api.multi
|
|
def _get_related_invoices(self):
|
|
self.ensure_one()
|
|
|
|
invoices = (
|
|
self.env['account.invoice.line']
|
|
.search(
|
|
[
|
|
(
|
|
'contract_line_id',
|
|
'in',
|
|
self.contract_line_ids.ids,
|
|
)
|
|
]
|
|
)
|
|
.mapped('invoice_id')
|
|
)
|
|
invoices |= self.env['account.invoice'].search(
|
|
[('old_contract_id', '=', self.id)]
|
|
)
|
|
return invoices
|
|
|
|
@api.depends("pricelist_id", "partner_id", "journal_id", "company_id")
|
|
def _compute_currency_id(self):
|
|
for rec in self:
|
|
currency = self.env['res.currency']
|
|
if any(rec.contract_line_ids.mapped('automatic_price')):
|
|
# Use pricelist currency
|
|
currency = (
|
|
rec.pricelist_id.currency_id or
|
|
rec.partner_id.with_context(
|
|
force_company=rec.company_id.id,
|
|
).property_product_pricelist.currency_id
|
|
)
|
|
rec.currency_id = (
|
|
currency.id or
|
|
rec.journal_id.currency_id.id or
|
|
rec.company_id.currency_id.id
|
|
)
|
|
|
|
@api.multi
|
|
def _compute_invoice_count(self):
|
|
for rec in self:
|
|
rec.invoice_count = len(rec._get_related_invoices())
|
|
|
|
@api.multi
|
|
def action_show_invoices(self):
|
|
self.ensure_one()
|
|
tree_view_ref = (
|
|
'account.invoice_supplier_tree'
|
|
if self.contract_type == 'purchase'
|
|
else 'account.invoice_tree_with_onboarding'
|
|
)
|
|
form_view_ref = (
|
|
'account.invoice_supplier_form'
|
|
if self.contract_type == 'purchase'
|
|
else 'account.invoice_form'
|
|
)
|
|
tree_view = self.env.ref(tree_view_ref, raise_if_not_found=False)
|
|
form_view = self.env.ref(form_view_ref, raise_if_not_found=False)
|
|
action = {
|
|
'type': 'ir.actions.act_window',
|
|
'name': 'Invoices',
|
|
'res_model': 'account.invoice',
|
|
'view_type': 'form',
|
|
'view_mode': 'tree,kanban,form,calendar,pivot,graph,activity',
|
|
'domain': [('id', 'in', self._get_related_invoices().ids)],
|
|
}
|
|
if tree_view and form_view:
|
|
action['views'] = [(tree_view.id, 'tree'), (form_view.id, 'form')]
|
|
return action
|
|
|
|
@api.depends('contract_line_ids.date_end')
|
|
def _compute_date_end(self):
|
|
for contract in self:
|
|
contract.date_end = False
|
|
date_end = contract.contract_line_ids.mapped('date_end')
|
|
if date_end and all(date_end):
|
|
contract.date_end = max(date_end)
|
|
|
|
@api.depends(
|
|
'contract_line_ids.recurring_next_date',
|
|
'contract_line_ids.is_canceled',
|
|
)
|
|
def _compute_recurring_next_date(self):
|
|
for contract in self:
|
|
recurring_next_date = contract.contract_line_ids.filtered(
|
|
lambda l: (l.recurring_next_date and not l.is_canceled
|
|
and (not l.display_type or l.is_recurring_note))
|
|
).mapped('recurring_next_date')
|
|
if recurring_next_date:
|
|
contract.recurring_next_date = min(recurring_next_date)
|
|
|
|
@api.depends('contract_line_ids.create_invoice_visibility')
|
|
def _compute_create_invoice_visibility(self):
|
|
for contract in self:
|
|
contract.create_invoice_visibility = any(
|
|
contract.contract_line_ids.mapped(
|
|
'create_invoice_visibility'
|
|
)
|
|
)
|
|
|
|
@api.onchange('contract_template_id')
|
|
def _onchange_contract_template_id(self):
|
|
"""Update the contract fields with that of the template.
|
|
|
|
Take special consideration with the `contract_line_ids`,
|
|
which must be created using the data from the contract lines. Cascade
|
|
deletion ensures that any errant lines that are created are also
|
|
deleted.
|
|
"""
|
|
contract_template_id = self.contract_template_id
|
|
if not contract_template_id:
|
|
return
|
|
for field_name, field in contract_template_id._fields.items():
|
|
if field.name == 'contract_line_ids':
|
|
lines = self._convert_contract_lines(contract_template_id)
|
|
self.contract_line_ids += lines
|
|
elif not any(
|
|
(
|
|
field.compute,
|
|
field.related,
|
|
field.automatic,
|
|
field.readonly,
|
|
field.company_dependent,
|
|
field.name in self.NO_SYNC,
|
|
)
|
|
):
|
|
if self.contract_template_id[field_name]:
|
|
self[field_name] = self.contract_template_id[field_name]
|
|
|
|
@api.onchange('partner_id')
|
|
def _onchange_partner_id(self):
|
|
self.pricelist_id = self.partner_id.property_product_pricelist.id
|
|
self.fiscal_position_id = self.partner_id.property_account_position_id
|
|
if self.contract_type == 'purchase':
|
|
self.payment_term_id = \
|
|
self.partner_id.property_supplier_payment_term_id
|
|
else:
|
|
self.payment_term_id = \
|
|
self.partner_id.property_payment_term_id
|
|
self.invoice_partner_id = self.partner_id.address_get(['invoice'])[
|
|
'invoice'
|
|
]
|
|
return {
|
|
'domain': {
|
|
'invoice_partner_id': [
|
|
'|',
|
|
('id', 'parent_of', self.partner_id.id),
|
|
('id', 'child_of', self.partner_id.id),
|
|
]
|
|
}
|
|
}
|
|
|
|
@api.multi
|
|
def _convert_contract_lines(self, contract):
|
|
self.ensure_one()
|
|
new_lines = self.env['contract.line']
|
|
contract_line_model = self.env['contract.line']
|
|
for contract_line in contract.contract_line_ids:
|
|
vals = contract_line._convert_to_write(contract_line.read()[0])
|
|
# Remove template link field
|
|
vals.pop('contract_template_id', False)
|
|
vals['date_start'] = fields.Date.context_today(contract_line)
|
|
vals['recurring_next_date'] = fields.Date.context_today(
|
|
contract_line
|
|
)
|
|
new_lines += contract_line_model.new(vals)
|
|
new_lines._onchange_date_start()
|
|
new_lines._onchange_is_auto_renew()
|
|
return new_lines
|
|
|
|
@api.multi
|
|
def _prepare_invoice(self, date_invoice, journal=None):
|
|
self.ensure_one()
|
|
if not journal:
|
|
journal = (
|
|
self.journal_id
|
|
if self.journal_id.type == self.contract_type
|
|
else self.env['account.journal'].search(
|
|
[
|
|
('type', '=', self.contract_type),
|
|
('company_id', '=', self.company_id.id),
|
|
],
|
|
limit=1,
|
|
)
|
|
)
|
|
if not journal:
|
|
raise ValidationError(
|
|
_("Please define a %s journal for the company '%s'.")
|
|
% (self.contract_type, self.company_id.name or '')
|
|
)
|
|
invoice_type = 'out_invoice'
|
|
if self.contract_type == 'purchase':
|
|
invoice_type = 'in_invoice'
|
|
vinvoice = self.env['account.invoice'].with_context(
|
|
force_company=self.company_id.id,
|
|
).new({
|
|
'company_id': self.company_id.id,
|
|
'partner_id': self.invoice_partner_id.id,
|
|
'type': invoice_type,
|
|
})
|
|
vinvoice._onchange_partner_id()
|
|
invoice_vals = vinvoice._convert_to_write(vinvoice._cache)
|
|
invoice_vals.update({
|
|
'name': self.code,
|
|
'currency_id': self.currency_id.id,
|
|
'date_invoice': date_invoice,
|
|
'journal_id': journal.id,
|
|
'origin': self.name,
|
|
'user_id': self.user_id.id,
|
|
})
|
|
if self.payment_term_id:
|
|
invoice_vals['payment_term_id'] = self.payment_term_id.id
|
|
if self.fiscal_position_id:
|
|
invoice_vals['fiscal_position_id'] = self.fiscal_position_id.id
|
|
return invoice_vals
|
|
|
|
@api.multi
|
|
def action_contract_send(self):
|
|
self.ensure_one()
|
|
template = self.env.ref('contract.email_contract_template', False)
|
|
compose_form = self.env.ref('mail.email_compose_message_wizard_form')
|
|
ctx = dict(
|
|
default_model='contract.contract',
|
|
default_res_id=self.id,
|
|
default_use_template=bool(template),
|
|
default_template_id=template and template.id or False,
|
|
default_composition_mode='comment',
|
|
)
|
|
return {
|
|
'name': _('Compose Email'),
|
|
'type': 'ir.actions.act_window',
|
|
'view_type': 'form',
|
|
'view_mode': 'form',
|
|
'res_model': 'mail.compose.message',
|
|
'views': [(compose_form.id, 'form')],
|
|
'view_id': compose_form.id,
|
|
'target': 'new',
|
|
'context': ctx,
|
|
}
|
|
|
|
@api.model
|
|
def _finalize_invoice_values(self, invoice_values):
|
|
"""Provided for keeping compatibility in this version."""
|
|
# TODO: Must be removed in >=13.0
|
|
return invoice_values
|
|
|
|
@api.model
|
|
def _finalize_invoice_creation(self, invoices):
|
|
"""This method is called right after the creation of the invoices.
|
|
|
|
Override it when you need to do something after the records are created
|
|
in the DB. If you need to modify any value, better to do it on the
|
|
_prepare_* methods on contract or contract line.
|
|
"""
|
|
invoices.compute_taxes()
|
|
|
|
@api.model
|
|
def _finalize_and_create_invoices(self, invoices_values):
|
|
"""This method:
|
|
|
|
- creates the invoices
|
|
- finalizes the created invoices (tax computation...)
|
|
|
|
:param invoices_values: list of dictionaries (invoices values)
|
|
:return: created invoices (account.invoice)
|
|
"""
|
|
final_invoices_values = []
|
|
# TODO: This call must be removed in >=13.0
|
|
for invoice_values in invoices_values:
|
|
final_invoices_values.append(
|
|
self._finalize_invoice_values(invoice_values)
|
|
)
|
|
invoices = self.env['account.invoice'].create(final_invoices_values)
|
|
self._finalize_invoice_creation(invoices)
|
|
return invoices
|
|
|
|
@api.model
|
|
def _get_contracts_to_invoice_domain(self, date_ref=None):
|
|
"""
|
|
This method builds the domain to use to find all
|
|
contracts (contract.contract) to invoice.
|
|
:param date_ref: optional reference date to use instead of today
|
|
:return: list (domain) usable on contract.contract
|
|
"""
|
|
domain = []
|
|
if not date_ref:
|
|
date_ref = fields.Date.context_today(self)
|
|
domain.extend([('recurring_next_date', '<=', date_ref)])
|
|
return domain
|
|
|
|
@api.multi
|
|
def _get_lines_to_invoice(self, date_ref):
|
|
"""
|
|
This method fetches and returns the lines to invoice on the contract
|
|
(self), based on the given date.
|
|
:param date_ref: date used as reference date to find lines to invoice
|
|
:return: contract lines (contract.line recordset)
|
|
"""
|
|
self.ensure_one()
|
|
|
|
def can_be_invoiced(l):
|
|
return (not l.is_canceled and l.recurring_next_date
|
|
and l.recurring_next_date <= date_ref)
|
|
|
|
lines2invoice = previous = self.env['contract.line']
|
|
current_section = current_note = False
|
|
for line in self.contract_line_ids:
|
|
if line.display_type == 'line_section':
|
|
current_section = line
|
|
elif (line.display_type == 'line_note' and
|
|
not line.is_recurring_note):
|
|
if line.note_invoicing_mode == "with_previous_line":
|
|
if previous in lines2invoice:
|
|
lines2invoice |= line
|
|
current_note = False
|
|
elif line.note_invoicing_mode == "with_next_line":
|
|
current_note = line
|
|
elif line.is_recurring_note or not line.display_type:
|
|
if can_be_invoiced(line):
|
|
if current_section:
|
|
lines2invoice |= current_section
|
|
current_section = False
|
|
if current_note:
|
|
lines2invoice |= current_note
|
|
lines2invoice |= line
|
|
current_note = False
|
|
previous = line
|
|
return lines2invoice.sorted()
|
|
|
|
@api.multi
|
|
def _prepare_recurring_invoices_values(self, date_ref=False):
|
|
"""
|
|
This method builds the list of invoices values to create, based on
|
|
the lines to invoice of the contracts in self.
|
|
!!! The date of next invoice (recurring_next_date) is updated here !!!
|
|
:return: list of dictionaries (invoices values)
|
|
"""
|
|
invoices_values = []
|
|
for contract in self:
|
|
if not date_ref:
|
|
date_ref = contract.recurring_next_date
|
|
if not date_ref:
|
|
# this use case is possible when recurring_create_invoice is
|
|
# called for a finished contract
|
|
continue
|
|
contract_lines = contract._get_lines_to_invoice(date_ref)
|
|
if not contract_lines:
|
|
continue
|
|
invoice_values = contract._prepare_invoice(date_ref)
|
|
for line in contract_lines:
|
|
invoice_values.setdefault('invoice_line_ids', [])
|
|
invoice_line_values = line._prepare_invoice_line(
|
|
invoice_values=invoice_values,
|
|
)
|
|
if invoice_line_values:
|
|
invoice_values['invoice_line_ids'].append(
|
|
(0, 0, invoice_line_values)
|
|
)
|
|
invoices_values.append(invoice_values)
|
|
contract_lines._update_recurring_next_date()
|
|
return invoices_values
|
|
|
|
@api.multi
|
|
def recurring_create_invoice(self):
|
|
"""
|
|
This method triggers the creation of the next invoices of the contracts
|
|
even if their next invoicing date is in the future.
|
|
"""
|
|
invoice = self._recurring_create_invoice()
|
|
if invoice:
|
|
self.message_post(
|
|
body=_(
|
|
'Contract manually invoiced: '
|
|
'<a href="#" data-oe-model="%s" data-oe-id="%s">Invoice'
|
|
'</a>'
|
|
)
|
|
% (invoice._name, invoice.id)
|
|
)
|
|
return invoice
|
|
|
|
@api.multi
|
|
def _recurring_create_invoice(self, date_ref=False):
|
|
invoices_values = self._prepare_recurring_invoices_values(date_ref)
|
|
return self._finalize_and_create_invoices(invoices_values)
|
|
|
|
@api.model
|
|
def cron_recurring_create_invoice(self, date_ref=None):
|
|
if not date_ref:
|
|
date_ref = fields.Date.context_today(self)
|
|
domain = self._get_contracts_to_invoice_domain(date_ref)
|
|
contracts_to_invoice = self.search(domain)
|
|
return contracts_to_invoice._recurring_create_invoice(date_ref)
|
|
|
|
@api.multi
|
|
def action_terminate_contract(self):
|
|
self.ensure_one()
|
|
context = {"default_contract_id": self.id}
|
|
return {
|
|
'type': 'ir.actions.act_window',
|
|
'name': _('Terminate Contract'),
|
|
'res_model': 'contract.contract.terminate',
|
|
'view_type': 'form',
|
|
'view_mode': 'form',
|
|
'target': 'new',
|
|
'context': context,
|
|
}
|
|
|
|
@api.multi
|
|
def _terminate_contract(
|
|
self, terminate_reason_id, terminate_comment, terminate_date
|
|
):
|
|
self.ensure_one()
|
|
if not self.env.user.has_group("contract.can_terminate_contract"):
|
|
raise UserError(_('You are not allowed to terminate contracts.'))
|
|
self.contract_line_ids.filtered('is_stop_allowed').stop(terminate_date)
|
|
self.write({
|
|
'is_terminated': True,
|
|
'terminate_reason_id': terminate_reason_id.id,
|
|
'terminate_comment': terminate_comment,
|
|
'terminate_date': terminate_date,
|
|
})
|
|
return True
|
|
|
|
@api.multi
|
|
def action_cancel_contract_termination(self):
|
|
self.ensure_one()
|
|
self.write({
|
|
'is_terminated': False,
|
|
'terminate_reason_id': False,
|
|
'terminate_comment': False,
|
|
'terminate_date': False,
|
|
})
|