@sis-cc/dotstatsuite-components 10.0.0 → 11.0.0

package/lib/rules2/src/index.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _constants = require('./constants');
+
+Object.defineProperty(exports, 'SDMX_2_0_JSON_DATA_FORMAT', {
+  enumerable: true,
+  get: function get() {
+    return _constants.SDMX_2_0_JSON_DATA_FORMAT;
+  }
+});
+
+var _getSidebarData = require('./getSidebarData');
+
+Object.defineProperty(exports, 'getSidebarData', {
+  enumerable: true,
+  get: function get() {
+    return _getSidebarData.getSidebarData;
+  }
+});
+
+var _parseMetadataSeries = require('./parseMetadataSeries');
+
+Object.defineProperty(exports, 'parseMetadataSeries', {
+  enumerable: true,
+  get: function get() {
+    return _parseMetadataSeries.parseMetadataSeries;
+  }
+});
+
+var _json = require('./json2.0DataFormatPatch');
+
+Object.defineProperty(exports, 'json_2_0_0_DataFormatPatch', {
+  enumerable: true,
+  get: function get() {
+    return _json.json_2_0_0_DataFormatPatch;
+  }
+});

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

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.json_2_0_0_DataFormatPatch = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var json_2_0_0_DataFormatPatch = exports.json_2_0_0_DataFormatPatch = function json_2_0_0_DataFormatPatch(sdmxJson) {
+  var dataSet = R.pipe(R.pathOr({}, ['data', 'dataSets']), R.head)(sdmxJson);
+  var structureIndex = R.prop('structure', dataSet);
+  var structure = R.pipe(R.pathOr([], ['data', 'structures']), R.nth(structureIndex))(sdmxJson);
+
+  return R.set(R.lensPath(['data', 'structure']), structure)(sdmxJson);
+};

package/lib/rules2/src/parseMetadataSeries.js

