EDIT

/**

* 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.app.cuba;

import java.net.URI;

import java.util.UUID;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration;

import eu.etaxonomy.cdm.api.service.ITermService;

import eu.etaxonomy.cdm.app.common.CdmDestinations;

import eu.etaxonomy.cdm.database.DbSchemaValidation;

import eu.etaxonomy.cdm.database.ICdmDataSource;

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

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

import eu.etaxonomy.cdm.io.cuba.CubaImportConfigurator;

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

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

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

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

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

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

/**

 * @author a.mueller

 * @created 04.01.2016

 */

public class CubaActivator {

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

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

	static DbSchemaValidation hbm2dll = DbSchemaValidation.CREATE;

	private static final URI source = monocots();

//    private static final URI source = cyperaceae();

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

	static final ICdmDataSource cdmDestination = CdmDestinations.cdm_test_local_mysql_test();

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

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

	//feature tree uuid

	public static final UUID featureTreeUuid = UUID.fromString("dad6b9b5-693f-4367-a7aa-076cc9c99476");

	//classification

	static final UUID classificationUuid = UUID.fromString("5de394de-9c76-4b97-b04d-71be31c7f44b");

	static final String sourceReferenceTitle = "Cuba import";

	//check - import

	static final CHECK check = CHECK.IMPORT_WITHOUT_CHECK;

	//taxa

	static final boolean doTaxa = true;

	static final boolean doDeduplicate = false;

	static final boolean doDistribution = false;

	private void doImport(ICdmDataSource cdmDestination){

		//make Source

		CubaImportConfigurator config= CubaImportConfigurator.NewInstance(source, cdmDestination);

		config.setClassificationUuid(classificationUuid);

		config.setCheck(check);

//		config.setDoDistribution(doDistribution);

		config.setDoTaxa(doTaxa);

		config.setDbSchemaValidation(hbm2dll);

		config.setSourceReferenceTitle(sourceReferenceTitle);

		CdmDefaultImport<CubaImportConfigurator> myImport = new CdmDefaultImport();

		//...

		if (true){

			System.out.println("Start import from ("+ source.toString() + ") ...");

			config.setSourceReference(getSourceReference(sourceReferenceTitle));

			myImport.invoke(config);

			if (doTaxa){

				FeatureTree tree = makeFeatureNodes(myImport.getCdmAppController().getTermService());

				myImport.getCdmAppController().getFeatureTreeService().saveOrUpdate(tree);

			}

			System.out.println("End import from ("+ source.toString() + ")...");

		}

		//deduplicate

		if (doDeduplicate){

			ICdmApplicationConfiguration app = myImport.getCdmAppController();

			int count = app.getAgentService().deduplicate(Person.class, null, null);

			logger.warn("Deduplicated " + count + " persons.");

//			count = app.getAgentService().deduplicate(Team.class, null, null);

//			logger.warn("Deduplicated " + count + " teams.");

			count = app.getReferenceService().deduplicate(Reference.class, null, null);

			logger.warn("Deduplicated " + count + " references.");

		}

	}

	private Reference<?> getSourceReference(String string) {

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

		result.setTitleCache(string, true);

		return result;

	}

	private FeatureTree makeFeatureNodes(ITermService service){

//		CyprusTransformer transformer = new CyprusTransformer();

		FeatureTree result = FeatureTree.NewInstance(featureTreeUuid);

		result.setTitleCache("Cuba Feature Tree", true);

		FeatureNode root = result.getRoot();

		FeatureNode newNode;

//		newNode = FeatureNode.NewInstance(Feature.STATUS());

//		root.addChild(newNode);

		newNode = FeatureNode.NewInstance(Feature.DISTRIBUTION());

		root.addChild(newNode);

//		newNode = FeatureNode.NewInstance(Feature.SYSTEMATICS());

//		root.addChild(newNode);

		//user defined features

//		String [] featureList = new String[]{"Red Book", "Endemism"};

//		addFeataureNodesByStringList(featureList, root, transformer, service);

		return result;

	}

	//Monocots

	public static URI monocots() {

	    return URI.create("file:////BGBM-PESIHPC/Cuba/Monocot.xlsx");

	}

	//Cyperaceae

	public static URI cyperaceae() {

	    return URI.create("file:////BGBM-PESIHPC/Cuba/Cyper_Poaceae.xlsx");

	}

	/**

	 * @param args

	 */

	public static void main(String[] args) {

	    CubaActivator me = new CubaActivator();

		me.doImport(cdmDestination);

	}

}

/**

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

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.common.CdmUtils;

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

import eu.etaxonomy.cdm.io.cyprus.CyprusRow;

import eu.etaxonomy.cdm.io.excel.common.ExcelImporterBase;

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.description.Distribution;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.strategy.parser.INonViralNameParser;

import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;

/**

 * @author a.mueller

 * @created 05.01.2016

 */

@Component

public class CubaExcelImport extends ExcelImporterBase<CubaImportState> {

    private static final long serialVersionUID = -747486709409732371L;

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

    private static INonViralNameParser<?> nameParser = NonViralNameParserImpl.NewInstance();

    private static NomenclaturalCode nc = NomenclaturalCode.ICNAFP;

    private  static List<String> expectedKeys= Arrays.asList(new String[]{"Fam.","(Fam.)","Taxón","(Notas)","Syn.","End","Ind","Ind? D","Nat","Dud P","Adv","Cult C","CuW","PR PR*","Art","Hab(*)","May","Mat","IJ","CuC","VC","Ci","SS","CA","Cam","LT","CuE","Gr","Ho","SC","Gu","Esp","Ja","PR","Men","Bah","Cay","AmN","AmC","AmS","VM"});

