@dhis2/analytics 26.4.1 → 26.5.0

package/build/es/__fixtures__/json/api/analytics/outlierDetection.json

@@ -0,0 +1,213 @@
+{
+  "headers": [
+    {
+      "name": "dxname",
+      "column": "Data name",
+      "valueType": "TEXT",
+      "type": "java.lang.String",
+      "hidden": false,
+      "meta": false
+    },
+    {
+      "name": "ouname",
+      "column": "Organisation unit name",
+      "valueType": "TEXT",
+      "type": "java.lang.String",
+      "hidden": false,
+      "meta": false
+    },
+    {
+      "name": "value",
+      "column": "Value",
+      "valueType": "NUMBER",
+      "type": "java.lang.Double",
+      "hidden": false,
+      "meta": false
+    },
+    {
+      "name": "absdev",
+      "column": "Absolute deviation",
+      "valueType": "NUMBER",
+      "type": "java.lang.Double",
+      "hidden": false,
+      "meta": false
+    },
+    {
+      "name": "modifiedzscore",
+      "column": "Modified zScore",
+      "valueType": "NUMBER",
+      "type": "java.lang.Double",
+      "hidden": false,
+      "meta": false
+    },
+    {
+      "name": "median",
+      "column": "Median",
+      "valueType": "NUMBER",
+      "type": "java.lang.Double",
+      "hidden": false,
+      "meta": false
+    },
+    {
+      "name": "lowerbound",
+      "column": "Lower boundary",
+      "valueType": "NUMBER",
+      "type": "java.lang.Double",
+      "hidden": false,
+      "meta": false
+    },
+    {
+      "name": "upperbound",
+      "column": "Upper boundary",
+      "valueType": "NUMBER",
+      "type": "java.lang.Double",
+      "hidden": false,
+      "meta": false
+    }
+  ],
+  "metaData": {
+    "maxResults": 100,
+    "count": 13,
+    "orderBy": "mean_abs_dev",
+    "threshold": 3.0,
+    "algorithm": "MOD_Z_SCORE"
+  },
+  "rowContext": {
+
+  },
+  "rows": [
+    [
+      "ANC 2nd visit",
+      "UMC (Urban Centre) Hospital",
+      "1669.0",
+      "920.0",
+      "3.902767295597484",
+      "749.0",
+      "-290.93013894085743",
+      "1788.9301389408574"
+    ],
+    [
+      "ANC 1st visit",
+      "Charlotte CHP",
+      "49.0",
+      "39.0",
+      "7.515857142857143",
+      "10.0",
+      "-23.948490393535913",
+      "43.94849039353591"
+    ],
+    [
+      "ANC 2nd visit",
+      "Charlotte CHP",
+      "40.0",
+      "33.0",
+      "22.258499999999998",
+      "7.0",
+      "-30.86489139031037",
+      "44.86489139031037"
+    ],
+    [
+      "ANC 2nd visit",
+      "Wilberforce CHC",
+      "56.0",
+      "24.5",
+      "3.004590909090909",
+      "31.5",
+      "-1.3890179239210454",
+      "64.38901792392105"
+    ],
+    [
+      "ANC 1st visit",
+      "Deep Eye water MCHP",
+      "40.0",
+      "16.0",
+      "3.5973333333333333",
+      "24.0",
+      "4.850913859925324",
+      "43.14908614007467"
+    ],
+    [
+      "ANC 2nd visit",
+      "Lion for Lion Clinic",
+      "30.0",
+      "16.0",
+      "3.5973333333333333",
+      "14.0",
+      "-5.620896815302167",
+      "33.62089681530217"
+    ],
+    [
+      "ANC 2nd visit",
+      "Deep Eye water MCHP",
+      "33.0",
+      "14.5",
+      "3.9121",
+      "18.5",
+      "-3.4245866551686603",
+      "40.42458665516866"
+    ],
+    [
+      "ANC 2nd visit",
+      "Blessed Mokaka East Clinic",
+      "2.0",
+      "13.0",
+      "4.38425",
+      "15.0",
+      "-3.417043736713012",
+      "33.41704373671301"
+    ],
+    [
+      "ANC 2nd visit",
+      "Malambay CHP",
+      "15.0",
+      "12.0",
+      "5.396",
+      "3.0",
+      "-13.770509831248425",
+      "19.770509831248425"
+    ],
+    [
+      "ANC 2nd visit",
+      "Wellbody MCHP",
+      "20.0",
+      "10.0",
+      "3.3725",
+      "10.0",
+      "-10.999999999999996",
+      "30.999999999999996"
+    ],
+    [
+      "ANC 1st visit",
+      "Blessed Mokaka East Clinic",
+      "26.0",
+      "10.0",
+      "4.496666666666667",
+      "16.0",
+      "1.6734512181055958",
+      "30.326548781894402"
+    ],
+    [
+      "ANC 1st visit",
+      "Murray Town CHC",
+      "18.0",
+      "9.0",
+      "6.0705",
+      "9.0",
+      "-2.43571205496543",
+      "20.43571205496543"
+    ],
+    [
+      "ANC 2nd visit",
+      "Thompson Bay MCHP",
+      "11.0",
+      "6.0",
+      "4.047",
+      "5.0",
+      "-2.038266127580332",
+      "12.038266127580332"
+    ]
+  ],
+  "headerWidth": 8,
+  "width": 8,
+  "height": 13
+}

