@sis-cc/dotstatsuite-components 22.0.1 → 22.0.2

package/src/rules2/src/getDimensionValuesIndexes.js

@@ -0,0 +1,13 @@
+import * as R from 'ramda';
+
+export const getDimensionValuesIndexes = (values) => R.addIndex(R.reduce)(
+  (acc, value, position) => {
+    const sdmxIndex = value.__index;
+    return R.over(
+      R.lensProp(String(sdmxIndex)),
+      R.ifElse(R.isNil, R.always([position]), R.append(position))
+    )(acc);
+  },
+  {},
+  values
+);

package/src/rules2/src/getHCodelistsRefsInData.js

@@ -0,0 +1,32 @@
+import * as R from 'ramda';
+
+export const getHCodelistsRefs = annotations => R.reduce(
+  (acc, annotation) => {
+    if (annotation.type !== 'HIER_CONTEXT') {
+      return acc;
+    }
+    const references = annotation.text || annotation.title || '';
+    const refs = R.pipe(
+      R.split(','),
+      R.reduce(
+        (acc2, ref) => {
+          const match = ref.match(/([\w@_.]+):([\w@_.]+):([\w@_.]+)\(([\d.]+)\).([\w@_.]+)$/);
+          if (R.isNil(match)) {
+            return acc2;
+          }
+          const [codelistId, agencyId, code, version, hierarchy] = R.tail(match);
+          return R.assoc(codelistId, { agencyId, code, version, hierarchy, codelistId }, acc2);
+        },
+        {}
+      )
+    )(references);
+    return R.mergeRight(acc, refs);
+  },
+  {},
+  annotations,
+);
+
+export const getHCodelistsRefsInData = sdmxJson => {
+  const annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
+  return getHCodelistsRefs(annotations);
+};

package/src/rules2/src/getHeaderCombinations.js

@@ -0,0 +1,48 @@
+import * as R from 'ramda';
+import { dimensionValueDisplay } from '../../rules/src';
+import { combinedValuesDisplay } from './combinedValuesDisplay';
+import { REJECTED_VALUE_IDS } from './constants';
+
+export const getHeaderCombinations = (combinations, dimensions, attributes, display) => {
+  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
+  const indexedAttributes = R.indexBy(R.prop('id'), attributes);
+  return R.reduce(
+    (acc, comb) => {
+      if (!R.prop('header', comb) || !R.propOr(true, 'display', comb)) {
+        return acc;
+      }
+
+      const header = `${dimensionValueDisplay(display)(comb)}:`;
+
+      const label = R.pipe(
+        R.reduce(
+          (_acc, concept) => {
+            const artefact = R.has(concept, indexedDimensions)
+              ? R.prop(concept, indexedDimensions)
+              : R.prop(concept, indexedAttributes);
+            if (R.isNil(artefact)) {
+              return _acc;
+            }
+            const value = R.path(['values', 0], artefact);
+            if (R.isNil(value)) {
+              return _acc;
+            }
+            if (R.has(concept, indexedAttributes) && (!R.propOr(true, 'display', value)
+              || !R.propOr(true, 'artefact', value) || R.includes(value.id, REJECTED_VALUE_IDS))) {
+              return _acc;
+            }
+            return R.append(value, _acc);
+          },
+          []
+        ),
+        values => combinedValuesDisplay(display, values)
+      )(comb.concepts || []);
+      if (R.isEmpty(label)) {
+        return acc;
+      }
+      return R.append({ header, label }, acc);
+    },
+    [],
+    combinations,
+  );
+};

package/src/rules2/src/getHeaderCoordinates.js

@@ -0,0 +1,7 @@
+import * as R from 'ramda';
+
+export const getHeaderCoordinates = (oneValueDimensions) => R.reduce(
+  (acc, dim) => R.assoc(dim.id, R.path(['values', 0, 'id'], dim), acc),
+  {},
+  oneValueDimensions
+);

package/src/rules2/src/getHeaderSubtitle.js

