@sis-cc/dotstatsuite-components 15.0.20 → 16.0.0

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

@@ -1,27 +0,0 @@
-import * as R from 'ramda';
-
-export const getConfirmedSeriesAttributesIds = (attributes, layoutIds) => R.reduce(
-  (acc, attribute) => {
-    const targetDimensions = R.pathOr([], ['relationship', 'dimensions'], attribute);
-
-    const headerTargets = R.intersection(targetDimensions, R.propOr([], 'header', layoutIds));
-    const sectionsAndRows = R.pipe(
-      R.props(['sections', 'rows']),
-      R.map(R.when(R.isNil, R.always([]))),
-      R.unnest
-    )(layoutIds);
-    const rowsTargets = R.intersection(targetDimensions, sectionsAndRows);
-
-    const isValid = R.pipe(
-      R.reject(R.isEmpty),
-      R.length,
-      R.equals(1),
-    )([headerTargets, rowsTargets]);
-
-    return R.when(
-      R.always(isValid),
-      R.append(attribute.id)
-    )(acc);
-  },
-  []
-)(attributes);

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

@@ -1,40 +0,0 @@
-import * as R from 'ramda';
-
-/*
-
-example shape = ['header', 'sections', 'rows']
-
-*/
-
-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 splitKey = R.split(':', obs.key);
-      const path = R.map(
-        pivot => pivot(splitKey),
-        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);
-};

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

@@ -1,171 +0,0 @@
-import * as R from 'ramda';
-
-const indexesToLayoutData = (dimensions, indexes) => R.addIndex(R.map)(
-  (valueIndex, dimensionIndex) => {
-    const dimension = R.nth(dimensionIndex, dimensions);
-    return ({
-      dimension: R.pick(['id', 'name', '__index'], dimension),
-      value: R.nth(Number(valueIndex), R.propOr([], 'values', dimension))
-    });
-  },
-  indexes
-);
-
-const parseParents = (value, previous) => {
-  const previousParents = R.pathOr([], ['value', 'parents'], previous);
-  const indexedParents = R.indexBy(R.identity, value.parents);
-
-  const refinedParents = R.reduce(
-    (acc, id) => {
-      if (R.has(id, indexedParents)) {
-        return R.append(id, acc);
-      }
-      return acc;
-    },
-    [],
-    R.append(R.path(['value', 'id'], previous), previousParents)
-  );
-  const lastParent = R.last(refinedParents);
-  const missingParents = R.takeLastWhile(id => id !== lastParent, value.parents);
-
-  return ({ parents: refinedParents, missingIds: missingParents });
-};
-
-const getRowData = (indexes, dimension) => {
-  return R.pipe(
-    R.propOr([], 'values'),
-    R.props(indexes),
-    R.reduce(
-      ({ data, missingParents }, _value) => {
-        if (R.isNil(_value)) {
-          return ({ data, missingParents: {} });
-        }
-        const raw = {
-          dimension: R.pick(['id', 'name', '__index'], dimension),
-          value: _value,
-        };
-        if (R.isNil(_value.parents) || R.isEmpty(_value.parents)) {
-          return ({ data: R.append([raw], data), missingParents: {} });
-        }
-        const previous = R.head(R.last(data) || []);
-        if (R.last(_value.parents) === R.path(['value', 'id'], previous)) { //previous is parent
-          const value = R.set(
-            R.lensPath(['value', 'parents']),
-            R.append(
-              R.path(['value', 'id'], previous),
-              R.pathOr([], ['value', 'parents'], previous)
-            )
-          )(raw);
-          return ({ data: R.append([value], data), missingParents: {} });
-        }
-
-        const previousParent = R.pipe(R.pathOr([], ['value', 'parents']), R.last)(previous);
-        if (R.last(_value.parents) === previousParent) { //previous is bro
-          const value = R.set(
-            R.lensPath(['value']),
-            {
-              ..._value,
-              name: R.isEmpty(missingParents) ? _value.name : `${missingParents.name} > ${_value.name}`,
-              parents: R.pathOr([], ['value', 'parents'], previous)
-            }
-          )(raw);
-          return ({ data: R.append([value], data), missingParents });
-        }
-        const { parents, missingIds } = parseParents(_value, previous);
-        const _missingParents = R.reduce(
-          (acc, value) => {
-            if (value.id !== R.head(acc.missingIds)) {
-              return acc;
-            }
-            const _missingIds = R.tail(acc.missingIds);
-            if (R.isEmpty(acc.name)) {
-              return ({ name: value.name, missingIds: _missingIds });
-            }
-            return ({
-              name: `${acc.name} > ${value.name}`,
-              missingIds: _missingIds
-            });
-          },
-          { name: '', missingIds },
-          dimension.values
-        );
-
-        const value = R.set(
-          R.lensProp('value'),
-          {
-            ..._value,
-            parents,
-            name: R.isEmpty(missingIds) ? _value.name : `${_missingParents.name} > ${_value.name}`,
-          }
-        )(raw);
-
-        return ({ data: R.append([value], data), missingParents: R.isEmpty(missingIds) ? {} : _missingParents });
-      },
-      { data: [], missingParents: {} }
-    ),
-    R.prop('data')
-  )(dimension);
-};
-
-const getRowsData = (rowsIndexes, dimensions) => {
-  const dimension = R.head(dimensions);
-
-  if (R.length(dimensions) === 1) {
-    return getRowData(R.unnest(rowsIndexes), R.head(dimensions));
-  }
-
-  const groupedIndexes = R.reduce(
-    (acc, indexes) => {
-      const headIndex = R.head(indexes);
-      const last = R.last(acc.heads);
-      if (last === headIndex) {
-        return ({
-          ...acc,
-          tails: R.over(
-            R.lensIndex(-1),
-            R.append(R.tail(indexes))
-          )(acc.tails)
-        });
-      }
-      return ({
-        heads: R.append(headIndex, acc.heads),
-        tails: R.append([R.tail(indexes)], acc.tails)
-      });
-    },
-    { heads: [], tails: [] },
-    rowsIndexes
-  );
-
-  const headsDatas = getRowData(groupedIndexes.heads, R.head(dimensions));
-
-  const res = R.addIndex(R.map)(
-    (tail, i) => {
-      const tailData = getRowsData(tail, R.tail(dimensions));
-      return R.map(
-        R.prepend(R.head(headsDatas[i])),
-        tailData
-      );
-    },
-    groupedIndexes.tails
-  );
-
-  return R.unnest(res);
-};
-
-export const getLayoutData = (layoutIndexes, layout) => {
-  const { header, sections, ...rest } = layoutIndexes;
-  const headerData = R.map(i => R.pipe(indexesToLayoutData, R.filter(R.prop('value')))(layout.header, i), header);
-
-  const sectionsData = R.map(
-    ([sectionIndexes, rows]) => {
-      const sectionData = R.pipe(indexesToLayoutData, R.filter(R.prop('value')))(layout.sections, sectionIndexes);
-
-
-      const rowsData = getRowsData(rows, layout.rows);
-
-      return [sectionData, rowsData];
-    },
-    sections
-  );
-  return ({ headerData, sectionsData, ...rest });
-};

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

