@sis-cc/dotstatsuite-components 9.1.0 → 9.2.0

package/lib/rules/src/preparators/enhanceObservations.js

@@ -0,0 +1,155 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.enhanceObservations = undefined;
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _getDisplay = require('./getDisplay');
+
+var _formatValue = require('./formatValue');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*
+  options = {
+    attachmentSeriesIndexes, //units
+    customAttributes: {
+      decimals: id,
+      prefscale: id,
+    },
+    noDisplayIndexes,
+    notDisplayedCodes,
+    unitsArtefacts,
+    obsAttributes,
+    rejectedValueIds,
+  }
+*/
+
+var getSerieKey = function getSerieKey(dimValuesIndexes, options) {
+  var indexes = R.propOr([], 'attachmentSeriesIndexes', options);
+  return R.pipe(R.addIndex(R.map)(function (valueIndex, dimIndex) {
+    if (dimIndex === R.head(indexes)) {
+      indexes = R.tail(indexes);
+      return valueIndex;
+    }
+    return 'x';
+  }), R.join(':'))(dimValuesIndexes);
+};
+
+var getUnitsValues = function getUnitsValues(indexes, options) {
+  return R.reduce(function (acc, codelist) {
+    var id = codelist.id;
+
+    if (!R.includes(id, R.propOr([], 'unitsIds', options))) {
+      return acc;
+    }
+    var valueIndex = R.prop(codelist.__index, indexes);
+    if (R.isNil(valueIndex) || !(0, _getDisplay.getDisplay)(options)(codelist)) {
+      return acc;
+    }
+    var value = R.path(['values', Number(valueIndex)], codelist);
+    if (R.isNil(value) || R.includes(value.id, R.propOr([], 'rejectedValueIds', options)) || !(0, _getDisplay.getDisplay)(options)((0, _extends3.default)({}, value, { parent: codelist.id }))) {
+      return acc;
+    }
+    return R.assoc(id, (0, _extends3.default)({}, R.pick(['id', 'name', '__index'], codelist), {
+      value: R.when(R.complement(R.isNil), R.assoc('index', Number(valueIndex)))(value)
+    }), acc);
+  }, {});
+};
+
+var getObservationUnits = function getObservationUnits(observation, dimensions, attributes, options) {
+  var dimensionsUnits = getUnitsValues(R.propOr([], 'dimValuesIndexes', observation), options)(dimensions);
+
+  var attributesUnits = getUnitsValues(R.propOr([], 'attrValuesIndexes', observation), options)(attributes);
+
+  var serieKey = getSerieKey(R.propOr([], 'dimValuesIndexes', observation), options);
+
+  return (0, _extends3.default)({}, dimensionsUnits, attributesUnits, { serieKey: serieKey });
+};
+
+var getOrderedDimensionsIndexes = function getOrderedDimensionsIndexes(dimensions, indexes) {
+  return R.addIndex(R.map)(function (valueIndex, dimensionIndex) {
+    return R.path([dimensionIndex, 'values', valueIndex, '__indexPosition'], dimensions);
+  }, indexes);
+};
+
+var getFormatAttributesIndexes = function getFormatAttributesIndexes(attributes, customAttributes) {
+  return R.addIndex(R.reduce)(function (acc, attribute, index) {
+    if (R.equals(attribute.id, customAttributes.decimals)) {
+      return (0, _extends3.default)({}, acc, { decimals: index });
+    }
+    if (R.equals(attribute.id, customAttributes.prefscale)) {
+      return (0, _extends3.default)({}, acc, { prefscale: index });
+    }
+    return acc;
+  }, { prefscale: null, decimals: null }, attributes);
+};
+
+var getAttributeValue = function getAttributeValue(attribute, valueIndex, options) {
+  if (!(0, _getDisplay.getDisplay)(options)(attribute)) {
+    return null;
+  }
+  var value = R.pipe(R.propOr([], 'values'), R.nth(valueIndex))(attribute);
+
+  if (R.isNil(value) || !(0, _getDisplay.getDisplay)(options)((0, _extends3.default)({}, value, { parent: attribute.id }))) {
+    return null;
+  }
+
+  return (0, _extends3.default)({}, R.pick(['id', 'name'], attribute), {
+    value: R.pick(['id', 'name'], value)
+  });
+};
+
+var enhanceObservations = exports.enhanceObservations = function enhanceObservations() {
+  var dimensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var observations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var attributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+  var formatAttributesIndexes = getFormatAttributesIndexes(attributes, R.propOr({}, 'customAttributes', options));
+  var _attributes = R.addIndex(R.map)(function (attr, index) {
+    return R.assoc('__index', index, attr);
+  }, attributes);
+  var _obsAttributes = R.pipe(R.indexBy(R.prop('id')), R.props(options.attributesIds || []))(_attributes);
+
+  var seriesDimensions = R.filter(R.pipe(R.propOr([], 'values'), R.length, R.lt(1)), dimensions);
+
+  return R.mapObjIndexed(function (observation) {
+    var attrValuesIndexes = observation.attrValuesIndexes,
+        dimValuesIndexes = observation.dimValuesIndexes;
+
+    var obsAttributes = R.reduce(function (acc, attribute) {
+      var attrValue = getAttributeValue(attribute, R.nth(attribute.__index, attrValuesIndexes), options);
+      if (R.isNil(attrValue)) {
+        return acc;
+      }
+      return R.assoc(attribute.id, attrValue, acc);
+    }, {}, _obsAttributes);
+
+    var indexedDimValIds = R.addIndex(R.reduce)(function (acc, dimension, dimensionIndex) {
+      var id = dimension.id;
+      var valueIndex = R.nth(dimensionIndex, dimValuesIndexes);
+      var valueId = R.path(['values', Number(valueIndex), 'id'], dimension);
+      return R.assoc(id, valueId, acc);
+    }, {}, dimensions);
+
+    return (0, _extends3.default)({}, observation, {
+      attributes: obsAttributes,
+      formattedValue: (0, _formatValue.formatValue)(observation, formatAttributesIndexes, attributes),
+      orderedDimIndexes: getOrderedDimensionsIndexes(dimensions, dimValuesIndexes),
+      units: getObservationUnits(observation, seriesDimensions, _attributes, options),
+      indexedDimValIds: indexedDimValIds
+    });
+  }, observations);
+};

