@sis-cc/dotstatsuite-components 22.0.1 → 22.0.2

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

@@ -0,0 +1,177 @@
+import * as R from 'ramda';
+import {
+  isTimePeriodDimension,
+} from '@sis-cc/dotstatsuite-sdmxjs';
+import {
+  getRelationnalAnnotations,
+  setAnnotationsLayout,
+  getIsHidden,
+} from './sdmx-data';
+import { getReportingYearStart } from './preparators/getReportingYearStart';
+import { getNotDisplayedIds } from '../../rules2/src';
+import { getValuesEnhanced } from './get-values-enhanced';
+
+const TIME_PERIOD_ID = 'TIME_PERIOD';
+
+export const dataTransformer = (dataNew, options = {}) => {
+  const { locale } = options;
+  const reportYearStart = getReportingYearStart(dataNew);
+  const getName = R.prop('name')
+  //---------------------------------------------------------------------------------------Annotations
+  const getStructure = R.pathOr({}, ['data', 'structure']);
+  const structure = getStructure(dataNew);
+  const getAnnotations = R.propOr([], 'annotations');
+  const annotations = getAnnotations(structure);
+  const getDataSets = R.pathOr({}, ['data', 'dataSets']);
+  const dataSets = getDataSets(dataNew);
+
+  const dataSetsAnnotations = R.props(
+    R.pathOr([], [0, 'annotations'], dataSets),
+    annotations,
+  );
+
+  /*
+    hiddenValues => codelistIds or codelistValuesIds for display computation
+    hiddenCombinations => used only for dimensions, if dimension values match the provided set, all dimension is removed
+  */
+  const { hiddenValues, hiddenCombinations } = getNotDisplayedIds(dataSetsAnnotations);
+  const getIsAllDimHidden = ({ id, values }) => {
+    if (!R.has(id, hiddenCombinations)) {
+      return false;
+    }
+    const valuesIds = R.pluck('id', values);
+    return R.isEmpty(R.difference(valuesIds, hiddenCombinations[id]));
+  }
+
+  //--------------------------------------------------------------------------------------------Header
+  const getMeta = R.propOr({}, 'meta');
+  const meta = getMeta(dataNew);
+
+  const getSender = R.propOr({}, 'sender');
+  const sender = getSender(meta);
+
+  const resHeader = {
+    ...meta,
+    sender: { ...sender, name: getName(sender) },
+  };
+
+  //----------------------------------------------------------------------------------------Attributes
+  const getAttributes = R.propOr({}, 'attributes');
+  const attributes = getAttributes(structure);
+
+  const getAttrObservations = R.propOr([], 'observation');
+  const attrObservations = getAttrObservations(attributes);
+
+  const resAttrObservations = R.addIndex(R.map)((observation, index) => {
+    const obsAnnotations = R.props(observation.annotations || [], annotations);
+    return {
+      ...observation,
+      __index: index,
+      display:
+        !R.has(observation.id, hiddenValues) && !getIsHidden(obsAnnotations),
+      name: getName(observation),
+      values: getValuesEnhanced({
+        locale,
+        annotations,
+        parent: observation.id,
+        reportYearStart,
+        hiddenIds: hiddenValues,
+        options,
+      })(R.propOr([], 'values', observation)),
+      roles: !R.isNil(observation.role) ? R.head(observation.role) : null,
+    };
+  }, attrObservations);
+
+  const datasetAttributes = R.map((attr) => {
+    const attrAnnotations = R.props(attr.annotations || [], annotations);
+    return {
+      ...attr,
+      display: !R.has(attr.id, hiddenValues) && !getIsHidden(attrAnnotations),
+      name: getName(attr),
+      values: getValuesEnhanced({
+        locale,
+        annotations,
+        parent: attr.id,
+        hiddenIds: hiddenValues,
+        options,
+        reportYearStart,
+      })(R.propOr([], 'values', attr)),
+    };
+  }, R.propOr([], 'dataSet', attributes));
+
+  const resAttributes = {
+    ...attributes,
+    observation: R.concat(resAttrObservations, datasetAttributes),
+  };
+
+  //----------------------------------------------------------------------------------------Dimensions
+  const getDimensions = R.propOr({}, 'dimensions');
+  const dimensions = getDimensions(structure);
+
+  const getDimObservations = R.propOr([], 'observation');
+  const dimObservations = getDimObservations(dimensions);
+
+  const getObservations = (locale) =>
+    R.addIndex(R.reduce)(
+      (acc, observation, obsIndex) => {
+        const id = R.prop('id')(observation);
+        const dimAnnotations = getRelationnalAnnotations(
+          R.propOr([], 'annotations')(observation),
+        )(annotations);
+        const isTimeDimension = isTimePeriodDimension(observation);
+        const values = getValuesEnhanced({
+          locale,
+          annotations,
+          isTimeDimension,
+          reportYearStart,
+          parent: id,
+          hiddenIds: hiddenValues,
+          options,
+        })(R.propOr([], 'values', observation));
+        const isAllDimHidden = getIsAllDimHidden({ id, values });
+        const isHidden = isAllDimHidden || R.has(id, hiddenValues)
+          || getIsHidden(dimAnnotations);
+        return {
+          observation: R.append({
+            ...observation,
+            rejected: isAllDimHidden || R.isEmpty(values),
+            display: !isHidden,
+            __index: obsIndex,
+            name: getName(observation),
+            values,
+            role: isTimeDimension
+              ? TIME_PERIOD_ID
+              : R.head(R.propOr([], 'roles', observation)),
+          })(acc.observation),
+          dimensionsLayout: setAnnotationsLayout(
+            id,
+            acc.dimensionsLayout,
+          )(dimAnnotations),
+        };
+      },
+      { observation: [], dimensionsLayout: {} },
+    );
+
+  //-----------------------------------------------------------------------------------------Structure
+  const { dimensionsLayout, observation } =
+    getObservations(locale)(dimObservations);
+  const resStructure = {
+    ...structure,
+    name: getName({ ...structure, id: options.dataflowId }),
+    annotations,
+    attributes: resAttributes,
+    dimensions: { observation },
+  };
+
+  //------------------------------------------------------------------------------------------------------Layout
+  const dataSetsLayout = R.reduce((acc, dataSetsAnnotation) => {
+    const title = R.propOr('', 'title')(dataSetsAnnotation);
+    if (R.isEmpty(title)) return acc;
+    return setAnnotationsLayout(title, acc)([dataSetsAnnotation]);
+  }, {})(dataSetsAnnotations);
+
+  return {
+    data: { header: resHeader, dataSets, structure: resStructure },
+    layout: R.mergeRight(dimensionsLayout, dataSetsLayout),
+  };
+};

