EDIT

/**

* Copyright (C) 2007 EDIT

* 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.

*/

	public static ICdmDataSource cdm_test_local_mysql(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "127.0.0.1";

		String cdmUserName = "root";

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

	}

	public static ICdmDataSource cdm_test_local_faunaEu_mysql(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "127.0.0.1";

		String cdmUserName = "root";

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

	}

	public static ICdmDataSource cdm_test_local_indexFungorum(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "127.0.0.1";

		String cdmUserName = "root";

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

	}

	public static ICdmDataSource cdm_test_local_mysql_erms(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "127.0.0.1";

		String cdmUserName = "root";

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

	}

	public static ICdmDataSource cdm_test_local_mysql_erms2(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "127.0.0.1";

		String cdmUserName = "root";

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

	}

	public static ICdmDataSource cdm_test_local_mysql_test(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "127.0.0.1";

		String cdmUserName = "edit";

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

	}

		String cdmUserName = "edit";

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

	}

	public static ICdmDataSource cdm_portal_test_localhost2(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "127.0.0.1";

		String cdmUserName = "edit";

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

	}

	public static ICdmDataSource NULL(){

		return null;

	}

	public static ICdmDataSource localH2(){

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

	}

	public static ICdmDataSource localH2(String database, String username, String filePath){

		return CdmDataSource.NewH2EmbeddedInstance(database, "sa", "", filePath, null);

	}

	public static ICdmDataSource localH2EuroMed(){

		return CdmDataSource.NewH2EmbeddedInstance("euroMed", "sa", "");

	}

	public static ICdmDataSource localH2Erms(){

		return CdmDataSource.NewH2EmbeddedInstance("erms", "sa", "");

	}

	public static ICdmDataSource cdm_algaterra_preview(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "160.45.63.201";

		String cdmUserName = "edit";

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

	}

	public static ICdmDataSource cdm_pesi_euroMed(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "160.45.63.175";

		String cdmUserName = "edit";

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

	}

		String cdmUserName = "root";

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

	}

	public static ICdmDataSource cdm_local_euroMed3(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "127.0.0.1";

	public static ICdmDataSource cdm_pesi_fauna_europaea(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "160.45.63.175";

		String cdmUserName = "edit";

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

	}

	public static ICdmDataSource cdm_pesi_erms(){

		DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

		String cdmServer = "160.45.63.175";

		String cdmUserName = "edit";

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

	}

	/**

	 * initializes source

	 * TODO only supports MySQL and PostgreSQL

	 * @param dbType

	 * @param cdmServer

	 * @param cdmDB

		pwd = AccountStore.readOrStorePassword(cdmServer, cdmDB, cdmUserName, pwd);

		ICdmDataSource destination;

		if(dbType.equals(DatabaseTypeEnum.MySQL)){

		} else if(dbType.equals(DatabaseTypeEnum.PostgreSQL)){

		} else {

			//TODO others

			throw new RuntimeException("Unsupported DatabaseType");

	/**

	 * the name of the given first string in the array

	 * @param args

	 * @return

	 */

	public static ICdmDataSource chooseDestination(String[] args) {

		String possibleDestination = args[0];

		Method[] methods = CdmDestinations.class.getMethods();

		for (Method method : methods){

			if(method.getName().equals(possibleDestination)){

				try {

		}

		return null;

	}

}

/**

* Copyright (C) 2007 EDIT

* 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.

*/

	static final Source faunaEuropaeaSource = PesiSources.mfn_faunEu_pesi3();

	static final ICdmDataSource cdmDestination = CdmDestinations.cdm_test_local_faunaEu_mysql();

	static final int limitSave = 5000;

//	static final CHECK check = CHECK.CHECK_AND_IMPORT;

	static final NomenclaturalCode nomenclaturalCode  = NomenclaturalCode.ICZN;

// ****************** ALL *****************************************

	// Fauna Europaea to CDM import

	static final boolean doAuthors = true;

	static final boolean doTaxa = true;

	static final boolean makeFeatureTree = true;

    // CDM to CDM import

	static final boolean doHeterotypicSynonymsForBasionyms = true;

// ************************ NONE **************************************** //

	// Fauna Europaea to CDM import

//	static final boolean doAuthors = false;

//	static final boolean doTaxa = false;

//	static final boolean makeFeatureTree = false;

//    // CDM to CDM import

//	static final boolean doHeterotypicSynonymsForBasionyms = false;

	/**

	 * @param args

	 */

	public static void main(String[] args) {

		ICdmDataSource destination = cdmDestination;

		System.out.println("Starting import from Fauna Europaea (" + faunaEuropaeaSource.getDatabase() + ") to CDM (" + destination.getDatabase() + ")...");

				// invoke Fauna Europaea to CDM import

			FaunaEuropaeaImportConfigurator.NewInstance(faunaEuropaeaSource,  destination);

		fauEuImportConfigurator.setDbSchemaValidation(dbSchemaValidation);

		fauEuImportConfigurator.setNomenclaturalCode(nomenclaturalCode);

		fauEuImportConfigurator.setCheck(check);

		fauEuImportConfigurator.setDoHeterotypicSynonyms(doHeterotypicSynonyms);

		fauEuImportConfigurator.setDoHeterotypicSynonymsForBasionyms(doHeterotypicSynonymsForBasionyms);

		fauEuImportConfigurator.setSourceRefUuid(PesiTransformer.uuidSourceRefFaunaEuropaea);

			new CdmDefaultImport<FaunaEuropaeaImportConfigurator>();

		try {

			fauEuImport.invoke(fauEuImportConfigurator);

		}

		// invoke CDM to CDM import

//		System.out.println("Starting import from CDM to CDM (" + destination.getDatabase() + ")...");

//			CdmImportConfigurator.NewInstance(destination, destination);

//		cdmImportConfigurator.setDbSchemaValidation(DbSchemaValidation.VALIDATE);

//		cdmImportConfigurator.setNomenclaturalCode(nomenclaturalCode);

//		cdmImportConfigurator.setCheck(check);

//		cdmImportConfigurator.setDoOccurrence(false);

//		cdmImportConfigurator.setLimitSave(limitSave);

//

//			new CdmDefaultImport<CdmImportConfigurator>();

//		try {

//			cdmImport.invoke(cdmImportConfigurator);

//			System.out.println("ERROR in CDM to CDM import");

//			e.printStackTrace();

//		}

		//make feature tree

			FeatureTree featureTree = FeatureTree.NewInstance(UUID.fromString("ff59b9ad-1fb8-4aa4-a8ba-79d62123d0fb"));

			FeatureNode root = featureTree.getRoot();

			app.getFeatureTreeService().saveOrUpdate(featureTree);

		}

		System.out.println("End importing Fauna Europaea data");

	}

// $Id$

/**

* Copyright (C) 2009 EDIT

* 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.

*/

	//database validation status (create, update, validate ...)

	static final Source pesiDestination = PesiDestinations.pesi_test_local_CDM_FE2PESI();

//	static final Source pesiDestination = PesiDestinations.pesi_test_local_CDM_ERMS2PESI();

	static final ICdmDataSource cdmSource = CdmDestinations.cdm_test_local_faunaEu_mysql();

//	static final ICdmDataSource cdmSource = CdmDestinations.cdm_test_local_mysql();

	//Taxon names can't be mapped to their CDM ids as PESI Taxon table mainly holds taxa and there IDs. We ad nameIdStart to the TaxonName id to get a unique id

	static final int nameIdStart = 10000000;

	static final int partitionSize = 2000;

	//check - export

	static final CHECK check = CHECK.EXPORT_WITHOUT_CHECK;

	static final boolean deleteAll = true;

	static final IdType idType = IdType.CDM_ID_WITH_EXCEPTIONS;

// ****************** ALL *****************************************

	//references

	static final DO_REFERENCES doReferences =  DO_REFERENCES.ALL;

	//taxa

	static final boolean doTaxa = true;

	static final boolean doRelTaxa = true;

	static final boolean doInferredSynonyms = true;

	static final boolean doPureNames = false; // !!!

	static final boolean doDescription = true;

// ************************ NONE **************************************** //

//	//references

//	static final DO_REFERENCES doReferences =  DO_REFERENCES.NONE;

//	//taxa

//	static final boolean doTaxa = false;

//	static final boolean doRelTaxa = false;

//	static final boolean doRank = true;

//	static final boolean doInferredSynonyms = true;

//	static final boolean doDescription = false;

	public boolean 	doExport(ICdmDataSource source){

		System.out.println("Start export to PESI ("+ pesiDestination.getDatabase() + ") ...");

		//make PESI Source

		Source destination = pesiDestination;

		PesiTransformer transformer = new PesiTransformer(destination);

		PesiExportConfigurator config = PesiExportConfigurator.NewInstance(destination, source, transformer);

		config.setDoTaxa(doTaxa);

		config.setDoRelTaxa(doRelTaxa);

		config.setDoOccurrence(doOccurrence);

		config.setDoInferredSynonyms(doInferredSynonyms);

		config.setDoPureNames(doPureNames);

		config.setDoDescription(doDescription);

		config.setCheck(check);

		config.setLimitSave(partitionSize);

		config.setIdType(idType);

		if (deleteAll){

			destination.update("EXEC sp_deleteAllData");

		}

		// invoke export

		CdmDefaultExport<PesiExportConfigurator> pesiExport = new CdmDefaultExport<PesiExportConfigurator>();

		boolean result = pesiExport.invoke(config);

		System.out.println("End export to PESI ("+ destination.getDatabase() + ")..." + (result? "(successful)":"(with errors)"));

		return result;

	}

	/**

	 * @param args

	 */

// $Id$

/**

* Copyright (C) 2009 EDIT

* 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.

*/

	//database validation status (create, update, validate ...)

	static final Source pesiDestination = PesiDestinations.pesi_test_local_CDM_IF2PESI();

	static final ICdmDataSource cdmSource = CdmDestinations.cdm_test_local_indexFungorum();

//	static final ICdmDataSource cdmSource = CdmDestinations.cdm_test_local_mysql_test();

	static final int partitionSize = 2000;

	//check - export

	static final CHECK check = CHECK.EXPORT_WITHOUT_CHECK;

	static final boolean deleteAll = true;

	static final IdType idType = IdType.CDM_ID;

// ****************** ALL *****************************************

	//references

	static final DO_REFERENCES doReferences =  DO_REFERENCES.ALL;

	//taxa

	static final boolean doTaxa = true;

	static final boolean doRelTaxa = true;

	static final boolean doInferredSynonyms = false;

	static final boolean doPureNames = false; // !!!

	static final boolean doDescription = true;

// ************************ NONE **************************************** //

//	//references

//	static final DO_REFERENCES doReferences =  DO_REFERENCES.NONE;

//	//taxa

//	static final boolean doTaxa = false;

//	static final boolean doRelTaxa = false;

//	static final boolean doRank = true;

//	static final boolean doInferredSynonyms = true;

//	static final boolean doDescription = false;

	public boolean 	doExport(ICdmDataSource source){

		System.out.println("Start export to PESI ("+ pesiDestination.getDatabase() + ") ...");

		//make PESI Source

		Source destination = pesiDestination;

		PesiTransformer transformer = new PesiTransformer(destination);

		PesiExportConfigurator config = PesiExportConfigurator.NewInstance(destination, source, transformer);

		config.setDoTaxa(doTaxa);

		config.setDoRelTaxa(doRelTaxa);

		config.setDoOccurrence(doOccurrence);

		config.setDoInferredSynonyms(doInferredSynonyms);

		config.setDoPureNames(doPureNames);

		config.setDoDescription(doDescription);

		config.setCheck(check);

		config.setLimitSave(partitionSize);

		config.setIdType(idType);

		// invoke export

		CdmDefaultExport<PesiExportConfigurator> pesiExport = new CdmDefaultExport<PesiExportConfigurator>();

		System.out.println("End export to PESI ("+ destination.getDatabase() + ")..." + (result? "(successful)":"(with errors)"));

		return result;

	}

	/**

	 * @param args

	 */

/**

* Copyright (C) 2007 EDIT

* 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.

*/

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

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

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

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

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

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

 */

public abstract class IndexFungorumImportBase extends CdmImportBase<IndexFungorumImportConfigurator, IndexFungorumImportState> implements ICdmIO<IndexFungorumImportState>, IPartitionedIO<IndexFungorumImportState> {

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

	//NAMESPACES

	protected static final String NAMESPACE_REFERENCE = "reference";

	protected static final String NAMESPACE_TAXON = "Taxon";

	protected static final String NAMESPACE_SUPRAGENERIC_NAMES = "SupragenericNames";

	protected static final String NAMESPACE_GENERA = "Genera";

	protected static final String NAMESPACE_SPECIES = "Species";

	protected static final String INCERTAE_SEDIS = "Incertae sedis";

	protected static final String FOSSIL_FUNGI = "Fossil Fungi";

	protected static final String SOURCE_REFERENCE = "SOURCE_REFERENCE";

	//TODO needed?

	/**

	 * @param dbTableName

	 */

	public IndexFungorumImportBase(String pluralString, String dbTableName, Class cdmTargetClass) {

		this.pluralString = pluralString;

		this.cdmTargetClass = cdmTargetClass;

	}

		IndexFungorumImportConfigurator config = state.getConfig();

		Source source = config.getSource();

		String strIdQuery = getIdQuery();

		String strRecordQuery = getRecordQuery(config);

		int recordsPerTransaction = config.getRecordsPerTransaction();

			state.setUnsuccessfull();

			return;

		}

		logger.info("end make " + getPluralString() + " ... " + getSuccessString(true));

		return;

	}

		boolean success = true ;

		Set objectsToSave = new HashSet<CdmBase>();

