gerrit.onap Code Review - so.git/blob

   1 package org.onap.graphinventory.generate;
   2
   3 import java.util.ArrayList;
   4 import java.util.HashMap;
   5 import java.util.HashSet;
   6 import java.util.List;
   7 import java.util.Map;
   8 import java.util.Set;
   9 import java.util.regex.Matcher;
  10 import java.util.regex.Pattern;
  11 import java.util.stream.Collectors;
  12 import org.apache.maven.plugin.logging.Log;
  13 import com.fasterxml.jackson.core.JsonProcessingException;
  14 import com.fasterxml.jackson.databind.ObjectMapper;
  15 import io.swagger.models.Path;
  16 import io.swagger.models.Swagger;
  17 import io.swagger.models.parameters.Parameter;
  18 import io.swagger.models.parameters.SerializableParameter;
  19 import io.swagger.parser.SwaggerParser;
  20
  21 public class SwaggerConverter {
  22
  23     private final Log log;
  24
  25     public SwaggerConverter(Log log) {
  26         this.log = log;
  27     }
  28
  29     public Map<String, ObjectType> getDoc(String swaggerLocation) throws JsonProcessingException {
  30         Swagger swagger = new SwaggerParser().read(swaggerLocation);
  31
  32         Map<String, Path> paths = swagger.getPaths().entrySet().stream()
  33                 .filter(item -> !item.getKey().endsWith("/relationship-list/relationship"))
  34                 .collect(Collectors.toMap(item -> item.getKey(), item -> item.getValue()));
  35
  36         Pattern pluralPattern = Pattern.compile(".*(?<partial>/(?<name>[^{]*$))");
  37         Pattern singularPattern = Pattern.compile(".*(?<partial>/(?<name>[^/{}]*)/\\{.*$)");
  38         Pattern topLevelPattern = Pattern.compile("^/([^/]+)/.*");
  39         Pattern urlTemplatePattern = Pattern.compile("\\{([^}]+)\\}");
  40         Matcher pluralMatcher;
  41         Matcher singularMatcher;
  42         Matcher topLevelMatcher;
  43
  44         Map<String, ObjectType> output = new HashMap<>();
  45         for (Map.Entry<String, Path> entry : paths.entrySet()) {
  46
  47             pluralMatcher = pluralPattern.matcher(entry.getKey());
  48             singularMatcher = singularPattern.matcher(entry.getKey());
  49             topLevelMatcher = topLevelPattern.matcher(entry.getKey());
  50             ObjectType item;
  51             if (pluralMatcher.matches()) {
  52                 if (!output.containsKey(pluralMatcher.group("name"))) {
  53                     output.put(pluralMatcher.group("name"), new ObjectType());
  54                 }
  55                 item = output.get(pluralMatcher.group("name"));
  56                 item.setType("plural");
  57                 item.setName(pluralMatcher.group("name"));
  58                 item.setPartialUri(pluralMatcher.group("partial"));
  59                 item.getPaths().add(entry.getKey());
  60
  61                 if (topLevelMatcher.matches()) {
  62                     item.setTopLevel(topLevelMatcher.group(1));
  63                     if (!output.containsKey(topLevelMatcher.group(1))) {
  64                         output.put(topLevelMatcher.group(1), new ObjectType());
  65                         output.get(topLevelMatcher.group(1)).setType("top level");
  66                         output.get(topLevelMatcher.group(1)).setName(topLevelMatcher.group(1));
  67                         output.get(topLevelMatcher.group(1)).setPartialUri("/" + topLevelMatcher.group(1));
  68                         output.get(topLevelMatcher.group(1)).getPaths().add("/" + topLevelMatcher.group(1));
  69
  70                     }
  71                 }
  72             } else if (singularMatcher.matches()) {
  73
  74                 if (!output.containsKey(singularMatcher.group("name"))) {
  75                     output.put(singularMatcher.group("name"), new ObjectType());
  76
  77                     item = output.get(singularMatcher.group("name"));
  78
  79                     item.setType("singular");
  80                     item.setName(singularMatcher.group("name"));
  81                     item.setPartialUri(singularMatcher.group("partial"));
  82
  83                     item.getPaths().add(entry.getKey());
  84
  85                     if (topLevelMatcher.matches()) {
  86                         item.setTopLevel(topLevelMatcher.group(1));
  87                         if (!output.containsKey(topLevelMatcher.group(1))) {
  88                             output.put(topLevelMatcher.group(1), new ObjectType());
  89                             output.get(topLevelMatcher.group(1)).setType("top level");
  90                             output.get(topLevelMatcher.group(1)).setName(topLevelMatcher.group(1));
  91                             output.get(topLevelMatcher.group(1)).setPartialUri("/" + topLevelMatcher.group(1));
  92                             output.get(topLevelMatcher.group(1)).getPaths().add("/" + topLevelMatcher.group(1));
  93                         }
  94                     }
  95                     List<Parameter> parameters = entry.getValue().getGet().getParameters();
  96
  97                     if (parameters != null) {
  98                         parameters.stream().filter(param -> "path".equals(param.getIn())).collect(Collectors.toList());
  99                     }
 100                     for (Parameter p : parameters) {
 101                         ObjectField field = new ObjectField();
 102
 103                         field.setName(p.getName());
 104                         field.setType(((SerializableParameter) p).getType());
 105                         item.getFields().add(field);
 106                     }
 107
 108                 } else {
 109                     item = output.get(singularMatcher.group("name"));
 110                     if (singularMatcher.group("partial").contains(item.getName() + ".")) {
 111                         item.setPartialUri(singularMatcher.group("partial"));
 112                     }
 113                     item.getPaths().add(entry.getKey());
 114                 }
 115             }
 116
 117         }
 118         ObjectMapper mapper = new ObjectMapper();
 119
 120         for (ObjectType item : output.values()) {
 121             for (String path : item.getPaths()) {
 122                 String partialUriReplacer = item.getPartialUri().replaceAll("\\{[^}]+\\}", "[^/]+");
 123                 String childParentUri = path.replaceFirst(partialUriReplacer + "$", "");
 124                 for (ObjectType itemToUpdate : output.values()) {
 125                     if (itemToUpdate.getPaths().stream()
 126                             .anyMatch(itemToUpdateUri -> itemToUpdateUri.equals(childParentUri))) {
 127                         itemToUpdate.getChildren().add(item.getName());
 128                     }
 129                 }
 130             }
 131         }
 132
 133         log.debug(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(output));
 134
 135         for (Map.Entry<String, ObjectType> item : output.entrySet()) {
 136
 137             if (item.getValue().getType().equals("plural")) {
 138                 Set<String> children = item.getValue().getChildren();
 139                 // should only be one
 140                 if (!children.isEmpty()) {
 141                     item.getValue().setAdditionalName(children.iterator().next());
 142                 }
 143             }
 144             Set<String> pluralChildren = new HashSet<>();
 145             for (String child : item.getValue().getChildren()) {
 146                 if (output.get(child).getType().equals("plural")) {
 147                     Set<String> children = output.get(child).getChildren();
 148                     pluralChildren.addAll(children);
 149                 }
 150             }
 151             item.getValue().getChildren().addAll(pluralChildren);
 152
 153             if (item.getValue().getType().equals("plural")) {
 154                 for (String child : item.getValue().getChildren()) {
 155                     output.get(child)
 156                             .setPartialUri(item.getValue().getPartialUri() + output.get(child).getPartialUri());
 157                 }
 158             }
 159
 160             if (!item.getValue().getFields().isEmpty()) {
 161                 Matcher templates = urlTemplatePattern.matcher(item.getValue().getPartialUri());
 162                 List<String> localFields = new ArrayList<>();
 163                 while (templates.find()) {
 164                     localFields.add(templates.group(1));
 165                 }
 166                 item.getValue().setFields(item.getValue().getFields().stream()
 167                         .filter(f -> localFields.contains(f.getName())).collect(Collectors.toList()));
 168             }
 169         }
 170
 171         output.values().stream().filter(item -> item.getType().equals("plural"))
 172                 .forEach(item -> item.getChildren().clear());
 173
 174         return output;
 175     }
 176 }