    private  static List<String> dummy= Arrays.asList(new String[]{

            "(Fam.)","Syn.","Ind? D","Nat","Dud P","Adv","Cult C",

            "CuW","PR PR*","Art","Hab(*)","May","Mat","IJ",

            "CuC","VC","Ci","SS","CA","Cam","LT",

            "CuE","Gr","Ho","SC","Gu",

            "Esp","Ja","PR","Men","Bah","Cay",

            "AmN","AmC","AmS","VM"});

	@Override

    protected void analyzeRecord(HashMap<String, String> record, CubaImportState state) {

		Set<String> keys = record.keySet();

        for (String key: keys) {

            if (! expectedKeys.contains(key)){

                logger.warn("Unexpected Key: " + key);

            }

        }

        //Fam.

        TaxonNode familyTaxon = getFamilyTaxon(record, state);

        if (familyTaxon == null){

            logger.warn("Family not recognized. Do not handle row");

            return;

        }

        //(Fam.)

        //TODO

        //Taxón

        Taxon taxon = makeTaxon(record, state, familyTaxon);

        //(Notas)

        makeNotes(record, state, taxon);

        //Syn.

        makeSynonyms(record, state, taxon);

        //End, Ind, Ind? D, Nat N, Dud P, Adv A, Cult C

        makeCubanDistribution(record, state, taxon);

    	return;

    }

    /**

     * @param record

     * @param state

     * @param taxon

     */

    private void makeCubanDistribution(HashMap<String, String> record, CubaImportState state, Taxon taxon) {

        try {

            NamedArea cuba = getNamedArea(state, state.getTransformer().getNamedAreaUuid("C"), null, null, null, null, null);

            TaxonDescription desc = getTaxonDescription(taxon, false, true);

            PresenceAbsenceTerm status =  makeCubanStatus(record, state);

            Distribution distribution = Distribution.NewInstance(cuba, status);

            desc.addElement(distribution);

        } catch (UndefinedTransformerMethodException e) {

            e.printStackTrace();

        }

    }

    /**

     * @param record

     * @param state

     * @return

     * @throws UndefinedTransformerMethodException

     */

    private PresenceAbsenceTerm makeCubanStatus(HashMap<String, String> record, CubaImportState state) throws UndefinedTransformerMethodException {

        boolean isAbsent = false;  //TODO

        String endemicStr = getValue(record, "End");

        String indigenousStr = getValue(record, "Ind");

        String indigenousDoubtStr = getValue(record, "Ind? D");

        String naturalisedStr = getValue(record, "Nat");

        String dudStr = getValue(record, "Dud P");

        String advStr = getValue(record, "Adv");

        String cultStr = getValue(record, "Cult C");

        if (endemicStr != null){

            boolean allNull = checkAllNull(indigenousStr, indigenousDoubtStr, naturalisedStr, dudStr, advStr, cultStr);

            if (!endemicStr.equals("+")){

                logger.warn("Endemic not recognized: " + endemicStr);

                return null;

            }else if (! allNull){

                logger.warn("Cuban state is endemic but others exist");

                return null;

            }else{

                return PresenceAbsenceTerm.ENDEMIC_FOR_THE_RELEVANT_AREA();

            }

        }else if (indigenousStr != null){

            boolean allNull = checkAllNull(indigenousDoubtStr, naturalisedStr, dudStr, advStr, cultStr);

            if (!checkPlusMinus(indigenousStr)){

                logger.warn("Indigenous not recognized: " + indigenousStr);

                return null;

            }else if (! allNull){

                //TODO may this exist?

                logger.warn("Cuban state is indigenous but others exist");

                return null;

            }else if(indigenousStr.equals("+")){

                UUID indigenousUuid = state.getTransformer().getPresenceTermUuid("Ind.");

                PresenceAbsenceTerm indigenousState = getPresenceTerm(state, indigenousUuid, null, null, null);

                return indigenousState;

            }else if(indigenousStr.equals("-") || indigenousStr.equals("–")){

                logger.warn("Indigenous status '-' not yet handled)");

                return PresenceAbsenceTerm.ABSENT();

            }else{

                logger.warn("Indigenous not recognized: " + indigenousStr);

                return null;

            }

        }else if(indigenousDoubtStr != null){

        }

        return null;

    }

    /**

     * @param indigenousStr

     * @return

     */

    private boolean checkPlusMinus(String str) {

        return str.equals("+") || str.equals("-") || str.equals("–");

    }

    /**

     * @param indigenousStr

     * @param indigenousDoubtStr

     * @param naturalisedStr

     * @param dudStr

     * @param advStr

     * @param cultStr

     */

    private boolean checkAllNull(String ... others) {

        for (String other : others){

            if (other != null){

                return false;

            }

        }

        return true;

    }

    /**

     * @param record

     * @param state

     * @param taxon

     */

    private void makeSynonyms(HashMap<String, String> record, CubaImportState state, Taxon taxon) {

        // TODO Auto-generated method stub

    }

    /**

     * @param record

     * @param state

     * @param taxon

     */

    private void makeNotes(HashMap<String, String> record, CubaImportState state, Taxon taxon) {

        String notesStr = getValue(record, "(Notas)");

        if (notesStr == null){

            return;

        }else{

            Annotation annotation = Annotation.NewDefaultLanguageInstance(notesStr);

            //TODO

            annotation.setAnnotationType(AnnotationType.EDITORIAL());

            taxon.addAnnotation(annotation);

        }

    }

