@sis-cc/dotstatsuite-components 22.0.1 → 22.0.2

package/src/rules2/src/parseCombinations.js

@@ -0,0 +1,102 @@
+import * as R from 'ramda';
+import { REJECTED_VALUE_IDS } from './constants';
+
+const getDisplayableValues = (values) =>
+  R.filter(
+    (val) =>
+      !R.includes(R.prop('id', val), REJECTED_VALUE_IDS) &&
+      R.propOr(true, 'display', val),
+    values,
+  );
+
+// invalid concepts:
+// - empty/null/undefined/!array values (so far)
+const hasInvalidValues = R.pipe(
+  R.prop('values'),
+  R.anyPass([R.isNil, R.complement(R.is(Array)), R.isEmpty]),
+);
+const isConceptInvalid = R.anyPass([hasInvalidValues /* add more... */]);
+const filterValidConcepts = R.reject(isConceptInvalid);
+// concepts is an array of ids... (misnamed!)
+const rejectInvalidConceptIds =
+  (concepts = []) =>
+  (combinations = []) => {
+    const validConceptIds = R.pluck('id', filterValidConcepts(concepts));
+    return R.reduce((acc, comb) => {
+      const refinedConcepts = R.intersection(validConceptIds, comb.concepts);
+      if (R.length(refinedConcepts) < 1) {
+        return acc;
+      }
+      return R.append({ ...comb, concepts: refinedConcepts }, acc);
+    }, [], combinations);
+  };
+
+export const parseCombinations = (
+  combinations,
+  parsedAttributes,
+  dimensions,
+) => {
+  const concepts = R.concat(dimensions, parsedAttributes);
+
+  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
+  const indexedAttributes = R.indexBy(R.prop('id'), parsedAttributes);
+
+  return R.pipe(
+    rejectInvalidConceptIds(concepts),
+    R.reduce((acc, comb) => {
+      let relationship = [];
+      let ids = {};
+      let displayable_values_count = 0;
+      const seriesConcepts = R.filter((concept) => {
+        if (R.has(concept, ids)) {
+          return false;
+        }
+        if (R.has(concept, indexedDimensions)) {
+          const dimension = R.prop(concept, indexedDimensions);
+          relationship = !dimension.header
+            ? R.append(concept, relationship)
+            : relationship;
+          ids = { ...ids, [concept]: concept };
+          displayable_values_count += R.length(dimension.values || []);
+          return !dimension.header;
+        } else if (!R.has(concept, indexedAttributes)) {
+          return false;
+        }
+        const attribute = R.prop(concept, indexedAttributes);
+        const displayableValues = getDisplayableValues(attribute.values || []);
+        const isDisplayable =
+          R.length(displayableValues) !== 0 &&
+          R.propOr(true, 'display', attribute);
+        relationship =
+          attribute.series && isDisplayable
+            ? R.pipe(
+                R.reject((id) => R.has(id, ids)),
+                R.concat(relationship),
+              )(attribute.relationship)
+            : relationship;
+        ids = attribute.series  && isDisplayable
+          ? { ...ids, ...R.indexBy(R.identity, attribute.relationship) }
+          : ids;
+        displayable_values_count = isDisplayable
+          ? displayable_values_count + R.length(displayableValues)
+          : displayable_values_count;
+        return attribute.series && isDisplayable;
+      }, comb.concepts);
+      if (R.isEmpty(seriesConcepts)) {
+        return R.append(
+          { ...comb, header: true, display: displayable_values_count > 0 },
+          acc,
+        );
+      }
+      return R.append(
+        {
+          ...comb,
+          series: true,
+          relationship,
+          display: displayable_values_count > 0,
+        },
+        acc,
+      );
+    }, []),
+  )(combinations);
+};

package/src/rules2/src/parseHierarchicalCodelist.js

