@sis-cc/dotstatsuite-components 15.0.20 → 16.0.0

package/src/rules2/src/getOneValueDimensions.js

@@ -0,0 +1,33 @@
+import * as R from 'ramda';
+
+export const getOneValueDimensions = (dimensions, attributes) => {
+  const indexedRelevantAttributes = R.reduce(
+    (acc, attr) => {
+      if (!attr.header || !attr.display || R.length(attr.relationship || []) !== 1) {
+        return acc;
+      }
+      const value = R.path(['values', 0], attr);
+      if (R.isNil(value) || !R.prop('display', value)) {
+        return acc;
+      }
+      const dim = R.head(attr.relationship);
+      return R.over(R.lensProp(dim), (values = {}) => ({
+        ...values,
+        [attr.id]: { ...attr, value },
+      }))(acc);
+    },
+    {},
+    attributes,
+  );
+  return R.reduce(
+    (acc, dim) => {
+      if (R.length(dim.values || []) !== 1) {
+        return acc;
+      }
+      const attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);
+      return R.append({ ...dim, attrValues }, acc);
+    },
+    [],
+    dimensions,
+  );
+};

package/src/rules2/src/hasCellMetadata.js

@@ -4,7 +4,7 @@ export const hasCellMetadata = (metadataCoordinates, cellCoordinates) => {
   return R.pipe(
     R.find(coordinates => {
       const mergedCoord = R.mergeLeft(coordinates, cellCoordinates);
-      return R.equals(mergedCoord, cellCoordinates);
+      return !R.isEmpty(coordinates) && R.equals(mergedCoord, cellCoordinates);
     }),
     R.complement(R.isNil)
   )(metadataCoordinates);

package/src/rules2/src/index.js

@@ -13,13 +13,28 @@ export { getHCodelistsRefs, getHCodelistsRefsInData } from './getHCodelistsRefsI
 export { parseHierarchicalCodelist } from './parseHierarchicalCodelist';
 export { refinePartialHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
 export { getMetadataCoordinates } from './getMetadataCoordinates';
-export {
-  getDataflowAdvancedAttributes,
-  getObservationsAdvancedAttributes,
-  getSeriesAdvancedAttributes
-} from './getAdvancedAttributes';
 export { duplicateObs } from './duplicateObservations';
 export { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
 export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy';
 export { getDimensionValuesIndexes } from './getDimensionValuesIndexes';
-
+export { getCombinationDefinitions } from './getCombinationDefinitions';
+export { parseAttributes } from './parseAttributes';
+export { parseCombinations } from './parseCombinations';
+export { refineAttributes } from './refineAttributes';
+export { enhanceObservations } from './enhanceObservations';
+export { getAttributesSeries } from './getAttributesSeries';
+export { getManyValuesDimensions } from './getManyValuesDimensions';
+export { getOneValueDimensions } from './getOneValueDimensions';
+export { getHeaderSubtitle } from './getHeaderSubtitle';
+export { getHeaderCombinations } from './getHeaderCombinations';
+export { getLayout } from './table/getLayout';
+export { getSortedLayoutIndexes } from './table/getSortedLayoutIndexes';
+export { refineLayoutSize } from './table/refineLayoutSize';
+export { getFlagsAndNotes } from './table/getFlagsAndNotes';
+export { getLayoutData } from './table/getLayoutData';
+export { getCellsAttributesIds } from './table/getCellsAttributesIds';
+export { getIndexedCombinationsByDisplay } from './table/getIndexedCombinationsByDisplay';
+export { getCells } from './table/getCells';
+export { getCuratedCells } from './table/getCuratedCells';
+export { prepareData } from './prepareData';
+export { getTableProps } from './table/getTableProps';

package/src/rules2/src/parseAttributes.js

@@ -0,0 +1,36 @@
+import * as R from 'ramda';
+import { REPORTING_YEAR_START_DAY, REPYEARSTART } from './constants';
+
+export const parseAttributes = (attributes, dimensions, customAttributes) => {
+  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
+  return R.addIndex(R.map)((attr, index) => {
+    let res = R.assoc('index', index, attr);
+    if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr)
+      || attr.id === REPORTING_YEAR_START_DAY || attr.id === REPYEARSTART) {
+      return R.assoc('display', false, res);
+    }
+    if (R.propEq('id', customAttributes.prefscale, attr)) {
+      return R.assoc('prefscale', true, res);
+    }
+    if (R.propEq('id', customAttributes.decimals, attr)) {
+      return R.assoc('decimals', true, res);
+    }
+    if (R.hasPath(['relationship', 'none'], attr) || R.hasPath(['relationship', 'dataflow'], attr)) {
+      return { ...res, header: true, relationship: [] };
+    }
+    if (R.hasPath(['relationship', 'primaryMeasure'], attr) || R.hasPath(['relationship', 'observation'], attr)) {
+      return { ...res, series: true, relationship: [] };
+    }
+    const seriesDimensions = R.pipe(
+      R.pathOr([], ['relationship', 'dimensions']),
+      R.filter(id => {
+        const values = R.path([id, 'values'], indexedDimensions);
+        return R.length(values) > 1;
+      }),
+    )(attr);
+    if (R.length(seriesDimensions) > 0) {
+      return { ...res, series: true, relationship: seriesDimensions };
+    }
+    return { ...res, header: true, relationship: R.prop('dimensions', attr.relationship || []) };
+  }, attributes);
+};

package/src/rules2/src/parseCombinations.js

@@ -0,0 +1,36 @@
+import * as R from 'ramda';
+
+export const parseCombinations = (combinations, parsedAttributes, dimensions) => {
+  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
+  const indexedAttributes = R.indexBy(R.prop('id'), parsedAttributes);
+
+  return R.map(comb => {
+    let relationship = [];
+    let ids = {};
+    const seriesConcepts = R.filter(concept => {
+      if (R.has(concept, ids)) {
+        return false;
+      }
+      if (R.has(concept, indexedDimensions)) {
+        const values = R.path([concept, 'values'], indexedDimensions);
+        relationship = R.length(values) > 1 ? R.append(concept, relationship) : relationship;
+        ids = { ...ids, [concept]: concept };
+        return R.length(values) > 1;
+      }
+      const attribute = R.prop(concept, indexedAttributes);
+      relationship = attribute.series
+        ? R.pipe(
+            R.reject(id => R.has(id, ids)),
+            R.concat(relationship),
+          )(attribute.relationship)
+        : relationship;
+      ids = attribute.series ? { ...ids, ...R.indexBy(R.identity, attribute.relationship) } : ids;
+      return true;
+    }, comb.concepts);
+
+    if (R.isEmpty(seriesConcepts) || R.isEmpty(relationship)) {
+      return { ...comb, header: true };
+    }
+    return { ...comb, series: true, relationship };
+  }, combinations);
+};

package/src/rules2/src/prepareData.js

@@ -0,0 +1,50 @@
+import * as R from 'ramda';
+import { getObservations } from '../../rules/src';
+import { enhanceObservations } from './enhanceObservations';
+import { parseAttributes } from './parseAttributes';
+import { getCombinationDefinitions } 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 './hierarchiseDimensionWithNativeHierarchy';
+import { hierarchiseDimensionWithAdvancedHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy';
+
+export const prepareData = (sdmxJson, customAttributes, locale, hierarchies) => {
+  const dimensions = R.pathOr([], ['data', 'structure', 'dimensions', 'observation'], sdmxJson);
+  const attributes = R.pathOr([], ['data', 'structure', 'attributes', 'observation'], sdmxJson);
+  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
+  const observations = getObservations(sdmxJson);
+  const combinations = getCombinationDefinitions(annotations, locale);
+  const metadataCoordinates = getMetadataCoordinates(sdmxJson);
+
+  const parsedAttributes = parseAttributes(attributes, dimensions, customAttributes);
+  const parsedCombinations = parseCombinations(combinations, parsedAttributes, dimensions);
+  const seriesCombinations = R.filter(R.prop('series'), parsedCombinations);
+  const refinedAttributes = refineAttributes(parsedAttributes, seriesCombinations);
+
+  const enhancedObservations = enhanceObservations(dimensions, observations, refinedAttributes, { customAttributes });
+  const attributesSeries = getAttributesSeries(enhancedObservations);
+  const manyValuesDimensions = getManyValuesDimensions(dimensions, attributesSeries, customAttributes, seriesCombinations);
+  const oneValueDimensions = getOneValueDimensions(dimensions, parsedAttributes);
+  const hierarchisedDimensions = R.map(dim => {
+    if (R.isEmpty(R.propOr({}, dim.id, hierarchies))) {
+      return hierarchiseDimensionWithNativeHierarchy(dim);
+    }
+    return hierarchiseDimensionWithAdvancedHierarchy(dim, R.prop(dim.id, hierarchies));
+  }, manyValuesDimensions)
+  const duplicatedObservations = duplicateObs(R.values(hierarchisedDimensions), enhancedObservations);
+  
+  return ({
+    observations: duplicatedObservations,
+    dimensions: hierarchisedDimensions,
+    combinations: parsedCombinations,
+    oneValueDimensions,
+    attributesSeries,
+    metadataCoordinates,
+    attributes: refinedAttributes
+  });
+};

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) };
+    }
+    return attr;
+  }, parsedAttributes);
+};

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