    /**

     * @param record

     * @param state

     * @param familyTaxon

     * @return

     */

    private Taxon makeTaxon(HashMap<String, String> record, CubaImportState state, TaxonNode familyNode) {

        String taxonStr = getValue(record, "Taxón");

        if (taxonStr == null){

            return null;

        }

        boolean isAbsent = false;

        if (taxonStr.startsWith("[") && taxonStr.endsWith("]")){

            taxonStr = taxonStr.substring(1, taxonStr.length() - 1);

            isAbsent = true;

        }

        TaxonNameBase<?,?> botanicalName = nameParser.parseFullName(taxonStr, nc, Rank.SPECIES());

        if (botanicalName.isProtectedTitleCache()){

            logger.warn("Taxon could not be parsed: " + taxonStr);

        }

        Reference<?> sec = null;

        Taxon taxon = Taxon.NewInstance(botanicalName, sec);

        familyNode.addChildTaxon(taxon, null, null);

        return taxon;

    }

    /**

     * @param record

     * @param state

     * @return

     */

    private TaxonNode getFamilyTaxon(HashMap<String, String> record, CubaImportState state) {

        String familyStr = getValue(record, "Fam.");

        if (familyStr == null){

            return null;

        }

        Taxon family = state.getHigherTaxon(familyStr);

        TaxonNode familyNode;

        if (family != null){

            familyNode = family.getTaxonNodes().iterator().next();

        }else{

            BotanicalName name = BotanicalName.NewInstance(Rank.FAMILY());

            name.setGenusOrUninomial(familyStr);

            Reference<?> sec = null;

            Taxon taxon = Taxon.NewInstance(name, sec);

            Classification classification = getClassification(state);

            familyNode = classification.addChildTaxon(taxon, sec, null);

        }

        return familyNode;

    }

    /**

     * @param state

     * @return

     */

    private Classification getClassification(CubaImportState state) {

        Classification classification = state.getClassification();

        if (classification == null){

            String name = state.getConfig().getClassificationName();

            //TODO

            Reference<?> sec = null;

            Language language = Language.DEFAULT();

            classification = Classification.NewInstance(name, sec, language);

            state.setClassification(classification);

            getClassificationService().save(classification);

        }

        return classification;

    }

    /**

     * @param record

     * @param originalKey

     * @return

     */

    private String getValue(HashMap<String, String> record, String originalKey) {

        String value = record.get(originalKey);

        if (! StringUtils.isBlank(value)) {

        	if (logger.isDebugEnabled()) { logger.debug(originalKey + ": " + value); }

        	value = CdmUtils.removeDuplicateWhitespace(value.trim()).toString();

        	return value;

        }else{

        	return null;

        }

    }

	private Feature redBookCategory;

	private Feature endemism;

	/**

	 *  Stores taxa records in DB

	 */

	@Override

    protected void firstPass(CubaImportState state) {

		CyprusRow taxonLight = null; //state.getCyprusRow();

		Reference<?> citation = null;

		String microCitation = null;

//		//species name

//		String speciesStr = taxonLight.getSpecies();

//		String subSpeciesStr = taxonLight.getSubspecies();

//		String homotypicSynonymsString = taxonLight.getHomotypicSynonyms();

//		List<String> homotypicSynonymList = Arrays.asList(homotypicSynonymsString.split(";"));

//		String heterotypicSynonymsString = taxonLight.getHeterotypicSynonyms();

//		List<String> heterotypicSynonymList = Arrays.asList(heterotypicSynonymsString.split(";"));

//

//		String systematicsString = taxonLight.getSystematics();

//		String endemismString = taxonLight.getEndemism();

//		String statusString = taxonLight.getStatus();

//		String redBookCategory = taxonLight.getRedDataBookCategory();

//

//		if (StringUtils.isNotBlank(speciesStr)) {

//			boolean speciesIsExisting = false;

//			Taxon mainTaxon = null;

//			//species

//			Taxon speciesTaxon = (Taxon)createTaxon(state, Rank.SPECIES(), speciesStr, Taxon.class, nc);

//			mainTaxon = speciesTaxon;

//

//			//subspecies

//			if (StringUtils.isNotBlank(subSpeciesStr)){

//				Taxon existingSpecies = state.getHigherTaxon(speciesStr);

//				if (existingSpecies != null){

//					speciesIsExisting = true;

//					speciesTaxon = existingSpecies;

//				}

//

//				Taxon subSpeciesTaxon = (Taxon)createTaxon(state, Rank.SUBSPECIES(), subSpeciesStr, Taxon.class, nc);

//

//				if (subSpeciesTaxon != null){

//					makeParent(state, speciesTaxon, subSpeciesTaxon, citation, microCitation);

//				}

//				mainTaxon = subSpeciesTaxon;

//				state.putHigherTaxon(speciesStr, speciesTaxon);

//			}

//

//			if (! speciesIsExisting){

//				makeHigherTaxa(state, taxonLight, speciesTaxon, citation, microCitation);

//			}

//			makeHomotypicSynonyms(state, citation, microCitation, homotypicSynonymList, mainTaxon);

//			makeHeterotypicSynonyms(state, citation, microCitation, heterotypicSynonymList, mainTaxon);

//			makeSystematics(systematicsString, mainTaxon);

//			makeEndemism(endemismString, mainTaxon);

//			makeStatus(statusString, mainTaxon);

//			makeRedBookCategory(redBookCategory, mainTaxon);

//

////			state.putHigherTaxon(higherName, uuid);//(speciesStr, mainTaxon);

//			getTaxonService().save(mainTaxon);

//		}

		return;

    }

