@sisense/sdk-data 0.11.3

package/dist/dimensional-model/filters/filters.js

@@ -0,0 +1,534 @@
+import { DimensionalElement } from '../base.js';
+import { DateLevels, MetadataTypes } from '../types.js';
+import { Guid } from 'guid-typescript';
+import { create } from '../factory.js';
+import { DimensionalBaseMeasure } from '../measures/measures.js';
+/**
+ * Different text operators that can be used with text filters
+ *
+ * @internal
+ */
+export const TextOperators = {
+    Contains: 'contains',
+    StartsWith: 'startsWith',
+    EndsWith: 'endsWith',
+    Equals: 'equals',
+    DoesntEqual: 'doesntEqual',
+    DoesntStartWith: 'doesntStartWith',
+    DoesntContain: 'doesntContain',
+    DoesntEndWith: 'doesntEndWidth',
+    Like: 'like',
+};
+/**
+ * Different numeric operators that can be used with numeric filters
+ */
+export const NumericOperators = {
+    Equals: 'equals',
+    DoesntEqual: 'doesntEqual',
+    From: 'from',
+    FromNotEqual: 'fromNotEqual',
+    To: 'to',
+    ToNotEqual: 'toNotEqual',
+};
+/**
+ * Different date operators that can be used with date filters
+ *
+ * @internal
+ */
+export const DateOperators = {
+    From: 'from',
+    To: 'to',
+    Last: 'last',
+    Next: 'next',
+    Anchor: 'Anchor',
+};
+/**
+ * Different logical operators that can be used with logical filters
+ *
+ * @internal
+ */
+export const LogicalOperators = {
+    Union: 'or',
+    Intersection: 'and',
+    Exclude: 'exclude',
+};
+/**
+ * Different ranking operators that can be used with ranking filter
+ *
+ * @internal
+ */
+export const RankingOperators = {
+    Top: 'top',
+    Bottom: 'bottom',
+};
+/**
+ * Different filter types
+ *
+ * @internal
+ */
+export const FilterTypes = {
+    logicalAttribute: 'logicalAttribute',
+    members: 'members',
+    exclude: 'exclude',
+    measure: 'measure',
+    ranking: 'ranking',
+    text: 'text',
+    numeric: 'numeric',
+    date: 'date',
+    relativeDate: 'relativeDate',
+};
+// CLASSES
+/**
+ * base implementation for filter classes
+ *
+ * @internal
+ */
+class AbstractFilter extends DimensionalElement {
+    constructor(att, filterType) {
+        super(Guid.create().toString(), MetadataTypes.Filter);
+        this.filterType = filterType;
+        AbstractFilter.checkAttributeSupport(att);
+        this.attribute = att;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.filterType = this.filterType;
+        result.attribute = this.attribute.serializable();
+        return result;
+    }
+    /**
+     * Gets the JAQL representation of this instance
+     *
+     * @param nested - defines whether the JAQL is nested within parent JAQL statement or a root JAQL element
+     */
+    jaql(nested) {
+        const result = this.attribute.jaql(false);
+        const level = this.attribute;
+        if (level.getFormat && level.getFormat() !== undefined) {
+            const granularityJaql = level.translateGranularityToJaql();
+            result.format = {
+                mask: {
+                    [granularityJaql.level]: level.getFormat(),
+                },
+            };
+        }
+        result.jaql.filter = this.filterJaql();
+        if (this.isScope) {
+            result.panel = 'scope';
+        }
+        return nested === true ? result.jaql : result;
+    }
+    static checkAttributeSupport(attribute) {
+        const { granularity } = attribute;
+        if (granularity === DateLevels.Hours ||
+            granularity === DateLevels.MinutesRoundTo30 ||
+            granularity === DateLevels.MinutesRoundTo15) {
+            throw new Error('Filters do not support the next "datetime" levels: Hours, MinutesRoundTo30, MinutesRoundTo15');
+        }
+    }
+}
+/**
+ * @internal
+ */
+export class LogicalAttributeFilter extends AbstractFilter {
+    constructor(filters, operator) {
+        super(filters[0].attribute, FilterTypes.logicalAttribute);
+        this.operator = operator;
+        this.filters = filters;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `${this.operator}_${this.filters.map((f) => f.id).join()}`;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.operator = this.operator;
+        result.filters = this.filters.map((f) => f.serializable());
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        const result = {};
+        result[this.operator] = this.filters.map((f) => f.filterJaql());
+        return result;
+    }
+}
+/**
+ * @internal
+ */
+export class MembersFilter extends AbstractFilter {
+    constructor(attribute, members) {
+        super(attribute, FilterTypes.members);
+        this.members = members !== null && members !== void 0 ? members : [];
+        if (this.members.filter((m) => m === null || m === undefined).length > 0) {
+            throw `MembersFilter of ${attribute.id} - member cannot be null`;
+        }
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `${this.attribute.id}_${this.members.map((m) => m.toString()).join()}`;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.members = this.members;
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        return {
+            members: this.members.map((m) => m.toString()),
+        };
+    }
+}
+/**
+ * @internal
+ */
+export class ExcludeFilter extends AbstractFilter {
+    constructor(filter, input) {
+        super(filter.attribute, FilterTypes.exclude);
+        this.input = input;
+        this.filter = filter;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        let result = `exclude_${this.filter.id}`;
+        if (this.input) {
+            result += '_from_' + this.input.id;
+        }
+        return result;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.filter = this.filter.serializable();
+        if (this.input) {
+            result.input = this.input.serializable();
+        }
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        const result = {};
+        const exclusion = this.filter.filterJaql();
+        if (this.input) {
+            result.filter = this.input.filterJaql();
+            result.filter.filter = { exclude: exclusion };
+        }
+        else {
+            result.exclude = exclusion;
+        }
+        return result;
+    }
+}
+/**
+ * @internal
+ */
+export class DoubleOperatorFilter extends AbstractFilter {
+    constructor(att, filterType, operatorA, valueA, operatorB, valueB) {
+        super(att, filterType);
+        if (operatorA && valueA !== undefined) {
+            this.valueA = valueA;
+            this.operatorA = operatorA;
+        }
+        if (operatorB && valueB !== undefined) {
+            this.operatorB = operatorB;
+            this.valueB = valueB;
+        }
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        let result = `${this.attribute.id}`;
+        if (this.operatorA && this.valueA !== undefined) {
+            result += `_${this.operatorA}:${this.valueA}`;
+        }
+        if (this.operatorB && this.valueB !== undefined) {
+            result += `_${this.operatorB}:${this.valueB}`;
+        }
+        return result;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        if (this.operatorA) {
+            result.operatorA = this.operatorA;
+        }
+        if (this.operatorB) {
+            result.operatorB = this.operatorB;
+        }
+        if (this.valueA !== undefined) {
+            result.valueA = this.valueA;
+        }
+        if (this.valueB !== undefined) {
+            result.valueB = this.valueB;
+        }
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        const result = {};
+        if (this.operatorA && this.valueA !== undefined) {
+            result[this.operatorA] = this.valueA;
+        }
+        if (this.operatorB && this.valueB !== undefined) {
+            result[this.operatorB] = this.valueB;
+        }
+        return result;
+    }
+}
+/**
+ * @internal
+ */
+export class MeasureFilter extends DoubleOperatorFilter {
+    constructor(att, measure, operatorA, valueA, operatorB, valueB) {
+        super(att, FilterTypes.measure, operatorA, valueA, operatorB, valueB);
+        this.measure = measure;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        let result = `${this.attribute.id}_${this.measure.id}`;
+        if (this.operatorA && this.valueA !== undefined) {
+            result += `_${this.operatorA}:${this.valueA}`;
+        }
+        if (this.operatorB && this.valueB !== undefined) {
+            result += `_${this.operatorB}${this.valueB}`;
+        }
+        return result;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.measure = this.measure.serializable();
+        return result;
+    }
+    jaql(nested) {
+        const result = super.jaql(nested);
+        if (this.measure instanceof DimensionalBaseMeasure) {
+            Object.entries(this.measure.jaql().jaql).forEach(([key, value]) => {
+                result.jaql[key] = value;
+            });
+        }
+        return result;
+    }
+}
+/**
+ * @internal
+ */
+export class RankingFilter extends AbstractFilter {
+    constructor(att, measure, operator, count) {
+        super(att, FilterTypes.ranking);
+        this.count = count;
+        this.operator = operator;
+        this.measure = measure;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `${this.operator}_${this.count}_${this.attribute.id}_by_${this.measure.id}`;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.count = this.count;
+        result.operator = this.operator;
+        result.measure = this.measure.serializable();
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        const result = {};
+        result[this.operator] = this.count;
+        result.by = this.measure.jaql(true);
+        return result;
+    }
+}
+/**
+ * @internal
+ */
+export class NumericFilter extends DoubleOperatorFilter {
+    constructor(att, operatorA, valueA, operatorB, valueB) {
+        super(att, FilterTypes.numeric, operatorA, valueA, operatorB, valueB);
+        // if (att.dimension && !MetadataTypes.isTextDimension(att.dimension.type)) {
+        //     throw 'Dimension must be of Text type to be applied with Text filter';
+        // }
+    }
+}
+/**
+ * @internal
+ */
+export class TextFilter extends DoubleOperatorFilter {
+    constructor(att, operator, value) {
+        super(att, FilterTypes.text, operator, value);
+        // if (att.dimension && !MetadataTypes.isTextDimension(att.dimension.type)) {
+        //     throw 'Dimension must be of Text type to be applied with Text filter';
+        // }
+    }
+}
+/**
+ * @internal
+ */
+export class DateRangeFilter extends DoubleOperatorFilter {
+    constructor(l, valueFrom, valueTo) {
+        super(l, FilterTypes.date, DateOperators.From, valueFrom, DateOperators.To, valueTo);
+        if (typeof valueFrom === 'object') {
+            this.valueA = valueFrom.toISOString();
+        }
+        if (typeof valueTo === 'object') {
+            this.valueB = valueTo.toISOString();
+        }
+    }
+    get level() {
+        return this.attribute;
+    }
+    get from() {
+        return this.valueA;
+    }
+    get to() {
+        return this.valueB;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        return super.filterJaql();
+    }
+}
+/**
+ * @internal
+ */
+export class RelativeDateFilter extends AbstractFilter {
+    constructor(l, offset, count, operator, anchor) {
+        super(l, FilterTypes.relativeDate);
+        if (!operator) {
+            operator = DateOperators.Next;
+        }
+        this.anchor = anchor;
+        this.operator = operator;
+        this.offset = offset;
+        this.count = count;
+    }
+    get level() {
+        return this.attribute;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        let result = `${this.level.id}_${this.operator}_${this.offset}_${this.count}`;
+        if (this.anchor) {
+            if (typeof this.anchor === 'string') {
+                result += `_${this.anchor}`;
+            }
+            else if (typeof this.anchor === 'object') {
+                result += `_${this.anchor.toISOString()}`;
+            }
+        }
+        return result;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.offset = this.offset;
+        result.count = this.count;
+        result.operator = this.operator;
+        if (this.anchor) {
+            result.anchor = this.anchor;
+        }
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     *
+     */
+    filterJaql() {
+        const result = {};
+        result[this.operator] = {
+            offset: this.offset,
+            count: this.count,
+        };
+        if (this.anchor) {
+            if (typeof this.anchor === 'string') {
+                result[this.operator].anchor = this.anchor;
+            }
+            else if (typeof this.anchor === 'object') {
+                result[this.operator].anchor = this.anchor.toISOString();
+            }
+        }
+        return result;
+    }
+}
+/**
+ * @param json
+ * @internal
+ */
+export function createFilter(json) {
+    switch (json.filterType) {
+        case FilterTypes.logicalAttribute:
+            return new LogicalAttributeFilter(json.filters.map((f) => createFilter(f)), json.operator);
+            break;
+        case FilterTypes.members:
+            return new MembersFilter(create(json.attribute), json.members);
+            break;
+        case FilterTypes.exclude:
+            return new ExcludeFilter(createFilter(json.filter), json.input && createFilter(json.input));
+            break;
+        case FilterTypes.measure:
+            return new MeasureFilter(create(json.attribute), create(json.measure), json.operatorA, json.valueA, json.operatorB, json.valueB);
+            break;
+        case FilterTypes.ranking:
+            return new RankingFilter(create(json.attribute), create(json.measure), json.operator, json.count);
+            break;
+        case FilterTypes.numeric:
+            return new NumericFilter(create(json.attribute), json.operatorA, json.valueA, json.operatorB, json.valueB);
+            break;
+        case FilterTypes.text:
+            return new TextFilter(create(json.attribute), json.operatorA, json.valueA);
+            break;
+        case FilterTypes.relativeDate:
+            return new RelativeDateFilter(create(json.attribute), json.offset, json.count, json.operator, json.anchor);
+            break;
+        case FilterTypes.date:
+            return new DateRangeFilter(create(json.attribute), json.valueA, json.valueB);
+            break;
+    }
+    throw 'unsupported filter type';
+}