EDIT

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

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

	static final Source berlinModelSource = BerlinModelSources.euroMed_BGBM42();

//	static final Source berlinModelSource = BerlinModelSources.euroMed_PESI3();

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

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

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

	static final boolean includePesiExport = false;

	//taxa

	static final boolean doTaxa = true;

	static final boolean doFacts = true;

	//etc.

	static final boolean doMarker = true;

		changeCommonNameLabel(config, bmImport);

        runTransmissionEngine(config, bmImport);

        importShapefile(config, bmImport);

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

	}

    private void renameRanks(BerlinModelImportConfigurator config,

            CdmDefaultImport<BerlinModelImportConfigurator> bmImport) {

			ICdmApplicationConfiguration app = bmImport.getCdmAppController();

			TransactionStatus tx = app.startTransaction();

			try {

		}

    }

    private void createFeatureTree(BerlinModelImportConfigurator config,

			ICdmApplicationConfiguration app = bmImport.getCdmAppController();

			TransactionStatus tx = app.startTransaction();

		}

    }

    private void changeCommonNameLabel(BerlinModelImportConfigurator config,

            CdmDefaultImport<BerlinModelImportConfigurator> bmImport) {

	        ICdmApplicationConfiguration app = bmImport.getCdmAppController();

	        TransactionStatus tx = app.startTransaction();

    //1. run transmission engine #3979

    private void runTransmissionEngine(BerlinModelImportConfigurator config,

            CdmDefaultImport<BerlinModelImportConfigurator> bmImport) {

            ICdmApplicationConfiguration app = bmImport.getCdmAppController();

            final List<String> term_init_strategy = Arrays.asList(new String []{

    private void markAreasAsHidden(BerlinModelImportConfigurator config,

            CdmDefaultImport<BerlinModelImportConfigurator> bmImport) {

	        ICdmApplicationConfiguration app = bmImport.getCdmAppController();

	        TransactionStatus tx = app.startTransaction();

    private void importShapefile(BerlinModelImportConfigurator config,

            CdmDefaultImport<BerlinModelImportConfigurator> bmImport) {

	       UUID areaVocabularyUuid = BerlinModelTransformer.uuidVocEuroMedAreas;

           List<String> idSearchFields = Arrays.asList(new String[]{"EMAREA","PARENT"});

    }

    //4. Create users and assign roles  #3979

            CdmDefaultImport<BerlinModelImportConfigurator> bmImport) {

	        ICdmApplicationConfiguration app = bmImport.getCdmAppController();

	        TransactionStatus tx = app.startTransaction();

			NamedArea newArea = makeSingleEuroMedArea(rs, eurMarkerType, euroMedAreaMarkerType,

					isoCodeExtType, tdwgCodeExtType, mclCodeExtType,

					areaLevelTop, areaLevelEm1 , areaLevelEm2, sourceReference, euroMedArea, lastLevel2Area);

			}

		}

		commitTransaction(txStatus);

		logger.warn("Created E+M areas");

		String mclCode = nullSafeTrim(rs.getString("MCLCode"));

		String geoSearch = nullSafeTrim(rs.getString("NameForGeoSearch"));

		if (isBlank(emCode)){

			emCode = unit;

		}

			if (uuid != null){

				area.setUuid(uuid);

			}else{

			}

		}

		//source

		area.addSource(OriginalSourceType.Import, String.valueOf(areaId), EM_AREA_NAMESPACE, sourceReference, null);

		//parent

		if (euroMedArea != null){

/**

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

*/

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

	public static final String TREE_NAMESPACE = "PTRefFk";

	private static int modCount = 30000;

	private static final String pluralString = "taxon relations";

	private static final String dbTableName = "RelPTaxon";

	public BerlinModelTaxonRelationImport(){

		super(dbTableName, pluralString);

	}

	 */

	private void makeClassifications(BerlinModelImportState state) throws SQLException{

		logger.info("start make classification ...");

		Set<String> idSet = getTreeReferenceIdSet(state);

		//reference map

		String nameSpace = BerlinModelReferenceImport.REFERENCE_NAMESPACE;

		Class<?> cdmClass = Reference.class;

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

		String treeName = "Classification - No Name";

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

		int i = 0;

		//for each reference

		try {

			//TODO handle case useSingleClassification = true && sourceSecId = null, which returns no record

			while (rs.next()){

				try {

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

					Integer ptRefFkInt = nullSafeInt(rs,"PTRefFk");

					String ptRefFk= String.valueOf(ptRefFkInt);

					Reference<?> ref = refMap.get(ptRefFk);

					String refCache = rs.getString("RefCache");

					if (StringUtils.isNotBlank(refCache)){

						treeName = refCache;

					}

					IdentifiableSource identifiableSource = IdentifiableSource.NewDataImportInstance(ptRefFk, TREE_NAMESPACE);

					tree.addSource(identifiableSource);

					getClassificationService().save(tree);

					state.putClassificationUuidInt(ptRefFkInt, tree);

				} catch (Exception e) {

	/**

	 * @return

	 */

	private Set<String> getTreeReferenceIdSet(BerlinModelImportState state) throws SQLException {

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

	 */

	private String getClassificationQuery(BerlinModelImportState state) {

		boolean includeAllClassifications = state.getConfig().isIncludeAllNonMisappliedRelatedClassifications();

							" INNER JOIN PTaxon AS PTaxon ON RelPTaxon.PTNameFk2 = PTaxon.PTNameFk AND RelPTaxon.PTRefFk2 = PTaxon.PTRefFk " +

		if (includeAllClassifications){

			strQueryWhere = " WHERE (RelPTaxon.RelQualifierFk <> 3) ";

		}else{

				}

			}

		}

		String strQueryGroupBy = " GROUP BY PTaxon.PTRefFk, r.RefCache ";

		String strQuery = strQuerySelect + " " + strQueryFrom + " " + strQueryWhere + " " + strQueryGroupBy;

		if (includeAllClassifications){

			//add otherdirection

								" INNER JOIN PTaxon AS PTaxon ON rel.PTNameFk1 = PTaxon.PTNameFk AND rel.PTRefFk1 = PTaxon.PTRefFk " +

			strQueryWhere =" WHERE (rel.RelQualifierFk <> 3) ";

			String strAllQuery =  strQuerySelect + " " + strQueryFrom + " " + strQueryWhere + " " + strQueryGroupBy;

			strQuery = strQuery + " UNION " + strAllQuery;

		}

		boolean includeFlatClassifications = state.getConfig().isIncludeFlatClassifications();

		if (includeFlatClassifications){

					" SELECT pt.PTRefFk AS secRefFk, r.RefCache AS secRef " +

					          " Reference r ON pt.PTRefFk = r.RefId LEFT OUTER JOIN " +

					          " RelPTaxon rel1 ON pt.PTNameFk = rel1.PTNameFk2 AND pt.PTRefFk = rel1.PTRefFk2 LEFT OUTER JOIN " +

					" GROUP BY pt.PTRefFk, r.RefCache "

					;

			strQuery = strQuery + " UNION " + strFlatQuery;

		}

		if (state.getConfig().getClassificationQuery() != null){

			strQuery = state.getConfig().getClassificationQuery();

		}

		return strQuery;

	}

	@Override

	protected String getRecordQuery(BerlinModelImportConfigurator config) {

			" FROM PTaxon as FromTaxon " +

              	" INNER JOIN RelPTaxon ON FromTaxon.PTNameFk = RelPTaxon.PTNameFk1 AND FromTaxon.PTRefFk = RelPTaxon.PTRefFk1 " +

              	" INNER JOIN PTaxon AS ToTaxon ON RelPTaxon.PTNameFk2 = ToTaxon.PTNameFk AND RelPTaxon.PTRefFk2 = ToTaxon.PTRefFk " +

            " WHERE RelPTaxon.RelPTaxonId IN ("+ID_LIST_TOKEN+") ORDER BY RelPTaxon.RelPTaxonId ";

		return strQuery;

	}

		boolean success = true ;

		BerlinModelImportConfigurator config = state.getConfig();

		Set<TaxonBase> taxaToSave = new HashSet<TaxonBase>();

		Map<Integer, Classification> classificationMap = new HashMap<Integer, Classification>();

		ResultSet rs = partitioner.getResultSet();

		try{

			int i = 0;

			//for each reference

			while (rs.next()){

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

				int relPTaxonId = rs.getInt("RelPTaxonId");

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

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

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

					int treeRefFk = rs.getInt("treeRefFk");

					int fromRefFk = rs.getInt("fromRefFk");

					int relQualifierFk = rs.getInt("relQualifierFk");

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

					boolean isConceptRelationship = rs.getBoolean("is_concept_relation");

					TaxonBase<?> taxon1 = taxonMap.get(String.valueOf(taxon1Id));

					TaxonBase<?> taxon2 = taxonMap.get(String.valueOf(taxon2Id));

					String refFk = String.valueOf(relRefFk);

					Reference<?> citation = refMap.get(refFk);

					String microcitation = null; //does not exist in RelPTaxon

					if (taxon2 != null && taxon1 != null){

							Synonym synonym = (Synonym)taxon1;

							SynonymRelationship synRel = getSynRel(relQualifierFk, toTaxon, synonym, citation, microcitation);

							taxonRelationship = synRel;

									relQualifierFk == TAX_REL_IS_HOMOTYPIC_SYNONYM_OF ||

									relQualifierFk == TAX_REL_IS_HETEROTYPIC_SYNONYM_OF){

								addProParteAndPartial(synRel, synonym, config);

									relQualifierFk == TAX_REL_IS_PROPARTE_HOMOTYPIC_SYNONYM_OF ||

									relQualifierFk == TAX_REL_IS_PROPARTE_HETEROTYPIC_SYNONYM_OF ){

									synRel.setProParte(true);

									relQualifierFk == TAX_REL_IS_PARTIAL_HOMOTYPIC_SYNONYM_OF ||

									relQualifierFk == TAX_REL_IS_PARTIAL_HETEROTYPIC_SYNONYM_OF ){

									synRel.setPartial(true);

							ResultWrapper<Boolean> isInverse = ResultWrapper.NewInstance(false);

							ResultWrapper<Boolean> isDoubtful = ResultWrapper.NewInstance(false);

							try {

								if (! (taxon1 instanceof Taxon)){

									success = false;

									handleAllRelatedTaxa(state, fromTaxon, classificationMap, fromRefFk);

									if (isDoubtful.getValue() == true){

										((TaxonRelationship)taxonRelationship).setDoubtful(true);

								}

							} catch (UnknownCdmTypeException e) {

								logger.warn("TaxonRelationShipType " + relQualifierFk + " (conceptRelationship) not yet implemented");

							logger.warn("TaxonRelationShipType " + relQualifierFk + " not yet implemented: RelPTaxonId = " + relPTaxonId );

							success = false;

						}

						doNotes(taxonRelationship, notes);

						taxaToSave.add(taxon2);

						//TODO

						//etc.

					}else{

						}else{

							logger.warn("Both taxa ("+taxon1Id+","+taxon2Id +") for RelPTaxon " + relPTaxonId + " do not exist in store. RelType: " + relQualifierFk);

						}

						success = false;

					}

				} catch (Exception e) {

					logger.error("Exception occurred when trying to handle taxon relationship " + relPTaxonId + " (" + taxon1Id + ","+ taxon2Id + "): " + e.getMessage());

				}

			}

		}catch(SQLException e){

		getTaxonService().saveOrUpdate(taxaToSave);

		classificationMap = null;

		taxaToSave = null;

		return success;

	}

	private void handleAllRelatedTaxa(BerlinModelImportState state, Taxon taxon, Map<Integer, Classification> classificationMap, Integer secRefFk) {

		if (taxon.getTaxonNodes().size() > 0){

	}

	@Override

		try {

			makeClassifications(state);

			super.doInvoke(state);

		} catch (SQLException e) {

			throw new RuntimeException(e);

		}

	}

	private void makeFlatClassificationTaxa(BerlinModelImportState state) {

		//Note: this part still does not use partitions

		logger.info("Flat classifications start");

						" ORDER BY pt.PTRefFk "	;

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

		Map<Object, Map<String, ? extends CdmBase>> maps = getRelatedObjectsForFlatPartition(rs);

		Map<String, TaxonBase> taxonMap = (Map<String, TaxonBase>) maps.get(BerlinModelTaxonImport.NAMESPACE);

		Map<Integer, Classification> classificationMap = new HashMap<Integer, Classification>();

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

		try {

			while (rs.next()){

		}

		commitTransaction(txStatus);

		logger.info("Flat classifications end");

	}

	@Override

			return super.getIdQuery(state);

		}

	}

	@Override

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

		String nameSpace;

		Class<?> cdmClass;

		Set<String> idSet;

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

		try{

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

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

//				handleForeignKey(rs, classificationIdSet, "treeRefFk");

				handleForeignKey(rs, referenceIdSet, "RelRefFk");

	}

			//taxon map

			nameSpace = BerlinModelTaxonImport.NAMESPACE;

			cdmClass = TaxonBase.class;

//			result.put(cdmClass, treeMap);

//			Set<UUID> treeUuidSet = state

//			getClassificationService().find(uuidSet);

			//reference map

			nameSpace = BerlinModelReferenceImport.REFERENCE_NAMESPACE;

			cdmClass = Reference.class;

		}

		return result;

	}

	private Map<Object, Map<String, ? extends CdmBase>> getRelatedObjectsForFlatPartition( 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> taxonIdSet = new HashSet<String>();

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

				handleForeignKey(rs, taxonIdSet, "RIdentifier");

//				handleForeignKey(rs, classificationIdSet, "treeRefFk");

	}

			//taxon map

			nameSpace = BerlinModelTaxonImport.NAMESPACE;

			cdmClass = TaxonBase.class;

//			result.put(cdmClass, treeMap);

//			Set<UUID> treeUuidSet = state

//			getClassificationService().find(uuidSet);

		} catch (SQLException e) {

			throw new RuntimeException(e);

		return result;

	}

	private  boolean isSynonymRelationship(int relQualifierFk){

			relQualifierFk == TAX_REL_IS_HETEROTYPIC_SYNONYM_OF ||

			relQualifierFk == TAX_REL_IS_PARTIAL_SYN_OF ||

			relQualifierFk == TAX_REL_IS_PROPARTE_HOMOTYPIC_SYNONYM_OF ||

			relQualifierFk == TAX_REL_IS_PROPARTE_HETEROTYPIC_SYNONYM_OF ||

			return false;

		}

	}

	private  boolean isTaxonRelationship(int relQualifierFk){

				relQualifierFk == TAX_REL_IS_MISAPPLIED_NAME_OF){

			return true;

		}else{

			return false;

		}

	}

	private void addProParteAndPartial(SynonymRelationship synRel, Synonym synonym, BerlinModelImportConfigurator bmiConfig){

		if (bmiConfig.isPartialSynonym(synonym)){

			synRel.setPartial(true);

			synRel.setProParte(true);

		}

	}

	private TaxonNode makeTaxonomicallyIncluded(BerlinModelImportState state, Map<Integer, Classification> classificationMap, int treeRefFk, Taxon child, Taxon parent, Reference citation, String microCitation){

		Classification tree = getClassificationTree(state, classificationMap, treeRefFk);

		return tree.addParentChild(parent, child, citation, microCitation);

	private Classification getClassificationTree(BerlinModelImportState state, Map<Integer, Classification> classificationMap, int treeRefFk) {

		if (state.getConfig().isUseSingleClassification()){

			if (state.getConfig().getSourceSecId() != null){

			}else{

				treeRefFk = 1;

			}

		}

		Classification tree = classificationMap.get(treeRefFk);

		if (tree == null){

		}

		return tree;

	}

	@Override

	protected boolean doCheck(BerlinModelImportState state){

		IOValidator<BerlinModelImportState> validator = new BerlinModelTaxonRelationImportValidator();

		return validator.validate(state);

	}

	@Override

	protected boolean isIgnore(BerlinModelImportState state){

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

	}

}