@sis-cc/dotstatsuite-components 9.1.2 → 9.2.2

package/src/rules/src/table/factories/refineLayoutSize.js

@@ -0,0 +1,224 @@
+import * as R from 'ramda';
+
+const getPivotKey = indexes => R.pipe(
+  R.props(indexes),
+  R.join(':')
+);
+
+const getPivots = (layout, shape) => R.pipe(
+  R.props(shape),
+  R.map(R.pipe(R.pluck('__index'), getPivotKey))
+)(layout);
+
+const indexWithPivots = (pivots, observations) => R.pipe(
+  R.values,
+  R.reduce(
+    (acc, obs) => {
+      const path = R.map(
+        pivot => pivot(obs.orderedDimIndexes),
+        pivots
+      );
+      return R.over(
+        R.lensPath(path),
+        R.ifElse(R.isNil, R.always([obs]), R.append(obs))
+      )(acc);
+    },
+    {}
+  )
+)(observations);
+
+export const getCuratedCells = ({ layout, observations, shape }) => {
+  const pivots = getPivots(layout, shape);
+  return indexWithPivots(pivots, observations);
+};
+
+export const refineSections = (sections, extractedKeys, curatedObs) => R.pipe(
+  R.map(
+    (section) => {
+      const sectionKey = R.join(':', R.head(section) || []);
+      return R.over(
+        R.lensIndex(1),
+        R.filter(
+          rowData => {
+            const rowKey = R.join(':', rowData);
+            return R.pipe(
+              R.path([sectionKey, rowKey]),
+              R.omit(extractedKeys),
+              R.isEmpty,
+              R.not
+            )(curatedObs);
+          }
+        )
+      )(section);
+    }
+  ),
+  R.filter(
+    R.pipe(R.nth(1), R.isEmpty, R.not)
+  )
+)(sections);
+
+export const refineHeader = (header, extractedKeys, curatedObs) => R.filter( // extracted : { [sectionKey]: [...rowKeys] }
+  (header) => {
+    const headerKey = R.join(':', header);
+    return R.pipe(
+      R.prop(headerKey),
+      (sections) => {
+        return R.pickBy(
+          (rows, section) => R.pipe(
+            R.omit(R.propOr([], section, extractedKeys)),
+            R.isEmpty,
+            R.not
+          )(rows),
+          sections
+        );
+      },
+      R.isEmpty,
+      R.not
+    )(curatedObs);
+  }
+)(header);
+
+export const truncateSectionRows = (n, sectionsData) => {
+  const [rest, extracted] = R.pipe(
+    R.last, // last section
+    R.nth(1), // rows
+    R.splitAt(R.negate(n)) // truncate from the end
+  )(sectionsData);
+
+  const truncatedData = R.isEmpty(rest)
+    ? R.dropLast(1, sectionsData) // remove section if no more rows
+    : R.adjust(-1, R.adjust(1, R.always(rest)), sectionsData)
+
+  const sectionKey = R.join(':', R.pipe(R.last, R.head)(sectionsData) || []);
+  const rowKeys = R.map(R.join(':'), extracted);
+
+  const extractedLength = R.length(extracted);
+  if (extractedLength < n) {
+    const { truncated, extractedKeys } = truncateSectionRows(
+      n - extractedLength,
+      truncatedData
+    );
+    return ({ truncated, extractedKeys: { ...extractedKeys, [sectionKey]: rowKeys } });
+  }
+
+  return ({ truncated: truncatedData, extractedKeys: { [sectionKey]: rowKeys } });
+};
+
+export const truncateHeader = (n, headerData) => {
+  const [truncated, extracted] = R.splitAt(R.negate(n))(headerData);
+  return ({ truncated, extractedKeys: R.map(R.join(':'), extracted) });
+};
+
+const refineLength = length => length === 0 ? 1 : length;
+
+const truncateLayout = (isVertical) => R.ifElse(
+  R.always(isVertical),
+  truncateSectionRows,
+  truncateHeader,
+);
+
+const refineLayout = (isVertical) => R.ifElse(
+  R.always(isVertical),
+  refineHeader,
+  refineSections
+)
+
+const getShape = isVertical => isVertical ? ['header', 'sections', 'rows'] : ['sections', 'rows', 'header'];
+
+const getRefinedLayout = (isVertical, truncated, refined) => R.ifElse(
+  R.always(isVertical),
+  R.pipe(R.assoc('sections', truncated), R.assoc('header', refined)),
+  R.pipe(R.assoc('header', truncated), R.assoc('sections', refined)),
+)({});
+
+const segregateLayout = (isVertical) => R.ifElse(
+  R.always(isVertical),
+  R.props(['sections', 'header']),
+  R.props(['header', 'sections'])
+);
+
+export const refineLayoutSize = ({ layout, observations, limit }) => layoutIndexes => {
+  const { header, sections } = layoutIndexes;
+  if (R.isNil(limit) || limit === 0 || R.all(R.isEmpty, [header, sections])) {
+    return R.assoc('truncated', false, layoutIndexes);
+  }
+
+  //number of dimensions in header
+  const headerDimCount = R.pipe(
+    R.head, // first column
+    R.when(R.isNil, R.always([])),
+    R.length // number of dims
+  )(header);
+
+  //number of columns for values
+  const headerValuesCount = R.pipe(
+    R.length,
+    R.when(R.equals(0), R.always(1))
+  )(header);
+
+  //total of cells in header
+  const headerCellsCount = headerDimCount * (headerValuesCount + 1);
+
+  // number of dimensions in a row
+  const rowDimCount = R.pipe(
+    R.head, // firstSection
+    R.last, // rows,
+    R.head, // first row
+    R.length
+  )(sections);
+
+  // number of cells in a row
+  const rowCellsCount = rowDimCount + headerValuesCount + 1;
+
+  // number of rows
+  const rowsCount = R.pipe(
+    R.map(R.last),
+    R.unnest,
+    R.length,
+    R.add(1)
+  )(sections);
+
+  // total of cells in all rows
+  const rowsCellsCount = rowCellsCount * rowsCount;
+
+  // number of sections cells
+  const sectionsCellsCount = R.ifElse(
+    R.pipe(R.head, R.head, R.length, R.equals(0)),
+    R.always(0),
+    R.length
+  )(sections);
+
+  const total = rowsCellsCount + sectionsCellsCount + headerCellsCount;
+
+  const excess = total - limit;
+  if (excess <= 0) {
+    return R.assoc('truncated', false, layoutIndexes);
+  }
+
+  // total of cells in one column
+  const columnCellsCount = headerDimCount + rowsCount;
+
+  const isVertical = columnCellsCount > rowCellsCount
+
+  const [toTruncate, toRefine] = segregateLayout(isVertical)(layoutIndexes);
+
+
+  const cutLength = R.pipe(
+    R.ifElse(R.identity, R.always(rowCellsCount), R.always(columnCellsCount)),
+    R.divide(excess),
+    Math.ceil
+  )(isVertical);
+
+  const { truncated, extractedKeys } = truncateLayout(isVertical)(cutLength, toTruncate);
+
+  const curatedObs = R.pipe(
+    getShape,
+    (shape) => getCuratedCells({ layout, observations, shape })
+  )(isVertical);
+
+  const refined = refineLayout(isVertical)(toRefine, extractedKeys, curatedObs);
+
+  const result = getRefinedLayout(isVertical, truncated, refined);
+
+  return R.assoc('truncated', true, result);
+};

