@sis-cc/dotstatsuite-components 15.0.20 → 16.0.0

package/src/rules2/src/table/getLayoutData.js

@@ -0,0 +1,183 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './getFlagsAndNotes';
+import { hasCellMetadata } from '../hasCellMetadata';
+import { getCombinationDimensionsData } from './getCombinationDimensionsData';
+import { parseValueHierarchy } from './parseValueHierarchy';
+
+const getSubLayoutData = (series, _definition, { metadataCoordinates, attributesSeries, customAttributes }) => {
+  const getHasAdvancedAttributes = (attrValues) => R.pipe(
+    R.omit(R.concat(customAttributes.flags, customAttributes.notes)),
+    R.isEmpty,
+    R.not
+  )(attrValues);
+
+  const combinationConceptIds = R.reduce(
+    (acc, def) => {
+      const concepts = R.propOr([], 'concepts', def);
+      if (R.isEmpty(concepts)) {
+        return acc;
+      }
+      return R.concat(acc, concepts);
+    },
+    [],
+    _definition
+  );
+
+  const definition = R.map( //used for parseValueHierarchy ...
+    (entry) => {
+      if (R.has('dimensions', entry)) {
+        return ({ 
+          ...entry,
+          dimensions: R.map(
+            dim => R.assoc('indexedValues', R.indexBy(R.prop('id'), dim.values || []), dim),
+            entry.dimensions
+          )
+        });
+      }
+      return R.assoc('indexedValues', R.indexBy(R.prop('id'), entry.values || []), entry);
+    },
+    _definition
+  );
+
+  const { res } = R.reduce(
+    (acc, serie) => {
+      let data = [];
+      let next = [];
+      let sameSerie = true;
+      let i = 0;
+      let hasAdvancedAttributes = false;
+      let coordinates = {};
+      let ids = [];
+      while (i < serie.length) {
+        const entry = serie[i];
+        if (R.is(Array, entry)) {
+          const combination = definition[i];
+          const previousDimValues = R.nth(i, acc.previous);
+          const combData = getCombinationDimensionsData(entry, combination, previousDimValues, sameSerie);
+          data = R.append({
+            dimension: R.pick(['id', 'name'], combination),
+            dimValues: combData.dimValues
+          }, data);
+          next = R.append(combData.dimValues, next);
+          hasAdvancedAttributes = !hasAdvancedAttributes ? combData.hasAdvancedAttributes : true;
+          sameSerie = combData.sameSerie;
+          coordinates = { ...coordinates, ...combData.coordinates };
+          ids = R.concat(ids, combData.ids);
+        }
+        else {
+          const dimension = definition[i];
+          const value = R.nth(Math.abs(entry), dimension.values || []);
+          const previousValue = R.nth(i, acc.previous) || {};
+          coordinates = R.assoc(dimension.id, value.id, coordinates);
+          ids = R.append(`${dimension.id}=${value.id}`, ids);
+          if (value.id === R.prop('id', previousValue || {}) && sameSerie) {
+            next = R.append(previousValue, next);
+            data = R.append({
+              dimension: R.pick(['id', 'name', '__index'], dimension),
+              value:  previousValue,
+            }, data);
+          }
+          else {
+            hasAdvancedAttributes = !hasAdvancedAttributes ? value.hasAdvancedAttributes : true;
+            const parsedValue = parseValueHierarchy(value, sameSerie ? previousValue || {} : {}, dimension.indexedValues);
+            next = R.append(parsedValue, next);
+            data = R.append({
+              dimension: R.pick(['id', 'name', '__index'], dimension),
+              value: parsedValue,
+            }, data);
+            if (!R.isNil(acc.previous)) {
+              sameSerie = false;
+            }
+          }
+        }
+        i++;
+      }
+
+      const attributesValues = R.reduce(
+        (acc, key) => {
+          const splitKey = R.split(':', key);
+          const isValid = R.all(entry => {
+            const [d, v] = R.split('=', entry);
+            return R.propEq(d, v, coordinates);
+          }, splitKey);
+          return isValid ? { ...acc, ...(R.length(splitKey) === 1 ? R.pick(combinationConceptIds, R.prop(key, attributesSeries)) : R.prop(key, attributesSeries)) } : acc;
+        },
+        {},
+        R.keys(attributesSeries)
+      );
+
+      data = R.addIndex(R.map)(
+        (entry, ind) => {
+          if (!R.has('dimValues', entry)) {
+            return entry;
+          }
+          const { dimValues, dimension } = entry;
+          const def = R.nth(ind, definition);
+          const fixedDimValues = R.propOr([], 'fixedDimValues', def);
+          const values = R.reduce(
+            (_acc, id) => {
+              if (R.has(id, dimValues)) {
+                return R.append(R.prop(id, dimValues), _acc);
+              }
+              if (R.has(id, fixedDimValues)) {
+                return R.append(R.prop(id, fixedDimValues), _acc);
+              }
+              if (!R.has(id, attributesValues)) {
+                return _acc;
+              }
+              return R.append(R.path([id, 'value'], attributesValues), _acc);
+            },
+            [],
+            def.concepts
+          );
+          return ({ dimension, values });
+        },
+        data
+      );
+
+      const layoutAttrValues = R.pipe(
+        R.omit(combinationConceptIds),
+        R.reject(R.prop('isObs'))
+      )(attributesValues);
+
+      const flags = getFlagsAndNotes(layoutAttrValues, customAttributes);
+      const hasMetadata = hasCellMetadata(metadataCoordinates, coordinates);
+
+      if (!hasAdvancedAttributes) {
+        hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues);
+      }
+
+      const sideProps = hasMetadata || hasAdvancedAttributes
+        ? { hasMetadata, hasAdvancedAttributes, coordinates } : null;
+
+      return {
+        res: R.append({ data, key: R.join(':', ids), flags, sideProps }, acc.res),
+        previous: next,
+      };
+    },
+    { res: [], previous: [] },
+    series
+  );
+
+  return res;
+};
+
+export const getLayoutData = (layoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes }) => {
+  const { header, sections, ...rest } = layoutIndexes;
+  const opts = { metadataCoordinates, attributesSeries, customAttributes };
+  const headerData = getSubLayoutData(header, layout.header, opts);
+  const sectionsData = R.pipe(
+    R.transpose,
+    ([sections, sectionsRows]) => {
+      if (R.isNil(sections)) {
+        return [];
+      }
+      const _sectionsData = getSubLayoutData(sections, layout.sections, opts);
+      const rowsData = R.map(rows => getSubLayoutData(rows, layout.rows, opts), sectionsRows);
+
+      return R.transpose([_sectionsData, rowsData]);
+    }
+  )(sections);
+
+  return ({ headerData, sectionsData, ...rest });
+};