@@ -0,0 +1,48 @@
+import * as R from 'ramda';
+
+export const parseHierarchicalCodelist = (sdmxJson, hierarchyId) => {
+  const hCodelist = R.pathOr({}, ['data', 'hierarchicalCodelists', 0], sdmxJson);
+  const hierarchy = R.find(R.propEq('id', hierarchyId), hCodelist.hierarchies || []);
+
+  const getParentedCodes = (codes, parent) => {
+    const ids = R.pluck('codeID', codes);
+
+    const siblings = R.reduce(
+      (acc, code) => {
+        if (R.isEmpty(code.hierarchicalCodes || [])) {
+          return acc;
+        }
+        return R.mergeRight(acc, getParentedCodes(code.hierarchicalCodes, code.id));
+      },
+      {},
+      codes
+    );
+
+    return ({ ...siblings, [parent]: ids });
+  };
+
+  const getChildren = (codes, parents) => {
+    const ids = R.pluck('codeID', codes);
+
+    const children = R.reduce(
+      (acc, code) => {
+        if (R.isEmpty(code.hierarchicalCodes || [])) {
+          return acc;
+        }
+        return ({
+          ...acc,
+          ...getChildren(code.hierarchicalCodes, R.append(code.codeID, parents))
+        });
+      },
+      {},
+      codes
+    );
+    const key = R.isEmpty(parents) ? '#ROOT' : R.join('.', parents);
+    return ({ ...children, [key]: ids });
+  }
+
+  return R.pipe(
+    R.propOr([], 'hierarchicalCodes'),
+    codes => getChildren(codes, []),
+  )(hierarchy);
+};

package/src/rules2/src/parseMetadataSeries.js

@@ -0,0 +1,121 @@
+import * as R from 'ramda';
+import { EMPTY_ATTACHMENT_LEVEL_CHAR } from './constants';
+
+const dimensionValueDisplay = (display) => data => {
+  if (display === 'code') {
+    return R.prop('id', data);
+  }
+  const name = R.prop('name')(data);
+  if (display === 'both') {
+    return `${R.prop('id', data)}: ${name}`;
+  }
+  return name;
+};
+// options = { locale, display, dimensions = [], attributes = { [id]: { format, parent } } };
+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 { notDisplayedIds = {} } = options;
+
+  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) || R.equals(EMPTY_ATTACHMENT_LEVEL_CHAR, vInd)) {
+            return '';
+          }
+          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.pipe(
+        R.addIndex(R.reduce)(
+          (acc, valueIndex, attrIndex) => {
+            const attribute = R.nth(attrIndex, metadataAttributes);
+            const isHidden = R.has(attribute.id, notDisplayedIds);
+            if ((R.isNil(valueIndex) && !(attribute.isPresentational)) || isHidden) {
+              return acc;
+            }
+            const attrOptions = R.pathOr({}, ['attributes', attribute.id], options);
+            const id = attrOptions.id;
+            const label = dimensionValueDisplay(options.display)({ ...attribute, id });
+
+            const _value = R.prop('value', R.nth(valueIndex, attribute.values || []));
+            const value = R.is(Object, _value) ? R.prop(options.locale, _value) : _value;
+
+            return R.append({
+              ...(R.isNil(value) ? {} : { value }),
+              id: attribute.id,
+              label,
+              handlerProps: R.omit(['id'], R.pathOr({}, ['attributes', attribute.id], options))
+            }, acc);
+          },
+          [],
+        ),
+        attributes => { // missing parents in metadata response 
+          const groupedAttrs = R.groupBy(R.pathOr('#ROOT', ['handlerProps', 'parent']), attributes);
+          const indexedAttrs = R.indexBy(R.prop('id'), attributes);
+
+          return R.reduce(
+            (acc, id) => {
+              if (R.has(id, indexedAttrs) || id === '#ROOT') {
+                return acc;
+              }
+              return R.append({
+                id,
+                label: dimensionValueDisplay(options.display)({ id, name: R.path(['attributes', id, 'name'], options) }),
+                handlerProps: R.omit(['id'], R.pathOr({}, ['attributes', id], options))
+              }, acc);
+            },
+            attributes,
+            R.keys(groupedAttrs)
+          );
+        },
+        attributes => {
+          const groupedAttrs = R.groupBy(R.pathOr('#ROOT', ['handlerProps', 'parent']), attributes);
+          const makeTree = R.map(attr => {
+            if (R.has(attr.id, groupedAttrs)) {
+              const children = makeTree(R.prop(attr.id, groupedAttrs));
+              return R.assoc('children', children, attr);
+            }
+            return attr;
+          });
+
+          return makeTree(R.propOr([], '#ROOT', groupedAttrs));
+        },
+      )(metaIndexes);
+
+      return R.assoc(evolvedKey, attributes, acc);
+    },
+      {},
+      R.keys(series)
+    ))(metadataJson);
+
+  return metadataSeries;
+};