package/lib/rules/src/preparators/formatValue.js

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatValue = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _numeral = require('numeral');
+
+var _numeral2 = _interopRequireDefault(_numeral);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var isValidNumber = R.both(R.is(Number), R.complement(R.equals(NaN)));
+
+var getFormatAttributesValues = function getFormatAttributesValues(observation, formatAttributesIndexes, attributes) {
+  return R.mapObjIndexed(function (attributeIndex) {
+    var valueIndex = R.pipe(R.propOr([], 'attrValuesIndexes'), R.nth(attributeIndex), function (v) {
+      return R.isNil(v) ? null : Number(v);
+    }, function (v) {
+      return isNaN(v) ? null : v;
+    })(observation);
+
+    return R.pipe(R.path([attributeIndex, 'values', valueIndex, 'id']), function (v) {
+      return R.isNil(v) ? null : Number(v);
+    }, function (v) {
+      return isNaN(v) ? null : v;
+    })(attributes);
+  }, formatAttributesIndexes);
+};
+
+var formatValue = exports.formatValue = function formatValue(observation, formatAttributesIndexes, attributes) {
+  var value = R.prop('value', observation);
+  if (R.is(Boolean, value)) {
+    return value;
+  }
+  if (R.is(String, value)) {
+    var monthMatch = value.match(/^\-\-([\d]{2})$/);
+    if (R.is(Array, monthMatch)) {
+      return R.nth(1, monthMatch);
+    }
+    var monthDayMatch = value.match(/^\-\-([\d]{2}\-[\d]{2})$/);
+    if (R.is(Array, monthDayMatch)) {
+      return R.nth(1, monthDayMatch);
+    }
+    var dayMatch = value.match(/^\-\-\-([\d]{2})$/);
+    if (R.is(Array, dayMatch)) {
+      return R.nth(1, dayMatch);
+    }
+    return value;
+  }
+
+  var _getFormatAttributesV = getFormatAttributesValues(observation, formatAttributesIndexes, attributes),
+      prefscale = _getFormatAttributesV.prefscale,
+      decimals = _getFormatAttributesV.decimals;
+
+  var formatScale = R.when(R.always(isValidNumber(prefscale)), function (value) {
+    return (0, _numeral2.default)(value).multiply(Math.pow(10, -1 * Number(prefscale))).value();
+  });
+
+  var formatSeparator = function formatSeparator(value) {
+    return (0, _numeral2.default)(value).format('0,0.[0000000]');
+  };
+  var formatDecimals = R.ifElse(R.always(isValidNumber(decimals)), function (value) {
+    return (0, _numeral2.default)(value).format(R.ifElse(R.equals(0), R.always('0,0'), function (d) {
+      return '0,0.' + R.join('', R.times(R.always('0'), d));
+    })(decimals));
+  }, formatSeparator);
+
+  return R.ifElse(isValidNumber, R.pipe(formatScale, formatDecimals), R.always('..'))(observation.value);
+};

