Edit

/**

* Copyright (C) 2008 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*/

package eu.etaxonomy.cdm.io.test.function;

import java.util.ArrayList;

import java.util.GregorianCalendar;

import java.util.List;

import org.apache.log4j.Logger;

import org.springframework.transaction.TransactionStatus;

import eu.etaxonomy.cdm.api.application.CdmApplicationController;

import eu.etaxonomy.cdm.common.AccountStore;

import eu.etaxonomy.cdm.database.CdmDataSource;

import eu.etaxonomy.cdm.database.DbSchemaValidation;

import eu.etaxonomy.cdm.database.ICdmDataSource;

import eu.etaxonomy.cdm.io.jaxb.DataSet;

import eu.etaxonomy.cdm.model.agent.AgentBase;

import eu.etaxonomy.cdm.model.agent.Institution;

import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.common.AnnotatableEntity;

import eu.etaxonomy.cdm.model.common.DefinedTermBase;

import eu.etaxonomy.cdm.model.common.TimePeriod;

import eu.etaxonomy.cdm.model.common.VersionableEntity;

import eu.etaxonomy.cdm.model.name.BotanicalName;

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.reference.ReferenceFactory;

import eu.etaxonomy.cdm.model.taxon.Synonym;

import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

/**

 * @author a.babadshanjan

 * @created 28.10.2008

 */

public class TestDatabase {

	private static final String server = "192.168.2.10";

	private static final String username = "edit";

	private static final Logger logger = Logger.getLogger(TestDatabase.class);

	public static ICdmDataSource CDM_DB(String dbname) {

		logger.info("Setting DB " + dbname);

		String password = AccountStore.readOrStorePassword(dbname, server, username, null);

		ICdmDataSource datasource = CdmDataSource.NewMySqlInstance(server, dbname, username, password);

		return datasource;

	}

    public static CdmApplicationController

    		initDb(ICdmDataSource db, DbSchemaValidation dbSchemaValidation, boolean omitTermLoading) {

		logger.info("Initializing database '" + db.getName() + "'");

		CdmApplicationController appCtrInit =

			CdmApplicationController.NewInstance(db, dbSchemaValidation, omitTermLoading);

		return appCtrInit;

    }

	public static void loadTestData(String dbname, CdmApplicationController appCtr) {

		logger.info("Loading test data into " + dbname);

		TransactionStatus txStatus = appCtr.startTransaction();

		DataSet dataSet = buildDataSet();

		appCtr.getTaxonService().save((List)dataSet.getTaxonBases());

		appCtr.commitTransaction(txStatus);

		appCtr.close();

    }

	/**

	 * This method constructs a small sample classification to test JAXB marshaling.

	 * The sample tree contains four taxa. The root taxon has two children taxa, and

	 * there is one "free" taxon without a parent and children.

	 */

