@lumeer/pivot 0.0.1

package/src/lib/util/pivot-data-converter.spec.ts

@@ -0,0 +1,647 @@
+/*
+ * Lumeer: Modern Data Definition and Processing Platform
+ *
+ * Copyright (C) since 2017 Lumeer.io, s.r.o. and/or its affiliates.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+import {AttributesResourceType, Collection, DataAggregationType, DataResource, DocumentModel, DocumentsAndLinksData, LinkInstance, LinkType, Query, UnknownConstraint} from '@lumeer/data-filters';
+
+
+import {PivotDataConverter} from './pivot-data-converter';
+import {LmrPivotConfig, LmrPivotTransform} from './lmr-pivot-config';
+
+const documents: DocumentModel[] = [
+  {collectionId: 'C1', id: 'D1', data: {a1: 'abc'}},
+  {collectionId: 'C1', id: 'D2', data: {a1: 'abc'}},
+  {collectionId: 'C1', id: 'D3', data: {a1: 'def'}},
+
+  {collectionId: 'C2', id: 'D21', data: {a1: 'a'}},
+  {collectionId: 'C2', id: 'D22', data: {a1: 'c'}},
+  {collectionId: 'C2', id: 'D23', data: {a1: 'a'}},
+  {collectionId: 'C2', id: 'D24', data: {a1: 'b'}},
+  {collectionId: 'C2', id: 'D25', data: {a1: 'b'}},
+  {collectionId: 'C2', id: 'D26', data: {a1: 'c'}},
+
+  {collectionId: 'C3', id: 'D31', data: {a1: 'xyz'}},
+  {collectionId: 'C3', id: 'D32', data: {a1: 'xyz'}},
+  {collectionId: 'C3', id: 'D33', data: {a1: 'vuw'}},
+  {collectionId: 'C3', id: 'D34', data: {a1: 'vuw'}},
+  {collectionId: 'C3', id: 'D35', data: {a1: 'vuw'}},
+  {collectionId: 'C3', id: 'D36', data: {a1: 'xyz'}},
+
+  {collectionId: 'C4', id: 'D41', data: {a1: 2, a2: 3}},
+  {collectionId: 'C4', id: 'D42', data: {a1: 4, a2: 0}},
+  {collectionId: 'C4', id: 'D43', data: {a1: 6, a2: -10}},
+  {collectionId: 'C4', id: 'D44', data: {a1: 1, a2: 3}},
+  {collectionId: 'C4', id: 'D45', data: {a1: null, a2: 1}},
+  {collectionId: 'C4', id: 'D46', data: {a1: 2, a2: null}},
+  {collectionId: 'C4', id: 'D47', data: {}},
+  {collectionId: 'C4', id: 'D48', data: {a1: 20, a2: 7}},
+  {collectionId: 'C4', id: 'D49', data: {a1: 11, a2: 9}},
+];
+
+const collections: Collection[] = [
+  {
+    id: 'C1',
+    attributes: [{id: 'a1', name: 'Aaa'}],
+  },
+  {
+    id: 'C2',
+    attributes: [{id: 'a1', name: 'Bbb'}],
+  },
+  {
+    id: 'C3',
+    attributes: [{id: 'a1', name: 'Ccc'}],
+  },
+  {
+    id: 'C4',
+    attributes: [
+      {id: 'a1', name: 'Ddd'},
+      {id: 'a2', name: 'Eee'},
+    ],
+  },
+];
+
+const linkInstances: LinkInstance[] = [
+  {
+    id: 'l121',
+    linkTypeId: 'LT1',
+    documentIds: ['D1', 'D21'],
+    data: {},
+  },
+  {
+    id: 'l122',
+    linkTypeId: 'LT1',
+    documentIds: ['D1', 'D22'],
+    data: {},
+  },
+  {
+    id: 'l123',
+    linkTypeId: 'LT1',
+    documentIds: ['D2', 'D23'],
+    data: {},
+  },
+  {
+    id: 'l124',
+    linkTypeId: 'LT1',
+    documentIds: ['D2', 'D24'],
+    data: {},
+  },
+  {
+    id: 'l125',
+    linkTypeId: 'LT1',
+    documentIds: ['D2', 'D25'],
+    data: {},
+  },
+  {
+    id: 'l126',
+    linkTypeId: 'LT1',
+    documentIds: ['D3', 'D26'],
+    data: {},
+  },
+  {
+    id: 'l2131',
+    linkTypeId: 'LT2',
+    documentIds: ['D21', 'D31'],
+    data: {},
+  },
+  {
+    id: 'l2232',
+    linkTypeId: 'LT2',
+    documentIds: ['D22', 'D32'],
+    data: {},
+  },
+  {
+    id: 'l2233',
+    linkTypeId: 'LT2',
+    documentIds: ['D22', 'D33'],
+    data: {},
+  },
+  {
+    id: 'l2334',
+    linkTypeId: 'LT2',
+    documentIds: ['D23', 'D34'],
+    data: {},
+  },
+  {
+    id: 'l2434',
+    linkTypeId: 'LT2',
+    documentIds: ['D24', 'D34'],
+    data: {},
+  },
+  {
+    id: 'l2534',
+    linkTypeId: 'LT2',
+    documentIds: ['D25', 'D34'],
+    data: {},
+  },
+  {
+    id: 'l2535',
+    linkTypeId: 'LT2',
+    documentIds: ['D25', 'D35'],
+    data: {},
+  },
+  {
+    id: 'l2636',
+    linkTypeId: 'LT2',
+    documentIds: ['D26', 'D36'],
+    data: {},
+  },
+  {
+    id: 'l3141',
+    linkTypeId: 'LT3',
+    documentIds: ['D31', 'D41'],
+    data: {},
+  },
+  {
+    id: 'l3241',
+    linkTypeId: 'LT3',
+    documentIds: ['D32', 'D41'],
+    data: {},
+  },
+  {
+    id: 'l3242',
+    linkTypeId: 'LT3',
+    documentIds: ['D32', 'D42'],
+    data: {},
+  },
+  {
+    id: 'l3342',
+    linkTypeId: 'LT3',
+    documentIds: ['D33', 'D43'],
+    data: {},
+  },
+  {
+    id: 'l3443',
+    linkTypeId: 'LT3',
+    documentIds: ['D34', 'D43'],
+    data: {},
+  },
+  {
+    id: 'l3444',
+    linkTypeId: 'LT3',
+    documentIds: ['D34', 'D44'],
+    data: {},
+  },
+  {
+    id: 'l3545',
+    linkTypeId: 'LT3',
+    documentIds: ['D35', 'D45'],
+    data: {},
+  },
+  {
+    id: 'l3546',
+    linkTypeId: 'LT3',
+    documentIds: ['D35', 'D46'],
+    data: {},
+  },
+  {
+    id: 'l3647',
+    linkTypeId: 'LT3',
+    documentIds: ['D36', 'D47'],
+    data: {},
+  },
+  {
+    id: 'l3648',
+    linkTypeId: 'LT3',
+    documentIds: ['D36', 'D48'],
+    data: {},
+  },
+  {
+    id: 'l3649',
+    linkTypeId: 'LT3',
+    documentIds: ['D36', 'D49'],
+    data: {},
+  },
+];
+
+const linkTypes: LinkType[] = [
+  {
+    id: 'LT1',
+    collectionIds: ['C1', 'C2'],
+    attributes: [],
+  },
+  {
+    id: 'LT2',
+    collectionIds: ['C2', 'C3'],
+    attributes: [],
+  },
+  {
+    id: 'LT3',
+    collectionIds: ['C3', 'C4'],
+    attributes: [],
+  },
+];
+
+const query: Query = {stems: [{collectionId: 'C1', linkTypeIds: ['LT1', 'LT2', 'LT3']}]};
+
+const data: DocumentsAndLinksData = {
+  uniqueLinkInstances: linkInstances,
+  uniqueDocuments: documents,
+  dataByStems: [{stem: query.stems![0], documents, linkInstances}],
+};
+
+describe('Pivot data converter', () => {
+  const transform: LmrPivotTransform = {
+    translateAggregation: type => type.toString(),
+    checkValidConstraintOverride: (c1, c2) => c1,
+  }
+  const dataConverter: PivotDataConverter = new PivotDataConverter();
+
+  it('should return empty data', () => {
+    const config: LmrPivotConfig = {stemsConfigs: [{rowAttributes: [], columnAttributes: [], valueAttributes: []}]};
+    const pivotData = dataConverter.createData(config, transform, collections, linkTypes, data, query);
+    expect(pivotData.data).toEqual([]);
+  });
+
+  it('should return by one row', () => {
+    const config: LmrPivotConfig = {
+      stemsConfigs: [
+        {
+          rowAttributes: [
+            {resourceId: 'C2', resourceType: AttributesResourceType.Collection, attributeId: 'a1', resourceIndex: 2},
+          ],
+          columnAttributes: [],
+          valueAttributes: [],
+        },
+      ],
+    };
+    const pivotData = dataConverter.createData(config, transform, collections, linkTypes, data, query);
+    expect(pivotData.data[0].rowHeaders).toEqual([
+      {
+        title: 'a',
+        targetIndex: 0,
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[1].attributes![0].name,
+      },
+      {
+        title: 'c',
+        targetIndex: 1,
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[1].attributes![0].name,
+      },
+      {
+        title: 'b',
+        targetIndex: 2,
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[1].attributes![0].name,
+      },
+    ]);
+    expect(pivotData.data[0].columnHeaders).toEqual([]);
+    expect(pivotData.data[0].values).toEqual([[undefined], [undefined], [undefined]]);
+    expect(pivotData.data[0].dataResources).toEqual([[undefined], [undefined], [undefined]]);
+  });
+
+  it('should return by one column', () => {
+    const config: LmrPivotConfig = {
+      stemsConfigs: [
+        {
+          rowAttributes: [],
+          columnAttributes: [
+            {resourceId: 'C3', resourceType: AttributesResourceType.Collection, attributeId: 'a1', resourceIndex: 4},
+          ],
+          valueAttributes: [],
+        },
+      ],
+    };
+    const pivotData = dataConverter.createData(config, transform, collections, linkTypes, data, query);
+    expect(pivotData.data[0].rowHeaders).toEqual([]);
+    expect(pivotData.data[0].columnHeaders).toEqual([
+      {
+        title: 'xyz',
+        targetIndex: 0,
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[2].attributes![0].name,
+      },
+      {
+        title: 'vuw',
+        targetIndex: 1,
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[2].attributes![0].name,
+      },
+    ]);
+    expect(pivotData.data[0].values).toEqual([[undefined, undefined]]);
+    expect(pivotData.data[0].dataResources).toEqual([[undefined, undefined]]);
+  });
+
+  it('should return by two values', () => {
+    const config: LmrPivotConfig = {
+      stemsConfigs: [
+        {
+          rowAttributes: [],
+          columnAttributes: [],
+          valueAttributes: [
+            {
+              resourceId: 'C4',
+              resourceType: AttributesResourceType.Collection,
+              attributeId: 'a1',
+              resourceIndex: 6,
+              aggregation: DataAggregationType.Sum,
+            },
+            {
+              resourceId: 'C4',
+              resourceType: AttributesResourceType.Collection,
+              attributeId: 'a2',
+              resourceIndex: 6,
+              aggregation: DataAggregationType.Min,
+            },
+          ],
+        },
+      ],
+    };
+    const pivotData = dataConverter.createData(config, transform, collections, linkTypes, data, query);
+    expect(pivotData.data[0].rowHeaders).toEqual([]);
+    expect(pivotData.data[0].columnHeaders).toEqual([
+      {
+        title: dataConverter.createValueTitle(DataAggregationType.Sum, 'Ddd'),
+        targetIndex: 0,
+        color: undefined,
+        isValueHeader: true,
+      },
+      {
+        title: dataConverter.createValueTitle(DataAggregationType.Min, 'Eee'),
+        targetIndex: 1,
+        color: undefined,
+        isValueHeader: true,
+      },
+    ]);
+    expect(pivotData.data[0].values).toEqual([[46, -10]]);
+    expect(pivotData.data[0].dataResources[0][0]).toHaveSize(9);
+    expect(pivotData.data[0].dataResources[0][0].map((d: DataResource) => d.id)).toEqual(
+      jasmine.arrayContaining(['D41', 'D42', 'D43', 'D44', 'D45', 'D46', 'D47', 'D48', 'D49'])
+    );
+    expect(pivotData.data[0].dataResources[0][1]).toHaveSize(9);
+    expect(pivotData.data[0].dataResources[0][1].map((d: DataResource) => d.id)).toEqual(
+      jasmine.arrayContaining(['D41', 'D42', 'D43', 'D44', 'D45', 'D46', 'D47', 'D48', 'D49'])
+    );
+  });
+
+  it('should return by row and value', () => {
+    const config: LmrPivotConfig = {
+      stemsConfigs: [
+        {
+          rowAttributes: [
+            {resourceId: 'C1', resourceType: AttributesResourceType.Collection, attributeId: 'a1', resourceIndex: 0},
+          ],
+          columnAttributes: [],
+          valueAttributes: [
+            {
+              resourceId: 'C4',
+              resourceType: AttributesResourceType.Collection,
+              attributeId: 'a1',
+              resourceIndex: 6,
+              aggregation: DataAggregationType.Sum,
+            },
+          ],
+        },
+      ],
+    };
+    const pivotData = dataConverter.createData(config, transform, collections, linkTypes, data, query);
+    expect(pivotData.data[0].rowHeaders).toEqual([
+      {
+        title: 'abc',
+        targetIndex: 0,
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[0].attributes![0].name,
+      },
+      {
+        title: 'def',
+        targetIndex: 1,
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[0].attributes![0].name,
+      },
+    ]);
+    expect(pivotData.data[0].columnHeaders).toEqual([
+      {
+        title: dataConverter.createValueTitle(DataAggregationType.Sum, 'Ddd'),
+        targetIndex: 0,
+        color: undefined,
+        isValueHeader: true,
+      },
+    ]);
+
+    expect(pivotData.data[0].values).toEqual([[37], [31]]);
+    expect(pivotData.data[0].dataResources[0][0].map((d: DataResource) => d.id)).toEqual(
+      jasmine.arrayContaining(['D41', 'D41', 'D42', 'D43', 'D43', 'D44', 'D43', 'D44', 'D43', 'D44', 'D45', 'D46'])
+    );
+    expect(pivotData.data[0].dataResources[1][0].map((d: DataResource) => d.id)).toEqual(
+      jasmine.arrayContaining(['D47', 'D48', 'D49'])
+    );
+  });
+
+  it('should return by column and value', () => {
+    const config: LmrPivotConfig = {
+      stemsConfigs: [
+        {
+          rowAttributes: [],
+          columnAttributes: [
+            {resourceId: 'C2', resourceType: AttributesResourceType.Collection, attributeId: 'a1', resourceIndex: 2},
+          ],
+          valueAttributes: [
+            {
+              resourceId: 'C4',
+              resourceType: AttributesResourceType.Collection,
+              attributeId: 'a2',
+              resourceIndex: 6,
+              aggregation: DataAggregationType.Sum,
+            },
+          ],
+        },
+      ],
+    };
+    const pivotData = dataConverter.createData(config, transform, collections, linkTypes, data, query);
+    expect(pivotData.data[0].rowHeaders).toEqual([]);
+    expect(pivotData.data[0].columnHeaders).toEqual([
+      {
+        title: 'a',
+        targetIndex: 0,
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[1].attributes![0].name,
+      },
+      {
+        title: 'c',
+        targetIndex: 1,
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[1].attributes![0].name,
+      },
+      {
+        title: 'b',
+        targetIndex: 2,
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[1].attributes![0].name,
+      },
+    ]);
+    expect(pivotData.data[0].values).toEqual([[-4, 9, -13]]);
+    expect(pivotData.data[0].dataResources[0][0].map((d: DataResource) => d.id)).toEqual(
+      jasmine.arrayContaining(['D41', 'D43', 'D44'])
+    );
+    expect(pivotData.data[0].dataResources[0][1].map((d: DataResource) => d.id)).toEqual(
+      jasmine.arrayContaining(['D41', 'D42', 'D43', 'D47', 'D48', 'D49'])
+    );
+    expect(pivotData.data[0].dataResources[0][2].map((d: DataResource) => d.id)).toEqual(
+      jasmine.arrayContaining(['D43', 'D44', 'D43', 'D44', 'D45', 'D46'])
+    );
+  });
+
+  it('should return by two rows, column and three values', () => {
+    const config: LmrPivotConfig = {
+      stemsConfigs: [
+        {
+          rowAttributes: [
+            {resourceId: 'C1', resourceType: AttributesResourceType.Collection, attributeId: 'a1', resourceIndex: 0},
+            {resourceId: 'C2', resourceType: AttributesResourceType.Collection, attributeId: 'a1', resourceIndex: 2},
+          ],
+          columnAttributes: [
+            {resourceId: 'C3', resourceType: AttributesResourceType.Collection, attributeId: 'a1', resourceIndex: 4},
+          ],
+          valueAttributes: [
+            {
+              resourceId: 'C4',
+              resourceType: AttributesResourceType.Collection,
+              attributeId: 'a1',
+              resourceIndex: 6,
+              aggregation: DataAggregationType.Sum,
+            },
+            {
+              resourceId: 'C4',
+              resourceType: AttributesResourceType.Collection,
+              attributeId: 'a1',
+              resourceIndex: 6,
+              aggregation: DataAggregationType.Max,
+            },
+            {
+              resourceId: 'C4',
+              resourceType: AttributesResourceType.Collection,
+              attributeId: 'a2',
+              resourceIndex: 6,
+              aggregation: DataAggregationType.Count,
+            },
+          ],
+        },
+      ],
+    };
+    const pivotData = dataConverter.createData(config, transform, collections, linkTypes, data, query);
+    expect(pivotData.data[0].rowHeaders).toEqual([
+      {
+        title: 'abc',
+        children: [
+          {
+            title: 'a',
+            targetIndex: 0,
+            color: undefined,
+            constraint: new UnknownConstraint(),
+            isValueHeader: false,
+            attributeName: collections[1].attributes![0].name,
+          },
+          {
+            title: 'c',
+            targetIndex: 1,
+            color: undefined,
+            constraint: new UnknownConstraint(),
+            isValueHeader: false,
+            attributeName: collections[1].attributes![0].name,
+          },
+          {
+            title: 'b',
+            targetIndex: 2,
+            color: undefined,
+            constraint: new UnknownConstraint(),
+            isValueHeader: false,
+            attributeName: collections[1].attributes![0].name,
+          },
+        ],
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[0].attributes![0].name,
+      },
+      {
+        title: 'def',
+        children: [
+          {
+            title: 'c',
+            targetIndex: 3,
+            color: undefined,
+            constraint: new UnknownConstraint(),
+            isValueHeader: false,
+            attributeName: collections[1].attributes![0].name,
+          },
+        ],
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[0].attributes![0].name,
+      },
+    ]);
+    const valueTitles = [
+      dataConverter.createValueTitle(DataAggregationType.Sum, 'Ddd'),
+      dataConverter.createValueTitle(DataAggregationType.Max, 'Ddd'),
+      dataConverter.createValueTitle(DataAggregationType.Count, 'Eee'),
+    ];
+    expect(pivotData.data[0].columnHeaders).toEqual([
+      {
+        title: 'xyz',
+        children: [
+          {title: valueTitles[0], targetIndex: 0, color: undefined, isValueHeader: true},
+          {title: valueTitles[1], targetIndex: 1, color: undefined, isValueHeader: true},
+          {title: valueTitles[2], targetIndex: 2, color: undefined, isValueHeader: true},
+        ],
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[2].attributes![0].name,
+      },
+      {
+        title: 'vuw',
+        children: [
+          {title: valueTitles[0], targetIndex: 3, color: undefined, isValueHeader: true},
+          {title: valueTitles[1], targetIndex: 4, color: undefined, isValueHeader: true},
+          {title: valueTitles[2], targetIndex: 5, color: undefined, isValueHeader: true},
+        ],
+        color: undefined,
+        constraint: new UnknownConstraint(),
+        isValueHeader: false,
+        attributeName: collections[2].attributes![0].name,
+      },
+    ]);
+    expect(pivotData.data[0].values).toEqual([
+      [2, 2, 1, 7, 6, 2],
+      [6, 4, 2, 6, 6, 1],
+      [undefined, undefined, undefined, 16, 6, 6],
+      [31, 20, 3, undefined, undefined, undefined],
+    ]);
+    expect(pivotData.data[0].valueTitles).toEqual(valueTitles);
+  });
+});