mirror of https://github.com/OCA/web.git
295 lines
10 KiB
JavaScript
295 lines
10 KiB
JavaScript
/* Copyright 2020 Tecnativa - Alexandre Díaz
|
|
* License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html) */
|
|
|
|
odoo.define("web_pivot_computed_measure.PivotModel", function(require) {
|
|
"use strict";
|
|
|
|
const core = require("web.core");
|
|
const PivotModel = require("web.PivotModel");
|
|
|
|
const _t = core._t;
|
|
|
|
PivotModel.include({
|
|
_computed_measures: [],
|
|
|
|
/**
|
|
* Create a new computed measure
|
|
*
|
|
* @param {String} id
|
|
* @param {String} field1
|
|
* @param {String} field2
|
|
* @param {String} operation
|
|
* @param {String} name
|
|
* @param {String} format
|
|
* @returns a promise
|
|
*/
|
|
createComputedMeasure: function(id, field1, field2, operation, name, format) {
|
|
const measure = _.find(this._computed_measures, item => {
|
|
return (
|
|
item.field1 === field1 &&
|
|
item.field2 === field2 &&
|
|
item.operation === operation
|
|
);
|
|
});
|
|
if (measure) {
|
|
return Promise.resolve();
|
|
}
|
|
const fieldM1 = this.fields[field1];
|
|
const fieldM2 = this.fields[field2];
|
|
const cmId = "__computed_" + id;
|
|
const oper = operation.replace(/m1/g, field1).replace(/m2/g, field2);
|
|
const oper_human = operation
|
|
.replace(
|
|
/m1/g,
|
|
fieldM1.__computed_id ? "(" + fieldM1.string + ")" : fieldM1.string
|
|
)
|
|
.replace(
|
|
/m2/g,
|
|
fieldM2.__computed_id ? "(" + fieldM2.string + ")" : fieldM2.string
|
|
);
|
|
const cmTotal = this._computed_measures.push({
|
|
field1: field1,
|
|
field2: field2,
|
|
operation: oper,
|
|
name: name || oper_human,
|
|
id: cmId,
|
|
format: format,
|
|
});
|
|
|
|
return this._createVirtualMeasure(this._computed_measures[cmTotal - 1]);
|
|
},
|
|
|
|
/**
|
|
* Create and enable a measure based on a 'fake' field
|
|
*
|
|
* @private
|
|
* @param {Object} cmDef
|
|
* @param {List} fields *Optional*
|
|
* @returns a promise
|
|
*/
|
|
_createVirtualMeasure: function(cmDef, fields) {
|
|
const arrFields = fields || this.fields;
|
|
// This is a minimal 'fake' field info
|
|
arrFields[cmDef.id] = {
|
|
// Used to format the value
|
|
type: cmDef.format,
|
|
// Used to print the header name
|
|
string: cmDef.name,
|
|
// Used to know if is a computed measure field
|
|
__computed_id: cmDef.id,
|
|
};
|
|
this.trigger_up("add_measure", {
|
|
id: cmDef.id,
|
|
def: arrFields[cmDef.id],
|
|
});
|
|
return this._activeMeasures([cmDef.field1, cmDef.field2, cmDef.id]);
|
|
},
|
|
|
|
/*
|
|
* @private
|
|
* @param {List of Strings} fields
|
|
*/
|
|
_activeMeasures: function(fields) {
|
|
let needLoad = false;
|
|
for (const field of fields) {
|
|
if (!this._isMeasureEnabled(field)) {
|
|
this.data.measures.push(field);
|
|
needLoad = true;
|
|
}
|
|
}
|
|
if (needLoad) {
|
|
return this._loadData();
|
|
}
|
|
return Promise.resolve();
|
|
},
|
|
|
|
/*
|
|
* @private
|
|
* @param {String} field
|
|
*/
|
|
_isMeasureEnabled: function(field) {
|
|
return _.contains(this.data.measures, field);
|
|
},
|
|
|
|
/**
|
|
* Helper function to add computed measure fields data into a 'subGroupData'
|
|
*
|
|
* @private
|
|
* @param {Object} subGroupData
|
|
*/
|
|
_fillComputedMeasuresData: function(subGroupData) {
|
|
for (const cm of this._computed_measures) {
|
|
if (!this._isMeasureEnabled(cm.id)) return;
|
|
if (subGroupData.__count === 0) {
|
|
subGroupData[cm.id] = false;
|
|
} else {
|
|
// eslint-disable-next-line no-undef
|
|
subGroupData[cm.id] = py.eval(cm.operation, subGroupData);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Fill the groupSubdivisions with the computed measures and their values
|
|
*
|
|
* @override
|
|
*/
|
|
_prepareData: function(group, groupSubdivisions) {
|
|
for (const groupSubdivision of groupSubdivisions) {
|
|
for (const subGroup of groupSubdivision.subGroups) {
|
|
this._fillComputedMeasuresData(subGroup);
|
|
}
|
|
}
|
|
this._super.apply(this, arguments);
|
|
},
|
|
|
|
/**
|
|
* _getGroupSubdivision method invokes the read_group method of the
|
|
* model via rpc and the passed 'fields' argument is the list of
|
|
* measure names that is in this.data.measures, so we remove the
|
|
* computed measures form this.data.measures before calling _super
|
|
* to prevent an exception
|
|
*
|
|
* @override
|
|
*/
|
|
_getGroupSubdivision: function() {
|
|
const computed_measures = [];
|
|
for (let i = 0; i < this.data.measures.length; i++)
|
|
if (this.data.measures[i].startsWith("__computed_")) {
|
|
computed_measures.push(this.data.measures[i]);
|
|
this.data.measures.splice(i, 1);
|
|
i--;
|
|
}
|
|
const res = this._super.apply(this, arguments);
|
|
$.merge(this.data.measures, computed_measures);
|
|
return res;
|
|
},
|
|
|
|
/**
|
|
* Load the computed measures in context. This is used by filters.
|
|
*
|
|
* @override
|
|
*/
|
|
load: function(params) {
|
|
this._computed_measures =
|
|
params.context.pivot_computed_measures ||
|
|
params.computed_measures ||
|
|
[];
|
|
const toActive = [];
|
|
for (const cmDef of this._computed_measures) {
|
|
params.fields[cmDef.id] = {
|
|
type: cmDef.format,
|
|
string: cmDef.name,
|
|
__computed_id: cmDef.id,
|
|
};
|
|
toActive.push(cmDef.field1, cmDef.field2, cmDef.id);
|
|
}
|
|
return this._super(params).then(() => {
|
|
_.defer(() => {
|
|
for (const cmDef of this._computed_measures) {
|
|
this.trigger_up("add_measure", {
|
|
id: cmDef.id,
|
|
def: this.fields[cmDef.id],
|
|
});
|
|
}
|
|
});
|
|
this._activeMeasures(toActive);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Load the computed measures in context. This is used by filters.
|
|
*
|
|
* @override
|
|
*/
|
|
reload: function(handle, params) {
|
|
if ("context" in params) {
|
|
this._computed_measures =
|
|
params.context.pivot_computed_measures ||
|
|
params.computed_measures ||
|
|
[];
|
|
}
|
|
for (const cmDef of this._computed_measures) {
|
|
this._createVirtualMeasure(cmDef);
|
|
}
|
|
const fieldNames = Object.keys(this.fields);
|
|
for (const fieldName of fieldNames) {
|
|
const field = this.fields[fieldName];
|
|
if (field.__computed_id) {
|
|
const cm = _.find(this._computed_measures, {
|
|
id: field.__computed_id,
|
|
});
|
|
if (!cm) {
|
|
delete this.fields[fieldName];
|
|
this.data.measures = _.without(this.data.measures, fieldName);
|
|
this.trigger_up("remove_measure", {
|
|
id: fieldName,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return this._super.apply(this, arguments);
|
|
},
|
|
|
|
/**
|
|
* Add the computed measures to the state. This is used by filters.
|
|
*
|
|
* @override
|
|
*/
|
|
get: function() {
|
|
const res = this._super.apply(this, arguments);
|
|
res.computed_measures = this._computed_measures;
|
|
return res;
|
|
},
|
|
|
|
/**
|
|
* Adds a rule to deny that measures can be disabled if are being used by a computed measure.
|
|
* In the other hand, when enables a measure analyzes it to active all involved measures.
|
|
*
|
|
* @override
|
|
*/
|
|
toggleMeasure: function(field) {
|
|
if (this._isMeasureEnabled(field)) {
|
|
// Measure is disabled
|
|
const umeasures = _.filter(this._computed_measures, item => {
|
|
return item.field1 === field || item.field2 === field;
|
|
});
|
|
if (umeasures.length && this._isMeasureEnabled(umeasures[0].id)) {
|
|
return Promise.reject(
|
|
_t(
|
|
"This measure is currently used by a 'computed measure'. Please, disable the computed measure first."
|
|
)
|
|
);
|
|
}
|
|
} else {
|
|
// Mesaure is enabled
|
|
const toEnable = [];
|
|
const toAnalize = [field];
|
|
while (toAnalize.length) {
|
|
const afield = toAnalize.shift();
|
|
const fieldDef = this.fields[afield];
|
|
if (fieldDef.__computed_id) {
|
|
const cm = _.find(this._computed_measures, {
|
|
id: fieldDef.__computed_id,
|
|
});
|
|
toAnalize.push(cm.field1, cm.field2);
|
|
const toEnableFields = [];
|
|
if (!this.fields[cm.field1].__computed_id) {
|
|
toEnableFields.push(cm.field1);
|
|
}
|
|
if (!this.fields[cm.field2].__computed_id) {
|
|
toEnableFields.push(cm.field2);
|
|
}
|
|
toEnableFields.push(afield);
|
|
toEnable.push(toEnableFields);
|
|
}
|
|
}
|
|
if (toEnable.length) {
|
|
return this._activeMeasures(_.flatten(toEnable.reverse()));
|
|
}
|
|
}
|
|
return this._super.apply(this, arguments);
|
|
},
|
|
});
|
|
});
|