	private static DataSet buildDataSet() {

		List<AgentBase> agents = new ArrayList<AgentBase>();

	    List<VersionableEntity> agentData = new ArrayList<VersionableEntity>();

	    //List<TermBase> terms = new ArrayList<TermBase>();

	    List<DefinedTermBase> terms = new ArrayList<DefinedTermBase>();

	    List<Reference> references = new ArrayList<Reference>();

	    List<TaxonNameBase> taxonomicNames = new ArrayList<TaxonNameBase>();

	    List<TaxonBase> taxonBases = new ArrayList<TaxonBase>();

	    List<AnnotatableEntity> homotypicalGroups;

		Reference citRef, sec;

		BotanicalName name1, name2, name21, nameRoot1, nameFree, synName11, synName12, synName2, synNameFree;

		BotanicalName nameRoot2, nameR2_1, nameR2_2;

		Taxon child1, child2, child21, root1T, root2T, freeT;

		Taxon childR2_1, childR2_2;

		Synonym syn11, syn12, syn2, synFree;

		Rank rankSpecies, rankSubspecies, rankGenus;

		// agents

		// - persons, institutions

		Person linne = new Person("Carl", "Linné", "L.");

		GregorianCalendar birth = new GregorianCalendar(1707, 4, 23);

		GregorianCalendar death = new GregorianCalendar(1778, 0, 10);

		TimePeriod period = TimePeriod.NewInstance(birth, death);

		linne.setLifespan(period);

//		Keyword keyword = Keyword.NewInstance("plantarum", "lat", "");

//		linne.addKeyword(keyword);

		Institution institute = Institution.NewInstance();

		agents.add(linne);

		agents.add(institute);

		// agent data

		// - contacts, addresses, memberships

		//Contact contact1 = new Contact();

		//contact1.setEmail("someone@somewhere.org");

		InstitutionalMembership membership = new InstitutionalMembership(institute, linne, period, "Biodiversity", "Head");

		//agentData.add(contact1);

        linne.getInstitutionalMemberships().add(membership);

		// terms

		// - ranks, keywords

		rankSpecies = Rank.SPECIES();

		rankSubspecies = Rank.SUBSPECIES();

		rankGenus = Rank.GENUS();

//		terms.add(keyword);

        // taxonomic names

		nameRoot1 = BotanicalName.NewInstance(rankGenus,"Calendula",null,null,null,linne,null,"p.100", null);

		name1 = BotanicalName.NewInstance(rankSpecies,"Calendula",null,"arvensis",null,linne,null,"p.1", null);

		synName11 = BotanicalName.NewInstance(rankSpecies,"Caltha",null,"arvensis",null,linne,null,"p.11", null);

		synName12 = BotanicalName.NewInstance(rankSpecies,"Calendula",null,"sancta",null,linne,null,"p.12", null);

		name2 = BotanicalName.NewInstance(rankSpecies,"Calendula",null,"lanzae",null,linne,null,"p.2", null);

		synName2 = BotanicalName.NewInstance(rankSpecies,"Calendula",null,"echinata",null,linne,null,"p.2", null);

		name21 = BotanicalName.NewInstance(rankSubspecies,"Calendula",null,"lanzea","something",linne,null,"p.1", null);

		//name211 = BotanicalName.NewInstance(rankSpecies,"Calendula",null,"lanzea",null,linne,null,"p.1", null);

		//name212 = BotanicalName.NewInstance(rankSpecies,"Calendula",null,"lanzea",null,linne,null,"p.1", null);

		nameRoot2 =

			BotanicalName.NewInstance(rankGenus,"Sonchus",null,null,null,linne,null,"p.200", null);

		nameR2_1 = BotanicalName.NewInstance(rankSpecies,"Sonchus",null,"child1",null,linne,null,"p.1", null);

		nameR2_2 = BotanicalName.NewInstance(rankSpecies,"Sonchus",null,"child2",null,linne,null,"p.2", null);

		nameFree = BotanicalName.NewInstance(rankSpecies,"Cichorium",null,"intybus",null,linne,null,"p.200", null);

		synNameFree = BotanicalName.NewInstance(rankSpecies,"Cichorium",null,"balearicum",null,linne,null,"p.2", null);

		taxonomicNames.add(nameRoot1);

		taxonomicNames.add(name1);

		taxonomicNames.add(synName11);

		taxonomicNames.add(synName12);

		taxonomicNames.add(name2);

		taxonomicNames.add(name21);

		taxonomicNames.add(synName2);

		taxonomicNames.add(nameFree);

		taxonomicNames.add(synNameFree);

		taxonomicNames.add(nameRoot2);

        // references

		sec = ReferenceFactory.newBook();

		sec.setAuthorship(linne);

		sec.setTitleCache("Plant Speciation", true);

		references.add(sec);

		citRef = ReferenceFactory.newDatabase();

		citRef.setAuthorship(linne);

		citRef.setTitleCache("BioCASE", true);

		references.add(citRef);

		// taxa

		root1T = Taxon.NewInstance(nameRoot1, sec);

		root2T = Taxon.NewInstance(nameRoot2, sec);

		freeT = Taxon.NewInstance(nameFree, sec);

		child1 = Taxon.NewInstance(name1, sec);

		child2 = Taxon.NewInstance(name2, sec);

		child21 = Taxon.NewInstance(name21, sec);

		childR2_1 = Taxon.NewInstance(nameR2_1, sec);

		childR2_2 = Taxon.NewInstance(nameR2_2, sec);

		// synonyms

		synFree = Synonym.NewInstance(synNameFree, sec);

		syn11 = Synonym.NewInstance(synName11, sec);

		syn12 = Synonym.NewInstance(synName12, sec);

		syn2 = Synonym.NewInstance(synName2, sec);

		child1.addSynonym(syn11, SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF());

		child1.addSynonym(syn12, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());

		child2.addSynonym(syn2, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());

		freeT.addSynonym(synFree, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());

		taxonBases.add(synFree);

		taxonBases.add(syn11);

		taxonBases.add(syn12);

		taxonBases.add(syn2);

		// taxonomic children

		root1T.addTaxonomicChild(child1, sec, "p.1010");

		root1T.addTaxonomicChild(child2, sec, "p.1020");

		child2.addTaxonomicChild(child21, sec, "p.2000");

		root2T.addTaxonomicChild(child1, sec, "p.1010");

		root2T.addTaxonomicChild(child2, sec, "p.1020");

		taxonBases.add(root1T);

		taxonBases.add(root2T);

		taxonBases.add(freeT);

		taxonBases.add(child1);

		taxonBases.add(child2);

		taxonBases.add(child21);

		taxonBases.add(childR2_1);

		taxonBases.add(childR2_2);

		DataSet dataSet = new DataSet();

		dataSet.setAgents(agents);

//		dataSet.setAgentData(agentData);

		dataSet.setTerms(terms);

		dataSet.setReferences(references);

		dataSet.setTaxonomicNames(taxonomicNames);

		dataSet.setTaxonBases((List)taxonBases);

		return dataSet;

	}

}

