Initial commit
This commit is contained in:
gsinghpal
@@ -0,0 +1,811 @@
|
||||
// Fusion Accounting - Account Report Controller
|
||||
// Copyright (C) 2026 Nexa Systems Inc.
|
||||
|
||||
/* global owl:readonly */
|
||||
|
||||
import { browser } from "@web/core/browser/browser";
|
||||
import { user } from "@web/core/user";
|
||||
import { useService } from "@web/core/utils/hooks";
|
||||
|
||||
import { removeTaxGroupingFromLineId } from "@fusion_accounting/js/util";
|
||||
|
||||
/**
|
||||
* AccountReportController - Core controller managing report data, options,
|
||||
* and server communication. Handles loading report data, applying filters,
|
||||
* managing line expansion/collapse state, and dispatching report actions.
|
||||
*/
|
||||
export class AccountReportController {
|
||||
constructor(action) {
|
||||
this.action = action;
|
||||
this.actionService = useService("action");
|
||||
this.dialog = useService("dialog");
|
||||
this.orm = useService("orm");
|
||||
}
|
||||
|
||||
async load(env) {
|
||||
this.env = env;
|
||||
this.reportOptionsMap = {};
|
||||
this.reportInformationMap = {};
|
||||
this.lastOpenedSectionByReport = {};
|
||||
this.loadingCallNumberByCacheKey = new Proxy(
|
||||
{},
|
||||
{
|
||||
get(target, name) {
|
||||
return name in target ? target[name] : 0;
|
||||
},
|
||||
set(target, name, newValue) {
|
||||
target[name] = newValue;
|
||||
return true;
|
||||
},
|
||||
}
|
||||
);
|
||||
this.actionReportId = this.action.context.report_id;
|
||||
const isOpeningReport = !this.action?.keep_journal_groups_options // true when opening the report, except when coming from the breadcrumb
|
||||
const mainReportOptions = await this.loadReportOptions(this.actionReportId, false, this.action.params?.ignore_session, isOpeningReport);
|
||||
const cacheKey = this.getCacheKey(mainReportOptions['sections_source_id'], mainReportOptions['report_id']);
|
||||
|
||||
// We need the options to be set and saved in order for the loading to work properly
|
||||
this.options = mainReportOptions;
|
||||
this.reportOptionsMap[cacheKey] = mainReportOptions;
|
||||
this.incrementCallNumber(cacheKey);
|
||||
this.options["loading_call_number"] = this.loadingCallNumberByCacheKey[cacheKey];
|
||||
this.saveSessionOptions(mainReportOptions);
|
||||
|
||||
const activeSectionPromise = this.displayReport(mainReportOptions['report_id']);
|
||||
this.preLoadClosedSections();
|
||||
await activeSectionPromise;
|
||||
}
|
||||
|
||||
getCacheKey(sectionsSourceId, reportId) {
|
||||
return `${sectionsSourceId}_${reportId}`
|
||||
}
|
||||
|
||||
incrementCallNumber(cacheKey = null) {
|
||||
if (!cacheKey) {
|
||||
cacheKey = this.getCacheKey(this.options['sections_source_id'], this.options['report_id']);
|
||||
}
|
||||
this.loadingCallNumberByCacheKey[cacheKey] += 1;
|
||||
}
|
||||
|
||||
async displayReport(reportId) {
|
||||
const cacheKey = await this.loadReport(reportId);
|
||||
const options = await this.reportOptionsMap[cacheKey];
|
||||
const informationMap = await this.reportInformationMap[cacheKey];
|
||||
if (
|
||||
options !== undefined
|
||||
&& this.loadingCallNumberByCacheKey[cacheKey] === options["loading_call_number"]
|
||||
&& (this.lastOpenedSectionByReport === {} || this.lastOpenedSectionByReport[options['selected_variant_id']] === options['selected_section_id'])
|
||||
) {
|
||||
// the options gotten from the python correspond to the ones that called this displayReport
|
||||
this.options = options;
|
||||
|
||||
// informationMap might be undefined if the promise has been deleted by another call.
|
||||
// Don't need to set data, the call that deleted it is coming to re-put data
|
||||
if (informationMap !== undefined) {
|
||||
this.data = informationMap;
|
||||
// If there is a specific order for lines in the options, we want to use it by default
|
||||
if (this.areLinesOrdered()) {
|
||||
await this.sortLines();
|
||||
}
|
||||
this.setLineVisibility(this.lines);
|
||||
this.refreshVisibleAnnotations();
|
||||
this.saveSessionOptions(this.options);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
async reload(optionPath, newOptions) {
|
||||
const rootOptionKey = optionPath ? optionPath.split(".")[0] : "";
|
||||
|
||||
/*
|
||||
When reloading the UI after setting an option filter, invalidate the cached options and data of all sections supporting this filter.
|
||||
This way, those sections will be reloaded (either synchronously when the user tries to access them or asynchronously via the preloading
|
||||
feature), and will then use the new filter value. This ensures the filters are always applied consistently to all sections.
|
||||
*/
|
||||
for (const [cacheKey, cachedOptionsPromise] of Object.entries(this.reportOptionsMap)) {
|
||||
let cachedOptions = await cachedOptionsPromise;
|
||||
|
||||
if (rootOptionKey === "" || cachedOptions.hasOwnProperty(rootOptionKey)) {
|
||||
delete this.reportOptionsMap[cacheKey];
|
||||
delete this.reportInformationMap[cacheKey];
|
||||
}
|
||||
}
|
||||
|
||||
this.saveSessionOptions(newOptions); // The new options will be loaded from the session. Saving them now ensures the new filter is taken into account.
|
||||
await this.displayReport(newOptions['report_id']);
|
||||
}
|
||||
|
||||
async preLoadClosedSections() {
|
||||
let sectionLoaded = false;
|
||||
for (const section of this.options['sections']) {
|
||||
// Preload the first non-loaded section we find amongst this report's sections.
|
||||
const cacheKey = this.getCacheKey(this.options['sections_source_id'], section.id);
|
||||
if (section.id != this.options['report_id'] && !this.reportInformationMap[cacheKey]) {
|
||||
await this.loadReport(section.id, true);
|
||||
|
||||
sectionLoaded = true;
|
||||
// Stop iterating and schedule next call. We don't go on in the loop in case the cache is reset and we need to restart preloading.
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let nextCallDelay = (sectionLoaded) ? 100 : 1000;
|
||||
|
||||
const self = this;
|
||||
setTimeout(() => self.preLoadClosedSections(), nextCallDelay);
|
||||
}
|
||||
|
||||
async loadReport(reportId, preloading=false) {
|
||||
const options = await this.loadReportOptions(reportId, preloading, false); // This also sets the promise in the cache
|
||||
const reportToDisplayId = options['report_id']; // Might be different from reportId, in case the report to open uses sections
|
||||
|
||||
const cacheKey = this.getCacheKey(options['sections_source_id'], reportToDisplayId)
|
||||
if (!this.reportInformationMap[cacheKey]) {
|
||||
this.reportInformationMap[cacheKey] = this.orm.call(
|
||||
"account.report",
|
||||
options.readonly_query ? "get_report_information_readonly" : "get_report_information",
|
||||
[
|
||||
reportToDisplayId,
|
||||
options,
|
||||
],
|
||||
{
|
||||
context: this.action.context,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
await this.reportInformationMap[cacheKey];
|
||||
|
||||
if (!preloading) {
|
||||
if (options['sections'].length)
|
||||
this.lastOpenedSectionByReport[options['sections_source_id']] = options['selected_section_id'];
|
||||
}
|
||||
|
||||
return cacheKey;
|
||||
}
|
||||
|
||||
async loadReportOptions(reportId, preloading=false, ignore_session=false, isOpeningReport=false) {
|
||||
const loadOptions = (ignore_session || !this.hasSessionOptions()) ? (this.action.params?.options || {}) : this.sessionOptions();
|
||||
const cacheKey = this.getCacheKey(loadOptions['sections_source_id'] || reportId, reportId);
|
||||
|
||||
if (!(cacheKey in this.loadingCallNumberByCacheKey)) {
|
||||
this.incrementCallNumber(cacheKey);
|
||||
}
|
||||
loadOptions["loading_call_number"] = this.loadingCallNumberByCacheKey[cacheKey];
|
||||
|
||||
loadOptions["is_opening_report"] = isOpeningReport;
|
||||
|
||||
if (!this.reportOptionsMap[cacheKey]) {
|
||||
// The options for this section are not loaded nor loading. Let's load them !
|
||||
|
||||
if (preloading)
|
||||
loadOptions['selected_section_id'] = reportId;
|
||||
else {
|
||||
/* Reopen the last opened section by default (cannot be done through regular caching, because composite reports' options are not
|
||||
cached (since they always reroute). */
|
||||
if (this.lastOpenedSectionByReport[reportId])
|
||||
loadOptions['selected_section_id'] = this.lastOpenedSectionByReport[reportId];
|
||||
}
|
||||
|
||||
this.reportOptionsMap[cacheKey] = this.orm.call(
|
||||
"account.report",
|
||||
"get_options",
|
||||
[
|
||||
reportId,
|
||||
loadOptions,
|
||||
],
|
||||
{
|
||||
context: this.action.context,
|
||||
},
|
||||
);
|
||||
|
||||
// Wait for the result, and check the report hasn't been rerouted to a section or variant; fix the cache if it has
|
||||
let reportOptions = await this.reportOptionsMap[cacheKey];
|
||||
|
||||
// In case of a reroute, also set the cached options into the reroute target's key
|
||||
const loadedOptionsCacheKey = this.getCacheKey(reportOptions['sections_source_id'], reportOptions['report_id']);
|
||||
if (loadedOptionsCacheKey !== cacheKey) {
|
||||
/* We delete the rerouting report from the cache, to avoid redoing this reroute when reloading the cached options, as it would mean
|
||||
route reports can never be opened directly if they open some variant by default.*/
|
||||
delete this.reportOptionsMap[cacheKey];
|
||||
this.reportOptionsMap[loadedOptionsCacheKey] = reportOptions;
|
||||
|
||||
this.loadingCallNumberByCacheKey[loadedOptionsCacheKey] = 1;
|
||||
delete this.loadingCallNumberByCacheKey[cacheKey];
|
||||
return reportOptions;
|
||||
}
|
||||
}
|
||||
|
||||
return this.reportOptionsMap[cacheKey];
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
// Generic data getters
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
get buttons() {
|
||||
return this.options.buttons;
|
||||
}
|
||||
|
||||
get caretOptions() {
|
||||
return this.data.caret_options;
|
||||
}
|
||||
|
||||
get columnHeadersRenderData() {
|
||||
return this.data.column_headers_render_data;
|
||||
}
|
||||
|
||||
get columnGroupsTotals() {
|
||||
return this.data.column_groups_totals;
|
||||
}
|
||||
|
||||
get context() {
|
||||
return this.data.context;
|
||||
}
|
||||
|
||||
get filters() {
|
||||
return this.data.filters;
|
||||
}
|
||||
|
||||
get annotations() {
|
||||
return this.data.annotations;
|
||||
}
|
||||
|
||||
get groups() {
|
||||
return this.data.groups;
|
||||
}
|
||||
|
||||
get lines() {
|
||||
return this.data.lines;
|
||||
}
|
||||
|
||||
get warnings() {
|
||||
return this.data.warnings;
|
||||
}
|
||||
|
||||
get linesOrder() {
|
||||
return this.data.lines_order;
|
||||
}
|
||||
|
||||
get report() {
|
||||
return this.data.report;
|
||||
}
|
||||
|
||||
get visibleAnnotations() {
|
||||
return this.data.visible_annotations;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
// Generic data setters
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
set annotations(value) {
|
||||
this.data.annotations = value;
|
||||
}
|
||||
|
||||
set columnGroupsTotals(value) {
|
||||
this.data.column_groups_totals = value;
|
||||
}
|
||||
|
||||
set lines(value) {
|
||||
this.data.lines = value;
|
||||
this.setLineVisibility(this.lines);
|
||||
}
|
||||
|
||||
set linesOrder(value) {
|
||||
this.data.lines_order = value;
|
||||
}
|
||||
|
||||
set visibleAnnotations(value) {
|
||||
this.data.visible_annotations = value;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
get needsColumnPercentComparison() {
|
||||
return this.options.column_percent_comparison === "growth";
|
||||
}
|
||||
|
||||
get hasCustomSubheaders() {
|
||||
return this.columnHeadersRenderData.custom_subheaders.length > 0;
|
||||
}
|
||||
|
||||
get hasDebugColumn() {
|
||||
return Boolean(this.options.show_debug_column);
|
||||
}
|
||||
|
||||
get hasStringDate() {
|
||||
return "date" in this.options && "string" in this.options.date;
|
||||
}
|
||||
|
||||
get hasVisibleAnnotations() {
|
||||
return Boolean(this.visibleAnnotations.length);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
// Options
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
async _updateOption(operationType, optionPath, optionValue=null, reloadUI=false) {
|
||||
const optionKeys = optionPath.split(".");
|
||||
|
||||
let currentOptionKey = null;
|
||||
let option = this.options;
|
||||
|
||||
while (optionKeys.length > 1) {
|
||||
currentOptionKey = optionKeys.shift();
|
||||
option = option[currentOptionKey];
|
||||
|
||||
if (option === undefined)
|
||||
throw new Error(`Invalid option key in _updateOption(): ${ currentOptionKey } (${ optionPath })`);
|
||||
}
|
||||
|
||||
switch (operationType) {
|
||||
case "update":
|
||||
option[optionKeys[0]] = optionValue;
|
||||
break;
|
||||
case "delete":
|
||||
delete option[optionKeys[0]];
|
||||
break;
|
||||
case "toggle":
|
||||
option[optionKeys[0]] = !option[optionKeys[0]];
|
||||
break;
|
||||
default:
|
||||
throw new Error(`Invalid operation type in _updateOption(): ${ operationType }`);
|
||||
}
|
||||
|
||||
if (reloadUI) {
|
||||
this.incrementCallNumber();
|
||||
await this.reload(optionPath, this.options);
|
||||
}
|
||||
}
|
||||
|
||||
async updateOption(optionPath, optionValue, reloadUI=false) {
|
||||
await this._updateOption('update', optionPath, optionValue, reloadUI);
|
||||
}
|
||||
|
||||
async deleteOption(optionPath, reloadUI=false) {
|
||||
await this._updateOption('delete', optionPath, null, reloadUI);
|
||||
}
|
||||
|
||||
async toggleOption(optionPath, reloadUI=false) {
|
||||
await this._updateOption('toggle', optionPath, null, reloadUI);
|
||||
}
|
||||
|
||||
async switchToSection(reportId) {
|
||||
this.saveSessionOptions({...this.options, 'selected_section_id': reportId});
|
||||
this.displayReport(reportId);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
// Session options
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
sessionOptionsID() {
|
||||
/* Options are stored by action report (so, the report that was targetted by the original action triggering this flow).
|
||||
This allows a more intelligent reloading of the previous options during user navigation (especially concerning sections and variants;
|
||||
you expect your report to open by default the same section as last time you opened it in this http session).
|
||||
*/
|
||||
return `account.report:${ this.actionReportId }:${ user.defaultCompany.id }`;
|
||||
}
|
||||
|
||||
hasSessionOptions() {
|
||||
return Boolean(browser.sessionStorage.getItem(this.sessionOptionsID()))
|
||||
}
|
||||
|
||||
saveSessionOptions(options) {
|
||||
browser.sessionStorage.setItem(this.sessionOptionsID(), JSON.stringify(options));
|
||||
}
|
||||
|
||||
sessionOptions() {
|
||||
return JSON.parse(browser.sessionStorage.getItem(this.sessionOptionsID()));
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
// Lines
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
lineHasDebugData(lineIndex) {
|
||||
return 'debug_popup_data' in this.lines[lineIndex];
|
||||
}
|
||||
|
||||
lineHasGrowthComparisonData(lineIndex) {
|
||||
return Boolean(this.lines[lineIndex].column_percent_comparison_data);
|
||||
}
|
||||
|
||||
isLineAncestorOf(ancestorLineId, lineId) {
|
||||
return lineId.startsWith(`${ancestorLineId}|`);
|
||||
}
|
||||
|
||||
isLineChildOf(childLineId, lineId) {
|
||||
return childLineId.startsWith(`${lineId}|`);
|
||||
}
|
||||
|
||||
isLineRelatedTo(relatedLineId, lineId) {
|
||||
return this.isLineAncestorOf(relatedLineId, lineId) || this.isLineChildOf(relatedLineId, lineId);
|
||||
}
|
||||
|
||||
isNextLineChild(index, lineId) {
|
||||
return index < this.lines.length && this.lines[index].id.startsWith(lineId);
|
||||
}
|
||||
|
||||
isNextLineDirectChild(index, lineId) {
|
||||
return index < this.lines.length && this.lines[index].parent_id === lineId;
|
||||
}
|
||||
|
||||
isTotalLine(lineIndex) {
|
||||
return this.lines[lineIndex].id.includes("|total~~");
|
||||
}
|
||||
|
||||
isLoadMoreLine(lineIndex) {
|
||||
return this.lines[lineIndex].id.includes("|load_more~~");
|
||||
}
|
||||
|
||||
isLoadedLine(lineIndex) {
|
||||
const lineID = this.lines[lineIndex].id;
|
||||
const nextLineIndex = lineIndex + 1;
|
||||
|
||||
return this.isNextLineChild(nextLineIndex, lineID) && !this.isTotalLine(nextLineIndex) && !this.isLoadMoreLine(nextLineIndex);
|
||||
}
|
||||
|
||||
async replaceLineWith(replaceIndex, newLines) {
|
||||
await this.insertLines(replaceIndex, 1, newLines);
|
||||
}
|
||||
|
||||
async insertLinesAfter(insertIndex, newLines) {
|
||||
await this.insertLines(insertIndex + 1, 0, newLines);
|
||||
}
|
||||
|
||||
async insertLines(lineIndex, deleteCount, newLines) {
|
||||
this.lines.splice(lineIndex, deleteCount, ...newLines);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
// Unfolded/Folded lines
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
async unfoldLoadedLine(lineIndex) {
|
||||
const lineId = this.lines[lineIndex].id;
|
||||
let nextLineIndex = lineIndex + 1;
|
||||
|
||||
while (this.isNextLineChild(nextLineIndex, lineId)) {
|
||||
if (this.isNextLineDirectChild(nextLineIndex, lineId)) {
|
||||
const nextLine = this.lines[nextLineIndex];
|
||||
nextLine.visible = true;
|
||||
if (!nextLine.unfoldable && this.isNextLineChild(nextLineIndex + 1, nextLine.id)) {
|
||||
await this.unfoldLine(nextLineIndex);
|
||||
}
|
||||
}
|
||||
nextLineIndex += 1;
|
||||
}
|
||||
return nextLineIndex;
|
||||
}
|
||||
|
||||
async unfoldNewLine(lineIndex) {
|
||||
const options = await this.options;
|
||||
const newLines = await this.orm.call(
|
||||
"account.report",
|
||||
options.readonly_query ? "get_expanded_lines_readonly" : "get_expanded_lines",
|
||||
[
|
||||
this.options['report_id'],
|
||||
this.options,
|
||||
this.lines[lineIndex].id,
|
||||
this.lines[lineIndex].groupby,
|
||||
this.lines[lineIndex].expand_function,
|
||||
this.lines[lineIndex].progress,
|
||||
0,
|
||||
this.lines[lineIndex].horizontal_split_side,
|
||||
],
|
||||
);
|
||||
|
||||
if (this.areLinesOrdered()) {
|
||||
this.updateLinesOrderIndexes(lineIndex, newLines, false)
|
||||
}
|
||||
this.insertLinesAfter(lineIndex, newLines);
|
||||
|
||||
const totalIndex = lineIndex + newLines.length + 1;
|
||||
|
||||
if (this.filters.show_totals && this.lines[totalIndex] && this.isTotalLine(totalIndex))
|
||||
this.lines[totalIndex].visible = true;
|
||||
return totalIndex
|
||||
}
|
||||
|
||||
/**
|
||||
* When unfolding a line of a sorted report, we need to update the linesOrder array by adding the new lines,
|
||||
* which will require subsequent updates on the array.
|
||||
*
|
||||
* - lineOrderValue represents the line index before sorting the report.
|
||||
* @param {Integer} lineIndex: Index of the current line
|
||||
* @param {Array} newLines: Array of lines to be added
|
||||
* @param {Boolean} replaceLine: Useful for the splice of the linesOrder array in case we want to replace some line
|
||||
* example: With the load more, we want to replace the line with others
|
||||
**/
|
||||
updateLinesOrderIndexes(lineIndex, newLines, replaceLine) {
|
||||
let unfoldedLineIndex;
|
||||
// The offset is useful because in case we use 'replaceLineWith' we want to replace the line at index
|
||||
// unfoldedLineIndex with the new lines.
|
||||
const offset = replaceLine ? 0 : 1;
|
||||
for (const [lineOrderIndex, lineOrderValue] of Object.entries(this.linesOrder)) {
|
||||
// Since we will have to add new lines into the linesOrder array, we have to update the index of the lines
|
||||
// having a bigger index than the one we will unfold.
|
||||
// deleteCount of 1 means that a line need to be replaced so the index need to be increase by 1 less than usual
|
||||
if (lineOrderValue > lineIndex) {
|
||||
this.linesOrder[lineOrderIndex] += newLines.length - replaceLine;
|
||||
}
|
||||
// The unfolded line is found, providing a reference for adding children in the 'linesOrder' array.
|
||||
if (lineOrderValue === lineIndex) {
|
||||
unfoldedLineIndex = parseInt(lineOrderIndex)
|
||||
}
|
||||
}
|
||||
|
||||
const arrayOfNewIndex = Array.from({ length: newLines.length }, (dummy, index) => this.linesOrder[unfoldedLineIndex] + index + offset);
|
||||
this.linesOrder.splice(unfoldedLineIndex + offset, replaceLine, ...arrayOfNewIndex);
|
||||
}
|
||||
|
||||
async unfoldLine(lineIndex) {
|
||||
const targetLine = this.lines[lineIndex];
|
||||
let lastLineIndex = lineIndex + 1;
|
||||
|
||||
if (this.isLoadedLine(lineIndex))
|
||||
lastLineIndex = await this.unfoldLoadedLine(lineIndex);
|
||||
else if (targetLine.expand_function) {
|
||||
lastLineIndex = await this.unfoldNewLine(lineIndex);
|
||||
}
|
||||
|
||||
this.setLineVisibility(this.lines.slice(lineIndex + 1, lastLineIndex));
|
||||
targetLine.unfolded = true;
|
||||
this.refreshVisibleAnnotations();
|
||||
|
||||
// Update options
|
||||
if (!this.options.unfolded_lines.includes(targetLine.id))
|
||||
this.options.unfolded_lines.push(targetLine.id);
|
||||
|
||||
this.saveSessionOptions(this.options);
|
||||
}
|
||||
|
||||
foldLine(lineIndex) {
|
||||
const targetLine = this.lines[lineIndex];
|
||||
|
||||
let foldedLinesIDs = new Set([targetLine.id]);
|
||||
let nextLineIndex = lineIndex + 1;
|
||||
|
||||
while (this.isNextLineChild(nextLineIndex, targetLine.id)) {
|
||||
this.lines[nextLineIndex].unfolded = false;
|
||||
this.lines[nextLineIndex].visible = false;
|
||||
|
||||
foldedLinesIDs.add(this.lines[nextLineIndex].id);
|
||||
|
||||
nextLineIndex += 1;
|
||||
}
|
||||
|
||||
targetLine.unfolded = false;
|
||||
|
||||
this.refreshVisibleAnnotations();
|
||||
|
||||
// Update options
|
||||
this.options.unfolded_lines = this.options.unfolded_lines.filter(
|
||||
unfoldedLineID => !foldedLinesIDs.has(unfoldedLineID)
|
||||
);
|
||||
|
||||
this.saveSessionOptions(this.options);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
// Ordered lines
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
linesCurrentOrderByColumn(columnIndex) {
|
||||
if (this.areLinesOrderedByColumn(columnIndex))
|
||||
return this.options.order_column.direction;
|
||||
|
||||
return "default";
|
||||
}
|
||||
|
||||
areLinesOrdered() {
|
||||
return this.linesOrder != null && this.options.order_column != null;
|
||||
}
|
||||
|
||||
areLinesOrderedByColumn(columnIndex) {
|
||||
return this.areLinesOrdered() && this.options.order_column.expression_label === this.options.columns[columnIndex].expression_label;
|
||||
}
|
||||
|
||||
async sortLinesByColumnAsc(columnIndex) {
|
||||
this.options.order_column = {
|
||||
expression_label: this.options.columns[columnIndex].expression_label,
|
||||
direction: "ASC",
|
||||
};
|
||||
|
||||
await this.sortLines();
|
||||
this.saveSessionOptions(this.options);
|
||||
}
|
||||
|
||||
async sortLinesByColumnDesc(columnIndex) {
|
||||
this.options.order_column = {
|
||||
expression_label: this.options.columns[columnIndex].expression_label,
|
||||
direction: "DESC",
|
||||
};
|
||||
|
||||
await this.sortLines();
|
||||
this.saveSessionOptions(this.options);
|
||||
}
|
||||
|
||||
sortLinesByDefault() {
|
||||
delete this.options.order_column;
|
||||
delete this.data.lines_order;
|
||||
|
||||
this.saveSessionOptions(this.options);
|
||||
}
|
||||
|
||||
async sortLines() {
|
||||
this.linesOrder = await this.orm.call(
|
||||
"account.report",
|
||||
"sort_lines",
|
||||
[
|
||||
this.lines,
|
||||
this.options,
|
||||
true,
|
||||
],
|
||||
{
|
||||
context: this.action.context,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
// Annotations
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
async refreshAnnotations() {
|
||||
this.annotations = await this.orm.call("account.report", "get_annotations", [
|
||||
this.action.context.report_id,
|
||||
this.options,
|
||||
]);
|
||||
|
||||
this.refreshVisibleAnnotations();
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
// Visibility
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
refreshVisibleAnnotations() {
|
||||
const visibleAnnotations = new Proxy(
|
||||
{},
|
||||
{
|
||||
get(target, name) {
|
||||
return name in target ? target[name] : [];
|
||||
},
|
||||
set(target, name, newValue) {
|
||||
target[name] = newValue;
|
||||
return true;
|
||||
},
|
||||
}
|
||||
);
|
||||
|
||||
this.lines.forEach((line) => {
|
||||
line["visible_annotations"] = [];
|
||||
const lineWithoutTaxGrouping = removeTaxGroupingFromLineId(line.id);
|
||||
if (line.visible && this.annotations[lineWithoutTaxGrouping]) {
|
||||
for (const index in this.annotations[lineWithoutTaxGrouping]) {
|
||||
const annotation = this.annotations[lineWithoutTaxGrouping][index];
|
||||
visibleAnnotations[lineWithoutTaxGrouping] = [
|
||||
...visibleAnnotations[lineWithoutTaxGrouping],
|
||||
{ ...annotation },
|
||||
];
|
||||
line["visible_annotations"].push({
|
||||
...annotation,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
line.visible_annotations &&
|
||||
(!this.annotations[lineWithoutTaxGrouping] || !line.visible)
|
||||
) {
|
||||
delete line.visible_annotations;
|
||||
}
|
||||
});
|
||||
|
||||
this.visibleAnnotations = visibleAnnotations;
|
||||
}
|
||||
|
||||
/**
|
||||
Defines which lines should be visible in the provided list of lines (depending on what is folded).
|
||||
**/
|
||||
setLineVisibility(linesToAssign) {
|
||||
let needHidingChildren = new Set();
|
||||
|
||||
linesToAssign.forEach((line) => {
|
||||
line.visible = !needHidingChildren.has(line.parent_id);
|
||||
|
||||
if (!line.visible || (line.unfoldable &! line.unfolded))
|
||||
needHidingChildren.add(line.id);
|
||||
});
|
||||
|
||||
// If the hide 0 lines is activated we will go through the lines to set the visibility.
|
||||
if (this.options.hide_0_lines) {
|
||||
this.hideZeroLines(linesToAssign);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Defines whether the line should be visible depending on its value and the ones of its children.
|
||||
* For parent lines, it's visible if there is at least one child with a value different from zero
|
||||
* or if a child is visible, indicating it's a parent line.
|
||||
* For leaf nodes, it's visible if the value is different from zero.
|
||||
*
|
||||
* By traversing the 'lines' array in reverse, we can set the visibility of the lines easily by keeping
|
||||
* a dict of visible lines for each parent.
|
||||
*
|
||||
* @param {Object} lines - The lines for which we want to determine visibility.
|
||||
*/
|
||||
hideZeroLines(lines) {
|
||||
const hasVisibleChildren = new Set();
|
||||
const reversed_lines = [...lines].reverse()
|
||||
|
||||
const number_figure_types = ['integer', 'float', 'monetary', 'percentage'];
|
||||
reversed_lines.forEach((line) => {
|
||||
const isZero = line.columns.every(column => !number_figure_types.includes(column.figure_type) || column.is_zero);
|
||||
|
||||
// If the line has no visible children and all the columns are equals to zero then the line needs to be hidden
|
||||
if (!hasVisibleChildren.has(line.id) && isZero) {
|
||||
line.visible = false;
|
||||
}
|
||||
|
||||
// If the line has a parent_id and is not hidden then we fill the set 'hasVisibleChildren'. Each parent
|
||||
// will have an array of his visible children
|
||||
if (line.parent_id && line.visible) {
|
||||
// This line allows the initialization of that list.
|
||||
hasVisibleChildren.add(line.parent_id);
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
// Server calls
|
||||
//------------------------------------------------------------------------------------------------------------------
|
||||
async reportAction(ev, action, actionParam = null, callOnSectionsSource = false) {
|
||||
// 'ev' might be 'undefined' if event is not triggered from a button/anchor
|
||||
ev?.preventDefault();
|
||||
ev?.stopPropagation();
|
||||
|
||||
let actionOptions = this.options;
|
||||
if (callOnSectionsSource) {
|
||||
// When calling the sections source, we want to keep track of all unfolded lines of all sections
|
||||
const allUnfoldedLines = this.options.sections.length ? [] : [...this.options['unfolded_lines']]
|
||||
|
||||
for (const sectionData of this.options['sections']) {
|
||||
const cacheKey = this.getCacheKey(this.options['sections_source_id'], sectionData['id']);
|
||||
const sectionOptions = await this.reportOptionsMap[cacheKey];
|
||||
if (sectionOptions)
|
||||
allUnfoldedLines.push(...sectionOptions['unfolded_lines']);
|
||||
}
|
||||
|
||||
actionOptions = {...this.options, unfolded_lines: allUnfoldedLines};
|
||||
}
|
||||
|
||||
const dispatchReportAction = await this.orm.call(
|
||||
"account.report",
|
||||
"dispatch_report_action",
|
||||
[
|
||||
this.options['report_id'],
|
||||
actionOptions,
|
||||
action,
|
||||
actionParam,
|
||||
callOnSectionsSource,
|
||||
],
|
||||
);
|
||||
if (dispatchReportAction?.help) {
|
||||
dispatchReportAction.help = owl.markup(dispatchReportAction.help)
|
||||
}
|
||||
|
||||
return dispatchReportAction ? this.actionService.doAction(dispatchReportAction) : null;
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------------------------------------------
|
||||
// Budget
|
||||
// -----------------------------------------------------------------------------------------------------------------
|
||||
|
||||
async openBudget(budget) {
|
||||
this.actionService.doAction({
|
||||
type: "ir.actions.act_window",
|
||||
res_model: "account.report.budget",
|
||||
res_id: budget.id,
|
||||
views: [[false, "form"]],
|
||||
});
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user