ApiUtilities.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.rest.api;

  23. import java.net.URI;
  24. import java.net.URL;
  25. import java.util.ArrayList;
  26. import java.util.List;

  28. import org.openspcoop2.utils.beans.BaseBean;
  29. import org.openspcoop2.utils.rest.ProcessingException;
  30. import org.openspcoop2.utils.rest.ValidatorException;
  31. import org.openspcoop2.utils.transport.http.HttpRequestMethod;

  33. /**
  34.  * ApiOperation
  35.  *
  36.  *
  37.  * @author Poli Andrea (apoli@link.it)
  38.  * @author $Author$
  39.  * @version $Rev$, $Date$
  40.  */
  41. public class ApiUtilities extends BaseBean {

  43.     private static final long serialVersionUID = 1L;
  44.     
  45.     private static List<String> _static_list_characters = new ArrayList<>();
  46.     static {
  47.         for (int i = 'A'; i <= 'Z'; i++) {
  48.             _static_list_characters.add(((char)i)+"");
  49.         }
  50.         for (int i = 'a'; i <= 'z'; i++) {
  51.             _static_list_characters.add(((char)i)+"");
  52.         }
  53.         String chars = ".-_*;:";
  54.         char[] cs = chars.toCharArray();
  55.         for (int i = 0; i < cs.length; i++) {
  56.             _static_list_characters.add(cs[i]+"");
  57.         }
  58.     }
  59.     
  60.     public static void validatePath(String path) throws ValidatorException {
  61.         if(path.contains("{") || path.contains("}") ) {
  62.             
  63.             if(path.contains("{") && !path.contains("}") ) {
  64.                 throw new ValidatorException("Dynamic path '{' without closing '}' ") ;
  65.             }
  66.             if(!path.contains("{") && path.contains("}") ) {
  67.                 throw new ValidatorException("Dynamic path '}' without opening '{' ") ;
  68.             }
  69.             int countOpen = 0;
  70.             int countClose = 0;
  71.             boolean open = false;
  72.             for (int i = 0; i < path.length(); i++) {
  73.                 String charAt = path.charAt(i)+"";
  74.                 if(charAt.equals("{")) {
  75.                     countOpen++;
  76.                     open = true;
  77.                 }
  78.                 else if(charAt.equals("}")) {
  79.                     if(!open) {
  80.                         throw new ValidatorException("Dynamic path malformed; found '}' before '{'") ;
  81.                     }
  82.                     open = false;
  83.                     countClose++;
  84.                 }
  85.             }
  86.             if(countOpen != countClose) {
  87.                 throw new ValidatorException("Dynamic path malformed; found "+countOpen+" '{' and "+countClose+" closing '}' ") ;
  88.             }
  89.             
  90.             String specialCharStart = null;
  91.             String specialCharEnd = null;
  92.             for (String check : _static_list_characters) {
  93.                 if(path.contains(check)==false) {
  94.                     if(specialCharStart==null) {
  95.                         specialCharStart = check;
  96.                     }
  97.                     else if(specialCharEnd==null) {
  98.                         specialCharEnd = check;
  99.                         break;
  100.                     } 
  101.                 }
  102.             }
  103.             String pathConverted = new String(path);
  104.             while(pathConverted.contains("{")){
  105.                 pathConverted = pathConverted.replace("{", specialCharStart);
  106.             }
  107.             while(pathConverted.contains("}")){
  108.                 pathConverted = pathConverted.replace("}", specialCharStart);
  109.             }
  110.             
  111. //          System.out.println("SPECIAL START: "+specialCharStart);
  112. //          System.out.println("SPECIAL END: "+specialCharEnd);
  113. //          System.out.println("SPECIAL pathConverted: "+pathConverted);
  114.             
  115.             try {
  116.                 URI.create(pathConverted);
  117.                 //System.out.println("VALIDATE PATH ("+path+")");
  118.             }catch(Exception e) {
  119.                 //System.out.println("ERRORE ORIGINALE: "+e.getMessage());
  120.                 String msg = e.getMessage();
  121.                 while(msg.contains(pathConverted)) {
  122.                     msg = msg.replace(pathConverted, path);
  123.                 }
  124.                 //System.out.println("ERRORE CONVERTITO: "+msg);
  125.                 throw new ValidatorException("Dynamic path malformed; "+msg,e);
  126.             }
  127.         }
  128.         else {
  129.             try {
  130.                 URI.create(path);
  131.             }catch(Exception e) {
  132.                 throw new ValidatorException("Path malformed; "+e.getMessage(),e);
  133.             }
  134.         }
  135.     }
  136.     
  137.     
  138.     public static ApiOperation findOperation(Api api, HttpRequestMethod httpMethod, String url, boolean exactlyLength) throws ProcessingException{

  140.         String[] urlList = extractUrlList(api.getBaseURL(), url);

  142.         return getOperation(urlList, api, httpMethod, exactlyLength);
  143.     }
  144.     public static String[] extractUrlList(URL baseURI, String url) throws ProcessingException{
  145.         if(url == null)
  146.             throw new ProcessingException("URL non fornita");

  148.         List<String> urlList = new ArrayList<>();

  150.         if(baseURI != null) {
  151.             if(url.startsWith(baseURI.toString())) {
  152.                 url = url.substring(baseURI.toString().length(), url.length());
  153.             }
  154.         }

  156.         for(String s : url.split("/")) {
  157.             if(s!=null && !s.equals("")) {
  158.                 urlList.add(s);
  159.             }
  160.         }

  162.         return urlList.toArray(new String[] {});

  164.     }
  165.     
  166.     private static ApiOperation getOperation(List<ApiOperation> list, String[] url, HttpRequestMethod httpMethod, boolean exactlyLength) throws ProcessingException{
  167.         int levelExactlyMatch = -1;
  168.         int levelDinamicMatch = -1;
  169.         ApiOperation apiOpExactlyMatch = null; 
  170.         ApiOperation apiOpDynamicMatch = null; 
  171.         for(int i = 0; i< list.size(); i++) {
  172.             
  173.             ApiOperation apiOp = list.get(i);
  174.             
  175.             if(apiOp.getHttpMethod()!=null) {
  176.                 if(!apiOp.getHttpMethod().equals(httpMethod)){
  177.                     continue;
  178.                 }
  179.             }
  180.             if(url.length<apiOp.sizePath()){
  181.                 continue;
  182.             }
  183.             int counterMatch = 0;
  184.             boolean exactlyMatch = true;
  185.             boolean dynamicMatch = true;
  186.             for (int j = 0; j < apiOp.sizePath(); j++) {
  187.                 String path = null;
  188.                 try{
  189.                     path = apiOp.getPath(j);
  190.                 }catch(ProcessingException pe){}
  191.                 if(path!=null && !path.equalsIgnoreCase(url[j])){
  192.                     exactlyMatch = false;
  193.                     if(!apiOp.isDynamicPath(j)){
  194.                         dynamicMatch = false;
  195.                         break;
  196.                     }
  197.                 }
  198.                 counterMatch++;
  199.             }
  200.             if(exactlyMatch){
  201.                 if(counterMatch>levelExactlyMatch){
  202.                     levelExactlyMatch=counterMatch;
  203.                     apiOpExactlyMatch = apiOp;
  204.                 }
  205.             }
  206.             else if(dynamicMatch){
  207.                 // dynamic
  208.                 if(counterMatch>levelDinamicMatch){
  209.                     levelDinamicMatch=counterMatch;
  210.                     apiOpDynamicMatch = apiOp;
  211.                 }
  212.             }
  213.             
  214.         }
  215.         
  216.         if(exactlyLength){
  217.             if(levelExactlyMatch==url.length){
  218.                 return apiOpExactlyMatch;
  219.             }
  220.             else if(levelDinamicMatch==url.length){
  221.                 return apiOpDynamicMatch;
  222.             }
  223.             else{
  224.                 return null;
  225.             }
  226.         }
  227.         else{
  228.             if(levelExactlyMatch>levelDinamicMatch){
  229.                 return apiOpExactlyMatch;
  230.             }
  231.             else{
  232.                 return apiOpDynamicMatch;
  233.             }
  234.         }
  235.     }
  236.     
  237.     private static ApiOperation getOperation(String[] url, Api api, HttpRequestMethod httpMethod, boolean exactlyLength) throws ProcessingException{

  239.         // Prima cerco operazioni con method specifico e path specifico
  240.         // prima della versione 3.3.0.p2: L'interfaccia non permette la creazione di risorse con un metodo preciso e qualsiasi path
  241.         // dopo la versione 3.3.0.p2: l'interfaccia consente la creazione di risorse con un metodo preciso e qualsiasi path ma controlla che non vi siano casi che possano essere inclusi in più path
  242.         List<ApiOperation> listMethodAndPath = new ArrayList<>();
  243.         List<ApiOperation> listQualsiasiMethodAndPath = new ArrayList<>();
  244.         List<ApiOperation> listMethodAndQualsiasiPath = new ArrayList<>();
  245.         List<ApiOperation> listQualsiasi = new ArrayList<>();
  246.         for (ApiOperation apiOperation : api.getOperations()) {
  247.             if(apiOperation.getHttpMethod()!=null && apiOperation.getPath()!=null) {
  248.                 listMethodAndPath.add(apiOperation);
  249.             }
  250.             else if(apiOperation.getPath()!=null) {
  251.                 listQualsiasiMethodAndPath.add(apiOperation);
  252.             }
  253.             else if(apiOperation.getHttpMethod()!=null) {
  254.                 if(apiOperation.getHttpMethod().equals(httpMethod)){
  255.                     listMethodAndQualsiasiPath.add(apiOperation);
  256.                 }
  257.             }
  258.             else {
  259.                 listQualsiasi.add(apiOperation);
  260.             }
  261.         }
  262.         
  263.         ApiOperation op = getOperation(listMethodAndPath, url, httpMethod, exactlyLength);
  264.         if(op==null) {
  265.             op = getOperation(listQualsiasiMethodAndPath, url, httpMethod, exactlyLength);
  266.         }
  267.         
  268.         if(op!=null) {
  269.             return op;
  270.         }
  271.         
  272.         if(listMethodAndQualsiasiPath.size()>0 && listQualsiasi.size()>0) {
  273.             throw new ProcessingException("Found more resource with path '*' (both httpMethod that '*')");
  274.         }
  275.         
  276.         if(listMethodAndQualsiasiPath.size()>0) {
  277.             if(listMethodAndQualsiasiPath.size()>1) {
  278.                 throw new ProcessingException("Found more resource with httpMethod '"+listMethodAndQualsiasiPath.get(0).getHttpMethod()+"' and path '*'");
  279.             }
  280.             else if(listMethodAndQualsiasiPath.size()==1) {
  281.                 return  listMethodAndQualsiasiPath.get(0);
  282.             }
  283.         }
  284.         
  285.         if(listQualsiasi.size()>0) {
  286.             if(listQualsiasi.size()>1) {
  287.                 throw new ProcessingException("Found more resource with httpMethod '*' and path '*'");
  288.             }
  289.             else if(listQualsiasi.size()==1) {
  290.                 return  listQualsiasi.get(0);
  291.             }
  292.         }
  293.         
  294.         return null;
  295.     }
  296.     
  297. }
Created with JaCoCo 0.8.8.202204050719