@@ -0,0 +1,34 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './table/getFlagsAndNotes';
+import { dimensionValueDisplay } from '../../rules/src/';
+
+export const getHeaderSubtitle = (dimensions, combinations, customAttributes, display, microdataDimension) => {
+  const combinationsConepts = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
+  const DEFAULT_REJECTED_SUBTITLE_IDS = ['_L', '_T', '_Z'];
+
+  return R.reduce(
+    (acc, dim) => {
+      if (!R.propOr(true, 'display', dim) || R.propEq('id', microdataDimension, dim)
+        || R.includes(dim.id, combinationsConepts)) {
+        return acc;
+      }
+      const value = R.path(['values', 0], dim);
+      if (!R.propOr(true, 'display', value) || R.includes(value.id, DEFAULT_REJECTED_SUBTITLE_IDS)) {
+        return acc;
+      }
+      const header = `${dimensionValueDisplay(display)(dim)}:`;
+      const label = dimensionValueDisplay(display)(value);
+      const flags = R.pipe(
+        getFlagsAndNotes,
+        R.map(entry => ({
+          code: entry.code,
+          header: `${dimensionValueDisplay(display)(entry)}:`,
+          label: dimensionValueDisplay(display)(entry.value),
+        })),
+      )(dim.attrValues, customAttributes);
+      return R.append({ header, label, flags }, acc);
+    },
+    [],
+    dimensions,
+  );
+};

package/src/rules2/src/getHeaderTitle.js

@@ -0,0 +1,15 @@
+import * as R from 'ramda';
+import { dimensionValueDisplay } from '../../rules/src';
+import { getFlagsAndNotes } from './table/getFlagsAndNotes';
+
+export const getHeaderTitle = (dataflow, attributes, display, customAttributes) => ({
+  label: dimensionValueDisplay(display)(dataflow),
+  flags: R.pipe(
+    getFlagsAndNotes,
+    R.map(entry => ({
+      code: entry.code,
+      header: `${dimensionValueDisplay(display)(entry)}:`,
+      label: dimensionValueDisplay(display)(entry.value),
+    })),
+  )(attributes, customAttributes),
+});

package/src/rules2/src/getMSDInformations.js

@@ -0,0 +1,23 @@
+import * as R from 'ramda';
+
+export const getMSDInformations = msdJson => {
+  const attributesDefinitions = R.pathOr([], ['data', 'metadataStructures', 0, 'metadataStructureComponents', 'reportStructures', 0, 'metadataAttributes'], msdJson);
+  const indexedConcepts = R.pipe(R.pathOr([], ['data', 'conceptSchemes', 0, 'concepts']), R.indexBy(R.prop('id')))(msdJson);
+
+  const parseAttributes = (parent) => R.reduce(
+    (acc, attribute) => {
+      const id = attribute.id;
+      const name = R.path([id, 'name'], indexedConcepts);
+      const hierarchicalId = parent === '#ROOT' ? id : `${parent}.${id}`;
+      const format = R.path(['localRepresentation', 'textFormat', 'textType'], attribute);
+      if (R.has('metadataAttributes', attribute)) {
+        const collection = parseAttributes(hierarchicalId)(attribute.metadataAttributes);
+        return ({ ...acc, ...collection, [hierarchicalId]: { format, parent, id, name } });
+      }
+      return R.assoc(hierarchicalId, { format, parent, id, name }, acc);
+    },
+    {}
+  )
+
+  return ({ attributes: parseAttributes('#ROOT')(attributesDefinitions) });
+};

package/src/rules2/src/getManyValuesDimensions.js