package/src/rules2/src/table/getSortedLayoutIndexes.js

@@ -0,0 +1,119 @@
+import * as R from 'ramda';
+
+/*
+  const layout = {
+    header: [
+      { id, __index },
+      { id: COMB, dimensions: [{ id, __index }] }
+    ],
+    sections: [],
+    rows: []
+  }
+
+*/
+
+const getLayoutPivots = layoutEntry => {
+  const valIndexGetter = d => R.pipe(
+    R.nth(R.prop('__index', d)),
+    ind => d.isInverted ? R.negate(ind) : ind
+  );
+  return indexes => R.map(
+    R.ifElse(
+      R.has('dimensions'),
+      c => R.map(d => valIndexGetter(d)(indexes), R.prop('dimensions', c)),
+      d => valIndexGetter(d)(indexes)
+    ),
+    layoutEntry
+  );
+};
+
+const comparator = (a, b) => {
+  const size = R.length(a);
+  let i = 0;
+  while (i < size) {
+    if (R.is(Array, a[i])) {
+      const _a = a[i];
+      const _b = b[i];
+      const _size = R.length(_a);
+      let j = 0;
+      while (_a[j] === _b[j] && j < _size) {
+        j++;
+      }
+      if (_a[j] !== _b[j]) {
+        return _a[j] - _b[j];
+      }
+    }
+    else if (a[i] !== b[i]) {
+      return a[i] - b[i];
+    }
+    i++;
+  }
+  return a[i] - b[i];
+};
+
+// simple call to ramda uniq method is very slow regarding performance
+const uniqIndexes = (indexes) => R.pipe(
+  R.reduce(
+    (acc, i) => {
+      const key = R.join(':', R.unnest(i));
+      if (R.has(key, acc.keys)) {
+        return acc;
+      }
+      return ({
+        indexes: R.append(i, acc.indexes),
+        keys: R.assoc(key, key, acc.keys)
+      });
+    },
+    { indexes: [], keys: {} },
+  ),
+  R.prop('indexes')
+)(indexes);
+
+export const getSortedLayoutIndexes = (layout, observations) => {
+  const dimIndexes = R.pipe(R.values, R.map(R.propOr([], 'orderedDimIndexes')))(observations);
+
+  const headerPivots = getLayoutPivots(layout.header);
+  const sectionsPivots = getLayoutPivots(R.concat(layout.sections, layout.rows));
+
+  const sectionLength = R.length(layout.sections);
+  const { header, sections } = R.pipe(
+    R.reduce(
+      (acc, indexes) => {
+        const headerIndexes = headerPivots(indexes);
+        const sectionsIndexes = sectionsPivots(indexes);
+
+        return ({
+          header: R.append(headerIndexes, acc.header),
+          sections: R.append(sectionsIndexes, acc.sections)
+        });
+      },
+      { header: [], sections: [] },
+    ),
+    R.mapObjIndexed(uniqIndexes),
+    R.evolve({
+      header: R.sort(comparator),
+      sections: R.sort(comparator)
+    }),
+    indexes => ({
+      ...indexes,
+      sections: R.reduce(
+        (acc, i) => {
+          const [sectionIndexes, rowIndexes] = R.splitAt(sectionLength, i);
+          const previousSecIndexes = R.pipe(R.nth(-1), i => R.isNil(i) ? null : R.head(i))(acc);
+          if (R.equals(R.unnest(sectionIndexes), previousSecIndexes ? R.unnest(previousSecIndexes) : null)) { //perhaps a bit dirty ...
+            return R.over(
+              R.lensIndex(-1),
+              R.over(R.lensIndex(1), R.append(rowIndexes))
+            )(acc);
+          }
+
+          return R.append([sectionIndexes, [rowIndexes]], acc);
+        },
+        [],
+        indexes.sections
+      )
+    })
+  )(dimIndexes);
+
+  return ({ header, sections });
+};

