Christophe Simonis
886eca0131
This attribute is misleading as it is insufficient to correctly upgrade the database. It only renames the column in the database, but other operations are needed, like updating the corresponding `ir.model.fields` record (and its xmlid). The default values and the translations are also lost during the upgrade. Moreover, this feature was misused. It was: - left on fields during multiple versions. - used on reports (SQL views). This would be ok if the feature was complete, but, as is, it was useless. - kept unchanged after a second renaming of the field (which can happen versions later the first rename). - used, even when the meaning of the field changed. i.e. the field `archived` has been renamed to the classic `active`, but the value in the database should be switched.
474 lines
23 KiB
Python
474 lines
23 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from ast import literal_eval
|
|
from operator import itemgetter
|
|
import time
|
|
|
|
from odoo import api, fields, models, _
|
|
from odoo.tools import DEFAULT_SERVER_DATETIME_FORMAT
|
|
from odoo.exceptions import ValidationError
|
|
from odoo.addons.base.models.res_partner import WARNING_MESSAGE, WARNING_HELP
|
|
|
|
class AccountFiscalPosition(models.Model):
|
|
_name = 'account.fiscal.position'
|
|
_description = 'Fiscal Position'
|
|
_order = 'sequence'
|
|
|
|
sequence = fields.Integer()
|
|
name = fields.Char(string='Fiscal Position', required=True)
|
|
active = fields.Boolean(default=True,
|
|
help="By unchecking the active field, you may hide a fiscal position without deleting it.")
|
|
company_id = fields.Many2one('res.company', string='Company')
|
|
account_ids = fields.One2many('account.fiscal.position.account', 'position_id', string='Account Mapping', copy=True)
|
|
tax_ids = fields.One2many('account.fiscal.position.tax', 'position_id', string='Tax Mapping', copy=True)
|
|
note = fields.Text('Notes', translate=True, help="Legal mentions that have to be printed on the invoices.")
|
|
auto_apply = fields.Boolean(string='Detect Automatically', help="Apply automatically this fiscal position.")
|
|
vat_required = fields.Boolean(string='VAT required', help="Apply only if partner has a VAT number.")
|
|
country_id = fields.Many2one('res.country', string='Country',
|
|
help="Apply only if delivery or invoicing country match.")
|
|
country_group_id = fields.Many2one('res.country.group', string='Country Group',
|
|
help="Apply only if delivery or invoicing country match the group.")
|
|
state_ids = fields.Many2many('res.country.state', string='Federal States')
|
|
zip_from = fields.Char(string='Zip Range From')
|
|
zip_to = fields.Char(string='Zip Range To')
|
|
# To be used in hiding the 'Federal States' field('attrs' in view side) when selected 'Country' has 0 states.
|
|
states_count = fields.Integer(compute='_compute_states_count')
|
|
|
|
def _compute_states_count(self):
|
|
for position in self:
|
|
position.states_count = len(position.country_id.state_ids)
|
|
|
|
@api.constrains('zip_from', 'zip_to')
|
|
def _check_zip(self):
|
|
for position in self:
|
|
if self.zip_from and self.zip_to and position.zip_from > position.zip_to:
|
|
raise ValidationError(_('Invalid "Zip Range", please configure it properly.'))
|
|
|
|
@api.model # noqa
|
|
def map_tax(self, taxes, product=None, partner=None):
|
|
result = self.env['account.tax'].browse()
|
|
for tax in taxes:
|
|
tax_count = 0
|
|
for t in self.tax_ids:
|
|
if t.tax_src_id == tax:
|
|
tax_count += 1
|
|
if t.tax_dest_id:
|
|
result |= t.tax_dest_id
|
|
if not tax_count:
|
|
result |= tax
|
|
return result
|
|
|
|
@api.model
|
|
def map_account(self, account):
|
|
for pos in self.account_ids:
|
|
if pos.account_src_id == account:
|
|
return pos.account_dest_id
|
|
return account
|
|
|
|
@api.model
|
|
def map_accounts(self, accounts):
|
|
""" Receive a dictionary having accounts in values and try to replace those accounts accordingly to the fiscal position.
|
|
"""
|
|
ref_dict = {}
|
|
for line in self.account_ids:
|
|
ref_dict[line.account_src_id] = line.account_dest_id
|
|
for key, acc in accounts.items():
|
|
if acc in ref_dict:
|
|
accounts[key] = ref_dict[acc]
|
|
return accounts
|
|
|
|
@api.onchange('country_id')
|
|
def _onchange_country_id(self):
|
|
if self.country_id:
|
|
self.zip_from = self.zip_to = self.country_group_id = False
|
|
self.state_ids = [(5,)]
|
|
self.states_count = len(self.country_id.state_ids)
|
|
|
|
@api.onchange('country_group_id')
|
|
def _onchange_country_group_id(self):
|
|
if self.country_group_id:
|
|
self.zip_from = self.zip_to = self.country_id = False
|
|
self.state_ids = [(5,)]
|
|
|
|
@api.model
|
|
def _convert_zip_values(self, zip_from='', zip_to=''):
|
|
max_length = max(len(zip_from), len(zip_to))
|
|
if zip_from.isdigit():
|
|
zip_from = zip_from.rjust(max_length, '0')
|
|
if zip_to.isdigit():
|
|
zip_to = zip_to.rjust(max_length, '0')
|
|
return zip_from, zip_to
|
|
|
|
@api.model
|
|
def create(self, vals):
|
|
zip_from = vals.get('zip_from')
|
|
zip_to = vals.get('zip_to')
|
|
if zip_from and zip_to:
|
|
vals['zip_from'], vals['zip_to'] = self._convert_zip_values(zip_from, zip_to)
|
|
return super(AccountFiscalPosition, self).create(vals)
|
|
|
|
def write(self, vals):
|
|
zip_from = vals.get('zip_from')
|
|
zip_to = vals.get('zip_to')
|
|
if zip_from or zip_to:
|
|
for rec in self:
|
|
vals['zip_from'], vals['zip_to'] = self._convert_zip_values(zip_from or rec.zip_from, zip_to or rec.zip_to)
|
|
return super(AccountFiscalPosition, self).write(vals)
|
|
|
|
@api.model
|
|
def _get_fpos_by_region(self, country_id=False, state_id=False, zipcode=False, vat_required=False):
|
|
if not country_id:
|
|
return False
|
|
base_domain = [('auto_apply', '=', True), ('vat_required', '=', vat_required)]
|
|
if self.env.context.get('force_company'):
|
|
base_domain.append(('company_id', '=', self.env.context.get('force_company')))
|
|
null_state_dom = state_domain = [('state_ids', '=', False)]
|
|
null_zip_dom = zip_domain = [('zip_from', '=', False), ('zip_to', '=', False)]
|
|
null_country_dom = [('country_id', '=', False), ('country_group_id', '=', False)]
|
|
|
|
if zipcode:
|
|
zip_domain = [('zip_from', '<=', zipcode), ('zip_to', '>=', zipcode)]
|
|
|
|
if state_id:
|
|
state_domain = [('state_ids', '=', state_id)]
|
|
|
|
domain_country = base_domain + [('country_id', '=', country_id)]
|
|
domain_group = base_domain + [('country_group_id.country_ids', '=', country_id)]
|
|
|
|
# Build domain to search records with exact matching criteria
|
|
fpos = self.search(domain_country + state_domain + zip_domain, limit=1)
|
|
# return records that fit the most the criteria, and fallback on less specific fiscal positions if any can be found
|
|
if not fpos and state_id:
|
|
fpos = self.search(domain_country + null_state_dom + zip_domain, limit=1)
|
|
if not fpos and zipcode:
|
|
fpos = self.search(domain_country + state_domain + null_zip_dom, limit=1)
|
|
if not fpos and state_id and zipcode:
|
|
fpos = self.search(domain_country + null_state_dom + null_zip_dom, limit=1)
|
|
|
|
# fallback: country group with no state/zip range
|
|
if not fpos:
|
|
fpos = self.search(domain_group + null_state_dom + null_zip_dom, limit=1)
|
|
|
|
if not fpos:
|
|
# Fallback on catchall (no country, no group)
|
|
fpos = self.search(base_domain + null_country_dom, limit=1)
|
|
return fpos or False
|
|
|
|
@api.model
|
|
def get_fiscal_position(self, partner_id, delivery_id=None):
|
|
if not partner_id:
|
|
return False
|
|
# This can be easily overridden to apply more complex fiscal rules
|
|
PartnerObj = self.env['res.partner']
|
|
partner = PartnerObj.browse(partner_id)
|
|
|
|
# if no delivery use invoicing
|
|
if delivery_id:
|
|
delivery = PartnerObj.browse(delivery_id)
|
|
else:
|
|
delivery = partner
|
|
|
|
# partner manually set fiscal position always win
|
|
if delivery.property_account_position_id or partner.property_account_position_id:
|
|
return delivery.property_account_position_id.id or partner.property_account_position_id.id
|
|
|
|
# First search only matching VAT positions
|
|
vat_required = bool(partner.vat)
|
|
fp = self._get_fpos_by_region(delivery.country_id.id, delivery.state_id.id, delivery.zip, vat_required)
|
|
|
|
# Then if VAT required found no match, try positions that do not require it
|
|
if not fp and vat_required:
|
|
fp = self._get_fpos_by_region(delivery.country_id.id, delivery.state_id.id, delivery.zip, False)
|
|
|
|
return fp.id if fp else False
|
|
|
|
|
|
class AccountFiscalPositionTax(models.Model):
|
|
_name = 'account.fiscal.position.tax'
|
|
_description = 'Tax Mapping of Fiscal Position'
|
|
_rec_name = 'position_id'
|
|
|
|
position_id = fields.Many2one('account.fiscal.position', string='Fiscal Position',
|
|
required=True, ondelete='cascade')
|
|
tax_src_id = fields.Many2one('account.tax', string='Tax on Product', required=True)
|
|
tax_dest_id = fields.Many2one('account.tax', string='Tax to Apply')
|
|
|
|
_sql_constraints = [
|
|
('tax_src_dest_uniq',
|
|
'unique (position_id,tax_src_id,tax_dest_id)',
|
|
'A tax fiscal position could be defined only one time on same taxes.')
|
|
]
|
|
|
|
|
|
class AccountFiscalPositionAccount(models.Model):
|
|
_name = 'account.fiscal.position.account'
|
|
_description = 'Accounts Mapping of Fiscal Position'
|
|
_rec_name = 'position_id'
|
|
|
|
position_id = fields.Many2one('account.fiscal.position', string='Fiscal Position',
|
|
required=True, ondelete='cascade')
|
|
account_src_id = fields.Many2one('account.account', string='Account on Product',
|
|
domain=[('deprecated', '=', False)], required=True)
|
|
account_dest_id = fields.Many2one('account.account', string='Account to Use Instead',
|
|
domain=[('deprecated', '=', False)], required=True)
|
|
|
|
_sql_constraints = [
|
|
('account_src_dest_uniq',
|
|
'unique (position_id,account_src_id,account_dest_id)',
|
|
'An account fiscal position could be defined only one time on same accounts.')
|
|
]
|
|
|
|
|
|
class ResPartner(models.Model):
|
|
_name = 'res.partner'
|
|
_inherit = 'res.partner'
|
|
|
|
def _credit_debit_get(self):
|
|
tables, where_clause, where_params = self.env['account.move.line'].with_context(company_id=self.env.company.id)._query_get()
|
|
where_params = [tuple(self.ids)] + where_params
|
|
if where_clause:
|
|
where_clause = 'AND ' + where_clause
|
|
self._cr.execute("""SELECT account_move_line.partner_id, act.type, SUM(account_move_line.amount_residual)
|
|
FROM """ + tables + """
|
|
LEFT JOIN account_account a ON (account_move_line.account_id=a.id)
|
|
LEFT JOIN account_account_type act ON (a.user_type_id=act.id)
|
|
WHERE act.type IN ('receivable','payable')
|
|
AND account_move_line.partner_id IN %s
|
|
AND account_move_line.reconciled IS FALSE
|
|
""" + where_clause + """
|
|
GROUP BY account_move_line.partner_id, act.type
|
|
""", where_params)
|
|
for pid, type, val in self._cr.fetchall():
|
|
partner = self.browse(pid)
|
|
if type == 'receivable':
|
|
partner.credit = val
|
|
elif type == 'payable':
|
|
partner.debit = -val
|
|
|
|
def _asset_difference_search(self, account_type, operator, operand):
|
|
if operator not in ('<', '=', '>', '>=', '<='):
|
|
return []
|
|
if type(operand) not in (float, int):
|
|
return []
|
|
sign = 1
|
|
if account_type == 'payable':
|
|
sign = -1
|
|
res = self._cr.execute('''
|
|
SELECT partner.id
|
|
FROM res_partner partner
|
|
LEFT JOIN account_move_line aml ON aml.partner_id = partner.id
|
|
RIGHT JOIN account_account acc ON aml.account_id = acc.id
|
|
WHERE acc.internal_type = %s
|
|
AND NOT acc.deprecated AND acc.company_id = %s
|
|
GROUP BY partner.id
|
|
HAVING %s * COALESCE(SUM(aml.amount_residual), 0) ''' + operator + ''' %s''', (account_type, self.env.user.company_id.id, sign, operand))
|
|
res = self._cr.fetchall()
|
|
if not res:
|
|
return [('id', '=', '0')]
|
|
return [('id', 'in', [r[0] for r in res])]
|
|
|
|
@api.model
|
|
def _credit_search(self, operator, operand):
|
|
return self._asset_difference_search('receivable', operator, operand)
|
|
|
|
@api.model
|
|
def _debit_search(self, operator, operand):
|
|
return self._asset_difference_search('payable', operator, operand)
|
|
|
|
def _invoice_total(self):
|
|
account_invoice_report = self.env['account.invoice.report']
|
|
if not self.ids:
|
|
return True
|
|
|
|
user_currency_id = self.env.company.currency_id.id
|
|
all_partners_and_children = {}
|
|
all_partner_ids = []
|
|
for partner in self:
|
|
# price_total is in the company currency
|
|
all_partners_and_children[partner] = self.with_context(active_test=False).search([('id', 'child_of', partner.id)]).ids
|
|
all_partner_ids += all_partners_and_children[partner]
|
|
|
|
# searching account.invoice.report via the ORM is comparatively expensive
|
|
# (generates queries "id in []" forcing to build the full table).
|
|
# In simple cases where all invoices are in the same currency than the user's company
|
|
# access directly these elements
|
|
|
|
# generate where clause to include multicompany rules
|
|
where_query = account_invoice_report._where_calc([
|
|
('partner_id', 'in', all_partner_ids), ('state', 'not in', ['draft', 'cancel']),
|
|
('type', 'in', ('out_invoice', 'out_refund'))
|
|
])
|
|
account_invoice_report._apply_ir_rules(where_query, 'read')
|
|
from_clause, where_clause, where_clause_params = where_query.get_sql()
|
|
|
|
# price_total is in the company currency
|
|
query = """
|
|
SELECT SUM(price_subtotal) as total, partner_id
|
|
FROM account_invoice_report account_invoice_report
|
|
WHERE %s
|
|
GROUP BY partner_id
|
|
""" % where_clause
|
|
self.env.cr.execute(query, where_clause_params)
|
|
price_totals = self.env.cr.dictfetchall()
|
|
for partner, child_ids in all_partners_and_children.items():
|
|
partner.total_invoiced = sum(price['total'] for price in price_totals if price['partner_id'] in child_ids)
|
|
|
|
def _compute_journal_item_count(self):
|
|
AccountMoveLine = self.env['account.move.line']
|
|
for partner in self:
|
|
partner.journal_item_count = AccountMoveLine.search_count([('partner_id', '=', partner.id)])
|
|
|
|
def get_followup_lines_domain(self, date, overdue_only=False, only_unblocked=False):
|
|
domain = [('reconciled', '=', False), ('account_id.deprecated', '=', False), ('account_id.internal_type', '=', 'receivable'), '|', ('debit', '!=', 0), ('credit', '!=', 0), ('company_id', '=', self.env.company.id)]
|
|
if only_unblocked:
|
|
domain += [('blocked', '=', False)]
|
|
if self.ids:
|
|
if 'exclude_given_ids' in self._context:
|
|
domain += [('partner_id', 'not in', self.ids)]
|
|
else:
|
|
domain += [('partner_id', 'in', self.ids)]
|
|
#adding the overdue lines
|
|
overdue_domain = ['|', '&', ('date_maturity', '!=', False), ('date_maturity', '<', date), '&', ('date_maturity', '=', False), ('date', '<', date)]
|
|
if overdue_only:
|
|
domain += overdue_domain
|
|
return domain
|
|
|
|
def _compute_has_unreconciled_entries(self):
|
|
for partner in self:
|
|
# Avoid useless work if has_unreconciled_entries is not relevant for this partner
|
|
if not partner.active or not partner.is_company and partner.parent_id:
|
|
continue
|
|
self.env.cr.execute(
|
|
""" SELECT 1 FROM(
|
|
SELECT
|
|
p.last_time_entries_checked AS last_time_entries_checked,
|
|
MAX(l.write_date) AS max_date
|
|
FROM
|
|
account_move_line l
|
|
RIGHT JOIN account_account a ON (a.id = l.account_id)
|
|
RIGHT JOIN res_partner p ON (l.partner_id = p.id)
|
|
WHERE
|
|
p.id = %s
|
|
AND EXISTS (
|
|
SELECT 1
|
|
FROM account_move_line l
|
|
WHERE l.account_id = a.id
|
|
AND l.partner_id = p.id
|
|
AND l.amount_residual > 0
|
|
)
|
|
AND EXISTS (
|
|
SELECT 1
|
|
FROM account_move_line l
|
|
WHERE l.account_id = a.id
|
|
AND l.partner_id = p.id
|
|
AND l.amount_residual < 0
|
|
)
|
|
GROUP BY p.last_time_entries_checked
|
|
) as s
|
|
WHERE (last_time_entries_checked IS NULL OR max_date > last_time_entries_checked)
|
|
""", (partner.id,))
|
|
partner.has_unreconciled_entries = self.env.cr.rowcount == 1
|
|
|
|
def mark_as_reconciled(self):
|
|
self.env['account.partial.reconcile'].check_access_rights('write')
|
|
return self.sudo().with_context(company_id=self.env.company.id).write({'last_time_entries_checked': time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)})
|
|
|
|
def _get_company_currency(self):
|
|
for partner in self:
|
|
if partner.company_id:
|
|
partner.currency_id = partner.sudo().company_id.currency_id
|
|
else:
|
|
partner.currency_id = self.env.company.currency_id
|
|
|
|
credit = fields.Monetary(compute='_credit_debit_get', search=_credit_search,
|
|
string='Total Receivable', help="Total amount this customer owes you.")
|
|
debit = fields.Monetary(compute='_credit_debit_get', search=_debit_search, string='Total Payable',
|
|
help="Total amount you have to pay to this vendor.")
|
|
debit_limit = fields.Monetary('Payable Limit')
|
|
total_invoiced = fields.Monetary(compute='_invoice_total', string="Total Invoiced",
|
|
groups='account.group_account_invoice')
|
|
currency_id = fields.Many2one('res.currency', compute='_get_company_currency', readonly=True,
|
|
string="Currency", help='Utility field to express amount currency')
|
|
journal_item_count = fields.Integer(compute='_compute_journal_item_count', string="Journal Items", type="integer")
|
|
property_account_payable_id = fields.Many2one('account.account', company_dependent=True,
|
|
string="Account Payable",
|
|
domain="[('internal_type', '=', 'payable'), ('deprecated', '=', False)]",
|
|
help="This account will be used instead of the default one as the payable account for the current partner",
|
|
required=True)
|
|
property_account_receivable_id = fields.Many2one('account.account', company_dependent=True,
|
|
string="Account Receivable",
|
|
domain="[('internal_type', '=', 'receivable'), ('deprecated', '=', False)]",
|
|
help="This account will be used instead of the default one as the receivable account for the current partner",
|
|
required=True)
|
|
property_account_position_id = fields.Many2one('account.fiscal.position', company_dependent=True,
|
|
string="Fiscal Position",
|
|
help="The fiscal position determines the taxes/accounts used for this contact.")
|
|
property_payment_term_id = fields.Many2one('account.payment.term', company_dependent=True,
|
|
string='Customer Payment Terms',
|
|
help="This payment term will be used instead of the default one for sales orders and customer invoices")
|
|
property_supplier_payment_term_id = fields.Many2one('account.payment.term', company_dependent=True,
|
|
string='Vendor Payment Terms',
|
|
help="This payment term will be used instead of the default one for purchase orders and vendor bills")
|
|
ref_company_ids = fields.One2many('res.company', 'partner_id',
|
|
string='Companies that refers to partner')
|
|
has_unreconciled_entries = fields.Boolean(compute='_compute_has_unreconciled_entries',
|
|
help="The partner has at least one unreconciled debit and credit since last time the invoices & payments matching was performed.")
|
|
last_time_entries_checked = fields.Datetime(
|
|
string='Latest Invoices & Payments Matching Date', readonly=True, copy=False,
|
|
help='Last time the invoices & payments matching was performed for this partner. '
|
|
'It is set either if there\'s not at least an unreconciled debit and an unreconciled credit '
|
|
'or if you click the "Done" button.')
|
|
invoice_ids = fields.One2many('account.move', 'partner_id', string='Invoices', readonly=True, copy=False)
|
|
contract_ids = fields.One2many('account.analytic.account', 'partner_id', string='Partner Contracts', readonly=True)
|
|
bank_account_count = fields.Integer(compute='_compute_bank_count', string="Bank")
|
|
trust = fields.Selection([('good', 'Good Debtor'), ('normal', 'Normal Debtor'), ('bad', 'Bad Debtor')], string='Degree of trust you have in this debtor', default='normal', company_dependent=True)
|
|
invoice_warn = fields.Selection(WARNING_MESSAGE, 'Invoice', help=WARNING_HELP, default="no-message")
|
|
invoice_warn_msg = fields.Text('Message for Invoice')
|
|
|
|
def _compute_bank_count(self):
|
|
bank_data = self.env['res.partner.bank'].read_group([('partner_id', 'in', self.ids)], ['partner_id'], ['partner_id'])
|
|
mapped_data = dict([(bank['partner_id'][0], bank['partner_id_count']) for bank in bank_data])
|
|
for partner in self:
|
|
partner.bank_account_count = mapped_data.get(partner.id, 0)
|
|
|
|
def _find_accounting_partner(self, partner):
|
|
''' Find the partner for which the accounting entries will be created '''
|
|
return partner.commercial_partner_id
|
|
|
|
@api.model
|
|
def _commercial_fields(self):
|
|
return super(ResPartner, self)._commercial_fields() + \
|
|
['debit_limit', 'property_account_payable_id', 'property_account_receivable_id', 'property_account_position_id',
|
|
'property_payment_term_id', 'property_supplier_payment_term_id', 'last_time_entries_checked']
|
|
|
|
def action_view_partner_invoices(self):
|
|
self.ensure_one()
|
|
action = self.env.ref('account.action_move_out_invoice_type').read()[0]
|
|
action['domain'] = [
|
|
('type', 'in', ('out_invoice', 'out_refund')),
|
|
('type', '=', 'posted'),
|
|
('partner_id', 'child_of', self.id),
|
|
]
|
|
action['context'] = {'default_type':'out_invoice', 'type':'out_invoice', 'journal_type': 'sale', 'search_default_unpaid': 1}
|
|
return action
|
|
|
|
@api.onchange('company_id')
|
|
def _onchange_company_id(self):
|
|
if self.company_id:
|
|
company = self.company_id
|
|
else:
|
|
company = self.env.company
|
|
return {'domain': {'property_account_position_id': [('company_id', 'in', [company.id, False])]}}
|
|
|
|
def can_edit_vat(self):
|
|
''' Can't edit `vat` if there is (non draft) issued invoices. '''
|
|
can_edit_vat = super(ResPartner, self).can_edit_vat()
|
|
if not can_edit_vat:
|
|
return can_edit_vat
|
|
has_invoice = self.env['account.move'].search([
|
|
('type', 'in', ['out_invoice', 'out_refund']),
|
|
('partner_id', 'child_of', self.commercial_partner_id.id),
|
|
('state', '=', 'posted')
|
|
], limit=1)
|
|
return can_edit_vat and not (bool(has_invoice))
|