@sis-cc/dotstatsuite-components 15.0.15 → 15.0.17

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

@@ -92,7 +92,7 @@ var getAttributeValue = function getAttributeValue(attribute, valueIndex, option
   }
   var value = R.pipe(R.propOr([], 'values'), R.nth(valueIndex))(attribute);
 
-  if (R.isNil(value) || !R.propOr(true, 'display', value)) {
+  if (R.isNil(value) || !R.propOr(true, 'display', value) || R.includes(value.id, R.propOr([], 'rejectedValueIds')(options))) {
     return null;
   }
 

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

@@ -18,20 +18,24 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 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 parseValidNumber = R.pipe(function (v) {
+  return R.isNil(v) ? null : Number(v);
+}, function (v) {
+  return isNaN(v) ? null : v;
+});
 
 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);
+    var valueIndex = void 0;
+    var relationship = R.pipe(R.nth(attributeIndex), R.propOr({}, 'relationship'))(attributes);
+    //if (!R.isNil(attributeIndex) && attributeIndex >= R.length(R.propOr([], 'attrValuesIndexes', observation))) {
+    if (R.has('none', relationship) || R.has('dataflow', relationship)) {
+      valueIndex = 0;
+    } else {
+      valueIndex = R.pipe(R.propOr([], 'attrValuesIndexes'), R.nth(attributeIndex), parseValidNumber)(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);
+    return R.pipe(R.path([attributeIndex, 'values', valueIndex, 'id']), parseValidNumber)(attributes);
   }, formatAttributesIndexes);
 };
 

package/lib/rules/src/table/preparators/parseAttributes.js

@@ -17,11 +17,16 @@ var registerAttrId = function registerAttrId(path, id) {
   return R.over(R.lensPath(R.prepend('attributesIdsIndexedByTargets', path)), R.ifElse(R.isNil, R.always([id]), R.append(id)));
 };
 
