DocumentoExporter.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.  */


  22. package org.openspcoop2.web.ctrlstat.servlet.archivi;

  24. import java.io.ByteArrayOutputStream;
  25. import java.io.File;
  26. import java.io.IOException;
  27. import java.io.OutputStream;
  28. import java.util.ArrayList;
  29. import java.util.Enumeration;
  30. import java.util.List;
  31. import java.util.zip.ZipEntry;
  32. import java.util.zip.ZipOutputStream;

  34. import javax.servlet.ServletException;
  35. import javax.servlet.http.HttpServlet;
  36. import javax.servlet.http.HttpServletRequest;
  37. import javax.servlet.http.HttpServletResponse;
  38. import javax.servlet.http.HttpSession;

  40. import org.apache.commons.lang.StringUtils;
  41. import org.openspcoop2.core.config.Credenziali;
  42. import org.openspcoop2.core.config.InvocazionePorta;
  43. import org.openspcoop2.core.config.PortaApplicativa;
  44. import org.openspcoop2.core.config.PortaDelegata;
  45. import org.openspcoop2.core.config.RegistroPluginArchivio;
  46. import org.openspcoop2.core.config.ServizioApplicativo;
  47. import org.openspcoop2.core.config.Soggetto;
  48. import org.openspcoop2.core.config.TrasformazioneRegola;
  49. import org.openspcoop2.core.config.TrasformazioneRegolaRichiesta;
  50. import org.openspcoop2.core.config.TrasformazioneRegolaRisposta;
  51. import org.openspcoop2.core.config.TrasformazioneSoap;
  52. import org.openspcoop2.core.config.TrasformazioneSoapRisposta;
  53. import org.openspcoop2.core.config.Trasformazioni;
  54. import org.openspcoop2.core.id.IDSoggetto;
  55. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  56. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  57. import org.openspcoop2.core.registry.CredenzialiSoggetto;
  58. import org.openspcoop2.core.registry.Documento;
  59. import org.openspcoop2.core.registry.Fruitore;
  60. import org.openspcoop2.core.registry.ProtocolProperty;
  61. import org.openspcoop2.core.registry.constants.CredenzialeTipo;
  62. import org.openspcoop2.core.registry.constants.ServiceBinding;
  63. import org.openspcoop2.core.registry.driver.AccordoServizioUtils;
  64. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  65. import org.openspcoop2.core.registry.wsdl.AccordoServizioWrapper;
  66. import org.openspcoop2.core.registry.wsdl.AccordoServizioWrapperUtilities;
  67. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  68. import org.openspcoop2.message.xml.MessageXMLUtils;
  69. import org.openspcoop2.pdd.core.jmx.JMXUtils;
  70. import org.openspcoop2.pdd.core.keystore.RemoteStoreKeyEntry;
  71. import org.openspcoop2.protocol.basic.Costanti;
  72. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  73. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  74. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  75. import org.openspcoop2.protocol.sdk.registry.RegistryNotFound;
  76. import org.openspcoop2.utils.json.YAMLUtils;
  77. import org.openspcoop2.utils.transport.http.HttpUtilities;
  78. import org.openspcoop2.utils.wsdl.WSDLUtilities;
  79. import org.openspcoop2.utils.xml.XMLException;
  80. import org.openspcoop2.utils.xml.XSDSchemaCollection;
  81. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  82. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  83. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCore;
  84. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCore;
  85. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCore;
  86. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCostanti;
  87. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCostanti;
  88. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCore;
  89. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCore;
  90. import org.openspcoop2.web.ctrlstat.servlet.protocol_properties.ProtocolPropertiesCore;
  91. import org.openspcoop2.web.ctrlstat.servlet.remote_stores.RemoteStoresCore;
  92. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCore;
  93. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCore;
  94. import org.openspcoop2.web.lib.mvc.PageData;
  95. import org.openspcoop2.web.lib.mvc.ServletUtils;
  96. import org.slf4j.Logger;

  98. /**
  99.  * Questa servlet si occupa di esportare le tracce diagnostiche in formato xml
  100.  * zippandole
  101.  * 
  102.  * 
  103.  * @author Andrea Poli (apoli@link.it)
  104.  * @author Stefano Corallo (corallo@link.it)
  105.  * @author Sandra Giangrandi (sandra@link.it)
  106.  * @author $Author$
  107.  * @version $Rev$, $Date$
  108.  * 
  109.  */
  110. public class DocumentoExporter extends HttpServlet {

  112.     private static final long serialVersionUID = -7341279067126334095L;

  114.     @Override
  115.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  116.         this.processRequest(req, resp);
  117.     }

  119.     @Override
  120.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  121.         this.processRequest(req, resp);
  122.     }

  124.     /**
  125.      * Processa la richiesta pervenuta e si occupa di fornire i dati richiesti
  126.      * in formato zip
  127.      * 
  128.      * @param req
  129.      * @param resp
  130.      * @throws ServletException
  131.      * @throws IOException
  132.      */
  133.     private void processRequest(HttpServletRequest request, HttpServletResponse response) {

  135.         HttpSession session = request.getSession(true);

  137.         // Inizializzo PageData
  138.         PageData pd = new PageData();

  140.         ArchiviHelper archiviHelper = null;
  141.         
  142.         byte[] docBytes = null;
  143.         String fileName = null;
  144.         
  145.         try {
  146.             archiviHelper = new ArchiviHelper(request, pd, session);

  148.             ControlStationCore.logDebug("Ricevuta Richiesta di esportazione...");
  149.             Enumeration<?> en = archiviHelper.getParameterNames();
  150.             ControlStationCore.logDebug("Parametri (nome = valore):\n-----------------");
  151.             while (en.hasMoreElements()) {
  152.                 String param = (String) en.nextElement();
  153.                 String value = archiviHelper.getParameter(param);
  154.                 ControlStationCore.logDebug(param + " = " + value);
  155.             }
  156.             ControlStationCore.logDebug("-----------------");

  158.             String idAllegato = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_ID_ALLEGATO);
  159.             String idAccordo = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_ID_ACCORDO);
  160.             String tipoDocumento = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO);
  161.             String tipoDocumentoDaScaricare = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO);
  162.             if(tipoDocumentoDaScaricare==null || "".equals(tipoDocumentoDaScaricare)){
  163.                 tipoDocumentoDaScaricare = ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_DOCUMENTO;
  164.             }

  166.             String tipoSoggettoFruitore = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_WSDL_IMPLEMENTATIVO_TIPO_SOGGETTO_FRUITORE);
  167.             String nomeSoggettoFruitore = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_WSDL_IMPLEMENTATIVO_NOME_SOGGETTO_FRUITORE);

  169.             long idAccordoLong = getIdAccordoLong(idAccordo);

  171.             ArchiviCore archiviCore = new ArchiviCore();
  172.             ProtocolPropertiesCore ppCore = new ProtocolPropertiesCore(archiviCore);
  173.             PorteDelegateCore pdCore = new PorteDelegateCore(archiviCore);
  174.             PorteApplicativeCore paCore = new PorteApplicativeCore(archiviCore);

  176.             if( ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_DOCUMENTO.equals(tipoDocumentoDaScaricare) ){

  178.                 long idAllegatoInt = Long.parseLong(idAllegato);

  180.                 if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_PARTE_COMUNE.equals(tipoDocumento)
  181.                         ||
  182.                         ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_PARTE_SPECIFICA.equals(tipoDocumento)
  183.                         ||
  184.                         ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_COOPERAZIONE.equals(tipoDocumento)){
  185.                     Documento doc = archiviCore.getDocumento(idAllegatoInt,true);
  186.                     fileName = doc.getFile();
  187.                     docBytes = doc.getByteContenuto();
  188.                 }
  189.                 else{
  190.                     throw new ServletException("Tipo archivio ["+tipoDocumento+"] non gestito (tipo documento: "+tipoDocumentoDaScaricare+")");
  191.                 }

  193.             }
  194.             else {

  196.                 if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_PARTE_COMUNE.equals(tipoDocumento)){

  198.                     AccordiServizioParteComuneCore asCore = new AccordiServizioParteComuneCore(archiviCore);
  199.                     AccordoServizioParteComune as = asCore.getAccordoServizioFull(idAccordoLong);

  201.                     if( ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_WSDL_DEFINITORIO.equals(tipoDocumentoDaScaricare) ){
  202.                         fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_INTERFACCIA_DEFINITORIA;
  203.                         docBytes = as.getByteWsdlDefinitorio();
  204.                     }
  205.                     else if( ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_WSDL_CONCETTUALE.equals(tipoDocumentoDaScaricare) ){
  206.                         docBytes = as.getByteWsdlConcettuale();
  207.                         if(as.getFormatoSpecifica()!=null) {
  208.                             switch (as.getFormatoSpecifica()) {
  209.                             case WSDL_11:
  210.                                 fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_CONCETTUALE_WSDL;
  211.                                 break;
  212.                             case OPEN_API_3:
  213.                                 YAMLUtils yamlUtils = YAMLUtils.getInstance();
  214.                                 if(yamlUtils.isYaml(docBytes)) {
  215.                                     fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_OPENAPI_3_0_YAML;
  216.                                 }
  217.                                 else {  
  218.                                     fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_OPENAPI_3_0_JSON;
  219.                                 }
  220.                                 break;
  221.                             case SWAGGER_2:
  222.                                 yamlUtils = YAMLUtils.getInstance();
  223.                                 if(yamlUtils.isYaml(docBytes)) {
  224.                                     fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SWAGGER_2_0_YAML;
  225.                                 }
  226.                                 else {
  227.                                     fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SWAGGER_2_0_JSON;
  228.                                 }
  229.                                 break;
  230.                             case WADL:
  231.                                 fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WADL;
  232.                                 break;
  233.                             }
  234.                         }
  235.                         else {
  236.                             fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_CONCETTUALE_WSDL;
  237.                         }
  238.                     }
  239.                     else if( ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_WSDL_LOGICO_EROGATORE.equals(tipoDocumentoDaScaricare) ){
  240.                         fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_LOGICO_EROGATORE_WSDL;
  241.                         docBytes = as.getByteWsdlLogicoErogatore();
  242.                     }
  243.                     else if( ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_WSDL_LOGICO_FRUITORE.equals(tipoDocumentoDaScaricare) ){
  244.                         fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_LOGICO_FRUITORE_WSDL;
  245.                         docBytes = as.getByteWsdlLogicoFruitore();
  246.                     }
  247.                     else if( ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_SPECIFICA_CONVERSAZIONE_CONCETTUALE.equals(tipoDocumentoDaScaricare) ){
  248.                         fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SPECIFICA_CONVERSIONE_CONCETTUALE;
  249.                         docBytes = as.getByteSpecificaConversazioneConcettuale();
  250.                     }
  251.                     else if( ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_SPECIFICA_CONVERSAZIONE_LOGICO_EROGATORE.equals(tipoDocumentoDaScaricare) ){
  252.                         fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SPECIFICA_CONVERSIONE_LOGICA_EROGATORE;
  253.                         docBytes = as.getByteSpecificaConversazioneErogatore();
  254.                     }
  255.                     else if( ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_SPECIFICA_CONVERSAZIONE_LOGICO_FRUITORE.equals(tipoDocumentoDaScaricare) ){
  256.                         fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_SPECIFICA_CONVERSIONE_LOGICA_FRUITORE;
  257.                         docBytes = as.getByteSpecificaConversazioneFruitore();
  258.                     }
  259.                     else if( ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_XSD_SCHEMA_COLLECTION.equals(tipoDocumentoDaScaricare) ){

  261.                         AccordoServizioParteComune asConAllegati = asCore.getAccordoServizioFull(IDAccordoFactory.getInstance().getIDAccordoFromAccordo(as), true);
  262.                         try{
  263.                             // Nel caso di API REST devo eliminare la parte concettuale/logica poichè non è un wsdl/xsd
  264.                             if( ServiceBinding.REST.equals(asConAllegati.getServiceBinding()) ){
  265.                                 asConAllegati.setByteWsdlConcettuale(null);
  266.                                 asConAllegati.setByteWsdlLogicoErogatore(null);
  267.                                 asConAllegati.setByteWsdlLogicoFruitore(null);
  268.                             }
  269.                             
  270.                             AccordoServizioUtils asUtils = new AccordoServizioUtils(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), ControlStationCore.getLog());
  271.                             XSDSchemaCollection schemaCollection = asUtils.buildSchemaCollection(asConAllegati, true);
  272.                             fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_XSD_SCHEMA_COLLECTION;
  273.                             docBytes = this.serializeWsdl(ControlStationCore.getLog(), schemaCollection, asConAllegati);
  274.                         }
  275.                         catch(Exception e){
  276.                             ControlStationCore.getLog().error("XSDSchemaCollection build error: "+e.getMessage(),e);
  277.                             fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_XSD_SCHEMA_COLLECTION_ERROR;
  278.                             String msg = e.getMessage();
  279.                             if(msg==null || msg.equals("")){
  280.                                 if(e instanceof NullPointerException){
  281.                                     msg = "Internal Error (NP)";
  282.                                 }
  283.                                 else{
  284.                                     msg = e.toString();
  285.                                     if(msg==null || msg.equals("")){
  286.                                         msg = "Internal Error";
  287.                                     }
  288.                                 }
  289.                             }
  290.                             docBytes = msg.getBytes();
  291.                         }

  293.                     }
  294.                     else{
  295.                         throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non gestito per il tipo archivio ["+tipoDocumento+"]");
  296.                     }

  298.                 }
  299.                 else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_PARTE_SPECIFICA.equals(tipoDocumento)){

  301.                     AccordiServizioParteSpecificaCore asCore = new AccordiServizioParteSpecificaCore(archiviCore);
  302.                     AccordoServizioParteSpecifica as = asCore.getAccordoServizioParteSpecifica(idAccordoLong);

  304.                     if( ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_WSDL_IMPLEMENTATIVO_EROGATORE.equals(tipoDocumentoDaScaricare) ){
  305.                         fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_IMPLEMENTATIVO_EROGATORE_WSDL;
  306.                         if(tipoSoggettoFruitore!=null && !"".equals(tipoSoggettoFruitore) &&
  307.                                 nomeSoggettoFruitore!=null && !"".equals(nomeSoggettoFruitore)){
  308.                             for (int i = 0; i < as.sizeFruitoreList(); i++) {
  309.                                 Fruitore f = as.getFruitore(i);
  310.                                 if(tipoSoggettoFruitore.equals(f.getTipo()) && nomeSoggettoFruitore.equals(f.getNome())){
  311.                                     docBytes = f.getByteWsdlImplementativoErogatore();
  312.                                     break;
  313.                                 }
  314.                             }
  315.                         }else{
  316.                             docBytes = as.getByteWsdlImplementativoErogatore();
  317.                         }
  318.                     }
  319.                     else if( ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ACCORDO_TIPO_DOCUMENTO_WSDL_IMPLEMENTATIVO_FRUITORE.equals(tipoDocumentoDaScaricare) ){
  320.                         fileName = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_IMPLEMENTATIVO_FRUITORE_WSDL;
  321.                         if(tipoSoggettoFruitore!=null && !"".equals(tipoSoggettoFruitore) &&
  322.                                 nomeSoggettoFruitore!=null && !"".equals(nomeSoggettoFruitore)){
  323.                             for (int i = 0; i < as.sizeFruitoreList(); i++) {
  324.                                 Fruitore f = as.getFruitore(i);
  325.                                 if(tipoSoggettoFruitore.equals(f.getTipo()) && nomeSoggettoFruitore.equals(f.getNome())){
  326.                                     docBytes = f.getByteWsdlImplementativoFruitore();
  327.                                     break;
  328.                                 }
  329.                             }
  330.                         }else{
  331.                             docBytes = as.getByteWsdlImplementativoFruitore();
  332.                         }
  333.                     }
  334.                     else{
  335.                         throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non gestito per il tipo archivio ["+tipoDocumento+"]");
  336.                     }

  338.                 }
  339.                 else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_PROTOCOL_PROPERTY.equals(tipoDocumento)){
  340.                     if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PROTOCOL_PROPERTY_BINARY.equals(tipoDocumentoDaScaricare)){
  341.                         long idAllegatoInt = Long.parseLong(idAllegato);
  342.                         ProtocolProperty bp = ppCore.getProtocolPropertyBinaria(idAllegatoInt);
  343.                         fileName = bp.getFile();
  344.                         docBytes = bp.getByteFile();
  345.                         docBytes = archiviCore.getDriverBYOKUtilities().unwrap(docBytes); // se cifrato, viene decifrato
  346.                     }else{
  347.                         throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non gestito per il tipo archivio ["+tipoDocumento+"]");
  348.                     }
  349.                 }
  350.                 else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_PORTA_APPLICATIVA.equals(tipoDocumento)){
  351.                     if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_XACML_POLICY.equals(tipoDocumentoDaScaricare)){
  352.                         Long idPorta = Long.parseLong(idAccordo);
  353.                         PortaApplicativa portaApplicativa = paCore.getPortaApplicativa(idPorta);
  354.                         fileName = ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_XACML_POLICY_FILENAME;
  355.                         
  356.                         String policy = portaApplicativa.getXacmlPolicy();

  358.                         if(StringUtils.isEmpty(policy)) {
  359.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  360.                         }

  362.                         docBytes = policy.getBytes();
  363.                     }else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TEMPLATE.equals(tipoDocumentoDaScaricare)){
  364.                         Long idPorta = Long.parseLong(idAccordo);
  365.                         PortaApplicativa portaApplicativa = paCore.getPortaApplicativa(idPorta);
  366.                         fileName = ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TEMPLATE_FILENAME;
  367.                         
  368.                         String idTrasformazioneRegola = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_ID);
  369.                         long idTrasformazione = Long.parseLong(idTrasformazioneRegola);
  370.                         
  371.                         Trasformazioni trasformazioni = portaApplicativa.getTrasformazioni();
  372.                         TrasformazioneRegola oldRegola = null;
  373.                         for (TrasformazioneRegola reg : trasformazioni.getRegolaList()) {
  374.                             if(reg.getId().longValue() == idTrasformazione) {
  375.                                 oldRegola = reg;
  376.                                 break;
  377.                             }
  378.                         }

  380.                         if(oldRegola == null) {
  381.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  382.                         }
  383.                         
  384.                         TrasformazioneRegolaRichiesta richiesta = oldRegola.getRichiesta();
  385.                     
  386.                         if(richiesta == null) {
  387.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  388.                         }
  389.                         
  390.                         if(richiesta.getConversioneTemplate() == null) {
  391.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  392.                         }
  393.                         
  394.                         org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione tipo = StringUtils.isNotEmpty(richiesta.getConversioneTipo()) ? 
  395.                                 org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(richiesta.getConversioneTipo()) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;

  397.                         switch(tipo) {
  398.                         case FREEMARKER_TEMPLATE:
  399.                         case CONTEXT_FREEMARKER_TEMPLATE:
  400.                         case FREEMARKER_TEMPLATE_ZIP:
  401.                         case VELOCITY_TEMPLATE:
  402.                         case CONTEXT_VELOCITY_TEMPLATE:
  403.                         case VELOCITY_TEMPLATE_ZIP:
  404.                         case TEMPLATE:
  405.                         case XSLT:
  406.                         case ZIP:
  407.                         case TGZ:
  408.                         case TAR:
  409.                             fileName += tipo.getExt();
  410.                             break;
  411.                         case EMPTY:
  412.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] '"+tipo+"' non disponibile per il tipo archivio ["+tipoDocumento+"]: tipo non supportato");
  413.                         }
  414.                         
  415. /**                     if(fileName==null) {
  416. //                          throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] '"+tipo+"' non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  417. //                      }*/

  419.                         docBytes = richiesta.getConversioneTemplate();
  420.                     }else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TEMPLATE.equals(tipoDocumentoDaScaricare)){
  421.                         Long idPorta = Long.parseLong(idAccordo);
  422.                         PortaApplicativa portaApplicativa = paCore.getPortaApplicativa(idPorta);
  423.                         fileName = ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TEMPLATE_FILENAME;
  424.                         
  425.                         String idTrasformazioneRegola = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_ID);
  426.                         long idTrasformazione = Long.parseLong(idTrasformazioneRegola);
  427.                         
  428.                         Trasformazioni trasformazioni = portaApplicativa.getTrasformazioni();
  429.                         TrasformazioneRegola oldRegola = null;
  430.                         for (TrasformazioneRegola reg : trasformazioni.getRegolaList()) {
  431.                             if(reg.getId().longValue() == idTrasformazione) {
  432.                                 oldRegola = reg;
  433.                                 break;
  434.                             }
  435.                         }

  437.                         if(oldRegola == null) {
  438.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  439.                         }
  440.                         
  441.                         TrasformazioneRegolaRichiesta richiesta = oldRegola.getRichiesta();
  442.                     
  443.                         if(richiesta == null) {
  444.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  445.                         }
  446.                         
  447.                         if(richiesta.getTrasformazioneSoap() == null) {
  448.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  449.                         }

  451.                         TrasformazioneSoap trasformazioneSoap = richiesta.getTrasformazioneSoap();
  452.                         
  453.                         if( trasformazioneSoap.getEnvelopeBodyConversioneTemplate() == null) {
  454.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  455.                         }
  456.                         
  457.                         org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione tipo = StringUtils.isNotEmpty(trasformazioneSoap.getEnvelopeBodyConversioneTipo()) ? 
  458.                                 org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(trasformazioneSoap.getEnvelopeBodyConversioneTipo()) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;

  460.                         switch(tipo) {
  461.                         case FREEMARKER_TEMPLATE:
  462.                         case CONTEXT_FREEMARKER_TEMPLATE:
  463.                         case FREEMARKER_TEMPLATE_ZIP:
  464.                         case VELOCITY_TEMPLATE:
  465.                         case CONTEXT_VELOCITY_TEMPLATE:
  466.                         case VELOCITY_TEMPLATE_ZIP:
  467.                         case TEMPLATE:
  468.                         case XSLT:
  469.                         case ZIP:
  470.                         case TGZ:
  471.                         case TAR:
  472.                             fileName += tipo.getExt();
  473.                             break;
  474.                         case EMPTY:
  475.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  476.                         }

  478.                         docBytes = trasformazioneSoap.getEnvelopeBodyConversioneTemplate();
  479.                     }else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TEMPLATE.equals(tipoDocumentoDaScaricare)){
  480.                         Long idPorta = Long.parseLong(idAccordo);
  481.                         PortaApplicativa portaApplicativa = paCore.getPortaApplicativa(idPorta);
  482.                         fileName = ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TEMPLATE_FILENAME;

  484.                         String idTrasformazioneRegola = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_ID);
  485.                         long idTrasformazione = Long.parseLong(idTrasformazioneRegola);
  486.                         
  487.                         String idTrasformazioneRegolaRes = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_RES_ID);
  488.                         long idTrasformazioneRisposta = Long.parseLong(idTrasformazioneRegolaRes);
  489.                         
  490.                         Trasformazioni trasformazioni = portaApplicativa.getTrasformazioni();
  491.                         TrasformazioneRegola oldRegola = null;
  492.                         for (TrasformazioneRegola reg : trasformazioni.getRegolaList()) {
  493.                             if(reg.getId().longValue() == idTrasformazione) {
  494.                                 oldRegola = reg;
  495.                                 break;
  496.                             }
  497.                         }

  499.                         if(oldRegola == null) {
  500.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  501.                         }
  502.                         
  503.                         TrasformazioneRegolaRisposta oldRisposta = null;
  504.                         for (int j = 0; j < oldRegola.sizeRispostaList(); j++) {
  505.                             TrasformazioneRegolaRisposta risposta = oldRegola.getRisposta(j);
  506.                             if (risposta.getId().longValue() == idTrasformazioneRisposta) {
  507.                                 oldRisposta = risposta;
  508.                                 break;
  509.                             }
  510.                         }
  511.                         
  512.                         if(oldRisposta == null) {
  513.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  514.                         }
  515.                         
  516.                         if(oldRisposta.getConversioneTemplate() == null) {
  517.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  518.                         }
  519.                         
  520.                         org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione tipo = StringUtils.isNotEmpty(oldRisposta.getConversioneTipo()) ? 
  521.                                 org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(oldRisposta.getConversioneTipo()) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;

  523.                         switch(tipo) {
  524.                         case FREEMARKER_TEMPLATE:
  525.                         case CONTEXT_FREEMARKER_TEMPLATE:
  526.                         case FREEMARKER_TEMPLATE_ZIP:
  527.                         case VELOCITY_TEMPLATE:
  528.                         case CONTEXT_VELOCITY_TEMPLATE:
  529.                         case VELOCITY_TEMPLATE_ZIP:
  530.                         case TEMPLATE:
  531.                         case XSLT:
  532.                         case ZIP:
  533.                         case TGZ:
  534.                         case TAR:
  535.                             fileName += tipo.getExt();
  536.                             break;
  537.                         case EMPTY:
  538.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  539.                         }
  540.                                 
  541.                         docBytes = oldRisposta.getConversioneTemplate();
  542.                     }else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TEMPLATE.equals(tipoDocumentoDaScaricare)){
  543.                         Long idPorta = Long.parseLong(idAccordo);
  544.                         PortaApplicativa portaApplicativa = paCore.getPortaApplicativa(idPorta);
  545.                         fileName = ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TEMPLATE_FILENAME;
  546.                         
  547.                         String idTrasformazioneRegola = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_ID);
  548.                         long idTrasformazione = Long.parseLong(idTrasformazioneRegola);
  549.                         
  550.                         String idTrasformazioneRegolaRes = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_APPLICATIVA_CONFIGURAZIONE_TRASFORMAZIONI_RES_ID);
  551.                         long idTrasformazioneRisposta = Long.parseLong(idTrasformazioneRegolaRes);

  553.                         Trasformazioni trasformazioni = portaApplicativa.getTrasformazioni();
  554.                         TrasformazioneRegola oldRegola = null;
  555.                         for (TrasformazioneRegola reg : trasformazioni.getRegolaList()) {
  556.                             if(reg.getId().longValue() == idTrasformazione) {
  557.                                 oldRegola = reg;
  558.                                 break;
  559.                             }
  560.                         }

  562.                         if(oldRegola == null) {
  563.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  564.                         }
  565.                         
  566.                         TrasformazioneRegolaRisposta oldRisposta = null;
  567.                         for (int j = 0; j < oldRegola.sizeRispostaList(); j++) {
  568.                             TrasformazioneRegolaRisposta risposta = oldRegola.getRisposta(j);
  569.                             if (risposta.getId().longValue() == idTrasformazioneRisposta) {
  570.                                 oldRisposta = risposta;
  571.                                 break;
  572.                             }
  573.                         }
  574.                         
  575.                         if(oldRisposta == null) {
  576.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  577.                         }
  578.                         
  579.                         if(oldRisposta.getTrasformazioneSoap() == null) {
  580.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  581.                         }

  583.                         TrasformazioneSoapRisposta trasformazioneSoap = oldRisposta.getTrasformazioneSoap();
  584.                         
  585.                         if( trasformazioneSoap.getEnvelopeBodyConversioneTemplate() == null) {
  586.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  587.                         }
  588.                         
  589.                         org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione tipo = StringUtils.isNotEmpty(trasformazioneSoap.getEnvelopeBodyConversioneTipo()) ? 
  590.                                 org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(trasformazioneSoap.getEnvelopeBodyConversioneTipo()) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;

  592.                         switch(tipo) {
  593.                         case FREEMARKER_TEMPLATE:
  594.                         case CONTEXT_FREEMARKER_TEMPLATE:
  595.                         case FREEMARKER_TEMPLATE_ZIP:
  596.                         case VELOCITY_TEMPLATE:
  597.                         case CONTEXT_VELOCITY_TEMPLATE:
  598.                         case VELOCITY_TEMPLATE_ZIP:
  599.                         case TEMPLATE:
  600.                         case XSLT:
  601.                         case ZIP:
  602.                         case TGZ:
  603.                         case TAR:
  604.                             fileName += tipo.getExt();
  605.                             break;
  606.                         case EMPTY:
  607.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  608.                         }

  610.                         docBytes = trasformazioneSoap.getEnvelopeBodyConversioneTemplate();
  611.                     }else {
  612.                         throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non gestito per il tipo archivio ["+tipoDocumento+"]");
  613.                     }
  614.                 }
  615.                 else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_PORTA_DELEGATA.equals(tipoDocumento)){
  616.                     if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_XACML_POLICY.equals(tipoDocumentoDaScaricare)){
  617.                         Long idPorta = Long.parseLong(idAccordo);
  618.                         PortaDelegata portaDelegata = pdCore.getPortaDelegata(idPorta);
  619.                         fileName = ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_XACML_POLICY_FILENAME;

  621.                         String policy = portaDelegata.getXacmlPolicy();

  623.                         if(StringUtils.isEmpty(policy)) {
  624.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  625.                         }

  627.                         docBytes = policy.getBytes();
  628.                     }else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TEMPLATE.equals(tipoDocumentoDaScaricare)){
  629.                         Long idPorta = Long.parseLong(idAccordo);
  630.                         PortaDelegata portaDelegata = pdCore.getPortaDelegata(idPorta);
  631.                         fileName = ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_CONVERSIONE_TEMPLATE_FILENAME;

  633.                         String idTrasformazioneRegola = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_ID);
  634.                         long idTrasformazione = Long.parseLong(idTrasformazioneRegola);
  635.                         
  636.                         Trasformazioni trasformazioni = portaDelegata.getTrasformazioni();
  637.                         TrasformazioneRegola oldRegola = null;
  638.                         for (TrasformazioneRegola reg : trasformazioni.getRegolaList()) {
  639.                             if(reg.getId().longValue() == idTrasformazione) {
  640.                                 oldRegola = reg;
  641.                                 break;
  642.                             }
  643.                         }

  645.                         if(oldRegola == null) {
  646.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  647.                         }
  648.                         
  649.                         TrasformazioneRegolaRichiesta richiesta = oldRegola.getRichiesta();
  650.                     
  651.                         if(richiesta == null) {
  652.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  653.                         }
  654.                         
  655.                         if(richiesta.getConversioneTemplate() == null) {
  656.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  657.                         }
  658.                         
  659.                         org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione tipo = StringUtils.isNotEmpty(richiesta.getConversioneTipo()) ? 
  660.                                 org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(richiesta.getConversioneTipo()) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;

  662.                         switch(tipo) {
  663.                         case FREEMARKER_TEMPLATE:
  664.                         case CONTEXT_FREEMARKER_TEMPLATE:
  665.                         case FREEMARKER_TEMPLATE_ZIP:
  666.                         case VELOCITY_TEMPLATE:
  667.                         case CONTEXT_VELOCITY_TEMPLATE:
  668.                         case VELOCITY_TEMPLATE_ZIP:
  669.                         case TEMPLATE:
  670.                         case XSLT:
  671.                         case ZIP:
  672.                         case TGZ:
  673.                         case TAR:
  674.                             fileName += tipo.getExt();
  675.                             break;
  676.                         case EMPTY:
  677.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  678.                         }
  679.                                 
  680.                         docBytes = richiesta.getConversioneTemplate();
  681.                     }else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TEMPLATE.equals(tipoDocumentoDaScaricare)){
  682.                         Long idPorta = Long.parseLong(idAccordo);
  683.                         PortaDelegata portaDelegata = pdCore.getPortaDelegata(idPorta);
  684.                         fileName = ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_SOAP_ENVELOPE_TEMPLATE_FILENAME;
  685.                         
  686.                         String idTrasformazioneRegola = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_ID);
  687.                         long idTrasformazione = Long.parseLong(idTrasformazioneRegola);

  689.                         Trasformazioni trasformazioni = portaDelegata.getTrasformazioni();
  690.                         TrasformazioneRegola oldRegola = null;
  691.                         for (TrasformazioneRegola reg : trasformazioni.getRegolaList()) {
  692.                             if(reg.getId().longValue() == idTrasformazione) {
  693.                                 oldRegola = reg;
  694.                                 break;
  695.                             }
  696.                         }

  698.                         if(oldRegola == null) {
  699.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  700.                         }
  701.                         
  702.                         TrasformazioneRegolaRichiesta richiesta = oldRegola.getRichiesta();
  703.                     
  704.                         if(richiesta == null) {
  705.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  706.                         }
  707.                         
  708.                         if(richiesta.getTrasformazioneSoap() == null) {
  709.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  710.                         }

  712.                         TrasformazioneSoap trasformazioneSoap = richiesta.getTrasformazioneSoap();
  713.                         
  714.                         if( trasformazioneSoap.getEnvelopeBodyConversioneTemplate() == null) {
  715.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  716.                         }
  717.                         
  718.                         org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione tipo = StringUtils.isNotEmpty(trasformazioneSoap.getEnvelopeBodyConversioneTipo()) ? 
  719.                                 org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(trasformazioneSoap.getEnvelopeBodyConversioneTipo()) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;

  721.                         switch(tipo) {
  722.                         case FREEMARKER_TEMPLATE:
  723.                         case CONTEXT_FREEMARKER_TEMPLATE:
  724.                         case FREEMARKER_TEMPLATE_ZIP:
  725.                         case VELOCITY_TEMPLATE:
  726.                         case CONTEXT_VELOCITY_TEMPLATE:
  727.                         case VELOCITY_TEMPLATE_ZIP:
  728.                         case TEMPLATE:
  729.                         case XSLT:
  730.                         case ZIP:
  731.                         case TGZ:
  732.                         case TAR:
  733.                             fileName += tipo.getExt();
  734.                             break;
  735.                         case EMPTY:
  736.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  737.                         }

  739.                         docBytes = trasformazioneSoap.getEnvelopeBodyConversioneTemplate();
  740.                     }else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TEMPLATE.equals(tipoDocumentoDaScaricare)){
  741.                         Long idPorta = Long.parseLong(idAccordo);
  742.                         PortaDelegata portaDelegata = pdCore.getPortaDelegata(idPorta);
  743.                         fileName = ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_CONVERSIONE_TEMPLATE_FILENAME;

  745.                         String idTrasformazioneRegola = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_ID);
  746.                         long idTrasformazione = Long.parseLong(idTrasformazioneRegola);
  747.                         
  748.                         String idTrasformazioneRegolaRes = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_RES_ID);
  749.                         long idTrasformazioneRisposta = Long.parseLong(idTrasformazioneRegolaRes);
  750.                         
  751.                         Trasformazioni trasformazioni = portaDelegata.getTrasformazioni();
  752.                         TrasformazioneRegola oldRegola = null;
  753.                         for (TrasformazioneRegola reg : trasformazioni.getRegolaList()) {
  754.                             if(reg.getId().longValue() == idTrasformazione) {
  755.                                 oldRegola = reg;
  756.                                 break;
  757.                             }
  758.                         }

  760.                         if(oldRegola == null) {
  761.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  762.                         }
  763.                         
  764.                         TrasformazioneRegolaRisposta oldRisposta = null;
  765.                         for (int j = 0; j < oldRegola.sizeRispostaList(); j++) {
  766.                             TrasformazioneRegolaRisposta risposta = oldRegola.getRisposta(j);
  767.                             if (risposta.getId().longValue() == idTrasformazioneRisposta) {
  768.                                 oldRisposta = risposta;
  769.                                 break;
  770.                             }
  771.                         }
  772.                         
  773.                         if(oldRisposta == null) {
  774.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  775.                         }
  776.                         
  777.                         if(oldRisposta.getConversioneTemplate() == null) {
  778.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  779.                         }
  780.                         
  781.                         org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione tipo = StringUtils.isNotEmpty(oldRisposta.getConversioneTipo()) ? 
  782.                                 org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(oldRisposta.getConversioneTipo()) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;

  784.                         switch(tipo) {
  785.                         case FREEMARKER_TEMPLATE:
  786.                         case CONTEXT_FREEMARKER_TEMPLATE:
  787.                         case FREEMARKER_TEMPLATE_ZIP:
  788.                         case VELOCITY_TEMPLATE:
  789.                         case CONTEXT_VELOCITY_TEMPLATE:
  790.                         case VELOCITY_TEMPLATE_ZIP:
  791.                         case TEMPLATE:
  792.                         case XSLT:
  793.                         case ZIP:
  794.                         case TGZ:
  795.                         case TAR:
  796.                             fileName += tipo.getExt();
  797.                             break;
  798.                         case EMPTY:
  799.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  800.                         }
  801.                                 
  802.                         docBytes = oldRisposta.getConversioneTemplate();
  803.                     }else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TEMPLATE.equals(tipoDocumentoDaScaricare)){
  804.                         Long idPorta = Long.parseLong(idAccordo);
  805.                         PortaDelegata portaDelegata = pdCore.getPortaDelegata(idPorta);
  806.                         fileName = ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_RISPOSTA_SOAP_ENVELOPE_TEMPLATE_FILENAME;
  807.                         
  808.                         String idTrasformazioneRegola = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_REQ_ID);
  809.                         long idTrasformazione = Long.parseLong(idTrasformazioneRegola);
  810.                         
  811.                         String idTrasformazioneRegolaRes = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_PORTA_DELEGATA_CONFIGURAZIONE_TRASFORMAZIONI_RES_ID);
  812.                         long idTrasformazioneRisposta = Long.parseLong(idTrasformazioneRegolaRes);

  814.                         Trasformazioni trasformazioni = portaDelegata.getTrasformazioni();
  815.                         TrasformazioneRegola oldRegola = null;
  816.                         for (TrasformazioneRegola reg : trasformazioni.getRegolaList()) {
  817.                             if(reg.getId().longValue() == idTrasformazione) {
  818.                                 oldRegola = reg;
  819.                                 break;
  820.                             }
  821.                         }

  823.                         if(oldRegola == null) {
  824.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  825.                         }
  826.                         
  827.                         TrasformazioneRegolaRisposta oldRisposta = null;
  828.                         for (int j = 0; j < oldRegola.sizeRispostaList(); j++) {
  829.                             TrasformazioneRegolaRisposta risposta = oldRegola.getRisposta(j);
  830.                             if (risposta.getId().longValue() == idTrasformazioneRisposta) {
  831.                                 oldRisposta = risposta;
  832.                                 break;
  833.                             }
  834.                         }
  835.                         
  836.                         if(oldRisposta == null) {
  837.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  838.                         }
  839.                         
  840.                         if(oldRisposta.getTrasformazioneSoap() == null) {
  841.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  842.                         }

  844.                         TrasformazioneSoapRisposta trasformazioneSoap = oldRisposta.getTrasformazioneSoap();
  845.                         
  846.                         if( trasformazioneSoap.getEnvelopeBodyConversioneTemplate() == null) {
  847.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  848.                         }
  849.                         
  850.                         org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione tipo = StringUtils.isNotEmpty(trasformazioneSoap.getEnvelopeBodyConversioneTipo()) ? 
  851.                                 org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.toEnumConstant(trasformazioneSoap.getEnvelopeBodyConversioneTipo()) : org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione.EMPTY;

  853.                         switch(tipo) {
  854.                         case FREEMARKER_TEMPLATE:
  855.                         case CONTEXT_FREEMARKER_TEMPLATE:
  856.                         case FREEMARKER_TEMPLATE_ZIP:
  857.                         case VELOCITY_TEMPLATE:
  858.                         case CONTEXT_VELOCITY_TEMPLATE:
  859.                         case VELOCITY_TEMPLATE_ZIP:
  860.                         case TEMPLATE:
  861.                         case XSLT:
  862.                         case ZIP:
  863.                         case TGZ:
  864.                         case TAR:
  865.                             fileName += tipo.getExt();
  866.                             break;
  867.                         case EMPTY:
  868.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non disponibile per il tipo archivio ["+tipoDocumento+"]: contenuto vuoto o non presente");
  869.                         }

  871.                         docBytes = trasformazioneSoap.getEnvelopeBodyConversioneTemplate();
  872.                     }else {
  873.                         throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non gestito per il tipo archivio ["+tipoDocumento+"]");
  874.                     }
  875.                 }else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_SOGGETTO.equals(tipoDocumento)){
  876.                     if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_CERTIFICATO_SSL.equals(tipoDocumentoDaScaricare)){
  877.                         Long idSogg = Long.parseLong(idAccordo);
  878.                         SoggettiCore soggettiCore = new SoggettiCore(archiviCore);

  880.                         String oldnomeprov = null;
  881.                         String oldtipoprov = null;
  882.                         if(soggettiCore.isRegistroServiziLocale()){
  883.                             org.openspcoop2.core.registry.Soggetto soggettoRegistry = soggettiCore.getSoggettoRegistro(idSogg); 
  884.                             oldnomeprov = soggettoRegistry.getNome();
  885.                             oldtipoprov = soggettoRegistry.getTipo();
  886.                         }
  887.                         else{
  888.                             Soggetto soggettoConfig = soggettiCore.getSoggetto(idSogg); 
  889.                             oldnomeprov = soggettoConfig.getNome();
  890.                             oldtipoprov = soggettoConfig.getTipo();
  891.                         }

  893.                         IDSoggetto idSoggetto = new IDSoggetto(oldtipoprov,oldnomeprov);
  894.                         String protocollo = soggettiCore.getProtocolloAssociatoTipoSoggetto(oldtipoprov);
  895.                         IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  896.                         IRegistryReader registryReader = soggettiCore.getRegistryReader(protocolFactory);

  898.                         int posizioneCredenziale = 0;
  899.                         String pos = archiviHelper.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CREDENZIALI_ID);
  900.                         if(StringUtils.isNotEmpty(pos)) {
  901.                             posizioneCredenziale = Integer.valueOf(pos);
  902.                         }
  903.                         
  904.                         CredenzialiSoggetto credenziali = null;
  905.                         org.openspcoop2.core.registry.Soggetto soggetto = null;
  906.                         try{
  907.                             soggetto =  registryReader.getSoggetto(idSoggetto);
  908.                             if(soggetto.sizeCredenzialiList()>0) {
  909.                                 credenziali = soggetto.getCredenziali(posizioneCredenziale);
  910.                             }
  911.                         }catch(RegistryNotFound r){
  912.                             // rilancio
  913.                             throw r;
  914.                         }
  915.                         
  916.                         fileName = soggetto.getNome() + ".crt";
  917.                         
  918.                         if(credenziali != null && credenziali.getTipo() != null && credenziali.getTipo().equals(CredenzialeTipo.SSL)) {
  919.                             if(credenziali.getCertificate() != null && credenziali.getCertificate().length > 0) {
  920.                                 docBytes = credenziali.getCertificate();
  921.                             } else {
  922.                                 throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non definito per il tipo archivio ["+tipoDocumento+"]");
  923.                             }
  924.                         } else 
  925.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non definito per il tipo archivio ["+tipoDocumento+"]");
  926.                     }else{
  927.                         throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non gestito per il tipo archivio ["+tipoDocumento+"]");
  928.                     }
  929.                 }else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_SERVIZIO_APPLICATIVO.equals(tipoDocumento)){
  930.                     if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_DOCUMENTO_CERTIFICATO_SSL.equals(tipoDocumentoDaScaricare)){
  931.                         Long idSA = Long.parseLong(idAccordo);
  932.                         ServiziApplicativiCore saCore = new ServiziApplicativiCore(archiviCore);
  933.                         ServizioApplicativo sa = saCore.getServizioApplicativo(idSA);
  934.                         
  935.                         fileName = sa.getNome() + ".crt";
  936.                         
  937.                         int posizioneCredenziale = 0;
  938.                         String pos = archiviHelper.getParameter(ConnettoriCostanti.PARAMETRO_CREDENZIALI_AUTENTICAZIONE_CREDENZIALI_ID);
  939.                         if(StringUtils.isNotEmpty(pos)) {
  940.                             posizioneCredenziale = Integer.valueOf(pos);
  941.                         }
  942.                         
  943.                         InvocazionePorta ip = sa.getInvocazionePorta();
  944.                         Credenziali credenziali = null;
  945.                         if (ip != null &&
  946.                             ip.sizeCredenzialiList()>0) {
  947.                             credenziali = ip.getCredenziali(posizioneCredenziale);
  948.                         }
  949.                         
  950.                         if(credenziali != null && credenziali.getTipo() != null && credenziali.getTipo().equals(org.openspcoop2.core.config.constants.CredenzialeTipo.SSL)) {
  951.                             if(credenziali.getCertificate() != null && credenziali.getCertificate().length > 0) {
  952.                                 docBytes = credenziali.getCertificate();
  953.                             } else {
  954.                                 throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non definito per il tipo archivio ["+tipoDocumento+"]");
  955.                             }
  956.                         } else 
  957.                             throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non definito per il tipo archivio ["+tipoDocumento+"]");
  958.                     }else{
  959.                         throw new ServletException("Tipo documento ["+tipoDocumentoDaScaricare+"] non gestito per il tipo archivio ["+tipoDocumento+"]");
  960.                     }
  961.                 }
  962.                 else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_CONNETTORE_CERTIFICATO_SERVER.equals(tipoDocumento)){
  963.                     
  964.                     String aliasForVerificaConnettore = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_ALIAS_CONNETTORE);
  965.                     
  966.                     String tipoConnettoreRegistro = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_TIPO_CONNETTORE_REGISTRO);
  967.                     boolean connettoreRegistro = ServletUtils.isCheckBoxEnabled(tipoConnettoreRegistro);
  968.                     String labelConnettore = connettoreRegistro ? "connettore del registro" : "connettore della configurazione";
  969.                     
  970.                     String idConnettore = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_ID_CONNETTORE);
  971.                     
  972.                     String tokenTipologia = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_TOKEN_TIPOLOGIA);
  973.                     String tokenNome= archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_TOKEN_NOME);
  974.                     String tokenConnettoreTipo = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_TOKEN_TIPO);
  975.                     
  976.                     String nameConnettore = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_CERTIFICATI_SERVER_NOME_CONNETTORE);
  977.                     
  978.                     fileName = nameConnettore + ".pem";
  979.                     
  980.                     String risorsa = null;
  981.                     if(connettoreRegistro) {
  982.                         risorsa = archiviCore.getJmxPdDConfigurazioneSistemaNomeRisorsaAccessoRegistroServizi(aliasForVerificaConnettore);
  983.                     }
  984.                     else {
  985.                         risorsa = archiviCore.getJmxPdDConfigurazioneSistemaNomeRisorsaConfigurazionePdD(aliasForVerificaConnettore);
  986.                     }
  987.                     
  988.                     String metodo = null;
  989.                     List<Object> parameters = new ArrayList<>();
  990.                     if(idConnettore!=null) {
  991.                         metodo = archiviCore.getJmxPdDConfigurazioneSistemaNomeMetodoGetCertificatiConnettoreById(aliasForVerificaConnettore);
  992.                         parameters.add(idConnettore+"");
  993.                     }
  994.                     else if(tokenTipologia!=null) {
  995.                         if(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_GESTIONE_POLICY_TOKEN.equals(tokenTipologia)) {
  996.                             metodo = archiviCore.getJmxPdDConfigurazioneSistemaNomeMetodoGetCertificatiConnettoreTokenPolicyValidazione(aliasForVerificaConnettore);
  997.                             parameters.add(tokenNome);
  998.                             if(tokenConnettoreTipo!=null && StringUtils.isNotEmpty(tokenConnettoreTipo)) {
  999.                                 parameters.add(tokenConnettoreTipo);
  1000.                             }
  1001.                         }
  1002.                         else if(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_RETRIEVE_POLICY_TOKEN.equals(tokenTipologia)) {
  1003.                             metodo = archiviCore.getJmxPdDConfigurazioneSistemaNomeMetodoGetCertificatiConnettoreTokenPolicyNegoziazione(aliasForVerificaConnettore);
  1004.                             parameters.add(tokenNome);
  1005.                         }
  1006.                         else if(ConfigurazioneCostanti.DEFAULT_VALUE_PARAMETRO_CONFIGURAZIONE_GESTORE_POLICY_TOKEN_TIPOLOGIA_ATTRIBUTE_AUTHORITY.equals(tokenTipologia)) {
  1007.                             metodo = archiviCore.getJmxPdDConfigurazioneSistemaNomeMetodoGetCertificatiConnettoreAttributeAuthority(aliasForVerificaConnettore);
  1008.                             parameters.add(tokenNome);
  1009.                         }
  1010.                         else {
  1011.                             throw new DriverControlStationException("Tipologia '"+tokenTipologia+"' da utilizzare per l'export dei certificati server non supportata");
  1012.                         }
  1013.                     }
  1014.                     else {
  1015.                         throw new DriverControlStationException("Nessuna risorsa definita da cui effettuare l'export dei certificati server");
  1016.                     }
  1017.                     
  1018.                     try{
  1019.                         String stato = archiviCore.getInvoker().invokeJMXMethod(aliasForVerificaConnettore, archiviCore.getJmxPdDConfigurazioneSistemaType(aliasForVerificaConnettore),
  1020.                                 risorsa, 
  1021.                                 metodo, 
  1022.                                 parameters.toArray());
  1023.                         if(stato==null) {
  1024.                             throw new ServletException("Recupero certificati server fallito");
  1025.                         }
  1026.                         if(stato==null || stato.startsWith(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA)) {
  1027.                             throw new ServletException(stato);
  1028.                         }
  1029.                         else {
  1030.                             docBytes = stato.getBytes();
  1031.                         }
  1032.                     }catch(Exception e){
  1033.                         String msgErrore = "Errore durante il recupero dei certificati server del "+labelConnettore+" con parametri '"+parameters+"' (jmxResource '"+risorsa+"') (node:"+aliasForVerificaConnettore+"): "+e.getMessage();
  1034.                         ControlStationCore.logError(msgErrore, e);
  1035.                         /**throw new ServletException(msgErrore);*/
  1036.                         // se lancio una eccezione ho il crash dell'interfaccia. Ritorno anzi un file errato.
  1037.                         fileName+=".error";
  1038.                         docBytes = msgErrore.getBytes();
  1039.                     }
  1040.                 }
  1041.                 else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_ARCHIVIO_JAR.equals(tipoDocumento)){
  1042.                     
  1043.                     String nomePlugin = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_JAR_NOME_PLUGIN);
  1044.                     String nomeJar = archiviHelper.getParameter(ArchiviCostanti.PARAMETRO_ARCHIVI_JAR_NOME_ARCHVIO);
  1045.                     
  1046.                     fileName = nomeJar;
  1047.                     
  1048.                     ConfigurazioneCore confCore = new ConfigurazioneCore(archiviCore);
  1049.                     try{
  1050.                         RegistroPluginArchivio jar = confCore.getRegistroPluginArchivio(nomePlugin, nomeJar);
  1051.                         docBytes = jar.getContenuto();
  1052.                     }catch(Exception e){
  1053.                         String msgErrore = "Errore durante il recupero dell'archivio jar '"+nomeJar+"' del plugin "+nomePlugin+": "+e.getMessage();
  1054.                         ControlStationCore.logError(msgErrore, e);
  1055.                         /**throw new ServletException(msgErrore);*/
  1056.                         // se lancio una eccezione ho il crash dell'interfaccia. Ritorno anzi un file errato.
  1057.                         fileName+=".error";
  1058.                         docBytes = msgErrore.getBytes();
  1059.                     }
  1060.                 }else if(ArchiviCostanti.PARAMETRO_VALORE_ARCHIVI_ALLEGATO_TIPO_REMOTE_STORE_ENTRY.equals(tipoDocumento)){
  1061.                     RemoteStoresCore remoteStoresCore = new RemoteStoresCore(archiviCore);
  1062.                     
  1063.                     RemoteStoreKeyEntry remoteStoreKeyEntry = remoteStoresCore.getRemoteStoreKeyEntry(idAccordoLong);
  1064.                     fileName = remoteStoreKeyEntry.getKid() + ".jwk";
  1065.                     docBytes = remoteStoreKeyEntry.getContentKey();
  1066.                 }
  1067.                 else{
  1068.                     throw new ServletException("Tipo archivio ["+tipoDocumento+"] non gestito (tipo documento: "+tipoDocumentoDaScaricare+")");
  1069.                 }

  1071.             } 

  1073.             // Setto Proprietà Export File
  1074.             HttpUtilities.setOutputFile(response, true, fileName);

  1076.             if(docBytes!=null) {
  1077.                 OutputStream out = response.getOutputStream();  
  1078.                 out.write(docBytes);
  1079.                 out.flush();
  1080.                 out.close();
  1081.             }

  1083.         } catch (Exception e) {
  1084.             ControlStationCore.logError("Errore durante il download dei documenti "+e.getMessage(), e);
  1085.         } 
  1086.     }

  1088.     private long getIdAccordoLong(String idAccordo){
  1089.         long idAccordoLong = 0;
  1090.         try{ idAccordoLong = Long.valueOf(idAccordo); }catch(Exception e){ idAccordoLong = 0 ; }
  1091.         return idAccordoLong;
  1092.     }

  1094.     private byte[] serializeWsdl(Logger log,XSDSchemaCollection schemaCollection, AccordoServizioParteComune asConAllegati) throws XMLException{
  1095.         try{
  1096.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1097.             serializeWsdl(log,bout,schemaCollection,asConAllegati);
  1098.             bout.flush();
  1099.             bout.close();
  1100.             return bout.toByteArray();
  1101.         }catch(Exception e){
  1102.             throw new XMLException(e.getMessage(),e);
  1103.         }
  1104.     }
  1105.     private void serializeWsdl(Logger log,OutputStream out,XSDSchemaCollection schemaCollection, AccordoServizioParteComune asConAllegati) throws XMLException{

  1107.         ZipOutputStream zipOut = null;
  1108.         try{
  1109.             zipOut = new ZipOutputStream(out);

  1111.             schemaCollection.zipSerialize(log, zipOut);

  1113.             String rootPackageDir = "wsdl"+File.separatorChar;

  1115.             if(asConAllegati.getByteWsdlLogicoErogatore()!=null){
  1116.                 String nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_LOGICO_EROGATORE_WSDL;
  1117.                 this.writeWsdl(log, rootPackageDir+nomeFile, zipOut, true, asConAllegati);
  1118.             }

  1120.             if(asConAllegati.getByteWsdlLogicoFruitore()!=null){
  1121.                 String nomeFile = Costanti.OPENSPCOOP2_ARCHIVE_ACCORDI_FILE_WSDL_LOGICO_FRUITORE_WSDL;
  1122.                 this.writeWsdl(log, rootPackageDir+nomeFile, zipOut, false, asConAllegati);
  1123.             }

  1125.             zipOut.flush();

  1127.         }catch(Exception e){
  1128.             throw new XMLException(e.getMessage(),e);
  1129.         }finally{
  1130.             try{
  1131.                 if(zipOut!=null)
  1132.                     zipOut.close();
  1133.             }catch(Exception eClose){
  1134.                 // close
  1135.             }
  1136.         }
  1137.     }
  1138.     private void writeWsdl(Logger log,String nomeFile, ZipOutputStream zipOut, boolean erogatore, AccordoServizioParteComune asConAllegati) throws IOException{
  1139.         try{
  1140.             AccordoServizioWrapperUtilities wsdlWrapperUtilities = new AccordoServizioWrapperUtilities(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), log);
  1141.             wsdlWrapperUtilities.setAccordoServizio(new AccordoServizioWrapper());
  1142.             wsdlWrapperUtilities.getAccordoServizioWrapper().setAccordoServizio((AccordoServizioParteComune)asConAllegati.clone());
  1143.             WSDLUtilities wsdlUtilities = new WSDLUtilities(MessageXMLUtils.DEFAULT);
  1144.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  1145.             javax.wsdl.Definition wsdl = null;
  1146.             if(erogatore){
  1147.                 wsdl = wsdlWrapperUtilities.buildWsdlErogatoreFromBytes();
  1148.             }
  1149.             else{
  1150.                 wsdl = wsdlWrapperUtilities.buildWsdlFruitoreFromBytes();
  1151.             }
  1152.             wsdlUtilities.writeWsdlTo(wsdl, bout);
  1153.             bout.flush();
  1154.             bout.close();

  1156.             zipOut.putNextEntry(new ZipEntry(nomeFile));
  1157.             zipOut.write(bout.toByteArray());
  1158.         }catch(Exception e){
  1159.             String tipo = "Erogatore";
  1160.             if(!erogatore){
  1161.                 tipo = "Fruitore";
  1162.             }
  1163.             log.error("Costruzione WSDL "+tipo+" fallita: "+e.getMessage(),e);
  1164.             nomeFile = nomeFile + ".buildFailed.txt";
  1165.             zipOut.putNextEntry(new ZipEntry(nomeFile));
  1166.             String msg = e.getMessage();
  1167.             if(msg==null || msg.equals("")){
  1168.                 if(e instanceof NullPointerException){
  1169.                     msg = "Internal Error (NP)";
  1170.                 }
  1171.                 else{
  1172.                     msg = e.toString();
  1173.                     if(msg==null || msg.equals("")){
  1174.                         msg = "Internal Error";
  1175.                     }
  1176.                 }
  1177.             }
  1178.             zipOut.write(msg.getBytes());
  1179.         }
  1180.     }

  1182. }
Created with JaCoCo 0.8.8.202204050719