SPCoopArchiveImport.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 it.gov.spcoop.sica.dao.driver.XMLUtils;

  25. import org.slf4j.Logger;

  27. import java.util.ArrayList;
  28. import java.util.List;

  30. import org.openspcoop2.core.config.Connettore;
  31. import org.openspcoop2.core.config.InvocazioneServizio;
  32. import org.openspcoop2.core.config.PortaApplicativa;
  33. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  34. import org.openspcoop2.core.config.PortaDelegata;
  35. import org.openspcoop2.core.config.RispostaAsincrona;
  36. import org.openspcoop2.core.config.ServizioApplicativo;
  37. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  38. import org.openspcoop2.core.config.constants.InvocazioneServizioTipoAutenticazione;
  39. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  40. import org.openspcoop2.core.config.constants.TipoAutenticazione;
  41. import org.openspcoop2.core.config.constants.TipoAutorizzazione;
  42. import org.openspcoop2.core.config.constants.TipologiaErogazione;
  43. import org.openspcoop2.core.config.constants.TipologiaFruizione;
  44. import org.openspcoop2.core.constants.CostantiDB;
  45. import org.openspcoop2.core.constants.TipiConnettore;
  46. import org.openspcoop2.core.id.IDServizio;
  47. import org.openspcoop2.core.id.IDSoggetto;
  48. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  49. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  50. import org.openspcoop2.core.registry.AccordoCooperazione;
  51. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  52. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  53. import org.openspcoop2.core.registry.Fruitore;
  54. import org.openspcoop2.core.registry.Soggetto;
  55. import org.openspcoop2.core.registry.constants.StatiAccordo;
  56. import org.openspcoop2.message.constants.ServiceBinding;
  57. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  58. import org.openspcoop2.protocol.sdk.ProtocolException;
  59. import org.openspcoop2.protocol.sdk.archive.Archive;
  60. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoCooperazione;
  61. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioComposto;
  62. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteComune;
  63. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
  64. import org.openspcoop2.protocol.sdk.archive.ArchiveFruitore;
  65. import org.openspcoop2.protocol.sdk.archive.ArchiveIdCorrelazione;
  66. import org.openspcoop2.protocol.sdk.archive.ArchivePortaApplicativa;
  67. import org.openspcoop2.protocol.sdk.archive.ArchivePortaDelegata;
  68. import org.openspcoop2.protocol.sdk.archive.ArchiveServizioApplicativo;
  69. import org.openspcoop2.protocol.sdk.config.ProtocolImplementation;
  70. import org.openspcoop2.protocol.sdk.config.ProtocolSubscription;
  71. import org.openspcoop2.protocol.sdk.registry.ProtocolFiltroRicercaSoggetti;
  72. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  73. import org.openspcoop2.protocol.sdk.registry.RegistryNotFound;
  74. import org.openspcoop2.protocol.spcoop.sica.SICAtoOpenSPCoopContext;
  75. import org.openspcoop2.protocol.spcoop.sica.SICAtoOpenSPCoopUtilities;

  77. /**
  78.  * SPCoopArchiveImport 
  79.  *
  80.  * @author Poli Andrea (apoli@link.it)
  81.  * @author $Author$
  82.  * @version $Rev$, $Date$
  83.  */
  84. public class SPCoopArchiveImport {

  86.     private IProtocolFactory<?> protocolFactory = null;
  87.     private Logger logger = null;
  88.     public SPCoopArchiveImport(IProtocolFactory<?> protocolFactory){
  89.         this.protocolFactory = protocolFactory;
  90.         this.logger = this.protocolFactory.getLogger();
  91.     }
  92.     
  93.     public Archive buildAccordoServizioParteComune(byte[]archive,
  94.             IRegistryReader registryReader,boolean validationDocuments) throws ProtocolException, SPCoopConvertToPackageCNIPAException{
  95.         
  96.         try{
  97.         
  98.             SICAtoOpenSPCoopContext sicaContext = new SICAtoOpenSPCoopContext();
  99.             
  100.             
  101.             // *** Trasformazione in package CNIPA ***
  102.             XMLUtils daoUtilities = new XMLUtils(sicaContext,this.logger);
  103.             it.gov.spcoop.sica.dao.AccordoServizioParteComune aspcSICA = null;
  104.             try{
  105.                 aspcSICA = daoUtilities.getAccordoServizioParteComune(archive);
  106.             }catch(Exception e){
  107.                 throw new SPCoopConvertToPackageCNIPAException("Conversione dell'archivio in package CNIPA non riuscita: "+e.getMessage(),e);
  108.             }
  109.             
  110.                                 
  111.             // *** Verifica informazioni presenti nel package ***
  112.             if(aspcSICA.getManifesto().getNome()==null){
  113.                 throw new ProtocolException("Riscontrato un archivio che possiede un manifesto senza nome");
  114.             }
  115.             
  116.             // soggetto referente
  117.             String soggettoReferente = null;
  118.             if(aspcSICA.getManifesto().getParteComune().getPubblicatore()!=null) {
  119.                 soggettoReferente = aspcSICA.getManifesto().getParteComune().getPubblicatore().toString();
  120.             }
  121.             if(soggettoReferente!=null){
  122.                 String codiceIPA = SICAtoOpenSPCoopUtilities.removeURI_IDSoggettoSica(soggettoReferente);
  123.                 if(registryReader.existsSoggettoByCodiceIPA(codiceIPA)==false){
  124.                     throw new ProtocolException("Il soggetto referente con Codice IPA ["+codiceIPA+"] non esiste.");
  125.                 }
  126.             }
  127.             
  128.             
  129.             // *** Verifica documenti wsdl/wsbl presenti all'interno del package ***
  130.             if(validationDocuments){
  131.                 SPCoopArchiveImportUtils.validazioneContenuti(aspcSICA);
  132.             }
  133.             
  134.                         
  135.             // *** impostazione mapping soggetto con codice IPA ***
  136.             SPCoopArchiveImportUtils.setIDSoggettoFromCodiceIPA(aspcSICA, sicaContext, registryReader);
  137.             
  138.             
  139.             // *** Trasformazione in oggetto OpenSPCoop2 ***
  140.             AccordoServizioParteComune aspcOpenSPCoop2 = null;
  141.             try{
  142.                 aspcOpenSPCoop2 = SICAtoOpenSPCoopUtilities.accordoServizioParteComune_sicaToOpenspcoop(registryReader, aspcSICA, sicaContext, this.logger);
  143.                 
  144.                 Archive archiveObject = new Archive();
  145.                 
  146.                 ArchiveIdCorrelazione idCorrelazione = new ArchiveIdCorrelazione("CnipaPackageASPC");
  147.                 
  148.                 ArchiveAccordoServizioParteComune archiveASPC = new ArchiveAccordoServizioParteComune(aspcOpenSPCoop2,idCorrelazione,true);
  149.                 archiveObject.getAccordiServizioParteComune().add(archiveASPC);

  151.                 return archiveObject;
  152.                 
  153.             }catch(Exception e){
  154.                 throw new ProtocolException("Conversione dell'archivio, da formato CNIPA a formato OpenSPCoop2, non riuscita: "+e.getMessage(),e);
  155.             }
  156.             
  157.         }catch(SPCoopConvertToPackageCNIPAException convert){
  158.             throw convert;
  159.         }catch(Exception e){
  160.             throw new ProtocolException("Conversione archivio non riuscita: "+e.getMessage(),e);
  161.         }
  162.         
  163.     } 
  164.     
  165.     public Archive buildAccordoServizioComposto(byte[]archive,
  166.             IRegistryReader registryReader, boolean validationDocuments) throws ProtocolException, SPCoopConvertToPackageCNIPAException{
  167.         
  168.         try{
  169.         
  170.             SICAtoOpenSPCoopContext sicaContext = new SICAtoOpenSPCoopContext();
  171.             
  172.             
  173.             // *** Trasformazione in package CNIPA ***
  174.             XMLUtils daoUtilities = new XMLUtils(sicaContext,this.logger);
  175.             it.gov.spcoop.sica.dao.AccordoServizioComposto asCompostoSICA = null;
  176.             try{
  177.                 asCompostoSICA = daoUtilities.getAccordoServizioComposto(archive);
  178.             }catch(Exception e){
  179.                 throw new SPCoopConvertToPackageCNIPAException("Conversione dell'archivio in package CNIPA non riuscita: "+e.getMessage(),e);
  180.             }
  181.             
  182.             
  183.             // *** Verifica informazioni presenti nel package ***
  184.             if(asCompostoSICA.getManifesto().getNome()==null){
  185.                 throw new ProtocolException("Riscontrato un archivio che possiede un manifesto senza nome");
  186.             }           
  187.             
  188.             // soggetto referente
  189.             String soggettoReferente = null;
  190.             if(asCompostoSICA.getManifesto().getPubblicatore()!=null) {
  191.                 soggettoReferente = asCompostoSICA.getManifesto().getPubblicatore().toString();
  192.             }
  193.             if(soggettoReferente!=null){
  194.                 String codiceIPA = SICAtoOpenSPCoopUtilities.removeURI_IDSoggettoSica(soggettoReferente);
  195.                 if(registryReader.existsSoggettoByCodiceIPA(codiceIPA)==false){
  196.                     throw new ProtocolException("Il soggetto referente con Codice IPA ["+codiceIPA+"] non esiste.");
  197.                 }
  198.             }
  199.             
  200.             
  201.             // *** Verifica documenti wsdl/wsbl presenti all'interno del package ***
  202.             if(validationDocuments){
  203.                 SPCoopArchiveImportUtils.validazioneContenuti(asCompostoSICA);
  204.             }
  205.             
  206.             
  207.             // *** impostazione mapping soggetto con codice IPA ***
  208.             SPCoopArchiveImportUtils.setIDSoggettoFromCodiceIPA(asCompostoSICA, sicaContext, registryReader);
  209.             SPCoopArchiveImportUtils.setIDServizioFromURI_APS(asCompostoSICA, sicaContext, registryReader);
  210.             
  211.                         
  212.             // *** Trasformazione in oggetto OpenSPCoop2 ***
  213.             AccordoServizioParteComune asCompostoOpenSPCoop2 = null;
  214.             try{
  215.                 asCompostoOpenSPCoop2 = SICAtoOpenSPCoopUtilities.accordoServizioComposto_sicaToOpenspcoop(registryReader, asCompostoSICA, sicaContext, this.logger);
  216.                 
  217.                 Archive archiveObject = new Archive();
  218.                 
  219.                 ArchiveIdCorrelazione idCorrelazione = new ArchiveIdCorrelazione("CnipaPackageASC");
  220.                 
  221.                 ArchiveAccordoServizioComposto archiveASC = new ArchiveAccordoServizioComposto(asCompostoOpenSPCoop2,idCorrelazione,true);
  222.                 archiveObject.getAccordiServizioComposto().add(archiveASC);
  223.                 
  224.                 return archiveObject;
  225.                 
  226.             }catch(Exception e){
  227.                 throw new ProtocolException("Conversione dell'archivio, da formato CNIPA a formato OpenSPCoop2, non riuscita: "+e.getMessage(),e);
  228.             }
  229.             
  230.         }catch(SPCoopConvertToPackageCNIPAException convert){
  231.             throw convert;
  232.         }catch(Exception e){
  233.             throw new ProtocolException("Conversione archivio non riuscita: "+e.getMessage(),e);
  234.         }
  235.         
  236.     } 
  237.     
  238.     
  239.     public Archive buildAccordoServizioParteSpecifica(byte[]archive,
  240.             IRegistryReader registryReader, boolean validationDocuments) throws ProtocolException, SPCoopConvertToPackageCNIPAException{
  241.         
  242.         try{
  243.             
  244.             SICAtoOpenSPCoopContext sicaContext = new SICAtoOpenSPCoopContext();
  245.             
  246.             
  247.             // *** Trasformazione in package CNIPA ***
  248.             XMLUtils daoUtilities = new XMLUtils(sicaContext,this.logger);
  249.             it.gov.spcoop.sica.dao.AccordoServizioParteSpecifica aspsSICA = null;
  250.             try{
  251.                 aspsSICA = daoUtilities.getAccordoServizioParteSpecifica(archive);
  252.             }catch(Exception e){
  253.                 throw new SPCoopConvertToPackageCNIPAException("Conversione dell'archivio in package CNIPA non riuscita: "+e.getMessage(),e);
  254.             }
  255.             
  256.             
  257.             // *** Verifica informazioni presenti nel package ***
  258.             if(aspsSICA.getManifesto().getNome()==null){
  259.                 throw new ProtocolException("Riscontrato un archivio che possiede un manifesto senza nome");
  260.             }
  261.             
  262.             // soggetto erogatore
  263.             String soggettoErogatore = null;
  264.             if(aspsSICA.getManifesto().getParteSpecifica().getErogatore()!=null) {
  265.                 soggettoErogatore = aspsSICA.getManifesto().getParteSpecifica().getErogatore().toString();
  266.             }
  267.             if(soggettoErogatore!=null){
  268.                 String codiceIPA = SICAtoOpenSPCoopUtilities.removeURI_IDSoggettoSica(soggettoErogatore);
  269.                 if(registryReader.existsSoggettoByCodiceIPA(codiceIPA)==false){
  270.                     throw new ProtocolException("Il soggetto referente con Codice IPA ["+codiceIPA+"] non esiste.");
  271.                 }
  272.             }
  273.                 
  274.             
  275.             // *** Verifica documenti presenti all'interno del package ***
  276.             if(validationDocuments){
  277.                 SPCoopArchiveImportUtils.validazioneContenuti(aspsSICA);
  278.             }
  279.             
  280.                         
  281.             // *** impostazione mapping soggetto con codice IPA ***
  282.             SPCoopArchiveImportUtils.setIDSoggettoFromCodiceIPA(aspsSICA, sicaContext, registryReader);
  283.             
  284.             
  285.             // *** Trasformazione in oggetto OpenSPCoop2 ***
  286.             try{
  287.                 AccordoServizioParteSpecifica aspsOpenSPCoop2 = SICAtoOpenSPCoopUtilities.accordoServizioParteSpecifica_sicaToOpenspcoop(registryReader, aspsSICA, sicaContext, this.logger);
  288.                 
  289.                 Archive archiveObject = new Archive();
  290.                 
  291.                 ArchiveIdCorrelazione idCorrelazione = new ArchiveIdCorrelazione("CnipaPackageASPS");
  292.                 
  293.                 ArchiveAccordoServizioParteSpecifica archiveASPS = new ArchiveAccordoServizioParteSpecifica(aspsOpenSPCoop2,idCorrelazione, true);
  294.                 archiveObject.getAccordiServizioParteSpecifica().add(archiveASPS);
  295.                                 
  296.                 return archiveObject;
  297.                 
  298.             }catch(Exception e){
  299.                 throw new ProtocolException("Conversione dell'archivio, da formato CNIPA a formato OpenSPCoop2, non riuscita: "+e.getMessage(),e);
  300.             }

  302.                 
  303.         }catch(SPCoopConvertToPackageCNIPAException convert){
  304.             throw convert;
  305.         }catch(Exception e){
  306.             throw new ProtocolException("Conversione archivio non riuscita: "+e.getMessage(),e);
  307.         }
  308.         
  309.     } 
  310.     
  311.     public void finalizeAccordoServizioParteSpecifica(Archive archiveObject,
  312.             IRegistryReader registryReader, boolean validationDocuments) throws ProtocolException, SPCoopConvertToPackageCNIPAException{
  313.         
  314.         try{
  315.             AccordoServizioParteSpecifica aspsOpenSPCoop2 = null;
  316.             ArchiveIdCorrelazione idCorrelazione = null;
  317.             if(archiveObject.getAccordiServizioParteSpecifica()!=null && archiveObject.getAccordiServizioParteSpecifica().size()>0) {
  318.                 aspsOpenSPCoop2 = archiveObject.getAccordiServizioParteSpecifica().get(0).getAccordoServizioParteSpecifica();
  319.                 idCorrelazione = archiveObject.getAccordiServizioParteSpecifica().get(0).getIdCorrelazione();
  320.             }
  321.             else {
  322.                 return;
  323.             }
  324.             
  325.             
  326.             boolean informazioniComplete = true;
  327.             if(aspsOpenSPCoop2.getTipoSoggettoErogatore()==null || aspsOpenSPCoop2.getNomeSoggettoErogatore()==null) {
  328.                 informazioniComplete = false;
  329.             }
  330.             if(aspsOpenSPCoop2.getVersione()==null) {
  331.                 informazioniComplete = false;
  332.             }
  333.             if(aspsOpenSPCoop2.getAccordoServizioParteComune()==null) {
  334.                 informazioniComplete = false;
  335.             }
  336.             
  337.             ArchiveAccordoServizioParteSpecifica archiveASPS = new ArchiveAccordoServizioParteSpecifica(aspsOpenSPCoop2,idCorrelazione,!informazioniComplete);
  338.             
  339.             if(informazioniComplete) {
  340.             
  341.                 // Devo creare una erogazione o fruizione
  342.                 IDServizio idServizio = archiveASPS.getIdAccordoServizioParteSpecifica();
  343.                 IDSoggetto idSoggettoErogatore = archiveASPS.getIdSoggettoErogatore();
  344.                 Soggetto soggetto = registryReader.getSoggetto(idSoggettoErogatore);
  345.                 String portaDominio = soggetto.getPortaDominio();
  346.                 boolean operativo = false;
  347.                 List<String> pddOperative = null;
  348.                 try {
  349.                     pddOperative = registryReader.findIdPorteDominio(true);
  350.                 }catch(RegistryNotFound notFound) {}
  351.                 if(portaDominio!=null) {
  352.                     if(pddOperative!=null && !pddOperative.isEmpty()) {
  353.                         for (String pdd : pddOperative) {
  354.                             if(portaDominio.equals(pdd)) {
  355.                                 operativo = true;
  356.                                 break;
  357.                             }
  358.                         }
  359.                     }
  360.                 }
  361.                 
  362.                 if(operativo) {
  363.                     
  364.                     // creo Porta Applicativa
  365.                     
  366.                     ProtocolImplementation implementationDefault = this.protocolFactory.createProtocolIntegrationConfiguration().
  367.                             createDefaultImplementation(ServiceBinding.SOAP, idServizio);
  368.                     
  369.                     PortaApplicativa portaApplicativa = implementationDefault.getPortaApplicativa();
  370.                     portaApplicativa.setIdSoggetto(soggetto.getId());
  371.                     portaApplicativa.setStato(StatoFunzionalita.DISABILITATO);
  372.                     // Per non creare un buco di sicurezza per default, abilito l'autorizzazione dei soggetti
  373.                     portaApplicativa.setAutenticazione(TipoAutenticazione.DISABILITATO.getValue());
  374.                     portaApplicativa.setAutorizzazione(TipoAutorizzazione.AUTHENTICATED.getValue());
  375.                     
  376.                     // Viene creata in automatico
  377.                     MappingErogazionePortaApplicativa mappingErogazione = implementationDefault.getMapping();
  378.                     
  379.                     ServizioApplicativo sa = new ServizioApplicativo();
  380.                     sa.setNome(portaApplicativa.getNome());
  381.                     sa.setTipologiaFruizione(TipologiaFruizione.DISABILITATO.getValue());
  382.                     sa.setTipologiaErogazione(TipologiaErogazione.TRASPARENTE.getValue());
  383.                     sa.setIdSoggetto(soggetto.getId());
  384.                     sa.setTipoSoggettoProprietario(portaApplicativa.getTipoSoggettoProprietario());
  385.                     sa.setNomeSoggettoProprietario(portaApplicativa.getNomeSoggettoProprietario());
  386.                         
  387.                     RispostaAsincrona rispostaAsinc = new RispostaAsincrona();
  388.                     rispostaAsinc.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  389.                     rispostaAsinc.setGetMessage(CostantiConfigurazione.DISABILITATO);
  390.                     sa.setRispostaAsincrona(rispostaAsinc);
  391.                         
  392.                     InvocazioneServizio invServizio = new InvocazioneServizio();
  393.                     invServizio.setAutenticazione(InvocazioneServizioTipoAutenticazione.NONE);
  394.                     invServizio.setGetMessage(CostantiConfigurazione.DISABILITATO);
  395.                     Connettore connettore = new Connettore();
  396.                     connettore.setTipo(TipiConnettore.HTTP.getNome());
  397.                     org.openspcoop2.core.config.Property prop = new org.openspcoop2.core.config.Property();
  398.                     prop.setNome(CostantiDB.CONNETTORE_HTTP_LOCATION);
  399.                     prop.setValore("http://undefined");
  400.                     connettore.addProperty(prop);
  401.                     invServizio.setConnettore(connettore);
  402.                     sa.setInvocazioneServizio(invServizio);
  403.                                 
  404.                     PortaApplicativaServizioApplicativo paSA = new PortaApplicativaServizioApplicativo();
  405.                     paSA.setNome(sa.getNome());
  406.                     portaApplicativa.addServizioApplicativo(paSA);
  407.             
  408.                     if(archiveASPS.getMappingPorteApplicativeAssociate()==null) {
  409.                         archiveASPS.setMappingPorteApplicativeAssociate(new ArrayList<>());
  410.                     }
  411.                     archiveASPS.getMappingPorteApplicativeAssociate().add(mappingErogazione);
  412.                     
  413.                     ArchiveServizioApplicativo archiveSA = new ArchiveServizioApplicativo(sa, idCorrelazione, false);
  414.                     archiveObject.getServiziApplicativi().add(archiveSA);   
  415.                     
  416.                     ArchivePortaApplicativa archivePA = new ArchivePortaApplicativa(portaApplicativa, idCorrelazione,false);
  417.                     archiveObject.getPorteApplicative().add(archivePA);
  418.                 }
  419.                 else {
  420.                     
  421.                     // creo Porta Delegata
  422.                     
  423.                     IDSoggetto idFruitore = null;
  424.                     if(pddOperative==null) {
  425.                         throw new Exception("Non esistono pdd operative");
  426.                     }
  427.                     for (String pddOperativa : pddOperative) {
  428.                         ProtocolFiltroRicercaSoggetti filtro = new ProtocolFiltroRicercaSoggetti();
  429.                         filtro.setTipo("spc");
  430.                         filtro.setNomePdd(pddOperativa);
  431.                         List<IDSoggetto> idSoggetti = null;
  432.                         try {
  433.                             idSoggetti = registryReader.findIdSoggetti(filtro);
  434.                         }catch(RegistryNotFound notFound) {}
  435.                         if(idSoggetti!=null && !idSoggetti.isEmpty()) {
  436.                             idFruitore = idSoggetti.get(0);
  437.                         }
  438.                     }
  439.                     if(idFruitore==null) {
  440.                         throw new Exception("Non esistone un soggetto interno al dominio");
  441.                     }
  442.                     Soggetto soggettoFruitore = registryReader.getSoggetto(idFruitore);
  443.                                                             
  444.                     ProtocolSubscription subscriptionDefault = this.protocolFactory.createProtocolIntegrationConfiguration().
  445.                             createDefaultSubscription(ServiceBinding.SOAP, idFruitore, idServizio);
  446.                     
  447.                     PortaDelegata portaDelegata = subscriptionDefault.getPortaDelegata();
  448.                     portaDelegata.setIdSoggetto(soggettoFruitore.getId());
  449.                     portaDelegata.setStato(StatoFunzionalita.DISABILITATO);
  450.                     // Per non creare un buco di sicurezza per default, abilito l'autenticazione degli applicativi
  451.                     portaDelegata.setAutenticazione(TipoAutenticazione.SSL.getValue());
  452.                     
  453.                     // Viene creata in automatico
  454.                     MappingFruizionePortaDelegata mappingFruizione = subscriptionDefault.getMapping();

  456.                     Fruitore fruitore = new Fruitore();
  457.                     fruitore.setTipo(idFruitore.getTipo());
  458.                     fruitore.setNome(idFruitore.getNome());
  459.                     org.openspcoop2.core.registry.Connettore connettore = new org.openspcoop2.core.registry.Connettore();
  460.                     connettore.setTipo(TipiConnettore.HTTP.getNome());
  461.                     org.openspcoop2.core.registry.Property prop = new org.openspcoop2.core.registry.Property();
  462.                     prop.setNome(CostantiDB.CONNETTORE_HTTP_LOCATION);
  463.                     prop.setValore("http://undefined");
  464.                     connettore.addProperty(prop);
  465.                     fruitore.setStatoPackage(StatiAccordo.operativo.name());
  466.                     fruitore.setConnettore(connettore);
  467.                                         
  468.                     ArchivePortaDelegata archivePD = new ArchivePortaDelegata(portaDelegata, idCorrelazione, false);
  469.                     archiveObject.getPorteDelegate().add(archivePD);
  470.                     
  471.                     ArchiveFruitore archiveFruitore = new ArchiveFruitore(idServizio, fruitore, idCorrelazione, false);
  472.                     archiveObject.getAccordiFruitori().add(archiveFruitore);
  473.                     
  474.                     if(archiveFruitore.getMappingPorteDelegateAssociate()==null) {
  475.                         archiveFruitore.setMappingPorteDelegateAssociate(new ArrayList<>());
  476.                     }
  477.                     archiveFruitore.getMappingPorteDelegateAssociate().add(mappingFruizione);
  478.                 }
  479.             }
  480.                 
  481.         }catch(SPCoopConvertToPackageCNIPAException convert){
  482.             throw convert;
  483.         }catch(Exception e){
  484.             throw new ProtocolException("Conversione archivio non riuscita: "+e.getMessage(),e);
  485.         }
  486.         
  487.     } 
  488.     
  489.     public Archive buildAccordoCooperazione(byte[]archive,
  490.             IRegistryReader registryReader) throws ProtocolException, SPCoopConvertToPackageCNIPAException{
  491.         
  492.         try{
  493.         
  494.             SICAtoOpenSPCoopContext sicaContext = new SICAtoOpenSPCoopContext();
  495.             
  496.             
  497.             // *** Trasformazione in package CNIPA ***
  498.             XMLUtils daoUtilities = new XMLUtils(sicaContext,this.logger);
  499.             it.gov.spcoop.sica.dao.AccordoCooperazione acSICA = null;
  500.             try{
  501.                 acSICA = daoUtilities.getAccordoCooperazione(archive);
  502.             }catch(Exception e){
  503.                 throw new SPCoopConvertToPackageCNIPAException("Conversione dell'archivio in package CNIPA non riuscita: "+e.getMessage(),e);
  504.             }
  505.             
  506.             
  507.             // *** Verifica informazioni presenti nel package ***
  508.             if(acSICA.getManifesto().getNome()==null){
  509.                 throw new ProtocolException("Riscontrato un archivio che possiede un manifesto senza nome");
  510.             }
  511.             
  512.             // soggetto coordinatore
  513.             String soggettoCoordinatore = null;
  514.             if(acSICA.getManifesto().getCoordinatore()!=null) {
  515.                 soggettoCoordinatore = acSICA.getManifesto().getCoordinatore().toString();
  516.             }
  517.             if(soggettoCoordinatore!=null){
  518.                 String codiceIPA = SICAtoOpenSPCoopUtilities.removeURI_IDSoggettoSica(soggettoCoordinatore);
  519.                 if(registryReader.existsSoggettoByCodiceIPA(codiceIPA)==false){
  520.                     throw new ProtocolException("Il soggetto coordinatore con Codice IPA ["+codiceIPA+"] non esiste.");
  521.                 }
  522.             }
  523.             
  524.             // soggetti partecipanti
  525.             if(acSICA.getManifesto()!=null && acSICA.getManifesto().getElencoPartecipanti()!=null){
  526.                 for(int i=0;i<acSICA.getManifesto().getElencoPartecipanti().sizePartecipanteList();i++){
  527.                     String partecipante = null;
  528.                     if(acSICA.getManifesto().getElencoPartecipanti().getPartecipante(i)!=null) {
  529.                         partecipante = acSICA.getManifesto().getElencoPartecipanti().getPartecipante(i).toString();
  530.                     }
  531.                     if(partecipante!=null) {
  532.                         String codiceIPA = SICAtoOpenSPCoopUtilities.removeURI_IDSoggettoSica(partecipante);
  533.                         if(registryReader.existsSoggettoByCodiceIPA(codiceIPA)==false){
  534.                             throw new ProtocolException("Il soggetto partecipante con Codice IPA ["+codiceIPA+"] non esiste.");
  535.                         }
  536.                     }
  537.                 }
  538.             }
  539.                                 
  540.                         
  541.             // *** impostazione mapping soggetto con codice IPA ***
  542.             SPCoopArchiveImportUtils.setIDSoggettoFromCodiceIPA(acSICA, sicaContext, registryReader);
  543.             
  544.             
  545.             // *** Trasformazione in oggetto OpenSPCoop2 ***
  546.             AccordoCooperazione acOpenSPCoop2 = null;
  547.             try{
  548.                 acOpenSPCoop2 = SICAtoOpenSPCoopUtilities.accordoCooperazione_sicaToOpenspcoop(registryReader, acSICA, sicaContext, this.logger);
  549.                 
  550.                 Archive archiveObject = new Archive();
  551.                 
  552.                 ArchiveIdCorrelazione idCorrelazione = new ArchiveIdCorrelazione("CnipaPackageAC");
  553.                 
  554.                 ArchiveAccordoCooperazione archiveAC = new ArchiveAccordoCooperazione(acOpenSPCoop2,idCorrelazione,true);
  555.                 archiveObject.getAccordiCooperazione().add(archiveAC);
  556.                 
  557.                 return archiveObject;
  558.                 
  559.             }catch(Exception e){
  560.                 throw new ProtocolException("Conversione dell'archivio, da formato CNIPA a formato OpenSPCoop2, non riuscita: "+e.getMessage(),e);
  561.             }
  562.             
  563.         }catch(SPCoopConvertToPackageCNIPAException convert){
  564.             throw convert;
  565.         }catch(Exception e){
  566.             throw new ProtocolException("Conversione archivio non riuscita: "+e.getMessage(),e);
  567.         }
  568.         
  569.     } 
  570.     
  571. }
Created with JaCoCo 0.8.8.202204050719