224 lines
8.7 KiB
JavaScript
224 lines
8.7 KiB
JavaScript
odoo.define('web_grid.MockServer', function (require) {
|
|
"use strict";
|
|
|
|
var MockServer = require('web.MockServer');
|
|
|
|
MockServer.include({
|
|
/**
|
|
* @override
|
|
*/
|
|
_performRpc: function (route, args) {
|
|
if (args.method === 'read_grid') {
|
|
return this._mockReadGrid(args.model, args.kwargs);
|
|
} else if (args.method === 'read_grid_grouped') {
|
|
return this._mockReadGridGrouped(args.model, args.kwargs);
|
|
} else if (args.method === 'adjust_grid') {
|
|
var domain = args.args[1];
|
|
var columnField = args.args[2];
|
|
var columnValue = args.args[3];
|
|
var cellField = args.args[4];
|
|
var change = args.args[5];
|
|
var lines = this._mockSearchReadController({
|
|
model: args.model,
|
|
domain: domain,
|
|
fields: [],
|
|
});
|
|
var newID = this._mockCopy(args.model, lines.records[0].id);
|
|
var newRecord = _.findWhere(this.data[args.model].records, {id: newID});
|
|
newRecord[cellField] = change;
|
|
newRecord[columnField] = columnValue.split('/')[0];
|
|
return Promise.resolve({});
|
|
} else {
|
|
return this._super(route, args);
|
|
}
|
|
},
|
|
/**
|
|
* @private
|
|
* @param {string} model
|
|
* @param {Object} kwargs
|
|
* @returns {Promise}
|
|
*/
|
|
_mockReadGrid: function (model, kwargs) {
|
|
var self = this;
|
|
|
|
// various useful dates
|
|
var gridAnchor = moment(kwargs.context.grid_anchor || this.currentDate);
|
|
const currentDate = kwargs.context.grid_anchor ? moment(this.currentDate) : gridAnchor;
|
|
var today = moment();
|
|
var span = kwargs.range.span;
|
|
var start = gridAnchor.clone().startOf(span === 'day' ? 'day' : span === 'week' ? 'isoWeek' : 'month');
|
|
var end = gridAnchor.clone().endOf(span === 'day' ? 'day' : span === 'week' ? 'isoWeek' : 'month');
|
|
var nextAnchor = gridAnchor.clone().add(1, span === 'day' ? 'day' : span === 'week' ? 'weeks' : 'month').format('YYYY-MM-DD');
|
|
var prevAnchor = gridAnchor.clone().subtract(1, span === 'day' ? 'day' : span === 'week' ? 'weeks' : 'month').format('YYYY-MM-DD');
|
|
|
|
// compute columns
|
|
var columns = [];
|
|
var current = start.clone().subtract(1, 'days');
|
|
var unavailable = end.clone().subtract(2, 'days');
|
|
|
|
while (!current.isSame(end, 'days')) {
|
|
current.add(1, 'days');
|
|
var dayStr = current.format('YYYY-MM-DD');
|
|
var nextDayStr = current.clone().add(1, 'days').format('YYYY-MM-DD');
|
|
columns.push({
|
|
is_current: current.isSame(today),
|
|
is_unavailable: unavailable.isSame(current, 'day'),
|
|
domain: ["&", ["date", ">=", dayStr], ["date", "<", nextDayStr]],
|
|
values: {date: [dayStr + '/' + nextDayStr, current.format('ddd,\nMMM\u00a0DD')]}
|
|
});
|
|
}
|
|
|
|
// compute rows
|
|
var rows = [];
|
|
var domain = [
|
|
'&',
|
|
[kwargs.col_field, '>=', start.format('YYYY-MM-DD')],
|
|
[kwargs.col_field, '<=', end.format('YYYY-MM-DD')]
|
|
].concat(kwargs.domain);
|
|
|
|
var groups = this._mockReadGroup(model, {
|
|
domain: domain,
|
|
fields: [kwargs.cell_field],
|
|
groupby: [kwargs.row_fields[0]],
|
|
});
|
|
_.each(groups, function (group) {
|
|
var groupValue = {};
|
|
groupValue[kwargs.row_fields[0]] = group[kwargs.row_fields[0]];
|
|
var groupDomain = ['&'].concat(domain).concat(group.__domain);
|
|
if (kwargs.row_fields[1]) {
|
|
var subGroups = self._mockReadGroup(model, {
|
|
domain: groupDomain,
|
|
fields: [kwargs.cell_field],
|
|
groupby: [kwargs.row_fields[1]],
|
|
});
|
|
_.each(subGroups, function (subGroup) {
|
|
var subGroupDomain = ['&'].concat(groupDomain, subGroup.__domain);
|
|
var values = _.extend({}, groupValue);
|
|
values[kwargs.row_fields[1]] = subGroup[kwargs.row_fields[1]] || false;
|
|
rows.unshift({
|
|
domain: subGroupDomain,
|
|
values: values,
|
|
});
|
|
});
|
|
} else {
|
|
rows.unshift({
|
|
domain: groupDomain,
|
|
values: groupValue,
|
|
});
|
|
}
|
|
});
|
|
|
|
// generate cells
|
|
var grid = [];
|
|
_.each(rows, function (row) {
|
|
var cells = [];
|
|
_.each(columns, function (col) {
|
|
var cellDomain = ['&'].concat(row.domain).concat(col.domain);
|
|
var read_fields = kwargs.readonly_field ? [kwargs.cell_field, kwargs.readonly_field] : [kwargs.cell_field];
|
|
var records = self._mockSearchReadController({
|
|
model: model,
|
|
domain: cellDomain,
|
|
fields: read_fields,
|
|
});
|
|
var value = 0;
|
|
_.each(records.records, function (rec) {
|
|
value += rec[kwargs.cell_field];
|
|
});
|
|
var readonly_dict = {};
|
|
readonly_dict[kwargs.readonly_field] = true;
|
|
cells.push({
|
|
size: records.length,
|
|
value: value,
|
|
is_current: col.is_current,
|
|
is_unavailable: col.is_unavailable,
|
|
readonly: _.isMatch(records.records[0], readonly_dict),
|
|
domain: cellDomain,
|
|
});
|
|
|
|
});
|
|
grid.push(cells);
|
|
});
|
|
|
|
return Promise.resolve({
|
|
cols: columns,
|
|
rows: rows,
|
|
grid: grid,
|
|
prev: {
|
|
default_date: prevAnchor,
|
|
grid_anchor: prevAnchor,
|
|
},
|
|
next: {
|
|
default_date: nextAnchor,
|
|
grid_anchor: nextAnchor,
|
|
},
|
|
initial: {
|
|
default_date: currentDate.format('YYYY-MM-DD'),
|
|
grid_anchor: currentDate.format('YYYY-MM-DD'),
|
|
},
|
|
});
|
|
},
|
|
_mockReadGridGrouped(model, kwargs) {
|
|
const self = this;
|
|
return this._mockReadGridDomain(model, kwargs).then(function (gridDomain) {
|
|
gridDomain = gridDomain.concat(kwargs.domain || []);
|
|
const groups = self._mockReadGroup(model, {
|
|
domain: gridDomain,
|
|
fields: [kwargs.section_field],
|
|
groupby: [kwargs.section_field],
|
|
});
|
|
if (!groups.length) {
|
|
return Promise.all([self._mockReadGrid(model, {
|
|
row_fields: kwargs.row_fields,
|
|
col_field: kwargs.col_field,
|
|
cell_field: kwargs.cell_field,
|
|
domain: kwargs.domain,
|
|
range: kwargs.current_range,
|
|
readonly_field: kwargs.readonly_field,
|
|
context: kwargs.context,
|
|
})]);
|
|
} else {
|
|
return Promise.all((groups || []).map((group) => {
|
|
return self._mockReadGrid(model, {
|
|
row_fields: kwargs.row_fields,
|
|
col_field: kwargs.col_field,
|
|
cell_field: kwargs.cell_field,
|
|
domain: group.__domain,
|
|
range: kwargs.current_range,
|
|
readonly_field: kwargs.readonly_field,
|
|
context: kwargs.context,
|
|
}).then(function (result) {
|
|
result.__label = group[kwargs.section_field];
|
|
return result;
|
|
});
|
|
}));
|
|
}
|
|
});
|
|
},
|
|
/**
|
|
* @TODO: this is not very generic but it works for the tests
|
|
* @private
|
|
* @returns {Promise}
|
|
*/
|
|
_mockReadGridDomain: function (model, kwargs) {
|
|
if (kwargs.context && kwargs.context.grid_anchor && kwargs.current_range && kwargs.current_range.span) {
|
|
var gridAnchor = moment(kwargs.context.grid_anchor || this.currentDate);
|
|
var span = kwargs.current_range.span;
|
|
var start = gridAnchor.clone().startOf(span === 'day' ? 'day' : span === 'week' ? 'isoWeek' : 'month');
|
|
var end = gridAnchor.clone().endOf(span === 'day' ? 'day' : span === 'week' ? 'isoWeek' : 'month');
|
|
|
|
return Promise.resolve([
|
|
'&',
|
|
['date', '>=', start.format('YYYY-MM-DD')],
|
|
['date', '<=', end.format('YYYY-MM-DD')],
|
|
]);
|
|
}
|
|
return Promise.resolve([
|
|
'&',
|
|
['date', '>=', '2017-01-01'],
|
|
['date', '<=', '2017-01-31'],
|
|
]);
|
|
},
|
|
});
|
|
|
|
});
|