package/build/es/api/analytics/AnalyticsAggregate.js

@@ -68,11 +68,37 @@ class AnalyticsAggregate extends AnalyticsBase {
    *  .withStartDate('2017-10-01')
    *  .withEndDate('2017-10-31');
    *
-   *  analytics.aggregate.getDebugSql(req);
+   *  analytics.aggregate.getDebugSql(req)
    *  .then(console.log);
    */
   getDebugSql(req) {
     return this.fetch(req.withPath('debug/sql'));
   }
+
+  /**
+   * @param {!AnalyticsRequest} req Request object
+   *
+   * @returns {Promise} Promise that resolves with the SQL statement used to query the database.
+   *
+   * @example
+   * const req = new analytics.request()
+   *  .withParameters({
+   *    dx: 'fbfJHSPpUQD,cYeuwXTCPkU',
+   *    pe: 'THIS_YEAR',
+   *    ou: 'USER_ORGUNIT,USER_ORGUNIT_CHILDREN',
+   *    headers: 'dxname,pename,ouname,value,absdev,modifiedzscore,median,lowerbound,upperbound',
+   *    algorithm: 'MODIFIED_Z_SCORE',
+   *    maxResults: 100,
+   *    threshold: 3,
+        orderBy: 'value',
+        sortOrder: 'desc',
+   *  });
+   *
+   *  analytics.aggregate.getOutliersData(req)
+   *  .then(console.log);
+   */
+  getOutliersData(req) {
+    return this.fetch(req.withPath('outlierDetection'));
+  }
 }
 export default AnalyticsAggregate;

package/build/es/api/analytics/AnalyticsBase.js

@@ -16,8 +16,8 @@ const analyticsQuery = {
       parameters
     } = _ref2;
     return {
-      dimension: dimensions,
-      filter: filters,
+      dimension: dimensions.length ? dimensions : undefined,
+      filter: filters.length ? filters : undefined,
       ...parameters
     };
   }
@@ -38,8 +38,8 @@ const analyticsDataQuery = {
       parameters
     } = _ref4;
     return {
-      dimension: dimensions,
-      filter: filters,
+      dimension: dimensions.length ? dimensions : undefined,
+      filter: filters.length ? filters : undefined,
       ...parameters,
       skipMeta: true,
       skipData: false
@@ -62,8 +62,8 @@ const analyticsMetaDataQuery = {
       parameters
     } = _ref6;
     return {
-      dimension: dimensions,
-      filter: filters,
+      dimension: dimensions.length ? dimensions : undefined,
+      filter: filters.length ? filters : undefined,
       ...parameters,
       skipMeta: false,
       skipData: true,
@@ -71,7 +71,7 @@ const analyticsMetaDataQuery = {
     };
   }
 };