/* just for testing */

/**

* Copyright (C) 2009 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.test.function;

import java.util.UUID;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.aspectj.PropertyChangeTest;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.common.Language;

import eu.etaxonomy.cdm.model.description.TaxonDescription;

import eu.etaxonomy.cdm.model.name.BotanicalName;

import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;

import eu.etaxonomy.cdm.model.name.NonViralName;

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

import eu.etaxonomy.cdm.model.name.ZoologicalName;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.reference.ReferenceFactory;

import eu.etaxonomy.cdm.model.taxon.Synonym;

import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;

import eu.etaxonomy.cdm.model.taxon.Taxon;

public class TestModel {

	private static final UUID TEST_TAXON_UUID = UUID.fromString("b3084573-343d-4279-ba92-4ab01bb47db5");

	static Logger logger = Logger.getLogger(TestModel.class);

	public void testSomething(){

		logger.info("Create name objects...");

		logger.info(NomenclaturalStatusType.NUDUM().getRepresentation(Language.LATIN()).getAbbreviatedLabel());

		NonViralName<?> tn = NonViralName.NewInstance(Rank.SPECIES());

		BotanicalName tn3 = BotanicalName.NewInstance(Rank.SUBSPECIES());

		ZoologicalName parentName = ZoologicalName.NewInstance(Rank.FAMILY());

		logger.info("Create reference objects...");

		Reference sec = ReferenceFactory.newJournal();

		sec.setTitleCache("TestJournal", true);

		logger.info("Create taxon objects...");

		Taxon childTaxon = Taxon.NewInstance(tn, sec);

		Synonym syn = Synonym.NewInstance(tn3, sec);

		childTaxon.addSynonym(syn, SynonymRelationshipType.SYNONYM_OF());

		Taxon parentTaxon = Taxon.NewInstance(parentName, sec);

		parentTaxon.setUuid(TEST_TAXON_UUID);

		parentTaxon.addTaxonomicChild(childTaxon, sec, null);

		// setup listeners

		PropertyChangeTest listener = new PropertyChangeTest();

		tn.addPropertyChangeListener(listener);

		tn3.addPropertyChangeListener(listener);

		// test listeners

		tn.setGenusOrUninomial("tn1-Genus1");

		tn3.setGenusOrUninomial("tn3-genus");

		tn3.getGenusOrUninomial();

		logger.info("Create new Author agent...");

		Person team= Person.NewInstance();

		team.addPropertyChangeListener(listener);

		team.setTitleCache("AuthorAgent1", true);

		tn.setCombinationAuthorship(team);

	}

	public void testParentRelation(){

		TaxonNameBase<?,?> taxonName = BotanicalName.NewInstance(Rank.SPECIES());

		Reference ref = ReferenceFactory.newJournal();

		Taxon parent = Taxon.NewInstance(taxonName, ref);

		Taxon child = Taxon.NewInstance(taxonName, null);

		parent.addTaxonomicChild(child, null, null);

		if (child.getTaxonomicParent() != parent){

			logger.warn("Error");

		}

	}

	public void testDescription(){

		Reference ref = ReferenceFactory.newJournal();

		Taxon taxon = Taxon.NewInstance(null, ref);

		TaxonDescription desc = TaxonDescription.NewInstance();

		taxon.addDescription(desc);

		taxon.removeDescription(desc);

	}

	public void testTDWG(){

//		NamedArea tdwgArea = TdwgArea.getAreaByTdwgAbbreviation("GER");

//		NamedArea tdwgArea2 = TdwgArea.getAreaByTdwgLabel("Qatar");

//		System.out.println(tdwgArea.getLabel());

//		System.out.println(tdwgArea2.getRepresentation(Language.DEFAULT()).getAbbreviatedLabel());

	}

	private void test(){

		System.out.println("Start ...");

		TestModel sc = new TestModel();

		//sc.testSomething();

		//sc.testParentRelation();

		//sc.testDescription();

		sc.testTDWG();

		System.out.println("\nEnd ...");

	}

	/**

	 * @param args

	 */

	public static void  main(String[] args) {

		TestModel sc = new TestModel();

		sc.test();

	}

}