package/src/rules2/src/applyHierarchicalCodesToDim.js

@@ -0,0 +1,123 @@
+import * as R from 'ramda';
+
+const addParentId = (id, ids) => {
+  const last = R.last(ids);
+  return R.append(R.isNil(last) ? id : `${last}.${id}`, ids); 
+}
+
+const _refineUnconfirmedPaths = (paths) => R.map(p => [R.head(p)], paths);
+
+const getHierId = v => R.isNil(v.parent) || R.isEmpty(v.parent)
+  ? v.id
+  : `${v.parent}.${v.id}`;
+
+export const applyHierarchicalCodesToDim = (hCodes, dim) => {
+  const confirmedHierarchisedChilds = new Set([]);
+  let unconfirmedPaths = {};
+
+  const indexedValues = R.reduce((acc, val) => {
+    if (!val.isSelected) {
+      return acc;
+    }
+    return R.assoc(val.id, val, acc);
+  }, {}, dim.values || []);
+
+  const parseHCodes = (parentsDef, parentsInDim) => R.reduce((acc, hC) => {
+    const { codeID, hierarchicalCodes = [] } = hC;
+    const hasInDim = R.has(codeID, indexedValues);
+    const isUnconfirmed = R.length(parentsInDim) !== R.length(parentsDef);
+    const children = parseHCodes(
+      R.append(codeID, parentsDef),
+      hasInDim ? addParentId(codeID, parentsInDim) : parentsInDim
+    )(hierarchicalCodes);
+    if (!hasInDim) {
+      return R.concat(acc, children);
+    }
+    const path = R.join('.', parentsDef);
+    let val = {
+      ...R.prop(codeID, indexedValues),
+      path,
+      parents: parentsInDim,
+      parent: R.last(parentsInDim),
+      children
+    };
+
+    if (isUnconfirmed) {
+      unconfirmedPaths = R.over(R.lensProp(val.id), paths => R.append(path, paths || []), unconfirmedPaths);
+      val = R.assoc('unconfirmed', true, val);
+      return R.append(val, acc);
+    }
+    confirmedHierarchisedChilds.add(codeID);
+    return R.append(val, acc);
+  }, []);
+
+  const parsed = parseHCodes([], [])(hCodes);
+
+  const _unconfirmedPaths = R.pipe(
+    R.reject(id => confirmedHierarchisedChilds.has(id)),
+    ids => R.pick(ids, unconfirmedPaths)
+  )(R.keys(unconfirmedPaths));
+
+  const refinedUnconfirmedPaths = _refineUnconfirmedPaths(_unconfirmedPaths);
+
+  const flattenDescendants = R.reduce((acc, val ) => {
+    const children = flattenDescendants(val.children || []);
+    return R.concat(acc, R.prepend(val, children));
+  }, []);
+
+  const isValid = val => !val.unconfirmed || val.path === R.head(refinedUnconfirmedPaths[val.id] || []);
+
+  const refineCodes = R.reduce((acc, hC) => {
+    const _flatDescendants = flattenDescendants(hC.children);
+    const flatDescendants = R.prepend(hC, _flatDescendants);
+
+    const valids = R.filter(isValid, flatDescendants);
+
+    if (R.isEmpty(valids)) {
+      return acc;
+    }
+    const refined = R.pipe(
+      R.reduce((_acc, v) => {
+        confirmedHierarchisedChilds.add(v.id);
+        const prev = R.last(_acc);
+        const parents = R.pipe(
+          p => R.isNil(p) ? [] : R.append(getHierId(p), prev.parents || []),
+          R.filter(id => R.includes(id, v.parents)),
+        )(prev);
+        const rV = {
+          ...R.omit(['unconfirmed', 'children', 'path'], v),
+          parents,
+          parent: R.isEmpty(parents) ? undefined : R.last(parents)
+        };
+        return R.append(rV, _acc);
+      }, [])
+    )(valids);
+    return R.concat(acc, refined);
+  }, []);
+
+  const refined = refineCodes(parsed);
+
+  const missingValues = R.pipe(
+    R.keys,
+    R.filter(id => !confirmedHierarchisedChilds.has(id)),
+    ids => R.props(ids, indexedValues),
+    R.map(v => ({ ...v, parents: [], parent: undefined })),
+    R.sortBy(R.propOr(-1, '__indexPosition')),
+  )(indexedValues);
+
+  let hierarchicalIndexes = {};
+  return R.pipe(
+    R.concat,
+    R.addIndex(R.map)((v, ind) => {
+      const parents = R.props(v.parents, hierarchicalIndexes);
+      const hierId = getHierId(v);
+      hierarchicalIndexes[hierId] = ind;
+      return {
+        ...R.dissoc('path', v),
+        parents,
+        __indexPosition: ind
+      };
+    }),
+    values => ({ ...dim, values })
+  )(missingValues, refined);
+};

