gristlabs_grist-core/app/client/models/MetaTableModel.js

252 lines
9.7 KiB
JavaScript
Raw Normal View History

/**
* MetaTableModel maintains the model for a built-in table, with MetaRowModels. It provides
* access to individual row models, as well as to collections of rows in that table.
*/
var _ = require('underscore');
var ko = require('knockout');
var dispose = require('../lib/dispose');
var MetaRowModel = require('./MetaRowModel');
var TableModel = require('./TableModel');
var rowset = require('./rowset');
var assert = require('assert');
var gutil = require('app/common/gutil');
/**
* MetaTableModel maintains observables for one table's rows. It accepts a list of fields to
* include into each RowModel, and an additional constructor to call when constructing RowModels.
* It exposes all rows, as well as groups of rows, as observable collections.
*/
function MetaTableModel(docModel, tableData, fields, rowConstructor) {
TableModel.call(this, docModel, tableData);
this._fields = fields;
this._rowConstructor = rowConstructor;
// Start out with empty list of row models. It's populated in loadData().
this.rowModels = [];
// It is possible for a new rowModel to be deleted and replaced with a new one for the same
// rowId. To allow a computed() to depend on the row version, we keep a permanent observable
// "version" associated with each rowId, which is incremented any time a rowId is replaced.
this._rowModelVersions = [];
// Whenever rowNotify is triggered, also send the action to all row RowModels that we maintain.
this.listenTo(this, 'rowNotify', function(rows, action) {
assert(rows !== rowset.ALL, "Unexpected schema action on a metadata table");
for (let r of rows) {
if (this.rowModels[r]) {
this.rowModels[r].dispatchAction(action);
}
}
});
}
dispose.makeDisposable(MetaTableModel);
_.extend(MetaTableModel.prototype, TableModel.prototype);
/**
* This is called from DocModel as soon as all the MetaTableModel objects have been created.
*/
MetaTableModel.prototype.loadData = function() {
// Whereas user-defined tables may not be initially loaded, MetaTableModels should only exist
// for built-in tables, which *should* already be loaded (and should never be reloaded).
assert(this.tableData.isLoaded, "MetaTableModel: tableData not yet loaded");
// Create and populate the array mapping rowIds to RowModels.
this.getAllRows().forEach(function(rowId) {
this._createRowModel(rowId);
}, this);
};
/**
* Returns an existing or a blank row. Used for `recordRef` descriptor in DocModel.
*
* A computed() that uses getRowModel() may not realize if a rowId gets deleted and later re-used
* for another row. If optDependOnVersion is set, then a dependency on the row version gets
* created automatically. It is only relevant when the computed is pure and may not get updated
* when the row is deleted; in that case lacking such dependency may cause subtle rare bugs.
*/
MetaTableModel.prototype.getRowModel = function(rowId, optDependOnVersion) {
const rowIdModel = this.rowModels[rowId];
const r = rowIdModel || this.getEmptyRowModel();
if (optDependOnVersion) {
// Versions are never deleted, so even if the rowModel is deleted, we still have its version
// in this list.
const version = this._rowModelVersions[rowId];
if (version) {
// Subscribe to updates for rowModel at rowId.
version();
} else {
// It shouldn't happen, but maybe it would be better to add an empty version observable at rowId.
// If it happens, it means we tried to get non existing row (row that wasn't created previously).
}
}
return r;
};
/**
* Returns the RowModel to use for invalid rows.
*/
MetaTableModel.prototype.getEmptyRowModel = function() {
return this._createRowModel(0);
};
/**
* Private helper to create a MetaRowModel for the given rowId. For public use, there are
* getRowModel(rowId) and createFloatingRowModel(rowIdObs).
*/
MetaTableModel.prototype._createRowModel = function(rowId) {
if (!this.rowModels[rowId]) {
// When creating a new row, we create new MetaRowModels which use observables. If
// _createRowModel is called from within the evaluation of a computed(), we do NOT want that
// computed to subscribe to observables used by individual MetaRowModels.
ko.ignoreDependencies(() => {
this.rowModels[rowId] = MetaRowModel.create(this, this._fields, this._rowConstructor, rowId);
// Whenever a rowModel is created, increment its version number.
let inc = this._rowModelVersions[rowId] || (this._rowModelVersions[rowId] = ko.observable(0));
inc(inc.peek() + 1);
});
}
return this.rowModels[rowId];
};
/**
* Returns a MetaRowModel-like object tied to an observable rowId. When the observable changes,
* the fields of the returned model start reflecting the values for the new rowId. See also
* MetaRowModel.Floater docs.
*
* There should be very few such floating rows. If you ever want a set, you should be using
* createAllRowsModel() or createRowGroupModel().
*
* @param {ko.observable} rowIdObs: observable that evaluates to a rowId.
*/
MetaTableModel.prototype.createFloatingRowModel = function(rowIdObs) {
return MetaRowModel.Floater.create(this, rowIdObs);
};
/**
* Override TableModel's _process_RemoveRecord to also remove our reference to this row model.
*/
MetaTableModel.prototype._process_RemoveRecord = function(action, tableId, rowId) {
TableModel.prototype._process_RemoveRecord.apply(this, arguments);
this._deleteRowModel(rowId);
};
/**
* Clean up the RowModel for a row when it's deleted by an action from the server.
*/
MetaTableModel.prototype._deleteRowModel = function(rowId) {
this.rowModels[rowId]._isDeleted(true);
this.rowModels[rowId].dispose();
delete this.rowModels[rowId];
};
/**
* We have to remember to override Bulk versions too.
*/
MetaTableModel.prototype._process_BulkRemoveRecord = function(action, tableId, rowIds) {
TableModel.prototype._process_BulkRemoveRecord.apply(this, arguments);
rowIds.forEach(rowId => this._deleteRowModel(rowId));
};
/**
* Override TableModel's _process_AddRecord to also add a row model for the given rowId.
*/
MetaTableModel.prototype._process_AddRecord = function(action, tableId, rowId, columnValues) {
this._createRowModel(rowId);
TableModel.prototype._process_AddRecord.apply(this, arguments);
};
/**
* We have to remember to override Bulk versions too.
*/
MetaTableModel.prototype._process_BulkAddRecord = function(action, tableId, rowIds, columns) {
rowIds.forEach(rowId => this._createRowModel(rowId));
TableModel.prototype._process_BulkAddRecord.apply(this, arguments);
};
/**
* Override TableModel's applySchemaAction to assert that there are NO metadata schema changes.
*/
MetaTableModel.prototype.applySchemaAction = function(action) {
throw new Error("No schema actions should apply to metadata");
};
/**
* Returns a new observable array (koArray) of MetaRowModels for all the rows in this table,
* sorted by the given column. It is the caller's responsibility to dispose this array.
* @param {string} sortColId: Column ID by which to sort.
*/
MetaTableModel.prototype.createAllRowsModel = function(sortColId) {
return this._createRowSetModel(this, sortColId);
};
/**
* Returns a new observable array (koArray) of MetaRowModels matching the given `groupValue`.
* It is the caller's responsibility to dispose this array.
* @param {String|Number} groupValue - The group value to match.
* @param {String} options.groupBy - RowModel field by which to group.
* @param {String} options.sortBy - RowModel field by which to sort.
*/
MetaTableModel.prototype.createRowGroupModel = function(groupValue, options) {
var grouping = this.getRowGrouping(options.groupBy);
return this._createRowSetModel(grouping.getGroup(groupValue), options.sortBy);
};
/**
* Helper that returns a new observable koArray of MetaRowModels subscribed to the given
* rowSource, and sorted by the given column. It is the caller's responsibility to dispose it.
*/
MetaTableModel.prototype._createRowSetModel = function(rowSource, sortColId) {
var getter = this.tableData.getRowPropFunc(sortColId);
var sortedRowSet = rowset.SortedRowSet.create(null, function(r1, r2) {
return gutil.nativeCompare(getter(r1), getter(r2));
});
sortedRowSet.subscribeTo(rowSource);
// When the returned value is disposed, dispose the underlying SortedRowSet too.
var ret = this._createRowModelArray(sortedRowSet.getKoArray());
ret.autoDispose(sortedRowSet);
return ret;
};
/**
* Helper which takes an observable array (koArray) of rowIds, and returns a new koArray of
* objects having those RowModels as prototypes, and with an additional `_index` observable to
* contain their index in the array. The index is kept correct as the array changes.
*
* TODO: this needs a unittest.
*/
MetaTableModel.prototype._createRowModelArray = function(rowIdArray) {
var ret = rowIdArray.map(this._createRowModelItem, this);
ret.subscribe(function(splice) {
var arr = splice.array, i;
for (i = 0; i < splice.deleted.length; i++) {
splice.deleted[i]._index(null);
}
var delta = splice.added - splice.deleted.length;
if (delta !== 0) {
for (i = splice.start + splice.added; i < arr.length; i++) {
arr[i]._index(i);
}
}
}, null, 'spliceChange');
return ret;
};
/**
* Creates and returns a RowModel with its own `_index` observable.
*/
MetaTableModel.prototype._createRowModelItem = function(rowId, index) {
var rowModel = this._createRowModel(rowId);
assert.ok(rowModel, "MetaTableModel._createRowModelItem called for invalid rowId " + rowId);
var ret = Object.create(rowModel); // New object, with rowModel as its prototype.
ret._index = ko.observable(index); // New _index observable overrides the existing one.
return ret;
};
module.exports = MetaTableModel;