Parser.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.csv;
  22. import java.io.ByteArrayInputStream;
  23. import java.io.File;
  24. import java.io.FileInputStream;
  25. import java.io.InputStream;
  26. import java.io.InputStreamReader;
  27. import java.io.Reader;
  28. import java.io.StringReader;
  29. import java.util.ArrayList;
  30. import java.util.Enumeration;
  31. import java.util.List;
  32. import java.util.Properties;

  34. import org.apache.commons.csv.CSVParser;
  35. import org.apache.commons.csv.CSVRecord;
  36. import org.apache.commons.io.input.BOMInputStream;
  37. import org.apache.commons.lang.ArrayUtils;
  38. import org.apache.commons.lang.CharEncoding;
  39. import org.openspcoop2.utils.Utilities;
  40. import org.openspcoop2.utils.UtilsException;
  41. import org.openspcoop2.utils.regexp.RegExpNotFoundException;
  42. import org.openspcoop2.utils.regexp.RegularExpressionEngine;

  44. /**
  45.  * Parser
  46.  *
  47.  * @author Andrea Poli (apoli@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */
  51. public class Parser {

  53.     private static final String PARSER_NAME_PREFIX_= "mapping.field.";
  54.     private static final String PARSER_REGEXP_PREFIX_= "mapping.regexp.";
  55.     private static final String PARSER_REGEXP_SUFFIX_NOT_FOUND= ".notFound";
  56.     private static final String PARSER_DEFAULT_PREFIX_= "mapping.default.";
  57.     private static final String PARSER_CONSTANT_PREFIX_= "mapping.constant.";
  58.     private static final String PARSER_REQUIRED_PREFIX_= "mapping.required.";
  59.     
  60.     private List<ParserMappingRecord> mapping;
  61.     
  62.     public Parser(List<ParserMappingRecord> mapping) throws UtilsException {
  63.         if(mapping==null || mapping.size()<=0){
  64.             throw new UtilsException("Map is null");
  65.         }
  66.         for (int i = 0; i < mapping.size(); i++) {
  67.             if(mapping.get(i).getName()==null){
  68.                 throw new UtilsException("RecordMapping["+i+"] without name");
  69.             }
  70.             if(mapping.get(i).getConstantValue()==null && mapping.get(i).getCsvPosition()==null && mapping.get(i).getCsvColumnName()==null ){
  71.                 throw new UtilsException("RecordMapping["+i+"] name["+mapping.get(i).getName()+"] without almost one required field: constantValue, csvPosition, csvColumnName");
  72.             }
  73.         }
  74.         this.mapping = mapping;
  75.     }
  76.     public Parser(InputStream is,boolean positionMapping) throws UtilsException {
  77.         Properties p = null;
  78.         try{
  79.             p = new Properties();
  80.             p.load(is);
  81.         }catch(Exception e){
  82.             throw new UtilsException(e.getMessage(),e);
  83.         }
  84.         this.init(p,positionMapping);
  85.     }
  86.     public Parser(Properties properties,boolean positionMapping) throws UtilsException {
  87.         this.init(properties,positionMapping);
  88.     }
  89.     
  90.     private void init(Properties properties,boolean positionMapping) throws UtilsException{
  91.         
  92.         Properties names = Utilities.readProperties(PARSER_NAME_PREFIX_, properties);
  93.         Properties regexps = Utilities.readProperties(PARSER_REGEXP_PREFIX_, properties);
  94.         Properties constants = Utilities.readProperties(PARSER_CONSTANT_PREFIX_, properties);
  95.         Properties required = Utilities.readProperties(PARSER_REQUIRED_PREFIX_, properties);
  96.         Properties defaults = Utilities.readProperties(PARSER_DEFAULT_PREFIX_, properties);
  97.         
  98.         if(names.size()<=0){
  99.             throw new UtilsException("No mapping exists");
  100.         }
  101.         
  102.         this.mapping = new ArrayList<ParserMappingRecord>();
  103.         
  104.         
  105.         Enumeration<?> enNames = names.keys();
  106.         while (enNames.hasMoreElements()) {
  107.             String key = (String) enNames.nextElement();
  108.             String value = names.getProperty(key);
  109.             if(value==null){
  110.                 throw new UtilsException("Property ["+PARSER_NAME_PREFIX_+key+"] without value");
  111.             }
  112.             value = value.trim();
  113.             
  114.             ParserMappingRecord recordMapping = null;
  115.                         
  116.             if(constants.containsKey(key)){
  117.                 if("true".equalsIgnoreCase(constants.getProperty(key).trim())){
  118.                     //  E' una costante
  119.                     recordMapping = ParserMappingRecord.newCsvConstantRecord(key, value);
  120.                 }
  121.                 else if("false".equalsIgnoreCase(required.getProperty(key).trim())){
  122.                     // verrà gestita come campo normale.
  123.                 }
  124.                 else{
  125.                     throw new UtilsException("Property ["+PARSER_CONSTANT_PREFIX_+key+"] with wrong value (expected true/false): "+required.getProperty(key).trim());
  126.                 }
  127.             }
  128.             
  129.             if(recordMapping==null){
  130.                 // non è una costante
  131.             
  132.                 String [] regExpr = null;
  133.                 ParserRegexpNotFound regexpNotFoundBehaviour = null;
  134.                 if(regexps.containsKey(key)){
  135.                     if(regexps.getProperty(key)!=null){
  136.                         List<String> r = new ArrayList<>();
  137.                         r.add(regexps.getProperty(key).trim());
  138.                         int index = 1;
  139.                         while(regexps.containsKey(key+"."+index) && regexps.getProperty(key+"."+index)!=null){
  140.                             r.add(regexps.getProperty(key+"."+index).trim());
  141.                             index++;
  142.                         }
  143.                         regExpr = r.toArray(new String[1]);
  144.                         
  145.                         if(regexps.containsKey(key+PARSER_REGEXP_SUFFIX_NOT_FOUND)){
  146.                             if(regexps.getProperty(key+PARSER_REGEXP_SUFFIX_NOT_FOUND)!=null){
  147.                                 String tmp = regexps.getProperty(key+PARSER_REGEXP_SUFFIX_NOT_FOUND).trim();
  148.                                 ParserRegexpNotFound [] p = ParserRegexpNotFound.values();
  149.                                 for (int i = 0; i < p.length; i++) {
  150.                                     if(p[i].toString().equals(tmp)){
  151.                                         regexpNotFoundBehaviour = p[i];
  152.                                         break;
  153.                                     }
  154.                                 }
  155.                                 if(regexpNotFoundBehaviour==null){
  156.                                     throw new UtilsException("Property ["+PARSER_REGEXP_PREFIX_+key+PARSER_REGEXP_SUFFIX_NOT_FOUND+"] with wrong value (expected: "+ArrayUtils.toString(p)+"): "+tmp);
  157.                                 }
  158.                             }
  159.                         }
  160.                     }
  161.                 }
  162.                 
  163.                 String defaultValue = null;
  164.                 if(defaults.containsKey(key)){
  165.                     if(defaults.getProperty(key)!=null){
  166.                         defaultValue = defaults.getProperty(key).trim();
  167.                     }
  168.                 }
  169.                 
  170.                 if(positionMapping){
  171.                     try{
  172.                         int intValue = Integer.parseInt(value);
  173.                         if(intValue<0){
  174.                             throw new Exception("Negative Number");
  175.                         }
  176.                         recordMapping = ParserMappingRecord.newCsvColumnPositionRecord(key, intValue, defaultValue, regexpNotFoundBehaviour, regExpr);
  177.                     }catch(Exception e){
  178.                         throw new UtilsException("Property ["+PARSER_NAME_PREFIX_+key+"] with wrong value (expected positive number): "+e.getMessage(),e);
  179.                     }
  180.                 }
  181.                 else{
  182.                     recordMapping = ParserMappingRecord.newCsvColumnNameRecord(key, value, defaultValue, regexpNotFoundBehaviour, regExpr);
  183.                 }
  184.                 
  185.                 if(required.containsKey(key)){
  186.                     if("true".equalsIgnoreCase(required.getProperty(key).trim())){
  187.                         recordMapping.setRequired(true);
  188.                     }
  189.                     else if("false".equalsIgnoreCase(required.getProperty(key).trim())){
  190.                         recordMapping.setRequired(false);
  191.                     }
  192.                     else{
  193.                         throw new UtilsException("Property ["+PARSER_REQUIRED_PREFIX_+key+"] with wrong value (expected true/false): "+required.getProperty(key).trim());
  194.                     }
  195.                 }
  196.                 
  197.             }
  198.             
  199.             this.mapping.add(recordMapping);
  200.         }
  201.         
  202.     }
  203.     
  204.     public ParserResult parseCsvFile(Format format, String csvContent) throws UtilsException{
  205.         Reader reader = null;
  206.         try{
  207.             reader = new StringReader(csvContent);
  208.             return this.parseCsvFile(format, reader);
  209.         }finally{
  210.             try{
  211.                 if(reader!=null){
  212.                     reader.close();
  213.                 }
  214.             }catch(Exception eClose){
  215.                 // close
  216.             }
  217.         }
  218.     }
  219.     
  220.     public ParserResult parseCsvFile(Format format, byte[] csv) throws UtilsException{
  221.         return this.parseCsvFile(format, csv, CharEncoding.UTF_8,false);
  222.     }
  223.     public ParserResult parseCsvFile(Format format, byte[] csv, String charset) throws UtilsException{
  224.         return this.parseCsvFile(format, csv, charset,false);
  225.     }
  226.     public ParserResult parseCsvFile(Format format, byte[] csv,boolean enableBomInputStream) throws UtilsException{
  227.         return this.parseCsvFile(format, csv, CharEncoding.UTF_8,enableBomInputStream);
  228.     }
  229.     public ParserResult parseCsvFile(Format format, byte[] csv, String charset,boolean enableBomInputStream) throws UtilsException{
  230.         ByteArrayInputStream bin = null;
  231.         try{
  232.             bin = new ByteArrayInputStream(csv);
  233.             return this.parseCsvFile(format, bin,charset,enableBomInputStream);
  234.         }finally{
  235.             try{
  236.                 if(bin!=null){
  237.                     bin.close();
  238.                 }
  239.             }catch(Exception eClose){
  240.                 // close
  241.             }
  242.         }
  243.     }
  244.     
  245.     public ParserResult parseCsvFile(Format format, File file) throws UtilsException{
  246.         return this.parseCsvFile(format, file, CharEncoding.UTF_8, false);
  247.     }
  248.     public ParserResult parseCsvFile(Format format, File file, String charset) throws UtilsException{
  249.         return this.parseCsvFile(format, file, charset, false);
  250.     }
  251.     public ParserResult parseCsvFile(Format format, File file, boolean enableBomInputStream) throws UtilsException{
  252.         return this.parseCsvFile(format, file, CharEncoding.UTF_8, enableBomInputStream);
  253.     }
  254.     public ParserResult parseCsvFile(Format format, File file, String charset,boolean enableBomInputStream) throws UtilsException{
  255.         FileInputStream fin = null;
  256.         try{
  257.             fin = new FileInputStream(file);
  258.             return this.parseCsvFile(format, fin,charset,enableBomInputStream);
  259.         }catch(Exception e){
  260.             throw new UtilsException(e.getMessage(),e);
  261.         }
  262.         finally{
  263.             try{
  264.                 if(fin!=null){
  265.                     fin.close();
  266.                 }
  267.             }catch(Exception eClose){
  268.                 // close
  269.             }
  270.         }
  271.     }
  272.     
  273.     public ParserResult parseCsvFile(Format format, InputStream is) throws UtilsException{
  274.         return parseCsvFile(format, is, CharEncoding.UTF_8, false);
  275.     }
  276.     public ParserResult parseCsvFile(Format format, InputStream is, String charset) throws UtilsException{
  277.         return parseCsvFile(format, is, charset, false);
  278.     }
  279.     public ParserResult parseCsvFile(Format format, InputStream is, boolean enableBomInputStream) throws UtilsException{
  280.         return parseCsvFile(format, is, CharEncoding.UTF_8, enableBomInputStream);
  281.     }
  282.     public ParserResult parseCsvFile(Format format, InputStream is, String charset,boolean enableBomInputStream) throws UtilsException{
  283.         Reader reader = null;
  284.         BOMInputStream bomInputStream = null;
  285.         try{
  286.             if(enableBomInputStream){
  287.                 bomInputStream =
  288.                         BOMInputStream.builder()
  289.                           .setInputStream(is)
  290.                           .setCharset(charset)
  291.                           .get();
  292.                 reader = new InputStreamReader(bomInputStream,charset);
  293.             }
  294.             else{
  295.                 reader = new InputStreamReader(is,charset);
  296.             }
  297.             return this.parseCsvFile(format, reader);
  298.         }catch(Exception e){
  299.             throw new UtilsException(e.getMessage(),e);
  300.         }
  301.         finally{
  302.             try{
  303.                 if(bomInputStream!=null){
  304.                     bomInputStream.close();
  305.                 }
  306.             }catch(Exception eClose){}
  307.             try{
  308.                 if(reader!=null){
  309.                     reader.close();
  310.                 }
  311.             }catch(Exception eClose){
  312.                 // close
  313.             }
  314.         }
  315.     }
  316.     public ParserResult parseCsvFile(Format format, Reader reader) throws UtilsException{
  317.         
  318.         CSVParser parser = null;
  319.         ParserResult parserResult = null;
  320.         try{
  321.             parser = new CSVParser(reader, format.getCsvFormat());
  322.             
  323.             parserResult = new ParserResult();
  324.             parserResult.setHeaderMap(parser.getHeaderMap());
  325.             
  326.             for(CSVRecord record : parser.getRecords()){
  327.                 if(format.isSkipEmptyRecord()){
  328.                     if(isRecordEmpty(record)){
  329.                         continue;
  330.                     }
  331.                 }
  332.                 
  333.                 Record recordBean = new Record();
  334.                 recordBean.setComment(record.getComment());
  335.                 recordBean.setCsvLine(record.getRecordNumber());
  336.                 recordBean.setRecord(record);
  337.                 MapResult recordMap = new MapResult();
  338.                 
  339.                 try{
  340.                     for (int i = 0; i < this.mapping.size(); i++) {
  341.                         
  342.                         ParserMappingRecord mappingRecord = this.mapping.get(i);
  343.                         String key = mappingRecord.getName();
  344.                         String valore = null;
  345.                         
  346.                         if(mappingRecord.getConstantValue()!=null){
  347.                             valore = mappingRecord.getConstantValue();
  348.                         }
  349.                         else{
  350.                             String tmpValue = null;
  351.                             if(mappingRecord.getCsvPosition()!=null){
  352.                                 if(mappingRecord.getCsvPosition()<record.size()){
  353.                                     tmpValue = record.get(mappingRecord.getCsvPosition());
  354.                                 }
  355.                                 else{
  356.                                     throw new Exception("Record with index ["+mappingRecord.getCsvPosition()+"] is greather or equals record size ["+record.size()+"]");
  357.                                 }
  358.                             }
  359.                             else{
  360.                                 if(record.isMapped(mappingRecord.getCsvColumnName())){
  361.                                     tmpValue = record.get(mappingRecord.getCsvColumnName());
  362.                                 }
  363.                                 else{
  364.                                     throw new Exception("Record with column name ["+mappingRecord.getCsvColumnName()+"] not exists");
  365.                                 }
  366.                             }
  367.                             if(tmpValue!=null && mappingRecord.getRegexpr()!=null){
  368.                                 String [] pattern = mappingRecord.getRegexpr();
  369.                                 String regExpValue = null;
  370.                                 for (int j = 0; j < pattern.length; j++) {
  371.                                     try{
  372.                                         regExpValue = RegularExpressionEngine.getStringMatchPattern(tmpValue, pattern[j]);
  373.                                         if(regExpValue!=null){
  374.                                             break;
  375.                                         }
  376.                                     }catch(RegExpNotFoundException notFound){}  
  377.                                 }
  378.                                 if(regExpValue==null){
  379.                                     if(ParserRegexpNotFound.ERROR.equals(mappingRecord.getRegexpNotFoundBehaviour())){
  380.                                         throw new Exception("Mapping for field ["+mappingRecord.getName()+"] failed, regular expression not match (value ["+tmpValue+"])");
  381.                                     }
  382.                                     else if(ParserRegexpNotFound.NULL.equals(mappingRecord.getRegexpNotFoundBehaviour())){
  383.                                         tmpValue = null;
  384.                                     }
  385. //                                  else if(ParserRegexpNotFound.ORIGINAL.equals(mappingRecord.getRegexpNotFoundBehaviour())){
  386. //                                      //tmpValue = tmpValue;
  387. //                                  }
  388.                                 }
  389.                                 else{
  390.                                     tmpValue = regExpValue;
  391.                                 }
  392.                             }
  393.                             if(tmpValue==null && mappingRecord.getDefaultValue()!=null){
  394.                                 tmpValue = mappingRecord.getDefaultValue();
  395.                             }
  396.                             if(tmpValue==null && mappingRecord.isRequired()){
  397.                                 throw new Exception("Mapping for field ["+mappingRecord.getName()+"] failed");
  398.                             }
  399.                             valore = tmpValue;
  400.                         }
  401.                         
  402.                         recordMap.add(key, valore);
  403.                     }
  404.                     
  405.         
  406.                 }catch(Exception e){
  407.                     throw new Exception("Record Line["+record.getRecordNumber()+"] ["+record+"]: "+e.getMessage(),e);
  408.                 }
  409.                 finally{
  410.                     try{
  411.                         if(parser!=null){
  412.                             parser.close();
  413.                             parser = null;
  414.                         }
  415.                     }catch(Exception eClose) {
  416.                         // close
  417.                     }
  418.                 }
  419.                 
  420.                 recordBean.setMap(recordMap);
  421.                 parserResult.getRecords().add(recordBean);
  422.             }
  423.             
  424.             return parserResult;
  425.         }
  426.         catch(Exception e){
  427.             throw new UtilsException(e.getMessage(),e);
  428.         }finally{
  429.             try{
  430.                 if(parser!=null){
  431.                     parser.close();
  432.                 }
  433.             }catch(Exception eClose){
  434.                 // close
  435.             }
  436.         }
  437.         
  438.     }
  439.     
  440.     
  441.     public static boolean isRecordEmpty(CSVRecord record){
  442.         for (int i = 0; i < record.size(); i++) {
  443.             if(record.get(i)!=null && !record.get(i).trim().equals("") ){
  444.                 return false;
  445.             }
  446.         }
  447.         return true;
  448.     }

  450. }
Created with JaCoCo 0.8.8.202204050719