FruizioneConverter.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.PortaDelegataAzioneIdentificazione;
  29. import org.openspcoop2.core.id.IDServizio;
  30. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  31. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  32. import org.openspcoop2.protocol.abstraction.Fruizione;
  33. import org.openspcoop2.protocol.abstraction.constants.Autenticazione;
  34. import org.openspcoop2.protocol.abstraction.constants.CostantiAbstraction;
  35. import org.openspcoop2.protocol.abstraction.constants.Tipologia;
  36. import org.openspcoop2.protocol.abstraction.template.DatiFruizione;
  37. import org.openspcoop2.protocol.abstraction.template.DatiServizio;
  38. import org.openspcoop2.protocol.abstraction.template.DatiServizioApplicativoFruitore;
  39. import org.openspcoop2.protocol.abstraction.template.DatiSoggetto;
  40. import org.openspcoop2.protocol.abstraction.template.IdSoggetto;
  41. import org.openspcoop2.protocol.abstraction.template.TemplateFruizione;
  42. import org.openspcoop2.protocol.basic.archive.ZIPReadUtils;
  43. import org.openspcoop2.protocol.sdk.ProtocolException;
  44. import org.openspcoop2.protocol.sdk.archive.Archive;
  45. import org.openspcoop2.protocol.sdk.archive.ArchiveFruitore;
  46. import org.openspcoop2.protocol.sdk.archive.ArchiveIdCorrelazione;
  47. import org.openspcoop2.protocol.sdk.archive.ArchivePortaDelegata;
  48. import org.openspcoop2.protocol.sdk.constants.ArchiveVersion;
  49. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  50. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  51. import org.openspcoop2.protocol.utils.ManagerUtils;
  52. import org.openspcoop2.utils.RandomString;
  53. import org.openspcoop2.utils.Utilities;
  54. import org.openspcoop2.utils.resources.TemplateUtils;
  55. import org.slf4j.Logger;

  57. /**     
  58.  * FruizioneConverter
  59.  *
  60.  * @author Poli Andrea (poli@link.it)
  61.  * @author $Author$
  62.  * @version $Rev$, $Date$
  63.  */
  64. public class FruizioneConverter extends AbstractConverter {

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

  93.         return idCorrelazione;
  94.     }
  95.     
  96.     
  97.     
  98.     
  99.     
  100.     
  101.     // ----- Instance method -----

  103.     public FruizioneConverter(Logger log,ZIPReadUtils zipReader) throws ProtocolException{
  104.         super(log, zipReader);
  105.     }
  106.     
  107.     // ritorna l'identificativo di correlazione.
  108.     public ArchiveIdCorrelazione fillArchive(Archive archive, Fruizione fruizione, TemplateFruizione templateFruizione,
  109.             IRegistryReader registryReader, IConfigIntegrationReader configIntegrationReader, boolean validationDocuments) throws ProtocolException{
  110.         
  111.         try{
  112.             
  113.             // Cerco identificare accordo di servizio parte speicfica
  114.             IDServizio idAccordoServizioParteSpecifica = null;
  115.             if(fruizione.getAccordoServizioParteSpecifica().getUri()!=null){
  116.                 idAccordoServizioParteSpecifica = this.idServizioFactory.getIDServizioFromUri(fruizione.getAccordoServizioParteSpecifica().getUri());
  117.                 if(idAccordoServizioParteSpecifica.getVersione()==null){
  118.                     // forzo il default a 1
  119.                     idAccordoServizioParteSpecifica = this.idServizioFactory.getIDServizioFromValues(idAccordoServizioParteSpecifica.getTipo(), idAccordoServizioParteSpecifica.getNome(), 
  120.                             idAccordoServizioParteSpecifica.getSoggettoErogatore(), 1);
  121.                 }
  122.                 if(this.existsAccordoServizioParteSpecifica(archive, registryReader, idAccordoServizioParteSpecifica)==false){
  123.                     throw new ProtocolException("Accordo di Servizio Parte Specifica ["+idAccordoServizioParteSpecifica.toString()+"] non esistente");
  124.                 }
  125.             }
  126.             else {
  127.                 if(fruizione.getAccordoServizioParteSpecifica().getIdServizio().getSoggetto()!=null && 
  128.                         fruizione.getAccordoServizioParteSpecifica().getIdServizio().getTipo()!=null){
  129.                     idAccordoServizioParteSpecifica = this.idServizioFactory.getIDServizioFromValues(fruizione.getAccordoServizioParteSpecifica().getIdServizio().getSoggetto().getTipo(), 
  130.                             fruizione.getAccordoServizioParteSpecifica().getIdServizio().getSoggetto().getNome(),
  131.                             fruizione.getAccordoServizioParteSpecifica().getIdServizio().getTipo(),
  132.                             fruizione.getAccordoServizioParteSpecifica().getIdServizio().getNome(), 
  133.                             1);
  134.                     if(this.existsAccordoServizioParteSpecifica(archive, registryReader, idAccordoServizioParteSpecifica)==false){
  135.                         throw new ProtocolException("Accordo di Servizio Parte Specifica ["+idAccordoServizioParteSpecifica.toString()+"] non esistente");
  136.                     }
  137.                 }
  138.                 else{
  139.                     idAccordoServizioParteSpecifica = this.findIdAccordoServizioParteSpecifica(archive, registryReader, 
  140.                             fruizione.getAccordoServizioParteSpecifica().getIdServizio().getNome(), 
  141.                             fruizione.getAccordoServizioParteSpecifica().getIdServizio().getTipo(), 
  142.                             1,
  143.                             fruizione.getAccordoServizioParteSpecifica().getIdServizio().getSoggetto());
  144.                 }
  145.             }
  146.             AccordoServizioParteSpecifica asps = this.getAccordoServizioParteSpecifica(archive, registryReader, idAccordoServizioParteSpecifica);
  147.             if(asps==null){
  148.                 throw new ProtocolException("Accordo di Servizio Parte Specifica ["+idAccordoServizioParteSpecifica.toString()+"] non esistente ?");
  149.             }
  150.             
  151.             // IdSoggetto
  152.             IdSoggetto soggettoErogatore = new IdSoggetto();
  153.             soggettoErogatore.setTipo(idAccordoServizioParteSpecifica.getSoggettoErogatore().getTipo());
  154.             soggettoErogatore.setNome(idAccordoServizioParteSpecifica.getSoggettoErogatore().getNome());
  155.             
  156.             // Protocollo
  157.             @SuppressWarnings("unused")
  158.             String protocollo = ManagerUtils.getProtocolByOrganizationType(soggettoErogatore.getTipo());
  159.                         
  160.             // Dati Servizio
  161.             DatiServizio datiServizio = new DatiServizio();
  162.             datiServizio.setUriAccordoServizioParteComune(asps.getAccordoServizioParteComune());
  163.             datiServizio.setPortType(asps.getPortType());
  164.             datiServizio.setTipo(idAccordoServizioParteSpecifica.getTipo());
  165.             datiServizio.setNome(idAccordoServizioParteSpecifica.getNome());
  166.             datiServizio.setErogatore(soggettoErogatore);
  167.             
  168.             // Dati Fruizione
  169.             IdSoggetto soggettoFruitore = new IdSoggetto();
  170.             soggettoFruitore.setTipo(fruizione.getSoggettoFruitore().getIdSoggetto().getTipo());
  171.             soggettoFruitore.setNome(fruizione.getSoggettoFruitore().getIdSoggetto().getNome());
  172.             DatiFruizione datiFruizione = new DatiFruizione();
  173.             datiFruizione.setSoggetto(soggettoFruitore);
  174.             if(fruizione.getFruizione()!=null){
  175.                 if(fruizione.getFruizione().getClientAuth()!=null){
  176.                     datiFruizione.setClientAuth(fruizione.getFruizione().getClientAuth().getValue());
  177.                 }
  178.                 datiFruizione.setEndpoint(fruizione.getFruizione().getEndpoint());
  179.             }

  181.             // Dati Applicativo Fruitore
  182.             boolean createApplicativoFruitore = false;
  183.             boolean createPortaDelegata = false;
  184.             DatiServizioApplicativoFruitore datiApplicativoFruitore = null;
  185.             if(Tipologia.INTERNA.equals(fruizione.getTipologia())){
  186.                 
  187.                 createPortaDelegata = true;
  188.                 
  189.                 if(fruizione.getServizioApplicativo()==null){
  190.                     throw new ProtocolException("Servizio Applicativo (Nome o DatiApplicativi) non indicati. Questi dati sono obbligatori per una fruizione di tipologia 'interna'");
  191.                 }
  192.                 
  193.                 datiApplicativoFruitore = new DatiServizioApplicativoFruitore();
  194.                 datiApplicativoFruitore.setNome(fruizione.getServizioApplicativo().getNome());
  195.                 datiApplicativoFruitore.setNomePortaDelegata(fruizione.getServizioApplicativo().getNomePortaDelegata());
  196.                 
  197.                 if(datiApplicativoFruitore.getNome()!=null){
  198.                     boolean existsSA = this.existsServizioApplicativo(archive, configIntegrationReader, fruizione.getSoggettoFruitore().getIdSoggetto(), datiApplicativoFruitore.getNome());
  199.                     if(!existsSA){
  200.                         if(fruizione.getServizioApplicativo().getDatiApplicativi()==null){
  201.                             throw new ProtocolException("Servizio Applicativo (DatiApplicativi) non indicati. Questi dati sono obbligatori per una fruizione di tipologia 'interna', quando viene indicato un servizio applicativo non esistente");
  202.                         }
  203.                         if(fruizione.getServizioApplicativo().getDatiApplicativi().getAutenticazione()==null){
  204.                             throw new ProtocolException("Servizio Applicativo (Autenticazione) non indicato. Questo dato è obbligatorio per una fruizione di tipologia 'interna', quando viene indicato un servizio applicativo non esistente");
  205.                         }
  206.                         datiApplicativoFruitore.setAutenticazione(fruizione.getServizioApplicativo().getDatiApplicativi().getAutenticazione().getValue());
  207.                         if(Autenticazione.NONE.equals(fruizione.getServizioApplicativo().getDatiApplicativi().getAutenticazione())==false){
  208.                             createApplicativoFruitore = true;
  209.                         }
  210.                     }
  211.                     else{
  212.                         // Se cmq ho indicato dei dati applicativi, allora magari desidero fare un update
  213.                         if(fruizione.getServizioApplicativo().getDatiApplicativi()!=null &&
  214.                                 fruizione.getServizioApplicativo().getDatiApplicativi().getAutenticazione() != null ){
  215.                             datiApplicativoFruitore.setAutenticazione(fruizione.getServizioApplicativo().getDatiApplicativi().getAutenticazione().getValue());
  216.                             if(Autenticazione.NONE.equals(fruizione.getServizioApplicativo().getDatiApplicativi().getAutenticazione())==false){
  217.                                 createApplicativoFruitore = true;
  218.                             }
  219.                         }
  220.                         else{
  221.                             datiApplicativoFruitore.setAutenticazione(this.getTipoCredenzialeServizioApplicativo(archive, configIntegrationReader, 
  222.                                     fruizione.getSoggettoFruitore().getIdSoggetto(), datiApplicativoFruitore.getNome()));
  223.                         }
  224.                     }
  225.                 }
  226.                 else{
  227.                     if(fruizione.getServizioApplicativo().getDatiApplicativi()==null){
  228.                         throw new ProtocolException("Servizio Applicativo (Nome o DatiApplicativi) non indicati. Questi dati sono obbligatori per una fruizione di tipologia 'interna'");
  229.                     }
  230.                     if(fruizione.getServizioApplicativo().getDatiApplicativi().getAutenticazione()==null){
  231.                         throw new ProtocolException("Servizio Applicativo (Autenticazione) non indicato. Questo dato è obbligatorio per una fruizione di tipologia 'interna', quando non viene indicato un servizio applicativo");
  232.                     }
  233.                     datiApplicativoFruitore.setAutenticazione(fruizione.getServizioApplicativo().getDatiApplicativi().getAutenticazione().getValue());
  234.                     if(Autenticazione.NONE.equals(fruizione.getServizioApplicativo().getDatiApplicativi().getAutenticazione())==false){
  235.                         createApplicativoFruitore = true;
  236.                     }
  237.                 }
  238.                 
  239.                 if(createApplicativoFruitore){
  240.                     
  241.                     if(Autenticazione.SSL.equals(fruizione.getServizioApplicativo().getDatiApplicativi().getAutenticazione())){
  242.                         if(fruizione.getServizioApplicativo().getDatiApplicativi().getSslSubject()==null){
  243.                             throw new ProtocolException("Ssl Subject non indicato per la fruizione, nonostante sia indicata una autenticazione di tipo 'ssl'");
  244.                         }
  245.                         if(fruizione.getServizioApplicativo().getDatiApplicativi().getBasicUsername()!=null){
  246.                             throw new ProtocolException("Basic Username non deve essere indicato per la fruizione. E' stata impostata una autenticazione di tipo 'ssl'");
  247.                         }
  248.                         if(fruizione.getServizioApplicativo().getDatiApplicativi().getBasicPassword()!=null){
  249.                             throw new ProtocolException("Basic Password non deve essere indicato per la fruizione. E' stata impostata una autenticazione di tipo 'ssl'");
  250.                         }
  251.                         datiApplicativoFruitore.setSslSubject(fruizione.getServizioApplicativo().getDatiApplicativi().getSslSubject());
  252.                     }
  253.                     else if(Autenticazione.BASIC.equals(fruizione.getServizioApplicativo().getDatiApplicativi().getAutenticazione())){
  254.                         if(fruizione.getServizioApplicativo().getDatiApplicativi().getSslSubject()!=null){
  255.                             throw new ProtocolException("Ssl Subject non deve essere indicato per la fruizione. E' stata impostata una autenticazione di tipo 'basic'");
  256.                         }
  257.                         datiApplicativoFruitore.setBasicUsername(fruizione.getServizioApplicativo().getDatiApplicativi().getBasicUsername());
  258.                         datiApplicativoFruitore.setBasicPassword(fruizione.getServizioApplicativo().getDatiApplicativi().getBasicPassword());
  259.                         if(datiApplicativoFruitore.getBasicPassword()==null){
  260.                             RandomString randomString = new RandomString(10);
  261.                             datiApplicativoFruitore.setBasicPassword(randomString.nextString());
  262.                         }
  263.                     }
  264.                 }
  265.     
  266.             }
  267.             else{
  268.                 if(fruizione.getServizioApplicativo()!=null){
  269.                     throw new ProtocolException("Servizio Applicativo (Nomi o DatiApplicativi) indicati in una fruizione di tipologia 'esterna'. Tale tipologia non prevede la configurazione di una PD e di un ServizioApplicativo");
  270.                 }
  271.             }
  272.             
  273.             // Dati Soggetto
  274.             boolean createSoggetto = false;
  275.             boolean createPdd = false;
  276.             DatiSoggetto datiSoggetto = new DatiSoggetto();
  277.             datiSoggetto.setId(soggettoFruitore);
  278.             if(this.existsSoggetto(archive, registryReader, fruizione.getSoggettoFruitore().getIdSoggetto()) == false){
  279.                 if(fruizione.getSoggettoFruitore().getNotExistsBehaviour()==null || fruizione.getSoggettoFruitore().getNotExistsBehaviour().isCreate()==false){
  280.                     throw new ProtocolException("Soggetto Fruitore ["+soggettoFruitore.getTipo()+"/"+soggettoFruitore.getNome()+"] non esistente");
  281.                 }
  282.                 else{
  283.                     
  284.                     createSoggetto = true;
  285.                     
  286.                     datiSoggetto.setEndpoint(fruizione.getSoggettoFruitore().getNotExistsBehaviour().getEndpoint());
  287.                     datiSoggetto.setPortaDominio(fruizione.getSoggettoFruitore().getNotExistsBehaviour().getPortaDominio());
  288.                     
  289.                     if(datiSoggetto.getPortaDominio()!=null){
  290.                         if(this.existsPdd(archive, registryReader, datiSoggetto.getPortaDominio())){
  291.                             if(Tipologia.INTERNA.equals(fruizione.getTipologia())){
  292.                                 if(this.isPddOperativa(archive, registryReader, datiSoggetto.getPortaDominio())==false){
  293.                                     throw new ProtocolException("La pdd ["+datiSoggetto.getPortaDominio()+
  294.                                             "] indicata per il Soggetto Fruitore ["+soggettoFruitore.getTipo()+"/"+soggettoFruitore.getNome()+"] "
  295.                                                     + "possiede un tipo 'esterno' non compatibile con una fruizione di tipologia 'interna'. Deve essere associata una pdd di tipo 'operativo'");
  296.                                 }
  297.                             }
  298.                             else{
  299.                                 if(this.isPddOperativa(archive, registryReader, datiSoggetto.getPortaDominio())){
  300.                                     throw new ProtocolException("La pdd ["+datiSoggetto.getPortaDominio()+
  301.                                             "] indicata per il Soggetto Fruitore ["+soggettoFruitore.getTipo()+"/"+soggettoFruitore.getNome()+"] "
  302.                                                     + "possiede un tipo 'operativo' non compatibile con una fruizione di tipologia 'esterna'. Deve essere associata una pdd di tipo 'esterno'");
  303.                                 }
  304.                             }
  305.                         }
  306.                         else{
  307.                             if(Tipologia.INTERNA.equals(fruizione.getTipologia())){
  308.                                 throw new ProtocolException("PdD ["+datiSoggetto.getPortaDominio()+"] non esistente (E' obbligatorio fornire una PdD esistente di tipo 'operativo' se la tipologia di fruizione è 'interna')");
  309.                             }
  310.                             createPdd = true;
  311.                         }
  312.                     }
  313.                     else{
  314.                         if(Tipologia.INTERNA.equals(fruizione.getTipologia())){
  315.                             datiSoggetto.setPortaDominio(this.getPddOperativa(registryReader));
  316.                         }else{
  317.                             createPdd = true; // creo pdd esterna.
  318.                         }
  319.                     }
  320.                     
  321.                 }
  322.             }
  323.                     
  324.             
  325.             // Identificativo Unico di Correlazione
  326.             ArchiveIdCorrelazione idCorrelazione = generateIdCorrelazione(soggettoFruitore.getTipo(),soggettoFruitore.getNome(),
  327.                     soggettoErogatore.getTipo(), soggettoErogatore.getNome(), datiServizio.getTipo(), datiServizio.getNome(),
  328.                     fruizione.getDescrizione());
  329.             
  330.             // Creazione mappa per FreeMarker
  331.             Map<String, Object> data = new HashMap<>();
  332.             data.put(CostantiAbstraction.EROGAZIONE_MAP_KEY_SERVIZIO, datiServizio);
  333.             data.put(CostantiAbstraction.EROGAZIONE_MAP_KEY_SOGGETTO, datiSoggetto);
  334.             data.put(CostantiAbstraction.EROGAZIONE_MAP_KEY_FRUIZIONE, datiFruizione);
  335.             data.put(CostantiAbstraction.EROGAZIONE_MAP_KEY_FRUITORE, soggettoFruitore); // metto entrambi in modo da averli a disposizione nel template
  336.             if(datiApplicativoFruitore!=null){
  337.                 data.put(CostantiAbstraction.EROGAZIONE_MAP_KEY_APPLICATIVO_FRUITORE, datiApplicativoFruitore);
  338.             }
  339.             
  340.             
  341.             // Creazione Pdd e Soggetti
  342.             if(createPdd){
  343.                 byte[]xml = TemplateUtils.toByteArray(templateFruizione.getTemplatePdd(), data);
  344.                 try{
  345.                     this.filler.readPortaDominio(archive, new ByteArrayInputStream(xml), xml, "pdd", validationDocuments, idCorrelazione);
  346.                 }catch(Exception e){
  347.                     throw new Exception("XmlTemplate["+new String(xml)+"]\n"+e.getMessage(),e);
  348.                 }
  349.             }
  350.             if(createSoggetto){
  351.                 byte[]xml = TemplateUtils.toByteArray(templateFruizione.getTemplateSoggetto(), data);
  352.                 try{
  353.                     this.filler.readSoggetto(archive,new ByteArrayInputStream(xml), xml, "soggetto", 
  354.                             soggettoFruitore.getTipo(), soggettoFruitore.getNome(), validationDocuments, idCorrelazione);
  355.                 }catch(Exception e){
  356.                     throw new Exception("XmlTemplate["+new String(xml)+"]\n"+e.getMessage(),e);
  357.                 }
  358.             }
  359.             
  360.             // Creazione Fruizione
  361.             byte[]xml = TemplateUtils.toByteArray(templateFruizione.getTemplateFruitore(), data);
  362.             try{
  363.                 this.filler.readAccordoServizioParteSpecifica_Fruitore(archive, new ByteArrayInputStream(xml), xml, 
  364.                         "fruizione", "servizio", soggettoErogatore.getTipo(), soggettoErogatore.getNome(), 
  365.                         idAccordoServizioParteSpecifica.getTipo(), idAccordoServizioParteSpecifica.getNome(), idAccordoServizioParteSpecifica.getVersione()+"", 
  366.                         validationDocuments, idCorrelazione,
  367.                         ArchiveVersion.V_1,null, null);
  368.             }catch(Exception e){
  369.                 throw new Exception("XmlTemplate["+new String(xml)+"]\n"+e.getMessage(),e);
  370.             }
  371.             
  372.             // Creazione SA
  373.             if(createApplicativoFruitore){
  374.                 for (int i = 0; i < templateFruizione.getTemplateServiziApplicativi().size(); i++) {
  375.                     xml = TemplateUtils.toByteArray(templateFruizione.getTemplateServiziApplicativi().get(i), data);
  376.                     try{
  377.                         this.filler.readServizioApplicativo(archive, new ByteArrayInputStream(xml), xml, 
  378.                             "sa_"+i, soggettoFruitore.getTipo(), soggettoFruitore.getNome(), validationDocuments, idCorrelazione);
  379.                     }catch(Exception e){
  380.                         throw new Exception("XmlTemplate["+new String(xml)+"]\n"+e.getMessage(),e);
  381.                     }
  382.                 }
  383.             }
  384.                         
  385.             // Creazione PortaDelegata
  386.             if(createPortaDelegata){
  387.                 for (int i = 0; i < templateFruizione.getTemplatePorteDelegate().size(); i++) {
  388.                     xml = TemplateUtils.toByteArray(templateFruizione.getTemplatePorteDelegate().get(i), data);
  389.                     try{
  390.                         this.filler.readPortaDelegata(archive, new ByteArrayInputStream(xml), xml, 
  391.                             "pd_"+i, soggettoFruitore.getTipo(), soggettoFruitore.getNome(), validationDocuments, idCorrelazione);
  392.                     }catch(Exception e){
  393.                         throw new Exception("XmlTemplate["+new String(xml)+"]\n"+e.getMessage(),e);
  394.                     }
  395.                 }
  396.             }
  397.             
  398.             // Creazione Mapping Fruizione
  399.             for (int i = 0; i < archive.getPorteDelegate().size(); i++) {
  400.                 ArchivePortaDelegata aPD = archive.getPorteDelegate().get(i);
  401.                 if(idCorrelazione.equals(aPD.getIdCorrelazione())){
  402.                     // Devo aggiungere in tutte le fruizioni la porta delegata
  403.                     for (int j = 0; j < archive.getAccordiFruitori().size(); j++) {
  404.                         ArchiveFruitore aFruitore = archive.getAccordiFruitori().get(j);
  405.                         if(idCorrelazione.equals(aFruitore.getIdCorrelazione())){
  406.                             
  407.                             MappingFruizionePortaDelegata mapping = new MappingFruizionePortaDelegata();
  408.                             mapping.setNome("regola_"+i+"_"+aPD.getIdPortaDelegata().getNome());
  409.                             mapping.setIdServizio(aFruitore.getIdAccordoServizioParteSpecifica());
  410.                             mapping.setIdFruitore(aFruitore.getIdSoggettoFruitore());
  411.                             mapping.setIdPortaDelegata(aPD.getIdPortaDelegata());
  412.                             mapping.setDefault(aPD.getPortaDelegata().getAzione()==null || 
  413.                                     !PortaDelegataAzioneIdentificazione.DELEGATED_BY.equals(aPD.getPortaDelegata().getAzione().getIdentificazione()));
  414.                             
  415.                             if(aFruitore.getMappingPorteDelegateAssociate()==null) {
  416.                                 aFruitore.setMappingPorteDelegateAssociate(new ArrayList<>());
  417.                             }
  418.                             aFruitore.getMappingPorteDelegateAssociate().add(mapping);
  419.                         }
  420.                     }
  421.                 }
  422.             }
  423.             
  424.             return idCorrelazione;
  425.             
  426.         }catch(Exception e){
  427.             throw new ProtocolException(e.getMessage(),e);
  428.         }
  429.         
  430.         
  431.     }
  432.     

  434.     
  435. }
Created with JaCoCo 0.8.8.202204050719