// 		DbImportMapping<?, ?> mapping = getMapping();

//		mapping.initialize(state, cdmTargetClass);

		ResultSet rs = partitioner.getResultSet();

		try{

			while (rs.next()){

			logger.error("SQLException:" +  e);

			return false;

		}

		partitioner.startDoSave();

		getCommonService().save(objectsToSave);

		return success;

	 */

	protected abstract String getRecordQuery(IndexFungorumImportConfigurator config);

	/**

	 * @return

	 */

		String result = " SELECT id FROM " + getTableName();

		return result;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.berlinModel.in.IPartitionedIO#getPluralString()

	 */

		return pluralString;

	}

		return this.dbTableName;

	}

	protected boolean resultSetHasColumn(ResultSet rs, String columnName){

		try {

			ResultSetMetaData metaData = rs.getMetaData();

            return false;

		}

	}

	protected boolean checkSqlServerColumnExists(Source source, String tableName, String columnName){

		String strQuery = "SELECT  Count(t.id) as n " +

				" FROM sysobjects AS t " +

				" INNER JOIN syscolumns AS c ON t.id = c.id " +

				" (c.name = '" + columnName + "')";

		int n;

		try {

			rs.next();

			e.printStackTrace();

			return false;

		}

	}

	/**

	 * Returns a map that holds all values of a ResultSet. This is needed if a value needs to

	 * be accessed twice

			idSet.add(id);

		}

	}

	/**

	 * Returns true if i is a multiple of recordsPerTransaction

	 * @param i

		startTransaction();

		return (i % recordsPerLoop) == 0;

	}

	protected void doLogPerLoop(int count, int recordsPerLog, String pluralString){

		if ((count % recordsPerLog ) == 0 && count!= 0 ){ logger.info(pluralString + " handled: " + (count));}

	}

	protected void makeAuthorAndPublication(IndexFungorumImportState state, ResultSet rs, NonViralName name) throws SQLException {

		//authors

		if (StringUtils.isNotBlank(authorStr)){

			try {

				parser.parseAuthors(name, authorStr);

				name.setAuthorshipCache(authorStr);

			}

		}

		//page

		String page = rs.getString("PAGE");

		if (StringUtils.isNotBlank(page)){

			name.setNomenclaturalMicroReference(page);

		}

		//Reference

		Reference<?> ref = ReferenceFactory.newGeneric();

		boolean hasInReference = false;

				logger.warn("'AUTHORS' is blank for not empty PUBLISHING_AUTHORS. This is not yet handled.");

			}

		}

		//inRef + inRefAuthor

		if (pubAuthor != null){

			Reference<?> inRef = ReferenceFactory.newGeneric();

			ref.setInReference(inRef);

			hasInReference = true;

		}

		//refAuthor

		TeamOrPersonBase<?> refAuthor = CdmBase.deproxy(name.getCombinationAuthorTeam(), TeamOrPersonBase.class);

		if (refAuthor == null){

			}

		}

		ref.setVolume(volume);

		//year

		String yearOfPubl = rs.getString("YEAR OF PUBLICATION");

		String yearOnPubl = rs.getString("YEAR ON PUBLICATION");

		if (year != null){

			ref.setDatePublished(TimePeriodParser.parseString(year));

		}

		//preliminary, set protected titlecache as Generic Cache Generation with in references currently doesn't fully work yet

		String titleCache = CdmUtils.concat(", ", pubAuthorStr, title);

		if  ( StringUtils.isNotBlank(pubAuthorStr)){

		titleCache = CdmUtils.concat(": ", titleCache, page);

		titleCache = CdmUtils.concat(". ", titleCache, year);

		ref.setTitleCache(titleCache, true);

		//set nom ref

		if (StringUtils.isNotBlank(titleCache)){

			name.setNomenclaturalReference(ref);

		}

	}

	protected MarkerType getNoLastActionMarkerType(IndexFungorumImportState state) {

				"has no last action", "No last action information available", "no last action");

	}

		String strId = (id == null ? null : String.valueOf(id));

		IdentifiableSource source = IdentifiableSource.NewInstance(OriginalSourceType.Import, strId, namespace, sourceReference, null);

		taxon.addSource(source);

		//no last action

		MarkerType hasNoLastAction = getNoLastActionMarkerType(state);

		taxon.addMarker(Marker.NewInstance(hasNoLastAction, true));

		MarkerType missingGUID = getMarkerType(state, PesiTransformer.uuidMarkerGuidIsMissing, "GUID is missing", "GUID is missing", null);

		return missingGUID;

	}

	protected Classification getClassification(IndexFungorumImportState state) {

		Classification result;

			result = makeTreeMemSave(state, sourceReference);

		} else {

			result = getClassificationService().find(classificationUuid);

		return result;

	}

}

// $Id$

/**

* Copyright (C) 2009 EDIT

* 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.

*/

