EDIT

                authorStr = authorStr.replace(" et ", " & ");

                boolean isEtAl = false;

                if (authorStr.endsWith(" & al.")){

                    isEtAl = true;

                    authorStr = authorStr.substring(0, authorStr.length()-6).trim();

                }

                            person = Person.NewInstance();

                            person.setNomenclaturalTitle(commaSplit);

                if (singlePersons.size() > 1 || singlePersons.size() ==  1 && isEtAl){

                    team.setHasMoreMembers(isEtAl);

                handleSingleRecord(state, rs, classification, taxaToSave);

            }

        } catch (SQLException e) {

            e.printStackTrace();

        }

        getTaxonService().saveOrUpdate(taxaToSave);

        return true;

    }

/**

     * @param state

     * @param rs

 * @param taxaToSave

 * @param classification

 * @throws SQLException

     */

    private void handleSingleRecord(EdaphobaseImportState state, ResultSet rs, Classification classification, Set<TaxonBase> taxaToSave) throws SQLException {

        Reference sourceReference = state.getTransactionalSourceReference();

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

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

        if (isDeleted){

            logger.warn("Deleted not handled according to mail Stephan 2018-03-07. ID: " + id );

            return;

        }

         //parentTaxonFk

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

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

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

//        Integer rankFk = rs.getInt("tax_rank_fk");

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

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

        Integer parentTaxonFk = nullSafeInt(rs, "parent_taxon_fk");

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

            }else{

                TaxonBase<?> child = state.getRelatedObject(TAXON_NAMESPACE, String.valueOf(id), TaxonBase.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);

                        if (child == null){

                            logger.warn("Child not found. ID= " + id);

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

                        taxaToSave.add(accParent);

                }else{

//                    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, SynonymType.SYNONYM_OF());

//                        taxaToSave.add(accepted);

//                    }

            }

        }

//      //id

