@sis-cc/dotstatsuite-components 17.30.2 → 17.31.0

package/lib/rules2/src/enhanceObservations.js

@@ -58,7 +58,7 @@ var parseAttributesValues = function parseAttributesValues(obs, attributes, inde
       return dim.id + '=' + valueId;
     }), R.ifElse(R.isEmpty, R.always(null), R.join(':')))(indexedDimensions);
 
-    return R.assoc(attribute.id, (0, _extends3.default)({}, R.pick(['id', 'name', 'relationship', 'display'], attribute), { value: value, serieKey: serieKey, coordinates: coordinates, isObs: R.isEmpty(relationship) }), acc);
+    return R.assoc(attribute.id, (0, _extends3.default)({}, R.pick(['id', 'name', 'relationship', 'display', 'combined'], attribute), { value: value, serieKey: serieKey, coordinates: coordinates, isObs: R.isEmpty(relationship) }), acc);
   }, {}, attrValuesIndexes);
 };
 

package/lib/rules2/src/table/getLayoutData2.js

@@ -33,7 +33,7 @@ var getValueData = function getValueData(index, dimension, parentsIndexes) {
 	var missingParents = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
 	return {
 		dimension: R.pick(['id', 'name', '__index'], dimension),
-		value: (0, _extends3.default)({}, R.pipe(R.pathOr({}, ['values', index]), R.pick(['id', 'name', 'isNonCoded', 'flags']))(dimension), {
+		value: (0, _extends3.default)({}, R.pipe(R.pathOr({}, ['values', index]), R.pick(['id', 'name', 'isNonCoded', 'flags', 'hasAdvancedAttributes']))(dimension), {
 			parents: parentsIndexes,
 			missingParents: missingParents
 		})
@@ -91,6 +91,9 @@ var getCoordinates = function getCoordinates(indexes, topCoordinates, definition
 var getAttributesSeries = function getAttributesSeries(validator, attributesSeries) {
 	return R.reduce(function (acc, attrs) {
 		var attr = R.head(R.values(attrs));
+		if (R.length(attr.relationship || []) === 1 && !attr.combined) {
+			return acc;
+		}
 		var coordinates = R.propOr({}, 'coordinates', attr);
 		var isValid = validator(coordinates);
 		if (!isValid && !R.prop('isObs', attr)) {
@@ -120,13 +123,16 @@ var combineConcepts = function combineConcepts(combDimValues, definition, attrVa
 	}));
 };
 
-var getSerieFlagsAndSideProps = function getSerieFlagsAndSideProps(coordinates, validator, attributesValues, customAttributes, metadataCoordinates) {
+var getSerieFlagsAndSideProps = function getSerieFlagsAndSideProps(coordinates, validator, attributesValues, customAttributes, metadataCoordinates, data) {
 	var layoutAttrValues = R.reject(function (attr) {
 		return R.prop('isObs', attr) && !validator(attr.coordinates);
 	}, attributesValues);
 	var flags = (0, _getFlagsAndNotes.getFlagsAndNotes)(layoutAttrValues, customAttributes);
 	var hasMetadata = !R.isNil(R.find(validator, metadataCoordinates));
-	var hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues, customAttributes);
+	var hasDataAdvancedAttributes = R.any(function (d) {
+		return R.has('value', d) ? d.hasAdvancedAttributes : R.any(R.prop('hasAdvancedAttributes'), d.values);
+	}, data);
+	var hasAdvancedAttributes = hasDataAdvancedAttributes || getHasAdvancedAttributes(layoutAttrValues, customAttributes);
 	var sideProps = hasMetadata || hasAdvancedAttributes ? { hasMetadata: hasMetadata, hasAdvancedAttributes: hasAdvancedAttributes, coordinates: coordinates } : null;
 	return { flags: flags, sideProps: sideProps };
 };
@@ -195,7 +201,7 @@ var getSerieDataWithMissingLines = function getSerieDataWithMissingLines(serie,
 		return coordinatesValidator(coordinates) && !topCoordinatesValidator(coordinates);
 	};
 
-	var _getSerieFlagsAndSide = getSerieFlagsAndSideProps(serieCoordinates, flagsValidator, attributes, customAttributes, metadataCoordinates),
+	var _getSerieFlagsAndSide = getSerieFlagsAndSideProps(serieCoordinates, flagsValidator, attributes, customAttributes, metadataCoordinates, serieData.data),
 	    flags = _getSerieFlagsAndSide.flags,
 	    sideProps = _getSerieFlagsAndSide.sideProps;
 
@@ -223,7 +229,7 @@ var getSerieDataWithoutMissingLines = function getSerieDataWithoutMissingLines(s
 	    attributes = _getSerieDimensionsDa2.attributes,
 	    serieData = (0, _objectWithoutProperties3.default)(_getSerieDimensionsDa2, ['attributes']);
 
-	var _getSerieFlagsAndSide2 = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributes, customAttributes, metadataCoordinates),
+	var _getSerieFlagsAndSide2 = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributes, customAttributes, metadataCoordinates, serieData.data),
 	    flags = _getSerieFlagsAndSide2.flags,
 	    sideProps = _getSerieFlagsAndSide2.sideProps;
 

package/lib/rules2/src/table/parseSeriesIndexesHierarchies.js

@@ -50,7 +50,9 @@ var parseSerieIndexesHierarchies = function parseSerieIndexesHierarchies(serieIn
     }
     var valueIndex = Math.abs(_valueIndex);
     var parents = R.pathOr([], [dimensionIndex, 'values', valueIndex, 'parents'], dimensions);
-    var previousIndex = acc.isSameSerie ? R.pathOr(-1, ['indexes', dimensionIndex], previousSerie) : -1;
+    var previousIndex = acc.isSameSerie ? R.pipe(R.path(['indexes', dimensionIndex]), function (i) {
+      return R.isNil(i) ? -1 : Math.abs(i);
+    })(previousSerie) : -1;
     var previousRegisteredIndexes = acc.isSameSerie ? R.pathOr(new _set2.default(), ['registeredIndexes', dimensionIndex], previousSerie) : new _set2.default();
     var registeredIndexes = new _set2.default(previousRegisteredIndexes);
 

package/lib/rules2/src/utils.js

@@ -43,7 +43,6 @@ var getLayoutCoordinatesValidator = exports.getLayoutCoordinatesValidator = func
         notInTop[key] = key;
       }
     }, keys);
-    return res;
-    //return res && !R.isEmpty(notInTop);
+    return res && !R.isEmpty(notInTop);
   };
 };