/* just for testing */

/**

* Copyright (C) 2009 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.test.function;

import java.util.UUID;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.name.BotanicalName;

import eu.etaxonomy.cdm.model.name.NonViralName;

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.name.ZoologicalName;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.reference.ReferenceFactory;

import eu.etaxonomy.cdm.model.taxon.Synonym;

import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;

import eu.etaxonomy.cdm.model.taxon.Taxon;

public class TestPersistence {

	private static final UUID TEST_TAXON_UUID = UUID.fromString("b3084573-343d-4279-ba92-4ab01bb47db5");

	static Logger logger = Logger.getLogger(TestPersistence.class);

	public void testAppController(){

		logger.info("Create name objects...");

		NonViralName<?> tn = NonViralName.NewInstance(Rank.SPECIES());

		BotanicalName tn3 = BotanicalName.NewInstance(Rank.SUBSPECIES());

		ZoologicalName parentName = ZoologicalName.NewInstance(Rank.FAMILY());

		logger.info("Create reference objects...");

		Reference sec = ReferenceFactory.newJournal();

		sec.setTitleCache("TestJournal", true);

		logger.info("Create taxon objects...");

		Taxon childTaxon = Taxon.NewInstance(tn, sec);

		Synonym syn = Synonym.NewInstance(tn3, sec);

		childTaxon.addSynonym(syn, SynonymRelationshipType.SYNONYM_OF());

		Taxon parentTaxon = Taxon.NewInstance(parentName, sec);

		parentTaxon.setUuid(TEST_TAXON_UUID);

		parentTaxon.addTaxonomicChild(childTaxon, sec, null);

		// test

		tn.setGenusOrUninomial("tn1-Genus1");

		tn3.setGenusOrUninomial("tn3-genus");

		logger.info("Create new Author agent...");

		Person team= Person.NewInstance();

		team.setTitleCache("AuthorAgent1", true);

		tn.setCombinationAuthorship(team);

		logger.info("Save objects ...");

//		appCtr.getTaxonService().saveTaxon(parentTaxon);

//

//		// load Name list

//		logger.info("Load existing names from db...");

//		List<TaxonNameBase> tnList = appCtr.getNameService().getAllNames(1000, 0);

//		for (TaxonNameBase tn2: tnList){

//			logger.info("Title: "+ tn2.getTitleCache() + " UUID: " + tn2.getUuid()+";");

//		}

//

//		// load Name list

//		logger.info("Load taxon from db...");

//		Taxon taxon = (Taxon)appCtr.getTaxonService().getTaxonByUuid(parentTaxon.getUuid());

//		logger.info("Parent: "+ taxon.toString());

//		for (Taxon child: taxon.getTaxonomicChildren()){

//			logger.info("Child: "+ child.toString());

//			for (Synonym synonym: child.getSynonyms()){

//				logger.info("Synonym: "+ synonym.toString());

//			}

//		}

//

//		// close

//		appCtr.close();

	}

	private void test(){

		System.out.println("Start ...");

		TestPersistence sc = new TestPersistence();

    	sc.testAppController();

    	System.out.println("\nEnd ...");

	}

	/**

	 * @param args

	 */

	public static void  main(String[] args) {

		TestPersistence sc = new TestPersistence();

    	sc.test();

	}

}

