SPCoopArchive.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.spcoop.archive;

  23. import java.io.ByteArrayOutputStream;
  24. import java.io.InputStream;
  25. import java.io.OutputStream;
  26. import java.util.List;

  28. import org.openspcoop2.core.id.IDAccordo;
  29. import org.openspcoop2.core.id.IDAccordoCooperazione;
  30. import org.openspcoop2.core.id.IDServizio;
  31. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  32. import org.openspcoop2.core.registry.Operation;
  33. import org.openspcoop2.core.registry.PortType;
  34. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  35. import org.openspcoop2.protocol.basic.archive.BasicArchive;
  36. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  37. import org.openspcoop2.protocol.sdk.ProtocolException;
  38. import org.openspcoop2.protocol.sdk.archive.Archive;
  39. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoCooperazione;
  40. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioComposto;
  41. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteComune;
  42. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
  43. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoDelete;
  44. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImport;
  45. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImportDetail;
  46. import org.openspcoop2.protocol.sdk.archive.ArchiveMode;
  47. import org.openspcoop2.protocol.sdk.archive.ArchiveModeType;
  48. import org.openspcoop2.protocol.sdk.archive.ExportMode;
  49. import org.openspcoop2.protocol.sdk.archive.ImportMode;
  50. import org.openspcoop2.protocol.sdk.archive.MapPlaceholder;
  51. import org.openspcoop2.protocol.sdk.archive.MappingModeTypesExtensions;
  52. import org.openspcoop2.protocol.sdk.constants.ArchiveStatoImport;
  53. import org.openspcoop2.protocol.sdk.constants.ArchiveType;
  54. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  55. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  56. import org.openspcoop2.protocol.spcoop.config.SPCoopProperties;
  57. import org.openspcoop2.protocol.spcoop.constants.SPCoopCostantiArchivi;
  58. import org.openspcoop2.utils.Utilities;
  59. import org.slf4j.Logger;

  61. import it.gov.spcoop.sica.dao.Costanti;
  62. import it.gov.spcoop.sica.wsbl.ConceptualBehavior;

  64. /**
  65.  * SPCoopArchive 
  66.  *
  67.  * @author Poli Andrea (apoli@link.it)
  68.  * @author $Author$
  69.  * @version $Rev$, $Date$
  70.  */
  71. public class SPCoopArchive extends BasicArchive {

  73.     private SPCoopArchiveImport importEngine = null;
  74.     private SPCoopArchiveExport exportEngine = null;
  75.     private SPCoopProperties spcoopProperties = null;
  76.     
  77.     public SPCoopArchive(Logger log, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  78.         super(protocolFactory);
  79.         this.importEngine = new SPCoopArchiveImport(protocolFactory);
  80.         this.exportEngine = new SPCoopArchiveExport(protocolFactory);
  81.         this.spcoopProperties = SPCoopProperties.getInstance(log);
  82.     }

  84.     
  85.     
  86.     
  87.     
  88.     /* ----- Utilita' generali ----- */
  89.     
  90.     @Override
  91.     public MappingModeTypesExtensions getMappingTypesExtensions(ArchiveMode mode)
  92.             throws ProtocolException {
  93.         
  94.         if(this.spcoopProperties.isGestionePackageSICA() && SPCoopCostantiArchivi.CNIPA_MODE.equals(mode) || 
  95.             SPCoopCostantiArchivi.EXPORT_MODE_COMPATIBILITA_CLIENT_SICA.equals(mode) ||
  96.             SPCoopCostantiArchivi.EXPORT_MODE_INFORMAZIONI_COMPLETE.equals(mode) ){

  98.             MappingModeTypesExtensions m = new MappingModeTypesExtensions();
  99.                         
  100.             m.add(org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_ARCHIVE_EXT, 
  101.                         SPCoopCostantiArchivi.TYPE_ALL,
  102.                         SPCoopCostantiArchivi.TYPE_APC,
  103.                         SPCoopCostantiArchivi.TYPE_APS,
  104.                         SPCoopCostantiArchivi.TYPE_ADC,
  105.                         SPCoopCostantiArchivi.TYPE_ASC);
  106.             
  107.             m.add(Costanti.ESTENSIONE_ACCORDO_SERVIZIO_PARTE_COMUNE, 
  108.                         ArchiveType.ACCORDO_SERVIZIO_PARTE_COMUNE,
  109.                         SPCoopCostantiArchivi.TYPE_APC,
  110.                         SPCoopCostantiArchivi.TYPE_ALL);
  111.             
  112.             m.add(Costanti.ESTENSIONE_ACCORDO_SERVIZIO_PARTE_SPECIFICA, 
  113.                         ArchiveType.ACCORDO_SERVIZIO_PARTE_SPECIFICA,
  114.                         SPCoopCostantiArchivi.TYPE_APS,
  115.                         SPCoopCostantiArchivi.TYPE_ALL);
  116.             
  117.             m.add(Costanti.ESTENSIONE_ACCORDO_COOPERAZIONE, 
  118.                         ArchiveType.ACCORDO_COOPERAZIONE,
  119.                         SPCoopCostantiArchivi.TYPE_ADC,
  120.                         SPCoopCostantiArchivi.TYPE_ALL);
  121.             
  122.             m.add(Costanti.ESTENSIONE_ACCORDO_SERVIZIO_COMPOSTO, 
  123.                         ArchiveType.ACCORDO_SERVIZIO_COMPOSTO,
  124.                         SPCoopCostantiArchivi.TYPE_ASC,
  125.                         SPCoopCostantiArchivi.TYPE_ALL);
  126.             
  127.             return m;
  128.         }
  129.         else{
  130.             return super.getMappingTypesExtensions(mode);
  131.         }
  132.     }
  133.     
  134.     /**
  135.      * Imposta per ogni portType e operation presente nell'accordo fornito come parametro 
  136.      * le informazioni di protocollo analizzando i documenti interni agli archivi
  137.      */
  138.     @Override
  139.     public void setProtocolInfo(AccordoServizioParteComune accordoServizioParteComune) throws ProtocolException{
  140.         
  141.         super.setProtocolInfo(accordoServizioParteComune);
  142.         
  143.         try{
  144.             
  145.             String operationAsincronaRichiesta = null;
  146.             String operationAsincronaRisposta = null;
  147.             boolean presenzaWSBLLogicoFruitore = false;
  148.             
  149.             if(accordoServizioParteComune.getByteSpecificaConversazioneConcettuale()!=null){
  150.                 
  151.                 byte [] wsbl = accordoServizioParteComune.getByteSpecificaConversazioneConcettuale();
  152.                 
  153.                 if(!it.gov.spcoop.sica.wsbl.driver.XMLUtils.isConceptualBehavior(wsbl)){
  154.                     if(it.gov.spcoop.sica.wsbl.driver.XMLUtils.isMessageBehavior(wsbl)){
  155.                         throw new Exception("La specifica di conversazione concettuale non e' un documento WSBL ConceptualBehavior, ma erroneamente un documento WSBL MessageBehavior");
  156.                     }else{
  157.                         throw new Exception("La specifica di conversazione concettuale non e' un documento WSBL ConceptualBehavior");
  158.                     }
  159.                 }
  160.     
  161.                 ConceptualBehavior wsblConcettuale = it.gov.spcoop.sica.wsbl.driver.XMLUtils.getConceptualBehavior(this.getProtocolFactory().getLogger(),wsbl);
  162.                 String[]operazioniAsincrone = it.gov.spcoop.sica.wsbl.driver.XMLUtils.getOperazioniAsincrone(wsblConcettuale);
  163.                 
  164.                 operationAsincronaRichiesta = operazioniAsincrone[0];
  165.                 operationAsincronaRisposta = operazioniAsincrone[1];
  166.                 //System.out.println("1: "+operazioniAsincrone[0]);
  167.                 //System.out.println("2: "+operazioniAsincrone[1]);
  168.                 
  169.                 if(accordoServizioParteComune.getByteSpecificaConversazioneFruitore()!=null){
  170.                     presenzaWSBLLogicoFruitore = it.gov.spcoop.sica.wsbl.driver.XMLUtils.isMessageBehavior(wsbl);
  171.                 }
  172.             
  173.                 
  174.                 // Verifico profilo di collaborazione e correlazione in base ai valori presenti nel WSBL
  175.                 // Verifico come nome:
  176.                 // 1. azione
  177.                 // 2. servizio_azione
  178.                 for (PortType ptOpenSPCoop : accordoServizioParteComune.getPortTypeList()) {
  179.                     
  180.                     for (Operation opOpenSPCoop : ptOpenSPCoop.getAzioneList()) {
  181.                         
  182.                         // 1. azione
  183.                         String tmp = opOpenSPCoop.getNome();
  184.                         if(tmp.equals(operationAsincronaRichiesta) || tmp.equals(operationAsincronaRisposta)){
  185.                             if(presenzaWSBLLogicoFruitore){
  186.                                 opOpenSPCoop.setProfiloCollaborazione(CostantiRegistroServizi.ASINCRONO_SIMMETRICO);
  187.                             }else{
  188.                                 opOpenSPCoop.setProfiloCollaborazione(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO);
  189.                             }
  190.                             opOpenSPCoop.setProfAzione(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO);
  191.                             if(tmp.equals(operationAsincronaRisposta)){
  192.                                 opOpenSPCoop.setCorrelata(operationAsincronaRichiesta);
  193.                                 // search servizio della richiesta
  194.                                 for (PortType ptSearch : accordoServizioParteComune.getPortTypeList()) {
  195.                                     boolean found = false;
  196.                                     for (Operation opSearch : ptSearch.getAzioneList()) {
  197.                                         if(opSearch!=null && opSearch.getNome().equals(operationAsincronaRichiesta)){
  198.                                             opOpenSPCoop.setCorrelataServizio(ptSearch.getNome());
  199.                                             found = true;
  200.                                             break;
  201.                                         }
  202.                                     }
  203.                                     if(found){
  204.                                         break;
  205.                                     }
  206.                                 }
  207.                             }
  208.                         }
  209.                         
  210.                         else {
  211.                             // 2. servizio_azione
  212.                             int lengthServizioAzione = (ptOpenSPCoop.getNome().length()+1+opOpenSPCoop.getNome().length());
  213.                             boolean richiesta = (operationAsincronaRichiesta!=null) 
  214.                                 && (operationAsincronaRichiesta.length()==lengthServizioAzione)
  215.                                 && (operationAsincronaRichiesta.startsWith(ptOpenSPCoop.getNome()))
  216.                                 && (operationAsincronaRichiesta.endsWith(opOpenSPCoop.getNome()));
  217.                             boolean risposta = (operationAsincronaRisposta!=null) 
  218.                                 && (operationAsincronaRisposta.length()==lengthServizioAzione)
  219.                                 && (operationAsincronaRisposta.startsWith(ptOpenSPCoop.getNome()))
  220.                                 && (operationAsincronaRisposta.endsWith(opOpenSPCoop.getNome()));
  221.                             if(richiesta || risposta){
  222.                                 //System.out.println("TROVATO ["+richiesta+"] ["+risposta+"]");
  223.                                 if(presenzaWSBLLogicoFruitore){
  224.                                     opOpenSPCoop.setProfiloCollaborazione(CostantiRegistroServizi.ASINCRONO_SIMMETRICO);
  225.                                 }else{
  226.                                     opOpenSPCoop.setProfiloCollaborazione(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO);
  227.                                 }
  228.                                 opOpenSPCoop.setProfAzione(CostantiRegistroServizi.PROFILO_AZIONE_RIDEFINITO);
  229.                                 //System.out.println("PROFILO ["+opOpenSPCoop.getProfiloCollaborazione()+"]");
  230.                                 if(risposta){
  231.                                     // search servizio della richiesta
  232.                                     for (PortType ptSearch : accordoServizioParteComune.getPortTypeList()) {
  233.                                         boolean found = false;
  234.                                         for (Operation opSearch : ptSearch.getAzioneList()) {
  235.                                             int lengthServizioAzioneSearch = (ptSearch.getNome().length()+1+opSearch.getNome().length());
  236.                                             boolean richiestaSearch = (operationAsincronaRichiesta.length()==lengthServizioAzioneSearch)
  237.                                                 && (operationAsincronaRichiesta.startsWith(ptSearch.getNome()))
  238.                                                 && (operationAsincronaRichiesta.endsWith(opSearch.getNome()));
  239.                                             if(richiestaSearch){
  240.                                                 opOpenSPCoop.setCorrelata(opSearch.getNome());
  241.                                                 opOpenSPCoop.setCorrelataServizio(ptSearch.getNome());
  242.                                                 //System.out.println("TROVATA CORRELAZIONE ["+opOpenSPCoop.getCorrelata()+"] ["+opOpenSPCoop.getCorrelataServizio()+"]");
  243.                                                 found = true;
  244.                                                 break;
  245.                                             }
  246.                                         }
  247.                                         if(found){
  248.                                             break;
  249.                                         }
  250.                                     }
  251.                                 }
  252.                             }
  253.                         }
  254.                     }
  255.                 }
  256.             }
  257.             
  258.         }catch(Exception e){
  259.             throw new ProtocolException(e.getMessage(),e);
  260.         }
  261.     }
  262.     
  263.     
  264.     
  265.     
  266.     
  267.     
  268.     
  269.     
  270.     /* ----- Utilita' generali di interpretazione di un Esito ----- */
  271.     
  272.     private String toString(ArchiveEsitoImport archive, boolean importOperation){
  273.         
  274.         StringBuilder bfEsito = new StringBuilder();
  275.         
  276.         // Nel CNIPA ci sono sempre e solo un oggetto.
  277.         
  278.         // Accordi di Cooperazione
  279.         if(archive.getAccordiCooperazione().size()>0){
  280.             bfEsito.append("Accordo di Cooperazione\n");
  281.             try{
  282.                 ArchiveEsitoImportDetail archiveAccordoCooperazione = archive.getAccordiCooperazione().get(0);
  283.                 IDAccordoCooperazione idAccordoCooperazione = ((ArchiveAccordoCooperazione)archiveAccordoCooperazione.getArchiveObject()).getIdAccordoCooperazione();
  284.                 String uriAccordo = this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordoCooperazione);
  285.                 bfEsito.append("\t- [").append(uriAccordo).append("] ");
  286.                 this.esitoUtils.serializeStato(archiveAccordoCooperazione, bfEsito, importOperation);
  287.             }catch(Exception e){
  288.                 bfEsito.append("\t- non importato: ").append(e.getMessage());
  289.             }
  290.         }
  291.         
  292.         
  293.         // Accordi di Servizio Parte Comune
  294.         else if(archive.getAccordiServizioParteComune().size()>0){
  295.             bfEsito.append("Accordi di Servizio Parte Comune\n");
  296.             try{
  297.                 ArchiveEsitoImportDetail archiveAccordoServizioParteComune = archive.getAccordiServizioParteComune().get(0);
  298.                 IDAccordo idAccordo = ((ArchiveAccordoServizioParteComune)archiveAccordoServizioParteComune.getArchiveObject()).getIdAccordoServizioParteComune();
  299.                 String uriAccordo = this.idAccordoFactory.getUriFromIDAccordo(idAccordo);
  300.                 bfEsito.append("\t- [").append(uriAccordo).append("] ");
  301.                 this.esitoUtils.serializeStato(archiveAccordoServizioParteComune, bfEsito, importOperation);
  302.             }catch(Exception e){
  303.                 bfEsito.append("\t- non importato: ").append(e.getMessage());
  304.             }
  305.         }
  306.         
  307.         
  308.         // Accordi di Servizio Parte Specifica (implementano accordi di servizio parte comune)
  309.         else if(archive.getAccordiServizioParteSpecifica().size()>0){
  310.             bfEsito.append("Accordi di Servizio Parte Specifica\n");
  311.             try{
  312.                 ArchiveEsitoImportDetail archiveAccordoServizioParteSpecifica = archive.getAccordiServizioParteSpecifica().get(0);
  313.                 IDServizio idServizio = ((ArchiveAccordoServizioParteSpecifica)archiveAccordoServizioParteSpecifica.getArchiveObject()).getIdAccordoServizioParteSpecifica();
  314.                 String uriAccordo = this.idServizioFactory.getUriFromIDServizio(idServizio);
  315.                 bfEsito.append("\t- [").append(uriAccordo).append("] ");
  316.                 this.esitoUtils.serializeStato(archiveAccordoServizioParteSpecifica, bfEsito, importOperation);
  317.                 if(archiveAccordoServizioParteSpecifica.getState()!=null &&
  318.                         (ArchiveStatoImport.CREATED.equals(archiveAccordoServizioParteSpecifica.getState())) || 
  319.                         ArchiveStatoImport.UPDATED.equals(archiveAccordoServizioParteSpecifica.getState())) {
  320.                     if(archive.getPorteApplicative().size()>0) {
  321.                         bfEsito.append("\n\n!!Attenzione!!: E' stata creata un'erogazione con stato disabilitato.\n\tDefinire correttamente il connettore ed abilitare l'erogazione per renderla operativa");
  322.                     }
  323.                     else if(archive.getPorteDelegate().size()>0) {
  324.                         bfEsito.append("\n\n!!Attenzione!!: E' stata creata una fruizione con stato disabilitato.\n\tDefinire correttamente il connettore ed abilitare la fruizione per renderla operativa");
  325.                     }
  326.                 }
  327.             }catch(Exception e){
  328.                 bfEsito.append("\t- non importato: ").append(e.getMessage());
  329.             }
  330.         }
  331.         
  332.         
  333.         // Accordi di Servizio Composto
  334.         else if(archive.getAccordiServizioComposto().size()>0){
  335.             bfEsito.append("Accordi di Servizio Composto\n");
  336.             try{
  337.                 ArchiveEsitoImportDetail archiveAccordoServizioComposto = archive.getAccordiServizioComposto().get(0);
  338.                 IDAccordo idAccordo = ((ArchiveAccordoServizioComposto)archiveAccordoServizioComposto.getArchiveObject()).getIdAccordoServizioParteComune();
  339.                 String uriAccordo = this.idAccordoFactory.getUriFromIDAccordo(idAccordo);
  340.                 bfEsito.append("\t- [").append(uriAccordo).append("] ");
  341.                 this.esitoUtils.serializeStato(archiveAccordoServizioComposto, bfEsito, importOperation);
  342.             }catch(Exception e){
  343.                 bfEsito.append("\t- non importato: ").append(e.getMessage());
  344.             }
  345.         }
  346.         
  347.         
  348.         // Accordi di Servizio Parte Specifica (implementano accordi di servizio composto)
  349.         if(archive.getAccordiServizioParteSpecificaServiziComposti().size()>0){
  350.             bfEsito.append("Accordi di Servizio Composto Parte Specifica\n");
  351.             try{
  352.                 ArchiveEsitoImportDetail archiveAccordoServizioParteSpecifica = archive.getAccordiServizioParteSpecificaServiziComposti().get(0);
  353.                 IDServizio idServizio = ((ArchiveAccordoServizioParteSpecifica)archiveAccordoServizioParteSpecifica.getArchiveObject()).getIdAccordoServizioParteSpecifica();
  354.                 String uriAccordo = this.idServizioFactory.getUriFromIDServizio(idServizio);
  355.                 bfEsito.append("\t- [").append(uriAccordo).append("] ");
  356.                 this.esitoUtils.serializeStato(archiveAccordoServizioParteSpecifica, bfEsito, importOperation);
  357.             }catch(Exception e){
  358.                 bfEsito.append("\t- non importato: ").append(e.getMessage());
  359.             }
  360.         }
  361.         
  362.         return bfEsito.toString();
  363.     }
  364.     
  365.     
  366.     
  367.     
  368.     
  369.     
  370.     
  371.     
  372.     
  373.     
  374.     /* ----- Import ----- */
  375.     
  376.     @Override
  377.     public List<ImportMode> getImportModes() throws ProtocolException {
  378.         List<ImportMode> list = super.getImportModes();
  379.         if(this.spcoopProperties.isGestionePackageSICA()) {
  380.             list.add(new ImportMode(SPCoopCostantiArchivi.CNIPA_MODE));
  381.         }
  382.         return list;
  383.     }

  385.     @Override
  386.     public Archive importArchive(byte[]archive,ArchiveMode mode,ArchiveModeType type,
  387.             IRegistryReader registryReader,IConfigIntegrationReader configIntegrationReader,
  388.             boolean validationDocuments, MapPlaceholder placeholder) throws ProtocolException { 
  389.         
  390.         if(org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_IMPORT_ARCHIVE_MODE.equals(mode)){
  391.             return super.importArchive(archive, mode, type, registryReader,configIntegrationReader,
  392.                     validationDocuments, placeholder);
  393.         }
  394.         else if(SPCoopCostantiArchivi.CNIPA_MODE.equals(mode)){
  395.             
  396.             if(SPCoopCostantiArchivi.TYPE_APC.equals(type)){
  397.                 try{
  398.                     return this.importEngine.buildAccordoServizioParteComune(archive, registryReader,validationDocuments);
  399.                 }catch(SPCoopConvertToPackageCNIPAException e){
  400.                     throw new ProtocolException(e.getMessage(), e);
  401.                 }
  402.             }
  403.             else if(SPCoopCostantiArchivi.TYPE_ASC.equals(type)){
  404.                 try{
  405.                     return this.importEngine.buildAccordoServizioComposto(archive, registryReader,validationDocuments);
  406.                 }catch(SPCoopConvertToPackageCNIPAException e){
  407.                     throw new ProtocolException(e.getMessage(), e);
  408.                 }
  409.             }
  410.             else if(SPCoopCostantiArchivi.TYPE_APS.equals(type)){
  411.                 try{
  412.                     return this.importEngine.buildAccordoServizioParteSpecifica(archive, registryReader,validationDocuments);
  413.                 }catch(SPCoopConvertToPackageCNIPAException e){
  414.                     throw new ProtocolException(e.getMessage(), e);
  415.                 }
  416.             }
  417.             else if(SPCoopCostantiArchivi.TYPE_ADC.equals(type)){
  418.                 try{
  419.                     return this.importEngine.buildAccordoCooperazione(archive, registryReader);
  420.                 }catch(SPCoopConvertToPackageCNIPAException e){
  421.                     throw new ProtocolException(e.getMessage(), e);
  422.                 }
  423.             }
  424.             else if(SPCoopCostantiArchivi.TYPE_ALL.equals(type)){
  425.                 try{
  426.                     return this.importEngine.buildAccordoServizioParteComune(archive, registryReader,validationDocuments);
  427.                 }catch(SPCoopConvertToPackageCNIPAException eAPC){
  428.                     try{
  429.                         return this.importEngine.buildAccordoServizioComposto(archive, registryReader,validationDocuments);
  430.                     }catch(SPCoopConvertToPackageCNIPAException eAComposto){
  431.                         try{
  432.                             return this.importEngine.buildAccordoServizioParteSpecifica(archive, registryReader,validationDocuments);
  433.                         }catch(SPCoopConvertToPackageCNIPAException eAPS){
  434.                             try{
  435.                                 return this.importEngine.buildAccordoCooperazione(archive, registryReader);
  436.                             }catch(SPCoopConvertToPackageCNIPAException eADC){
  437.                                 throw new ProtocolException("L'archivio fornito non e' stato possibile interpretarlo come nessuno dei package supportati (per ottenere maggiori dettagli re-importarlo indicando un tipo specifico): "+
  438.                                             SPCoopCostantiArchivi.TYPE_APC
  439.                                             +","+
  440.                                             SPCoopCostantiArchivi.TYPE_APS
  441.                                             +","+
  442.                                             SPCoopCostantiArchivi.TYPE_ASC
  443.                                             +","+
  444.                                             SPCoopCostantiArchivi.TYPE_ADC);
  445.                             }
  446.                         }
  447.                     }
  448.                 }
  449.             }
  450.             else{
  451.                 throw new ProtocolException("Type ["+type+"] unknown");
  452.             }
  453.         }
  454.         else{
  455.             throw new ProtocolException("Mode ["+mode+"] unknown");
  456.         }       
  457.             
  458.     }
  459.     
  460.     @Override
  461.     public Archive importArchive(InputStream archive,ArchiveMode mode,ArchiveModeType type,
  462.             IRegistryReader registryReader, IConfigIntegrationReader configIntegrationReader,
  463.             boolean validationDocuments, MapPlaceholder placeholder) throws ProtocolException { 
  464.         
  465.         byte[] bytes = null;
  466.         try{
  467.             bytes = Utilities.getAsByteArray(archive);
  468.         }
  469.         catch(Exception e){
  470.             throw new ProtocolException(e.getMessage(),e);
  471.         }
  472.         finally{
  473.             try{
  474.                 if(archive!=null){
  475.                     archive.close();
  476.                 }
  477.             }catch(Exception eClose){
  478.                 // close
  479.             }
  480.         }
  481.         return this.importArchive(bytes, mode, type, registryReader, configIntegrationReader,
  482.                 validationDocuments, placeholder);
  483.     }
  484.     
  485.     @Override
  486.     public void finalizeImportArchive(Archive archive,ArchiveMode mode,ArchiveModeType type,
  487.             IRegistryReader registryReader,IConfigIntegrationReader configIntegrationReader,
  488.             boolean validationDocuments, MapPlaceholder placeholder) throws ProtocolException {
  489.         if(org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_IMPORT_ARCHIVE_MODE.equals(mode)){
  490.             super.finalizeImportArchive(archive, mode, type, registryReader,configIntegrationReader,
  491.                     validationDocuments, placeholder);
  492.         }
  493.         else if(SPCoopCostantiArchivi.CNIPA_MODE.equals(mode)){
  494.             
  495.             if(SPCoopCostantiArchivi.TYPE_APC.equals(type)){
  496.                 // nop;
  497.             }
  498.             else if(SPCoopCostantiArchivi.TYPE_ASC.equals(type)){
  499.                 // nop;
  500.             }
  501.             else if(SPCoopCostantiArchivi.TYPE_APS.equals(type)){
  502.                 try{
  503.                     this.importEngine.finalizeAccordoServizioParteSpecifica(archive, registryReader,validationDocuments);
  504.                 }catch(SPCoopConvertToPackageCNIPAException e){
  505.                     throw new ProtocolException(e.getMessage(), e);
  506.                 }
  507.             }
  508.             else if(SPCoopCostantiArchivi.TYPE_ADC.equals(type)){
  509.                 // nop;
  510.             }
  511.             else if(SPCoopCostantiArchivi.TYPE_ALL.equals(type)){
  512.                 try{
  513.                     this.importEngine.finalizeAccordoServizioParteSpecifica(archive, registryReader,validationDocuments);
  514.                 }catch(SPCoopConvertToPackageCNIPAException e){
  515.                     throw new ProtocolException(e.getMessage(), e);
  516.                 }
  517.             }
  518.             else{
  519.                 throw new ProtocolException("Type ["+type+"] unknown");
  520.             }
  521.         }
  522.         else{
  523.             throw new ProtocolException("Mode ["+mode+"] unknown");
  524.         }
  525.     }
  526.     
  527.     @Override
  528.     public String toString(ArchiveEsitoImport esito, ArchiveMode archiveMode) throws ProtocolException{
  529.         if(org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_IMPORT_ARCHIVE_MODE.equals(archiveMode)){
  530.             return super.toString(esito, archiveMode);
  531.         }
  532.         else if(SPCoopCostantiArchivi.CNIPA_MODE.equals(archiveMode)){
  533.             return this.toString(esito,true);
  534.         }
  535.         else{
  536.             throw new ProtocolException("Mode ["+archiveMode+"] unknown");
  537.         }   
  538.     }
  539.     
  540.     @Override
  541.     public String toString(ArchiveEsitoDelete esito, ArchiveMode archiveMode) throws ProtocolException{
  542.         if(org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_IMPORT_ARCHIVE_MODE.equals(archiveMode)){
  543.             return super.toString(esito, archiveMode);
  544.         }
  545.         else if(SPCoopCostantiArchivi.CNIPA_MODE.equals(archiveMode)){
  546.             return this.toString(esito,false);
  547.         }
  548.         else{
  549.             throw new ProtocolException("Mode ["+archiveMode+"] unknown");
  550.         }
  551.     }
  552.     
  553.     
  554.     
  555.     
  556.     
  557.     
  558.     /* ----- Export ----- */
  559.     
  560.     @Override
  561.     public List<ExportMode> getExportModes(ArchiveType archiveType) throws ProtocolException {
  562.         List<ExportMode> list = super.getExportModes(archiveType);
  563.         if(this.spcoopProperties.isGestionePackageSICA()) {
  564.             switch (archiveType) {
  565.             case ACCORDO_SERVIZIO_PARTE_COMUNE:
  566.             case ACCORDO_SERVIZIO_PARTE_SPECIFICA:
  567.             case ACCORDO_SERVIZIO_COMPOSTO:
  568.             case ACCORDO_COOPERAZIONE:
  569.                 ExportMode exportSICA = new ExportMode(SPCoopCostantiArchivi.EXPORT_MODE_COMPATIBILITA_CLIENT_SICA);
  570.                 ExportMode exportComplete = new ExportMode(SPCoopCostantiArchivi.EXPORT_MODE_INFORMAZIONI_COMPLETE);
  571.                 list.add(exportSICA);
  572.                 list.add(exportComplete);
  573.                 break;
  574.             default:
  575.                 break;
  576.             }
  577.         }
  578.         return list;
  579.     }
  580.     
  581.     @Override
  582.     public byte[] exportArchive(Archive archive, ArchiveMode mode,
  583.             IRegistryReader registroReader, IConfigIntegrationReader configIntegrationReader)
  584.             throws ProtocolException {
  585.         
  586.         if(org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_EXPORT_ARCHIVE_MODE.equals(mode)){
  587.             return super.exportArchive(archive, mode, registroReader, configIntegrationReader);
  588.         }
  589.         else if(SPCoopCostantiArchivi.EXPORT_MODE_COMPATIBILITA_CLIENT_SICA.equals(mode) ||
  590.                 SPCoopCostantiArchivi.EXPORT_MODE_INFORMAZIONI_COMPLETE.equals(mode)){
  591.             try{
  592.                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  593.                 this.exportEngine.exportArchive(archive, mode, registroReader, bout);
  594.                 bout.flush();
  595.                 bout.close();
  596.                 return bout.toByteArray();
  597.             }catch(Exception e){
  598.                 throw new ProtocolException(e.getMessage(),e);
  599.             }
  600.         }
  601.         else{
  602.             throw new ProtocolException("Mode ["+mode+"] unknown");
  603.         }   
  604.         
  605.     }

  607.     @Override
  608.     public void exportArchive(Archive archive, OutputStream out, ArchiveMode mode,
  609.             IRegistryReader registroReader, IConfigIntegrationReader configIntegrationReader)
  610.             throws ProtocolException {
  611.         if(org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_EXPORT_ARCHIVE_MODE.equals(mode)){
  612.             super.exportArchive(archive, out, mode, registroReader, configIntegrationReader);
  613.         }
  614.         else if(SPCoopCostantiArchivi.EXPORT_MODE_COMPATIBILITA_CLIENT_SICA.equals(mode) ||
  615.                 SPCoopCostantiArchivi.EXPORT_MODE_INFORMAZIONI_COMPLETE.equals(mode)){
  616.             this.exportEngine.exportArchive(archive, mode, registroReader, out);
  617.         }
  618.         else{
  619.             throw new ProtocolException("Mode ["+mode+"] unknown");
  620.         }   
  621.     }

  623.     


  626.     
  627. }
Created with JaCoCo 0.8.8.202204050719