package/package.json

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

package/src/rules2/src/enhanceObservations.js

@@ -39,7 +39,11 @@ const parseAttributesValues = (obs, attributes, indexedDimensions) => {
         R.ifElse(R.isEmpty, R.always(null), R.join(':'))
       )(indexedDimensions);
 
-      return R.assoc(attribute.id, { ...R.pick(['id', 'name', 'relationship', 'display'], attribute), value, serieKey, coordinates, isObs: R.isEmpty(relationship) }, acc);
+      return R.assoc(
+        attribute.id,
+        { ...R.pick(['id', 'name', 'relationship', 'display', 'combined'], attribute), value, serieKey, coordinates, isObs: R.isEmpty(relationship) },
+        acc
+      );
     },
     {},
     attrValuesIndexes

package/src/rules2/src/table/getLayoutData2.js

@@ -5,7 +5,7 @@ import { getLayoutCoordinatesValidator } from '../utils';
 const getValueData = (index, dimension, parentsIndexes, missingParents = []) => ({
 	dimension: R.pick(['id', 'name', '__index'], dimension),
 	value: {
-		...R.pipe(R.pathOr({}, ['values', index]), R.pick(['id', 'name', 'isNonCoded', 'flags']))(dimension),
+		...R.pipe(R.pathOr({}, ['values', index]), R.pick(['id', 'name', 'isNonCoded', 'flags', 'hasAdvancedAttributes']))(dimension),
 		parents: parentsIndexes,
 		missingParents
 	}
@@ -52,6 +52,9 @@ const getCoordinates = (indexes, topCoordinates, definition) => R.addIndex(R.red
 
 const getAttributesSeries = (validator, attributesSeries) => R.reduce((acc, attrs) => {
 	const attr = R.head(R.values(attrs));
+	if (R.length(attr.relationship || []) === 1 && !attr.combined) {
+		return acc;
+	}
 	const coordinates = R.propOr({}, 'coordinates', attr);
 	const isValid = validator(coordinates);
 	if (!isValid && !R.prop('isObs', attr)) {
@@ -79,11 +82,14 @@ const combineConcepts = (combDimValues, definition, attrValues) => R.over(
 		}, [], definition.concepts)
 	})));
 
-const getSerieFlagsAndSideProps = (coordinates, validator, attributesValues, customAttributes, metadataCoordinates) => {
+const getSerieFlagsAndSideProps = (coordinates, validator, attributesValues, customAttributes, metadataCoordinates, data) => {
 	const layoutAttrValues = R.reject(attr => R.prop('isObs', attr) && !validator(attr.coordinates), attributesValues);
   const flags = getFlagsAndNotes(layoutAttrValues, customAttributes);
   const hasMetadata = !R.isNil(R.find(validator, metadataCoordinates));
-  const hasAdvancedAttributes = getHasAdvancedAttributes(layoutAttrValues, customAttributes);
+	const hasDataAdvancedAttributes = R.any(
+		d => R.has('value', d) ? d.hasAdvancedAttributes : R.any(R.prop('hasAdvancedAttributes'), d.values)
+	, data);
+  const hasAdvancedAttributes = hasDataAdvancedAttributes || getHasAdvancedAttributes(layoutAttrValues, customAttributes);
   const sideProps = hasMetadata || hasAdvancedAttributes
     ? { hasMetadata, hasAdvancedAttributes, coordinates } : null;
 	return { flags, sideProps };
@@ -140,11 +146,10 @@ export const getSerieDataWithMissingLines = (serie, definition, topCoordinates,
 			return R.over(R.lensProp('parentsIndexes'), R.append(index), acc);
 		},
 	{ parentsIndexes: _parentsIndexes, missingParents: [] }, missingParentsIndexes);
-
 	const { attributes, ...serieData } = getSerieDimensionsData(serie, definition, attributesValues, getMissingParents);
 	const topCoordinatesValidator = getLayoutCoordinatesValidator(topCoordinates);
 	const flagsValidator = coordinates => coordinatesValidator(coordinates) && !topCoordinatesValidator(coordinates);
-	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, flagsValidator, attributes, customAttributes, metadataCoordinates);
+	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, flagsValidator, attributes, customAttributes, metadataCoordinates, serieData.data);
 	return R.append({ ...serieData, flags, sideProps, coordinates: serieCoordinates }, lines);
 };
 
