Improved aggrMethod to accept multiple values

CHANGES_NEXT_RELEASE

@@ -1 +1,3 @@
-- Set Nodejs 14 as minimum version in packages.json (effectively removing Nodev12 from supported versions)
+- Add: aggrMethod accept multiple values separated by comma (#432, partial)
+- Add: aggrMethod 'all' to get all the possible aggregations (#432, partial)
+- Set Nodejs 14 as minimum version in packages.json (effectively removing Nodev12 from supported versions)

doc/manuals/aggregated-data-retrieval.md

@@ -19,9 +19,11 @@ The requests for aggregated time series context information can use the followin
 
 -   **aggrMethod**: The aggregation method. The STH component supports the following aggregation methods: `max` (maximum
     value), `min` (minimum value), `sum` (sum of all the samples) and `sum2` (sum of the square value of all the
-    samples) for numeric attribute values and `occur` for attributes values of type string. Combining the information
-    provided by these aggregated methods with the number of samples, it is possible to calculate probabilistic values
-    such as the average value, the variance as well as the standard deviation. It is a mandatory parameter.
+    samples) for numeric attribute values and `occur` for attributes values of type string. It accepts multiple values
+    separated by comma (min,max) to get multiple aggregation method values. Additionally, `aggrMethod=all` can be used
+    to get all the aggregation method values. Combining the information provided by these aggregated methods with the
+    number of samples, it is possible to calculate probabilistic values such as the average value, the variance as well
+    as the standard deviation. It is a mandatory parameter.
 -   **aggrPeriod**: Aggregation period or resolution. A fixed resolution determines the origin time format and the
     possible offsets. It is a mandatory parameter. Possible valid resolution values supported by the STH are: `month`,
     `day`, `hour`, `minute` and `second`.

lib/database/sthDatabase.js

@@ -760,7 +760,21 @@ function getAggregatedData(data, callback) {
         'points.offset': 1,
         'points.samples': 1
     };
-    fieldFilter['points.' + aggregatedFunction] = 1;
+    function findAggregatedFunction(aggregatedFunction) {
+        let aggregatedFunctionsArray = [];
+        if (aggregatedFunction.includes('all')) {
+            aggregatedFunctionsArray = ['min','max','sum','sum2','occur'];
+        } else {
+            aggregatedFunctionsArray = aggregatedFunction.split(',');
+        }
+        return aggregatedFunctionsArray;
+    }
+
+    const aggregatedFunctions = findAggregatedFunction(aggregatedFunction);
+
+    for (let i = 0; i < aggregatedFunctions.length; i++) {
+        fieldFilter['points.' + aggregatedFunctions[i]] = 1;
+    }
 
     let originFilter;
     if (from && to) {
@@ -783,7 +797,9 @@ function getAggregatedData(data, callback) {
             offset: '$points.offset',
             samples: '$points.samples'
         };
-        pushAccumulator[aggregatedFunction] = '$points.' + aggregatedFunction;
+        for (let i = 0; i < aggregatedFunctions.length; i++) {
+            pushAccumulator[aggregatedFunctions[i]] = '$points.' + aggregatedFunctions[i];
+        }
 
         let matchCondition;
         switch (sthConfig.DATA_MODEL) {

lib/server/sthServer.js

@@ -63,6 +63,10 @@ function doStartServer(host, port, callback) {
             reply({ error: 'BadRequest', description: error.output.payload.message }).code(400);
         }
 
+        const list = ['min', 'max', 'sum', 'sum2', 'occur', 'all'];
+        const joinedList = '(' + list.join('|') + ')';
+        const regex = new RegExp('^' + joinedList + '(,' + joinedList + ')*$');
+
         const config = {
             validate: {
                 headers: sthHeaderValidator,
@@ -74,8 +78,7 @@ function doStartServer(host, port, callback) {
                     // prettier-ignore
                     hOffset: joi.number().integer().greater(-1).optional(),
                     // prettier-ignore
-                    aggrMethod: joi.string().valid(
-                        'max', 'min', 'sum', 'sum2', 'occur').optional(),
+                    aggrMethod: joi.string().regex(regex).optional(),
                     // prettier-ignore
                     aggrPeriod: joi.string().required().valid(
                         'month', 'day', 'hour', 'minute', 'second').optional(),

test/unit/sthTestUtils.js

@@ -912,21 +912,22 @@ function aggregatedDataAvailableSinceDateTest(ngsiVersion, params, done) {
             break;
     }
 
-    let value;
-    switch (aggrMethod) {
-        case 'min':
-        case 'max':
+    let value,valueSum,valueSum2,valueOccur;
+    const aggrMethods=aggrMethod.split(',');
+
+    for (let i=0;i<aggrMethods.length;i++) {
+        if (aggrMethods[i] === 'min' || aggrMethods[i] === 'max') {
             value = parseFloat(theEvent.attrValue).toFixed(2);
-            break;
-        case 'sum':
-            value = (events.length * parseFloat(theEvent.attrValue)).toFixed(2);
-            break;
-        case 'sum2':
-            value = (events.length * Math.pow(parseFloat(theEvent.attrValue), 2)).toFixed(2);
-            break;
-        case 'occur':
-            value = events.length;
-            break;
+        }
+        if (aggrMethods[i] === 'sum') {
+            valueSum = (events.length * parseFloat(theEvent.attrValue)).toFixed(2);
+        }
+        if (aggrMethods[i] === 'sum2') {
+            valueSum2 = (events.length * Math.pow(parseFloat(theEvent.attrValue), 2)).toFixed(2);
+        }
+        if (aggrMethods[i] === 'occur') {
+            valueOccur = events.length;
+        }
     }
 
     if (ngsiVersion === 2) {
@@ -963,19 +964,37 @@ function aggregatedDataAvailableSinceDateTest(ngsiVersion, params, done) {
                     events.length
                 );
                 if (attrType === 'float') {
-                    expect(
-                        parseFloat(
-                            bodyJSON.value[0].points[sthConfig.FILTER_OUT_EMPTY ? 0 : index][aggrMethod]
-                        ).toFixed(2)
-                    ).to.equal(value);
+                    for (let j=0;j<aggrMethods.length;j++) {
+                        if (aggrMethods[j] === 'min' || aggrMethods[j] === 'max') {
+                            expect(
+                                parseFloat(
+                                    bodyJSON.value[0].points[sthConfig.FILTER_OUT_EMPTY ? 0 : index][aggrMethods[j]]
+                                ).toFixed(2)
+                            ).to.equal(value);
+                        }
+                        if (aggrMethods[j] === 'sum') {
+                            expect(
+                                parseFloat(
+                                    bodyJSON.value[0].points[sthConfig.FILTER_OUT_EMPTY ? 0 : index][aggrMethods[j]]
+                                ).toFixed(2)
+                             ).to.equal(valueSum);
+                        }
+                        if (aggrMethods[j] === 'sum2') {
+                            expect(
+                                parseFloat(
+                                    bodyJSON.value[0].points[sthConfig.FILTER_OUT_EMPTY ? 0 : index][aggrMethods[j]]
+                                ).toFixed(2)
+                            ).to.equal(valueSum2);
+                        }
+                    }
                 } else if (attrType === 'string') {
                     expect(
                         parseFloat(
                             bodyJSON.value[0].points[sthConfig.FILTER_OUT_EMPTY ? 0 : index][aggrMethod][
                                 'just a string'
                             ]
                         )
-                    ).to.equal(value);
+                    ).to.equal(valueOccur);
                 }
                 done();
             }
@@ -1025,21 +1044,43 @@ function aggregatedDataAvailableSinceDateTest(ngsiVersion, params, done) {
                     ].samples
                 ).to.equal(events.length);
                 if (attrType === 'float') {
-                    expect(
-                        parseFloat(
-                            bodyJSON.contextResponses[0].contextElement.attributes[0].values[0].points[
-                                sthConfig.FILTER_OUT_EMPTY ? 0 : index
-                            ][aggrMethod]
-                        ).toFixed(2)
-                    ).to.equal(value);
+                    for (let j=0;j<aggrMethods.length;j++) {
+                        if (aggrMethods[j] === 'min' || aggrMethods[j] === 'max') {
+                            expect(
+                                parseFloat(
+                                    bodyJSON.contextResponses[0].contextElement.attributes[0].values[0].points[
+                                        sthConfig.FILTER_OUT_EMPTY ? 0 : index
+                                    ][aggrMethods[j]]
+                                ).toFixed(2)
+                            ).to.equal(value);
+                        }
+                        if (aggrMethods[j] === 'sum') {
+                            expect(
+                                parseFloat(
+                                    bodyJSON.contextResponses[0].contextElement.attributes[0].values[0].points[
+                                        sthConfig.FILTER_OUT_EMPTY ? 0 : index
+                                    ][aggrMethods[j]]
+                                ).toFixed(2)
+                            ).to.equal(valueSum);
+                        }
+                        if (aggrMethods[j] === 'sum2') {
+                            expect(
+                                parseFloat(
+                                    bodyJSON.contextResponses[0].contextElement.attributes[0].values[0].points[
+                                        sthConfig.FILTER_OUT_EMPTY ? 0 : index
+                                    ][aggrMethods[j]]
+                                ).toFixed(2)
+                            ).to.equal(valueSum2);
+                        }
+                    }
                 } else if (attrType === 'string') {
                     expect(
                         parseFloat(
                             bodyJSON.contextResponses[0].contextElement.attributes[0].values[0].points[
                                 sthConfig.FILTER_OUT_EMPTY ? 0 : index
                             ][aggrMethod]['just a string']
                         )
-                    ).to.equal(value);
+                    ).to.equal(valueOccur);
                 }
                 expect(bodyJSON.contextResponses[0].statusCode.code).to.equal('200');
                 expect(bodyJSON.contextResponses[0].statusCode.reasonPhrase).to.equal('OK');

test/unit/sth_test.js

@@ -324,13 +324,45 @@ describe('sth tests', function() {
             })
         );
 
+        it(
+            'should respond with 200 - OK if aggrMethod are multiple and aggrPeriod query params',
+            sthTestUtils.status200Test.bind(null, 2, {
+                aggrMethod: 'min,max',
+                aggrPeriod: 'second'
+            })
+        );
+
+        it(
+            'should respond with 200 - OK if aggrMethod are multiple and aggrPeriod query params',
+            sthTestUtils.status200Test.bind(null, 2, {
+                aggrMethod: 'all',
+                aggrPeriod: 'second'
+            })
+        );
+
         it(
             'should respond with 200 - OK if aggrMethod and aggrPeriod query params - NGSIv1',
             sthTestUtils.status200Test.bind(null, 1, {
                 aggrMethod: 'min',
                 aggrPeriod: 'second'
             })
         );
+
+        it(
+            'should respond with 200 - OK if aggrMethod are multiple and aggrPeriod query params - NGSIv1',
+            sthTestUtils.status200Test.bind(null, 1, {
+                aggrMethod: 'min,max',
+                aggrPeriod: 'second'
+            })
+        );
+
+        it(
+            'should respond with 200 - OK if aggrMethod are multiple and aggrPeriod query params - NGSIv1',
+            sthTestUtils.status200Test.bind(null, 1, {
+                aggrMethod: 'all',
+                aggrPeriod: 'second'
+            })
+        );
     });
 
     function eachEventTestSuiteContainer(attrName, attrType, includeTimeInstantMetadata) {
@@ -390,6 +422,16 @@ describe('sth tests', function() {
             'aggregated data retrieval',
             sthTestUtils.aggregatedDataRetrievalSuite.bind(null, 'attribute-float', 'float', 'sum2')
         );
+
+        describe(
+            'aggregated data retrieval',
+            sthTestUtils.aggregatedDataRetrievalSuite.bind(null, 'attribute-float', 'float', 'max,sum2')
+        );
+
+        describe(
+            'aggregated data retrieval',
+            sthTestUtils.aggregatedDataRetrievalSuite.bind(null, 'attribute-float', 'float', 'all')
+        );
     }
 
     for (let j = 0; j < sthTestConfig.SAMPLES; j++) {