--- /dev/null
+/**
+ * ============LICENSE_START=======================================================
+ * org.onap.aai
+ * ================================================================================
+ * Copyright © 2017-2018 AT&T Intellectual Property. 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.
+ * ============LICENSE_END=========================================================
+ */
+package org.onap.aai.schemagen.genxsd;
+
+import org.onap.aai.edges.EdgeIngestor;
+import org.onap.aai.edges.exceptions.EdgeRuleNotFoundException;
+import org.onap.aai.nodes.NodeIngestor;
+import org.onap.aai.setup.SchemaVersion;
+import org.onap.aai.setup.SchemaVersions;
+import org.w3c.dom.*;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import javax.xml.XMLConstants;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.*;
+
+public abstract class OxmFileProcessor {
+
+ public static final String LINE_SEPARATOR = System.getProperty("line.separator");
+ public static final String DOUBLE_LINE_SEPARATOR = System.getProperty("line.separator") + System.getProperty("line.separator");
+
+ EdgeIngestor ei;
+ NodeIngestor ni;
+ protected Set<String> namespaceFilter;
+ protected File oxmFile;
+ protected String xml;
+ protected SchemaVersion v;
+ protected Document doc = null;
+ protected String apiVersion = null;
+ protected SchemaVersions schemaVersions;
+
+
+ protected static int annotationsStartVersion = 9; // minimum version to support annotations in xsd
+ protected static int annotationsMinVersion = 6; // lower versions support annotations in xsd
+ protected static int swaggerSupportStartsVersion = 1; // minimum version to support swagger documentation
+ protected static int swaggerDiffStartVersion = 1; // minimum version to support difference
+ protected static int swaggerMinBasepath = 6; // minimum version to support difference
+
+ protected Map combinedJavaTypes;
+
+
+ protected String apiVersionFmt = null;
+ protected HashMap<String, String> generatedJavaType = new HashMap<String, String>();
+ protected HashMap<String, String> appliedPaths = new HashMap<String, String>();
+ protected NodeList javaTypeNodes = null;
+
+ protected Map<String,String> javaTypeDefinitions = createJavaTypeDefinitions();
+ private Map<String, String> createJavaTypeDefinitions()
+ {
+ StringBuffer aaiInternal = new StringBuffer();
+ StringBuffer nodes = new StringBuffer();
+ Map<String,String> javaTypeDefinitions = new HashMap<String, String>();
+ aaiInternal.append(" aai-internal:\n");
+ aaiInternal.append(" properties:\n");
+ aaiInternal.append(" property-name:\n");
+ aaiInternal.append(" type: string\n");
+ aaiInternal.append(" property-value:\n");
+ aaiInternal.append(" type: string\n");
+// javaTypeDefinitions.put("aai-internal", aaiInternal.toString());
+ nodes.append(" nodes:\n");
+ nodes.append(" properties:\n");
+ nodes.append(" inventory-item-data:\n");
+ nodes.append(" type: array\n");
+ nodes.append(" items:\n");
+ nodes.append(" $ref: \"#/definitions/inventory-item-data\"\n");
+ javaTypeDefinitions.put("nodes", nodes.toString());
+ return javaTypeDefinitions;
+ }
+ static List<String> nodeFilter = createNodeFilter();
+ private static List<String> createNodeFilter()
+ {
+ List<String> list = Arrays.asList("search", "actions", "aai-internal", "nodes");
+ return list;
+ }
+
+ public OxmFileProcessor(SchemaVersions schemaVersions, NodeIngestor ni, EdgeIngestor ei){
+ this.schemaVersions = schemaVersions;
+ this.ni = ni;
+ this.ei = ei;
+ }
+
+
+
+ public void setOxmVersion(File oxmFile, SchemaVersion v) {
+ this.oxmFile = oxmFile;
+ this.v = v;
+ }
+
+ public void setXmlVersion(String xml, SchemaVersion v) {
+ this.xml = xml;
+ this.v = v;
+ }
+
+ public void setVersion(SchemaVersion v) {
+ this.oxmFile = null;
+ this.v = v;
+ }
+
+ public void setNodeIngestor(NodeIngestor ni) {
+ this.ni = ni;
+ }
+
+ public void setEdgeIngestor(EdgeIngestor ei) {
+ this.ei = ei;
+ }
+
+ public SchemaVersions getSchemaVersions() {
+ return schemaVersions;
+ }
+
+ public void setSchemaVersions(SchemaVersions schemaVersions) {
+ this.schemaVersions = schemaVersions;
+ }
+
+ protected void init() throws ParserConfigurationException, SAXException, IOException, EdgeRuleNotFoundException {
+ if(this.xml != null || this.oxmFile != null ) {
+ createDocument();
+ }
+ if(this.doc == null) {
+ this.doc = ni.getSchema(v);
+ }
+ namespaceFilter = new HashSet<>();
+
+ NodeList bindingsNodes = doc.getElementsByTagName("xml-bindings");
+ Element bindingElement;
+ NodeList javaTypesNodes;
+ Element javaTypesElement;
+
+ if ( bindingsNodes == null || bindingsNodes.getLength() == 0 ) {
+ throw new SAXException("OXM file error: missing <binding-nodes> in " + oxmFile);
+ }
+
+ bindingElement = (Element) bindingsNodes.item(0);
+ javaTypesNodes = bindingElement.getElementsByTagName("java-types");
+ if ( javaTypesNodes.getLength() < 1 ) {
+ throw new SAXException("OXM file error: missing <binding-nodes><java-types> in " + oxmFile);
+ }
+ javaTypesElement = (Element) javaTypesNodes.item(0);
+
+ javaTypeNodes = javaTypesElement.getElementsByTagName("java-type");
+ if ( javaTypeNodes.getLength() < 1 ) {
+ throw new SAXException("OXM file error: missing <binding-nodes><java-types><java-type> in " + oxmFile );
+ }
+ }
+
+ private void createDocument() throws ParserConfigurationException, SAXException, IOException {
+ DocumentBuilder dBuilder = null;
+ try {
+ DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
+ dbFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+ dBuilder = dbFactory.newDocumentBuilder();
+ } catch (ParserConfigurationException e) {
+ throw e;
+ }
+ try {
+ if ( xml == null ) {
+ doc = dBuilder.parse(oxmFile);
+ } else {
+ InputSource isInput = new InputSource(new StringReader(xml));
+ doc = dBuilder.parse(isInput);
+ }
+ } catch (SAXException e) {
+ throw e;
+ } catch (IOException e) {
+ throw e;
+ }
+ return;
+ }
+ public abstract String getDocumentHeader();
+ public abstract String process() throws ParserConfigurationException, SAXException, IOException, FileNotFoundException, EdgeRuleNotFoundException ;
+
+ public String getXMLRootElementName(Element javaTypeElement) {
+ String xmlRootElementName=null;
+ NamedNodeMap attributes;
+
+ NodeList valNodes = javaTypeElement.getElementsByTagName("xml-root-element");
+ Element valElement = (Element) valNodes.item(0);
+ attributes = valElement.getAttributes();
+ for ( int i = 0; i < attributes.getLength(); ++i ) {
+ Attr attr = (Attr) attributes.item(i);
+ String attrName = attr.getNodeName();
+
+ String attrValue = attr.getNodeValue();
+ if ( attrName.equals("name"))
+ xmlRootElementName = attrValue;
+ }
+ return xmlRootElementName;
+ }
+
+ public String getXmlRootElementName( String javaTypeName )
+ {
+ String attrName, attrValue;
+ Attr attr;
+ Element javaTypeElement;
+ for ( int i = 0; i < javaTypeNodes.getLength(); ++ i ) {
+ javaTypeElement = (Element) javaTypeNodes.item(i);
+ NamedNodeMap attributes = javaTypeElement.getAttributes();
+ for ( int j = 0; j < attributes.getLength(); ++j ) {
+ attr = (Attr) attributes.item(j);
+ attrName = attr.getNodeName();
+ attrValue = attr.getNodeValue();
+ if ( attrName.equals("name") && attrValue.equals(javaTypeName)) {
+ NodeList valNodes = javaTypeElement.getElementsByTagName("xml-root-element");
+ Element valElement = (Element) valNodes.item(0);
+ attributes = valElement.getAttributes();
+ for ( int k = 0; k < attributes.getLength(); ++k ) {
+ attr = (Attr) attributes.item(k);
+ attrName = attr.getNodeName();
+
+ attrValue = attr.getNodeValue();
+ if ( attrName.equals("name"))
+ return (attrValue);
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ public Map getCombinedJavaTypes() {
+ return combinedJavaTypes;
+ }
+
+ public void setCombinedJavaTypes(Map combinedJavaTypes) {
+ this.combinedJavaTypes = combinedJavaTypes;
+ }
+
+ public Element getJavaTypeElementSwagger( String javaTypeName )
+ {
+
+ String attrName, attrValue;
+ Attr attr;
+ Element javaTypeElement;
+
+ List<Element> combineElementList = new ArrayList<Element>();
+ for ( int i = 0; i < javaTypeNodes.getLength(); ++ i ) {
+ javaTypeElement = (Element) javaTypeNodes.item(i);
+ NamedNodeMap attributes = javaTypeElement.getAttributes();
+ for ( int j = 0; j < attributes.getLength(); ++j ) {
+ attr = (Attr) attributes.item(j);
+ attrName = attr.getNodeName();
+ attrValue = attr.getNodeValue();
+ if ( attrName.equals("name") && attrValue.equals(javaTypeName)) {
+ combineElementList.add(javaTypeElement);
+ }
+ }
+ }
+ if ( combineElementList.size() == 0 ) {
+ return (Element) null;
+ } else if ( combineElementList.size() > 1 ) {
+ return combineElements( javaTypeName, combineElementList);
+ }
+ return combineElementList.get(0);
+ }
+
+ public boolean versionSupportsSwaggerDiff( String version) {
+ int ver = new Integer(version.substring(1)).intValue();
+ if ( ver >= HTMLfromOXM.swaggerDiffStartVersion ) {
+ return true;
+ }
+ return false;
+ }
+
+ public boolean versionSupportsBasePathProperty( String version) {
+ int ver = new Integer(version.substring(1)).intValue();
+ if ( ver <= HTMLfromOXM.swaggerMinBasepath ) {
+ return true;
+ }
+ return false;
+ }
+
+ protected void updateParentXmlElements(Element parentElement, NodeList moreXmlElementNodes) {
+ Element xmlElement;
+ NodeList childNodes;
+ Node childNode;
+
+ Node refChild = null;
+ // find childNode with attributes and no children, insert children before that node
+ childNodes = parentElement.getChildNodes();
+ if ( childNodes == null || childNodes.getLength() == 0 ) {
+ // should not happen since the base parent was chosen if it had children
+ return;
+ }
+
+ for ( int i = 0; i < childNodes.getLength(); ++i ) {
+ refChild = childNodes.item(i);
+ if ( refChild.hasAttributes() && !refChild.hasChildNodes()) {
+ break;
+ }
+
+ }
+
+ for ( int i = 0; i < moreXmlElementNodes.getLength(); ++i ) {
+ xmlElement = (Element)moreXmlElementNodes.item(i);
+ childNode = xmlElement.cloneNode(true);
+ parentElement.insertBefore(childNode, refChild);
+ }
+ }
+
+ protected Node getXmlPropertiesNode(Element javaTypeElement ) {
+ NodeList nl = javaTypeElement.getChildNodes();
+ Node child;
+ for ( int i = 0; i < nl.getLength(); ++i ) {
+ child = nl.item(i);
+ if ( "xml-properties".equals(child.getNodeName())) {
+ return child;
+ }
+ }
+ return null;
+ }
+
+ protected Node merge( NodeList nl, Node mergeNode ) {
+ NamedNodeMap nnm = mergeNode.getAttributes();
+ Node childNode;
+ NamedNodeMap childNnm;
+
+ String mergeName = nnm.getNamedItem("name").getNodeValue();
+ String mergeValue = nnm.getNamedItem("value").getNodeValue();
+ String childName;
+ String childValue;
+ for ( int j = 0; j < nl.getLength(); ++j ) {
+ childNode = nl.item(j);
+ if ( "xml-property".equals(childNode.getNodeName())) {
+ childNnm = childNode.getAttributes();
+ childName = childNnm.getNamedItem("name").getNodeValue();
+ childValue = childNnm.getNamedItem("value").getNodeValue();
+ if ( childName.equals(mergeName)) {
+ // attribute exists
+ // keep, replace or update
+ if ( childValue.contains(mergeValue) ) {
+ return null;
+ }
+ if ( mergeValue.contains(childValue) ) {
+ childNnm.getNamedItem("value").setTextContent(mergeValue);
+ return null;
+ }
+ childNnm.getNamedItem("value").setTextContent(mergeValue + "," + childValue);
+ return null;
+ }
+ }
+ }
+ childNode = mergeNode.cloneNode(true);
+ return childNode;
+ }
+
+ protected void mergeXmlProperties(Node useChildProperties, NodeList propertiesToMerge ) {
+ NodeList nl = useChildProperties.getChildNodes();
+ Node childNode;
+ Node newNode;
+ for ( int i = 0; i < propertiesToMerge.getLength(); ++i ) {
+ childNode = propertiesToMerge.item(i);
+ if ( "xml-property".equals(childNode.getNodeName()) ) {
+ newNode = merge(nl, childNode);
+ if ( newNode != null ) {
+ useChildProperties.appendChild(newNode);
+ }
+ }
+
+ }
+ }
+
+ protected void combineXmlProperties(int useElement, List<Element> combineElementList) {
+ // add or update xml-properties to the referenced element from the combined list
+ Element javaTypeElement = combineElementList.get(useElement);
+ NodeList nl = javaTypeElement.getChildNodes();
+ Node useChildProperties = getXmlPropertiesNode( javaTypeElement);
+ int cloneChild = -1;
+ Node childProperties;
+ if ( useChildProperties == null ) {
+ // find xml-properties to clone
+ for ( int i = 0; i < combineElementList.size(); ++i ) {
+ if ( i == useElement ) {
+ continue;
+ }
+ childProperties = getXmlPropertiesNode(combineElementList.get(i));
+ if ( childProperties != null ) {
+ useChildProperties = childProperties.cloneNode(true);
+ javaTypeElement.appendChild(useChildProperties);
+ cloneChild = i;
+ }
+ }
+ }
+ NodeList cnl;
+ // find other xml-properties
+ for ( int i = 0; i < combineElementList.size(); ++i ) {
+ if ( i == useElement|| ( cloneChild >= 0 && i <= cloneChild )) {
+ continue;
+ }
+ childProperties = getXmlPropertiesNode(combineElementList.get(i));
+ if ( childProperties == null ) {
+ continue;
+ }
+ cnl = childProperties.getChildNodes();
+ mergeXmlProperties( useChildProperties, cnl);
+ }
+
+ }
+
+ protected Element combineElements( String javaTypeName, List<Element> combineElementList ) {
+ Element javaTypeElement;
+ NodeList parentNodes;
+ Element parentElement = null;
+ NodeList xmlElementNodes;
+
+ int useElement = -1;
+ if ( combinedJavaTypes.containsKey( javaTypeName) ) {
+ return combineElementList.get((int)combinedJavaTypes.get(javaTypeName));
+ }
+ for ( int i = 0; i < combineElementList.size(); ++i ) {
+ javaTypeElement = combineElementList.get(i);
+ parentNodes = javaTypeElement.getElementsByTagName("java-attributes");
+ if ( parentNodes.getLength() == 0 ) {
+ continue;
+ }
+ parentElement = (Element)parentNodes.item(0);
+ xmlElementNodes = parentElement.getElementsByTagName("xml-element");
+ if ( xmlElementNodes.getLength() <= 0 ) {
+ continue;
+ }
+ useElement = i;
+ break;
+ }
+ boolean doCombineElements = true;
+ if ( useElement < 0 ) {
+ useElement = 0;
+ doCombineElements = false;
+ } else if ( useElement == combineElementList.size() - 1) {
+ doCombineElements = false;
+ }
+ if ( doCombineElements ) {
+ // get xml-element from other javaTypeElements
+ Element otherParentElement = null;
+ for ( int i = 0; i < combineElementList.size(); ++i ) {
+ if ( i == useElement ) {
+ continue;
+ }
+ javaTypeElement = combineElementList.get(i);
+ parentNodes = javaTypeElement.getElementsByTagName("java-attributes");
+ if ( parentNodes.getLength() == 0 ) {
+ continue;
+ }
+ otherParentElement = (Element)parentNodes.item(0);
+ xmlElementNodes = otherParentElement.getElementsByTagName("xml-element");
+ if ( xmlElementNodes.getLength() <= 0 ) {
+ continue;
+ }
+ // xml-element that are not present
+ updateParentXmlElements( parentElement, xmlElementNodes);
+
+ }
+ }
+ // need to combine xml-properties
+ combineXmlProperties(useElement, combineElementList );
+ combinedJavaTypes.put( javaTypeName, useElement);
+ return combineElementList.get(useElement);
+ }
+}
Code Review / aai / schema-service.git / blobdiff