@sis-cc/dotstatsuite-components 10.0.0 → 11.0.0

package/src/rules2/src/getSidebarData.js

@@ -0,0 +1,73 @@
+import * as R from 'ramda';
+
+const dimensionValueDisplay = (display) => data => {
+  if (display === 'code') {
+    return R.prop('id', data);
+  }
+  if (display ===  'both') {
+    return `${R.prop('id', data)}: ${R.prop('name', data)}`;
+  }
+  return R.prop('name', data);
+};
+
+const sortByCoordinates = (a, b) => {
+  const splitACoord = a.splitCoord;
+  const splitBCoord = b.splitCoord;
+
+  const aWeight = R.pipe(R.reject(R.isEmpty), R.length)(splitACoord);
+  const bWeight = R.pipe(R.reject(R.isEmpty), R.length)(splitBCoord);
+  if (aWeight !== bWeight) {
+    return bWeight - aWeight;
+  }
+
+  let ind = 0;
+  while (splitACoord[ind] === splitBCoord[ind]) {
+    ind++;
+  }
+  const _a = R.isEmpty(splitACoord[ind]) ? 0 : Number(splitACoord[ind]);
+  const _b = R.isEmpty(splitBCoord[ind]) ? 0 : Number(splitBCoord[ind]);
+  return _b - _a;
+};
+
+// options = { display, attributesLabel }
+export const getSidebarData = (attributesSeries, metadataSeries, dataflow, dimensions, options) => {
+  const coordinates = R.uniq(R.concat(R.keys(attributesSeries), R.keys(metadataSeries)));
+  return R.pipe(
+    R.map(coordinate => {
+      const attributes = R.prop(coordinate, attributesSeries);
+      const metadata = R.prop(coordinate, metadataSeries);
+      const children = R.concat(
+        R.isNil(attributes) ? [] : [{ id: `${coordinate}-attr`, label: options.attributesLabel, children: attributes }],
+        R.isNil(metadata) ? [] : metadata,
+      );
+      const splitCoord = R.split(':', coordinate);
+      let label = null;
+      if (R.all(R.isEmpty, splitCoord)) {
+        label = dimensionValueDisplay(options.display)(dataflow);
+      }
+      else {
+        label = R.pipe(
+          R.addIndex(R.reduce)((acc, valIndex, dimIndex) => {
+            if (R.isEmpty(valIndex)) {
+              return acc;
+            }
+            const dim = R.nth(dimIndex, dimensions);
+            const dimLabel = dimensionValueDisplay(options.display)(dim);
+            const value = R.nth(Number(valIndex), dim.values);
+            const valLabel = dimensionValueDisplay(options.display)(value);
+            return R.append(`${dimLabel}: ${valLabel}`, acc);
+          }, []),
+          R.join(' - ')
+        )(splitCoord);
+      }
+
+      return ({
+        id: coordinate,
+        splitCoord,
+        label,
+        children: R.filter(R.identity, children),
+      });
+    }),
+    R.sort(sortByCoordinates)
+  )(coordinates);
+};

package/src/rules2/src/hasCellMetadata.js

@@ -0,0 +1,11 @@
+import * as R from 'ramda';
+
+export const hasCellMetadata = (metadataCoordinates, cellCoordinates) => {
+  return R.pipe(
+    R.find(coordinates => {
+      const mergedCoord = R.mergeLeft(coordinates, cellCoordinates);
+      return R.equals(mergedCoord, cellCoordinates);
+    }),
+    R.complement(R.isNil)
+  )(metadataCoordinates);
+};

package/src/rules2/src/hasLayoutEntryMetadata.js

@@ -0,0 +1,9 @@
+import * as R from 'ramda';
+
+/*
+const layoutData = [{ dimension: { id: 'D1', __index: 2 }, value: { id: 'V', __index: 0 } }];
+*/
+
+export const getLayoutEntryMetadataCoordinates = (layoutData, metadataSeries) => {
+  
+};

package/src/rules2/src/index.js

@@ -0,0 +1,5 @@
+export { SDMX_2_0_JSON_DATA_FORMAT } from './constants';
+
+export { getSidebarData } from './getSidebarData';
+export { parseMetadataSeries } from './parseMetadataSeries';
+export { json_2_0_0_DataFormatPatch } from './json2.0DataFormatPatch';

