EDIT

error.log

import eu.etaxonomy.cdm.database.DatabaseTypeEnum;

import org.apache.log4j.Appender;

import org.apache.log4j.RollingFileAppender;

    static DbSchemaValidation hbm2dll = DbSchemaValidation.CREATE;

    static ICdmDataSource cdmDestination = null;

    static {

        DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;

        String cdmServer = "127.0.0.1";

        String cdmDB = "cdm_algea_registry";

        String cdmUserName = "edit";

        cdmDestination =  CdmDestinations.makeDestination(dbType, cdmServer, cdmDB, -1, cdmUserName, null);

        // cdmDestination = CdmDestinations.localH2();

    }

        File f = new File(System.getProperty("user.home") + "/data/Projekte/Algea Name Registry/registry/sources/IAPT/Registration_DB_from_BGBM17-cleaned.xls");

import org.apache.commons.lang.StringEscapeUtils;

import org.apache.log4j.Level;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

@Component("iAPTExcelImport")

    public static final String ANNOTATION_MARKER_STRING = "[*]";

    private static NonViralNameParserImpl nameParser = NonViralNameParserImpl.NewInstance();

    private static final Pattern nomRefTokenizeP = Pattern.compile("^(.*):\\s([^\\.:]+)\\.(.*)$");

    private static final Pattern nomRefPubYearExtractP = Pattern.compile("(.*?)(1[7,8,9][0-9]{2}).*$|^.*?[0-9]{1,2}([\\./])[0-1]?[0-9]\\3([0-9]{2})\\.$"); // 1700 - 1999

        String titleCacheStr = getValue(record, FULLNAME, true);

        String nameStr = getValue(record, NAMESTRING, true);

        String authorStr = getValue(record, AUTHORSTRING, true);

        String nomRefStr = getValue(record, LITSTRING, true);

        String nomRefTitle = null;

        String nomRefDetail = null;

        String nomRefPupDate = null;

        String nomRefPupYear = null;

        // preprocess nomRef: separate citation, reference detail, publishing date

        if(!StringUtils.isEmpty(nomRefStr)){

            nomRefStr = nomRefStr.trim();

            Matcher m = nomRefTokenizeP.matcher(nomRefStr);

            if(m.matches()){

                nomRefTitle = m.group(1);

                nomRefDetail = m.group(2);

                nomRefPupDate = m.group(3);

                // nomRefDetail.replaceAll("[\\:\\.\\s]", ""); // TODO integrate into nomRefTokenizeP

                Matcher m2 = nomRefPubYearExtractP.matcher(nomRefPupDate);

                if(m2.matches()){

                    nomRefPupYear = m2.group(2);

                    if(nomRefPupYear.length() == 2 ){

                        // it is an abbreviated year from the 19** years

                        nomRefPupYear = "19" + nomRefPupYear;

                    }

                    nomRefTitle = nomRefTitle + ": " + nomRefDetail + ". " + nomRefPupYear + ".";

                } else {

                    logger.warn("Pub year not found in " + nomRefStr );

                }

            } else {

                nomRefTitle = nomRefStr;

            }

        }

        BotanicalName taxonName;

        Map<String, AnnotationType> nameAnnotations = new HashMap<>();

        if(titleCacheStr.endsWith(ANNOTATION_MARKER_STRING) && authorStr.endsWith(ANNOTATION_MARKER_STRING)){

            nameAnnotations.put("Author abbreviation not checked.", AnnotationType.EDITORIAL());

            titleCacheStr = titleCacheStr.replace(ANNOTATION_MARKER_STRING, "").trim();

            authorStr = authorStr.replace(ANNOTATION_MARKER_STRING, "").trim();

        }

        if(!StringUtils.isEmpty(nomRefTitle)){

            String referenceSeparator = nomRefTitle.startsWith("in ") ? " " : ", ";

            String taxonFullNameStr = titleCacheStr + referenceSeparator + nomRefTitle;

            logger.debug(":::::" + taxonFullNameStr);

            taxonName = (BotanicalName) nameParser.parseReferencedName(taxonFullNameStr, NomenclaturalCode.ICNAFP, null);

        } else {

            taxonName = (BotanicalName) nameParser.parseFullName(titleCacheStr, NomenclaturalCode.ICNAFP, null);

        }

            logger.warn(line + "Name could not be parsed: " + titleCacheStr);

            boolean doRestoreTitleCacheStr = false;

            // Check titleCache

            String generatedTitleCache = taxonName.getTitleCache();

            if (!generatedTitleCache.trim().equals(titleCacheStr)) {

                logger.warn(line + "The generated titleCache differs from the imported string : " + generatedTitleCache + " <> " + titleCacheStr + " will restore original titleCacheStr");

                doRestoreTitleCacheStr = true;

            }

            if (!taxonName.getNameCache().trim().equals(nameStr)) {

            //  Author

            //nameParser.handleAuthors(taxonName, titleCacheStr, authorStr);

            //if (!titleCacheStr.equals(taxonName.getTitleCache())) {

            //    logger.warn(line + "titleCache has changed after setting authors, will restore original titleCacheStr");

            //    doRestoreTitleCacheStr = true;

            //}

            if(doRestoreTitleCacheStr){

                taxonName.setTitleCache(titleCacheStr, true);

            // Annotations

            if(!nameAnnotations.isEmpty()){

                for(String text : nameAnnotations.keySet()){

                    taxonName.addAnnotation(Annotation.NewInstance(text, nameAnnotations.get(text), Language.DEFAULT()));

                }

                getNameService().save(taxonName);

            }

     * @param doUnescapeHtmlEntities

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

        	if (logger.isDebugEnabled()) {

        	    logger.debug(originalKey + ": " + value);

        	}

            if(doUnescapeHtmlEntities){

                value = StringEscapeUtils.unescapeHtml(value);

            }

        	return value.trim();

        logger.setLevel(Level.DEBUG);

        logger.debug(record.toString());

        String reg_id = record.get(REGISTRATIONNO_PK);

            htn = StringUtils.capitalize(htn.trim());

                getTaxonService().save(higherTaxon);

                getClassificationService().saveTreeNode(higherTaxonNode);

            rootNode = higherTaxonNode;

        Rank rank = guessRank(name);

    private Rank guessRank(String name) {

        // normalize

        name = name.replaceAll("\\(.*\\)", "").trim();

        if(name.matches("^Plantae$|^Fungi$|^Musci$")){

           return Rank.KINGDOM();

        } else if(name.matches(".*incertae sedis$|^Fossil no group assigned$")){

           return Rank.FAMILY();

        } else if(name.matches(".*phyta$|.*mycota$")){

           return Rank.SECTION_BOTANY();

        } else if(name.matches(".*phytina$|.*mycotina$")){

           return Rank.SUBSECTION_BOTANY();

        } else if(name.matches(".*opsida$|.*phyceae$|.*mycetes$|.*ones$")){

           return Rank.CLASS();

        } else if(name.matches(".*idae$|.*phycidae$|.*mycetidae$")){

           return Rank.SUBCLASS();

        } else if(name.matches(".*ales$")){

           return Rank.ORDER();

        } else if(name.matches(".*ineae$")){

           return Rank.SUBORDER();

        } else if(name.matches(".*oideae$")){

           return Rank.SUBFAMILY();

        } else if(name.matches(".*eae$")){

           return Rank.TRIBE();

        } else if(name.matches(".*inae$")){

           return Rank.SUBTRIBE();

        } else if(name.matches(".*ae$")){

           return Rank.FAMILY();

        }

        return Rank.UNKNOWN_RANK();

    }

        return new IAPTImportState(this);