	private void makeHigherTaxa(CubaImportState state, CyprusRow taxonLight, Taxon speciesTaxon, Reference citation, String microCitation) {

		String divisionStr = taxonLight.getDivision();

		String genusStr = taxonLight.getGenus();

		String familyStr = taxonLight.getFamily();

		Taxon division = getTaxon(state, divisionStr, Rank.DIVISION(), null, citation, microCitation);

		Taxon family = getTaxon(state, familyStr, Rank.FAMILY(), division, citation, microCitation);

		Taxon genus = getTaxon(state, genusStr, Rank.GENUS(), family, citation, microCitation);

		makeParent(state, genus, speciesTaxon, citation, microCitation)	;

	}

	private Taxon getTaxon(CubaImportState state, String taxonNameStr, Rank rank, Taxon parent, Reference citation, String microCitation) {

		Taxon result;

		if (state.containsHigherTaxon(taxonNameStr)){

			result = state.getHigherTaxon(taxonNameStr);

		}else{

			result = (Taxon)createTaxon(state, rank, taxonNameStr, Taxon.class, nc);

			state.putHigherTaxon(taxonNameStr, result);

			if (parent == null){

				makeParent(state, null,result, citation, microCitation);

			}else{

				makeParent(state, parent, result, citation, microCitation);

			}

		}

		return result;

	}

	private void makeHomotypicSynonyms(CubaImportState state,

			Reference citation, String microCitation, List<String> homotypicSynonymList, Taxon mainTaxon) {

		for (String homotypicSynonym: homotypicSynonymList){

			if (StringUtils.isNotBlank(homotypicSynonym)){

				Synonym synonym = (Synonym)createTaxon(state, null, homotypicSynonym, Synonym.class, nc);

				mainTaxon.addHomotypicSynonym(synonym, citation, microCitation);

			}

		}

	}

	private void makeHeterotypicSynonyms(CubaImportState state, Reference citation, String microCitation, List<String> heterotypicSynonymList, Taxon mainTaxon) {

		for (String heterotypicSynonym: heterotypicSynonymList){

			if (StringUtils.isNotBlank(heterotypicSynonym)){

				Synonym synonym = (Synonym)createTaxon(state, null, heterotypicSynonym, Synonym.class, nc);

				mainTaxon.addSynonym(synonym, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), citation, microCitation);

			}

		}

	}

	private void makeSystematics(String systematicsString, Taxon mainTaxon) {

		//Systematics

		if (StringUtils.isNotBlank(systematicsString)){

			TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);

			TextData textData = TextData.NewInstance(Feature.SYSTEMATICS());

			textData.putText(Language.UNDETERMINED(), systematicsString);

			td.addElement(textData);

		}

	}

	private void makeEndemism(String endemismString, Taxon mainTaxon) {

		//endemism

		if (StringUtils.isNotBlank(endemismString)){

			//OLD - not wanted as marker

//			boolean flag;

//			if (endemismString.trim().equalsIgnoreCase("not endemic") || endemismString.trim().equalsIgnoreCase("ne?")){

//				flag = false;

//			}else if (endemismString.trim().equalsIgnoreCase("endemic")){

//				flag = true;

//			}else{

//				throw new RuntimeException(endemismString + " is not a valid value for endemism");

//			}

//			Marker marker = Marker.NewInstance(MarkerType.ENDEMIC(), flag);

//			mainTaxon.addMarker(marker);

			//text data

			TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);

			TextData textData = TextData.NewInstance(endemism);

			textData.putText(Language.ENGLISH(), endemismString);

			td.addElement(textData);

		}

	}

	private void makeRedBookCategory(String redBookCategory, Taxon mainTaxon) {

		//red data book category

		if (StringUtils.isNotBlank(redBookCategory)){

			TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);

			TextData textData = TextData.NewInstance(this.redBookCategory);

			textData.putText(Language.ENGLISH(), redBookCategory);

			td.addElement(textData);

		}

	}

	/**

	 *  Stores parent-child, synonym and common name relationships

	 */

	@Override

    protected void secondPass(CubaImportState state) {

//		CyprusRow cyprusRow = state.getCyprusRow();

		return;

	}

	/**

	 * @param state

	 * @param rank

	 * @param taxonNameStr

	 * @param authorStr

	 * @param nameStatus

	 * @param nc

	 * @return

	 */

	private TaxonBase createTaxon(CubaImportState state, Rank rank, String taxonNameStr,

			Class statusClass, NomenclaturalCode nc) {

		TaxonBase taxonBase;

		NonViralName taxonNameBase = null;

		if (nc == NomenclaturalCode.ICVCN){

			logger.warn("ICVCN not yet supported");

		}else{

			taxonNameBase =(NonViralName) nc.getNewTaxonNameInstance(rank);

			//NonViralName nonViralName = (NonViralName)taxonNameBase;

			INonViralNameParser parser = nameParser;//NonViralNameParserImpl.NewInstance();

			taxonNameBase = (NonViralName<BotanicalName>)parser.parseFullName(taxonNameStr, nc, rank);

			//taxonNameBase.setNameCache(taxonNameStr);

		}

		//Create the taxon

		Reference sec = state.getConfig().getSourceReference();

		// Create the status

		if (statusClass.equals(Taxon.class)){

			taxonBase = Taxon.NewInstance(taxonNameBase, sec);

		}else if (statusClass.equals(Synonym.class)){

			taxonBase = Synonym.NewInstance(taxonNameBase, sec);

		}else {

			Taxon taxon = Taxon.NewInstance(taxonNameBase, sec);

			taxon.setTaxonStatusUnknown(true);

			taxonBase = taxon;

		}

		return taxonBase;

	}

	private boolean makeParent(CubaImportState state, Taxon parentTaxon, Taxon childTaxon, Reference citation, String microCitation){

		boolean success = true;

		Reference sec = state.getConfig().getSourceReference();

//		Reference sec = parentTaxon.getSec();

		Classification tree = state.getTree(sec);

		if (tree == null){

			tree = makeTree(state, sec);

			tree.setTitleCache(state.getConfig().getSourceReferenceTitle(), true);

		}

		if (sec.equals(childTaxon.getSec())){

			success &=  (null !=  tree.addParentChild(parentTaxon, childTaxon, citation, microCitation));

		}else{

			logger.warn("No relationship added for child " + childTaxon.getTitleCache());

		}

		return success;

	}

    @Override

    protected boolean isIgnore(CubaImportState state) {

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

    }

    @Override

    protected boolean doCheck(CubaImportState state) {

        logger.warn("DoCheck not yet implemented for CubaExcelImport");

        return true;

    }

}