package/src/rules2/src/combinedValuesDisplay.js

@@ -0,0 +1,74 @@
+import * as R from 'ramda';
+import { dimensionValueDisplay } from '../../rules/src';
+import { REJECTED_VALUE_IDS } from './constants';
+
+const getRefinedMissinParentsLabels = R.pipe(
+  R.propOr([], 'missingParents'),
+  R.reduce((acc, par) => {
+    if (
+      !R.propOr(true, 'display', par) ||
+      R.includes(par.id, REJECTED_VALUE_IDS)
+    ) {
+      return acc;
+    }
+    return R.append(dimensionValueDisplay('label')(par), acc);
+  }, []),
+);
+
+export const singleValueDisplay = (display, value) => {
+  if (display === 'label') {
+    return R.converge(
+      (missingParents, label) =>
+        R.isEmpty(missingParents)
+          ? label
+          : R.join(' > ', R.append(label, missingParents)),
+      [getRefinedMissinParentsLabels, dimensionValueDisplay(display)],
+    )(value);
+  } else if (display === 'both') {
+    return `(${singleValueDisplay('code', value)}) ${singleValueDisplay(
+      'label',
+      value,
+    )}`;
+  }
+  return dimensionValueDisplay(display)(value);
+};
+
+const _combinedValuesDisplay = (_display) => (values) =>
+  R.pipe(
+    R.reduce((acc, val) => {
+      if (R.isNil(val)) return acc;
+      const isDisplayed = R.propOr(true, 'display', val);
+      const isRejected = R.includes(val.id, REJECTED_VALUE_IDS);
+      if ((!isDisplayed || isRejected) && _display === 'label') return acc;
+      return R.append(singleValueDisplay(_display, val), acc);
+    }, []),
+    (labels) => {
+      if (!R.isEmpty(labels) || _display !== 'label') {
+        return R.join(', ', labels);
+      }
+      const totalValue = R.find(R.propEq('id', '_T'), values);
+      if (!R.isNil(totalValue)) {
+        return dimensionValueDisplay('label')(totalValue);
+      }
+      if (R.isEmpty(values)) {
+        return '';
+      }
+      const firstValue = R.head(values);
+      return dimensionValueDisplay('label')(firstValue);
+    },
+  )(values);
+
+export const combinedValuesDisplay = (display, values) => {
+  if (display === 'both') {
+    return R.converge(
+      (_ids, labels) => {
+        return dimensionValueDisplay('both')({
+          id: _ids,
+          name: labels,
+        });
+      },
+      [_combinedValuesDisplay('code'), _combinedValuesDisplay('label')],
+    )(values);
+  }
+  return _combinedValuesDisplay(display)(values);
+};

