EDIT

	static final ICdmDataSource cdmDestination = CdmDestinations.localH2();

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

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

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

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

			OrderedTermVocabulary<NamedArea> informalAreasVoc = (OrderedTermVocabulary<NamedArea>)getVocabulary(TermType.NamedArea, AlgaTerraImportTransformer.uuidNamedAreaVocAlgaTerraInformalAreas, "AlgaTerra Specific Areas", "AlgaTerra Specific Areas", abbrevLabel, uri, true, NamedArea.NewInstance());

			String areaSql = "SELECT * FROM TDWGGazetteer WHERE subL4 = 1 ";

			rs = source.getResultSet(areaSql);

			while (rs.next()){

				String l1Code = rs.getString("L1Code");

				String l2Code = rs.getString("L2Code");

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

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

				String gazetteer = rs.getString("Gazetteer");

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

				String notes = rs.getString("Notes");

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

				String tdwgCode =  (l4Code != null) ? l4Code : (l3Code != null) ? l3Code : (l2Code != null) ? l2Code : l1Code;

				NamedArea tdwgArea = TdwgAreaProvider.getAreaByTdwgAbbreviation(tdwgCode);

				NamedArea newArea  = getNamedArea(state, AlgaTerraImportTransformer.uuidNamedAreaPatagonia,gazetteer, gazetteer, null, null, null, informalAreasVoc, TermMatchMode.UUID_ONLY, null);

				if (isNotBlank(notes)){

					newArea.addAnnotation(Annotation.NewInstance(notes, AnnotationType.EDITORIAL(), Language.DEFAULT()));

				}

				addOriginalSource(newArea, id.toString(), "TDWGGazetteer", state.getTransactionalSourceReference());

				getTermService().saveOrUpdate(newArea);

				newArea.setPartOf(tdwgArea);

				informalAreasVoc.addTerm(newArea);

			}

import java.sql.Timestamp;

import org.joda.time.DateTime;

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

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

