EDIT

/**

* 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.remote.io.application;

import org.apache.log4j.Logger;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;

import eu.etaxonomy.cdm.database.DataSourceNotFoundException;

import eu.etaxonomy.cdm.database.DbSchemaValidation;

import eu.etaxonomy.cdm.database.ICdmDataSource;

import eu.etaxonomy.cdm.io.api.application.CdmIoApplicationController;

import eu.etaxonomy.cdm.persistence.hibernate.HibernateConfiguration;

//for now we need this controller only within test therefore it is only in test modul

public class CdmRemoteApplicationController extends CdmIoApplicationController {

    @SuppressWarnings("unused")

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

	public static final String DEFAULT_APPLICATION_CONTEXT_RESOURCE = "/eu/etaxonomy/cdm/applicationContext-test.xml";

	public static CdmRemoteApplicationController NewRemoteInstance() {

		return CdmRemoteApplicationController.NewRemoteInstance(null, null);

	}

	public static CdmRemoteApplicationController NewRemoteInstance(ICdmDataSource dataSource, DbSchemaValidation dbSchemaValidation) {

	    try {

            dataSource = dataSource == null? getDefaultDatasource() : dataSource;

        } catch (DataSourceNotFoundException e) {

            throw new RuntimeException(e);

        }

	    dbSchemaValidation = dbSchemaValidation == null? defaultDbSchemaValidation : dbSchemaValidation;

	    return CdmRemoteApplicationController.NewRemoteInstance(dataSource, dbSchemaValidation, null, false);

	}

    public static CdmRemoteApplicationController NewRemoteInstance(ICdmDataSource dataSource, DbSchemaValidation dbSchemaValidation,

            HibernateConfiguration hibernateConfig, boolean omitTermLoading) {

        return new CdmRemoteApplicationController(getClasspathResource(),dataSource, dbSchemaValidation,

                hibernateConfig, omitTermLoading, null);

    }

// *************************************** CONSTRUCTOR ***********************************************************/

	protected CdmRemoteApplicationController(Resource applicationContextResource, ICdmDataSource dataSource,

	        DbSchemaValidation dbSchemaValidation, HibernateConfiguration hibernateConfig,

			boolean omitTermLoading, IProgressMonitor progressMonitor) {

		super(applicationContextResource, dataSource, dbSchemaValidation, hibernateConfig,

		        omitTermLoading, progressMonitor);

	}

    protected static ClassPathResource getClasspathResource() {

        return new ClassPathResource(DEFAULT_APPLICATION_CONTEXT_RESOURCE);

    }

}

/**

* 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.io.IOException;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

import org.hibernate.Query;

import org.hibernate.Session;

import org.springframework.transaction.TransactionStatus;

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

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

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

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

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

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

import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;

import eu.etaxonomy.cdm.api.service.description.AggregationMode;

import eu.etaxonomy.cdm.api.service.description.DistributionAggregationConfiguration;

import eu.etaxonomy.cdm.api.service.description.StructuredDescriptionAggregationConfiguration;

import eu.etaxonomy.cdm.api.service.dto.GroupedTaxonDTO;

import eu.etaxonomy.cdm.api.util.TaxonRelationshipEdge;

import eu.etaxonomy.cdm.common.monitor.DefaultProgressMonitor;

import eu.etaxonomy.cdm.config.AccountStore;

import eu.etaxonomy.cdm.database.CdmDataSource;

import eu.etaxonomy.cdm.database.CdmPersistentDataSource;

import eu.etaxonomy.cdm.database.DataSourceNotFoundException;

import eu.etaxonomy.cdm.database.DatabaseTypeEnum;

import eu.etaxonomy.cdm.database.DbSchemaValidation;

import eu.etaxonomy.cdm.database.ICdmDataSource;

import eu.etaxonomy.cdm.filter.TaxonNodeFilter;

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

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

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

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

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

import eu.etaxonomy.cdm.model.location.NamedArea;

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.term.TermTree;

import eu.etaxonomy.cdm.model.term.init.TermNotFoundException;

import eu.etaxonomy.cdm.persistence.dao.initializer.EntityInitStrategy;

import eu.etaxonomy.cdm.remote.controller.MediaPortalController;

import eu.etaxonomy.cdm.remote.controller.TaxonPortalController;

import eu.etaxonomy.cdm.remote.controller.TaxonPortalController.EntityMediaContext;

import eu.etaxonomy.cdm.remote.controller.util.ControllerUtils;

import eu.etaxonomy.cdm.remote.editor.UuidList;

import eu.etaxonomy.cdm.remote.io.application.CdmRemoteApplicationController;

/**

 * @author a.mueller

 * @since 08.11.2021

 */

