use of org.hisp.dhis.category.Category in project dhis2-core by dhis2.
the class AnalyticsServiceTest method setUpTest.
// Database (value, data element, period)
// --------------------------------------------------------------------
//
// A: 2, deA, peJan - 4, deB, peFeb - 6, deC, peMar - 8, deD, peApril
// 100, deB, peJan - 2, deD, peFeb
//
// B: 1, deA, peJan - 3, deB, peFeb - 5, deC, peMar - 7, deD, peApril
//
// C: 5, deA, peJan - 10, deB, peFeb - 15, deC, peMar - 20, deD, peApril
// 4, deD, peJan - 23, deC, peFeb
//
// D: 66, deA, peJan - 233, deA, peFeb - 399, deB, peFeb
//
// E: 1, deA, peJan - 1, deB, peFeb - 1, deC, peMar - 1, deD, peApril
// 32, deD, peJan
//
// --------------------------------------------------------------------
@Override
public void setUpTest() throws IOException, InterruptedException {
// Set up meta data for data values
ReportingRate reportingRateA;
ReportingRate reportingRateB;
ocDef = categoryService.getDefaultCategoryOptionCombo();
ocDef.setUid("o1234578def");
categoryService.updateCategoryOptionCombo(ocDef);
catDef = categoryService.getDefaultCategory();
catDef.setUid("cat12345def");
categoryService.updateCategory(catDef);
Period peJan = createPeriod("2017-01");
Period peFeb = createPeriod("2017-02");
Period peMar = createPeriod("2017-03");
Period peApril = createPeriod("2017-04");
Period peMay = createPeriod("2017-05");
Period peJune = createPeriod("2017-06");
Period peJuly = createPeriod("2017-07");
Period quarter = createPeriod("2017Q1");
periodService.addPeriod(peJan);
periodService.addPeriod(peFeb);
periodService.addPeriod(peMar);
periodService.addPeriod(peApril);
periodService.addPeriod(peMay);
periodService.addPeriod(peJune);
periodService.addPeriod(peJuly);
DataElement deA = createDataElement('A');
DataElement deB = createDataElement('B');
DataElement deC = createDataElement('C');
DataElement deD = createDataElement('D');
DataElement deE = createDataElement('E');
deE.setValueType(ValueType.INTEGER);
dataElementService.addDataElement(deA);
dataElementService.addDataElement(deB);
dataElementService.addDataElement(deC);
dataElementService.addDataElement(deD);
dataElementService.addDataElement(deE);
OrganisationUnit ouA = createOrganisationUnit('A');
OrganisationUnit ouB = createOrganisationUnit('B');
OrganisationUnit ouC = createOrganisationUnit('C');
ouC.setOpeningDate(getDate(2016, 4, 10));
ouC.setClosedDate(null);
OrganisationUnit ouD = createOrganisationUnit('D');
ouD.setOpeningDate(getDate(2016, 12, 10));
ouD.setClosedDate(null);
OrganisationUnit ouE = createOrganisationUnit('E');
AnalyticsTestUtils.configureHierarchy(ouA, ouB, ouC, ouD, ouE);
organisationUnitService.addOrganisationUnit(ouA);
organisationUnitService.addOrganisationUnit(ouB);
organisationUnitService.addOrganisationUnit(ouC);
organisationUnitService.addOrganisationUnit(ouD);
organisationUnitService.addOrganisationUnit(ouE);
OrganisationUnitGroup organisationUnitGroupA = createOrganisationUnitGroup('A');
organisationUnitGroupA.setUid("a2345groupA");
organisationUnitGroupA.addOrganisationUnit(ouA);
organisationUnitGroupA.addOrganisationUnit(ouB);
OrganisationUnitGroup organisationUnitGroupB = createOrganisationUnitGroup('B');
organisationUnitGroupB.setUid("a2345groupB");
organisationUnitGroupB.addOrganisationUnit(ouC);
organisationUnitGroupB.addOrganisationUnit(ouD);
organisationUnitGroupB.addOrganisationUnit(ouE);
OrganisationUnitGroup organisationUnitGroupC = createOrganisationUnitGroup('C');
organisationUnitGroupC.setUid("a2345groupC");
organisationUnitGroupC.addOrganisationUnit(ouA);
organisationUnitGroupC.addOrganisationUnit(ouB);
organisationUnitGroupC.addOrganisationUnit(ouC);
OrganisationUnitGroup organisationUnitGroupD = createOrganisationUnitGroup('D');
organisationUnitGroupD.setUid("a2345groupD");
organisationUnitGroupD.addOrganisationUnit(ouD);
organisationUnitGroupD.addOrganisationUnit(ouE);
organisationUnitGroupService.addOrganisationUnitGroup(organisationUnitGroupA);
organisationUnitGroupService.addOrganisationUnitGroup(organisationUnitGroupB);
organisationUnitGroupService.addOrganisationUnitGroup(organisationUnitGroupC);
organisationUnitGroupService.addOrganisationUnitGroup(organisationUnitGroupD);
OrganisationUnitGroupSet organisationUnitGroupSetA = createOrganisationUnitGroupSet('A');
organisationUnitGroupSetA.setUid("a234567setA");
OrganisationUnitGroupSet organisationUnitGroupSetB = createOrganisationUnitGroupSet('B');
organisationUnitGroupSetB.setUid("a234567setB");
organisationUnitGroupSetA.getOrganisationUnitGroups().add(organisationUnitGroupA);
organisationUnitGroupSetA.getOrganisationUnitGroups().add(organisationUnitGroupB);
organisationUnitGroupSetB.getOrganisationUnitGroups().add(organisationUnitGroupC);
organisationUnitGroupSetB.getOrganisationUnitGroups().add(organisationUnitGroupD);
organisationUnitGroupService.addOrganisationUnitGroupSet(organisationUnitGroupSetA);
organisationUnitGroupService.addOrganisationUnitGroupSet(organisationUnitGroupSetB);
DataSet dataSetA = createDataSet('A');
dataSetA.setUid("a23dataSetA");
dataSetA.addOrganisationUnit(ouD);
dataSetA.addOrganisationUnit(ouC);
DataSet dataSetB = createDataSet('B');
dataSetB.setUid("a23dataSetB");
dataSetB.addOrganisationUnit(ouD);
dataSetService.addDataSet(dataSetA);
dataSetService.addDataSet(dataSetB);
// Read data values from CSV files
List<String[]> dataValueLines = CsvUtils.readCsvAsListFromClasspath("csv/dataValues.csv", true);
parseDataValues(dataValueLines);
List<String[]> dataSetRegistrationLines = CsvUtils.readCsvAsListFromClasspath("csv/dataSetRegistrations.csv", true);
parseDataSetRegistrations(dataSetRegistrationLines);
// Make indicators
IndicatorType indicatorType_1 = createIndicatorType('A');
indicatorType_1.setFactor(1);
indicatorService.addIndicatorType(indicatorType_1);
// deA
Indicator indicatorA = createIndicator('A', indicatorType_1);
String expressionA = "#{" + deA.getUid() + "." + ocDef.getUid() + "}";
indicatorA.setNumerator(expressionA);
indicatorA.setDenominator("1");
// deB + deC
Indicator indicatorB = createIndicator('B', indicatorType_1);
String expressionB = "#{" + deB.getUid() + "." + ocDef.getUid() + "}" + "+#{" + deC.getUid() + "." + ocDef.getUid() + "}";
indicatorB.setNumerator(expressionB);
indicatorB.setDenominator("1");
// (deB * deC) / 100
Indicator indicatorC = createIndicator('C', indicatorType_1);
String expressionC = "#{" + deB.getUid() + "." + ocDef.getUid() + "}" + "*#{" + deC.getUid() + "." + ocDef.getUid() + "}";
indicatorC.setNumerator(expressionC);
indicatorC.setDenominator("100");
// (deA * deC) / deB
Indicator indicatorD = createIndicator('D', indicatorType_1);
String expressionD = "#{" + deA.getUid() + "." + ocDef.getUid() + "}" + "*#{" + deC.getUid() + "." + ocDef.getUid() + "}";
indicatorD.setNumerator(expressionD);
indicatorD.setDenominator("#{" + deB.getUid() + "." + ocDef.getUid() + "}");
// deA * reporting rate B
Indicator indicatorE = createIndicator('E', indicatorType_1);
reportingRateA = new ReportingRate(dataSetA);
reportingRateB = new ReportingRate(dataSetB);
String expressionE = "#{" + deA.getUid() + "." + ocDef.getUid() + "}" + "*(R{" + reportingRateB.getUid() + ".REPORTING_RATE} / 100)";
indicatorE.setNumerator(expressionE);
indicatorE.setDenominator("1");
// deA * reporting rate A
Indicator indicatorF = createIndicator('F', indicatorType_1);
String expressionF = "#{" + deA.getUid() + "." + ocDef.getUid() + "}" + "*(R{" + reportingRateA.getUid() + ".REPORTING_RATE} / 100)";
indicatorF.setNumerator(expressionF);
indicatorF.setDenominator("1");
// deE.periodOffset(-1) + deE.periodOffset(-2)
Indicator indicatorG = createIndicator('G', indicatorType_1);
String expressionG = "#{" + deE.getUid() + "}.periodOffset(-1) + #{" + deE.getUid() + "}.periodOffset(-2)";
indicatorG.setNumerator(expressionG);
indicatorG.setDenominator("1");
indicatorService.addIndicator(indicatorA);
indicatorService.addIndicator(indicatorB);
indicatorService.addIndicator(indicatorC);
indicatorService.addIndicator(indicatorD);
indicatorService.addIndicator(indicatorE);
indicatorService.addIndicator(indicatorF);
indicatorService.addIndicator(indicatorG);
// Validation results
CategoryOption optionA = new CategoryOption("CategoryOptionA");
CategoryOption optionB = new CategoryOption("CategoryOptionB");
categoryService.addCategoryOption(optionA);
categoryService.addCategoryOption(optionB);
Category categoryA = createCategory('A', optionA, optionB);
categoryA.setDataDimensionType(DataDimensionType.ATTRIBUTE);
categoryA.setUid("categoryabA");
categoryService.addCategory(categoryA);
CategoryCombo categoryComboA = createCategoryCombo('A', categoryA);
categoryService.addCategoryCombo(categoryComboA);
CategoryOptionCombo optionComboA = createCategoryOptionCombo(categoryComboA, optionA);
CategoryOptionCombo optionComboB = createCategoryOptionCombo(categoryComboA, optionB);
CategoryOptionCombo optionComboC = createCategoryOptionCombo(categoryComboA, optionA, optionB);
categoryService.addCategoryOptionCombo(optionComboA);
categoryService.addCategoryOptionCombo(optionComboB);
categoryService.addCategoryOptionCombo(optionComboC);
CategoryOptionGroup optionGroupA = createCategoryOptionGroup('A', optionA);
CategoryOptionGroup optionGroupB = createCategoryOptionGroup('B', optionB);
categoryService.saveCategoryOptionGroup(optionGroupA);
categoryService.saveCategoryOptionGroup(optionGroupB);
CategoryOptionGroupSet optionGroupSetB = new CategoryOptionGroupSet("OptionGroupSetB");
categoryService.saveCategoryOptionGroupSet(optionGroupSetB);
optionGroupSetB.addCategoryOptionGroup(optionGroupA);
optionGroupSetB.addCategoryOptionGroup(optionGroupB);
optionGroupA.getGroupSets().add(optionGroupSetB);
optionGroupB.getGroupSets().add(optionGroupSetB);
Expression expressionVRA = new Expression("expressionA", "descriptionA");
Expression expressionVRB = new Expression("expressionB", "descriptionB");
Expression expressionVRC = new Expression("expressionC", "descriptionC");
Expression expressionVRD = new Expression("expressionD", "descriptionD");
expressionService.addExpression(expressionVRA);
expressionService.addExpression(expressionVRB);
expressionService.addExpression(expressionVRC);
expressionService.addExpression(expressionVRD);
PeriodType periodType = PeriodType.getPeriodTypeByName("Monthly");
ValidationRule validationRuleA = createValidationRule('A', equal_to, expressionVRA, expressionVRB, periodType);
validationRuleA.setUid("a234567vruA");
ValidationRule validationRuleB = createValidationRule('B', equal_to, expressionVRC, expressionVRD, periodType);
validationRuleB.setUid("a234567vruB");
validationRuleService.saveValidationRule(validationRuleA);
validationRuleService.saveValidationRule(validationRuleB);
Date today = new Date();
ValidationResult validationResultBA = new ValidationResult(validationRuleA, peJan, ouB, optionComboA, 1.0, 2.0, 3);
validationResultBA.setCreated(today);
ValidationResult validationResultBB = new ValidationResult(validationRuleA, peJan, ouB, optionComboB, 1.0, 2.0, 3);
validationResultBB.setCreated(today);
ValidationResult validationResultAA = new ValidationResult(validationRuleA, peJan, ouA, optionComboA, 1.0, 2.0, 3);
validationResultAA.setCreated(today);
ValidationResult validationResultAB = new ValidationResult(validationRuleA, peJan, ouA, optionComboB, 1.0, 2.0, 3);
validationResultAB.setCreated(today);
ValidationResult validationResultBAB = new ValidationResult(validationRuleB, peJan, ouA, optionComboB, 1.0, 2.0, 3);
validationResultBAB.setCreated(today);
ValidationResult validationResultBBB = new ValidationResult(validationRuleB, peFeb, ouB, optionComboB, 1.0, 2.0, 3);
validationResultBBB.setCreated(today);
ValidationResult validationResultBBA = new ValidationResult(validationRuleB, peFeb, ouB, optionComboA, 1.0, 2.0, 3);
validationResultService.saveValidationResults(Lists.newArrayList(validationResultAA, validationResultAB, validationResultBB, validationResultBA, validationResultBAB, validationResultBBB, validationResultBBA));
// to ensure that Hibernate has flushed validation
Thread.sleep(1000);
// results before generating tables.
// Generate analytics tables
analyticsTableGenerator.generateTables(AnalyticsTableUpdateParams.newBuilder().build(), NoopJobProgress.INSTANCE);
// Set parameters
List<Indicator> param_indicators = new ArrayList<>();
List<ReportingRate> param_reportingRates = new ArrayList<>();
Period y2017 = createPeriod("2017");
// all data elements - mar 2017
Period y2017_mar = createPeriod("2017-03");
DataQueryParams de_avg_2017_03_params = DataQueryParams.newBuilder().withDataElements(dataElementService.getAllDataElements()).withAggregationType(AnalyticsAggregationType.AVERAGE).withSkipRounding(true).withPeriod(y2017_mar).withOutputFormat(OutputFormat.ANALYTICS).build();
// org unit B - data element C - mar 2017
List<DataElement> dataElements1 = new ArrayList<>();
dataElements1.add(deC);
DataQueryParams deC_ouB_2017_03_params = DataQueryParams.newBuilder().withOrganisationUnit(ouB).withDataElements(dataElements1).withAggregationType(AnalyticsAggregationType.SUM).withPeriod(y2017_mar).withOutputFormat(OutputFormat.ANALYTICS).build();
AnalyticalObject deC_ouB_2017_03_analytical = new Visualization("deC_ouB_2017_03", dataElements1, param_indicators, param_reportingRates, Lists.newArrayList(y2017_mar), Lists.newArrayList(ouB), false, true, true);
// org unit A - data element A - Q1 2017
List<DataElement> dataElements2 = new ArrayList<>();
dataElements2.add(deA);
DataQueryParams deA_ouA_2017_Q01_params = DataQueryParams.newBuilder().withOrganisationUnit(ouA).withDataElements(dataElements2).withAggregationType(AnalyticsAggregationType.SUM).withPeriod(quarter).withOutputFormat(OutputFormat.ANALYTICS).build();
AnalyticalObject deA_ouA_2017_Q01_analytical = new Visualization("deA_ouA_2017_Q01", dataElements2, param_indicators, param_reportingRates, Lists.newArrayList(quarter), Lists.newArrayList(ouA), false, true, true);
// indicator A - 2017
DataQueryParams inA_2017_params = DataQueryParams.newBuilder().withIndicators(Lists.newArrayList(indicatorA)).withAggregationType(AnalyticsAggregationType.SUM).withPeriod(y2017).withOutputFormat(OutputFormat.ANALYTICS).build();
// indicator B (deB + deC) - 2017 Q1
DataQueryParams inB_deB_deC_2017_Q01_params = DataQueryParams.newBuilder().withIndicators(Lists.newArrayList(indicatorB)).withAggregationType(AnalyticsAggregationType.SUM).withPeriod(quarter).withOutputFormat(OutputFormat.ANALYTICS).build();
// indicator C (deB * deC) in hundreds - 2017 Q1
List<Indicator> param_indicators3 = new ArrayList<>();
param_indicators3.add(indicatorC);
DataQueryParams inC_deB_deC_2017_Q01_params = DataQueryParams.newBuilder().withIndicators(param_indicators3).withAggregationType(AnalyticsAggregationType.SUM).withPeriod(quarter).withOutputFormat(OutputFormat.ANALYTICS).build();
AnalyticalObject inC_deB_deC_2017_Q01_analytical = new Visualization("deA_ouA_2017_Q01", Lists.newArrayList(), param_indicators3, param_reportingRates, Lists.newArrayList(quarter), Lists.newArrayList(ouA), true, true, true);
// indicator D (deA * deC)/deB - 2017 Q1
DataQueryParams inD_deA_deB_deC_2017_Q01_params = DataQueryParams.newBuilder().withIndicators(Lists.newArrayList(indicatorD)).withAggregationType(AnalyticsAggregationType.SUM).withPeriod(quarter).withOutputFormat(OutputFormat.ANALYTICS).build();
// indicator E (deA * reporting rate B) / 100 - 2017 Q1
DataQueryParams inE_deA_reRateA_2017_Q01_params = DataQueryParams.newBuilder().withOrganisationUnit(ouD).withIndicators(Lists.newArrayList(indicatorE)).withAggregationType(AnalyticsAggregationType.SUM).withPeriod(quarter).withOutputFormat(OutputFormat.ANALYTICS).build();
// indicator F (deA * reporting rate A) / 100 - 2017 Q1
DataQueryParams inF_deA_reRateB_2017_Q01_params = DataQueryParams.newBuilder().withOrganisationUnit(ouD).withIndicators(Lists.newArrayList(indicatorF)).withAggregationType(AnalyticsAggregationType.SUM).withPeriod(quarter).withOutputFormat(OutputFormat.ANALYTICS).build();
// indicator G (deE.periodOffset(-1) + deE.periodOffset(-2)) 2017-07
DataQueryParams inG_deE_periodOffsets_2017_07_params = DataQueryParams.newBuilder().withOrganisationUnit(ouA).withIndicators(Lists.newArrayList(indicatorG)).withAggregationType(AnalyticsAggregationType.SUM).withPeriod(peJuly).withOutputFormat(OutputFormat.ANALYTICS).build();
// Max value - org unit B and C - data element A - 2017 Feb
DataQueryParams deA_ouB_ouC_2017_02_params = DataQueryParams.newBuilder().withFilterOrganisationUnits(Lists.newArrayList(ouB, ouC)).withDataElements(Lists.newArrayList(deA)).withAggregationType(new AnalyticsAggregationType(AggregationType.MAX, AggregationType.MAX)).withPeriod(peFeb).withOutputFormat(OutputFormat.ANALYTICS).build();
// Average value - org unit C and E - data element A, B and D - 2017
// April
DataQueryParams deA_deB_deD_ouC_ouE_2017_04_params = DataQueryParams.newBuilder().withFilterOrganisationUnits(Lists.newArrayList(ouC, ouE)).withDataElements(Lists.newArrayList(deA, deB, deD)).withAggregationType(AnalyticsAggregationType.AVERAGE).withOutputFormat(OutputFormat.ANALYTICS).withPeriod(peApril).withOutputFormat(OutputFormat.ANALYTICS).build();
// Sum org unit B - 2017-01-01 -> 2017-02-20
DataQueryParams ouB_2017_01_01_2017_02_20_params = DataQueryParams.newBuilder().withDataElements(Lists.newArrayList(deA, deB)).withOrganisationUnit(ouB).withStartDate(getDate(2017, 1, 1)).withEndDate(getDate(2017, 2, 20)).withAggregationType(AnalyticsAggregationType.SUM).withOutputFormat(OutputFormat.ANALYTICS).build();
// Reportingrate for dataSet A - Q1 2017
DataQueryParams reRate_2017_Q01_ouC_params = DataQueryParams.newBuilder().withOrganisationUnit(ouC).withReportingRates(Lists.newArrayList(reportingRateA)).withPeriod(quarter).withAggregationType(AnalyticsAggregationType.SUM).withOutputFormat(OutputFormat.ANALYTICS).build();
// Reportingrate for dataSet B - Q1 2017
DataQueryParams reRate_2017_Q01_ouD_params = DataQueryParams.newBuilder().withOrganisationUnit(ouD).withReportingRates(Lists.newArrayList(reportingRateB)).withPeriod(quarter).withAggregationType(AnalyticsAggregationType.SUM).withOutputFormat(OutputFormat.ANALYTICS).build();
// Validation result queries
DataQueryParams ou_2017_validationruleA_params = DataQueryParams.newBuilder().withValidationRules(Lists.newArrayList(validationRuleA)).withOrganisationUnits(organisationUnitService.getAllOrganisationUnits()).withAggregationType(AnalyticsAggregationType.COUNT).withPeriod(y2017).withOutputFormat(OutputFormat.ANALYTICS).build();
DataQueryParams ou_2017_validationruleB_params = DataQueryParams.newBuilder().withValidationRules(Lists.newArrayList(validationRuleB)).withOrganisationUnits(organisationUnitService.getAllOrganisationUnits()).withAggregationType(AnalyticsAggregationType.COUNT).withPeriod(y2017).withOutputFormat(OutputFormat.ANALYTICS).build();
DataQueryParams ou_2017_validationruleAB_params = DataQueryParams.newBuilder().withValidationRules(Lists.newArrayList(validationRuleA, validationRuleB)).withOrganisationUnits(organisationUnitService.getAllOrganisationUnits()).withAggregationType(AnalyticsAggregationType.COUNT).withPeriod(y2017).withOutputFormat(OutputFormat.ANALYTICS).build();
dataQueryParams.put("de_avg_2017_03", de_avg_2017_03_params);
dataQueryParams.put("deC_ouB_2017_03", deC_ouB_2017_03_params);
dataQueryParams.put("deA_ouA_2017_Q01", deA_ouA_2017_Q01_params);
dataQueryParams.put("inA_2017", inA_2017_params);
dataQueryParams.put("inB_deB_deC_2017_Q01", inB_deB_deC_2017_Q01_params);
dataQueryParams.put("inC_deB_deC_2017_Q01", inC_deB_deC_2017_Q01_params);
dataQueryParams.put("inD_deA_deB_deC_2017_Q01", inD_deA_deB_deC_2017_Q01_params);
dataQueryParams.put("inE_deA_reRateA_2017_Q01", inE_deA_reRateA_2017_Q01_params);
dataQueryParams.put("inF_deA_reRateB_2017_Q01", inF_deA_reRateB_2017_Q01_params);
dataQueryParams.put("inG_deE_periodOffsets_2017_07", inG_deE_periodOffsets_2017_07_params);
dataQueryParams.put("deA_ouB_ouC_2017_02", deA_ouB_ouC_2017_02_params);
dataQueryParams.put("deA_deB_deD_ouC_ouE_2017_04", deA_deB_deD_ouC_ouE_2017_04_params);
dataQueryParams.put("ouB_2017_01_01_2017_02_20", ouB_2017_01_01_2017_02_20_params);
dataQueryParams.put("reRate_2017_Q01_ouC", reRate_2017_Q01_ouC_params);
dataQueryParams.put("reRate_2017_Q01_ouD", reRate_2017_Q01_ouD_params);
dataQueryParams.put("ou_2017_validationruleA", ou_2017_validationruleA_params);
dataQueryParams.put("ou_2017_validationruleB", ou_2017_validationruleB_params);
dataQueryParams.put("ou_2017_validationruleAB", ou_2017_validationruleAB_params);
analyticalObjectHashMap.put("deC_ouB_2017_03", deC_ouB_2017_03_analytical);
analyticalObjectHashMap.put("deA_ouA_2017_Q01", deA_ouA_2017_Q01_analytical);
analyticalObjectHashMap.put("inC_deB_deC_2017_Q01", inC_deB_deC_2017_Q01_analytical);
// Set results
// --------------------------------------------------------------------
Map<String, Double> de_avg_2017_03_keyValue = new HashMap<>();
de_avg_2017_03_keyValue.put("deabcdefghC-201703", 6.75);
Map<String, Double> deC_ouB_2017_03_keyValue = new HashMap<>();
deC_ouB_2017_03_keyValue.put("deabcdefghC-ouabcdefghB-201703", 6.0);
deC_ouB_2017_03_keyValue.put("deabcdefghC-201703-ouabcdefghB", 6.0);
Map<String, Double> deA_ouA_2017_Q01_keyValue = new HashMap<>();
deA_ouA_2017_Q01_keyValue.put("deabcdefghA-ouabcdefghA-2017Q1", 308.0);
deA_ouA_2017_Q01_keyValue.put("deabcdefghA-2017Q1-ouabcdefghA", 308.0);
Map<String, Double> inA_2017_keyValue = new HashMap<>();
inA_2017_keyValue.put("inabcdefghA-2017", 308.0);
Map<String, Double> inB_deB_deC_2017_Q01_keyValue = new HashMap<>();
inB_deB_deC_2017_Q01_keyValue.put("inabcdefghB-2017Q1", 567.0);
Map<String, Double> inC_deB_deC_2017_Q01_keyValue = new HashMap<>();
inC_deB_deC_2017_Q01_keyValue.put("inabcdefghC-2017Q1", 258.50);
inC_deB_deC_2017_Q01_keyValue.put("inabcdefghC-2017Q1-ouabcdefghA", 258.50);
Map<String, Double> inD_deA_deB_deC_2017_Q01_keyValue = new HashMap<>();
inD_deA_deB_deC_2017_Q01_keyValue.put("inabcdefghD-2017Q1", 29.8);
Map<String, Double> inE_deA_reRateA_2017_Q01_keyValue = new HashMap<>();
inE_deA_reRateA_2017_Q01_keyValue.put("inabcdefghE-ouabcdefghD-2017Q1", 99.6);
Map<String, Double> inF_deA_reRateB_2017_Q01_keyValue = new HashMap<>();
inF_deA_reRateB_2017_Q01_keyValue.put("inabcdefghF-ouabcdefghD-2017Q1", 199.4);
Map<String, Double> inG_deE_periodOffsets_2017_07_keyvalue = new HashMap<>();
inG_deE_periodOffsets_2017_07_keyvalue.put("inabcdefghG-ouabcdefghA-201707", 3.0);
Map<String, Double> deA_ouB_ouC_2017_02_keyValue = new HashMap<>();
deA_ouB_ouC_2017_02_keyValue.put("deabcdefghA-201702", 233.0);
Map<String, Double> deA_deB_deD_ouC_ouE_2017_04_keyValue = new HashMap<>();
deA_deB_deD_ouC_ouE_2017_04_keyValue.put("deabcdefghD-201704", 10.5);
Map<String, Double> deA_deB_2017_Q01_keyValue = new HashMap<>();
deA_deB_2017_Q01_keyValue.put("2017Q1", 53.3);
Map<String, Double> ouB_2017_01_01_2017_02_20_keyValue = new HashMap<>();
ouB_2017_01_01_2017_02_20_keyValue.put("deabcdefghA-ouabcdefghB", 68.0);
Map<String, Double> reRate_2017_Q01_ouC_keyValue = new HashMap<>();
reRate_2017_Q01_ouC_keyValue.put("a23dataSetA.REPORTING_RATE-ouabcdefghC-2017Q1", 100.0);
Map<String, Double> reRate_2017_Q01_ouD_keyValue = new HashMap<>();
reRate_2017_Q01_ouD_keyValue.put("a23dataSetB.REPORTING_RATE-ouabcdefghD-2017Q1", 33.3);
Map<String, Double> ou_2017_validationruleA_keyValue = new HashMap<>();
ou_2017_validationruleA_keyValue.put("a234567vruA-ouabcdefghA-2017", 4.0);
ou_2017_validationruleA_keyValue.put("a234567vruA-ouabcdefghB-2017", 2.0);
Map<String, Double> ou_2017_validationruleB_keyValue = new HashMap<>();
ou_2017_validationruleB_keyValue.put("a234567vruB-ouabcdefghA-2017", 3.0);
ou_2017_validationruleB_keyValue.put("a234567vruB-ouabcdefghB-2017", 2.0);
Map<String, Double> ou_2017_validationruleAB_keyValue = new HashMap<>();
ou_2017_validationruleAB_keyValue.put("a234567vruA-ouabcdefghA-2017", 4.0);
ou_2017_validationruleAB_keyValue.put("a234567vruA-ouabcdefghB-2017", 2.0);
ou_2017_validationruleAB_keyValue.put("a234567vruB-ouabcdefghA-2017", 3.0);
ou_2017_validationruleAB_keyValue.put("a234567vruB-ouabcdefghB-2017", 2.0);
results.put("de_avg_2017_03", de_avg_2017_03_keyValue);
results.put("deC_ouB_2017_03", deC_ouB_2017_03_keyValue);
results.put("deA_ouA_2017_Q01", deA_ouA_2017_Q01_keyValue);
results.put("inA_2017", inA_2017_keyValue);
results.put("inB_deB_deC_2017_Q01", inB_deB_deC_2017_Q01_keyValue);
results.put("inC_deB_deC_2017_Q01", inC_deB_deC_2017_Q01_keyValue);
results.put("inD_deA_deB_deC_2017_Q01", inD_deA_deB_deC_2017_Q01_keyValue);
results.put("inE_deA_reRateA_2017_Q01", inE_deA_reRateA_2017_Q01_keyValue);
results.put("inF_deA_reRateB_2017_Q01", inF_deA_reRateB_2017_Q01_keyValue);
results.put("inG_deE_periodOffsets_2017_07", inG_deE_periodOffsets_2017_07_keyvalue);
results.put("deA_ouB_ouC_2017_02", deA_ouB_ouC_2017_02_keyValue);
results.put("deA_deB_deD_ouC_ouE_2017_04", deA_deB_deD_ouC_ouE_2017_04_keyValue);
results.put("deA_deB_2017_Q01", deA_deB_2017_Q01_keyValue);
results.put("ouB_2017_01_01_2017_02_20", ouB_2017_01_01_2017_02_20_keyValue);
results.put("reRate_2017_Q01_ouC", reRate_2017_Q01_ouC_keyValue);
results.put("reRate_2017_Q01_ouD", reRate_2017_Q01_ouD_keyValue);
results.put("ou_2017_validationruleA", ou_2017_validationruleA_keyValue);
results.put("ou_2017_validationruleB", ou_2017_validationruleB_keyValue);
results.put("ou_2017_validationruleAB", ou_2017_validationruleAB_keyValue);
}
use of org.hisp.dhis.category.Category in project dhis2-core by dhis2.
the class JdbcCompletenessTableManager method getDimensionColumns.
private List<AnalyticsTableColumn> getDimensionColumns() {
List<AnalyticsTableColumn> columns = new ArrayList<>();
String idColAlias = "(ds.uid || '-' || ps.iso || '-' || ou.uid || '-' || ao.uid) as id ";
columns.add(new AnalyticsTableColumn(quote("id"), ColumnDataType.TEXT, idColAlias));
List<OrganisationUnitGroupSet> orgUnitGroupSets = idObjectManager.getDataDimensionsNoAcl(OrganisationUnitGroupSet.class);
List<OrganisationUnitLevel> levels = organisationUnitService.getFilledOrganisationUnitLevels();
List<CategoryOptionGroupSet> attributeCategoryOptionGroupSets = categoryService.getAttributeCategoryOptionGroupSetsNoAcl();
List<Category> attributeCategories = categoryService.getAttributeDataDimensionCategoriesNoAcl();
for (OrganisationUnitGroupSet groupSet : orgUnitGroupSets) {
columns.add(new AnalyticsTableColumn(quote(groupSet.getUid()), CHARACTER_11, "ougs." + quote(groupSet.getUid())).withCreated(groupSet.getCreated()));
}
for (OrganisationUnitLevel level : levels) {
String column = quote(PREFIX_ORGUNITLEVEL + level.getLevel());
columns.add(new AnalyticsTableColumn(column, CHARACTER_11, "ous." + column).withCreated(level.getCreated()));
}
for (CategoryOptionGroupSet groupSet : attributeCategoryOptionGroupSets) {
columns.add(new AnalyticsTableColumn(quote(groupSet.getUid()), CHARACTER_11, "acs." + quote(groupSet.getUid())).withCreated(groupSet.getCreated()));
}
for (Category category : attributeCategories) {
columns.add(new AnalyticsTableColumn(quote(category.getUid()), CHARACTER_11, "acs." + quote(category.getUid())).withCreated(category.getCreated()));
}
columns.addAll(addPeriodTypeColumns("ps"));
String timelyDateDiff = statementBuilder.getDaysBetweenDates("pe.enddate", statementBuilder.getCastToDate("cdr.date"));
String timelyAlias = "(select (" + timelyDateDiff + ") <= ds.timelydays) as timely";
columns.add(new AnalyticsTableColumn(quote("timely"), BOOLEAN, timelyAlias));
columns.addAll(getFixedColumns());
return filterDimensionColumns(columns);
}
use of org.hisp.dhis.category.Category in project dhis2-core by dhis2.
the class JdbcAnalyticsTableManager method getDimensionColumns.
private List<AnalyticsTableColumn> getDimensionColumns(Integer year) {
List<AnalyticsTableColumn> columns = new ArrayList<>();
String idColAlias = "(de.uid || '-' || ps.iso || '-' || ou.uid || '-' || co.uid || '-' || ao.uid) as id ";
columns.add(new AnalyticsTableColumn(quote("id"), ColumnDataType.TEXT, idColAlias));
List<DataElementGroupSet> dataElementGroupSets = idObjectManager.getDataDimensionsNoAcl(DataElementGroupSet.class);
List<OrganisationUnitGroupSet> orgUnitGroupSets = idObjectManager.getDataDimensionsNoAcl(OrganisationUnitGroupSet.class);
List<CategoryOptionGroupSet> disaggregationCategoryOptionGroupSets = categoryService.getDisaggregationCategoryOptionGroupSetsNoAcl();
List<CategoryOptionGroupSet> attributeCategoryOptionGroupSets = categoryService.getAttributeCategoryOptionGroupSetsNoAcl();
List<Category> disaggregationCategories = categoryService.getDisaggregationDataDimensionCategoriesNoAcl();
List<Category> attributeCategories = categoryService.getAttributeDataDimensionCategoriesNoAcl();
List<OrganisationUnitLevel> levels = organisationUnitService.getFilledOrganisationUnitLevels();
for (DataElementGroupSet groupSet : dataElementGroupSets) {
columns.add(new AnalyticsTableColumn(quote(groupSet.getUid()), CHARACTER_11, "degs." + quote(groupSet.getUid())).withCreated(groupSet.getCreated()));
}
for (OrganisationUnitGroupSet groupSet : orgUnitGroupSets) {
columns.add(new AnalyticsTableColumn(quote(groupSet.getUid()), CHARACTER_11, "ougs." + quote(groupSet.getUid())).withCreated(groupSet.getCreated()));
}
for (CategoryOptionGroupSet groupSet : disaggregationCategoryOptionGroupSets) {
columns.add(new AnalyticsTableColumn(quote(groupSet.getUid()), CHARACTER_11, "dcs." + quote(groupSet.getUid())).withCreated(groupSet.getCreated()));
}
for (CategoryOptionGroupSet groupSet : attributeCategoryOptionGroupSets) {
columns.add(new AnalyticsTableColumn(quote(groupSet.getUid()), CHARACTER_11, "acs." + quote(groupSet.getUid())).withCreated(groupSet.getCreated()));
}
for (Category category : disaggregationCategories) {
columns.add(new AnalyticsTableColumn(quote(category.getUid()), CHARACTER_11, "dcs." + quote(category.getUid())).withCreated(category.getCreated()));
}
for (Category category : attributeCategories) {
columns.add(new AnalyticsTableColumn(quote(category.getUid()), CHARACTER_11, "acs." + quote(category.getUid())).withCreated(category.getCreated()));
}
for (OrganisationUnitLevel level : levels) {
String column = quote(PREFIX_ORGUNITLEVEL + level.getLevel());
columns.add(new AnalyticsTableColumn(column, CHARACTER_11, "ous." + column).withCreated(level.getCreated()));
}
columns.addAll(addPeriodTypeColumns("ps"));
String approvalCol = isApprovalEnabled(year) ? "coalesce(des.datasetapprovallevel, aon.approvallevel, da.minlevel, " + APPROVAL_LEVEL_UNAPPROVED + ") as approvallevel " : DataApprovalLevelService.APPROVAL_LEVEL_HIGHEST + " as approvallevel";
columns.add(new AnalyticsTableColumn(quote("approvallevel"), INTEGER, approvalCol));
columns.addAll(getFixedColumns());
return filterDimensionColumns(columns);
}
use of org.hisp.dhis.category.Category in project dhis2-core by dhis2.
the class ExpressionService2Test method setUp.
@BeforeEach
public void setUp() {
target = new DefaultExpressionService(hibernateGenericStore, constantService, dimensionService, idObjectManager, statementBuilder, i18nManager, cacheProvider);
categoryOptionA = new CategoryOption("Under 5");
categoryOptionB = new CategoryOption("Over 5");
categoryOptionC = new CategoryOption("Male");
categoryOptionD = new CategoryOption("Female");
categoryA = new Category("Age", DataDimensionType.DISAGGREGATION);
categoryB = new Category("Gender", DataDimensionType.DISAGGREGATION);
categoryA.getCategoryOptions().add(categoryOptionA);
categoryA.getCategoryOptions().add(categoryOptionB);
categoryB.getCategoryOptions().add(categoryOptionC);
categoryB.getCategoryOptions().add(categoryOptionD);
categoryCombo = new CategoryCombo("Age and gender", DataDimensionType.DISAGGREGATION);
categoryCombo.getCategories().add(categoryA);
categoryCombo.getCategories().add(categoryB);
categoryCombo.generateOptionCombos();
List<CategoryOptionCombo> optionCombos = Lists.newArrayList(categoryCombo.getOptionCombos());
cocA = optionCombos.get(0);
cocA.setUid(CodeGenerator.generateUid());
cocB = optionCombos.get(1);
cocB.setUid(CodeGenerator.generateUid());
deA = createDataElement('A');
deB = createDataElement('B');
deC = createDataElement('C');
deD = createDataElement('D');
deE = createDataElement('E', categoryCombo);
coc = rnd.nextObject(CategoryOptionCombo.class);
coc.setName(DEFAULT_CATEGORY_COMBO_NAME);
optionCombos.add(coc);
opA = new DataElementOperand(deA, coc);
opB = new DataElementOperand(deB, coc);
opC = new DataElementOperand(deC, coc);
opD = new DataElementOperand(deD, coc);
opE = new DataElementOperand(deB, cocA);
opF = new DataElementOperand(deA, cocA, cocB);
period = createPeriod(getDate(2000, 1, 1), getDate(2000, 1, 31));
pteaA = rnd.nextObject(ProgramTrackedEntityAttributeDimensionItem.class);
pdeA = rnd.nextObject(ProgramDataElementDimensionItem.class);
piA = rnd.nextObject(ProgramIndicator.class);
unitA = createOrganisationUnit('A');
unitB = createOrganisationUnit('B');
unitC = createOrganisationUnit('C');
constantA = rnd.nextObject(Constant.class);
constantA.setName("ConstantA");
constantA.setValue(2.0);
constantB = rnd.nextObject(Constant.class);
constantB.setName("ConstantB");
constantB.setValue(5.0);
groupA = createOrganisationUnitGroup('A');
groupA.addOrganisationUnit(unitA);
groupA.addOrganisationUnit(unitB);
groupA.addOrganisationUnit(unitC);
groupB = createOrganisationUnitGroup('B');
groupB.addOrganisationUnit(unitB);
DataSet dataSetA = createDataSet('A');
dataSetA.setUid("a23dataSetA");
dataSetA.addOrganisationUnit(unitA);
reportingRate = new ReportingRate(dataSetA);
expressionA = "#{" + opA.getDimensionItem() + "}+#{" + opB.getDimensionItem() + "}";
expressionB = "#{" + deC.getUid() + SEPARATOR + coc.getUid() + "}-#{" + deD.getUid() + SEPARATOR + coc.getUid() + "}";
expressionC = "#{" + deA.getUid() + SEPARATOR + coc.getUid() + "}+#{" + deE.getUid() + "}-10";
expressionD = "#{" + deA.getUid() + SEPARATOR + coc.getUid() + "}+" + SYMBOL_DAYS;
expressionE = "#{" + deA.getUid() + SEPARATOR + coc.getUid() + "}*C{" + constantA.getUid() + "}";
expressionF = "#{" + deA.getUid() + SEPARATOR + coc.getUid() + "}";
expressionG = expressionF + "+#{" + deB.getUid() + "}-#{" + deC.getUid() + "}";
expressionH = "#{" + deA.getUid() + SEPARATOR + coc.getUid() + "}*OUG{" + groupA.getUid() + "}";
expressionI = "#{" + opA.getDimensionItem() + "}*" + "#{" + deB.getDimensionItem() + "}+" + "C{" + constantA.getUid() + "}+5-" + "D{" + pdeA.getDimensionItem() + "}+" + "A{" + pteaA.getDimensionItem() + "}-10+" + "I{" + piA.getDimensionItem() + "}";
expressionJ = "#{" + opA.getDimensionItem() + "}+#{" + opB.getDimensionItem() + "}";
expressionK = "1.5*avg(" + expressionJ + ")";
expressionL = expressionA + "+avg(" + expressionJ + ")+1.5*stddev(" + expressionJ + ")+" + expressionB;
expressionM = "#{" + deA.getUid() + SEPARATOR + SYMBOL_WILDCARD + "}-#{" + deB.getUid() + SEPARATOR + coc.getUid() + "}";
expressionN = "#{" + deA.getUid() + SEPARATOR + cocA.getUid() + SEPARATOR + cocB.getUid() + "}-#{" + deB.getUid() + SEPARATOR + cocA.getUid() + "}";
expressionO = "#{" + opA.getDimensionItem() + "}+sum(#{" + opB.getDimensionItem() + "})";
expressionP = "#{" + deB.getUid() + SEPARATOR + coc.getUid() + "}";
expressionR = "#{" + deB.getUid() + SEPARATOR + coc.getUid() + "}" + " + R{" + reportingRate.getUid() + ".REPORTING_RATE}";
}
use of org.hisp.dhis.category.Category in project dhis2-core by dhis2.
the class AnalyticsSecurityManagerTest method setUpTest.
@Override
public void setUpTest() {
userService = _userService;
createAndInjectAdminUser();
coA = createCategoryOption('A');
coB = createCategoryOption('B');
coNotReadable = createCategoryOption('N');
categoryService.addCategoryOption(coA);
categoryService.addCategoryOption(coB);
long nonReadableCatOption = categoryService.addCategoryOption(coNotReadable);
coNotReadable = categoryService.getCategoryOption(nonReadableCatOption);
Sharing sharing = Sharing.builder().owner("cannotRead").publicAccess(AccessStringHelper.DEFAULT).build();
coNotReadable.setSharing(sharing);
coNotReadable.setPublicAccess(AccessStringHelper.DEFAULT);
caA = createCategory('A', coA, coB, coNotReadable);
categoryService.addCategory(caA);
Set<Category> catDimensionConstraints = Sets.newHashSet(caA);
deA = createDataElement('A');
dataElementService.addDataElement(deA);
ouA = createOrganisationUnit('A');
ouB = createOrganisationUnit('B', ouA);
ouC = createOrganisationUnit('C', ouB);
ouD = createOrganisationUnit('D', ouC);
ouE = createOrganisationUnit('E', ouC);
ouF = createOrganisationUnit('F', ouA);
organisationUnitService.addOrganisationUnit(ouA);
organisationUnitService.addOrganisationUnit(ouB);
organisationUnitService.addOrganisationUnit(ouC);
organisationUnitService.addOrganisationUnit(ouD);
organisationUnitService.addOrganisationUnit(ouE);
userOrgUnits = Sets.newHashSet(ouB, ouC);
User user = createUser("A", "F_VIEW_EVENT_ANALYTICS");
user.setOrganisationUnits(userOrgUnits);
user.setDataViewOrganisationUnits(userOrgUnits);
user.setDataViewMaxOrganisationUnitLevel(3);
user.setCatDimensionConstraints(catDimensionConstraints);
userService.addUser(user);
injectSecurityContext(user);
}
Aggregations