package/src/rules2/src/json2.0DataFormatPatch.js

@@ -0,0 +1,9 @@
+import * as R from 'ramda';
+
+export const json_2_0_0_DataFormatPatch = (sdmxJson) => {
+  const dataSet = R.pipe(R.pathOr({}, ['data', 'dataSets']), R.head)(sdmxJson);
+  const structureIndex = R.prop('structure', dataSet);
+  const structure = R.pipe(R.pathOr([], ['data', 'structures']), R.nth(structureIndex))(sdmxJson);
+
+  return R.set(R.lensPath(['data', 'structure']), structure)(sdmxJson);
+};

package/src/rules2/src/parseMetadataSeries.js

@@ -0,0 +1,80 @@
+import * as R from 'ramda';
+import { getLocalisedName } from '@sis-cc/dotstatsuite-sdmxjs';
+
+const dimensionValueDisplay = (locale, display) => data => {
+  if (display === 'code') {
+    return R.prop('id', data);
+  }
+  if (display ===  'both') {
+    return `${R.prop('id', data)}: ${getLocalisedName(locale)(data)}`;
+  }
+  return getLocalisedName(locale)(data);
+};
+// options = { locale, display, dimensions = [] };
+export const parseMetadataSeries = (metadataJson, options) => {
+  const metadataAttributes = R.pathOr([], ['data', 'structures', 0, 'attributes', 'dimensionGroup'], metadataJson);
+  const metaAttrLength = R.length(metadataAttributes);
+
+  if (!metaAttrLength) {
+    return ({});
+  }
+
+  const dimensions = R.pipe(
+    R.pathOr([], ['data', 'structures', 0, 'dimensions']),
+    ({ series = [], observation = [] }) => R.concat(series, observation),
+    dims => R.isEmpty(options.dimensions || [])
+      ? dims
+      : R.props(R.pluck('id', options.dimensions), R.indexBy(R.prop('id'), dims))
+  )(metadataJson);
+
+  const metadataSeries = R.pipe(
+    R.pathOr({}, ['data', 'dataSets', 0, 'dimensionGroupAttributes']),
+    series => R.reduce((acc, serieKey) => {
+      const indexes = series[serieKey];
+      const metaIndexes = R.take(metaAttrLength, indexes);
+
+      const evolvedKey = R.pipe(
+        R.split(':'),
+        R.addIndex(R.map)((vInd, dInd) => {
+          if (R.isEmpty(vInd)) {
+            return vInd;
+          }
+          const dim = R.nth(dInd, dimensions);
+          const val = R.nth(Number(vInd), dim.values || []);
+
+          const originalVal = R.find(
+            R.propEq('id', val.id),
+          )(R.propOr([], 'values', R.nth(dInd, options.dimensions)));
+          return R.propOr('', '__index', originalVal);
+        }),
+        R.join(':')
+      )(serieKey)
+
+      const attributes = R.addIndex(R.reduce)(
+        (acc, valueIndex, attrIndex) => {
+          if (R.isNil(valueIndex)) {
+            return acc;
+          }
+          const attribute = R.nth(attrIndex, metadataAttributes);
+          const label = dimensionValueDisplay(options.locale, options.display)(attribute);
+
+          const value = R.prop('value', R.nth(valueIndex, attribute.values || []));
+
+          return R.append({
+            id: attribute.id,
+            label,
+            value: R.is(Object, value) ? R.prop(options.locale, value) : value
+          }, acc);
+        },
+        [],
+        metaIndexes
+      );
+
+      return R.assoc(evolvedKey, attributes, acc);
+    },
+    {},
+    R.keys(series)
+  ))(metadataJson);
+
+  return metadataSeries;
+};

package/src/rules2/src/refineMetadataCoordinates.js