package/src/rules2/src/table/getTableProps.js

@@ -0,0 +1,36 @@
+import * as R from 'ramda';
+import { getLayout } from './getLayout';
+import { getSortedLayoutIndexes } from './getSortedLayoutIndexes';
+import { refineLayoutSize } from './refineLayoutSize';
+import { getLayoutData } from './getLayoutData';
+import { getCellsAttributesIds } from './getCellsAttributesIds';
+import { getIndexedCombinationsByDisplay } from './getIndexedCombinationsByDisplay';
+import { getCells } from './getCells';
+import { getCuratedCells } from './getCuratedCells';
+
+export const getTableProps = ({ data, layoutIds, customAttributes, limit, isTimeInverted }) => {
+  const {
+    observations,
+    dimensions,
+    combinations,
+    oneValueDimensions,
+    attributesSeries,
+    metadataCoordinates,
+    attributes
+  } = data;
+
+  const seriesCombinations = R.filter(R.prop('series'), combinations);
+  const layout = getLayout(layoutIds, dimensions, seriesCombinations, isTimeInverted, oneValueDimensions);
+  const layoutIndexes = getSortedLayoutIndexes(layout, observations);
+  const refinedLayoutIndexes = refineLayoutSize({ layout, observations, limit })(layoutIndexes);
+  const layoutData = getLayoutData(refinedLayoutIndexes, layout, { metadataCoordinates, attributesSeries, customAttributes });
+
+  const cellsAttributesIds = getCellsAttributesIds(layoutIds, attributes);
+  const indexedCombinations = getIndexedCombinationsByDisplay(layout, seriesCombinations);
+  const cells = getCells(customAttributes, cellsAttributesIds, indexedCombinations, attributesSeries, metadataCoordinates)(observations);
+
+  return ({
+    ...layoutData,
+    cells: getCuratedCells(cells, layout)
+  });
+};

package/src/rules2/src/table/parseValueHierarchy.js