public class TestScript {

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

	private void testNewConfigControler(){

		DbSchemaValidation schema = DbSchemaValidation.VALIDATE;

		String server;

		String database;

		String username;

		ICdmDataSource dataSource;

//      List<CdmPersistentDataSource> lsDataSources = CdmPersistentDataSource.getAllDataSources();

//     System.out.println(lsDataSources);

//     dataSource = lsDataSources.get(1);

//		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

//		server = "localhost";

//		database = "cdm_bupleurum";

////		database = "cdm_production_edaphobase";

//		username = "edit";

//		dataSource = CdmDataSource.NewMySqlInstance(server, database, username, AccountStore.readOrStorePassword(server, database, username, null));

		server = "160.45.63.171";

		database = "cdm_production_campanulaceae";

		username = "edit";

		dataSource = CdmDataSource.NewMySqlInstance(server, database, username, AccountStore.readOrStorePassword(server, database, username, null));

//		server = "test.e-taxonomy.eu";

//		database = "cdm_rem_conf_am";

//		username = "edit";

//		dataSource = CdmDataSource.NewMySqlInstance(server, database, username, AccountStore.readOrStorePassword(server, database, username, null));

//		String server = "localhost";

//		String database = "testCDM";

//		String username = "postgres";

//		dataSource = CdmDataSource.NewInstance(DatabaseTypeEnum.PostgreSQL, server, database, DatabaseTypeEnum.PostgreSQL.getDefaultPort(), username, AccountStore.readOrStorePassword(server, database, username, null));

//		//SQLServer

//		server = "BGBM-PESISQL";

//		database = "cdm36";

//		int port = 1433;

//		username = "cdmupdater";

//		dataSource = CdmDataSource.NewSqlServer2012Instance(server, database, port, username, AccountStore.readOrStorePassword(server, database, username, null));

//

//		//H2

//        String path = "C:\\Users\\a.mueller\\.cdmLibrary\\writableResources\\h2\\LocalH2";

////		String path = "C:\\Users\\pesiimport\\.cdmLibrary\\writableResources\\h2\\LocalH2";

////      String path = "C:\\Users\\a.mueller\\eclipse\\svn\\cdmlib-trunk\\cdmlib-remote-webapp\\src\\test\\resources\\h2";

//		username = "sa";

//    	dataSource = CdmDataSource.NewH2EmbeddedInstance("cdm", username, "", path);

//    	dataSource = CdmDataSource.NewH2EmbeddedInstance(database, username, "sa");

//       server = "160.45.63.201";

//       database = "cdm_integration_cichorieae";

//       username = "edit";

//       dataSource = CdmDataSource.NewMySqlInstance(server, database, username, AccountStore.readOrStorePassword(server, database, username, null));

		CdmApplicationController appCtr = CdmRemoteApplicationController.NewRemoteInstance(dataSource, schema);

		try {

            doTemporary(appCtr);

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

//		List<UuidAndTitleCache<TaxonBase>> list = appCtr.getTaxonService().getUuidAndTitleCache(null, 10, "Abies alba%");

//		System.out.println(list);

//		appCtr.getOccurrenceService().findRootUnitDTOs(UUID.fromString("2debf5ee-cb57-40bc-af89-173d1d17cefe"));

//		aggregateDDS(appCtr);

//		aggregateDistribution(appCtr);

		appCtr.close();

		System.exit(0);

	}

    private void doTemporary(CdmApplicationController appCtr) throws IOException {

        UUID taxonUUID = UUID.fromString("cdcacbda-11c0-4cb8-a2e0-8d7abc5ae756");

        boolean includeTaxonomicChildren = true;

        UuidList relationshipUuids = new UuidList();

        UuidList relationshipInversUuids = new UuidList();

        boolean includeTaxonDescriptions = true;

        boolean includeOccurrences = true;

        boolean includeTaxonNameDescriptions = true;

        HttpServletResponse response = null;

        TaxonPortalController taxonPortalController = (TaxonPortalController) appCtr.getBean("taxonPortalController");

        ITermService termService = appCtr.getTermService();

        EntityInitStrategy taxonInitStrategy = includeTaxonomicChildren? TaxonPortalController.TAXON_WITH_CHILDNODES_INIT_STRATEGY : TaxonPortalController.TAXON_INIT_STRATEGY;

        EntityMediaContext<Taxon> entityMediaContext = taxonPortalController.loadMediaForTaxonAndRelated(taxonUUID,

                relationshipUuids, relationshipInversUuids,

                includeTaxonDescriptions, includeOccurrences, includeTaxonNameDescriptions,

                response, taxonInitStrategy.getPropertyPaths(),

                MediaPortalController.MEDIA_INIT_STRATEGY.getPropertyPaths());

        if(includeTaxonomicChildren){

            Set<TaxonRelationshipEdge> includeRelationships = ControllerUtils.loadIncludeRelationships(relationshipUuids, relationshipInversUuids, termService);

            entityMediaContext.setMedia(

                    taxonPortalController.addTaxonomicChildrenMedia(includeTaxonDescriptions, includeOccurrences, includeTaxonNameDescriptions, entityMediaContext.getEntity(), includeRelationships, entityMediaContext.getMedia())

                            );

        }

    }

    private void aggregateDistribution(CdmApplicationController app){

        System.out.println("agg distr");

        DefaultProgressMonitor monitor = DefaultProgressMonitor.NewInstance();

        UUID descriptaceaeUuid = UUID.fromString("5a37c47c-347c-49f8-88ba-2720b194dfb9");

        TaxonNodeFilter filter = TaxonNodeFilter.NewSubtreeInstance(descriptaceaeUuid);

        filter.setIncludeUnpublished(true);

        List<AggregationMode> aggregationModes = AggregationMode.byToParent();

        TermTree<PresenceAbsenceTerm> statusOrder = null;

        List<UUID> superAreas = new ArrayList<>();

        DistributionAggregationConfiguration config = DistributionAggregationConfiguration.NewInstance(aggregationModes, superAreas, filter, statusOrder, monitor);

        config.setAdaptBatchSize(false);

        UpdateResult result = config.getTaskInstance().invoke(config, app);

        System.out.println(result);

    }

	private void aggregateDDS(CdmApplicationController app){

	    System.out.println("find dds");

	    DescriptiveDataSet dds = app.getDescriptiveDataSetService().find(21);

	    UUID facciniaSubtreeUuid = UUID.fromString("cf0bc346-a203-4ad7-ad25-477098361db6");

	    UUID arenarioAdamssubtreeUuid = UUID.fromString("0215e668-0a65-42cd-85e0-d97ce78e758b");

	    TaxonNodeFilter filter = TaxonNodeFilter.NewSubtreeInstance(arenarioAdamssubtreeUuid);

	    filter.setIncludeUnpublished(true);

	    DefaultProgressMonitor monitor = DefaultProgressMonitor.NewInstance();

	    StructuredDescriptionAggregationConfiguration config = StructuredDescriptionAggregationConfiguration.NewInstance(filter, monitor);

        config.setDatasetUuid(dds.getUuid());

        config.setAggregationMode(AggregationMode.byWithinTaxonAndToParent());

        config.setAdaptBatchSize(false);

        UpdateResult result = config.getTaskInstance().invoke(config, app);

        System.out.println(result);

//	    app.getLongRunningTasksService().invoke(config);

	}

    private void listClassification(CdmApplicationController appCtr, List<String> propertyPaths) {

        try {

            List<Classification> list = appCtr.getClassificationService().list(null, null, null, null, propertyPaths);

        } catch (Exception e) {

            e.printStackTrace();

            logger.warn(e.getMessage());

        }

    }

    private void testGroupedTaxa(CdmApplicationController appCtr) {

        UUID classificationUuid = UUID.fromString("91231ebf-1c7a-47b9-a56c-b45b33137244");

		UUID taxonUuid1 = UUID.fromString("3bae1c86-1235-4e2e-be63-c7f8c4410527");

		UUID taxonUuid2 = UUID.fromString("235d3872-defe-4b92-bf2f-75a7c91510de");

		List<UUID> taxonUuids = Arrays.asList(new UUID[]{taxonUuid1, taxonUuid2});

		Rank maxRank = DefinedTermBase.getTermByClassAndUUID(Rank.class, UUID.fromString("af5f2481-3192-403f-ae65-7c957a0f02b6"));

		Rank minRank = DefinedTermBase.getTermByClassAndUUID(Rank.class, UUID.fromString("78786e16-2a70-48af-a608-494023b91904"));

        List<GroupedTaxonDTO> groupedTaxa = appCtr.getClassificationService().groupTaxaByHigherTaxon(taxonUuids, classificationUuid, minRank, maxRank);

        System.out.println(groupedTaxa);

    }

    private void addPerson(CdmApplicationController appCtr) {

        TransactionStatus tx = appCtr.startTransaction();

		appCtr.getAgentService().save(Person.NewInstance());

		appCtr.commitTransaction(tx);

    }

	private void deleteHighLevelNode(CdmApplicationController appCtr) {

		TransactionStatus tx = appCtr.startTransaction();

		ITaxonNodeService service = appCtr.getTaxonNodeService();

		TaxonNode node = service.find(60554);

//		service.delete(node);

		ITaxonService taxonService = appCtr.getTaxonService();

		Taxon taxon = node.getTaxon();

		//try {

			taxonService.deleteTaxon(taxon.getUuid(), new TaxonDeletionConfigurator(), node.getClassification().getUuid());

		/*} catch (DataChangeNoRollbackException e) {

			e.printStackTrace();

		}*/

		try {

			appCtr.commitTransaction(tx);

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		TaxonNode node2 = service.find(60554);

	}

//	private void insertSomeData(CdmApplicationController appCtr) {

//		Classification cl = Classification.NewInstance("myClass");

//		TaxonNode node1 = cl.addChildTaxon(Taxon.NewInstance(TaxonNameFactory.NewBotanicalInstance(null), null), null, null);

//		appCtr.getClassificationService().save(cl);

//

//		Taxon t2 = Taxon.NewInstance(null, null);

//		t2.setTitleCache("Taxon2", true);

//		TaxonNode node2 = node1.addChildTaxon(t2, null, null);

//

//		Taxon t3 = Taxon.NewInstance(null, null);

//		t3.setTitleCache("Taxon3", true);

//		TaxonNode node3 = node1.addChildTaxon(t3, 0, null, null);

//

//		appCtr.getTaxonNodeService().saveOrUpdate(node1);

//

//		cl.addChildNode(node3, 0, null, null);

//		appCtr.getTaxonNodeService().saveOrUpdate(node3);

//		appCtr.getClassificationService().saveOrUpdate(cl);

//

//		TermTree<Feature> ft1 = TermTree.NewInstance();

//		FeatureNode fn1 = TermNode.NewInstance((Feature)null);

//		ft1.getRoot().addChild(fn1);

//		appCtr.getFeatureNodeService().save(fn1);

//

//		TermNode fn2 = TermNode.NewInstance((Feature)null);

//		fn1.addChild(fn2);

//

//		TermNode fn3 = TermNode.NewInstance((Feature)null);

//		fn1.addChild(fn2, 0);

//

//		appCtr.getFeatureNodeService().saveOrUpdate(fn1);

//

//		ft1.getRoot().addChild(fn3, 0);

//		appCtr.getFeatureNodeService().saveOrUpdate(fn3);

//		appCtr.getFeatureTreeService().saveOrUpdate(ft1);

//	}

	private void testDatabaseChange() throws DataSourceNotFoundException{

		CdmApplicationController appCtr;

		appCtr = CdmApplicationController.NewInstance();

//		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

//		String server = "192.168.2.10";

//		String database = "cdm_test_andreas";

//		String user = "edit";

//		String pwd = "wp5";

//

		DatabaseTypeEnum dbType = DatabaseTypeEnum.SqlServer2005;

		String server = "LAPTOPHP";

		String database = "cdmTest";

		String username = "edit";

		String password = "";

		ICdmDataSource dataSource = CdmDataSource.NewInstance(DatabaseTypeEnum.SqlServer2005, "LAPTOPHP", "cdmTest", DatabaseTypeEnum.SqlServer2005.getDefaultPort(), "edit", "");

		appCtr.getDatabaseService().saveDataSource("testSqlServer", dataSource);

		try {

			appCtr.getDatabaseService().connectToDatabase(dbType, server, database, username, password);

		} catch (TermNotFoundException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		appCtr.close();

	}

	private void testSqlServer2005(){

		DatabaseTypeEnum databaseTypeEnum = DatabaseTypeEnum.SqlServer2005;

		String server = "LAPTOPHP";

		String database = "cdmTest";

		String username = "edit";

		String password = "";

		ICdmDataSource dataSource = CdmDataSource.NewInstance(databaseTypeEnum, server, database, databaseTypeEnum.getDefaultPort(), username, password);

		CdmPersistentDataSource ds = CdmPersistentDataSource.save("testSqlServer", dataSource);

		CdmApplicationController appCtr = CdmApplicationController.NewInstance(ds);

		Person agent = Person.NewInstance();

		appCtr.getAgentService().save(agent);

		TaxonName tn = TaxonNameFactory.NewBotanicalInstance(null);

		appCtr.getNameService().save(tn);

		appCtr.close();

	}

	private void testLocalHsql(){

		CdmApplicationController appCtr = null;

		try {

			CdmPersistentDataSource ds = CdmPersistentDataSource.NewLocalHsqlInstance();

			appCtr = CdmApplicationController.NewInstance(ds);

			List<?> l = appCtr.getNameService().list(null,5, 1,null,null);

			System.out.println(l);

			//Agent agent = new Agent();

			//appCtr.getAgentService().saveAgent(agent);

			appCtr.close();

		} catch (RuntimeException e) {

			logger.error("Runtime Exception");

			e.printStackTrace();

			if (appCtr != null){

			    appCtr.close();

			}

		} catch (DataSourceNotFoundException e) {

			logger.error("Runtime Exception");

			e.printStackTrace();

		}

	}

	private void testLocalH2(){

		DbSchemaValidation validation = DbSchemaValidation.CREATE;

		ICdmDataSource ds =

			CdmDataSource.NewH2EmbeddedInstance("cdm", "sa", "", null);

//			ds =

//				 CdmPersistentDataSource.NewInstance("localH2");

		CdmApplicationController appCtr = CdmApplicationController.NewInstance(ds, validation);

		boolean exists = appCtr.getUserService().userExists("admin");

		try {

			IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(null);

			String nameCache = "testName";

			name.setNameCache(nameCache);

			name.setTitleCache(nameCache, true);

			Reference ref = ReferenceFactory.newGeneric();

			ref.setTitleCache("mySec", true);

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

			TaxonDescription description = TaxonDescription.NewInstance();

			taxon.addDescription(description);

			NamedArea area1 = appCtr.getTermService().getAreaByTdwgAbbreviation("GER");

			Distribution distribution = Distribution.NewInstance(area1, PresenceAbsenceTerm.PRESENT());

			description.addElement(distribution);

			List<Distribution> distrList = new ArrayList<Distribution>();

			distrList.add(distribution);

			List<NamedArea> areaList = new ArrayList<NamedArea>();

			areaList.add(area1);

		//	distribution.getInDescription().get

			appCtr.getTaxonService().save(taxon);

			System.out.println(taxon.getDescriptions().size());

			TransactionStatus txStatus = appCtr.startTransaction();

			Session session = appCtr.getSessionFactory().getCurrentSession();

			//String hqlQuery = "from DescriptionBase d join d.elements  as e "

//				String hqlQuery = "from Taxon t join t.descriptions  as d "+

//				 " inner join d.elements e on e member of d "

//				+

//				"";//" where e.area = :namedArea " ;

			String hqlQuery = "Select t from Distribution e join e.inDescription d join d.taxon t join t.name n "+

				" WHERE e.area in (:namedArea) AND n.nameCache = :nameCache ";

			Query query = session.createQuery(hqlQuery);

			//query.setEntity("namedArea", area1);

			query.setParameter("nameCache", nameCache);

			query.setParameterList("namedArea", areaList);

			List resultList = query.list();

			//List list = appCtr.getCommonService().getHqlResult(hqlQuery);

			for (Object o:resultList){

				System.out.println(o);

			}

			appCtr.commitTransaction(txStatus);

			//System.out.println(l);

			//Agent agent = new Agent();

			//appCtr.getAgentService().saveAgent(agent);

			appCtr.close();

		} catch (RuntimeException e) {

			logger.error("Runtime Exception");

			e.printStackTrace();

			appCtr.close();

		}

	}

	private boolean testWritableResourceDirectory() throws IOException{

		CdmApplicationUtils.getWritableResourceDir();

		return true;

	}

	private boolean testH2(){

//		testLocalH2();

//		if (true)return true;

		DbSchemaValidation validation = DbSchemaValidation.CREATE;

		ICdmDataSource ds =

			CdmDataSource.NewH2EmbeddedInstance("cdm", "sa", "", null);

			//CdmDataSource.NewH2EmbeddedInstance("cdm", "sa", "");

//		ds =

//			 CdmPersistentDataSource.NewInstance("localH2");

		CdmApplicationController appCtr = CdmApplicationController.NewInstance(ds, validation);

		try {

		    TaxonName botName1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());

			TaxonName botName2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());

			IBotanicalName hybridName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());

			botName1.addRelationshipToName(botName2, NameRelationshipType.ORTHOGRAPHIC_VARIANT(), null, null);

			UUID uuid1 = botName1.getUuid();

			UUID uuid2 = botName2.getUuid();

			try {

				Logger loggerTrace = Logger.getLogger("org.hibernate.type");

				//loggerTrace.setLevel(Level.TRACE);

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

				appCtr.getNameService().save(botName1);

				ResultSet rs = ds.executeQuery("Select count(*) as n FROM NameRelationship");

				rs.next();

				int c = rs.getInt("n");

				System.out.println("Begin :" + c);

				botName1.removeRelationToTaxonName(botName2);

				botName1.setSpecificEpithet("DELETED");

				botName2.addHybridParent(hybridName, HybridRelationshipType.FIRST_PARENT(), null);

				TransactionStatus tx = appCtr.startTransaction();

				appCtr.getNameService().saveOrUpdate(botName2);

				rs = ds.executeQuery("Select count(*) as n FROM NameRelationship");

				rs.next();

				c = rs.getInt("n");

				System.out.println("End: " + c);

				appCtr.commitTransaction(tx);

				appCtr.getNameService().saveOrUpdate(botName1);

				rs = ds.executeQuery("Select count(*) as n FROM NameRelationship");

				rs.next();

				c = rs.getInt("n");

				System.out.println("End: " + c);

			} catch (SQLException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

			//Agent agent = new Agent();

			//appCtr.getAgentService().saveAgent(agent);

			appCtr.close();

			return true;

		} catch (RuntimeException e) {

			logger.error("Runtime Exception");

			e.printStackTrace();

			appCtr.close();

		}

		return false;

	}

	private void test(){

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

		testNewConfigControler();

    	//testDatabaseChange();

		//testSqlServer();

		//CdmUtils.findLibrary(au.com.bytecode.opencsv.CSVReader.class);

		//testPostgreServer();

		//testLocalHsql();

		//testLocalH2();

		//testWritableResourceDirectory();

//		testH2();

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

	}

	public static void  main(String[] args) {

	    TestScript cc = new TestScript();

    	cc.test();

	}

}

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