@@ -161,7 +166,7 @@ export const getSerieDataWithoutMissingLines = (serie, definition, topCoordinate
 	{ parentsIndexes: _parentsIndexes, missingParents: [] }, missingParentsIndexes);
 
 	const { attributes, ...serieData } = getSerieDimensionsData(serie, definition, attributesValues, getMissingParents);
-	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributes, customAttributes, metadataCoordinates);
+	const { flags, sideProps } = getSerieFlagsAndSideProps(serieCoordinates, coordinatesValidator, attributes, customAttributes, metadataCoordinates, serieData.data);
 	return ({ ...serieData, flags, sideProps, coordinates: serieCoordinates });
 };
 

package/src/rules2/src/table/parseSeriesIndexesHierarchies.js

@@ -14,8 +14,10 @@ const parseSerieIndexesHierarchies = (serieIndexes, previousSerie, dimensions, d
 		}
     const valueIndex = Math.abs(_valueIndex);
     const parents = R.pathOr([], [dimensionIndex, 'values', valueIndex, 'parents'], dimensions);
-    const previousIndex = acc.isSameSerie ? R.pathOr(-1, ['indexes', dimensionIndex], previousSerie) : -1;
-    const previousRegisteredIndexes = acc.isSameSerie ? R.pathOr(new Set(), ['registeredIndexes', dimensionIndex], previousSerie) : new Set();
+    const previousIndex = acc.isSameSerie
+      ? R.pipe(R.path(['indexes', dimensionIndex]), i => R.isNil(i) ? -1 : Math.abs(i))(previousSerie)
+      : -1;
+    const previousRegisteredIndexes = acc.isSameSerie? R.pathOr(new Set(), ['registeredIndexes', dimensionIndex], previousSerie) : new Set();
     const registeredIndexes = new Set(previousRegisteredIndexes);
     const { presentParentsIndexes, missingParentsIndexes } = R.reduce((_acc, i) => {
       if (previousRegisteredIndexes.has(i)) {

package/src/rules2/src/utils.js

@@ -33,6 +33,5 @@ export const getLayoutCoordinatesValidator = (layoutCoordinates, topCoordinates=
       notInTop[key] = key;
     }
   }, keys);
-  return res;
-  //return res && !R.isEmpty(notInTop);
+  return res && !R.isEmpty(notInTop);
 };