package/src/rules/src/table/preparators/prepareData.js

@@ -3,11 +3,9 @@ import { getObservationsType } from '../../properties/getObservationsType';
 import { parseDimensionsIds } from './parseDimensionsIds';
 import { getNoDisplayAnnotationsIndexes } from './getNoDisplayAnnotationsIndexes';
 import { getNoDisplayCodes } from './getNoDisplayCodes';
-import { getDisplay } from './getDisplay';
 import { parseAttributes } from './parseAttributes';
 import { getDimensionsAttributesRegisters } from './getDimensionsAttributesRegisters';
 import { parseAttributesValuesFromObservations } from './parseAttributesValuesFromObservations';
-import { parseObservations } from './parseObservations';
 import { getOneValueDimensions } from './getOneValueDimensions';
 import { getManyValuesDimensions } from './getManyValuesDimensions';
 import { getAttributeValue } from './getAttributeValue';
@@ -17,8 +15,11 @@ import { getUnitsDefinition } from '../units/getUnitsDefinition';
 import { getUnitsArtefacts } from '../units/getUnitsArtefacts';
 import { getHeaderUnits } from '../units/getHeaderUnits';
 import { getAttachmentSeriesIndexes } from '../units/getAttachmentSeriesIndexes';
-import { getUnitsSeriesOccurences } from '../units/getUnitsSeriesOccurences';
-import { refineDimSeriesUnits } from '../units/refineDimSeriesUnits';
+import { getUnitsSeries } from '../units/getUnitsSeries';
+
+import { getDisplay } from '../../preparators/getDisplay';
+import { getObservations } from '../../preparators/getObservations';
+import { enhanceObservations } from '../../preparators/enhanceObservations';
 
 export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
   const {
@@ -30,10 +31,7 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
     defaultCodes, annotationsDefinitionCodes, data: sdmxJson
   });
   const _customAttributes = R.assoc('units', unitsDefinitionCodes, customAttributes);