@@ -1,137 +0,0 @@
-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);
-  if (length === 0) {
-    return null;
-  }
-
-  const serieIndexes = R.reduce(
-    (acc, entry) => {
-      const dimIndex = R.pathOr(null, ['dimension', '__index'], entry);
-      const valIndex = R.pathOr(null, ['value', '__index'], entry);
-
-      if (R.isNil(dimIndex) || R.isNil(valIndex)) {
-        return acc;
-      }
-
-      return R.assoc(String(dimIndex), String(valIndex))(acc);
-    },
-    {},
-    layoutSerie
-  );
-
-  return R.pipe(
-    R.filter(
-      R.pipe(
-        R.propOr([], 'serie'),
-        R.addIndex(R.all)((valIndex, dimIndex) => {
-          if (valIndex === 'x') {
-            return true;
-          }
-          return R.propEq(String(dimIndex), String(valIndex), serieIndexes);
-        }),
-      ),
-    )
-  )(seriesAttributes);
-};
-
-const getFlagsFromSeriesAttributes = (display, customAttributes) => R.pipe(
-  R.values,
-  R.pluck('attributes'),
-  R.mergeAll,
-  (attributes) => getFlags(customAttributes, dimensionValueDisplay(display))({ attributes })
-);
-
-const formatCell = (display, customAttributes) => R.converge(
-  (label, flags, others) => ({ label, flags, ...others }),
-  [
-    dimensionValueDisplay(display),
-    getFlags(customAttributes, dimensionValueDisplay(display)),
-    R.pick(['parents', 'unitsLabel', 'id'])
-  ]
-);
-
-export const getSublayoutDataCells = (display, customAttributes) => R.map(
-  R.evolve({
-    dimension: formatCell(display, customAttributes),
-    value: formatCell(display, customAttributes)
-  })
-);
-
-const getSerieKey = R.pipe(R.reduce(
-  (acc, entry) => {
-    const index = R.pathOr(null, ['value', '__index'], entry);
-    if (R.isNil(index)) {
-      return acc;
-    }
-    return R.append(index, acc);
-  },
-  []
-), R.join(':'));
-
-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.notes || []);
-  const formatSublayout = (getAttributes, mCoordinates = [], 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(mCoordinates, coordinates);
-    const dataAdvancedAttrs = R.reduce(
-      (acc, { dimension, value }) => {
-        const attrs = { ...dimension.attributes || {}, ...value.attributes || {}};
-        const advAttrs = R.omit(regularAttrsIds, attrs);
-        return  ({ ...acc, ...advAttrs })
-      },
-      {},
-      data
-    );
-    const advancedAttributesSeries = R.isNil(attributes)
-      ? {}
-      : R.filter(
-        serie => !R.isEmpty(R.omit(regularAttrsIds, R.propOr({}, 'attributes', serie))),
-        attributes
-      );
-    const hasAdvancedAttributes = !R.isEmpty(advancedAttributesSeries) || !R.isEmpty(dataAdvancedAttrs);
-    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), metadataCoordinates.header)),
-  sectionsData: R.map(
-    sectionData => {
-      const sectionSerie = R.head(sectionData);
-      const sectionAttributes = getLayoutSerieAttributes(sectionSerie, seriesAttributes);
-      return ([
-        formatSublayout(() => sectionAttributes, metadataCoordinates.sections)(sectionSerie),
-        R.map(
-          formatSublayout(
-            rowData => getLayoutSerieAttributes(R.concat(sectionSerie, rowData), R.omit(R.keys(sectionAttributes), seriesAttributes)),
-            metadataCoordinates.rows,
-            sectionSerie)
-        )(R.last(sectionData))
-      ]);
-    }
-  )
-});
-}

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