@@ -0,0 +1,83 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseMetadataSeries = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _dotstatsuiteSdmxjs = require('@sis-cc/dotstatsuite-sdmxjs');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var dimensionValueDisplay = function dimensionValueDisplay(locale, display) {
+  return function (data) {
+    if (display === 'code') {
+      return R.prop('id', data);
+    }
+    if (display === 'both') {
+      return R.prop('id', data) + ': ' + (0, _dotstatsuiteSdmxjs.getLocalisedName)(locale)(data);
+    }
+    return (0, _dotstatsuiteSdmxjs.getLocalisedName)(locale)(data);
+  };
+};
+// options = { locale, display, dimensions = [] };
+var parseMetadataSeries = exports.parseMetadataSeries = function parseMetadataSeries(metadataJson, options) {
+  var metadataAttributes = R.pathOr([], ['data', 'structures', 0, 'attributes', 'dimensionGroup'], metadataJson);
+  var metaAttrLength = R.length(metadataAttributes);
+
+  if (!metaAttrLength) {
+    return {};
+  }
+
+  var dimensions = R.pipe(R.pathOr([], ['data', 'structures', 0, 'dimensions']), function (_ref) {
+    var _ref$series = _ref.series,
+        series = _ref$series === undefined ? [] : _ref$series,
+        _ref$observation = _ref.observation,
+        observation = _ref$observation === undefined ? [] : _ref$observation;
+    return R.concat(series, observation);
+  }, function (dims) {
+    return R.isEmpty(options.dimensions || []) ? dims : R.props(R.pluck('id', options.dimensions), R.indexBy(R.prop('id'), dims));
+  })(metadataJson);
+
+  var metadataSeries = R.pipe(R.pathOr({}, ['data', 'dataSets', 0, 'dimensionGroupAttributes']), function (series) {
+    return R.reduce(function (acc, serieKey) {
+      var indexes = series[serieKey];
+      var metaIndexes = R.take(metaAttrLength, indexes);
+
+      var evolvedKey = R.pipe(R.split(':'), R.addIndex(R.map)(function (vInd, dInd) {
+        if (R.isEmpty(vInd)) {
+          return vInd;
+        }
+        var dim = R.nth(dInd, dimensions);
+        var val = R.nth(Number(vInd), dim.values || []);
+
+        var originalVal = R.find(R.propEq('id', val.id))(R.propOr([], 'values', R.nth(dInd, options.dimensions)));
+        return R.propOr('', '__index', originalVal);
+      }), R.join(':'))(serieKey);
+
+      var attributes = R.addIndex(R.reduce)(function (acc, valueIndex, attrIndex) {
+        if (R.isNil(valueIndex)) {
+          return acc;
+        }
+        var attribute = R.nth(attrIndex, metadataAttributes);
+        var label = dimensionValueDisplay(options.locale, options.display)(attribute);
+
+        var value = R.prop('value', R.nth(valueIndex, attribute.values || []));
+
+        return R.append({
+          id: attribute.id,
+          label: 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/lib/rules2/src/refineMetadataCoordinates.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.refineMetadataCoordinates = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var refineMetadataCoordinates = exports.refineMetadataCoordinates = function refineMetadataCoordinates(metadataCoordinates, layoutIds, headerDimensionsIds) {
+  return R.reduce(function (acc, coordinates) {
+    var refinedCoord = R.omit(headerDimensionsIds, coordinates);
+    if (R.isEmpty(refinedCoord)) {
+      return acc;
+    }
+    var removedHeaderCodes = R.omit(layoutIds.header, refinedCoord);
+    if (R.isEmpty(removedHeaderCodes)) {
+      return R.over(R.lensProp('layout'), R.append(refinedCoord))(acc);
+    }
+    var removedSectionCodes = R.omit(layoutIds.sections, refinedCoord);
+    if (R.isEmpty(removedSectionCodes)) {
+      return R.over(R.lensProp('layout'), R.append(refinedCoord))(acc);
+    }
+    var 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sis-cc/dotstatsuite-components",
   "description": "Set components based on React.",
-  "version": "10.0.0",
+  "version": "11.0.0",
   "main": "lib/index.js",
   "author": "OECD",
   "license": "MIT",

package/src/index.js

@@ -2,9 +2,11 @@ import meta from '../package.json';
 console.info(`${meta.name}@${meta.version}`);
 
 import * as rules from './rules/src';
+import * as rules2 from './rules2/src';
 import * as bridgeD3React from './bridge-d3-react/src';
 
 export { rules };
+export { rules2 };
 export { bridgeD3React };
 
 export { default as RulesDriver } from './rules-driver/src';

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

@@ -1,12 +1,13 @@
 import * as R from 'ramda';
 import { dimensionValueDisplay } from '../../dimension-utils';
+import { hasCellMetadata } from '../../../../rules2/src/hasCellMetadata';
 
 const getAttrLabel = (display) => (attribute) => `${display(attribute)}: ${display(R.propOr({}, 'value', attribute))}`;
 
 export const getFlags = (customAttributesIds, display, unitsProps) => ({ attributes={}, units={} }) => {
   const refinedAttributes = R.omit(R.propOr([], 'rejected', customAttributesIds), attributes);
   const flags = R.pipe(R.pick(R.propOr([], 'flags', customAttributesIds)), R.values)(refinedAttributes);
-  const footnotes = R.pipe(R.omit(R.propOr([], 'flags', customAttributesIds)), R.values)(refinedAttributes);
+  const footnotes = R.pipe(R.pick(R.propOr([], 'footnotes', customAttributesIds)), R.values)(refinedAttributes);
 
   const unitsDisplay = R.prop('unitsDisplay', unitsProps);
   const rejectedUnitsValueIds = R.propOr([], 'rejectedValueIds', unitsProps);
@@ -73,9 +74,16 @@ export const getFlags = (customAttributesIds, display, unitsProps) => ({ attribu
   )(flags, footnotes);
 };
 
-const isValidNumber = R.both(R.is(Number), R.complement(R.equals(NaN)));
+const getSideProps = ({ attributes, indexedDimValIds }, customAttributes, metadataCoordinates) => {
+  const rejected = [...customAttributes.flags || [], ...customAttributes.footnotes || [], ...customAttributes.rejected || []];
+  const advancedAttributes = R.omit(rejected, attributes);
+  const hasAdvancedAttributes = !R.isEmpty(advancedAttributes);
+  const hasMetadata = hasCellMetadata(metadataCoordinates, indexedDimValIds);
 
-export const getCells = (data, display, customAttributes, unitsProps) => R.mapObjIndexed(
+  return hasAdvancedAttributes || hasMetadata ? { hasAdvancedAttributes, hasMetadata, coordinates: indexedDimValIds } : null;
+}
+
+export const getCells = (data, display, customAttributes, unitsProps, metadataCoordinates) => R.mapObjIndexed(
   (observation) => R.pipe(
     R.set(
       R.lensProp('flags'),
@@ -85,7 +93,8 @@ export const getCells = (data, display, customAttributes, unitsProps) => R.mapOb
     ),
     R.set(R.lensProp('intValue'), R.prop('value', observation)),
     R.set(R.lensProp('value'), R.prop('formattedValue', observation)),
-    R.assoc('indexedDimValIds', R.prop('indexedDimValIds', observation))
+    R.assoc('indexedDimValIds', R.prop('indexedDimValIds', observation)),
+    R.assoc('sideProps', getSideProps(observation, customAttributes, metadataCoordinates))
   )({}),
   R.propOr({}, 'observations', data)
 );

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

@@ -1,6 +1,7 @@
 import * as R from 'ramda';
 import { getFlags } from './getCells';
 import { dimensionValueDisplay } from '../../dimension-utils';
+import { hasCellMetadata } from '../../../../rules2/src/hasCellMetadata';
 
 export const getLayoutSerieAttributes  = (layoutSerie, seriesAttributes) => {
   const length = R.length(layoutSerie);
@@ -72,15 +73,39 @@ const getSerieKey = R.pipe(R.reduce(
   []
 ), R.join(':'));
 
-export const getLayoutDataWithFlags = (seriesAttributes, display, customAttributes) => {
-  const formatSublayout = getAttributes => R.converge(
-    (data, key, flags) => ({ data, key, flags }),
-    [
-      getSublayoutDataCells(display, customAttributes),
-      getSerieKey,
-      R.pipe(getAttributes, getFlagsFromSeriesAttributes(display, customAttributes))
-    ]
-  );
+const getCoordinates = (data, unitsId) => R.reduce(
+  (acc, entry) => {
+    const dimId = R.path(['dimension', 'id'], entry);
+    const valId = R.path(['value', 'id'], entry);
+    if (dimId === unitsId) {
+      return acc;
+    }
+    return R.assoc(dimId, valId, acc);
+  },
+  {},
+  data
+);
+
+export const getLayoutDataWithFlags = (seriesAttributes, display, customAttributes, metadataCoordinates, unitsId) => {
+  const regularAttrsIds = R.concat(customAttributes.flags || [], customAttributes.footnotes || []);
+  const formatSublayout = (getAttributes, supplData = []) => data => {
+    const attributes = getAttributes(data);
+    const key = getSerieKey(data);
+    const cells = getSublayoutDataCells(display, customAttributes)(data);
+    const flags = getFlagsFromSeriesAttributes(display, customAttributes)(attributes);
+    const coordinates = getCoordinates(R.concat(supplData, data), unitsId);
+    const hasMetadata = hasCellMetadata(metadataCoordinates, coordinates);
+    const advancedAttributesSeries = R.isNil(attributes)
+      ? {}
+      : R.filter(
+        serie => !R.isEmpty(R.omit(regularAttrsIds, R.propOr({}, 'attributes', serie))),
+        attributes
+      );
+    const hasAdvancedAttributes = !R.isEmpty(advancedAttributesSeries);
+    const sideProps = hasMetadata || hasAdvancedAttributes ? { hasAdvancedAttributes, hasMetadata, coordinates } : null;
+
+    return ({ data: cells, key, flags, sideProps });
+  };
 
   return R.evolve({
   headerData: R.map(formatSublayout(data => getLayoutSerieAttributes(data, seriesAttributes))),
@@ -91,7 +116,8 @@ export const getLayoutDataWithFlags = (seriesAttributes, display, customAttribut
       return ([
         formatSublayout(() => sectionAttributes)(sectionSerie),
         R.map(
-          formatSublayout(rowData => getLayoutSerieAttributes(R.concat(sectionSerie, rowData), R.omit(R.keys(sectionAttributes), seriesAttributes)))
+          formatSublayout(rowData => getLayoutSerieAttributes(R.concat(sectionSerie, rowData), R.omit(R.keys(sectionAttributes), seriesAttributes)),
+          sectionSerie)
         )(R.last(sectionData))
       ]);
     }

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

@@ -13,6 +13,7 @@ import { cleanUnitsInLayoutData } from '../units/cleanUnitsInLayoutData';
 import { getSortedLayoutIndexes } from './getSortedLayoutIndexes';
 import { refineLayoutSize } from './refineLayoutSize';
 import { getLayoutData } from './getLayoutData';
+import { refineMetadataCoordinates } from '../../../../rules2/src/refineMetadataCoordinates';
 
 export const getTableProps = ({ data, layoutIds, display, customAttributes, limit, isTimeInverted }) => {
   const seriesAttributes = R.propOr({}, 'seriesAttributes', data);
@@ -22,6 +23,12 @@ export const getTableProps = ({ data, layoutIds, display, customAttributes, limi
     layoutIds
   );
 
+  const headerDimensionsIds = R.pluck('id',
+      R.concat(R.pathOr([], ['units', 'headerUnits'], data), R.values(R.pathOr({}, ['dimensions', 'one'], data)))
+  );
+
+  const refinedMetadataCoordinates = refineMetadataCoordinates(data.metadataCoordinates, layoutIds, headerDimensionsIds);
+
   const {
     rejectedValueIds,
     unitDimension,
@@ -45,7 +52,8 @@ export const getTableProps = ({ data, layoutIds, display, customAttributes, limi
       unitsDefinitionCodes, unitsSeries, unitsDisplay: unitsLevelDisplay,
       unitDimension, rejectedValueIds, layoutDimsIds
     },
-    data.observationsType
+    refinedMetadataCoordinates.cells,
+    data.observationsType,
   );
 
   const dimensions = R.mapObjIndexed(
@@ -89,9 +97,10 @@ export const getTableProps = ({ data, layoutIds, display, customAttributes, limi
       unitsDefinitionCodes, unitsIndexes: unitsAttachmentIndexesInLayout,
       partialUnitSerieIndexes, rejectedValueIds, layoutIds
     }),
-    getLayoutDataWithFlags(seriesAttributesValues, display, customAttributes),
-    cleanUnitsInLayoutData({ unitsDisplay: unitsLevelDisplay, unitsLayoutIndexes: unitsIndexesInLayout })
+    getLayoutDataWithFlags(seriesAttributesValues, display, customAttributes, refinedMetadataCoordinates.layout, unitDimension.id),
+    cleanUnitsInLayoutData({ unitsDisplay: unitsLevelDisplay, unitsLayoutIndexes: unitsIndexesInLayout }),
   )(layout, R.propOr({}, 'observations', data));
+  
   return ({
     cells: getCuratedCells({ layout, observations: cells, shape: ['header', 'sections', 'rows'] }),
     layout,

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

@@ -21,6 +21,13 @@ import { getDisplay } from '../../preparators/getDisplay';
 import { getObservations } from '../../preparators/getObservations';
 import { enhanceObservations } from '../../preparators/enhanceObservations';
 
+import { getMetadataCoordinates } from '../../../../rules2/src/getMetadataCoordinates';
+import {
+  getDataflowAdvancedAttributes,
+  getObservationsAdvancedAttributes,
+  getSeriesAdvancedAttributes
+} from '../../../../rules2/src/getAdvancedAttributes';
+
 export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
   const {
     defaultCodes=[],
@@ -127,10 +134,42 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
     attributesIndexedByIds,
   );
 
-  const seriesAttributesValues = refineSeriesAttributesValues(
-    dimensionsAttributesValues.series,
-    attributesIndexedByIds,
+  const seriesAttributesValues = R.map(
+    series => refineSeriesAttributesValues(series, attributesIndexedByIds),
+    dimensionsAttributesValues
+  );
+
+  const metadataCoordinates = getMetadataCoordinates(sdmxJson);
+  const headerAttributesIds = R.concat(attributesIdsIndexedByTargets.dataflow || [], attributesIdsIndexedByTargets.oneValueDimensions || []);
+  const headerAttributes = R.pick(headerAttributesIds, attributesIndexedByIds);
+  const headerAdvancedAttrIds = R.pipe(
+    R.filter(id => !R.includes(id, customAttributes.flags || []) && !R.includes(id, customAttributes.footnotes || [])),
+  )(headerAttributesIds);
+
+  const dataflowAdvancedAttributes = getDataflowAdvancedAttributes(
+    headerAttributes,
+    oneValueDimensions,
+    headerAdvancedAttrIds,
+    R.length(dimensions)
+  );
+
+  const observationsAdvancedAttributesIds = R.filter(
+    id => !R.includes(id, customAttributes.flags || []) && !R.includes(id, customAttributes.footnotes || []),
+    attributesIdsIndexedByTargets.observations || []
   );
+  const observationsAdvancedAttributes = getObservationsAdvancedAttributes(observations, observationsAdvancedAttributesIds);
+
+  const seriesAdvancedAttributesIds = R.filter(
+    id => !R.includes(id, customAttributes.flags || []) && !R.includes(id, customAttributes.footnotes || []),
+    R.concat(attributesIdsIndexedByTargets.series || [], attributesIdsIndexedByTargets.manyValuesDimensions || [])
+  );
+
+  const seriesAdvancedAttributes = getSeriesAdvancedAttributes(
+    seriesAttributesValues,
+    dimensions,
+    seriesAdvancedAttributesIds
+  );
+
   return ({
     dimensions: {
       one: oneValueDimensions,
@@ -144,11 +183,13 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}) => {
       unitsAttachmentSeriesIds,
       unitsSeries,
     },
+    metadataCoordinates,
+    advancedAttributes: { ...dataflowAdvancedAttributes, ...observationsAdvancedAttributes, ...seriesAdvancedAttributes },
     observations,
     observationsType: getObservationsType(sdmxJson.data),
     dataflowAttributes,
     dataflowName: R.path(['data', 'structure', 'name'], sdmxJson),
     seriesAttributes: R.props(seriesAttributesIds, attributesIndexedByIds),
-    seriesAttributesValues
+    seriesAttributesValues: seriesAttributesValues.series || {}
   });
 };

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

@@ -95,22 +95,17 @@ export const dataTransformer = (dataNew, options = {}) => {
   const getAttrObservations = R.propOr([], 'observation');
   const attrObservations = getAttrObservations(attributes);
 
-  const getAttrDataset = R.propOr([], 'dataset')
-  const attrDataset = getAttrDataset(attributes);
-
-  const mergeAttr = R.concat(attrDataset, attrObservations);
-
   const resAttrObservations = R.map((observation) => ({
     ...observation,
     name: getLocalisedProp('names', observation),
-    values: getValues(observation.values),
+    values: getValues(observation.values || []),
     roles: !R.isNil(observation.role) ? R.head(observation.role) : null,
-  }), mergeAttr);
+  }), attrObservations);
 
   const resAttributes = {
     ...attributes,
     observation: resAttrObservations,
-  }
+  };
 
 //----------------------------------------------------------------------------------------Dimensions
   const getDimensions = R.propOr({}, 'dimensions');

package/src/rules2/src/constants.js

@@ -0,0 +1,2 @@
+export const SDMX_2_0_JSON_DATA_FORMAT = 'application/vnd.sdmx.data+json;version=2.0.0';
+export const SDMX_2_0_CSV_DATA_FORMAT = 'application/vnd.sdmx.data+csv;version=2.0.0';

package/src/rules2/src/getAdvAttrSeriesAtCoordinates.js

@@ -0,0 +1,29 @@
+import * as R from 'ramda';
+
+const attribueValueDisplay = (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);
+};
+
+export const getAdvAttrSeriesAtCoordinates = (coordinates, advancedAttributes, display) => R.pipe(
+  R.filter(serie => {
+    const mergedCoord = R.mergeLeft(serie.coordinates, coordinates);
+    return R.equals(mergedCoord, coordinates);
+  }),
+  R.map(serie => {
+    return R.pipe(
+      R.propOr({}, 'attributes'),
+      R.values,
+      R.map(attribute => ({
+        id: attribute.id,
+        label: attribueValueDisplay(display)(attribute),
+        value: attribueValueDisplay(display)(attribute.value)
+      }))
+    )(serie);
+  }),
+)(advancedAttributes);

package/src/rules2/src/getAdvancedAttributes.js

@@ -0,0 +1,113 @@
+import * as R from 'ramda';
+
+export const getObservationsAdvancedAttributes = (observations, advancedAttributesIds) => R.pipe(
+  R.map(obs => ({ attributes: R.pick(advancedAttributesIds, obs.attributes || {}), coordinates: obs.indexedDimValIds || {} })),
+  R.filter(entry => !R.isEmpty(entry.attributes))
+)(observations);
+
+export const getDataflowAdvancedAttributes = (attributes, dimensions, advancedAttributesIds, dimLength) => {
+  const advancedAttributes = R.pick(advancedAttributesIds, attributes);
+  const keyTemplate = R.times(R.always(''), dimLength);
+  return R.reduce(
+    (acc, attribute) => {
+      const value = R.head(attribute.values || []);
+      const attr = { ...R.pick(['id', 'name'], attribute), value };
+      let coordinates = {};
+      let key = keyTemplate;
+
+      if (!R.isEmpty(R.pathOr([], ['relationship', 'dimensions'], attribute))) {
+        const attrDimensionsIds = R.pathOr([], ['relationship', 'dimensions'], attribute);
+        const attrDimensions = R.props(attrDimensionsIds, dimensions);
+        R.forEach(
+          dim => {
+            const dId = dim.id;
+            const dIndex = dim.__index;
+            const vId = R.path(['values', 0, 'id'], dim);
+            coordinates = { ...coordinates, [dId]: vId };
+            key = R.set(R.lensIndex(dIndex), 0)(key);
+          },
+          attrDimensions
+        );
+      }
+
+      key = R.join(':', key);
+      return R.over(
+        R.lensProp(key),
+        entry => R.isNil(entry)
+          ? ({ attributes: { [attribute.id]: attr }, coordinates })
+          : R.over(R.lensProp('attributes'), R.assoc(attribute.id, attr))(entry)
+      )(acc);
+    },
+    {},
+    R.values(advancedAttributes)
+  )
+};
+
+/*
+{
+  series: {
+    '0:0:x:x:x': { attributes: { a2: { id, value } } }
+  },
+  dimensions: {
+    '3:0': { attributes: { a1: { id, value } } },
+  }
+}
+
+*/
+
+export const getSeriesAdvancedAttributes = (seriesAttributes, dimensions, advancedAttributesIds) => {
+  const seriesAdvancedAttributes = R.pipe(
+    R.propOr({}, 'series'),
+    series => R.reduce(
+      (acc, key) => {
+        const serie = series[key];
+        const advancedAttributes = R.pick(advancedAttributesIds, serie.attributes);
+        if (R.isEmpty(advancedAttributes)) {
+          return acc;
+        }
+        const splitKey = R.split(':', key); 
+        const { coordinates, refinedKey } = R.addIndex(R.reduce)(
+          (acc, vInd, dInd) => {
+            if (vInd === 'x') {
+              return ({ ...acc, refinedKey: R.append('', acc.refinedKey) });
+            }
+            const _refined = R.append(vInd, acc.refinedKey);
+            const dim = R.nth(dInd, dimensions);
+            const valId = R.path(['values', Number(vInd), 'id'], dim);
+            const _coordinates = R.assoc(dim.id, valId, acc.coordinates);
+            return ({ coordinates: _coordinates, refinedKey: _refined });
+          },
+          { coordinates: {}, refinedKey: [] },
+          splitKey
+        );
+        return R.assoc(R.join(':', refinedKey), { attributes: advancedAttributes, coordinates }, acc);
+      },
+      {},
+      R.keys(series)
+    )
+  )(seriesAttributes);
+  const keyTemplate = R.map(R.always(''), dimensions);
+  const dimensionsAdvancedAttributes = R.pipe(
+    R.propOr({}, 'dimensions'),
+    series => R.reduce(
+      (acc, key) => {
+        const serie = series[key];
+        const advancedAttributes = R.pick(advancedAttributesIds, serie.attributes);
+        if (R.isEmpty(advancedAttributes)) {
+          return acc;
+        }
+        const [dInd, vInd] = R.split(':', key);
+        const dim = R.nth(Number(dInd), dimensions);
+        const valId = R.path(['values', Number(vInd), 'id'], dim);
+        const coordinates = { [dim.id]: valId };
+        let refinedKey = keyTemplate;
+        refinedKey[Number(dInd)] = vInd;
+        return R.assoc(R.join(':', refinedKey), { attributes: advancedAttributes, coordinates }, acc);
+      },
+      {},
+      R.keys(series)
+    )
+  )(seriesAttributes);
+
+  return R.merge(seriesAdvancedAttributes, dimensionsAdvancedAttributes);
+};

package/src/rules2/src/getMetadataCoordinates.js

@@ -0,0 +1,37 @@
+import * as R from 'ramda';
+
+export const getMetadataCoordinates = (sdmxJson) => {
+  const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
+  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
+  const metadataAvailKeys = R.pipe(
+    R.pathOr([], ['data', 'dataSets', 0, 'dimensionGroupAttributes']),
+    R.map(indexes => R.props(indexes, annotations)),
+    R.filter(R.find(R.propEq('type', 'HAS_METADATA'))),
+    R.keys
+  )(sdmxJson);
+
+  return R.map(
+    key => {
+      const indexes = R.split(':', key);
+      return R.addIndex(R.reduce)(
+        (acc, vIndex, dimIndex) => {
+          if (R.isNil(vIndex) || R.isEmpty(vIndex)) {
+            return acc;
+          }
+          const dim = R.nth(dimIndex, dimensions);
+          if (R.isNil(dim)) {
+            return acc;
+          }
+          const val = R.path(['values', Number(vIndex)], dim);
+          if (R.isNil(val)) {
+            return acc;
+          }
+          return R.assoc(dim.id, val.id, acc);
+        },
+        {},
+        indexes
+      );
+    },
+    metadataAvailKeys
+  );
+};

package/src/rules2/src/getMetadataStructureFromData.js

@@ -0,0 +1,17 @@
+import * as R from 'ramda';
+
+export const getDataflowMetadataStructure = sdmxJson => {
+  const annotations = R.pathOr([], ['data', 'stucture', 'annotations'], sdmxJson);
+  const dataSetAnnotIndexes = R.pathOr([], ['data', 'dataSets', 0, 'annotations'], sdmxJson);
+  const dataSetAnnotations = R.props(dataSetAnnotIndexes, annotations);
+  const metadataAnnotation = R.find(R.propEq('type', 'METADATA'), dataSetAnnotations);
+  if (!metadataAnnotation) {
+    return null;
+  }
+  return R.pipe(
+    R.propOr('', 'title'),
+    R.split('='),
+    R.last,
+    
+  )(metadataAnnotation);
+};