ErogazioneConverter.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.basic.archive.abstraction;

  23. import java.io.ByteArrayInputStream;
  24. import java.util.ArrayList;
  25. import java.util.HashMap;
  26. import java.util.Map;

  28. import org.openspcoop2.core.config.constants.PortaApplicativaAzioneIdentificazione;
  29. import org.openspcoop2.core.id.IDAccordo;
  30. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  31. import org.openspcoop2.protocol.abstraction.Erogazione;
  32. import org.openspcoop2.protocol.abstraction.Soggetto;
  33. import org.openspcoop2.protocol.abstraction.constants.CostantiAbstraction;
  34. import org.openspcoop2.protocol.abstraction.constants.Tipologia;
  35. import org.openspcoop2.protocol.abstraction.template.DatiServizio;
  36. import org.openspcoop2.protocol.abstraction.template.DatiServizioApplicativoErogatore;
  37. import org.openspcoop2.protocol.abstraction.template.DatiSoggetto;
  38. import org.openspcoop2.protocol.abstraction.template.IdSoggetto;
  39. import org.openspcoop2.protocol.abstraction.template.TemplateErogazione;
  40. import org.openspcoop2.protocol.basic.archive.ZIPReadUtils;
  41. import org.openspcoop2.protocol.sdk.ProtocolException;
  42. import org.openspcoop2.protocol.sdk.archive.Archive;
  43. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
  44. import org.openspcoop2.protocol.sdk.archive.ArchiveIdCorrelazione;
  45. import org.openspcoop2.protocol.sdk.archive.ArchivePortaApplicativa;
  46. import org.openspcoop2.protocol.sdk.constants.ArchiveVersion;
  47. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  48. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  49. import org.openspcoop2.protocol.utils.ManagerUtils;
  50. import org.openspcoop2.utils.Utilities;
  51. import org.openspcoop2.utils.resources.TemplateUtils;
  52. import org.slf4j.Logger;

  54. /**     
  55.  * ErogazioneConverter
  56.  *
  57.  * @author Poli Andrea (poli@link.it)
  58.  * @author $Author$
  59.  * @version $Rev$, $Date$
  60.  */
  61. public class ErogazioneConverter extends AbstractConverter {

  63.     // ----- Static method -----
  64.     
  65.     public static synchronized ArchiveIdCorrelazione generateIdCorrelazione(String tipoSoggettoErogatore,String nomeSoggettoErogatore,
  66.             String tipoServizio, String nomeServizio,
  67.             String descrizione) throws ProtocolException{
  68.         
  69.         // Identificativo Unico di Correlazione
  70.         String uuid = "Erogazione_"+tipoSoggettoErogatore+"/"+nomeSoggettoErogatore+"_"+tipoServizio+"/"+nomeServizio+"_"+System.currentTimeMillis();
  71.         
  72.         Utilities.sleep(1); // per rendere univco il prossimo uuid
  73.         
  74.         ArchiveIdCorrelazione idCorrelazione = new ArchiveIdCorrelazione(uuid);
  75.         
  76.         String d = null;
  77.         if(descrizione!=null && !"".equals(descrizione)){
  78.             d = descrizione;
  79.         }
  80.         else{
  81.             d = "Erogazione servizio:"+tipoServizio+"/"+nomeServizio+" erogatore:"+tipoSoggettoErogatore+"/"+nomeSoggettoErogatore;
  82.         }
  83.         idCorrelazione.setDescrizione(d);

  85.         return idCorrelazione;
  86.     }
  87.     
  88.     
  89.     
  90.     
  91.     // ----- Instance method -----

  93.     public ErogazioneConverter(Logger log,ZIPReadUtils zipReader) throws ProtocolException{
  94.         super(log, zipReader);
  95.     }
  96.     
  97.     // ritorna l'identificativo di correlazione.
  98.     public ArchiveIdCorrelazione fillArchive(Archive archive, Erogazione erogazione, TemplateErogazione templateErogazione,
  99.             IRegistryReader registryReader, IConfigIntegrationReader configIntegrationReader, boolean validationDocuments) throws ProtocolException{
  100.         
  101.         try{
  102.             
  103.             // Cerco identificare accordo di servizio parte comune
  104.             IDAccordo idAccordoServizioParteComune = null;
  105.             if(erogazione.getAccordoServizioParteComune().getUri()!=null){
  106.                 idAccordoServizioParteComune = this.idAccordoFactory.getIDAccordoFromUri(erogazione.getAccordoServizioParteComune().getUri());
  107.                 if(this.existsAccordoServizioParteComune(archive, registryReader, idAccordoServizioParteComune)==false){
  108.                     throw new ProtocolException("Accordo di Servizio Parte Comune ["+idAccordoServizioParteComune.toString()+"] non esistente");
  109.                 }
  110.             }
  111.             else {
  112.                 if(erogazione.getAccordoServizioParteComune().getIdAccordo().getSoggetto()!=null && 
  113.                         erogazione.getAccordoServizioParteComune().getIdAccordo().getVersione()!=null){
  114.                     idAccordoServizioParteComune = 
  115.                             this.idAccordoFactory.getIDAccordoFromValues(
  116.                                     erogazione.getAccordoServizioParteComune().getIdAccordo().getNome(), 
  117.                                     erogazione.getAccordoServizioParteComune().getIdAccordo().getSoggetto().getTipo(), 
  118.                                     erogazione.getAccordoServizioParteComune().getIdAccordo().getSoggetto().getNome(), 
  119.                                     erogazione.getAccordoServizioParteComune().getIdAccordo().getVersione());
  120.                     if(this.existsAccordoServizioParteComune(archive, registryReader, idAccordoServizioParteComune)==false){
  121.                         throw new ProtocolException("Accordo di Servizio Parte Comune ["+idAccordoServizioParteComune.toString()+"] non esistente");
  122.                     }
  123.                 }
  124.                 else{
  125.                     idAccordoServizioParteComune = this.findIdAccordoServizioParteComune(archive, registryReader, 
  126.                             erogazione.getAccordoServizioParteComune().getIdAccordo().getNome(), 
  127.                             erogazione.getAccordoServizioParteComune().getIdAccordo().getSoggetto(), 
  128.                             erogazione.getAccordoServizioParteComune().getIdAccordo().getVersione());
  129.                 }
  130.             }
  131.             
  132.             // IdSoggetto
  133.             IdSoggetto soggettoErogatore = new IdSoggetto();
  134.             soggettoErogatore.setTipo(erogazione.getSoggettoErogatore().getIdSoggetto().getTipo());
  135.             soggettoErogatore.setNome(erogazione.getSoggettoErogatore().getIdSoggetto().getNome());
  136.             
  137.             // Protocollo
  138.             String protocollo = ManagerUtils.getProtocolByOrganizationType(soggettoErogatore.getTipo());
  139.             
  140.             // Nome Servizio
  141.             String nomeServizio = null;
  142.             if(erogazione.getServizio()!=null && erogazione.getServizio().getNome()!=null){
  143.                 nomeServizio = erogazione.getServizio().getNome();
  144.             }
  145.             else if(erogazione.getAccordoServizioParteComune().getServizio()!=null){
  146.                 nomeServizio = erogazione.getAccordoServizioParteComune().getServizio();
  147.             }
  148.             else {
  149.                 nomeServizio = idAccordoServizioParteComune.getNome();
  150.             }
  151.             
  152.             // TipoServizio
  153.             String tipoServizio = null;
  154.             if(erogazione.getServizio()!=null && erogazione.getServizio().getTipo()!=null){
  155.                 tipoServizio = erogazione.getServizio().getTipo();
  156.             }
  157.             else{
  158.                 tipoServizio = ManagerUtils.getDefaultServiceType(protocollo);
  159.             }
  160.             
  161.             // Dati Servizio
  162.             DatiServizio datiServizio = new DatiServizio();
  163.             datiServizio.setUriAccordoServizioParteComune(this.idAccordoFactory.getUriFromIDAccordo(idAccordoServizioParteComune));
  164.             datiServizio.setPortType(erogazione.getAccordoServizioParteComune().getServizio());
  165.             datiServizio.setTipo(tipoServizio);
  166.             datiServizio.setNome(nomeServizio);
  167.             if(erogazione.getServizio()!=null){
  168.                 datiServizio.setEndpoint(erogazione.getServizio().getEndpoint());
  169.                 if(erogazione.getServizio().getTipologiaServizio()!=null){
  170.                     datiServizio.setTipologiaServizio(erogazione.getServizio().getTipologiaServizio().getValue());
  171.                 }
  172.             }
  173.             datiServizio.setErogatore(soggettoErogatore);

  175.             // Dati Applicativo Erogatore
  176.             boolean createApplicativoErogatore = false;
  177.             boolean createPortaApplicativa = false;
  178.             DatiServizioApplicativoErogatore datiApplicativiErogatore = null;
  179.             if(Tipologia.INTERNA.equals(erogazione.getTipologia())){
  180.                 
  181.                 createPortaApplicativa = true;
  182.                 
  183.                 if(erogazione.getServizioApplicativo()==null){
  184.                     throw new ProtocolException("Servizio Applicativo (Nome o DatiApplicativi) non indicati. Questi dati sono obbligatori per una erogazione di tipologia 'interna'");
  185.                 }
  186.                 
  187.                 datiApplicativiErogatore = new DatiServizioApplicativoErogatore();
  188.                 datiApplicativiErogatore.setNome(erogazione.getServizioApplicativo().getNome());
  189.                 datiApplicativiErogatore.setNomePortaApplicativa(erogazione.getServizioApplicativo().getNomePortaApplicativa());
  190.                                 
  191.                 if(datiApplicativiErogatore.getNome()!=null){
  192.                     boolean existsSA = this.existsServizioApplicativo(archive, configIntegrationReader, erogazione.getSoggettoErogatore().getIdSoggetto(), datiApplicativiErogatore.getNome());
  193.                     if(!existsSA){
  194.                         if(erogazione.getServizioApplicativo().getDatiApplicativi()==null){
  195.                             throw new ProtocolException("Servizio Applicativo (DatiApplicativi) non indicati. Questi dati sono obbligatori per una erogazione di tipologia 'interna', quando viene indicato un servizio applicativo non esistente");
  196.                         }
  197.                         if(erogazione.getServizioApplicativo().getDatiApplicativi().getEndpoint()==null){
  198.                             throw new ProtocolException("Servizio Applicativo (Endpoint) non indicato. Questo dato è obbligatorio per una erogazione di tipologia 'interna', quando viene indicato un servizio applicativo non esistente");
  199.                         }
  200.                         createApplicativoErogatore = true;
  201.                     }
  202.                     else{
  203.                         // Se cmq ho indicato dei dati applicativi, allora magari desidero fare un update
  204.                         if(erogazione.getServizioApplicativo().getDatiApplicativi()!=null &&
  205.                                 erogazione.getServizioApplicativo().getDatiApplicativi().getEndpoint()!=null){
  206.                             createApplicativoErogatore = true;
  207.                         }
  208.                     }
  209.                 }
  210.                 else{
  211.                     if(erogazione.getServizioApplicativo().getDatiApplicativi()==null){
  212.                         throw new ProtocolException("Servizio Applicativo (Nome o DatiApplicativi) non indicati. Questi dati sono obbligatori per una erogazione di tipologia 'interna'");
  213.                     }
  214.                     if(erogazione.getServizioApplicativo().getDatiApplicativi().getEndpoint()==null){
  215.                         throw new ProtocolException("Servizio Applicativo (Endpoint) non indicato. Questo dato è obbligatorio per una erogazione di tipologia 'interna', quando non viene indicato un servizio applicativo");
  216.                     }
  217.                     createApplicativoErogatore = true;
  218.                 }
  219.                     
  220.                 if(createApplicativoErogatore){
  221.                     datiApplicativiErogatore.setEndpoint(erogazione.getServizioApplicativo().getDatiApplicativi().getEndpoint());
  222.                     if(erogazione.getServizioApplicativo().getDatiApplicativi().getCredenzialiBasic()!=null){
  223.                         datiApplicativiErogatore.setUsername(erogazione.getServizioApplicativo().getDatiApplicativi().getCredenzialiBasic().getUsername());
  224.                         datiApplicativiErogatore.setPassword(erogazione.getServizioApplicativo().getDatiApplicativi().getCredenzialiBasic().getPassword());
  225.                     }
  226.                 }
  227.                 
  228.             }
  229.             else{
  230.                 if(erogazione.getServizioApplicativo()!=null){
  231.                     throw new ProtocolException("Servizio Applicativo (Nomi o DatiApplicativi) indicati in una erogazione di tipologia 'esterna'. Tale tipologia non prevede la configurazione di una PA e di un ServizioApplicativo");
  232.                 }
  233.             }
  234.             
  235.             // Dati Soggetto
  236.             boolean createSoggetto = false;
  237.             boolean createPdd = false;
  238.             DatiSoggetto datiSoggetto = new DatiSoggetto();
  239.             datiSoggetto.setId(soggettoErogatore);
  240.             if(this.existsSoggetto(archive, registryReader, erogazione.getSoggettoErogatore().getIdSoggetto()) == false){
  241.                 if(erogazione.getSoggettoErogatore().getNotExistsBehaviour()==null || erogazione.getSoggettoErogatore().getNotExistsBehaviour().isCreate()==false){
  242.                     throw new ProtocolException("Soggetto Erogatore ["+soggettoErogatore.getTipo()+"/"+soggettoErogatore.getNome()+"] non esistente");
  243.                 }
  244.                 else{
  245.                     
  246.                     createSoggetto = true;
  247.                     
  248.                     datiSoggetto.setEndpoint(erogazione.getSoggettoErogatore().getNotExistsBehaviour().getEndpoint());
  249.                     datiSoggetto.setPortaDominio(erogazione.getSoggettoErogatore().getNotExistsBehaviour().getPortaDominio());
  250.                     
  251.                     if(datiSoggetto.getPortaDominio()!=null){
  252.                         if(this.existsPdd(archive, registryReader, datiSoggetto.getPortaDominio())){
  253.                             if(Tipologia.INTERNA.equals(erogazione.getTipologia())){
  254.                                 if(this.isPddOperativa(archive, registryReader, datiSoggetto.getPortaDominio())==false){
  255.                                     throw new ProtocolException("La pdd ["+datiSoggetto.getPortaDominio()+
  256.                                             "] indicata per il Soggetto Erogatore ["+soggettoErogatore.getTipo()+"/"+soggettoErogatore.getNome()+"] "
  257.                                                     + "possiede un tipo 'esterno' non compatibile con una erogazione di tipologia 'interna'. Deve essere associata una pdd di tipo 'operativo'");
  258.                                 }
  259.                             }
  260.                             else{
  261.                                 if(this.isPddOperativa(archive, registryReader, datiSoggetto.getPortaDominio())){
  262.                                     throw new ProtocolException("La pdd ["+datiSoggetto.getPortaDominio()+
  263.                                             "] indicata per il Soggetto Erogatore ["+soggettoErogatore.getTipo()+"/"+soggettoErogatore.getNome()+"] "
  264.                                                     + "possiede un tipo 'operativo' non compatibile con una erogazione di tipologia 'esterna'. Deve essere associata una pdd di tipo 'esterno'");
  265.                                 }
  266.                             }
  267.                         }
  268.                         else{
  269.                             if(Tipologia.INTERNA.equals(erogazione.getTipologia())){
  270.                                 throw new ProtocolException("PdD ["+datiSoggetto.getPortaDominio()+"] non esistente (E' obbligatorio fornire una PdD esistente di tipo 'operativo' se la tipologia di erogazione è 'interna')");
  271.                             }
  272.                             createPdd = true;
  273.                         }
  274.                     }
  275.                     else{
  276.                         if(Tipologia.INTERNA.equals(erogazione.getTipologia())){
  277.                             datiSoggetto.setPortaDominio(this.getPddOperativa(registryReader));
  278.                         }else{
  279.                             createPdd = true; // creo pdd esterna.
  280.                         }
  281.                     }
  282.                     
  283.                 }
  284.             }
  285.                     
  286.             
  287.             // Identificativo Unico di Correlazione
  288.             ArchiveIdCorrelazione idCorrelazione = generateIdCorrelazione(soggettoErogatore.getTipo(), soggettoErogatore.getNome(), 
  289.                     datiServizio.getTipo(), datiServizio.getNome(),
  290.                     erogazione.getDescrizione());
  291.             
  292.             // Creazione mappa per FreeMarker
  293.             Map<String, Object> data = new HashMap<>();
  294.             data.put(CostantiAbstraction.EROGAZIONE_MAP_KEY_SERVIZIO, datiServizio);
  295.             data.put(CostantiAbstraction.EROGAZIONE_MAP_KEY_SOGGETTO, datiSoggetto);
  296.             if(datiApplicativiErogatore!=null){
  297.                 data.put(CostantiAbstraction.EROGAZIONE_MAP_KEY_APPLICATIVO_EROGATORE, datiApplicativiErogatore);
  298.             }
  299.             
  300.             
  301.             // Creazione Pdd e Soggetti
  302.             if(createPdd){
  303.                 byte[]xml = TemplateUtils.toByteArray(templateErogazione.getTemplatePdd(), data);
  304.                 try{
  305.                     this.filler.readPortaDominio(archive, new ByteArrayInputStream(xml), xml, "pdd", validationDocuments, idCorrelazione);
  306.                 }catch(Exception e){
  307.                     throw new Exception("XmlTemplate["+new String(xml)+"]\n"+e.getMessage(),e);
  308.                 }
  309.             }
  310.             if(createSoggetto){
  311.                 byte[]xml = TemplateUtils.toByteArray(templateErogazione.getTemplateSoggetto(), data);
  312.                 try{
  313.                     this.filler.readSoggetto(archive,new ByteArrayInputStream(xml), xml, "soggetto", 
  314.                             soggettoErogatore.getTipo(), soggettoErogatore.getNome(), validationDocuments, idCorrelazione);
  315.                 }catch(Exception e){
  316.                     throw new Exception("XmlTemplate["+new String(xml)+"]\n"+e.getMessage(),e);
  317.                 }
  318.             }
  319.             
  320.             // Creazione Accordi di Servizio Parte Specifica
  321.             for (int i = 0; i < templateErogazione.getTemplateAccordiParteSpecifica().size(); i++) {
  322.                 byte[]xml = TemplateUtils.toByteArray(templateErogazione.getTemplateAccordiParteSpecifica().get(i), data);
  323.                 try{
  324.                     //String fileSystemName = this.filler.convertCharNonPermessiQualsiasiSistemaOperativo(datiServizio.getNome(),false);
  325.                     String tipo = datiServizio.getTipo();
  326.                     String nome = datiServizio.getNome();
  327.                     this.filler.readAccordoServizioParteSpecifica(archive, new ByteArrayInputStream(xml), xml,
  328.                         "asps_"+i, soggettoErogatore.getTipo(), soggettoErogatore.getNome(), "asps_"+i, 
  329.                         tipo, nome, ZIPReadUtils.USE_VERSION_XML_BEAN, validationDocuments, idCorrelazione,
  330.                         ArchiveVersion.V_1,null,null,null);
  331.                 }catch(Exception e){
  332.                     throw new Exception("XmlTemplate["+new String(xml)+"]\n"+e.getMessage(),e);
  333.                 }
  334.             }
  335.             
  336.             // Creazione Fruitori
  337.             if(erogazione.getServizio()!=null && 
  338.                     erogazione.getServizio().getFruitori()!=null &&
  339.                     erogazione.getServizio().getFruitori().sizeFruitoreList()>0){
  340.                 for (int i = 0; i < erogazione.getServizio().getFruitori().sizeFruitoreList(); i++) {
  341.                     Soggetto fruitore = erogazione.getServizio().getFruitori().getFruitore(i);
  342.                     IdSoggetto s = new IdSoggetto();
  343.                     s.setTipo(fruitore.getTipo());
  344.                     s.setNome(fruitore.getNome());
  345.                     data.remove(CostantiAbstraction.EROGAZIONE_MAP_KEY_FRUITORE);
  346.                     data.put(CostantiAbstraction.EROGAZIONE_MAP_KEY_FRUITORE, s);
  347.                     
  348.                     byte[]xml = TemplateUtils.toByteArray(templateErogazione.getTemplateFruitore(), data);
  349.                     try{
  350.                         this.filler.readAccordoServizioParteSpecifica_Fruitore(archive, new ByteArrayInputStream(xml), xml, 
  351.                                 "fruitore_"+i, "asps_"+i, soggettoErogatore.getTipo(), soggettoErogatore.getNome(), 
  352.                                 tipoServizio,nomeServizio, ZIPReadUtils.USE_VERSION_XML_BEAN, validationDocuments, idCorrelazione,
  353.                                 ArchiveVersion.V_1,null,null);
  354.                     }catch(Exception e){
  355.                         throw new Exception("XmlTemplate["+new String(xml)+"]\n"+e.getMessage(),e);
  356.                     }
  357.                 }
  358.             }
  359.             data.remove(CostantiAbstraction.EROGAZIONE_MAP_KEY_FRUITORE);
  360.             
  361.             // Creazione SA
  362.             if(createApplicativoErogatore){
  363.                 for (int i = 0; i < templateErogazione.getTemplateServiziApplicativi().size(); i++) {
  364.                     byte[]xml = TemplateUtils.toByteArray(templateErogazione.getTemplateServiziApplicativi().get(i), data);
  365.                     try{
  366.                         this.filler.readServizioApplicativo(archive, new ByteArrayInputStream(xml), xml, 
  367.                             "sa_"+i, soggettoErogatore.getTipo(), soggettoErogatore.getNome(), validationDocuments, idCorrelazione);
  368.                     }catch(Exception e){
  369.                         throw new Exception("XmlTemplate["+new String(xml)+"]\n"+e.getMessage(),e);
  370.                     }
  371.                 }
  372.             }
  373.             
  374.             // Creazione PortaApplicativa
  375.             if(createPortaApplicativa){
  376.                 for (int i = 0; i < templateErogazione.getTemplatePorteApplicative().size(); i++) {
  377.                     byte[]xml = TemplateUtils.toByteArray(templateErogazione.getTemplatePorteApplicative().get(i), data);
  378.                     try{
  379.                         this.filler.readPortaApplicativa(archive, new ByteArrayInputStream(xml), xml, 
  380.                             "pa_"+i, soggettoErogatore.getTipo(), soggettoErogatore.getNome(), validationDocuments, idCorrelazione);
  381.                     }catch(Exception e){
  382.                         throw new Exception("XmlTemplate["+new String(xml)+"]\n"+e.getMessage(),e);
  383.                     }
  384.                 }
  385.             }
  386.             
  387.             // Creazione Mapping Erogazione
  388.             for (int i = 0; i < archive.getPorteApplicative().size(); i++) {
  389.                 ArchivePortaApplicativa aPA = archive.getPorteApplicative().get(i);
  390.                 if(idCorrelazione.equals(aPA.getIdCorrelazione())){
  391.                     // Devo aggiungerlo in tutte le erogazioni la porta applicativa
  392.                     for (int j = 0; j < archive.getAccordiServizioParteSpecifica().size(); j++) {
  393.                         ArchiveAccordoServizioParteSpecifica aASPS = archive.getAccordiServizioParteSpecifica().get(j);
  394.                         if(idCorrelazione.equals(aASPS.getIdCorrelazione())){
  395.                                 
  396.                             MappingErogazionePortaApplicativa mapping = new MappingErogazionePortaApplicativa();
  397.                             mapping.setNome("regola_"+i+"_"+aPA.getIdPortaApplicativa().getNome());
  398.                             mapping.setIdServizio(aASPS.getIdAccordoServizioParteSpecifica());
  399.                             mapping.setIdPortaApplicativa(aPA.getIdPortaApplicativa());
  400.                             mapping.setDefault(aPA.getPortaApplicativa().getAzione()==null || 
  401.                                     !PortaApplicativaAzioneIdentificazione.DELEGATED_BY.equals(aPA.getPortaApplicativa().getAzione().getIdentificazione()));
  402.                             
  403.                             if(aASPS.getMappingPorteApplicativeAssociate()==null) {
  404.                                 aASPS.setMappingPorteApplicativeAssociate(new ArrayList<>());
  405.                             }
  406.                             aASPS.getMappingPorteApplicativeAssociate().add(mapping);
  407.                         }
  408.                     }
  409.                 }
  410.             }
  411.             
  412.             return idCorrelazione;
  413.             
  414.         }catch(Exception e){
  415.             throw new ProtocolException(e.getMessage(),e);
  416.         }
  417.         
  418.         
  419.     }
  420.     

  422.     
  423. }
Created with JaCoCo 0.8.8.202204050719