EDIT

app-import/src/main/java/eu/etaxonomy/cdm/io/algaterra/AlgaTerraSpecimenImportBase.java -text

app-import/src/main/java/eu/etaxonomy/cdm/io/algaterra/AlgaTerraTypeImport.java -text

app-import/src/main/java/eu/etaxonomy/cdm/io/algaterra/validation/AlgaTerraTypeImportValidator.java -text

				, AlgaTerraTypeImport.class

 * @created 01.09.2012

public class AlgaTerraSpecimenImport  extends AlgaTerraSpecimenImportBase {

			String strQuery =   

					handleEcoFactSpecificSpecimen(rs,facade, state);

	private void handleEcoFactSpecificSpecimen(ResultSet rs, DerivedUnitFacade facade, AlgaTerraImportState state) throws SQLException {

		Object alkalinityFlag = rs.getBoolean("AlkalinityFlag");

		//alkalinity marker

		if (alkalinityFlag != null){

			MarkerType alkalinityMarkerType = getMarkerType(state, uuidMarkerAlkalinity, "Alkalinity", "Alkalinity", null);

			boolean alkFlag = Boolean.valueOf(alkalinityFlag.toString());

			Marker alkalinityMarker = Marker.NewInstance(alkalinityMarkerType, alkFlag);

			facade.getFieldObservation(true).addMarker(alkalinityMarker);

		}

		DescriptionBase<?> fieldDescription = getFieldObservationDescription(facade);

		//habitat, ecology, community, etc.

		String habitat = rs.getString("HabitatExplanation");

		if (isNotBlank(habitat)){

			Feature habitatExplanation = getFeature(state, uuidFeatureHabitatExplanation, "Habitat Explanation", "HabitatExplanation", null, null);

			TextData textData = TextData.NewInstance(habitatExplanation);

			textData.putText(Language.DEFAULT(), habitat);

			fieldDescription.addElement(textData);

		}

		String community = rs.getString("Comunity");

		if (isNotBlank(community)){

			Feature communityFeature = getFeature(state, uuidFeatureSpecimenCommunity, "Community", "The community of a specimen (e.g. other algae in the same sample)", null, null);

			TextData textData = TextData.NewInstance(communityFeature);

			textData.putText(Language.DEFAULT(), community);

			fieldDescription.addElement(textData);

		}

		String additionalData = rs.getString("AdditionalData");

		if (isNotBlank(additionalData)){  //or handle it as Annotation ??

			Feature additionalDataFeature = getFeature(state, uuidFeatureAdditionalData, "Additional Data", "Additional Data", null, null);

			TextData textData = TextData.NewInstance(additionalDataFeature);

			textData.putText(Language.DEFAULT(), additionalData);

			fieldDescription.addElement(textData);

		}

		String climateUuid = rs.getString("climateUuid");

		String habitatUuid = rs.getString("habitatUuid");

		String lifeFormUuid = rs.getString("lifeFormUuid");

		addCategoricalValue(state, fieldDescription, climateUuid, uuidFeatureAlgaTerraClimate);

		addCategoricalValue(state, fieldDescription, habitatUuid, Feature.HABITAT().getUuid());

		addCategoricalValue(state, fieldDescription, lifeFormUuid, uuidFeatureAlgaTerraLifeForm);

		//collection

		String voucher = rs.getString("Voucher");

		if (StringUtils.isNotBlank(voucher)){

			facade.setAccessionNumber(voucher);

		//parameters

		makeParameter(state, rs, getFieldObservationDescription(facade));

	private void addCategoricalValue(AlgaTerraImportState importState, DescriptionBase description, String uuidTerm, UUID featureUuid) {

		if (uuidTerm != null){

			State state = this.getStateTerm(importState, UUID.fromString(uuidTerm));

			Feature feature = getFeature(importState, featureUuid);

			CategoricalData categoricalData = CategoricalData.NewInstance(state, feature);

			description.addElement(categoricalData);

				return getMeasurementUnit(state, uuidMeasurementUnitMgL, unitStr, unitStr, unitStr, null);

				return getMeasurementUnit(state, uuidMeasurementUnitMolMol, unitStr, unitStr, unitStr, null);

			idSet = fieldObservationIdSet;

			idSet = termsIdSet;

/**

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

import java.net.URI;

import java.sql.Date;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.Set;

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.springframework.transaction.TransactionStatus;

import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade;

import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase;

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

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

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

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

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

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

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

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

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

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

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

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

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

/**

 * @author a.mueller

 * @created 12.09.2012

 */

public abstract class AlgaTerraSpecimenImportBase extends BerlinModelImportBase{

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

	public static final String ECO_FACT_NAMESPACE = "EcoFact";

	public static final String TYPE_SPECIMEN_NAMESPACE = "TypeSpecimen";

	public static final String TERMS_NAMESPACE = "ALGA_TERRA_TERMS";

	//TODO move to transformrer

	final static UUID uuidMarkerAlkalinity = UUID.fromString("e52d0ea2-0c1f-4d95-ae6d-e21ab317c594");  

	final static UUID uuidRefSystemGps = UUID.fromString("c23e4928-c137-4e4a-b6ab-b430da3d0b94");  

	final static UUID uuidFeatureSpecimenCommunity = UUID.fromString("3ff5b1ab-3999-4b5a-b8f7-01fd2f6c12c7");

	final static UUID uuidFeatureAdditionalData = UUID.fromString("0ac82ab8-2c2b-4953-98eb-a9f718eb9c57");

	final static UUID uuidFeatureHabitatExplanation = UUID.fromString("6fe32295-61a3-44fc-9fcf-a85790ea888f");

	final static UUID uuidVocAlgaTerraClimate = UUID.fromString("b0a677c6-8bb6-43f4-b1b8-fc377a10feb5");

	final static UUID uuidVocAlgaTerraHabitat = UUID.fromString("06f30114-e19c-4e7d-a8e5-5488c41fcbc5");

	final static UUID uuidVocAlgaTerraLifeForm = UUID.fromString("3c0b194e-809c-4b42-9498-6ff034066ed7");

	final static UUID uuidFeatureAlgaTerraClimate = UUID.fromString("8754674c-9ab9-4f28-95f1-91eeee2314ee");

	final static UUID uuidFeatureAlgaTerraHabitat = UUID.fromString("7def3fc2-cdc5-4739-8e13-62edbd053415");

	final static UUID uuidFeatureAlgaTerraLifeForm = UUID.fromString("9b657901-1b0d-4a2a-8d21-dd8c1413e2e6");

	final static UUID uuidVocParameter = UUID.fromString("45888b40-5bbb-4293-aa1e-02479796cd7c");

	final static UUID uuidStatMeasureSingleValue = UUID.fromString("eb4c3d98-4d4b-4c37-8eb4-17315ce79920");

	final static UUID uuidMeasurementValueModifier = UUID.fromString("0218a7a3-f6c0-4d06-a4f8-6b50b73aef5e");

	final static UUID uuidModifierLowerThan = UUID.fromString("2b500085-6bef-4003-b6ea-e0ad0237d79d");

	final static UUID uuidModifierGreaterThan = UUID.fromString("828df49d-c745-48f7-b083-0ada43356c34");

	/**

	 * Creates the vocabularies and the features for Climate, Habitat and Lifeform

	 * @param state

	 * @throws SQLException

	 */

	protected void makeVocabulariesAndFeatures(AlgaTerraImportState state) throws SQLException {

		String abbrevLabel = null;

		URI uri = null;

		if (! state.isSpecimenVocabulariesCreated()){

			TransactionStatus txStatus = this.startTransaction();

			boolean isOrdered = true;

			OrderedTermVocabulary<State> climateVoc = (OrderedTermVocabulary)getVocabulary(uuidVocAlgaTerraClimate, "Climate", "Climate", abbrevLabel, uri, isOrdered, null);

			OrderedTermVocabulary<State> habitatVoc = (OrderedTermVocabulary)getVocabulary(uuidVocAlgaTerraHabitat, "Habitat", "Habitat", abbrevLabel, uri, isOrdered, null);

			OrderedTermVocabulary<State> lifeformVoc = (OrderedTermVocabulary)getVocabulary(uuidVocAlgaTerraLifeForm, "Lifeform", "Lifeform", abbrevLabel, uri, isOrdered, null);

			Feature feature = getFeature(state, uuidFeatureAlgaTerraClimate, "Climate","Climate", null, null);

			feature.setSupportsCategoricalData(true);

			feature = getFeature(state, uuidFeatureAlgaTerraLifeForm, "LifeForm","LifeForm", null, null);

			feature.setSupportsCategoricalData(true);

			feature = Feature.HABITAT();

			feature.setSupportsCategoricalData(true);

			getTermService().saveOrUpdate(feature);

			Source source = state.getAlgaTerraConfigurator().getSource();

			String climateSql = "SELECT * FROM EcoClimate";

			ResultSet rs = source.getResultSet(climateSql);

			while (rs.next()){

				String climate = rs.getString("Climate");

				String description = rs.getString("Description");

				Integer id = rs.getInt("ClimateId");

				UUID uuid = UUID.fromString(rs.getString("UUID"));

				State stateTerm = getStateTerm(state, uuid, climate, description, null, climateVoc);

				addOriginalSource(stateTerm, id.toString(), "EcoClimate", state.getTransactionalSourceReference());

				getTermService().saveOrUpdate(stateTerm);

			}

			String habitatSql = "SELECT * FROM EcoHabitat";

			rs = source.getResultSet(habitatSql);

			while (rs.next()){

				String habitat = rs.getString("Habitat");

				String description = rs.getString("Description");

				Integer id = rs.getInt("HabitatId");

				UUID uuid = UUID.fromString(rs.getString("UUID"));

				State stateTerm = getStateTerm(state, uuid, habitat, description, null, habitatVoc);

				addOriginalSource(stateTerm, id.toString(), "EcoHabitat", state.getTransactionalSourceReference());

				getTermService().saveOrUpdate(stateTerm);

			}

			String lifeformSql = "SELECT * FROM EcoLifeForm";

			rs = source.getResultSet(lifeformSql);

			while (rs.next()){

				String lifeform = rs.getString("LifeForm");

				String description = rs.getString("Description");

				Integer id = rs.getInt("LifeFormId");

				UUID uuid = UUID.fromString(rs.getString("UUID"));

				State stateTerm = getStateTerm(state, uuid, lifeform, description, null, lifeformVoc);

				addOriginalSource(stateTerm, id.toString(), "EcoLifeForm", state.getTransactionalSourceReference());

				getTermService().saveOrUpdate(stateTerm);

			}

			this.commitTransaction(txStatus);

			state.setSpecimenVocabulariesCreated(true);

		}

	}

	protected String getLocalityString(){

		return "Locality";

	}

	protected void handleSingleSpecimen(ResultSet rs, DerivedUnitFacade facade, AlgaTerraImportState state) throws SQLException {

		//FIXME missing fields #3084, #3085, #3080

		try {

			String locality = rs.getString(getLocalityString());

			Double latitude = nullSafeDouble(rs, "Latitude");

			Double longitude = nullSafeDouble(rs, "Longitude");

			Integer errorRadius = nullSafeInt(rs,"Prec");

			String geoCodeMethod = rs.getString("GeoCodeMethod");

			Integer altitude = nullSafeInt(rs, "Altitude");

			Integer lowerAltitude = nullSafeInt(rs,"AltitudeLowerValue");

			String altitudeUnit = rs.getString("AltitudeUnit");

			Double depth = nullSafeDouble(rs, "Depth");

			Double depthLow = nullSafeDouble(rs, "DepthLow");

			String collectorsNumber = rs.getString("CollectorsNumber");

			Date collectionDateStart = rs.getDate("CollectionDate");

			Date collectionDateEnd = rs.getDate("CollectionDateEnd");

			//location

			facade.setLocality(locality);

			//exact location

			ReferenceSystem referenceSystem = makeRefrenceSystem(geoCodeMethod, state);

			if (longitude != null || latitude != null || referenceSystem != null || errorRadius != null){

				Point exactLocation = Point.NewInstance(longitude, latitude, referenceSystem, errorRadius);

				facade.setExactLocation(exactLocation);

			}

			//altitude, depth

			if (StringUtils.isNotBlank(altitudeUnit) && ! altitudeUnit.trim().equalsIgnoreCase("m")){

				logger.warn("Altitude unit is not [m] but: " +  altitudeUnit);

			}

			if ( altitude != null){

				if (lowerAltitude == null){

					facade.setAbsoluteElevation(altitude);

				}else{

			   		if (! facade.isEvenDistance(lowerAltitude, altitude)){

			   			//FIXME there is a ticket for this

			   			altitude = altitude + 1;

			   			logger.info("Current implementation of altitude does not allow uneven distances");

			   		}

					facade.setAbsoluteElevationRange(lowerAltitude,altitude);

			   	}

			}

			if ( depth != null){

				//FIXME needs model change to accept double #3072

				Integer intDepth = depth.intValue();

				if (depthLow == null){

					facade.setDistanceToWaterSurface(intDepth);

				}else{

					//FIXME range not yet in model #3074

			   		facade.setDistanceToWaterSurface(intDepth);

			   	}

			}

			//field

			facade.setFieldNumber(collectorsNumber);

			TimePeriod gatheringPeriod = TimePeriod.NewInstance(collectionDateStart, collectionDateEnd);

			facade.setGatheringPeriod(gatheringPeriod);

			handleCollectorTeam(state, facade, rs);

			//areas

			makeAreas(state, rs, facade);

			//notes

			//TODO is this an annotation on field observation or on the derived unit?

			//TODO id, created for fact +  ecoFact

			//    	this.doIdCreatedUpdatedNotes(state, descriptionElement, rs, id, namespace);

		} catch (Exception e) {

			throw new RuntimeException(e);

		}

	}

	protected DescriptionBase getFieldObservationDescription(DerivedUnitFacade facade) {

		Set<DescriptionBase> descriptions = facade.innerFieldObservation().getDescriptions();

		for (DescriptionBase desc : descriptions){

			if (desc.isImageGallery() == false){

				return desc;

			}

		}

		SpecimenDescription specDesc = SpecimenDescription.NewInstance(facade.innerFieldObservation());

		descriptions.add(specDesc);

		return specDesc;

	}

	private void makeAreas(AlgaTerraImportState state, ResultSet rs, DerivedUnitFacade facade) throws SQLException {

	   	Object gazetteerId = rs.getObject("GazetteerId");

	   	if (gazetteerId != null){

	   		//TDWG

	   		NamedArea tdwgArea;

	   		String tdwg4 = rs.getString("L4Code");

	   		if (isNotBlank(tdwg4)){

	   			tdwgArea = TdwgArea.getAreaByTdwgAbbreviation(tdwg4);

	   		}else{

	   			String tdwg3 = rs.getString("L3Code");

	   			if (isNotBlank(tdwg3)){

	   				tdwgArea = TdwgArea.getAreaByTdwgAbbreviation(tdwg3);

	   			}else{

	   				Integer tdwg2 = rs.getInt("L2Code");   				

	   				tdwgArea = TdwgArea.getAreaByTdwgAbbreviation(String.valueOf(tdwg2));

		   		}

	   		}

	   		if (tdwgArea == null){

	   			logger.warn("TDWG area could not be defined for gazetterId: " + gazetteerId);

	   		}else{

	   			facade.addCollectingArea(tdwgArea);

	   		}

	   		//Countries

	   		WaterbodyOrCountry country = null;

	   		String isoCountry = rs.getString("ISOCountry");

	   		String countryStr = rs.getString("Country");

	   		if (isNotBlank(isoCountry)){

		   		country = WaterbodyOrCountry.getWaterbodyOrCountryByIso3166A2(isoCountry);

	   		}else if (isNotBlank(countryStr)){

	   			logger.warn("Country exists but no ISO code");

	   		}

	   		if (country == null){

	   			logger.warn("Country does not exist for GazetteerID " + gazetteerId);

	   		}else{

	   			facade.setCountry(country);

	   		}

	   	}

	   	//Waterbody

	   	WaterbodyOrCountry waterbody = null;

	   	String waterbodyStr = rs.getString("WaterBody");

	   	if (isNotBlank(waterbodyStr)){

	   		if (waterbodyStr.equals("Atlantic Ocean")){

	   			waterbody = WaterbodyOrCountry.ATLANTICOCEAN();

	   		}else{

	   			logger.warn("Waterbody not recognized: " + waterbody);

	   		}

	   		if (waterbody != null){

	   			facade.addCollectingArea(waterbody);

	   		}

	   	}

	   	//countries sub

	   	//TODO -> SpecimenImport (not existing in TypeSpecimen)

	}

	private ReferenceSystem makeRefrenceSystem(String geoCodeMethod, AlgaTerraImportState state) {

		if (StringUtils.isBlank(geoCodeMethod)){

			return null;

		}else if(geoCodeMethod.startsWith("GPS")){

			getReferenceSystem(state, uuidRefSystemGps, "GPS", "GPS", "GPS", ReferenceSystem.GOOGLE_EARTH().getVocabulary());

			return ReferenceSystem.WGS84(); 

		}else if(geoCodeMethod.startsWith("Google")){

			return ReferenceSystem.GOOGLE_EARTH();

		}else if(geoCodeMethod.startsWith("Map")){

			logger.warn("Reference system " +  geoCodeMethod +  " not yet supported.");

			return null;

		}else if(geoCodeMethod.startsWith("WikiProjekt Georeferenzierung") || geoCodeMethod.startsWith("http://toolserver.org/~geohack/geohack.php") ){

			return ReferenceSystem.WGS84();

		}else {

			logger.warn("Reference system " +  geoCodeMethod +  " not yet supported.");

			return null;

		}

	}

	private void handleCollectorTeam(AlgaTerraImportState state, DerivedUnitFacade facade, ResultSet rs) throws SQLException {

		// FIXME parsen

		String collector = rs.getString("Collector");

		Team team = Team.NewTitledInstance(collector, collector);

		facade.setCollector(team);

	}

}

/**

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

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade;

import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade.DerivedUnitType;

import eu.etaxonomy.cdm.api.facade.DerivedUnitFacadeNotSupportedException;

import eu.etaxonomy.cdm.io.algaterra.validation.AlgaTerraTypeImportValidator;

import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportConfigurator;

import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState;

import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelReferenceImport;

import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelTaxonNameImport;

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;

import eu.etaxonomy.cdm.model.occurrence.FieldObservation;

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

/**

 * @author a.mueller

 * @created 20.03.2008

 * @version 1.0

 */

@Component

public class AlgaTerraTypeImport  extends AlgaTerraSpecimenImportBase {

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

	private static int modCount = 5000;

	private static final String pluralString = "types";

	private static final String dbTableName = "TypeDesignation";  //??  

	protected String getLocalityString(){

		return "TypeLocality";

	}

	public AlgaTerraTypeImport(){

		super();

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getIdQuery()

	 */

	@Override

	protected String getIdQuery(BerlinModelImportState state) {

		String result = " SELECT TypeDesignationId "  

				+ " FROM TypeDesignation " 

				+ " ORDER BY NameFk ";

		return result;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getRecordQuery(eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportConfigurator)

	 */

	@Override

	protected String getRecordQuery(BerlinModelImportConfigurator config) {

			String strQuery =    

			" SELECT ts.*, td.*, gz.ID as GazetteerId, gz.L2Code, gz.L3Code, gz.L4Code, gz.ISOCountry, gz.Country, ts.WaterBody " + 

               " " +

            " FROM TypeSpecimenDesignation tsd  " 

            	+ " LEFT OUTER JOIN TypeSpecimen AS ts ON tsd.TypeSpecimenFk = ts.TypeSpecimenId " 

            	+ " FULL OUTER JOIN TypeDesignation td ON  td.TypeDesignationId = tsd.TypeDesignationFk "

            	+ " LEFT OUTER JOIN TDWGGazetteer gz ON ts.TDWGGazetteerFk = gz.ID "

		+ 	" WHERE (td.TypeDesignationId IN (" + ID_LIST_TOKEN + ")  )"  

          + " ORDER BY NameFk "

            ;

		return strQuery;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.berlinModel.in.IPartitionedIO#doPartition(eu.etaxonomy.cdm.io.berlinModel.in.ResultSetPartitioner, eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState)

	 */

	public boolean doPartition(ResultSetPartitioner partitioner, BerlinModelImportState bmState) {

		boolean success = true;

		AlgaTerraImportState state = (AlgaTerraImportState)bmState;

		//TODO check that no duplicate vocabularies will be created, also remove redundant code here

//		and in Specimen importer

		try {

			makeVocabulariesAndFeatures(state);

		} catch (SQLException e1) {

			logger.warn("Exception occurred when trying to create Type specimen vocabularies: " + e1.getMessage());

			e1.printStackTrace();

		}

		Set<TaxonNameBase> namesToSave = new HashSet<TaxonNameBase>();

		Map<String, TaxonNameBase> taxonNameMap = (Map<String, TaxonNameBase>) partitioner.getObjectMap(BerlinModelTaxonNameImport.NAMESPACE);

		Map<String, DerivedUnit> ecoFactMap = (Map<String, DerivedUnit>) partitioner.getObjectMap(AlgaTerraSpecimenImport.ECO_FACT_NAMESPACE);

		Map<String, DerivedUnit> typeSpecimenMap = (Map<String, DerivedUnit>) partitioner.getObjectMap(TYPE_SPECIMEN_NAMESPACE);

		Map<String, Reference> biblioReference = (Map<String, Reference>) partitioner.getObjectMap(BerlinModelReferenceImport.BIBLIO_REFERENCE_NAMESPACE);

		ResultSet rs = partitioner.getResultSet();

		try {

			int i = 0;

			//for each reference

            while (rs.next()){

        		if ((i++ % modCount) == 0 && i!= 1 ){ logger.info("Type designations handled: " + (i-1));}

				int nameId = rs.getInt("nameFk");

				int typeSpecimenId = rs.getInt("TypeSpecimenId");

				int typeDesignationId = rs.getInt("TypeDesignationId");

				Integer typeStatusFk =  nullSafeInt(rs, "typeStatusFk");

				Integer ecoFactId = nullSafeInt(rs, "ecoFactFk");

//				String recordBasis = rs.getString("RecordBasis");

				try {

					//source ref

					Reference<?> sourceRef = state.getTransactionalSourceReference();

					//facade

					//FIXME - depends on material category

//					DerivedUnitType type = makeDerivedUnitType(recordBasis);

					DerivedUnitType type = DerivedUnitType.Specimen;

					DerivedUnitFacade facade = getDerivedUnit(state, typeSpecimenId, typeSpecimenMap, type, ecoFactMap, ecoFactId);

					//field observation

					handleSingleSpecimen(rs, facade, state);

					handleTypeSpecimenSpecificSpecimen(rs,facade, state);

					state.setCurrentFieldObservationNotNew(false);

					//Designation

					TaxonNameBase<?,?> name = getTaxonName(state, taxonNameMap, nameId);

					SpecimenTypeDesignation designation = SpecimenTypeDesignation.NewInstance();

					SpecimenTypeDesignationStatus status = getSpecimenTypeDesignationStatusByKey(typeStatusFk);

					designation.setTypeSpecimen(facade.innerDerivedUnit());

					designation.setTypeStatus(status);

					if (name != null){

						name.addTypeDesignation(designation, true); //TODO check if true is correct

					}else{

						logger.warn("Name could not be found for type designation " + typeDesignationId);

					}

					namesToSave.add(name); 

				} catch (Exception e) {

					logger.warn("Exception in TypeDesignation: TypeDesignationId " + typeDesignationId + ". " + e.getMessage());

					e.printStackTrace();

				} 

            }

//            logger.warn("Specimen: " + countSpecimen + ", Descriptions: " + countDescriptions );

			logger.warn("Names to save: " + namesToSave.size());

			getNameService().save(namesToSave);	

			return success;

		} catch (SQLException e) {

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

			return false;

		}

	}

	/**

	 * @param state 

	 * @param taxonNameMap

	 * @param nameId

	 * @return

	 */

	private TaxonNameBase getTaxonName(AlgaTerraImportState state, Map<String, TaxonNameBase> taxonNameMap, int nameId) {

		TaxonNameBase result;

		if (state.getConfig().isDoTaxonNames()){

			result = taxonNameMap.get(String.valueOf(nameId));

		}else{

			//for testing

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

		}

		return result;

	}

	private void handleTypeSpecimenSpecificSpecimen(ResultSet rs, DerivedUnitFacade facade, AlgaTerraImportState state) throws SQLException {

		//TODO

		//collection

		String barcode = rs.getString("Barcode");

		if (StringUtils.isNotBlank(barcode)){

			facade.setBarcode(barcode);

		}

	}

	/**

	 * @param state

	 * @param ecoFactId

	 * @param derivedUnitMap

	 * @param type 

	 * @param ecoFactId2 

	 * @param ecoFactMap 

	 * @return

	 */

	private DerivedUnitFacade getDerivedUnit(AlgaTerraImportState state, int typeSpecimenId, Map<String, DerivedUnit> typeSpecimenMap, DerivedUnitType type, Map<String, DerivedUnit> ecoFactMap, Integer ecoFactId2) {

		//TODO implement ecoFact map - if not all null anymore

		String typeKey = String.valueOf(typeSpecimenId);

		DerivedUnit derivedUnit = typeSpecimenMap.get(typeKey);

		DerivedUnitFacade facade;

		if (derivedUnit == null){

			facade = DerivedUnitFacade.NewInstance(type);

			typeSpecimenMap.put(typeKey, derivedUnit);

		}else{

			try {

				facade = DerivedUnitFacade.NewInstance(derivedUnit);

			} catch (DerivedUnitFacadeNotSupportedException e) {

				logger.error(e.getMessage());

				facade = DerivedUnitFacade.NewInstance(type);

			}

		}

		return facade;

	}

	private DerivedUnitType makeDerivedUnitType(String recordBasis) {

		DerivedUnitType result = null;

		if (StringUtils.isBlank(recordBasis)){

			result = DerivedUnitType.DerivedUnit;

		} else if (recordBasis.equalsIgnoreCase("FossileSpecimen")){

			result = DerivedUnitType.Fossil;

		}else if (recordBasis.equalsIgnoreCase("HumanObservation")){

			result = DerivedUnitType.Observation;

		}else if (recordBasis.equalsIgnoreCase("Literature")){

			logger.warn("Literature record basis not yet supported");

			result = DerivedUnitType.DerivedUnit;

		}else if (recordBasis.equalsIgnoreCase("LivingSpecimen")){

			result = DerivedUnitType.LivingBeing;

		}else if (recordBasis.equalsIgnoreCase("MachineObservation")){

			logger.warn("MachineObservation record basis not yet supported");

			result = DerivedUnitType.Observation;

		}else if (recordBasis.equalsIgnoreCase("PreservedSpecimen")){

			result = DerivedUnitType.Specimen;

		}

		return result;

	}

	private SpecimenTypeDesignationStatus getSpecimenTypeDesignationStatusByKey(Integer typeStatusFk) {

		if (typeStatusFk == null){ return null;

		}else if (typeStatusFk == 1) { return SpecimenTypeDesignationStatus.HOLOTYPE();

		}else if (typeStatusFk == 2) { return SpecimenTypeDesignationStatus.LECTOTYPE();

		}else if (typeStatusFk == 3) { return SpecimenTypeDesignationStatus.NEOTYPE();

		}else if (typeStatusFk == 4) { return SpecimenTypeDesignationStatus.EPITYPE();

		}else if (typeStatusFk == 5) { return SpecimenTypeDesignationStatus.ISOLECTOTYPE();

		}else if (typeStatusFk == 6) { return SpecimenTypeDesignationStatus.ISONEOTYPE();

		}else if (typeStatusFk == 7) { return SpecimenTypeDesignationStatus.ISOTYPE();

		}else if (typeStatusFk == 8) { return SpecimenTypeDesignationStatus.PARANEOTYPE();

		}else if (typeStatusFk == 9) { return SpecimenTypeDesignationStatus.PARATYPE();

		}else if (typeStatusFk == 10) { return SpecimenTypeDesignationStatus.SECOND_STEP_LECTOTYPE();

		}else if (typeStatusFk == 11) { return SpecimenTypeDesignationStatus.SECOND_STEP_NEOTYPE();

		}else if (typeStatusFk == 12) { return SpecimenTypeDesignationStatus.SYNTYPE();

		}else if (typeStatusFk == 13) { return SpecimenTypeDesignationStatus.PARALECTOTYPE();

		}else if (typeStatusFk == 14) { return SpecimenTypeDesignationStatus.ISOEPITYPE();

		}else if (typeStatusFk == 21) { return SpecimenTypeDesignationStatus.ICONOTYPE();

		}else if (typeStatusFk == 22) { return SpecimenTypeDesignationStatus.PHOTOTYPE();

		}else if (typeStatusFk == 30) { return SpecimenTypeDesignationStatus.TYPE();

		}else if (typeStatusFk == 38) { return SpecimenTypeDesignationStatus.ISOEPITYPE();

//		}else if (typeStatusFk == 39) { return SpecimenTypeDesignationStatus.;

		}else if (typeStatusFk == 40) { return SpecimenTypeDesignationStatus.ORIGINAL_MATERIAL();

		}else{

			logger.warn("typeStatusFk undefined for " +  typeStatusFk);

			return SpecimenTypeDesignationStatus.TYPE();

		}

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.berlinModel.in.IPartitionedIO#getRelatedObjectsForPartition(java.sql.ResultSet)

	 */

	public Map<Object, Map<String, ? extends CdmBase>> getRelatedObjectsForPartition(ResultSet rs) {

		String nameSpace;

		Class cdmClass;

		Set<String> idSet;

		Map<Object, Map<String, ? extends CdmBase>> result = new HashMap<Object, Map<String, ? extends CdmBase>>();

		try{

			Set<String> nameIdSet = new HashSet<String>();

			Set<String> ecoFieldObservationIdSet = new HashSet<String>();

			Set<String> typeSpecimenIdSet = new HashSet<String>();

			Set<String> termsIdSet = new HashSet<String>();

			while (rs.next()){

				handleForeignKey(rs, nameIdSet, "nameFk");

				handleForeignKey(rs, ecoFieldObservationIdSet, "ecoFactFk");

				handleForeignKey(rs, typeSpecimenIdSet, "TypeSpecimenId");

			}

			//name map

			nameSpace = BerlinModelTaxonNameImport.NAMESPACE;

			cdmClass = TaxonNameBase.class;

			idSet = nameIdSet;

			Map<String, TaxonNameBase> objectMap = (Map<String, TaxonNameBase>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);

			result.put(nameSpace, objectMap);

			//eco fact field observation map

			nameSpace = AlgaTerraTypeImport.ECO_FACT_NAMESPACE;

			cdmClass = FieldObservation.class;

			idSet = ecoFieldObservationIdSet;

			Map<String, FieldObservation> fieldObservationMap = (Map<String, FieldObservation>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);

			result.put(nameSpace, fieldObservationMap);

			//type specimen map

			nameSpace = AlgaTerraTypeImport.TYPE_SPECIMEN_NAMESPACE;

			cdmClass = FieldObservation.class;

			idSet = typeSpecimenIdSet;

			Map<String, FieldObservation> typeSpecimenMap = (Map<String, FieldObservation>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);

			result.put(nameSpace, typeSpecimenMap);

			//

//			//terms

//			nameSpace = AlgaTerraTypeImport.TERMS_NAMESPACE;

//			cdmClass = FieldObservation.class;

//			idSet = taxonIdSet;

//			Map<String, DefinedTermBase> termMap = (Map<String, DefinedTermBase>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);

//			result.put(nameSpace, termMap);

		} catch (SQLException e) {

			throw new RuntimeException(e);

		}

		return result;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doCheck(eu.etaxonomy.cdm.io.common.IoStateBase)

	 */

	@Override

	protected boolean doCheck(BerlinModelImportState state){

		IOValidator<BerlinModelImportState> validator = new AlgaTerraTypeImportValidator();

		return validator.validate(state);

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getTableName()

	 */

	@Override

	protected String getTableName() {

		return dbTableName;

	}

	/* (non-Javadoc)

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

	 */

	@Override

	public String getPluralString() {

		return pluralString;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.common.CdmIoBase#isIgnore(eu.etaxonomy.cdm.io.common.IImportConfigurator)

	 */

	protected boolean isIgnore(BerlinModelImportState state){

		return ! state.getConfig().isDoTypes();

	}

}

// $Id$

/**

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

import java.sql.ResultSet;

import java.sql.SQLException;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportConfigurator;

import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState;

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

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

/**

 * @author a.mueller

 * @created 17.02.2010

 * @version 1.0

 */

public class AlgaTerraTypeImportValidator implements IOValidator<BerlinModelImportState> {

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

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.common.IOValidator#validate(eu.etaxonomy.cdm.io.common.IoStateBase)

	 */

	public boolean validate(BerlinModelImportState state) {

		boolean result = true;

		BerlinModelImportConfigurator bmiConfig = state.getConfig();

		result &= checkMultipleEntriesInTypeSpecimenDesignation(bmiConfig);

		//result &= checkPartOfJournal(bmiConfig);

		System.out.println("Checking for Specimen not yet fully implemented");

		return result;

	}

	//******************************** CHECK *************************************************

		private static boolean checkMultipleEntriesInTypeSpecimenDesignation(BerlinModelImportConfigurator config){

			try {

				boolean result = true;

				Source source = config.getSource();

				String strQuery = " SELECT COUNT(*) AS n, TypeSpecimenFk " +

							" FROM TypeSpecimenDesignation " +

							" GROUP BY TypeSpecimenFk " +

							" HAVING (COUNT(*) > 1)  ";

				ResultSet resulSet = source.getResultSet(strQuery);

				if (resulSet.next()){

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

					System.out.println("There are multiple TypeSpecimenDesignations sharing the same TypeSpecimen!");

					System.out.println("This is not supported by the current import and will lead to duplicates!");

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

					result = false;

				}

				strQuery = " SELECT COUNT(*) AS n, TypeDesignationFk " +

						" FROM TypeSpecimenDesignation " +

						" GROUP BY TypeDesignationFk " +

						" HAVING (COUNT(*) > 1)  ";

				resulSet = source.getResultSet(strQuery);

				if (resulSet.next()){

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

					System.out.println("There are multiple TypeSpecimenDesignations sharing the same TypeDesignation!");

					System.out.println("This is not supported by the current import and will lead to duplicates!");

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

					result = false;

				}

				return result;

			} catch (SQLException e) {

				e.printStackTrace();

				return false;

			}

		}

}