-  const dimensions = R.pipe(
-    R.pathOr([], ['data', 'structure', 'dimensions', 'observation']),
-    R.addIndex(R.map)((dim, index) => R.assoc('__index', index, dim))
-  )(sdmxJson);
+  const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
 
   const dimensionsIndexedByIds = R.indexBy(R.prop('id'), dimensions);
 
@@ -60,40 +58,33 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
     const attachmentSeriesIndexes = getAttachmentSeriesIndexes({ dimensions: _dimensions, unitsArtefacts });
   //------------------------------------------------------------------
 
+  const attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
+
   const { attributesIndexedByIds, attributesIdsIndexedByTargets } = parseAttributes({
     attributes: R.concat(
-      R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson),
+      attributes,
       R.pathOr([], ['data', 'structure', 'attributes', 'dataSet'], sdmxJson),
     ),
     parsedDimensionsIds,
     getDisplay: _getDisplay,
     customAttributes: _customAttributes,
   });
-  
+
   const seriesAttributesIds = R.propOr([], 'series', attributesIdsIndexedByTargets);
   const observationsAttributesIds = R.propOr([], 'observations', attributesIdsIndexedByTargets);
-  const observations = parseObservations(
-    R.pathOr({}, ['data', 'dataSets', 0, 'observations'], sdmxJson),
-    dimensions,
-    R.pick(R.concat(seriesAttributesIds, observationsAttributesIds), attributesIndexedByIds),
-    R.pipe(
-      R.pick(['prefscale', 'decimals']),
-      R.mapObjIndexed(R.flip(R.prop)(attributesIndexedByIds))
-    )(attributesIdsIndexedByTargets),
-    unitsArtefacts,
-    _getDisplay
-  );
+  const options = {
+    attachmentSeriesIndexes,
+    customAttributes,
+    noDisplayIndexes,
+    notDisplayedCodes,
+    attributesIds: R.concat(seriesAttributesIds, observationsAttributesIds),
+    unitsIds: unitsDefinitionCodes,
+  };
+  
+  const _observations = getObservations(sdmxJson);
+  const observations = enhanceObservations(dimensions, _observations, attributes, options);
   //------------------------------------------------------------------
-  const { rawUnitsSeries, obs } = getUnitsSeriesOccurences({
-    unitsArtefacts, attachmentSeriesIndexes
-  })(observations);
-  const unitsSeries = refineDimSeriesUnits({
-    unitsArtefacts: R.merge(
-      R.pathOr({}, ['dimensions', 'series'], unitsArtefacts),
-      R.pathOr({}, ['attributes', 'series'], unitsArtefacts)
-    ),
-    rejectedValueIds
-  })(rawUnitsSeries);
+  const unitsSeries = getUnitsSeries(observations);
   const unitsAttachmentSeriesIds = R.pipe(
     R.props(attachmentSeriesIndexes),
     R.pluck('id')
@@ -153,7 +144,7 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
       unitsAttachmentSeriesIds,
       unitsSeries,
     },
