Map<String, Object> map = analyticsService.getAggregatedDataValueMapping( params.build() );
@Override public Map<String, Object> getAggregatedTotals( DataSet dataSet, Period period, OrganisationUnit unit, Set<String> dimensions ) { List<DataElement> dataElements = new ArrayList<>( dataSet.getDataElements() ); FilterUtils.filter( dataElements, AggregatableDataElementFilter.INSTANCE ); if ( dataElements.isEmpty() ) { return new HashMap<>(); } DataQueryParams.Builder params = DataQueryParams.newBuilder() .withDataElements( dataElements ) .withPeriod( period ) .withOrganisationUnit( unit ); if ( dimensions != null ) { params.addFilters( dataQueryService.getDimensionalObjects( dimensions, null, null, null, false, IdScheme.UID ) ); } Map<String, Object> map = analyticsService.getAggregatedDataValueMapping( params.build() ); Map<String, Object> dataMap = new HashMap<>(); for ( Entry<String, Object> entry : map.entrySet() ) { String[] split = entry.getKey().split( SEPARATOR ); dataMap.put( split[0], entry.getValue() ); } return dataMap; }
Map<String, Object> map = analyticsService.getAggregatedDataValueMapping( params.build() );
/** * Adds data element values to the given grid based on the given data query * parameters. * * @param params the {@link DataQueryParams}. * @param grid the grid. */ private void addDataElementValues( DataQueryParams params, Grid grid ) { if ( !params.getAllDataElements().isEmpty() && !params.isSkipData() ) { DataQueryParams dataSourceParams = DataQueryParams.newBuilder( params ) .retainDataDimension( DataDimensionItemType.DATA_ELEMENT ) .withIncludeNumDen( false ).build(); Map<String, Object> aggregatedDataMap = getAggregatedDataValueMapObjectTyped( dataSourceParams ); for ( Map.Entry<String, Object> entry : aggregatedDataMap.entrySet() ) { Object value = AnalyticsUtils.getRoundedValueObject( params, entry.getValue() ); grid.addRow() .addValues( entry.getKey().split( DIMENSION_SEP ) ) .addValue( value ); if ( params.isIncludeNumDen() ) { grid.addNullValues( 5 ); } } } }
/** * Groups the given query in sub queries for each dimension period. This only applies * if the aggregation type is {@link AggregationType#LAST} or * {@link AggregationType#LAST_AVERAGE_ORG_UNIT}. In this case, each period must be * aggregated individually. * * @param params the data query parameters. * @return a list of {@link DataQueryParams}. */ private List<DataQueryParams> groupByPeriod( DataQueryParams params ) { List<DataQueryParams> queries = new ArrayList<>(); if ( params.getAggregationType().isLastPeriodAggregationType() && !params.getPeriods().isEmpty() ) { for ( DimensionalItemObject period : params.getPeriods() ) { String periodType = ((Period) period).getPeriodType().getName().toLowerCase(); DataQueryParams query = DataQueryParams.newBuilder( params ) .withPeriods( Lists.newArrayList( period ), periodType ).build(); queries.add( query ); } } else { queries.add( params ); } logQuerySplit( queries, "period" ); return queries; }
/** * Returns a mapping between dimension items and values for the given data * query and list of indicators. The dimensional items part of the indicator * numerators and denominators are used as dimensional item for the aggregated * values being retrieved. * * @param params the {@link DataQueryParams}. * @param indicators the list of indicators. * @return a dimensional items to aggregate values map. */ private Map<String, Double> getAggregatedDataValueMap( DataQueryParams params, List<Indicator> indicators ) { List<DimensionalItemObject> items = Lists.newArrayList( expressionParserService.getIndicatorDimensionalItemObjects( indicators ) ); items = DimensionalObjectUtils.replaceOperandTotalsWithDataElements( items ); DimensionalObject dimension = new BaseDimensionalObject( DimensionalObject.DATA_X_DIM_ID, DimensionType.DATA_X, null, DISPLAY_NAME_DATA_X, items ); DataQueryParams dataSourceParams = DataQueryParams.newBuilder( params ) .replaceDimension( dimension ) .withMeasureCriteria( new HashMap<>() ) .withIncludeNumDen( false ) .withSkipHeaders( true ) .withSkipMeta( true ).build(); Grid grid = getAggregatedDataValueGridInternal( dataSourceParams ); return grid.getAsMap( grid.getWidth() - 1, DimensionalObject.DIMENSION_SEP ); }
/** * Gets aggregated event data for the given parameters. * * @param hasAttributeOptions whether the event data has attribute options. */ private MapMapMap<Integer, String, DimensionalItemObject, Double> getEventMap( boolean hasAttributeOptions, Set<DimensionalItemObject> eventItems ) { if ( eventItems.isEmpty() ) { return new MapMapMap<>(); } DataQueryParams.Builder paramsBuilder = DataQueryParams.newBuilder() .withDataDimensionItems( Lists.newArrayList( eventItems ) ) .withAttributeOptionCombos( Lists.newArrayList() ) .withFilterPeriods( Lists.newArrayList( period ) ) .withOrganisationUnits( orgUnits ); if ( hasAttributeOptions ) { paramsBuilder.withAttributeOptionCombos( Lists.newArrayList() ); } return getEventData( paramsBuilder.build(), hasAttributeOptions ); }
/** * Generates a mapping of permutations keys (organisation unit id or null) * and mappings of organisation unit group and counts. * * @param params the {@link DataQueryParams}. * @param indicators the indicators for which formulas to scan for organisation * unit groups. * @return a map of maps. */ private Map<String, Map<String, Integer>> getOrgUnitTargetMap( DataQueryParams params, Collection<Indicator> indicators ) { Set<OrganisationUnitGroup> orgUnitGroups = expressionParserService.getIndicatorOrgUnitGroups( indicators ); if ( orgUnitGroups.isEmpty() ) { return null; } DataQueryParams orgUnitTargetParams = DataQueryParams.newBuilder( params ) .pruneToDimensionType( DimensionType.ORGANISATION_UNIT ) .addDimension( new BaseDimensionalObject( DimensionalObject.ORGUNIT_GROUP_DIM_ID, DimensionType.ORGANISATION_UNIT_GROUP, new ArrayList<DimensionalItemObject>( orgUnitGroups ) ) ) .withSkipPartitioning( true ).build(); Map<String, Double> orgUnitCountMap = getAggregatedOrganisationUnitTargetMap( orgUnitTargetParams ); return DataQueryParams.getPermutationOrgUnitGroupCountMap( orgUnitCountMap ); }
/** * Adds reporting rates to the given grid based on the given data query * parameters. * * @param params the {@link DataQueryParams}. * @param grid the grid. */ private void addReportingRates( DataQueryParams params, Grid grid ) { if ( !params.getReportingRates().isEmpty() && !params.isSkipData() ) { for ( ReportingRateMetric metric : ReportingRateMetric.values() ) { DataQueryParams dataSourceParams = DataQueryParams.newBuilder( params ) .retainDataDimensionReportingRates( metric ) .ignoreDataApproval() // No approval for reporting rates .withAggregationType( AnalyticsAggregationType.COUNT ) .withTimely( ( REPORTING_RATE_ON_TIME == metric || ACTUAL_REPORTS_ON_TIME == metric ) ).build(); addReportingRates( dataSourceParams, grid, metric ); } } }
/** * Adds validation results to the given grid based on the given data query * parameters. * * @param params the {@link DataQueryParams}. * @param grid the grid. */ private void addValidationResultValues( DataQueryParams params, Grid grid ) { if ( !params.getAllValidationResults().isEmpty() && !params.isSkipData() ) { DataQueryParams dataSourceParams = DataQueryParams.newBuilder( params ) .retainDataDimension( DataDimensionItemType.VALIDATION_RULE ) .withAggregationType( AnalyticsAggregationType.COUNT ) .withIncludeNumDen( false ).build(); Map<String, Double> aggregatedDataMap = getAggregatedValidationResultMapObjectTyped( dataSourceParams ); fillGridWithAggregatedDataMap(params, grid, aggregatedDataMap); } }
/** * Performs pre-handling of the given query and returns the immutable, * handled query. If the query has a single indicator as item for the data * filter, the filter is set as a dimension and removed as a filter. * * @param params the {@link DataQueryParams}. * @return a {@link DataQueryParams}. */ private DataQueryParams preHandleQuery( DataQueryParams params ) { if ( params.hasSingleIndicatorAsDataFilter() || params.hasSingleReportingRateAsDataFilter() ) { DimensionalObject dx = params.getFilter( DATA_X_DIM_ID ); params = DataQueryParams.newBuilder( params ) .addDimension( dx ) .removeFilter( DATA_X_DIM_ID ) .addProcessingHint( ProcessingHint.SINGLE_INDICATOR_REPORTING_RATE_FILTER_ITEM ).build(); } return params; }
/** * Adds data element operand values to the given grid based on the given data * query parameters. * * @param params the {@link DataQueryParams}. * @param grid the grid. */ private void addDataElementOperandValues( DataQueryParams params, Grid grid ) { if ( !params.getDataElementOperands().isEmpty() && !params.isSkipData() ) { DataQueryParams dataSourceParams = DataQueryParams.newBuilder( params ) .retainDataDimension( DataDimensionItemType.DATA_ELEMENT_OPERAND ).build(); for ( DataElementOperand.TotalType type : DataElementOperand.TotalType.values() ) { addDataElementOperandValues( dataSourceParams, grid, type ); } } }
/** * Adds program data element values to the given grid based on the given data * query parameters. * * @param params the {@link DataQueryParams}. * @param grid the grid. */ private void addProgramDataElementAttributeIndicatorValues( DataQueryParams params, Grid grid ) { if ( ( !params.getAllProgramDataElementsAndAttributes().isEmpty() || !params.getProgramIndicators().isEmpty() ) && !params.isSkipData() ) { DataQueryParams dataSourceParams = DataQueryParams.newBuilder( params ) .retainDataDimensions( PROGRAM_DATA_ELEMENT, PROGRAM_ATTRIBUTE, PROGRAM_INDICATOR ).build(); EventQueryParams eventQueryParams = new EventQueryParams.Builder( EventQueryParams.fromDataQueryParams( dataSourceParams ) ) .withSkipMeta( true ).build(); Grid eventGrid = eventAnalyticsService.getAggregatedEventData( eventQueryParams ); grid.addRows( eventGrid ); } }
/** * Adds values to the given grid based on dynamic dimensions from the given * data query parameters. This assumes that no fixed dimensions are part of * the query. * * @param params the {@link DataQueryParams}. * @param grid the grid. */ private void addDynamicDimensionValues( DataQueryParams params, Grid grid ) { if ( params.getDataDimensionAndFilterOptions().isEmpty() && !params.isSkipData() ) { Map<String, Double> aggregatedDataMap = getAggregatedDataValueMap( DataQueryParams.newBuilder( params ) .withIncludeNumDen( false ).build() ); fillGridWithAggregatedDataMap(params, grid, aggregatedDataMap); } }
/** * Prepares the given data query parameters. * * @param params the {@link DataQueryParams}. */ private DataQueryParams preHandleRawDataQuery( DataQueryParams params ) { Builder builder = DataQueryParams.newBuilder( params ) .withEarliestStartDateLatestEndDate() .withPeriodDimensionWithoutOptions() .withIncludePeriodStartEndDates( true ); if ( params.isShowHierarchy() ) { builder.withOrgUnitLevels( organisationUnitService.getFilledOrganisationUnitLevels() ); } return builder.build(); }
@Override public Grid getAggregatedDataValues( DataQueryParams params ) { // --------------------------------------------------------------------- // Security and validation // --------------------------------------------------------------------- securityManager.decideAccess( params ); params = securityManager.withDataApprovalConstraints( params ); params = securityManager.withDimensionConstraints( params ); queryValidator.validate( params ); if ( dhisConfig.isAnalyticsCacheEnabled() ) { final DataQueryParams query = DataQueryParams.newBuilder( params ).build(); return queryCache.get( params.getKey(), key -> getAggregatedDataValueGridInternal( query ) ).get(); } return getAggregatedDataValueGridInternal( params ); }
@Override public DataQueryParams withTableNameAndPartitions( DataQueryParams params, QueryPlannerParams plannerParams ) { Partitions partitions = params.hasStartEndDate() ? PartitionUtils.getPartitions( params.getStartDate(), params.getEndDate() ) : PartitionUtils.getPartitions( params.getAllPeriods() ); return DataQueryParams.newBuilder( params ) .withTableName( plannerParams.getTableName() ) .withPartitions( partitions ) .build(); }
@Override public Map<String, Object> getAggregatedDataValueMapping( DataQueryParams params ) { Grid grid = getAggregatedDataValues( DataQueryParams.newBuilder( params ) .withIncludeNumDen( false ).build() ); return AnalyticsUtils.getAggregatedDataValueMapping( grid ); }
@Override public DataValueSet getAggregatedDataValueSet( DataQueryParams params ) { DataQueryParams query = DataQueryParams.newBuilder( params ) .withSkipMeta( false ) .withSkipData( false ) .withIncludeNumDen( false ) .withOutputFormat( OutputFormat.DATA_VALUE_SET ) .build(); Grid grid = getAggregatedDataValueGridInternal( query ); return AnalyticsUtils.getDataValueSetFromGrid( params, grid ); }
@Override public DataQueryParams withDimensionConstraints( DataQueryParams params ) { DataQueryParams.Builder builder = DataQueryParams.newBuilder( params ); applyOrganisationUnitConstraint( builder, params ); applyUserConstraints( builder, params ); return builder.build(); }