@@ -1,108 +0,0 @@
-import * as R from 'ramda';
-
-/*
-
-const layout = {
-  header: [
-    { ...dim, values: [] } // values already sorted regarding order annotation
-  ],
-  rows: [],
-  sections: []
-};
-
-const observations = {
-  [obsKey]: {
-    ...obs,
-    orderedDimIndexes: [sortedValIndex]
-  }
-}
-
-*/
-
-const getLayoutPivots = layout => {
-  return R.mapObjIndexed(
-    dimensions => R.props(R.pluck('__index', dimensions)),
-  )(layout);
-};
-
-const comparator = size => (a, b) => {
-  let i = 0;
-  while (a[i] === b[i] && i < size) {
-    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(':', 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 headerLength = R.length(layout.header);
-
-  const sectionLength = R.length(layout.sections);
-  const rowLength = R.length(layout.rows);
-
-  const layoutPivots = getLayoutPivots(layout);
-
-  const { header, sections } = R.pipe(
-    R.reduce(
-      (acc, indexes) => {
-        const headerIndexes = layoutPivots.header(indexes);
-        const sectionsIndexes = layoutPivots.sections(indexes);
-        const rowsIndexes = layoutPivots.rows(indexes);
-
-        return ({
-          header: R.append(headerIndexes, acc.header),
-          sections: R.append(
-            R.concat(sectionsIndexes, rowsIndexes),
-            acc.sections
-          )
-        });
-      },
-      { header: [], sections: [] },
-    ),
-    R.mapObjIndexed(uniqIndexes),
-    R.evolve({
-      header: R.sort(comparator(headerLength)),
-      sections: R.sort(comparator(sectionLength + rowLength))
-    }),
-    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(sectionIndexes, previousSecIndexes)) {
-            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/rules/src/table/factories/getTableCells.js

@@ -1,16 +0,0 @@
-import * as R from 'ramda';
-import { getCells } from './getCells';
-import { getCuratedCells } from './getCuratedCells';
-
-export const getTableCells = (data, layoutIds, display, customAttributes) => {
-  const cells = getCells(data, layoutIds, display, customAttributes);
-
-  const layout = R.pipe(
-    R.mergeRight({ header: [], sections: [], rows: [] }),
-    R.mapObjIndexed(
-      R.flip(R.props)(R.pathOr({}, ['dimensions', 'many'], data))
-    )
-  )(layoutIds);
-
-  return getCuratedCells({ layout, observations: cells, shape: ['header', 'sections', 'rows'] });
-};

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

@@ -1,86 +0,0 @@
-import * as R from 'ramda';
-import { getCells } from './getCells';
-import { getConfirmedSeriesAttributesIds } from './getConfirmedSeriesAttributesIds';
-import { getCuratedCells } from './getCuratedCells';
-import { getLayoutDataWithFlags } from './getLayoutWithFlags';
-
-import { getUnitsInLayout } from '../units/getUnitsinLayout';
-import { appendUnitsInLayoutData } from '../units/appendUnitsInLayoutData';
-import { cleanUnitsInLayoutData } from '../units/cleanUnitsInLayoutData';
-
-
-import { getSortedLayoutIndexes } from './getSortedLayoutIndexes';
-import { refineLayoutSize } from './refineLayoutSize';
-import { getLayoutData } from './getLayoutData';
-import { refineMetadataCoordinates } from '../../../../rules2/src/refineMetadataCoordinates';
-import { invertTime } from '../../../../rules2/src/invertTime';
-
-export const getTableProps = ({ data, layoutIds, display, customAttributes, limit, isTimeInverted }) => {
-  const seriesAttributes = R.propOr({}, 'seriesAttributes', data);
-
-  const confirmedSeriesAttributesIds = getConfirmedSeriesAttributesIds(
-    seriesAttributes,
-    layoutIds
-  );
-
-  const refinedMetadataCoordinates = refineMetadataCoordinates(data.metadataCoordinates, layoutIds);
-
-  const {
-    rejectedValueIds,
-    unitDimension,
-    unitsAttachmentSeriesIds,
-    unitsDefinitionCodes,
-    unitsSeries,
-  } = R.propOr({}, 'units', data);
-  const {
-    unitsLevelDisplay,
-    unitsAttachmentIndexesInLayout,
-    unitsIndexesInLayout
-  } = getUnitsInLayout({ layoutIds, unitsAttachmentSeriesIds, unitsDefinitionCodes, unitsSeries });
-
-  const layoutDimsIds = R.pipe(R.pathOr({}, ['dimensions', 'many']), R.keys)(data);
-
-  const cells = getCells(
-    data,
-    display,
-    R.assoc('rejected', confirmedSeriesAttributesIds, customAttributes),
-    {
-      unitsDefinitionCodes, unitsSeries, unitsDisplay: unitsLevelDisplay,
-      unitDimension, rejectedValueIds, layoutDimsIds
-    },
-    refinedMetadataCoordinates.cells,
-    data.observationsType,
-  );
-
-  const { dimensions, observations } = invertTime(data, isTimeInverted);
-
-  const seriesAttributesValues = R.propOr({}, 'seriesAttributesValues', data);
-  const layout = R.pipe(
-    R.mergeRight({ header: [], sections: [], rows: [] }),
-    R.mapObjIndexed(R.flip(R.props)(dimensions)),
-  )(layoutIds);
-
-  const partialUnitSerieIndexes = R.pipe(
-    R.pathOr(0, ['dimensions', 'length']),
-    R.times(R.always('x'))
-  )(data);
-
-  const layoutData = R.pipe(
-    getSortedLayoutIndexes,
-    refineLayoutSize({ layout, observations: data.observations, limit: R.when(R.isNil, R.always(0))(limit) }),
-    indexes => getLayoutData(indexes, layout),
-    appendUnitsInLayoutData({
-      display, unitDimension, unitsDisplay: unitsLevelDisplay, unitsSeries,
-      unitsDefinitionCodes, unitsIndexes: unitsAttachmentIndexesInLayout,
-      partialUnitSerieIndexes, rejectedValueIds, layoutIds
-    }),
-    getLayoutDataWithFlags(seriesAttributesValues, display, customAttributes, refinedMetadataCoordinates, unitDimension.id),
-    cleanUnitsInLayoutData({ unitsDisplay: unitsLevelDisplay, unitsLayoutIndexes: unitsIndexesInLayout }),
-  )(layout, observations);
-  
-  return ({
-    cells: getCuratedCells({ layout, observations: cells, shape: ['header', 'sections', 'rows'] }),
-    layout,
-    ...layoutData
-  });
-};

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

@@ -1,17 +0,0 @@
-import * as R from 'ramda';
-
-export const getAttributeValue = (attribute, valueIndex) => {
-  const value = R.pipe(
-    R.propOr([], 'values'),
-    R.nth(valueIndex)
-  )(attribute);
-
-  if (R.isNil(value)) {
-    return null;
-  }
-
-  return ({
-    ...R.pick(['id', 'name'], attribute),
-    value: R.pick(['id', 'name'], value)
-  });
-};

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

@@ -1,51 +0,0 @@
-import * as R from 'ramda';
-
-const getSerieRegisterPath = (attribute, obsDimValuesIndexes) => {
-  const serieKey = R.pipe(
-    R.addIndex(R.map)(
-      (dimensionValueIndex, dimensionIndex) => R.when(
-        R.always(!R.has(String(dimensionIndex), attribute.targetIndexes)),
-        R.always('x')
-      )(dimensionValueIndex)
-    ),
-    R.join(':')
-  )(obsDimValuesIndexes);
-
-  return ['series', serieKey, attribute.id];
-};
-
-const getDimensionRegisterPath = (attribute, obsDimValuesIndexes) => {
-  const dimensionIndex = attribute.targetIndex;
-  const dimensionValueIndex = R.nth(dimensionIndex, obsDimValuesIndexes);
-
-  return ['dimensions', `${dimensionIndex}:${dimensionValueIndex}`, attribute.id];
-};
-
-const getAttributesRegisters = (getPath) => R.map(
-  (attribute) => (observation) => {
-    const valueIndex = R.nth(attribute.index, R.propOr([], 'attrValuesIndexes', observation));
-
-    const registerPath = getPath(attribute, R.propOr([], 'dimValuesIndexes', observation));
-
-    return R.over(
-      R.lensPath(registerPath),
-      R.ifElse(R.isNil, R.always([valueIndex]), R.append(valueIndex))
-    );
-  }
-);
-
-export const getDimensionsAttributesRegisters = (attributesIds, attributesByIds) => R.converge(
-  R.concat,
-  [
-    R.pipe(
-      R.propOr([], 'series'),
-      R.flip(R.props)(attributesByIds),
-      getAttributesRegisters(getSerieRegisterPath)
-    ),
-    R.pipe(
-      R.propOr([], 'manyValuesDimensions'),
-      R.flip(R.props)(attributesByIds),
-      getAttributesRegisters(getDimensionRegisterPath)
-    )
-  ]
-)(attributesIds);

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

@@ -1,19 +0,0 @@
-import * as R from 'ramda';
-import { refineObservationsAttributesValues } from './refineObservationsAttributesValues';
-
-export const getManyValuesDimensions = (dimensionsByIds, dimensionsIds, attributeValues, attributes) => R.mapObjIndexed(
-  (dimension) => {
-    const dimensionIndex = R.prop(dimension.id, dimensionsIds);
-    const values = R.map(
-      value => {
-        const valueAttributes = refineObservationsAttributesValues(attributes)
-          (R.propOr({}, `${dimensionIndex}:${value.__index}`, attributeValues));
-        return ({
-          ...R.pick(['id', 'name', '__indexPosition', 'parent', '__index', 'notes'], value),
-          attributes: valueAttributes,
-        });
-      }, dimension.values);
-    return R.assoc('values', values, dimension);
-  },
-  R.pick(R.keys(dimensionsIds), dimensionsByIds)
-);

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

@@ -1,17 +0,0 @@
-import * as R from 'ramda';
-import { getAttributeValue } from './getAttributeValue';
-
-export const getOneValueDimensions = (dimensions, attributesIds, attributes) => R.map(
-  (dimension) => {
-    const dimensionAttributes = R.pipe(
-      R.mapObjIndexed(attr => getAttributeValue(attr, 0)),
-      R.filter(R.complement(R.isNil))
-    )(R.pick(R.propOr([], dimension.id, attributesIds), attributes));
-
-    return R.over(
-      R.lensPath(['values', 0]),
-      R.assoc('attributes', dimensionAttributes)
-    )(dimension);
-  },
-  dimensions
-);