@@ -0,0 +1,27 @@
+import * as R from 'ramda';
+
+export const parseValueHierarchy = (value, previousValue, indexedValues) => {
+  const parentsIds = R.propOr([], 'parents', value);
+  if (R.isEmpty(parentsIds)) {
+    return value;
+  }
+  const _previousParentsIds = R.propOr([], 'parentsIds', previousValue);
+  const previousParentsIds = R.isNil(previousValue) ? [] : R.append(R.prop('id', previousValue), _previousParentsIds);
+  const [presentIds, missingIds] = R.addIndex(R.splitWhen)((val, ind) => R.nth(ind, previousParentsIds) !== val, parentsIds);
+  //console.log({ presentIds, missingIds });
+  const _previousParents = R.propOr([], 'parents', previousValue);
+  const previousParents = R.isNil(previousValue) ? [] : R.append(R.pick(['id', 'name'], previousValue), _previousParents);
+  //console.log('previousParents', previousParents);
+  const parents = R.takeWhile(p => R.includes(p.id, presentIds), previousParents);
+  const missingParents = R.concat(
+    R.includes(R.prop('id', previousValue), presentIds)
+      ? [] : R.takeWhile(p => R.includes(p.id, presentIds), R.propOr([], 'missingParents', previousValue)),
+    R.props(missingIds, indexedValues)
+  );
+  return ({
+    ...value,
+    parents,
+    parentsIds,
+    missingParents
+  });
+};

package/src/{rules/src/table/factories → rules2/src/table}/refineLayoutSize.js

@@ -1,5 +1,14 @@
 import * as R from 'ramda';
 