package/src/rules2/src/prepareData.js

@@ -0,0 +1,75 @@
+import * as R from 'ramda';
+import { getObservations } from '../../rules/src';
+import { refineDimensions } from './refineDimensions';
+import { enhanceObservations } from './enhanceObservations';
+import { parseAttributes } from './parseAttributes';
+import { getCombinationDefinitions, parseCombinationDefinition } from './getCombinationDefinitions';
+import { parseCombinations } from './parseCombinations';
+import { refineAttributes } from './refineAttributes';
+import { duplicateObs } from './duplicateObservations';
+import { getMetadataCoordinates } from './getMetadataCoordinates';
+import { getAttributesSeries } from './getAttributesSeries';
+import { getManyValuesDimensions } from './getManyValuesDimensions';
+import { getOneValueDimensions } from './getOneValueDimensions';
+import { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
+import { getDataflowAttributes } from './getDataflowAttributes';
+import { getHeaderTitle } from './getHeaderTitle';
+import { getHeaderSubtitle } from './getHeaderSubtitle';
+import { getHeaderCombinations } from './getHeaderCombinations';
+import { getHeaderCoordinates } from './getHeaderCoordinates';
+import { applyHierarchicalCodesToDim } from './applyHierarchicalCodesToDim';
+
+export const prepareData = (sdmxJson, { customAttributes, locale, hierarchies, dataflow, display, defaultCombinations, dataquery }) => {
+  const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
+  const refinedDimensions = refineDimensions(dimensions, dataquery);
+  const attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
+  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
+  const observations = getObservations(sdmxJson);
+  let combinations = getCombinationDefinitions(annotations, locale);
+  if (R.isEmpty(combinations) && !R.isEmpty(defaultCombinations)) {
+    const { concepts, names } = defaultCombinations;
+    combinations = parseCombinationDefinition(locale)(concepts, names);
+  }
+  const metadataCoordinates = getMetadataCoordinates(sdmxJson);
+
+  const parsedAttributes = parseAttributes(attributes, refinedDimensions, customAttributes);
+  const parsedCombinations = parseCombinations(combinations, parsedAttributes, refinedDimensions);
+  const seriesCombinations = R.filter(R.prop('series'), parsedCombinations);
+  const refinedAttributes = refineAttributes(parsedAttributes, seriesCombinations);
+
+  const enhancedObservations = enhanceObservations(refinedDimensions, observations, refinedAttributes, { customAttributes });
+  const attributesSeries = getAttributesSeries(enhancedObservations);
+  const manyValuesDimensions = getManyValuesDimensions(refinedDimensions, attributesSeries, customAttributes, seriesCombinations);
+  const oneValueDimensions = getOneValueDimensions(refinedDimensions, parsedAttributes);
+  const rejectedDimensions = R.filter(R.prop('rejected', dimensions));
+  const headerCoordinates = getHeaderCoordinates(oneValueDimensions);
+  const hierarchisedDimensions = R.map(dim => {
+    if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
+      return hierarchiseDimensionWithNativeHierarchy(dim);
+    }
+    return applyHierarchicalCodesToDim(R.prop(dim.id, hierarchies), dim);
+  }, manyValuesDimensions)
+  const duplicatedObservations = duplicateObs(R.values(hierarchisedDimensions), enhancedObservations);
+
+  const dataflowAttributes = getDataflowAttributes(parsedAttributes, parsedCombinations);
+  const headerTitle = getHeaderTitle(dataflow, dataflowAttributes, display, customAttributes);
+  const headerSubtitle = getHeaderSubtitle(oneValueDimensions, parsedCombinations, customAttributes, display);
+  const headerCombinations = getHeaderCombinations(parsedCombinations, oneValueDimensions, refinedAttributes, display);
+  
+  return ({
+    observations: duplicatedObservations,
+    dimensions: hierarchisedDimensions,
+    combinations: parsedCombinations,
+    oneValueDimensions,
+    attributesSeries,
+    metadataCoordinates,
+    attributes: refinedAttributes,
+    rejectedDimensions,
+    header: {
+      title: headerTitle,
+      subtitle: headerSubtitle,
+      combinations: headerCombinations,
+      coordinates: headerCoordinates
+    }
+  });
+};