-    observations: obs,
+    observations,
     observationsType: getObservationsType(sdmxJson.data),
     dataflowAttributes,
     dataflowName: R.path(['data', 'structure', 'name'], sdmxJson),

package/src/rules/src/table/units/getAttachmentSeriesIndexes.js

@@ -21,6 +21,7 @@ export const getAttachmentSeriesIndexes = ({
     R.props(R.concat(unitsDimensionsCodes, targettedDimensionsCodes)),
     R.filter(dim => !R.isNil(dim)),
     R.pluck('index'),
-    R.uniq
+    R.uniq,
+    R.sortBy(R.identity)
   )(dimensions);
 };

package/src/rules/src/table/units/getUnitsSeries.js

@@ -0,0 +1,20 @@
+import * as R from 'ramda';
+
+/*
+  observations = { [obsKey]: { units: { serieKey: '', [id]: { id, name, value } } } };
+*/
+
+export const getUnitsSeries = (observations) => {
+  let series = {};
+  R.map(obs => {
+    series = R.over(R.lensProp(obs.units.serieKey), R.ifElse(R.isNil, R.always([obs.units]), R.append(obs.units)))(series);
+  }, observations);
+
+  return R.map(
+    serie => R.reduce(
+      (acc, units) => R.mergeWith((a, b) => R.path(['value', 'index'], a) === R.path(['value', 'index'], b) ? a : null, acc, units),
+      {},
+      serie
+    )
+  )(series);
+};

package/src/rules/src/v8-transformer.js