@@ -0,0 +1,72 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './getFlagsAndNotes';
+import { hasCellMetadata } from '../hasCellMetadata';
+import { trimedProps } from '../utils';
+
+export const getCellRelevantAttributes = (attributes, attributesSeries, cellAttributeIds) => R.filter(
+  (attr) => {
+    if (R.has(attr.id, cellAttributeIds)) {
+      return true;
+    }
+    const attrInSerie = R.path([attr.serieKey, attr.id], attributesSeries);
+    return R.isNil(attrInSerie);
+  },
+  attributes
+);
+
+export const getCellCombinedAttributes = (attributes, combinations) => R.reduce(
+  (acc, comb) => {
+    const values = trimedProps(comb.concepts, attributes);
+    if (R.isEmpty(values)) {
+      return acc;
+    }
+    return R.append({ ...R.pick(['id', 'name'], comb), values: R.pluck('value', 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.concat(notes || [], attributesInLayoutCombination)
+  )(customAttributes);
+
+  return R.mapObjIndexed(
+    obs => {
+      const relevantAttributes = getCellRelevantAttributes(obs.attributes, attributesSeries, cellsAttributesId);
+      const flagsAndNotes = getFlagsAndNotes(relevantAttributes, _customAttributes);
+      const combinedAttributes = getCellCombinedAttributes(relevantAttributes, combinations.cells || []);
+
+      const hasAdvancedAttributes = R.pipe(
+        R.omit(R.unnest([_customAttributes.flags || [], _customAttributes.notes || [], attributesInCellsCombination])),
+        R.isEmpty,
+        R.not
+      )(relevantAttributes);
+
+      const hasMetadata = hasCellMetadata(metadataCoordinates, obs.indexedDimValIds);
+
+      return ({
+        ...R.pick(['indexedDimValIds', 'key'], obs),
+        flags: R.concat(flagsAndNotes, combinedAttributes),
+        sideProps: hasAdvancedAttributes || hasMetadata ? { hasAdvancedAttributes, hasMetadata, coordinates: obs.indexedDimValIds } : null,
+        intValue: R.is(Number, obs.value) ? obs.value : null,
+        value: obs.formattedValue,
+      });
+    },
+    observations
+  );
+};

package/src/rules2/src/table/getCellsAttributesIds.js

@@ -0,0 +1,38 @@
+import * as R from 'ramda';
+
+export const getCellsAttributesIds = (layoutIds, attributes) => {
+  return R.reduce(
+    (acc, attr) => {
+      if (!attr.series) {
+        return acc;
+      }
+      if (R.isEmpty(attr.relationship || [])) {
+        return R.assoc(attr.id, attr.id, acc);
+      }
+      const indexedHeaderIds = R.indexBy(R.identity, layoutIds.header);
+      const indexedSectionsIds = R.indexBy(R.identity, layoutIds.sections);
+      const indexedRowsIds = { ...indexedSectionsIds, ...R.indexBy(R.identity, layoutIds.rows) };
+      const [idsInHeader, rest] = R.partition(
+        id => R.has(id, indexedHeaderIds),
+        attr.relationship,
+      );
+      if (R.isEmpty(rest)) {
+        return acc;
+      } else if (!R.isEmpty(idsInHeader)) {
+        return R.assoc(attr.id, attr.id, acc);
+      } else {
+        const idsNotInSections = R.reject(id => R.has(id, indexedSectionsIds), attr.relationship);
+        if (R.isEmpty(idsNotInSections)) {
+          return acc;
+        }
+        const idsNotInRows = R.reject(id => R.has(id, indexedRowsIds), idsNotInSections);
+        if (R.isEmpty(idsNotInRows)) {
+          return acc;
+        }
+      }
+      return R.assoc(attr.id, attr.id, acc);
+    },
+    {},
+    attributes,
+  );
+};

package/src/rules2/src/table/getCombinationDimensionsData.js

@@ -0,0 +1,38 @@
+import * as R from 'ramda';
+import { parseValueHierarchy } from './parseValueHierarchy';
+
+export const getCombinationDimensionsData = (indexes, combination, previous, sameSerie) => {
+  let coordinates = {};
+  let ids = [];
+  let _sameSerie = sameSerie;
+  let hasAdvancedAttributes = false;
+
+  const { dimensions=[] } = combination;
+  const dimValues = R.addIndex(R.reduce)(
+    (acc, valIndex, dimIndex) => {
+      const dimension = R.nth(dimIndex, dimensions);
+      const value = R.nth(Math.abs(valIndex), R.propOr([], 'values', dimension));
+      hasAdvancedAttributes = !hasAdvancedAttributes ? value.hasAdvancedAttributes : true;
+      if (!value) {
+        return acc;
+      }
+      coordinates = R.assoc(dimension.id, value.id, coordinates);
+      ids = R.append(`${dimension.id}=${value.id}`, ids);
+      const previousValue = R.propOr({}, dimension.id, previous);
+      if (value.id === R.prop('id', previousValue || {}) && _sameSerie) {
+        return R.assoc(dimension.id, previousValue, acc);
+      }
+      else {
+        const parsedValue = parseValueHierarchy(value, _sameSerie ? previousValue || {} : {}, dimension.indexedValues);
+        if (!R.isNil(previous)) {
+          _sameSerie = false;
+        }
+        return R.assoc(dimension.id, parsedValue, acc);
+      }
+    },
+    {},
+    indexes
+  );
+
+  return ({ dimValues, coordinates, ids, sameSerie: _sameSerie, hasAdvancedAttributes });
+};

package/src/rules2/src/table/getCuratedCells.js

@@ -0,0 +1,33 @@
+import * as R from 'ramda';
+
+export const getCuratedCells = (cells, layout) => {
+  const layoutIds = R.map(
+    R.pipe(
+      R.map(entry =>
+        R.has('dimensions', entry) ? R.pluck('id', entry.dimensions || []) : entry.id,
+      ),
+      R.unnest,
+    ),
+  )(layout);
+  return R.pipe(
+    R.values,
+    R.reduce((acc, cell) => {
+      const keys = R.map(
+        R.pipe(
+          R.map(dim => {
+            const val = R.prop(dim, cell.indexedDimValIds);
+            return `${dim}=${val}`;
+          }),
+          R.join(':'),
+        ),
+        layoutIds,
+      );
+
+      return R.over(
+        R.lensPath(R.props(['header', 'sections', 'rows'], keys)),
+        cells => (R.isNil(cells) ? [cell] : R.append(cell, cells)),
+        acc,
+      );
+    }, {}),
+  )(cells);
+};

package/src/rules2/src/table/getFlagsAndNotes.js

@@ -0,0 +1,21 @@
+import * as R from 'ramda';
+
+export const getFlagsAndNotes = (attributesValues, customAttributes) => {
+  const flagsIds = R.propOr([], 'flags', customAttributes);
+  const notesIds = R.propOr([], 'notes', customAttributes);
+
+  return R.addIndex(R.reduce)(
+    (acc, id, index) => {
+      if (!R.has(id, attributesValues)) {
+        return acc;
+      }
+      const attr = R.prop(id, attributesValues);
+      if (R.isNil(attr.value)) {
+        return acc;
+      }
+      return R.append(index < flagsIds.length ? R.assoc('code', R.path(['value', 'id'], attr), attr) : attr, acc);
+    },
+    [],
+    R.concat(flagsIds, notesIds)
+  );
+};

package/src/rules2/src/table/getIndexedCombinationsByDisplay.js

@@ -0,0 +1,16 @@
+import * as R from 'ramda';
+
+export const getIndexedCombinationsByDisplay = (layout, combinations) => {
+  const layoutIds = R.pipe(
+    R.map(R.pluck('id')),
+    R.values,
+    R.unnest,
+    R.indexBy(R.identity),
+  )(layout);
+
+  const [combsInLayout, combsInCells] = R.partition(
+    comb => R.has(comb.id, layoutIds),
+    combinations,
+  );
+  return { cells: combsInCells, layout: combsInLayout };
+};

package/src/rules2/src/table/getLayout.js

@@ -0,0 +1,80 @@
+import * as R from 'ramda';
+import { isTimePeriodDimension } from '@sis-cc/dotstatsuite-sdmxjs';
+import { trimedProps } from '../utils';
+
+export const getLayout = (layoutIds, dimensions, combinations, isTimeInverted, fixedDimensions) => {
+    const indexedDimensions = R.pipe(
+      R.indexBy(R.prop('id')),
+      R.map(d => (isTimePeriodDimension(d) && isTimeInverted ? R.assoc('isInverted', true, d) : d)),
+    )(dimensions);
+    const indexedFixedDimsValues = R.reduce(
+      (acc, dim) => {
+        const value = R.head(dim.values);
+        return !dim.display || !value.display ? acc : R.assoc(dim.id, R.head(dim.values), acc);
+      },
+      {},
+      fixedDimensions,
+    );
+    const indexedHeaderIds = R.indexBy(R.identity, layoutIds.header);
+    const indexedSectionsIds = R.indexBy(R.identity, layoutIds.sections);
+    const indexedRowsIds = { ...indexedSectionsIds, ...R.indexBy(R.identity, layoutIds.rows) };
+    let layout = { header: [], sections: [], rows: [] };
+    R.forEach(comb => {
+      if (R.isEmpty(comb.relationship)) {
+        return;
+      }
+      const [idsInHeader, rest] = R.partition(id => R.has(id, indexedHeaderIds), comb.relationship);
+      if (R.isEmpty(rest)) {
+        layout = R.over(
+          R.lensProp('header'),
+          R.append({
+            ...comb,
+            dimensions: trimedProps(comb.concepts, indexedDimensions),
+            fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues),
+          }),
+        )(layout);
+      } else if (!R.isEmpty(idsInHeader)) {
+        return;
+      } else {
+        const idsNotInSections = R.reject(id => R.has(id, indexedSectionsIds), comb.relationship);
+        if (R.isEmpty(idsNotInSections)) {
+          layout = R.over(
+            R.lensProp('sections'),
+            R.append({
+              ...comb,
+              dimensions: trimedProps(comb.concepts, indexedDimensions),
+              fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues),
+            }),
+          )(layout);
+        } else {
+          const idsNotInRows = R.reject(id => R.has(id, indexedRowsIds), comb.relationship);
+          if (R.isEmpty(idsNotInRows)) {
+            layout = R.over(
+              R.lensProp('rows'),
+              R.append({
+                ...comb,
+                dimensions: R.pipe(R.omit(layoutIds.sections), o => trimedProps(comb.concepts, o))(
+                  indexedDimensions,
+                ),
+                fixedDimValues: R.pick(comb.concepts, indexedFixedDimsValues),
+              }),
+            )(layout);
+          }
+        }
+      }
+    }, combinations);
+    return R.mapObjIndexed((combs, key) => {
+      const conceptIds = R.pipe(R.pluck('concepts'), R.unnest, R.indexBy(R.identity))(combs);
+      const rest = R.reduce(
+        (acc, id) => {
+          if (R.has(id, conceptIds)) {
+            return acc;
+          }
+          return R.append(R.prop(id, indexedDimensions), acc);
+        },
+        [],
+        layoutIds[key],
+      );
+      return R.concat(rest, combs);
+    }, layout);
+  };