/**

* Copyright (C) 2009 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.test.function;

import java.util.List;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.junit.Ignore;

import eu.etaxonomy.cdm.api.application.CdmApplicationController;

import eu.etaxonomy.cdm.database.CdmPersistentDataSource;

import eu.etaxonomy.cdm.database.DataSourceNotFoundException;

import eu.etaxonomy.cdm.database.DbSchemaValidation;

import eu.etaxonomy.cdm.model.name.BotanicalName;

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.reference.ReferenceFactory;

import eu.etaxonomy.cdm.model.taxon.Synonym;

import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.persistence.fetch.CdmFetch;

import eu.etaxonomy.cdm.strategy.parser.INonViralNameParser;

import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;

/**

 * <h2>NOTE</h2>

 * This is a test for sole development purposes, it is not

 * touched by mvn test since it is not matching the "\/**\/*Test" pattern,

 * but it should be annotate with @Ignore when running the project a s junit suite in eclipse

 *

 */

@Ignore

public class TestTaxonFunction {

	private static final Logger logger = Logger.getLogger(TestTaxonFunction.class);

	private CdmApplicationController getCdmApplicationController(String strDataSource, DbSchemaValidation hbm2dll){

		CdmApplicationController cdmApp= null;

		try {

			CdmPersistentDataSource dataSource = CdmPersistentDataSource.NewInstance(strDataSource);

			cdmApp = CdmApplicationController.NewInstance(dataSource, hbm2dll);

		} catch (DataSourceNotFoundException e) {

			e.printStackTrace();

		}

		return cdmApp;

	}

	private UUID getRefUuid(){

		return UUID.fromString("5d5363e2-f560-4da2-857d-dfa344b9f5ae");

	}

	private void initDatabase(){

		logger.info("init Database start ...");

		DbSchemaValidation hbm2dll = DbSchemaValidation.CREATE;

		CdmApplicationController cdmApp = getCdmApplicationController("defaultMySql", hbm2dll);

		INonViralNameParser<?> parser = NonViralNameParserImpl.NewInstance();

		Reference sec = ReferenceFactory.newBook();

		sec.setTitleCache("ConceptRef", true);

		//root

		String rootName = "Hieracium L.";

		TaxonNameBase<?,?> botanicalName= parser.parseFullName(rootName);

		sec.setUuid(getRefUuid());

		Taxon genusTaxon = Taxon.NewInstance(botanicalName, sec);

		//child1

		String child1Name = "Hieracium asturianum Pau";

		TaxonNameBase<?,?> botSpecies= parser.parseFullName(child1Name);

		Taxon childTaxon = Taxon.NewInstance(botSpecies, sec);

		childTaxon.setTaxonomicParent(genusTaxon, null, null);

		//child2

		String child2Name = "Hieracium wolffii Zahn";

		TaxonNameBase<?,?> botSpecies2= parser.parseFullName(child2Name);

		Taxon childTaxon2 = Taxon.NewInstance(botSpecies2, sec);

		childTaxon2.setTaxonomicParent(childTaxon, null, null);

		//synonym

		String synonymName = "Acacium wolffii Syn.";

		TaxonNameBase<?,?> botSynName= parser.parseFullName(synonymName);

		Synonym synTaxon = Synonym.NewInstance(botSynName, sec);

		childTaxon2.addSynonym(synTaxon, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());

		//save

		cdmApp.getTaxonService().save(genusTaxon);

		//other taxon

		BotanicalName otherName = BotanicalName.NewInstance(Rank.GENUS());

		otherName.setTitleCache("otherName", true);

		Taxon otherTaxon = Taxon.NewInstance(otherName, sec);

		cdmApp.getTaxonService().save(otherTaxon);

		cdmApp.close();

		logger.info("init Database end ...");

	}

