forked from Mapan/odoo17e
304 lines
15 KiB
Python
304 lines
15 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import datetime
|
|
from dateutil.relativedelta import relativedelta
|
|
import itertools
|
|
|
|
from odoo import api, fields, models, _
|
|
from odoo.exceptions import UserError
|
|
from odoo.tools import date_utils
|
|
from odoo.tools.misc import format_date
|
|
|
|
|
|
class ResCompany(models.Model):
|
|
_inherit = "res.company"
|
|
|
|
totals_below_sections = fields.Boolean(
|
|
string='Add totals below sections',
|
|
help='When ticked, totals and subtotals appear below the sections of the report.')
|
|
account_tax_periodicity = fields.Selection([
|
|
('year', 'annually'),
|
|
('semester', 'semi-annually'),
|
|
('4_months', 'every 4 months'),
|
|
('trimester', 'quarterly'),
|
|
('2_months', 'every 2 months'),
|
|
('monthly', 'monthly')], string="Delay units", help="Periodicity", default='monthly', required=True)
|
|
account_tax_periodicity_reminder_day = fields.Integer(string='Start from', default=7, required=True)
|
|
account_tax_periodicity_journal_id = fields.Many2one('account.journal', string='Journal', domain=[('type', '=', 'general')], check_company=True)
|
|
account_revaluation_journal_id = fields.Many2one('account.journal', domain=[('type', '=', 'general')], check_company=True)
|
|
account_revaluation_expense_provision_account_id = fields.Many2one('account.account', string='Expense Provision Account', check_company=True)
|
|
account_revaluation_income_provision_account_id = fields.Many2one('account.account', string='Income Provision Account', check_company=True)
|
|
account_tax_unit_ids = fields.Many2many(string="Tax Units", comodel_name='account.tax.unit', help="The tax units this company belongs to.")
|
|
account_representative_id = fields.Many2one('res.partner', string='Accounting Firm',
|
|
help="Specify an Accounting Firm that will act as a representative when exporting reports.")
|
|
account_display_representative_field = fields.Boolean(compute='_compute_account_display_representative_field')
|
|
|
|
@api.depends('account_fiscal_country_id.code')
|
|
def _compute_account_display_representative_field(self):
|
|
country_set = self._get_countries_allowing_tax_representative()
|
|
for record in self:
|
|
record.account_display_representative_field = record.account_fiscal_country_id.code in country_set
|
|
|
|
def _get_countries_allowing_tax_representative(self):
|
|
""" Returns a set containing the country codes of the countries for which
|
|
it is possible to use a representative to submit the tax report.
|
|
This function is a hook that needs to be overridden in localisation modules.
|
|
"""
|
|
return set()
|
|
|
|
def _get_default_misc_journal(self):
|
|
""" Returns a default 'miscellanous' journal to use for
|
|
account_tax_periodicity_journal_id field. This is useful in case a
|
|
CoA was already installed on the company at the time the module
|
|
is installed, so that the field is set automatically when added."""
|
|
return self.env['account.journal'].search([
|
|
*self.env['account.journal']._check_company_domain(self),
|
|
('type', '=', 'general'),
|
|
('show_on_dashboard', '=', True),
|
|
], limit=1)
|
|
|
|
def write(self, values):
|
|
tax_closing_update_dependencies = ('account_tax_periodicity', 'account_tax_periodicity_reminder_day', 'account_tax_periodicity_journal_id.id')
|
|
to_update = self.env['res.company']
|
|
for company in self:
|
|
if company.account_tax_periodicity_journal_id:
|
|
|
|
need_tax_closing_update = any(
|
|
update_dep in values and company.mapped(update_dep)[0] != values[update_dep]
|
|
for update_dep in tax_closing_update_dependencies
|
|
)
|
|
|
|
if need_tax_closing_update:
|
|
to_update += company
|
|
|
|
res = super().write(values)
|
|
|
|
for update_company in to_update:
|
|
update_company._update_tax_closing_after_periodicity_change()
|
|
|
|
return res
|
|
|
|
def _update_tax_closing_after_periodicity_change(self):
|
|
self.ensure_one()
|
|
|
|
vat_fiscal_positions = self.env['account.fiscal.position'].search([
|
|
('company_id', '=', self.id),
|
|
('foreign_vat', '!=', False),
|
|
])
|
|
|
|
self._get_and_update_tax_closing_moves(fields.Date.today(), vat_fiscal_positions, include_domestic=True)
|
|
|
|
def _get_and_update_tax_closing_moves(self, in_period_date, fiscal_positions=None, include_domestic=False):
|
|
""" Searches for tax closing moves. If some are missing for the provided parameters,
|
|
they are created in draft state. Also, existing moves get updated in case of configuration changes
|
|
(closing journal or periodicity, for example). Note the content of these moves stays untouched.
|
|
|
|
:param in_period_date: A date within the tax closing period we want the closing for.
|
|
:param fiscal_positions: The fiscal positions we want to generate the closing for (as a recordset).
|
|
:param include_domestic: Whether or not the domestic closing (i.e. the one without any fiscal_position_id) must be included
|
|
|
|
:return: The closing moves, as a recordset.
|
|
"""
|
|
self.ensure_one()
|
|
|
|
if not fiscal_positions:
|
|
fiscal_positions = []
|
|
|
|
# Compute period dates depending on the date
|
|
period_start, period_end = self._get_tax_closing_period_boundaries(in_period_date)
|
|
activity_deadline = period_end + relativedelta(days=self.account_tax_periodicity_reminder_day)
|
|
|
|
# Search for an existing tax closing move
|
|
tax_closing_activity_type = self.env.ref('account_reports.tax_closing_activity_type', raise_if_not_found=False)
|
|
tax_closing_activity_type_id = tax_closing_activity_type.id if tax_closing_activity_type else False
|
|
|
|
all_closing_moves = self.env['account.move']
|
|
for fpos in itertools.chain(fiscal_positions, [None] if include_domestic else []):
|
|
|
|
tax_closing_move = self.env['account.move'].search([
|
|
('state', '=', 'draft'),
|
|
('company_id', '=', self.id),
|
|
('tax_closing_end_date', '>=', period_start),
|
|
('tax_closing_end_date', '<=', period_end),
|
|
('fiscal_position_id', '=', fpos.id if fpos else None),
|
|
])
|
|
|
|
# This should never happen, but can be caused by wrong manual operations
|
|
if len(tax_closing_move) > 1:
|
|
if fpos:
|
|
error = _("Multiple draft tax closing entries exist for fiscal position %s after %s. There should be at most one. \n %s")
|
|
params = (fpos.name, period_start, tax_closing_move.mapped('display_name'))
|
|
|
|
else:
|
|
error = _("Multiple draft tax closing entries exist for your domestic region after %s. There should be at most one. \n %s")
|
|
params = (period_start, tax_closing_move.mapped('display_name'))
|
|
|
|
raise UserError(error % params)
|
|
|
|
# Compute tax closing description
|
|
ref = self._get_tax_closing_move_description(self.account_tax_periodicity, period_start, period_end, fpos)
|
|
|
|
# Values for update/creation of closing move
|
|
closing_vals = {
|
|
'company_id': self.id,# Important to specify together with the journal, for branches
|
|
'journal_id': self.account_tax_periodicity_journal_id.id,
|
|
'date': period_end,
|
|
'tax_closing_end_date': period_end,
|
|
'fiscal_position_id': fpos.id if fpos else None,
|
|
'ref': ref,
|
|
'name': '/', # Explicitly set a void name so that we don't set the sequence for the journal and don't consume a sequence number
|
|
}
|
|
|
|
if tax_closing_move:
|
|
# Update the next activity on the existing move
|
|
for act in tax_closing_move.activity_ids:
|
|
if act.activity_type_id.id == tax_closing_activity_type_id:
|
|
act.write({'date_deadline': activity_deadline})
|
|
|
|
tax_closing_move.write(closing_vals)
|
|
else:
|
|
# Create a new, empty, tax closing move
|
|
tax_closing_move = self.env['account.move'].create(closing_vals)
|
|
report, tax_closing_options = tax_closing_move._get_report_options_from_tax_closing_entry()
|
|
|
|
if report._get_sender_company_for_export(tax_closing_options) == tax_closing_move.company_id:
|
|
# In case of VAT units or branches, only the main company's closing needs to receive the next activity
|
|
group_account_manager = self.env.ref('account.group_account_manager')
|
|
advisor_user = tax_closing_activity_type.default_user_id if tax_closing_activity_type else self.env['res.users']
|
|
if advisor_user and not (self in advisor_user.company_ids and group_account_manager in advisor_user.groups_id):
|
|
advisor_user = self.env['res.users']
|
|
|
|
if not advisor_user:
|
|
advisor_user = self.env['res.users'].search(
|
|
[('company_ids', 'in', self.ids), ('groups_id', 'in', group_account_manager.ids)],
|
|
limit=1, order="id ASC",
|
|
)
|
|
|
|
self.env['mail.activity'].with_context(mail_activity_quick_update=True).create({
|
|
'res_id': tax_closing_move.id,
|
|
'res_model_id': self.env['ir.model']._get_id('account.move'),
|
|
'activity_type_id': tax_closing_activity_type_id,
|
|
'date_deadline': activity_deadline,
|
|
'automated': True,
|
|
'user_id': advisor_user.id or self.env.user.id
|
|
})
|
|
|
|
all_closing_moves += tax_closing_move
|
|
|
|
return all_closing_moves
|
|
|
|
def _get_tax_closing_move_description(self, periodicity, period_start, period_end, fiscal_position):
|
|
""" Returns a string description of the provided period dates, with the
|
|
given tax periodicity.
|
|
"""
|
|
self.ensure_one()
|
|
|
|
foreign_vat_fpos_count = self.env['account.fiscal.position'].search_count([
|
|
('company_id', '=', self.id),
|
|
('foreign_vat', '!=', False)
|
|
])
|
|
if foreign_vat_fpos_count:
|
|
if fiscal_position:
|
|
country_code = fiscal_position.country_id.code
|
|
state_codes = fiscal_position.mapped('state_ids.code') if fiscal_position.state_ids else []
|
|
else:
|
|
# On domestic country
|
|
country_code = self.account_fiscal_country_id.code
|
|
|
|
# Only consider the state in case there are foreign VAT fpos on states in this country
|
|
vat_fpos_with_state_count = self.env['account.fiscal.position'].search_count([
|
|
('company_id', '=', self.id),
|
|
('foreign_vat', '!=', False),
|
|
('country_id', '=', self.account_fiscal_country_id.id),
|
|
('state_ids', '!=', False),
|
|
])
|
|
state_codes = [self.state_id.code] if vat_fpos_with_state_count else []
|
|
|
|
if state_codes:
|
|
region_string = " (%s - %s)" % (country_code, ', '.join(state_codes))
|
|
else:
|
|
region_string = " (%s)" % country_code
|
|
else:
|
|
# Don't add region information in case there is no foreign VAT fpos
|
|
region_string = ''
|
|
|
|
if periodicity == 'year':
|
|
return _("Tax return for %s%s", period_start.year, region_string)
|
|
elif periodicity == 'trimester':
|
|
return _("Tax return for %s%s", format_date(self.env, period_start, date_format='qqq yyyy'), region_string)
|
|
elif periodicity == 'monthly':
|
|
return _("Tax return for %s%s", format_date(self.env, period_start, date_format='LLLL yyyy'), region_string)
|
|
else:
|
|
return _("Tax return from %s to %s%s", format_date(self.env, period_start), format_date(self.env, period_end), region_string)
|
|
|
|
def _get_tax_closing_period_boundaries(self, date):
|
|
""" Returns the boundaries of the tax period containing the provided date
|
|
for this company, as a tuple (start, end).
|
|
"""
|
|
self.ensure_one()
|
|
period_months = self._get_tax_periodicity_months_delay()
|
|
period_number = (date.month//period_months) + (1 if date.month % period_months != 0 else 0)
|
|
end_date = date_utils.end_of(datetime.date(date.year, period_number * period_months, 1), 'month')
|
|
start_date = end_date + relativedelta(day=1, months=-period_months + 1)
|
|
|
|
return start_date, end_date
|
|
|
|
def _get_tax_periodicity_months_delay(self):
|
|
""" Returns the number of months separating two tax returns with the provided periodicity
|
|
"""
|
|
self.ensure_one()
|
|
periodicities = {
|
|
'year': 12,
|
|
'semester': 6,
|
|
'4_months': 4,
|
|
'trimester': 3,
|
|
'2_months': 2,
|
|
'monthly': 1,
|
|
}
|
|
return periodicities[self.account_tax_periodicity]
|
|
|
|
def _get_branches_with_same_vat(self, accessible_only=False):
|
|
""" Returns all companies among self and its branch hierachy (considering children and parents) that share the same VAT number
|
|
as self. An empty VAT number is considered as being the same as the one of the closest parent with a VAT number.
|
|
|
|
self is always returned as the first element of the resulting recordset (so that this can safely be used to restore the active company).
|
|
|
|
Example:
|
|
- main company ; vat = 123
|
|
- branch 1
|
|
- branch 1_1
|
|
- branch 2 ; vat = 456
|
|
- branch 2_1 ; vat = 789
|
|
- branch 2_2
|
|
|
|
In this example, the following VAT numbers will be considered for each company:
|
|
- main company: 123
|
|
- branch 1: 123
|
|
- branch 1_1: 123
|
|
- branch 2: 456
|
|
- branch 2_1: 789
|
|
- branch 2_2: 456
|
|
|
|
:param accessible_only: whether the returned companies should exclude companies that are not in self.env.companies
|
|
"""
|
|
self.ensure_one()
|
|
|
|
current = self.sudo()
|
|
same_vat_branch_ids = [current.id] # Current is always available
|
|
current_strict_parents = current.parent_ids - current
|
|
if accessible_only:
|
|
candidate_branches = current.root_id._accessible_branches()
|
|
else:
|
|
candidate_branches = self.env['res.company'].sudo().search([('id', 'child_of', current.root_id.ids)])
|
|
|
|
current_vat_check_set = {current.vat} if current.vat else set()
|
|
for branch in candidate_branches - current:
|
|
parents_vat_set = set(filter(None, (branch.parent_ids - current_strict_parents).mapped('vat')))
|
|
if parents_vat_set == current_vat_check_set:
|
|
# If all the branches between the active company and branch (both included) share the same VAT number as the active company,
|
|
# we want to add the branch to the selection.
|
|
same_vat_branch_ids.append(branch.id)
|
|
|
|
return self.browse(same_vat_branch_ids)
|