package/lib/rules/src/preparators/getDimensions.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDimensions = exports.isDisplayedFromOwnAnnotations = undefined;
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+var _dotstatsuiteSdmxjs = require('@sis-cc/dotstatsuite-sdmxjs');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var isDisplayedFromOwnAnnotations = exports.isDisplayedFromOwnAnnotations = function isDisplayedFromOwnAnnotations(artefact) {
+  var artefactAnnotations = R.propOr([], 'annotations', artefact);
+  return R.pipe(R.propOr([], 'annotations'), R.find(R.propEq('type', 'NOT_DISPLAYED')), R.isNil)(artefact);
+};
+
+// sdmxJson
+
+var getDimensions = exports.getDimensions = function getDimensions(sdmxJson) {
+  var annotations = R.pathOr([], ['data', 'structure', 'annotations'], sdmxJson);
+  var locale = R.path([], ['meta', 'contentLanguage'], sdmxJson);
+
+  var enhanceValues = R.addIndex(R.map)(function (val, __index) {
+    var annotationsIndexes = R.propOr([], 'annotations', val);
+    var valueAnnotations = R.props(annotationsIndexes, annotations);
+
+    return (0, _extends3.default)({}, value, {
+      __index: __index,
+      annotations: valueAnnotations,
+      name: R.pathOr('[' + val.id + ']', ['names', locale], val)
+    });
+  });
+
+  return R.pipe(R.pathOr([], ['data', 'structure', 'dimensions']), R.addIndex(R.map)(function (dimension, __index) {
+    var annotationsIndexes = R.propOr([], 'annotations', dimension);
+    var dimensionAnnotations = R.props(annotationsIndexes, annotations);
+
+    return (0, _extends3.default)({}, dimension, {
+      __index: __index,
+      name: R.pathOr('[' + val.id + ']', ['names', locale], val),
+      annotations: dimensionAnnotations,
+      values: enhanceValues(R.propOr([], 'values', dimension))
+    });
+  }))(sdmxJson);
+};

package/lib/rules/src/preparators/getDisplay.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDisplay = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var getDisplay = exports.getDisplay = function getDisplay(_ref) {
+  var _ref$noDisplayIndexes = _ref.noDisplayIndexes,
+      noDisplayIndexes = _ref$noDisplayIndexes === undefined ? [] : _ref$noDisplayIndexes,
+      _ref$notDisplayedCode = _ref.notDisplayedCodes,
+      notDisplayedCodes = _ref$notDisplayedCode === undefined ? {} : _ref$notDisplayedCode;
+
+  var annotationsValidator = R.pipe(R.propOr([], 'annotations'), R.intersection(noDisplayIndexes), R.isEmpty);
+
+  var blacklistValidator = R.ifElse(R.has('values'), function (_ref2) {
+    var id = _ref2.id;
+    return R.anyPass([R.complement(R.has)(id), R.hasPath([id, 'values'])])(notDisplayedCodes);
+  }, function (_ref3) {
+    var id = _ref3.id,
+        parent = _ref3.parent;
+    return R.complement(R.hasPath)([parent, 'values', id], notDisplayedCodes);
+  });
+
+  return R.allPass([annotationsValidator, blacklistValidator]);
+};

package/lib/rules/src/preparators/getObservations.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getObservations = undefined;
+
+var _ramda = require('ramda');
+
+var R = _interopRequireWildcard(_ramda);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var getObservations = exports.getObservations = function getObservations(sdmxJson) {
+  return R.pipe(R.pathOr({}, ['data', 'dataSets', 0, 'observations']), R.mapObjIndexed(function (observation, observationKey) {
+    var value = R.head(observation);
+    var attrValuesIndexes = R.tail(observation);
+    var dimValuesIndexes = R.split(':', observationKey);
+
+    return {
+      key: observationKey,
+      value: value,
+      attrValuesIndexes: attrValuesIndexes,
+      dimValuesIndexes: dimValuesIndexes
+    };
+  }))(sdmxJson);
+};

package/lib/rules/src/table/factories/getCells.js

@@ -9,8 +9,6 @@ var _ramda = require('ramda');
 
 var R = _interopRequireWildcard(_ramda);
 
-var _getCellValue = require('./getCellValue');
-
 var _dimensionUtils = require('../../dimension-utils');
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
@@ -72,6 +70,6 @@ var isValidNumber = R.both(R.is(Number), R.complement(R.equals(NaN)));
 
 var getCells = exports.getCells = function getCells(data, display, customAttributes, unitsProps) {
   return R.mapObjIndexed(function (observation) {
-    return R.pipe(R.set(R.lensProp('flags'), getFlags(customAttributes, (0, _dimensionUtils.dimensionValueDisplay)(display), unitsProps)(R.pick(['attributes', 'units'], observation))), R.set(R.lensProp('intValue'), R.prop('value')(observation)), R.set(R.lensProp('value'), (0, _getCellValue.getCellValue)(observation)), R.assoc('indexedDimValIds', R.prop('indexedDimValIds', observation)))({});
+    return R.pipe(R.set(R.lensProp('flags'), getFlags(customAttributes, (0, _dimensionUtils.dimensionValueDisplay)(display), unitsProps)(observation)), R.set(R.lensProp('intValue'), R.prop('value', observation)), R.set(R.lensProp('value'), R.prop('formattedValue', observation)), R.assoc('indexedDimValIds', R.prop('indexedDimValIds', observation)))({});
   }, R.propOr({}, 'observations', data));
 };