ImporterInformationMissingSetter.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.  */
  20. package org.openspcoop2.protocol.engine.archive;

  22. import java.util.ArrayList;
  23. import java.util.List;

  25. import org.openspcoop2.core.config.CorrelazioneApplicativaElemento;
  26. import org.openspcoop2.core.config.CorrelazioneApplicativaRispostaElemento;
  27. import org.openspcoop2.core.config.Credenziali;
  28. import org.openspcoop2.core.config.InvocazioneCredenziali;
  29. import org.openspcoop2.core.config.InvocazionePorta;
  30. import org.openspcoop2.core.config.InvocazioneServizio;
  31. import org.openspcoop2.core.config.PortaApplicativa;
  32. import org.openspcoop2.core.config.PortaDelegata;
  33. import org.openspcoop2.core.config.ServizioApplicativo;
  34. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  35. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  36. import org.openspcoop2.core.config.constants.TipologiaFruizione;
  37. import org.openspcoop2.core.id.IDAccordo;
  38. import org.openspcoop2.core.id.IDAccordoCooperazione;
  39. import org.openspcoop2.core.id.IDServizio;
  40. import org.openspcoop2.core.id.IDSoggetto;
  41. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  42. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  43. import org.openspcoop2.core.registry.AccordoCooperazione;
  44. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  45. import org.openspcoop2.core.registry.AccordoServizioParteComuneServizioComposto;
  46. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  47. import org.openspcoop2.core.registry.ConfigurazioneServizio;
  48. import org.openspcoop2.core.registry.Connettore;
  49. import org.openspcoop2.core.registry.Fruitore;
  50. import org.openspcoop2.core.registry.IdSoggetto;
  51. import org.openspcoop2.core.registry.Property;
  52. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  53. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  54. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  55. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  56. import org.openspcoop2.protocol.information_missing.ReplaceFruitoreMatchType;
  57. import org.openspcoop2.protocol.information_missing.ReplaceMatchFieldType;
  58. import org.openspcoop2.protocol.information_missing.ReplaceMatchType;
  59. import org.openspcoop2.protocol.information_missing.Soggetto;
  60. import org.openspcoop2.protocol.information_missing.constants.Costanti;
  61. import org.openspcoop2.protocol.information_missing.constants.ReplaceKeywordType;
  62. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  63. import org.openspcoop2.protocol.sdk.ProtocolException;
  64. import org.openspcoop2.protocol.sdk.archive.Archive;
  65. import org.openspcoop2.protocol.sdk.archive.ArchiveAccordoServizioParteSpecifica;
  66. import org.openspcoop2.protocol.sdk.archive.ArchiveFruitore;
  67. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;

  69. /**
  70.  * ImporterInformationMissingSetter
  71.  *
  72.  * @author Andrea Poli (apoli@link.it)
  73.  * @author $Author$
  74.  * @version $Rev$, $Date$
  75.  */
  76. public class ImporterInformationMissingSetter {

  78.     public static void setInformationMissingReferenteAPI(Archive archive, IRegistryReader registryReader) throws ProtocolException {
  79.         // Accordi di Servizio Parte Comune 
  80.         if(archive.getAccordiServizioParteComune()!=null && archive.getAccordiServizioParteComune().size()>0) {
  81.             for (int i = 0; i < archive.getAccordiServizioParteComune().size(); i++) {
  82.                 AccordoServizioParteComune as = archive.getAccordiServizioParteComune().get(i).getAccordoServizioParteComune();
  83.                 IdSoggetto soggettoReferente = as.getSoggettoReferente();
  84.                 String tipoSoggettoReferente = null;
  85.                 String nomeSoggettoReferente = null;
  86.                 if(soggettoReferente!=null){
  87.                     tipoSoggettoReferente = soggettoReferente.getTipo();
  88.                     nomeSoggettoReferente = soggettoReferente.getNome();
  89.                 }
  90.                 if(tipoSoggettoReferente!=null && !"".equals(tipoSoggettoReferente) && 
  91.                         (nomeSoggettoReferente==null || "".equals(nomeSoggettoReferente))){
  92.                     
  93.                     ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance(); 
  94.                     IProtocolFactory<?> protocol = protocolFactoryManager.getProtocolFactoryByOrganizationType(tipoSoggettoReferente);
  95.                     boolean referente = protocol.createProtocolConfiguration().isSupportoSoggettoReferenteAccordiParteComune();
  96.                     if(!referente) {
  97.                         String tipoSoggettoDefault = protocolFactoryManager.getDefaultOrganizationTypes().get(protocol.getProtocol());
  98.                         IDSoggetto idSoggettoDefault = null;
  99.                         try {
  100.                             idSoggettoDefault = registryReader.getIdSoggettoDefault(tipoSoggettoDefault);
  101.                         }catch(Exception e) {
  102.                             throw new ProtocolException(e.getMessage(),e);
  103.                         }
  104.                         as.getSoggettoReferente().setNome(idSoggettoDefault.getNome());                     
  105.                     }
  106.                 }
  107.             }
  108.         }
  109.     }
  110.     
  111.     public static void setInformationMissingSoggetto(Archive archive, Soggetto soggetto, IDSoggetto idSoggetto, Connettore connettore) throws ProtocolException{
  112.         
  113.         switch (soggetto.getTipo()) {
  114.         case RIFERIMENTO:
  115.             setInformationMissing_RiferimentoSoggetto(archive, soggetto, idSoggetto);
  116.             break;
  117.         case CONNETTORE:
  118.             setInformationMissing_ConnettoreSoggetto(archive, soggetto, connettore);
  119.             break;
  120.         }
  121.         
  122.     }
  123.     
  124.     public static void setInformationMissingServizioApplicativo(Archive archive, org.openspcoop2.protocol.information_missing.ServizioApplicativo sa, 
  125.             InvocazioneServizio invocazioneServizio, Credenziali credenziali) throws ProtocolException{
  126.         
  127.         switch (sa.getTipo()) {
  128.         case RIFERIMENTO:
  129.             // non ancora gestito
  130.             break;
  131.         case CONNETTORE:
  132.             setInformationMissing_ConnettoreSA(archive, sa, invocazioneServizio, credenziali);
  133.             break;
  134.         case CREDENZIALI_ACCESSO_PDD:
  135.             setInformationMissing_CredenzialiSA(archive, sa, credenziali);
  136.             break;
  137.         case ALLINEA_CREDENZIALI_PD:
  138.             setInformationMissing_AllineaCredenzialiPD(archive, sa);
  139.             break;
  140.         }
  141.         
  142.     }
  143.     
  144.     public static void setInformationMissingAccordoCooperazione(Archive archive, org.openspcoop2.protocol.information_missing.AccordoCooperazione ac, IDAccordoCooperazione idAccordo) throws ProtocolException{
  145.         
  146.         switch (ac.getTipo()) {
  147.         case RIFERIMENTO:
  148.             setInformationMissing_RiferimentoAccordoCooperazione(archive, ac, idAccordo);
  149.             break;
  150.         case STATO_ARCHIVIO:
  151.             if(ac.getStato()==null){
  152.                 throw new ProtocolException("Stato non fornito, è richiesto con tipo di operazione ["+ac.getTipo().name()+"]");
  153.             }
  154.             setInformationMissing_StatoAccordoCooperazione(archive, ac);
  155.             break;
  156.         }
  157.         
  158.     }
  159.     
  160.     public static void setInformationMissingAccordoServizioParteComune(Archive archive, org.openspcoop2.protocol.information_missing.AccordoServizioParteComune as, IDAccordo idAccordo) throws ProtocolException{
  161.         
  162.         switch (as.getTipo()) {
  163.         case RIFERIMENTO:
  164.             setInformationMissing_RiferimentoAccordoServizioParteComune(archive, as, idAccordo);
  165.             break;
  166.         case STATO_ARCHIVIO:
  167.             if(as.getStato()==null){
  168.                 throw new ProtocolException("Stato non fornito, è richiesto con tipo di operazione ["+as.getTipo().name()+"]");
  169.             }
  170.             setInformationMissing_StatoAccordoServizioParteComune(archive, as);
  171.             break;
  172.         }
  173.         
  174.     }
  175.     
  176.     public static void setInformationMissingAccordoServizioParteSpecifica(Archive archive, org.openspcoop2.protocol.information_missing.AccordoServizioParteSpecifica asps, 
  177.             Connettore connettore) throws ProtocolException{
  178.         
  179.         switch (asps.getTipo()) {
  180.         case CONNETTORE:
  181.             setInformationMissing_ConnettoreASPS(archive, asps, connettore);
  182.             break;
  183.         case STATO_ARCHIVIO:
  184.             if(asps.getStato()==null){
  185.                 throw new ProtocolException("Stato non fornito, è richiesto con tipo di operazione ["+asps.getTipo().name()+"]");
  186.             }
  187.             setInformationMissing_StatoAccordoServizioParteSpecifica(archive, asps);
  188.             break;
  189.         }
  190.         
  191.     }
  192.     
  193.     public static void setInformationMissingAccordoServizioComposto(Archive archive, org.openspcoop2.protocol.information_missing.AccordoServizioParteComune as, IDAccordo idAccordo) throws ProtocolException{
  194.         
  195.         switch (as.getTipo()) {
  196.         case RIFERIMENTO:
  197.             setInformationMissing_RiferimentoAccordoServizioComposto(archive, as, idAccordo);
  198.             break;
  199.         case STATO_ARCHIVIO:
  200.             if(as.getStato()==null){
  201.                 throw new ProtocolException("Stato non fornito, è richiesto con tipo di operazione ["+as.getTipo().name()+"]");
  202.             }
  203.             setInformationMissing_StatoAccordoServizioComposto(archive, as);
  204.             break;
  205.         }
  206.         
  207.     }
  208.     
  209.     public static void setInformationMissingFruitore(Archive archive, org.openspcoop2.protocol.information_missing.Fruitore fruitore,
  210.             Connettore connettore) throws ProtocolException{
  211.         
  212.         switch (fruitore.getTipo()) {
  213.         case CONNETTORE:
  214.             setInformationMissing_ConnettoreFruitore(archive, fruitore, connettore);
  215.             break;
  216.         case STATO_ARCHIVIO:
  217.             setInformationMissing_StatoFruitore(archive, fruitore);
  218.             break;
  219.         }
  220.         
  221.     }
  222.     
  223.     public static void setInformationMissingPortaDelegata(Archive archive, org.openspcoop2.protocol.information_missing.PortaDelegata portaDelegata) throws ProtocolException{
  224.         
  225.         switch (portaDelegata.getTipo()) {
  226.         case STATO:
  227.             setInformationMissing_StatoPortaDelegata(archive, portaDelegata);
  228.             break;
  229.         }
  230.         
  231.     }
  232.     
  233.     public static void setInformationMissingPortaApplicativa(Archive archive, org.openspcoop2.protocol.information_missing.PortaApplicativa portaApplicativa) throws ProtocolException{
  234.         
  235.         switch (portaApplicativa.getTipo()) {
  236.         case STATO:
  237.             setInformationMissing_StatoPortaApplicativa(archive, portaApplicativa);
  238.             break;
  239.         }
  240.         
  241.     }
  242.     
  243.     
  244.     
  245.     
  246.     // ******* MATCH **********
  247.     
  248.     private static boolean match(ReplaceMatchFieldType fieldType,String value){
  249.         if(ReplaceKeywordType.EMPTY.equals(fieldType.getTipo())){
  250.             if( value==null || "".equals(value) ){
  251.                 return true;
  252.             }
  253.         }
  254.         else if(ReplaceKeywordType.EQUALS.equals(fieldType.getTipo())){
  255.             if(value!=null && value.equals(fieldType.getValore())){
  256.                 return true;
  257.             }
  258.         }
  259.         else if(ReplaceKeywordType.CONTAINS.equals(fieldType.getTipo())){
  260.             if(value!=null && value.contains(fieldType.getValore())){
  261.                 return true;
  262.             }
  263.         }
  264.         else if(ReplaceKeywordType.STARTS_WITH.equals(fieldType.getTipo())){
  265.             if(value!=null && value.startsWith(fieldType.getValore())){
  266.                 return true;
  267.             }
  268.         }
  269.         else if(ReplaceKeywordType.ENDS_WITH.equals(fieldType.getTipo())){
  270.             if(value!=null && value.endsWith(fieldType.getValore())){
  271.                 return true;
  272.             }
  273.         }
  274.         else if(ReplaceKeywordType.ALL.equals(fieldType.getTipo())){
  275.             return true;
  276.         }
  277.         return false;
  278.     }
  279.     
  280.     private static boolean matchSoggetto(ReplaceMatchType replaceMatch,
  281.             String tipoSoggetto,String nomeSoggetto){
  282.         
  283.         ReplaceMatchFieldType nome = replaceMatch.getNome();
  284.         ReplaceMatchFieldType tipo = replaceMatch.getTipo();
  285.         if(nome==null && tipo==null){
  286.             return false; // per trovare un soggetto almeno un criterio di ricerca deve essere fornito
  287.         }
  288.         
  289.         if(nome!=null){
  290.             if(match(nome, nomeSoggetto)==false){
  291.                 return false;
  292.             }
  293.         }
  294.         
  295.         if(tipo!=null){
  296.             if(match(tipo, tipoSoggetto)==false){
  297.                 return false;
  298.             }
  299.         }
  300.         
  301.         return true;
  302.     }
  303.     
  304.     
  305.     private static boolean matchServizio(ReplaceMatchType replaceMatch,
  306.             String tipoServizio,String nomeServizio){
  307.         ReplaceMatchFieldType nome = replaceMatch.getNome();
  308.         ReplaceMatchFieldType tipo = replaceMatch.getTipo();
  309.         if(nome==null && tipo==null){
  310.             return false; // per trovare un servizio almeno un criterio di ricerca deve essere fornito
  311.         }
  312.         
  313.         if(nome!=null){
  314.             if(match(nome, nomeServizio)==false){
  315.                 return false;
  316.             }
  317.         }
  318.         
  319.         if(tipo!=null){
  320.             if(match(tipo, tipoServizio)==false){
  321.                 return false;
  322.             }
  323.         }
  324.         
  325.         return true;
  326.     }
  327.     
  328.     private static boolean matchFruitore(ReplaceFruitoreMatchType replaceMatch,
  329.             String tipoSoggetto,String nomeSoggetto,
  330.             String tipoServizio,String nomeServizio,
  331.             String tipoSoggettoErogatore,String nomeSoggettoErogatore){
  332.         
  333.         ReplaceMatchFieldType nome = replaceMatch.getNome();
  334.         ReplaceMatchFieldType tipo = replaceMatch.getTipo();
  335.         ReplaceMatchFieldType rNomeServizio = replaceMatch.getNomeServizio();
  336.         ReplaceMatchFieldType rTipoServizio = replaceMatch.getTipoServizio();
  337.         ReplaceMatchFieldType rNomeSoggettoErogatore = replaceMatch.getNomeErogatore();
  338.         ReplaceMatchFieldType rTipoSoggettoErogatore = replaceMatch.getTipoErogatore();
  339.         
  340.         if(nome==null && tipo==null &&
  341.                 rNomeServizio==null && rTipoServizio==null &&
  342.                 rNomeSoggettoErogatore==null && rTipoSoggettoErogatore==null){
  343.             return false; // per trovare un soggetto almeno un criterio di ricerca deve essere fornito
  344.         }
  345.         
  346.         // tipo/nome soggetto
  347.         
  348.         if(nome!=null){
  349.             if(match(nome, nomeSoggetto)==false){
  350.                 return false;
  351.             }
  352.         }
  353.         
  354.         if(tipo!=null){
  355.             if(match(tipo, tipoSoggetto)==false){
  356.                 return false;
  357.             }
  358.         }
  359.         
  360.         // tipo/nome servizio

  362.         if(rNomeServizio!=null){
  363.             if(match(rNomeServizio, nomeServizio)==false){
  364.                 return false;
  365.             }
  366.         }
  367.         
  368.         if(rTipoServizio!=null){
  369.             if(match(rTipoServizio, tipoServizio)==false){
  370.                 return false;
  371.             }
  372.         }
  373.         
  374.         // tipo/nome erogatore

  376.         if(rNomeSoggettoErogatore!=null){
  377.             if(match(rNomeSoggettoErogatore, nomeSoggettoErogatore)==false){
  378.                 return false;
  379.             }
  380.         }
  381.         
  382.         if(rTipoSoggettoErogatore!=null){
  383.             if(match(rTipoSoggettoErogatore, tipoSoggettoErogatore)==false){
  384.                 return false;
  385.             }
  386.         }
  387.         
  388.         return true;
  389.     }
  390.     
  391.     private static boolean matchServizioApplicativo(ReplaceMatchType replaceMatch,
  392.             String nomeServizio){
  393.         ReplaceMatchFieldType nome = replaceMatch.getNome();
  394.         if(nome==null){
  395.             return false; // per trovare un servizio applicativo un criterio di ricerca deve essere fornito
  396.         }
  397.         
  398.         if(nome!=null){
  399.             if(match(nome, nomeServizio)==false){
  400.                 return false;
  401.             }
  402.         }
  403.         
  404.         return true;
  405.     }
  406.     
  407.     private static boolean matchAccordo(ReplaceMatchType replaceMatch,
  408.             String nomeAccordo){
  409.         ReplaceMatchFieldType nome = replaceMatch.getNome();
  410.         if(nome==null){
  411.             return false; // per trovare un accordo un criterio di ricerca deve essere fornito
  412.         }
  413.         
  414.         if(nome!=null){
  415.             if(match(nome, nomeAccordo)==false){
  416.                 return false;
  417.             }
  418.         }
  419.         
  420.         return true;
  421.     }
  422.     
  423.     private static boolean matchPorta(ReplaceMatchType replaceMatch,
  424.             String nomePorta){
  425.         ReplaceMatchFieldType nome = replaceMatch.getNome();
  426.         if(nome==null){
  427.             return false; // per trovare un accordo un criterio di ricerca deve essere fornito
  428.         }
  429.         
  430.         if(nome!=null){
  431.             if(match(nome, nomePorta)==false){
  432.                 return false;
  433.             }
  434.         }
  435.         
  436.         return true;
  437.     }
  438.     

  440.     
  441.     
  442.     // ******* SOGGETTI **********
  443.     
  444.     private static void setInformationMissing_RiferimentoSoggetto(Archive archive, Soggetto soggetto, IDSoggetto idSoggetto) throws ProtocolException{
  445.         
  446.         // ServiziApplicativi
  447.         for (int i = 0; i < archive.getServiziApplicativi().size(); i++) {
  448.             ServizioApplicativo sa = archive.getServiziApplicativi().get(i).getServizioApplicativo();
  449.             if(matchSoggetto(soggetto.getReplaceMatch(), 
  450.                     sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario())){
  451.                 sa.setTipoSoggettoProprietario(idSoggetto.getTipo());
  452.                 sa.setNomeSoggettoProprietario(idSoggetto.getNome());
  453.                 archive.getServiziApplicativi().get(i).update(sa, false);
  454.             }
  455.         }
  456.         
  457.         // PorteDelegate
  458.         for (int i = 0; i < archive.getPorteDelegate().size(); i++) {
  459.             PortaDelegata pd = archive.getPorteDelegate().get(i).getPortaDelegata();
  460.             if(matchSoggetto(soggetto.getReplaceMatch(), 
  461.                     pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario())){
  462.                 pd.setTipoSoggettoProprietario(idSoggetto.getTipo());
  463.                 pd.setNomeSoggettoProprietario(idSoggetto.getNome());
  464.                 archive.getPorteDelegate().get(i).update(pd, false);
  465.             }
  466.             if(pd.getSoggettoErogatore()!=null){
  467.                 if(matchSoggetto(soggetto.getReplaceMatch(), 
  468.                         pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome())){
  469.                     pd.getSoggettoErogatore().setTipo(idSoggetto.getTipo());
  470.                     pd.getSoggettoErogatore().setNome(idSoggetto.getNome());
  471.                     archive.getPorteDelegate().get(i).update(pd, false);
  472.                 }
  473.             }
  474.         }
  475.         
  476.         // PorteApplicative
  477.         for (int i = 0; i < archive.getPorteApplicative().size(); i++) {
  478.             PortaApplicativa pa = archive.getPorteApplicative().get(i).getPortaApplicativa();
  479.             if(matchSoggetto(soggetto.getReplaceMatch(), 
  480.                     pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario())){
  481.                 pa.setTipoSoggettoProprietario(idSoggetto.getTipo());
  482.                 pa.setNomeSoggettoProprietario(idSoggetto.getNome());
  483.                 archive.getPorteApplicative().get(i).update(pa, false);
  484.             }
  485.             if(pa.getSoggettoVirtuale()!=null){
  486.                 if(matchSoggetto(soggetto.getReplaceMatch(), 
  487.                         pa.getSoggettoVirtuale().getTipo(), pa.getSoggettoVirtuale().getNome())){
  488.                     pa.getSoggettoVirtuale().setTipo(idSoggetto.getTipo());
  489.                     pa.getSoggettoVirtuale().setNome(idSoggetto.getNome());
  490.                     archive.getPorteApplicative().get(i).update(pa, false);
  491.                 }
  492.             }
  493.         }
  494.         
  495.         // Accordi di Cooperazione
  496.         for (int i = 0; i < archive.getAccordiCooperazione().size(); i++) {
  497.             AccordoCooperazione ac = archive.getAccordiCooperazione().get(i).getAccordoCooperazione();
  498.             IdSoggetto soggettoReferente = ac.getSoggettoReferente();
  499.             String tipoSoggettoReferente = null;
  500.             String nomeSoggettoReferente = null;
  501.             if(soggettoReferente!=null){
  502.                 tipoSoggettoReferente = soggettoReferente.getTipo();
  503.                 nomeSoggettoReferente = soggettoReferente.getNome();
  504.             }
  505.             if(matchSoggetto(soggetto.getReplaceMatch(), 
  506.                     tipoSoggettoReferente, nomeSoggettoReferente)){
  507.                 if(soggettoReferente==null){
  508.                     ac.setSoggettoReferente(new IdSoggetto());
  509.                 }
  510.                 ac.getSoggettoReferente().setTipo(idSoggetto.getTipo());
  511.                 ac.getSoggettoReferente().setNome(idSoggetto.getNome());
  512.                 archive.getAccordiCooperazione().get(i).update(ac, false);
  513.             }
  514.         }
  515.         
  516.         // Accordi di Servizio Parte Comune 
  517.         for (int i = 0; i < archive.getAccordiServizioParteComune().size(); i++) {
  518.             AccordoServizioParteComune as = archive.getAccordiServizioParteComune().get(i).getAccordoServizioParteComune();
  519.             IdSoggetto soggettoReferente = as.getSoggettoReferente();
  520.             String tipoSoggettoReferente = null;
  521.             String nomeSoggettoReferente = null;
  522.             if(soggettoReferente!=null){
  523.                 tipoSoggettoReferente = soggettoReferente.getTipo();
  524.                 nomeSoggettoReferente = soggettoReferente.getNome();
  525.             }
  526.             if(matchSoggetto(soggetto.getReplaceMatch(), 
  527.                     tipoSoggettoReferente, nomeSoggettoReferente)){
  528.                 if(soggettoReferente==null){
  529.                     as.setSoggettoReferente(new IdSoggetto());
  530.                 }
  531.                 as.getSoggettoReferente().setTipo(idSoggetto.getTipo());
  532.                 as.getSoggettoReferente().setNome(idSoggetto.getNome());
  533.                 archive.getAccordiServizioParteComune().get(i).update(as, false);
  534.             }
  535.         }
  536.         
  537.         // Accordi di Servizio Parte Specifica 
  538.         for (int i = 0; i < archive.getAccordiServizioParteSpecifica().size(); i++) {
  539.             ArchiveAccordoServizioParteSpecifica archiveAS = archive.getAccordiServizioParteSpecifica().get(i); 
  540.             AccordoServizioParteSpecifica as = archiveAS.getAccordoServizioParteSpecifica();
  541.             String tipoSoggettoReferente = as.getTipoSoggettoErogatore();
  542.             String nomeSoggettoReferente = as.getNomeSoggettoErogatore();
  543.             if(matchSoggetto(soggetto.getReplaceMatch(), 
  544.                     tipoSoggettoReferente, nomeSoggettoReferente)){
  545.                 as.setTipoSoggettoErogatore(idSoggetto.getTipo());
  546.                 as.setNomeSoggettoErogatore(idSoggetto.getNome());
  547.                 archive.getAccordiServizioParteSpecifica().get(i).update(as, false);
  548.             }
  549.             
  550.             if(as.getAccordoServizioParteComune()!=null) {
  551.                 try {
  552.                     IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(as.getAccordoServizioParteComune());
  553.                     if(idAccordo.getSoggettoReferente()!=null) {
  554.                         String tipoSoggettoReferenteAccordo = idAccordo.getSoggettoReferente().getTipo();
  555.                         String nomeSoggettoReferenteAccordo = idAccordo.getSoggettoReferente().getNome();
  556.                         if(matchSoggetto(soggetto.getReplaceMatch(), 
  557.                                 tipoSoggettoReferenteAccordo, nomeSoggettoReferenteAccordo)){
  558.                             idAccordo.getSoggettoReferente().setTipo(idSoggetto.getTipo());
  559.                             idAccordo.getSoggettoReferente().setNome(idSoggetto.getNome());
  560.                             as.setAccordoServizioParteComune(IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordo));
  561.                             archive.getAccordiServizioParteSpecifica().get(i).update(as, false);
  562.                         }
  563.                     }
  564.                 }catch(Exception e) {
  565.                     throw new ProtocolException(e.getMessage(),e );
  566.                 }
  567.             }
  568.             
  569.             if(archiveAS.getMappingPorteApplicativeAssociate()!=null && !archiveAS.getMappingPorteApplicativeAssociate().isEmpty()) {
  570.                 for (MappingErogazionePortaApplicativa mappingPA : archiveAS.getMappingPorteApplicativeAssociate()) {
  571.                     if(mappingPA.getIdServizio()!=null && mappingPA.getIdServizio().getSoggettoErogatore()!=null) {
  572.                         String tipoSoggettoErogatore = mappingPA.getIdServizio().getSoggettoErogatore().getTipo();
  573.                         String nomeSoggettoErogatore = mappingPA.getIdServizio().getSoggettoErogatore().getNome();
  574.                         if(matchSoggetto(soggetto.getReplaceMatch(), 
  575.                                 tipoSoggettoErogatore, nomeSoggettoErogatore)){
  576.                             mappingPA.getIdServizio().getSoggettoErogatore().setTipo(idSoggetto.getTipo());
  577.                             mappingPA.getIdServizio().getSoggettoErogatore().setNome(idSoggetto.getNome());
  578.                         }
  579.                     }
  580.                 }
  581.             }
  582.         }

  584.         // Accordi di Servizio Composti
  585.         for (int i = 0; i < archive.getAccordiServizioComposto().size(); i++) {
  586.             AccordoServizioParteComune as = archive.getAccordiServizioComposto().get(i).getAccordoServizioParteComune();
  587.             IdSoggetto soggettoReferente = as.getSoggettoReferente();
  588.             String tipoSoggettoReferente = null;
  589.             String nomeSoggettoReferente = null;
  590.             if(soggettoReferente!=null){
  591.                 tipoSoggettoReferente = soggettoReferente.getTipo();
  592.                 nomeSoggettoReferente = soggettoReferente.getNome();
  593.             }
  594.             if(matchSoggetto(soggetto.getReplaceMatch(), 
  595.                     tipoSoggettoReferente, nomeSoggettoReferente)){
  596.                 if(soggettoReferente==null){
  597.                     as.setSoggettoReferente(new IdSoggetto());
  598.                 }
  599.                 as.getSoggettoReferente().setTipo(idSoggetto.getTipo());
  600.                 as.getSoggettoReferente().setNome(idSoggetto.getNome());
  601.                 archive.getAccordiServizioComposto().get(i).update(as, false);
  602.             }
  603.         }
  604.         
  605.         // Fruizioni
  606.         for (int i = 0; i < archive.getAccordiFruitori().size(); i++) {
  607.             ArchiveFruitore archiveFruitore = archive.getAccordiFruitori().get(i);
  608.             Fruitore fruitore = archiveFruitore.getFruitore();
  609.             IDServizio idAps = archiveFruitore.getIdAccordoServizioParteSpecifica();
  610.             String tipoSoggettoReferente = null;
  611.             String nomeSoggettoReferente = null;
  612.             if(idAps.getSoggettoErogatore()!=null){
  613.                 tipoSoggettoReferente = idAps.getSoggettoErogatore().getTipo();
  614.                 nomeSoggettoReferente = idAps.getSoggettoErogatore().getNome();
  615.             }
  616.             if(matchSoggetto(soggetto.getReplaceMatch(), 
  617.                     fruitore.getTipo(), fruitore.getNome())){
  618.                 fruitore.setTipo(idSoggetto.getTipo());
  619.                 fruitore.setNome(idSoggetto.getNome());
  620.                 archive.getAccordiFruitori().get(i).update(idAps,fruitore, false);
  621.             }
  622.             else if(matchSoggetto(soggetto.getReplaceMatch(), 
  623.                     tipoSoggettoReferente, nomeSoggettoReferente)){
  624.                 try{
  625.                     idAps = IDServizioFactory.getInstance().getIDServizioFromValuesWithoutCheck(idAps.getTipo(),idAps.getNome(),
  626.                             idSoggetto.getTipo(),idSoggetto.getNome(), idAps.getVersione());
  627.                 }catch(Exception e){
  628.                     throw new ProtocolException(e.getMessage(),e);
  629.                 }
  630.                 archive.getAccordiFruitori().get(i).update(idAps,fruitore, false);
  631.             } 
  632.             
  633.             if(archiveFruitore.getMappingPorteDelegateAssociate()!=null && !archiveFruitore.getMappingPorteDelegateAssociate().isEmpty()) {
  634.                 for (MappingFruizionePortaDelegata mappingPD : archiveFruitore.getMappingPorteDelegateAssociate()) {
  635.                     if(mappingPD.getIdServizio()!=null && mappingPD.getIdServizio().getSoggettoErogatore()!=null) {
  636.                         String tipoSoggettoErogatore = mappingPD.getIdServizio().getSoggettoErogatore().getTipo();
  637.                         String nomeSoggettoErogatore = mappingPD.getIdServizio().getSoggettoErogatore().getNome();
  638.                         if(matchSoggetto(soggetto.getReplaceMatch(), 
  639.                                 tipoSoggettoErogatore, nomeSoggettoErogatore)){
  640.                             mappingPD.getIdServizio().getSoggettoErogatore().setTipo(idSoggetto.getTipo());
  641.                             mappingPD.getIdServizio().getSoggettoErogatore().setNome(idSoggetto.getNome());
  642.                         }
  643.                     }
  644.                     if(mappingPD.getIdFruitore()!=null) {
  645.                         String tipoSoggettoFruitore = mappingPD.getIdFruitore().getTipo();
  646.                         String nomeSoggettoFruitore = mappingPD.getIdFruitore().getNome();
  647.                         if(matchSoggetto(soggetto.getReplaceMatch(), 
  648.                                 tipoSoggettoFruitore, nomeSoggettoFruitore)){
  649.                             mappingPD.getIdFruitore().setTipo(idSoggetto.getTipo());
  650.                             mappingPD.getIdFruitore().setNome(idSoggetto.getNome());
  651.                         }
  652.                     }
  653.                 }
  654.             }
  655.         }
  656.     }

  658.     private static void setInformationMissing_ConnettoreSoggetto(Archive archive, Soggetto soggetto, Connettore connettore) throws ProtocolException{
  659.         
  660.         // Soggetti
  661.         for (int i = 0; i < archive.getSoggetti().size(); i++) {
  662.             org.openspcoop2.core.registry.Soggetto soggettoRegistro = archive.getSoggetti().get(i).getSoggettoRegistro();
  663.             if(soggettoRegistro!=null){
  664.                 if(matchSoggetto(soggetto.getReplaceMatch(), 
  665.                         soggettoRegistro.getTipo(), soggettoRegistro.getNome())){
  666.                     if(soggettoRegistro.getConnettore()==null)
  667.                         soggettoRegistro.setConnettore(connettore);
  668.                     else{
  669.                         soggettoRegistro.getConnettore().setCustom(connettore.getCustom());
  670.                         soggettoRegistro.getConnettore().setTipo(connettore.getTipo());
  671.                         while(soggettoRegistro.getConnettore().sizePropertyList()>0)
  672.                             soggettoRegistro.getConnettore().removeProperty(0);
  673.                         if(connettore.sizePropertyList()>0)
  674.                             soggettoRegistro.getConnettore().getPropertyList().addAll(connettore.getPropertyList());
  675.                     }
  676.                 }
  677.             }
  678.         }
  679.         
  680.     }
  681.     
  682.     
  683.     
  684.     
  685.     // ***** SERVIZI APPLICATIVI ******
  686.     
  687.     private static void setInformationMissing_ConnettoreSA(Archive archive,  org.openspcoop2.protocol.information_missing.ServizioApplicativo saMissingInfo, 
  688.             InvocazioneServizio invocazioneServizio, Credenziali credenziali) throws ProtocolException{
  689.         
  690.         // ServiziApplicativi
  691.         for (int i = 0; i < archive.getServiziApplicativi().size(); i++) {
  692.             ServizioApplicativo sa = archive.getServiziApplicativi().get(i).getServizioApplicativo();
  693.             if(matchServizioApplicativo(saMissingInfo.getReplaceMatch(), 
  694.                     sa.getNome())){
  695.                 
  696.                 if(credenziali!=null){
  697.                     if(sa.getInvocazionePorta()==null){
  698.                         sa.setInvocazionePorta(new InvocazionePorta());
  699.                     }
  700.                     while(sa.getInvocazionePorta().sizeCredenzialiList()>0){
  701.                         sa.getInvocazionePorta().removeCredenziali(0);
  702.                     }
  703.                     sa.getInvocazionePorta().addCredenziali(credenziali);
  704.                 }
  705.                 
  706.                 if(sa.getInvocazioneServizio()==null){
  707.                     sa.setInvocazioneServizio(invocazioneServizio);
  708.                 }
  709.                 else{
  710.                     sa.getInvocazioneServizio().setSbustamentoInformazioniProtocollo(invocazioneServizio.getSbustamentoInformazioniProtocollo());
  711.                     sa.getInvocazioneServizio().setSbustamentoSoap(invocazioneServizio.getSbustamentoSoap());
  712.                     sa.getInvocazioneServizio().setGetMessage(invocazioneServizio.getGetMessage());
  713.                     sa.getInvocazioneServizio().setInvioPerRiferimento(invocazioneServizio.getInvioPerRiferimento());
  714.                     sa.getInvocazioneServizio().setRispostaPerRiferimento(invocazioneServizio.getRispostaPerRiferimento());
  715.                     
  716.                     if(sa.getInvocazioneServizio().getCredenziali()==null){
  717.                         sa.getInvocazioneServizio().setCredenziali(invocazioneServizio.getCredenziali());
  718.                     }
  719.                     else{
  720.                         sa.getInvocazioneServizio().getCredenziali().setUser(invocazioneServizio.getCredenziali().getUser());
  721.                         sa.getInvocazioneServizio().getCredenziali().setPassword(invocazioneServizio.getCredenziali().getPassword());
  722.                     }
  723.                     
  724.                     sa.getInvocazioneServizio().setAutenticazione(invocazioneServizio.getAutenticazione());
  725.                     
  726.                     if(sa.getInvocazioneServizio().getConnettore()==null){
  727.                         sa.getInvocazioneServizio().setConnettore(invocazioneServizio.getConnettore());
  728.                     }
  729.                     else{
  730.                         sa.getInvocazioneServizio().getConnettore().setCustom(invocazioneServizio.getConnettore().getCustom());
  731.                         sa.getInvocazioneServizio().getConnettore().setTipo(invocazioneServizio.getConnettore().getTipo());
  732.                         while(sa.getInvocazioneServizio().getConnettore().sizePropertyList()>0)
  733.                             sa.getInvocazioneServizio().getConnettore().removeProperty(0);
  734.                         if(invocazioneServizio.getConnettore().sizePropertyList()>0)
  735.                             sa.getInvocazioneServizio().getConnettore().getPropertyList().addAll(invocazioneServizio.getConnettore().getPropertyList());
  736.                     }
  737.                 }
  738.             }
  739.         }
  740.     }
  741.     
  742.     private static void setInformationMissing_CredenzialiSA(Archive archive,  org.openspcoop2.protocol.information_missing.ServizioApplicativo saMissingInfo, 
  743.              Credenziali credenziali) throws ProtocolException{
  744.         
  745.         // ServiziApplicativi
  746.         for (int i = 0; i < archive.getServiziApplicativi().size(); i++) {
  747.             ServizioApplicativo sa = archive.getServiziApplicativi().get(i).getServizioApplicativo();
  748.             if(matchServizioApplicativo(saMissingInfo.getReplaceMatch(), 
  749.                     sa.getNome())){
  750.                 
  751.                 if(sa.getInvocazionePorta()==null){
  752.                     sa.setInvocazionePorta(new InvocazionePorta());
  753.                 }
  754.                 while(sa.getInvocazionePorta().sizeCredenzialiList()>0){
  755.                     sa.getInvocazionePorta().removeCredenziali(0);
  756.                 }
  757.                 sa.getInvocazionePorta().addCredenziali(credenziali);
  758.                 sa.setTipologiaFruizione(TipologiaFruizione.NORMALE.getValue());
  759.                 sa.setTipo(CostantiConfigurazione.CLIENT);
  760.             }
  761.         }
  762.     }
  763.     private static void setInformationMissing_AllineaCredenzialiPD(Archive archive,  org.openspcoop2.protocol.information_missing.ServizioApplicativo saMissingInfo) throws ProtocolException{
  764.         
  765.         // ServiziApplicativi
  766.         for (int i = 0; i < archive.getServiziApplicativi().size(); i++) {
  767.             ServizioApplicativo sa = archive.getServiziApplicativi().get(i).getServizioApplicativo();
  768.             if(matchServizioApplicativo(saMissingInfo.getReplaceMatch(), 
  769.                     sa.getNome())){
  770.                 
  771.                 if(sa.getInvocazionePorta()==null || sa.getInvocazionePorta().sizeCredenzialiList()<=0){
  772.                     throw new ProtocolException("Credenziali di accesso non presenti nel servizio applicativo ["+sa.getNome()+
  773.                             "]. Le credenziali sono richieste dalla modalità di gestione delle informazioni mancanti impostata");
  774.                 }
  775.                 Credenziali credenziali = sa.getInvocazionePorta().getCredenziali(0);
  776.                 if(credenziali.getTipo()==null){
  777.                     throw new ProtocolException("Credenziali di accesso non presenti nel servizio applicativo ["+sa.getNome()+
  778.                             "] (tipo non definito). Le credenziali sono richieste dalla modalità di gestione delle informazioni mancanti impostata");
  779.                 }
  780.                 
  781.                 for (int j = 0; j < archive.getPorteDelegate().size(); j++) {
  782.                     PortaDelegata pd = archive.getPorteDelegate().get(j).getPortaDelegata();
  783.                     if(pd!=null && pd.sizeServizioApplicativoList()>0){
  784.                         for (int k = 0; k < pd.sizeServizioApplicativoList(); k++) {
  785.                             if(sa.getNome().equals(pd.getServizioApplicativo(k).getNome())){
  786.                                 pd.setAutenticazione(credenziali.getTipo().getValue());
  787.                                 break;
  788.                             }
  789.                         }
  790.                     }
  791.                 }
  792.             }
  793.         }
  794.     }
  795.     

  797.     
  798.     
  799.     
  800.     
  801.     
  802.     
  803.     // ******* ACCORDI COOPERAZIONE **********
  804.     
  805.     private static void setInformationMissing_RiferimentoAccordoCooperazione(Archive archive, org.openspcoop2.protocol.information_missing.AccordoCooperazione ac, IDAccordoCooperazione idAccordo) throws ProtocolException{
  806.         
  807.         // Accordi di Servizio Composti
  808.         for (int i = 0; i < archive.getAccordiServizioComposto().size(); i++) {
  809.             AccordoServizioParteComune as = archive.getAccordiServizioComposto().get(i).getAccordoServizioParteComune();
  810.             
  811.             String uriAccordoCooperazione = null;
  812.             if(as.getServizioComposto()!=null){
  813.                 uriAccordoCooperazione = as.getServizioComposto().getAccordoCooperazione(); 
  814.             }
  815.             if(matchAccordo(ac.getReplaceMatch(), 
  816.                     uriAccordoCooperazione)){
  817.                 if(as.getServizioComposto()==null){
  818.                     as.setServizioComposto(new AccordoServizioParteComuneServizioComposto());
  819.                 }
  820.                 try{
  821.                     as.getServizioComposto().setAccordoCooperazione(IDAccordoCooperazioneFactory.getInstance().getUriFromIDAccordo(idAccordo));
  822.                 }catch(Exception e){
  823.                     throw new ProtocolException(e.getMessage(),e);
  824.                 }
  825.                 archive.getAccordiServizioComposto().get(i).update(as, false);
  826.             }
  827.         }
  828.             
  829.     }
  830.     
  831.     private static void setInformationMissing_StatoAccordoCooperazione(Archive archive, org.openspcoop2.protocol.information_missing.AccordoCooperazione ac) throws ProtocolException{
  832.         
  833.         // Accordi di Cooperazione
  834.         if(ac.getStato()!=null){
  835.             for (int i = 0; i < archive.getAccordiCooperazione().size(); i++) {
  836.                 AccordoCooperazione acObject = archive.getAccordiCooperazione().get(i).getAccordoCooperazione();
  837.                 String uriAccordoCooperazione = null;
  838.                 try{
  839.                     uriAccordoCooperazione = IDAccordoCooperazioneFactory.getInstance().getUriFromAccordo(acObject);
  840.                 }catch(Exception e){
  841.                     throw new ProtocolException(e.getMessage(),e);
  842.                 }
  843.                 if(matchAccordo(ac.getReplaceMatch(), 
  844.                         uriAccordoCooperazione)){
  845.                     acObject.setStatoPackage(ac.getStato().getValue());
  846.                 }
  847.             }
  848.         }
  849.             
  850.     }
  851.     
  852.     
  853.     
  854.     
  855.     
  856.     
  857.     
  858.     
  859.     
  860.     
  861.     
  862.     
  863.     // ******* ACCORDI SERVIZIO PARTE COMUNE **********
  864.     
  865.     private static void setInformationMissing_RiferimentoAccordoServizioParteComune(Archive archive, org.openspcoop2.protocol.information_missing.AccordoServizioParteComune as, IDAccordo idAccordo) throws ProtocolException{
  866.         
  867.         // Accordi di Servizio Parte Specifica 
  868.         for (int i = 0; i < archive.getAccordiServizioParteSpecifica().size(); i++) {
  869.             AccordoServizioParteSpecifica asObject = archive.getAccordiServizioParteSpecifica().get(i).getAccordoServizioParteSpecifica();
  870.             String uriAccordo = null;
  871.             if(asObject.getAccordoServizioParteComune()!=null){
  872.                 uriAccordo = asObject.getAccordoServizioParteComune();
  873.             }
  874.             if(matchAccordo(as.getReplaceMatch(), 
  875.                     uriAccordo)){
  876.                 try{
  877.                     asObject.setAccordoServizioParteComune(IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordo));
  878.                 }catch(Exception e){
  879.                     throw new ProtocolException(e.getMessage(),e);
  880.                 }
  881.                 archive.getAccordiServizioParteSpecifica().get(i).update(asObject, false);
  882.             }
  883.         }
  884.             
  885.     }
  886.     
  887.     private static void setInformationMissing_StatoAccordoServizioParteComune(Archive archive, org.openspcoop2.protocol.information_missing.AccordoServizioParteComune as) throws ProtocolException{
  888.         
  889.         // Accordi di Servizio Parte Comune 
  890.         if(as.getStato()!=null){
  891.             for (int i = 0; i < archive.getAccordiServizioParteComune().size(); i++) {
  892.                 AccordoServizioParteComune asObject = archive.getAccordiServizioParteComune().get(i).getAccordoServizioParteComune();
  893.                 String uriAccordo = null;
  894.                 try{
  895.                     uriAccordo = IDAccordoFactory.getInstance().getUriFromAccordo(asObject);
  896.                 }catch(Exception e){
  897.                     throw new ProtocolException(e.getMessage(),e);
  898.                 }
  899.                 if(matchAccordo(as.getReplaceMatch(), 
  900.                         uriAccordo)){
  901.                     asObject.setStatoPackage(as.getStato().getValue());
  902.                 }
  903.             }
  904.         }
  905.             
  906.     }



  910.     
  911.     
  912.     
  913.     
  914.     
  915.     
  916.     
  917.     // ***** ACCORDI SERVIZIO PARTE SPECIFICA ******
  918.     
  919.     private static void setInformationMissing_ConnettoreASPS(Archive archive, org.openspcoop2.protocol.information_missing.AccordoServizioParteSpecifica aspsMissingInfo, 
  920.             Connettore connettore) throws ProtocolException{
  921.         
  922.         // Accordi
  923.         for (int i = 0; i < archive.getAccordiServizioParteSpecifica().size(); i++) {
  924.             org.openspcoop2.core.registry.AccordoServizioParteSpecifica asps = archive.getAccordiServizioParteSpecifica().get(i).getAccordoServizioParteSpecifica();
  925.             if(asps!=null){
  926.                 
  927.                 boolean matchTipoNome = matchServizio(aspsMissingInfo.getReplaceMatch(), 
  928.                         asps.getTipo(), asps.getNome());
  929.                     
  930.                 String uriAccordo = null;
  931.                 try{
  932.                     uriAccordo = IDServizioFactory.getInstance().getUriFromAccordo(asps);
  933.                 }catch(Exception e){
  934.                     throw new ProtocolException(e.getMessage(),e);
  935.                 }
  936.                 boolean matchAccordo = matchAccordo(aspsMissingInfo.getReplaceMatch(), 
  937.                         uriAccordo);
  938.                 
  939.                 if(matchTipoNome || matchAccordo){
  940.                     if(asps.getConfigurazioneServizio()==null){
  941.                         asps.setConfigurazioneServizio(new ConfigurazioneServizio());
  942.                     }
  943.                     if(asps.getConfigurazioneServizio().getConnettore()==null)
  944.                         asps.getConfigurazioneServizio().setConnettore(connettore);
  945.                     else{
  946.                         asps.getConfigurazioneServizio().getConnettore().setCustom(connettore.getCustom());
  947.                         asps.getConfigurazioneServizio().getConnettore().setTipo(connettore.getTipo());
  948.                         while(asps.getConfigurazioneServizio().getConnettore().sizePropertyList()>0)
  949.                             asps.getConfigurazioneServizio().getConnettore().removeProperty(0);
  950.                         if(connettore.sizePropertyList()>0)
  951.                             asps.getConfigurazioneServizio().getConnettore().getPropertyList().addAll(connettore.getPropertyList());
  952.                     }
  953.                 }
  954.             }
  955.         }
  956.         
  957.     }

  959.     private static void setInformationMissing_StatoAccordoServizioParteSpecifica(Archive archive, org.openspcoop2.protocol.information_missing.AccordoServizioParteSpecifica aspsMissingInfo) throws ProtocolException{
  960.         
  961.         // Accordi di Servizio Parte Specifica
  962.         if(aspsMissingInfo.getStato()!=null){
  963.             for (int i = 0; i < archive.getAccordiServizioParteSpecifica().size(); i++) {
  964.                 org.openspcoop2.core.registry.AccordoServizioParteSpecifica asps = archive.getAccordiServizioParteSpecifica().get(i).getAccordoServizioParteSpecifica();
  965.                 if(asps!=null){
  966.                     
  967.                     boolean matchTipoNome = matchServizio(aspsMissingInfo.getReplaceMatch(), 
  968.                             asps.getTipo(), asps.getNome());
  969.                         
  970.                     String uriAccordo = asps.getAccordoServizioParteComune();
  971.                     boolean matchAccordo = matchAccordo(aspsMissingInfo.getReplaceMatch(), 
  972.                             uriAccordo);
  973.                                 
  974.                     if(matchTipoNome || matchAccordo){
  975.                         asps.setStatoPackage(aspsMissingInfo.getStato().getValue());
  976.                     }
  977.                 }
  978.             }
  979.         }
  980.             
  981.     }
  982.     
  983.     
  984.     
  985.     
  986.     
  987.     // ******* ACCORDI SERVIZIO COMPOSTO **********
  988.     
  989.     private static void setInformationMissing_RiferimentoAccordoServizioComposto(Archive archive, org.openspcoop2.protocol.information_missing.AccordoServizioParteComune as, IDAccordo idAccordo) throws ProtocolException{
  990.         
  991.         setInformationMissing_RiferimentoAccordoServizioParteComune(archive, as, idAccordo);
  992.             
  993.     }
  994.     
  995.     private static void setInformationMissing_StatoAccordoServizioComposto(Archive archive, org.openspcoop2.protocol.information_missing.AccordoServizioParteComune as) throws ProtocolException{
  996.         
  997.         // Accordi di Servizio Composto
  998.         if(as.getStato()!=null){
  999.             for (int i = 0; i < archive.getAccordiServizioComposto().size(); i++) {
  1000.                 AccordoServizioParteComune asObject = archive.getAccordiServizioComposto().get(i).getAccordoServizioParteComune();
  1001.                 String uriAccordo = null;
  1002.                 try{
  1003.                     uriAccordo = IDAccordoFactory.getInstance().getUriFromAccordo(asObject);
  1004.                 }catch(Exception e){
  1005.                     throw new ProtocolException(e.getMessage(),e);
  1006.                 }
  1007.                 if(matchAccordo(as.getReplaceMatch(), 
  1008.                         uriAccordo)){
  1009.                     asObject.setStatoPackage(as.getStato().getValue());
  1010.                 }
  1011.             }
  1012.         }
  1013.             
  1014.     }
  1015.     
  1016.     
  1017.     
  1018.     
  1019.     
  1020.     
  1021.     
  1022.     
  1023.     
  1024.     
  1025.     // ******* FRUITORE **********
  1026.     
  1027.     private static void setInformationMissing_ConnettoreFruitore(Archive archive, org.openspcoop2.protocol.information_missing.Fruitore fruitoreMissingInfo, 
  1028.             Connettore connettore) throws ProtocolException{
  1029.         
  1030.         // Accordi
  1031.         for (int i = 0; i < archive.getAccordiFruitori().size(); i++) {
  1032.             ArchiveFruitore archiveFruitore = archive.getAccordiFruitori().get(i);
  1033.             Fruitore fruitore = archiveFruitore.getFruitore();
  1034.             
  1035.             String tipoServizio = null;
  1036.             String nomeServizio = null;
  1037.             String tipoSoggettoErogatore = null;
  1038.             String nomeSoggettoErogatore = null;
  1039.             if(archiveFruitore.getIdAccordoServizioParteSpecifica()!=null) {
  1040.                 tipoServizio = archiveFruitore.getIdAccordoServizioParteSpecifica().getTipo();
  1041.                 nomeServizio = archiveFruitore.getIdAccordoServizioParteSpecifica().getNome();
  1042.                 if(archiveFruitore.getIdAccordoServizioParteSpecifica().getSoggettoErogatore()!=null) {
  1043.                     tipoSoggettoErogatore = archiveFruitore.getIdAccordoServizioParteSpecifica().getSoggettoErogatore().getTipo();
  1044.                     nomeSoggettoErogatore = archiveFruitore.getIdAccordoServizioParteSpecifica().getSoggettoErogatore().getNome();
  1045.                 }
  1046.             }
  1047.                 
  1048.             if(fruitore!=null){
  1049.                 
  1050.                 if(matchFruitore(fruitoreMissingInfo.getReplaceMatch(), 
  1051.                         fruitore.getTipo(), fruitore.getNome(),
  1052.                         tipoServizio,nomeServizio,
  1053.                         tipoSoggettoErogatore,nomeSoggettoErogatore)){
  1054.                     
  1055.                     if(fruitore.getConnettore()==null) {
  1056.                         fruitore.setConnettore(connettore);
  1057.                     }
  1058.                     else {
  1059.                         fruitore.getConnettore().setCustom(connettore.getCustom());
  1060.                         fruitore.getConnettore().setTipo(connettore.getTipo());
  1061.                         while(fruitore.getConnettore().sizePropertyList()>0)
  1062.                             fruitore.getConnettore().removeProperty(0);
  1063.                         if(connettore.sizePropertyList()>0)
  1064.                             fruitore.getConnettore().getPropertyList().addAll(connettore.getPropertyList());
  1065.                     }
  1066.                     
  1067.                 }
  1068.                 
  1069.             }
  1070.         }
  1071.         
  1072.     }
  1073.     
  1074.     private static void setInformationMissing_StatoFruitore(Archive archive, org.openspcoop2.protocol.information_missing.Fruitore fruitoreMissingInfo) throws ProtocolException{
  1075.         
  1076.         // Fruitori
  1077.         if(fruitoreMissingInfo.getStato()!=null){
  1078.             for (int i = 0; i < archive.getAccordiFruitori().size(); i++) {
  1079.                 ArchiveFruitore archiveFruitore = archive.getAccordiFruitori().get(i);
  1080.                 Fruitore fruitore = archiveFruitore.getFruitore();
  1081.                 
  1082.                 String tipoServizio = null;
  1083.                 String nomeServizio = null;
  1084.                 String tipoSoggettoErogatore = null;
  1085.                 String nomeSoggettoErogatore = null;
  1086.                 if(archiveFruitore.getIdAccordoServizioParteSpecifica()!=null) {
  1087.                     tipoServizio = archiveFruitore.getIdAccordoServizioParteSpecifica().getTipo();
  1088.                     nomeServizio = archiveFruitore.getIdAccordoServizioParteSpecifica().getNome();
  1089.                     if(archiveFruitore.getIdAccordoServizioParteSpecifica().getSoggettoErogatore()!=null) {
  1090.                         tipoSoggettoErogatore = archiveFruitore.getIdAccordoServizioParteSpecifica().getSoggettoErogatore().getTipo();
  1091.                         nomeSoggettoErogatore = archiveFruitore.getIdAccordoServizioParteSpecifica().getSoggettoErogatore().getNome();
  1092.                     }
  1093.                 }
  1094.                 
  1095.                 if(matchFruitore(fruitoreMissingInfo.getReplaceMatch(), 
  1096.                         fruitore.getTipo(), fruitore.getNome(),
  1097.                         tipoServizio,nomeServizio,
  1098.                         tipoSoggettoErogatore,nomeSoggettoErogatore)){
  1099.                     fruitore.setStatoPackage(fruitoreMissingInfo.getStato().getValue());
  1100.                 }
  1101.             }
  1102.         }
  1103.             
  1104.     }
  1105.     

  1107.     
  1108.     
  1109.     
  1110.     
  1111.     
  1112.     // ******* PORTA DELEGATA **********
  1113.     
  1114.     private static void setInformationMissing_StatoPortaDelegata(Archive archive, org.openspcoop2.protocol.information_missing.PortaDelegata portaDelegataMissingInfo) throws ProtocolException{
  1115.         
  1116.         // portaDelegataMissingInfo
  1117.         if(portaDelegataMissingInfo.getStato()!=null){
  1118.             for (int i = 0; i < archive.getPorteDelegate().size(); i++) {
  1119.                 PortaDelegata portaDelegata = archive.getPorteDelegate().get(i).getPortaDelegata();
  1120.                 if(matchPorta(portaDelegataMissingInfo.getReplaceMatch(), 
  1121.                         portaDelegata.getNome())){
  1122.                     portaDelegata.setStato(StatoFunzionalita.toEnumConstant(portaDelegataMissingInfo.getStato().getValue()));
  1123.                 }
  1124.             }
  1125.         }
  1126.             
  1127.     }
  1128.     
  1129.     
  1130.     
  1131.     
  1132.     
  1133.     
  1134.     
  1135.     // ******* PORTA APPLICATIVA **********
  1136.     
  1137.     private static void setInformationMissing_StatoPortaApplicativa(Archive archive, org.openspcoop2.protocol.information_missing.PortaApplicativa portaApplicativaMissingInfo) throws ProtocolException{
  1138.         
  1139.         // portaDelegataMissingInfo
  1140.         if(portaApplicativaMissingInfo.getStato()!=null){
  1141.             for (int i = 0; i < archive.getPorteApplicative().size(); i++) {
  1142.                 PortaApplicativa portaApplicativa = archive.getPorteApplicative().get(i).getPortaApplicativa();
  1143.                 if(matchPorta(portaApplicativaMissingInfo.getReplaceMatch(), 
  1144.                         portaApplicativa.getNome())){
  1145.                     portaApplicativa.setStato(StatoFunzionalita.toEnumConstant(portaApplicativaMissingInfo.getStato().getValue()));
  1146.                 }
  1147.             }
  1148.         }
  1149.             
  1150.     }
  1151.     
  1152.     
  1153.     
  1154.     
  1155.     
  1156.     
  1157.     
  1158.     // ******* REPLACE NAME **********
  1159.     
  1160.     protected static String replaceSoggettoProprietarioOrDefault(IRegistryReader registryReader, String original, String tipoSoggetto, String nomeSoggetto) throws ProtocolException{
  1161.         
  1162.         if(original==null){
  1163.             return null;
  1164.         }
  1165.         
  1166.         String returnValue = new String(original);
  1167.         
  1168.         if(tipoSoggetto!=null && !"".equals(tipoSoggetto)){
  1169.             returnValue = returnValue.replace(Costanti.TIPO_SOGGETTO, tipoSoggetto);
  1170.             returnValue = returnValue.replace(Costanti.TIPO_SOGGETTO_PROPRIETARIO, tipoSoggetto);
  1171.             
  1172.             if(original.contains(Costanti.NOME_SOGGETTO_DEFAULT)) {
  1173.                 
  1174.                 ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance(); 
  1175.                 IProtocolFactory<?> protocol = protocolFactoryManager.getProtocolFactoryByOrganizationType(tipoSoggetto);
  1176.                 String tipoSoggettoDefault = protocolFactoryManager.getDefaultOrganizationTypes().get(protocol.getProtocol());
  1177.                 IDSoggetto idSoggettoDefault = null;
  1178.                 try {
  1179.                     idSoggettoDefault = registryReader.getIdSoggettoDefault(tipoSoggettoDefault);
  1180.                 }catch(Exception e) {
  1181.                     throw new ProtocolException(e.getMessage(),e);
  1182.                 }
  1183.                 returnValue = returnValue.replace(Costanti.NOME_SOGGETTO_DEFAULT, idSoggettoDefault.getNome());
  1184.                 
  1185.             }
  1186.         }
  1187.         
  1188.         if(nomeSoggetto!=null && !"".equals(nomeSoggetto)){
  1189.             returnValue = returnValue.replace(Costanti.NOME_SOGGETTO, nomeSoggetto);
  1190.             returnValue = returnValue.replace(Costanti.NOME_SOGGETTO_PROPRIETARIO, nomeSoggetto);
  1191.         }
  1192.         
  1193.         return returnValue;
  1194.     }
  1195.     
  1196.     protected static String replaceSoggettoErogatore(String original, String tipoSoggetto, String nomeSoggetto){
  1197.         
  1198.         if(original==null){
  1199.             return null;
  1200.         }
  1201.         
  1202.         String returnValue = new String(original);
  1203.         
  1204.         if(tipoSoggetto!=null && !"".equals(tipoSoggetto)){
  1205.             returnValue = returnValue.replace(Costanti.TIPO_SOGGETTO_EROGATORE, tipoSoggetto);
  1206.         }
  1207.         
  1208.         if(nomeSoggetto!=null && !"".equals(nomeSoggetto)){
  1209.             returnValue = returnValue.replace(Costanti.NOME_SOGGETTO_EROGATORE, nomeSoggetto);
  1210.         }
  1211.         
  1212.         return returnValue;
  1213.     }
  1214.     
  1215.     private static String replaceServizio(String original, String tipoServizio, String nomeServizio){
  1216.         
  1217.         if(original==null){
  1218.             return null;
  1219.         }
  1220.         
  1221.         String returnValue = new String(original);
  1222.         
  1223.         if(tipoServizio!=null && !"".equals(tipoServizio)){
  1224.             returnValue = returnValue.replace(Costanti.TIPO_SERVIZIO, tipoServizio);
  1225.         }
  1226.         
  1227.         if(nomeServizio!=null && !"".equals(nomeServizio)){
  1228.             returnValue = returnValue.replace(Costanti.NOME_SERVIZIO, nomeServizio);
  1229.         }
  1230.         
  1231.         return returnValue;
  1232.     }
  1233.     
  1234.     private static String replaceAzione(String original, String nome){
  1235.         
  1236.         if(original==null){
  1237.             return null;
  1238.         }
  1239.         
  1240.         String returnValue = new String(original);
  1241.         
  1242.         if(nome!=null && !"".equals(nome)){
  1243.             returnValue = returnValue.replace(Costanti.AZIONE, nome);
  1244.         }
  1245.         
  1246.         return returnValue;
  1247.     }
  1248.     
  1249.     private static String replaceFruitore(String original, String tipoSoggetto, String nomeSoggetto){
  1250.         
  1251.         if(original==null){
  1252.             return null;
  1253.         }
  1254.         
  1255.         String returnValue = new String(original);
  1256.         
  1257.         if(tipoSoggetto!=null && !"".equals(tipoSoggetto)){
  1258.             returnValue = returnValue.replace(Costanti.TIPO_FRUITORE, tipoSoggetto);
  1259.         }
  1260.         
  1261.         if(nomeSoggetto!=null && !"".equals(nomeSoggetto)){
  1262.             returnValue = returnValue.replace(Costanti.NOME_FRUITORE, nomeSoggetto);
  1263.         }
  1264.         
  1265.         return returnValue;
  1266.     }
  1267.     
  1268.     public static void replaceTemplatesNames(Archive archive, IRegistryReader registryReader) throws ProtocolException{
  1269.             
  1270.         // Soggetti
  1271.         for (int i = 0; i < archive.getSoggetti().size(); i++) {
  1272.             org.openspcoop2.core.registry.Soggetto soggetto = archive.getSoggetti().get(i).getSoggettoRegistro();
  1273.             if(soggetto!=null) {
  1274.                 if(soggetto.getConnettore()!=null){
  1275.                     if(soggetto.getConnettore().sizePropertyList()>0){
  1276.                         for (int j = 0; j < soggetto.getConnettore().sizePropertyList(); j++) {
  1277.                             org.openspcoop2.core.registry.Property p = soggetto.getConnettore().getProperty(j);
  1278.                             p.setNome(replaceSoggettoProprietarioOrDefault(registryReader,p.getNome(), 
  1279.                                     soggetto.getTipo(),soggetto.getNome()));
  1280.                             p.setValore(replaceSoggettoProprietarioOrDefault(registryReader,p.getValore(), 
  1281.                                     soggetto.getTipo(),soggetto.getNome()));
  1282.                         }
  1283.                     }
  1284.                 }
  1285.                 if(soggetto.getIdentificativoPorta()!=null) {
  1286.                     soggetto.setIdentificativoPorta(replaceSoggettoProprietarioOrDefault(registryReader,soggetto.getIdentificativoPorta(), 
  1287.                                     soggetto.getTipo(),soggetto.getNome()));
  1288.                 }
  1289.                 if(soggetto.getPortaDominio()!=null) {
  1290.                     soggetto.setPortaDominio(replaceSoggettoProprietarioOrDefault(registryReader,soggetto.getPortaDominio(), 
  1291.                             soggetto.getTipo(),soggetto.getNome()));
  1292.                 }
  1293.             }
  1294.         }
  1295.         
  1296.         // ServiziApplicativi
  1297.         for (int i = 0; i < archive.getServiziApplicativi().size(); i++) {
  1298.             ServizioApplicativo sa = archive.getServiziApplicativi().get(i).getServizioApplicativo();           
  1299.             sa.setNome(replaceSoggettoProprietarioOrDefault(registryReader,sa.getNome(), 
  1300.                     sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));           
  1301.             if(sa.getInvocazionePorta()!=null){
  1302.                 if(sa.getInvocazionePorta().sizeCredenzialiList()>0){
  1303.                     for (int j = 0; j < sa.getInvocazionePorta().sizeCredenzialiList(); j++) {
  1304.                         Credenziali c  = sa.getInvocazionePorta().getCredenziali(j);
  1305.                         c.setUser(replaceSoggettoProprietarioOrDefault(registryReader,c.getUser(), 
  1306.                                 sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  1307.                         c.setPassword(replaceSoggettoProprietarioOrDefault(registryReader,c.getPassword(), 
  1308.                                 sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  1309.                         c.setSubject(replaceSoggettoProprietarioOrDefault(registryReader,c.getSubject(), 
  1310.                                 sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  1311.                     }
  1312.                 }
  1313.             }
  1314.             if(sa.getInvocazioneServizio()!=null){
  1315.                 if(sa.getInvocazioneServizio().getCredenziali()!=null){
  1316.                     InvocazioneCredenziali c  = sa.getInvocazioneServizio().getCredenziali();
  1317.                     c.setUser(replaceSoggettoProprietarioOrDefault(registryReader,c.getUser(), 
  1318.                             sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  1319.                     c.setPassword(replaceSoggettoProprietarioOrDefault(registryReader,c.getPassword(), 
  1320.                             sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  1321.                 }
  1322.                 if(sa.getInvocazioneServizio().getConnettore()!=null){
  1323.                     if(sa.getInvocazioneServizio().getConnettore().sizePropertyList()>0){
  1324.                         for (int j = 0; j < sa.getInvocazioneServizio().getConnettore().sizePropertyList(); j++) {
  1325.                             org.openspcoop2.core.config.Property p = sa.getInvocazioneServizio().getConnettore().getProperty(j);
  1326.                             p.setNome(replaceSoggettoProprietarioOrDefault(registryReader,p.getNome(), 
  1327.                                     sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  1328.                             p.setValore(replaceSoggettoProprietarioOrDefault(registryReader,p.getValore(), 
  1329.                                     sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  1330.                         }
  1331.                     }
  1332.                 }
  1333.             }
  1334.             if(sa.getRispostaAsincrona()!=null){
  1335.                 if(sa.getRispostaAsincrona().getCredenziali()!=null){
  1336.                     InvocazioneCredenziali c  = sa.getRispostaAsincrona().getCredenziali();
  1337.                     c.setUser(replaceSoggettoProprietarioOrDefault(registryReader,c.getUser(), 
  1338.                             sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  1339.                     c.setPassword(replaceSoggettoProprietarioOrDefault(registryReader,c.getPassword(), 
  1340.                             sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  1341.                 }
  1342.                 if(sa.getRispostaAsincrona().getConnettore()!=null){
  1343.                     if(sa.getRispostaAsincrona().getConnettore().sizePropertyList()>0){
  1344.                         for (int j = 0; j < sa.getRispostaAsincrona().getConnettore().sizePropertyList(); j++) {
  1345.                             org.openspcoop2.core.config.Property p = sa.getRispostaAsincrona().getConnettore().getProperty(j);
  1346.                             p.setNome(replaceSoggettoProprietarioOrDefault(registryReader,p.getNome(), 
  1347.                                     sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  1348.                             p.setValore(replaceSoggettoProprietarioOrDefault(registryReader,p.getValore(), 
  1349.                                     sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()));
  1350.                         }
  1351.                     }
  1352.                 }
  1353.             }
  1354.         }
  1355.         
  1356.         // PorteDelegate
  1357.         for (int i = 0; i < archive.getPorteDelegate().size(); i++) {
  1358.             PortaDelegata pd = archive.getPorteDelegate().get(i).getPortaDelegata();
  1359.                         
  1360.             pd.setNome(replaceSoggettoProprietarioOrDefault(registryReader,pd.getNome(), 
  1361.                     pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario()));
  1362.             if(pd.getSoggettoErogatore()!=null && 
  1363.                     pd.getSoggettoErogatore().getNome()!=null && 
  1364.                     !"".equals(pd.getSoggettoErogatore().getNome()) ){
  1365.                 pd.setNome(replaceSoggettoErogatore(pd.getNome(), 
  1366.                         pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome()));
  1367.             }
  1368.             if(pd.getServizio()!=null && 
  1369.                     pd.getServizio().getNome()!=null && 
  1370.                     !"".equals(pd.getServizio().getNome()) ){
  1371.                 pd.setNome(replaceServizio(pd.getNome(), 
  1372.                         pd.getServizio().getTipo(), pd.getServizio().getNome()));
  1373.             }
  1374.             if(pd.getAzione()!=null && 
  1375.                     pd.getAzione().getNome()!=null &&
  1376.                     !"".equals(pd.getAzione().getNome()) ){
  1377.                 pd.setNome(replaceAzione(pd.getNome(), 
  1378.                         pd.getAzione().getNome()));
  1379.             }
  1380.             
  1381.             if(pd.getDescrizione()!=null && !"".equals(pd.getDescrizione())){
  1382.                 pd.setDescrizione(replaceSoggettoProprietarioOrDefault(registryReader,pd.getDescrizione(), 
  1383.                         pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario()));
  1384.                 if(pd.getSoggettoErogatore()!=null && 
  1385.                         pd.getSoggettoErogatore().getNome()!=null && 
  1386.                         !"".equals(pd.getSoggettoErogatore().getNome()) ){
  1387.                     pd.setDescrizione(replaceSoggettoErogatore(pd.getDescrizione(), 
  1388.                             pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome()));
  1389.                 }
  1390.                 if(pd.getServizio()!=null && 
  1391.                         pd.getServizio().getNome()!=null && 
  1392.                         !"".equals(pd.getServizio().getNome()) ){
  1393.                     pd.setDescrizione(replaceServizio(pd.getDescrizione(), 
  1394.                             pd.getServizio().getTipo(), pd.getServizio().getNome()));
  1395.                 }
  1396.                 if(pd.getAzione()!=null && 
  1397.                         pd.getAzione().getNome()!=null &&
  1398.                         !"".equals(pd.getAzione().getNome()) ){
  1399.                     pd.setDescrizione(replaceAzione(pd.getDescrizione(), 
  1400.                             pd.getAzione().getNome()));
  1401.                 }
  1402.             }
  1403.             
  1404.             if(pd.getAzione()!=null){
  1405.                 if(pd.getAzione().getPattern()!=null &&
  1406.                         !"".equals(pd.getAzione().getPattern())){
  1407.                     pd.getAzione().setPattern(replaceSoggettoProprietarioOrDefault(registryReader,pd.getAzione().getPattern(), 
  1408.                             pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario()));
  1409.                     if(pd.getSoggettoErogatore()!=null && 
  1410.                             pd.getSoggettoErogatore().getNome()!=null && 
  1411.                             !"".equals(pd.getSoggettoErogatore().getNome()) ){
  1412.                         pd.getAzione().setPattern(replaceSoggettoErogatore(pd.getAzione().getPattern(), 
  1413.                                 pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome()));
  1414.                     }
  1415.                     if(pd.getServizio()!=null && 
  1416.                             pd.getServizio().getNome()!=null && 
  1417.                             !"".equals(pd.getServizio().getNome()) ){
  1418.                         pd.getAzione().setPattern(replaceServizio(pd.getAzione().getPattern(), 
  1419.                                 pd.getServizio().getTipo(), pd.getServizio().getNome()));
  1420.                     }
  1421.                     // se ho il pattern configurato, non c'è il nome dell'azione
  1422. //                  pd.getAzione().setPattern(replaceAzione(pd.getAzione().getPattern(), 
  1423. //                          pd.getAzione().getNome()));
  1424.                     // se ho il pattern configurato, non c'è il nome dell'azione
  1425.                 }
  1426.             }
  1427.             
  1428.             if(pd.getAzione()!=null) {
  1429.                 if(pd.getAzione().getNomePortaDelegante()!=null &&
  1430.                         !"".equals(pd.getAzione().getNomePortaDelegante())){
  1431.                     pd.getAzione().setNomePortaDelegante(replaceSoggettoProprietarioOrDefault(registryReader,pd.getAzione().getNomePortaDelegante(), 
  1432.                             pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario()));
  1433.                 }
  1434.             }
  1435.             
  1436.             for (int j = 0; j < pd.sizeServizioApplicativoList(); j++) {
  1437.                 pd.getServizioApplicativo(j).setNome(replaceSoggettoProprietarioOrDefault(registryReader,pd.getServizioApplicativo(j).getNome(), 
  1438.                     pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario()));
  1439.                 if(pd.getSoggettoErogatore()!=null && 
  1440.                         pd.getSoggettoErogatore().getNome()!=null && 
  1441.                         !"".equals(pd.getSoggettoErogatore().getNome()) ){
  1442.                     pd.getServizioApplicativo(j).setNome(replaceSoggettoErogatore(pd.getServizioApplicativo(j).getNome(), 
  1443.                             pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome()));
  1444.                 }
  1445.                 if(pd.getServizio()!=null && 
  1446.                         pd.getServizio().getNome()!=null && 
  1447.                         !"".equals(pd.getServizio().getNome()) ){
  1448.                     pd.getServizioApplicativo(j).setNome(replaceServizio(pd.getServizioApplicativo(j).getNome(), 
  1449.                             pd.getServizio().getTipo(), pd.getServizio().getNome()));
  1450.                 }
  1451.                 if(pd.getAzione()!=null && 
  1452.                         pd.getAzione().getNome()!=null && 
  1453.                         !"".equals(pd.getAzione().getNome()) ){
  1454.                     pd.getServizioApplicativo(j).setNome(replaceAzione(pd.getServizioApplicativo(j).getNome(), 
  1455.                             pd.getAzione().getNome()));
  1456.                 }
  1457.             }
  1458.             
  1459.             if(pd.getCorrelazioneApplicativa()!=null && pd.getCorrelazioneApplicativa().sizeElementoList()>0) {
  1460.                 for (CorrelazioneApplicativaElemento elemento : pd.getCorrelazioneApplicativa().getElementoList()) {
  1461.                     if(elemento.getNome()!=null && !"".equals(elemento.getNome())){
  1462.                         elemento.setNome(replaceSoggettoProprietarioOrDefault(registryReader,elemento.getNome(), 
  1463.                                 pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario()));
  1464.                         if(pd.getSoggettoErogatore()!=null && 
  1465.                                 pd.getSoggettoErogatore().getNome()!=null && 
  1466.                                 !"".equals(pd.getSoggettoErogatore().getNome()) ){
  1467.                             elemento.setNome(replaceSoggettoErogatore(elemento.getNome(), 
  1468.                                     pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome()));
  1469.                         }
  1470.                         if(pd.getServizio()!=null && 
  1471.                                 pd.getServizio().getNome()!=null && 
  1472.                                 !"".equals(pd.getServizio().getNome()) ){
  1473.                             elemento.setNome(replaceServizio(elemento.getNome(), 
  1474.                                     pd.getServizio().getTipo(), pd.getServizio().getNome()));
  1475.                         }
  1476.                         if(pd.getAzione()!=null && 
  1477.                                 pd.getAzione().getNome()!=null &&
  1478.                                 !"".equals(pd.getAzione().getNome()) ){
  1479.                             elemento.setNome(replaceAzione(elemento.getNome(), 
  1480.                                     pd.getAzione().getNome()));
  1481.                         }
  1482.                     }
  1483.                     if(elemento.getPattern()!=null && !"".equals(elemento.getPattern())){
  1484.                         elemento.setPattern(replaceSoggettoProprietarioOrDefault(registryReader,elemento.getPattern(), 
  1485.                                 pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario()));
  1486.                         if(pd.getSoggettoErogatore()!=null && 
  1487.                                 pd.getSoggettoErogatore().getNome()!=null && 
  1488.                                 !"".equals(pd.getSoggettoErogatore().getNome()) ){
  1489.                             elemento.setPattern(replaceSoggettoErogatore(elemento.getPattern(), 
  1490.                                     pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome()));
  1491.                         }
  1492.                         if(pd.getServizio()!=null && 
  1493.                                 pd.getServizio().getNome()!=null && 
  1494.                                 !"".equals(pd.getServizio().getNome()) ){
  1495.                             elemento.setPattern(replaceServizio(elemento.getPattern(), 
  1496.                                     pd.getServizio().getTipo(), pd.getServizio().getNome()));
  1497.                         }
  1498.                         if(pd.getAzione()!=null && 
  1499.                                 pd.getAzione().getNome()!=null &&
  1500.                                 !"".equals(pd.getAzione().getNome()) ){
  1501.                             elemento.setPattern(replaceAzione(elemento.getPattern(), 
  1502.                                     pd.getAzione().getNome()));
  1503.                         }
  1504.                     }
  1505.                 }
  1506.             }
  1507.             if(pd.getCorrelazioneApplicativaRisposta()!=null && pd.getCorrelazioneApplicativaRisposta().sizeElementoList()>0) {
  1508.                 for (CorrelazioneApplicativaRispostaElemento elemento : pd.getCorrelazioneApplicativaRisposta().getElementoList()) {
  1509.                     if(elemento.getNome()!=null && !"".equals(elemento.getNome())){
  1510.                         elemento.setNome(replaceSoggettoProprietarioOrDefault(registryReader,elemento.getNome(), 
  1511.                                 pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario()));
  1512.                         if(pd.getSoggettoErogatore()!=null && 
  1513.                                 pd.getSoggettoErogatore().getNome()!=null && 
  1514.                                 !"".equals(pd.getSoggettoErogatore().getNome()) ){
  1515.                             elemento.setNome(replaceSoggettoErogatore(elemento.getNome(), 
  1516.                                     pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome()));
  1517.                         }
  1518.                         if(pd.getServizio()!=null && 
  1519.                                 pd.getServizio().getNome()!=null && 
  1520.                                 !"".equals(pd.getServizio().getNome()) ){
  1521.                             elemento.setNome(replaceServizio(elemento.getNome(), 
  1522.                                     pd.getServizio().getTipo(), pd.getServizio().getNome()));
  1523.                         }
  1524.                         if(pd.getAzione()!=null && 
  1525.                                 pd.getAzione().getNome()!=null &&
  1526.                                 !"".equals(pd.getAzione().getNome()) ){
  1527.                             elemento.setNome(replaceAzione(elemento.getNome(), 
  1528.                                     pd.getAzione().getNome()));
  1529.                         }
  1530.                     }
  1531.                     if(elemento.getPattern()!=null && !"".equals(elemento.getPattern())){
  1532.                         elemento.setPattern(replaceSoggettoProprietarioOrDefault(registryReader,elemento.getPattern(), 
  1533.                                 pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario()));
  1534.                         if(pd.getSoggettoErogatore()!=null && 
  1535.                                 pd.getSoggettoErogatore().getNome()!=null && 
  1536.                                 !"".equals(pd.getSoggettoErogatore().getNome()) ){
  1537.                             elemento.setPattern(replaceSoggettoErogatore(elemento.getPattern(), 
  1538.                                     pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome()));
  1539.                         }
  1540.                         if(pd.getServizio()!=null && 
  1541.                                 pd.getServizio().getNome()!=null && 
  1542.                                 !"".equals(pd.getServizio().getNome()) ){
  1543.                             elemento.setPattern(replaceServizio(elemento.getPattern(), 
  1544.                                     pd.getServizio().getTipo(), pd.getServizio().getNome()));
  1545.                         }
  1546.                         if(pd.getAzione()!=null && 
  1547.                                 pd.getAzione().getNome()!=null &&
  1548.                                 !"".equals(pd.getAzione().getNome()) ){
  1549.                             elemento.setPattern(replaceAzione(elemento.getPattern(), 
  1550.                                     pd.getAzione().getNome()));
  1551.                         }
  1552.                     }
  1553.                 }
  1554.             }
  1555.             
  1556.         }
  1557.         
  1558.         // PorteApplicative
  1559.         for (int i = 0; i < archive.getPorteApplicative().size(); i++) {
  1560.             PortaApplicativa pa = archive.getPorteApplicative().get(i).getPortaApplicativa();
  1561.             
  1562.             if(pa.getDescrizione()!=null && !"".equals(pa.getDescrizione())){
  1563.                 pa.setDescrizione(replaceSoggettoProprietarioOrDefault(registryReader,pa.getDescrizione(), 
  1564.                         pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  1565.                 if(pa.getServizio()!=null && 
  1566.                         pa.getServizio().getNome()!=null && 
  1567.                         !"".equals(pa.getServizio().getNome()) ){
  1568.                     pa.setDescrizione(replaceServizio(pa.getDescrizione(), 
  1569.                             pa.getServizio().getTipo(), pa.getServizio().getNome()));
  1570.                 }
  1571.                 if(pa.getAzione()!=null && 
  1572.                         pa.getAzione().getNome()!=null && 
  1573.                         !"".equals(pa.getAzione().getNome()) ){
  1574.                     pa.setDescrizione(replaceAzione(pa.getDescrizione(), 
  1575.                             pa.getAzione().getNome()));
  1576.                 }
  1577.             }
  1578.             
  1579.             pa.setNome(replaceSoggettoProprietarioOrDefault(registryReader,pa.getNome(), 
  1580.                     pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  1581.             if(pa.getServizio()!=null && 
  1582.                     pa.getServizio().getNome()!=null && 
  1583.                     !"".equals(pa.getServizio().getNome()) ){
  1584.                 pa.setNome(replaceServizio(pa.getNome(), 
  1585.                         pa.getServizio().getTipo(), pa.getServizio().getNome()));
  1586.             }
  1587.             if(pa.getAzione()!=null && 
  1588.                     pa.getAzione().getNome()!=null && 
  1589.                     !"".equals(pa.getAzione().getNome()) ){
  1590.                 pa.setNome(replaceAzione(pa.getNome(), 
  1591.                         pa.getAzione().getNome()));
  1592.             }
  1593.             
  1594.             if(pa.getAzione()!=null) {
  1595.                 if(pa.getAzione().getNomePortaDelegante()!=null &&
  1596.                         !"".equals(pa.getAzione().getNomePortaDelegante())){
  1597.                     pa.getAzione().setNomePortaDelegante(replaceSoggettoProprietarioOrDefault(registryReader,pa.getAzione().getNomePortaDelegante(), 
  1598.                             pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  1599.                 }
  1600.             }
  1601.             
  1602.             for (int j = 0; j < pa.sizeServizioApplicativoList(); j++) {
  1603.                 pa.getServizioApplicativo(j).setNome(replaceSoggettoProprietarioOrDefault(registryReader,pa.getServizioApplicativo(j).getNome(), 
  1604.                     pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  1605.                 if(pa.getServizio()!=null && 
  1606.                         pa.getServizio().getNome()!=null && 
  1607.                         !"".equals(pa.getServizio().getNome()) ){
  1608.                     pa.getServizioApplicativo(j).setNome(replaceServizio(pa.getServizioApplicativo(j).getNome(), 
  1609.                             pa.getServizio().getTipo(), pa.getServizio().getNome()));
  1610.                 }
  1611.                 if(pa.getAzione()!=null && 
  1612.                         pa.getAzione().getNome()!=null && 
  1613.                         !"".equals(pa.getAzione().getNome()) ){
  1614.                     pa.getServizioApplicativo(j).setNome(replaceAzione(pa.getServizioApplicativo(j).getNome(), 
  1615.                             pa.getAzione().getNome()));
  1616.                 }
  1617.             }
  1618.             
  1619.             if(pa.getCorrelazioneApplicativa()!=null && pa.getCorrelazioneApplicativa().sizeElementoList()>0) {
  1620.                 for (CorrelazioneApplicativaElemento elemento : pa.getCorrelazioneApplicativa().getElementoList()) {
  1621.                     if(elemento.getNome()!=null && !"".equals(elemento.getNome())){
  1622.                         elemento.setNome(replaceSoggettoProprietarioOrDefault(registryReader,elemento.getNome(), 
  1623.                                 pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  1624.                         if(pa.getServizio()!=null && 
  1625.                                 pa.getServizio().getNome()!=null && 
  1626.                                 !"".equals(pa.getServizio().getNome()) ){
  1627.                             elemento.setNome(replaceServizio(elemento.getNome(), 
  1628.                                     pa.getServizio().getTipo(), pa.getServizio().getNome()));
  1629.                         }
  1630.                         if(pa.getAzione()!=null && 
  1631.                                 pa.getAzione().getNome()!=null &&
  1632.                                 !"".equals(pa.getAzione().getNome()) ){
  1633.                             elemento.setNome(replaceAzione(elemento.getNome(), 
  1634.                                     pa.getAzione().getNome()));
  1635.                         }
  1636.                     }
  1637.                     if(elemento.getPattern()!=null && !"".equals(elemento.getPattern())){
  1638.                         elemento.setPattern(replaceSoggettoProprietarioOrDefault(registryReader,elemento.getPattern(), 
  1639.                                 pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  1640.                         if(pa.getServizio()!=null && 
  1641.                                 pa.getServizio().getNome()!=null && 
  1642.                                 !"".equals(pa.getServizio().getNome()) ){
  1643.                             elemento.setPattern(replaceServizio(elemento.getPattern(), 
  1644.                                     pa.getServizio().getTipo(), pa.getServizio().getNome()));
  1645.                         }
  1646.                         if(pa.getAzione()!=null && 
  1647.                                 pa.getAzione().getNome()!=null &&
  1648.                                 !"".equals(pa.getAzione().getNome()) ){
  1649.                             elemento.setPattern(replaceAzione(elemento.getPattern(), 
  1650.                                     pa.getAzione().getNome()));
  1651.                         }
  1652.                     }
  1653.                 }
  1654.             }
  1655.             if(pa.getCorrelazioneApplicativaRisposta()!=null && pa.getCorrelazioneApplicativaRisposta().sizeElementoList()>0) {
  1656.                 for (CorrelazioneApplicativaRispostaElemento elemento : pa.getCorrelazioneApplicativaRisposta().getElementoList()) {
  1657.                     if(elemento.getNome()!=null && !"".equals(elemento.getNome())){
  1658.                         elemento.setNome(replaceSoggettoProprietarioOrDefault(registryReader,elemento.getNome(), 
  1659.                                 pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  1660.                         if(pa.getServizio()!=null && 
  1661.                                 pa.getServizio().getNome()!=null && 
  1662.                                 !"".equals(pa.getServizio().getNome()) ){
  1663.                             elemento.setNome(replaceServizio(elemento.getNome(), 
  1664.                                     pa.getServizio().getTipo(), pa.getServizio().getNome()));
  1665.                         }
  1666.                         if(pa.getAzione()!=null && 
  1667.                                 pa.getAzione().getNome()!=null &&
  1668.                                 !"".equals(pa.getAzione().getNome()) ){
  1669.                             elemento.setNome(replaceAzione(elemento.getNome(), 
  1670.                                     pa.getAzione().getNome()));
  1671.                         }
  1672.                     }
  1673.                     if(elemento.getPattern()!=null && !"".equals(elemento.getPattern())){
  1674.                         elemento.setPattern(replaceSoggettoProprietarioOrDefault(registryReader,elemento.getPattern(), 
  1675.                                 pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  1676.                         if(pa.getServizio()!=null && 
  1677.                                 pa.getServizio().getNome()!=null && 
  1678.                                 !"".equals(pa.getServizio().getNome()) ){
  1679.                             elemento.setPattern(replaceServizio(elemento.getPattern(), 
  1680.                                     pa.getServizio().getTipo(), pa.getServizio().getNome()));
  1681.                         }
  1682.                         if(pa.getAzione()!=null && 
  1683.                                 pa.getAzione().getNome()!=null &&
  1684.                                 !"".equals(pa.getAzione().getNome()) ){
  1685.                             elemento.setPattern(replaceAzione(elemento.getPattern(), 
  1686.                                     pa.getAzione().getNome()));
  1687.                         }
  1688.                     }
  1689.                 }
  1690.             }
  1691.         }
  1692.         
  1693.         // AccordoServizioParteSpecifica
  1694.         for (int i = 0; i < archive.getAccordiServizioParteSpecifica().size(); i++) {
  1695.             
  1696.             ArchiveAccordoServizioParteSpecifica archiveAS = archive.getAccordiServizioParteSpecifica().get(i); 
  1697.             AccordoServizioParteSpecifica as = archiveAS.getAccordoServizioParteSpecifica();
  1698.             
  1699.             if(as.getAccordoServizioParteComune()!=null) {
  1700.                 as.setAccordoServizioParteComune(replaceSoggettoProprietarioOrDefault(registryReader,as.getAccordoServizioParteComune(), as.getTipoSoggettoErogatore(),as.getNomeSoggettoErogatore()));
  1701.                 as.setAccordoServizioParteComune(replaceSoggettoErogatore(as.getAccordoServizioParteComune(), as.getTipoSoggettoErogatore(),as.getNomeSoggettoErogatore()));
  1702.             }
  1703.             
  1704.             if(as.getConfigurazioneServizio()!=null && as.getConfigurazioneServizio().getConnettore()!=null){
  1705.                 for (int j = 0; j < as.getConfigurazioneServizio().getConnettore().sizePropertyList(); j++) {
  1706.                     Property p = as.getConfigurazioneServizio().getConnettore().getProperty(j);
  1707.                     p.setNome(replaceSoggettoProprietarioOrDefault(registryReader,p.getNome(), as.getTipoSoggettoErogatore(),as.getNomeSoggettoErogatore()));
  1708.                     p.setValore(replaceSoggettoProprietarioOrDefault(registryReader,p.getValore(), as.getTipoSoggettoErogatore(),as.getNomeSoggettoErogatore()));
  1709.                 }
  1710.             }
  1711.             if(as.getConfigurazioneServizio()!=null && as.getConfigurazioneServizio().getConnettore()!=null){
  1712.                 for (int j = 0; j < as.getConfigurazioneServizio().getConnettore().sizePropertyList(); j++) {
  1713.                     Property p = as.getConfigurazioneServizio().getConnettore().getProperty(j);
  1714.                     p.setNome(replaceSoggettoErogatore(p.getNome(), as.getTipoSoggettoErogatore(),as.getNomeSoggettoErogatore()));
  1715.                     p.setValore(replaceSoggettoErogatore(p.getValore(), as.getTipoSoggettoErogatore(),as.getNomeSoggettoErogatore()));
  1716.                 }
  1717.             }
  1718.             
  1719.             if(as.sizeFruitoreList()==1){
  1720.                 if(as.getConfigurazioneServizio()!=null && as.getConfigurazioneServizio().getConnettore()!=null){
  1721.                     for (int j = 0; j < as.getConfigurazioneServizio().getConnettore().sizePropertyList(); j++) {
  1722.                         Property p = as.getConfigurazioneServizio().getConnettore().getProperty(j);
  1723.                         p.setNome(replaceFruitore(p.getNome(), as.getFruitore(0).getTipo(), as.getFruitore(0).getNome()));
  1724.                         p.setValore(replaceFruitore(p.getValore(), as.getFruitore(0).getTipo(), as.getFruitore(0).getNome()));
  1725.                     }
  1726.                 }
  1727.             }
  1728.             else{
  1729.                 if(as.sizeFruitoreList()==0){
  1730.                     
  1731.                     IDServizio idAccordoAttuale = null;
  1732.                     try{
  1733.                         idAccordoAttuale = IDServizioFactory.getInstance().getIDServizioFromAccordo(as);
  1734.                     }catch(Exception e){
  1735.                         throw new ProtocolException(e.getMessage(),e);
  1736.                     }
  1737.                     
  1738.                     // cerco fruitori di questo accordo
  1739.                     List<Fruitore> listFruitori = new ArrayList<Fruitore>();
  1740.                     for (int j = 0; j < archive.getAccordiFruitori().size(); j++) {
  1741.                         Fruitore fr = archive.getAccordiFruitori().get(j).getFruitore();
  1742.                         IDServizio idAccordo = archive.getAccordiFruitori().get(j).getIdAccordoServizioParteSpecifica();
  1743.                         if(idAccordo.equals(idAccordoAttuale)){
  1744.                             listFruitori.add(fr);
  1745.                         }
  1746.                     }
  1747.                     if(listFruitori.size()==1){
  1748.                         if(as.getConfigurazioneServizio()!=null && as.getConfigurazioneServizio().getConnettore()!=null){
  1749.                             for (int j = 0; j < as.getConfigurazioneServizio().getConnettore().sizePropertyList(); j++) {
  1750.                                 Property p = as.getConfigurazioneServizio().getConnettore().getProperty(j);
  1751.                                 p.setNome(replaceFruitore(p.getNome(), listFruitori.get(0).getTipo(), listFruitori.get(0).getNome()));
  1752.                                 p.setValore(replaceFruitore(p.getValore(), listFruitori.get(0).getTipo(), listFruitori.get(0).getNome()));
  1753.                             }
  1754.                         }
  1755.                     }
  1756.                 }
  1757.             }
  1758.             
  1759.             if(archiveAS.getMappingPorteApplicativeAssociate()!=null && !archiveAS.getMappingPorteApplicativeAssociate().isEmpty()) {
  1760.                 for (MappingErogazionePortaApplicativa mappingPA : archiveAS.getMappingPorteApplicativeAssociate()) {
  1761.                     if(mappingPA.getIdPortaApplicativa()!=null && mappingPA.getIdPortaApplicativa().getNome()!=null) {
  1762.                         mappingPA.getIdPortaApplicativa().setNome(replaceSoggettoProprietarioOrDefault(registryReader,mappingPA.getIdPortaApplicativa().getNome(), 
  1763.                                 as.getTipoSoggettoErogatore(),as.getNomeSoggettoErogatore()));
  1764.                         mappingPA.getIdPortaApplicativa().setNome(replaceSoggettoErogatore(mappingPA.getIdPortaApplicativa().getNome(), 
  1765.                                 as.getTipoSoggettoErogatore(),as.getNomeSoggettoErogatore()));
  1766.                         mappingPA.getIdPortaApplicativa().setNome(replaceServizio(mappingPA.getIdPortaApplicativa().getNome(), 
  1767.                                 as.getTipo(),as.getNome()));
  1768.                     }
  1769.                     if(mappingPA.getIdServizio()!=null) {
  1770.                         replaceTemplatesNames(registryReader, mappingPA.getIdServizio(),
  1771.                                 as.getTipoSoggettoErogatore(),as.getNomeSoggettoErogatore(),
  1772.                                 as.getTipo(),as.getNome(),
  1773.                                 true);
  1774.                     }
  1775.                 }
  1776.             }
  1777.         }
  1778.         
  1779.         // Fruitori
  1780.         for (int i = 0; i < archive.getAccordiFruitori().size(); i++) {
  1781.             ArchiveFruitore archiveFr = archive.getAccordiFruitori().get(i);
  1782.             Fruitore fr = archiveFr.getFruitore();
  1783.             IDServizio idAccordo = archive.getAccordiFruitori().get(i).getIdAccordoServizioParteSpecifica();
  1784.             String tipoSoggettoErogatore = null;
  1785.             String nomeSoggettoErogatore = null;
  1786.             String tipoServizio = null;
  1787.             String nomeServizio = null;
  1788.             if(idAccordo!=null && idAccordo.getSoggettoErogatore()!=null){
  1789.                 tipoSoggettoErogatore = idAccordo.getSoggettoErogatore().getTipo();
  1790.                 nomeSoggettoErogatore = idAccordo.getSoggettoErogatore().getNome();
  1791.             }
  1792.             if(idAccordo!=null) {
  1793.                 tipoServizio = idAccordo.getTipo();
  1794.                 nomeServizio = idAccordo.getNome();
  1795.             }
  1796.             if(fr.getConnettore()!=null){
  1797.                 for (int j = 0; j < fr.getConnettore().sizePropertyList(); j++) {
  1798.                     Property p = fr.getConnettore().getProperty(j);
  1799.                     p.setNome(replaceFruitore(p.getNome(), fr.getTipo(), fr.getNome()));
  1800.                     p.setValore(replaceFruitore(p.getValore(), fr.getTipo(), fr.getNome()));
  1801.                 }
  1802.                 for (int j = 0; j < fr.getConnettore().sizePropertyList(); j++) {
  1803.                     Property p = fr.getConnettore().getProperty(j);
  1804.                     p.setNome(replaceSoggettoProprietarioOrDefault(registryReader,p.getNome(), fr.getTipo(), fr.getNome()));
  1805.                     p.setValore(replaceSoggettoProprietarioOrDefault(registryReader,p.getValore(), fr.getTipo(), fr.getNome()));
  1806.                 }
  1807.                 if(tipoSoggettoErogatore!=null && nomeSoggettoErogatore!=null){
  1808.                     for (int j = 0; j < fr.getConnettore().sizePropertyList(); j++) {
  1809.                         Property p = fr.getConnettore().getProperty(j);
  1810.                         p.setNome(replaceSoggettoErogatore(p.getNome(), tipoSoggettoErogatore, nomeSoggettoErogatore));
  1811.                         p.setValore(replaceSoggettoErogatore(p.getValore(), tipoSoggettoErogatore, nomeSoggettoErogatore));
  1812.                     }   
  1813.                 }
  1814.             }
  1815.             
  1816.             if(archiveFr.getMappingPorteDelegateAssociate()!=null && !archiveFr.getMappingPorteDelegateAssociate().isEmpty()) {
  1817.                 for (MappingFruizionePortaDelegata mappingPD : archiveFr.getMappingPorteDelegateAssociate()) {
  1818.                     if(mappingPD.getIdPortaDelegata()!=null && mappingPD.getIdPortaDelegata().getNome()!=null) {
  1819.                         if(tipoSoggettoErogatore!=null && nomeSoggettoErogatore!=null){
  1820.                             mappingPD.getIdPortaDelegata().setNome(replaceSoggettoErogatore(mappingPD.getIdPortaDelegata().getNome(), 
  1821.                                     tipoSoggettoErogatore,nomeSoggettoErogatore));
  1822.                         }
  1823.                         if(tipoServizio!=null && nomeServizio!=null){
  1824.                             mappingPD.getIdPortaDelegata().setNome(replaceServizio(mappingPD.getIdPortaDelegata().getNome(), 
  1825.                                     tipoServizio,nomeServizio));
  1826.                         }
  1827.                         mappingPD.getIdPortaDelegata().setNome(replaceSoggettoProprietarioOrDefault(registryReader,mappingPD.getIdPortaDelegata().getNome(), 
  1828.                                 fr.getTipo(), fr.getNome()));
  1829.                         mappingPD.getIdPortaDelegata().setNome(replaceFruitore(mappingPD.getIdPortaDelegata().getNome(), 
  1830.                                 fr.getTipo(), fr.getNome()));
  1831.                     }
  1832.                     if(mappingPD.getIdServizio()!=null) {
  1833.                         if(tipoSoggettoErogatore!=null && nomeSoggettoErogatore!=null && tipoServizio!=null && nomeServizio!=null){
  1834.                             replaceTemplatesNames(registryReader,mappingPD.getIdServizio(),
  1835.                                     tipoSoggettoErogatore,nomeSoggettoErogatore,
  1836.                                     tipoServizio,nomeServizio,
  1837.                                     false);
  1838.                         }
  1839.                     }
  1840.                     if(mappingPD.getIdFruitore()!=null) {
  1841.                         if(mappingPD.getIdFruitore().getTipo()!=null) {
  1842.                             mappingPD.getIdFruitore().setTipo(replaceSoggettoProprietarioOrDefault(registryReader,mappingPD.getIdFruitore().getTipo(), 
  1843.                                     fr.getTipo(), fr.getNome()));
  1844.                             mappingPD.getIdFruitore().setTipo(replaceFruitore(mappingPD.getIdFruitore().getTipo(), 
  1845.                                     fr.getTipo(), fr.getNome()));
  1846.                         }
  1847.                         if(mappingPD.getIdFruitore().getNome()!=null) {
  1848.                             mappingPD.getIdFruitore().setNome(replaceSoggettoProprietarioOrDefault(registryReader,mappingPD.getIdFruitore().getNome(), 
  1849.                                     fr.getTipo(), fr.getNome()));
  1850.                             mappingPD.getIdFruitore().setNome(replaceFruitore(mappingPD.getIdFruitore().getNome(), 
  1851.                                     fr.getTipo(), fr.getNome()));
  1852.                         }
  1853.                     }
  1854.                 }
  1855.             }
  1856.         }
  1857.     }
  1858.     
  1859.     @SuppressWarnings("deprecation")
  1860.     private static void replaceTemplatesNames(IRegistryReader registryReader, IDServizio idServizio, 
  1861.             String tipoSoggettoErogatore, String nomeSoggettoErogatore, 
  1862.             String tipoServizio, String nomeServizio,
  1863.             boolean replaceProprietario) throws ProtocolException {
  1864.         if(idServizio.getSoggettoErogatore()!=null) {
  1865.             if(idServizio.getSoggettoErogatore().getTipo()!=null) {
  1866.                 if(replaceProprietario) {
  1867.                     idServizio.getSoggettoErogatore().setTipo(replaceSoggettoProprietarioOrDefault(registryReader,idServizio.getSoggettoErogatore().getTipo(), 
  1868.                             tipoSoggettoErogatore,nomeSoggettoErogatore));
  1869.                 }
  1870.                 idServizio.getSoggettoErogatore().setTipo(replaceSoggettoErogatore(idServizio.getSoggettoErogatore().getTipo(), 
  1871.                         tipoSoggettoErogatore,nomeSoggettoErogatore));
  1872.             }
  1873.             if(idServizio.getSoggettoErogatore().getNome()!=null) {
  1874.                 if(replaceProprietario) {
  1875.                     idServizio.getSoggettoErogatore().setNome(replaceSoggettoProprietarioOrDefault(registryReader,idServizio.getSoggettoErogatore().getNome(), 
  1876.                             tipoSoggettoErogatore,nomeSoggettoErogatore));
  1877.                 }
  1878.                 idServizio.getSoggettoErogatore().setNome(replaceSoggettoErogatore(idServizio.getSoggettoErogatore().getNome(), 
  1879.                         tipoSoggettoErogatore,nomeSoggettoErogatore));
  1880.             }
  1881.         }
  1882.         if(idServizio.getTipo()!=null) {
  1883.             idServizio.setTipo(replaceServizio(idServizio.getTipo(), 
  1884.                     tipoServizio,nomeServizio));
  1885.         }
  1886.         if(idServizio.getNome()!=null) {
  1887.             idServizio.setNome(replaceServizio(idServizio.getNome(), 
  1888.                     tipoServizio,nomeServizio));
  1889.         }
  1890.     }
  1891. }
Created with JaCoCo 0.8.8.202204050719