import eu.etaxonomy.cdm.io.common.IImportConfigurator.EDITOR;

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

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

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

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

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

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

               " ts.RefFk as tsRefFk, ts.RefDetailFk as tsRefDetailFk, td.RefFk as tdRefFk, td.RefDetailFk as tdRefDetailFk, " +

               " RefDet.Details as tdRefDetails, " +

               " td.created_When tdCreated_When, tsd.created_When tsdCreated_When, td.updated_when tdUpdated_when" +

               " td.created_who tdCreated_who, tsd.created_who tdCreated_who, td.updated_who tdUpdated_who,  " +

            	+ " LEFT OUTER JOIN RefDetail refDet ON td.RefDetailFk = refDet.RefDetailId AND td.RefFk = refDet.RefFk "

	@Override

		Map<String, Reference> refDetailMap = partitioner.getObjectMap(BerlinModelRefDetailImport.REFDETAIL_NAMESPACE);

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

				Boolean restrictedFlag = nullSafeBoolean(rs, "RestrictedFlag");

				String typeSpecimenPhrase = rs.getString("TypeSpecimnePhrase");

				boolean isIcon = typeSpecimenPhrase.toLowerCase().startsWith("[icon");

					if (isIcon){

						//TODO handle images correctly for these specimen

						type = SpecimenOrObservationType.StillImage;

					}else if (typeStatusFk.equals(39)){

						type =  SpecimenOrObservationType.LivingSpecimen;

					}

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

					if (typeStatusFk.equals(39)){

						designation.addAnnotation(Annotation.NewInstance("Type status: Authentic strain", AnnotationType.EDITORIAL(), Language.DEFAULT()));

					}

						Reference<?> typeDesigRef = getReferenceFromMaps(refDetailMap, refMap, String.valueOf(tdRefDetailFk), String.valueOf(tdRefFk));

					if (isNotBlank(tdRefDetails)){

						designation.setCitationMicroReference(tdRefDetails);

					}

					//ID: Type designations do not allow OriginalSources

					designation.addAnnotation(Annotation.NewInstance("Id in BerlinModel-TypeDesignation: " + String.valueOf(typeDesignationId), AnnotationType.TECHNICAL(), Language.UNDETERMINED()));

					if (restrictedFlag != null &&restrictedFlag.equals(true)){

						logger.warn("Restricted Flag is expected to be null or 0. TypeDesignationId" + typeDesignationId);

					//Created, Updated

					this.doCreatedUpdated(state, designation, rs);

	/**

	 * same as {@link BerlinModelImportBase#doCreatedUpdatedNotes}, but handles multiple similar fields

	 * @throws SQLException 

	 */

	private void doCreatedUpdated(BerlinModelImportState state, AnnotatableEntity annotatableEntity, ResultSet rs) throws SQLException{

		BerlinModelImportConfigurator config = state.getConfig();

		Object createdWhen = rs.getObject("tsdCreated_When");

		Object tdCreatedWhen = rs.getObject("tdCreated_When");

		if (tdCreatedWhen != null){

			createdWhen = tdCreatedWhen;

		}

		String createdWho = rs.getString("tsdCreated_Who");

		String tdCreatedWho = rs.getString("tdCreated_Who");

		if (tdCreatedWho != null){

			createdWho = tdCreatedWho;

		}

		Object updatedWhen = rs.getObject("tdUpdated_When");

		String updatedWho = rs.getString("tdUpdated_who");

		//Created When, Who, Updated When Who

		if (config.getEditor() == null || config.getEditor().equals(EDITOR.NO_EDITORS)){

			//do nothing

		}else if (config.getEditor().equals(EDITOR.EDITOR_AS_ANNOTATION)){

			String createdAnnotationString = "Berlin Model record was created By: " + String.valueOf(createdWho) + " (" + String.valueOf(createdWhen) + ") ";

			if (updatedWhen != null && updatedWho != null){

				createdAnnotationString += " and updated By: " + String.valueOf(updatedWho) + " (" + String.valueOf(updatedWhen) + ")";

			}

			Annotation annotation = Annotation.NewInstance(createdAnnotationString, Language.DEFAULT());

			annotation.setCommentator(config.getCommentator());

			annotation.setAnnotationType(AnnotationType.TECHNICAL());

			annotatableEntity.addAnnotation(annotation);

		}else if (config.getEditor().equals(EDITOR.EDITOR_AS_EDITOR)){

			User creator = getUser(state, createdWho);

			User updator = getUser(state, updatedWho);

			DateTime created = getDateTime(createdWhen);

			DateTime updated = getDateTime(updatedWhen);

			annotatableEntity.setCreatedBy(creator);

			annotatableEntity.setUpdatedBy(updator);

			annotatableEntity.setCreated(created);

			annotatableEntity.setUpdated(updated);

		}else {

			logger.warn("Editor type not yet implemented: " + config.getEditor());

		}

	}

	private DateTime getDateTime(Object timeString){

		if (timeString == null){

			return null;

		}

		DateTime dateTime = null;

		if (timeString instanceof Timestamp){

			Timestamp timestamp = (Timestamp)timeString;

			dateTime = new DateTime(timestamp);

		}else{

			logger.warn("time ("+timeString+") is not a timestamp. Datetime set to current date. ");

			dateTime = new DateTime();

		}

		return dateTime;

	}

	 * @param sourceRef 

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

				facade.addSource(IdentifiableSource.NewDataImportInstance(typeKey, "TypeSpecimen", sourceRef));

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

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

				handleForeignKey(rs, refDetailIdSet, "tdRefDetailFk");

			//refDetail map

			nameSpace = BerlinModelRefDetailImport.REFDETAIL_NAMESPACE;

			cdmClass = Reference.class;

			idSet = refDetailIdSet;

			Map<String, Reference> refDetailMap= (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);

			result.put(nameSpace, refDetailMap);

import java.sql.ResultSet;

import java.sql.SQLException;

import org.apache.commons.lang.StringUtils;

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

	@SuppressWarnings("unused")

	@Override

		result &= checkOrphanedEcologyFacts(bmiConfig);

		private static boolean checkOrphanedEcologyFacts(BerlinModelImportConfigurator config){

			try {

				boolean result = true;

				Source source = config.getSource();

				String strQuery = "SELECT * FROM Fact " + 

						" WHERE FactCategoryFk = 202 AND ExtensionFk NOT IN (SELECT EcoFactId FROM EcoFact) " +

						" ORDER BY ExtensionFk  ";

				ResultSet resulSet = source.getResultSet(strQuery);

				boolean firstRow = true;

				while (resulSet.next()){

					if (firstRow){

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

						System.out.println("There EcologyFacts with pointing to non existing EcoFacts!");

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

					}

					int factId = resulSet.getInt("FactId");

					int extensionFk = resulSet.getInt("ExtensionFk");

					System.out.println("FactId:" + factId + "\n  ExtensionFk: " + extensionFk);

					result = firstRow = false;

				}

				return result;

			} catch (SQLException e) {

				e.printStackTrace();

				return false;

			}

		}