allegro · adrianmroz-allegro · Feb 17, 2022 · Feb 14, 2022 · Feb 14, 2022 · Feb 17, 2022
@@ -24,6 +24,7 @@ import { DateRange } from "../../../common/models/date-range/date-range";
 import { canBucketByDefault, Dimension } from "../../../common/models/dimension/dimension";
 import { findDimensionByName } from "../../../common/models/dimension/dimensions";
 import {
+  BooleanFilterClause,
   FilterClause,
   FixedTimeFilterClause,
   NumberFilterClause,
@@ -99,6 +100,8 @@ function getFilterFromDatum(splits: Splits, dataPath: Datum[]): List<FilterClaus
     const segment: any = datum[reference];
 
     switch (type) {
+      case SplitType.boolean:
+        return new BooleanFilterClause({ reference, values: Set.of(segment) });
       case SplitType.number:
         return new NumberFilterClause({ reference, values: List.of(segment) });
       case SplitType.time:

@@ -19,7 +19,12 @@ import { List } from "immutable";
 import { NumberRange, TimeRange } from "plywood";
 import { EssenceFixtures } from "../../../../common/models/essence/essence.fixtures";
 import { FilterClause } from "../../../../common/models/filter-clause/filter-clause";
-import { numberRange, stringIn, timeRange } from "../../../../common/models/filter-clause/filter-clause.fixtures";
+import {
+  boolean,
+  numberRange,
+  stringIn,
+  timeRange
+} from "../../../../common/models/filter-clause/filter-clause.fixtures";
 import { getFilterFromDatum } from "./filter-for-datum";
 
 describe("getFilterForDatum", () => {
@@ -28,14 +33,14 @@ describe("getFilterForDatum", () => {
     const datum = {
       __nest: 4,
       channel: "foobar",
-      isRobot: "bazz",
+      isRobot: "true",
       commentLength: new NumberRange({ start: 42, end: 71 }),
       time: new TimeRange({ start: new Date(0), end: new Date(10000) })
     };
     const list = getFilterFromDatum(splits, datum);
     expect(list).to.deep.equal(List.of<FilterClause>(
       stringIn("channel", ["foobar"]),
-      stringIn("isRobot", ["bazz"]),
+      boolean("isRobot", ["true"]),
       numberRange("commentLength", 42, 71),
       timeRange("time", new Date(0), new Date(10000))
     ));

@@ -16,7 +16,15 @@
 import { List, Set } from "immutable";
 import { PseudoDatum } from "plywood";
 import { DateRange } from "../../../../common/models/date-range/date-range";
-import { FilterClause, FixedTimeFilterClause, NumberFilterClause, NumberRange, StringFilterAction, StringFilterClause } from "../../../../common/models/filter-clause/filter-clause";
+import {
+  BooleanFilterClause,
+  FilterClause,
+  FixedTimeFilterClause,
+  NumberFilterClause,
+  NumberRange,
+  StringFilterAction,
+  StringFilterClause
+} from "../../../../common/models/filter-clause/filter-clause";
 import { SplitType } from "../../../../common/models/split/split";
 import { Splits } from "../../../../common/models/splits/splits";
 
@@ -38,6 +46,8 @@ export function getFilterFromDatum(splits: Splits, flatDatum: PseudoDatum): List
           return new FixedTimeFilterClause({ reference, values: List.of(new DateRange(segment)) });
         case SplitType.string:
           return new StringFilterClause({ reference, action: StringFilterAction.IN, values: Set.of(segment) });
+        case SplitType.boolean:
+          return new BooleanFilterClause({ reference, values: Set.of(segment) });
       }
     });
 

@@ -28,7 +28,7 @@ import { Filter } from "../filter/filter";
 import { EMPTY_SERIES, SeriesList } from "../series-list/series-list";
 import { measureSeries } from "../series/series.fixtures";
 import { SortDirection } from "../sort/sort";
-import { numberSplitCombine, stringSplitCombine, timeSplitCombine } from "../split/split.fixtures";
+import { booleanSplitCombine, numberSplitCombine, stringSplitCombine, timeSplitCombine } from "../split/split.fixtures";
 import { EMPTY_SPLITS, Splits } from "../splits/splits";
 import { TimeShift } from "../time-shift/time-shift";
 import { Essence, EssenceValue, VisStrategy } from "./essence";
@@ -119,7 +119,7 @@ export class EssenceFixtures {
     ];
     const splitCombines = [
       stringSplitCombine("channel", { sort: { reference: "delta", direction: SortDirection.descending }, limit: 50 }),
-      stringSplitCombine("isRobot", { sort: { reference: "delta", direction: SortDirection.descending }, limit: 5 }),
+      booleanSplitCombine("isRobot", { sort: { reference: "delta", direction: SortDirection.descending }, limit: 5 }),
       numberSplitCombine("commentLength", 10, { sort: { reference: "delta", direction: SortDirection.descending }, limit: 5 }),
       timeSplitCombine("time", "PT1H", { sort: { reference: "delta", direction: SortDirection.descending }, limit: null })
     ];

@@ -51,6 +51,22 @@ export function stringSplitCombine(dimension: string, {
   });
 }
 
+export function booleanSplitCombine(dimension: string, {
+  limit = 50,
+  sort: {
+    direction = SortDirection.ascending,
+    period = SeriesDerivation.CURRENT,
+    reference = dimension
+  } = {}
+}: SplitOpts = {}): Split {
+  return new Split({
+    type: SplitType.boolean,
+    reference: dimension,
+    sort: createSort(dimension === reference, { reference, period, direction }),
+    limit
+  });
+}
+
 export function numberSplitCombine(dimension: string, granularity = 100, {
   limit = 50,
   sort: {

@@ -20,14 +20,15 @@ import { Record } from "immutable";
 import { Expression, NumberBucketExpression, TimeBucketExpression } from "plywood";
 import { isTruthy } from "../../utils/general/general";
 import nullableEquals from "../../utils/immutable-utils/nullable-equals";
-import { Dimension } from "../dimension/dimension";
+import { Dimension, DimensionKind } from "../dimension/dimension";
 import { DimensionSort, Sort } from "../sort/sort";
 import { TimeShiftEnv, TimeShiftEnvType } from "../time-shift/time-shift-env";
 
 export enum SplitType {
   number = "number",
   string = "string",
-  time = "time"
+  time = "time",
+  boolean = "boolean"
 }
 
 export type Bucket = number | Duration;
@@ -68,13 +69,15 @@ export function toExpression({ bucket, type }: Split, { expression }: Dimension,
   return expWithShift.performAction(bucketToAction(bucket));
 }
 
-export function kindToType(kind: string): SplitType {
+export function kindToType(kind: DimensionKind): SplitType {
   switch (kind) {
     case "time":
       return SplitType.time;
     case "number":
       return SplitType.number;
-    default:
+    case "boolean":
+      return SplitType.boolean;
+    case "string":
       return SplitType.string;
   }
 }

@@ -40,15 +40,14 @@ export class UrlHashConverterFixtures {
   }
 
   static tableHashVersion4() {
-    return "4/N4IgbglgzgrghgGwgLzgFwgewHYgFwhpwBGCApiADTjTxKoY4DKZaG2A5lPqAMaYIEcAA5QyAJUwB3bngBmiMQF9qGALZlkOCgQCiaXgHoAqgBUAwlRByICNGQ" +
-      "BOsgNqg0AT2E7CEDVYdkcvg+fqq+EnCcZC6gUEQOaMEATAAMAIwArAC0KQCcWWlJpikpeCVlKQB0JSkAWlZk2AAmyenZeQUAzMWl5SXVJfVKALoqbp7ecQ4QnP6BwbwAF" +
-      "pHYZAhWcLyMuAQzVmCIMNH4ziCNIMPU2JiJ8opkY4QTwcSYAmSRc0G7UJKvidQDggji40A4jpcQNdbmCjo8PF5glMZhwvsFhHAOBRqJttgscEQZtxAYdjnhTgApRxkNTu" +
-      "C5XG74BQIZSUcaIgjI2bUALfEAwMQOczLJwbLZYHYgNToJb7UkuEAAPQAggASelQxl3FkPNlPDlQmBqYiONEEfhqDTYNAAGUaHDQiys0KZ9x5kSxMRAcTgCXwnWojRaeG" +
-      "wMEE1FeMGashAzgAlCARiNqFBhEg0F6EZMwSirE1wtgoBKFstsKt1inMH68KBecEmmsiFYs0jHBBjtR8wFxTh69FeEHc9QvNNMMGQInqEg1BBbhkUvDnpyc9yQPmrUXez" +
-      "8/ozK9Xa/MCA27HBm0vvW2O2uIN28Uf+4PVyOsOPJyBp7P8BlFwbQ8bTZ2BabpKFpWra9qOlYHAOJEYa+rOdJ4GkKR7rcB58seTaqOegrtsS163sW95QAOzRDiAz5jsEb" +
-      "4fnOP7eOo2LXhuREhEx0GwUI0weMEAAKphpAAElYUBVmhIB1veJ5ngauFXl2ZA9pKDYkY+qLDm2VEEDRvifiGYYIMmF7TGSrgSYE1LYAOfbSdQchVtK4ktveChhgC4Ckt" +
-      "RKj6t4GhwLAASTuhlnWeamBRu59kOI5PA+X2rl2HKwLeG+zlSh8AUUI8vIhd4cBNA2LR2Q56CxWlDYJe5QJHF52EGn5mWJpCwgzKsTQACJARKCpLCsazOnAGippsTHQDu" +
-      "iTNa1ZBNEwYk2U2ShAA";
+    return "4/N4IgbglgzgrghgGwgLzgFwgewHYgFwhpwBGCApiADTjTxKoY4DKZaG2A5lPqAMaYIEcAA5QyAJUwB3bngBmiMQF9qGALZlkOCgQCiaXgHoAqgBUAwlRByICNGQBOs" +
+      "gNqg0AT2E7CEDVYdkcvg+fqq+EnCcZC6gUEQOaMEATAAMAIwArAC0KQCcWWlJpikpeCVlKQB0JSkAWlZk2AAmyenZeQUAzMWl5SXVJfVKALoqbp7ecQ4QnP6BwbwAFpHYZAh" +
+      "WcLyMuAQzVmCIMNH4ziCNIMPU2JiJ8opkY4QTwcSYAmSRc0G7UJKvidQDggji40A4jpcQNdbmCjo8PF5glMZhwvsFhHAOBRqJttgscEQZtxAYdjnhTgApRxkNTuC5XG74BQI" +
+      "ZSUcaIgjI2bUALfEAwMQOczLJwbLZYHYgNToJb7UkuEAAPQAggASelQxl3FkPNlPDlQmBqYiONEEfhqDTYNAAGUaHDQiys0KZ9x5kSxMRAcTgCXwnWojRaeGwMEE1FeMGash" +
+      "AzgAlCARiNqFBhEg0F6EZMwSirE1wtgoBKFstsKt1inMH68KBecEmmsiFYs0jHBBjtR8wFxTh69FeEHc9QvNNMMGQInqEg1BBbhkUvDngRXu9Pp2C0Xez8/ozK9Xa/MCA27H" +
+      "Bm0vvW2OyAu2Qe5KG1AB80hyAR1hx5OQNPZ/gMouDaGxqmuuVqbpKFpWra9qOlYHAOJEYa+rOdJ4GkKR7rcB58seTaqOegrtsS14QN2eJHv2g7cq+bZjsEn7fnO/7eOo2LEa" +
+      "BxYECxsHwaGQjTB4wQAAqmGkAASVhQFWmEgHW5EnmeBoEVeN53n2j6Uaiw40R+Khfr4P4hmGCDJhe0xkq4MmBNS2ADn28nUHIVbStJLbkQoYYAuApJ0bprlSh8sABJOWHWbZ" +
+      "5qYFGnmOQ4zk8Pq3gNu5dhysC3ifn5GhwIFFCPLyoXeHATQNi0DlOegcV+YlcAeSlRw+XhBqZdliaQsIMyrE0AAiG4SgqSwrGszpwBoqabKx0A7okrXtWQTRMFJdlNkoQA=";
   }
 
   static lineChartVersion2() {

@@ -20,7 +20,7 @@ import { Dimension } from "../../models/dimension/dimension";
 import { findDimensionByName } from "../../models/dimension/dimensions";
 import { SeriesDerivation } from "../../models/series/concrete-series";
 import { DimensionSort, SeriesSort, Sort, SortDirection, SortType } from "../../models/sort/sort";
-import { Split, SplitType } from "../../models/split/split";
+import { kindToType, Split, SplitType } from "../../models/split/split";
 import { isFiniteNumber, isNumber } from "../../utils/general/general";
 
 export interface SplitSortDefinition {
@@ -51,7 +51,11 @@ export interface TimeSplitDefinition extends BaseSplitDefinition {
   granularity: string;
 }
 
-export type SplitDefinition = NumberSplitDefinition | StringSplitDefinition | TimeSplitDefinition;
+export interface BooleanSplitDefinition extends BaseSplitDefinition {
+  type: SplitType.boolean;
+}
+
+export type SplitDefinition = BooleanSplitDefinition | NumberSplitDefinition | StringSplitDefinition | TimeSplitDefinition;
 
 interface SplitDefinitionConversion<In extends SplitDefinition> {
   toSplitCombine(split: In, dimension: Dimension): Split;
@@ -182,7 +186,29 @@ const stringSplitConversion: SplitDefinitionConversion<StringSplitDefinition> =
   }
 };
 
+const booleanSplitConversion: SplitDefinitionConversion<BooleanSplitDefinition> = {
+  fromSplitCombine({ limit, sort, reference }: Split): BooleanSplitDefinition {
+    return {
+      type: SplitType.boolean,
+      dimension: reference,
+      sort: sort && fromSort(sort),
+      limit
+    };
+  },
+
+  toSplitCombine(split: BooleanSplitDefinition, dimension: Dimension): Split {
+    const { limit, sort } = split;
+    return new Split({
+      type: SplitType.boolean,
+      reference: dimension.name,
+      sort: sort && toSort(sort, dimension.name),
+      limit: toLimit(limit, dimension)
+    });
+  }
+};
+
 const splitConversions: { [type in SplitType]: SplitDefinitionConversion<SplitDefinition> } = {
+  boolean: booleanSplitConversion,
   number: numberSplitConversion,
   string: stringSplitConversion,
   time: timeSplitConversion
@@ -200,18 +226,19 @@ export const splitConverter: SplitDefinitionConverter = {
     if (dimension == null) {
       throw new Error(`Dimension ${split.dimension} not found in data cube ${dataCube.name}.`);
     }
-    return splitConversions[split.type].toSplitCombine(split, dimension);
+    return splitConversions[kindToType(dimension.kind)].toSplitCombine(split, dimension);
   },
 
   fromSplitCombine(splitCombine: Split): SplitDefinition {
-    const { bucket } = splitCombine;
-
-    if (bucket instanceof Duration) {
-      return timeSplitConversion.fromSplitCombine(splitCombine);
-    } else if (typeof bucket === "number") {
-      return numberSplitConversion.fromSplitCombine(splitCombine);
-    } else {
-      return stringSplitConversion.fromSplitCombine(splitCombine);
+    switch (splitCombine.type) {
+      case SplitType.boolean:
+        return booleanSplitConversion.fromSplitCombine(splitCombine);
+      case SplitType.number:
+        return numberSplitConversion.fromSplitCombine(splitCombine);
+      case SplitType.string:
+        return stringSplitConversion.fromSplitCombine(splitCombine);
+      case SplitType.time:
+        return timeSplitConversion.fromSplitCombine(splitCombine);
     }
   }
 };