/*
* SoapUI, Copyright (C) 2004-2016 SmartBear Software
*
* Licensed under the EUPL, Version 1.1 or - as soon as they will be approved by the European Commission - subsequent
* versions of the EUPL (the "Licence");
* You may not use this work except in compliance with the Licence.
* You may obtain a copy of the Licence at:
*
* http://ec.europa.eu/idabc/eupl
*
* Unless required by applicable law or agreed to in writing, software distributed under the Licence is
* distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the Licence for the specific language governing permissions and limitations
* under the Licence.
*/
package com.eviware.soapui.impl.support.definition.support;
import com.eviware.soapui.config.DefinitionCacheConfig;
import com.eviware.soapui.config.DefinitionCacheTypeConfig;
import com.eviware.soapui.config.DefintionPartConfig;
import com.eviware.soapui.impl.support.AbstractInterface;
import com.eviware.soapui.impl.support.definition.DefinitionCache;
import com.eviware.soapui.impl.support.definition.DefinitionLoader;
import com.eviware.soapui.impl.support.definition.InterfaceDefinitionPart;
import com.eviware.soapui.impl.wsdl.support.xsd.SchemaUtils;
import com.eviware.soapui.support.xml.XmlUtils;
import org.apache.xmlbeans.XmlObject;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentFragment;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public abstract class AbstractDefinitionCache<T extends AbstractInterface<?>> implements DefinitionCache {
protected DefinitionCacheConfig definitionCache;
private T container;
private InterfaceDefinitionPart rootPart;
private List<InterfaceDefinitionPart> parts;
public AbstractDefinitionCache(DefinitionCacheConfig definitionCache, T container) {
this.definitionCache = definitionCache;
this.container = container;
if (this.definitionCache == null) {
this.definitionCache = reinit(container);
}
}
protected abstract DefinitionCacheConfig reinit(T owner);
public T getContainer() {
return container;
}
public boolean validate() {
if (definitionCache.getRootPart() == null) {
return false;
}
if (definitionCache.sizeOfPartArray() == 0) {
return false;
}
return true;
}
public void importCache(DefinitionCache cache) throws Exception {
if (cache instanceof AbstractDefinitionCache<?>) {
definitionCache = reinit(container);
definitionCache.set(((AbstractDefinitionCache<?>) cache).getConfig());
initParts();
} else {
update(new InterfaceCacheDefinitionLoader(cache));
}
}
protected DefinitionCacheConfig getConfig() {
return definitionCache;
}
public void update(DefinitionLoader loader) throws Exception {
definitionCache = reinit(container);
String baseUri = loader.getBaseURI();
definitionCache.setType(DefinitionCacheTypeConfig.TEXT);
Map<String, XmlObject> urls = SchemaUtils.getDefinitionParts(loader);
definitionCache.setRootPart(baseUri);
for (Map.Entry<String, XmlObject> entry : urls.entrySet()) {
DefintionPartConfig definitionPart = definitionCache.addNewPart();
String url = entry.getKey();
definitionPart.setUrl(url);
XmlObject xmlObject = entry.getValue();
Node domNode = xmlObject.getDomNode();
if (domNode.getNodeType() == Node.DOCUMENT_FRAGMENT_NODE) {
Node node = ((DocumentFragment) domNode).getFirstChild();
if (node.getNodeType() == Node.TEXT_NODE) {
domNode = XmlUtils.parseXml(node.getNodeValue());
// xmlObject = XmlObject.Factory.parse( domNode );
xmlObject = XmlUtils.createXmlObject(domNode);
}
}
Element contentElement = ((Document) domNode).getDocumentElement();
Node newDomNode = definitionPart.addNewContent().getDomNode();
newDomNode.appendChild(newDomNode.getOwnerDocument().createTextNode(xmlObject.toString()));
definitionPart.setType(contentElement.getNamespaceURI());
}
initParts();
}
public List<InterfaceDefinitionPart> getDefinitionParts() throws Exception {
if (parts == null) {
initParts();
}
return parts;
}
private void initParts() {
parts = new ArrayList<InterfaceDefinitionPart>();
List<DefintionPartConfig> partList = definitionCache.getPartList();
for (DefintionPartConfig part : partList) {
try {
boolean rootElement = URLDecoder.decode(part.getUrl(), "UTF-8").equals(
URLDecoder.decode(definitionCache.getRootPart(), "UTF-8"));
ConfigInterfaceDefinitionPart configInterfaceDefinitionPart = new ConfigInterfaceDefinitionPart(part,
rootElement, definitionCache.getType());
parts.add(configInterfaceDefinitionPart);
if (configInterfaceDefinitionPart.isRootPart()) {
rootPart = configInterfaceDefinitionPart;
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
// ConfigInterfaceDefinitionPart configInterfaceDefinitionPart = new
// ConfigInterfaceDefinitionPart( part, part
// .getUrl().equals( definitionCache.getRootPart() ),
// definitionCache.getType() );
}
}
public InterfaceDefinitionPart getRootPart() {
if (parts == null) {
initParts();
}
return rootPart;
}
public void clear() {
definitionCache.setRootPart(null);
while (definitionCache.sizeOfPartArray() > 0) {
definitionCache.removePart(0);
}
}
}