	private boolean testHasTaxonomicChild(){

		logger.info("testHasTaxonomicChild start ...");

		if (false){

			initDatabase();

		}

		CdmApplicationController cdmApp = getCdmApplicationController("defaultMySql", DbSchemaValidation.VALIDATE);

		Reference sec = cdmApp.getReferenceService().find(getRefUuid());

		List<Taxon> rootList = cdmApp.getTaxonService().getRootTaxa(sec, CdmFetch.NO_FETCH(), false);

		for (Taxon taxon:rootList){

			System.out.println(taxon);

			//taxon.getT

			taxon.hasTaxonomicChildren();

			Taxon child = taxon.getTaxonomicChildren().iterator().next();

			logger.warn("Child has children: " + child.hasTaxonomicChildren());

			Taxon child2 = child.getTaxonomicChildren().iterator().next();

			logger.warn("Child2 has children: " + child2.hasTaxonomicChildren());

			logger.warn("Child2 has synonym: " + child2.hasSynonyms());

			Synonym syn = child2.getSynonyms().iterator().next();

			logger.warn("Syn has reference: " + syn.getSec());

		}

		logger.info("testHasTaxonomicChild end . ..");

		return true;

	}

	/**

	 * @param args

	 */

	public static void main(String[] args) {

		TestTaxonFunction testClass = new TestTaxonFunction();

		testClass.testHasTaxonomicChild();

		System.out.println("End");

	}

}

/**

* Copyright (C) 2009 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.test.integration;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.fail;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.joda.time.DateTime;

import org.junit.After;

import org.junit.AfterClass;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Ignore;

import org.junit.Test;

import eu.etaxonomy.cdm.api.application.CdmApplicationController;

import eu.etaxonomy.cdm.api.service.ITaxonService;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.database.CdmDataSource;

import eu.etaxonomy.cdm.database.DbSchemaValidation;

import eu.etaxonomy.cdm.database.ICdmDataSource;

import eu.etaxonomy.cdm.model.common.Language;

import eu.etaxonomy.cdm.model.description.CommonTaxonName;

import eu.etaxonomy.cdm.model.description.DescriptionElementBase;

import eu.etaxonomy.cdm.model.description.TaxonDescription;

import eu.etaxonomy.cdm.model.description.TextData;

import eu.etaxonomy.cdm.model.name.BotanicalName;

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

public class CreateDataTest {

	private static Logger logger = Logger.getLogger(CreateDataTest.class);

	private static boolean isCreated;

	private CdmApplicationController app;

	public static final String genusUuid = "c399e245-3def-427d-8502-afa0ae87e875";

	public static final String genusNameUuid = "d399e245-3def-427d-8502-afa0ae87e875";

	private static boolean ignore = true;

	@BeforeClass

	public static void setUpBeforeClass() throws Exception {

		if (ignore){

			logger.warn("\nCreateDataTest ignored !\n");

			return;

		}

		logger.info("setUpBeforeClass");

		isCreated = false;

	}

	@AfterClass

	public static void tearDownAfterClass() throws Exception {

	}

	@Before

	public void setUp() throws Exception {

		if (ignore){return;}

		DbSchemaValidation dbSchemaValidation = DbSchemaValidation.VALIDATE;

		if (isCreated == false){

			 dbSchemaValidation = DbSchemaValidation.CREATE;

		}

		ICdmDataSource dataSource = cdm_test();

		app  = CdmApplicationController.NewInstance(dataSource, dbSchemaValidation);

	}

	@After

	public void tearDown() throws Exception {

		if (ignore){return;}

		isCreated = true;

		app.close();

	}

	//just temporarly

	public static ICdmDataSource cdm_test(){

		//DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "192.168.2.10";

		String cdmDB = "cdm_test_andreasM";

		String cdmUserName = "edit";

		return makeDestination(cdmServer, cdmDB, -1, cdmUserName, null);

	}

	//just temporarly

	public static ICdmDataSource paddie(){

//		DatabaseTypeEnum dbType = DatabaseTypeEnum.SqlServer2005;

		String cdmServer = "PADDIE";

		String cdmDB = "edit_test";

		String cdmUserName = "andreas";

		return makeDestination(cdmServer, cdmDB, -1, cdmUserName, null);

	}

	/**

	 * initializes source

	 * @return true, if connection establisehd

	 */

	private static ICdmDataSource makeDestination(String cdmServer, String cdmDB, int port, String cdmUserName, String pwd ){

		//establish connection

		try {

			if (pwd == null){

				pwd = CdmUtils.readInputLine("Please insert password for " + CdmUtils.Nz(cdmUserName) + ": ");

			}

			//TODO not MySQL

			ICdmDataSource destination = CdmDataSource.NewMySqlInstance(cdmServer, cdmDB, port, cdmUserName, pwd, null);

			//ICdmDataSource destination = CdmDataSource.NewSqlServer2005Instance(cdmServer, cdmDB, cdmUserName, pwd);

			return destination;

		} catch (Exception e) {

			logger.error(e);

			return null;

		}

	}