package/src/rules2/src/constants.js

@@ -0,0 +1,6 @@
+export const SDMX_3_0_JSON_DATA_FORMAT = 'application/vnd.sdmx.data+json;version=2.0';
+export const SDMX_3_0_CSV_DATA_FORMAT = 'application/vnd.sdmx.data+csv;version=2.0';
+export const EMPTY_ATTACHMENT_LEVEL_CHAR = '~';
+export const REPORTING_YEAR_START_DAY = 'REPORTING_YEAR_START_DAY';
+export const REPYEARSTART = 'REPYEARSTART';
+export const REJECTED_VALUE_IDS = ['_L', '_T', '_Z'];

package/src/rules2/src/duplicateObservations.js

@@ -0,0 +1,35 @@
+import * as R from 'ramda';
+
+export const duplicateObs = (dims, observations) => {
+  const obsValues = R.values(observations);
+  if (R.length(dims) === 0) {
+    return observations;
+  }
+  const duplicated = R.reduce(
+    (obs, dim) => {
+      const groupedObs = R.groupBy(o => R.prop(dim.id, o.indexedDimValIds), obs);
+      const enhancedObs = R.addIndex(R.map)(
+        (value, index) => {
+          const matchingObs = R.propOr([], value.id, groupedObs);
+
+          return R.map(
+            obs => R.over(
+              R.lensProp('orderedDimIndexes'),
+              _indexes => {
+                const indexes = R.isNil(_indexes) ? R.map(i => Number(i), obs.dimValuesIndexes) : _indexes;
+                return R.set(R.lensIndex(dim.__index), index)(indexes);
+              }
+            )(obs),
+            matchingObs
+          );
+        },
+        dim.values
+      );
+      return R.unnest(enhancedObs);
+    },
+    obsValues,
+    dims
+  );
+  const res =  R.indexBy(R.pipe(R.prop('orderedDimIndexes'), R.join(':')), duplicated);
+  return res;
+};

package/src/rules2/src/enhanceObservations.js