package/test/enhanceObservations2.test.js

@@ -245,9 +245,9 @@ describe('enhanceObservations tests', () => {
           A1: { id: 'A1', display: false, value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
           A2: { id: 'A2', value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
           A3: { id: 'A3', value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
-          A4: { id: 'A4', display: false, value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
-          A5: { id: 'A5', value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
-          A6: { id: 'A6', value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true },
+          A4: { id: 'A4', display: false, value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true, combined: true },
+          A5: { id: 'A5', value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true, combined: true },
+          A6: { id: 'A6', value: null, relationship: [], serieKey: null, coordinates: {}, isObs: true, combined: true },
         },
         indexedDimValIds: {}
       }

package/test/getLayoutData2.test.js

@@ -253,7 +253,7 @@ describe('getLayoutData 2 tests', () => {
   		}
   	]);
   });
-	it('getSerieDataWithMissingLines test 2', () => {
+	it('getSerieDataWithoutMissingLines test 1', () => {
   	const dimensions = [
   		{
 				id: 'D0',
@@ -362,4 +362,81 @@ describe('getLayoutData 2 tests', () => {
 				}
   		});
   });
+	it('getSerieDataWithoutMissingLines, sideProps and flags non dupplication', () => {
+		const dimensions = [
+			{ 
+				id: 'D0',
+				values: [
+					{ id: 'D0V0', flags: [{ id: 'A0', value: { id: 'A0V' }}] },
+					{ id: 'D1V1' }
+				]
+			}, {
+				id: 'COMB',
+				concepts: ['D1', 'A1'],
+				dimensions: [
+					{
+						id: 'D1',
+						values: [
+							{ id: 'D1V0', hasAdvancedAttributes: true },
+							{ id: 'D1V1' },
+						]
+					}
+				]
+			}
+		];
+
+		const attributesSeries = {
+  		'D0=D0V0': {
+  			A0: { id: 'A0', value: { id: 'A0V' }, coordinates: { D0: 'D0V0' }, relationship: ['D0'] },
+  		},
+			'D1=D1V0': {
+  			A1: { id: 'A1', value: { id: 'A1V' }, coordinates: { D1: 'D1V0' }, relationship: ['D1'], combined: true },
+  		},
+			'D0=D0V0:D1=D1V0': {
+				A2: { id: 'A2', value: { id: 'A2V' }, coordinates: { D0: 'D0V0', D1: 'D1V0' }, relationship: ['D0', 'D1'] },
+			},
+  	};
+
+		const topCoordinates = {};
+
+		const serie = {
+  		indexes: [0, [0]],
+  		parentsIndexes: [[], [[]]],
+  		missingIndexes: [[], [[]]],
+  	};
+
+		const customAttributes = {
+			flags: [],
+			notes: ['A0', 'A2']
+		}
+
+		expect(getSerieDataWithoutMissingLines(serie, dimensions, topCoordinates, attributesSeries, customAttributes, {})).to.deep.equal({
+			data: [
+				{
+					dimension: { id: 'D0' },
+					value: { id: 'D0V0', missingParents: [], parents: [], flags: [{ id: 'A0', value: { id: 'A0V' } }] }
+				},
+				{
+					dimension: { id: 'COMB' },
+					values: [
+						{ id: 'D1V0', missingParents: [], parents: [], hasAdvancedAttributes: true },
+						{ id: 'A1V' },
+					]
+				}
+			],
+			coordinates: { D0: 'D0V0', D1: 'D1V0' },
+			key: 'D0=D0V0:D1=D1V0',
+			flags: [
+				{ id: 'A2', value: { id: 'A2V' } }
+			],
+			sideProps: {
+				coordinates: {
+					D0: 'D0V0',
+					D1: 'D1V0',
+				},
+				hasAdvancedAttributes: true,
+				hasMetadata: false
+			}
+		});
+	});
 });

package/test/parseSeriesIndexesHierarchies.test.js

@@ -102,4 +102,56 @@ describe('parseSeriesIndexesHierarchies tests', () => {
 			{ indexes: [[0, 1]], parentsIndexes: [[[], [0]]], missingIndexes: [[[], []]], registeredIndexes: [[new Set([0]), new Set([0, 1])]] },
 		])
 	});
+	it('combinations and inversed dimension', () => {
+		const dimensions = [
+			{
+				id: 'D',
+				values: [
+					{ id: 'A' },
+					{ id: 'B' },
+					{ id: 'C' }
+				]
+			},
+			{
+				id: 'COMB',
+				dimensions: [{
+					values: [
+						{ id: 'v0' },
+						{ id: 'v1' },
+						{ id: 'v2' },
+						{ id: 'v3' },
+						{ id: 'v4' },
+					]
+				},
+				{
+					values: [
+						{ id: 'W', isSelected: true },
+						{ id: 'NA', parents: [0], isSelected: false },
+						{ id: 'A', parents: [0, 1], isSelected: true },
+						{ id: 'USA', parents: [0, 1, 2], isSelected: true },
+						{ id: 'CAN', parents: [0, 1, 2], isSelected: true },
+						{ id: 'MEX', parents: [0, 1, 2], isSelected: true }
+					]
+				}]
+			},
+		];
+
+		const seriesIndexes = [
+			[-2, [0, 2]],
+			[-2, [0, 3]],
+			[-1, [0, 2]],
+			[-1, [0, 3]],
+			[0, [0, 2]],
+			[0, [0, 3]],
+		];
+
+		expect(parseSeriesIndexesHierarchies(seriesIndexes, dimensions)).to.deep.equal([
+			{ indexes: [-2, [0, 2]], parentsIndexes: [[], [[], []]], missingIndexes: [[], [[], [0]]], registeredIndexes: [new Set([2]), [new Set([0]), new Set([0, 2])]] },
+			{ indexes: [-2, [0, 3]], parentsIndexes: [[], [[], [0, 2]]], missingIndexes: [[], [[], []]], registeredIndexes: [new Set([2]), [new Set([0]), new Set([0, 2, 3])]] },
+			{ indexes: [-1, [0, 2]], parentsIndexes: [[], [[], []]], missingIndexes: [[], [[], [0]]], registeredIndexes: [new Set([1, 2]), [new Set([0]), new Set([0, 2])]] },
+			{ indexes: [-1, [0, 3]], parentsIndexes: [[], [[], [0, 2]]], missingIndexes: [[], [[], []]], registeredIndexes: [new Set([1, 2]), [new Set([0]), new Set([0, 2, 3])]] },
+			{ indexes: [0, [0, 2]], parentsIndexes: [[], [[], []]], missingIndexes: [[], [[], [0]]], registeredIndexes: [new Set([0, 1, 2]), [new Set([0]), new Set([0, 2])]] },
+			{ indexes: [0, [0, 3]], parentsIndexes: [[], [[], [0, 2]]], missingIndexes: [[], [[], []]], registeredIndexes: [new Set([0, 1, 2]), [new Set([0]), new Set([0, 2, 3])]] },
+		])
+	})
 });