AbstractMappedConverter.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.xml2json;

  23. import java.io.File;
  24. import java.util.ArrayList;
  25. import java.util.List;
  26. import java.util.Scanner;

  28. import org.apache.commons.lang.StringUtils;
  29. import org.openspcoop2.utils.SortedMap;
  30. import org.openspcoop2.utils.UtilsException;
  31. import org.openspcoop2.utils.resources.FileSystemUtilities;

  33. /**
  34.  * @author Bussu Giovanni (bussu@link.it)
  35.  * @author  $Author$
  36.  * @version $Rev$, $Date$
  37.  * 
  38.  */
  39. public class AbstractMappedConverter {

  41.     protected boolean camelCase = false;
  42.     protected boolean camelCase_firstLower = false;
  43.     protected SortedMap<String> renameFields = new SortedMap<String>();
  44.     
  45.     protected List<String> arrays = new ArrayList<>();

  47.     protected SortedMap<String[]> reorderChildren = new SortedMap<String[]>();
  48.     protected boolean forceReorder = false;
  49.     
  50.     protected boolean prettyPrint = false;
  51.     
  52.     
  53.     // -- CamelCase e Rename Field
  54.     
  55.     public void activeCamelCase(boolean firstLowerCase) {
  56.         this.camelCase = true;
  57.         this.camelCase_firstLower = firstLowerCase;
  58.     }
  59.     public void addRenameField(String path, String newName) throws UtilsException {
  60.         this.renameFields.add(path, newName);
  61.     }   
  62.     public void readRenameFieldConfigFromFile(String path) throws UtilsException {
  63.         this.readRenameFieldConfigFromFile(new File(path));
  64.     }
  65.     public void readRenameFieldConfigFromFile(File path) throws UtilsException {
  66.         if(path.exists()==false) {
  67.             throw new UtilsException("File ["+path.getAbsolutePath()+"] not exists");
  68.         }
  69.         if(path.canRead()==false) {
  70.             throw new UtilsException("File ["+path.getAbsolutePath()+"] cannot read");
  71.         }
  72.         byte [] r = null;
  73.         try {
  74.             r = FileSystemUtilities.readBytesFromFile(path);
  75.         }catch(Exception e) {
  76.             throw new UtilsException(e.getMessage(),e);
  77.         }
  78.         this.readRenameFieldConfigFromFile(r);
  79.     }
  80.     public void readRenameFieldConfigFromFile(byte[] resource) throws UtilsException {
  81.         readFileConfig(resource, this.renameFields);
  82.     }   
  83.     
  84.     
  85.     // -- Array
  86.     
  87.     public void addArrayMapping(String path) throws UtilsException {
  88.         this.arrays.add(path);
  89.     }
  90.     
  91.     public void readArrayMappingFromFile(String path) throws UtilsException {
  92.         this.readArrayMappingFromFile(new File(path));
  93.     }
  94.     public void readArrayMappingFromFile(File path) throws UtilsException {
  95.         if(path.exists()==false) {
  96.             throw new UtilsException("File ["+path.getAbsolutePath()+"] not exists");
  97.         }
  98.         if(path.canRead()==false) {
  99.             throw new UtilsException("File ["+path.getAbsolutePath()+"] cannot read");
  100.         }
  101.         byte [] r = null;
  102.         try {
  103.             r = FileSystemUtilities.readBytesFromFile(path);
  104.         }catch(Exception e) {
  105.             throw new UtilsException(e.getMessage(),e);
  106.         }
  107.         this.readArrayMappingFromFile(r);
  108.     }
  109.     public void readArrayMappingFromFile(byte[] resource) throws UtilsException {
  110.         readFileConfig(resource, this.arrays);
  111.     }   
  112.             
  113.     
  114.     // -- Reorder elements
  115.     
  116.     public void addReorderChildren(String path, List<String> children) throws UtilsException {
  117.         if(children==null || children.size()<=0) {
  118.             throw new UtilsException("Children undefined");
  119.         }
  120.         addReorderChildren(path, children.toArray(new String[1]));
  121.     }
  122.     public void addReorderChildren(String path, String children) throws UtilsException {
  123.         List<String> l = toList(children);
  124.         if(l.isEmpty()) {
  125.             throw new UtilsException("Children not found");
  126.         }
  127.         addReorderChildren(path, l);
  128.     }
  129.     public void addReorderChildren(String path, String ... children) throws UtilsException {
  130.         if(children==null || children.length<=0) {
  131.             throw new UtilsException("Children undefined");
  132.         }
  133.         this.reorderChildren.add(path, children);
  134.     }   
  135.     public void readReorderChildrenConfigFromFile(String path) throws UtilsException {
  136.         this.readReorderChildrenConfigFromFile(new File(path));
  137.     }
  138.     public void readReorderChildrenConfigFromFile(File path) throws UtilsException {
  139.         if(path.exists()==false) {
  140.             throw new UtilsException("File ["+path.getAbsolutePath()+"] not exists");
  141.         }
  142.         if(path.canRead()==false) {
  143.             throw new UtilsException("File ["+path.getAbsolutePath()+"] cannot read");
  144.         }
  145.         byte [] r = null;
  146.         try {
  147.             r = FileSystemUtilities.readBytesFromFile(path);
  148.         }catch(Exception e) {
  149.             throw new UtilsException(e.getMessage(),e);
  150.         }
  151.         this.readReorderChildrenConfigFromFile(r);
  152.     }
  153.     public void readReorderChildrenConfigFromFile(byte[] resource) throws UtilsException {
  154.         readFileConfig_mapStringArray(resource, this.reorderChildren);
  155.     }   
  156.     
  157.     public void setForceReorder(boolean forceReorder) {
  158.         this.forceReorder = forceReorder;
  159.     }
  160.     
  161.     
  162.     // -- Pretty Print
  163.     
  164.     public void setPrettyPrint(boolean prettyPrint) {
  165.         this.prettyPrint = prettyPrint;
  166.     }
  167.     
  168.     
  169.     
  170.     
  171.     
  172.     // -- Utilities interne
  173.     
  174.     protected static String getParentPath(String name) throws UtilsException {
  175.         if(name.contains(".")) {
  176.             if(name.startsWith(".") || name.endsWith(".")) {
  177.                 throw new UtilsException("Uncorrect format path ["+name+"]");
  178.             }
  179.             int l = name.lastIndexOf(".");
  180.             String parentPath = name.substring(0, l);
  181.             return parentPath;
  182.         }
  183.         return null;
  184.     }
  185.     protected static String getLastNamePath(String name) throws UtilsException {
  186.         if(name.contains(".")) {
  187.             if(name.startsWith(".") || name.endsWith(".")) {
  188.                 throw new UtilsException("Uncorrect format path ["+name+"]");
  189.             }
  190.             int l = name.lastIndexOf(".");
  191.             String last = name.substring(l+1,name.length());
  192.             return last;
  193.         }
  194.         return name;
  195.     }
  196.     
  197.     protected List<String> correctPath(String tipologia, List<String> params) throws UtilsException {
  198.         List<String> newListArray = new ArrayList<>();
  199.         List<String> removePath = new ArrayList<>();
  200.         if(!params.isEmpty()) {
  201.             
  202.             for (String path : params) {
  203.                 String [] tmp = path.split("\\.");
  204.                 StringBuilder sbNewPath = new StringBuilder();
  205.                 int limit = 1;
  206.                 
  207.                 while(limit<=tmp.length) {
  208.                         
  209.                     StringBuilder sbPathCheck = new StringBuilder();
  210.                     for (int i = 0; i < limit; i++) {
  211.                         if(i>0) {
  212.                             sbPathCheck.append(".");
  213.                         }
  214.                         sbPathCheck.append(tmp[i]);
  215.                     }
  216.                     String patchCheck = sbPathCheck.toString();
  217.                     if(sbNewPath.length()>0) {
  218.                         sbNewPath.append(".");
  219.                     }
  220.                     String nome = tmp[limit-1];
  221.                     if(this.renameFields.containsKey(patchCheck)) {
  222.                         nome = this.renameFields.get(patchCheck);
  223.                     }
  224.                     sbNewPath.append(nome);
  225.                                             
  226.                     limit++;
  227.                 }
  228.                 String newPath = sbNewPath.toString();
  229.                 //System.out.println("@"+tipologia+" PRIMA path["+path+"] DOPO path["+newPath+"]");
  230.                 newListArray.add(newPath);
  231.                 if("reorder".equals(tipologia)) {
  232.                     removePath.add(path);
  233.                 }
  234.             }
  235.         }
  236.         
  237.         if("reorder".equals(tipologia) && !newListArray.isEmpty()) {
  238.             for (int i = 0; i < newListArray.size(); i++) {
  239.                 String newPath = newListArray.get(i);
  240.                 String path = removePath.get(i);
  241.                 String [] v = this.reorderChildren.remove(path);
  242.                 String [] newV = new String[v.length];
  243.                 for (int j = 0; j < v.length; j++) {
  244.                     String old = v[j];
  245.                     String key = ("".equals(path)) ? old : path+"."+old;
  246.                     String newK = old;
  247.                     if(this.renameFields.containsKey(key)) {
  248.                         newK = this.renameFields.get(key);
  249.                     }
  250.                     newV[j] = newK;
  251.                 }
  252.                 //System.out.println("@"+tipologia+" PRIMA path["+path+"] DOPO path["+newPath+"] ARRAY-PRIMA["+Arrays.asList(v)+"] ARRAY["+Arrays.asList(newV)+"]");
  253.                 this.reorderChildren.add(newPath, newV);
  254.             }
  255.         }
  256.                 
  257.         return newListArray;
  258.     }
  259.     
  260.     protected void readFileConfig(byte [] file, List<String> list) throws UtilsException {
  261.         _readFileConfig(file, false, list, null, null);
  262.     }
  263.     protected void readFileConfig_mapStringArray(byte [] file, SortedMap<String[]> mapStringArray) throws UtilsException {
  264.         _readFileConfig(file, true, null, mapStringArray, null);
  265.     }
  266.     protected void readFileConfig(byte [] file, SortedMap<String> mapString) throws UtilsException {
  267.         _readFileConfig(file, true, null, null, mapString);
  268.     }
  269.     private void _readFileConfig(byte [] file, boolean isProperty, List<String> listString, SortedMap<String[]> mapStringArray, SortedMap<String> mapString) throws UtilsException {
  270.         Scanner scanner = new Scanner(new String(file));
  271.         try {
  272.             while (scanner.hasNextLine()) {
  273.                 String line = scanner.nextLine();
  274.                 if(line==null || line.trim().equals("") || line.trim().startsWith("#")) {
  275.                     continue;
  276.                 }
  277.                 if(isProperty) {
  278.                     if(line.contains("=")==false) {
  279.                         throw new UtilsException("In ogni riga deve essere indicata una coppia (nome=valore); non รจ stato riscontrato il carattere separatore '=' nella riga '"+line+"'");
  280.                     }
  281.                     int indexOf = line.indexOf("=");
  282.                     String key = null;
  283.                     String value = null;
  284.                     if(indexOf==0) {
  285.                         // senza chiave (es. per root)
  286.                         key = "";
  287.                         value=line.substring(indexOf+1, line.length());
  288.                     }
  289.                     else if(indexOf==(line.length()-1)) {
  290.                         // senza valore
  291.                         key=line.substring(0,indexOf);
  292.                         value="";
  293.                     }
  294.                     else {
  295.                         key = line.substring(0, indexOf);
  296.                         value = line.substring(indexOf+1, line.length());
  297.                     }
  298.                     
  299.                     if(value.contains("#")) {
  300.                         // commento inserito dopo la definizione
  301.                         int indexOfCommento = value.indexOf("#");
  302.                         value = value.substring(0, indexOfCommento);
  303.                     }
  304.                     
  305.                     if(mapStringArray!=null) {
  306.                         List<String> l = toList(value);
  307.                         if(l.isEmpty()) {
  308.                             throw new UtilsException("element for key '"+key+"' not found");
  309.                         }
  310.                         //System.out.println("INIT ["+key+"] ["+l+"]");
  311.                         mapStringArray.add(key, l.toArray(new String[1]));
  312.                     }
  313.                     else {
  314.                         mapString.add(key, value);
  315.                     }
  316.                 }
  317.                 else {
  318.                     listString.add(line);
  319.                 }
  320.             }
  321.         }finally {
  322.             scanner.close();
  323.         }
  324.     }
  325.     
  326.     protected List<String> toList(String param){
  327.         List<String> l = new ArrayList<>();
  328.         if(param!=null && param.contains(",")) {
  329.             String [] tmp = param.split(",");
  330.             if(tmp!=null && tmp.length>0) {
  331.                 for (String c : tmp) {
  332.                     if(c!=null && !StringUtils.isEmpty(c.trim())) {
  333.                         l.add(c.trim());
  334.                     }
  335.                 }
  336.             }
  337.         }
  338.         else {
  339.             if(param!=null && !StringUtils.isEmpty(param.trim())) {
  340.                 l.add(param.trim());
  341.             }
  342.         }
  343.         return l;
  344.     }
  345. }
Created with JaCoCo 0.8.8.202204050719