@@ -0,0 +1,34 @@
+import * as R from 'ramda';
+import { getFlagsAndNotes } from './table/getFlagsAndNotes';
+
+export const getManyValuesDimensions = (dimensions, attributesSeries, customAttributes, combinations) => {
+  const combConceptsIds = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
+  return R.reduce(
+    (acc, dim) => {
+      if (dim.header || dim.rejected) {
+        return acc;
+      }
+      const enhancedValues = R.map(val => {
+        const attrSeries = R.propOr({}, `${dim.id}=${val.id}`, attributesSeries);
+        if (R.isEmpty(attrSeries)) {
+          return val;
+        }
+        const flags = getFlagsAndNotes(attrSeries, customAttributes);
+        const hasAdvancedAttributes = R.pipe(
+          R.omit(
+            R.unnest([
+              customAttributes.flags || [],
+              customAttributes.notes || [],
+              combConceptsIds,
+            ]),
+          ),
+          R.complement(R.isEmpty),
+        )(attrSeries);
+        return { ...val, flags, hasAdvancedAttributes };
+      }, dim.values);
+      return R.append(R.assoc('values', enhancedValues, dim), acc);
+    },
+    [],
+    dimensions,
+  );
+};

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(a => a && R.propEq('type', 'HAS_METADATA', a))),
+    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) || R.prop('rejected', 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);
+};

package/src/rules2/src/getNotDisplayedIds.js

@@ -0,0 +1,53 @@
+import * as R from 'ramda';
+import { getNotDisplayedCombinations } from '@sis-cc/dotstatsuite-sdmxjs';
+
+const getNotDisplayedValues = annot => {
+  if (R.isNil(annot)) {
+    return {};
+  }
+  const ids = R.split(',', annot.title || '');
+  return R.reduce(
+    (acc, entry) => {
+      if (R.isEmpty(entry)) {
+        return acc;
+      }
+      const parsed = R.split('=', entry);
+      const dimensionId = parsed[0];
+      if (R.length(parsed) === 1) {
+        return R.assoc(dimensionId, dimensionId, acc);
+      }
+      const values = R.split('+', parsed[1]);
+      if (R.length(values) === 1 && R.isEmpty(values[0])) {
+        return R.assoc(dimensionId, dimensionId, acc);
+      }
+      return R.reduce(
+        (_acc, val) => {
+          let _val = val
+          if (R.isEmpty(val)) {
+            return _acc;
+          }
+          if (R.test('/[()]/')) {
+            _val = R.replace(/[()]/g, '')(val)
+          }
+          const key = R.isEmpty(_val) ? dimensionId : `${dimensionId}.${_val}`;
+          return R.assoc(key, key, _acc);
+        },
+        acc,
+        values
+      );
+    },
+    {},
+    ids
+  );
+};
+
+export const getNotDisplayedIds = (annotations) => R.pipe(
+  R.find(R.propEq('type', 'NOT_DISPLAYED')),
+  R.converge((hiddenValues, hiddenCombinations) => ({
+    hiddenValues,
+    hiddenCombinations
+  }), [
+    getNotDisplayedValues,
+    (annot={ title: '' }) => getNotDisplayedCombinations(annot) 
+  ])
+)(annotations);

package/src/rules2/src/getOneValueDimensions.js