/**

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

import java.net.URI;

import java.util.UUID;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.database.ICdmDataSource;

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

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

import eu.etaxonomy.cdm.io.excel.common.ExcelImportConfiguratorBase;

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

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

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

/**

 * @author a.mueller

 * @created 20.03.2008

 */

public class CubaImportConfigurator extends ExcelImportConfiguratorBase {

    private static final long serialVersionUID = 5590553979984931651L;

    @SuppressWarnings("unused")

	private static Logger logger = Logger.getLogger(CubaImportConfigurator.class);

    private String cubaReferenceTitle;

    private UUID uuidCyprusReference = UUID.fromString("b5281cd3-9d5d-4ae2-8d55-b62a592ce846");

	private boolean isDoTaxa;

	private static IInputTransformer defaultTransformer = new CubaTransformer();

	public static CubaImportConfigurator NewInstance(URI source, ICdmDataSource destination){

		return new CubaImportConfigurator(source, destination);

	}

	@Override

    protected void makeIoClassList(){

		ioClassList = new Class[]{

		        CubaVocabularyImport.class,

				CubaExcelImport.class

		};

	}

	@Override

    public ImportStateBase getNewState() {

		return new CubaImportState(this);

	}

	private CubaImportConfigurator(URI source, ICdmDataSource destination) {

	   super(source, destination, defaultTransformer);

	   setNomenclaturalCode(NomenclaturalCode.ICNAFP);

	   setSource(source);

	   setDestination(destination);

	}

	@Override

    public URI getSource() {

		return super.getSource();

	}

	@Override

    public void setSource(URI source) {

		super.setSource(source);

	}

	@Override

    public Reference<?> getSourceReference() {

		if (sourceReference == null){

			sourceReference =  ReferenceFactory.newDatabase();

			if (getSource() != null){

				sourceReference.setTitleCache(getCubaReferenceTitle(), true);

			}

		}

		return sourceReference;

	}

	@Override

    public String getSourceNameString() {

		return getSource().toString();

	}

	public void setUuidCyprusReference(UUID uuidCyprusReference) {

		this.uuidCyprusReference = uuidCyprusReference;

	}

	public UUID getUuidCyprusReference() {

		return uuidCyprusReference;

	}

	public void setCubaReferenceTitle(String cyprusReferenceTitle) {

		this.cubaReferenceTitle = cyprusReferenceTitle;

	}

	public String getCubaReferenceTitle() {

		return cubaReferenceTitle;

	}

	public void setDoTaxa(boolean isDoTaxa) {

		this.isDoTaxa = isDoTaxa;

	}

	public boolean isDoTaxa() {

		return isDoTaxa;

	}

}

// $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.cuba;

import java.util.HashMap;

import java.util.Map;

import java.util.UUID;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.io.excel.common.ExcelImportState;

import eu.etaxonomy.cdm.io.excel.common.ExcelRowBase;

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

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

/**

 * @author a.mueller

 * @created 11.05.2009

 */

public class CubaImportState extends ExcelImportState<CubaImportConfigurator, ExcelRowBase>{

	@SuppressWarnings("unused")

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

	private final Map<String, Taxon> higherTaxonTaxonMap = new HashMap<String, Taxon>();

	private final Map<String, UUID> higherTaxonUuidMap = new HashMap<String, UUID>();

//	private CyprusRow cyprusRow;

//	private CyprusDistributionRow cyprusDistributionRow;

	private Classification classification;

	public CubaImportState(CubaImportConfigurator config) {

		super(config);

	}

	public boolean containsHigherTaxon(String higherName) {

		return higherTaxonTaxonMap.containsKey(higherName);

	}

	public Taxon putHigherTaxon(String higherName, Taxon taxon) {

		return higherTaxonTaxonMap.put(higherName, taxon);

	}

	public Taxon removeHigherTaxon(String higherName) {

		return higherTaxonTaxonMap.remove(higherName);

	}

	public Taxon getHigherTaxon(String higherName) {

		return higherTaxonTaxonMap.get(higherName);

	}

	public boolean containsHigherTaxonUuid(String higherName) {

		return higherTaxonUuidMap.containsKey(higherName);

	}

	public UUID putHigherTaxon(String higherName, UUID uuid) {

		return higherTaxonUuidMap.put(higherName, uuid);

	}