@@ -0,0 +1,95 @@
+import * as R from 'ramda';
+import { formatValue } from '../../rules/src/preparators/formatValue';
+import { REJECTED_VALUE_IDS } from './constants';
+
+/*
+  options = {
+    customAttributes: {
+      decimals: id,
+      prefscale: id,
+    },
+  }
+*/
+
+const parseAttributesValues = (obs, attributes, indexedDimensions) => {
+  const { attrValuesIndexes, dimValuesIndexes } = obs;
+  return R.addIndex(R.reduce)(
+    (acc, valueIndex, attrIndex) => {
+      const attribute = R.nth(attrIndex, attributes);
+      if (R.isNil(attribute) || !R.prop('series', attribute)) {
+        return acc;
+      }
+      const _value = R.nth(valueIndex, attribute.values || []);
+      let value = R.isNil(_value)
+        ? _value
+        : R.over(R.lensProp('display'), (display=true) => display && !R.includes(_value.id, REJECTED_VALUE_IDS))(_value);
+      if ((!R.propOr(true, 'display', attribute) || !R.propOr(true, 'display', value))) {
+        value = null;
+      }
+      const relationship = R.propOr([], 'relationship', attribute);
+      let coordinates = {};
+      const serieKey = R.pipe(
+        dims => R.isEmpty(relationship) ? R.values(dims) : R.props(relationship, dims),
+        R.map(dim => {
+          const valueIndex = R.nth(dim.__index, dimValuesIndexes);
+          const valueId = R.path(['values', valueIndex, 'id'], dim);
+          coordinates = R.assoc(dim.id, valueId, coordinates);
+          return `${dim.id}=${valueId}`;
+        }),
+        R.ifElse(R.isEmpty, R.always(null), R.join(':'))
+      )(indexedDimensions);
+
+      return R.assoc(
+        attribute.id,
+        { ...R.pick(['id', 'name', 'relationship', 'display', 'combined'], attribute), value, serieKey, coordinates, isObs: R.isEmpty(relationship) },
+        acc
+      );
+    },
+    {},
+    attrValuesIndexes
+  );
+};
+
+const getFormatAttributesIndexes = (attributes, customAttributes) => R.addIndex(R.reduce)(
+  (acc, attribute, index) => {
+    if (R.equals(attribute.id, customAttributes.decimals)) {
+      return ({ ...acc, decimals: index });
+    }
+    if (R.equals(attribute.id, customAttributes.prefscale)) {
+      return ({ ...acc, prefscale: index });
+    }
+    return acc;
+  },
+  { prefscale: null, decimals: null },
+  attributes
+);
+
+export const enhanceObservations = (dimensions = [], observations = {}, attributes = [], options = {}) => {
+  const formatAttributesIndexes = getFormatAttributesIndexes(attributes, R.propOr({}, 'customAttributes', options));
+  const indexedDimensions = R.indexBy(R.prop('id'), dimensions);
+
+  return R.map(
+    (observation) => {
+      const { dimValuesIndexes } = observation;
+
+      const indexedDimValIds = R.addIndex(R.reduce)(
+        (acc, dimension, dimensionIndex) => {
+          const id = dimension.id;
+          const valueIndex = R.nth(dimensionIndex, dimValuesIndexes);
+          const valueId = R.path(['values', Number(valueIndex), 'id'], dimension);
+          return R.assoc(id, valueId, acc);
+        },
+        {},
+        dimensions
+      );
+
+      return ({
+        ...observation,
+        attributes: parseAttributesValues(observation, attributes, indexedDimensions),
+        formattedValue: formatValue(observation, formatAttributesIndexes, attributes),
+        indexedDimValIds,
+      });
+    },
+    observations
+  );
+};

package/src/rules2/src/getAdvAttrSeriesAtCoordinates.js

@@ -0,0 +1,29 @@
+import * as R from 'ramda';
+
+const attribueValueDisplay = (display) => data => {
+  if (display === 'code') {
+    return R.prop('id', data);
+  }
+  if (display ===  'both') {
+    return `${R.prop('id', data)}: ${R.prop('name', data)}`;
+  }
+  return R.prop('name', data);
+};
+
+export const getAdvAttrSeriesAtCoordinates = (coordinates, advancedAttributes, display) => R.pipe(
+  R.filter(serie => {
+    const mergedCoord = R.mergeLeft(serie.coordinates, coordinates);
+    return R.equals(mergedCoord, coordinates);
+  }),
+  R.map(serie => {
+    return R.pipe(
+      R.propOr({}, 'attributes'),
+      R.values,
+      R.map(attribute => ({
+        id: attribute.id,
+        label: attribueValueDisplay(display)(attribute),
+        value: attribueValueDisplay(display)(attribute.value)
+      }))
+    )(serie);
+  }),
+)(advancedAttributes);

package/src/rules2/src/getAttributesSeries.js

@@ -0,0 +1,36 @@
+import * as R from 'ramda';
+
+export const getAttributesSeries = observations => R.pipe(
+  R.values,
+  R.reduce(
+    (acc, { attributes }) => {
+      let res = acc.res;
+      let rejected = acc.rejected;
+      R.forEachObjIndexed(
+        (attribute) => {
+          if (!R.isNil(attribute.serieKey) && !attribute.isObs) {
+            if (R.isNil(attribute.value)) {
+              res = R.dissocPath([attribute.serieKey, attribute.id], res);
+              rejected = R.assocPath([attribute.serieKey, attribute.id], true, rejected);
+            }
+            if (R.path([attribute.serieKey, attribute.id], rejected)) {
+              return ;
+            }
+            const valueInRes = R.path([attribute.serieKey, attribute.id, 'value', 'id'], res);
+            if (!R.isNil(valueInRes) && valueInRes !== R.path(['value', 'id'], attribute)) {
+              res = R.dissocPath([attribute.serieKey, attribute.id], res);
+              rejected = R.assocPath([attribute.serieKey, attribute.id], true, rejected);
+            }
+            else {
+              res = R.assocPath([attribute.serieKey, attribute.id], attribute, res);
+            }
+          }
+        },
+        attributes
+      );
+      return ({ res, rejected });
+    },
+    { res: {}, rejected: {}, }
+  ),
+  R.prop('res')
+)(observations);