/* ********************* TESTS *********************************/

	@Ignore

	@Test

	public void testCreateTaxon(){

		if (ignore){return;}

		//Taxon with childs, basionym, childrens synonyms, child misapplied Name

		Taxon genusTaxon = eu.etaxonomy.cdm.datagenerator.TaxonGenerator.getTestTaxon();

		genusTaxon.setUuid(UUID.fromString(genusUuid));

		genusTaxon.getName().setUuid(UUID.fromString(genusNameUuid));

//		Synonym syn2 = Synonym.NewInstance(genusTaxon.getName(), null);

		app.getTaxonService().save(genusTaxon);

		//app.getTaxonService().saveTaxon(syn2);

	}

	@Test

	public void testLoadTaxon(){

		if (ignore){return;}

		//Taxon with childs, basionym, childrens synonyms, child misapplied Name

		TaxonNameBase<?,?> genusName2 = app.getNameService().find(UUID.fromString(genusNameUuid));

		Set<TaxonBase> set = genusName2.getTaxonBases();

		System.out.println("Size:" + set.size());

		for (TaxonBase tb : set){

			System.out.println(tb.getName());

		}

		//taxon

		Taxon genusTaxon = (Taxon)app.getTaxonService().find(UUID.fromString(genusUuid));

		assertNotNull(genusTaxon);

		//name

		BotanicalName genusName = (BotanicalName)genusTaxon.getName();

		assertNotNull(genusName);

		Set<TaxonBase> taxaSet = genusName.getTaxonBases();

		for (TaxonBase tb : taxaSet){

			System.out.println(tb.getName());

		}

		//taxonBases of Name

		Set<TaxonBase> taxonBases = genusName.getTaxonBases();

		logger.warn(taxonBases.size());

		Set<Taxon> children = genusTaxon.getTaxonomicChildren();

		for (Taxon child : children){

			child.getSynonyms();

			child.getMisappliedNames();

			child.getHomotypicGroup();

			child.getHomotypicSynonymsByHomotypicGroup();

			child.getHomotypicSynonymsByHomotypicRelationship();

		}

		Set<TaxonDescription> descriptions = genusTaxon.getDescriptions();

		assertEquals(1, descriptions.size());

		TaxonDescription firstDescription = descriptions.iterator().next();

		Set<DescriptionElementBase> descriptionElements = firstDescription.getElements();

		//assertEquals(2, descriptions.size());

		Language language = Language.DEFAULT();

		for (DescriptionElementBase descriptionElement : descriptionElements){

			if (descriptionElement instanceof TextData){

				TextData textData = (TextData)descriptionElement;

				textData.getText(language);

				System.out.println(textData);

			}else if(descriptionElement instanceof CommonTaxonName){

				CommonTaxonName commonTaxonName = (CommonTaxonName)descriptionElement;

				commonTaxonName.getName();

				commonTaxonName.getLanguage();

				System.out.println(commonTaxonName);

			}else{

				fail();

			}

		}

	}

	@Ignore

	@Test

	public void testSave(){

		if (ignore){return;}

		logger.warn("testSave");

		ITaxonService taxonService = app.getTaxonService();

		Taxon genusTaxon = (Taxon)taxonService.find(UUID.fromString(genusUuid));

		BotanicalName genusName = (BotanicalName)genusTaxon.getName();

		genusName.setGenusOrUninomial("newGenusUninomial");

		genusName.setUpdated(new DateTime());

		BotanicalName newName = BotanicalName.NewInstance(Rank.SPECIES());

		Taxon newTaxon = Taxon.NewInstance(newName, genusTaxon.getSec());

		genusTaxon.addTaxonomicChild(newTaxon, null, "5677");

		UUID uuid = taxonService.save(newTaxon).getUuid();

		assertNotNull(uuid);

	}

}

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy 