@@ -0,0 +1,34 @@
+import * as R from 'ramda';
+import { REJECTED_VALUE_IDS } from './constants';
+
+export const getOneValueDimensions = (dimensions, attributes) => {
+  const indexedRelevantAttributes = R.reduce(
+    (acc, attr) => {
+      if (!attr.header || !R.propOr(true, 'display', attr) || R.length(attr.relationship || []) !== 1) {
+        return acc;
+      }
+      const value = R.path(['values', 0], attr);
+      if (R.isNil(value) || !R.propOr(true, 'display', value) || R.includes(R.prop('id', value), REJECTED_VALUE_IDS)) {
+        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 (!dim.header) {
+        return acc;
+      }
+      const attrValues = R.propOr({}, dim.id, indexedRelevantAttributes);
+      return R.append({ ...dim, attrValues }, acc);
+    },
+    [],
+    dimensions,
+  );
+};

package/src/rules2/src/getSeriesCombinations.js

@@ -0,0 +1,24 @@
+import * as R from 'ramda';
+
+export const getSeriesCombinations = (combinations, oneValuesDimensions) => {
+  const indexedValues =  R.reduce(
+    (acc, dim) => {
+      const value = R.head(dim.values);
+      return R.assoc(dim.id, value, acc);
+    },
+    {},
+    oneValuesDimensions
+  );
+
+  return R.reduce(
+    (acc, comb) => {
+      if (!R.prop('series', comb)) {
+        return acc;
+      }
+      const fixedDimValues = R.pick(comb.concepts, indexedValues);
+      return R.append({ ...comb, fixedDimValues }, acc);
+    },
+    [],
+    combinations
+  );
+};

package/src/rules2/src/hasCellMetadata.js

@@ -0,0 +1,14 @@
+import * as R from 'ramda';
+
+export const hasCellMetadata = (metadataCoordinates, cellCoordinates) => {
+  if (R.propOr('OBS_VALUE', 'OBS_ATTRIBUTES', cellCoordinates) !== 'OBS_VALUE') {
+    return false;
+  }
+  return R.pipe(
+    R.find(coordinates => {
+      const mergedCoord = R.mergeLeft(coordinates, cellCoordinates);
+      return !R.isEmpty(coordinates) && R.equals(mergedCoord, cellCoordinates);
+    }),
+    R.complement(R.isNil)
+  )(metadataCoordinates);
+};

package/src/rules2/src/hierarchiseDimensionWithAdvancedHierarchy2.js

@@ -0,0 +1,57 @@
+import * as R from 'ramda';
+
+const uniq = R.pipe(
+  R.reduce(
+    ({ ids, list }, id) => {
+      if (R.has(id, list)) {
+        return ({ ids, list });
+      }
+      return ({ ids: R.append(id, ids), list: R.assoc(id, id, list) });
+    },
+    { ids: [], list: {} }
+  ),
+  R.prop('ids')
+);
+
+export const refinePartialHierarchy = (hier, indexed) => {
+  const { intact, broken } = R.pipe(
+    R.keys,
+    R.reduce(
+      ({ intact, broken }, key) => {
+        const ids = R.filter(id => R.has(id, indexed), hier[key]);
+        if (key === '#ROOT') {
+          return ({ broken, intact: R.assoc(key, ids, intact) });
+        }
+        const splitKey = R.split('.', key);
+        const filtered = R.takeLastWhile(id => R.has(id, indexed), splitKey);
+        if (R.length(filtered) === R.length(splitKey)) {
+          return ({ broken, intact: R.assoc(key, ids, intact) });
+        }
+        const refinedKey = R.isEmpty(filtered) ? '#ROOT' : R.join('.', filtered);
+        return ({
+          intact,
+          broken: R.over(R.lensProp(refinedKey), R.ifElse(R.isNil, R.always([ids]), R.append(ids)))(broken)
+        });
+      },
+      { intact: {}, broken: {} }
+    )
+  )(hier);
+  const intactIds = R.pipe(R.values, R.unnest)(intact);
+  const refinedBroken = R.pipe(
+    R.omit(intactIds),
+    R.over(
+      R.lensProp('#ROOT'),
+      R.pipe(
+        i => R.isNil(i) ? [] : i,
+        R.unnest,
+        R.reject(R.flip(R.includes)(intactIds)))
+      ),
+    R.map(R.pipe(R.unnest, uniq))
+  )(broken);
+
+  return ({
+    ...refinedBroken,
+    ...intact,
+    '#ROOT': R.concat(refinedBroken['#ROOT'], intact['#ROOT'])
+  })
+};

package/src/rules2/src/hierarchiseDimensionWithNativeHierarchy2.js

@@ -0,0 +1,35 @@
+import * as R from 'ramda';
+
+export const hierarchiseDimensionWithNativeHierarchy = (dimension) => {
+  const values = R.sortBy(R.prop('__indexPosition'), dimension.values || []);
+  const indexed = R.indexBy(R.prop('id'), values);
+  const grouped = R.groupBy(val => val.parent && R.has(val.parent, indexed) ? val.parent : '#ROOT', values);
+
+  let index = -1;
+  const getChildren = ({ parentsIndexes, parentId }) => {
+    const childs = R.propOr([], parentId, grouped);
+    return R.reduce(
+      (acc, child) => {
+        index = index + 1;
+        const refined = R.pipe(
+          R.assoc('__indexPosition', index),
+          R.assoc('parents', parentsIndexes),
+          R.assoc('parent', R.isEmpty(parentsIndexes) ? undefined : parentId),
+        )(child);
+        const children = getChildren({
+          parentsIndexes: R.propOr(false, 'isSelected', child)
+           ? R.append(index, parentsIndexes) : parentsIndexes,
+          parentId: child.id
+        });
+        return R.concat(acc, R.prepend(refined, children));
+      },
+      [],
+      childs
+    );
+  }
+
+  return R.set(
+    R.lensProp('values'),
+    getChildren({ parentsIndexes: [], parentId: '#ROOT' })
+  )(dimension);
+};

package/src/rules2/src/index.js

@@ -0,0 +1,50 @@
+export {
+  SDMX_3_0_JSON_DATA_FORMAT,
+  SDMX_3_0_CSV_DATA_FORMAT
+} from './constants';
+
+export { parseMetadataSeries } from './parseMetadataSeries';
+export { sdmx_3_0_DataFormatPatch } from './sdmx3.0DataFormatPatch';
+export { getDataflowTooltipAttributesIds } from './getDataflowTooltipAttributesIds';
+export { getMSDInformations } from './getMSDInformations';
+export { getNotDisplayedIds } from './getNotDisplayedIds';
+export { getHCodelistsRefs, getHCodelistsRefsInData } from './getHCodelistsRefsInData';
+export { parseHierarchicalCodelist } from './parseHierarchicalCodelist';
+export { getMetadataCoordinates } from './getMetadataCoordinates';
+export { duplicateObs } from './duplicateObservations';
+export { refinePartialHierarchy } from './hierarchiseDimensionWithAdvancedHierarchy2';
+export { hierarchiseDimensionWithNativeHierarchy } from './hierarchiseDimensionWithNativeHierarchy2';
+export { getDimensionValuesIndexes } from './getDimensionValuesIndexes';
+export { getCombinationDefinitions, parseCombinationDefinition } from './getCombinationDefinitions';
+export { refineDimensions } from './refineDimensions';
+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 { getDataflowAttributes } from './getDataflowAttributes';
+export { getHeaderTitle } from './getHeaderTitle';
+export { getHeaderSubtitle } from './getHeaderSubtitle';
+export { getSeriesCombinations } from './getSeriesCombinations';
+export { getHeaderCombinations } from './getHeaderCombinations';
+export { getHeaderCoordinates } from './getHeaderCoordinates';
+export { getLayout } from './table/getLayout';
+export { getSortedLayoutIndexes } from './table/getSortedLayoutIndexes';
+export { refineLayoutSize } from './table/refineLayoutSize2';
+export { getFlagsAndNotes } from './table/getFlagsAndNotes';
+export { getLayoutData } from './table/getLayoutData2';
+export { getCellsAttributesIds } from './table/getCellsAttributesIds';
+export { getCellsMetadataCoordinates } from './table/getCellsMetadataCoordinates';
+export { getIndexedCombinationsByDisplay } from './table/getIndexedCombinationsByDisplay';
+export { getCells } from './table/getCells';
+export { getCuratedCells } from './table/getCuratedCells';
+export { prepareData } from './prepareData';
+export { getTableProps } from './table/getTableProps';
+export { getTableLabelAccessor } from './table/getTableLabelAccessor';
+export { parseValueHierarchy } from './table/parseValueHierarchy';
+export { parseLayoutIndexesHierarchies } from './table/parseSeriesIndexesHierarchies';
+export { getTableLayoutIds, injectCombinationsInLayout } from './table/getTableLayoutIds';
+export { declineObservationsOverAttributes } from './table/declineObservationsOverAttributes';
+export { applyHierarchicalCodesToDim } from './applyHierarchicalCodesToDim';

package/src/rules2/src/parseAttributes.js

@@ -0,0 +1,41 @@
+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);
+    const displayableValuesCount = R.pipe(
+      R.filter(R.propOr(true, 'display')),
+      R.length,
+    )(attr);
+    if (R.isEmpty(attr.values || []) || !R.propOr(true, 'display', attr)
+      || displayableValuesCount < 1 || 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 dimension = R.prop(id, indexedDimensions);
+        return !dimension.header && R.length(dimension.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);
+};