@@ -0,0 +1,27 @@
+import * as R from 'ramda';
+
+export const refineMetadataCoordinates = (metadataCoordinates, layoutIds, headerDimensionsIds) => {
+  return R.reduce(
+    (acc, coordinates) => {
+      const refinedCoord = R.omit(headerDimensionsIds, coordinates);
+      if (R.isEmpty(refinedCoord)) {
+        return acc;
+      }
+      const removedHeaderCodes = R.omit(layoutIds.header, refinedCoord);
+      if (R.isEmpty(removedHeaderCodes)) {
+        return R.over(R.lensProp('layout'), R.append(refinedCoord))(acc);
+      }
+      const removedSectionCodes = R.omit(layoutIds.sections, refinedCoord);
+      if (R.isEmpty(removedSectionCodes)) {
+        return R.over(R.lensProp('layout'), R.append(refinedCoord))(acc);
+      }
+      const removedRowsCodes = R.omit(layoutIds.rows, removedSectionCodes);
+      if (R.isEmpty(removedRowsCodes)) {
+        return R.over(R.lensProp('layout'), R.append(refinedCoord))(acc);
+      }
+      return R.over(R.lensProp('cells'), R.append(refinedCoord))(acc);
+    }, 
+    { cells: [], layout: [] },
+    metadataCoordinates
+  );
+};

package/test/advanced-attributes-parsing-perf.test.js

@@ -0,0 +1,16 @@
+import { expect } from 'chai';
+import {
+  getDataflowAdvancedAttributes,
+  getObservationsAdvancedAttributes,
+  getSeriesAdvancedAttributes
+} from '../src/rules2/src/getAdvancedAttributes';
+
+import obsMock from './mocks/table-prep-units--observations.json';
+import obsAdvancedAttributes from './mocks/observations-advanced-attributes.json';
+
+describe('advanced attributes parsing performance tests', () => {
+  it('1800 observations test', function() {
+    this.timeout(1500);
+    expect(getObservationsAdvancedAttributes(obsMock, ['CURRENCY', 'OBS_STATUS'])).to.deep.equal(obsAdvancedAttributes);
+  });
+});

package/test/getCells.test.js

@@ -24,7 +24,7 @@ describe('getCells tests', () => {
         }
       }
     }, 'label', customAttributes,
-    { unitsDefinitionCodes: [], unitsSeries: {}, unitsDisplay: 'cells', unitDimension: {} })).to.deep.equal({
+    { unitsDefinitionCodes: [], unitsSeries: {}, unitsDisplay: 'cells', unitDimension: {} }, [])).to.deep.equal({
       a: {
         value: '33',
         intValue: 33,
@@ -33,7 +33,8 @@ describe('getCells tests', () => {
           { label: 'Footnote 1: Footnote 1 Value 1' },
           { label: 'Footnote 3: Footnote 3 Value 3' }
         ],
-        indexedDimValIds: {}
+        indexedDimValIds: {},
+        sideProps: null
       }
     })
   });
@@ -48,10 +49,10 @@ describe('getCells tests', () => {
             FT1: { id: 'FT1', name: 'Footnote 1', value: { id: 'FT1.1', name: 'Footnote 1 Value 1' } },
             FT3: { id: 'FT3', name: 'Footnote 3', value: { id: 'FT3.3', name: 'Footnote 3 Value 3' } },
           },
-          indexedDimValIds: {}
+          indexedDimValIds: {},
         }
       }
-    }, 'both', customAttributes)).to.deep.equal({
+    }, 'both', customAttributes, {}, [])).to.deep.equal({
       a: {
         value: '33',
         intValue: 33,
@@ -60,7 +61,8 @@ describe('getCells tests', () => {
           { label: '(FT1) Footnote 1: (FT1.1) Footnote 1 Value 1' },
           { label: '(FT3) Footnote 3: (FT3.3) Footnote 3 Value 3' }
         ],
-        indexedDimValIds: {}
+        indexedDimValIds: {},
+        sideProps: null
       }
     })
   });

package/test/getDataflowAdvancedAttributes.test.js