import org.springframework.stereotype.Component;

import org.springframework.transaction.TransactionStatus;

import eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer;

import eu.etaxonomy.cdm.io.common.DbExportStateBase;

import eu.etaxonomy.cdm.io.common.Source;

import eu.etaxonomy.cdm.io.common.mapping.out.DbDescriptionElementTaxonMapper;

import eu.etaxonomy.cdm.io.common.mapping.out.DbDistributionStatusMapper;

import eu.etaxonomy.cdm.io.common.mapping.out.DbExportIgnoreMapper;

import eu.etaxonomy.cdm.io.common.mapping.out.DbLanguageMapper;

import eu.etaxonomy.cdm.io.common.mapping.out.DbObjectMapper;

import eu.etaxonomy.cdm.io.common.mapping.out.DbOriginalNameMapper;

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

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

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

/**

 * The export class for {@link eu.etaxonomy.cdm.model.description.DescriptionElementBase DescriptionElements}.<p>

 * Inserts into DataWarehouse database table <code>Note</code>.<p>

@Component

public class PesiDescriptionExport extends PesiExportBase {

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

	private static final Class<? extends CdmBase> standardMethodParameter = DescriptionElementBase.class;

	private static int modCount = 1000;

	//decide where to handle them best (configurator, transformer, single method, ...)

	private static Set<Integer> excludedNoteCategories = new HashSet<Integer>(Arrays.asList(new Integer[]{250,251,252,253,10,11,13}));

	//debugging

	private static int countDescriptions;

	private static int countTaxa;

	private static int countAdditionalSources;

	private static int countImages;

	private static int countNotes;

	private static int countCommonName;

	private static int countOccurrence;

	private static int countOthers;

	public PesiDescriptionExport() {

		super();

	}

			// Stores whether this invoke was successful or not.

			boolean success = true;

			// Get specific mappings: (CDM) DescriptionElement -> (PESI) Note

			PesiExportMapping notesMapping = getNotesMapping();

			notesMapping.initialize(state);

			additionalSourceMapping.initialize(state);

			// Get specific mappings: (CDM) DescriptionElement -> (PESI) Additional taxon source

			PesiExportMapping vernacularMapping = getVernacularNamesMapping();

			vernacularMapping.initialize(state);

			// Get specific mappings: (CDM) DescriptionElement -> (PESI) Additional taxon source

			PesiExportMapping imageMapping = getImageMapping();

			imageMapping.initialize(state);

			// Start transaction

			success &= doPhase01(state, notesMapping, occurrenceMapping, addSourceSourceMapping, additionalSourceMapping, vernacularMapping, imageMapping);

			// Start transaction

			success &= doPhase01b(state, notesMapping, occurrenceMapping, addSourceSourceMapping, additionalSourceMapping, vernacularMapping, imageMapping);

			logger.info("PHASE 2...");

			success &= doPhase02(state);

			logger.info("*** Finished Making " + pluralString + " ..." + getSuccessString(success));

			if (!success){

				state.setUnsuccessfull();

			}

	}

	//PHASE 01: Description Elements

			PesiExportMapping additionalSourceMapping, PesiExportMapping vernacularMapping, PesiExportMapping imageMapping) throws SQLException {

		int count = 0;

		int pastCount = 0;

		boolean success = true;

		int limit = state.getConfig().getLimitSave();

		List<Taxon> taxonList = null;

		TransactionStatus txStatus = startTransaction(true);

		logger.info("Started new transaction. Fetching some " + pluralString + " (max: " + limit + ") ...");

		List<String> propPath = Arrays.asList(new String[]{"descriptions.elements.*"});

		logger.debug("Start snapshot, before starting loop");

		//taxon descriptions

		int partitionCount = 0;

		while ((taxonList = getNextTaxonPartition(Taxon.class, limit, partitionCount++, propPath )) != null   ) {

			logger.info("Fetched " + taxonList.size() + " " + pluralString + ". Exporting...");

			for (Taxon taxon : taxonList) {

				countTaxa++;

				doCount(count++, modCount, pluralString);

				state.setCurrentTaxon(taxon);

			}

			taxonList = null;

			state.setCurrentTaxon(null);

			txStatus = startTransaction(true);

			logger.info("Started new transaction. Fetching some " + pluralString + " (max: " + limit + ") for description import ...");

		}

		logger.info("No " + pluralString + " left to fetch.");

		logger.info("Partition: " + partitionCount);

		logger.info("Taxa: " + countTaxa);

		logger.info("Images: " + countImages);

		logger.info("Notes: " + countNotes);

		logger.info("Others: " + countOthers);

		// Commit transaction

		commitTransaction(txStatus);

		logger.debug("Committed transaction.");

		return success;

	}

	//PHASE 01b: Name Descriptions

			PesiExportMapping additionalSourceMapping, PesiExportMapping vernacularMapping, PesiExportMapping imageMapping) throws SQLException {

		logger.info("PHASE 1b...");

		int count = 0;

		int pastCount = 0;

		boolean success = true;

		int limit = state.getConfig().getLimitSave();

		List<TaxonNameDescription> nameDescList = null;

		TransactionStatus txStatus = startTransaction(true);

		logger.info("Started new transaction. Fetching some name descriptions (max: " + limit + ") ...");

		List<String> propPath = Arrays.asList(new String[]{"descriptions.elements.*"});

		//name descriptions

		int partitionCount = 0;

		while ((nameDescList = getNextNameDescriptionPartition( limit, partitionCount++, propPath )) != null   ) {

			logger.info("Fetched " + nameDescList.size() + " name descriptions. Exporting...");

			for (TaxonNameDescription desc : nameDescList) {

				countTaxa++;

				doCount(count++, modCount, "name descriptions");

				boolean isImageGallery = desc.isImageGallery();

				TaxonNameBase<?,?> name = desc.getTaxonName();

				for (DescriptionElementBase element : desc.getElements()){

					if (isPurePesiName(name)){

						success &= handleDescriptionElement(state, notesMapping, occurrenceMapping, vernacularMapping, imageMapping,

			txStatus = startTransaction(true);

			logger.info("Started new transaction. Fetching some name descriptions (max: " + limit + ") for description import ...");

		}

		logger.info("No " + pluralString + " left to fetch.");

		logger.info("Partition: " + partitionCount);

		logger.info("Taxa: " + countTaxa);

		logger.info("Images: " + countImages);

		logger.info("Notes: " + countNotes);

		logger.info("Others: " + countOthers);

		// Commit transaction

		commitTransaction(txStatus);

		logger.debug("Committed transaction.");

	}

	private boolean handleSingleTaxon(Taxon taxon, PesiExportState state, PesiExportMapping notesMapping, PesiExportMapping occurrenceMapping,

			PesiExportMapping vernacularMapping, PesiExportMapping imageMapping) throws SQLException {

		boolean success = true;

		Set<DescriptionBase<?>> descriptions = new HashSet<DescriptionBase<?>>();

		descriptions.addAll(taxon.getDescriptions());

		for (DescriptionBase<?> desc : descriptions){

			countDescriptions++;

	}

	private boolean handleDescriptionElement(PesiExportState state, PesiExportMapping notesMapping,

			PesiExportMapping addSourceSourceMapping, PesiExportMapping additionalSourceMapping, boolean isImageGallery, DescriptionElementBase element) throws SQLException {

		try {

			boolean success = true;

				countOccurrence++;

				Distribution distribution = CdmBase.deproxy(element, Distribution.class);

				MarkerType markerType = getUuidMarkerType(PesiTransformer.uuidMarkerTypeHasNoLastAction, state);

				distribution.addMarker(Marker.NewInstance(markerType, true));

				if (isPesiDistribution(state, distribution)){

					countDistribution++;

				}

			}else if (isAdditionalTaxonSource(element)){

				countAdditionalSources++;

			}else if (isPesiNote(element)){

				countNotes++;

				success &= notesMapping.invoke(element);

			}else{

				countOthers++;

				String featureTitle = element.getFeature() == null ? "no feature" :element.getFeature().getTitleCache();

		if (distribution.getStatus() == null){

			return false;

		}

		//...this may change in future so we keep the following code

		Integer key;

		//area filter

//			//Macaronesia records should not be exported to PESI

//			return false;

//		//TODO exclude Russion areas Rs*, and maybe ohters

				if (state.getTransformer().getKeyByNamedArea(area) == null){

					String warning = "Area (%s,%s) not available in PESI transformer for taxon %S: ";

					TaxonBase<?> taxon =  state.getCurrentTaxon();

				logger.warn("Area not available in PESI transformer " +  area.getTitleCache());

				return false;

			}

		return true;

//		//status

//		PresenceAbsenceTermBase<?> status = distribution.getStatus();

//		if (status == null){

	private boolean doPhase02(PesiExportState state) {

		TransactionStatus txStatus;

		boolean success =  true;

		// Get the limit for objects to save within a single transaction.

		int limit = state.getConfig().getLimitSave();

		txStatus = startTransaction(true);

		ExtensionType taxCommentExtensionType = (ExtensionType)getTermService().find(PesiTransformer.taxCommentUuid);

		ExtensionType fauCommentExtensionType = (ExtensionType)getTermService().find(PesiTransformer.fauCommentUuid);

		ExtensionType fauExtraCodesExtensionType = (ExtensionType)getTermService().find(PesiTransformer.fauExtraCodesUuid);

		List<TaxonNameBase> taxonNameList = null;

		int count = 0;

		int pastCount = 0;

		Connection connection = state.getConfig().getDestination().getConnection();

				for (Extension extension : extensions) {

					if (extension.getType().equals(taxCommentExtensionType)) {

						String taxComment = extension.getValue();

								PesiTransformer.getNoteCategoryCache(PesiTransformer.taxCommentUuid),

								null, null, getTaxonKey(taxonName, state),connection);

					} else if (extension.getType().equals(fauCommentExtensionType)) {

						String fauComment = extension.getValue();

								PesiTransformer.getNoteCategoryCache(PesiTransformer.fauCommentUuid),

								null, null, getTaxonKey(taxonName, state),connection);

					} else if (extension.getType().equals(fauExtraCodesExtensionType)) {

						String fauExtraCodes = extension.getValue();

								PesiTransformer.getNoteCategoryCache(PesiTransformer.fauExtraCodesUuid),

								null, null, getTaxonKey(taxonName, state),connection);

					}

				}

				doCount(count++, modCount, pluralString);

			}

	 * @param object2

	 */

	private void invokeNotes(String note, Integer noteCategoryFk,

			Integer taxonFk, Connection connection) {

		try {

			PreparedStatement notesStmt = connection.prepareStatement(notesSql);

			if (note != null) {

				notesStmt.setString(1, note);

			} else {

				notesStmt.setObject(1, null);

			}

			if (noteCategoryFk != null) {

				notesStmt.setInt(2, noteCategoryFk);

			} else {

				notesStmt.setObject(2, null);

			}

			if (noteCategoryCache != null) {

				notesStmt.setString(3, noteCategoryCache);

			} else {

				notesStmt.setObject(3, null);

			}

			if (languageFk != null) {

				notesStmt.setInt(4, languageFk);

			} else {

				notesStmt.setObject(4, null);

			}

			if (languageCache != null) {

				notesStmt.setString(5, languageCache);

			} else {

				notesStmt.setObject(5, null);

			}

			if (taxonFk != null) {

				notesStmt.setInt(6, taxonFk);

			} else {

				notesStmt.setObject(6, null);

			}

			notesStmt.executeUpdate();

		} catch (SQLException e) {

			logger.error("Note could not be created: " + note);

	 * @return Whether the delete operation was successful or not.

	 */

	protected boolean doDelete(PesiExportState state) {

		String sql;

		Source destination =  pesiConfig.getDestination();

		}

		return result;

	}

	/**

	 * Returns the <code>NoteCategoryCache</code> attribute.

	 * @param descriptionElement The {@link DescriptionElementBase DescriptionElement}.

	private static String getNoteCategoryCache(DescriptionElementBase descriptionElement, PesiExportState state) {

		return state.getTransformer().getCacheByFeature(descriptionElement.getFeature());

	}

	/**

	 * Returns the <code>LanguageCache</code> attribute.

	 * @param descriptionElement The {@link DescriptionElementBase DescriptionElement}.

	 * @return The <code>LanguageCache</code> attribute.

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

		} else {

			logger.debug("Given descriptionElement does not support languages. Hence LanguageCache could not be determined: " + descriptionElement.getUuid());

		}

		if (multilanguageText != null) {

			Set<Language> languages = multilanguageText.keySet();

//	private static String getRegion(DescriptionElementBase descriptionElement) {

//		String result = null;

//		DescriptionBase<?> inDescription = descriptionElement.getInDescription();

//		// Area information are associated to TaxonDescriptions and Distributions.

//		if (descriptionElement.isInstanceOf(Distribution.class)) {

//			Distribution distribution = CdmBase.deproxy(descriptionElement, Distribution.class);

//		return result;

//	}

	/**

	 * Returns the TaxonFk for a given TaxonName or Taxon.

	 * @param state The {@link DbExportStateBase DbExportState}.

		TaxonBase<?> entity = state.getCurrentTaxon();

		return state.getDbId(entity);

	}

	/**

	 * Returns the TaxonFk for a given TaxonName.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

	private static Integer getTaxonKey(TaxonNameBase<?,?> taxonName, DbExportStateBase<?, PesiTransformer> state) {

		return state.getDbId(taxonName);

	}

	/**

	 * Returns the <code>FullName</code> attribute.

	 * @param taxonName The {@link NonViralName NonViralName}.

	 */

	@SuppressWarnings("unused")

	private static String getTaxonFullNameCache(DescriptionElementBase deb, PesiExportState state) {

		TaxonBase<?> taxon =  state.getCurrentTaxon();

		TaxonNameBase<?,?> taxonName = taxon.getName();

		NonViralName<?> nvn = CdmBase.deproxy(taxonName, NonViralName.class);

	 */

	private PesiExportMapping getNotesMapping() {

		PesiExportMapping mapping = new PesiExportMapping(dbNoteTableName);

		mapping.addMapper(IdMapper.NewInstance("NoteId"));

		mapping.addMapper(DbTextDataMapper.NewInstance(Language.ENGLISH(), "Note_1"));

		//TODO

		mapping.addMapper(MethodMapper.NewInstance("Note_2", this, DescriptionElementBase.class));

		mapping.addMapper(MethodMapper.NewInstance("NoteCategoryFk", this, DescriptionElementBase.class ));

		mapping.addMapper(MethodMapper.NewInstance("NoteCategoryCache", this, DescriptionElementBase.class, PesiExportState.class ));

		mapping.addMapper(MethodMapper.NewInstance("LanguageFk", this));

		mapping.addMapper(MethodMapper.NewInstance("LanguageCache", this, DescriptionElementBase.class, PesiExportState.class));

//		mapping.addMapper(MethodMapper.NewInstance("Region", this));

		mapping.addMapper(DbDescriptionElementTaxonMapper.NewInstance("taxonFk"));

		mapping.addCollectionMapping(getNoteSourceMapping());

		return mapping;

	}

	private CollectionExportMapping<PesiExportState, PesiExportConfigurator,PesiTransformer> getNoteSourceMapping() {

		String tableName = "NoteSource";

		String collectionAttribute = "sources";