/ - Diff - EDIT - EDIT Project Management

« Previous | Next »

Revision 5ea7ddcb

Added by Andreas Müller over 12 years ago

ID 5ea7ddcb62f3e8811121b844f0b0621c4bad9079
Parent bd2ed834
Child 33d2c80f

updates for markup import

     import org.springframework.security.authentication.AuthenticationManager;
     import org.springframework.security.core.Authentication;
     import org.springframework.stereotype.Component;
     import org.springframework.transaction.TransactionStatus;
     import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade;
     import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade.DerivedUnitType;
-...
     import eu.etaxonomy.cdm.model.name.TaxonNameBase;
     import eu.etaxonomy.cdm.model.occurrence.Collection;
     import eu.etaxonomy.cdm.model.occurrence.DerivedUnitBase;
     import eu.etaxonomy.cdm.model.occurrence.FieldObservation;
     import eu.etaxonomy.cdm.model.occurrence.Specimen;
     import eu.etaxonomy.cdm.model.reference.IArticle;
     import eu.etaxonomy.cdm.model.reference.IJournal;
-...
+     *
      */
     @Component
     public class MarkupDocumentImport extends MarkupImportBase implements
     		ICdmIO<MarkupImportState> {
     	private static final String TO_COUPLET = "toCouplet";
     	private static final String TO_TAXON = "toTaxon";
     	private static final String TO_KEY = "toKey";
     	private static final String TEXT = "text";
     	private static final String QUESTION = "question";
     	private static final String COUPLET = "couplet";
     	private static final String KEYNOTES = "keynotes";
     	private static final String KEY_TITLE = "keyTitle";
     	private static final String IS_SPOTCHARACTERS = "isSpotcharacters";
     public class MarkupDocumentImport extends MarkupImportBase implements ICdmIO<MarkupImportState> {
     	private static final String FREQUENCY = "frequency";
     	private static final String REF_NUM = "refNum";
     	private static final String TAXONTYPE = "taxontype";
     	private static final String SERIALS_ABBREVIATIONS = "serialsAbbreviations";
     	private static final String DEDICATION = "dedication";
     	private static final String BIBLIOGRAPHY = "bibliography";
     	private static final String QUOTE = "quote";
     	private static final String HABITAT = "habitat";
     	private static final String LIFE_CYCLE_PERIODS = "lifeCyclePeriods";
     	private static final String DISTRIBUTION_LOCALITY = "distributionLocality";
     	private static final String REFERENCE = "reference";
     	private static final Logger logger = Logger
     			.getLogger(MarkupDocumentImport.class);
     	private static final Logger logger = Logger.getLogger(MarkupDocumentImport.class);
     	private static final boolean CREATE_NEW = true;
     	private static final boolean IS_IMAGE_GALLERY = true;
-...
     	private static final String ALTITUDE = "altitude";
     	private static final String ANNOTATION = "annotation";
     	private static final String AUTHOR = "author";
     	private static final String BIBLIOGRAPHY = "bibliography";
     	private static final String BIOGRAPHIES = "biographies";
     	private static final String BOLD = "bold";
     	private static final String BR = "br";
     	private static final String CHAR = "char";
     	private static final String CITATION = "citation";
     	private static final String COLLECTION = "collection";
     	private static final String COLLECTION_TYPE_STATUS = "collectionTypeStatus";
     	private static final String COLLECTOR = "collector";
     	private static final String COORDINATES = "coordinates";
     	private static final String COUPLET = "couplet";
     	private static final String DATES = "dates";
     	private static final String DEFAULT_MEDIA_URL = "defaultMediaUrl";
     	private static final String DESTROYED = "destroyed";
     	private static final String DETAILS = "details";
     	private static final String DISTRIBUTION_LIST = "distributionList";
     	private static final String DISTRIBUTION_LOCALITY = "distributionLocality";
     	private static final String EDITION = "edition";
     	private static final String EDITORS = "editors";
     	private static final String FEATURE = "feature";
-...
     	private static final String FIELD_NUM = "fieldNum";
     	private static final String FULL_NAME = "fullName";
     	private static final String FULL_TYPE = "fullType";
     	private static final String GATHERING = "gathering";
     	private static final String HEADING = "heading";
     	private static final String HABITAT = "habitat";
     	private static final String HABITAT_LIST = "habitatList";
     	private static final String HOMONYM = "homonym";
     	private static final String HOMOTYPES = "homotypes";
-...
     	private static final String INFRANK = "infrank";
     	private static final String INFRAUT = "infraut";
     	private static final String INFRPARAUT = "infrparaut";
     	private static final String IS_SPOTCHARACTERS = "isSpotcharacters";
     	private static final String ISSUE = "issue";
     	private static final String ITALICS = "italics";
     	private static final String KEY = "key";
     	private static final String KEY_TITLE = "keyTitle";
     	private static final String KEYNOTES = "keynotes";
     	private static final String LIFE_CYCLE_PERIODS = "lifeCyclePeriods";
     	private static final String LOCALITY = "locality";
     	private static final String LOST = "lost";
     	private static final String META_DATA = "metaData";
-...
     	private static final String PUBNAME = "pubname";
     	private static final String PUBTITLE = "pubtitle";
     	private static final String PUBTYPE = "pubtype";
     	private static final String QUESTION = "question";
     	private static final String RANK = "rank";
     	private static final String REF = "ref";
     	private static final String REF_NUM = "refNum";
     	private static final String REF_PART = "refPart";
     	private static final String REFERENCE = "reference";
     	private static final String REFERENCES = "references";
     	private static final String TAXON = "taxon";
     	private static final String TAXONTITLE = "taxontitle";
     	private static final String TEXT = "text";
     	private static final String TEXT_SECTION = "textSection";
     	private static final String TO_COUPLET = "toCouplet";
     	private static final String TO_KEY = "toKey";
     	private static final String TO_TAXON = "toTaxon";
     	private static final String TYPE = "type";
     	private static final String TYPE_STATUS = "typeStatus";
     	private static final String TREATMENT = "treatment";
     	private static final String SERIALS_ABBREVIATIONS = "serialsAbbreviations";
     	private static final String SPECIMEN_TYPE = "specimenType";
     	private static final String STATUS = "status";
     	private static final String STRING = "string";
-...
+    	}
     	@Override
     	public void doInvoke(MarkupImportState state) {
     		fireProgressEvent("Start import markup document",
     				"Before start of document");
     		fireWarningEvent("Test a warning", "At start", 17);
     	public void doInvoke(MarkupImportState state) {
     		fireProgressEvent("Start import markup document", "Before start of document");
     		Queue<CdmBase> outputStream = new LinkedList<CdmBase>();
     		TransactionStatus tx = startTransaction();
     		// FIXME reset state
     		doAllTheOldOtherStuff(state);
-...
     			// publication
     			String elName = PUBLICATION;
     			boolean hasPublication = false;
     			while (reader.hasNext()) {
     				XMLEvent nextEvent = reader.nextEvent();
     				if (isStartingElement(nextEvent, elName)) {
-...
     					fireSchemaConflictEventExpectedStartTag(elName, reader);
+    				}
+    			}
     			commitTransaction(tx);
     			// //SAX
     			// ImportHandlerBase handler= new PublicationHandler(this);
     			// parseSAX(state, handler);
     		} catch (FactoryConfigurationError e1) {
     			fireWarningEvent(
     					"Some error occurred while setting up xml factory. Data can't be imported",
     					"Start", 16);
     			fireWarningEvent("Some error occurred while setting up xml factory. Data can't be imported", "Start", 16);
     			state.setUnsuccessfull();
     		} catch (XMLStreamException e1) {
     			fireWarningEvent(
     					"An XMLStreamException occurred while parsing. Data can't be imported",
     					"Start", 16);
     			fireWarningEvent("An XMLStreamException occurred while parsing. Data can't be imported", "Start", 16);
     			state.setUnsuccessfull();
     			// } catch (ParserConfigurationException e) {
     			// fireWarningEvent("A ParserConfigurationException occurred while parsing. Data can't be imported",
-...
     					keySet.add(key);
+    				}
     				save(keySet, state);
     				//unmatched key leads
     				UnmatchedLeads unmatched = state.getUnmatchedLeads();
     				if (unmatched.size() > 0){
     					String message = "The following key leads are unmatched: %s";
     					message = String.format(message, state.getUnmatchedLeads().toString());
     					fireWarningEvent(message, next, 6);
+    				}
     //				save(keyNodesToSave, state);
     				return;
-...
     	private void doTaxonRelation(MarkupImportState state, Taxon taxon,
     			Taxon lastTaxon, Location dataLocation) {
     		Classification tree = makeTree(state);
     		Classification tree = makeTree(state, dataLocation);
     		if (lastTaxon == null) {
     			tree.addChildTaxon(taxon, null, null, null);
     			return;
-...
     	/**
     	 * @param state
     	 * @param dataLocation
     	 * @return
     	 */
     	private Classification makeTree(MarkupImportState state) {
     	private Classification makeTree(MarkupImportState state, Location dataLocation) {
     		Classification result = state.getTree(null);
     		if (result == null) {
     			UUID uuid = state.getConfig().getClassificationUuid();
     			if (uuid == null) {
     				logger.warn("No classification uuid is defined");
     				String message = "No classification uuid is defined";
     				fireWarningEvent(message, makeLocationStr(dataLocation), 6);
     				result = createNewClassification(state);
     			} else {
     				result = getClassificationService().find(uuid);
-...
     		return result;
+    	}
     	private Taxon handleTaxon(MarkupImportState state, XMLEventReader reader,
     			StartElement parentEvent) throws XMLStreamException {
     	private Taxon handleTaxon(MarkupImportState state, XMLEventReader reader, StartElement parentEvent) throws XMLStreamException {
     		// TODO progress monitoring
     		Map<String, Attribute> attributes = getAttributes(parentEvent);
     		Taxon taxon = createTaxonAndName(state, attributes);
-...
     					checkMandatoryElement(hasNomenclature, parentEvent,	NOMENCLATURE);
     					handleUnexpectedAttributes(parentEvent.getLocation(),attributes);
     					makeKeyNodes(state, parentEvent);
     					makeKeyNodes(state, parentEvent, taxonTitle);
     					state.setCurrentTaxon(null);
     					state.setCurrentTaxonNum(null);
     					save(taxon, state);
-...
     		throw new IllegalStateException("<Taxon> has no closing tag");
+    	}
     	private void makeKeyNodes(MarkupImportState state, XMLEvent event) {
     	private void makeKeyNodes(MarkupImportState state, XMLEvent event, String taxonTitle) {
     		Taxon taxon = state.getCurrentTaxon();
     		String num = state.getCurrentTaxonNum();
     		String nameString = CdmBase.deproxy(taxon.getName(), NonViralName.class).getNameCache();
     //		String nameString = taxonTitle;
     		//try to find matching lead nodes
     		UnmatchedLeadsKey leadsKey = UnmatchedLeadsKey.NewInstance(num, nameString);
     		Set<PolytomousKeyNode> matchingNodes = handleMatchingNodes(state, taxon, leadsKey);
     		//same without using the num
     		if (num != null){
     		if (num != null){//same without using the num
     			UnmatchedLeadsKey noNumLeadsKey = UnmatchedLeadsKey.NewInstance("", nameString);
     			//TODO inform about differences
     			handleMatchingNodes(state, taxon, noNumLeadsKey);
     			Set<PolytomousKeyNode> noNumMatchingNodes = handleMatchingNodes(state, taxon, noNumLeadsKey);
     			if(noNumMatchingNodes.size() > 0){
     				String message ="Taxon matches additional key node when not considering <num> attribute in taxontitle. This may be correct but may also indicate an error.";
     				fireWarningEvent(message, event, 1);
+    			}
+    		}
     		//report missing match, if num exists
     		if (matchingNodes.isEmpty() && num != null){
     			String message = "Taxon has num in taxontitle but no matching nodes exist: %s, Key: %s";
     			String message = "Taxon has <num> attribute in taxontitle but no matching key nodes exist: %s, Key: %s";
     			message = String.format(message, num, leadsKey.toString());
     			fireWarningEvent(message, event, 1);
+    		}
-...
     		String isSpotcharacters = getAndRemoveAttributeValue(attributes, IS_SPOTCHARACTERS);
     		if (isNotBlank(isSpotcharacters) ) {
     			//TODO isSpotcharacters
     			String message = "isSpotcharacters not yet implemented for <key>";
     			String message = "Attribute isSpotcharacters not yet implemented for <key>";
     			fireWarningEvent(message, parentEvent, 4);
+    		}
-...
     				return;
     			} else if (isEndingElement(next, KEYNOTES)){
     				popUnimplemented(next.asEndElement());
     			} else if (next.isStartElement()) {
     				if (isStartingElement(next, KEY_TITLE)) {
     			} else if (isStartingElement(next, KEY_TITLE)) {
     					handleKeyTitle(state, reader, next);
     				} else if (isStartingElement(next, KEYNOTES)) {
     					//TODO
     					handleNotYetImplementedElement(next);
     				} else if (isStartingElement(next, COUPLET)) {
     					PolytomousKeyNode node = null;
     					if (isFirstCouplet){
     						node = key.getRoot();
     						isFirstCouplet = false;
+    					}
     					handleCouplet(state, reader, next, node);
     				} else {
     					handleUnexpectedStartElement(next.asStartElement());
     			} else if (isStartingElement(next, KEYNOTES)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isStartingElement(next, COUPLET)) {
     				PolytomousKeyNode node = null;
     				if (isFirstCouplet){
     					node = key.getRoot();
     					isFirstCouplet = false;
+    				}
     				handleCouplet(state, reader, next, node);
     			} else {
     				handleUnexpectedElement(next);
+    			}
+    		}
     		throw new IllegalStateException("<key> has no closing tag");
+    	}
     	/**
-...
     			if (isMyEndingElement(next, parentEvent)) {
     				completeCouplet(state, parentEvent, parentNode, num, childList);
     				return;
     			} else if (isEndingElement(next, KEYNOTES)){
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, QUESTION)) {
     				handleQuestion(state, reader, next, childList);
     			} else if (isStartingElement(next, KEYNOTES)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, KEYNOTES)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else {
     				handleUnexpectedElement(next);
+    			}
-...
     			XMLEvent next = readNoWhitespace(reader);
     			if (isMyEndingElement(next, parentEvent)) {
     				return;
     			} else if (isEndingElement(next, TO_KEY)){
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isEndingElement(next, KEYNOTES)){
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, TEXT)) {
     				String text = getCData(state, reader, next);
     				KeyStatement statement = KeyStatement.NewInstance(text);
-...
     				handleToCouplet(state, reader, next, myNode);
     			} else if (isStartingElement(next, TO_TAXON)) {
     				handleToTaxon(state, reader, next, myNode);
     			} else if (isStartingElement(next, TO_KEY)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, TO_KEY)){
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, KEYNOTES)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, KEYNOTES)){
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else {
     				handleUnexpectedElement(next);
+    			}
-...
     	private void handleToCouplet(MarkupImportState state, XMLEventReader reader, XMLEvent next, PolytomousKeyNode node) throws XMLStreamException {
     		String num = getOnlyAttribute(next, NUM, true);
     		String cData = getCData(state, reader, next, false);
     		if (isNotBlank(cData)){
     			String message = "CData ('%s') not handled";
     		if (isNotBlank(cData) && ! cData.equals(num)){
     			String message = "CData ('%s') not handled in <toCouplet>";
     			message = String.format(message, cData);
     			fireWarningEvent(message, next, 4);
+    		}
-...
     		if (strGoto == null){
     			return "";
+    		}
     		String strGenusName = CdmBase.deproxy(taxon.getName(), NonViralName.class).getGenusOrUninomial();
     		NonViralName<?> name = CdmBase.deproxy(taxon.getName(), NonViralName.class);
     		String strGenusName = name.getGenusOrUninomial();
     		strGoto = strGoto.replaceAll("\\([^\\(\\)]*\\)", "");  //replace all brackets
     		strGoto = strGoto.replaceAll("\\s+", " "); //replace multiple whitespaces by exactly one whitespace
-...
     			if (isGenusAbbrev(single, strGenusName)){
     				split[i] = strGenusName;
+    			}
     //			if (isInfraSpecificMarker(single)){
     //				String strSpeciesName = CdmBase.deproxy(taxon.getName(), NonViralName.class).getSpecificEpithet();
     //				split[i] = strGenusName + " " + strSpeciesName + " ";
     //			}
     			if (isInfraSpecificMarker(single)){
     				String strSpeciesEpi = name.getSpecificEpithet();
     				if (isBlank(result)){
     					result += strGenusName + " " + strSpeciesEpi;
+    				}
+    			}
     			result = (result + " " + split[i]).trim();
+    		}
     		return result;
+    	}
     	private boolean isInfraSpecificMarker(String single) {
     		try {
     			if (Rank.getRankByAbbreviation(single).isInfraSpecific()){
     				return true;
     			}else{
     				return false;
+    			}
     		} catch (UnknownCdmTypeException e) {
     			return false;
+    		}
+    	}
     	private boolean isGenusAbbrev(String single, String strGenusName) {
     		if (! single.matches("[A-Z]\\.?")) {
     			return false;
-...
     	 * @throws XMLStreamException
     	 */
     	private String makeNotesString(MarkupImportState state,	XMLEventReader reader, String text, XMLEvent next) throws XMLStreamException {
     		Map<String, String> stringMap = handleString(state, reader,	next);
     		Map<String, String> stringMap = handleString(state, reader,	next, null);
     		if (stringMap.size() == 0){
     			String message = "No text available in <notes>";
     			fireWarningEvent(message, next, 4);
-...
     		// TODO handle attributes
     		while (reader.hasNext()) {
     			XMLEvent next = readNoWhitespace(reader);
     			if (next.isEndElement()) {
     				if (isMyEndingElement(next, parentEvent)) {
     					text = CdmUtils.removeBrackets(text);
     					if (checkMandatoryText(text, parentEvent)) {
     						text = normalize(text);
     						dataHolder.writer = text;
     						dataHolder.footnotes = footnotes;
     						// Extension
     						UUID uuidWriterExtension = MarkupTransformer.uuidWriterExtension;
     						ExtensionType writerExtensionType = this
     								.getExtensionType(state, uuidWriterExtension,
     										"Writer", "writer", "writer");
     						Extension extension = Extension.NewInstance();
     						extension.setType(writerExtensionType);
     						extension.setValue(text);
     						dataHolder.extension = extension;
     						// Annotation
     						UUID uuidWriterAnnotation = MarkupTransformer.uuidWriterAnnotation;
     						AnnotationType writerAnnotationType = this
     								.getAnnotationType(state, uuidWriterAnnotation,
     										"Writer", "writer", "writer", null);
     						Annotation annotation = Annotation.NewInstance(text,
     								writerAnnotationType, Language.DEFAULT());
     						dataHolder.annotation = annotation;
     						return dataHolder;
     					} else {
     						return null;
+    					}
     			if (isMyEndingElement(next, parentEvent)) {
     				text = CdmUtils.removeBrackets(text);
     				if (checkMandatoryText(text, parentEvent)) {
     					text = normalize(text);
     					dataHolder.writer = text;
     					dataHolder.footnotes = footnotes;
     					// Extension
     					UUID uuidWriterExtension = MarkupTransformer.uuidWriterExtension;
     					ExtensionType writerExtensionType = this
     							.getExtensionType(state, uuidWriterExtension,
     									"Writer", "writer", "writer");
     					Extension extension = Extension.NewInstance();
     					extension.setType(writerExtensionType);
     					extension.setValue(text);
     					dataHolder.extension = extension;
     					// Annotation
     					UUID uuidWriterAnnotation = MarkupTransformer.uuidWriterAnnotation;
     					AnnotationType writerAnnotationType = this.getAnnotationType(state, uuidWriterAnnotation, "Writer", "writer", "writer", null);
     					Annotation annotation = Annotation.NewInstance(text, writerAnnotationType, Language.DEFAULT());
     					dataHolder.annotation = annotation;
     					return dataHolder;
     				} else {
     					if (isEndingElement(next, FOOTNOTE)) {
     						// NOT YET IMPLEMENTED
     						popUnimplemented(next.asEndElement());
     					} else {
     						handleUnexpectedEndElement(next.asEndElement());
     						state.setUnsuccessfull();
+    					}
     					return null;
+    				}
     			} else if (next.isStartElement()) {
     				if (isStartingElement(next, FOOTNOTE_REF)) {
     					FootnoteDataHolder footNote = handleFootnoteRef(state,
     							reader, next);
     					if (footNote.isRef()) {
     						footnotes.add(footNote);
     					} else {
     						logger.warn("Non ref footnotes not yet impelemnted");
+    					}
     			} else if (isStartingElement(next, FOOTNOTE_REF)) {
     				FootnoteDataHolder footNote = handleFootnoteRef(state, reader, next);
     				if (footNote.isRef()) {
     					footnotes.add(footNote);
     				} else {
     					handleUnexpectedStartElement(next);
     					state.setUnsuccessfull();
     					logger.warn("Non ref footnotes not yet impelemnted");
+    				}
     			} else if (next.isCharacters()) {
     				text += next.asCharacters().getData();
-...
     				state.setUnsuccessfull();
+    			}
+    		}
     		return null;
     		throw new IllegalStateException("<writer> has no end tag");
+    	}
     	private void registerFootnotes(MarkupImportState state,
-...
     		throw new IllegalStateException("<figureRef> has no end tag");
+    	}
     	private FootnoteDataHolder handleFootnote(MarkupImportState state,
     			XMLEventReader reader, XMLEvent parentEvent)
     			throws XMLStreamException {
     	private FootnoteDataHolder handleFootnote(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent) throws XMLStreamException {
     		FootnoteDataHolder result = new FootnoteDataHolder();
     		Map<String, Attribute> attributes = getAttributes(parentEvent);
     		result.id = getAndRemoveAttributeValue(attributes, ID);
-...
     		return;
+    	}
     	private String handleFootnoteString(MarkupImportState state,
     			XMLEventReader reader, XMLEvent parentEvent)
     			throws XMLStreamException {
     	private String handleFootnoteString(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent) throws XMLStreamException {
     		boolean isTextMode = true;
     		String text = "";
     		while (reader.hasNext()) {
-...
     			} else if (next.isEndElement()) {
     				if (isEndingElement(next, FULL_NAME)) {
     					popUnimplemented(next.asEndElement());
     				} else if (isEndingElement(next, COLLECTION)) {
     					popUnimplemented(next.asEndElement());
     				} else if (isEndingElement(next, BR)) {
     					isTextMode = true;
     				} else if (isHtml(next)) {
-...
     			} else if (next.isStartElement()) {
     				if (isStartingElement(next, FULL_NAME)) {
     					handleNotYetImplementedElement(next);
     				} else if (isStartingElement(next, COLLECTION)) {
     					handleNotYetImplementedElement(next);
     				} else if (isStartingElement(next, GATHERING)) {
     					text += handleInLineGathering(state, reader, next);
     				} else if (isStartingElement(next, REFERENCES)) {
     					text += " " + handleInLineReferences(state, reader, next)+ " ";
     				} else if (isStartingElement(next, BR)) {
-...
     					String message = "footnoteString is not in text mode";
     					fireWarningEvent(message, next, 6);
     				} else {
     					text += next.asCharacters().getData().trim(); // getCData(state,
     																	// reader,
     																	// next);
     																	// does not
     																	// work as
     																	// we have
     																	// inner
     																	// tags like
     																	// <references>
     					text += next.asCharacters().getData().trim();
     					// getCData(state, reader, next); does not work as we have inner tags like <references>
+    				}
     			} else {
     				handleUnexpectedEndElement(next.asEndElement());
-...
+    	}
     	private String handleInLineGathering(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent) throws XMLStreamException {
     		DerivedUnitFacade facade = DerivedUnitFacade.NewInstance(DerivedUnitType.DerivedUnit.FieldObservation);
     		handleGathering(state, reader, parentEvent, null, facade);
     		FieldObservation fieldObservation = facade.innerFieldObservation();
     		String result = "<cdm:specimen uuid='%s'>%s</specimen>";
     		result = String.format(result, fieldObservation.getUuid(), fieldObservation.getTitleCache());
     		save(fieldObservation, state);
     		return result;
+    	}
     	private String handleInLineReferences(MarkupImportState state,
     			XMLEventReader reader, XMLEvent parentEvent)
     			throws XMLStreamException {
-...
     				handleUnexpectedElement(next);
+    			}
+    		}
     		// TODO handle missing end element
     		throw new IllegalStateException("<References> has no closing tag");
+    	}
     	private String handleInLineReference(MarkupImportState state,
     			XMLEventReader reader, XMLEvent parentEvent)
     			throws XMLStreamException {
     	private String handleInLineReference(MarkupImportState state,XMLEventReader reader, XMLEvent parentEvent)throws XMLStreamException {
     		Reference<?> reference = handleReference(state, reader, parentEvent);
     		String result = "<ref uuid='%s'>%s</ref>";
     		result = String.format(result, reference.getUuid(),
     				reference.getTitleCache());
     		String result = "<cdm:ref uuid='%s'>%s</ref>";
     		result = String.format(result, reference.getUuid(), reference.getTitleCache());
     		save(reference, state);
     		return result;
+    	}
     	private Reference<?> handleReference(MarkupImportState state,
     			XMLEventReader reader, XMLEvent parentEvent)
     			throws XMLStreamException {
     	private Reference<?> handleReference(MarkupImportState state,XMLEventReader reader, XMLEvent parentEvent)throws XMLStreamException {
     		checkNoAttributes(parentEvent);
     		boolean hasRefPart = false;
-...
     					// homotypicalGroup);
     				} else if (isStartingElement(next, TYPE_STATUS)) {
     					handleNotYetImplementedElement(next);
     				} else if (isStartingElement(next, COLLECTION)) {
     					handleCollection(state, reader, next, homotypicalGroup,
     							facade);
     				} else if (isStartingElement(next, GATHERING)) {
     					handleGathering(state, reader, next, homotypicalGroup, facade);
     				} else if (isStartingElement(next, ORIGINAL_DETERMINATION)) {
     					handleNotYetImplementedElement(next);
     				} else if (isStartingElement(next, SPECIMEN_TYPE)) {
-...
+    	}
     	private void handleCollection(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent, HomotypicalGroup homotypicalGroup, DerivedUnitFacade facade)
     			throws XMLStreamException {
     	private void handleGathering(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent, HomotypicalGroup homotypicalGroup, DerivedUnitFacade facade) throws XMLStreamException {
     		checkNoAttributes(parentEvent);
     		boolean hasCollector = false;
     		boolean hasFieldNum = false;
-...
+    	}
     	private void handleLocality(MarkupImportState state, XMLEventReader reader,
     			XMLEvent parentEvent, DerivedUnitFacade facade)
     			throws XMLStreamException {
     	private void handleLocality(MarkupImportState state, XMLEventReader reader,XMLEvent parentEvent, DerivedUnitFacade facade)throws XMLStreamException {
     		String classValue = getClassOnlyAttribute(parentEvent);
     		boolean isLocality = false;
     		NamedAreaLevel areaLevel = null;
-...
     	 * @return
     	 * @throws XMLStreamException
     	 */
     	private NonViralName<?> handleNom(MarkupImportState state,
     			XMLEventReader reader, XMLEvent parentEvent,
     	private NonViralName<?> handleNom(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent,
     			HomotypicalGroup homotypicalGroup) throws XMLStreamException {
     		boolean isSynonym = false;
     		boolean isNameType = state.isNameType();
-...
     		makeRankDecision(state, nameMap, name, event, infrank);
     		// test consistency of rank and authors
     		testRankAuthorConsistency(name, event, authorStr, paraut, infrParAut,
     				infrAut);
     		testRankAuthorConsistency(name, event, authorStr, paraut, infrParAut,infrAut);
     		// authors
     		makeNomenclaturalAuthors(name, event, authorStr, paraut, infrParAut,
     				infrAut);
     		makeNomenclaturalAuthors(name, event, authorStr, paraut, infrParAut,infrAut);
     		// status
     		// TODO handle pro parte, pro syn. etc.
-...
     	 * @param infrAut
     	 */
     	private void makeNomenclaturalAuthors(NonViralName name, XMLEvent event,
     			String authorStr, String paraut, String infrParAut, String infrAut) {
     		if (name.getRank().isInfraSpecific()) {
     				String authorStr, String paraut, String infrParAut, String infrAut) {
     		if (name.getRank() != null && name.getRank().isInfraSpecific()) {
     			if (StringUtils.isNotBlank(infrAut)) {
     				INomenclaturalAuthor[] authorAndEx = authorAndEx(infrAut, event);
     				name.setCombinationAuthorTeam(authorAndEx[0]);
     				name.setExCombinationAuthorTeam(authorAndEx[1]);
+    			}
     			if (StringUtils.isNotBlank(infrParAut)) {
     				INomenclaturalAuthor[] authorAndEx = authorAndEx(infrParAut,
     						event);
     				INomenclaturalAuthor[] authorAndEx = authorAndEx(infrParAut, event);
     				name.setBasionymAuthorTeam(authorAndEx[0]);
     				name.setExBasionymAuthorTeam(authorAndEx[1]);
+    			}
     		} else {
     			if (name.getRank() == null){
     				String message = "No rank defined. Check correct usage of authors!";
     				fireWarningEvent(message, event, 4);
     				if (isNotBlank(infrParAut) || isNotBlank(infrAut)){
     					authorStr = infrAut;
     					paraut = infrParAut;
+    				}
+    			}
     			if (StringUtils.isNotBlank(authorStr)) {
     				INomenclaturalAuthor[] authorAndEx = authorAndEx(authorStr,
     						event);
     				INomenclaturalAuthor[] authorAndEx = authorAndEx(authorStr, event);
     				name.setCombinationAuthorTeam(authorAndEx[0]);
     				name.setExCombinationAuthorTeam(authorAndEx[1]);
+    			}
-...
+    	}
     	/**
     	 * Tests if the names rank is consistent with the given author strings.
     	 * @param name
     	 * @param event
     	 * @param authorStr
-...
     	 * @param infrAut
     	 */
     	private void testRankAuthorConsistency(NonViralName name, XMLEvent event,
     			String authorStr, String paraut, String infrParAut, String infrAut) {
     					String authorStr, String paraut, String infrParAut, String infrAut) {
     		if (name.getRank() == null){
     			return;
+    		}
     		if (name.getRank().isInfraSpecific()) {
     			if (StringUtils.isBlank(infrParAut)
     					&& StringUtils.isNotBlank(infrAut)
     					&& (StringUtils.isNotBlank(paraut) || StringUtils
     							.isNotBlank(authorStr))) {
     					&& (StringUtils.isNotBlank(paraut) || StringUtils.isNotBlank(authorStr))) {
     				String message = "Rank is infraspecicific but has only specific or higher author(s)";
     				fireWarningEvent(message, event, 4);
+    			}
     		} else {
     			// is not infraspecific
     			if (StringUtils.isNotBlank(infrParAut)
     					|| StringUtils.isNotBlank(infrAut)) {
     			if (StringUtils.isNotBlank(infrParAut) 	|| StringUtils.isNotBlank(infrAut)) {
     				String message = "Rank is not infraspecicific but name has infra author(s)";
     				fireWarningEvent(message, event, 4);
+    			}
-...
+    	}
     	private void handleRefPart(MarkupImportState state, XMLEventReader reader,
     			XMLEvent parentEvent, Map<String, String> refMap)
     			throws XMLStreamException {
     	private void handleRefPart(MarkupImportState state, XMLEventReader reader,XMLEvent parentEvent, Map<String, String> refMap) throws XMLStreamException {
     		String classValue = getClassOnlyAttribute(parentEvent);
     		String text = "";
-...
+    	}
     	private Reference createReference(MarkupImportState state,
     			Map<String, String> refMap, XMLEvent parentEvent) {
     	private Reference createReference(MarkupImportState state, Map<String, String> refMap, XMLEvent parentEvent) {
     		// TODO
     		Reference reference;
-...
     		reference.setDatePublished(TimePeriod.parseString(year));
     		// TODO
     		// ALTERNATEPUBTITLE
     		// ISSUE
     		// NOTES
     		String[] unhandledList = new String[]{ALTERNATEPUBTITLE, ISSUE, NOTES, STATUS};
     		for (String unhandled : unhandledList){
     			String value = getAndRemoveMapKey(refMap, unhandled);
     			if (isNotBlank(value)){
     				this.handleNotYetImplementedAttributeValue(parentEvent, CLASS, unhandled);
+    			}
+    		}
     		for (String key : refMap.keySet()) {
     			if (!DETAILS.equalsIgnoreCase(key)) {
     				this.fireUnexpectedAttributeValue(parentEvent, CLASS, key);
-...
+    		}
+    	}
     	private void handleFeature(MarkupImportState state, XMLEventReader reader,
     			XMLEvent parentEvent) throws XMLStreamException {
     	private void handleFeature(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent) throws XMLStreamException {
     		String classValue = getClassOnlyAttribute(parentEvent);
     		Feature feature = makeFeature(classValue, state, parentEvent);
     		Taxon taxon = state.getCurrentTaxon();
     		TaxonDescription taxonDescription = getTaxonDescription(taxon, state
     				.getConfig().getSourceReference(), NO_IMAGE_GALLERY, CREATE_NEW);
     		TaxonDescription taxonDescription = getTaxonDescription(taxon, state.getConfig().getSourceReference(), NO_IMAGE_GALLERY, CREATE_NEW);
     		// TextData figureHolderTextData = null; //for use with one TextData for
     		// all figure only
     		boolean isDescription = feature.equals(Feature.DESCRIPTION());
     		DescriptionElementBase lastDescriptionElement = null;
     		while (reader.hasNext()) {
     			XMLEvent next = readNoWhitespace(reader);
     			if (next.isEndElement()) {
     				if (isMyEndingElement(next, parentEvent)) {
     					return;
     				} else {
     					if (isEndingElement(next, DISTRIBUTION_LIST)
     							|| isEndingElement(next, HABITAT_LIST)) {
     						// only handle list elements
     					} else {
     						handleUnexpectedEndElement(next.asEndElement());
+    					}
     			if (isMyEndingElement(next, parentEvent)) {
     				return;
     			} else if (isEndingElement(next, DISTRIBUTION_LIST) || isEndingElement(next, HABITAT_LIST)) {
     				// only handle list elements
     			} else if (isStartingElement(next, HEADING)) {
     				makeFeatureHeading(state, reader, classValue, feature, next);
     			} else if (isStartingElement(next, WRITER)) {
     				makeFeatureWriter(state, reader, feature, taxon, next);
     //			} else if (isStartingElement(next, DISTRIBUTION_LOCALITY)) {
     //				if (!feature.equals(Feature.DISTRIBUTION())) {
     //					String message = "Distribution locality only allowed for feature of type 'distribution'";
     //					fireWarningEvent(message, next, 4);
     //				}
     //				handleDistributionLocality(state, reader, next);
     			} else if (isStartingElement(next, DISTRIBUTION_LIST) || isStartingElement(next, HABITAT_LIST)) {
     				// only handle single list elements
     			} else if (isStartingElement(next, HABITAT)) {
     				if (!(feature.equals(Feature.HABITAT())
     						|| feature.equals(Feature.HABITAT_ECOLOGY())
     						|| feature.equals(Feature.ECOLOGY()))) {
     					String message = "Habitat only allowed for feature of type 'habitat','habitat ecology' or 'ecology'";
     					fireWarningEvent(message, next, 4);
+    				}
     			} else if (next.isStartElement()) {
     				if (isStartingElement(next, HEADING)) {
     					makeFeatureHeading(state, reader, classValue, feature, next);
     				} else if (isStartingElement(next, WRITER)) {
     					makeFeatureWriter(state, reader, feature, taxon, next);
     				} else if (isStartingElement(next, DISTRIBUTION_LOCALITY)) {
     					if (!feature.equals(Feature.DISTRIBUTION())) {
     						String message = "Distribution locality only allowed for feature of type 'distribution'";
     						fireWarningEvent(message, next, 4);
+    					}
     					handleDistributionLocality(state, reader, next);
     				} else if (isStartingElement(next, DISTRIBUTION_LIST)
     						|| isStartingElement(next, HABITAT_LIST)) {
     					// only handle single list elements
     				} else if (isStartingElement(next, HABITAT)) {
     					if (!(feature.equals(Feature.HABITAT())
     							|| feature.equals(Feature.HABITAT_ECOLOGY()) || feature
     							.equals(Feature.ECOLOGY()))) {
     						String message = "Habitat only allowed for feature of type 'habitat','habitat ecology' or 'ecology'";
     						fireWarningEvent(message, next, 4);
+    					}
     					handleHabitat(state, reader, next);
     				} else if (isStartingElement(next, CHAR)) {
     					TextData textData = handleChar(state, reader, next);
     					taxonDescription.addElement(textData);
     				} else if (isStartingElement(next, STRING)) {
     					lastDescriptionElement = makeFeatureString(state, reader,feature, taxonDescription, lastDescriptionElement,next);
     				} else if (isStartingElement(next, FIGURE_REF)) {
     					lastDescriptionElement = makeFeatureFigureRef(state, reader, taxonDescription, isDescription, lastDescriptionElement, next);
     				} else if (isStartingElement(next, REFERENCES)) {
     					// TODO details/microcitation ??
     					List<Reference<?>> refs = handleReferences(state, reader, next);
     					if (!refs.isEmpty()) {
     						// TODO
     						Reference<?> descriptionRef = state.getConfig().getSourceReference();
     						TaxonDescription description = getTaxonDescription(taxon, descriptionRef, false, true);
     						TextData featurePlaceholder = getFeaturePlaceholder(state, description, feature, true);
     						for (Reference<?> citation : refs) {
     							featurePlaceholder.addSource(null, null, citation, null);
+    						}
     					} else {
     						String message = "No reference found in references";
     						fireWarningEvent(message, next, 6);
     				handleHabitat(state, reader, next);
     			} else if (isStartingElement(next, CHAR)) {
     				TextData textData = handleChar(state, reader, next);
     				taxonDescription.addElement(textData);
     			} else if (isStartingElement(next, STRING)) {
     				lastDescriptionElement = makeFeatureString(state, reader,feature, taxonDescription, lastDescriptionElement,next);
     			} else if (isStartingElement(next, FIGURE_REF)) {
     				lastDescriptionElement = makeFeatureFigureRef(state, reader, taxonDescription, isDescription, lastDescriptionElement, next);
     			} else if (isStartingElement(next, REFERENCES)) {
     				// TODO details/microcitation ??
     				List<Reference<?>> refs = handleReferences(state, reader, next);
     				if (!refs.isEmpty()) {
     					// TODO
     					Reference<?> descriptionRef = state.getConfig().getSourceReference();
     					TaxonDescription description = getTaxonDescription(taxon, descriptionRef, false, true);
     					TextData featurePlaceholder = getFeaturePlaceholder(state, description, feature, true);
     					for (Reference<?> citation : refs) {
     						featurePlaceholder.addSource(null, null, citation, null);
+    					}
     				} else {
     					handleUnexpectedStartElement(next);
     					String message = "No reference found in references";
     					fireWarningEvent(message, next, 6);
+    				}
     			} else if (isStartingElement(next, NUM)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, NUM)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else {
     				handleUnexpectedElement(next);
+    			}
+    		}
     		// TODO handle missing end element
     		throw new IllegalStateException("Feature has no closing tag");
     		throw new IllegalStateException("<Feature> has no closing tag");
+    	}
     	/**
-...
     	 * @return
     	 * @throws XMLStreamException
     	 */
     	private DescriptionElementBase makeFeatureFigureRef(
     			MarkupImportState state, XMLEventReader reader,
     			TaxonDescription taxonDescription, boolean isDescription,
     			DescriptionElementBase lastDescriptionElement, XMLEvent next)
     			throws XMLStreamException {
     	private DescriptionElementBase makeFeatureFigureRef(MarkupImportState state, XMLEventReader reader,TaxonDescription taxonDescription,
     					boolean isDescription, DescriptionElementBase lastDescriptionElement, XMLEvent next)throws XMLStreamException {
     		FigureDataHolder figureHolder = handleFigureRef(state, reader, next);
     		Feature figureFeature = getFeature(state,
     				MarkupTransformer.uuidFigures, "Figures", "Figures", "Fig.",
     				null);
     		Feature figureFeature = getFeature(state,MarkupTransformer.uuidFigures, "Figures", "Figures", "Fig.",null);
     		if (isDescription) {
     			TextData figureHolderTextData = null;
     			// if (figureHolderTextData == null){
-...
     				figureHolderTextData.addAnnotation(annotation);
+    			}
     			if (StringUtils.isNotBlank(figureHolder.figurePart)) {
     				String annotationText = "<figurePart>"
     						+ figureHolder.figurePart.trim() + "</figurePart>";
     				Annotation annotation = Annotation.NewInstance(annotationText,
     						AnnotationType.EDITORIAL(), Language.DEFAULT());
     				String annotationText = "<figurePart>"+ figureHolder.figurePart.trim() + "</figurePart>";
     				Annotation annotation = Annotation.NewInstance(annotationText,AnnotationType.EDITORIAL(), Language.DEFAULT());
     				figureHolderTextData.addAnnotation(annotation);
+    			}
     			// if (StringUtils.isNotBlank(figureText)){
-...
     	 * @param feature
     	 * @param taxonDescription
     	 * @param lastDescriptionElement
     	 * @param distributionList
     	 * @param next
     	 * @return
     	 * @throws XMLStreamException
     	 */
     	private DescriptionElementBase makeFeatureString(MarkupImportState state,XMLEventReader reader, Feature feature,
     			TaxonDescription taxonDescription, DescriptionElementBase lastDescriptionElement, XMLEvent next)
     			throws XMLStreamException {
     		Map<String, String> subheadingMap = handleString(state, reader, next);
     	private DescriptionElementBase makeFeatureString(MarkupImportState state,XMLEventReader reader, Feature feature,
     				TaxonDescription taxonDescription, DescriptionElementBase lastDescriptionElement, XMLEvent next) throws XMLStreamException {
     		Map<String, String> subheadingMap = handleString(state, reader, next, feature);
     		for (String subheading : subheadingMap.keySet()) {
     			Feature subheadingFeature = feature;
     			if (StringUtils.isNotBlank(subheading) && subheadingMap.size() > 1) {
-...
     	 * @param next
     	 * @throws XMLStreamException
     	 */
     	private void makeFeatureWriter(MarkupImportState state,
     			XMLEventReader reader, Feature feature, Taxon taxon, XMLEvent next)
     			throws XMLStreamException {
     	private void makeFeatureWriter(MarkupImportState state,XMLEventReader reader, Feature feature, Taxon taxon, XMLEvent next) throws XMLStreamException {
     		WriterDataHolder writer = handleWriter(state, reader, next);
     		if (isNotBlank(writer.writer)) {
     			// TODO
-...
     	 * @param next
     	 * @throws XMLStreamException
     	 */
     	private void makeFeatureHeading(MarkupImportState state,
     			XMLEventReader reader, String classValue, Feature feature,
     			XMLEvent next) throws XMLStreamException {
     	private void makeFeatureHeading(MarkupImportState state, XMLEventReader reader, String classValue, Feature feature, XMLEvent next) throws XMLStreamException {
     		String heading = handleHeading(state, reader, next);
     		if (StringUtils.isNotBlank(heading)) {
     			if (!heading.equalsIgnoreCase(classValue)) {
-...
+    		}
+    	}
     	private List<Reference<?>> handleReferences(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent)
     			throws XMLStreamException {
     	private List<Reference<?>> handleReferences(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent) throws XMLStreamException {
     		// attributes
     		Map<String, Attribute> attributes = getAttributes(parentEvent);
     		String bibliography = getAndRemoveAttributeValue(attributes,
-...
     		throw new IllegalStateException("<References> has no closing tag");
+    	}
     	private void handleHabitat(MarkupImportState state, XMLEventReader reader,
     			XMLEvent parentEvent) throws XMLStreamException {
     	private void handleHabitat(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent) throws XMLStreamException {
     		checkNoAttributes(parentEvent);
     		Taxon taxon = state.getCurrentTaxon();
     		// TODO which ref to take?
-...
     		throw new IllegalStateException("<Habitat> has no closing tag");
+    	}
     	private String getTaggedCData(MarkupImportState state,
     			XMLEventReader reader, XMLEvent parentEvent)
     			throws XMLStreamException {
     	private String getTaggedCData(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent) throws XMLStreamException {
     		checkNoAttributes(parentEvent);
     		String text = getXmlTag(parentEvent);
-...
+    	}
     	private void handleDistributionLocality(MarkupImportState state,
     			XMLEventReader reader, XMLEvent parentEvent)
     			throws XMLStreamException {
     		String classValue = getClassOnlyAttribute(parentEvent);
     	private void handleDistributionLocality(MarkupImportState state,XMLEventReader reader, XMLEvent parentEvent)throws XMLStreamException {
     		Map<String, Attribute> attributes = getAttributes(parentEvent);
     		String classValue = getAndRemoveRequiredAttributeValue(parentEvent, attributes, CLASS);
     		String statusValue =getAndRemoveAttributeValue(attributes, STATUS);
     		String frequencyValue =getAndRemoveAttributeValue(attributes, FREQUENCY);
     		Taxon taxon = state.getCurrentTaxon();
     		// TODO which ref to take?
     		Reference ref = state.getConfig().getSourceReference();
     		Reference<?> ref = state.getConfig().getSourceReference();
     		String text = "";
     		while (reader.hasNext()) {
     			XMLEvent next = readNoWhitespace(reader);
     			if (isMyEndingElement(next, parentEvent)) {
     				if (StringUtils.isNotBlank(text)) {
     					TaxonDescription description = getTaxonDescription(taxon,
     							ref, false, true);
     					NamedAreaLevel level = makeNamedAreaLevel(state,
     							classValue, next);
     					TaxonDescription description = getTaxonDescription(taxon, ref, false, true);
     					NamedAreaLevel level = makeNamedAreaLevel(state,classValue, next);
     					NamedArea area = createArea(text, level, state);
     					PresenceAbsenceTermBase<?> status = null;
     					Distribution distribution = Distribution.NewInstance(area,
     							status);
     					try {
     						status = state.getTransformer().getPresenceTermByKey(statusValue);
     					} catch (UndefinedTransformerMethodException e) {
     						throw new RuntimeException(e);
+    					}
     					Distribution distribution = Distribution.NewInstance(area,status);
     					description.addElement(distribution);
     					if (isNotBlank(frequencyValue)){
     						String message = "The frequency attribute is currently not yet available in CDM";
     						fireWarningEvent(message, parentEvent, 6);
+    					}
     				} else {
     					String message = "Empty distribution locality";
     					fireWarningEvent(message, next, 4);
+    				}
     				return;
     			} else if (next.isStartElement()) {
     				if (isStartingElement(next, COORDINATES)) {
     					handleNotYetImplementedElement(next);
     				} else {
     					handleUnexpectedStartElement(next.asStartElement());
+    				}
     			} else if (isStartingElement(next, COORDINATES)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, COORDINATES)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (next.isCharacters()) {
     				text += next.asCharacters().getData();
     			} else {
     				handleUnexpectedEndElement(next.asEndElement());
+    			}
+    		}
     		throw new IllegalStateException(
     				"<DistributionLocality> has no closing tag");
     		throw new IllegalStateException("<DistributionLocality> has no closing tag");
+    	}
     	/**
-...
     		try {
     			level = state.getTransformer().getNamedAreaLevelByKey(levelString);
     			if (level == null) {
     				UUID levelUuid = state.getTransformer().getNamedAreaLevelUuid(
     						levelString);
     				UUID levelUuid = state.getTransformer().getNamedAreaLevelUuid(levelString);
     				if (levelUuid == null) {
     					String message = "Unknown distribution locality class (named area level): %s. Create new level instead.";
     					message = String.format(message, levelString);
-...
     		return level;
+    	}
     	private String handleHeading(MarkupImportState state,
     			XMLEventReader reader, XMLEvent parentEvent)
     			throws XMLStreamException {
     	private String handleHeading(MarkupImportState state,XMLEventReader reader, XMLEvent parentEvent)throws XMLStreamException {
     		checkNoAttributes(parentEvent);
     		String text = "";
-...
+    	}
     	private Map<String, String> handleString(MarkupImportState state,
     			XMLEventReader reader, XMLEvent parentEvent)
     			throws XMLStreamException {
     	/**
     	 * Handle string
     	 * @param state
     	 * @param reader
     	 * @param parentEvent
     	 * @param feature only needed for distributionLocalities
     	 * @return
     	 * @throws XMLStreamException
     	 */
     	private Map<String, String> handleString(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent, Feature feature)throws XMLStreamException {
     		// attributes
     		String classValue = getClassOnlyAttribute(parentEvent, false);
     		if (StringUtils.isNotBlank(classValue)) {
-...
     				text = putCurrentSubheading(subHeadingMap,currentSubheading, text);
     				// TODO footnotes
     				currentSubheading = getCData(state, reader, next).trim();
     			} else if (isStartingElement(next, DISTRIBUTION_LOCALITY)) {
     				if (feature != null && !feature.equals(Feature.DISTRIBUTION())) {
     					String message = "Distribution locality only allowed for feature of type 'distribution'";
     					fireWarningEvent(message, next, 4);
+    				}
     				handleDistributionLocality(state, reader, next);
     			} else if (next.isCharacters()) {
     				if (!isTextMode) {
     					String message = "String is not in text mode";
-...
     				} else {
     					text += next.asCharacters().getData();
+    				}
     			} else if (isStartingElement(next, COLLECTION)) {
     			} else if (isStartingElement(next, HEADING)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, HEADING)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, QUOTE)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, QUOTE)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, DEDICATION)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, DEDICATION)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, TAXONTYPE)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, TAXONTYPE)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, FULL_NAME)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, FULL_NAME)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			}else if (isStartingElement(next, REFERENCES)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, REFERENCES)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, GATHERING)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, COLLECTION)) {
     			} else if (isEndingElement(next, GATHERING)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, ANNOTATION)) {
-...
     			} else if (isEndingElement(next, ANNOTATION)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, HABITAT)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, HABITAT)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, FIGURE_REF)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, FIGURE_REF)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, FIGURE)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, FIGURE)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, FOOTNOTE_REF)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, FOOTNOTE_REF)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, FOOTNOTE)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, FOOTNOTE)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, WRITER)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, WRITER)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (isStartingElement(next, DATES)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, DATES)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else {
     				handleUnexpectedElement(next);
+    			}
-...
     				TextData textData = TextData.NewInstance(feature);
     				textData.putText(Language.DEFAULT(), text);
     				return textData;
     			} else if (isStartingElement(next, FIGURE_REF)) {
     				//TODO
     				handleNotYetImplementedElement(next);
     			} else if (isEndingElement(next, FIGURE_REF)) {
     				//TODO
     				popUnimplemented(next.asEndElement());
     			} else if (next.isStartElement()) {
     				if (isStartingElement(next, ANNOTATION)) {
     					handleNotYetImplementedElement(next);
-...
     	 * @return
     	 * @throws UndefinedTransformerMethodException
     	 */
     	private Feature makeFeature(String classValue, MarkupImportState state,
     			XMLEvent parentEvent) {
     	private Feature makeFeature(String classValue, MarkupImportState state, XMLEvent parentEvent) {
     		UUID uuid;
     		try {
     			Feature feature = state.getTransformer()
     					.getFeatureByKey(classValue);
     			Feature feature = state.getTransformer().getFeatureByKey(classValue);
     			if (feature != null) {
     				return feature;
+    			}
     			uuid = state.getTransformer().getFeatureUuid(classValue);
     			if (uuid == null) {
     				// TODO
     				logger.warn("Uuid is null for " + classValue);
     				String message = "Uuid is not defined for %s";
     				message = String.format(message, classValue);
     				fireWarningEvent(message, parentEvent, 8);
+    			}
     			String featureText = StringUtils.capitalize(classValue);
     			// TODO eFlora vocabulary
     			TermVocabulary<Feature> voc = null;
     			feature = getFeature(state, uuid, featureText, featureText,
     					classValue, voc);
     			feature = getFeature(state, uuid, featureText, featureText, classValue, voc);
     			if (feature == null) {
     				throw new NullPointerException(classValue
     						+ " not recognized as a feature");
     				throw new NullPointerException(classValue + " not recognized as a feature");
+    			}
     			return feature;
     		} catch (Exception e) {

     import eu.etaxonomy.cdm.io.common.mapping.UndefinedTransformerMethodException;
     import eu.etaxonomy.cdm.model.common.MarkerType;
     import eu.etaxonomy.cdm.model.description.Feature;
     import eu.etaxonomy.cdm.model.description.PresenceTerm;
     import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
     /**
-...
     	public static final UUID uuidFigure = UUID.fromString("5165cd6a-9b31-4a1f-8b30-04ab740c502c");
     	public static final UUID uuidFigures = UUID.fromString("6dfb4e78-c67e-410c-8989-c1fb1295abf6");
     	public static final UUID uuidExtractedHabitat = UUID.fromString("d80511d2-a76c-48b8-b3aa-5fbd4a58fe5c");
     	public static final UUID uuidHabit = UUID.fromString("03487108-173a-4335-92be-05076af29155");
     //	public static final UUID uuidHabit = UUID.fromString("03487108-173a-4335-92be-05076af29155");
     	public static final UUID uuidHabitat = UUID.fromString("fb16929f-bc9c-456f-9d40-dec987b36438");
     	public static final UUID uuidHabitatEcology = UUID.fromString("9fdc4663-4d56-47d0-90b5-c0bf251bafbb");
     	public static final UUID uuidChromosomes = UUID.fromString("c4a60319-4978-4692-9545-58d60cf8379e");
     	public static final UUID uuidPhylogeny = UUID.fromString("8bcffbeb-a849-4222-83f9-bfcbbc3baef9");
     	public static final UUID uuidHistory = UUID.fromString("6f9f0316-1c27-4e17-b96a-51332521f74e");
     	public static final UUID uuidCultivation = UUID.fromString("f10f34fb-53b9-43c2-bfd6-05ea475e8e0f");
     	public static final UUID uuidNote = UUID.fromString("b9af1489-6b68-497f-8d4b-260a9f886827");
     	public static final UUID uuidNotes = UUID.fromString("e31bb420-f39e-493d-b452-dd5e63dda443");
-...
     	public static final UUID uuidPerianth = UUID.fromString("bd1480bb-ce44-495f-a462-98db4ac80530");
     	public static final UUID uuidScales = UUID.fromString("bd1480bb-ce44-495f-a462-98db4ac80530");
     	public static final UUID uuidPerigoneTube = UUID.fromString("d1799423-31ce-4525-b0ba-8d7cc9240abf");
     	public static final UUID uuidPerigoneLobes = UUID.fromString("e309e1e3-8f60-4478-9b89-ca5069bc1622");
     	public static final UUID uuidPerigone = UUID.fromString("f026fc87-5fc6-4559-a7e5-e8832c20033d");
     	public static final UUID uuidCorolla = UUID.fromString("9ff17ff9-cb59-4ad7-bfa1-1d67935e567f");
     	public static final UUID uuidAnnulus = UUID.fromString("d9b93acb-9b49-45ef-8661-09e00081931f");
     	public static final UUID uuidFemaleFlowers = UUID.fromString("2e06cea2-5993-417c-8d0d-81cb571aa17a");
-...
     	public UUID getFeatureUuid(String key) 	throws UndefinedTransformerMethodException {
     		if (CdmUtils.isEmpty(key)){return null;
     		}else if (key.equalsIgnoreCase("cultivation")){return uuidCultivation;
     		}else if (key.equalsIgnoreCase("history")){return uuidHistory;
     		}else if (key.equalsIgnoreCase("phylogeny")){return uuidPhylogeny;
     		}else if (key.equalsIgnoreCase("Chromosomes")){return uuidChromosomes;
     		}else if (key.equalsIgnoreCase("habit")){return uuidHabit;
     		}else if (key.equalsIgnoreCase("Habitat")){return uuidHabitat;
     		}else if (key.equalsIgnoreCase("Habitat & Ecology")){return uuidHabitatEcology;
     		}else if (key.equalsIgnoreCase("Leaflets")){return uuidLeaflets;
     		}else if (key.equalsIgnoreCase("Leaves")){return uuidLeaves;
     		}else if (key.equalsIgnoreCase("Branchlets")){return uuidBranchlets;
     		}else if (key.equalsIgnoreCase("lifeform")){return uuidLifeform;
     		}else if (key.equalsIgnoreCase("habit")){return uuidLifeform;
     		}else if (key.equalsIgnoreCase("Inflorescences")){return uuidInflorescences;
     		}else if (key.equalsIgnoreCase("Flowers")){return uuidFlowers;
     		}else if (key.equalsIgnoreCase("Sepals")){return uuidSepals;
-...
     		}else if (key.equalsIgnoreCase("Fruit")){return uuidFruit;
     		}else if (key.equalsIgnoreCase("Branch")){return uuidBranch;
     		}else if (key.equalsIgnoreCase("Inflorescence")){return uuidInflorescence;
     		}else if (key.equalsIgnoreCase("male inflorescences")){return uuidMaleInflorescences;
     		}else if (key.equalsIgnoreCase("female inflorescences")){return uuidFemaleInflorescences;
     		}else if (key.equalsIgnoreCase("Male inflorescences")){return uuidMaleInflorescences;
     		}else if (key.equalsIgnoreCase("Female inflorescences")){return uuidFemaleInflorescences;
     		}else if (key.equalsIgnoreCase("Calyx")){return uuidCalyx;
     		}else if (key.equalsIgnoreCase("Seedling")){return uuidSeedling;
-...
     		}else if (key.equalsIgnoreCase("perianth")){return uuidPerianth;
     		}else if (key.equalsIgnoreCase("scales")){return uuidScales;
     		}else if (key.equalsIgnoreCase("perigone tube")){return uuidPerigoneTube;
     		}else if (key.equalsIgnoreCase("perigone")){return uuidPerigone;
     		}else if (key.equalsIgnoreCase("perigone lobes")){return uuidPerigoneLobes;
     		}else if (key.equalsIgnoreCase("corolla")){return uuidCorolla;
     		}else if (key.equalsIgnoreCase("annulus")){return uuidAnnulus;
     		}else if (key.equalsIgnoreCase("female flowers")){return uuidFemaleFlowers;
-...
     		}else if (key.equalsIgnoreCase("Flower morphology")){return uuidFlowerMorphology;
     		}else if (key.equalsIgnoreCase("Pollination")){return uuidPollination;
     		}else if (key.equalsIgnoreCase("Life cycle")){return uuidLifeCycle;
     		}else if (key.equalsIgnoreCase("lifehistory")){return uuidLifeCycle;
     		}else if (key.equalsIgnoreCase("Fruits and embryology")){return uuidFruitsAndEmbryology;
     		}else if (key.equalsIgnoreCase("Dispersal")){return uuidDispersal;
     		}else if (key.equalsIgnoreCase("Phytochemistry")){return uuidPhytochemistry;
-...
     	 * @see eu.etaxonomy.cdm.io.common.mapping.InputTransformerBase#getNamedAreaLevelUuid(java.lang.String)
     	 */
     	@Override
     	public UUID getNamedAreaLevelUuid(String key)
     			throws UndefinedTransformerMethodException {
     	public UUID getNamedAreaLevelUuid(String key) throws UndefinedTransformerMethodException {
     		if (CdmUtils.isEmpty(key)){return null;
     		}else if (key.equalsIgnoreCase("region")){return uuidRegion;
     		}else if (key.equalsIgnoreCase("world")){return uuidWorld;
-...
     			return null;
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see eu.etaxonomy.cdm.io.common.mapping.InputTransformerBase#getPresenceTermByKey(java.lang.String)
     	 */
     	@Override
     	public PresenceTerm getPresenceTermByKey(String key) throws UndefinedTransformerMethodException {
     		if (CdmUtils.isEmpty(key)){return null;
     		}else if (key.equalsIgnoreCase("endemic")){return PresenceTerm.ENDEMIC_FOR_THE_RELEVANT_AREA();
     		}else if (key.equalsIgnoreCase("cultivated")){return PresenceTerm.CULTIVATED();
     		}else{
     			return null;
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see eu.etaxonomy.cdm.io.common.mapping.InputTransformerBase#getPresenceTermUuid(java.lang.String)
     	 */
     	@Override
     	public UUID getPresenceTermUuid(String key) throws UndefinedTransformerMethodException {
     		if (CdmUtils.isEmpty(key)){return null;
     //		}else if (key.equalsIgnoreCase("region")){return uuidRegion;
     		}else{
     			return null;
+    		}
+    	}

     		//taxonKey
     		String numAndTaxon;
     		public boolean isInnerLead(){
     			return (key != null);
+    		}
-...
     		return false;

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Project

General

Profile

EDIT

Revision 5ea7ddcb

Added by Andreas Müller over 12 years ago