* http://www.e-taxonomy.eu

* 

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.test.integration;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.fail;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.api.application.CdmApplicationController;

import eu.etaxonomy.cdm.database.DbSchemaValidation;

import eu.etaxonomy.cdm.database.ICdmDataSource;

import eu.etaxonomy.cdm.model.common.Language;

import eu.etaxonomy.cdm.model.description.CommonTaxonName;

import eu.etaxonomy.cdm.model.description.DescriptionElementBase;

import eu.etaxonomy.cdm.model.description.TaxonDescription;

import eu.etaxonomy.cdm.model.description.TextData;

import eu.etaxonomy.cdm.model.name.BotanicalName;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

/**

 * @author a.mueller

 * @created 28.05.2008

 * @version 1.0

 */

public class CreateDataTestNoUnit {

	private static Logger logger = Logger.getLogger(CreateDataTestNoUnit.class);

	private CdmApplicationController app;

	public void test(){

		boolean isCreated = true;

		DbSchemaValidation dbSchemaValidation = DbSchemaValidation.VALIDATE;

		if (isCreated == false){

			 dbSchemaValidation = DbSchemaValidation.CREATE;

		}

		ICdmDataSource dataSource = CreateDataTest.cdm_test();

		app  = CdmApplicationController.NewInstance(dataSource, dbSchemaValidation);

		TaxonNameBase<?,?> genusName2 = (TaxonNameBase<?,?>)app.getNameService().find(UUID.fromString(CreateDataTest.genusNameUuid));

		Set<TaxonBase> set = (Set<TaxonBase>)genusName2.getTaxonBases();

		System.out.println("Size:" + set.size());

		for (TaxonBase tb : set){

			System.out.println(tb.getName());

		}

		//taxon

		Taxon genusTaxon = (Taxon)app.getTaxonService().find(UUID.fromString(CreateDataTest.genusUuid));

		assertNotNull(genusTaxon);

		//name

		BotanicalName genusName = (BotanicalName)genusTaxon.getName();

		assertNotNull(genusName);

		Set<TaxonBase> taxaSet = genusName.getTaxonBases();

		for (TaxonBase tb : taxaSet){

			System.out.println(tb.getName());

		}

		//taxonBases of Name

		Set<TaxonBase> taxonBases = genusName.getTaxonBases();

		logger.warn(taxonBases.size());

		Set<Taxon> children = genusTaxon.getTaxonomicChildren();

		for (Taxon child : children){

			child.getSynonyms();

			child.getMisappliedNames();

			child.getHomotypicGroup();

			child.getHomotypicSynonymsByHomotypicGroup();

			child.getHomotypicSynonymsByHomotypicRelationship();

		}

		Set<TaxonDescription> descriptions = genusTaxon.getDescriptions();

		assertEquals(2, descriptions.size());

		TaxonDescription description = descriptions.iterator().next();

		Set<DescriptionElementBase> descriptionElements = description.getElements();

		Language language = Language.DEFAULT(); 

		for (DescriptionElementBase descriptionElement : descriptionElements){

			if (descriptionElement instanceof TextData){

				TextData textData = (TextData)descriptionElement;

				textData.getText(language);

			}else if(descriptionElement instanceof CommonTaxonName){

				CommonTaxonName commonTaxonName = (CommonTaxonName)descriptionElement;

				commonTaxonName.getName();

				commonTaxonName.getLanguage();

			}else{

				fail();

			}

		}

	}

	/**

	 * @param args

	 */

	public static void main(String[] args) {

		CreateDataTestNoUnit test = new CreateDataTestNoUnit();

		test.test();

	}

}