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 abstract class GlobisImportBase<CDM_BASE extends CdmBase> extends CdmImportBase<GlobisImportConfigurator, GlobisImportState> implements ICdmIO<GlobisImportState>, IPartitionedIO<GlobisImportState> {

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

	public static final UUID ID_IN_SOURCE_EXT_UUID = UUID.fromString("23dac094-e793-40a4-bad9-649fc4fcfd44");

	//NAMESPACES

	protected static final String REFERENCE_NAMESPACE = "Literatur";

	protected static final String TAXON_NAMESPACE = "current_species";

	protected static final String COLLECTION_NAMESPACE = "Collection";

	protected static final String IMAGE_NAMESPACE = "Einzelbilder";

	protected static final String SPEC_TAX_NAMESPACE = "specTax";

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

	/**

	 * @param dbTableName

	 */

	public GlobisImportBase(String pluralString, String dbTableName, Class<?> cdmTargetClass) {

		this.pluralString = pluralString;

		this.cdmTargetClass = cdmTargetClass;

	}

		logger.info("start make " + getPluralString() + " ...");

		GlobisImportConfigurator config = state.getConfig();

		Source source = config.getSource();

		String strIdQuery = getIdQuery();

		String strRecordQuery = getRecordQuery(config);

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

			state.setUnsuccessfull();

		}

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

		return;

	}

					doubtfulAuthorAndYear = authorAndYear;

					authorAndYear = authorAndYear.replace("[", "").replace("]", "");

				}

				parser.parseAuthors(zooName, authorAndYear);

				deduplicateAuthors(zooName, state);

				if (doubtfulAuthorAndYear != null){

					zooName.setAuthorshipCache(doubtfulAuthorAndYear, true);

				}

			} catch (StringNotParsableException e) {

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

				zooName.setAuthorshipCache(authorAndYear, true);

			state.putTeam(teamStr, team);

			getAgentService().save(team);

		}

		zooName.setPublicationYear(1775);

		zooName.setAuthorshipCache("[Denis & Schifferm\u00FCller], 1775", true);

	}

	private void deduplicateAuthors(ZoologicalName zooName, GlobisImportState state) {

	}

	private TeamOrPersonBase<?> getExistingAuthor(INomenclaturalAuthor nomAuthor, GlobisImportState state) {

						try {

							getAgentService().update(existingPerson);

						} catch (NonUniqueObjectException nuoe){

							existingPerson = CdmBase.deproxy(getAgentService().find(existingPerson.getUuid()), Person.class);

							state.putPerson(existingPerson.getTitleCache(), existingPerson);

						} catch (Exception e) {

							throw new RuntimeException (e);

						}

						newTeam.addTeamMember(existingPerson);

//						logger.warn("newTeam " + newTeam.getId());

					}else{

						newTeam.addTeamMember(member);

				}

				author = newTeam;

			}

			return saveAndDecide(existingTeam, author, key, state);

		}else{

			logger.warn("Author type not supported: " + author.getClass().getName());

			try {

				getAgentService().update(existing);

			} catch (NonUniqueObjectException nuoe){

				existing = CdmBase.deproxy(getAgentService().find(existing.getUuid()), TeamOrPersonBase.class);

				putAgent(existing, key, state);

			} catch (Exception e) {

		NamedArea country = Country.getCountryByLabel(countryStr);

		if (country == null){

			try {

			} catch (UndefinedTransformerMethodException e) {

				e.printStackTrace();

			}

		return country;

	}

		boolean success = true ;

		Set objectsToSave = new HashSet();

 		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;

	}

	/**

	 * @return

	 */

	protected /*abstract*/ DbImportMapping<?, ?> getMapping(){

		return null;

	}

	/**

	 * @return

	 */

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

		return result;

	}

	/* (non-Javadoc)

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

	 */

		return pluralString;

	}

	protected String getTableName(){

		return this.dbTableName;

	}

	protected boolean doIdCreatedUpdatedNotes(GlobisImportState state, IdentifiableEntity identifiableEntity, ResultSet rs, long id, String namespace)

			throws SQLException{

		boolean success = true;

		success &= doCreatedUpdatedNotes(state, identifiableEntity, rs, namespace);

		return success;

	}

	protected boolean doCreatedUpdatedNotes(GlobisImportState state, AnnotatableEntity annotatableEntity, ResultSet rs, String namespace)

			throws SQLException{

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

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

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

		boolean success  = true;

		//Created When, Who, Updated When Who

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

			//do nothing

		}else {

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

		}

		//notes

		if (StringUtils.isNotBlank(notes)){

			String notesString = String.valueOf(notes);

		}

		return success;

	}

	private User getUser(String userString, GlobisImportState state){

		if (isBlank(userString)){

			return null;

		}

		userString = userString.trim();

		User user = state.getUser(userString);

		if (user == null){

			user = getTransformedUser(userString,state);

		}

		return user;

	}

	private User getTransformedUser(String userString, GlobisImportState state){

		Method method = state.getConfig().getUserTransformationMethod();

		if (method == null){

	}

	private User makeNewUser(String userString, GlobisImportState state){

		User user = User.NewInstance(userString, pwd);

		state.putUser(userString, user);

		getUserService().save(user);

		logger.info("Added new user: " + userString);

		return user;

	}

	private String getPassword(){

		String result = UUID.randomUUID().toString();

		return result;

	}

	private DateTime getDateTime(Object timeString){

		if (timeString == null){

			return null;

		}

		return dateTime;

	}

	/**

	 * Reads a foreign key field from the result set and adds its value to the idSet.

	 * @param rs

			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));}

	}

}