package/src/rules2/src/getCombinationDefinitions.js

@@ -0,0 +1,47 @@
+import * as R from 'ramda';
+
+const parseTexts = texts => R.reduce(
+  (acc, text) => {
+    const splitted = R.split(':', text);
+    if (R.length(splitted) !== 2) {
+      return acc;
+    }
+    const [id, name] = splitted;
+    return R.assoc(id, name, acc);
+  },
+  {},
+  texts
+);
+
+export const parseCombinationDefinition = (locale) => (title, texts) => R.useWith(
+  (titles, texts) =>
+    R.reduce((acc, title) => {
+      const split = R.split(':', title);
+      if (R.length(split) !== 2) {
+        return acc;
+      }
+      const [id, codes] = split;
+      if (R.isEmpty(codes)) {
+        return acc;
+      }
+      return R.append({
+        id,
+        concepts: R.split(',', codes),
+        name: R.hasPath([locale, id], texts)
+          ? R.path([locale, id], texts)
+          : `[${id}]`,
+      }, acc);
+    }, [], titles),
+  [R.split(';'), R.map(R.pipe(R.split(';'), parseTexts))],
+)(title, texts);
+
+export const getCombinationDefinitions = (annotations, locale) => {
+  const annotation = R.find(annot => annot.type === 'COMBINED_CONCEPTS', annotations);
+  if (R.isNil(annotation)) {
+    return [];
+  }
+  const title = R.propOr('', 'title', annotation);
+  const texts = R.propOr({}, 'texts', annotation);
+
+  return parseCombinationDefinition(locale)(title, texts);
+};

package/src/rules2/src/getDataflowAttributes.js

@@ -0,0 +1,23 @@
+import * as R from 'ramda';
+import { REJECTED_VALUE_IDS } from './constants';
+
+export const getDataflowAttributes = (attributes, combinations) => {
+  const combinationsConceptsIds = R.pipe(R.pluck('concepts'), R.unnest)(combinations);
+  return R.reduce(
+    (acc, attribute) => {
+      if (!R.prop('header', attribute) || !R.isEmpty(attribute.relationship)
+        || R.includes(attribute.id, combinationsConceptsIds)) {
+        return acc;
+      }
+      const value = R.head(attribute.values);
+      if (!R.propOr(true, 'display', attribute) || R.isNil(value)
+        || !R.propOr(true, 'display', value) || R.includes(R.prop('id', value), REJECTED_VALUE_IDS)) {
+        return acc;
+      }
+      return R.assoc(attribute.id, { ...R.pick(['id', 'name'], attribute), value }, acc);
+    },
+    {},
+    attributes,
+  );
+};
+

package/src/rules2/src/getDataflowTooltipAttributesIds.js

@@ -0,0 +1,31 @@
+import * as R from 'ramda';
+
+export const getDataflowTooltipAttributesIds = (sdmxJson, defaults = {}) => {
+  const dataflowAnnotationsIndexes = R.pathOr([], ['data', 'dataSets', 0, 'annotations'], sdmxJson);
+  const dataflowAnnotations = R.props(dataflowAnnotationsIndexes, R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson));
+
+  const flagsAttrAnnotation = R.find(R.propEq('type', 'LAYOUT_FLAG'), dataflowAnnotations);
+  const footnotesAttrAnnotation = R.find(R.propEq('type', 'LAYOUT_NOTE'), dataflowAnnotations);
+
+  const customFlags = R.pipe(
+    R.propOr('', 'title'),
+    title => R.isNil(title) || R.isEmpty(title) ? [] : R.split(',', title)
+  )(flagsAttrAnnotation || {});
+
+  const customNotes = R.pipe(
+    R.propOr('', 'title'),
+    title => R.isNil(title) || R.isEmpty(title) ? [] : R.split(',', title),
+    notes => R.difference(notes, customFlags)
+  )(footnotesAttrAnnotation || {});
+
+  const flags = R.isNil(flagsAttrAnnotation)
+    ? R.difference(defaults.flags || [], customNotes)
+    : customFlags;
+
+  const notes = R.isNil(footnotesAttrAnnotation)
+    ? R.difference(defaults.notes || [], flags)
+    : customNotes;
+
+  return ({ flags, notes });
+};
+