Examples with CategoryOptionCombo org.hisp.dhis.category.CategoryOptionCombo used on opensource projects

Example 1 with CategoryOptionCombo

use of org.hisp.dhis.category.CategoryOptionCombo 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);
}

Example 2 with CategoryOptionCombo

use of org.hisp.dhis.category.CategoryOptionCombo in project dhis2-core by dhis2.

the class EnrollmentSMSListener method processEvent.

protected List<Object> processEvent(SmsEvent event, User user, ProgramInstance programInstance, IncomingSms sms) {
    Uid stageid = event.getProgramStage();
    Uid aocid = event.getAttributeOptionCombo();
    Uid orgunitid = event.getOrgUnit();
    OrganisationUnit orgUnit = organisationUnitService.getOrganisationUnit(orgunitid.getUid());
    if (orgUnit == null) {
        throw new SMSProcessingException(SmsResponse.INVALID_ORGUNIT.set(orgunitid));
    }
    ProgramStage programStage = programStageService.getProgramStage(stageid.getUid());
    if (programStage == null) {
        throw new SMSProcessingException(SmsResponse.INVALID_STAGE.set(stageid));
    }
    CategoryOptionCombo aoc = categoryService.getCategoryOptionCombo(aocid.getUid());
    if (aoc == null) {
        throw new SMSProcessingException(SmsResponse.INVALID_AOC.set(aocid));
    }
    List<Object> errorUIDs = saveNewEvent(event.getEvent().getUid(), orgUnit, programStage, programInstance, sms, aoc, user, event.getValues(), event.getEventStatus(), event.getEventDate(), event.getDueDate(), event.getCoordinates());
    return errorUIDs;
}

Example 3 with CategoryOptionCombo

use of org.hisp.dhis.category.CategoryOptionCombo in project dhis2-core by dhis2.

the class DataValueSMSListener method markCompleteDataSet.

private boolean markCompleteDataSet(IncomingSms sms, OrganisationUnit orgunit, SMSCommand command, Date date) {
    String sender = sms.getOriginator();
    Period period = null;
    int numberOfEmptyValue = 0;
    for (SMSCode code : command.getCodes()) {
        CategoryOptionCombo optionCombo = dataElementCategoryService.getCategoryOptionCombo(code.getOptionId().getId());
        period = getPeriod(command, date);
        DataValue dv = dataValueService.getDataValue(code.getDataElement(), period, orgunit, optionCombo);
        if (dv == null && !StringUtils.isEmpty(code.getCode())) {
            numberOfEmptyValue++;
        }
    }
    // Check completeness method
    if (command.getCompletenessMethod() == CompletenessMethod.ALL_DATAVALUE) {
        if (numberOfEmptyValue > 0) {
            return false;
        }
    } else if (command.getCompletenessMethod() == CompletenessMethod.AT_LEAST_ONE_DATAVALUE) {
        if (numberOfEmptyValue == command.getCodes().size()) {
            return false;
        }
    } else if (command.getCompletenessMethod() == CompletenessMethod.DO_NOT_MARK_COMPLETE) {
        return false;
    }
    // Go through the complete process
    String storedBy = SmsUtils.getUser(sender, command, Collections.singletonList(getUser(sms))).getUsername();
    if (StringUtils.isBlank(storedBy)) {
        storedBy = "[unknown] from [" + sender + "]";
    }
    // If new values are submitted re-register as complete
    deregisterCompleteDataSet(command.getDataset(), period, orgunit);
    registerCompleteDataSet(command.getDataset(), period, orgunit, storedBy);
    return true;
}

Example 4 with CategoryOptionCombo

use of org.hisp.dhis.category.CategoryOptionCombo in project dhis2-core by dhis2.

the class TrackerEventSMSListener method postProcess.

@Override
protected SmsResponse postProcess(IncomingSms sms, SmsSubmission submission) throws SMSProcessingException {
    TrackerEventSmsSubmission subm = (TrackerEventSmsSubmission) submission;
    Uid ouid = subm.getOrgUnit();
    Uid stageid = subm.getProgramStage();
    Uid enrolmentid = subm.getEnrollment();
    Uid aocid = subm.getAttributeOptionCombo();
    OrganisationUnit orgUnit = organisationUnitService.getOrganisationUnit(ouid.getUid());
    User user = userService.getUser(subm.getUserId().getUid());
    ProgramInstance programInstance = programInstanceService.getProgramInstance(enrolmentid.getUid());
    if (programInstance == null) {
        throw new SMSProcessingException(SmsResponse.INVALID_ENROLL.set(enrolmentid));
    }
    ProgramStage programStage = programStageService.getProgramStage(stageid.getUid());
    if (programStage == null) {
        throw new SMSProcessingException(SmsResponse.INVALID_STAGE.set(stageid));
    }
    CategoryOptionCombo aoc = categoryService.getCategoryOptionCombo(aocid.getUid());
    if (aoc == null) {
        throw new SMSProcessingException(SmsResponse.INVALID_AOC.set(aocid));
    }
    List<Object> errorUIDs = saveNewEvent(subm.getEvent().getUid(), orgUnit, programStage, programInstance, sms, aoc, user, subm.getValues(), subm.getEventStatus(), subm.getEventDate(), subm.getDueDate(), subm.getCoordinates());
    if (!errorUIDs.isEmpty()) {
        return SmsResponse.WARN_DVERR.setList(errorUIDs);
    } else if (subm.getValues() == null || subm.getValues().isEmpty()) {
        // TODO: Should we save the event if there are no data values?
        return SmsResponse.WARN_DVEMPTY;
    }
    return SmsResponse.SUCCESS;
}

Example 5 with CategoryOptionCombo

use of org.hisp.dhis.category.CategoryOptionCombo in project dhis2-core by dhis2.

the class SmsCommandObjectBundleHook method getReferences.

private void getReferences(SMSCommand command) {
    CategoryOptionCombo defaultCoc = categoryService.getDefaultCategoryOptionCombo();
    command.getCodes().stream().filter(SMSCode::hasDataElement).forEach(c -> {
        c.setOptionId(c.getOptionId() == null ? defaultCoc : categoryService.getCategoryOptionCombo(c.getOptionId().getUid()));
        c.setDataElement(dataElementService.getDataElement(c.getDataElement().getUid()));
    });
    command.getCodes().stream().filter(SMSCode::hasTrackedEntityAttribute).forEach(c -> {
        c.setOptionId(c.getOptionId() == null ? defaultCoc : categoryService.getCategoryOptionCombo(c.getOptionId().getUid()));
        c.setTrackedEntityAttribute(trackedEntityAttributeService.getTrackedEntityAttribute(c.getTrackedEntityAttribute().getUid()));
    });
}