aai-core/src/main/java/org/openecomp/aai/util/GenerateXsd.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * org.openecomp.aai
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.aai.util;
  22
  23 import java.io.BufferedWriter;
  24 import java.io.File;
  25 import java.io.FileWriter;
  26 import java.io.IOException;
  27 import java.lang.reflect.Field;
  28 import java.util.ArrayList;
  29 import java.util.Collection;
  30 import java.util.HashMap;
  31 import java.util.Iterator;
  32 import java.util.List;
  33 import java.util.Map;
  34 import java.util.StringTokenizer;
  35 import java.util.Vector;
  36
  37 import javax.xml.XMLConstants;
  38 import javax.xml.bind.JAXBContext;
  39 import javax.xml.bind.JAXBException;
  40 import javax.xml.bind.SchemaOutputResolver;
  41 import javax.xml.parsers.DocumentBuilder;
  42 import javax.xml.parsers.DocumentBuilderFactory;
  43 import javax.xml.transform.Result;
  44 import javax.xml.transform.stream.StreamResult;
  45 import javax.xml.xpath.XPath;
  46 import javax.xml.xpath.XPathConstants;
  47 import javax.xml.xpath.XPathExpression;
  48 import javax.xml.xpath.XPathExpressionException;
  49 import javax.xml.xpath.XPathFactory;
  50
  51 import org.w3c.dom.Attr;
  52 import org.w3c.dom.Document;
  53 import org.w3c.dom.Element;
  54 import org.w3c.dom.NamedNodeMap;
  55 import org.w3c.dom.NodeList;
  56
  57 import org.openecomp.aai.dbmodel.DbEdgeRules;
  58 import com.google.common.base.Joiner;
  59 import com.google.common.collect.Multimap;
  60
  61
  62 public class GenerateXsd {
  63         static String apiVersion = null;
  64         static String apiVersionFmt = null;
  65         static String responsesUrl = null;
  66         static String responsesLabel = null;
  67         static Map<String, String> generatedJavaType = new HashMap<String, String>();
  68         static Map<String, String> appliedPaths = new HashMap<String, String>();
  69         static NodeList javaTypeNodes;
  70         static Class<?> versionedClass;
  71
  72
  73         public static final int VALUE_NONE = 0;
  74         public static final int VALUE_DESCRIPTION = 1;
  75         public static final int VALUE_INDEXED_PROPS = 2;
  76
  77         private static XPath xpath = XPathFactory.newInstance().newXPath();
  78
  79
  80         private enum LineageType {
  81                 PARENT, CHILD, UNRELATED;
  82         }
  83         private class EdgeDescription {
  84
  85                 private String ruleKey;
  86                 private LineageType type = LineageType.UNRELATED;
  87                 private String direction;
  88                 private String multiplicity;
  89                 private boolean hasDelTarget = false;
  90
  91                 public String getRuleKey() {
  92                         return ruleKey;
  93                 }
  94                 public String getMultiplicity() {
  95                         return multiplicity;
  96                 }
  97                 public String getDirection() {
  98                         return direction;
  99                 }
 100                 public void setRuleKey(String val) {
 101                         this.ruleKey=val;
 102                 }
 103                 public void setType(LineageType val) {
 104                         this.type=val;
 105                 }
 106                 public void setDirection(String val) {
 107                         this.direction = val;
 108                 }
 109                 public void setMultiplicity(String val) {
 110                         this.multiplicity=val;
 111                 }
 112                 public void setHasDelTarget(String val) {
 113                         hasDelTarget = Boolean.parseBoolean(val);
 114                 }
 115
 116                 public String getRelationshipDescription(String fromTo, String otherNodeName) {
 117
 118                         String result = "";
 119
 120                         if ("FROM".equals(fromTo)) {
 121                                 if ("OUT".equals(direction)) {
 122                                         if (LineageType.PARENT == type) {
 123                                                 result = " (is composed of "+otherNodeName;
 124                                         }
 125                                 }
 126                                 else {
 127                                         if (LineageType.CHILD == type) {
 128                                                 result = " (comprises "+otherNodeName;
 129                                         }
 130                                         else if (LineageType.PARENT == type) {
 131                                                 result = " (comprises "+otherNodeName;
 132                                         }
 133                                 }
 134                         } else {
 135                                 if ("OUT".equals(direction)) {
 136                                         if (LineageType.PARENT == type) {
 137                                                 result = " (comprises "+otherNodeName;
 138                                         }
 139                                 } else {
 140                                         if (LineageType.PARENT == type) {
 141                                                 result = " (is composed of "+otherNodeName;
 142                                         }
 143                                 }
 144                         }
 145
 146 //                      if (type != null) {
 147 //                              if (LineageType.PARENT.equals(type) && "FROM".equals(fromTo)) {
 148 //                                      if ("OUT".equals(direction)) {
 149 //                                              result = " (is composed of "+otherNodeName;
 150 //                                      } else {
 151 //                                              result = " (comprises "+otherNodeName;
 152 //                                      }
 153 //                              } else {
 154 //                                      result = " (comprises " + otherNodeName;
 155 //                                      //                                      if (!(multiplicity.startsWith("One"))) {
 156 //                                      //                                              System.err.println("Surprised to find multiplicity "+multiplicity+" with comprises for "+ruleKey);
 157 //                                      //                                      }
 158 //                              }
 159 //                      }
 160                         if ("TO".equals(fromTo)) {
 161                                 if (result.length() == 0) result = result + " (";
 162                                 else result = result + ", ";
 163
 164                                 result = result + mapMultiplicity(fromTo);
 165                                 if (hasDelTarget) result = result + ", will delete target node";
 166                         }
 167
 168                         if (result.length() > 0) result = result + ")";
 169
 170                         return result;
 171                 }
 172
 173                 private String mapMultiplicity(String fromTo) {
 174                         String result = multiplicity;
 175 // Below logic works if an IN switches multiplicity, which it doesn't today.
 176 //                      if ("TO".equals(fromTo)) {
 177 //                              if (direction.equals("OUT")) {
 178 //                                      result = multiplicity;
 179 //                              } else {
 180 //                                      result = switchMultiplicity(multiplicity);
 181 //                              }
 182 //                      } else {
 183 //                              if (direction.equals("OUT")) {
 184 //                                      result = multiplicity;
 185 //                              } else {
 186 //                                      result = switchMultiplicity(multiplicity);
 187 //                              }
 188 //                      }
 189                         return result;
 190                 }
 191
 192 //              private String switchMultiplicity(String val) throws IllegalArgumentException
 193 //              {
 194 //                      String result = null;
 195 //                      switch (val) {
 196 //                      case "Many2Many":
 197 //                      case "One2One":
 198 //                              result = val;
 199 //                              break;
 200 //                      case "Many2One":
 201 //                              result = "One2Many";
 202 //                              break;
 203 //                      case "One2Many":
 204 //                              result = "Many2One";
 205 //                              break;
 206 //                      default:
 207 //                              throw new IllegalArgumentException("Multiplicity cannot be "+val);
 208 //                      }
 209 //                      System.out.println("Switched Multiplicity from "+val+" to "+result);
 210 //                      return result;
 211 //              }
 212         }
 213
 214         public static void main(String[] args) throws IOException {
 215
 216                 if (args.length > 0) {
 217                         if (args[0] != null) {
 218                                 apiVersion = args[0];
 219                         }
 220                 }
 221                 boolean genDoc = false;
 222                 if ( args.length > 1 ) {
 223                         genDoc = true;
 224                         int index = args[1].indexOf("|");
 225                         if ( index > 0 ) {
 226                                 responsesUrl = args[1].substring(0, index);
 227                                 responsesLabel = args[1].substring(index+1);
 228                                 //System.out.println( "response URL " + responsesUrl);
 229                                 //System.out.println( "response label " + responsesLabel);
 230                                 responsesUrl = "description: "+ responsesLabel + "(" +
 231                                                 responsesUrl + ").\n";
 232                                 //System.out.println( "operation described with " + responsesUrl);
 233                         } else { // default
 234                                 responsesUrl = "";
 235                         }
 236                 }
 237                 String oxmPath = null;
 238                 if ( apiVersion == null ) {
 239                         // to run from eclipse, set these env, e.g. v7, \sources\aai\aaimastergit\bundleconfig-local\etc\oxm\
 240                         String envRev= System.getenv("OXM_REV");
 241                         if ( envRev != null )
 242                                 apiVersion = envRev;
 243
 244                 }
 245                 oxmPath = System.getenv("OXM_PATH");
 246                 String outfileName;
 247                 if ( genDoc ) {
 248                         outfileName = "c:\\temp\\aai.yaml";
 249                 } else
 250                         outfileName = "c:\\temp\\aai_schema.xsd";
 251                 if ( apiVersion != null ) { // generate from oxm
 252                         apiVersionFmt = "." + apiVersion + ".";
 253                         if ( oxmPath == null ) {
 254                                 oxmPath = AAIConstants.AAI_HOME_ETC_OXM + AAIConstants.AAI_FILESEP;
 255                                 //oxmPath = "\\sources\\aai\\aaimastergit\\bundleconfig-local\\etc\\oxm\\";
 256                         }
 257
 258                         File oxm_file = new File(oxmPath + "aai_oxm_" + apiVersion + ".xml");
 259                         String xsd;
 260                         File outfile;
 261                         if ( genDoc ) {
 262                                 xsd = generateSwaggerFromOxmFile( oxm_file);
 263                                 outfile =new File(outfileName);
 264                         } else {
 265                                 xsd = processOxmFile( oxm_file);
 266                                 outfile =new File(outfileName);
 267                         }
 268
 269
 270                     try {
 271                         outfile.createNewFile();
 272                     } catch (IOException e) {
 273                         System.out.println( "Exception creating output file " + outfileName);
 274                         e.printStackTrace();
 275                     }
 276                 try {
 277                         FileWriter fw = new FileWriter(outfile.getAbsoluteFile());
 278                         BufferedWriter bw = new BufferedWriter(fw);
 279                         bw.write(xsd);
 280                         bw.close();
 281
 282                 } catch ( IOException e) {
 283                         System.out.println( "Exception writing output file " + outfileName);
 284                         e.printStackTrace();
 285                 }
 286                         System.out.println( "GeneratedXSD successful, saved in " + outfileName);
 287                         return;
 288                 }
 289
 290                 JAXBContext jaxbContext = null;
 291                 try {
 292                         jaxbContext = JAXBContext.newInstance(org.openecomp.aai.domain.yang.Vce.class);
 293                 } catch (JAXBException e) {
 294
 295                         e.printStackTrace();
 296                 }
 297                 SchemaOutputResolver sor = new MySchemaOutputResolver();
 298                 jaxbContext.generateSchema(sor);
 299
 300         }
 301
 302         public static class MySchemaOutputResolver extends SchemaOutputResolver {
 303
 304                 public Result createOutput(String namespaceURI, String suggestedFileName) throws IOException {
 305                         File file = new File("c:\\temp\\aai_schema.xsd");
 306                         StreamResult result = new StreamResult(file);
 307                         result.setSystemId(file.toURI().toURL().toString());
 308                         return result;
 309                 }
 310
 311         }
 312
 313         public static String processJavaTypeElement( String javaTypeName, Element javaTypeElement) {
 314
 315                 String xmlRootElementName = null;
 316
 317                 NodeList parentNodes = javaTypeElement.getElementsByTagName("java-attributes");
 318                 StringBuffer sb = new StringBuffer();
 319                 if ( parentNodes.getLength() == 0 ) {
 320                         System.out.println( "no java-attributes for java-type " + javaTypeName);
 321                         return "";
 322
 323                 }
 324
 325                 NamedNodeMap attributes;
 326
 327                 NodeList valNodes = javaTypeElement.getElementsByTagName("xml-root-element");
 328                 Element valElement = (Element) valNodes.item(0);
 329                 attributes = valElement.getAttributes();
 330                 for ( int i = 0; i < attributes.getLength(); ++i ) {
 331             Attr attr = (Attr) attributes.item(i);
 332             String attrName = attr.getNodeName();
 333
 334             String attrValue = attr.getNodeValue();
 335             //System.out.println("Found xml-root-element attribute: " + attrName + " with value: " + attrValue);
 336             if ( attrName.equals("name"))
 337                 xmlRootElementName = attrValue;
 338                 }
 339                 /*
 340                 if ( javaTypeName.equals("RelationshipList")) {
 341                         System.out.println( "Skipping " + javaTypeName);
 342                         generatedJavaType.put(javaTypeName, null);
 343                         return "";
 344                 }
 345                 */
 346
 347                 Element parentElement = (Element)parentNodes.item(0);
 348                 NodeList xmlElementNodes = parentElement.getElementsByTagName("xml-element");
 349                 NodeList childNodes;
 350                 Element childElement;
 351                 String xmlElementWrapper;
 352
 353                 Element xmlElementElement;
 354                 String addType;
 355                 String elementName, elementType, elementIsKey, elementIsRequired, elementContainerType;
 356                 StringBuffer sb1 = new StringBuffer();
 357                 if ( xmlElementNodes.getLength() > 0 ) {
 358                         sb1.append("  <xs:element name=\"" + xmlRootElementName + "\">\n");
 359                         sb1.append("    <xs:complexType>\n");
 360                         NodeList properties = GenerateXsd.locateXmlProperties(javaTypeElement);
 361                         if (properties != null) {
 362                                 System.out.println("properties found for: " + xmlRootElementName);
 363                                 sb1.append("      <xs:annotation>\r\n");
 364                                 insertAnnotation(properties, false, "class", sb1, "      ");
 365
 366                                 sb1.append("      </xs:annotation>\r\n");
 367                         } else {
 368                                 System.out.println("no properties found for: " + xmlRootElementName);
 369                         }
 370                         sb1.append("      <xs:sequence>\n");
 371                         for ( int i = 0; i < xmlElementNodes.getLength(); ++i ) {
 372
 373                                 xmlElementElement = (Element)xmlElementNodes.item(i);
 374                                 childNodes = xmlElementElement.getElementsByTagName("xml-element-wrapper");
 375
 376                                 xmlElementWrapper = null;
 377                                 if ( childNodes.getLength() > 0 ) {
 378                                         childElement = (Element)childNodes.item(0);
 379                                         // get name
 380                                         attributes = childElement.getAttributes();
 381                                         for ( int k = 0; k < attributes.getLength(); ++k ) {
 382                                                 Attr attr = (Attr) attributes.item(k);
 383                                                 String attrName = attr.getNodeName();
 384                                                 String attrValue = attr.getNodeValue();
 385                                                 if ( attrName.equals("name")) {
 386                                                         xmlElementWrapper = attrValue;
 387                                                         //System.out.println("found xml-element-wrapper " + xmlElementWrapper);
 388                                                 }
 389                                         }
 390
 391                                 }
 392                                 attributes = xmlElementElement.getAttributes();
 393                                 addType = null;
 394
 395
 396                                 elementName = elementType = elementIsKey = elementIsRequired = elementContainerType = null;
 397                                 for ( int j = 0; j < attributes.getLength(); ++j ) {
 398                             Attr attr = (Attr) attributes.item(j);
 399                             String attrName = attr.getNodeName();
 400
 401                             String attrValue = attr.getNodeValue();
 402                             //System.out.println("For " + xmlRootElementName + " Found xml-element attribute: " + attrName + " with value: " + attrValue);
 403                             if ( attrName.equals("name")) {
 404                                 elementName = attrValue;
 405                             }
 406                             if ( attrName.equals("type")) {
 407                                 elementType = attrValue;
 408                                 if ( attrValue.contains(apiVersionFmt) ) {
 409                                         addType = attrValue.substring(attrValue.lastIndexOf('.')+1);
 410                                         if ( !generatedJavaType.containsKey(addType) ) {
 411                                                 generatedJavaType.put(addType, attrValue);
 412                                                 sb.append(processJavaTypeElement( addType, getJavaTypeElement(addType) ));
 413                                         }
 414                                 }
 415
 416                             }
 417
 418                             if ( attrName.equals("xml-key")) {
 419                                 elementIsKey = attrValue;
 420                             }
 421                             if ( attrName.equals("required")) {
 422                                 elementIsRequired = attrValue;
 423                             }
 424                             if ( attrName.equals("container-type")) {
 425                                 elementContainerType = attrValue;
 426                             }
 427                                 }
 428
 429                                 if ( xmlElementWrapper != null ) {
 430                                         sb1.append("        <xs:element name=\"" + xmlElementWrapper +"\"");
 431                                         if ( elementIsRequired == null || !elementIsRequired.equals("true")||addType != null) {
 432                                                 sb1.append(" minOccurs=\"0\"");
 433                                         }
 434                                         sb1.append(">\n");
 435                                         sb1.append("          <xs:complexType>\n");
 436                                         properties = GenerateXsd.locateXmlProperties(javaTypeElement);
 437                                         if (properties != null) {
 438                                                 sb1.append("            <xs:annotation>\r\n");
 439                                                 insertAnnotation(properties, false, "class", sb1, "            ");
 440                                                 sb1.append("            </xs:annotation>\r\n");
 441                                         } else {
 442                                                 System.out.println("no properties found for: " + xmlElementWrapper);
 443                                         }
 444                                         sb1.append("            <xs:sequence>\n");
 445                                         sb1.append("      ");
 446                                 }
 447                 if ("Nodes".equals(addType)) {
 448                         System.out.println ("Skipping nodes, temporary testing");
 449                         continue;
 450                 }
 451                                 if ( addType != null ) {
 452                                         //sb1.append("        <xs:element ref=\"tns:" + elementName +"\"");
 453                                         sb1.append("        <xs:element ref=\"tns:" + getXmlRootElementName(addType) +"\"");
 454                                 } else {
 455                                         sb1.append("        <xs:element name=\"" + elementName +"\"");
 456                                 }
 457                                 if ( elementType.equals("java.lang.String"))
 458                                         sb1.append(" type=\"xs:string\"");
 459                                 //if ( elementType.equals("java.lang.String"))
 460                                         //sb1.append(" type=\"xs:string\"");
 461                                 if ( elementType.equals("java.lang.Long"))
 462                                         sb1.append(" type=\"xs:unsignedInt\"");
 463                                 if ( elementType.equals("java.lang.Integer"))
 464                                         sb1.append(" type=\"xs:int\"");
 465                                 if ( elementType.equals("java.lang.Boolean"))
 466                                         sb1.append(" type=\"xs:boolean\"");
 467                                 //if ( elementIsRequired != null && elementIsRequired.equals("true")||addType != null) {
 468                                 if ( elementIsRequired == null || !elementIsRequired.equals("true")||addType != null) {
 469                                         sb1.append(" minOccurs=\"0\"");
 470                                 }
 471                                 if ( elementContainerType != null && elementContainerType.equals("java.util.ArrayList")) {
 472                                         sb1.append(" maxOccurs=\"unbounded\"");
 473                                 }
 474                                 properties = GenerateXsd.locateXmlProperties(xmlElementElement);
 475                                 if (properties != null || elementIsKey != null) {
 476                                         sb1.append(">\n");
 477                                         sb1.append("          <xs:annotation>\r\n");
 478                                         insertAnnotation(properties, elementIsKey != null, "field", sb1, "          ");
 479                                         sb1.append("          </xs:annotation>\r\n");
 480
 481                                         if (xmlElementWrapper== null) {
 482                                                 sb1.append("        </xs:element>\n");
 483                                         }
 484                                 } else {
 485                                         sb1.append("/>\n");
 486                                 }
 487                                 if ( xmlElementWrapper != null ) {
 488                                         sb1.append("            </xs:sequence>\n");
 489                                         sb1.append("          </xs:complexType>\n");
 490                                         sb1.append("        </xs:element>\n");
 491                                 }
 492                         }
 493                         /*
 494                 if (  xmlRootElementName.equals("notify") ||
 495                         xmlRootElementName.equals("relationship") ||
 496                         xmlRootElementName.equals("relationship-data") ||
 497                         xmlRootElementName.equals("related-to-property") )
 498
 499                         sb1.append("        <xs:any namespace=\"##other\" processContents=\"lax\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n");
 500                 */
 501                 sb1.append("      </xs:sequence>\n");
 502                 sb1.append("    </xs:complexType>\n");
 503                 sb1.append("  </xs:element>\n");
 504                 }
 505                 /*
 506                 NodeList valNodes = javaTypeElement.getElementsByTagName("xml-root-element");
 507                 Element valElement = (Element) valNodes.item(0);
 508                 attributes = valElement.getAttributes();
 509                 for ( int i = 0; i < attributes.getLength(); ++i ) {
 510             Attr attr = (Attr) attributes.item(i);
 511             String attrName = attr.getNodeName();
 512
 513             String attrValue = attr.getNodeValue();
 514             System.out.println("Found xml-root-element attribute: " + attrName + " with value: " + attrValue);
 515             if ( attrValue.equals("name"))
 516                 xmlRootElementName = attrValue;
 517                 }
 518                 */
 519
 520                 if ( xmlElementNodes.getLength() < 1 ) {
 521                         sb.append("  <xs:element name=\"" + xmlRootElementName + "\">\n");
 522                         sb.append("    <xs:complexType>\n");
 523                         sb.append("      <xs:sequence/>\n");
 524                         sb.append("    </xs:complexType>\n");
 525                         sb.append("  </xs:element>\n");
 526                         generatedJavaType.put(javaTypeName, null);
 527                         return sb.toString();
 528                 }
 529
 530                 sb.append( sb1 );
 531
 532                 return sb.toString();
 533         }
 534
 535         private static void insertAnnotation(NodeList items, boolean isKey, String target, StringBuffer sb1, String indentation) {
 536                 if (items != null || isKey) {
 537                         List<String> metadata = new ArrayList<>();
 538
 539                         String name = "";
 540                         String value = "";
 541                         Element item = null;
 542                         if (isKey) {
 543                                 metadata.add("isKey=true");
 544                         }
 545                         if (items != null) {
 546                                 for (int i = 0; i < items.getLength(); i++) {
 547                                         item = (Element)items.item(i);
 548                                         name = item.getAttribute("name");
 549                                         value = item.getAttribute("value");
 550                                         if (name.equals("abstract")) {
 551                                                 name = "isAbstract";
 552                                         } else if (name.equals("extends")) {
 553                                                 name = "extendsFrom";
 554                                         }
 555                                         metadata.add(name + "=\"" + value.replaceAll("&",  "&amp;") + "\"");
 556                                         System.out.println("property name: " + name);
 557
 558                                 }
 559                         }
 560                         sb1.append(
 561                                         indentation + "  <xs:appinfo>\r\n" +
 562                                                         indentation + "    <annox:annotate target=\""+target+"\">@org.openecomp.aai.annotations.Metadata(" + Joiner.on(",").join(metadata) + ")</annox:annotate>\r\n" +
 563                                                         indentation + "  </xs:appinfo>\r\n");
 564                 }
 565
 566         }
 567
 568         private static Element getJavaTypeElement( String javaTypeName )
 569         {
 570
 571                 String attrName, attrValue;
 572                 Attr attr;
 573                 Element javaTypeElement;
 574                 for ( int i = 0; i < javaTypeNodes.getLength(); ++ i ) {
 575                         javaTypeElement = (Element) javaTypeNodes.item(i);
 576                         NamedNodeMap attributes = javaTypeElement.getAttributes();
 577                         for ( int j = 0; j < attributes.getLength(); ++j ) {
 578                     attr = (Attr) attributes.item(j);
 579                     attrName = attr.getNodeName();
 580                     attrValue = attr.getNodeValue();
 581                     if ( attrName.equals("name") && attrValue.equals(javaTypeName))
 582                         return javaTypeElement;
 583                         }
 584                 }
 585                 System.out.println( "oxm file format error, missing java-type " + javaTypeName);
 586                 return (Element) null;
 587         }
 588
 589         private static Element getJavaTypeElementSwagger( String javaTypeName )
 590         {
 591
 592                 String attrName, attrValue;
 593                 Attr attr;
 594                 Element javaTypeElement;
 595                 for ( int i = 0; i < javaTypeNodes.getLength(); ++ i ) {
 596                         javaTypeElement = (Element) javaTypeNodes.item(i);
 597                         NamedNodeMap attributes = javaTypeElement.getAttributes();
 598                         for ( int j = 0; j < attributes.getLength(); ++j ) {
 599                     attr = (Attr) attributes.item(j);
 600                     attrName = attr.getNodeName();
 601                     attrValue = attr.getNodeValue();
 602                     if ( attrName.equals("name") && attrValue.equals(javaTypeName))
 603                         return javaTypeElement;
 604                         }
 605                 }
 606                 System.out.println( "oxm file format error, missing java-type " + javaTypeName);
 607                 return (Element) null;
 608         }
 609         private static String getXmlRootElementName( String javaTypeName )
 610         {
 611
 612                 String attrName, attrValue;
 613                 Attr attr;
 614                 Element javaTypeElement;
 615                 for ( int i = 0; i < javaTypeNodes.getLength(); ++ i ) {
 616                         javaTypeElement = (Element) javaTypeNodes.item(i);
 617                         NamedNodeMap attributes = javaTypeElement.getAttributes();
 618                         for ( int j = 0; j < attributes.getLength(); ++j ) {
 619                     attr = (Attr) attributes.item(j);
 620                     attrName = attr.getNodeName();
 621                     attrValue = attr.getNodeValue();
 622                     if ( attrName.equals("name") && attrValue.equals(javaTypeName)) {
 623                                 NodeList valNodes = javaTypeElement.getElementsByTagName("xml-root-element");
 624                                 Element valElement = (Element) valNodes.item(0);
 625                                 attributes = valElement.getAttributes();
 626                                 for ( int k = 0; k < attributes.getLength(); ++k ) {
 627                             attr = (Attr) attributes.item(k);
 628                             attrName = attr.getNodeName();
 629
 630                             attrValue = attr.getNodeValue();
 631                             //System.out.println("Found xml-root-element attribute: " + attrName + " with value: " + attrValue);
 632                             if ( attrName.equals("name"))
 633                                 return (attrValue);
 634                                 }
 635                     }
 636                         }
 637                 }
 638                 System.out.println( "oxm file format error, missing java-type " + javaTypeName);
 639                 return null;
 640         }
 641
 642
 643         public static String processOxmFile( File oxmFile )
 644         {
 645                 StringBuffer sb = new StringBuffer();
 646                 sb.append("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n");
 647                 String namespace = "org.openecomp";
 648                 sb.append("<xs:schema elementFormDefault=\"qualified\" version=\"1.0\" targetNamespace=\"http://" + namespace + ".aai.inventory/"
 649                                 + apiVersion + "\" xmlns:tns=\"http://" + namespace + ".aai.inventory/" + apiVersion + "\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
 650                                                 + "\n"
 651                                                 + "xmlns:jaxb=\"http://java.sun.com/xml/ns/jaxb\"\r\n" +
 652                                                 "    jaxb:version=\"2.1\" \r\n" +
 653                                                 "    xmlns:annox=\"http://annox.dev.java.net\" \r\n" +
 654                                                 "    jaxb:extensionBindingPrefixes=\"annox\">\n\n");
 655
 656                 try {
 657
 658                     DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
 659                     dbFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
 660                     DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
 661                     Document doc = dBuilder.parse(oxmFile);
 662
 663                     NodeList bindingsNodes = doc.getElementsByTagName("xml-bindings");
 664                         Element bindingElement;
 665                         NodeList javaTypesNodes;
 666                         Element javaTypesElement;
 667
 668                         Element javaTypeElement;
 669
 670
 671                         if ( bindingsNodes == null || bindingsNodes.getLength() == 0 ) {
 672                                 System.out.println( "missing <binding-nodes> in " + oxmFile );
 673                                 return null;
 674                         }
 675
 676                         bindingElement = (Element) bindingsNodes.item(0);
 677                         javaTypesNodes = bindingElement.getElementsByTagName("java-types");
 678                         if ( javaTypesNodes.getLength() < 1 ) {
 679                                 System.out.println( "missing <binding-nodes><java-types> in " + oxmFile );
 680                                 return null;
 681                         }
 682                         javaTypesElement = (Element) javaTypesNodes.item(0);
 683                         javaTypeNodes = javaTypesElement.getElementsByTagName("java-type");
 684                         if ( javaTypeNodes.getLength() < 1 ) {
 685                                 System.out.println( "missing <binding-nodes><java-types><java-type> in " + oxmFile );
 686                                 return null;
 687                         }
 688
 689                         String javaTypeName;
 690                         String attrName, attrValue;
 691                         Attr attr;
 692                         for ( int i = 0; i < javaTypeNodes.getLength(); ++ i ) {
 693                                 javaTypeElement = (Element) javaTypeNodes.item(i);
 694                                 NamedNodeMap attributes = javaTypeElement.getAttributes();
 695                                 javaTypeName = null;
 696                                 for ( int j = 0; j < attributes.getLength(); ++j ) {
 697                             attr = (Attr) attributes.item(j);
 698                             attrName = attr.getNodeName();
 699                             attrValue = attr.getNodeValue();
 700                             if ( attrName.equals("name"))
 701                                 javaTypeName = attrValue;
 702                                 }
 703                                 if ( javaTypeName == null ) {
 704                                         System.out.println( "<java-type> has no name attribute in " + oxmFile );
 705                                         return null;
 706                                 }
 707                                 if ("Nodes".equals(javaTypeName)) {
 708                                         System.out.println("skipping Nodes entry (temporary feature)");
 709                                         continue;
 710                                 }
 711                                 if ( !generatedJavaType.containsKey(javaTypeName) ) {
 712                                         generatedJavaType.put(javaTypeName, null);
 713                                         sb.append(processJavaTypeElement( javaTypeName, javaTypeElement ));
 714                                 }
 715                         }
 716
 717                 } catch (Exception e) {
 718                         e.printStackTrace();
 719                         return null;
 720                 }
 721                 sb.append("</xs:schema>\n");
 722                 return sb.toString();
 723         }
 724
 725         private static boolean isStandardType( String elementType )
 726         {
 727                 switch ( elementType ) {
 728                 case "java.lang.String":
 729                 case "java.lang.Long":
 730                 case "java.lang.Integer":
 731                 case"java.lang.Boolean":
 732                         return true;
 733                 }
 734                 return false;
 735         }
 736
 737         private static Vector<String> getIndexedProps( String attrValue )
 738         {
 739                 if ( attrValue == null )
 740                         return null;
 741                 StringTokenizer st = new StringTokenizer( attrValue, ",");
 742                 if ( st.countTokens() ==  0 )
 743                         return null;
 744                 Vector<String> result = new Vector<String>();
 745                 while ( st.hasMoreTokens()) {
 746                         result.add(st.nextToken());
 747                 }
 748                 return result;
 749         }
 750
 751         private static Class<?> getEdgeRulesClass() throws ClassNotFoundException {
 752                 Class<?> result = null;
 753
 754                 // If a class matching the apiVersion exists, we are generating documentation for a prior release
 755                 // Otherwise, we're generated documentation for the current release.
 756                 try {
 757                         result = Class.forName("org.openecomp.aai.dbmodel." + apiVersion +".gen.DbEdgeRules");
 758                 } catch (ClassNotFoundException  ex) {
 759                         result = Class.forName("org.openecomp.aai.dbmodel.DbEdgeRules");
 760                 }
 761                 return result;
 762         }
 763
 764         /**
 765          * Guaranteed to at least return non null but empty collection of edge descriptions
 766          * @param nodeName name of the vertex whose edge relationships to return
 767          * @return collection of node neighbors based on DbEdgeRules
 768          */
 769         private static Collection<EdgeDescription> getEdgeRules( String nodeName )
 770         {
 771
 772                 ArrayList<EdgeDescription> result = new ArrayList<>();
 773                 Iterator<String> edgeRulesIterator;
 774
 775                 try {
 776
 777                         Field mapfield = versionedClass.getField("EdgeRules");
 778                         Object map = mapfield.get(null);
 779                         if (map instanceof Multimap<?,?>) {
 780                                 edgeRulesIterator = ((Multimap<String,String>) map).keySet().iterator();
 781                         } else {
 782                                 throw new NoSuchFieldException ("Didn't get back the multimap field expected");
 783                         }
 784                         GenerateXsd x = new GenerateXsd();
 785
 786                         while( edgeRulesIterator.hasNext() ){
 787                                 String ruleKey = edgeRulesIterator.next();
 788                                 if ( ruleKey.startsWith(nodeName + "|" ) ||
 789                                                 ruleKey.endsWith("|" + nodeName)) {
 790                                         Collection <String> edRuleColl = DbEdgeRules.EdgeRules.get(ruleKey);
 791                                         Iterator <String> ruleItr = edRuleColl.iterator();
 792                                         while( ruleItr.hasNext() ){
 793                                                 EdgeDescription edgeDes = x.new EdgeDescription();
 794                                                 edgeDes.setRuleKey(ruleKey);
 795                                                 String fullRuleString = ruleItr.next();
 796                                                 String[] toks = fullRuleString.split(",");
 797                                                 if (toks != null) {
 798                                                         if (toks.length > 1) {
 799                                                                 edgeDes.setDirection(toks[1]);
 800                                                         }
 801                                                         if (toks.length > 2) {
 802                                                                 edgeDes.setMultiplicity(toks[2]);
 803                                                         }
 804                                                         if (toks.length > 3) {
 805                                                                 if (toks[3].equals("true"))
 806                                                                         edgeDes.setType(LineageType.PARENT);
 807                                                                 else if (toks[3].equals("parent"))
 808                                                                         edgeDes.setType(LineageType.PARENT);
 809                                                                 else if (toks[3].equals("child"))
 810                                                                         edgeDes.setType(LineageType.CHILD);
 811                                                                 else
 812                                                                         edgeDes.setType(LineageType.UNRELATED);
 813                                                         }
 814                                                         if (toks.length > 5) {
 815                                                                 edgeDes.setHasDelTarget(toks[5]);;
 816                                                         }
 817                                                 }
 818
 819                                                 //System.out.println( "nodeName " + nodeName + " ruleKey "  + ruleKey + " ruleString " + fullRuleString);
 820                                                 //result.add(ruleKey + "-" + fullRuleString);
 821                                                 result.add(edgeDes);
 822                                         }
 823                                 }
 824                         }
 825                 } catch (Exception ex) {
 826                         ex.printStackTrace();
 827                 }
 828                 return result;
 829         }
 830
 831         /**
 832          * Finds the default delete scope from DBEdgeRules
 833          * @param nodeName name of vertex whose delete scope to return
 834          * @return default delete scope of the input nodeName, null if none.
 835          */
 836         private static String getDeleteRules( String nodeName )
 837         {
 838                 String result = null;
 839                 Iterator<String> delRulesIterator;
 840
 841                 try {
 842
 843                         Field mapfield = versionedClass.getField("DefaultDeleteScope");
 844                         Object map = mapfield.get(null);
 845                         if (map instanceof Multimap<?,?>) {
 846                                 delRulesIterator = ((Multimap<String,String>) map).keySet().iterator();
 847                         } else {
 848                                 throw new NoSuchFieldException ("Didn't get back the multimap field expected");
 849                         }
 850
 851                         while( delRulesIterator.hasNext() ){
 852                                 String ruleKey = delRulesIterator.next();
 853                                 if ( ruleKey.equals(nodeName)) {
 854                                         Collection <String> deRuleColl = DbEdgeRules.DefaultDeleteScope.get(ruleKey);
 855                                         Iterator <String> ruleItr = deRuleColl.iterator();
 856                                         if( ruleItr.hasNext() ){
 857                                                 result = ruleItr.next();
 858                                         }
 859                                 }
 860                         }
 861
 862                 } catch (Exception ex) {
 863                         ex.printStackTrace();
 864                 }
 865                 return result;
 866         }
 867
 868         public static String processJavaTypeElementSwagger( String javaTypeName, Element javaTypeElement,
 869                         StringBuffer pathSb, StringBuffer definitionsSb, String path, String tag, String opId,
 870                         String getItemName, StringBuffer pathParams, String queryParams, String validEdges) {
 871
 872                 String xmlRootElementName = null;
 873
 874                 //Map<String, String> addJavaType = new HashMap<String, String>();
 875                 String useTag = null;
 876                 String useOpId = null;
 877
 878                 if ( tag != null ) {
 879                         switch ( tag ) {
 880                         case "Network":
 881                         case "ServiceDesignAndCreation":
 882                         case "Business":
 883                         case "CloudInfrastructure":
 884                                 break;
 885                         default:
 886                                 return null;
 887                         }
 888                 }
 889
 890                 if ( !javaTypeName.equals("Inventory") ) {
 891                         if ( javaTypeName.equals("AaiInternal"))
 892                                 return null;
 893                         if ( opId == null )
 894                                 useOpId = javaTypeName;
 895                         else
 896                                 useOpId = opId + javaTypeName;
 897                         if ( tag == null )
 898                                 useTag = javaTypeName;
 899                 }
 900
 901                 NodeList parentNodes = javaTypeElement.getElementsByTagName("java-attributes");
 902
 903                 if ( parentNodes.getLength() == 0 ) {
 904                         System.out.println( "no java-attributes for java-type " + javaTypeName);
 905                         return "";
 906
 907                 }
 908
 909                 NamedNodeMap attributes;
 910
 911                 NodeList valNodes = javaTypeElement.getElementsByTagName("xml-root-element");
 912                 Element valElement = (Element) valNodes.item(0);
 913                 attributes = valElement.getAttributes();
 914                 for ( int i = 0; i < attributes.getLength(); ++i ) {
 915             Attr attr = (Attr) attributes.item(i);
 916             String attrName = attr.getNodeName();
 917
 918             String attrValue = attr.getNodeValue();
 919             //System.out.println("Found xml-root-element attribute: " + attrName + " with value: " + attrValue);
 920             if ( attrName.equals("name"))
 921                 xmlRootElementName = attrValue;
 922                 }
 923                 /*
 924                 if ( xmlRootElementName.equals("oam-networks"))
 925                         System.out.println( "xmlRootElement oam-networks with getItemData [" + getItemName + "]");
 926                 */
 927                 //already processed
 928                 /*
 929                 if ( generatedJavaType.containsKey(xmlRootElementName) ) {
 930                         return null;
 931                 }
 932                 */
 933                 NodeList childNodes;
 934                 Element childElement;
 935                 NodeList xmlPropNodes = javaTypeElement.getElementsByTagName("xml-properties");
 936                 Element xmlPropElement;
 937                 String pathDescriptionProperty = null;
 938
 939
 940                 Vector<String> indexedProps = null;
 941
 942                 /*System.out.println( "javaTypeName " + javaTypeName + " has xml-properties length " + xmlPropNodes.getLength());
 943                 if ( path != null && path.equals("/network/generic-vnfs"))
 944                         System.out.println("path is " + "/network/generic-vnfs with getItemName " + getItemName);
 945                 */
 946                 if ( xmlPropNodes.getLength() > 0 ) {
 947
 948                         for ( int i = 0; i < xmlPropNodes.getLength(); ++i ) {
 949                                 xmlPropElement = (Element)xmlPropNodes.item(i);
 950                                 if ( !xmlPropElement.getParentNode().isSameNode(javaTypeElement))
 951                                         continue;
 952                                 childNodes = xmlPropElement.getElementsByTagName("xml-property");
 953
 954                                 if ( childNodes.getLength() > 0 ) {
 955                                         for ( int j = 0; j < childNodes.getLength(); ++j ) {
 956                                                 childElement = (Element)childNodes.item(j);
 957                                                 // get name
 958                                                 int useValue = VALUE_NONE;
 959                                                 attributes = childElement.getAttributes();
 960                                                 for ( int k = 0; k < attributes.getLength(); ++k ) {
 961                                                         Attr attr = (Attr) attributes.item(k);
 962                                                         String attrName = attr.getNodeName();
 963                                                         String attrValue = attr.getNodeValue();
 964                                                         if ( attrName == null || attrValue == null )
 965                                                                 continue;
 966                                                         if ( attrName.equals("name") && attrValue.equals("description")) {
 967                                                                 useValue = VALUE_DESCRIPTION;
 968                                                         }
 969                                                         if ( useValue == VALUE_DESCRIPTION && attrName.equals("value")) {
 970                                                                 pathDescriptionProperty = attrValue;
 971                                                                 //break;
 972                                                                 //System.out.println("found xml-element-wrapper " + xmlElementWrapper);
 973                                                         }
 974                                                         if ( attrValue.equals("indexedProps")) {
 975                                                                 useValue = VALUE_INDEXED_PROPS;
 976                                                         }
 977                                                         if ( useValue == VALUE_INDEXED_PROPS && attrName.equals("value")) {
 978                                                                 indexedProps = getIndexedProps( attrValue );
 979                                                         }
 980                                                 }
 981                                         }
 982                                 }
 983                         }
 984                 }
 985                 //System.out.println("javaTypeName " + javaTypeName + " description " + pathDescriptionProperty);
 986
 987                 /*
 988                 if ( javaTypeName.equals("RelationshipList")) {
 989                         System.out.println( "Skipping " + javaTypeName);
 990                         generatedJavaType.put(javaTypeName, null);
 991                         return "";
 992                 }
 993                 */
 994
 995                 Element parentElement = (Element)parentNodes.item(0);
 996                 NodeList xmlElementNodes = parentElement.getElementsByTagName("xml-element");
 997
 998
 999                 String attrDescription = null;
1000
1001                 Element xmlElementElement;
1002                 String addType = null;
1003                 String elementType = null, elementIsKey = null, elementIsRequired, elementContainerType = null;
1004                 String elementName = null;
1005                 StringBuffer sbParameters = new StringBuffer();
1006
1007                 StringBuffer sbRequired = new StringBuffer();
1008                 int requiredCnt = 0;
1009                 int propertyCnt = 0;
1010                 StringBuffer sbProperties = new StringBuffer();
1011                 StringBuffer sbIndexedParams = new StringBuffer();
1012
1013
1014                 StringTokenizer st;
1015                 if ( xmlRootElementName.equals("inventory"))
1016                         path = "";
1017                 else if ( path == null )
1018                         //path = "/aai/" + apiVersion;
1019                         path = "/" + xmlRootElementName;
1020                 else
1021                         path += "/" + xmlRootElementName;
1022                 st = new StringTokenizer(path, "/");
1023                 /*
1024                 if ( path.equals("/business/customers/customer/{global-customer-id}/service-subscriptions/service-subscription"))
1025                         System.out.println("processing path /business/customers/customer/{global-customer-id}/service-subscriptions with tag " + tag);
1026                 */
1027                 boolean genPath = false;
1028                 /*
1029                 if ( path != null && path.equals("/network/generic-vnfs/generic-vnf"))
1030                         System.out.println("path is " + "/network/generic-vnfs/generic-vnf");
1031                 */
1032                 if ( st.countTokens() > 1 && getItemName == null ) {
1033                         if ( appliedPaths.containsKey(path))
1034                                 return null;
1035                         appliedPaths.put(path, null);
1036                         genPath = true;
1037                         if ( path.contains("/relationship/") ) { // filter paths with relationship-list
1038                                 genPath = false;
1039                         }
1040                         if ( path.endsWith("/relationship-list")) {
1041                                 genPath = false;
1042                         }
1043
1044                 }
1045
1046                 Vector<String> addTypeV = null;
1047                 if (  xmlElementNodes.getLength() > 0 ) {
1048
1049                         for ( int i = 0; i < xmlElementNodes.getLength(); ++i ) {
1050                                 xmlElementElement = (Element)xmlElementNodes.item(i);
1051                                 if ( !xmlElementElement.getParentNode().isSameNode(parentElement))
1052                                         continue;
1053                                 /*childNodes = xmlElementElement.getElementsByTagName("xml-element-wrapper");
1054                                 if ( childNodes.getLength() > 0 ) {
1055                                         childElement = (Element)childNodes.item(0);
1056                                         // get name
1057                                         attributes = childElement.getAttributes();
1058                                         for ( int k = 0; k < attributes.getLength(); ++k ) {
1059                                                 Attr attr = (Attr) attributes.item(k);
1060                                                 String attrName = attr.getNodeName();
1061                                                 String attrValue = attr.getNodeValue();
1062                                                 if ( attrName.equals("name")) {
1063                                                         xmlElementWrapper = attrValue;
1064                                                         //System.out.println("found xml-element-wrapper " + xmlElementWrapper);
1065                                                 }
1066                                         }
1067
1068                                 }
1069                                 */
1070                                 valNodes = xmlElementElement.getElementsByTagName("xml-properties");
1071                                 attrDescription = null;
1072                                 if ( valNodes.getLength() > 0 ) {
1073                                         for ( int j = 0; j < valNodes.getLength(); ++j ) {
1074                                                 valElement = (Element)valNodes.item(j);
1075                                                 if ( !valElement.getParentNode().isSameNode(xmlElementElement))
1076                                                         continue;
1077                                                 childNodes = valElement.getElementsByTagName("xml-property");
1078                                                 if ( childNodes.getLength() > 0 ) {
1079                                                         childElement = (Element)childNodes.item(0);
1080                                                         // get name
1081                                                         attributes = childElement.getAttributes();
1082                                                         attrDescription = null;
1083                                                         boolean useValue = false;
1084                                                         for ( int k = 0; k < attributes.getLength(); ++k ) {
1085                                                                 Attr attr = (Attr) attributes.item(k);
1086                                                                 String attrName = attr.getNodeName();
1087                                                                 String attrValue = attr.getNodeValue();
1088                                                                 if ( attrName.equals("name") && attrValue.equals("description")) {
1089                                                                         useValue = true;
1090                                                                 }
1091                                                                 if ( useValue && attrName.equals("value")) {
1092                                                                         attrDescription = attrValue;
1093                                                                         //System.out.println("found xml-element-wrapper " + xmlElementWrapper);
1094                                                                 }
1095                                                         }
1096
1097                                                 }
1098                                         }
1099                                 }
1100
1101                                 attributes = xmlElementElement.getAttributes();
1102                                 addTypeV = null; // vector of 1
1103                                 addType = null;
1104
1105                                 elementName = elementType = elementIsKey = elementIsRequired = elementContainerType = null;
1106                                 for ( int j = 0; j < attributes.getLength(); ++j ) {
1107                             Attr attr = (Attr) attributes.item(j);
1108                             String attrName = attr.getNodeName();
1109
1110                             String attrValue = attr.getNodeValue();
1111                             //System.out.println("For " + xmlRootElementName + " Found xml-element attribute: " + attrName + " with value: " + attrValue);
1112                             if ( attrName.equals("name")) {
1113                                 elementName = attrValue;
1114
1115                             }
1116                             if ( attrName.equals("type") && getItemName == null ) {
1117                                 elementType = attrValue;
1118                                 if ( attrValue.contains(apiVersionFmt) ) {
1119                                         addType = attrValue.substring(attrValue.lastIndexOf('.')+1);
1120                                         if ( addTypeV == null )
1121                                                 addTypeV = new Vector<String>();
1122                                         addTypeV.add(addType);
1123                                 }
1124
1125                             }
1126                             if ( attrName.equals("xml-key")) {
1127                                 elementIsKey = attrValue;
1128                                 path += "/{" + elementName + "}";
1129                             }
1130                             if ( attrName.equals("required")) {
1131                                 elementIsRequired = attrValue;
1132                             }
1133                             if ( attrName.equals("container-type")) {
1134                                 elementContainerType = attrValue;
1135                             }
1136                                 }
1137                 if ( getItemName != null ) {
1138                         if ( getItemName.equals("array") ) {
1139                                 if ( elementContainerType != null && elementContainerType.equals("java.util.ArrayList")) {
1140                                         //System.out.println( " returning array " + elementName );
1141                                         return elementName;
1142                                 }
1143
1144                         } else { // not an array check
1145                                 if ( elementContainerType == null || !elementContainerType.equals("java.util.ArrayList")) {
1146                                         //System.out.println( " returning object " + elementName );
1147                                         return elementName;
1148                                 }
1149
1150                         }
1151                         //System.out.println( " returning null" );
1152                         return null;
1153                 }
1154                                 if ( elementIsRequired != null ) {
1155                                         if ( requiredCnt == 0 )
1156                                                 sbRequired.append("    required:\n");
1157                                         ++requiredCnt;
1158                                         if ( addTypeV != null ) {
1159                                                 for ( int k = 0; k < addTypeV.size(); ++i ) {
1160                                                         sbRequired.append("    - " + getXmlRootElementName(addTypeV.elementAt(k)) + ":\n");
1161                                                 }
1162                                         } else
1163                                                 sbRequired.append("    - " + elementName + "\n");
1164
1165                                 }
1166
1167                                 if (  elementIsKey != null )  {
1168                                                                                 sbParameters.append(("        - name: " + elementName + "\n"));
1169                                         sbParameters.append(("          in: path\n"));
1170                                         if ( attrDescription != null && attrDescription.length() > 0 )
1171                                                 sbParameters.append(("          description: " + attrDescription + "\n"));
1172                                         sbParameters.append(("          required: true\n"));
1173                                         if ( elementType.equals("java.lang.String"))
1174                                                 sbParameters.append("          type: string\n");
1175                                         if ( elementType.equals("java.lang.Long")) {
1176                                                 sbParameters.append("          type: integer\n");
1177                                                 sbParameters.append("          format: int64\n");
1178                                         }
1179                                         if ( elementType.equals("java.lang.Integer")) {
1180                                                 sbParameters.append("          type: integer\n");
1181                                                 sbParameters.append("          format: int32\n");
1182                                         }
1183                                         if ( elementType.equals("java.lang.Boolean"))
1184                                                 sbParameters.append("          type: boolean\n");
1185
1186
1187                                 } else if (  indexedProps != null
1188                                                 && indexedProps.contains(elementName ) ) {
1189                                         sbIndexedParams.append(("        - name: " + elementName + "\n"));
1190                                         sbIndexedParams.append(("          in: query\n"));
1191                                         if ( attrDescription != null && attrDescription.length() > 0 )
1192                                                 sbIndexedParams.append(("          description: " + attrDescription + "\n"));
1193                                         sbIndexedParams.append(("          required: false\n"));
1194                                         if ( elementType.equals("java.lang.String"))
1195                                                 sbIndexedParams.append("          type: string\n");
1196                                         if ( elementType.equals("java.lang.Long")) {
1197                                                 sbIndexedParams.append("          type: integer\n");
1198                                                 sbIndexedParams.append("          format: int64\n");
1199                                         }
1200                                         if ( elementType.equals("java.lang.Integer")) {
1201                                                 sbIndexedParams.append("          type: integer\n");
1202                                                 sbIndexedParams.append("          format: int32\n");
1203                                         }
1204                                         if ( elementType.equals("java.lang.Boolean"))
1205                                                 sbIndexedParams.append("          type: boolean\n");
1206                                 }
1207
1208                         /*
1209                         if ( elementName != null && elementName.equals("inventory-item"))
1210                                 System.out.println( "processing inventory-item elementName");
1211                         */
1212
1213                         if ( isStandardType(elementType)) {
1214                                 sbProperties.append("      " + elementName + ":\n");
1215                                 ++propertyCnt;
1216                                 sbProperties.append("        type: ");
1217
1218                                 if ( elementType.equals("java.lang.String"))
1219                                         sbProperties.append("string\n");
1220                                 else if ( elementType.equals("java.lang.Long")) {
1221                                         sbProperties.append("integer\n");
1222                                         sbProperties.append("        format: int64\n");
1223                                 }
1224                                 else if ( elementType.equals("java.lang.Integer")){
1225                                         sbProperties.append("integer\n");
1226                                         sbProperties.append("        format: int32\n");
1227                                 }
1228                                 else if ( elementType.equals("java.lang.Boolean"))
1229                                         sbProperties.append("boolean\n");
1230                                 if ( attrDescription != null && attrDescription.length() > 0 )
1231                                         sbProperties.append("        description: " + attrDescription + "\n");
1232                         }
1233
1234                         //if ( addType != null && elementContainerType != null && elementContainerType.equals("java.util.ArrayList") ) {
1235
1236                 if ( addTypeV !=  null ) {
1237                         StringBuffer newPathParams = null;
1238                         if ( pathParams != null  ) {
1239                                 newPathParams = new StringBuffer();
1240                                 newPathParams.append(pathParams);
1241                         }
1242                     if ( sbParameters.toString().length() > 0 ) {
1243                                         if ( newPathParams == null )
1244                                                 newPathParams = new StringBuffer();
1245                                         newPathParams.append(sbParameters);
1246                     }
1247                     String newQueryParams = null;
1248                     if ( sbIndexedParams.toString().length() > 0 ) {
1249                         if ( queryParams == null )
1250                                 newQueryParams = sbIndexedParams.toString();
1251                         else
1252                                 newQueryParams = queryParams + sbIndexedParams.toString();
1253                     } else {
1254                         newQueryParams = queryParams;
1255                     }
1256                         for ( int k = 0; k < addTypeV.size(); ++k ) {
1257                                 addType = addTypeV.elementAt(k);
1258
1259                                 if ( opId == null || !opId.contains(addType)) {
1260                                         processJavaTypeElementSwagger( addType, getJavaTypeElementSwagger(addType),
1261                                                 pathSb, definitionsSb, path,  tag == null ? useTag : tag, useOpId, null,
1262                                                 newPathParams, newQueryParams, validEdges);
1263                                 }
1264                                 // need item name of array
1265                                         String itemName = processJavaTypeElementSwagger( addType, getJavaTypeElementSwagger(addType),
1266                                                 pathSb, definitionsSb, path,  tag == null ? useTag : tag, useOpId,
1267                                                                 "array", null, null, null );
1268
1269                                         if ( itemName != null ) {
1270                                                 if ( addType.equals("AaiInternal") ) {
1271                                                         //System.out.println( "addType AaiInternal, skip properties");
1272
1273                                                 } else if ( getItemName == null) {
1274                                                         ++propertyCnt;
1275                                                         sbProperties.append("      " + getXmlRootElementName(addType) + ":\n");
1276                                                         sbProperties.append("        type: array\n        items:\n");
1277                                                         sbProperties.append("          $ref: \"#/definitions/" + itemName + "\"\n");
1278                                                         if ( attrDescription != null && attrDescription.length() > 0 )
1279                                                                 sbProperties.append("        description: " + attrDescription + "\n");
1280                                                 }
1281                                         } else {
1282                                                 /*itemName = processJavaTypeElementSwagger( addType, getJavaTypeElementSwagger(addType),
1283                                                         pathSb, definitionsSb, path,  tag == null ? useTag : tag, useOpId, "other" );
1284                                                 if ( itemName != null ) {
1285                                                 */
1286                                                 if ( elementContainerType != null && elementContainerType.equals("java.util.ArrayList")) {
1287                                                         // need properties for getXmlRootElementName(addType)
1288                                                 newPathParams = null;
1289                                                 if ( pathParams != null  ) {
1290                                                         newPathParams = new StringBuffer();
1291                                                         newPathParams.append(pathParams);
1292                                                 }
1293                                             if ( sbParameters.toString().length() > 0 ) {
1294                                                                 if ( newPathParams == null )
1295                                                                         newPathParams = new StringBuffer();
1296                                                                 newPathParams.append(sbParameters);
1297                                             }
1298                                             newQueryParams = null;
1299                                             if ( sbIndexedParams.toString().length() > 0 ) {
1300                                                 if ( queryParams == null )
1301                                                         newQueryParams = sbIndexedParams.toString();
1302                                                 else
1303                                                         newQueryParams = queryParams + sbIndexedParams.toString();
1304                                             } else {
1305                                                 newQueryParams = queryParams;
1306                                             }
1307                                                         processJavaTypeElementSwagger( addType, getJavaTypeElementSwagger(addType),
1308                                                                 pathSb, definitionsSb, path,  tag == null ? useTag : tag, useOpId,
1309                                                                                 null, newPathParams, newQueryParams, validEdges );
1310                                                         sbProperties.append("      " + getXmlRootElementName(addType) + ":\n");
1311                                                         sbProperties.append("        type: array\n        items:          \n");
1312                                                         sbProperties.append("          $ref: \"#/definitions/" + getXmlRootElementName(addType) + "\"\n");
1313                                                 } else {
1314                                                         sbProperties.append("      " + getXmlRootElementName(addType) + ":\n");
1315                                                         sbProperties.append("        type: object\n");
1316                                                         sbProperties.append("        $ref: \"#/definitions/" + getXmlRootElementName(addType) + "\"\n");
1317                                                 }
1318                                                 if ( attrDescription != null && attrDescription.length() > 0 )
1319                                                         sbProperties.append("        description: " + attrDescription + "\n");
1320                                                 ++propertyCnt;
1321                                                 /*}
1322                                                 else {
1323                                                         System.out.println(" unable to define swagger object for " + addType);
1324                                                 }
1325                                                 */
1326                                         }
1327                                         //if ( getItemName == null) looking for missing properties
1328                                                 //generatedJavaType.put(addType, null);
1329                         }
1330                 }
1331                 }
1332         }
1333                 if ( genPath ) {
1334                         /*
1335                         if ( useOpId.equals("CloudInfrastructureComplexesComplexCtagPools"))
1336                                 System.out.println( "adding path CloudInfrastructureComplexesComplexCtagPools");
1337                         */
1338
1339                         if ( !path.endsWith("/relationship") ) {
1340                                 pathSb.append("  " + path + ":\n" );
1341                                 pathSb.append("    get:\n");
1342                                 pathSb.append("      tags:\n");
1343                                 pathSb.append("        - " + tag + "\n");
1344                                 pathSb.append("      summary: returns " + xmlRootElementName + "\n");
1345
1346                                 pathSb.append("      description: returns " + xmlRootElementName + "\n");
1347                                 pathSb.append("      operationId: get" + useOpId + "\n");
1348                                 pathSb.append("      produces:\n");
1349                                 pathSb.append("        - application/json\n");
1350                                 pathSb.append("        - application/xml\n");
1351
1352                                 pathSb.append("      responses:\n");
1353                                 pathSb.append("        \"200\":\n");
1354                                 pathSb.append("          description: successful operation\n");
1355                                 pathSb.append("          schema:\n");
1356                                 pathSb.append("              $ref: \"#/definitions/" + xmlRootElementName + "\"\n");
1357                                 pathSb.append("        \"default\":\n");
1358                                 pathSb.append("          " + responsesUrl);
1359                                 /*
1360                                 pathSb.append("        \"200\":\n");
1361                                 pathSb.append("          description: successful operation\n");
1362                                 pathSb.append("          schema:\n");
1363                                 pathSb.append("              $ref: \"#/definitions/" + xmlRootElementName + "\"\n");
1364                                 pathSb.append("        \"404\":\n");
1365                                 pathSb.append("          description: resource was not found\n");
1366                                 pathSb.append("        \"400\":\n");
1367                                 pathSb.append("          description: bad request\n");
1368                                 */
1369                                 if ( path.indexOf('{') > 0 ) {
1370
1371                             if ( sbParameters.toString().length() > 0 ) {
1372                                                 if ( pathParams == null )
1373                                                         pathParams = new StringBuffer();
1374                                                 pathParams.append(sbParameters);
1375                             }
1376                                         if ( pathParams != null) {
1377                                                 pathSb.append("      parameters:\n");
1378                                                 pathSb.append(pathParams);
1379                                         } else
1380                                                 System.out.println( "null pathParams for " + useOpId);
1381                                         if ( sbIndexedParams.toString().length() > 0 ) {
1382                                                 if ( queryParams == null )
1383                                                         queryParams = sbIndexedParams.toString();
1384                                                 else
1385                                                         queryParams = queryParams + sbIndexedParams.toString();
1386                                         }
1387                                         if ( queryParams != null ) {
1388                                                 if ( pathParams == null ) {
1389                                                         pathSb.append("      parameters:\n");
1390                                                 }
1391                                                 pathSb.append(queryParams);
1392                                         }
1393                                 }
1394                         }
1395                         boolean skipPutDelete = false; // no put or delete for "all"
1396                         if ( !path.endsWith("/relationship") ) {
1397                                 if ( !path.endsWith("}") ){
1398                                                 skipPutDelete = true;
1399                                 }
1400
1401                         }
1402                         if ( path.indexOf('{') > 0 && !opId.startsWith("Search") &&!skipPutDelete) {
1403                                 // add PUT
1404                                 if ( path.endsWith("/relationship") ) {
1405                                         pathSb.append("  " + path + ":\n" );
1406                                 }
1407                                 pathSb.append("    put:\n");
1408                                 pathSb.append("      tags:\n");
1409                                 pathSb.append("        - " + tag + "\n");
1410
1411                                 if ( path.endsWith("/relationship") ) {
1412                                         pathSb.append("      summary: see node definition for valid relationships\n");
1413                                 } else {
1414                                         pathSb.append("      summary: create or update an existing " + xmlRootElementName + "\n");
1415                                         pathSb.append("      description: create or update an existing " + xmlRootElementName + "\n");
1416                                 }
1417                                 pathSb.append("      operationId: createOrUpdate" + useOpId + "\n");
1418                                 pathSb.append("      consumes:\n");
1419                                 pathSb.append("        - application/json\n");
1420                                 pathSb.append("        - application/xml\n");
1421                                 pathSb.append("      produces:\n");
1422                                 pathSb.append("        - application/json\n");
1423                                 pathSb.append("        - application/xml\n");
1424                                 pathSb.append("      responses:\n");
1425                                 pathSb.append("        \"default\":\n");
1426                                 pathSb.append("          " + responsesUrl);
1427                                 /*
1428                                 pathSb.append("      responses:\n");
1429                                 pathSb.append("        \"200\":\n");
1430                                 pathSb.append("          description: existing resource has been modified and there is a response buffer\n");
1431                                 pathSb.append("        \"201\":\n");
1432                                 pathSb.append("          description: new resource is created\n");
1433                                 pathSb.append("        \"202\":\n");
1434                                 pathSb.append("          description: action requested but may have taken other actions as well, which are returned in the response payload\n");
1435                                 pathSb.append("        \"204\":\n");
1436                                 pathSb.append("          description: existing resource has been modified and there is no response buffer\n");
1437                                 pathSb.append("        \"400\":\n");
1438                                 pathSb.append("          description: Bad Request will be returned if headers are missing\n");
1439                                 pathSb.append("        \"404\":\n");
1440                                 pathSb.append("          description: Not Found will be returned if an unknown URL is used\n");
1441                                 */
1442                                 pathSb.append("      parameters:\n");
1443                                 //pathSb.append("        - in: path\n");
1444                                 pathSb.append(pathParams); // for nesting
1445                                 pathSb.append("        - name: body\n");
1446                                 pathSb.append("          in: body\n");
1447                                 pathSb.append("          description: " + xmlRootElementName + " object that needs to be created or updated\n");
1448                                 pathSb.append("          required: true\n");
1449                                 pathSb.append("          schema:\n");
1450                                 pathSb.append("            $ref: \"#/definitions/" + xmlRootElementName + "\"\n");
1451                                 /*
1452                                 if ( queryParams != null ) {
1453                                         pathSb.append(queryParams);
1454                                 }
1455                                 */
1456                                 // add DELETE
1457                                 pathSb.append("    delete:\n");
1458                                 pathSb.append("      tags:\n");
1459                                 pathSb.append("        - " + tag + "\n");
1460                                 pathSb.append("      summary: delete an existing " + xmlRootElementName + "\n");
1461
1462                                 pathSb.append("      description: delete an existing " + xmlRootElementName + "\n");
1463
1464                                 pathSb.append("      operationId: delete" + useOpId + "\n");
1465                                 pathSb.append("      consumes:\n");
1466                                 pathSb.append("        - application/json\n");
1467                                 pathSb.append("        - application/xml\n");
1468                                 pathSb.append("      produces:\n");
1469                                 pathSb.append("        - application/json\n");
1470                                 pathSb.append("        - application/xml\n");
1471                                 pathSb.append("      responses:\n");
1472                                 pathSb.append("        \"default\":\n");
1473                                 pathSb.append("          " + responsesUrl);
1474                                 /*
1475                                 pathSb.append("      responses:\n");
1476                                 pathSb.append("        \"200\":\n");
1477                                 pathSb.append("          description: successful, the response includes an entity describing the status\n");
1478                                 pathSb.append("        \"204\":\n");
1479                                 pathSb.append("          description: successful, action has been enacted but the response does not include an entity\n");
1480                                 pathSb.append("        \"400\":\n");
1481                                 pathSb.append("          description: Bad Request will be returned if headers are missing\n");
1482                                 pathSb.append("        \"404\":\n");
1483                                 pathSb.append("          description: Not Found will be returned if an unknown URL is used\n");
1484                                 */
1485                                 pathSb.append("      parameters:\n");
1486                                 //pathSb.append("        - in: path\n");
1487                                 pathSb.append(pathParams); // for nesting
1488                                 if ( !path.endsWith("/relationship") ) {
1489                                         pathSb.append("        - name: resource-version\n");
1490
1491                                         pathSb.append("          in: query\n");
1492                                         pathSb.append("          description: resource-version for concurrency\n");
1493                                         pathSb.append("          required: true\n");
1494                                         pathSb.append("          type: string\n");
1495                                 }
1496                                 /*
1497                                 if ( queryParams != null ) {
1498                                         pathSb.append(queryParams);
1499                                 }
1500                                 */
1501                         }
1502
1503                 }
1504                 if ( generatedJavaType.containsKey(xmlRootElementName) ) {
1505                         return null;
1506                 }
1507
1508                 definitionsSb.append("  " + xmlRootElementName + ":\n");
1509                 Collection<EdgeDescription> edges = getEdgeRules(xmlRootElementName );
1510                 if ( edges.size() > 0 ) {
1511                         StringBuffer sbEdge = new StringBuffer();
1512                         sbEdge.append("      ###### Related Nodes\n");
1513                         for (EdgeDescription ed : edges) {
1514                                 if ( ed.getRuleKey().startsWith(xmlRootElementName)) {
1515                                     sbEdge.append("      - TO ").append(ed.getRuleKey().substring(ed.getRuleKey().indexOf("|")+1));
1516                                     sbEdge.append(ed.getRelationshipDescription("TO", xmlRootElementName));
1517                                     sbEdge.append("\n");
1518                                 }
1519                         }
1520                         for (EdgeDescription ed : edges) {
1521                                 if ( ed.getRuleKey().endsWith(xmlRootElementName)) {
1522                                     sbEdge.append("      - FROM ").append(ed.getRuleKey().substring(0, ed.getRuleKey().indexOf("|")));
1523                                     sbEdge.append(ed.getRelationshipDescription("FROM", xmlRootElementName));
1524                                     sbEdge.append("\n");
1525                                 }
1526                         }
1527                         validEdges = sbEdge.toString();
1528                 }
1529
1530                 String deleteRule = getDeleteRules(xmlRootElementName);
1531                 // Handle description property.  Might have a description OR valid edges OR both OR neither.
1532                 // Only put a description: tag if there is at least one.
1533                 if (pathDescriptionProperty != null || deleteRule != null || validEdges != null) {
1534                         definitionsSb.append("    description: |\n");
1535
1536                         if ( pathDescriptionProperty != null )
1537                                 definitionsSb.append("      " + pathDescriptionProperty + "\n" );
1538                         if (deleteRule != null)
1539                                 definitionsSb.append("      ###### Default Delete Scope\n      ").append(deleteRule).append("\n");
1540                         if (validEdges != null)
1541                                 definitionsSb.append(validEdges);
1542                 }
1543
1544                 if ( requiredCnt > 0 )
1545                         definitionsSb.append(sbRequired);
1546                 if ( propertyCnt > 0 ) {
1547                         definitionsSb.append("    properties:\n");
1548                         definitionsSb.append(sbProperties);
1549                 }
1550                 generatedJavaType.put(xmlRootElementName, null);
1551                 return null;
1552         }
1553
1554         public static String generateSwaggerFromOxmFile( File oxmFile )
1555         {
1556
1557                 StringBuffer sb = new StringBuffer();
1558                 sb.append("swagger: \"2.0\"\ninfo:\n  description:\n    A&AI REST API\n  version: \"" + apiVersion +"\"\n");
1559                 sb.append("  title: Active and Available Inventory REST API\n");
1560                 sb.append("  license:\n    name: Apache 2.0\n    url: http://www.apache.org/licenses/LICENSE-2.0.html\n");
1561                 sb.append("schemes:\n  - https\npaths:\n");
1562                 /*
1563                 sb.append("responses:\n");
1564                 sb.append("  \"200\":\n");
1565                 sb.append("    description: successful operation\n");
1566                 sb.append("  \"404\":\n");
1567                 sb.append("    description: resource was not found\n");
1568                 sb.append("  \"400\":\n");
1569                 sb.append("    description: bad request\n");
1570                 */
1571                 try {
1572
1573                         versionedClass = getEdgeRulesClass();
1574
1575                     DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
1576                     dbFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
1577                     DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
1578                     Document doc = dBuilder.parse(oxmFile);
1579
1580                     NodeList bindingsNodes = doc.getElementsByTagName("xml-bindings");
1581                         Element bindingElement;
1582                         NodeList javaTypesNodes;
1583                         Element javaTypesElement;
1584
1585                         Element javaTypeElement;
1586
1587
1588                         if ( bindingsNodes == null || bindingsNodes.getLength() == 0 ) {
1589                                 System.out.println( "missing <binding-nodes> in " + oxmFile );
1590                                 return null;
1591                         }
1592
1593                         bindingElement = (Element) bindingsNodes.item(0);
1594                         javaTypesNodes = bindingElement.getElementsByTagName("java-types");
1595                         if ( javaTypesNodes.getLength() < 1 ) {
1596                                 System.out.println( "missing <binding-nodes><java-types> in " + oxmFile );
1597                                 return null;
1598                         }
1599                         javaTypesElement = (Element) javaTypesNodes.item(0);
1600
1601                         javaTypeNodes = javaTypesElement.getElementsByTagName("java-type");
1602                         if ( javaTypeNodes.getLength() < 1 ) {
1603                                 System.out.println( "missing <binding-nodes><java-types><java-type> in " + oxmFile );
1604                                 return null;
1605                         }
1606
1607                         String javaTypeName;
1608                         String attrName, attrValue;
1609                         Attr attr;
1610                         StringBuffer pathSb = new StringBuffer();
1611
1612                         StringBuffer definitionsSb = new StringBuffer("definitions:\n");
1613
1614                         for ( int i = 0; i < javaTypeNodes.getLength(); ++ i ) {
1615                                 javaTypeElement = (Element) javaTypeNodes.item(i);
1616                                 NamedNodeMap attributes = javaTypeElement.getAttributes();
1617                                 javaTypeName = null;
1618                                 for ( int j = 0; j < attributes.getLength(); ++j ) {
1619                             attr = (Attr) attributes.item(j);
1620                             attrName = attr.getNodeName();
1621                             attrValue = attr.getNodeValue();
1622                             if ( attrName.equals("name"))
1623                                 javaTypeName = attrValue;
1624                                 }
1625                                 if ( javaTypeName == null ) {
1626                                         System.out.println( "<java-type> has no name attribute in " + oxmFile );
1627                                         return null;
1628                                 }
1629                                 if ( !generatedJavaType.containsKey(getXmlRootElementName(javaTypeName)) ) {
1630
1631                                         //generatedJavaType.put(javaTypeName, null);
1632                                         //if ( javaTypeName.equals("search")||javaTypeName.equals("actions"))
1633
1634                                         processJavaTypeElementSwagger( javaTypeName, javaTypeElement, pathSb,
1635                                                         definitionsSb, null, null, null, null, null, null, null);
1636                                 }
1637                         }
1638                         sb.append(pathSb);
1639                         //System.out.println( "definitions block\n" + definitionsSb.toString());
1640                         sb.append(definitionsSb.toString());
1641                         //sb.append(definitionsSb);
1642
1643                 } catch (Exception e) {
1644                         e.printStackTrace();
1645                         return null;
1646                 }
1647                 //System.out.println("generated " + sb.toString());
1648                 return sb.toString();
1649         }
1650
1651         private static NodeList locateXmlProperties(Element element) {
1652                 XPathExpression expr;
1653                 NodeList result = null;
1654                 try {
1655                         expr = xpath.compile("xml-properties");
1656                         if (expr != null) {
1657                                 Object nodeset = expr.evaluate(element, XPathConstants.NODESET);
1658                                 if (nodeset != null) {
1659                                         NodeList nodes = (NodeList) nodeset;
1660                                         if (nodes != null && nodes.getLength() > 0) {
1661                                                 Element xmlProperty = (Element)nodes.item(0);
1662                                                 result = xmlProperty.getElementsByTagName("xml-property");
1663                                         }
1664                                 }
1665                         }
1666                 } catch (XPathExpressionException e) {
1667                         e.printStackTrace();
1668                 }
1669                 return result;
1670
1671         }
1672 }