	public UUID removeHigherTaxonUuid(String higherName) {

		return higherTaxonUuidMap.remove(higherName);

	}

	public UUID getHigherTaxonUuid(String higherName) {

		return higherTaxonUuidMap.get(higherName);

	}

    /**

     * @return

     */

    public Classification getClassification() {

        return classification;

    }

    /**

     * @param classification the classification to set

     */

    public void setClassification(Classification classification) {

        this.classification = classification;

    }

//	/**

//	 * @return the cyprusRow

//	 */

//	public CyprusRow getCyprusRow() {

//		return cyprusRow;

//	}

//

//	/**

//	 * @param cyprusRow the normalExplicitRow to set

//	 */

//	public void setCyprusRow(CyprusRow cyprusRow) {

//		this.cyprusRow = cyprusRow;

//	}

//	/**

//	 * @return the cyprusRow

//	 */

//	public CyprusDistributionRow getCyprusDistributionRow() {

//		return cyprusDistributionRow;

//	}

//

//	/**

//	 * @param cyprusRow the normalExplicitRow to set

//	 */

//	public void setCyprusDistributionRow(CyprusDistributionRow cyprusRow) {

//		this.cyprusDistributionRow = cyprusRow;

//	}

}

// $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.cuba;

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

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

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

import eu.etaxonomy.cdm.io.cyprus.CyprusTransformer;

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

/**

 * @author a.mueller

 * @created 01.03.2010

 */

public final class CubaTransformer extends InputTransformerBase {

    private static final long serialVersionUID = 1070018208741186271L;

    @SuppressWarnings("unused")

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

    //presenceTerm

    public static final UUID nonNativeDoubtfullyNaturalisedUuid = UUID.fromString("a1e26234-831e-4190-9fe3-011aca09ddba");

    public static final UUID nonAdventiveAlienUuid = UUID.fromString("06e48a0b-3e48-4ef8-9bdd-0755880e99ce");

    public static final UUID cultivatedOnlyUuid = UUID.fromString("9cca5c3b-aced-41c4-accc-f800b67168f8");

    //Named Areas

    public static final UUID uuidCubaVocabulary = UUID.fromString("2119f610-1f93-4d87-af28-40aeefaca100");

//    public static final UUID uuidCyprusDivisionsAreaLevel = UUID.fromString("ff52bbd9-f73d-4476-af39-f3991fa892bd");

    public static final UUID uuidCuba = UUID.fromString("d0144a6e-0e17-4a1d-bce5-d464a2aa7229");

    public static final UUID uuidWesternCuba = UUID.fromString("53ee35a5-03dd-4c1e-9b23-1a0d08489684");

    public static final UUID uuidPinarDelRio = UUID.fromString("ee1bae89-b6a8-4b89-a864-238fe3c4dbf3");

    public static final UUID uuidHabana = UUID.fromString("ff906b63-6e74-4a38-b492-73d32817ad3a");

    public static final UUID uuidMatanzas = UUID.fromString("bc280278-1b67-4766-ba28-e3a5c215d6a9");

    public static final UUID uuidIslaDeLaJuventud = UUID.fromString("0e0683d6-90d4-4b0f-834e-05737ca9b2b4");

    public static final UUID uuidCentralCuba = UUID.fromString("25eb5879-358e-4ff7-837d-101569d5d843");

    public static final UUID uuidVillaClara = UUID.fromString("4de5e35d-fdad-49d0-a5c8-dc44e4e844a0");

    public static final UUID uuidCienfuegos = UUID.fromString("c4189205-4543-4f4d-b211-6f899734a2f1");

    public static final UUID uuidSanctiSpiritus = UUID.fromString("70ee99b9-d006-4a08-a8c2-19269d60865f");

    public static final UUID uuidCiegoDeAvila = UUID.fromString("2ce7f4bc-4142-4866-b156-cf5300973c6d");

    public static final UUID uuidCamaguey = UUID.fromString("4a4e2ab9-bce1-4018-8654-e7dfe6ea9a0f");

    public static final UUID uuidLasTunas = UUID.fromString("6e0e9c28-23fe-4ea7-8ae1-75e1dce385e9");

    public static final UUID uuidEastCuba = UUID.fromString("6a9ed0e2-7d3a-4620-9376-720c166674ee");

    public static final UUID uuidGranma = UUID.fromString("7098418f-992a-4888-b4a0-722870bc7c69");

    public static final UUID uuidHolguin = UUID.fromString("1595e1f2-5ae6-4db7-982c-552c26130051");

    public static final UUID uuidSantiagoDeCuba = UUID.fromString("838a2e44-f3cc-4d89-83a8-6f83c6f9726d");

    public static final UUID uuidGuantanamo = UUID.fromString("3a76b1af-da3a-44a3-859f-eeba5ad6f58b");

    public static final UUID uuidEspanola = UUID.fromString("27d9d0f3-cd5f-4f3e-979d-64e47b6b5768");

    public static final UUID uuidJamaica = UUID.fromString("2825a0ee-0bd1-49d5-afb4-bac80db5551f");

    public static final UUID uuidPuertoRico = UUID.fromString("9fca701d-4899-4266-a29f-0d136670c795");

    public static final UUID uuidSmallerAntilles = UUID.fromString("9720309a-2467-4aad-992e-b3c34b95d8d7");

    public static final UUID uuidBahamas = UUID.fromString("23615e27-e916-48f4-8d49-8c148106216c");

