EDIT

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

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

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

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

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

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

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

	//dirty but acceptable for globis environment

	private Map<Integer,Reference> refMap = new HashMap<Integer,Reference>();

        		Integer idTaxon = nullSafeInt(rs,"IDCurrentSpec");

        		try {

					//common names

					Integer id = nullSafeInt(rs,"ID");

					String isoLang = rs.getString("ISO");

					String strCommonName = rs.getString("commonname");

					Integer refID = nullSafeInt(rs,"ReferenceID");

					String strCountryCode = rs.getString("Code2");

					Taxon taxon = taxonMap.get(String.valueOf(idTaxon));

					if (taxon == null){

						logger.warn("No taxon found for taxonId " + idTaxon);

					}else if (isBlank(strCommonName)){

						logger.warn("No common name string defined for common name ID: " + id);

					}else{

						Language language = getLanguage(isoLang);

						if (language == null){

							logger.warn("No language found for common name ID: " + id);

						}

						NamedArea area = WaterbodyOrCountry.getWaterbodyOrCountryByIso3166A2(strCountryCode);

						if (area == null){

							logger.warn("No country found for common name ID: " + id);

						}

						TaxonDescription taxonDescription = getTaxonDescription(taxon, sourceRef, ! IMAGE_GALLERY,  CREATE);

						CommonTaxonName commonName = CommonTaxonName.NewInstance(strCommonName, language, area);

						taxonDescription.addElement(commonName);

						Reference<?> ref = handleReference(state, refID);

						if (ref == null && refID != null){

							logger.warn("No reference found for common name ID: " + id);

						}else{

							commonName.addSource(String.valueOf(refID), "reference", sourceRef, null);

						}

						objectsToSave.add(taxon); 

					}

					logger.warn("Exception in current_species: IDcurrentspec " + idTaxon + ". " + e.getMessage());

					e.printStackTrace();

	private Map<String,Language> languageMap = new HashMap<String,Language>();

	private Language getLanguage(String isoLang) {

		Language result = languageMap.get(isoLang);

		if (result == null){

			result = getTermService().getLanguageByIso(isoLang);

			if (result == null){

				logger.warn("No language found for iso code: " + isoLang);

		return result;

	private Reference<?> handleReference(GlobisImportState state, Integer refId){

		Reference<?> result = refMap.get(refId);

		if (result == null){

			try {

				String sql = "SELECT * FROM references WHERE ReferenceID = " + refId;

				ResultSet rs = state.getConfig().getSource().getResultSet(sql);

				rs.next();

				String authors = rs.getString("Author(s)");

				String title = rs.getString("Title");

				String details = rs.getString("Details");

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

				result = ReferenceFactory.newGeneric();

				result.setTitleCache(details);

				result.setTitle(title);

				result.setDatePublished(TimePeriod.NewInstance(year));

				TeamOrPersonBase<?> author;

				String[] authorSplit = authors.split("&");

				if (authorSplit.length > 1){

					Team team = Team.NewInstance();

					author = team;

					for (String singleAuthor : authorSplit){

						Person person = makeSingleAuthor(singleAuthor);

						team.addTeamMember(person);

					}

				}else{

					author = makeSingleAuthor(authors);

				}

				result.setAuthorTeam(author);

				refMap.put(refId,result);

				rs.close();

			} catch (SQLException e) {

				e.printStackTrace();

			}

		return result;

	private Person makeSingleAuthor(String authors) {

		Person result = Person.NewTitledInstance(authors);

		return result;

	}

				handleForeignKey(rs, taxonIdSet, "IDCurrentSpec");

//		IOValidator<GlobisImportState> validator = new GlobisCurrentSpeciesImportValidator();

		return true;

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

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

					Taxon species = createObject(rs, state, taxonId);

					Taxon family = getTaxon(state, rs, familyStr, null, Rank.FAMILY(), null, taxonMap, taxonId);

					Taxon subFamily = getTaxon(state, rs, subFamilyStr, null, Rank.SUBFAMILY(), null, taxonMap, taxonId);

					Taxon tribe = getTaxon(state, rs, tribeStr, null, Rank.TRIBE(), null, taxonMap, taxonId);

					Taxon genus = getTaxon(state, rs, genusStr, null, Rank.GENUS(), genusAuthorStr, taxonMap, taxonId);

						Taxon subGenus = getTaxon(state, rs, genusStr, subGenusStr, Rank.SUBGENUS(), subGenusAuthorStr, taxonMap, taxonId);

			NamedArea country = getCountry(state, countryStr);

	private Taxon getTaxon(GlobisImportState state, ResultSet rs, String uninomial, String infraGenericEpi, Rank rank, String author, Map<String, Taxon> taxonMap, Integer taxonId) {

			handleAuthorAndYear(author, name, taxonId);

	public Taxon createObject(ResultSet rs, GlobisImportState state, Integer taxonId)

		handleAuthorAndYear(author, zooName, taxonId);

	private int modCount = 1000;

		Map<String, Specimen> typeMap = (Map<String, Specimen>) partitioner.getObjectMap(TYPE_NAMESPACE);

		Map<String, ZoologicalName> specTaxNameMap = (Map<String, ZoologicalName>) partitioner.getObjectMap(SPEC_TAX_NAMESPACE);

						specimen.addSource(specimenId, "specimenId", refGart, null);

		Pattern pattern = Pattern.compile("(.+)(_.{4}(-.{1,3})?(_Nr\\d{3,4})?_.{2,3}\\.jpg)");

				handleForeignKey(rs, specTaxIdSet, "spectaxID");

			nameSpace = SPEC_TAX_NAMESPACE;

			cdmClass = ZoologicalName.class;

			Map<String, ZoologicalName> specTaxNameMap = (Map<String, ZoologicalName>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);

			result.put(nameSpace, specTaxNameMap);

//			//taxon map

//			nameSpace = TAXON_NAMESPACE;

//			cdmClass = Taxon.class;

//			idSet = currSpecIdSet;

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

//			result.put(nameSpace, taxonMap);

	private void handleTypeKey(ResultSet rs, Set<String> idSet, String specTaxIdAttr, String copyrightAttr) throws SQLException {

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

	protected static final String IMAGE_NAMESPACE = "Einzelbilder";

	protected static final String SPEC_TAX_NAMESPACE = "specTax";

	protected static final String TYPE_NAMESPACE = "specTax.SpecTypeDepository";

			ResultSetPartitioner<GlobisImportState> partitioner = ResultSetPartitioner.NewInstance(source, strIdQuery, strRecordQuery, recordsPerTransaction);

	protected void handleAuthorAndYear(String authorAndYear, ZoologicalName zooName, Integer id) {

				authorAndYear = authorAndYear.replace("M?n?tri?s","M\u00E9n\u00E9tri\u00E9s");

				authorAndYear = authorAndYear.replace("Schifferm?ller","Schifferm\u00fcller");

			logger.warn("Author could not be parsed: " + authorAndYear + " for id "  +id);

	protected NamedArea getCountry(GlobisImportState state, String countryStr) {

		NamedArea country = WaterbodyOrCountry.getWaterbodyOrCountryByLabel(countryStr);

				country = (NamedArea)state.getTransformer().getNamedAreaByKey(countryStr);

				, GlobisCommonNameImport.class

import eu.etaxonomy.cdm.io.common.mapping.UndefinedTransformerMethodException;

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

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

        		//ignore: CountryDummy, currentSpecies, DepositoryDisplay, DepositoryDummy, ReferenceDisplay, SpecDescriptionImageFile, all *Valid*

					//makeMarker1(state, rs, name);   //ignore!

					makeNotAvailable(state, rs, name);

//						ExtensionType exTypeCitedTypeLoc = getExtensionType(state, uuidCitedTypeLocality, "Type locality as cited in original description", "Type locality as cited in original description", null, ExtensionType.DOI().getVocabulary());

//						name.addExtension(citedTypeLocality, exTypeCitedTypeLoc);

						addNameDescription(state, name, uuidCitedTypeLocality, citedTypeLocality, "Type locality as cited in original description");

						ExtensionType exTypeCitedTypeLoc = getExtensionType(state, uuidCitedTypeMaterial, "Type material as cited in original description", "Type material as cited in original description", null, ExtensionType.DOI().getVocabulary());

					name.addSource(String.valueOf(specTaxId), SPEC_TAX_NAMESPACE, state.getTransactionalSourceReference(), null);

	private void makeNotAvailable(GlobisImportState state, ResultSet rs, ZoologicalName name) throws SQLException {

		String notAvailableStr = rs.getString("SpecNotAvailable");

		try {

			if (isNotBlank(notAvailableStr)){

				if (notAvailableStr.contains("not available") ){ 

					UUID uuidNotAvailableMarkerType = state.getTransformer().getMarkerTypeUuid("not available");

					MarkerType markerType = getMarkerType(state, uuidNotAvailableMarkerType, "not available", "not available", null);

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

				}

			}

		} catch (UndefinedTransformerMethodException e) {

			e.printStackTrace();

		}

		//Not available reason

		//TODO make it a vocabulary

		String notAvailableReason = rs.getString("SpecNotAvailableReason");

		if (isNotBlank(notAvailableReason)){

			UUID uuidNotAvailableReason;

			try {

				uuidNotAvailableReason = state.getTransformer().getExtensionTypeUuid("not available reason");

				ExtensionType notAvailableReasonExtType = getExtensionType(state, uuidNotAvailableReason, "Not available reason", "Not available reason", null, null);

				name.addExtension(notAvailableReason, notAvailableReasonExtType);

			} catch (UndefinedTransformerMethodException e) {

				e.printStackTrace();

			} 

		}

	}

	/**

	 * This method is not used anymore as according to Alexander Marker1 should be ignored.

	 * @param state

	 * @param rs

	 * @param name

	 * @throws SQLException

	 */

	private void makeMarker1(GlobisImportState state, ResultSet rs, ZoologicalName name) throws SQLException {

		String marker1Str = rs.getString("Marker1");

		try {

			if (isNotBlank(marker1Str)){

				marker1Str = marker1Str.trim();

				if (marker1Str.contains("checked") || marker1Str.contains("berpr") ){ //überprüft

					UUID uuidCheckedMarkerType;

						uuidCheckedMarkerType = state.getTransformer().getMarkerTypeUuid("checked");

					MarkerType markerType = getMarkerType(state, uuidCheckedMarkerType, "checked", "checked", null);

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

				}

				if (marker1Str.contains("old record") || marker1Str.contains("alte Angabe") ){

					UUID uuidOldRecordMarkerType = state.getTransformer().getMarkerTypeUuid("old record");

					MarkerType markerType = getMarkerType(state, uuidOldRecordMarkerType, "checked", "checked", null);

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

				}

			}

		} catch (UndefinedTransformerMethodException e) {

			e.printStackTrace();

		}

	}

	private void addNameDescription(GlobisImportState state, ZoologicalName name, UUID featureUuid,

			String citedTypeLocality, String featureLabel) {

		Feature feature = getFeature(state, featureUuid,featureLabel,featureLabel, null, null);

		getTaxonNameDescription(name, false, true);

	}

			makeTypeDesignation(name, rs, specimen, specTaxId);

			makeTypeDesignation(name, rs, specimen, specTaxId);

		NamedArea typeCountry = getCountry(state, countryString);

	 * @param specTaxId 

	protected void makeTypeDesignation(ZoologicalName name, ResultSet rs, Specimen specimen, Integer specTaxId) throws SQLException {

		SpecimenTypeDesignationStatus status = getTypeDesigType(specType, specTaxId);

	private SpecimenTypeDesignationStatus getTypeDesigType(String specType, Integer specTaxId) {

		}else if (specType.matches("Holotype(.*Holotypus)?")){

			logger.warn("SpecimenTypeDesignationStatus does not match: " + specType + " in specTaxId "  + specTaxId);

		handleAuthorAndYear(authorAndYearStr, name, specTaxId);

	public Reference<?> createObject(ResultSet rs, GlobisImportState state)

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

	//marker types

	public static final UUID uuidCheckedMarkerType = UUID.fromString("f2a7926f-def1-49a6-b642-9b81e6b1e35c");

	public static final UUID uuidOldRecordMarkerType = UUID.fromString("8616edc5-00d4-40ca-aca4-d48ec32231e9");

	public static final UUID uuidNotAvailableMarkerType = UUID.fromString("6931e584-6fc2-44ab-9084-e6452f8cd5d1");

	//extension types

	public static final UUID uuidExtTypeNotAvailableReason = UUID.fromString("d7dd5632-8c65-4058-b804-d1291560ac4c");

		}else if (area.matches("United States: Alaska")){ return TdwgArea.getAreaByTdwgAbbreviation("ASK");

				logger.warn("Unhandled country '" + area + "' replaced by null" );

		}else if (key.equalsIgnoreCase("not available reason")){return uuidExtTypeNotAvailableReason;

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.common.mapping.InputTransformerBase#getExtensionTypeUuid(java.lang.String)

	 */

	@Override

	public UUID getMarkerTypeUuid(String key)

			throws UndefinedTransformerMethodException {

		if (key == null){return null;

		}else if (key.equalsIgnoreCase("old record")){return uuidOldRecordMarkerType;

		}else if (key.equalsIgnoreCase("checked")){return uuidCheckedMarkerType;

		}else if (key.equalsIgnoreCase("not available")){return uuidNotAvailableMarkerType;

		}

		return null;

	}