+const toKey = indexes => R.reduce(
+  (acc, _ind) => {
+    const ind = R.is(Array, _ind) ? toKey(_ind) : Math.abs(_ind);
+    return R.isEmpty(acc) ? String(ind) : `${acc}:${ind}`
+  },
+  '',
+  indexes
+);
+
 const getPivotKey = indexes => R.pipe(
   R.props(indexes),
   R.join(':')
@@ -7,7 +16,13 @@ const getPivotKey = indexes => R.pipe(
 
 const getPivots = (layout, shape) => R.pipe(
   R.props(shape),
-  R.map(R.pipe(R.pluck('__index'), getPivotKey))
+  R.map(
+    R.pipe(
+      R.map(entry => R.has('dimensions', entry) ? R.pluck('__index', entry.dimensions || []) : entry.__index),
+      R.unnest,
+      getPivotKey
+    )
+  )
 )(layout);
 
 const indexWithPivots = (pivots, observations) => R.pipe(
@@ -35,12 +50,12 @@ export const getCuratedCells = ({ layout, observations, shape }) => {
 export const refineSections = (sections, extractedKeys, curatedObs) => R.pipe(
   R.map(
     (section) => {
-      const sectionKey = R.join(':', R.head(section) || []);
+      const sectionKey = toKey(R.head(section) || []);
       return R.over(
         R.lensIndex(1),
         R.filter(
           rowData => {
-            const rowKey = R.join(':', rowData);
+            const rowKey = toKey(rowData);
             return R.pipe(
               R.path([sectionKey, rowKey]),
               R.omit(extractedKeys),
@@ -59,7 +74,7 @@ export const refineSections = (sections, extractedKeys, curatedObs) => R.pipe(
 
 export const refineHeader = (header, extractedKeys, curatedObs) => R.filter( // extracted : { [sectionKey]: [...rowKeys] }
   (header) => {
-    const headerKey = R.join(':', header);
+    const headerKey = toKey(header);
     return R.pipe(
       R.prop(headerKey),
       (sections) => {
@@ -86,17 +101,17 @@ export const truncateSectionRows = (n, sectionsData) => {
     const lastSection = R.last(truncated);
     const rows = lastSection[1];
     const rowsLength = R.length(rows);
-    const sectionKey = R.join(':', R.head(lastSection));
+    const sectionKey = toKey(R.head(lastSection));
     if (rowsLength > _n) {
       const [rest, extracted] = R.splitAt(R.negate(_n), rows);
       const updatedSection = R.set(R.lensIndex(1), rest)(lastSection);
       truncated = R.set(R.lensIndex(-1), updatedSection)(truncated);
-      extractedKeys = { ...extractedKeys, [sectionKey]: R.map(R.join(':'), extracted) };
+      extractedKeys = { ...extractedKeys, [sectionKey]: R.map(toKey, extracted) };
       _n = 0;
     }
     else {
       truncated = R.dropLast(1, truncated);
-      extractedKeys = { ...extractedKeys, [sectionKey]: R.map(R.join(':'), rows) };
+      extractedKeys = { ...extractedKeys, [sectionKey]: R.map(toKey, rows) };
       _n = _n - rowsLength;
     }
   }
@@ -105,7 +120,7 @@ export const truncateSectionRows = (n, sectionsData) => {
 
 export const truncateHeader = (n, headerData) => {
   const [truncated, extracted] = R.splitAt(R.negate(n))(headerData);
-  return ({ truncated, extractedKeys: R.map(R.join(':'), extracted) });
+  return ({ truncated, extractedKeys: R.map(toKey, extracted) });
 };
 
 const truncateLayout = (isVertical) => R.ifElse(
@@ -218,6 +233,7 @@ export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndex
     (shape) => getCuratedCells({ layout, observations, shape })
   )(isVertical);
 
+
   const refined = refineLayout(isVertical)(toRefine, extractedKeys, curatedObs);
 
   const result = getRefinedLayout(isVertical, truncated, refined);

package/src/rules2/src/utils.js

@@ -0,0 +1,12 @@
+import * as R from 'ramda';
+
+export const trimedProps = (properties, obj) => R.reduce(
+  (acc, prop) => {
+    if (!R.has(prop, obj)) {
+      return acc;
+    }
+    return R.append(obj[prop], acc);
+  },
+  [],
+  properties,
+);

package/test/enhanceObservations2.test.js

@@ -0,0 +1,219 @@
+import { expect } from 'chai';
+import { enhanceObservations } from '../src/rules2/src/enhanceObservations';
+import numeral from 'numeral';
+
+numeral.register('locale', 'eObs', { delimiters: { thousands: ",", decimal: "."  } });
+describe('enhanceObservations tests', () => {
+  it('blank test', () => {
+    expect(enhanceObservations([], {}, [], {})).to.deep.equal({});
+  });
+  it('formatValue test', () => {
+    numeral.locale('eObs');
+    const attributes = [
+      { id: 'A1', values: [] },
+      { id: 'A2', values: [{ id: '-1' }, { id: '0' }, { id: '1' }, { id: '3' }, { id: 'Z' }] },
+      { id: 'A3', values: [{ id: '0' }, { id: '2' }, { id: '3' }, { id: '5' }, { id: 'A' }] }
+    ];
+
+    const customAttributes = { prefscale: 'A2', decimals: 'A3' };
+
+    const observations = {
+      a: { value: 2, attrValuesIndexes: [null, null, null], dimValuesIndexes: [] },
+      c: { value: 10, attrValuesIndexes: [null, 4, null], dimValuesIndexes: [] },
+      d: { value: 5, attrValuesIndexes: [null, 1, null], dimValuesIndexes: [] },
+      e: { value: 8.3, attrValuesIndexes: [null, 0, null], dimValuesIndexes: [] },
+      f: { value: 25.62, attrValuesIndexes: [null, 3, null], dimValuesIndexes: [] },
+      g: { value: 3.7, attrValuesIndexes: [null, null, 4], dimValuesIndexes: [] },
+      h: { value: 21.1234567, attrValuesIndexes: [null, null, 2], dimValuesIndexes: [] },
+      i: { value: 20.1, attrValuesIndexes: [null, null, 3], dimValuesIndexes: [] },
+      j: { value: 19.9, attrValuesIndexes: [null, null, 0], dimValuesIndexes: [] },
+      k: { value: 16.35, attrValuesIndexes: [null, 2, 1], dimValuesIndexes: [] },
+      l: { value: 155062.56, attrValuesIndexes: [null, null, 2], dimValuesIndexes: [] },
+      m: { value: 155062.56, attrValuesIndexes: [null, null, 0], dimValuesIndexes: [] },
+      n: { value: null, attrValuesIndexes: [null, null, 1], dimValuesIndexes: [] },
+    };
+
+    expect(enhanceObservations([], observations, attributes, { customAttributes })).to.deep.equal({
+      a: { attributes: {}, value: 2, formattedValue: '2', attrValuesIndexes: [null, null, null], dimValuesIndexes: [], indexedDimValIds: {} },
+      c: { attributes: {}, value: 10, formattedValue: '10', attrValuesIndexes: [null, 4, null], dimValuesIndexes: [], indexedDimValIds: {} },
+      d: { attributes: {}, value: 5, formattedValue: '5', attrValuesIndexes: [null, 1, null], dimValuesIndexes: [], indexedDimValIds: {} },
+      e: { attributes: {}, value: 8.3, formattedValue: '83', attrValuesIndexes: [null, 0, null], dimValuesIndexes: [], indexedDimValIds: {} },
+      f: { attributes: {}, value: 25.62, formattedValue: '0.02562', attrValuesIndexes: [null, 3, null], dimValuesIndexes: [], indexedDimValIds: {} },
+      g: { attributes: {}, value: 3.7, formattedValue: '3.7', attrValuesIndexes: [null, null, 4], dimValuesIndexes: [], indexedDimValIds: {} },
+      h: { attributes: {}, value: 21.1234567, formattedValue: '21.123', attrValuesIndexes: [null, null, 2], dimValuesIndexes: [], indexedDimValIds: {} },
+      i: { attributes: {}, value: 20.1, formattedValue: '20.10000', attrValuesIndexes: [null, null, 3], dimValuesIndexes: [], indexedDimValIds: {} },
+      j: { attributes: {}, value: 19.9, formattedValue: '20', attrValuesIndexes: [null, null, 0], dimValuesIndexes: [], indexedDimValIds: {} },
+      k: { attributes: {}, value: 16.35, formattedValue: '1.64', attrValuesIndexes: [null, 2, 1], dimValuesIndexes: [], indexedDimValIds: {} },
+      l: { attributes: {}, value: 155062.56, formattedValue: '155,062.560', attrValuesIndexes: [null, null, 2], dimValuesIndexes: [], indexedDimValIds: {} },
+      m: { attributes: {}, value: 155062.56, formattedValue: '155,063', attrValuesIndexes: [null, null, 0], dimValuesIndexes: [], indexedDimValIds: {} },
+      n: { attributes: {}, value: null, formattedValue: '..', attrValuesIndexes: [null, null, 1], dimValuesIndexes: [], indexedDimValIds: {} },
+    });
+  });
+  it('attributes', () => {
+    const attributes = [
+      {
+        id: 'a0',
+        values: [{ id: 'v0' }, { id: 'v1' }, { id: 'v2' }],
+        relationship: ['d0', 'd1'],
+        series: true
+      },
+      {
+        id: 'a1',
+        values: [{ id: 'v0' }],
+      },
+      {
+        id: 'a2',
+        values: [{ id: 'v0' }, { id: 'v1' }],
+        relationship: []
+      },
+      {
+        id: 'a3',
+        values: [{ id: 'v0' }, { id: 'v1' }],
+        relationship: ['d2', 'd3'],
+        series: true
+      },
+      {
+        id: 'a4',
+        values: [{ id: 'v0' }, { id: 'v1', display: false }],
+        relationship: ['d4'],
+        series: true
+      },
+    ];
+
+    const dimensions = [
+      {
+        id: 'd0',
+        __index: 0,
+        values: [
+          { id: 'v0', __index: 0, __indexPosition: 0 },
+          { id: 'v1', __index: 1, __indexPosition: 1 },
+          { id: 'v2', __index: 2, __indexPosition: 2 },
+          { id: 'v3', __index: 3, __indexPosition: 3, display: false }
+        ]
+      },
+      {
+        id: 'd1',
+        __index: 1,
+        values: [
+          { id: 'v0', __index: 0, __indexPosition: 0 }
+        ]
+      },
+      {
+        id: 'd2',
+        __index: 2,
+        values: [
+          { id: 'v0', __index: 0, __indexPosition: 0 }
+        ]
+      },
+      {
+        id: 'd3',
+        __index: 3,
+        values: [
+          { id: 'v0', __index: 0, __indexPosition: 0 },
+          { id: 'v1', __index: 1, __indexPosition: 1 }
+        ]
+      },
+      {
+        id: 'd4',
+        __index: 4,
+        values: [
+          { id: 'v0', __index: 0, __indexPosition: 0 }
+        ]
+      }
+    ];
+
+
+    const observations = {
+      a: {
+        attrValuesIndexes: [0, 0, 0, 0, 0],
+        dimValuesIndexes: [0, 0, 0, 0, 0],
+        value: 22,
+      },
+      b: {
+        attrValuesIndexes: [1, 0, 1, 1, 0],
+        dimValuesIndexes: [0, 0, 0, 1, 0],
+        value: 17,
+      },
+      c: {
+        attrValuesIndexes: [2, 0, null, null, 0],
+        dimValuesIndexes: [1, 0, 0, 0, 0],
+        value: 55,
+      },
+      d: {
+        attrValuesIndexes: [2, 0, null, null, null],
+        dimValuesIndexes: [2, 0, 0, 0, 0],
+        value: 35,
+      },
+      e: {
+        attrValuesIndexes: [2, null, null, null, null],
+        dimValuesIndexes: [3, 0, 0, 0, 0],
+        value: 35,
+      }
+    };
+
+
+    expect(enhanceObservations(dimensions, observations, attributes, {})).to.deep.equal({
+      a: {
+        attrValuesIndexes: [0, 0, 0, 0, 0],
+        dimValuesIndexes: [0, 0, 0, 0, 0],
+        value: 22,
+        formattedValue: '22',
+        attributes: {
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v0' }, serieKey: 'd0=v0:d1=v0', coordinates: { d0: 'v0', d1: 'v0' }, isObs: false },
+          a3: { id: 'a3', relationship: ['d2', 'd3'], value: { id: 'v0' }, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
+          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0' }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
+        },
+        indexedDimValIds: { d0: 'v0', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
+      },
+      b: {
+        attrValuesIndexes: [1, 0, 1, 1, 0],
+        dimValuesIndexes: [0, 0, 0, 1, 0],
+        value: 17,
+        formattedValue: '17',
+        attributes: {
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v1' }, serieKey: 'd0=v0:d1=v0', coordinates: { d0: 'v0', d1: 'v0' }, isObs: false },
+          a3: { id: 'a3', relationship: ['d2', 'd3'], value: { id: 'v1' }, serieKey: 'd2=v0:d3=v1', coordinates: { d2: 'v0', d3: 'v1' }, isObs: false },
+          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0' }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
+        },
+        indexedDimValIds: { d0: 'v0', d1: 'v0', d2: 'v0', d3: 'v1', d4: 'v0' }
+      },
+      c: {
+        attrValuesIndexes: [2, 0, null, null, 0],
+        dimValuesIndexes: [1, 0, 0, 0, 0],
+        value: 55,
+        formattedValue: '55',
+        attributes: {
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2' }, serieKey: 'd0=v1:d1=v0', coordinates: { d0: 'v1', d1: 'v0' }, isObs: false },
+          a3: { id: 'a3', relationship: ['d2', 'd3'], value: undefined, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
+          a4: { id: 'a4', relationship: ['d4'], value: { id: 'v0' }, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
+        },
+        indexedDimValIds: { d0: 'v1', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
+      },
+      d: {
+        attrValuesIndexes: [2, 0, null, null, null],
+        dimValuesIndexes: [2, 0, 0, 0, 0],
+        value: 35,
+        formattedValue: '35',
+        attributes: {
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2' }, serieKey: 'd0=v2:d1=v0', coordinates: { d0: 'v2', d1: 'v0' }, isObs: false },
+          a3: { id: 'a3', relationship: ['d2', 'd3'], value: undefined, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
+          a4: { id: 'a4', relationship: ['d4'], value: undefined, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
+        },
+        indexedDimValIds: { d0: 'v2', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
+      },
+      e: {
+        attrValuesIndexes: [2, null, null, null, null],
+        dimValuesIndexes: [3, 0, 0, 0, 0],
+        value: 35,
+        formattedValue: '35',
+        attributes: {
+          a0: { id: 'a0', relationship: ['d0', 'd1'], value: { id: 'v2' }, serieKey: 'd0=v3:d1=v0', coordinates: { d0: 'v3', d1: 'v0' }, isObs: false },
+          a3: { id: 'a3', relationship: ['d2', 'd3'], value: undefined, serieKey: 'd2=v0:d3=v0', coordinates: { d2: 'v0', d3: 'v0' }, isObs: false },
+          a4: { id: 'a4', relationship: ['d4'], value: undefined, serieKey: 'd4=v0', coordinates: { d4: 'v0' }, isObs: false },
+        },
+        indexedDimValIds: { d0: 'v3', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
+      }
+    });
+  });
+});
+