-var registerAttr = function registerAttr(attr) {
-  return R.set(R.lensPath(['attributesIndexedByIds', attr.id]), attr);
+var _registerAttr = function _registerAttr(rejected) {
+  return function (attr) {
+    return R.set(R.lensPath(['attributesIndexedByIds', attr.id]), R.over(R.lensProp('values'), R.map(function (v) {
+      return R.includes(R.prop('id')(v), rejected) ? null : v;
+    }))(attr));
+  };
 };
 
 var getAttributeRegisters = function getAttributeRegisters(attribute, parsedDimensionsIds, customAttributes) {
+  var registerAttr = _registerAttr(R.propOr([], 'rejectedValueIds')(customAttributes));
   if (R.propEq('id', customAttributes.prefscale, attribute)) {
     return [registerAttrId(['prefscale'], attribute.id), registerAttr(attribute)];
   }

package/lib/rules/src/table/preparators/prepareData.js

@@ -111,7 +111,8 @@ var prepareData = exports.prepareData = function prepareData(sdmxJson, customAtt
     attachmentSeriesIndexes: attachmentSeriesIndexes,
     customAttributes: customAttributes,
     attributesIds: R.concat(seriesAttributesIds, observationsAttributesIds),
-    unitsIds: obsUnitsIds
+    unitsIds: obsUnitsIds,
+    rejectedValueIds: rejectedValueIds
   };
 
   var _observations = (0, _getObservations.getObservations)(sdmxJson);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sis-cc/dotstatsuite-components",
   "description": "Set components based on React.",
-  "version": "15.0.15",
+  "version": "15.0.17",
   "main": "lib/index.js",
   "author": "OECD",
   "license": "MIT",

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

@@ -94,7 +94,7 @@ const getAttributeValue = (attribute, valueIndex, options) => {
     R.nth(valueIndex)
   )(attribute);
 
-  if (R.isNil(value) || !R.propOr(true, 'display', value)) {
+  if (R.isNil(value) || !R.propOr(true, 'display', value) || R.includes(value.id,R.propOr([],'rejectedValueIds')(options))) {
     return null;
   }
 

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

@@ -2,20 +2,30 @@ import * as R from 'ramda';
 import numeral from 'numeral';
 
 const isValidNumber = R.both(R.is(Number), R.complement(R.equals(NaN)));
+const parseValidNumber = R.pipe(
+  v => R.isNil(v) ? null : Number(v),
+  v => isNaN(v) ? null : v
+);
 
 const getFormatAttributesValues = (observation, formatAttributesIndexes, attributes) => R.mapObjIndexed(
   attributeIndex => {
-    const valueIndex = R.pipe(
-      R.propOr([], 'attrValuesIndexes'),
-      R.nth(attributeIndex),
-      v => R.isNil(v) ? null : Number(v),
-      v => isNaN(v) ? null : v
-    )(observation);
+    let valueIndex;
+    const relationship = R.pipe(R.nth(attributeIndex), R.propOr({}, 'relationship'))(attributes);
+    //if (!R.isNil(attributeIndex) && attributeIndex >= R.length(R.propOr([], 'attrValuesIndexes', observation))) {
+    if (R.has('none', relationship) || R.has('dataflow', relationship)) {
+      valueIndex = 0;
+    }
+    else {
+      valueIndex = R.pipe(
+        R.propOr([], 'attrValuesIndexes'),
+        R.nth(attributeIndex),
+        parseValidNumber
+      )(observation);
+    }
 
     return R.pipe(
       R.path([attributeIndex, 'values', valueIndex, 'id']),
-      v => R.isNil(v) ? null : Number(v),
-      v => isNaN(v) ? null : v
+      parseValidNumber
     )(attributes);
   },
   formatAttributesIndexes

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

@@ -6,12 +6,13 @@ const registerAttrId = (path, id) => R.over(
   R.ifElse(R.isNil, R.always([id]), R.append(id))
 );
 
-const registerAttr = (attr) => R.set(
+const _registerAttr = rejected=>(attr) => R.set(
   R.lensPath(['attributesIndexedByIds', attr.id]),
-  attr
+  R.over(R.lensProp('values'),R.map(v=> R.includes(R.prop('id')(v),rejected)? null : v))(attr)
 );
 
 const getAttributeRegisters = (attribute, parsedDimensionsIds, customAttributes) => {
+  const registerAttr = _registerAttr(R.propOr([],'rejectedValueIds')(customAttributes))
   if (R.propEq('id', customAttributes.prefscale, attribute)) {
     return [registerAttrId(['prefscale'], attribute.id), registerAttr(attribute)];
   }

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

@@ -76,7 +76,8 @@ export const prepareData = (sdmxJson, customAttributes, unitsProps={}, _options=
     attachmentSeriesIndexes,
     customAttributes,
     attributesIds: R.concat(seriesAttributesIds, observationsAttributesIds),
-    unitsIds: obsUnitsIds
+    unitsIds: obsUnitsIds,
+    rejectedValueIds
   };
   
   const _observations = getObservations(sdmxJson);

package/test/enhanceObservations.test.js

@@ -232,4 +232,109 @@ describe('enhanceObservations tests', () => {
       }
     });
   });
+  it('should not return attributes with rejectedValueIds [v0,v1]',()=> {
+    const attributes = [
+      {
+        id: 'a0',
+        values: [{ id: 'v0' }, { id: 'v1' }, { id: 'v2' }],
+      },
+      {
+        id: 'a1',
+        values: [{ id: 'v0' }],
+      },  
+    ];
+
+    const dimensions = [
+      {
+        id: 'd0',
+        __index: 0,
+        values: [
+          { id: 'v0', __index: 0, __indexPosition: 0 },
+          { id: 'v1', __index: 1, __indexPosition: 1 },
+          { id: 'v2', __index: 2, __indexPosition: 2 },
+          { id: 'v3', __index: 3, __indexPosition: 3, display: false }
+        ]
+      },
+      {
+        id: 'd1',
+        __index: 1,
+        values: [
+          { id: 'v0', __index: 0, __indexPosition: 0 }
+        ]
+      }
+    ];
+
+
+    const observations = {
+      a: {
+        attrValuesIndexes: [0, 0, 0, 0, 0],
+        dimValuesIndexes: [0, 0, 0, 0, 0],
+        value: 22,
+      },
+      b: {
+        attrValuesIndexes: [1, 0, 1, 1, 0],
+        dimValuesIndexes: [0, 0, 0, 1, 0],
+        value: 17,
+      },
+    };
+
+    const options = {
+      noDisplayIndexes: [],
+      notDisplayedCodes: {
+        d0: { values: { v3: 'v3' } },
+      },
+      attributesIds: ['a0', 'a1'],
+      unitsIds: ['d0'],
+      rejectedValueIds: ['v0','v1']
+    };
+    expect(enhanceObservations(dimensions, observations, attributes, options)).to.deep.equal({
+      a: {
+        attrValuesIndexes: [0, 0, 0, 0, 0],
+        dimValuesIndexes: [0, 0, 0, 0, 0],
+        value: 22,
+        formattedValue: '22',
+        units: {
+          serieKey: 'x:x:x:x:x'
+        },
+        attributes: {},
+        indexedDimValIds: { d0: 'v0', d1: 'v0'}
+      },
+      b: {
+        attrValuesIndexes: [1, 0, 1, 1, 0],
+        dimValuesIndexes: [0, 0, 0, 1, 0],
+        value: 17,
+        formattedValue: '17',
+        units: {
+          serieKey: 'x:x:x:x:x'
+        },
+        attributes: {},
+        indexedDimValIds: { d0: 'v0', d1: 'v0'}
+      },
+  })
+})
+  it('apply format attrs from dataflow level', () => {
+    const observations = {
+      a: { value: 2.358, attrValuesIndexes: [], dimValuesIndexes: [] },
+      b: { value: 10.578, attrValuesIndexes: [], dimValuesIndexes: [] },
+    };
+
+    const attributes = [
+      { id: 'PREF', relationship: { none: {} }, values: [{ id: '-1' }] },
+      { id: 'DEC', relationship: { dataflow: {} }, values: [{ id: '1' }] }
+    ];
+
+    const options = {
+      noDisplayIndexes: [],
+      notDisplayedCodes: {},
+      attributesIds: [],
+      unitsIds: [],
+      rejectedValueIds: [],
+      customAttributes: { prefscale: 'PREF', decimals: 'DEC' }
+    };
+    expect(enhanceObservations([], observations, attributes, options)).to.deep.equal({
+      a: { attributes: {}, units: { serieKey: '' }, value: 2.358, formattedValue: '23.6', attrValuesIndexes: [], dimValuesIndexes: [], indexedDimValIds: {} },
+      b: { attributes: {}, units: { serieKey: '' }, value: 10.578, formattedValue: '105.8', attrValuesIndexes: [], dimValuesIndexes: [], indexedDimValIds: {} },
+    });
+  });
 });
+

package/test/parseAttributes.test.js

@@ -27,12 +27,14 @@ const attributes = [
   { id: 'a22', relationship: { observation: {} }, values: [{ id: 'a22v0' }] }, // alternative observation relationship
   { id: 'REPORTING_YEAR_START_DAY', relationship: { observation: {} }, values: [{ id: 'a22v0' }]},
   { id: 'REPYEARSTART', relationship: { observation: {} }, values: [{ id: 'a22v0' }]},
+  { id: 'a23', relationship: { observation: {} }, values: [{ id: 'a23v0' },{id : 'a23v1'}]},
 ];
 
 const customAttributes = {
   prefscale: 'a15',
   decimals: 'a16',
-  units: ['d7', 'a20']
+  units: ['d7', 'a20'],
+  rejectedValueIds:['a23v0']
 };
 
 const parsedDimensionsIds = {
@@ -59,10 +61,11 @@ describe('parseAttributes test', () => {
         a18: { id: 'a18', index: 18, relationship: { primaryMeasure: 'OBS_VALUE' }, values: [{ id: 'a18v1' }, null] },
         a19: { id: 'a19', index: 19, relationship: { none: {} }, values: [{ id: 'a19v1' }] },
         a21: { id: 'a21', index: 21, relationship: { dataflow: {} }, values: [{ id: 'a21v0' }] },
-        a22: { id: 'a22', index: 22, relationship: { observation: {} }, values: [{ id: 'a22v0' }] }, 
+        a22: { id: 'a22', index: 22, relationship: { observation: {} }, values: [{ id: 'a22v0' }] },
+        a23: { id: 'a23', index: 25, relationship: { observation: {} }, values:[null,{id:'a23v1'}] } 
       },
       attributesIdsIndexedByTargets: {
-        observations: ['a6', 'a18', 'a22'],
+        observations: ['a6', 'a18', 'a22','a23'],
         oneValueDimensions: { d1: ['a8', 'a14'] },
         manyValuesDimensions: ['a9', 'a11'],
         dataflow: ['a10', 'a19', 'a21'],