	xmlns:context="http://www.springframework.org/schema/context"

	xmlns:tx="http://www.springframework.org/schema/tx"

	xsi:schemaLocation="http://www.springframework.org/schema/beans 

    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-4.3.xsd

    http://www.springframework.org/schema/tx 

    http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

<!-- Until now this is mostly a quick and dirty copy of cdmlib-remote-webapp applicationContext.xml to 

   make debugging from commandline possible in cdmlib-remote  -->

  <!-- 

    NOTE: 

    For a detailed overview on the spring MVC and application context configuration and 

    bootstrapping of this web application see: 

    http://dev.e-taxonomy.eu/redmine/projects/edit/wiki/cdmlib-remote-webappConfigurationAndBootstrapping

  -->

  <context:annotation-config />

  <!-- include default application context and customization -->

  <import resource="classpath:/eu/etaxonomy/cdm/defaultApplicationContext.xml" />

  <bean id="persistentTermInitializer" class="eu.etaxonomy.cdm.database.PersistentTermInitializer">

    <property name="omit" value="false" />

  </bean>

  <context:component-scan base-package="eu/etaxonomy/cdm/ext" />

  <import resource="classpath:/eu/etaxonomy/cdm/remote.xml"/>

  <context:component-scan base-package="eu/etaxonomy/cdm/io"/>