package/src/rules2/src/refineAttributes.js

@@ -0,0 +1,16 @@
+import * as R from 'ramda';
+
+export const refineAttributes = (parsedAttributes, seriesCombinations) => {
+  const indexedRelationships = R.reduce(
+    (acc, comb) =>
+      R.reduce((_acc, concept) => R.assoc(concept, comb.relationship, _acc), acc, comb.concepts),
+    {},
+    seriesCombinations,
+  );
+  return R.map(attr => {
+    if (R.has(attr.id, indexedRelationships)) {
+      return { ...attr, series: true, relationship: R.prop(attr.id, indexedRelationships), combined: true };
+    }
+    return attr;
+  }, parsedAttributes);
+};

package/src/rules2/src/refineDimensions.js

@@ -0,0 +1,18 @@
+import * as R from 'ramda';
+
+export const refineDimensions = (dimensions=[], dataquery='') => {
+  const selectionIds = R.pipe(R.split('.'), R.map(R.split('+')))(dataquery);
+
+  return R.addIndex(R.map)((dim, index) => {
+    const selection = R.nth(index, selectionIds);
+    const values = R.map(val => {
+      if (R.includes(val.id, selection || []) || R.isNil(selection) || R.length(selection) === 0 || R.isEmpty(R.head(selection))) {
+        return R.assoc('isSelected', true, val);
+      }
+      return R.assoc('empty', true, val);
+    }, dim.values || []);
+
+    const size = R.length(values);
+    return { ...dim, values, header: size === 1 || (size > 1 && R.length(selection) === 1 && !R.isEmpty(R.head(selection))) };
+  }, dimensions);
+};

package/src/rules2/src/refineMetadataCoordinates.js

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

package/src/rules2/src/refineTimePeriod.js

