EDIT

    public static ICdmDataSource cdm_production_edaphobase(){

        DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

        String cdmServer = "160.45.63.171";

        String cdmDB = "cdm_production_edaphobase";

        String cdmUserName = "edit";

        return makeDestination(dbType, cdmServer, cdmDB, -1, cdmUserName, null);

    }

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

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

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

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

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

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

    static final ICdmDataSource cdmDestination = CdmDestinations.cdm_production_edaphobase();

    private static final UUID featureTreeUuid = UUID.fromString("a543d66a-e310-4b3e-a9fa-b729afefad16");

    static final UUID secUuid = UUID.fromString("95dcb1b6-5197-4ce6-b2fa-c6482119d2ea");

    static final String secundumTitle = "Edaphobase";

    private static final boolean doSynonyms = true;

    private static final boolean doReferences = true;

        config.setEdaphobaseSecundumTitle(secundumTitle);

        config.setSecUuid(secUuid);

        config.setDoReferences(doReferences);

        config.setDoSynonyms(doSynonyms);

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

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

    }

    private FeatureTree makeFeatureNodes(ITermService service){

        FeatureTree result = FeatureTree.NewInstance(featureTreeUuid);

        result.setTitleCache(featureTreeTitle, true);

        FeatureNode root = result.getRoot();

        FeatureNode newNode;

        Feature distributionFeature = (Feature)service.find(Feature.DISTRIBUTION().getUuid());

        newNode = FeatureNode.NewInstance(distributionFeature);

        root.addChild(newNode);

        return result;

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

                int id = rs.getInt("taxon_id");

                if (parentTaxonFk != null){

                    TaxonBase<?> parent = state.getRelatedObject(TAXON_NAMESPACE, parentTaxonFk.toString(), TaxonBase.class);

                    if (parent == null){

                        logger.warn("Parent taxon " + parentTaxonFk + " not found for taxon " + id );

                        TaxonNameBase<?,?> parentName = parent.getName();

                        TaxonBase<?> child = state.getRelatedObject(TAXON_NAMESPACE, String.valueOf(id), TaxonBase.class);

//                        TaxonNameBase<?,?> childName = child.getName();

//                        handleMissingNameParts(CdmBase.deproxy(childName, NonViralName.class), CdmBase.deproxy(parentName, NonViralName.class));

                        if (isValid){

                            if (parent.isInstanceOf(Synonym.class)){

                                logger.warn("Parent taxon (" + parentTaxonFk + " is not valid for valid child " + id);

                            }else{

                                Taxon accParent = CdmBase.deproxy(parent, Taxon.class);

                                classification.addParentChild(accParent, (Taxon)child, sourceReference, null);

                                taxaToSave.add(accParent);

                            }

//                            Synonym synonym = CdmBase.deproxy(child, Synonym.class);

//                            if (synonym == null){

//                                logger.warn("Synonym " + id + " not found for taxon ");

//                            }

//                            if(parent.isInstanceOf(Synonym.class)){

//                                String message = "Taxon ("+parentTaxonFk+") is not accepted but synonym. Can't add synonym ("+id+")";

//                                logger.warn(message);

//                            }else{

//                                Taxon accepted = CdmBase.deproxy(parent, Taxon.class);

////                                accepted.addSynonym(synonym, SynonymRelationshipType.SYNONYM_OF());

//                                taxaToSave.add(accepted);

//                            }

//    /**

//     * @param childName

//     * @param parentName

//     */

//    private void handleMissingNameParts(NonViralName<?> childName, NonViralName<?> parentName) {

//        if (childName.getGenusOrUninomial())

//    }

    protected static final String REFERENCE_NAMESPACE = "lit_document";

    private boolean doSynonyms = true;

    public boolean isDoSynonyms() {return doSynonyms;}

    public void setDoSynonyms(boolean doSynonyms) {this.doSynonyms = doSynonyms;}

    private boolean doReferences = true;

    public boolean isDoReferences() {return doReferences;}

    public void setDoReferences(boolean doReferences) {this.doReferences = doReferences;}

    private String edaphobaseSecundumTitle;

    public String getEdaphobaseSecundumTitle() {return edaphobaseSecundumTitle;}

    public void setEdaphobaseSecundumTitle(String edaphobaseSecundumTitle) {this.edaphobaseSecundumTitle = edaphobaseSecundumTitle;}

                EdaphobaseReferenceImport.class,

                EdaphobaseInReferenceImport.class,

                EdaphobaseSynonymyImport.class,

// $Id$

/**

* Copyright (C) 2015 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.edaphobase;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

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

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

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

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

/**

 * @author a.mueller

 * @date 18.12.2015

 *

 */

@Component

public class EdaphobaseInReferenceImport extends EdaphobaseImportBase {

    private static final long serialVersionUID = 6895687693249076160L;

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

    private static final String tableName = "lit_document";

    private static final String pluralString = "documents";

    /**

     * @param tableName

     * @param pluralString

     */

    public EdaphobaseInReferenceImport() {

        super(tableName, pluralString);

    }

    @Override

    protected String getIdQuery(EdaphobaseImportState state) {

        return    " SELECT DISTINCT document_id "

                + " FROM lit_document ld INNER JOIN tax_taxon t ON t.tax_document = ld.document_id "

                + " WHERE ld.parent_document_fk_document_id IS NOT NULL "

                + " ORDER BY document_id ";

    }

    @Override

    protected String getRecordQuery(EdaphobaseImportConfigurator config) {

        String result = " SELECT document_id, parent_document_fk_document_id "

                + " FROM lit_document ld "

                + " WHERE ld.document_id IN (@IDSET)";

        result = result.replace("@IDSET", IPartitionedIO.ID_LIST_TOKEN);

        return result;

    }

    @Override

    public boolean doPartition(ResultSetPartitioner partitioner, EdaphobaseImportState state) {

        ResultSet rs = partitioner.getResultSet();

        Set<Reference> referencesToSave = new HashSet<>();

        try {

            while (rs.next()){

                handleSingleReference(state, rs, referencesToSave);

            }

        } catch (SQLException e) {

            e.printStackTrace();

        }

        getReferenceService().saveOrUpdate(referencesToSave);

        return true;

    }

    /**

     * @param state

     * @param rs

     * @param referencesToSave

     * @throws SQLException

     */

    private void handleSingleReference(EdaphobaseImportState state, ResultSet rs, Set<Reference> referencesToSave) throws SQLException {

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

        Integer parentId = rs.getInt("parent_document_fk_document_id");

//        Integer documentType = nullSafeInt(rs, "document_type");

        Reference<?> child = state.getRelatedObject(REFERENCE_NAMESPACE, String.valueOf(id), Reference.class);

        Reference<?> parent = state.getRelatedObject(REFERENCE_NAMESPACE, String.valueOf(parentId), Reference.class);

        if (child == null){

            logger.warn("Child reference for document_id " + id + " is NULL" );

        }else if (parent == null){

            logger.warn("Parent reference for document_type_fk_document_type_id " + parentId + " is NULL" );

        }else{

            child.setInReference(parent);

            referencesToSave.add(child);

        }

    }

    @Override

    public Map<Object, Map<String, ? extends CdmBase>> getRelatedObjectsForPartition(ResultSet rs,

            EdaphobaseImportState state) {

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

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

        try {

            while (rs.next()){

                handleForeignKey(rs, referenceIdSet, "document_id");

                handleForeignKey(rs, referenceIdSet, "parent_document_fk_document_id");

            }

        } catch (SQLException e) {

            e.printStackTrace();

        }

        //reference map

        String nameSpace = REFERENCE_NAMESPACE;

        Class<?> cdmClass = Reference.class;

        Set<String> idSet = referenceIdSet;

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

        result.put(nameSpace, referenceMap);

        return result;

    }

    @Override

    protected boolean doCheck(EdaphobaseImportState state) {

        return false;

    }

    @Override

    protected boolean isIgnore(EdaphobaseImportState state) {

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

    }

}

import org.apache.commons.lang3.StringUtils;

import eu.etaxonomy.cdm.common.DOI;

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

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

    private static final long serialVersionUID = 6895687693249076160L;

    @SuppressWarnings("unused")

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

    private static final String tableName = "lit_document";

    private static final String pluralString = "documents";

//

//    private static final Object AUTHOR_NAMESPACE = "tax_author_name";

        return    " SELECT DISTINCT document_id "

                + " FROM lit_document ld INNER JOIN tax_taxon t ON t.tax_document = ld.document_id "

                + " UNION "

                + " SELECT DISTINCT pd.document_id "

                + " FROM lit_document ld INNER JOIN tax_taxon t ON t.tax_document = ld.document_id "

                + " INNER JOIN lit_document pd ON pd.document_id = ld.parent_document_fk_document_id "

                + " ORDER BY document_id ";

        String result = " SELECT * "

                + " FROM lit_document ld "

                + " WHERE ld.document_id IN (@IDSET)";

        Set<Reference> referencesToSave = new HashSet<>();

                handleSingleReference(state, rs, referencesToSave);

        getReferenceService().saveOrUpdate(referencesToSave);

    /**

     * @param state

     * @param rs

     * @param referencesToSave

     * @throws SQLException

     */

    private void handleSingleReference(EdaphobaseImportState state, ResultSet rs, Set<Reference> referencesToSave) throws SQLException {

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

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

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

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

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

        Integer pageFrom = nullSafeInt(rs, "page_from");

        Integer pageTo = nullSafeInt(rs, "page_to");

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

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

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

        //refers_to_literature

        //refers_to_collection

        //refers_to_observation

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

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

        //abbreviation (no record)

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

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

        //circulation //2 records

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

        String abstractt = rs.getString("abstract");

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

        //language_fk_language_id

        //document_type_fk_document_type_id

        //editor_fk_person_id

        Integer editorFk = nullSafeInt(rs, "editor_fk_person_id");

//        Integer parentFk = nullSafeInt(rs, "parent_document_fk_document_id");

        //publisher_fk_publisher_id

        //deleted

        //chapter_no

        //versionfield

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

        String displayString = rs.getString("display_string");

        //aquisistion_date, aquisition_type, adoption_date, ex_colletion, barcode_prefix, barcode_org_prefix

        //barcode_type, collection_status, barcode, typus_form,

        //taxon_for_scope, taxon_is_scope

        //language_fk, document_type_backup

        Integer documentType = nullSafeInt(rs, "document_type");

        //normalized_title, normalized_abk_official_remark

        Reference<?> ref = makeReferenceType(documentType, dtype);

        ref.setTitle(title);

        ref.setPlacePublished(place);

        ref.setIssn(issn);

        ref.setIsbn(isbn);

        if (pageFrom != null || pageTo != null){

            String pageStr = pageFrom == null ? "" : String.valueOf(pageFrom);

            pageStr = pageTo == null ? pageStr : "-" + pageTo;

            ref.setPages(pageStr);

        if (year != null){

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

        ref.setVolume(volume);

        ref.setReferenceAbstract(abstractt);

        if (StringUtils.isNotBlank(doi)){

            try {

                String doiStr = doi;

                if (doiStr.startsWith("dx.doi.org/")){

                    doiStr = doiStr.substring(11);

                }

                ref.setDoi(DOI.fromString(doiStr));

            } catch (IllegalArgumentException e) {

                logger.warn("DOI could not be parsed: " + doi);

            }

        ref.setEdition(issue);

        //id

        ImportHelper.setOriginalSource(ref, state.getTransactionalSourceReference(), id, REFERENCE_NAMESPACE);

        referencesToSave.add(ref);

    /**

     * @param documentType

     * @return

     */

    private Reference<?> makeReferenceType(Integer documentType, String dtype) {

        if (documentType == 11914){

            return ReferenceFactory.newArticle();

        } else if (documentType == 11916){

            return ReferenceFactory.newBook();

        } else if (documentType == 11915){

            return ReferenceFactory.newPrintSeries();

        } else if (documentType == 11913){

            return ReferenceFactory.newJournal();

        } else if (documentType == 11917){

            return ReferenceFactory.newBookSection();

        } else if (documentType == 11912 || documentType == 11919 || documentType == 11924 ){

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

            return ref;

        } else {

            throw new RuntimeException("DocumentType not yet supported: " + documentType + ", " + dtype);

    @Override

    public Map<Object, Map<String, ? extends CdmBase>> getRelatedObjectsForPartition(ResultSet rs,

            EdaphobaseImportState state) {

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

//        Map<String, TeamOrPersonBase<?>> authorMap = new HashMap<>();

//        Set<String> authorSet = new HashSet<>();

//        try {

//            while (rs.next()){

//                String authorStr = rs.getString("tax_author_name");

//                authorSet.add(authorStr);

//            }

//        } catch (SQLException e) {

//            e.printStackTrace();

//        }

//

//        //Authors

//        Set<UUID> uuidSet = new HashSet<>();

//        for (String authorStr : authorSet){

//            UUID uuid = state.getAuthorUuid(authorStr);

//            uuidSet.add(uuid);

//        }

//        List<TeamOrPersonBase<?>> authors = (List)getAgentService().find(uuidSet);

//        Map<UUID, TeamOrPersonBase<?>> authorUuidMap = new HashMap<>();

//        for (TeamOrPersonBase<?> author : authors){

//            authorUuidMap.put(author.getUuid(), author);

//        }

//

//        for (String authorStr : authorSet){

//            UUID uuid = state.getAuthorUuid(authorStr);

//            TeamOrPersonBase<?> author = authorUuidMap.get(uuid);

//            authorMap.put(authorStr, author);

//        }

//        result.put(AUTHOR_NAMESPACE, authorMap);

        return result;

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

// $Id$

/**

* Copyright (C) 2015 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.edaphobase;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

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

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

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

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

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;

/**

 * @author a.mueller

 * @date 21.12.2015

 *

 */

@Component

public class EdaphobaseSynonymyImport extends EdaphobaseImportBase {

    private static final long serialVersionUID = 6641343927320994726L;

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

    private static final String tableName = "tax_synonym";

    private static final String pluralString = "synonym relationships";

    /**

     * @param tableName

     * @param pluralString

     */

    public EdaphobaseSynonymyImport() {

        super(tableName, pluralString);

    }

    @Override

    protected String getIdQuery(EdaphobaseImportState state) {

        return "SELECT tax_synonym_id  "

                + " FROM tax_synonym "

                + " ORDER BY tax_synonym.a_taxon_fk_taxon_id ";

    }

    @Override

    protected String getRecordQuery(EdaphobaseImportConfigurator config) {

        String result = "SELECT sr.* "

                + " FROM tax_synonym sr"

                + " WHERE tax_synonym_id IN (@IDSET)";

        result = result.replace("@IDSET", IPartitionedIO.ID_LIST_TOKEN);

        return result;

    }

    @Override

    public boolean doPartition(ResultSetPartitioner partitioner, EdaphobaseImportState state) {

        ResultSet rs = partitioner.getResultSet();

        Map<String, TaxonBase> map = partitioner.getObjectMap(TAXON_NAMESPACE);

        Reference<?> sourceReference = state.getTransactionalSourceReference();

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

        try {

            while (rs.next()){

                int id = rs.getInt("tax_synonym_id");

                 //parentTaxonFk

//                boolean isValid = rs.getBoolean("valid");

                Integer synId = nullSafeInt(rs, "a_taxon_fk_taxon_id");

                Integer accId = nullSafeInt(rs, "b_taxon_fk_taxon_id");

                if (synId == null || accId == null){

                    logger.warn("Either a_taxon or b_taxon is NULL for tax_synonym " + id);

                }else{

                    TaxonBase<?> synonymCandidate = state.getRelatedObject(TAXON_NAMESPACE, String.valueOf(synId), TaxonBase.class);

                    if (synonymCandidate == null){

                        logger.warn("Synonym " + synId + " not found for synonymRelations (tax_synonym): " + id);

                    }else if (synonymCandidate.isInstanceOf(Taxon.class)){

                        String message = "Synonym ("+synId+") is not synonym but accepted (valid). Can't add synonym relationship for tax_synonym: "+id;

                        logger.warn(message);

                    }else{

                        Synonym synonym = CdmBase.deproxy(synonymCandidate, Synonym.class);

                        TaxonBase<?> accepted = state.getRelatedObject(TAXON_NAMESPACE, String.valueOf(accId), TaxonBase.class);

                        if (accepted == null){

                            logger.warn("Accepted(parent) taxon " + accId + " not found for tax_synonym " + id );

                        }else if(accepted.isInstanceOf(Synonym.class)){

                            String message = "Taxon ("+accId+") is not accepted but synonym. Can't add synonym relationship for tax_synonym: "+id;

                            logger.warn(message);

                        }else{

                            Taxon taxon = CdmBase.deproxy(accepted, Taxon.class);

                            taxon.addSynonym(synonym, SynonymRelationshipType.SYNONYM_OF());

                            taxaToSave.add(synonym);

                            taxaToSave.add(taxon);

                        }

                    }

                }

//              //id

//              String nameSpace = "tax_taxon";

//              ImportHelper.setOriginalSource(taxonBase, state.getTransactionalSourceReference(), id, nameSpace);

//              ImportHelper.setOriginalSource(name, state.getTransactionalSourceReference(), id, nameSpace);

            }

        } catch (SQLException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        getTaxonService().saveOrUpdate(taxaToSave);

        return true;

    }

    @Override

    public Map<Object, Map<String, ? extends CdmBase>> getRelatedObjectsForPartition(ResultSet rs,

            EdaphobaseImportState state) {

        String nameSpace;

        Class<?> cdmClass;

        Set<String> idSet;

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

        try{

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

            while (rs.next()){

                handleForeignKey(rs, taxonIdSet, "a_taxon_fk_taxon_id");

                handleForeignKey(rs, taxonIdSet, "b_taxon_fk_taxon_id");

            }

            //name map

            nameSpace = TAXON_NAMESPACE;

            cdmClass = TaxonBase.class;

            idSet = taxonIdSet;

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

            result.put(nameSpace, taxonMap);

        } catch (SQLException e) {

            throw new RuntimeException(e);

        }

        return result;

    }

    @Override

    protected boolean doCheck(EdaphobaseImportState state) {

        return false;

    }

    @Override

    protected boolean isIgnore(EdaphobaseImportState state) {

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

    }

}

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

                makeSingleTaxon(state, rs, taxaToSave);

    /**

     * @param state

     * @param rs

     * @param taxaToSave

     * @throws SQLException

     */

    private void makeSingleTaxon(EdaphobaseImportState state, ResultSet rs, Set<TaxonBase> taxaToSave)

            throws SQLException {

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

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

        boolean isBrackets = rs.getBoolean("tax_brackets");

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

        String nameStr = rs.getString("name");

        String authorName = rs.getString("tax_author_name");

        //parentTaxonFk

        //rankFk

        Integer nomRefId = nullSafeInt(rs, "tax_document");

        boolean isValid = rs.getBoolean("valid");

        boolean idDeleted = rs.getBoolean("deleted");

        String displayString = rs.getString("display_string");

        Integer version = nullSafeInt(rs, "versionfield");

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

        String treeIndex = rs.getString("path_to_root");

//      Integer rankFk = nullSafeInt(rs, "tax_rank_fk");

        String nameAddition = rs.getString("name_addition");

        String officialRemark = rs.getString("official_remark");

        boolean isGroup = rs.getBoolean("taxonomic_group");

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

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

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

        String parentNameStr = rs.getString("parentName");

        String grandParentNameStr = rs.getString("grandParentName");

        TaxonBase<?> taxonBase;

        //Name etc.

        Rank rank = makeRank(state, rankStr);

        ZoologicalName name = ZoologicalName.NewInstance(rank);

        setNamePart(nameStr, rank, name);

        Rank parentRank = makeRank(state, parentRankStr);

        setNamePart(parentNameStr, parentRank, name);

        Rank parentParentRank = makeRank(state, grandParentRankStr);

        setNamePart(grandParentNameStr, parentParentRank, name);

        //Authors

        if (StringUtils.isNotBlank(authorName)){

            TeamOrPersonBase<?> author = state.getRelatedObject(AUTHOR_NAMESPACE, authorName, TeamOrPersonBase.class);

            if (author == null){

                logger.warn("Author not found in state: "  + authorName);

            }else{

                if (isBrackets){

                    name.setBasionymAuthorship(author);

                    name.setOriginalPublicationYear(year);

                }else{

                    name.setCombinationAuthorship(author);

                    name.setPublicationYear(year);

                }

            }

        }

        //nomRef

        if (nomRefId != null){

            Reference<?> nomRef = state.getRelatedObject(REFERENCE_NAMESPACE, String.valueOf(nomRefId), Reference.class);

            if (nomRef == null){

                logger.warn("Reference " + nomRefId + " could not be found");

            }

            name.setNomenclaturalReference(nomRef);

        }

        name.setNomenclaturalMicroReference(StringUtils.isBlank(pages)? null : pages);

        Reference<?> secRef = state.getRelatedObject(REFERENCE_NAMESPACE, state.getConfig().getSecUuid().toString(), Reference.class);

        if (secRef == null){

            secRef = makeSecRef(state);

        }

        if (isValid){

            taxonBase = Taxon.NewInstance(name, secRef);

        }else{

            taxonBase = Synonym.NewInstance(name, secRef);

        }

        taxaToSave.add(taxonBase);

        //remarks

        doNotes(taxonBase, remark);

        //id

        ImportHelper.setOriginalSource(taxonBase, state.getTransactionalSourceReference(), id, TAXON_NAMESPACE);

        ImportHelper.setOriginalSource(name, state.getTransactionalSourceReference(), id, TAXON_NAMESPACE);

    }

    /**

     * @param state

     * @return

     */

    private Reference<?> makeSecRef(EdaphobaseImportState state) {

        Reference<?> ref = ReferenceFactory.newDatabase();

        ref.setTitle(state.getConfig().getEdaphobaseSecundumTitle());

        ref.setUuid(state.getConfig().getSecUuid());

        state.addRelatedObject(REFERENCE_NAMESPACE, ref.getUuid().toString(), ref);

        getReferenceService().save(ref);

        return ref;

    }

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

                handleForeignKey(rs, referenceIdSet, "tax_document");

        //reference map

        String nameSpace = REFERENCE_NAMESPACE;

        Class<?> cdmClass = Reference.class;

        Set<String> idSet = referenceIdSet;

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

        result.put(nameSpace, referenceMap);

        //secundum

        UUID secUuid = state.getConfig().getSecUuid();

        Reference<?> secRef = getReferenceService().find(secUuid);

        referenceMap.put(secUuid.toString(), secRef);