  <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

    <property name="properties">

      <props>

        <prop key="eu.etaxonomy.cdm.base.path">${user.home}/.cdmLibrary/</prop>

        <prop key="eu.etaxonomy.cdm.search.index.path">${user.home}/.cdmLibrary/index/</prop>

      </props>

    </property>

  </bean>

  <!-- enable the configuration of transactional behavior based on annotations -->

  <tx:annotation-driven transaction-manager="transactionManager" />

  <!-- import additional beans into the root context -->

<!--   <import resource="applicationContext.views.xml" /> -->

  <!-- import configuration of the datasource bean -->

<!--   <import resource="datasources/configurable.xml" /> -->

  <!-- bootstrap the Web Configuration -->

  <bean class="eu.etaxonomy.cdm.remote.config.MultiWebSecurityConfiguration" />

<!--   <bean class="eu.etaxonomy.cdm.opt.config.LoggingConfigurer" /> -->

<!--   <bean class="eu.etaxonomy.cdm.opt.config.EhCacheDiskStoreConfiguration" /> -->

  <!-- OAI-PMH TODO externalize? -->

  <bean name="taxonOaiPmhController"

    class="eu.etaxonomy.cdm.remote.controller.oaipmh.TaxonOaiPmhController">

    <property name="cachingModel" ref="taxonOaiPmhCacheMapping" />

