Deserializer.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.protocol.abstraction.csv;

  23. import java.io.ByteArrayInputStream;
  24. import java.io.InputStream;
  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;
  29. import java.util.Properties;

  31. import org.apache.commons.lang.CharEncoding;
  32. import org.openspcoop2.protocol.abstraction.Erogazione;
  33. import org.openspcoop2.protocol.abstraction.Fruizione;
  34. import org.openspcoop2.protocol.sdk.ProtocolException;
  35. import org.openspcoop2.protocol.utils.ManagerUtils;
  36. import org.openspcoop2.utils.Utilities;
  37. import org.openspcoop2.utils.UtilsException;
  38. import org.openspcoop2.utils.csv.Format;
  39. import org.openspcoop2.utils.csv.FormatReader;
  40. import org.openspcoop2.utils.csv.Parser;
  41. import org.openspcoop2.utils.csv.ParserResult;
  42. import org.openspcoop2.utils.csv.Record;
  43. import org.openspcoop2.utils.resources.TemplateUtils;
  44. import org.slf4j.Logger;

  46. import freemarker.template.Template;

  48. /**     
  49.  * Deserializer
  50.  *
  51.  * @author Poli Andrea (poli@link.it)
  52.  * @author $Author$
  53.  * @version $Rev$, $Date$
  54.  */
  55. public class Deserializer {

  57.     private static final String PROTOCOLLO = "protocollo";
  58.     private static final String DEFAULT_SUBJECT_TYPE = "_DefaultSubjectType_";
  59.     
  60.     
  61.     private org.openspcoop2.protocol.abstraction.utils.serializer.JaxbDeserializer jaxbAbstractionDeserializer = null;
  62.     private boolean validate;
  63.     private Logger log;
  64.     public Deserializer(boolean validate,Logger log) throws ProtocolException{
  65.         // -- unmarshall
  66.         this.jaxbAbstractionDeserializer = new org.openspcoop2.protocol.abstraction.utils.serializer.JaxbDeserializer();
  67.         this.validate = validate;
  68.         this.log = log;
  69.     }


  72.     

  74.     
  75.     
  76.     
  77.     
  78.     
  79.     

  81.     // *********** EROGAZIONE ******************

  83.     public List<Erogazione> toErogazione(byte[] erogazioneTemplateParam, byte[] formatParam, byte[] mappingParam, byte[] csv) throws ProtocolException{
  84.         return this.toErogazione(erogazioneTemplateParam, formatParam, mappingParam, csv, CharEncoding.UTF_8);
  85.     }
  86.     public List<Erogazione> toErogazione(byte[] erogazioneTemplateParam, byte[] formatParam, byte[] mappingParam, byte[] csv, String charset) throws ProtocolException{
  87.         Properties format = null;
  88.         if(formatParam!=null){
  89.             try {
  90.                 format = Utilities.getAsProperties(formatParam);
  91.             } catch (UtilsException e) {
  92.                 throw new ProtocolException(e.getMessage(),e);
  93.             }
  94.         }   
  95.         Properties mapping = null;
  96.         if(mappingParam!=null){
  97.             try {
  98.                 mapping = Utilities.getAsProperties(mappingParam);
  99.             } catch (UtilsException e) {
  100.                 throw new ProtocolException(e.getMessage(),e);
  101.             }
  102.         }   
  103.         return toErogazione(erogazioneTemplateParam, format, mapping, csv, charset);
  104.     }
  105.     public List<Erogazione> toErogazione(byte[] erogazioneTemplateParam, Properties formatParam, Properties mappingParam, byte[] csvParam) throws ProtocolException{
  106.         return this.toErogazione(erogazioneTemplateParam, formatParam, mappingParam, csvParam, CharEncoding.UTF_8);
  107.     }
  108.     public List<Erogazione> toErogazione(byte[] erogazioneTemplateParam, Properties formatParam, Properties mappingParam, byte[] csvParam, String charset) throws ProtocolException{
  109.         String csv = null;
  110.         if(csvParam==null){
  111.             throw new ProtocolException("CSV non disponibile");
  112.         }
  113.         if(charset==null){
  114.             charset = CharEncoding.UTF_8;
  115.         }
  116.         try{
  117.             csv = new String(csvParam, charset);
  118.         }catch(Exception e){
  119.             throw new ProtocolException("CSV con formato errato [encoding:"+charset+"]: "+e.getMessage());
  120.         }
  121.         return this.toErogazione(erogazioneTemplateParam, formatParam, mappingParam, csv);
  122.     }

  124.     public List<Erogazione> toErogazione(byte[] erogazioneTemplateParam, byte[] formatParam, byte[] mappingParam, String csv) throws ProtocolException{
  125.         Properties format = null;
  126.         if(formatParam!=null){
  127.             try {
  128.                 format = Utilities.getAsProperties(formatParam);
  129.             } catch (UtilsException e) {
  130.                 throw new ProtocolException(e.getMessage(),e);
  131.             }
  132.         }   
  133.         Properties mapping = null;
  134.         if(mappingParam!=null){
  135.             try {
  136.                 mapping = Utilities.getAsProperties(mappingParam);
  137.             } catch (UtilsException e) {
  138.                 throw new ProtocolException(e.getMessage(),e);
  139.             }
  140.         }
  141.         return this.toErogazione(erogazioneTemplateParam, format, mapping, csv);
  142.     }
  143.     public List<Erogazione> toErogazione(byte[] erogazioneTemplateParam, Properties formatParam, Properties mappingParam, String csv) throws ProtocolException{

  145.         try{
  146.         
  147.             byte[] erogazioneTemplate = erogazioneTemplateParam;
  148.             Template template = null;
  149.             if(erogazioneTemplate==null){
  150.                 erogazioneTemplate = this.readBytes("/templates/csv/Erogazione.ftl");
  151.             }
  152.             try{
  153.                 template = TemplateUtils.buildTemplate("Erogazione", erogazioneTemplate);
  154.             }catch(Exception e){
  155.                 throw new ProtocolException("Build Template error: "+e.getMessage());
  156.             }
  157.     
  158.             Properties format = formatParam;
  159.             if(format==null){
  160.                 format = this.readProperties("/templates/csv/format.properties");
  161.             }
  162.     
  163.             Properties mapping = mappingParam;
  164.             if(mapping==null){
  165.                 mapping = this.readProperties("/templates/csv/erogazione.properties");
  166.             }
  167.     
  168.             List<Erogazione> listErogazioni = new ArrayList<Erogazione>();
  169.     
  170.             // Deserializzo CSV per avere la mappa
  171.             FormatReader formatReader = new FormatReader(format);
  172.             Format f = formatReader.getFormat();
  173.             Parser p = new Parser(mapping, true);
  174.             ParserResult pr = p.parseCsvFile(f, csv);
  175.             for (Record record : pr.getRecords()) {
  176.     
  177.                 // Costruisco Mappa
  178.                 Map<String, Object> mapFreemarker = new HashMap<>();
  179.                 if(record.getMap().size()<=0){
  180.                     throw new ProtocolException("Csv Record at line ["+record.getCsvLine()+"] not correct, mapping produce 0 fields");
  181.                 }
  182.                 List<String> keys = record.getMap().keys();
  183.                 for (String key : keys) {
  184.                     String s = record.getMap().get(key);
  185.                     if(s!=null)
  186.                         mapFreemarker.put(key, s);
  187.                 }
  188.                 
  189.                 // TipoSoggettoDefault
  190.                 String protocollo = record.getMap().get(PROTOCOLLO);
  191.                 if(protocollo == null){
  192.                     protocollo = ManagerUtils.getDefaultProtocol();
  193.                 }
  194.                 mapFreemarker.put(DEFAULT_SUBJECT_TYPE, ManagerUtils.getDefaultOrganizationType(protocollo));
  195.                 
  196.                 // Creo xml della singola erogazione
  197.                 byte[] xmlErogazione = null;
  198.                 try{
  199.                     xmlErogazione = TemplateUtils.toByteArray(template, mapFreemarker);
  200.                 }catch(Exception e){
  201.                     throw new ProtocolException("Csv Record at line ["+record.getCsvLine()+"] not correct (Build xml from template failed): "+e.getMessage());
  202.                 }
  203.                 ByteArrayInputStream bin = null;
  204.                 try{
  205.                     if(this.validate){
  206.                         bin = new ByteArrayInputStream(xmlErogazione);
  207.                         org.openspcoop2.protocol.abstraction.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  208.                     }
  209.                     Erogazione erogazione = this.jaxbAbstractionDeserializer.readErogazione(xmlErogazione);
  210.                     listErogazioni.add(erogazione);
  211.                 }catch(Exception e){
  212.                     throw new ProtocolException("Csv Record at line ["+record.getCsvLine()+"] not correct. Marshall Xml ["+new String(xmlErogazione)+"]\n"+e.getMessage(),e);
  213.                 }
  214.                 finally{
  215.                     try{
  216.                         if(bin!=null)
  217.                             bin.close();
  218.                     }catch(Exception e){
  219.                         // close
  220.                     }
  221.                 }
  222.             }
  223.     
  224.             return listErogazioni;
  225.             
  226.         } catch (UtilsException e) {
  227.             throw new ProtocolException(e.getMessage(),e);
  228.         }

  230.     }






  237.     // *********** FRUIZIONE ******************

  239.     public List<Fruizione> toFruizione(byte[] fruizioneTemplateParam, byte[] formatParam, byte[] mappingParam, byte[] csv) throws ProtocolException{
  240.         return this.toFruizione(fruizioneTemplateParam, formatParam, mappingParam, csv, CharEncoding.UTF_8);
  241.     }
  242.     public List<Fruizione> toFruizione(byte[] fruizioneTemplateParam, byte[] formatParam, byte[] mappingParam, byte[] csv, String charset) throws ProtocolException{
  243.         Properties format = null;
  244.         if(formatParam!=null){
  245.             try{
  246.                 format = Utilities.getAsProperties(formatParam);
  247.             } catch (UtilsException e) {
  248.                 throw new ProtocolException(e.getMessage(),e);
  249.             }
  250.         }   
  251.         Properties mapping = null;
  252.         if(mappingParam!=null){
  253.             try{
  254.                 mapping = Utilities.getAsProperties(mappingParam);
  255.             } catch (UtilsException e) {
  256.                 throw new ProtocolException(e.getMessage(),e);
  257.             }
  258.         }   
  259.         return toFruizione(fruizioneTemplateParam, format, mapping, csv, charset);
  260.     }
  261.     public List<Fruizione> toFruizione(byte[] fruizioneTemplateParam, Properties formatParam, Properties mappingParam, byte[] csvParam) throws ProtocolException{
  262.         return this.toFruizione(fruizioneTemplateParam, formatParam, mappingParam, csvParam, CharEncoding.UTF_8);
  263.     }
  264.     public List<Fruizione> toFruizione(byte[] fruizioneTemplateParam, Properties formatParam, Properties mappingParam, byte[] csvParam, String charset) throws ProtocolException{
  265.         String csv = null;
  266.         if(csvParam==null){
  267.             throw new ProtocolException("CSV non disponibile");
  268.         }
  269.         if(charset==null){
  270.             charset = CharEncoding.UTF_8;
  271.         }
  272.         try{
  273.             csv = new String(csvParam, charset);
  274.         }catch(Exception e){
  275.             throw new ProtocolException("CSV con formato errato [encoding:"+charset+"]: "+e.getMessage());
  276.         }
  277.         return this.toFruizione(fruizioneTemplateParam, formatParam, mappingParam, csv);
  278.     }

  280.     public List<Fruizione> toFruizione(byte[] fruizioneTemplateParam, byte[] formatParam, byte[] mappingParam, String csv) throws ProtocolException{
  281.         Properties format = null;
  282.         if(formatParam!=null){
  283.             try{
  284.                 format = Utilities.getAsProperties(formatParam);
  285.             } catch (UtilsException e) {
  286.                 throw new ProtocolException(e.getMessage(),e);
  287.             }
  288.         }   
  289.         Properties mapping = null;
  290.         if(mappingParam!=null){
  291.             try{
  292.                 mapping = Utilities.getAsProperties(mappingParam);
  293.             } catch (UtilsException e) {
  294.                 throw new ProtocolException(e.getMessage(),e);
  295.             }
  296.         }
  297.         return this.toFruizione(fruizioneTemplateParam, format, mapping, csv);
  298.     }
  299.     public List<Fruizione> toFruizione(byte[] fruizioneTemplateParam, Properties formatParam, Properties mappingParam, String csv) throws ProtocolException{

  301.         try{
  302.         
  303.             byte[] fruizioneTemplate = fruizioneTemplateParam;
  304.             Template template = null;
  305.             if(fruizioneTemplate==null){
  306.                 fruizioneTemplate = this.readBytes("/templates/csv/Fruizione.ftl");
  307.             }
  308.             try{
  309.                 template = TemplateUtils.buildTemplate("Fruizione", fruizioneTemplate);
  310.             }catch(Exception e){
  311.                 throw new ProtocolException("Build Template error: "+e.getMessage());
  312.             }
  313.     
  314.             Properties format = formatParam;
  315.             if(format==null){
  316.                 format = this.readProperties("/templates/csv/format.properties");
  317.             }
  318.     
  319.             Properties mapping = mappingParam;
  320.             if(mapping==null){
  321.                 mapping = this.readProperties("/templates/csv/fruizione.properties");
  322.             }
  323.     
  324.             List<Fruizione> listFruizioni = new ArrayList<Fruizione>();
  325.     
  326.             // Deserializzo CSV per avere la mappa
  327.             FormatReader formatReader = new FormatReader(format);
  328.             Format f = formatReader.getFormat();
  329.             Parser p = new Parser(mapping, true);
  330.             ParserResult pr = p.parseCsvFile(f, csv);
  331.             for (Record record : pr.getRecords()) {
  332.     
  333.                 // Costruisco Mappa
  334.                 Map<String, Object> mapFreemarker = new HashMap<>();
  335.                 if(record.getMap().size()<=0){
  336.                     throw new ProtocolException("Csv Record at line ["+record.getCsvLine()+"] not correct, mapping produce 0 fields");
  337.                 }
  338.                 List<String> keys = record.getMap().keys();
  339.                 for (String key : keys) {
  340.                     String s = record.getMap().get(key);
  341.                     if(s!=null)
  342.                         mapFreemarker.put(key, s);
  343.                 }
  344.                 
  345.                 // TipoSoggettoDefault
  346.                 String protocollo = record.getMap().get(PROTOCOLLO);
  347.                 if(protocollo == null){
  348.                     protocollo = ManagerUtils.getDefaultProtocol();
  349.                 }
  350.                 mapFreemarker.put(DEFAULT_SUBJECT_TYPE, ManagerUtils.getDefaultOrganizationType(protocollo));
  351.                 
  352.                 // Creo xml della singola fruizione
  353.                 byte[] xmlFruizione = null;
  354.                 try{
  355.                     xmlFruizione = TemplateUtils.toByteArray(template, mapFreemarker);
  356.                 }catch(Exception e){
  357.                     throw new ProtocolException("Csv Record at line ["+record.getCsvLine()+"] not correct (Build xml from template failed): "+e.getMessage());
  358.                 }
  359.                 ByteArrayInputStream bin = null;
  360.                 try{
  361.                     if(this.validate){
  362.                         bin = new ByteArrayInputStream(xmlFruizione);
  363.                         org.openspcoop2.protocol.abstraction.utils.XSDValidator.getXSDValidator(this.log).valida(bin);
  364.                     }
  365.                     Fruizione fruizione = this.jaxbAbstractionDeserializer.readFruizione(xmlFruizione);
  366.                     listFruizioni.add(fruizione);
  367.                 }catch(Exception e){
  368.                     throw new ProtocolException("Csv Record at line ["+record.getCsvLine()+"] not correct. Marshall Xml ["+new String(xmlFruizione)+"]\n"+e.getMessage(),e);
  369.                 }
  370.                 finally{
  371.                     try{
  372.                         if(bin!=null)
  373.                             bin.close();
  374.                     }catch(Exception e){
  375.                         // close
  376.                     }
  377.                 }
  378.             }
  379.     
  380.             return listFruizioni;
  381.             
  382.         } catch (UtilsException e) {
  383.             throw new ProtocolException(e.getMessage(),e);
  384.         }

  386.     }









  396.     // *********** UTILS ******************

  398.     private byte[] readBytes(String resourceName) throws UtilsException{
  399.         InputStream is = null;
  400.         try{
  401.             is = Deserializer.class.getResourceAsStream(resourceName);
  402.             if(is==null){
  403.                 throw new UtilsException("["+resourceName+"] non disponibile");
  404.             }
  405.             return Utilities.getAsByteArray(is);
  406.         }
  407.         catch(Exception e){
  408.             throw new UtilsException(e.getMessage(),e);
  409.         }finally{
  410.             try{
  411.                 if(is!=null){
  412.                     is.close();
  413.                 }
  414.             }catch(Exception eClose){
  415.                 // close
  416.             }
  417.         }   
  418.     }

  420.     private Properties readProperties(String resourceName) throws UtilsException{
  421.         InputStream isProp = null;
  422.         try{
  423.             isProp = Deserializer.class.getResourceAsStream(resourceName);
  424.             if(isProp==null){
  425.                 throw new UtilsException("Format non disponibile");
  426.             }
  427.             Properties p = new Properties();
  428.             p.load(isProp);
  429.             return p;
  430.         }
  431.         catch(Exception e){
  432.             throw new UtilsException(e.getMessage(),e);
  433.         }finally{
  434.             try{
  435.                 if(isProp!=null){
  436.                     isProp.close();
  437.                 }
  438.             }catch(Exception eClose){
  439.                 // close
  440.             }
  441.         }
  442.     }

  444. }
Created with JaCoCo 0.8.8.202204050719