    public static final UUID uuidCaymanIslands = UUID.fromString("f53ea0b5-3bca-4e95-9a10-2d13edcd7501");

    public static final UUID uuidNorthAmerica = UUID.fromString("5ab08324-baa2-4121-8c37-e1d558b51f2f");

    public static final UUID uuidCentralAmerica = UUID.fromString("4d972402-5ef8-43d8-a377-f0b6dd88d32e");

    public static final UUID uuidSouthAmerica = UUID.fromString("0fccc041-ce9d-40d5-8b9b-d7d833feed38");

    public static final UUID uuidOldWorld = UUID.fromString("c6b45544-01df-4c97-bb29-9058964c5b57");

//    public static final UUID uuid = UUID.fromString("");

//    public static final UUID uuid = UUID.fromString("");

//    public static final UUID uuid = UUID.fromString("");

    @Override

    public UUID getNamedAreaUuid(String key) throws UndefinedTransformerMethodException {

        if (StringUtils.isBlank(key)){return null;

        }else if (key.equalsIgnoreCase("C")){return uuidCuba;

        }else if (key.equalsIgnoreCase("CuW")){return uuidWesternCuba;

        }else if (key.equalsIgnoreCase("PR")){return uuidPinarDelRio;

        }else if (key.equalsIgnoreCase("Hab")){return uuidHabana;

        }else if (key.equalsIgnoreCase("Mat")){return uuidMatanzas;

        }else if (key.equalsIgnoreCase("IJ")){return uuidIslaDeLaJuventud;

        }else if (key.equalsIgnoreCase("CuC")){return uuidCentralCuba;

        }else if (key.equalsIgnoreCase("VC")){return uuidVillaClara;

        }else if (key.equalsIgnoreCase("Ci")){return uuidCienfuegos;

        }else if (key.equalsIgnoreCase("SS")){return uuidSanctiSpiritus;

        }else if (key.equalsIgnoreCase("CA")){return uuidCiegoDeAvila;

        }else if (key.equalsIgnoreCase("Cam")){return uuidCamaguey;

        }else if (key.equalsIgnoreCase("LT")){return uuidLasTunas;

        }else if (key.equalsIgnoreCase("CuE")){return uuidEastCuba;

        }else if (key.equalsIgnoreCase("Gr")){return uuidGranma;

        }else if (key.equalsIgnoreCase("Ho")){return uuidHolguin;

        }else if (key.equalsIgnoreCase("SC")){return uuidSantiagoDeCuba;

        }else if (key.equalsIgnoreCase("Gu")){return uuidGuantanamo;

        }else if (key.equalsIgnoreCase("Esp")){return uuidEspanola;

        }else if (key.equalsIgnoreCase("Ja")){return uuidJamaica;

        }else if (key.equalsIgnoreCase("PR")){return uuidPuertoRico;

        //TODO same as Pinar del Rio

        }else if (key.equalsIgnoreCase("Men")){return uuidSmallerAntilles;

        }else if (key.equalsIgnoreCase("Bah")){return uuidBahamas;

        }else if (key.equalsIgnoreCase("Cay")){return uuidCaymanIslands;

        }else if (key.equalsIgnoreCase("AmN")){return uuidNorthAmerica;

        }else if (key.equalsIgnoreCase("AmC")){return uuidCentralAmerica;

        }else if (key.equalsIgnoreCase("AmS")){return uuidSouthAmerica;

        }else if (key.equalsIgnoreCase("VM")){return uuidOldWorld;

        }else{

            return null;

        }

    }

    @Override

    public UUID getPresenceTermUuid(String key) throws UndefinedTransformerMethodException {

        if (StringUtils.isBlank(key)){return null;

        }else if (key.equalsIgnoreCase("Ind.")){return CyprusTransformer.indigenousUuid;

        }else if (key.equalsIgnoreCase("Ind?")){return CyprusTransformer.indigenousDoubtfulUuid;

        }else if (key.equalsIgnoreCase("Dud.")){return nonNativeDoubtfullyNaturalisedUuid;

        }else if (key.equalsIgnoreCase("Adv.")){return nonAdventiveAlienUuid;

        }else if (key.equalsIgnoreCase("Cult.")){return cultivatedOnlyUuid;

        }else{

            return null;

        }

    }

    @Override

    public PresenceAbsenceTerm getPresenceTermByKey(String key) throws UndefinedTransformerMethodException {

        if (StringUtils.isBlank(key)){return null;

        }else if (key.equalsIgnoreCase("Nat.")){return PresenceAbsenceTerm.NATURALISED();

        }else if (key.equalsIgnoreCase("Cult.")){return PresenceAbsenceTerm.CULTIVATED();

        }else{

            return null;

        }

    }

}

/**

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

import java.util.UUID;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

import org.springframework.transaction.TransactionStatus;

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

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

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

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

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

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

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

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

/**

 * @author a.mueller

 * @created 05.01.2016

 */

@Component

public class CubaVocabularyImport extends CdmImportBase<CubaImportConfigurator, CubaImportState> {

    private static final long serialVersionUID = -747486709409732371L;

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

    /**

     * {@inheritDoc}

     */

    @Override

    protected void doInvoke(CubaImportState state) {

        try {

            makeAreas(state);

            makePresenceAbsenceTerms(state);

        } catch (UndefinedTransformerMethodException e) {

           e.printStackTrace();

        }

    }

    /**

     * @param state

     */

    private void makePresenceAbsenceTerms(CubaImportState state) {

        TransactionStatus tx = startTransaction();

        commitTransaction(tx);

    }

