org.databene.edifatto.xml.NameBasedEdiToXMLConverter Maven / Gradle / Ivy

Go to download
/*
 * Copyright (C) 2013-2015 Volker Bergmann ([email protected]).
 * All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.databene.edifatto.xml;

import org.databene.commons.StringUtil;
import org.databene.commons.xml.XMLUtil;
import org.databene.edifatto.EdiFormatSymbols;
import org.databene.edifatto.definition.CompositeDefinition;
import org.databene.edifatto.definition.ComponentDefinition;
import org.databene.edifatto.definition.SegmentDefinition;
import org.databene.edifatto.definition.SegmentGroupDefinition;
import org.databene.edifatto.definition.SegmentItemDefinition;
import org.databene.edifatto.model.Component;
import org.databene.edifatto.model.Composite;
import org.databene.edifatto.model.Interchange;
import org.databene.edifatto.model.Message;
import org.databene.edifatto.model.Segment;
import org.databene.edifatto.model.SegmentGroup;
import org.databene.edifatto.model.SegmentGroupItem;
import org.databene.edifatto.model.SegmentGroupItemContainer;
import org.databene.edifatto.model.SegmentItem;
import org.databene.edifatto.util.EdiUtil;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * Converts an EDI interchange to an XML document using the EDI element names as XML element names.
 * Created: 02.06.2014 16:49:43
 * @since 1.2
 * @author Volker Bergmann
 */

public class NameBasedEdiToXMLConverter implements EdiToXMLConverter {
	
	@Override
	public Document convert(Interchange interchange) {
		Message message = interchange.getMessages().get(0);
		Document document = XMLUtil.createDocument(message.getName());
		Element root = document.getDocumentElement();
		appendMessage(message, root, interchange.getSymbols());
		return document;
	}
	
	// private helper methods ------------------------------------------------------------------------------------------

	private static void appendMessage(Message message, Element parentElement, EdiFormatSymbols symbols) {
		addChildren(message, parentElement, symbols);
	}

	private static void addChildren(SegmentGroupItemContainer item, Element element, EdiFormatSymbols symbols) {
		for (SegmentGroupItem child : item.getChildren()) {
			appendChild(child, element, symbols);
		}
	}

	private static void appendChild(SegmentGroupItem item, Element parent, EdiFormatSymbols symbols) {
		if (item instanceof Segment)
			appendSegment((Segment) item, parent, symbols);
		else if (item instanceof SegmentGroup)
			appendSegmentGroup((SegmentGroup) item, parent, symbols);
		else
			throw new UnsupportedOperationException("Not a supported Edifact type: " + item.getClass());
	}

	private static void appendSegmentGroup(SegmentGroup group, Element parent, EdiFormatSymbols symbols) {
		SegmentGroupDefinition def = group.getDefinition();
		Element groupElement = parent.getOwnerDocument().createElement(def.getName());
		for (SegmentGroupItem childItem : group.getChildren())
			appendChild(childItem, groupElement, symbols);
		parent.appendChild(groupElement);
	}
	
	private static void appendSegment(Segment segment, Element parent, EdiFormatSymbols symbols) {
		Element childElement = parent.getOwnerDocument().createElement(segment.getName());
		SegmentDefinition def = segment.getDefinition();
		for (int i = 0; i < def.getChildren().size(); i++) {
			if (i < segment.getChildCount()) {
				SegmentItemDefinition itemDef = def.getChild(i);
				SegmentItem item = segment.getChild(i);
				if (containsNonEmptyComponents(item))
					if (itemDef instanceof CompositeDefinition)
						appendComposite((Composite) item, (CompositeDefinition) itemDef, childElement, symbols);
					else
						appendComponent(item, (ComponentDefinition) itemDef, childElement, symbols);
			}
		}
		parent.appendChild(childElement);
	}

	private static boolean containsNonEmptyComponents(SegmentItem item) {
		if (item instanceof Component) {
			return !StringUtil.isEmpty(((Component) item).getData());
		} else {
			Composite composite = (Composite) item;
			for (Component component : composite.getChildren())
				if (!StringUtil.isEmpty(component.getData()))
					return true;
			return false;
		}
	}

	private static void appendComposite(Composite item, CompositeDefinition def, Element parent, EdiFormatSymbols symbols) {
		Element componentElement = parent.getOwnerDocument().createElement(def.getName());
		for (int i = 0; i < def.getChildCount(); i++)
			if (i < item.getChildCount())
				appendComponent(item.getChild(i), def.getChild(i), componentElement, symbols);
		parent.appendChild(componentElement);
	}

	private static void appendComponent(SegmentItem item, ComponentDefinition def, Element parent, EdiFormatSymbols symbols) {
		Component component = (item instanceof Component ? (Component) item : ((Composite) item).getChild(0));
		Element elementElement = parent.getOwnerDocument().createElement(def.getName());
		elementElement.setTextContent(EdiUtil.unescape(component.getData(), symbols));
		parent.appendChild(elementElement);
	}

}