@adaptabletools/adaptable
Version:
Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements
176 lines (175 loc) • 7.61 kB
JavaScript
import { ApiBase } from './ApiBase';
import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
import StringExtensions from '../../Utilities/Extensions/StringExtensions';
import { PredicateInternalApi } from '../Internal/PredicateInternalApi';
import { SystemPredicateDefs } from '../../AdaptableState/Common/AdaptablePredicate';
import { AG_GRID_GROUPED_COLUMN } from '../../Utilities/Constants/GeneralConstants';
import { TreeSelectionState } from '@infinite-table/infinite-react';
const treeSelectionStatesForPredicates = new WeakMap();
export const getTreeSelectionStateForPredicateInputs = (inputs, cache = treeSelectionStatesForPredicates) => {
const treeSelectionState = cache.get(inputs);
if (treeSelectionState) {
return treeSelectionState;
}
const newTreeSelectionState = new TreeSelectionState({
defaultSelection: false,
selectedPaths: inputs,
}, {
treePaths: inputs,
strictCheckPaths: false,
});
cache.set(inputs, newTreeSelectionState);
return newTreeSelectionState;
};
export class PredicateApiImpl extends ApiBase {
constructor(_adaptable) {
super(_adaptable);
this.internalApi = new PredicateInternalApi(_adaptable);
}
getPredicateDefs() {
return this.internalApi.mergeSystemAndCustomPredicates(this.getSystemPredicateDefs(), this.getCustomPredicateDefs());
}
getSystemPredicateDefs() {
return SystemPredicateDefs;
}
getSystemPredicateDefsByModuleScope(moduleScope) {
return SystemPredicateDefs.filter((p) => p.moduleScope.includes(moduleScope));
}
getCustomPredicateDefs() {
const predicateDefsMap = new Map(this.getSystemPredicateDefs().map((p) => [p.id, p]));
const customPredicateDefs = this.getPredicateOptions().customPredicateDefs || [];
return customPredicateDefs
.map((p) => {
if ('extends' in p) {
const foundPredicateDef = predicateDefsMap.get(p.extends);
if (!foundPredicateDef) {
this.logWarn(`Custom predicate with ID '${p.id}' references a missing 'extends' target '${p.extends}'. No such system or custom predicate found.`);
return null;
}
else {
const { extends: _, ...rest } = p;
const result = {
...foundPredicateDef,
...rest,
id: rest.id,
};
predicateDefsMap.set(result.id, result);
return result;
}
}
predicateDefsMap.set(p.id, p);
return p;
})
.filter((p) => p !== null);
}
getPredicateDefsByModuleScope(moduleScope) {
return this.getPredicateDefs().filter((p) => p.moduleScope.includes(moduleScope));
}
getPredicateDefById(predicateId) {
return this.getPredicateDefs().find((predicateDef) => predicateDef.id === predicateId);
}
getSystemPredicateDefById(predicateId) {
return this.getSystemPredicateDefs().find((predicateDef) => predicateDef.id === predicateId);
}
getCustomPredicateDefById(predicateId) {
return this.getCustomPredicateDefs().find((predicateDef) => predicateDef.id === predicateId);
}
predicateToString(predicate) {
const predicateDef = this.getPredicateDefById(predicate.PredicateId);
if (!predicateDef) {
this.logWarn('Cannot find Predicate with Id:' + predicate.PredicateId);
return '[Predicate Not found]';
}
let strPredicate = predicateDef.hasOwnProperty('toString')
? predicateDef.toString({ inputs: predicate.Inputs })
: predicateDef.label;
if ('ColumnId' in predicate) {
strPredicate = `[${predicate.ColumnId}] ${strPredicate}`;
}
return strPredicate;
}
predicatesToString(predicates, logicalOperator = 'AND') {
return predicates
.map((predicate) => this.predicateToString(predicate))
.join(` ${logicalOperator} `);
}
isValidPredicate(predicate) {
if (!predicate) {
return false;
}
const adaptablePredicateDef = this.getPredicateDefById(predicate.PredicateId);
if (!adaptablePredicateDef) {
return false;
}
// not perfect but if there are no inputs - and there should be some - we treat the filter as invalid
if (adaptablePredicateDef.inputs) {
if (ArrayExtensions.IsNullOrEmpty(predicate.Inputs) ||
StringExtensions.IsNullOrEmpty(predicate.Inputs[0])) {
return false;
}
}
return !(['In', 'NotIn'].includes(predicate.PredicateId) &&
ArrayExtensions.IsNullOrEmpty(predicate.Inputs));
}
isEveryPredicateValid(predicates) {
return predicates.every((predicate) => this.isValidPredicate(predicate));
}
handleColumnPredicate(predicate, context, defaultReturn) {
if (!predicate.ColumnId) {
return this.handlePredicate(predicate, context, defaultReturn);
}
const paramsForColumn = {
...context,
column: this.getColumnApi().getColumnWithColumnId(predicate.ColumnId),
// value: params?.node?.data?.[predicate.ColumnId],
value: this.getGridApi().getRawValueFromRowNode(context.node, predicate.ColumnId),
};
if ('oldValue' in paramsForColumn) {
delete paramsForColumn.oldValue;
}
return this.handlePredicate(predicate, paramsForColumn, defaultReturn);
}
handleColumnPredicates(predicates, context, defaultReturn) {
return predicates.every((predicate) => this.handleColumnPredicate(predicate, context, defaultReturn));
}
handlePredicate(predicate, context, defaultReturn) {
if (!predicate) {
return defaultReturn;
}
const predicateDef = this.getPredicateDefById(predicate.PredicateId);
if (predicateDef === undefined) {
return defaultReturn;
}
if (predicateDef.inputs?.some((_, i) => predicate.Inputs?.[i] === undefined || predicate.Inputs?.[i] === '')) {
return defaultReturn;
}
let treeSelectionState;
if (context.column.columnId === AG_GRID_GROUPED_COLUMN && predicate.PredicateId === 'In') {
treeSelectionState = getTreeSelectionStateForPredicateInputs(predicate.Inputs);
}
try {
return predicateDef.handler({
adaptableApi: this.getAdaptableApi(),
inputs: predicate.Inputs,
treeSelectionState,
...context,
});
}
catch (error) {
this.logError(`Error in predicate ${predicateDef.label}`, error);
return false;
}
}
handlePredicates(predicates, params, defaultReturn) {
if (predicates === undefined || predicates === null || predicates?.length === 0) {
return this.handlePredicate(undefined, params, defaultReturn);
}
if (params.predicatesOperator && params.predicatesOperator === 'OR') {
return predicates?.some((p) => this.handlePredicate(p, params, defaultReturn));
}
return predicates?.every((p) => this.handlePredicate(p, params, defaultReturn));
}
useCaseSensitivity(columnId) {
return this.internalApi.shouldUseCaseSensitivePredicates(columnId);
}
}