@@ -0,0 +1,127 @@
+import * as R from 'ramda';
+import * as dateFns from 'date-fns';
+import { getLocale, dateWithoutTZ } from '../../rules/src/date';
+
+const computeDisplayFreq = (start, duration) => {
+  const startMinute = dateFns.startOfMinute(start);
+  const startHour = dateFns.startOfHour(start);
+  const startDay = dateFns.startOfDay(start);
+  if (!dateFns.isEqual(start, startMinute) || duration === 'S') {
+    return 'S';
+  }
+  else if (!dateFns.isEqual(start, startHour) || !dateFns.isEqual(start, startDay)
+    || duration === 'H' || duration === 'm') {
+    return 'm';
+  }
+  else if (!dateFns.isFirstDayOfMonth(start) || duration === 'D') {
+    return 'D';
+  }
+  else if (dateFns.getMonth(start) !== 0 || duration === 'M') {
+    return 'M';
+  }
+  return 'Y';
+};
+
+const getAdder = (duration) => {
+  if (duration === 'S')
+    return dateFns.addSeconds;
+  if (duration === 'm')
+    return dateFns.addMinutes;
+  if (duration === 'H')
+    return dateFns.addHours;
+  if (duration === 'D')
+    return dateFns.addDays;
+  if (duration === 'M')
+    return dateFns.addMonths;
+  return dateFns.addYears;
+};
+
+const getFormat = (freqDisplay) => {
+  if (freqDisplay === 'Y')
+    return 'YYYY';
+  if (freqDisplay === 'D')
+    return 'YYYY-MM-DD';
+  if (freqDisplay === 'H' || freqDisplay === 'm') {
+    return 'HH:mm';
+  }
+  if (freqDisplay === 'S') {
+    return 'HH:mm:ss';
+  }
+  return 'YYYY-MMM';
+}
+
+const getEndDate = (start, mult, duration) => {
+  const adder = getAdder(duration);
+  const endDate = adder(start, Number(mult));
+  return dateFns.subSeconds(endDate, 1);
+};
+
+const computeName = (start, end, freqDisplay, locale, format) => {
+  const opts = { locale: getLocale(locale) };
+  const isSameDay = dateFns.isSameDay(start, end);
+  const isSameYear = dateFns.isSameYear(start, end);
+  if (freqDisplay === 'H' || freqDisplay === 'm' || freqDisplay === 'S') {
+    const dayFormat = getFormat('D');
+    if (isSameDay)
+      return `${dateFns.format(start, dayFormat, opts)} ${dateFns.format(start, format, opts)} - ${dateFns.format(end, format, opts)}`;
+    return `${dateFns.format(start, `${dayFormat} ${format}`, opts)} - ${dateFns.format(end, `${dayFormat} ${format}`, opts)}`;
+  }
+  if (freqDisplay !== 'M') {
+    return `${dateFns.format(start, format, opts)} - ${dateFns.format(end, format, opts)}`;
+  }
+
+  if (isSameYear && !R.includes('-', format)) {
+    const yearFormatMatch = R.match(/([Y]+)/, format);
+    const monthFormatMatch = R.match(/([M]+|Mo)/, format);
+    const yearFormat = R.length(yearFormatMatch) >= 2 ? R.nth(1, yearFormatMatch) : null;
+    const monthFormat = R.length(monthFormatMatch) >= 2 ? R.nth(1, monthFormatMatch) : null;
+    const formattedYear = yearFormat ? dateFns.format(start, yearFormat, opts) : null;
+    const formattedMonths = monthFormat ? `${dateFns.format(start, monthFormat, opts)} - ${dateFns.format(end, monthFormat, opts)}` : null;
+    if (monthFormat) {
+      return R.pipe(
+        format => yearFormat ? R.replace(yearFormat, formattedYear, format) : format,
+        R.replace(monthFormat, formattedMonths)
+      )(format);
+    }
+  }
+  return `${dateFns.format(start, format, opts)} - ${dateFns.format(end, format, opts)}`;
+};
+
+export const getStartDate = (start) => {
+  if (!R.includes('T', start) && !R.endsWith('Z', start)) {
+    return dateWithoutTZ(new Date(start));
+  }
+  return new Date(start);
+};
+
+const dateWithTZ = date => dateFns.addMinutes(date, -date.getTimezoneOffset());
+
+export const refineTimePeriod = (timePeriod, { locale, monthlyFormat='YYYY-MMM' }) => {
+  const { id } = timePeriod;
+  const split = R.split('/', id);
+  if (R.length(split) !== 2) {
+    const start = getStartDate(R.prop('start', timePeriod));
+    const end = getStartDate(R.prop('end', timePeriod))
+    return ({ ...timePeriod, start: dateWithTZ(start).toISOString(), end: dateWithTZ(end).toISOString() });
+  }
+  const [start, range] = split;
+  const startDate = getStartDate(start);
+  const match = R.match(/^P(T?)(\d+)([YMDHS])$/, range);
+  if (R.isEmpty(match) || !dateFns.isValid(startDate)) {
+    return timePeriod;
+  }
+  const [timeIndicator, mult, _duration] = R.tail(match);
+  const duration = !R.isEmpty(timeIndicator) && _duration === 'M' ? 'm' : _duration;
+  const endDate = getEndDate(startDate, mult, duration);
+  const freqDisplay = computeDisplayFreq(start, duration);
+  const format = freqDisplay === 'M' ? monthlyFormat : getFormat(freqDisplay);
+  const name = computeName(startDate, endDate, freqDisplay, locale, format);
+
+  return ({
+    ...timePeriod,
+    id,
+    name,
+    start: dateWithTZ(startDate).toISOString(),
+    end: dateWithTZ(endDate).toISOString()
+  })
+};

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

@@ -0,0 +1,9 @@
+import * as R from 'ramda';
+
+export const sdmx_3_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/table/declineObservationsOverAttributes.js

@@ -0,0 +1,32 @@
+import * as R from 'ramda';
+
+export const declineObservationsOverAttributes = (attrsIds, observations) => {
+  const obsKeys = R.keys(observations);
+  return R.reduce((acc, obsKey) => {
+    const obs = R.prop(obsKey, observations);
+    const enhancedObs = R.pipe(
+      R.over(R.lensProp('orderedDimIndexes'), R.append(0)),
+      R.over(R.lensProp('attributes'), R.omit(attrsIds)),
+      R.assocPath(['indexedDimValIds', 'OBS_ATTRIBUTES'], 'OBS_VALUE')
+    )(obs);
+    return R.addIndex(R.reduce)((_acc, attrId, attrIndex) => {
+      const attr = R.pathOr({}, ['attributes', attrId], obs);
+      if (R.isEmpty(attr) || R.isNil(R.prop('value', attr)) || !R.pathOr(true, ['value', 'display'], attr)) {
+        return _acc;
+      }
+      const declinedKey = `${obsKey}:${attrIndex+1}`;
+      const declined = {
+        ...obs,
+        attributes: {},
+        value: R.prop('value', attr),
+        formattedValue: R.prop('value', attr),
+        orderedDimIndexes: R.append(attrIndex+1, obs.orderedDimIndexes),
+        indexedDimValIds: {
+          ...obs.indexedDimValIds,
+          OBS_ATTRIBUTES: attr.id
+        }
+      };
+      return R.assoc(declinedKey, declined, _acc);
+    }, R.assoc(`${obsKey}:0`, enhancedObs, acc), attrsIds);
+  }, {}, obsKeys);
+};

