898 lines
46 KiB
Python
898 lines
46 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import ast
|
|
import re
|
|
from collections import defaultdict
|
|
|
|
from odoo import models, fields, api, _, osv, Command
|
|
from odoo.exceptions import ValidationError, UserError
|
|
|
|
FIGURE_TYPE_SELECTION_VALUES = [
|
|
('monetary', "Monetary"),
|
|
('percentage', "Percentage"),
|
|
('integer', "Integer"),
|
|
('float', "Float"),
|
|
('date', "Date"),
|
|
('datetime', "Datetime"),
|
|
('boolean', 'Boolean'),
|
|
('string', 'String'),
|
|
]
|
|
|
|
DOMAIN_REGEX = re.compile(r'(-?sum)\((.*)\)')
|
|
|
|
class AccountReport(models.Model):
|
|
_name = "account.report"
|
|
_description = "Accounting Report"
|
|
_order = 'sequence, id'
|
|
|
|
# CORE ==========================================================================================================================================
|
|
|
|
name = fields.Char(string="Name", required=True, translate=True)
|
|
sequence = fields.Integer(string="Sequence")
|
|
active = fields.Boolean(string="Active", default=True)
|
|
line_ids = fields.One2many(string="Lines", comodel_name='account.report.line', inverse_name='report_id')
|
|
column_ids = fields.One2many(string="Columns", comodel_name='account.report.column', inverse_name='report_id')
|
|
root_report_id = fields.Many2one(string="Root Report", comodel_name='account.report', help="The report this report is a variant of.")
|
|
variant_report_ids = fields.One2many(string="Variants", comodel_name='account.report', inverse_name='root_report_id')
|
|
section_report_ids = fields.Many2many(string="Sections", comodel_name='account.report', relation="account_report_section_rel", column1="main_report_id", column2="sub_report_id")
|
|
section_main_report_ids = fields.Many2many(string="Section Of", comodel_name='account.report', relation="account_report_section_rel", column1="sub_report_id", column2="main_report_id")
|
|
use_sections = fields.Boolean(
|
|
string="Composite Report",
|
|
compute="_compute_use_sections", store=True, readonly=False,
|
|
help="Create a structured report with multiple sections for convenient navigation and simultaneous printing.",
|
|
)
|
|
chart_template = fields.Selection(string="Chart of Accounts", selection=lambda self: self.env['account.chart.template']._select_chart_template())
|
|
country_id = fields.Many2one(string="Country", comodel_name='res.country')
|
|
only_tax_exigible = fields.Boolean(
|
|
string="Only Tax Exigible Lines",
|
|
compute=lambda x: x._compute_report_option_filter('only_tax_exigible'), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
availability_condition = fields.Selection(
|
|
string="Availability",
|
|
selection=[('country', "Country Matches"), ('coa', "Chart of Accounts Matches"), ('always', "Always")],
|
|
compute='_compute_default_availability_condition', readonly=False, store=True,
|
|
)
|
|
load_more_limit = fields.Integer(string="Load More Limit")
|
|
search_bar = fields.Boolean(string="Search Bar")
|
|
prefix_groups_threshold = fields.Integer(string="Prefix Groups Threshold", default=4000)
|
|
integer_rounding = fields.Selection(string="Integer Rounding", selection=[('HALF-UP', "Nearest"), ('UP', "Up"), ('DOWN', "Down")])
|
|
|
|
default_opening_date_filter = fields.Selection(
|
|
string="Default Opening",
|
|
selection=[
|
|
('this_year', "This Year"),
|
|
('this_quarter', "This Quarter"),
|
|
('this_month', "This Month"),
|
|
('today', "Today"),
|
|
('previous_month', "Last Month"),
|
|
('previous_quarter', "Last Quarter"),
|
|
('previous_year', "Last Year"),
|
|
('this_tax_period', "This Tax Period"),
|
|
('previous_tax_period', "Last Tax Period"),
|
|
],
|
|
compute=lambda x: x._compute_report_option_filter('default_opening_date_filter', 'previous_month'),
|
|
readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
|
|
currency_translation = fields.Selection(
|
|
string="Currency Translation",
|
|
selection=[
|
|
('current', "Use the most recent rate at the date of the report"),
|
|
('cta', "Use CTA"),
|
|
],
|
|
compute=lambda x: x._compute_report_option_filter('currency_translation', 'cta'),
|
|
readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
|
|
# FILTERS =======================================================================================================================================
|
|
# Those fields control the display of menus on the report
|
|
|
|
filter_multi_company = fields.Selection(
|
|
string="Multi-Company",
|
|
selection=[('disabled', "Disabled"), ('selector', "Use Company Selector"), ('tax_units', "Use Tax Units")],
|
|
compute=lambda x: x._compute_report_option_filter('filter_multi_company', 'disabled'), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_date_range = fields.Boolean(
|
|
string="Date Range",
|
|
compute=lambda x: x._compute_report_option_filter('filter_date_range', True), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_show_draft = fields.Boolean(
|
|
string="Draft Entries",
|
|
compute=lambda x: x._compute_report_option_filter('filter_show_draft', True), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_unreconciled = fields.Boolean(
|
|
string="Unreconciled Entries",
|
|
compute=lambda x: x._compute_report_option_filter('filter_unreconciled', False), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_unfold_all = fields.Boolean(
|
|
string="Unfold All",
|
|
compute=lambda x: x._compute_report_option_filter('filter_unfold_all'), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_hide_0_lines = fields.Selection(
|
|
string="Hide lines at 0",
|
|
selection=[('by_default', "Enabled by Default"), ('optional', "Optional"), ('never', "Never")],
|
|
compute=lambda x: x._compute_report_option_filter('filter_hide_0_lines', 'optional'), readonly=False, store=True, depends=['root_report_id'],
|
|
)
|
|
filter_period_comparison = fields.Boolean(
|
|
string="Period Comparison",
|
|
compute=lambda x: x._compute_report_option_filter('filter_period_comparison', True), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_growth_comparison = fields.Boolean(
|
|
string="Growth Comparison",
|
|
compute=lambda x: x._compute_report_option_filter('filter_growth_comparison', True), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_journals = fields.Boolean(
|
|
string="Journals",
|
|
compute=lambda x: x._compute_report_option_filter('filter_journals'), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_analytic = fields.Boolean(
|
|
string="Analytic Filter",
|
|
compute=lambda x: x._compute_report_option_filter('filter_analytic'), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_hierarchy = fields.Selection(
|
|
string="Account Groups",
|
|
selection=[('by_default', "Enabled by Default"), ('optional', "Optional"), ('never', "Never")],
|
|
compute=lambda x: x._compute_report_option_filter('filter_hierarchy', 'optional'), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_account_type = fields.Selection(
|
|
string="Account Types",
|
|
selection=[('both', "Payable and receivable"), ('payable', "Payable"), ('receivable', "Receivable"), ('disabled', 'Disabled')],
|
|
compute=lambda x: x._compute_report_option_filter('filter_account_type', 'disabled'), readonly=False, store=True, depends=['root_report_id'],
|
|
)
|
|
filter_partner = fields.Boolean(
|
|
string="Partners",
|
|
compute=lambda x: x._compute_report_option_filter('filter_partner'), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_fiscal_position = fields.Boolean(
|
|
string="Filter Multivat",
|
|
compute=lambda x: x._compute_report_option_filter('filter_fiscal_position'), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
filter_aml_ir_filters = fields.Boolean(
|
|
string="Favorite Filters", help="If activated, user-defined filters on journal items can be selected on this report",
|
|
compute=lambda x: x._compute_report_option_filter('filter_aml_ir_filters'), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
|
|
filter_budgets = fields.Boolean(
|
|
string="Budgets",
|
|
compute=lambda x: x._compute_report_option_filter('filter_budgets'), readonly=False, store=True, depends=['root_report_id', 'section_main_report_ids'],
|
|
)
|
|
|
|
def _compute_report_option_filter(self, field_name, default_value=False):
|
|
# We don't depend on the different filter fields on the root report, as we don't want a manual change on it to be reflected on all the reports
|
|
# using it as their root (would create confusion). The root report filters are only used as some kind of default values.
|
|
# When a report is a section, it can also get its default filter values from its parent composite report. This only happens when we're sure
|
|
# the report is not used as a section of multiple reports, nor as a standalone report.
|
|
for report in self.sorted(lambda x: not x.section_report_ids):
|
|
# Reports are sorted in order to first treat the composite reports, in case they need to compute their filters a the same time
|
|
# as their sections
|
|
if report.root_report_id:
|
|
report[field_name] = report.root_report_id[field_name]
|
|
elif len(report.section_main_report_ids) == 1 and not self.env['ir.actions.client'].search_count([('context', 'ilike', f"'report_id': {report.id}"), ('tag', '=', 'account_report')]):
|
|
report[field_name] = report.section_main_report_ids[field_name]
|
|
else:
|
|
report[field_name] = default_value
|
|
|
|
@api.depends('root_report_id', 'country_id')
|
|
def _compute_default_availability_condition(self):
|
|
for report in self:
|
|
if report.root_report_id and report.country_id:
|
|
report.availability_condition = 'country'
|
|
elif not report.availability_condition:
|
|
report.availability_condition = 'always'
|
|
|
|
@api.depends('section_report_ids')
|
|
def _compute_use_sections(self):
|
|
for report in self:
|
|
report.use_sections = bool(report.section_report_ids)
|
|
|
|
@api.constrains('root_report_id')
|
|
def _validate_root_report_id(self):
|
|
for report in self:
|
|
if report.root_report_id.root_report_id:
|
|
raise ValidationError(_("Only a report without a root report of its own can be selected as root report."))
|
|
|
|
@api.constrains('line_ids')
|
|
def _validate_parent_sequence(self):
|
|
previous_lines = self.env['account.report.line']
|
|
for line in self.line_ids:
|
|
if line.parent_id and line.parent_id not in previous_lines:
|
|
raise ValidationError(
|
|
_('Line "%(line)s" defines line "%(parent_line)s" as its parent, but appears before it in the report. '
|
|
'The parent must always come first.', line=line.name, parent_line=line.parent_id.name))
|
|
previous_lines |= line
|
|
|
|
@api.constrains('section_report_ids')
|
|
def _validate_section_report_ids(self):
|
|
for record in self:
|
|
if any(section.section_report_ids for section in record.section_report_ids):
|
|
raise ValidationError(_("The sections defined on a report cannot have sections themselves."))
|
|
|
|
@api.constrains('availability_condition', 'country_id')
|
|
def _validate_availability_condition(self):
|
|
for record in self:
|
|
if record.availability_condition == 'country' and not record.country_id:
|
|
raise ValidationError(_("The Availability is set to 'Country Matches' but the field Country is not set."))
|
|
|
|
@api.onchange('availability_condition')
|
|
def _onchange_availability_condition(self):
|
|
if self.availability_condition != 'country':
|
|
self.country_id = None
|
|
|
|
def write(self, vals):
|
|
# Overridden so that changing the country of a report also creates new tax tags if necessary, or updates the country
|
|
# of existing tags, if they aren't shared with another report.
|
|
if 'country_id' in vals:
|
|
impacted_reports = self.filtered(lambda x: x.country_id.id != vals['country_id'])
|
|
tax_tags_expressions = impacted_reports.line_ids.expression_ids.filtered(lambda x: x.engine == 'tax_tags')
|
|
|
|
for expression in tax_tags_expressions:
|
|
tax_tags = self.env['account.account.tag']._get_tax_tags(expression.formula, expression.report_line_id.report_id.country_id.id)
|
|
tag_reports = tax_tags._get_related_tax_report_expressions().report_line_id.report_id
|
|
|
|
if all(report in self for report in tag_reports):
|
|
# Only reports in self are using these tags; let's change their country
|
|
tax_tags.write({'country_id': vals['country_id']})
|
|
else:
|
|
# Another report uses these tags as well; let's keep them and create new tags in the target country
|
|
# if they don't exist yet.
|
|
existing_tax_tags = self.env['account.account.tag']._get_tax_tags(expression.formula, vals['country_id'])
|
|
if not existing_tax_tags:
|
|
tag_vals = self.env['account.report.expression']._get_tags_create_vals(expression.formula, vals['country_id'])
|
|
self.env['account.account.tag'].create(tag_vals)
|
|
|
|
return super().write(vals)
|
|
|
|
def copy_data(self, default=None):
|
|
vals_list = super().copy_data(default=default)
|
|
return [dict(vals, name=report._get_copied_name()) for report, vals in zip(self, vals_list)]
|
|
|
|
def copy(self, default=None):
|
|
'''Copy the whole financial report hierarchy by duplicating each line recursively.
|
|
|
|
:param default: Default values.
|
|
:return: The copied account.report record.
|
|
'''
|
|
new_reports = super().copy(default=default)
|
|
for old_report, new_report in zip(self, new_reports):
|
|
code_mapping = {}
|
|
for line in old_report.line_ids.filtered(lambda x: not x.parent_id):
|
|
line._copy_hierarchy(new_report, code_mapping=code_mapping)
|
|
|
|
# Replace line codes by their copy in aggregation formulas
|
|
for expression in new_report.line_ids.expression_ids:
|
|
if expression.engine == 'aggregation':
|
|
copied_formula = f" {expression.formula} " # Add spaces so that the lookahead/lookbehind of the regex can work (we can't do a | in those)
|
|
for old_code, new_code in code_mapping.items():
|
|
copied_formula = re.sub(f"(?<=\\W){old_code}(?=\\W)", new_code, copied_formula)
|
|
expression.formula = copied_formula.strip() # Remove the spaces introduced for lookahead/lookbehind
|
|
|
|
old_report.column_ids.copy({'report_id': new_report.id})
|
|
return new_reports
|
|
|
|
@api.ondelete(at_uninstall=False)
|
|
def _unlink_if_no_variant(self):
|
|
if self.variant_report_ids:
|
|
raise UserError(_("You can't delete a report that has variants."))
|
|
|
|
def _get_copied_name(self):
|
|
'''Return a copied name of the account.report record by adding the suffix (copy) at the end
|
|
until the name is unique.
|
|
|
|
:return: an unique name for the copied account.report
|
|
'''
|
|
self.ensure_one()
|
|
name = self.name + ' ' + _('(copy)')
|
|
while self.search_count([('name', '=', name)]) > 0:
|
|
name += ' ' + _('(copy)')
|
|
return name
|
|
|
|
@api.depends('name', 'country_id')
|
|
def _compute_display_name(self):
|
|
for report in self:
|
|
if report.name:
|
|
report.display_name = report.name + (f' ({report.country_id.code})' if report.country_id else '')
|
|
else:
|
|
report.display_name = False
|
|
|
|
|
|
class AccountReportLine(models.Model):
|
|
_name = "account.report.line"
|
|
_description = "Accounting Report Line"
|
|
_order = 'sequence, id'
|
|
|
|
name = fields.Char(string="Name", translate=True, required=True)
|
|
expression_ids = fields.One2many(string="Expressions", comodel_name='account.report.expression', inverse_name='report_line_id')
|
|
report_id = fields.Many2one(
|
|
string="Parent Report",
|
|
comodel_name='account.report',
|
|
compute='_compute_report_id',
|
|
store=True,
|
|
readonly=False,
|
|
required=True,
|
|
recursive=True,
|
|
precompute=True,
|
|
ondelete='cascade'
|
|
)
|
|
hierarchy_level = fields.Integer(
|
|
string="Level",
|
|
compute='_compute_hierarchy_level',
|
|
store=True,
|
|
readonly=False,
|
|
recursive=True,
|
|
required=True,
|
|
precompute=True,
|
|
)
|
|
parent_id = fields.Many2one(string="Parent Line", comodel_name='account.report.line', ondelete='set null')
|
|
children_ids = fields.One2many(string="Child Lines", comodel_name='account.report.line', inverse_name='parent_id')
|
|
groupby = fields.Char(string="Group By", help="Comma-separated list of fields from account.move.line (Journal Item). When set, this line will generate sublines grouped by those keys.")
|
|
user_groupby = fields.Char(
|
|
string="User Group By",
|
|
compute='_compute_user_groupby', store=True, readonly=False, precompute=True,
|
|
help="Comma-separated list of fields from account.move.line (Journal Item). When set, this line will generate sublines grouped by those keys.",
|
|
)
|
|
sequence = fields.Integer(string="Sequence")
|
|
code = fields.Char(string="Code", help="Unique identifier for this line.")
|
|
foldable = fields.Boolean(string="Foldable", help="By default, we always unfold the lines that can be. If this is checked, the line won't be unfolded by default, and a folding button will be displayed.")
|
|
print_on_new_page = fields.Boolean('Print On New Page', help='When checked this line and everything after it will be printed on a new page.')
|
|
action_id = fields.Many2one(string="Action", comodel_name='ir.actions.actions', help="Setting this field will turn the line into a link, executing the action when clicked.")
|
|
hide_if_zero = fields.Boolean(string="Hide if Zero", help="This line and its children will be hidden when all of their columns are 0.")
|
|
domain_formula = fields.Char(string="Domain Formula Shortcut", help="Internal field to shorten expression_ids creation for the domain engine", inverse='_inverse_domain_formula', store=False)
|
|
account_codes_formula = fields.Char(string="Account Codes Formula Shortcut", help="Internal field to shorten expression_ids creation for the account_codes engine", inverse='_inverse_account_codes_formula', store=False)
|
|
aggregation_formula = fields.Char(string="Aggregation Formula Shortcut", help="Internal field to shorten expression_ids creation for the aggregation engine", inverse='_inverse_aggregation_formula', store=False)
|
|
external_formula = fields.Char(string="External Formula Shortcut", help="Internal field to shorten expression_ids creation for the external engine", inverse='_inverse_external_formula', store=False)
|
|
horizontal_split_side = fields.Selection(string="Horizontal Split Side", selection=[('left', "Left"), ('right', "Right")], compute='_compute_horizontal_split_side', readonly=False, store=True, recursive=True)
|
|
tax_tags_formula = fields.Char(string="Tax Tags Formula Shortcut", help="Internal field to shorten expression_ids creation for the tax_tags engine", inverse='_inverse_aggregation_tax_formula', store=False)
|
|
|
|
_sql_constraints = [
|
|
('code_uniq', 'unique (report_id, code)', "A report line with the same code already exists."),
|
|
]
|
|
|
|
@api.depends('parent_id.hierarchy_level')
|
|
def _compute_hierarchy_level(self):
|
|
for report_line in self:
|
|
if report_line.parent_id:
|
|
increase_level = 3 if report_line.parent_id.hierarchy_level == 0 else 2
|
|
report_line.hierarchy_level = report_line.parent_id.hierarchy_level + increase_level
|
|
else:
|
|
report_line.hierarchy_level = 1
|
|
|
|
@api.depends('parent_id.report_id')
|
|
def _compute_report_id(self):
|
|
for report_line in self:
|
|
if report_line.parent_id:
|
|
report_line.report_id = report_line.parent_id.report_id
|
|
|
|
@api.depends('parent_id.horizontal_split_side')
|
|
def _compute_horizontal_split_side(self):
|
|
for report_line in self:
|
|
if report_line.parent_id:
|
|
report_line.horizontal_split_side = report_line.parent_id.horizontal_split_side
|
|
|
|
@api.depends('groupby', 'expression_ids.engine')
|
|
def _compute_user_groupby(self):
|
|
for report_line in self:
|
|
if not report_line.id and not report_line.user_groupby:
|
|
report_line.user_groupby = report_line.groupby
|
|
try:
|
|
report_line._validate_groupby()
|
|
except UserError:
|
|
report_line.user_groupby = report_line.groupby
|
|
|
|
@api.constrains('parent_id')
|
|
def _validate_groupby_no_child(self):
|
|
for report_line in self:
|
|
if report_line.parent_id.groupby or report_line.parent_id.user_groupby:
|
|
raise ValidationError(_("A line cannot have both children and a groupby value (line '%s').", report_line.parent_id.name))
|
|
|
|
@api.constrains('groupby', 'user_groupby')
|
|
def _validate_groupby(self):
|
|
self.expression_ids._validate_engine()
|
|
|
|
@api.constrains('parent_id')
|
|
def _check_parent_line(self):
|
|
for line in self.filtered(lambda x: x.parent_id == x):
|
|
raise ValidationError(_('Line "%s" defines itself as its parent.', line.name))
|
|
|
|
def _copy_hierarchy(self, copied_report, parent=None, code_mapping=None):
|
|
''' Copy the whole hierarchy from this line by copying each line children recursively and adapting the
|
|
formulas with the new copied codes.
|
|
|
|
:param copied_report: The copy of the report.
|
|
:param parent: The parent line in the hierarchy (a copy of the original parent line).
|
|
:param code_mapping: A dictionary keeping track of mapping old_code -> new_code
|
|
'''
|
|
self.ensure_one()
|
|
|
|
copied_line = self.copy({
|
|
'report_id': copied_report.id,
|
|
'parent_id': parent and parent.id,
|
|
'code': self._get_copied_code(),
|
|
})
|
|
|
|
# Keep track of old_code -> new_code in a mutable dict
|
|
if code_mapping is None:
|
|
code_mapping = {}
|
|
if self.code:
|
|
code_mapping[self.code] = copied_line.code
|
|
|
|
# Copy children
|
|
for line in self.children_ids:
|
|
line._copy_hierarchy(copied_report, parent=copied_line, code_mapping=code_mapping)
|
|
|
|
# Update aggregation expressions, so that they use the copied lines
|
|
for expression in self.expression_ids:
|
|
copy_defaults = {'report_line_id': copied_line.id}
|
|
expression.copy(copy_defaults)
|
|
|
|
def _get_copied_code(self):
|
|
'''Look for an unique copied code.
|
|
|
|
:return: an unique code for the copied account.report.line
|
|
'''
|
|
self.ensure_one()
|
|
if not self.code:
|
|
return False
|
|
code = self.code + '_COPY'
|
|
while self.search_count([('code', '=', code)]) > 0:
|
|
code += '_COPY'
|
|
return code
|
|
|
|
def _inverse_domain_formula(self):
|
|
self._create_report_expression(engine='domain')
|
|
|
|
def _inverse_aggregation_formula(self):
|
|
self._create_report_expression(engine='aggregation')
|
|
|
|
def _inverse_aggregation_tax_formula(self):
|
|
self._create_report_expression(engine='tax_tags')
|
|
|
|
def _inverse_account_codes_formula(self):
|
|
self._create_report_expression(engine='account_codes')
|
|
|
|
def _inverse_external_formula(self):
|
|
self._create_report_expression(engine='external')
|
|
|
|
def _create_report_expression(self, engine):
|
|
# create account.report.expression for each report line based on the formula provided to each
|
|
# engine-related field. This makes xmls a bit shorter
|
|
vals_list = []
|
|
xml_ids = self.expression_ids.filtered(lambda exp: exp.label == 'balance').get_external_id()
|
|
for report_line in self:
|
|
if engine == 'domain' and report_line.domain_formula:
|
|
subformula, formula = DOMAIN_REGEX.match(report_line.domain_formula or '').groups()
|
|
# Resolve the calls to ref(), to mimic the fact those formulas are normally given with an eval="..." in XML
|
|
formula = re.sub(r'''\bref\((?P<quote>['"])(?P<xmlid>.+?)(?P=quote)\)''', lambda m: str(self.env.ref(m['xmlid']).id), formula)
|
|
elif engine == 'account_codes' and report_line.account_codes_formula:
|
|
subformula, formula = None, report_line.account_codes_formula
|
|
elif engine == 'aggregation' and report_line.aggregation_formula:
|
|
subformula, formula = None, report_line.aggregation_formula
|
|
elif engine == 'external' and report_line.external_formula:
|
|
subformula, formula = 'editable', 'most_recent'
|
|
if report_line.external_formula == 'percentage':
|
|
subformula = 'editable;rounding=0'
|
|
elif report_line.external_formula == 'monetary':
|
|
formula = 'sum'
|
|
elif engine == 'tax_tags' and report_line.tax_tags_formula:
|
|
subformula, formula = None, report_line.tax_tags_formula
|
|
else:
|
|
# If we want to replace a formula shortcut with a full-syntax expression, we need to make the formula field falsy
|
|
# We can't simply remove it from the xml because it won't be updated
|
|
# If the formula field is falsy, we need to remove the expression that it generated
|
|
report_line.expression_ids.filtered(lambda exp: exp.engine == engine and exp.label == 'balance' and not xml_ids.get(exp.id)).unlink()
|
|
continue
|
|
|
|
vals = {
|
|
'report_line_id': report_line.id,
|
|
'label': 'balance',
|
|
'engine': engine,
|
|
'formula': formula.lstrip(' \t\n'), # Avoid IndentationError in evals
|
|
'subformula': subformula
|
|
}
|
|
if engine == 'external' and report_line.external_formula:
|
|
vals['figure_type'] = report_line.external_formula
|
|
|
|
if report_line.expression_ids:
|
|
# expressions already exists, update the first expression with the right engine
|
|
# since syntactic sugar aren't meant to be used with multiple expressions
|
|
for expression in report_line.expression_ids:
|
|
if expression.label == 'balance':
|
|
# If we had a 'balance' expression coming from the xml and are using a formula shortcut on top of it,
|
|
# we expect the shortcut to replace the original expression. The full declaration should also
|
|
# be removed from the data file, leading to the ORM deleting it automatically.
|
|
if xml_ids.get(expression.id):
|
|
expression.unlink()
|
|
vals_list.append(vals)
|
|
else:
|
|
expression.write(vals)
|
|
break
|
|
else:
|
|
# else prepare batch creation
|
|
vals_list.append(vals)
|
|
|
|
if vals_list:
|
|
self.env['account.report.expression'].create(vals_list)
|
|
|
|
@api.ondelete(at_uninstall=False)
|
|
def _unlink_child_expressions(self):
|
|
"""
|
|
We explicitly unlink child expressions.
|
|
This is necessary even if there is an ondelete='cascade' on it, because
|
|
the @api.ondelete method _unlink_archive_used_tags is not automatically
|
|
called if the parent model is deleted.
|
|
"""
|
|
self.expression_ids.unlink()
|
|
|
|
|
|
class AccountReportExpression(models.Model):
|
|
_name = "account.report.expression"
|
|
_description = "Accounting Report Expression"
|
|
_rec_name = 'report_line_name'
|
|
|
|
report_line_id = fields.Many2one(string="Report Line", comodel_name='account.report.line', required=True, ondelete='cascade')
|
|
report_line_name = fields.Char(string="Report Line Name", related="report_line_id.name")
|
|
label = fields.Char(string="Label", required=True)
|
|
engine = fields.Selection(
|
|
string="Computation Engine",
|
|
selection=[
|
|
('domain', "Odoo Domain"),
|
|
('tax_tags', "Tax Tags"),
|
|
('aggregation', "Aggregate Other Formulas"),
|
|
('account_codes', "Prefix of Account Codes"),
|
|
('external', "External Value"),
|
|
('custom', "Custom Python Function"),
|
|
],
|
|
required=True
|
|
)
|
|
formula = fields.Char(string="Formula", required=True)
|
|
subformula = fields.Char(string="Subformula")
|
|
date_scope = fields.Selection(
|
|
string="Date Scope",
|
|
selection=[
|
|
('from_beginning', 'From the very start'),
|
|
('from_fiscalyear', 'From the start of the fiscal year'),
|
|
('to_beginning_of_fiscalyear', 'At the beginning of the fiscal year'),
|
|
('to_beginning_of_period', 'At the beginning of the period'),
|
|
('strict_range', 'Strictly on the given dates'),
|
|
('previous_tax_period', "From previous tax period")
|
|
],
|
|
required=True,
|
|
default='strict_range',
|
|
)
|
|
figure_type = fields.Selection(string="Figure Type", selection=FIGURE_TYPE_SELECTION_VALUES)
|
|
green_on_positive = fields.Boolean(string="Is Growth Good when Positive", default=True)
|
|
blank_if_zero = fields.Boolean(string="Blank if Zero", help="When checked, 0 values will not show when displaying this expression's value.")
|
|
auditable = fields.Boolean(string="Auditable", store=True, readonly=False, compute='_compute_auditable')
|
|
|
|
# Carryover fields
|
|
carryover_target = fields.Char(
|
|
string="Carry Over To",
|
|
help="Formula in the form line_code.expression_label. This allows setting the target of the carryover for this expression "
|
|
"(on a _carryover_*-labeled expression), in case it is different from the parent line."
|
|
)
|
|
|
|
_sql_constraints = [
|
|
(
|
|
"domain_engine_subformula_required",
|
|
"CHECK(engine != 'domain' OR subformula IS NOT NULL)",
|
|
"Expressions using 'domain' engine should all have a subformula."
|
|
),
|
|
(
|
|
"line_label_uniq",
|
|
"UNIQUE(report_line_id,label)",
|
|
"The expression label must be unique per report line."
|
|
),
|
|
]
|
|
|
|
@api.constrains('carryover_target', 'label')
|
|
def _check_carryover_target(self):
|
|
for expression in self:
|
|
if expression.carryover_target and not expression.label.startswith('_carryover_'):
|
|
raise UserError(_("You cannot use the field carryover_target in an expression that does not have the label starting with _carryover_"))
|
|
elif expression.carryover_target and not expression.carryover_target.split('.')[1].startswith('_applied_carryover_'):
|
|
raise UserError(_("When targeting an expression for carryover, the label of that expression must start with _applied_carryover_"))
|
|
|
|
@api.constrains('formula')
|
|
def _check_domain_formula(self):
|
|
for expression in self.filtered(lambda expr: expr.engine == 'domain'):
|
|
try:
|
|
domain = ast.literal_eval(expression.formula)
|
|
self.env['account.move.line']._where_calc(domain)
|
|
except:
|
|
raise UserError(_("Invalid domain for expression '%(label)s' of line '%(line)s': %(formula)s",
|
|
label=expression.label, line=expression.report_line_name, formula=expression.formula))
|
|
|
|
@api.depends('engine')
|
|
def _compute_auditable(self):
|
|
auditable_engines = self._get_auditable_engines()
|
|
for expression in self:
|
|
expression.auditable = expression.engine in auditable_engines
|
|
|
|
@api.constrains('engine', 'report_line_id')
|
|
def _validate_engine(self):
|
|
for expression in self:
|
|
if expression.engine == 'aggregation' and (expression.report_line_id.groupby or expression.report_line_id.user_groupby):
|
|
raise ValidationError(_(
|
|
"Groupby feature isn't supported by aggregation engine. Please remove the groupby value on '%s'",
|
|
expression.report_line_id.display_name,
|
|
))
|
|
|
|
def _get_auditable_engines(self):
|
|
return {'tax_tags', 'domain', 'account_codes', 'external', 'aggregation'}
|
|
|
|
def _strip_formula(self, vals):
|
|
if 'formula' in vals and isinstance(vals['formula'], str):
|
|
vals['formula'] = re.sub(r'\s+', ' ', vals['formula'].strip())
|
|
|
|
def _create_tax_tags(self, tag_name, country):
|
|
existing_tags = self.env['account.account.tag']._get_tax_tags(tag_name, country.id)
|
|
if len(existing_tags) < 2:
|
|
# We can have only one tag in case we archived it and deleted its unused complement sign
|
|
tag_vals = self._get_tags_create_vals(tag_name, country.id, existing_tag=existing_tags)
|
|
self.env['account.account.tag'].create(tag_vals)
|
|
|
|
@api.model_create_multi
|
|
def create(self, vals_list):
|
|
# Overridden so that we create the corresponding account.account.tag objects when instantiating an expression
|
|
# with engine 'tax_tags'.
|
|
for vals in vals_list:
|
|
self._strip_formula(vals)
|
|
|
|
result = super().create(vals_list)
|
|
|
|
for expression in result:
|
|
tag_name = expression.formula if expression.engine == 'tax_tags' else None
|
|
if tag_name:
|
|
country = expression.report_line_id.report_id.country_id
|
|
self._create_tax_tags(tag_name, country)
|
|
|
|
return result
|
|
|
|
def write(self, vals):
|
|
|
|
self._strip_formula(vals)
|
|
|
|
if vals.get('engine') == 'tax_tags':
|
|
tag_name = vals.get('formula') or self.formula
|
|
country = self.report_line_id.report_id.country_id
|
|
self._create_tax_tags(tag_name, country)
|
|
return super().write(vals)
|
|
|
|
# In case the engine is changed we don't propagate any change to the tags themselves
|
|
if 'formula' not in vals or (vals.get('engine') and vals['engine'] != 'tax_tags'):
|
|
return super().write(vals)
|
|
|
|
tax_tags_expressions = self.filtered(lambda x: x.engine == 'tax_tags')
|
|
former_formulas_by_country = defaultdict(lambda: [])
|
|
for expr in tax_tags_expressions:
|
|
former_formulas_by_country[expr.report_line_id.report_id.country_id].append(expr.formula)
|
|
|
|
result = super().write(vals)
|
|
|
|
for country, former_formulas_list in former_formulas_by_country.items():
|
|
for former_formula in former_formulas_list:
|
|
new_tax_tags = self.env['account.account.tag']._get_tax_tags(vals['formula'], country.id)
|
|
|
|
if not new_tax_tags:
|
|
# If new tags already exist, nothing to do ; else, we must create them or update existing tags.
|
|
former_tax_tags = self.env['account.account.tag']._get_tax_tags(former_formula, country.id)
|
|
|
|
if former_tax_tags and all(tag_expr in self for tag_expr in former_tax_tags._get_related_tax_report_expressions()):
|
|
# If we're changing the formula of all the expressions using that tag, rename the tag
|
|
positive_tags, negative_tags = former_tax_tags.sorted(lambda x: x.tax_negate)
|
|
if self.pool['account.tax'].name.translate:
|
|
positive_tags._update_field_translations('name', {'en_US': f"+{vals['formula']}"})
|
|
negative_tags._update_field_translations('name', {'en_US': f"-{vals['formula']}"})
|
|
else:
|
|
positive_tags.name = f"+{vals['formula']}"
|
|
negative_tags.name = f"-{vals['formula']}"
|
|
else:
|
|
# Else, create a new tag. Its the compute functions will make sure it is properly linked to the expressions
|
|
tag_vals = self.env['account.report.expression']._get_tags_create_vals(vals['formula'], country.id)
|
|
self.env['account.account.tag'].create(tag_vals)
|
|
|
|
return result
|
|
|
|
@api.ondelete(at_uninstall=False)
|
|
def _unlink_archive_used_tags(self):
|
|
"""
|
|
Manages unlink or archive of tax_tags when account.report.expression are deleted.
|
|
If a tag is still in use on amls, we archive it.
|
|
"""
|
|
expressions_tags = self._get_matching_tags()
|
|
tags_to_archive = self.env['account.account.tag']
|
|
tags_to_unlink = self.env['account.account.tag']
|
|
for tag in expressions_tags:
|
|
other_expression_using_tag = self.env['account.report.expression'].sudo().search([
|
|
('engine', '=', 'tax_tags'),
|
|
('formula', '=', tag.with_context(lang='en_US').name[1:]), # we escape the +/- sign
|
|
('report_line_id.report_id.country_id', '=', tag.country_id.id),
|
|
('id', 'not in', self.ids),
|
|
], limit=1)
|
|
if not other_expression_using_tag:
|
|
aml_using_tag = self.env['account.move.line'].sudo().search([('tax_tag_ids', 'in', tag.id)], limit=1)
|
|
if aml_using_tag:
|
|
tags_to_archive += tag
|
|
else:
|
|
tags_to_unlink += tag
|
|
|
|
if tags_to_archive or tags_to_unlink:
|
|
rep_lines_with_tag = self.env['account.tax.repartition.line'].sudo().search([('tag_ids', 'in', (tags_to_archive + tags_to_unlink).ids)])
|
|
rep_lines_with_tag.write({'tag_ids': [Command.unlink(tag.id) for tag in tags_to_archive + tags_to_unlink]})
|
|
tags_to_archive.active = False
|
|
tags_to_unlink.unlink()
|
|
|
|
@api.depends('report_line_name', 'label')
|
|
def _compute_display_name(self):
|
|
for expr in self:
|
|
expr.display_name = f'{expr.report_line_name} [{expr.label}]'
|
|
|
|
|
|
def _expand_aggregations(self):
|
|
"""Return self and its full aggregation expression dependency"""
|
|
result = self
|
|
|
|
to_expand = self.filtered(lambda x: x.engine == 'aggregation')
|
|
while to_expand:
|
|
domains = []
|
|
sub_expressions = self.env['account.report.expression']
|
|
|
|
for candidate_expr in to_expand:
|
|
if candidate_expr.formula == 'sum_children':
|
|
sub_expressions |= candidate_expr.report_line_id.children_ids.expression_ids.filtered(lambda e: e.label == candidate_expr.label)
|
|
else:
|
|
labels_by_code = candidate_expr._get_aggregation_terms_details()
|
|
|
|
cross_report_domain = []
|
|
if candidate_expr.subformula != 'cross_report':
|
|
cross_report_domain = [('report_line_id.report_id', '=', candidate_expr.report_line_id.report_id.id)]
|
|
|
|
for line_code, expr_labels in labels_by_code.items():
|
|
dependency_domain = [('report_line_id.code', '=', line_code), ('label', 'in', tuple(expr_labels))] + cross_report_domain
|
|
domains.append(dependency_domain)
|
|
|
|
if domains:
|
|
sub_expressions |= self.env['account.report.expression'].search(osv.expression.OR(domains))
|
|
|
|
to_expand = sub_expressions.filtered(lambda x: x.engine == 'aggregation' and x not in result)
|
|
result |= sub_expressions
|
|
|
|
return result
|
|
|
|
def _get_aggregation_terms_details(self):
|
|
""" Computes the details of each aggregation expression in self, and returns them in the form of a single dict aggregating all the results.
|
|
|
|
Example of aggregation details:
|
|
formula 'A.balance + B.balance + A.other'
|
|
will return: {'A': {'balance', 'other'}, 'B': {'balance'}}
|
|
"""
|
|
totals_by_code = defaultdict(set)
|
|
for expression in self:
|
|
if expression.engine != 'aggregation':
|
|
raise UserError(_("Cannot get aggregation details from a line not using 'aggregation' engine"))
|
|
|
|
expression_terms = re.split('[-+/*]', re.sub(r'[\s()]', '', expression.formula))
|
|
for term in expression_terms:
|
|
if term and not re.match(r'^([0-9]*[.])?[0-9]*$', term): # term might be empty if the formula contains a negative term
|
|
line_code, total_name = term.split('.')
|
|
totals_by_code[line_code].add(total_name)
|
|
|
|
if expression.subformula:
|
|
if_other_expr_match = re.match(r'if_other_expr_(above|below)\((?P<line_code>.+)[.](?P<expr_label>.+),.+\)', expression.subformula)
|
|
if if_other_expr_match:
|
|
totals_by_code[if_other_expr_match['line_code']].add(if_other_expr_match['expr_label'])
|
|
|
|
return totals_by_code
|
|
|
|
def _get_matching_tags(self, sign=None):
|
|
""" Returns all the signed account.account.tags records whose name matches any of the formulas of the tax_tags expressions contained in self.
|
|
"""
|
|
tag_expressions = self.filtered(lambda x: x.engine == 'tax_tags')
|
|
if not tag_expressions:
|
|
return self.env['account.account.tag']
|
|
|
|
or_domains = []
|
|
for tag_expression in tag_expressions:
|
|
country = tag_expression.report_line_id.report_id.country_id
|
|
or_domains.append(self.env['account.account.tag']._get_tax_tags_domain(tag_expression.formula, country.id, sign))
|
|
|
|
return self.env['account.account.tag'].with_context(active_test=False, lang='en_US').search(osv.expression.OR(or_domains))
|
|
|
|
@api.model
|
|
def _get_tags_create_vals(self, tag_name, country_id, existing_tag=None):
|
|
"""
|
|
We create the plus and minus tags with tag_name.
|
|
In case there is an existing_tag (which can happen if we deleted its unused complement sign)
|
|
we only recreate the missing sign.
|
|
"""
|
|
minus_tag_vals = {
|
|
'name': '-' + tag_name,
|
|
'applicability': 'taxes',
|
|
'tax_negate': True,
|
|
'country_id': country_id,
|
|
}
|
|
plus_tag_vals = {
|
|
'name': '+' + tag_name,
|
|
'applicability': 'taxes',
|
|
'tax_negate': False,
|
|
'country_id': country_id,
|
|
}
|
|
res = []
|
|
if not existing_tag or not existing_tag.tax_negate:
|
|
res.append(minus_tag_vals)
|
|
if not existing_tag or existing_tag.tax_negate:
|
|
res.append(plus_tag_vals)
|
|
return res
|
|
|
|
def _get_carryover_target_expression(self, options):
|
|
self.ensure_one()
|
|
|
|
if self.carryover_target:
|
|
line_code, expr_label = self.carryover_target.split('.')
|
|
return self.env['account.report.expression'].search([
|
|
('report_line_id.code', '=', line_code),
|
|
('label', '=', expr_label),
|
|
('report_line_id.report_id', '=', self.report_line_id.report_id.id),
|
|
])
|
|
|
|
main_expr_label = re.sub("^_carryover_", '', self.label)
|
|
target_label = '_applied_carryover_%s' % main_expr_label
|
|
auto_chosen_target = self.report_line_id.expression_ids.filtered(lambda x: x.label == target_label)
|
|
|
|
if not auto_chosen_target:
|
|
raise UserError(_("Could not determine carryover target automatically for expression %s.", self.label))
|
|
|
|
return auto_chosen_target
|
|
|
|
|
|
class AccountReportColumn(models.Model):
|
|
_name = "account.report.column"
|
|
_description = "Accounting Report Column"
|
|
_order = 'sequence, id'
|
|
|
|
name = fields.Char(string="Name", translate=True, required=True)
|
|
expression_label = fields.Char(string="Expression Label", required=True)
|
|
sequence = fields.Integer(string="Sequence")
|
|
report_id = fields.Many2one(string="Report", comodel_name='account.report')
|
|
sortable = fields.Boolean(string="Sortable")
|
|
figure_type = fields.Selection(string="Figure Type", selection=FIGURE_TYPE_SELECTION_VALUES, default="monetary", required=True)
|
|
blank_if_zero = fields.Boolean(string="Blank if Zero", help="When checked, 0 values will not show in this column.")
|
|
custom_audit_action_id = fields.Many2one(string="Custom Audit Action", comodel_name="ir.actions.act_window")
|
|
|
|
|
|
class AccountReportExternalValue(models.Model):
|
|
_name = "account.report.external.value"
|
|
_description = 'Accounting Report External Value'
|
|
_check_company_auto = True
|
|
_order = 'date, id'
|
|
|
|
name = fields.Char(required=True)
|
|
value = fields.Float(string="Numeric Value")
|
|
text_value = fields.Char(string="Text Value")
|
|
date = fields.Date(required=True)
|
|
|
|
target_report_expression_id = fields.Many2one(string="Target Expression", comodel_name="account.report.expression", required=True, ondelete="cascade")
|
|
target_report_line_id = fields.Many2one(string="Target Line", related="target_report_expression_id.report_line_id")
|
|
target_report_expression_label = fields.Char(string="Target Expression Label", related="target_report_expression_id.label")
|
|
report_country_id = fields.Many2one(string="Country", related='target_report_line_id.report_id.country_id')
|
|
|
|
company_id = fields.Many2one(string='Company', comodel_name='res.company', required=True, default=lambda self: self.env.company)
|
|
|
|
foreign_vat_fiscal_position_id = fields.Many2one(
|
|
string="Fiscal position",
|
|
comodel_name='account.fiscal.position',
|
|
domain="[('country_id', '=', report_country_id), ('foreign_vat', '!=', False)]",
|
|
check_company=True,
|
|
help="The foreign fiscal position for which this external value is made.",
|
|
)
|
|
|
|
# Carryover fields
|
|
carryover_origin_expression_label = fields.Char(string="Origin Expression Label")
|
|
carryover_origin_report_line_id = fields.Many2one(string="Origin Line", comodel_name='account.report.line')
|
|
|
|
@api.constrains('foreign_vat_fiscal_position_id', 'target_report_expression_id')
|
|
def _check_fiscal_position(self):
|
|
for record in self:
|
|
if record.foreign_vat_fiscal_position_id and record.foreign_vat_fiscal_position_id.country_id != record.report_country_id:
|
|
raise ValidationError(_("The country set on the foreign VAT fiscal position must match the one set on the report."))
|