=== added file 'dhis-2/dhis-api/src/main/java/org/hisp/dhis/dataelement/CategoryComboMap.java' --- dhis-2/dhis-api/src/main/java/org/hisp/dhis/dataelement/CategoryComboMap.java 1970-01-01 00:00:00 +0000 +++ dhis-2/dhis-api/src/main/java/org/hisp/dhis/dataelement/CategoryComboMap.java 2015-02-03 14:49:54 +0000 @@ -0,0 +1,151 @@ +package org.hisp.dhis.dataelement; + +/* + * Copyright (c) 2004-2015, University of Oslo + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of the HISP project nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import org.hisp.dhis.common.IdentifiableProperty; + +/** + * CategoryComboMap is used to lookup categoryoptioncombos + * by identifiers of the categoryoptions. Identifiers must be trimmed + * of whitespace and be concatenated in the order given by the categories + * property in object of this class. + * + * @author bobj + */ +public class CategoryComboMap { + + private final IdentifiableProperty idScheme; + + private final List categories; + + private DataElementCategoryCombo categoryCombo; + + private HashMap ccMap; + + public List getCategories() { + return categories; + } + + public IdentifiableProperty getIdScheme() { + return idScheme; + } + + public DataElementCategoryCombo getCategoryCombo() { + return categoryCombo; + } + + public class CategoryComboMapException extends Exception { + public CategoryComboMapException(String msg) { super (msg); } + } + + public CategoryComboMap(DataElementCategoryCombo cc, IdentifiableProperty idScheme) + throws CategoryComboMapException + { + this.categoryCombo = cc; + this.idScheme = idScheme; + ccMap = new HashMap<>(); + + categories = categoryCombo.getCategories(); + + Collection optionCombos = categoryCombo.getOptionCombos(); + + for (DataElementCategoryOptionCombo optionCombo : optionCombos) + { + + Collection catopts = optionCombo.getCategoryOptions(); + + String compositeIdentifier =""; + + for (DataElementCategory category : categories) + { + DataElementCategoryOption catopt = category.getCategoryOption(optionCombo); + if (catopt == null) { + throw new CategoryComboMapException( + "No categoryOption in " + category.getName() + " matching " + optionCombo.getName()); + } else + { + String identifier; + + switch (idScheme) { + case UID: + identifier = catopt.getUid().trim(); + break; + case CODE: + identifier = catopt.getCode().trim(); + break; + case NAME: + identifier = catopt.getName().trim(); + break; + default: + throw new CategoryComboMapException("Unsupported ID Scheme: " + idScheme.toString()); + } + + if (identifier == null) + throw new CategoryComboMapException( + "No " + idScheme.toString() + " identifier for CategoryOption: " + catopt.getName()); + + compositeIdentifier += "\"" + identifier + "\""; + } + } + this.ccMap.put(compositeIdentifier, optionCombo); + } + } + + /** + * Look up the categoryoptioncombo based on a composite identifier + * + * @param compositeIdentifier + * @return + */ + public DataElementCategoryOptionCombo getCategoryOptionCombo(String compositeIdentifier) + { + return (DataElementCategoryOptionCombo) ccMap.get(compositeIdentifier); + } + + /** + * Create a composite identifier from a list of identifiers + * + * Note: identifiers must be in same order as list of categories in the map + * + * @param identifiers + * @return + */ + public String getKey (List identifiers) + { + String key = ""; + for (String identifier : identifiers) + { + key += "\"" + identifier + "\""; + } + return key; + } +} === added file 'dhis-2/dhis-api/src/test/java/org/hisp/dhis/dataelement/CategoryComboMapTest.java' --- dhis-2/dhis-api/src/test/java/org/hisp/dhis/dataelement/CategoryComboMapTest.java 1970-01-01 00:00:00 +0000 +++ dhis-2/dhis-api/src/test/java/org/hisp/dhis/dataelement/CategoryComboMapTest.java 2015-02-03 14:49:54 +0000 @@ -0,0 +1,142 @@ +package org.hisp.dhis.dataelement; + +/* + * Copyright (c) 2004-2015, University of Oslo + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of the HISP project nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +import java.util.LinkedList; +import static org.junit.Assert.assertNotNull; + +import java.util.List; +import org.hisp.dhis.common.IdentifiableProperty; +import static org.hisp.dhis.common.IdentifiableProperty.NAME; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +/** + * + * @author bobj + */ +public class CategoryComboMapTest { + private DataElementCategoryOption categoryOptionA; + private DataElementCategoryOption categoryOptionB; + private DataElementCategoryOption categoryOptionC; + private DataElementCategoryOption categoryOptionD; + private DataElementCategoryOption categoryOptionE; + private DataElementCategoryOption categoryOptionF; + + private DataElementCategory categoryA; + private DataElementCategory categoryB; + private DataElementCategory categoryC; + + private DataElementCategoryCombo categoryCombo; + + // ------------------------------------------------------------------------- + // Fixture + // ------------------------------------------------------------------------- + + @Before + public void before() + { + categoryOptionA = new DataElementCategoryOption( "OptionA" ); + categoryOptionB = new DataElementCategoryOption( "OptionB" ); + categoryOptionC = new DataElementCategoryOption( "OptionC" ); + categoryOptionD = new DataElementCategoryOption( "OptionD" ); + categoryOptionE = new DataElementCategoryOption( "OptionE" ); + categoryOptionF = new DataElementCategoryOption( "OptionF" ); + + categoryA = new DataElementCategory( "CategoryA" ); + categoryB = new DataElementCategory( "CategoryB" ); + categoryC = new DataElementCategory( "CategoryC" ); + + categoryA.getCategoryOptions().add( categoryOptionA ); + categoryA.getCategoryOptions().add( categoryOptionB ); + categoryB.getCategoryOptions().add( categoryOptionC ); + categoryB.getCategoryOptions().add( categoryOptionD ); + categoryC.getCategoryOptions().add( categoryOptionE ); + categoryC.getCategoryOptions().add( categoryOptionF ); + + categoryCombo = new DataElementCategoryCombo( "CategoryCombo" ); + + categoryCombo.addDataElementCategory(categoryA); + categoryCombo.addDataElementCategory(categoryB); + categoryCombo.addDataElementCategory(categoryC); + + categoryCombo.generateOptionCombos(); + } + + @Test + public void testMapRetrievalByName() + { + try { + CategoryComboMap map = new CategoryComboMap(categoryCombo, NAME); + + List catopts = new LinkedList<>(); + catopts.add(categoryOptionA); + catopts.add(categoryOptionC); + catopts.add(categoryOptionE); + + String key = "\"" + categoryOptionA.getName() + "\"" + + "\"" + categoryOptionC.getName() + "\"" + + "\"" + categoryOptionE.getName() + "\""; + DataElementCategoryOptionCombo catoptcombo = map.getCategoryOptionCombo(key); + + assertNotNull( catoptcombo ); + assertTrue(catoptcombo.getCategoryOptions().containsAll(catopts)); + } catch (CategoryComboMap.CategoryComboMapException ex) { + System.out.println(ex.getMessage()); + assertTrue(ex.getMessage(),false); + } + } + + @Test + public void testMapRetrievalByUid() + { + try { + CategoryComboMap map = new CategoryComboMap(categoryCombo, IdentifiableProperty.UID); + + List catopts = new LinkedList<>(); + catopts.add(categoryOptionA); + catopts.add(categoryOptionC); + catopts.add(categoryOptionE); + + String key = "\"" + categoryOptionA.getUid() + "\"" + + "\"" + categoryOptionC.getUid() + "\"" + + "\"" + categoryOptionE.getUid() + "\""; + + DataElementCategoryOptionCombo catoptcombo = map.getCategoryOptionCombo(key); + + assertNotNull( catoptcombo ); + assertTrue(catoptcombo.getCategoryOptions().containsAll(catopts)); + } catch (CategoryComboMap.CategoryComboMapException ex) { + System.out.println(ex.getMessage()); + assertTrue(ex.getMessage(),false); + } + } +}