package/src/rules2/src/table/getCells.js

@@ -0,0 +1,93 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './getFlagsAndNotes';
+import { hasCellMetadata } from '../hasCellMetadata';
+
+export const getCellRelevantAttributes = (attributes, attributesSeries, cellAttributeIds) => R.filter(
+  (attr) => {
+    if (R.isNil(attr.value)) {
+      return false;
+    }
+    if (R.has(attr.id, cellAttributeIds)) {
+      return true;
+    }
+    const attrInSerie = R.path([attr.serieKey, attr.id], attributesSeries);
+    return R.isNil(attrInSerie);
+  },
+  attributes
+);
+
+export const getCellCombinedSeries = (attributes, combinations) => R.reduce(
+  (acc, comb) => {
+    const values = R.reduce(
+      (acc, concept) => {
+        if (R.has(concept, comb.fixedDimValues || {})) {
+          return R.append(R.prop(concept, comb.fixedDimValues), acc);
+        }
+        if (R.has(concept, attributes || {})) {
+          return R.append(R.path([concept, 'value'], attributes), acc);
+        }
+        return acc;
+      },
+      [],
+      comb.concepts
+    );
+
+    if (R.isEmpty(values)) {
+      return acc;
+    }
+    return R.append({ ...R.pick(['id', 'name'], comb), values }, acc);
+  },
+  [],
+  combinations
+);
+
+// combinations = { cells, layout };
+export const getCells = (customAttributes, cellsAttributesId, combinations, attributesSeries, metadataCoordinates) => observations => {
+  const attributesInLayoutCombination = R.pipe(
+    R.propOr([], 'layout'),
+    R.pluck('concepts'),
+    R.unnest
+  )(combinations);
+
+  const attributesInCellsCombination = R.pipe(
+    R.propOr([], 'cells'),
+    R.pluck('concepts'),
+    R.unnest
+  )(combinations);
+
+  const _customAttributes = R.over(
+    R.lensProp('notes'),
+    notes => R.pipe(R.concat, R.uniq)(notes || [], attributesInLayoutCombination)
+  )(customAttributes);
+
+  return R.mapObjIndexed(
+    obs => {
+      const isAttrCell = R.pathOr('OBS_VAL', ['indexedDimValIds', 'OBS_ATTR'], obs) !== 'OBS_VAL';
+      const relevantAttributes = isAttrCell ? [] : getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
+      const flagsAndNotes = isAttrCell ? [] : getFlagsAndNotes(R.omit(attributesInCellsCombination, relevantAttributes), _customAttributes);
+      const combinedSeries = isAttrCell ? [] : getCellCombinedSeries(relevantAttributes, combinations.cells || []);
+      const hasAdvancedAttributes = isAttrCell
+        ? false : R.pipe(
+        R.omit(R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination])),
+        res => !R.isEmpty(res)
+      )(relevantAttributes);
+
+      const advancedAttributes = R.omit(
+        R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination]),
+        R.filter(attr => !R.isNil(attr.value), obs.attributes), 
+      );
+
+      const hasMetadata = isAttrCell ? false : hasCellMetadata(metadataCoordinates, obs.indexedDimValIds);
+
+      return ({
+        ...R.pick(['indexedDimValIds', 'key'], obs),
+        flags: R.concat(flagsAndNotes, combinedSeries),
+        sideProps: hasAdvancedAttributes || hasMetadata
+          ? { hasMetadata, coordinates: obs.indexedDimValIds, advancedAttributes } : null,
+        intValue: R.is(Number, obs.value) ? obs.value : null,
+        value: obs.formattedValue,
+      });
+    },
+    observations
+  );
+};