@@ -0,0 +1,32 @@
+import { expect } from 'chai';
+import { getDataflowAdvancedAttributes } from '../src/rules2/src/getAdvancedAttributes';
+
+describe('getDataflowAdvancedAttributes tests', () => {
+  it('complete test', () => {
+    const advancedAttributesIds = ['a0', 'a2', 'a4', 'a6'];
+    const attributes = {
+      a0: { id: 'a0', relationship: { none: {} }, values: [{ id: 'v0' }] },
+      a1: { id: 'a1', relationship: { none: {} }, values: [{ id: 'v0' }] },
+      a2: { id: 'a2', relationship: { dimensions: ['d0'] }, values: [{ id: 'v0' }] },
+      a3: { id: 'a3', relationship: { dimensions: ['d0'] }, values: [{ id: 'v0' }] },
+      a4: { id: 'a4', relationship: { dimensions: ['d0', 'd1'] }, values: [{ id: 'v0' }] },
+      a5: { id: 'a5', relationship: { dimensions: ['d0', 'd1'] }, values: [{ id: 'v0' }] },
+      a6: { id: 'a6', relationship: { dimensions: ['d0', 'd1', 'd2'] }, values: [{ id: 'v0' }] },
+    };
+    const dimLength = 4;
+    const dimensions = {
+      d0: { id: 'd0', __index: 1, values: [{ id: 'v0' }] },
+      d1: { id: 'd1', __index: 2, values: [{ id: 'v0' }] },
+      d2: { id: 'd2', __index: 3, values: [{ id: 'v0' }] },
+    };
+
+    const expected = {
+      ':::': { attributes: { a0: { id: 'a0', value: { id: 'v0' } } }, coordinates: {} },
+      ':0::': { attributes: { a2: { id: 'a2', value: { id: 'v0' } } }, coordinates: { d0: 'v0' } },
+      ':0:0:': { attributes: { a4: { id: 'a4', value: { id: 'v0' } } }, coordinates: { d0: 'v0', d1: 'v0' } },
+      ':0:0:0': { attributes: { a6: { id: 'a6', value: { id: 'v0' } } }, coordinates: { d0: 'v0', d1: 'v0', d2: 'v0' } },
+    }
+
+    expect(getDataflowAdvancedAttributes(attributes, dimensions, advancedAttributesIds, dimLength)).to.deep.equal(expected);
+  });
+});

package/test/getLayoutDataWithFlags.test.js

@@ -1,7 +1,7 @@
 import { expect } from 'chai';
 import { getLayoutDataWithFlags } from '../src/rules/src/table/factories/getLayoutWithFlags';
 