//      String nameSpace = "tax_taxon";

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

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

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

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

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

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

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

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

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

    public boolean doPartition(@SuppressWarnings("rawtypes") ResultSetPartitioner partitioner, EdaphobaseImportState state) {

        @SuppressWarnings("rawtypes")

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

        if (isDeleted){

            logger.warn("Deleted not handled according to mail Stephan 2018-03-07. ID: " + id );

            return;

        }

        boolean nameAdditionUsed =  isBlank(nameAddition);

        if (!nameAdditionUsed){

            nameAddition = nameAddition.trim();

        }

        //for debug only

        if (id.equals(97600) || id.equals(97601)){

            logger.debug("now");

        }

        if (rank == null){

            name.setNameCache(nameStr, true);

        }else{

            setNamePart(nameStr, rank, name);

            Rank parentRank = makeRank(state, parentRankStr);

            setNamePart(parentNameStr, parentRank, name);

            Rank parentParentRank = makeRank(state, grandParentRankStr);

            setNamePart(grandParentNameStr, parentParentRank, name);

            Rank grandParentParentRank = makeRank(state, grandGrandParentRankStr);

            setNamePart(grandGrandParentNameStr, grandParentParentRank, name);

            if (grandParentParentRank != null && grandParentParentRank.isLower(Rank.GENUS()) || isBlank(name.getGenusOrUninomial()) && !name.isProtectedNameCache()){

                logger.warn("Grand-Grandparent rank is lower than genus for " +

                        name.getTitleCache() + " (edapho-id: " + id + "; cdm-id: " + name.getId() + ")");

            }

        if (isNotBlank(authorName)){

            authorName = authorName.replace(" et ", " & ");

        String capitalWord = NonViralNameParserImplRegExBase.capitalWord;

        String autNam = "(" + capitalWord + "( in "+capitalWord+")?|Schuurmans Stekhoven|Winiszewska-Ślipińska|Fürst von Lieven|de Coninck|de Man|de Ley|de Grisse|"

                + "van der Linde|Pschorn-Walcher|van der Berg|J. Goddey)";

        if (isNotBlank(nameAddition) && nameAddition.matches("(\\[|\\()?nomen.*")){

            if ("(nomen oblitum)".equals(nameAddition) ){

                name.addStatus(NomenclaturalStatusType.ZOO_OBLITUM(), null, null);

            }else if ("nomen dubium".equals(nameAddition) || "[nomen dubium]".equals(nameAddition)){

                name.addStatus(NomenclaturalStatusType.DOUBTFUL(), null, null);

            }else if ("nomen nudum".equals(nameAddition)){

                name.addStatus(NomenclaturalStatusType.NUDUM(), null, null);

            }else if (nameAddition.matches("nomen nudum \\["+autNam+"\\, 19\\d{2}]")){

                name.addStatus(NomenclaturalStatusType.NUDUM(), null, null);

                Person nomNudAuthor = parseNomenNudumAuthor(state, name, nameAddition);

                if (name.getCombinationAuthorship()!= null || name.getBasionymAuthorship() != null){

                    logger.warn("Author already exists for nomen nudum name with author. ID: " + id);

                }

                name.setCombinationAuthorship(nomNudAuthor);

            }else{

                logger.warn("'nomen xxx' name addition not recognized: " + nameAddition + ". ID: " + id);

            }

            nameAdditionUsed = true;

        }

        if (isNotBlank(nameAddition) && nameAddition.matches(autNam + "((, "+autNam+")? & " + autNam + ")?" +    ", \\d{4}")){

            nameAddition = nameAddition.replace(" et ", " & ");

            int pos = nameAddition.length()-6;

            String authorStr = nameAddition.substring(0, pos);

            Integer naYear = Integer.valueOf(nameAddition.substring(pos +  2));

            if (name.getPublicationYear() != null){

                logger.warn("Publication year already exists. ID=" +  id);

            }

            name.setPublicationYear(naYear);

            TeamOrPersonBase<?> author = getNameAdditionAuthor(authorStr);

            if (name.getCombinationAuthorship() != null){

                logger.warn("Combination author already exists. ID=" +  id);

            }

            name.setCombinationAuthorship(author);

            nameAdditionUsed = true;

        }

        if (isNotBlank(nameAddition) && nameAddition.matches("(nec|non) " + capitalWord +  ", \\d{4}")){

            String str = nameAddition.substring(4);

            String[] split = str.split(",");

            IZoologicalName homonym = (IZoologicalName)name.clone();

            homonym.setCombinationAuthorship(null);

            homonym.setBasionymAuthorship(null);

            homonym.setPublicationYear(null);

            homonym.setOriginalPublicationYear(null);

            TeamOrPersonBase<?> author = getNameAdditionAuthor(split[0]);

            homonym.setCombinationAuthorship(author);

            homonym.setPublicationYear(Integer.valueOf(split[1].trim()));

            nameAdditionUsed = true;

        }

        //sensu, auct.

        if (isNotBlank(nameAddition) && (nameAddition.startsWith("sensu ") || "auct.".equals(nameAddition))){

            nameAddition = nameAddition.replace(" et ", " & ");

            taxonBase.setSec(null);

            taxonBase.setAppendedPhrase(nameAddition);

            //TODO

            nameAdditionUsed = true;

        }

        doNotes(taxonBase, remark, AnnotationType.TECHNICAL());

        doNotes(taxonBase, officialRemark, AnnotationType.EDITORIAL());

        if (!nameAdditionUsed){

            logger.warn("name_addition not recognized: " +  nameAddition + ". ID="+id);

            name.setAppendedPhrase(nameAddition);

        }

        String orig = displayString.replace("nomen nudum [Hirschmann, 1951]", "Hirschmann, 1951")

                .replace("  ", " ");

        String nameTitleCache = name.getTitleCache().replace("species group", "group");

        String taxonTitleCache = taxonBase.getTitleCache().replace("species group", "group");

        if (!orig.equals(nameTitleCache) && !orig.equals(name.getFullTitleCache()) && !orig.equals(taxonTitleCache)){

            String titleCache = taxonBase.getAppendedPhrase() != null ? taxonBase.getTitleCache() : name.getTitleCache();

            logger.warn("Displaystring differs from titleCache. ID=" + id + ".\n   " + displayString + "\n   " + titleCache);

        }

    /**

     * @param authorStr

     * @return

     */

    private TeamOrPersonBase<?> getNameAdditionAuthor(String authorStr) {

        TeamOrPersonBase<?> result;

        String[] splits = authorStr.split("(, | & )");

        if (splits.length == 1){

            Person person = Person.NewInstance();

            person.setNomenclaturalTitle(splits[0]);

            result = person;

        }else{

            Team team = Team.NewInstance();

            for (String split: splits){

                Person person = Person.NewInstance();

                person.setNomenclaturalTitle(split);

                team.addTeamMember(person);

            }

            result = team;

        }

        //TODO deduplicate

        return result;

    }

    /**

     * @param state

     * @param nameAddition

     * @return

     */

    private Person parseNomenNudumAuthor(EdaphobaseImportState state, IZoologicalName name, String nameAddition) {

        nameAddition = nameAddition.replace("nomen nudum [", "").replace("tz, 195]", "tz, 1952]")

                .replace("]", "");

        String[] split = nameAddition.split(", ");

        Integer year = Integer.valueOf(split[1]);

        name.setPublicationYear(year);

        //TODO deduplicate

        Person author = Person.NewInstance();

        author.setNomenclaturalTitle(split[0].trim());

        return author;

    }

    protected void doNotes(AnnotatableEntity annotatableEntity, String notes, AnnotationType type) {

        if (StringUtils.isNotBlank(notes) && annotatableEntity != null ){

            String notesString = String.valueOf(notes);

            if (notesString.length() > 65530 ){

                notesString = notesString.substring(0, 65530) + "...";

                logger.warn("Notes string is longer than 65530 and was truncated: " + annotatableEntity);

            }

            Annotation notesAnnotation = Annotation.NewInstance(notesString, Language.UNDETERMINED());

            //notesAnnotation.setAnnotationType(AnnotationType.EDITORIAL());

            //notes.setCommentator(bmiConfig.getCommentator());

            annotatableEntity.addAnnotation(notesAnnotation);

        }

    }