UniqueInterfaceGenerator.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it).
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.utils.openapi;

  23. import java.io.File;
  24. import java.io.FileOutputStream;
  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.Iterator;
  28. import java.util.List;
  29. import java.util.Map;

  31. import org.apache.logging.log4j.Level;
  32. import org.openspcoop2.utils.LoggerWrapperFactory;
  33. import org.openspcoop2.utils.json.JSONUtils;
  34. import org.openspcoop2.utils.json.JsonPathExpressionEngine;
  35. import org.openspcoop2.utils.json.YAMLUtils;
  36. import org.openspcoop2.utils.resources.FileSystemUtilities;
  37. import org.openspcoop2.utils.rest.ApiFormats;
  38. import org.slf4j.Logger;

  40. import com.fasterxml.jackson.databind.JsonNode;

  42. import io.swagger.v3.oas.models.Components;
  43. import io.swagger.v3.oas.models.OpenAPI;
  44. import io.swagger.v3.oas.models.callbacks.Callback;
  45. import io.swagger.v3.oas.models.examples.Example;
  46. import io.swagger.v3.oas.models.headers.Header;
  47. import io.swagger.v3.oas.models.links.Link;
  48. import io.swagger.v3.oas.models.media.Schema;
  49. import io.swagger.v3.oas.models.parameters.Parameter;
  50. import io.swagger.v3.oas.models.parameters.RequestBody;
  51. import io.swagger.v3.oas.models.responses.ApiResponse;
  52. import io.swagger.v3.oas.models.security.SecurityScheme;
  53. import io.swagger.v3.parser.OpenAPIV3Parser;
  54. import io.swagger.v3.parser.converter.SwaggerConverter;
  55. import io.swagger.v3.parser.core.models.ParseOptions;
  56. import io.swagger.v3.parser.core.models.SwaggerParseResult;

  58. /**
  59.  * UniqueInterfaceGenerator
  60.  * 
  61.  * @author Andrea Poli (apoli@link.it)
  62.  * @author $Author$
  63.  * @version $Rev$, $Date$
  64.  */
  65. public class UniqueInterfaceGenerator {

  67.     public static void main(String[] args) throws Exception {
  68.         
  69.         LoggerWrapperFactory.setDefaultConsoleLogConfiguration(Level.ERROR);
  70.         
  71.         if(args==null || args.length<4) {
  72.             throw new Exception("Use: UniqueInterfaceGenerator <versioneOpenAPI> <destFile> <master> <attachmentsDir>");
  73.         }
  74.         
  75.         String tipo = args[0].trim();
  76.         ApiFormats format = ApiFormats.valueOf(tipo);
  77.         
  78.         String fileDest = args[1].trim();
  79.         
  80.         UniqueInterfaceGeneratorConfig config = new UniqueInterfaceGeneratorConfig(); 
  81.         config.format = format;
  82.         String fileMaster = args[2].trim();
  83.         config.master =  FileSystemUtilities.readFile(fileMaster);
  84.         File fMaster = new File(fileMaster);
  85.         String ext = null;
  86.         try{
  87.             ext = fileMaster.substring(fileMaster.lastIndexOf(".")+1,fileMaster.length());
  88.         }catch(Exception e){
  89.             // ext undefined
  90.         }
  91.         config.yaml = "yaml".equalsIgnoreCase(ext);
  92.         HashMap<String,String> attachments = new HashMap<>();
  93.         File fDir = new File(args[3].trim());
  94.         if(fDir.isDirectory()==false) {
  95.             throw new Exception("attachmentsDir ["+fDir.getAbsolutePath()+"] is not directory");
  96.         }
  97.         File[] files = fDir.listFiles();
  98.         if(files!=null) {
  99.             for (int j = 0; j < files.length; j++) {
  100.                 if(files[j].getName().equals(fMaster.getName())) {
  101.                     continue;
  102.                 }
  103.                 if(files[j].isDirectory()) {
  104.                     continue;
  105.                 }
  106.                 //System.out.println("READ ["+files[j]+"] ... ");
  107.                 attachments.put(files[j].getName(), FileSystemUtilities.readFile(files[j]));
  108.                 //System.out.println("READ ["+files[j]+"] ok");
  109.             }
  110.         }
  111.         config.attachments = attachments;
  112.         
  113.         List<String> blackListParameters = null;
  114.         List<String> blackListComponents = null;
  115.         if(args.length>5) {
  116.             
  117.             String blackListParametersArgs = args[4].trim();
  118.             if(blackListParametersArgs!=null) {
  119.                 blackListParameters = new ArrayList<>();
  120.                 if(blackListParametersArgs.contains(",")) {
  121.                     String [] tmp = blackListParametersArgs.split(",");
  122.                     for (String s : tmp) {
  123.                         blackListParameters.add(s);
  124.                     }
  125.                 }else {
  126.                     blackListParameters.add(blackListParametersArgs);
  127.                 }
  128.             }
  129.             
  130.             String blackListComponentsArgs = args[5].trim();
  131.             if(blackListComponentsArgs!=null) {
  132.                 blackListComponents = new ArrayList<>();
  133.                 if(blackListComponentsArgs.contains(",")) {
  134.                     String [] tmp = blackListComponentsArgs.split(",");
  135.                     for (String s : tmp) {
  136.                         blackListComponents.add(s);
  137.                     }
  138.                 }else {
  139.                     blackListComponents.add(blackListComponentsArgs);
  140.                 }
  141.             }
  142.             
  143.         }
  144.         
  145.         generate(fileDest, config, blackListParameters, blackListComponents, true, null);
  146.     }

  148.     private static void debug(boolean debug, Logger log, String msg) {
  149.         if(debug) {
  150.             if(log!=null) {
  151.                 log.debug(msg); 
  152.             }
  153.             else {
  154.                 System.out.println(msg);
  155.             }
  156.         }
  157.     }
  158.     
  159.     public static void generate(String fileDest, UniqueInterfaceGeneratorConfig config, 
  160.             List<String> blackListParameters, List<String> blackListComponents,
  161.             boolean debug, Logger log) throws Exception {
  162.         String schemaRebuild = generate(config, blackListParameters, blackListComponents, debug, log);
  163.         try(FileOutputStream fout = new FileOutputStream(fileDest)){
  164.             fout.write(schemaRebuild.getBytes());
  165.             fout.flush();
  166.         }
  167.     }
  168.     public static String generate(UniqueInterfaceGeneratorConfig config, 
  169.             List<String> blackListParameters, List<String> blackListComponents,
  170.             boolean debug, Logger log) throws Exception {
  171.         
  172.         SwaggerParseResult pr = null;
  173.         ParseOptions parseOptions = new ParseOptions();
  174.         
  175.         if(ApiFormats.SWAGGER_2.equals(config.format)) {
  176.             pr = new SwaggerConverter().readContents(config.master, null, parseOptions);    
  177.         }
  178.         else {
  179.             pr = new OpenAPIV3Parser().readContents(config.master, null, parseOptions);
  180.         }
  181.         StringBuilder sbParseWarningResult = new StringBuilder();
  182.         OpenAPI api = AbstractOpenapiApiReader.parseResult(LoggerWrapperFactory.getLogger(UniqueInterfaceGenerator.class), pr, sbParseWarningResult);
  183.         if(api.getComponents()==null) {
  184.             api.setComponents(new Components());
  185.         }
  186.         
  187.         Map<String,String> attachments = config.attachments;
  188.         Iterator<String> attachmentNames = attachments.keySet().iterator();
  189.         while (attachmentNames.hasNext()) {
  190.             String attachName = (String) attachmentNames.next();
  191.             String attach = attachments.get(attachName);
  192.         
  193.             debug(debug,log,"Merge ["+attachName+"] ...");
  194.             if(ApiFormats.SWAGGER_2.equals(config.format)) {
  195.                 pr = new SwaggerConverter().readContents(attach, null, parseOptions);   
  196.             }
  197.             else {
  198.                 pr = new OpenAPIV3Parser().readContents(attach, null, parseOptions);
  199.             }
  200.             OpenAPI apiInternal = AbstractOpenapiApiReader.parseResult(LoggerWrapperFactory.getLogger(UniqueInterfaceGenerator.class), pr, sbParseWarningResult);
  201.             if(apiInternal.getComponents()!=null) {
  202.                 if(apiInternal.getComponents().getCallbacks()!=null) {
  203.                     Map<String, Callback> maps = apiInternal.getComponents().getCallbacks();
  204.                     int mapsSize = 0;
  205.                     if(maps!=null && !maps.isEmpty()) {
  206.                         mapsSize = maps.size();
  207.                         Iterator<String> keys = maps.keySet().iterator();
  208.                         while (keys.hasNext()) {
  209.                             String key = (String) keys.next();
  210.                             Callback value = maps.get(key);
  211.                             api.getComponents().addCallbacks(key, value);
  212.                         }
  213.                     }
  214.                     debug(debug,log,"\t"+mapsSize+" callback");
  215.                 }
  216.                 if(apiInternal.getComponents().getExamples()!=null) {
  217.                     Map<String, Example> maps = apiInternal.getComponents().getExamples();
  218.                     int mapsSize = 0;
  219.                     if(maps!=null && !maps.isEmpty()) {
  220.                         mapsSize = maps.size();
  221.                         Iterator<String> keys = maps.keySet().iterator();
  222.                         while (keys.hasNext()) {
  223.                             String key = (String) keys.next();
  224.                             Example value = maps.get(key);
  225.                             api.getComponents().addExamples(key, value);
  226.                         }
  227.                     }
  228.                     debug(debug,log,"\t"+mapsSize+" example");
  229.                 }
  230.                 if(apiInternal.getComponents().getExtensions()!=null) {
  231.                     Map<String, Object> maps = apiInternal.getComponents().getExtensions();
  232.                     int mapsSize = 0;
  233.                     if(maps!=null && !maps.isEmpty()) {
  234.                         mapsSize = maps.size();
  235.                         Iterator<String> keys = maps.keySet().iterator();
  236.                         while (keys.hasNext()) {
  237.                             String key = (String) keys.next();
  238.                             Object value = maps.get(key);
  239.                             api.getComponents().addExtension(key, value);
  240.                         }
  241.                     }
  242.                     debug(debug,log,"\t"+mapsSize+" extensions");
  243.                 }
  244.                 if(apiInternal.getComponents().getHeaders()!=null) {
  245.                     Map<String, Header> maps = apiInternal.getComponents().getHeaders();
  246.                     int mapsSize = 0;
  247.                     if(maps!=null && !maps.isEmpty()) {
  248.                         mapsSize = maps.size();
  249.                         Iterator<String> keys = maps.keySet().iterator();
  250.                         while (keys.hasNext()) {
  251.                             String key = (String) keys.next();
  252.                             Header value = maps.get(key);
  253.                             api.getComponents().addHeaders(key, value);
  254.                         }
  255.                     }
  256.                     debug(debug,log,"\t"+mapsSize+" header");
  257.                 }
  258.                 if(apiInternal.getComponents().getLinks()!=null) {
  259.                     Map<String, Link> maps = apiInternal.getComponents().getLinks();
  260.                     int mapsSize = 0;
  261.                     if(maps!=null && !maps.isEmpty()) {
  262.                         mapsSize = maps.size();
  263.                         Iterator<String> keys = maps.keySet().iterator();
  264.                         while (keys.hasNext()) {
  265.                             String key = (String) keys.next();
  266.                             Link value = maps.get(key);
  267.                             api.getComponents().addLinks(key, value);
  268.                         }
  269.                     }
  270.                     debug(debug,log,"\t"+mapsSize+" link");
  271.                 }
  272.                 if(apiInternal.getComponents().getParameters()!=null) {
  273.                     Map<String, Parameter> maps = apiInternal.getComponents().getParameters();
  274.                     int mapsSize = 0;
  275.                     if(maps!=null && !maps.isEmpty()) {
  276.                         mapsSize = maps.size();
  277.                         Iterator<String> keys = maps.keySet().iterator();
  278.                         while (keys.hasNext()) {
  279.                             String key = (String) keys.next();
  280.                             if(blackListParameters!=null && blackListParameters.contains(key)) {
  281.                                 debug(debug,log,"Parameter '"+key+"' skipped");
  282.                                 continue;
  283.                             }
  284.                             Parameter value = maps.get(key);
  285.                             api.getComponents().addParameters(key, value);
  286.                         }
  287.                     }
  288.                     debug(debug,log,"\t"+mapsSize+" parameter");
  289.                 }
  290.                 if(apiInternal.getComponents().getRequestBodies()!=null) {
  291.                     Map<String, RequestBody> maps = apiInternal.getComponents().getRequestBodies();
  292.                     int mapsSize = 0;
  293.                     if(maps!=null && !maps.isEmpty()) {
  294.                         mapsSize = maps.size();
  295.                         Iterator<String> keys = maps.keySet().iterator();
  296.                         while (keys.hasNext()) {
  297.                             String key = (String) keys.next();
  298.                             RequestBody value = maps.get(key);
  299.                             api.getComponents().addRequestBodies(key, value);
  300.                         }
  301.                     }
  302.                     debug(debug,log,"\t"+mapsSize+" requestBody");
  303.                 }
  304.                 if(apiInternal.getComponents().getResponses()!=null) {
  305.                     Map<String, ApiResponse> maps = apiInternal.getComponents().getResponses();
  306.                     int mapsSize = 0;
  307.                     if(maps!=null && !maps.isEmpty()) {
  308.                         mapsSize = maps.size();
  309.                         Iterator<String> keys = maps.keySet().iterator();
  310.                         while (keys.hasNext()) {
  311.                             String key = (String) keys.next();
  312.                             ApiResponse value = maps.get(key);
  313.                             api.getComponents().addResponses(key, value);
  314.                         }
  315.                     }
  316.                     debug(debug,log,"\t"+mapsSize+"] response");
  317.                 }
  318.                 if(apiInternal.getComponents().getSchemas()!=null) {
  319.                     @SuppressWarnings("rawtypes")
  320.                     Map<String, Schema> maps = apiInternal.getComponents().getSchemas();
  321.                     int mapsSize = 0;
  322.                     if(maps!=null && !maps.isEmpty()) {
  323.                         mapsSize = maps.size();
  324.                         Iterator<String> keys = maps.keySet().iterator();
  325.                         while (keys.hasNext()) {
  326.                             String key = (String) keys.next();
  327.                             if(blackListComponents!=null && blackListComponents.contains(key)) {
  328.                                 debug(debug,log,"Component '"+key+"' skipped");
  329.                                 continue;
  330.                             }
  331.                             Schema<?> value = maps.get(key);
  332.                             api.getComponents().addSchemas(key, value);
  333.                         }
  334.                     }
  335.                     debug(debug,log,"\t"+mapsSize+" schema");
  336.                 }
  337.                 if(apiInternal.getComponents().getSecuritySchemes()!=null) {
  338.                     Map<String, SecurityScheme> maps = apiInternal.getComponents().getSecuritySchemes();
  339.                     int mapsSize = 0;
  340.                     if(maps!=null && !maps.isEmpty()) {
  341.                         mapsSize = maps.size();
  342.                         Iterator<String> keys = maps.keySet().iterator();
  343.                         while (keys.hasNext()) {
  344.                             String key = (String) keys.next();
  345.                             SecurityScheme value = maps.get(key);
  346.                             api.getComponents().addSecuritySchemes(key, value);
  347.                         }
  348.                     }
  349.                     debug(debug,log,"\t"+mapsSize+" security schema");
  350.                 }
  351.             }
  352.             debug(debug,log,"Merge ["+attachName+"] ok");
  353.         }
  354.         
  355.         // clean attributi non permessi in swagger editor
  356.         api.setExtensions(null);
  357.         api.getComponents().setExtensions(null);
  358.         if(api.getComponents().getHeaders()!=null) {
  359.             Map<String, Header> maps = api.getComponents().getHeaders();
  360.             if(maps!=null && !maps.isEmpty()) {
  361.                 Iterator<String> keys = maps.keySet().iterator();
  362.                 while (keys.hasNext()) {
  363.                     String key = (String) keys.next();
  364.                     Header value = maps.get(key);
  365.                     value.setExplode(null);
  366.                     value.setStyle(null);
  367.                 }
  368.             }
  369.         }
  370.         if(api.getComponents().getParameters()!=null) {
  371.             Map<String, Parameter> maps = api.getComponents().getParameters();
  372.             if(maps!=null && !maps.isEmpty()) {
  373.                 Iterator<String> keys = maps.keySet().iterator();
  374.                 while (keys.hasNext()) {
  375.                     String key = (String) keys.next();
  376.                     Parameter value = maps.get(key);
  377.                     value.setExplode(null);
  378.                     value.setStyle(null);
  379.                     //debug(debug,log,"PARAMETRO *"+key+"* ["+value.getName()+"] ["+value.getExample()+"] ["+value.getExamples()+"] ref["+value.get$ref()+"] tipo["+value.getClass().getName()+"]");
  380.                     checkSchema(0,("Parameter-"+key), value.getSchema());
  381.                 }
  382.             }
  383.         }
  384.         if(api.getComponents().getSchemas()!=null) {
  385.             @SuppressWarnings("rawtypes")
  386.             Map<String, Schema> maps = api.getComponents().getSchemas();
  387.             if(maps!=null && !maps.isEmpty()) {
  388.                 Iterator<String> keys = maps.keySet().iterator();
  389.                 while (keys.hasNext()) {
  390.                     String key = (String) keys.next();
  391.                     Schema<?> value = maps.get(key);
  392.                     String sorgente = "";
  393.                     if(value.getName()!=null) {
  394.                         sorgente = sorgente + value.getName();
  395.                     }
  396.                     else {
  397.                         sorgente = sorgente + "RootSchema";
  398.                     }
  399.                     checkSchema(0, sorgente, value);    
  400.                 }
  401.             }
  402.         }
  403.         
  404.         JsonNode jsonNode = null;
  405.         String s = null;
  406.         if(config.yaml) {
  407.             s = YAMLUtils.getObjectWriter().writeValueAsString(api);
  408.             jsonNode = YAMLUtils.getInstance().getAsNode(s);
  409.         }
  410.         else {
  411.             s = JSONUtils.getObjectWriter().writeValueAsString(api);
  412.             jsonNode = JSONUtils.getInstance().getAsNode(s);
  413.         }
  414.         
  415.         JsonPathExpressionEngine engine = new JsonPathExpressionEngine();
  416.         List<String> refPath = engine.getStringMatchPattern(jsonNode, "$..$ref");
  417.         String schemaRebuild = s;
  418.         
  419.         // Faccio due passate, prima con i caratteri " e ' in modo da risolvere le ref precisamente,
  420.         // poiche' l'algoritmo e' soggetto a problemi quando ci sono nomi inclusi in altri ref. Es.:
  421.         // test.yaml#...
  422.         // http://test/test.yaml#....
  423.         schemaRebuild = replace(refPath, schemaRebuild, true);
  424.         schemaRebuild = replace(refPath, schemaRebuild, false);
  425.             
  426.         /*
  427.         Object oDescr = engine.getMatchPattern(jsonNode, "$.info.description", JsonPathReturnType.NODE);
  428.         if(oDescr!=null) {
  429.             String descr = null;
  430.             if(oDescr instanceof List<?>) {
  431.                 @SuppressWarnings("unchecked")
  432.                 List<String> l = (List<String>) oDescr;
  433.                 if(!l.isEmpty()) {
  434.                     descr = l.get(0);
  435.                 }
  436.             }
  437.             else if(oDescr instanceof String) {
  438.                 descr = (String) oDescr;
  439.             }
  440.             else if(oDescr instanceof JsonNode) {
  441.                 JsonNode jN = (JsonNode) oDescr;
  442.                 descr = jN.asText();
  443.             }
  444.             else {
  445.                 debug(debug,log,"Description type unknown ["+oDescr.getClass().getName()+"]");
  446.             }
  447.             if(descr!=null && org.apache.commons.lang.StringUtils.isNotEmpty(descr)) {
  448.                 schemaRebuild = schemaRebuild.replace("info:", "info:\n  x-summary: \""+descr+"\"");
  449.             }
  450.         }
  451.         */
  452.         
  453.         if(schemaRebuild.startsWith("---")) {
  454.             schemaRebuild = schemaRebuild.substring("---".length());
  455.         }
  456.         if(schemaRebuild.startsWith("\n")) {
  457.             schemaRebuild = schemaRebuild.substring("\n".length());
  458.         }
  459.         
  460.         String extensions = "extensions:\n" +"    ";
  461.         schemaRebuild = schemaRebuild.replace(extensions, "");
  462.         String ext = "    x-";
  463.         String extCorrect = "  x-";
  464.         while(schemaRebuild.contains(ext)) {
  465.             schemaRebuild = schemaRebuild.replace(ext, extCorrect);
  466.         }
  467.         
  468.         return schemaRebuild;
  469.         
  470.     }

  472.     private static String replace(List<String> refPath, String schemaRebuild, boolean usePrefixChar) {
  473.         if(refPath!=null && !refPath.isEmpty()) {
  474.             for (String ref : refPath) {
  475.                 
  476.                 //System.out.println("...............ANALIZZO REF ["+ref+"]");
  477.                 
  478.                 if(schemaRebuild.contains(ref)) {
  479.                     
  480.                     //System.out.println(" PROCESS ["+ref+"]");
  481.                     
  482.                     if(ref.startsWith("#")==false) {
  483.                         
  484.                         //System.out.println(" PROCESS INTERNAL ["+ref+"]");
  485.                         
  486.                         String destra = ref.substring(ref.indexOf("#"));
  487.                         String refForReplace = ref;
  488.                         
  489.                         //System.out.println("destra ["+destra+"]");
  490.                         //System.out.println("destra ["+refForReplace+"]");
  491.                         
  492.                         if(usePrefixChar) {
  493.                             String rep = "\""+refForReplace+"\"";
  494.                             String destraRep = "\""+destra+"\"";
  495.                             while(schemaRebuild.contains(rep)) {
  496.                                 schemaRebuild = schemaRebuild.replace(rep, destraRep);
  497.                             }
  498.                             rep = "'"+refForReplace+"'";
  499.                             destraRep = "'"+destra+"'";
  500.                             while(schemaRebuild.contains(rep)) {
  501.                                 schemaRebuild = schemaRebuild.replace(rep, destraRep);
  502.                             }
  503.                         }
  504.                         else {
  505.                             while(schemaRebuild.contains(refForReplace)) {
  506.                                 schemaRebuild = schemaRebuild.replace(refForReplace, destra);
  507.                             }
  508.                         }
  509.                         
  510.                         if(refForReplace.startsWith("./") && refForReplace.length()>2) {
  511.                             
  512.                             //System.out.println("CASO SPECIALE!");
  513.                             
  514.                             refForReplace = refForReplace.substring(2);
  515.                             
  516.                             if(usePrefixChar) {
  517.                                 String rep = "\""+refForReplace+"\"";
  518.                                 String destraRep = "\""+destra+"\"";
  519.                                 while(schemaRebuild.contains(rep)) {
  520.                                     schemaRebuild = schemaRebuild.replace(rep, destraRep);
  521.                                 }
  522.                                 rep = "'"+refForReplace+"'";
  523.                                 destraRep = "'"+destra+"'";
  524.                                 while(schemaRebuild.contains(rep)) {
  525.                                     schemaRebuild = schemaRebuild.replace(rep, destraRep);
  526.                                 }
  527.                             }
  528.                             else {
  529.                                 while(schemaRebuild.contains(refForReplace)) {
  530.                                     schemaRebuild = schemaRebuild.replace(refForReplace, destra);
  531.                                 }
  532.                             }
  533.                         }
  534.                         
  535.                     }
  536.                 }
  537.             }
  538.         }
  539.         return schemaRebuild;
  540.     }
  541.     
  542.     private static int checkSchema(int profondita, String sorgente, Schema<?> schema) {
  543.         
  544.         if(profondita>1000) {
  545.             return profondita; // evitare stack overflow
  546.         }
  547.         
  548.         @SuppressWarnings("rawtypes")
  549.         Map<String, Schema> properties = schema.getProperties();
  550.         if(properties!=null && !properties.isEmpty()) {
  551.             for (String key : properties.keySet()) {
  552.                 Schema<?> value = properties.get(key);
  553.                 String sorgenteInterno = sorgente+".";
  554.                 if(value.getName()!=null) {
  555.                     sorgenteInterno = sorgenteInterno + value.getName();
  556.                 }
  557.                 else {
  558.                     sorgenteInterno = sorgenteInterno + "schemaProfondita"+profondita;
  559.                 }
  560.                 //debug(debug,log,"SCHEMA ("+sorgente+") *"+key+"* ["+value.getName()+"] ["+value.getType()+"] ["+value.getFormat()+"] ["+value.getExample()+"] ref["+value.get$ref()+"] schema["+value.getClass().getName()+"]");
  561.                 @SuppressWarnings("unused")
  562.                 int p = checkSchema((profondita+1),sorgenteInterno,value);
  563.             }
  564.         }
  565.         
  566.         return profondita;
  567.     }
  568.     
  569. }
Created with JaCoCo 0.8.8.202204050719