  </bean>

  <bean name="taxonOaiPmhCacheMapping"

    class="org.springmodules.cache.provider.ehcache.EhCacheCachingModel">

    <property name="cacheName"

      value="eu.etaxonomy.cdm.remote.controller.TaxonOaiPmhController.resumptionToken" />

  </bean>

  <bean id="serializableFactory" class="org.springmodules.cache.serializable.XStreamSerializableFactory" />

  <bean id="cacheProviderFacade" class="org.springmodules.cache.provider.ehcache.EhCacheFacade">

    <!-- 

        the cacheManager is provided by the eu.etaxonomy.cdm.api.config.EhCacheConfiguration

        in cdmlib-services

     -->

    <property name="cacheManager" ref="cacheManager" />

    <property name="serializableFactory" ref="serializableFactory" />

  </bean>

<!--     <context:property-override location="classpath:eu/etaxonomy/cdm/override.properties"/> -->

    <!-- 

        This applicationContext is not a full cdm application context. It only covers the remote components 

        without service and persistence. The cacheManager is usually provided via a Java config class in

        eu/etaxonomy/cdm/service/api/conf which cannot be used in this context. Therefore we are 

        using the EhCacheManagerFactoryBean here to initialize the cacheManager bean.

     -->

<!--     <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"> -->

<!--       <property name="configLocation" value="classpath:/eu/etaxonomy/cdm/remote/ehcache.xml"/> -->

<!--       <property name="shared" value="true"/> -->

<!--     </bean>  -->

    <context:component-scan base-package="eu/etaxonomy/cdm/remote/controller"/> 

</beans>