310 lines
13 KiB
Python
310 lines
13 KiB
Python
# The COPYRIGHT file at the top level of this repository contains
|
|
# the full copyright notices and license terms.
|
|
from collections import defaultdict
|
|
from trytond.model import fields, ModelView
|
|
from trytond.pool import Pool, PoolMeta
|
|
from trytond.pyson import Equal, Eval, If, Bool
|
|
from trytond.transaction import Transaction
|
|
|
|
|
|
class Invoice(metaclass=PoolMeta):
|
|
__name__ = 'account.invoice'
|
|
_intercompany_excluded_fields = ['id', 'company', 'party', 'lines',
|
|
'account', 'type', 'state', 'create_date', 'create_uid', 'write_date',
|
|
'write_uid', 'target_company', 'taxes', 'invoice_report_cache',
|
|
'invoice_report_format', 'move', 'number', 'taxes']
|
|
|
|
target_company = fields.Many2One('company.company', 'Target company',
|
|
domain=[
|
|
('party', '=', Eval('party')),
|
|
],
|
|
states={
|
|
'invisible': Eval('type', '') != 'out',
|
|
'readonly': Eval('state') != 'draft',
|
|
},
|
|
depends=['type', 'state', 'party'])
|
|
intercompany_invoices = fields.Function(fields.One2Many('account.invoice',
|
|
None, 'Intercompany Invoice'),
|
|
'get_intercompany_invoices')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(Invoice, cls).__setup__()
|
|
cls._buttons.update({
|
|
'create_intercompany_invoices': {
|
|
'invisible': (~Eval('state').in_(['posted', 'paid'])
|
|
| Equal(Eval('type'), 'in')),
|
|
},
|
|
})
|
|
|
|
def get_intercompany_invoices(self, name):
|
|
if not self.target_company or not self.target_company.intercompany_user:
|
|
return
|
|
|
|
with Transaction().set_user(self.target_company.intercompany_user.id), \
|
|
Transaction().set_context(company=self.target_company.id,
|
|
_check_access=False):
|
|
return [i.id for i in self.search([
|
|
('lines.origin.invoice.id', '=', self.id,
|
|
'account.invoice.line'),
|
|
('company', '=', self.target_company.id),
|
|
('type', '=', self.intercompany_type),
|
|
])]
|
|
|
|
@classmethod
|
|
def post(cls, invoices):
|
|
super(Invoice, cls).post(invoices)
|
|
cls.create_intercompany_invoices(invoices)
|
|
|
|
@classmethod
|
|
@ModelView.button
|
|
def create_intercompany_invoices(cls, invoices):
|
|
intercompany_invoices = defaultdict(list)
|
|
|
|
for invoice in invoices:
|
|
intercompany_invoice = invoice.get_intercompany_invoice()
|
|
if intercompany_invoice:
|
|
company = intercompany_invoice.company
|
|
intercompany_invoices[company].append(
|
|
intercompany_invoice)
|
|
|
|
for company, new_invoices in intercompany_invoices.items():
|
|
# Company must be set on context to avoid domain errors
|
|
with Transaction().set_user(company.intercompany_user.id), \
|
|
Transaction().set_context(company=company.id,
|
|
_check_access=False):
|
|
to_write, to_create, to_post = [], [], []
|
|
# XXX: Use save multi on version 3.6
|
|
for new_invoice in new_invoices:
|
|
if new_invoice.id is None or invoice.id < 0:
|
|
to_create.append(new_invoice._save_values)
|
|
elif new_invoice._save_values:
|
|
to_write.append(new_invoice)
|
|
else:
|
|
to_post.append(new_invoice)
|
|
to_post += cls.create(to_create)
|
|
if to_write:
|
|
cls.write(*sum(
|
|
(([i], i._save_values) for i in to_write),
|
|
()))
|
|
# We must reload invoices
|
|
to_post += cls.browse(to_write)
|
|
super(Invoice, cls).post(to_post)
|
|
|
|
@classmethod
|
|
def draft(cls, invoices):
|
|
to_delete = defaultdict(list)
|
|
for invoice in invoices:
|
|
with Transaction().set_user(0):
|
|
intercompany = cls.browse(invoice.intercompany_invoices)
|
|
for iinvoice in intercompany:
|
|
to_delete[iinvoice.company.id].append(iinvoice)
|
|
|
|
if to_delete:
|
|
for company, delete in to_delete.items():
|
|
if not company.intercompany_user:
|
|
continue
|
|
|
|
with Transaction().set_user(company.intercompany_user.id), \
|
|
Transaction().set_context(company=company.id,
|
|
_check_access=False):
|
|
cls.draft(delete)
|
|
cls.delete(delete)
|
|
super(Invoice, cls).draft(invoices)
|
|
|
|
@classmethod
|
|
def credit(cls, invoices, refund=False, **values):
|
|
pool = Pool()
|
|
MoveLine = pool.get('account.move.line')
|
|
new_invoices = super(Invoice, cls).credit(invoices, refund, **values)
|
|
if refund:
|
|
for invoice, new_invoice in zip(invoices, new_invoices):
|
|
if new_invoice.state == 'paid':
|
|
for source, target in zip(invoice.intercompany_invoices,
|
|
new_invoice.intercompany_invoices):
|
|
if not source.company.intercompany_user:
|
|
continue
|
|
|
|
with Transaction().set_user(0):
|
|
source, = cls.browse([source])
|
|
target, = cls.browse([target])
|
|
company_id = source.company.id
|
|
user_id = source.company.intercompany_user.id
|
|
|
|
with Transaction().set_user(user_id), \
|
|
Transaction().set_context(company=company_id,
|
|
_check_access=False):
|
|
lines = ([l for l in source.lines_to_pay
|
|
if not l.reconciliation] +
|
|
[l for l in target.lines_to_pay
|
|
if not l.reconciliation])
|
|
MoveLine.reconcile(lines)
|
|
return new_invoices
|
|
|
|
def get_intercompany_account(self):
|
|
Party = Pool().get('party.party')
|
|
|
|
with Transaction().set_user(self.target_company.intercompany_user.id), \
|
|
Transaction().set_context(company=self.target_company.id,
|
|
_check_access=False):
|
|
party = Party(self.company.party)
|
|
if self.type == 'out':
|
|
return party.account_payable_used
|
|
else:
|
|
return party.account_receivable_used
|
|
|
|
@property
|
|
def intercompany_type(self):
|
|
return 'in'
|
|
|
|
def get_intercompany_invoice(self):
|
|
Party = Pool().get('party.party')
|
|
|
|
if (self.type != 'out' or not self.target_company
|
|
or self.intercompany_invoices):
|
|
return
|
|
values = {}
|
|
for name, field in self.__class__._fields.items():
|
|
if (name in set(self._intercompany_excluded_fields) or
|
|
isinstance(field, fields.Function)):
|
|
continue
|
|
values[name] = getattr(self, name)
|
|
|
|
if not self.target_company.intercompany_user:
|
|
return
|
|
|
|
with Transaction().set_user(self.target_company.intercompany_user.id), \
|
|
Transaction().set_context(company=self.target_company.id,
|
|
_check_access=False):
|
|
invoice = self.__class__(**values)
|
|
invoice.type = self.intercompany_type
|
|
invoice.company = self.target_company
|
|
# Rebrowse party in order to pick the correct company context
|
|
invoice.party = Party(self.company.party)
|
|
invoice.state = 'draft'
|
|
invoice.reference = self.number
|
|
invoice.on_change_party()
|
|
invoice.account = self.get_intercompany_account()
|
|
invoice.set_journal()
|
|
lines = []
|
|
for line in self.lines:
|
|
lines.append(line.get_intercompany_line())
|
|
invoice.lines = lines
|
|
return invoice
|
|
|
|
def _credit(self, **values):
|
|
credit = super(Invoice, self)._credit(**values)
|
|
if self.target_company:
|
|
credit.target_company = self.target_company.id
|
|
return credit
|
|
|
|
|
|
class InvoiceLine(metaclass=PoolMeta):
|
|
__name__ = 'account.invoice.line'
|
|
_intercompany_excluded_fields = ['id', 'account', 'taxes', 'origin',
|
|
'party', 'invoice_type', 'company', 'create_date', 'create_uid',
|
|
'write_date', 'write_uid', 'intercompany_account']
|
|
|
|
intercompany_invoice = fields.Function(fields.Boolean(
|
|
'Intercompany Invoice'),
|
|
'on_change_with_intercompany_invoice')
|
|
intercompany_account = fields.Many2One('account.account.template',
|
|
'Intercompany Account',
|
|
domain=[
|
|
If(Bool(Eval('_parent_invoice')),
|
|
If(Eval('_parent_invoice', {}).get('type') == 'out',
|
|
('type.expense', '=', True),
|
|
('type.revenue', '=', True)),
|
|
If(Eval('invoice_type') == 'out',
|
|
('type.expense', '=', True),
|
|
('type.revenue', '=', True)))
|
|
],
|
|
states={
|
|
'invisible': If(Bool(Eval('_parent_invoice')),
|
|
~Bool(Eval('_parent_invoice', {}).get('target_company')),
|
|
~Eval('intercompany_invoice', False)),
|
|
'required': If(Bool(Eval('_parent_invoice')),
|
|
Bool(Eval('_parent_invoice', {}).get('target_company')),
|
|
Eval('intercompany_invoice', False)),
|
|
},
|
|
depends=['invoice'])
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(InvoiceLine, cls).__setup__()
|
|
if 'intercompany_invoice' not in cls.product.depends:
|
|
required = Bool(Eval('intercompany_invoice'))
|
|
old_required = cls.product.states.get('required')
|
|
if old_required:
|
|
required |= old_required
|
|
cls.product.states['required'] = required
|
|
cls.product.depends.add('intercompany_invoice')
|
|
|
|
@fields.depends('_parent_invoice.target_company', '_parent_invoice.type',
|
|
'invoice_type', 'invoice')
|
|
def on_change_product(self):
|
|
super(InvoiceLine, self).on_change_product()
|
|
type_ = self.invoice.type if self.invoice else self.invoice_type
|
|
if self.product and self.invoice and self.invoice.target_company:
|
|
account_name = 'account_%s_used' % ('revenue' if type_[:2] == 'in'
|
|
else 'expense')
|
|
account = getattr(self.product, account_name)
|
|
if account and account.template:
|
|
self.intercompany_account = account.template
|
|
|
|
@fields.depends('invoice', '_parent_invoice.target_company')
|
|
def on_change_with_intercompany_invoice(self, name=None):
|
|
return self.invoice and bool(self.invoice.target_company)
|
|
|
|
def get_intercompany_account(self):
|
|
target_company = self.invoice.target_company
|
|
# TODO: Check for account without template
|
|
return self.intercompany_account.get_syncronized_company_value(
|
|
target_company)
|
|
|
|
def get_intercompany_taxes(self):
|
|
pool = Pool()
|
|
Product = pool.get('product.product')
|
|
taxes = []
|
|
if not self.product:
|
|
return taxes
|
|
target_company = self.invoice.target_company
|
|
type = self.invoice.type if self.invoice else self.invoice_type
|
|
tax_name = '%s_taxes_used' % ('customer' if type[:2] == 'in'
|
|
else 'supplier')
|
|
|
|
with Transaction().set_user(target_company.intercompany_user.id), \
|
|
Transaction().set_context(company=target_company.id,
|
|
_check_access=False):
|
|
product = Product(self.product.id)
|
|
taxes = getattr(product, tax_name, [])
|
|
return taxes
|
|
|
|
def get_intercompany_line(self):
|
|
with Transaction().set_user(0):
|
|
line = self.__class__()
|
|
|
|
for name, field in self.__class__._fields.items():
|
|
if (name in set(self._intercompany_excluded_fields) or
|
|
isinstance(field, fields.Function)):
|
|
continue
|
|
setattr(line, name, getattr(self, name))
|
|
target_company = self.invoice.target_company
|
|
|
|
with Transaction().set_user(target_company.intercompany_user.id), \
|
|
Transaction().set_context(company=target_company.id,
|
|
_check_access=False):
|
|
line.invoice_type = self.invoice.intercompany_type
|
|
line.company = target_company
|
|
if self.party:
|
|
line.party = target_company.party
|
|
line.account = self.get_intercompany_account()
|
|
line.taxes = self.get_intercompany_taxes()
|
|
line.origin = self
|
|
return line
|
|
|
|
def _credit(self):
|
|
credit = super(InvoiceLine, self)._credit()
|
|
credit.intercompany_account = self.intercompany_account
|
|
return credit
|