-const customAttributes = { flags: ['a1', 'a2'] };
+const customAttributes = { flags: ['a1', 'a2'], footnotes: ['a3', 'a4'] };
 
 const layoutData = {
   headerData: [
@@ -41,7 +41,8 @@ const expected = {
         { dimension: { id: 'COL2', label: 'COL2', flags: [] }, value: { id: 'COL2V1', label: 'COL2V1', flags: [] } }
       ],
       key: '0:0',
-      flags: [{ code: 'A1VAL', label: 'A1: A1VAL' }, { label: 'A3: A3VAL' }]
+      flags: [{ code: 'A1VAL', label: 'A1: A1VAL' }, { label: 'A3: A3VAL' }],
+      sideProps: null
     },
     {
       data: [
@@ -49,7 +50,8 @@ const expected = {
         { dimension: { id: 'COL2', label: 'COL2', flags: [] }, value: { id: 'COL2V1', label: 'COL2V1', flags: [] } }
       ],
       key: '1:0',
-      flags: []
+      flags: [],
+      sideProps: null
     }
   ],
   sectionsData: [
@@ -57,7 +59,8 @@ const expected = {
       {
         data: [{ dimension: { id: 'SEC', label: 'SEC', flags: [] }, value: { id: 'SECV1', label: 'SECV1', flags: [] } }],
         key: '0',
-        flags: []
+        flags: [],
+        sideProps: null
       },
       [
         {
@@ -66,7 +69,8 @@ const expected = {
             { dimension: { id: 'ROW2', label: 'ROW2', flags: [] }, value: { id: 'ROW2V1', label: 'ROW2V1', flags: [] } }
           ],
           key: '0:0',
-          flags: []
+          flags: [],
+          sideProps: null
         },
         {
           data: [
@@ -74,7 +78,8 @@ const expected = {
             { dimension: { id: 'ROW2', label: 'ROW2', flags: [] }, value: { id: 'ROW2V2', label: 'ROW2V2', flags: [] } }
           ],
           key: '0:1',
-          flags: []
+          flags: [],
+          sideProps: null
         },
         {
           data: [
@@ -82,7 +87,8 @@ const expected = {
             { dimension: { id: 'ROW2', label: 'ROW2', flags: [] }, value: { id: 'ROW2V3', label: 'ROW2V3', flags: [] } }
           ],
           key: '0:2',
-          flags: []
+          flags: [],
+          sideProps: null
         },
       ]
     ],
@@ -90,7 +96,8 @@ const expected = {
       {
         data: [{ dimension: { id: 'SEC', label: 'SEC', flags: [] }, value: { id: 'SECV2', label: 'SECV2', flags: [] } }],
         key: '1',
-        flags: []
+        flags: [],
+        sideProps: null
       },
       [
         {
@@ -99,7 +106,8 @@ const expected = {
             { dimension: { id: 'ROW2', label: 'ROW2', flags: [] }, value: { id: 'ROW2V1', label: 'ROW2V1', flags: [] } }
           ],
           key: '0:0',
-          flags: []
+          flags: [],
+          sideProps: null
         },
         {
           data: [
@@ -107,7 +115,8 @@ const expected = {
             { dimension: { id: 'ROW2', label: 'ROW2', flags: [] }, value: { id: 'ROW2V2', label: 'ROW2V2', flags: [] } }
           ],
           key: '0:1',
-          flags: [{ label: 'A4: A4VAL' }]
+          flags: [{ label: 'A4: A4VAL' }],
+          sideProps: null
         },
         {
           data: [
@@ -115,7 +124,8 @@ const expected = {
             { dimension: { id: 'ROW2', label: 'ROW2', flags: [] }, value: { id: 'ROW2V3', label: 'ROW2V3', flags: [] } }
           ],
           key: '0:2',
-          flags: []
+          flags: [],
+          sideProps: null
         },
       ]
     ]
@@ -127,6 +137,6 @@ describe('getLayoutDataWithFlags test', () => {
     expect(getLayoutDataWithFlags({}, 'label', {})({ headerData: [], sectionsData: [] })).to.deep.equal({ headerData: [], sectionsData: [] });
   });
   it('multi cases', () => {
-    expect(getLayoutDataWithFlags(attributesValues, 'code', customAttributes)(layoutData)).to.deep.equal(expected);
+    expect(getLayoutDataWithFlags(attributesValues, 'code', customAttributes, [], [])(layoutData)).to.deep.equal(expected);
   });
 });

package/test/getSeriesAdvancedAttributes.test.js

@@ -0,0 +1,30 @@
+import { expect } from 'chai';
+import { getSeriesAdvancedAttributes } from '../src/rules2/src/getAdvancedAttributes';
+
+describe('getSeriesAdvancedAttributes tests', () => {
+  it('complete case', () => {
+    const seriesAttributes = {
+      series: {
+        '0:0:x:x:x': { attributes: { a0: { id: 'a0' } } },
+        '0:1:0:x:x': { attributes: { a0: { id: 'a0' }, a1: { id: 'a1' } } },
+      },
+      dimensions: {
+        '3:0': { attributes: { a0: { id: 'a0' } } },
+        '4:1': { attributes: { a0: { id: 'a0' }, a1: { id: 'a1' } } },
+      }
+    };
+    const advancedAttributesIds = ['a1'];
+    const dimensions = [
+      { id: 'd0', values: [{ id: 'v0' }] },
+      { id: 'd1', values: [{ id: 'v0' }, { id: 'v1' }] },
+      { id: 'd2', values: [{ id: 'v0' }] },
+      { id: 'd3', values: [{ id: 'v0' }] },
+      { id: 'd4', values: [{ id: 'v0' }, { id: 'v1' }] },
+    ];
+
+    expect(getSeriesAdvancedAttributes(seriesAttributes, dimensions, advancedAttributesIds)).to.deep.equal({
+      '0:1:0::': { attributes: { a1: { id: 'a1' } }, coordinates: { d0: 'v0', d1: 'v1', d2: 'v0' } },
+      '::::1': { attributes: { a1: { id: 'a1' } }, coordinates: { d4: 'v1' } }
+    });
+  });
+});

package/test/getSidebarData.test.js

@@ -0,0 +1,116 @@
+import { expect } from 'chai';
+import { getSidebarData } from '../src/rules2/src/getSidebarData';
+
+describe('getSidebarData tests', () => {
+  it('complete case', () => {
+    const attributes = {
+      '::': [
+        { id: 'aa0', label: 'advanced attribute 0', value: 'value' },
+        { id: 'aa1', label: 'advanced attribute 1', value: 'value' },
+      ],
+      '0::': [
+        { id: 'aa2', label: 'advanced attribute 2', value: 'value' },
+        { id: 'aa3', label: 'advanced attribute 3', value: 'value' },
+      ]
+    };
+    const metadata = {
+      '0::': [
+        { id: 'ma0', label: 'metadata attribute 0', value: 'value' },
+        { id: 'ma1', label: 'metadata attribute 1', value: 'value' },
+      ],
+      '0::0': [
+        { id: 'ma2', label: 'metadata attribute 2', value: 'value' },
+        { id: 'ma3', label: 'metadata attribute 3', value: 'value' },
+      ]
+    };
+    const options = {
+      display: 'code',
+      attributesLabel: 'Advanced Attributes'
+    };
+    const dataflow = {
+      id: 'DF',
+      name: 'Dataflow'
+    };
+    const dimensions = [
+      { id: 'd0', name: 'dimension 0', values: [{ id: 'd0v0', name: 'value 0' }] },
+      { id: 'd1', name: 'dimension 1', values: [{ id: 'd1v0', name: 'value 0' }] },
+      { id: 'd2', name: 'dimension 2', values: [{ id: 'd2v0', name: 'value 0' }] },
+    ];
+
+    expect(getSidebarData(attributes, metadata, dataflow, dimensions, options)).to.deep.equal([
+      {
+        id: '0::0',
+        label: 'd0: d0v0 - d2: d2v0',
+        splitCoord: ['0', '', '0'],
+        children: [
+          {
+            id: 'ma2',
+            label: 'metadata attribute 2',
+            value: 'value'
+          },
+          {
+            id: 'ma3',
+            label: 'metadata attribute 3',
+            value: 'value'
+          }
+        ]
+      },
+      {
+        id: '0::',
+        label: 'd0: d0v0',
+        splitCoord: ['0', '', ''],
+        children: [
+          {
+            id: '0::-attr',
+            label: 'Advanced Attributes',
+            children: [
+              {
+                id: 'aa2',
+                label: 'advanced attribute 2',
+                value: 'value'
+              },
+              {
+                id: 'aa3',
+                label: 'advanced attribute 3',
+                value: 'value'
+              }
+            ]
+          },
+          {
+            id: 'ma0',
+            label: 'metadata attribute 0',
+            value: 'value'
+          },
+          {
+            id: 'ma1',
+            label: 'metadata attribute 1',
+            value: 'value'
+          }
+        ]
+      },
+      {
+        id: '::',
+        label: 'DF',
+        splitCoord: ['', '', ''],
+        children: [
+          {
+            id: '::-attr',
+            label: 'Advanced Attributes',
+            children: [
+              {
+                id: 'aa0',
+                label: 'advanced attribute 0',
+                value: 'value'
+              },
+              {
+                id: 'aa1',
+                label: 'advanced attribute 1',
+                value: 'value'
+              }
+            ]
+          }
+        ]
+      }
+    ]);
+  });
+});

package/test/getSubtitleFlags.test.js

@@ -22,7 +22,7 @@ describe('getSubtitleFlags tests', () => {
   });
   it('simple test', () => {
     expect(getSubtitleFlags({
-      customAttributes: {},
+      customAttributes: { flags: [], footnotes: ['f1', 'f2'] },
       dimensions: {
         one: {
           a: {

package/test/getTableData.test.js

@@ -14,7 +14,8 @@ const data = {
   dataflowAttributes: {},
   dataflowName: undefined,
   seriesAttributes: [],
-  seriesAttributesValues: {}
+  seriesAttributesValues: {},
+  metadataCoordinates: []
 };
 
 const data1 = {