# -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. from odoo import fields, models, _ from odoo.tools import format_date from itertools import groupby from collections import defaultdict MAX_NAME_LENGTH = 50 class AssetsReportCustomHandler(models.AbstractModel): _name = 'account.asset.report.handler' _inherit = 'account.report.custom.handler' _description = 'Assets Report Custom Handler' def _get_custom_display_config(self): return { 'client_css_custom_class': 'depreciation_schedule', 'templates': { 'AccountReportFilters': 'account_asset.DepreciationScheduleFilters', } } def _dynamic_lines_generator(self, report, options, all_column_groups_expression_totals, warnings=None): report = self._with_context_company2code2account(report) lines, totals_by_column_group = self._generate_report_lines_without_grouping(report, options) # add the groups by account if options['assets_groupby_account']: lines = self._group_by_account(report, lines, options) else: lines = report._regroup_lines_by_name_prefix(options, lines, '_report_expand_unfoldable_line_assets_report_prefix_group', 0) # add the total line total_columns = [] for column_data in options['columns']: col_value = totals_by_column_group[column_data['column_group_key']].get(column_data['expression_label']) col_value = col_value if column_data.get('figure_type') == 'monetary' else '' total_columns.append(report._build_column_dict(col_value, column_data, options=options)) if lines: lines.append({ 'id': report._get_generic_line_id(None, None, markup='total'), 'level': 1, 'name': _('Total'), 'columns': total_columns, 'unfoldable': False, 'unfolded': False, }) return [(0, line) for line in lines] def _generate_report_lines_without_grouping(self, report, options, prefix_to_match=None, parent_id=None, forced_account_id=None): # construct a dictionary: # {(account_id, asset_id): {col_group_key: {expression_label_1: value, expression_label_2: value, ...}}} all_asset_ids = set() all_lines_data = {} for column_group_key, column_group_options in report._split_options_per_column_group(options).items(): # the lines returned are already sorted by account_id! lines_query_results = self._query_lines(column_group_options, prefix_to_match=prefix_to_match, forced_account_id=forced_account_id) for account_id, asset_id, cols_by_expr_label in lines_query_results: line_id = (account_id, asset_id) all_asset_ids.add(asset_id) if line_id not in all_lines_data: all_lines_data[line_id] = {column_group_key: []} all_lines_data[line_id][column_group_key] = cols_by_expr_label column_names = [ 'assets_date_from', 'assets_plus', 'assets_minus', 'assets_date_to', 'depre_date_from', 'depre_plus', 'depre_minus', 'depre_date_to', 'balance' ] totals_by_column_group = defaultdict(lambda: dict.fromkeys(column_names, 0.0)) # Browse all the necessary assets in one go, to minimize the number of queries assets_cache = {asset.id: asset for asset in self.env['account.asset'].browse(all_asset_ids)} # construct the lines, 1 at a time lines = [] company_currency = self.env.company.currency_id column_expression = self.env['account.report.expression'] for (account_id, asset_id), col_group_totals in all_lines_data.items(): all_columns = [] for column_data in options['columns']: col_group_key = column_data['column_group_key'] expr_label = column_data['expression_label'] if col_group_key not in col_group_totals or expr_label not in col_group_totals[col_group_key]: all_columns.append(report._build_column_dict(None, None)) continue col_value = col_group_totals[col_group_key][expr_label] col_data = None if col_value is None else column_data all_columns.append(report._build_column_dict(col_value, col_data, options=options, column_expression=column_expression, currency=company_currency)) # add to the total line if column_data['figure_type'] == 'monetary': totals_by_column_group[column_data['column_group_key']][column_data['expression_label']] += col_value name = assets_cache[asset_id].name line = { 'id': report._get_generic_line_id('account.asset', asset_id, parent_line_id=parent_id), 'level': 2, 'name': name, 'columns': all_columns, 'unfoldable': False, 'unfolded': False, 'caret_options': 'account_asset_line', 'assets_account_id': account_id, } if parent_id: line['parent_id'] = parent_id if len(name) >= MAX_NAME_LENGTH: line['title_hover'] = name lines.append(line) return lines, totals_by_column_group def _caret_options_initializer(self): # Use 'caret_option_open_record_form' defined in account_reports rather than a custom function return { 'account_asset_line': [ {'name': _("Open Asset"), 'action': 'caret_option_open_record_form'}, ] } def _custom_options_initializer(self, report, options, previous_options=None): super()._custom_options_initializer(report, options, previous_options=previous_options) column_group_options_map = report._split_options_per_column_group(options) for col in options['columns']: column_group_options = column_group_options_map[col['column_group_key']] # Dynamic naming of columns containing dates if col['expression_label'] == 'balance': col['name'] = '' # The column label will be displayed in the subheader if col['expression_label'] in ['assets_date_from', 'depre_date_from']: col['name'] = format_date(self.env, column_group_options['date']['date_from']) elif col['expression_label'] in ['assets_date_to', 'depre_date_to']: col['name'] = format_date(self.env, column_group_options['date']['date_to']) options['custom_columns_subheaders'] = [ {"name": _("Characteristics"), "colspan": 4}, {"name": _("Assets"), "colspan": 4}, {"name": _("Depreciation"), "colspan": 4}, {"name": _("Book Value"), "colspan": 1} ] # Group by account by default groupby_activated = (previous_options or {}).get('assets_groupby_account', True) options['assets_groupby_account'] = groupby_activated # If group by account is activated, activate the hierarchy (which will group by account group as well) if # the company has at least one account group, otherwise only group by account has_account_group = self.env['account.group'].search_count([('company_id', '=', self.env.company.id)], limit=1) hierarchy_activated = (previous_options or {}).get('hierarchy', True) options['hierarchy'] = has_account_group and hierarchy_activated or False def _with_context_company2code2account(self, report): if self.env.context.get('company2code2account') is not None: return report company2code2account = defaultdict(dict) for account in self.env['account.account'].search([]): company2code2account[account.company_id.id][account.code] = account return report.with_context(company2code2account=company2code2account) def _query_lines(self, options, prefix_to_match=None, forced_account_id=None): """ Returns a list of tuples: [(asset_id, account_id, [{expression_label: value}])] """ lines = [] asset_lines = self._query_values(options, prefix_to_match=prefix_to_match, forced_account_id=forced_account_id) # Assign the gross increases sub assets to their main asset (parent) parent_lines = [] children_lines = defaultdict(list) for al in asset_lines: if al['parent_id']: children_lines[al['parent_id']] += [al] else: parent_lines += [al] for al in parent_lines: # Compute the depreciation rate string if al['asset_method'] == 'linear' and al['asset_method_number']: # some assets might have 0 depreciations because they dont lose value total_months = int(al['asset_method_number']) * int(al['asset_method_period']) months = total_months % 12 years = total_months // 12 asset_depreciation_rate = " ".join(part for part in [ years and _("%s y", years), months and _("%s m", months), ] if part) elif al['asset_method'] == 'linear': asset_depreciation_rate = '0.00 %' else: asset_depreciation_rate = ('{:.2f} %').format(float(al['asset_method_progress_factor']) * 100) # Manage the opening of the asset opening = (al['asset_acquisition_date'] or al['asset_date']) < fields.Date.to_date(options['date']['date_from']) # Get the main values of the board for the asset depreciation_opening = al['depreciated_before'] depreciation_add = al['depreciated_during'] depreciation_minus = 0.0 asset_disposal_value = al['asset_disposal_value'] if al['asset_disposal_date'] and al['asset_disposal_date'] <= fields.Date.to_date(options['date']['date_to']) else 0.0 asset_opening = al['asset_original_value'] if opening else 0.0 asset_add = 0.0 if opening else al['asset_original_value'] asset_minus = 0.0 asset_salvage_value = al.get('asset_salvage_value', 0.0) # Add the main values of the board for all the sub assets (gross increases) for child in children_lines[al['asset_id']]: depreciation_opening += child['depreciated_before'] depreciation_add += child['depreciated_during'] opening = (child['asset_acquisition_date'] or child['asset_date']) < fields.Date.to_date(options['date']['date_from']) asset_opening += child['asset_original_value'] if opening else 0.0 asset_add += 0.0 if opening else child['asset_original_value'] # Compute the closing values asset_closing = asset_opening + asset_add - asset_minus depreciation_closing = depreciation_opening + depreciation_add - depreciation_minus al_currency = self.env['res.currency'].browse(al['asset_currency_id']) # Manage the closing of the asset if ( al['asset_state'] == 'close' and al['asset_disposal_date'] and al['asset_disposal_date'] <= fields.Date.to_date(options['date']['date_to']) and al_currency.compare_amounts(depreciation_closing, asset_closing - asset_salvage_value) == 0 ): depreciation_add -= asset_disposal_value depreciation_minus += depreciation_closing - asset_disposal_value depreciation_closing = 0.0 asset_minus += asset_closing asset_closing = 0.0 # Manage negative assets (credit notes) if al['asset_original_value'] < 0: asset_add, asset_minus = -asset_minus, -asset_add depreciation_add, depreciation_minus = -depreciation_minus, -depreciation_add # Format the data columns_by_expr_label = { "acquisition_date": al["asset_acquisition_date"] and format_date(self.env, al["asset_acquisition_date"]) or "", # Characteristics "first_depreciation": al["asset_date"] and format_date(self.env, al["asset_date"]) or "", "method": (al["asset_method"] == "linear" and _("Linear")) or (al["asset_method"] == "degressive" and _("Declining")) or _("Dec. then Straight"), "duration_rate": asset_depreciation_rate, "assets_date_from": asset_opening, "assets_plus": asset_add, "assets_minus": asset_minus, "assets_date_to": asset_closing, "depre_date_from": depreciation_opening, "depre_plus": depreciation_add, "depre_minus": depreciation_minus, "depre_date_to": depreciation_closing, "balance": asset_closing - depreciation_closing, } lines.append((al['account_id'], al['asset_id'], columns_by_expr_label)) return lines def _group_by_account(self, report, lines, options): """ This function adds the grouping lines on top of each group of account.asset It iterates over the lines, change the line_id of each line to include the account.account.id and the account.asset.id. """ if not lines: return lines line_vals_per_account_id = {} for line in lines: parent_account_id = line.get('assets_account_id') model, res_id = report._get_model_info_from_id(line['id']) assert model == 'account.asset' # replace the line['id'] to add the account.account.id line['id'] = report._build_line_id([ (None, 'account.account', parent_account_id), (None, 'account.asset', res_id) ]) line_vals_per_account_id.setdefault(parent_account_id, { # We don't assign a name to the line yet, so that we can batch the browsing of account.account objects 'id': report._build_line_id([(None, 'account.account', parent_account_id)]), 'columns': [], # Filled later 'unfoldable': True, 'unfolded': options.get('unfold_all', False), 'level': 1, # This value is stored here for convenience; it will be removed from the result 'group_lines': [], })['group_lines'].append(line) # Generate the result idx_monetary_columns = [idx_col for idx_col, col in enumerate(options['columns']) if col['figure_type'] == 'monetary'] accounts = self.env['account.account'].browse(line_vals_per_account_id.keys()) rslt_lines = [] for account in accounts: account_line_vals = line_vals_per_account_id[account.id] account_line_vals['name'] = f"{account.code} {account.name}" rslt_lines.append(account_line_vals) group_totals = {column_index: 0 for column_index in idx_monetary_columns} group_lines = report._regroup_lines_by_name_prefix( options, account_line_vals.pop('group_lines'), '_report_expand_unfoldable_line_assets_report_prefix_group', account_line_vals['level'], parent_line_dict_id=account_line_vals['id'], ) for account_subline in group_lines: # Add this line to the group totals for column_index in idx_monetary_columns: group_totals[column_index] += account_subline['columns'][column_index].get('no_format', 0) # Setup the parent and add the line to the result account_subline['parent_id'] = account_line_vals['id'] rslt_lines.append(account_subline) # Add totals (columns) to the account line for column_index in range(len(options['columns'])): account_line_vals['columns'].append(report._build_column_dict( group_totals.get(column_index, ''), options['columns'][column_index], options=options, )) return rslt_lines def _query_values(self, options, prefix_to_match=None, forced_account_id=None): "Get the data from the database" self.env['account.move.line'].check_access_rights('read') self.env['account.asset'].check_access_rights('read') move_filter = f"""move.state {"!= 'cancel'" if options.get('all_entries') else "= 'posted'"}""" query_params = { 'date_to': options['date']['date_to'], 'date_from': options['date']['date_from'], 'company_ids': tuple(self.env['account.report'].get_report_company_ids(options)), 'include_draft': options.get('all_entries', False), } prefix_query = '' if prefix_to_match: prefix_query = "AND asset.name ILIKE %(prefix_to_match)s" query_params['prefix_to_match'] = f"{prefix_to_match}%" account_query = '' if forced_account_id: account_query = "AND account.id = %(forced_account_id)s" query_params['forced_account_id'] = forced_account_id analytical_query = '' analytic_account_ids = [] if options.get('analytic_accounts') and not any(x in options.get('analytic_accounts_list', []) for x in options['analytic_accounts']): analytic_account_ids += [[str(account_id) for account_id in options['analytic_accounts']]] if options.get('analytic_accounts_list'): analytic_account_ids += [[str(account_id) for account_id in options.get('analytic_accounts_list')]] if analytic_account_ids: analytical_query = r"""AND %(analytic_account_ids)s && regexp_split_to_array(jsonb_path_query_array(asset.analytic_distribution, '$.keyvalue()."key"')::text, '\D+')""" query_params['analytic_account_ids'] = analytic_account_ids sql = f""" SELECT asset.id AS asset_id, asset.parent_id AS parent_id, asset.name AS asset_name, asset.original_value AS asset_original_value, asset.currency_id AS asset_currency_id, COALESCE(asset.salvage_value, 0) as asset_salvage_value, MIN(move.date) AS asset_date, asset.disposal_date AS asset_disposal_date, asset.acquisition_date AS asset_acquisition_date, asset.method AS asset_method, asset.method_number AS asset_method_number, asset.method_period AS asset_method_period, asset.method_progress_factor AS asset_method_progress_factor, asset.state AS asset_state, asset.company_id AS company_id, account.code AS account_code, account.name AS account_name, account.id AS account_id, COALESCE(SUM(move.depreciation_value) FILTER (WHERE move.date < %(date_from)s AND {move_filter}), 0) + COALESCE(asset.already_depreciated_amount_import, 0) AS depreciated_before, COALESCE(SUM(move.depreciation_value) FILTER (WHERE move.date BETWEEN %(date_from)s AND %(date_to)s AND {move_filter}), 0) AS depreciated_during, COALESCE(SUM(move.depreciation_value) FILTER (WHERE move.date BETWEEN %(date_from)s AND %(date_to)s AND {move_filter} AND move.asset_number_days IS NULL), 0) AS asset_disposal_value FROM account_asset AS asset LEFT JOIN account_account AS account ON asset.account_asset_id = account.id LEFT JOIN account_move move ON move.asset_id = asset.id WHERE asset.company_id in %(company_ids)s AND (asset.acquisition_date <= %(date_to)s OR move.date <= %(date_to)s) AND (asset.disposal_date >= %(date_from)s OR asset.disposal_date IS NULL) AND (asset.state not in ('model', 'draft', 'cancelled') OR (asset.state = 'draft' AND %(include_draft)s)) AND asset.active = 't' {prefix_query} {account_query} {analytical_query} GROUP BY asset.id, account.id ORDER BY account.code, asset.acquisition_date, asset.id; """ self._cr.execute(sql, query_params) results = self._cr.dictfetchall() return results def _report_expand_unfoldable_line_assets_report_prefix_group(self, line_dict_id, groupby, options, progress, offset, unfold_all_batch_data=None): matched_prefix = self.env['account.report']._get_prefix_groups_matched_prefix_from_line_id(line_dict_id) report = self.env['account.report'].browse(options['report_id']) lines, _totals_by_column_group = self._generate_report_lines_without_grouping( report, options, prefix_to_match=matched_prefix, parent_id=line_dict_id, forced_account_id=self.env['account.report']._get_res_id_from_line_id(line_dict_id, 'account.account'), ) lines = report._regroup_lines_by_name_prefix( options, lines, '_report_expand_unfoldable_line_assets_report_prefix_group', len(matched_prefix), matched_prefix=matched_prefix, parent_line_dict_id=line_dict_id, ) return { 'lines': lines, 'offset_increment': len(lines), 'has_more': False, } class AssetsReport(models.Model): _inherit = 'account.report' def _get_caret_option_view_map(self): view_map = super()._get_caret_option_view_map() view_map['account.asset.line'] = 'account_asset.view_account_asset_expense_form' return view_map