@finos/legend-data-cube
Version:
153 lines • 6.17 kB
JavaScript
/**
* Copyright (c) 2020-present, Goldman Sachs
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { DataCubeDimensionsConfiguration, } from '../../core/model/DataCubeConfiguration.js';
import { DataCubeColumnKind, DataCubeGridMode, } from '../../core/DataCubeQueryEngine.js';
import {} from '../../core/DataCubeSnapshot.js';
import { _findCol, _sortByColName } from '../../core/model/DataCubeColumn.js';
import { DataCubeEditorColumnsSelectorColumnState } from './DataCubeEditorColumnsSelectorState.js';
import { action, computed, makeObservable, observable } from 'mobx';
import { generateEnumerableNameFromToken, guaranteeNonNullable, } from '@finos/legend-shared';
export class DataCubeEditorDimensionState {
name;
isRenaming = false;
columns = [];
constructor(name) {
makeObservable(this, {
name: observable,
setName: action,
isRenaming: observable,
setIsRenaming: action,
columns: observable,
setColumns: action,
});
this.name = name;
}
setName(name) {
this.name = name;
}
setIsRenaming(val) {
this.isRenaming = val;
}
setColumns(columns) {
this.columns = columns;
}
}
export class DataCubeEditorDimensionsPanelState {
_editor;
availableColumnsSearchText = '';
dimensions = [];
dimensionsTreeData = { nodes: [] };
dimensionsTreeSearchText = '';
constructor(editor) {
makeObservable(this, {
availableColumns: computed,
availableColumnsForDisplay: computed,
availableColumnsSearchText: observable,
setAvailableColumnsSearchText: action,
selectedColumns: computed,
deselectColumns: action,
dimensions: observable,
setDimensions: action,
newDimension: action,
dimensionsTreeData: observable.ref,
refreshDimensionsTreeData: action,
dimensionsTreeSearchText: observable,
setDimensionsTreeSearchText: action,
});
this._editor = editor;
}
get availableColumns() {
return this._editor.columnProperties.columns
.filter((column) => column.kind === DataCubeColumnKind.DIMENSION &&
// exclude group-level extended columns
!_findCol(this._editor.groupExtendColumns, column.name) &&
// exclude pivot columns
!_findCol(this._editor.horizontalPivots.selector.selectedColumns, column.name))
.map((col) => new DataCubeEditorColumnsSelectorColumnState(col.name, col.type));
}
get availableColumnsForDisplay() {
return this.availableColumns
.filter((column) => !_findCol(this.selectedColumns, column.name))
.sort(_sortByColName);
}
setAvailableColumnsSearchText(val) {
this.availableColumnsSearchText = val;
}
get selectedColumns() {
return this.dimensions.flatMap((dimension) => dimension.columns);
}
deselectColumns(columns) {
this.dimensions.forEach((dimension) => {
dimension.setColumns(dimension.columns.filter((column) => !_findCol(columns, column.name)));
});
}
setDimensions(dimensions) {
this.dimensions = dimensions;
}
newDimension() {
const newDimension = new DataCubeEditorDimensionState(generateEnumerableNameFromToken(this.dimensions.map((dimension) => dimension.name), 'Dimension', 'whitespace'));
this.dimensions.push(newDimension);
return newDimension;
}
refreshDimensionsTreeData() {
this.dimensionsTreeData = {
nodes: this.dimensions.map((dimension) => ({
name: dimension.name,
data: dimension,
children: dimension.columns.map((column) => ({
name: column.name,
data: column,
})),
})),
};
}
setDimensionsTreeSearchText(val) {
this.dimensionsTreeSearchText = val;
}
adaptPropagatedChanges() {
this.deselectColumns(this.selectedColumns.filter((column) => !_findCol(this.availableColumns, column.name)));
this.refreshDimensionsTreeData();
}
applySnaphot(snapshot, configuration) {
this.setDimensions(configuration.dimensions.dimensions.map((dimension) => {
const _dimension = new DataCubeEditorDimensionState(dimension.name);
_dimension.setColumns(dimension.columns.map((colName) => {
const column = guaranteeNonNullable(_findCol(configuration.columns, colName));
return new DataCubeEditorColumnsSelectorColumnState(column.name, column.type);
}));
return _dimension;
}));
this.refreshDimensionsTreeData();
}
buildSnapshot(newSnapshot, baseSnapshot) {
const dimensionsConfiguration = new DataCubeDimensionsConfiguration();
if (this._editor.generalProperties.configuration.gridMode ===
DataCubeGridMode.MULTIDIMENSIONAL) {
dimensionsConfiguration.dimensions = this.dimensions.map((dimension) => ({
name: dimension.name,
columns: dimension.columns.map((column) => column.name),
}));
newSnapshot.data.configuration = {
...newSnapshot.data.configuration,
dimensions: DataCubeDimensionsConfiguration.serialization.toJson(dimensionsConfiguration),
};
}
else {
newSnapshot = baseSnapshot;
}
}
}
//# sourceMappingURL=DataCubeEditorDimensionsPanelState.js.map