-const generateDimensionStrings = function () {
+export const generateDimensionStrings = function () {
   let dimensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   let options = arguments.length > 1 ? arguments[1] : undefined;
   if (options && options.sorted) {

package/build/es/api/analytics/AnalyticsRequestBase.js

@@ -47,7 +47,7 @@ class AnalyticsRequestBase {
   buildUrl(options) {
     // at least 1 dimension is required
     let dimensions = this.dimensions;
-    if (options && options.sorted) {
+    if (dimensions.length && options !== null && options !== void 0 && options.sorted) {
       dimensions = sortBy(dimensions, 'dimension');
     }
     const encodedDimensions = dimensions.map(_ref => {
@@ -57,7 +57,7 @@ class AnalyticsRequestBase {
       } = _ref;
       if (Array.isArray(items) && items.length) {
         const encodedItems = items.map(customEncodeURIComponent);
-        if (options && options.sorted) {
+        if (options !== null && options !== void 0 && options.sorted) {
           encodedItems.sort();
         }
         return `${dimension}:${encodedItems.join(';')}`;
@@ -65,7 +65,11 @@ class AnalyticsRequestBase {
       return dimension;
     });
     const endPoint = [this.endPoint, this.path, this.program].filter(e => !!e).join('/');
-    return `${endPoint}.${this.format}?dimension=${encodedDimensions.join('&dimension=')}`;
+    let url = `${endPoint}.${this.format}`;
+    if (encodedDimensions.length) {
+      url += `?dimension=${encodedDimensions.join('&dimension=')}`;
+    }
+    return url;
   }
 
   /**
@@ -83,7 +87,7 @@ class AnalyticsRequestBase {
    */
   buildQuery(options) {
     let filters = this.filters;
-    if (options && options.sorted) {
+    if (filters.length && options !== null && options !== void 0 && options.sorted) {
       filters = sortBy(filters, 'dimension');
     }
     const encodedFilters = filters.map(_ref2 => {
@@ -93,7 +97,7 @@ class AnalyticsRequestBase {
       } = _ref2;
       if (Array.isArray(items) && items.length) {
         const encodedItems = items.map(customEncodeURIComponent);
-        if (options && options.sorted) {
+        if (options !== null && options !== void 0 && options.sorted) {
           encodedItems.sort();
         }
         return `${dimension}:${encodedItems.join(';')}`;

package/build/es/api/analytics/AnalyticsResponse.js

@@ -51,7 +51,8 @@ class AnalyticsResponse {
     }
   }
   extractHeaders() {
-    const dimensions = this.response.metaData.dimensions;
+    // some endpoints (ie. outlierDetection) don't return dimensions in metaData
+    const dimensions = this.response.metaData.dimensions || {};
     const headers = this.response.headers || [];
     return headers.map((header, index) => new AnalyticsResponseHeader(header, {
       isPrefix: isPrefixHeader(header, dimensions[header.name]),
@@ -87,48 +88,50 @@ class AnalyticsResponse {
       items
     } = metaData;
 
-    // populate metaData dimensions and items
-    this.headers.filter(header => !DEFAULT_COLLECT_IGNORE_HEADERS.includes(header.name)).forEach(header => {
-      let ids;
+    // some endpoints (ie. outlierDetection) don't return dimensions or items
+    if (dimensions && items) {
+      this.headers.filter(header => !DEFAULT_COLLECT_IGNORE_HEADERS.includes(header.name)).forEach(header => {
+        let ids;
 
-      // collect row values
-      if (header.isCollect) {
-        ids = this.getSortedUniqueRowIdStringsByHeader(header);
-        dimensions[header.name] = ids;
-      } else {
-        ids = dimensions[header.name];
-      }
-      if (header.isPrefix) {
-        // create prefixed dimensions array
-        dimensions[header.name] = ids.map(id => getPrefixedId(id, header.name));
-
-        // create items
-        dimensions[header.name].forEach((prefixedId, index) => {
-          const id = ids[index];
-          const valueType = header.valueType;
-          const name = getNameByIdsByValueType(id, valueType);
-          items[prefixedId] = {
-            name
-          };
-        });
-      }
-    });
+        // collect row values
+        if (header.isCollect) {
+          ids = this.getSortedUniqueRowIdStringsByHeader(header);
+          dimensions[header.name] = ids;
+        } else {
+          ids = dimensions[header.name];
+        }
+        if (header.isPrefix) {
+          // create prefixed dimensions array
+          dimensions[header.name] = ids.map(id => getPrefixedId(id, header.name));
 
-    // for events, add items from 'ouname'
-    if (this.hasHeader(OUNAME) && this.hasHeader(OU)) {
-      const ouNameHeaderIndex = this.getHeader(OUNAME).getIndex();
-      const ouHeaderIndex = this.getHeader(OU).getIndex();
-      let ouId;
-      let ouName;
-      this.rows.forEach(row => {
-        ouId = row[ouHeaderIndex];
-        if (items[ouId] === undefined) {
-          ouName = row[ouNameHeaderIndex];
-          items[ouId] = {
-            name: ouName
-          };
+          // create items
+          dimensions[header.name].forEach((prefixedId, index) => {
+            const id = ids[index];
+            const valueType = header.valueType;
+            const name = getNameByIdsByValueType(id, valueType);
+            items[prefixedId] = {
+              name
+            };
+          });
         }
       });
+
+      // for events, add items from 'ouname'
+      if (this.hasHeader(OUNAME) && this.hasHeader(OU)) {
+        const ouNameHeaderIndex = this.getHeader(OUNAME).getIndex();
+        const ouHeaderIndex = this.getHeader(OU).getIndex();
+        let ouId;
+        let ouName;
+        this.rows.forEach(row => {
+          ouId = row[ouHeaderIndex];
+          if (items[ouId] === undefined) {
+            ouName = row[ouNameHeaderIndex];
+            items[ouId] = {
+              name: ouName
+            };
+          }
+        });
+      }
     }
     return metaData;
   }

package/build/es/api/analytics/__tests__/Analytics.spec.js

@@ -1,5 +1,6 @@
 import Analytics from '../Analytics.js';
 import AnalyticsAggregate from '../AnalyticsAggregate.js';
+import AnalyticsEnrollments from '../AnalyticsEnrollments.js';
 import AnalyticsEvents from '../AnalyticsEvents.js';
 import AnalyticsRequest from '../AnalyticsRequest.js';
 describe('Analytics', () => {
@@ -7,6 +8,7 @@ describe('Analytics', () => {
   beforeEach(() => {
     analytics = new Analytics({
       aggregate: new AnalyticsAggregate(),
+      enrollments: new AnalyticsEnrollments(),
       events: new AnalyticsEvents(),
       request: AnalyticsRequest
     });
@@ -20,6 +22,9 @@ describe('Analytics', () => {
   it('should contain an instance of AnalyticsAggregate', () => {
     expect(analytics.aggregate).toBeInstanceOf(AnalyticsAggregate);
   });
+  it('should contain an instance of AnalyticsEnrollments', () => {
+    expect(analytics.enrollments).toBeInstanceOf(AnalyticsEnrollments);
+  });
   it('should contain an instance of AnalyticsEvents', () => {
     expect(analytics.events).toBeInstanceOf(AnalyticsEvents);
   });

package/build/es/api/analytics/__tests__/AnalyticsAggregate.spec.js

@@ -84,4 +84,33 @@ describe('Analytics.aggregate', () => {
       expect(data.height).toEqual(0);
     }));
   });
+  describe('.getOutliersData', () => {
+    beforeEach(() => {
+      aggregate = new AnalyticsAggregate(new DataEngineMock());
+      request = new AnalyticsRequest();
+      request.withParameters({
+        dx: 'fbfJHSPpUQD,cYeuwXTCPkU',
+        pe: 'THIS_YEAR',
+        ou: 'at6UHUQatSo',
+        headers: 'dxname,pename,ouname,value,absdev,modifiedzscore,median,lowerbound,upperbound',
+        algorithm: 'MOD_Z_SCORE',
+        maxResults: 100,
+        threshold: 3
+      });
+      fixture = fixtures.get('/api/analytics/outlierDetection');
+      dataEngineMock.query.mockReturnValue(Promise.resolve({
+        data: fixture
+      }));
+    });
+    it('should be a function', () => {
+      expect(aggregate.getOutliersData).toBeInstanceOf(Function);
+    });
+    it('should resolve a promise with data', () => aggregate.getOutliersData(request).then(data => {
+      expect(data.metaData.items).toEqual(fixture.metaData.items);
+      expect(data.metaData.dimensions).toEqual(fixture.metaData.dimensions);
+      expect(data.headers).toEqual(fixture.headers);
+      expect(data.width).toEqual(8);
+      expect(data.height).toEqual(13);
+    }));
+  });
 });

package/build/es/api/analytics/__tests__/AnalyticsBase.spec.js

@@ -1,4 +1,4 @@
-import AnalyticsBase from '../AnalyticsBase.js';
+import AnalyticsBase, { generateDimensionStrings } from '../AnalyticsBase.js';
 let base;
 describe('constructor', () => {
   beforeEach(() => {
@@ -12,4 +12,37 @@ describe('constructor', () => {
     base = new AnalyticsBase(dataEngineMock);
     expect(base.dataEngine).toBe(dataEngineMock);
   });
+});
+describe('generateDimensionString', () => {
+  const tests = [{
+    input: [{
+      dimension: 'dim2',
+      items: ['item2', 'item1']
+    }, {
+      dimension: 'dim1',
+      items: ['item1']
+    }],
+    output: ['dim2:item2;item1', 'dim1:item1'],
+    outputSorted: ['dim1:item1', 'dim2:item1;item2']
+  }];
+  it('should return dimension strings correctly formatted', () => {
+    tests.forEach(_ref => {
+      let {
+        input,
+        output
+      } = _ref;
+      expect(generateDimensionStrings(input)).toEqual(output);
+    });
+  });
+  it('should return dimension strings correctly formatted and sorted', () => {
+    tests.forEach(_ref2 => {
+      let {
+        input,
+        outputSorted
+      } = _ref2;
+      expect(generateDimensionStrings(input, {
+        sorted: true
+      })).toEqual(outputSorted);
+    });
+  });
 });

package/build/es/components/DataDimension/DataDimension.js

@@ -1,20 +1,33 @@
 import { useConfig } from '@dhis2/app-runtime';
 import PropTypes from 'prop-types';
-import React from 'react';
+import React, { createContext, useContext, useCallback, useEffect, useState } from 'react';
+import { dataTypeMap, DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM } from '../../modules/dataTypes.js';
 import { DIMENSION_ID_DATA } from '../../modules/predefinedDimensions.js';
 import ItemSelector from './ItemSelector.js';
+const DataDimensionCtx = /*#__PURE__*/createContext({});
 const DataDimension = _ref => {
   let {
     onSelect,
     selectedDimensions,
     displayNameProp,
+    enabledDataTypes,
     infoBoxMessage,
-    onCalculationSave
+    onCalculationSave,
+    visType
   } = _ref;
   const {
     serverVersion
   } = useConfig();
-  const supportsEDI = `${serverVersion.major}.${serverVersion.minor}.${serverVersion.patch || 0}` >= '2.40.0';
+  const filterDataTypesByVersion = useCallback(dataTypes => dataTypes.filter(_ref2 => {
+    let {
+      id
+    } = _ref2;
+    return (
+      // Calculations only available from 2.40
+      id !== DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM || serverVersion.minor >= 40
+    );
+  }), [serverVersion.minor]);
+  const [dataTypes, setDataTypes] = useState(filterDataTypesByVersion(enabledDataTypes || Object.values(dataTypeMap)));
   const onSelectItems = selectedItem => onSelect({
     dimensionId: DIMENSION_ID_DATA,
     items: selectedItem.map(item => ({
@@ -24,7 +37,12 @@ const DataDimension = _ref => {
       expression: item.expression
     }))
   });
-  return /*#__PURE__*/React.createElement(ItemSelector, {
+  useEffect(() => enabledDataTypes && setDataTypes(filterDataTypesByVersion(enabledDataTypes)), [enabledDataTypes, filterDataTypesByVersion]);
+  return /*#__PURE__*/React.createElement(DataDimensionCtx.Provider, {
+    value: {
+      visType
+    }
+  }, /*#__PURE__*/React.createElement(ItemSelector, {
     selectedItems: selectedDimensions.map(item => ({
       value: item.id,
       label: item.name,
@@ -37,9 +55,9 @@ const DataDimension = _ref => {
     displayNameProp: displayNameProp,
     infoBoxMessage: infoBoxMessage,
     dataTest: 'data-dimension',
-    supportsEDI: supportsEDI,
+    dataTypes: dataTypes,
     onEDISave: onCalculationSave
-  });
+  }));
 };
 DataDimension.propTypes = {
   displayNameProp: PropTypes.string.isRequired,
@@ -51,11 +69,14 @@ DataDimension.propTypes = {
     type: PropTypes.string
   })).isRequired,
   onSelect: PropTypes.func.isRequired,
+  enabledDataTypes: PropTypes.array,
   infoBoxMessage: PropTypes.string,
+  visType: PropTypes.string,
   onCalculationSave: PropTypes.func
 };
 DataDimension.defaultProps = {
   selectedDimensions: [],
   onSelect: Function.prototype
 };
+export const useDataDimensionContext = () => useContext(DataDimensionCtx);
 export default DataDimension;

package/build/es/components/DataDimension/DataTypeSelector.js

@@ -3,22 +3,43 @@ import { SingleSelectField, SingleSelectOption } from '@dhis2/ui';
 import PropTypes from 'prop-types';
 import React from 'react';
 import i18n from '../../locales/index.js';
-import { DIMENSION_TYPE_ALL, dataTypeMap as dataTypes, DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM } from '../../modules/dataTypes.js';
+import { DIMENSION_TYPE_ALL, dataTypeMap } from '../../modules/dataTypes.js';
+import { getDisplayNameByVisType } from '../../modules/visTypes.js';
+import { useDataDimensionContext } from './DataDimension.js';
 import styles from './styles/DataTypeSelector.style.js';
 const DataTypeSelector = _ref => {
-  var _dataTypes$currentDat;
   let {
     currentDataType,
+    dataTypes,
     onChange,
-    dataTest,
-    includeCalculations
+    dataTest
   } = _ref;
+  const {
+    visType
+  } = useDataDimensionContext();
+  const label = i18n.t('Data Type');
   return /*#__PURE__*/React.createElement("div", {
     className: `jsx-${styles.__hash}` + " " + "container"
-  }, /*#__PURE__*/React.createElement(SingleSelectField, {
-    label: i18n.t('Data Type'),
+  }, dataTypes.length === 1 ? /*#__PURE__*/React.createElement(SingleSelectField, {
+    label: label,
     dataTest: dataTest,
-    selected: ((_dataTypes$currentDat = dataTypes[currentDataType]) === null || _dataTypes$currentDat === void 0 ? void 0 : _dataTypes$currentDat.id) || DIMENSION_TYPE_ALL,
+    selected: dataTypes[0].id,
+    onChange: ref => onChange(ref.selected),
+    dense: true,
+    disabled: true,
+    helpText: visType ? i18n.t('Only {{dataType}} can be used in {{visType}}', {
+      dataType: dataTypeMap[dataTypes[0].id].getName(),
+      visType: getDisplayNameByVisType(visType)
+    }) : ''
+  }, dataTypes.map(type => /*#__PURE__*/React.createElement(SingleSelectOption, {
+    value: type.id,
+    key: type.id,
+    label: type.getName(),
+    dataTest: `${dataTest}-option-${type.id}`
+  }))) : /*#__PURE__*/React.createElement(SingleSelectField, {
+    label: label,
+    dataTest: dataTest,
+    selected: currentDataType || DIMENSION_TYPE_ALL,
     onChange: ref => onChange(ref.selected),
     dense: true
   }, /*#__PURE__*/React.createElement(SingleSelectOption, {
@@ -26,7 +47,7 @@ const DataTypeSelector = _ref => {
     key: DIMENSION_TYPE_ALL,
     label: i18n.t('All types'),
     dataTest: `${dataTest}-option-all`
-  }), Object.values(dataTypes).filter(type => type.id !== DIMENSION_TYPE_EXPRESSION_DIMENSION_ITEM || includeCalculations).map(type => /*#__PURE__*/React.createElement(SingleSelectOption, {
+  }), dataTypes.map(type => /*#__PURE__*/React.createElement(SingleSelectOption, {
     value: type.id,
     key: type.id,
     label: type.getName(),
@@ -39,6 +60,6 @@ DataTypeSelector.propTypes = {
   currentDataType: PropTypes.string.isRequired,
   onChange: PropTypes.func.isRequired,
   dataTest: PropTypes.string,
-  includeCalculations: PropTypes.bool
+  dataTypes: PropTypes.array
 };
 export default DataTypeSelector;