Esempio n. 1
0
  public ModelList getCategoryOptionCombos(org.hisp.dhis.dataelement.DataElement dataElement) {
    DataElementCategoryCombo categoryCombo = dataElement.getCategoryCombo();

    // Client DataElement
    ModelList deCateOptCombo = new ModelList();
    List<Model> listCateOptCombo = new ArrayList<Model>();
    deCateOptCombo.setModels(listCateOptCombo);

    for (DataElementCategoryOptionCombo oneCatOptCombo : categoryCombo.getSortedOptionCombos()) {
      Model oneCateOptCombo = new Model();
      oneCateOptCombo.setId(oneCatOptCombo.getId());
      oneCateOptCombo.setName(oneCatOptCombo.getName());
      listCateOptCombo.add(oneCateOptCombo);
    }
    return deCateOptCombo;
  }
  @Override
  public String execute() {
    if (dataElementGroupId > 0) {
      DataElementGroup group =
          dataElementService.getDataElementGroup(dataElementGroupId.intValue());

      dataElements = new ArrayList<>(group.getMembers());
    } else {
      dataElements = new ArrayList<>(dataElementService.getAllDataElements());
    }

    Collections.sort(dataElements, new IdentifiableObjectNameComparator());

    for (DataElement dataElement : dataElements) {
      DataElementCategoryCombo categoryCombo = dataElement.getCategoryCombo();

      Set<DataElementCategoryOptionCombo> optionCombos = categoryCombo.getOptionCombos();

      if (optionCombos.size() > 1) {
        for (DataElementCategoryOptionCombo optionCombo : optionCombos) {
          DataElementOperand operand =
              new DataElementOperand(
                  dataElement.getUid(),
                  optionCombo.getUid(),
                  dataElement.getName() + optionCombo.getName());
          operands.add(operand);
        }
      } else {
        DataElementOperand operand =
            new DataElementOperand(
                dataElement.getUid(),
                optionCombos.iterator().next().getUid(),
                dataElement.getName());
        operands.add(operand);
      }
    }

    return SUCCESS;
  }
  @Override
  public String allowDeleteDataElementCategoryCombo(DataElementCategoryCombo categoryCombo) {
    Collection<CaseAggregationCondition> conditions =
        aggregationConditionService.getAllCaseAggregationCondition();

    for (CaseAggregationCondition condition : conditions) {
      if (categoryCombo.getOptionCombos().contains(condition.getOptionCombo())) {
        return ERROR;
      }
    }

    return null;
  }
  @Override
  public String execute() {
    DataElementCategoryCombo categoryCombo =
        dataElementCategoryService.getDataElementCategoryCombo(id);

    DataElementCategoryCombo defaultCategoryCombo =
        dataElementCategoryService.getDataElementCategoryComboByName(
            DataElementCategoryCombo.DEFAULT_CATEGORY_COMBO_NAME);

    if (!categoryCombo.equals(defaultCategoryCombo)) {
      try {
        dataElementCategoryService.deleteDataElementCategoryCombo(categoryCombo);
      } catch (DeleteNotAllowedException ex) {
        if (ex.getErrorCode().equals(DeleteNotAllowedException.ERROR_ASSOCIATED_BY_OTHER_OBJECTS)) {
          message =
              i18n.getString("object_not_deleted_associated_by_objects") + " " + ex.getMessage();
          return ERROR;
        }
      }
    }

    return SUCCESS;
  }
 @Override
 public int compare(DataElementCategoryCombo o1, DataElementCategoryCombo o2) {
   return o1.getOptionCombos().size() - o2.getOptionCombos().size();
 }
  @Override
  public void setUpTest() {
    aggregationService = (AggregationService) getBean(AggregationService.ID);

    categoryService = (DataElementCategoryService) getBean(DataElementCategoryService.ID);

    dataElementService = (DataElementService) getBean(DataElementService.ID);

    indicatorService = (IndicatorService) getBean(IndicatorService.ID);

    dataSetService = (DataSetService) getBean(DataSetService.ID);

    periodService = (PeriodService) getBean(PeriodService.ID);

    organisationUnitService = (OrganisationUnitService) getBean(OrganisationUnitService.ID);

    dataValueService = (DataValueService) getBean(DataValueService.ID);

    expressionService = (ExpressionService) getBean(ExpressionService.ID);

    // ---------------------------------------------------------------------
    // Setup Dimensions
    // ---------------------------------------------------------------------

    categoryOptionA = new DataElementCategoryOption("Male");
    categoryOptionB = new DataElementCategoryOption("Female");

    categoryService.addDataElementCategoryOption(categoryOptionA);
    categoryService.addDataElementCategoryOption(categoryOptionB);

    category = new DataElementCategory("Gender");
    category.getCategoryOptions().add(categoryOptionA);
    category.getCategoryOptions().add(categoryOptionB);

    categoryService.addDataElementCategory(category);

    categoryCombo = new DataElementCategoryCombo("Gender");
    categoryCombo.getCategories().add(category);

    categoryService.addDataElementCategoryCombo(categoryCombo);

    categoryOptionComboA = createCategoryOptionCombo(categoryCombo, categoryOptionA);
    categoryOptionComboB = createCategoryOptionCombo(categoryCombo, categoryOptionB);

    categoryService.addDataElementCategoryOptionCombo(categoryOptionComboA);
    categoryService.addDataElementCategoryOptionCombo(categoryOptionComboB);

    // ---------------------------------------------------------------------
    // Setup DataElements
    // ---------------------------------------------------------------------

    dataElementA =
        createDataElement(
            'A', DataElement.VALUE_TYPE_INT, DataElement.AGGREGATION_OPERATOR_SUM, categoryCombo);
    dataElementB =
        createDataElement(
            'B', DataElement.VALUE_TYPE_BOOL, DataElement.AGGREGATION_OPERATOR_SUM, categoryCombo);
    dataElementC =
        createDataElement(
            'C', DataElement.VALUE_TYPE_INT, DataElement.AGGREGATION_OPERATOR_SUM, categoryCombo);

    dataElementService.addDataElement(dataElementA);
    dataElementService.addDataElement(dataElementB);
    dataElementService.addDataElement(dataElementC);

    // ---------------------------------------------------------------------
    // Setup Indicators
    // ---------------------------------------------------------------------

    indicatorType = createIndicatorType('A');
    indicatorType.setFactor(100);

    indicatorService.addIndicatorType(indicatorType);

    indicatorA = createIndicator('A', indicatorType);
    indicatorA.setNumerator(
        "#{" + dataElementA.getUid() + SEPARATOR + categoryOptionComboA.getUid() + "}+150");
    indicatorA.setDenominator(
        "#{" + dataElementB.getUid() + SEPARATOR + categoryOptionComboA.getUid() + "}");

    indicatorB = createIndicator('B', indicatorType);
    indicatorB.setNumerator("#{" + dataElementC.getUid() + "}");
    indicatorB.setDenominator("1");

    indicatorService.addIndicator(indicatorA);
    indicatorService.addIndicator(indicatorB);

    // ---------------------------------------------------------------------
    // Setup DataSets (to get correct PeriodType for DataElements)
    // ---------------------------------------------------------------------

    dataSet = createDataSet('A', new MonthlyPeriodType());
    dataSet.getDataElements().add(dataElementA);
    dataSet.getDataElements().add(dataElementB);
    dataSetService.addDataSet(dataSet);
    dataElementA.getDataSets().add(dataSet);
    dataElementB.getDataSets().add(dataSet);
    dataElementC.getDataSets().add(dataSet);
    dataElementService.updateDataElement(dataElementA);
    dataElementService.updateDataElement(dataElementB);
    dataElementService.updateDataElement(dataElementC);

    // ---------------------------------------------------------------------
    // Setup Periods
    // ---------------------------------------------------------------------

    PeriodType monthly = new MonthlyPeriodType();

    periodA = createPeriod(monthly, mar01, mar31);
    periodB = createPeriod(monthly, apr01, apr30);
    periodC = createPeriod(monthly, may01, may31);

    periodService.addPeriod(periodA);
    periodService.addPeriod(periodB);
    periodService.addPeriod(periodC);

    // ---------------------------------------------------------------------
    // Setup OrganisationUnits
    // ---------------------------------------------------------------------

    unitA = createOrganisationUnit('A');
    unitB = createOrganisationUnit('B', unitA);
    unitC = createOrganisationUnit('C', unitA);
    unitD = createOrganisationUnit('D', unitB);
    unitE = createOrganisationUnit('E', unitB);
    unitF = createOrganisationUnit('F', unitB);
    unitG = createOrganisationUnit('G', unitF);
    unitH = createOrganisationUnit('H', unitF);
    unitI = createOrganisationUnit('I');

    organisationUnitService.addOrganisationUnit(unitA);
    organisationUnitService.addOrganisationUnit(unitB);
    organisationUnitService.addOrganisationUnit(unitC);
    organisationUnitService.addOrganisationUnit(unitD);
    organisationUnitService.addOrganisationUnit(unitE);
    organisationUnitService.addOrganisationUnit(unitF);
    organisationUnitService.addOrganisationUnit(unitG);
    organisationUnitService.addOrganisationUnit(unitH);
    organisationUnitService.addOrganisationUnit(unitI);

    // ---------------------------------------------------------------------
    // Setup DataValues
    // ---------------------------------------------------------------------

    dataValueService.addDataValue(
        createDataValue(dataElementA, periodA, unitC, "90", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodA, unitD, "10", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodA, unitE, "35", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodA, unitF, "25", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodA, unitG, "20", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodA, unitH, "60", categoryOptionComboA));

    dataValueService.addDataValue(
        createDataValue(dataElementA, periodB, unitC, "70", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodB, unitD, "40", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodB, unitE, "65", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodB, unitF, "55", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodB, unitG, "20", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodB, unitH, "15", categoryOptionComboA));

    dataValueService.addDataValue(
        createDataValue(dataElementA, periodC, unitC, "95", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodC, unitD, "40", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodC, unitE, "45", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodC, unitF, "30", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodC, unitG, "50", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementA, periodC, unitH, "70", categoryOptionComboA));

    dataValueService.addDataValue(
        createDataValue(dataElementB, periodA, unitC, T, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodA, unitD, T, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodA, unitE, F, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodA, unitF, T, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodA, unitG, F, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodA, unitH, T, categoryOptionComboA));

    dataValueService.addDataValue(
        createDataValue(dataElementB, periodB, unitC, T, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodB, unitD, F, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodB, unitE, T, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodB, unitF, T, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodB, unitG, F, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodB, unitH, T, categoryOptionComboA));

    dataValueService.addDataValue(
        createDataValue(dataElementB, periodC, unitC, F, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodC, unitD, T, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodC, unitE, F, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodC, unitF, T, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodC, unitG, T, categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementB, periodC, unitH, T, categoryOptionComboA));

    dataValueService.addDataValue(
        createDataValue(dataElementC, periodA, unitB, "30", categoryOptionComboA));
    dataValueService.addDataValue(
        createDataValue(dataElementC, periodA, unitB, "20", categoryOptionComboB));

    aggregationService.clearCache();
  }
  @Override
  public void setUpTest() {
    // ---------------------------------------------------------------------
    // Services
    // ---------------------------------------------------------------------

    importObjectService = (ImportObjectService) getBean(ImportObjectService.ID);

    batchHandlerFactory = (BatchHandlerFactory) getBean("batchHandlerFactory");

    dataElementService = (DataElementService) getBean(DataElementService.ID);

    categoryService = (DataElementCategoryService) getBean(DataElementCategoryService.ID);

    periodService = (PeriodService) getBean(PeriodService.ID);

    organisationUnitService = (OrganisationUnitService) getBean(OrganisationUnitService.ID);

    dataValueService = (DataValueService) getBean(DataValueService.ID);

    // ---------------------------------------------------------------------
    // CategoryOption
    // ---------------------------------------------------------------------

    categoryOptionA = new DataElementCategoryOption("CategoryOptionA");
    categoryOptionB = new DataElementCategoryOption("CategoryOptionB");
    categoryOptionC = new DataElementCategoryOption("CategoryOptionC");
    categoryOptionD = new DataElementCategoryOption("CategoryOptionD");

    categoryService.addDataElementCategoryOption(categoryOptionA);
    categoryService.addDataElementCategoryOption(categoryOptionB);
    categoryService.addDataElementCategoryOption(categoryOptionC);
    categoryService.addDataElementCategoryOption(categoryOptionD);

    categoryOptionADuplicate = new DataElementCategoryOption("CategoryOptionA");
    categoryOptionBDuplicate = new DataElementCategoryOption("CategoryOptionB");
    categoryOptionCDuplicate = new DataElementCategoryOption("CategoryOptionC");
    categoryOptionDDuplicate = new DataElementCategoryOption("CategoryOptionD");

    categoryOptionADuplicate.setId('A');
    categoryOptionBDuplicate.setId('B');
    categoryOptionCDuplicate.setId('C');
    categoryOptionDDuplicate.setId('D');

    importObjectService.addImportObject(ImportObjectStatus.MATCH, categoryOptionADuplicate, null);
    importObjectService.addImportObject(ImportObjectStatus.MATCH, categoryOptionBDuplicate, null);
    importObjectService.addImportObject(ImportObjectStatus.MATCH, categoryOptionCDuplicate, null);
    importObjectService.addImportObject(ImportObjectStatus.MATCH, categoryOptionDDuplicate, null);

    // ---------------------------------------------------------------------
    // Category
    // ---------------------------------------------------------------------

    categoryA = new DataElementCategory("CategoryA");
    categoryB = new DataElementCategory("CategoryB");

    categoryA.getCategoryOptions().add(categoryOptionA);
    categoryA.getCategoryOptions().add(categoryOptionB);
    categoryB.getCategoryOptions().add(categoryOptionC);
    categoryB.getCategoryOptions().add(categoryOptionD);

    categoryService.addDataElementCategory(categoryA);
    categoryService.addDataElementCategory(categoryB);

    categoryADuplicate = new DataElementCategory("CategoryA");
    categoryBDuplicate = new DataElementCategory("CategoryB");

    categoryADuplicate.setId('A');
    categoryBDuplicate.setId('B');

    importObjectService.addImportObject(ImportObjectStatus.MATCH, categoryADuplicate, null);
    importObjectService.addImportObject(ImportObjectStatus.MATCH, categoryBDuplicate, null);

    // ---------------------------------------------------------------------
    // Category - CategoryOption Association
    // ---------------------------------------------------------------------

    categoryCategoryOptionAssociationA = new GroupMemberAssociation('A', 'A', 1);
    categoryCategoryOptionAssociationB = new GroupMemberAssociation('A', 'B', 2);
    categoryCategoryOptionAssociationC = new GroupMemberAssociation('B', 'C', 1);
    categoryCategoryOptionAssociationD = new GroupMemberAssociation('B', 'D', 2);

    importObjectService.addImportObject(
        ImportObjectStatus.NEW,
        GroupMemberType.CATEGORY_CATEGORYOPTION,
        categoryCategoryOptionAssociationA);
    importObjectService.addImportObject(
        ImportObjectStatus.NEW,
        GroupMemberType.CATEGORY_CATEGORYOPTION,
        categoryCategoryOptionAssociationB);
    importObjectService.addImportObject(
        ImportObjectStatus.NEW,
        GroupMemberType.CATEGORY_CATEGORYOPTION,
        categoryCategoryOptionAssociationC);
    importObjectService.addImportObject(
        ImportObjectStatus.NEW,
        GroupMemberType.CATEGORY_CATEGORYOPTION,
        categoryCategoryOptionAssociationD);

    // ---------------------------------------------------------------------
    // CategoryCombo
    // ---------------------------------------------------------------------

    categoryComboA = new DataElementCategoryCombo("CategoryComboA");
    categoryComboB = new DataElementCategoryCombo("CategoryComboB");

    categoryComboA.getCategories().add(categoryA);
    categoryComboA.getCategories().add(categoryB);
    categoryComboB.getCategories().add(categoryA);

    categoryService.addDataElementCategoryCombo(categoryComboA);
    categoryService.addDataElementCategoryCombo(categoryComboB);

    categoryComboADuplicate = new DataElementCategoryCombo("CategoryComboA");
    categoryComboBDuplicate = new DataElementCategoryCombo("CategoryComboB");

    categoryComboADuplicate.setId('A');
    categoryComboBDuplicate.setId('B');

    importObjectService.addImportObject(ImportObjectStatus.MATCH, categoryComboADuplicate, null);
    importObjectService.addImportObject(ImportObjectStatus.MATCH, categoryComboBDuplicate, null);

    // ---------------------------------------------------------------------
    // CategoryCombo - Category Association
    // ---------------------------------------------------------------------

    categoryComboCategoryAssociationA = new GroupMemberAssociation('A', 'A', 1);
    categoryComboCategoryAssociationB = new GroupMemberAssociation('A', 'B', 2);
    categoryComboCategoryAssociationC = new GroupMemberAssociation('B', 'A', 1);

    importObjectService.addImportObject(
        ImportObjectStatus.NEW,
        GroupMemberType.CATEGORYCOMBO_CATEGORY,
        categoryComboCategoryAssociationA);
    importObjectService.addImportObject(
        ImportObjectStatus.NEW,
        GroupMemberType.CATEGORYCOMBO_CATEGORY,
        categoryComboCategoryAssociationB);
    importObjectService.addImportObject(
        ImportObjectStatus.NEW,
        GroupMemberType.CATEGORYCOMBO_CATEGORY,
        categoryComboCategoryAssociationC);

    // ---------------------------------------------------------------------
    // CategoryOptionCombo
    // ---------------------------------------------------------------------

    categoryOptionComboA = new DataElementCategoryOptionCombo();
    categoryOptionComboB = new DataElementCategoryOptionCombo();
    categoryOptionComboC = new DataElementCategoryOptionCombo();
    categoryOptionComboD = new DataElementCategoryOptionCombo();

    categoryOptionComboA.setCategoryCombo(categoryComboA);
    categoryOptionComboB.setCategoryCombo(categoryComboA);
    categoryOptionComboC.setCategoryCombo(categoryComboB);
    categoryOptionComboD.setCategoryCombo(categoryComboB);

    categoryOptionComboA.getCategoryOptions().add(categoryOptionA);
    categoryOptionComboA.getCategoryOptions().add(categoryOptionC);
    categoryOptionComboB.getCategoryOptions().add(categoryOptionB);
    categoryOptionComboB.getCategoryOptions().add(categoryOptionD);
    categoryOptionComboC.getCategoryOptions().add(categoryOptionA);
    categoryOptionComboD.getCategoryOptions().add(categoryOptionB);

    categoryService.addDataElementCategoryOptionCombo(categoryOptionComboA);
    categoryService.addDataElementCategoryOptionCombo(categoryOptionComboB);
    categoryService.addDataElementCategoryOptionCombo(categoryOptionComboC);
    categoryService.addDataElementCategoryOptionCombo(categoryOptionComboD);

    categoryOptionComboADuplicate = new DataElementCategoryOptionCombo();
    categoryOptionComboBDuplicate = new DataElementCategoryOptionCombo();
    categoryOptionComboCDuplicate = new DataElementCategoryOptionCombo();
    categoryOptionComboDDuplicate = new DataElementCategoryOptionCombo();

    categoryOptionComboADuplicate.setId('A');
    categoryOptionComboBDuplicate.setId('B');
    categoryOptionComboCDuplicate.setId('C');
    categoryOptionComboDDuplicate.setId('D');

    categoryOptionComboADuplicate.setCategoryCombo(categoryComboADuplicate);
    categoryOptionComboBDuplicate.setCategoryCombo(categoryComboADuplicate);
    categoryOptionComboCDuplicate.setCategoryCombo(categoryComboBDuplicate);
    categoryOptionComboDDuplicate.setCategoryCombo(categoryComboBDuplicate);

    categoryOptionComboADuplicate.getCategoryOptions().add(categoryOptionADuplicate);
    categoryOptionComboADuplicate.getCategoryOptions().add(categoryOptionCDuplicate);
    categoryOptionComboBDuplicate.getCategoryOptions().add(categoryOptionBDuplicate);
    categoryOptionComboBDuplicate.getCategoryOptions().add(categoryOptionDDuplicate);
    categoryOptionComboCDuplicate.getCategoryOptions().add(categoryOptionADuplicate);
    categoryOptionComboDDuplicate.getCategoryOptions().add(categoryOptionBDuplicate);

    importObjectService.addImportObject(
        ImportObjectStatus.MATCH, categoryOptionComboADuplicate, null);
    importObjectService.addImportObject(
        ImportObjectStatus.MATCH, categoryOptionComboBDuplicate, null);
    importObjectService.addImportObject(
        ImportObjectStatus.MATCH, categoryOptionComboCDuplicate, null);
    importObjectService.addImportObject(
        ImportObjectStatus.MATCH, categoryOptionComboDDuplicate, null);

    // ---------------------------------------------------------------------
    // DataElement
    // ---------------------------------------------------------------------

    dataElementA = createDataElement('A', categoryComboA);
    dataElementB = createDataElement('B', categoryComboA);
    dataElementC = createDataElement('C', categoryComboA);
    dataElementD = createDataElement('D', categoryComboA);

    dataElementAModified = createDataElement('A', categoryComboADuplicate);
    dataElementBModified = createDataElement('B', categoryComboADuplicate);
    dataElementCModified = createDataElement('C', categoryComboADuplicate);
    dataElementDModified = createDataElement('D', categoryComboADuplicate);

    dataElementAModified.setId('A');
    dataElementBModified.setId('B');
    dataElementCModified.setId('C');
    dataElementDModified.setId('D');

    dataElementAModified.setShortName("ShortNameModifiedA");
    dataElementBModified.setShortName("ShortNameModifiedB");
    dataElementCModified.setShortName("ShortNameModifiedC");
    dataElementDModified.setShortName("ShortNameModifiedD");

    // ---------------------------------------------------------------------
    // DataElementGroup
    // ---------------------------------------------------------------------

    dataElementGroupA = createDataElementGroup('A');
    dataElementGroupB = createDataElementGroup('B');
    dataElementGroupC = createDataElementGroup('C');

    dataElementGroupADuplicate = createDataElementGroup('A');
    dataElementGroupBDuplicate = createDataElementGroup('B');
    dataElementGroupCDuplicate = createDataElementGroup('C');

    dataElementGroupADuplicate.setId('A');
    dataElementGroupBDuplicate.setId('B');
    dataElementGroupCDuplicate.setId('C');

    dataElementGroupAssociationA = new GroupMemberAssociation('A', 'A');
    dataElementGroupAssociationB = new GroupMemberAssociation('A', 'B');
    dataElementGroupAssociationC = new GroupMemberAssociation('A', 'C');
    dataElementGroupAssociationD = new GroupMemberAssociation('A', 'D');
    dataElementGroupAssociationE = new GroupMemberAssociation('B', 'A');
    dataElementGroupAssociationF = new GroupMemberAssociation('B', 'B');
    dataElementGroupAssociationG = new GroupMemberAssociation('B', 'C');
    dataElementGroupAssociationH = new GroupMemberAssociation('B', 'D');
    dataElementGroupAssociationI = new GroupMemberAssociation('C', 'A');
    dataElementGroupAssociationJ = new GroupMemberAssociation('C', 'B');
    dataElementGroupAssociationK = new GroupMemberAssociation('C', 'C');
    dataElementGroupAssociationL = new GroupMemberAssociation('C', 'D');

    // ---------------------------------------------------------------------
    // Period
    // ---------------------------------------------------------------------

    periodTypeA = periodService.getPeriodTypeByName(MonthlyPeriodType.NAME);

    periodA = createPeriod(periodTypeA, getDate(1, 0, 2000), getDate(31, 0, 2000));

    periodADuplicate = createPeriod(periodTypeA, getDate(1, 0, 2000), getDate(31, 0, 2000));

    periodADuplicate.setId('A');

    // ---------------------------------------------------------------------
    // OrganisationUnit
    // ---------------------------------------------------------------------

    organisationUnitA = createOrganisationUnit('A');
    organisationUnitB = createOrganisationUnit('B');
    organisationUnitC = createOrganisationUnit('C');

    organisationUnitAModified = createOrganisationUnit('A');
    organisationUnitBModified = createOrganisationUnit('B');
    organisationUnitCModified = createOrganisationUnit('C');

    organisationUnitAModified.setId('A');
    organisationUnitBModified.setId('B');
    organisationUnitCModified.setId('C');

    organisationUnitAModified.setShortName("ShortNameModifiedA");
    organisationUnitBModified.setShortName("ShortNameModifiedB");
    organisationUnitCModified.setShortName("ShortNameModifiedC");

    // ---------------------------------------------------------------------
    // RelationshipAssociation
    // ---------------------------------------------------------------------

    relationshipAssociationA = new GroupMemberAssociation('A', 'B');
    relationshipAssociationB = new GroupMemberAssociation('B', 'C');

    // ---------------------------------------------------------------------
    // DataValue
    // ---------------------------------------------------------------------

    dataValueA =
        createDataValue(dataElementA, periodA, organisationUnitA, "10", categoryOptionComboA);
    dataValueB =
        createDataValue(dataElementA, periodA, organisationUnitB, "10", categoryOptionComboA);
    dataValueC =
        createDataValue(dataElementA, periodA, organisationUnitC, "10", categoryOptionComboA);
    dataValueD =
        createDataValue(dataElementB, periodA, organisationUnitA, "10", categoryOptionComboA);
    dataValueE =
        createDataValue(dataElementB, periodA, organisationUnitB, "10", categoryOptionComboA);
    dataValueF =
        createDataValue(dataElementB, periodA, organisationUnitC, "10", categoryOptionComboA);
    dataValueG =
        createDataValue(dataElementC, periodA, organisationUnitA, "10", categoryOptionComboA);
    dataValueH =
        createDataValue(dataElementC, periodA, organisationUnitB, "10", categoryOptionComboA);
    dataValueI =
        createDataValue(dataElementC, periodA, organisationUnitC, "10", categoryOptionComboA);

    dataValueADuplicate =
        createDataValue(
            dataElementAModified,
            periodADuplicate,
            organisationUnitAModified,
            "10",
            categoryOptionComboADuplicate);
    dataValueBDuplicate =
        createDataValue(
            dataElementAModified,
            periodADuplicate,
            organisationUnitBModified,
            "10",
            categoryOptionComboADuplicate);
    dataValueCDuplicate =
        createDataValue(
            dataElementAModified,
            periodADuplicate,
            organisationUnitCModified,
            "10",
            categoryOptionComboADuplicate);
    dataValueDDuplicate =
        createDataValue(
            dataElementBModified,
            periodADuplicate,
            organisationUnitAModified,
            "10",
            categoryOptionComboADuplicate);
    dataValueEDuplicate =
        createDataValue(
            dataElementBModified,
            periodADuplicate,
            organisationUnitBModified,
            "10",
            categoryOptionComboADuplicate);
    dataValueFDuplicate =
        createDataValue(
            dataElementBModified,
            periodADuplicate,
            organisationUnitCModified,
            "10",
            categoryOptionComboADuplicate);
    dataValueGDuplicate =
        createDataValue(
            dataElementCModified,
            periodADuplicate,
            organisationUnitAModified,
            "10",
            categoryOptionComboADuplicate);
    dataValueHDuplicate =
        createDataValue(
            dataElementCModified,
            periodADuplicate,
            organisationUnitBModified,
            "10",
            categoryOptionComboADuplicate);
    dataValueIDuplicate =
        createDataValue(
            dataElementCModified,
            periodADuplicate,
            organisationUnitCModified,
            "10",
            categoryOptionComboADuplicate);
  }