@@ -112,7 +112,7 @@ export const dataTransformer = (dataNew, options = {}) => {
   const getDimObservations = R.propOr([], 'observation');
   const dimObservations = getDimObservations(dimensions);
 
-  const getObservations = locale => R.reduce((acc, observation) => {
+  const getObservations = locale => R.addIndex(R.reduce)((acc, observation, obsIndex) => {
     const id = R.prop('id')(observation);
     const dimAnnotations = getRelationnalAnnotations(R.propOr([],'annotations')(observation))(annotations)
     const isHidden = R.includes(id)(hiddenIds) ? hiddenFormat : getIsHidden(dimAnnotations);
@@ -147,6 +147,7 @@ export const dataTransformer = (dataNew, options = {}) => {
     return ({
       observation: R.append({
         ...observation,
+        __index: obsIndex,
         name: getLocalisedProp('names', observation),
         values: sortedValues,
         role: R.isNil(observation.roles) ? null : R.head(observation.roles),

package/test/appendUnitsInLayoutDataEntry.test.js

@@ -29,7 +29,7 @@ describe('appendUnitsInLayoutDataEntry tests', () => {
       unitsDefinitionCodes: [],
       unitsIndexes: [],
       partialUnitSerieIndexes: []
-    })([])).to.deep.equal([{ dimension: {}, value: { id: 'VAL', unitsLabel: '' } }]);
+    })([])).to.deep.equal([{ dimension: {}, value: { id: '', unitsLabel: '' } }]);
   });
   it('complete test', () => {
     expect(appendUnitsInLayoutDataEntry({
@@ -43,7 +43,7 @@ describe('appendUnitsInLayoutDataEntry tests', () => {
       { dimension: { id: 'D1', __index: 2 }, value: { id: 'V', __index: 0 } },
       { dimension: { id: 'D2', __index: 0 }, value: { id: 'V', __index: 0 } },
       { dimension: { id: 'D3', __index: 4 }, value: { id: 'V', __index: 0 } },
-      { dimension: { id: 'U' }, value: { id: 'VAL', unitsLabel: 'U3V, U1V' } }
+      { dimension: { id: 'U' }, value: { id: 'U3V - U1V', unitsLabel: 'U3V, U1V' } }
     ]);
   });
   it('rejectedValues test', () => {
@@ -59,7 +59,7 @@ describe('appendUnitsInLayoutDataEntry tests', () => {
         { dimension: { id: 'D1', __index: 2 }, value: { id: 'V', __index: 0 } },
         { dimension: { id: 'D2', __index: 0 }, value: { id: 'V', __index: 0 } },
         { dimension: { id: 'D3', __index: 4 }, value: { id: 'V', __index: 0 } },
-        { dimension: { id: 'U' }, value: { id: 'VAL', unitsLabel: 'U1V' } }
+        { dimension: { id: 'U' }, value: { id: 'U1V', unitsLabel: 'U1V' } }
     ]);
   })
 });

package/test/enhanceObservations.test.js

@@ -0,0 +1,270 @@
+import { expect } from 'chai';
+import { enhanceObservations } from '../src/rules/src/preparators/enhanceObservations';
+import numeral from 'numeral';
+
+numeral.register('locale', 'eObs', { delimiters: { thousands: ",", decimal: "."  } });
+describe('enhanceObservations tests', () => {
+  it('blank test', () => {
+    expect(enhanceObservations([], {}, [], {})).to.deep.equal({});
+  });
+  it('orderedDimIndexes test', () => {
+    const dimensions = [
+      { id: 'D1', values: [{ id: 'v1', __indexPosition: 2 }, { id: 'v2', __indexPosition: 0 }, { id: 'v3', __indexPosition: 1 }] },
+      { id: 'D2', values: [{ id: 'v1', __indexPosition: 1 }, { id: 'v2', __indexPosition: 2 }, { id: 'v3', __indexPosition: 0 }] },
+      { id: 'D3', values: [{ id: 'v1', __indexPosition: 0 }] }
+    ];
+    const observations = {
+      a: { dimValuesIndexes: [0, 0, 0], value: '1' },
+      b: { dimValuesIndexes: [0, 1, 0], value: '2' },
+      c: { dimValuesIndexes: [0, 2, 0], value: '3' },
+      d: { dimValuesIndexes: [1, 0, 0], value: '4' },
+      e: { dimValuesIndexes: [1, 1, 0], value: '5' },
+      f: { dimValuesIndexes: [1, 2, 0], value: '6' },
+      g: { dimValuesIndexes: [2, 0, 0], value: '7' },
+      h: { dimValuesIndexes: [2, 1, 0], value: '8' },
+      i: { dimValuesIndexes: [2, 2, 0], value: '9' }
+    };
+    expect(enhanceObservations(dimensions, observations, [], {})).to.deep.equal({
+      a: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [0, 0, 0], orderedDimIndexes: [2, 1, 0], value: '1', formattedValue: '1', indexedDimValIds: { D1: 'v1', D2: 'v1', D3: 'v1' } },
+      b: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [0, 1, 0], orderedDimIndexes: [2, 2, 0], value: '2', formattedValue: '2', indexedDimValIds: { D1: 'v1', D2: 'v2', D3: 'v1' } },
+      c: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [0, 2, 0], orderedDimIndexes: [2, 0, 0], value: '3', formattedValue: '3', indexedDimValIds: { D1: 'v1', D2: 'v3', D3: 'v1' } },
+      d: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [1, 0, 0], orderedDimIndexes: [0, 1, 0], value: '4', formattedValue: '4', indexedDimValIds: { D1: 'v2', D2: 'v1', D3: 'v1' } },
+      e: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [1, 1, 0], orderedDimIndexes: [0, 2, 0], value: '5', formattedValue: '5', indexedDimValIds: { D1: 'v2', D2: 'v2', D3: 'v1' } },
+      f: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [1, 2, 0], orderedDimIndexes: [0, 0, 0], value: '6', formattedValue: '6', indexedDimValIds: { D1: 'v2', D2: 'v3', D3: 'v1' } },
+      g: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [2, 0, 0], orderedDimIndexes: [1, 1, 0], value: '7', formattedValue: '7', indexedDimValIds: { D1: 'v3', D2: 'v1', D3: 'v1' } },
+      h: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [2, 1, 0], orderedDimIndexes: [1, 2, 0], value: '8', formattedValue: '8', indexedDimValIds: { D1: 'v3', D2: 'v2', D3: 'v1' } },
+      i: { attributes: {}, units: { serieKey: 'x:x:x' }, dimValuesIndexes: [2, 2, 0], orderedDimIndexes: [1, 0, 0], value: '9', formattedValue: '9', indexedDimValIds: { D1: 'v3', D2: 'v3', D3: 'v1' } }
+    });
+  });
+
+  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: {}, units: { serieKey: '' }, value: 2, formattedValue: '2', attrValuesIndexes: [null, null, null], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      c: { attributes: {}, units: { serieKey: '' }, value: 10, formattedValue: '10', attrValuesIndexes: [null, 4, null], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      d: { attributes: {}, units: { serieKey: '' }, value: 5, formattedValue: '5', attrValuesIndexes: [null, 1, null], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      e: { attributes: {}, units: { serieKey: '' }, value: 8.3, formattedValue: '83', attrValuesIndexes: [null, 0, null], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      f: { attributes: {}, units: { serieKey: '' }, value: 25.62, formattedValue: '0.02562', attrValuesIndexes: [null, 3, null], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      g: { attributes: {}, units: { serieKey: '' }, value: 3.7, formattedValue: '3.7', attrValuesIndexes: [null, null, 4], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      h: { attributes: {}, units: { serieKey: '' }, value: 21.1234567, formattedValue: '21.123', attrValuesIndexes: [null, null, 2], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      i: { attributes: {}, units: { serieKey: '' }, value: 20.1, formattedValue: '20.10000', attrValuesIndexes: [null, null, 3], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      j: { attributes: {}, units: { serieKey: '' }, value: 19.9, formattedValue: '20', attrValuesIndexes: [null, null, 0], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      k: { attributes: {}, units: { serieKey: '' }, value: 16.35, formattedValue: '1.64', attrValuesIndexes: [null, 2, 1], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      l: { attributes: {}, units: { serieKey: '' }, value: 155062.56, formattedValue: '155,062.560', attrValuesIndexes: [null, null, 2], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      m: { attributes: {}, units: { serieKey: '' }, value: 155062.56, formattedValue: '155,063', attrValuesIndexes: [null, null, 0], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+      n: { attributes: {}, units: { serieKey: '' }, value: null, formattedValue: '..', attrValuesIndexes: [null, null, 1], dimValuesIndexes: [], orderedDimIndexes: [], indexedDimValIds: {} },
+    });
+  });
+
+  it('attributes and units test', () => {
+    const attributes = [
+      {
+        id: 'a0',
+        values: [{ id: 'v0' }, { id: 'v1' }, { id: 'v2' }],
+      },
+      {
+        id: 'a1',
+        values: [{ id: 'v0' }],
+      },
+      {
+        id: 'a2',
+        values: [{ id: 'v0' }, { id: 'v1' }],
+      },
+      {
+        id: 'a3',
+        values: [{ id: 'v0' }, { id: 'v1' }],
+      },
+      {
+        id: 'a4',
+        values: [{ id: 'v0' }, { id: 'v1' }],
+      },
+    ];
+
+    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 }
+        ]
+      },
+      {
+        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, 1],
+        dimValuesIndexes: [2, 0, 0, 0, 0],
+        value: 35,
+      },
+      e: {
+        attrValuesIndexes: [2, null, null, null, null],
+        dimValuesIndexes: [3, 0, 0, 0, 0],
+        value: 35,
+      }
+    };
+
+    const options = {
+      noDisplayIndexes: [],
+      notDisplayedCodes: {
+        d0: { values: { v3: 'v3' } },
+        a4: { values: { v1: 'v1' } }
+      },
+      attributesIds: ['a0', 'a1'],
+      unitsIds: ['d0', 'a4'],
+    };
+
+    expect(enhanceObservations(dimensions, observations, attributes, options)).to.deep.equal({
+      a: {
+        attrValuesIndexes: [0, 0, 0, 0, 0],
+        dimValuesIndexes: [0, 0, 0, 0, 0],
+        orderedDimIndexes: [0, 0, 0, 0, 0],
+        value: 22,
+        formattedValue: '22',
+        units: {
+          d0: { id: 'd0', __index: 0, value: { id: 'v0', index: 0, __index: 0, __indexPosition: 0 } },
+          a4: { id: 'a4', __index: 4, value: { id: 'v0', index: 0 } },
+          serieKey: 'x:x:x:x:x'
+        },
+        attributes: {
+          a0: { id: 'a0', value: { id: 'v0' } },
+          a1: { id: 'a1', value: { id: 'v0' } }
+        },
+        indexedDimValIds: { d0: 'v0', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
+      },
+      b: {
+        attrValuesIndexes: [1, 0, 1, 1, 0],
+        dimValuesIndexes: [0, 0, 0, 1, 0],
+        orderedDimIndexes: [0, 0, 0, 1, 0],
+        value: 17,
+        formattedValue: '17',
+        units: {
+          d0: { id: 'd0', __index: 0, value: { id: 'v0', index: 0, __index: 0, __indexPosition: 0 } },
+          a4: { id: 'a4', __index: 4, value: { id: 'v0', index: 0 } },
+          serieKey: 'x:x:x:x:x'
+        },
+        attributes: {
+          a0: { id: 'a0', value: { id: 'v1' } },
+          a1: { id: 'a1', value: { id: 'v0' } }
+        },
+        indexedDimValIds: { d0: 'v0', d1: 'v0', d2: 'v0', d3: 'v1', d4: 'v0' }
+      },
+      c: {
+        attrValuesIndexes: [2, 0, null, null, 0],
+        dimValuesIndexes: [1, 0, 0, 0, 0],
+        orderedDimIndexes: [1, 0, 0, 0, 0],
+        value: 55,
+        formattedValue: '55',
+        units: {
+          d0: { id: 'd0', __index: 0, value: { id: 'v1', index: 1, __index: 1, __indexPosition: 1 } },
+          a4: { id: 'a4', __index: 4, value: { id: 'v0', index: 0 } },
+          serieKey: 'x:x:x:x:x'
+        },
+        attributes: {
+          a0: { id: 'a0', value: { id: 'v2' } },
+          a1: { id: 'a1', value: { id: 'v0' } }
+        },
+        indexedDimValIds: { d0: 'v1', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
+      },
+      d: {
+        attrValuesIndexes: [2, 0, null, null, 1],
+        dimValuesIndexes: [2, 0, 0, 0, 0],
+        orderedDimIndexes: [2, 0, 0, 0, 0],
+        value: 35,
+        formattedValue: '35',
+        units: {
+          d0: { id: 'd0', __index: 0, value: { id: 'v2', index: 2, __index: 2, __indexPosition: 2 } },
+          serieKey: 'x:x:x:x:x'
+        },
+        attributes: {
+          a0: { id: 'a0', value: { id: 'v2' } },
+          a1: { id: 'a1', value: { id: 'v0' } }
+        },
+        indexedDimValIds: { d0: 'v2', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
+      },
+      e: {
+        attrValuesIndexes: [2, null, null, null, null],
+        dimValuesIndexes: [3, 0, 0, 0, 0],
+        orderedDimIndexes: [3, 0, 0, 0, 0],
+        value: 35,
+        formattedValue: '35',
+        units: { serieKey: 'x:x:x:x:x' },
+        attributes: {
+          a0: { id: 'a0', value: { id: 'v2' } }
+        },
+        indexedDimValIds: { d0: 'v3', d1: 'v0', d2: 'v0', d3: 'v0', d4: 'v0' }
+      }
+    });
+  });
+});

package/test/getAttachmentSeriesIndexes.test.js

@@ -30,6 +30,6 @@ describe('getAttachmentSeriesIndexes test', () => {
   });
   it('basic test', () => {
     expect(getAttachmentSeriesIndexes({ dimensions, unitsArtefacts }))
-      .to.deep.equal([0, 3, 2]);
+      .to.deep.equal([0, 2, 3]);
   });
 });