    private boolean makeAreas(CubaImportState state) throws UndefinedTransformerMethodException{

        TransactionStatus tx = startTransaction();

        IInputTransformer transformer = state.getTransformer();

        //vocabulary

        UUID cubaAreasVocabularyUuid = UUID.fromString("c81e3c7b-3c01-47d1-87cf-388de4b1908c");

        String label = "Cuba Areas";

        String abbrev = null;

        boolean isOrdered = true;

        NamedArea anyArea = NamedArea.ARCTICOCEAN();  //just any

        TermVocabulary<NamedArea> cubaAreasVocabualary = getVocabulary(TermType.NamedArea, cubaAreasVocabularyUuid, label, label, abbrev, null, isOrdered, anyArea);

        TermMatchMode matchMode = null;

        NamedAreaType areaType = null;  //TODO

        NamedAreaLevel level = null;  //TODO

        //Cuba

        level = NamedAreaLevel.COUNTRY();

        label = "Cuba";

        abbrev = "C";

        UUID cubaUuid = transformer.getNamedAreaUuid(abbrev);

        NamedArea cuba = getNamedArea(state, cubaUuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        //Regions

        level = null;

        //Western Cuba

        label = "Western Cuba";

        abbrev = "CuW";

        UUID cubaWestUuid = transformer.getNamedAreaUuid(abbrev);

        NamedArea westernCuba = getNamedArea(state, cubaWestUuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        cuba.addIncludes(westernCuba);

        //Central Cuba

        label = "Central Cuba";

        abbrev = "CuC";

        UUID cubaCentralUuid = transformer.getNamedAreaUuid(abbrev);

        NamedArea centralCuba = getNamedArea(state, cubaCentralUuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        cuba.addIncludes(centralCuba);

        //East Cuba

        label = "East Cuba";

        abbrev = "CuE";

        UUID cubaEastUuid = transformer.getNamedAreaUuid(abbrev);

        NamedArea eastCuba = getNamedArea(state, cubaEastUuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        cuba.addIncludes(eastCuba);

        //Provinces - West

        level = NamedAreaLevel.PROVINCE();

        //Pinar del Río PR

        label = "Pinar del Río";

        abbrev = "PR";

        UUID uuid = transformer.getNamedAreaUuid(abbrev);

        NamedArea area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        westernCuba.addIncludes(area);

        //Habana Hab

        label = "Habana"; //including Ciudad de la Habana, Mayabeque, Artemisa

        abbrev = "Hab";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        westernCuba.addIncludes(area);

        //Matanzas Mat

        label = "Matanzas";

        abbrev = "Mat";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        westernCuba.addIncludes(area);

        //Isla de la Juventud IJ

        label = "Isla de la Juventud";

        abbrev = "IJ";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        westernCuba.addIncludes(area);

        //Provinces - Central

        //Villa Clara VC

        label = "Villa Clara";

        abbrev = "VC";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        centralCuba.addIncludes(area);

        //Cienfuegos Ci VC

        label = "Cienfuegos";

        abbrev = "Ci";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        centralCuba.addIncludes(area);

        //Sancti Spiritus SS

        label = "Sancti Spiritus";

        abbrev = "SS";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        centralCuba.addIncludes(area);

        //Ciego de Ávila CA

        label = "Ciego de Ávila";

        abbrev = "CA";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        centralCuba.addIncludes(area);

        //Camagüey Cam

        label = "Camagüey";

        abbrev = "Cam";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        centralCuba.addIncludes(area);

        //Las Tunas LT

        label = "Las Tunas";

        abbrev = "LT";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        centralCuba.addIncludes(area);

        //Provinces - East

        //Granma Gr

        label = "Granma";

        abbrev = "Gr";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        eastCuba.addIncludes(area);

        //Holguín Ho

        label = "Holguín";

        abbrev = "Ho";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        eastCuba.addIncludes(area);

        //Santiago de Cuba SC

        label = "Santiago de Cuba";

        abbrev = "SC";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        eastCuba.addIncludes(area);

        //Guantánamo Gu

        label = "Guantánamo";

        abbrev = "Gu";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        eastCuba.addIncludes(area);

        //Surrounding

        //Española Esp

        label = "Española";

        abbrev = "Esp";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        //Jamaica Ja

        label = "Jamaica";

        abbrev = "Ja";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        //Puerto Rico PR

        label = "Puerto Rico";  //Greater Antilles

        abbrev = "PR";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        //Smaller Antilles Men

        label = "Smaller Antilles";

        abbrev = "Men";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        //Bahamas

        label = "Bahamas";

        abbrev = "Bah";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        //Cayman Islands

        label = "Cayman Islands"; //[Trinidad, Tobago, Curaçao, Margarita, ABC Isl. = S. America];

        abbrev = "Cay";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        //World

        //N America

        label = "N America"; //(incl. Mexico)

        abbrev = "AmN";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        //Central America

        label = "Central America";

        abbrev = "AmC";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        //S America

        label = "S America";

        abbrev = "AmS";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        //Old World

        label = "Old World ";

        abbrev = "VM";

        uuid = transformer.getNamedAreaUuid(abbrev);

        area = getNamedArea(state, uuid, label, label, abbrev, areaType, level, cubaAreasVocabualary, matchMode);

        commitTransaction(tx);

        return true;

    }

    @Override

    protected boolean isIgnore(CubaImportState state) {

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

    }

    @Override

    protected boolean doCheck(CubaImportState state) {

        logger.warn("DoCheck not yet implemented for CubaVocabularyImport");

        return true;

    }

}