SoggettoUpdateUtilities.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.web.ctrlstat.servlet.soggetti;

  22. import java.util.ArrayList;
  23. import java.util.HashMap;
  24. import java.util.List;
  25. import java.util.Map;

  27. import org.apache.commons.lang3.StringUtils;
  28. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  29. import org.openspcoop2.core.config.Configurazione;
  30. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
  31. import org.openspcoop2.core.config.PortaApplicativa;
  32. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneServizioApplicativo;
  33. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneSoggetto;
  34. import org.openspcoop2.core.config.PortaApplicativaAzione;
  35. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  36. import org.openspcoop2.core.config.PortaDelegata;
  37. import org.openspcoop2.core.config.PortaDelegataAzione;
  38. import org.openspcoop2.core.config.PortaDelegataSoggettoErogatore;
  39. import org.openspcoop2.core.config.ServizioApplicativo;
  40. import org.openspcoop2.core.config.TrasformazioneRegola;
  41. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaServizioApplicativo;
  42. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaSoggetto;
  43. import org.openspcoop2.core.config.constants.PortaApplicativaAzioneIdentificazione;
  44. import org.openspcoop2.core.config.constants.PortaDelegataAzioneIdentificazione;
  45. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  46. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  47. import org.openspcoop2.core.config.driver.FiltroRicercaPorteApplicative;
  48. import org.openspcoop2.core.config.driver.FiltroRicercaPorteDelegate;
  49. import org.openspcoop2.core.config.driver.db.IDServizioApplicativoDB;
  50. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  51. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  52. import org.openspcoop2.core.id.IDAccordo;
  53. import org.openspcoop2.core.id.IDAccordoCooperazione;
  54. import org.openspcoop2.core.id.IDPortaApplicativa;
  55. import org.openspcoop2.core.id.IDPortaDelegata;
  56. import org.openspcoop2.core.id.IDServizio;
  57. import org.openspcoop2.core.id.IDServizioApplicativo;
  58. import org.openspcoop2.core.id.IDSoggetto;
  59. import org.openspcoop2.core.registry.AccordoCooperazione;
  60. import org.openspcoop2.core.registry.AccordoCooperazionePartecipanti;
  61. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  62. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  63. import org.openspcoop2.core.registry.Fruitore;
  64. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  65. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  66. import org.openspcoop2.core.registry.driver.FiltroRicercaAccordi;
  67. import org.openspcoop2.core.registry.driver.FiltroRicercaServizi;
  68. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  69. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  70. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  71. import org.openspcoop2.monitor.engine.alarm.wrapper.ConfigurazioneAllarmeBean;
  72. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  73. import org.openspcoop2.web.ctrlstat.dao.SoggettoCtrlStat;
  74. import org.openspcoop2.web.ctrlstat.servlet.ac.AccordiCooperazioneCore;
  75. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCore;
  76. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCore;
  77. import org.openspcoop2.web.ctrlstat.servlet.config.ConfigurazioneCore;
  78. import org.openspcoop2.web.ctrlstat.servlet.connettori.ConnettoriCostanti;
  79. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCore;
  80. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCore;
  81. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCore;

  83. /**
  84.  * SoggettoUpdateUtilities
  85.  *
  86.  * @author Poli Andrea (apoli@link.it)
  87.  * @author $Author$
  88.  * @version $Rev$, $Date$
  89.  */
  90. public class SoggettoUpdateUtilities {

  92.     // pattern (fruitore)/(erogatore)/....
  93.     private static final String REGEXP_FRUITORE_EROGATORE_OTHER = ".*\\/.*\\/.*";
  94.     
  95.     private static final String REGEXP_FRUITORE_EROGATORE_OTHER_MATCH = "(.*)\\/(.*)\\/(.*)";
  96.     
  97.     private static final String PATTERN_AZIONE_PREFIX_OLD = ".*/";
  98.     private static final String PATTERN_AZIONE_SUFFIX_OLD = "/([^/|^?]*).*";
  99.     
  100.     private static final String PATTERN_AZIONE_PREFIX_NEW = "/";
  101.     private static final String PATTERN_AZIONE_SUFFIX_NEW = "/([^/?]*).*";
  102.     
  103.     
  104.     List<Object> oggettiDaAggiornare = null;
  105.     private SoggettiCore soggettiCore;
  106.     private ServiziApplicativiCore saCore;
  107.     private AccordiServizioParteComuneCore apcCore;
  108.     private AccordiServizioParteSpecificaCore apsCore;
  109.     private PorteDelegateCore porteDelegateCore;
  110.     private PorteApplicativeCore porteApplicativeCore;
  111.     private AccordiCooperazioneCore acCore;
  112.     private ConfigurazioneCore confCore;
  113.     private SoggettoCtrlStat sog;
  114.     private String oldnomeprov;
  115.     private String nomeprov;
  116.     private String oldtipoprov;
  117.     private String tipoprov;
  118.     private IDAccordoCooperazioneFactory idAccordoCooperazioneFactory = IDAccordoCooperazioneFactory.getInstance();
  119.     private IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();

  121.     public SoggettoUpdateUtilities(SoggettiCore soggettiCore,
  122.             String oldnomeprov,String nomeprov,
  123.             String oldtipoprov,String tipoprov,
  124.             SoggettoCtrlStat sog) throws Exception{
  125.         this.oggettiDaAggiornare = new ArrayList<>();
  126.         this.soggettiCore = soggettiCore;
  127.         this.saCore = new ServiziApplicativiCore(this.soggettiCore);
  128.         this.apcCore = new AccordiServizioParteComuneCore(this.soggettiCore);
  129.         this.apsCore = new AccordiServizioParteSpecificaCore(this.soggettiCore);
  130.         this.porteDelegateCore = new PorteDelegateCore(this.soggettiCore);
  131.         this.porteApplicativeCore = new PorteApplicativeCore(this.soggettiCore);
  132.         this.acCore = new AccordiCooperazioneCore(this.soggettiCore);
  133.         this.confCore = new ConfigurazioneCore(this.soggettiCore);
  134.         this.oldnomeprov = oldnomeprov;
  135.         this.nomeprov = nomeprov;
  136.         this.oldtipoprov = oldtipoprov;
  137.         this.tipoprov = tipoprov;
  138.         this.sog = sog;
  139.     }

  141.     public List<Object> getOggettiDaAggiornare() {
  142.         return this.oggettiDaAggiornare;
  143.     }
  144.     
  145.     public void addSoggetto(){
  146.         this.oggettiDaAggiornare.add(this.sog);
  147.     }

  149.     public void checkServiziApplicativi() throws DriverConfigurazioneException{
  150.         // SERVIZI - APPLICATIVI 
  151.         // Se e' cambiato il tipo o il nome del soggetto devo effettuare la modifica dei servizi applicativi
  152.         // poiche il cambio si riflette sul nome dei connettori del servizio applicativo

  154.         if (!this.oldnomeprov.equals(this.nomeprov) || !this.oldtipoprov.equals(this.tipoprov)) {

  156.             List<String> nomeListSA = new ArrayList<>();
  157.             List<ServizioApplicativo> listSA = new ArrayList<>();
  158.             List<IDServizioApplicativoDB> tmpListIDSA = this.saCore.getIdServiziApplicativiWithIdErogatore(this.sog.getId());
  159.             for (IDServizioApplicativoDB idServizioApplicativo : tmpListIDSA) {
  160.                 if (!nomeListSA.contains(idServizioApplicativo.getNome())) {
  161.                     nomeListSA.add(idServizioApplicativo.getNome());
  162.                     ServizioApplicativo servizioApplicativo = this.saCore.getServizioApplicativo(idServizioApplicativo);
  163.                     servizioApplicativo.setTipoSoggettoProprietario(this.tipoprov);
  164.                     servizioApplicativo.setNomeSoggettoProprietario(this.nomeprov);
  165.                     IDServizioApplicativo oldIDServizioApplicativoForUpdate = new IDServizioApplicativo();
  166.                     oldIDServizioApplicativoForUpdate.setNome(servizioApplicativo.getNome());
  167.                     oldIDServizioApplicativoForUpdate.setIdSoggettoProprietario(new IDSoggetto(this.oldtipoprov, this.oldnomeprov));
  168.                     servizioApplicativo.setOldIDServizioApplicativoForUpdate(oldIDServizioApplicativoForUpdate);
  169.                     listSA.add(servizioApplicativo);
  170.                 }

  172.             }

  174.             // aggiungo tutti i servizi applicativi trovati
  175.             for (ServizioApplicativo sa : listSA) {
  176.                 this.oggettiDaAggiornare.add(sa);
  177.             }

  179.         }

  181.     }

  183.     public void checkAccordiCooperazione() throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  184.         // Accordi di Cooperazione
  185.         // Se e' cambiato il tipo o il nome del soggetto devo effettuare la modifica degli accordi di cooperazione:
  186.         // - soggetto referente
  187.         // - soggetti partecipanti
  188.         if(this.soggettiCore.isRegistroServiziLocale() &&
  189.              (!this.oldnomeprov.equals(this.nomeprov) || !this.oldtipoprov.equals(this.tipoprov)) 
  190.              ){

  192.             // - Soggetto referente
  193.             FiltroRicercaAccordi filtroRicercaAccordi = new FiltroRicercaAccordi();
  194.             filtroRicercaAccordi.setTipoSoggettoReferente(this.oldtipoprov);
  195.             filtroRicercaAccordi.setNomeSoggettoReferente(this.oldnomeprov);
  196.             List<IDAccordoCooperazione> idAccordiCooperazione = null;
  197.             try{
  198.                 idAccordiCooperazione = this.acCore.getAllIdAccordiCooperazione(filtroRicercaAccordi);
  199.             }catch(DriverRegistroServiziNotFound dNot){
  200.                 // ignore
  201.             }
  202.             if(idAccordiCooperazione!=null){
  203.                 for(int i=0; i<idAccordiCooperazione.size(); i++){
  204.                     AccordoCooperazione ac = this.acCore.getAccordoCooperazione(idAccordiCooperazione.get(i));
  205.                     ac.getSoggettoReferente().setTipo(this.tipoprov);
  206.                     ac.getSoggettoReferente().setNome(this.nomeprov);

  208.                     // Check se come soggetto partecipante c'e' il soggetto stesso
  209.                     if(ac.getElencoPartecipanti()!=null){
  210.                         AccordoCooperazionePartecipanti partecipanti = ac.getElencoPartecipanti();
  211.                         for(int j=0; j<partecipanti.sizeSoggettoPartecipanteList(); j++){
  212.                             if(partecipanti.getSoggettoPartecipante(j).getTipo().equals(this.oldtipoprov) && 
  213.                                     partecipanti.getSoggettoPartecipante(j).getNome().equals(this.oldnomeprov)){
  214.                                 partecipanti.getSoggettoPartecipante(j).setTipo(this.tipoprov);
  215.                                 partecipanti.getSoggettoPartecipante(j).setNome(this.nomeprov);
  216.                             }
  217.                         }
  218.                     }

  220.                     this.oggettiDaAggiornare.add(ac);
  221.                     /**System.out.println("AC ["+IDAccordoCooperazione.getUriFromAccordo(ac)+"]");*/
  222.                 }
  223.             }


  226.             // - Soggetti Partecipanti
  227.             List<AccordoCooperazione> acs = this.acCore.accordiCoopWithSoggettoPartecipante(new IDSoggetto(this.oldtipoprov,this.oldnomeprov));
  228.             for(int i=0; i<acs.size(); i++){
  229.                 AccordoCooperazione ac = acs.get(i);

  231.                 // check accordi con referente (non effettuo il change 2 volte)
  232.                 boolean find = false;
  233.                 if(idAccordiCooperazione!=null){
  234.                     for(int j=0; j<idAccordiCooperazione.size(); j++){
  235.                         if(this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordiCooperazione.get(j)).equals(this.idAccordoCooperazioneFactory.getUriFromAccordo(ac))){
  236.                             find = true;
  237.                             break;
  238.                         }
  239.                     }
  240.                 }
  241.                 if(!find){
  242.                     if(ac.getElencoPartecipanti()!=null){
  243.                         AccordoCooperazionePartecipanti partecipanti = ac.getElencoPartecipanti();
  244.                         for(int j=0; j<partecipanti.sizeSoggettoPartecipanteList(); j++){
  245.                             if(partecipanti.getSoggettoPartecipante(j).getTipo().equals(this.oldtipoprov) && 
  246.                                     partecipanti.getSoggettoPartecipante(j).getNome().equals(this.oldnomeprov)){
  247.                                 partecipanti.getSoggettoPartecipante(j).setTipo(this.tipoprov);
  248.                                 partecipanti.getSoggettoPartecipante(j).setNome(this.nomeprov);
  249.                             }
  250.                         }
  251.                     }
  252.                     this.oggettiDaAggiornare.add(ac);
  253.                     /**System.out.println("AC PARTECIPANTE ["+IDAccordoCooperazione.getUriFromAccordo(ac)+"]");*/
  254.                 }
  255.             }

  257.         }
  258.     }



  262.     public void checkAccordiServizioParteComune() throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  263.         // Accordi di Servizio
  264.         // Se e' cambiato il tipo o il nome del soggetto devo effettuare la modifica degli accordi di servizio 
  265.         // poiche il cambio si riflette sul soggetto gestore

  267.         if(this.soggettiCore.isRegistroServiziLocale() &&
  268.              (!this.oldnomeprov.equals(this.nomeprov) || !this.oldtipoprov.equals(this.tipoprov)) 
  269.              ){

  271.             /**try{
  272.                 as = core.getAllIdAccordiWithSoggettoReferente(new IDSoggetto(oldtipoprov,oldnomeprov));
  273.             }catch(DriverRegistroServiziNotFound dNotFound){}
  274.             if(as!=null){
  275.                 for(int i=0; i<as.length; i++){
  276.                     as[i].getSoggettoReferente().setTipo(tipoprov);
  277.                     as[i].getSoggettoReferente().setNome(nomeprov);
  278.                     oggettiDaAggiornare.add(as[i]);
  279.                 }
  280.             }*/

  282.             FiltroRicercaAccordi filtroRicercaAccordi = new FiltroRicercaAccordi();
  283.             filtroRicercaAccordi.setTipoSoggettoReferente(this.oldtipoprov);
  284.             filtroRicercaAccordi.setNomeSoggettoReferente(this.oldnomeprov);
  285.             List<IDAccordo> idAccordoServizio = null;
  286.             try{
  287.                 idAccordoServizio = this.apcCore.getAllIdAccordiServizio(filtroRicercaAccordi);
  288.             }catch(DriverRegistroServiziNotFound dNot){
  289.                 // ignore
  290.             }
  291.             if(idAccordoServizio!=null){
  292.                 for(int i=0; i<idAccordoServizio.size(); i++){
  293.                     AccordoServizioParteComune as = this.apcCore.getAccordoServizioFull(idAccordoServizio.get(i));
  294.                     as.getSoggettoReferente().setTipo(this.tipoprov);
  295.                     as.getSoggettoReferente().setNome(this.nomeprov);
  296.                     IDAccordo idAccordoOLD = this.idAccordoFactory.getIDAccordoFromValues(as.getNome(), this.oldtipoprov, this.oldnomeprov, as.getVersione());
  297.                     as.setOldIDAccordoForUpdate(idAccordoOLD);
  298.                     this.oggettiDaAggiornare.add(as);
  299.                     /**System.out.println("AS ["+IDAccordo.getUriFromAccordo(as)+"]");*/
  300.                 }
  301.             }


  304.             // - soggetti erogatore di servizi componenti
  305.             List<AccordoServizioParteComune> ass = this.apcCore.accordiServizioServiziComponentiConSoggettoErogatore(new IDSoggetto(this.oldtipoprov,this.oldnomeprov));
  306.             for(int i=0; i<ass.size(); i++){
  307.                 AccordoServizioParteComune as = ass.get(i);
  308.                 // check accordi con referente (non effettuo il change 2 volte)
  309.                 boolean find = false;
  310.                 if(idAccordoServizio!=null){
  311.                     for(int j=0; j<idAccordoServizio.size(); j++){
  312.                         if(this.idAccordoFactory.getUriFromIDAccordo(idAccordoServizio.get(j)).equals(IDAccordoFactory.getInstance().getUriFromAccordo(as))){
  313.                             find = true;
  314.                             break;
  315.                         }
  316.                     }
  317.                 }
  318.                 if(!find &&
  319.                     as.getServizioComposto()!=null){
  320.                     for(int j=0;j<as.getServizioComposto().sizeServizioComponenteList();j++){
  321.                         if(as.getServizioComposto().getServizioComponente(j).getTipoSoggetto().equals(this.oldtipoprov) &&
  322.                                 as.getServizioComposto().getServizioComponente(j).getNomeSoggetto().equals(this.oldnomeprov)){
  323.                             as.getServizioComposto().getServizioComponente(j).setTipoSoggetto(this.tipoprov);
  324.                             as.getServizioComposto().getServizioComponente(j).setNomeSoggetto(this.nomeprov);
  325.                         }
  326.                     }
  327.                     // Devo anche controllare che non sia cambiato il soggetto referente di questo as.
  328.                     if(as.getSoggettoReferente()!=null &&
  329.                         this.oldtipoprov.equals(as.getSoggettoReferente().getTipo()) &&
  330.                                 this.oldnomeprov.equals(as.getSoggettoReferente().getNome())){
  331.                         as.getSoggettoReferente().setTipo(this.tipoprov);
  332.                         as.getSoggettoReferente().setNome(this.nomeprov);
  333.                         IDAccordo idAccordoOLD = IDAccordoFactory.getInstance().getIDAccordoFromValues(as.getNome(), this.oldtipoprov, this.oldnomeprov, as.getVersione());
  334.                         as.setOldIDAccordoForUpdate(idAccordoOLD);
  335.                     }
  336.                     this.oggettiDaAggiornare.add(as);
  337.                     /**System.out.println("As SERVIZIO COMPONENTE ["+IDAccordo.getUriFromAccordo(as)+"]");*/
  338.                 }
  339.             }

  341.         }

  343.     }

  345.     private List<AccordoServizioParteSpecifica> accordiServizioParteSpecifica = null;
  346.     public void checkAccordiServizioParteSpecifica() throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  347.         // SERVIZI
  348.         // Se e' cambiato il tipo o il nome del soggetto devo effettuare la modifica dei servizi 
  349.         // poiche il cambio si riflette sul nome dei connettori del servizio 
  350.         this.accordiServizioParteSpecifica = new ArrayList<>();
  351.         if (!this.oldnomeprov.equals(this.nomeprov) || !this.oldtipoprov.equals(this.tipoprov)) {
  352.             FiltroRicercaServizi filtroRicercaServizi = new FiltroRicercaServizi();
  353.             filtroRicercaServizi.setTipoSoggettoErogatore(this.oldtipoprov);
  354.             filtroRicercaServizi.setNomeSoggettoErogatore(this.oldnomeprov);
  355.             List<IDServizio> idServizio = null;
  356.             try{
  357.                 idServizio = this.apsCore.getAllIdServizi(filtroRicercaServizi);
  358.             }catch(DriverRegistroServiziNotFound dNot){
  359.                 // ignore
  360.             }
  361.             if(idServizio!=null){
  362.                 for(int i=0; i<idServizio.size(); i++){
  363.                     AccordoServizioParteSpecifica asps = this.apsCore.getServizio(idServizio.get(i));
  364.                     asps.setTipoSoggettoErogatore(this.tipoprov);
  365.                     asps.setNomeSoggettoErogatore(this.nomeprov);
  366.                     IDServizio oldIDServizioForUpdate = IDServizioFactory.getInstance().getIDServizioFromValues(asps.getTipo(), asps.getNome(), 
  367.                             new IDSoggetto(this.oldtipoprov, this.oldnomeprov), 
  368.                             asps.getVersione());
  369.                     asps.setOldIDServizioForUpdate(oldIDServizioForUpdate);

  371.                     // Check accordo di Servizio
  372.                     IDAccordo idAccordo = this.idAccordoFactory.getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  373.                     if(idAccordo.getSoggettoReferente()!=null && 
  374.                             idAccordo.getSoggettoReferente().getTipo().equals(this.oldtipoprov) &&
  375.                             idAccordo.getSoggettoReferente().getNome().equals(this.oldnomeprov)){
  376.                         idAccordo.getSoggettoReferente().setTipo(this.tipoprov);
  377.                         idAccordo.getSoggettoReferente().setNome(this.nomeprov);
  378.                         asps.setAccordoServizioParteComune(this.idAccordoFactory.getUriFromIDAccordo(idAccordo));
  379.                     }

  381.                     // Fruitori
  382.                     for(int j=0; j<asps.sizeFruitoreList(); j++){
  383.                         if(asps.getFruitore(j).getTipo().equals(this.oldtipoprov) && 
  384.                                 asps.getFruitore(j).getNome().equals(this.oldnomeprov)){
  385.                             asps.getFruitore(j).setTipo(this.tipoprov);
  386.                             asps.getFruitore(j).setNome(this.nomeprov);
  387.                         }
  388.                     }

  390.                     if(this.soggettiCore.isRegistroServiziLocale()){
  391.                         this.oggettiDaAggiornare.add(asps);
  392.                     }
  393.                     this.accordiServizioParteSpecifica.add(asps);
  394.                 }
  395.             }
  396.         }
  397.     }


  400.     public void checkPorteDelegate() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  401.         // Porte Delegate
  402.         // Se e' cambiato il tipo o il nome del soggetto devo effettuare la modifica delle porte delegate
  403.         // poiche il cambio si riflette sul nome della porta delegata
  404.         Map<Long, PortaDelegata> listaPD = new HashMap<>();
  405.         
  406.         if (!this.oldnomeprov.equals(this.nomeprov) || !this.oldtipoprov.equals(this.tipoprov)) {

  408.             // ** Verifica per soggetto proprietario o soggetto erogatore ** // 
  409.             
  410.             // Vanno modificate tutte le Porte Delegate (appartenenti al soggetto modificato oppure che possiedono come soggetto erogatore il soggetto modificato) 
  411.             // che presentano la seguente situazione:
  412.             // - pattern (fruitore)/(erogatore)/....
  413.             //   se (fruitore) contiene tipoNomeSoggetto proprietario della PortaDelegata deve essere modificato
  414.             //   se (erogatore) contiene tipoNomeSoggetto erogatore definito all'interno della porta delegata deve essere modificato.
  415.             List<PortaDelegata> list = new ArrayList<>();
  416.             
  417.             FiltroRicercaPorteDelegate filtroRicerca = new FiltroRicercaPorteDelegate();
  418.             filtroRicerca.setTipoSoggetto(this.oldtipoprov);
  419.             filtroRicerca.setNomeSoggetto(this.oldnomeprov);
  420.             List<IDPortaDelegata> listID = this.porteDelegateCore.getAllIdPorteDelegate(filtroRicerca);
  421.             if(listID!=null && !listID.isEmpty()){
  422.                 for (IDPortaDelegata idPortaDelegata : listID) {
  423.                     list.add(this.porteDelegateCore.getPortaDelegata(idPortaDelegata));
  424.                 }
  425.             }
  426.             filtroRicerca = new FiltroRicercaPorteDelegate();
  427.             filtroRicerca.setTipoSoggettoErogatore(this.oldtipoprov);
  428.             filtroRicerca.setNomeSoggettoErogatore(this.oldnomeprov);
  429.             listID = this.porteDelegateCore.getAllIdPorteDelegate(filtroRicerca);
  430.             if(listID!=null && !listID.isEmpty()){
  431.                 for (IDPortaDelegata idPortaDelegata : listID) {
  432.                     list.add(this.porteDelegateCore.getPortaDelegata(idPortaDelegata));
  433.                 }
  434.             }
  435.             
  436.             if(list!=null && !list.isEmpty()){
  437.                 List<String> checkUnique = new ArrayList<>();
  438.                 for (PortaDelegata portaDelegata : list) {
  439.                     
  440.                     if(checkUnique.contains((portaDelegata.getId().longValue()+""))){
  441.                         continue;
  442.                     }
  443.                     
  444.                     boolean modificatoNome = true;
  445.                     
  446.                     boolean soggettoProprietarioCombaciaSoggettoInModifica = false;
  447.                     String tipoNomeSoggettoFruitore = portaDelegata.getTipoSoggettoProprietario()+"_"+portaDelegata.getNomeSoggettoProprietario();
  448.                     if(tipoNomeSoggettoFruitore.equals(this.oldtipoprov+"_"+this.oldnomeprov)){
  449.                         soggettoProprietarioCombaciaSoggettoInModifica = true;
  450.                         
  451.                         portaDelegata.setTipoSoggettoProprietario(this.tipoprov);
  452.                         portaDelegata.setNomeSoggettoProprietario(this.nomeprov);
  453.                     }
  454.                     
  455.                     String nomeAttuale = portaDelegata.getNome();
  456.                     String regex = REGEXP_FRUITORE_EROGATORE_OTHER;
  457.                     // pattern (fruitore)/(erogatore)/....
  458.                     if(nomeAttuale.matches(regex)){
  459.                         String[] tmp = nomeAttuale.split("\\/");
  460.                         String partFruitore = tmp[0];
  461.                         String partErogatore = tmp[1];
  462.                         String rimanente = "";
  463.                         int lengthParteRimanente = (partFruitore+"/"+partErogatore).length();
  464.                         if(nomeAttuale.length()>lengthParteRimanente){
  465.                             rimanente = nomeAttuale.substring(lengthParteRimanente);
  466.                         }                           
  467.                         
  468.                         // se (fruitore) contiene tipoNomeSoggetto proprietario della PortaDelegata deve essere modificato
  469.                         if(tipoNomeSoggettoFruitore.equals(partFruitore)){
  470.                             if(tipoNomeSoggettoFruitore.equals(this.oldtipoprov + "_" + this.oldnomeprov)){
  471.                                 partFruitore = this.tipoprov + "_" + this.nomeprov;
  472.                                 modificatoNome = true;
  473.                             }
  474.                         }
  475.                         else if(("__"+tipoNomeSoggettoFruitore).equals(partFruitore) &&
  476.                             (tipoNomeSoggettoFruitore).equals(this.oldtipoprov + "_" + this.oldnomeprov)){
  477.                             partFruitore = "__"+this.tipoprov + "_" + this.nomeprov;
  478.                             modificatoNome = true;
  479.                         }
  480.                         
  481.                         // se (erogatore) contiene tipoNomeSoggetto erogatore della PortaDelegata deve essere modificato
  482.                         if(portaDelegata.getSoggettoErogatore()!=null && 
  483.                                 portaDelegata.getSoggettoErogatore().getTipo()!=null && !"".equals(portaDelegata.getSoggettoErogatore().getTipo()) &&
  484.                                 portaDelegata.getSoggettoErogatore().getNome()!=null && !"".equals(portaDelegata.getSoggettoErogatore().getNome())){
  485.                             String tipoNomeSoggettoErogatore = portaDelegata.getSoggettoErogatore().getTipo()+"_"+portaDelegata.getSoggettoErogatore().getNome();
  486.                             if(tipoNomeSoggettoErogatore.equals(partErogatore) &&
  487.                                 tipoNomeSoggettoErogatore.equals(this.oldtipoprov + "_" + this.oldnomeprov)){
  488.                                 partErogatore = this.tipoprov + "_" + this.nomeprov;
  489.                                 portaDelegata.getSoggettoErogatore().setTipo(this.tipoprov);
  490.                                 portaDelegata.getSoggettoErogatore().setNome(this.nomeprov);
  491.                                 modificatoNome = true;
  492.                             }
  493.                         }
  494.                         
  495.                         if(modificatoNome){
  496.                             String nuovoNome = partFruitore + "/" + partErogatore + rimanente;
  497.                             IDPortaDelegata oldIDPortaDelegataForUpdate = new IDPortaDelegata();
  498.                             oldIDPortaDelegataForUpdate.setNome(nomeAttuale);
  499.                             portaDelegata.setOldIDPortaDelegataForUpdate(oldIDPortaDelegataForUpdate);
  500.                             portaDelegata.setNome(nuovoNome);
  501.                             
  502.                             // modifica della descrizione
  503.                             String descrizionePD = portaDelegata.getDescrizione();
  504.                             if (descrizionePD != null && !descrizionePD.equals("")) {

  506.                                 // Caso 1: subscription default
  507.                                 // Subscription from gw/ENTE for service gw/ErogatoreEsterno:gw/EsempioREST:1
  508.                                 String matchCaso1testFrom = " "+this.oldtipoprov+"/"+this.oldnomeprov+" ";
  509.                                 if(descrizionePD.contains(matchCaso1testFrom)) {
  510.                                     String replaceCaso1testFrom = " "+this.tipoprov+"/"+this.nomeprov+" ";
  511.                                     descrizionePD = descrizionePD.replace(matchCaso1testFrom, replaceCaso1testFrom);
  512.                                 }
  513.                                 String matchCaso1testService = " "+this.oldtipoprov+"/"+this.oldnomeprov+":";
  514.                                 if(descrizionePD.contains(matchCaso1testService)) {
  515.                                     String replaceCaso1testService = " "+this.tipoprov+"/"+this.nomeprov+":";
  516.                                     descrizionePD = descrizionePD.replace(matchCaso1testService, replaceCaso1testService);
  517.                                 }
  518.                             
  519.                                 // Caso 2: altra subscription
  520.                                 // Internal Subscription 'Specific1' for gw_ENTE/gw_ErogatoreEsterno/gw_EsempioREST/1
  521.                                 String matchCaso2testMittente = " "+this.oldtipoprov+"_"+this.oldnomeprov+"/";
  522.                                 if(descrizionePD.contains(matchCaso2testMittente)) {
  523.                                     String replaceCaso2testMittente = " "+this.tipoprov+"_"+this.nomeprov+"/";
  524.                                     descrizionePD = descrizionePD.replace(matchCaso2testMittente, replaceCaso2testMittente);
  525.                                 }
  526.                                 String matchCaso2testErogatore = "/"+this.oldtipoprov+"_"+this.oldnomeprov+"/";
  527.                                 if(descrizionePD.contains(matchCaso2testErogatore)) {
  528.                                     String replaceCaso2testErogatore = "/"+this.tipoprov+"_"+this.nomeprov+"/";
  529.                                     descrizionePD = descrizionePD.replace(matchCaso2testErogatore, replaceCaso2testErogatore);
  530.                                 }
  531.                                 
  532.                                 portaDelegata.setDescrizione(descrizionePD);

  534.                             }
  535.                             
  536.                             // regex del pattern azione
  537.                             // OLD: .*/(fruitore)/(erogatore)/(servizio)/([^/|^?]*).*
  538.                             // NEW 3.3.13: /(fruitore)/(erogatore)/(servizio)/([^/?]*).*
  539.                             PortaDelegataAzione pdAzione = portaDelegata.getAzione();
  540.                             PortaDelegataAzioneIdentificazione identificazione = pdAzione != null ? pdAzione.getIdentificazione() : null;
  541.                             String patterAzione = "";
  542.                             if(pdAzione!=null) {
  543.                                 patterAzione = pdAzione.getPattern() != null ? pdAzione.getPattern() : "";
  544.                             }
  545.                             String patternAzionePrefixOld = PATTERN_AZIONE_PREFIX_OLD;
  546.                             String patternAzioneSuffix1Old = PATTERN_AZIONE_SUFFIX_OLD;
  547.                             String patternAzionePrefixNew = PATTERN_AZIONE_PREFIX_NEW;
  548.                             String patternAzioneSuffix1New = PATTERN_AZIONE_SUFFIX_NEW;
  549.                             // se identificazione urlbased procedo con i controlli
  550.                             if (PortaDelegataAzioneIdentificazione.URL_BASED.equals(identificazione)) {
  551.                                 
  552.                                 boolean oldPattern = patterAzione.startsWith(patternAzionePrefixOld) && patterAzione.endsWith(patternAzioneSuffix1Old);
  553.                                 boolean newPattern = patterAzione.startsWith(patternAzionePrefixNew) && patterAzione.endsWith(patternAzioneSuffix1New);
  554.                                 
  555.                                 if(oldPattern || newPattern) {
  556.                                 
  557.                                     // caso1
  558.                                     int startidx = oldPattern ? patternAzionePrefixOld.length() : patternAzionePrefixNew.length();
  559.                                     int endidx = oldPattern ? patterAzione.lastIndexOf(patternAzioneSuffix1Old) : patterAzione.lastIndexOf(patternAzioneSuffix1New);
  560.                                     String tmpPat = patterAzione.substring(startidx, endidx);
  561.                                     // a questo punto ottengo una stringa del tipo
  562.                                     // (fruitore)/(erogatore)/(servizio)
  563.                                     // se rispetta la regex allora vuol dire che il
  564.                                     // pattern azione e' quello di default
  565.                                     // e devo effettuare i cambiamenti
  566.                                     if (tmpPat.matches(regex)) {
  567.                                         String[] val = tmpPat.split("/");
  568.                                         String fruitore = val[0];
  569.                                         String erogatore = val[1];
  570.                                         String rimanenteRegExp = "";
  571.                                         int lengthParteRimanenteRegExp = (fruitore+"/"+erogatore).length();
  572.                                         if(tmpPat.length()>lengthParteRimanenteRegExp){
  573.                                             rimanenteRegExp = tmpPat.substring(lengthParteRimanenteRegExp);
  574.                                         }   

  576.                                         boolean match = false;
  577.                                         String partOld = "(?:"+this.oldtipoprov+"_)?"+this.oldnomeprov+"";
  578.                                         String partNew = "(?:"+this.tipoprov+"_)?"+this.nomeprov+"";
  579.                                         
  580.                                         // vedo se matcha il fruitore
  581.                                         if (fruitore.equals(partOld)) {
  582.                                             fruitore = partNew;
  583.                                             match = true;
  584.                                         }
  585.                                         
  586.                                         // vedo se matcha anche erogatore (loopback)
  587.                                         if (erogatore.equals(partOld)) {
  588.                                             erogatore = partNew;
  589.                                             match = true;
  590.                                         }

  592.                                         if(match){
  593.                                             String newPatternAzione = patternAzionePrefixNew + fruitore + "/" + erogatore + rimanenteRegExp + patternAzioneSuffix1New;
  594.                                             pdAzione.setPattern(newPatternAzione);
  595.                                             portaDelegata.setAzione(pdAzione);
  596.                                         }
  597.                                     }
  598.                                 }
  599.                             }// fine controllo azione
  600.     
  601.                             // DelegatedBy
  602.                             String nomePortaDelegante = null;
  603.                             if(pdAzione!=null) {
  604.                                 nomePortaDelegante = pdAzione.getNomePortaDelegante() != null ? pdAzione.getNomePortaDelegante() : null;
  605.                             }
  606.                             if (PortaDelegataAzioneIdentificazione.DELEGATED_BY.equals(identificazione) && nomePortaDelegante!=null ) {
  607.                                 String regexDelegante = REGEXP_FRUITORE_EROGATORE_OTHER;
  608.                                 // pattern (fruitore)/(erogatore)/....
  609.                                 if(nomePortaDelegante.matches(regexDelegante)){
  610.                                     String[] tmpDelegante = nomePortaDelegante.split("\\/");
  611.                                     String partFruitoreDelegante = tmpDelegante[0];
  612.                                     String partErogatoreDelegante = tmpDelegante[1];
  613.                                     String rimanenteDelegante = "";
  614.                                     int lengthParteRimanenteDelegante = (partFruitoreDelegante+"/"+partErogatoreDelegante).length();
  615.                                     if(nomePortaDelegante.length()>lengthParteRimanenteDelegante){
  616.                                         rimanenteDelegante = nomePortaDelegante.substring(lengthParteRimanenteDelegante);
  617.                                     }                           
  618.                                     boolean modificatoNomeDelegante = false;
  619.                                     
  620.                                     // se (fruitore) contiene tipoNomeSoggetto proprietario della PortaDelegata deve essere modificato
  621.                                     if(tipoNomeSoggettoFruitore.equals(partFruitoreDelegante)){
  622.                                         if(tipoNomeSoggettoFruitore.equals(this.oldtipoprov + "_" + this.oldnomeprov)){
  623.                                             partFruitoreDelegante = this.tipoprov + "_" + this.nomeprov;
  624.                                             modificatoNomeDelegante = true;
  625.                                         }
  626.                                     }
  627.                                     else if(("__"+tipoNomeSoggettoFruitore).equals(partFruitoreDelegante) &&
  628.                                         (tipoNomeSoggettoFruitore).equals(this.oldtipoprov + "_" + this.oldnomeprov)){
  629.                                         partFruitoreDelegante = "__"+this.tipoprov + "_" + this.nomeprov;
  630.                                         modificatoNomeDelegante = true;
  631.                                     }
  632.                                     
  633.                                     // se (erogatore) contiene tipoNomeSoggetto erogatore della PortaDelegata deve essere modificato
  634.                                     if(partErogatoreDelegante!=null && partErogatoreDelegante.equals(this.oldtipoprov + "_" + this.oldnomeprov)){
  635.                                         partErogatoreDelegante = this.tipoprov + "_" + this.nomeprov;
  636.                                         modificatoNomeDelegante = true;
  637.                                     }
  638.                                     
  639.                                     if(modificatoNomeDelegante){
  640.                                         String nuovoNomeDelegante = partFruitoreDelegante + "/" + partErogatoreDelegante + rimanenteDelegante;
  641.                                         portaDelegata.getAzione().setNomePortaDelegante(nuovoNomeDelegante);
  642.                                     }
  643.                                 }
  644.                             }// fine controllo DelegatedBy
  645.                         }
  646.                     }
  647.                     
  648.                     // inserisco la porta
  649.                     if(soggettoProprietarioCombaciaSoggettoInModifica || modificatoNome){
  650.                         listaPD.put(portaDelegata.getId(), portaDelegata);
  651.                         checkUnique.add((portaDelegata.getId().longValue()+""));
  652.                     }
  653.                 }
  654.             }
  655.             
  656.             // ** Verifica per soggetto proprietario o soggetto erogatore ** // 


  659.             // PORTE DELEGATE
  660.             // Modifica servizio
  661.             // per ogni servizio da modificare devo effettuare le modifiche
  662.             // alle porte delegate
  663.             for (int j=0; j<this.accordiServizioParteSpecifica.size(); j++) {

  665.                 AccordoServizioParteSpecifica asps = this.accordiServizioParteSpecifica.get(j);

  667.                 List<PortaDelegata> tmpListPD = null;
  668.                 // modifico le porte delegate interessate dal cambiamento
  669.                 // del nome del soggetto
  670.                 // recupero lo porte delegate per location
  671.                 // e aggiorno il nome e la location
  672.                 String locationPrefix = "";
  673.                 String locationSuffix = "/" + this.oldtipoprov +"_" + this.oldnomeprov + "/" + asps.getTipo()+"_" +asps.getNome() + "/v" + asps.getVersione().intValue();
  674.                 for (Fruitore fruitore : asps.getFruitoreList()) {
  675.                     locationPrefix = fruitore.getTipo()+"_" + fruitore.getNome();
  676.                     String location = locationPrefix + locationSuffix;
  677.                     IDPortaDelegata idPD = new IDPortaDelegata();
  678.                     idPD.setNome(location);
  679.                     
  680.                     PortaDelegata portaDelegata = null;
  681.                     try {
  682.                         portaDelegata = this.porteDelegateCore.getPortaDelegata(idPD);
  683.                     }catch(DriverConfigurazioneNotFound notFound) {
  684.                         // ignore
  685.                     }
  686.                     if(portaDelegata==null) {
  687.                         try {
  688.                             // backward compatibility: provare ad eliminare la v, che prima non veniva utilizzata
  689.                             String oldLocationSuffix = "/" + this.oldtipoprov +"_" + this.oldnomeprov + "/" + asps.getTipo()+"_" +asps.getNome() + "/" + asps.getVersione().intValue();
  690.                             String oldLocation = locationPrefix + oldLocationSuffix;
  691.                             idPD.setNome(oldLocation);
  692.                             portaDelegata = this.porteDelegateCore.getPortaDelegata(idPD);
  693.                         }catch(DriverConfigurazioneNotFound notFound) {
  694.                             // ignore
  695.                         }
  696.                     }
  697.                     if(portaDelegata!=null){

  699.                         // Per tutte le porte delegate che rispettano la
  700.                         // location cambio la vecchia location e inoltre
  701.                         // controllo pure il pattern azione

  703.                         Long idPorta = portaDelegata.getId();

  705.                         // se la porta delegata e' gia stata inserita
  706.                         // nella lista per modifiche
  707.                         // allora prendo quella ed effettuo ulteriori
  708.                         // modifiche
  709.                         if (listaPD.containsKey(idPorta)) {
  710.                             portaDelegata = listaPD.get(idPorta);
  711.                         }
  712.                         // new locationSuffix
  713.                         String newLocationSuffix = "/" + this.tipoprov+"_" +this.nomeprov + "/" + asps.getTipo()+"_" +asps.getNome() + "/v" + asps.getVersione().intValue();
  714.                         String newLocationPrefix = null;
  715.                         if(fruitore.getTipo().equals(this.oldtipoprov) && fruitore.getNome().equals(this.oldnomeprov)){
  716.                             newLocationPrefix = this.tipoprov+ "_" +this.nomeprov;
  717.                         }
  718.                         else{
  719.                             newLocationPrefix = fruitore.getTipo()+ "_" +fruitore.getNome();
  720.                         }
  721.                         String newLocation = newLocationPrefix + newLocationSuffix;

  723.                         if(portaDelegata.getOldIDPortaDelegataForUpdate()==null){
  724.                             // Il vecchio nome e' gia essere stato messo prima nella passata sopra.
  725.                             IDPortaDelegata oldIDPortaDelegataForUpdate = new IDPortaDelegata();
  726.                             oldIDPortaDelegataForUpdate.setNome(portaDelegata.getNome());
  727.                             portaDelegata.setOldIDPortaDelegataForUpdate(oldIDPortaDelegataForUpdate);
  728.                         }
  729.                         portaDelegata.setNome(newLocation);
  730.                         // aggiorno la descrizione della porta
  731.                         String descrizionePD = portaDelegata.getDescrizione();
  732.                         if (descrizionePD != null && !descrizionePD.equals("")) {
  733.                             
  734.                             // Caso 1: subscription default
  735.                             // Subscription from gw/ENTE for service gw/ErogatoreEsterno:gw/EsempioREST:1
  736.                             String matchCaso1testFrom = " "+this.oldtipoprov+"/"+this.oldnomeprov+" ";
  737.                             if(descrizionePD.contains(matchCaso1testFrom)) {
  738.                                 String replaceCaso1testFrom = " "+this.tipoprov+"/"+this.nomeprov+" ";
  739.                                 descrizionePD = descrizionePD.replace(matchCaso1testFrom, replaceCaso1testFrom);
  740.                             }
  741.                             String matchCaso1testService = " "+this.oldtipoprov+"/"+this.oldnomeprov+":";
  742.                             if(descrizionePD.contains(matchCaso1testService)) {
  743.                                 String replaceCaso1testService = " "+this.tipoprov+"/"+this.nomeprov+":";
  744.                                 descrizionePD = descrizionePD.replace(matchCaso1testService, replaceCaso1testService);
  745.                             }
  746.                         
  747.                             // Caso 2: altra subscription
  748.                             // Internal Subscription 'Specific1' for gw_ENTE/gw_ErogatoreEsterno/gw_EsempioREST/1
  749.                             String matchCaso2testMittente = " "+this.oldtipoprov+"_"+this.oldnomeprov+"/";
  750.                             if(descrizionePD.contains(matchCaso2testMittente)) {
  751.                                 String replaceCaso2testMittente = " "+this.tipoprov+"_"+this.nomeprov+"/";
  752.                                 descrizionePD = descrizionePD.replace(matchCaso2testMittente, replaceCaso2testMittente);
  753.                             }
  754.                             String matchCaso2testErogatore = "/"+this.oldtipoprov+"_"+this.oldnomeprov+"/";
  755.                             if(descrizionePD.contains(matchCaso2testErogatore)) {
  756.                                 String replaceCaso2testErogatore = "/"+this.tipoprov+"_"+this.nomeprov+"/";
  757.                                 descrizionePD = descrizionePD.replace(matchCaso2testErogatore, replaceCaso2testErogatore);
  758.                             }
  759.                             
  760.                             portaDelegata.setDescrizione(descrizionePD);
  761.                         }
  762.                         // aggiorno anche il soggetto
  763.                         PortaDelegataSoggettoErogatore sogErogatore = portaDelegata.getSoggettoErogatore();
  764.                         sogErogatore.setTipo(this.sog.getTipo());
  765.                         sogErogatore.setNome(this.sog.getNome());
  766.                         portaDelegata.setSoggettoErogatore(sogErogatore);


  769.                         // CONTROLLO PATTERN AZIONE inoltre va
  770.                         // controllato anche il pattern dell'azione in
  771.                         // caso il pattern azione fosse URLBASED e fosse
  772.                         // quello di default allora va cambiato

  774.                         String regex = REGEXP_FRUITORE_EROGATORE_OTHER_MATCH;
  775.                         PortaDelegataAzione pdAzione = portaDelegata.getAzione();
  776.                         PortaDelegataAzioneIdentificazione identificazione = pdAzione != null ? pdAzione.getIdentificazione() : null;
  777.                         String patterAzione = "";
  778.                         if(pdAzione!=null) {
  779.                             patterAzione = pdAzione.getPattern() != null ? pdAzione.getPattern() : "";
  780.                         }
  781.                         
  782.                         // regex del pattern azione
  783.                         // OLD: .*/(fruitore)/(erogatore)/(servizio)/([^/|^?]*).*
  784.                         // NEW 3.3.13: /(fruitore)/(erogatore)/(servizio)/([^/?]*).*
  785.                         String patternAzionePrefixOld = PATTERN_AZIONE_PREFIX_OLD;
  786.                         String patternAzioneSuffixOld = PATTERN_AZIONE_SUFFIX_OLD;
  787.                         String patternAzionePrefixNew = PATTERN_AZIONE_PREFIX_NEW;
  788.                         String patternAzioneSuffixNew = PATTERN_AZIONE_SUFFIX_NEW;
  789.                         // se identificazione urlbased procedo con i
  790.                         // controlli
  791.                         if (PortaDelegataAzioneIdentificazione.URL_BASED.equals(identificazione)) {
  792.                             
  793.                             boolean oldPattern = patterAzione.startsWith(patternAzionePrefixOld) && patterAzione.endsWith(patternAzioneSuffixOld);
  794.                             boolean newPattern = patterAzione.startsWith(patternAzionePrefixNew) && patterAzione.endsWith(patternAzioneSuffixNew);
  795.                             
  796.                             if(oldPattern || newPattern) {
  797.                             
  798.                                 int startidx = oldPattern ? patternAzionePrefixOld.length() : patternAzionePrefixNew.length();
  799.                                 int endidx = oldPattern ? patterAzione.lastIndexOf(patternAzioneSuffixOld) : patterAzione.lastIndexOf(patternAzioneSuffixNew);
  800.                                 String tmpPat = patterAzione.substring(startidx, endidx);
  801.                                 // a questo punto ottengo una stringa del tipo
  802.                                 // (fruitore)/(erogatore)/(servizio)
  803.                                 // se rispetta la regex allora vuol dire che il
  804.                                 // pattern azione e' quello di default
  805.                                 // e devo effettuare i cambiamenti
  806.                                 if (tmpPat.matches(regex)) {
  807.                                     String[] val = tmpPat.split("/");
  808.                                     String fruitoreA = val[0];
  809.                                     String erogatore = val[1];
  810.                                     String rimanenteRegExp = "";
  811.                                     int lengthParteRimanenteRegExp = (fruitoreA+"/"+erogatore).length();
  812.                                     if(tmpPat.length()>lengthParteRimanenteRegExp){
  813.                                         rimanenteRegExp = tmpPat.substring(lengthParteRimanenteRegExp);
  814.                                     }   

  816.                                     boolean match = false;
  817.                                     String partOld = "(?:"+this.oldtipoprov+"_)?"+this.oldnomeprov+"";
  818.                                     String partNew = "(?:"+this.tipoprov+"_)?"+this.nomeprov+"";
  819.                                     
  820.                                     // vedo se matcha il fruitore
  821.                                     if (fruitoreA.equals(partOld)) {
  822.                                         fruitoreA = partNew;
  823.                                         match = true;
  824.                                     }
  825.                                     
  826.                                     // vedo se matcha anche erogatore (loopback)
  827.                                     if (erogatore.equals(partOld)) {
  828.                                         erogatore = partNew;
  829.                                         match = true;
  830.                                     }

  832.                                     if(match){
  833.                                         String newPatternAzione = patternAzionePrefixNew + fruitoreA + "/" + erogatore + rimanenteRegExp + patternAzioneSuffixNew;
  834.                                         pdAzione.setPattern(newPatternAzione);
  835.                                         portaDelegata.setAzione(pdAzione);
  836.                                     }
  837.                                 }

  839.                             }
  840.                         }// fine controllo azione
  841.                         
  842.                         // DelegatedBy
  843.                         String nomePortaDelegante = null;
  844.                         if(pdAzione!=null) {
  845.                             nomePortaDelegante = pdAzione.getNomePortaDelegante() != null ? pdAzione.getNomePortaDelegante() : null;
  846.                         }
  847.                         if (PortaDelegataAzioneIdentificazione.DELEGATED_BY.equals(identificazione) && nomePortaDelegante!=null ) {
  848.                             String regexDelegante = REGEXP_FRUITORE_EROGATORE_OTHER;
  849.                             // pattern (fruitore)/(erogatore)/....
  850.                             if(nomePortaDelegante.matches(regexDelegante)){
  851.                                 String[] tmpDelegante = nomePortaDelegante.split("\\/");
  852.                                 String partFruitoreDelegante = tmpDelegante[0];
  853.                                 String partErogatoreDelegante = tmpDelegante[1];
  854.                                 String rimanenteDelegante = "";
  855.                                 int lengthParteRimanenteDelegante = (partFruitoreDelegante+"/"+partErogatoreDelegante).length();
  856.                                 if(nomePortaDelegante.length()>lengthParteRimanenteDelegante){
  857.                                     rimanenteDelegante = nomePortaDelegante.substring(lengthParteRimanenteDelegante);
  858.                                 }                           
  859.                                 boolean modificatoNomeDelegante = false;
  860.                                 
  861.                                 // se (fruitore) contiene tipoNomeSoggetto proprietario della PortaDelegata deve essere modificato
  862.                                 if((this.oldtipoprov + "_" + this.oldnomeprov).equals(partFruitoreDelegante)){
  863.                                     partFruitoreDelegante = this.tipoprov + "_" + this.nomeprov;
  864.                                     modificatoNomeDelegante = true;
  865.                                 }
  866.                                 else if(("__"+(this.oldtipoprov + "_" + this.oldnomeprov)).equals(partFruitoreDelegante)){
  867.                                     partFruitoreDelegante = "__"+this.tipoprov + "_" + this.nomeprov;
  868.                                     modificatoNomeDelegante = true;
  869.                                 }
  870.                                 
  871.                                 // se (erogatore) contiene tipoNomeSoggetto erogatore della PortaDelegata deve essere modificato
  872.                                 if(partErogatoreDelegante!=null && partErogatoreDelegante.equals(this.oldtipoprov + "_" + this.oldnomeprov)){
  873.                                     partErogatoreDelegante = this.tipoprov + "_" + this.nomeprov;
  874.                                     modificatoNomeDelegante = true;
  875.                                 }
  876.                                 
  877.                                 if(modificatoNomeDelegante){
  878.                                     String nuovoNomeDelegante = partFruitoreDelegante + "/" + partErogatoreDelegante + rimanenteDelegante;
  879.                                     portaDelegata.getAzione().setNomePortaDelegante(nuovoNomeDelegante);
  880.                                 }
  881.                             }
  882.                         }// fine controllo DelegatedBy

  884.                         // (ri)aggiungo pd
  885.                         listaPD.put(idPorta, portaDelegata);

  887.                     }// fine foreach pd
  888.                 }// fine foreach fruitore


  891.                 // recupero le porte delegate per id_soggetto_erogatore
  892.                 tmpListPD = this.porteDelegateCore.porteDelegateWithSoggettoErogatoreList(this.sog.getId());
  893.                 if(tmpListPD!=null && !tmpListPD.isEmpty()) {
  894.                     for (PortaDelegata portaDelegata : tmpListPD) {
  895.                         Long idPorta = portaDelegata.getId();
  896.     
  897.                         if (listaPD.containsKey(idPorta)) {
  898.                             // se la porta delegata e' gia stata modificata e
  899.                             // inserita
  900.                             // nella lista, allora prendo la porta inserita in
  901.                             // lista
  902.                             // ed effettuo ulteriori modifiche
  903.                             portaDelegata = listaPD.get(idPorta);
  904.                         }
  905.     
  906.                         // modifico le informazioni sul soggetto erogatore
  907.                         PortaDelegataSoggettoErogatore sogErogatore = portaDelegata.getSoggettoErogatore();
  908.                         sogErogatore.setTipo(this.sog.getTipo());
  909.                         sogErogatore.setNome(this.sog.getNome());
  910.                         portaDelegata.setSoggettoErogatore(sogErogatore);
  911.                         // (re)inserisco la porta nella lista
  912.                         listaPD.put(idPorta, portaDelegata);
  913.     
  914.                     }
  915.                 }

  917.                 // recupero le porte delegate per tipo/nome soggetto erogatore
  918.                 tmpListPD = this.porteDelegateCore.porteDelegateWithTipoNomeErogatoreList(this.sog.getOldTipoForUpdate(), this.sog.getOldNomeForUpdate());
  919.                 if(tmpListPD!=null && !tmpListPD.isEmpty()) {
  920.                     for (PortaDelegata portaDelegata : tmpListPD) {
  921.                         Long idPorta = portaDelegata.getId();
  922.                         if (listaPD.containsKey(idPorta)) {
  923.                             // se la porta delegata e' gia stata modificata e
  924.                             // inserita
  925.                             // nella lista, allora prendo la porta inserita in
  926.                             // lista
  927.                             // ed effettuo ulteriori modifiche
  928.                             portaDelegata = listaPD.get(idPorta);
  929.                         }
  930.                         // modifico informazioni su soggetto erogatore
  931.                         PortaDelegataSoggettoErogatore sogErogatore = portaDelegata.getSoggettoErogatore();
  932.                         sogErogatore.setTipo(this.sog.getTipo());
  933.                         sogErogatore.setNome(this.sog.getNome());
  934.                         portaDelegata.setSoggettoErogatore(sogErogatore);
  935.     
  936.     
  937.                         // inserisco la porta
  938.                         listaPD.put(idPorta, portaDelegata);
  939.     
  940.                     }
  941.                 }

  943.             }// for each servizio



  947.         }// if oldnome || oldtipo changed


  950.         // aggiorno le porte delegate
  951.         
  952.         Map<String, AttivazionePolicy> listaPolicyPD = new HashMap<>();
  953.         Map<String, ConfigurazioneAllarmeBean> listaAllarmiPD = new HashMap<>();
  954.         
  955.         if(listaPD!=null && !listaPD.isEmpty()) {
  956.             for (PortaDelegata portaDelegata : listaPD.values()) {
  957.                 
  958.                 updateSoggettoInlisteEngine(portaDelegata);
  959.                 
  960.                 this.oggettiDaAggiornare.add(portaDelegata);
  961.                 
  962.                 // verifico rate limiting per ogni porta delegata trovata
  963.                 
  964.                 // Controllo policy di Rate Limiting
  965.                 ConsoleSearch ricercaPolicies = new ConsoleSearch(true);
  966.                 List<AttivazionePolicy> listaPolicies = null;
  967.                 String oldNomePorta = portaDelegata.getNome();
  968.                 try {
  969.                     if(portaDelegata.getOldIDPortaDelegataForUpdate()!=null && portaDelegata.getOldIDPortaDelegataForUpdate().getNome()!=null) {
  970.                         oldNomePorta = portaDelegata.getOldIDPortaDelegataForUpdate().getNome();
  971.                     }
  972.                     listaPolicies = this.confCore.attivazionePolicyList(ricercaPolicies, RuoloPolicy.DELEGATA, oldNomePorta);
  973.                 }catch(Exception e) {
  974.                     // ignore
  975.                 }
  976.                 if(listaPolicies!=null && !listaPolicies.isEmpty()) {
  977.                     for (AttivazionePolicy ap : listaPolicies) {
  978.                         if(ap.getFiltro()!=null && oldNomePorta.equals(ap.getFiltro().getNomePorta())) {
  979.                             
  980.                             // aggiorno nome porta
  981.                             ap.getFiltro().setNomePorta(portaDelegata.getNome());
  982.                             
  983.                             updateFiltroSoggettoEngine(ap);
  984.                                                             
  985.                             listaPolicyPD.put(ap.getIdActivePolicy(), ap);
  986.                         }
  987.                     }
  988.                 }
  989.                 // fine Controllo policy di Rate Limiting
  990.                 
  991.                 if(this.confCore.isConfigurazioneAllarmiEnabled()) {
  992.                     // Controllo allarmi
  993.                     ConsoleSearch ricercaAllarmi = new ConsoleSearch(true);
  994.                     List<ConfigurazioneAllarmeBean> listaAllarmi = null;
  995.                     oldNomePorta = portaDelegata.getNome();
  996.                     try {
  997.                         if(portaDelegata.getOldIDPortaDelegataForUpdate()!=null && portaDelegata.getOldIDPortaDelegataForUpdate().getNome()!=null) {
  998.                             oldNomePorta = portaDelegata.getOldIDPortaDelegataForUpdate().getNome();
  999.                         }
  1000.                         listaAllarmi = this.confCore.allarmiList(ricercaAllarmi, RuoloPorta.DELEGATA, oldNomePorta);
  1001.                     }catch(Exception e) {
  1002.                         // ignore
  1003.                     }
  1004.                     if(listaAllarmi!=null && !listaAllarmi.isEmpty()) {
  1005.                         for (ConfigurazioneAllarmeBean allarme : listaAllarmi) {
  1006.                             if(allarme.getFiltro()!=null && oldNomePorta.equals(allarme.getFiltro().getNomePorta())) {
  1007.                                 
  1008.                                 // aggiorno nome porta
  1009.                                 allarme.getFiltro().setNomePorta(portaDelegata.getNome());
  1010.                                 
  1011.                                 updateFiltroSoggettoEngine(allarme);
  1012.                                                                 
  1013.                                 listaAllarmiPD.put(allarme.getNome(), allarme);
  1014.                             }
  1015.                         }
  1016.                     }
  1017.                     // fine Controllo allarmi
  1018.                 }
  1019.                 
  1020.             }
  1021.         }
  1022.         
  1023.         
  1024.         
  1025.         // Controllo policy di Rate Limiting di altre porte delegate che utilizzano il soggetto solamente nel filtro.
  1026.         
  1027.         List<AttivazionePolicy> listPolicyDaVerificare = new ArrayList<>();
  1028.         
  1029.         IDSoggetto filtroSoggettoFruitore = new IDSoggetto(this.oldtipoprov, this.oldnomeprov);
  1030.         ConsoleSearch ricercaPolicies = new ConsoleSearch(true);
  1031.         List<AttivazionePolicy> listaPolicies = null;
  1032.         try {
  1033.             listaPolicies = this.confCore.attivazionePolicyListByFilter(ricercaPolicies, RuoloPolicy.DELEGATA, null,
  1034.                     filtroSoggettoFruitore, null, null,
  1035.                     null, null,
  1036.                     null, null);
  1037.         }catch(Exception e) {
  1038.             // ignore
  1039.         }
  1040.         if(listaPolicies!=null && !listaPolicies.isEmpty()) {
  1041.             for (AttivazionePolicy ap : listaPolicies) {
  1042.                 if(listaPolicyPD.containsKey(ap.getIdActivePolicy())) {
  1043.                     continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1044.                 }
  1045.                 listPolicyDaVerificare.add(ap);
  1046.             }
  1047.         }
  1048.         
  1049.         IDSoggetto filtroSoggettoErogatore = new IDSoggetto(this.oldtipoprov, this.oldnomeprov);
  1050.         ricercaPolicies = new ConsoleSearch(true);
  1051.         listaPolicies = null;
  1052.         try {
  1053.             listaPolicies = this.confCore.attivazionePolicyListByFilter(ricercaPolicies, RuoloPolicy.DELEGATA, null,
  1054.                     null, null, null,
  1055.                     filtroSoggettoErogatore, null,
  1056.                     null, null);
  1057.         }catch(Exception e) {
  1058.             // ignore
  1059.         }
  1060.         if(listaPolicies!=null && !listaPolicies.isEmpty()) {
  1061.             for (AttivazionePolicy ap : listaPolicies) {
  1062.                 if(listaPolicyPD.containsKey(ap.getIdActivePolicy())) {
  1063.                     continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1064.                 }
  1065.                 listPolicyDaVerificare.add(ap);
  1066.             }
  1067.         }
  1068.         
  1069.         if(listPolicyDaVerificare!=null && !listPolicyDaVerificare.isEmpty()) {
  1070.             for (AttivazionePolicy ap : listPolicyDaVerificare) {
  1071.                 
  1072.                 if(listaPolicyPD.containsKey(ap.getIdActivePolicy())) {
  1073.                     continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1074.                 }
  1075.             
  1076.                 if(ap.getFiltro()!=null) {
  1077.                     
  1078.                     updateFiltroSoggettoEngine(ap);
  1079.                                                     
  1080.                     listaPolicyPD.put(ap.getIdActivePolicy(), ap);
  1081.                 }
  1082.             }
  1083.         }
  1084.         // fine Controllo policy di Rate Limiting
  1085.         
  1086.         
  1087.         // aggiorno le policy di rate limiting associate alle porte delegate
  1088.         if(listaPolicyPD!=null && !listaPolicyPD.isEmpty()) {
  1089.             for (AttivazionePolicy ap : listaPolicyPD.values()) {
  1090.                 this.oggettiDaAggiornare.add(ap);
  1091.             }
  1092.         }
  1093.         
  1094.         
  1095.         if(this.confCore.isConfigurazioneAllarmiEnabled()) {
  1096.             
  1097.             // Controllo policy di Rate Limiting di altre porte delegate che utilizzano il soggetto solamente nel filtro.
  1098.             
  1099.             List<ConfigurazioneAllarmeBean> listAllarmiDaVerificare = new ArrayList<>();
  1100.             
  1101.             filtroSoggettoFruitore = new IDSoggetto(this.oldtipoprov, this.oldnomeprov);
  1102.             ConsoleSearch ricercaAllarmi = new ConsoleSearch(true);
  1103.             List<ConfigurazioneAllarmeBean> listaAllarmi = null;
  1104.             try {
  1105.                 listaAllarmi = this.confCore.allarmiListByFilter(ricercaAllarmi, RuoloPorta.DELEGATA, null,
  1106.                         filtroSoggettoFruitore, null, null,
  1107.                         null, null,
  1108.                         null, null);
  1109.             }catch(Exception e) {
  1110.                 // ignore
  1111.             }
  1112.             if(listaAllarmi!=null && !listaAllarmi.isEmpty()) {
  1113.                 for (ConfigurazioneAllarmeBean allarme : listaAllarmi) {
  1114.                     if(listaAllarmiPD.containsKey(allarme.getNome())) {
  1115.                         continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1116.                     }
  1117.                     listAllarmiDaVerificare.add(allarme);
  1118.                 }
  1119.             }
  1120.             
  1121.             filtroSoggettoErogatore = new IDSoggetto(this.oldtipoprov, this.oldnomeprov);
  1122.             ricercaAllarmi = new ConsoleSearch(true);
  1123.             listaAllarmi = null;
  1124.             try {
  1125.                 listaAllarmi = this.confCore.allarmiListByFilter(ricercaAllarmi, RuoloPorta.DELEGATA, null,
  1126.                         null, null, null,
  1127.                         filtroSoggettoErogatore, null,
  1128.                         null, null);
  1129.             }catch(Exception e) {
  1130.                 // ignore
  1131.             }
  1132.             if(listaAllarmi!=null && !listaAllarmi.isEmpty()) {
  1133.                 for (ConfigurazioneAllarmeBean allarme : listaAllarmi) {
  1134.                     if(listaAllarmiPD.containsKey(allarme.getNome())) {
  1135.                         continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1136.                     }
  1137.                     listAllarmiDaVerificare.add(allarme);
  1138.                 }
  1139.             }
  1140.             
  1141.             if(listAllarmiDaVerificare!=null && !listAllarmiDaVerificare.isEmpty()) {
  1142.                 for (ConfigurazioneAllarmeBean allarme : listAllarmiDaVerificare) {
  1143.                     
  1144.                     if(listaAllarmiPD.containsKey(allarme.getNome())) {
  1145.                         continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1146.                     }
  1147.                 
  1148.                     if(allarme.getFiltro()!=null) {
  1149.                         
  1150.                         updateFiltroSoggettoEngine(allarme);
  1151.                                                         
  1152.                         listaAllarmiPD.put(allarme.getNome(), allarme);
  1153.                     }
  1154.                 }
  1155.             }
  1156.             // fine Controllo policy di Rate Limiting
  1157.             
  1158.             
  1159.             // aggiorno gli allarmi associati alle porte delegate
  1160.             if(listaAllarmiPD!=null && !listaAllarmiPD.isEmpty()) {
  1161.                 for (ConfigurazioneAllarmeBean allarme : listaAllarmiPD.values()) {
  1162.                     this.oggettiDaAggiornare.add(allarme);
  1163.                 }
  1164.             }
  1165.         }
  1166.     }

  1168.     private void updateSoggettoInlisteEngine(PortaDelegata portaDelegata) {
  1169.                 
  1170.         // controlloServiziApplicativi riferiti nelle Trasformazioni
  1171.         
  1172.         if(portaDelegata.getTrasformazioni()!=null && portaDelegata.getTrasformazioni().sizeRegolaList()>0) {
  1173.             for (TrasformazioneRegola trRegola : portaDelegata.getTrasformazioni().getRegolaList()) {
  1174.                 if(trRegola.getApplicabilita()!=null && trRegola.getApplicabilita().sizeServizioApplicativoList()>0) {
  1175.                     for (TrasformazioneRegolaApplicabilitaServizioApplicativo trSA : trRegola.getApplicabilita().getServizioApplicativoList()) {
  1176.                         if (this.oldtipoprov.equals(trSA.getTipoSoggettoProprietario()) && 
  1177.                                 this.oldnomeprov.equals(trSA.getNomeSoggettoProprietario())) {
  1178.                             trSA.setTipoSoggettoProprietario(this.tipoprov);
  1179.                             trSA.setNomeSoggettoProprietario(this.nomeprov);
  1180.                             break;
  1181.                         }
  1182.                     }
  1183.                 }
  1184.             }
  1185.         }
  1186.         
  1187.         // fine controlloSoggetti riferiti nelle Trasformazioni
  1188.     }

  1190.     public void checkPorteApplicative() throws DriverConfigurazioneException{
  1191.         if(this.soggettiCore.isRegistroServiziLocale()){
  1192.             // PORTE APPLICATIVE
  1193.             // Se e' cambiato il tipo o il nome del soggetto virtuale devo effettuare la modifica delle porte applicative
  1194.             // poiche il cambio si riflette all'interno delle informazioni delle porte applicative
  1195.             Map<String, PortaApplicativa> listaPA = new HashMap<>();
  1196.             Map<String, ServizioApplicativo> listaPAeSA = new HashMap<>();
  1197.             Map<String, AttivazionePolicy> listaPolicyPA = new HashMap<>();
  1198.             Map<String, ConfigurazioneAllarmeBean> listaAllarmiPA = new HashMap<>();

  1200.             
  1201.             if (!this.oldnomeprov.equals(this.nomeprov) || !this.oldtipoprov.equals(this.tipoprov)) {

  1203.                 // ** Verifica per soggetto proprietario ** // 
  1204.                 
  1205.                 // NomePorta
  1206.                 // Tutte le porte applicativa di questo soggetto con nome "di default"
  1207.                 // devono essere cambiate
  1208.                 // Nome della Porta: 
  1209.                 List<PortaApplicativa> tmpList = this.porteApplicativeCore.porteAppList(this.sog.getId().intValue(), new ConsoleSearch(true));
  1210.                 for (PortaApplicativa portaApplicativa : tmpList) {
  1211.                     
  1212.                     IDPortaApplicativa oldIDPortaApplicativaForUpdate = null;
  1213.                     String nomeAttuale = portaApplicativa.getNome();

  1215.                     // se il nome e' quello di default cioe' (erogatore)/(servizio)/(versioneServizio) o (erogatore)/(servizio)/(versioneServizio)/azione
  1216.                     String regex = REGEXP_FRUITORE_EROGATORE_OTHER_MATCH;
  1217.                     String newNome = null;
  1218.                     if (nomeAttuale.matches(regex)) {

  1220.                         String[] val = nomeAttuale.split("\\/");
  1221.                         String patErogatore = val[0];
  1222.                         String patServizio = val[1];
  1223.                         String patVersioneServizio = val[2];
  1224.                         StringBuilder sbPatAzione = new StringBuilder();
  1225.                         if(val.length>3){
  1226.                             for (int i = 3; i < val.length; i++) {
  1227.                                 if(i>3){
  1228.                                     sbPatAzione.append("/");
  1229.                                 }
  1230.                                 sbPatAzione.append(val[i]);
  1231.                             }
  1232.                         }
  1233.                         String patAzione = sbPatAzione.toString();

  1235.                         // erogatore
  1236.                         if (patErogatore.equals(this.oldtipoprov+ "_" +this.oldnomeprov)) {
  1237.                             patErogatore = this.tipoprov+ "_" +this.nomeprov;
  1238.                         }
  1239.                         else if (patErogatore.equals("__"+this.oldtipoprov+ "_" +this.oldnomeprov)) {
  1240.                             patErogatore = "__"+this.tipoprov+ "_" +this.nomeprov;
  1241.                         }

  1243.                         newNome = patErogatore + "/" + patServizio + "/" + patVersioneServizio ;
  1244.                         if(patAzione!=null && StringUtils.isNotEmpty(patAzione)){
  1245.                             newNome = newNome + "/" + patAzione;
  1246.                         }
  1247.                         
  1248.                         portaApplicativa.setNome(newNome);
  1249.                         oldIDPortaApplicativaForUpdate = new IDPortaApplicativa();
  1250.                         oldIDPortaApplicativaForUpdate.setNome(nomeAttuale);
  1251.                         portaApplicativa.setOldIDPortaApplicativaForUpdate(oldIDPortaApplicativaForUpdate);

  1253.                         // modifica della descrizione
  1254.                         String descrizionePA = portaApplicativa.getDescrizione();
  1255.                         if (descrizionePA != null && !descrizionePA.equals("")) {

  1257.                             // Caso 1: implementation default
  1258.                             // Service implementation gw/ENTE:gw/TEST:1
  1259.                             String matchCaso1testService = " "+this.oldtipoprov+"/"+this.oldnomeprov+":";
  1260.                             if(descrizionePA.contains(matchCaso1testService)) {
  1261.                                 String replaceCaso1testService = " "+this.tipoprov+"/"+this.nomeprov+":";
  1262.                                 descrizionePA = descrizionePA.replace(matchCaso1testService, replaceCaso1testService);
  1263.                             }
  1264.                         
  1265.                             // Caso 2: altra subscription
  1266.                             // Internal Implementation 'Specific1' for gw_ENTE/gw_TEST/1
  1267.                             String matchCaso2testService = " "+this.oldtipoprov+"_"+this.oldnomeprov+"/";
  1268.                             if(descrizionePA.contains(matchCaso2testService)) {
  1269.                                 String replaceCaso2testService = " "+this.tipoprov+"_"+this.nomeprov+"/";
  1270.                                 descrizionePA = descrizionePA.replace(matchCaso2testService, replaceCaso2testService);
  1271.                             }
  1272.                             
  1273.                             portaApplicativa.setDescrizione(descrizionePA);
  1274.                         }
  1275.                         
  1276.                         // regex del pattern azione
  1277.                         // OLD: .*/(erogatore)/(servizio)/([^/|^?]*).*
  1278.                         // NEW 3.3.13: /(erogatore)/(servizio)/([^/?]*).*
  1279.                         PortaApplicativaAzione paAzione = portaApplicativa.getAzione();
  1280.                         PortaApplicativaAzioneIdentificazione identificazione = paAzione != null ? paAzione.getIdentificazione() : null;
  1281.                         String patterAzione = "";
  1282.                         if(paAzione!=null) {
  1283.                             patterAzione = paAzione.getPattern() != null ? paAzione.getPattern() : "";
  1284.                         }
  1285.                         String patternAzionePrefixOld = PATTERN_AZIONE_PREFIX_OLD;
  1286.                         String patternAzioneSuffix1Old = PATTERN_AZIONE_SUFFIX_OLD;
  1287.                         String patternAzionePrefixNew = PATTERN_AZIONE_PREFIX_NEW;
  1288.                         String patternAzioneSuffix1New = PATTERN_AZIONE_SUFFIX_NEW;
  1289.                         // se identificazione urlbased procedo con i controlli
  1290.                         if (PortaApplicativaAzioneIdentificazione.URL_BASED.equals(identificazione)) {
  1291.                             
  1292.                             boolean oldPattern = patterAzione.startsWith(patternAzionePrefixOld) && patterAzione.endsWith(patternAzioneSuffix1Old);
  1293.                             boolean newPattern = patterAzione.startsWith(patternAzionePrefixNew) && patterAzione.endsWith(patternAzioneSuffix1New);
  1294.                             
  1295.                             if(oldPattern || newPattern) {
  1296.                             
  1297.                                 // caso1
  1298.                                 int startidx = oldPattern ? patternAzionePrefixOld.length() : patternAzionePrefixNew.length();
  1299.                                 int endidx = oldPattern ? patterAzione.lastIndexOf(patternAzioneSuffix1Old) : patterAzione.lastIndexOf(patternAzioneSuffix1New);
  1300.                                 String tmpPat = patterAzione.substring(startidx, endidx);
  1301.                                 // a questo punto ottengo una stringa del tipo
  1302.                                 // (fruitore)/(erogatore)/(servizio)
  1303.                                 // se rispetta la regex allora vuol dire che il
  1304.                                 // pattern azione e' quello di default
  1305.                                 // e devo effettuare i cambiamenti
  1306.                                 if (tmpPat.matches(regex)) {
  1307.                                     val = tmpPat.split("/");
  1308.                                     String partErogatore = val[0];
  1309.                                     String partServizio = val[1];
  1310.                                     String partVersione = val[2];
  1311.                                     String rimanenteRegExp = "";
  1312.                                     int lengthParteRimanenteRegExp = (partErogatore+"/"+partServizio+"/"+partVersione).length();
  1313.                                     if(tmpPat.length()>lengthParteRimanenteRegExp){
  1314.                                         rimanenteRegExp = tmpPat.substring(lengthParteRimanenteRegExp);
  1315.                                     }   
  1316.                                     
  1317.                                     boolean matchURL = false;
  1318.                                     String partOld = "(?:"+this.oldtipoprov+"_)?"+this.oldnomeprov+"";
  1319.                                     String partNew = "(?:"+this.tipoprov+"_)?"+this.nomeprov+"";
  1320.                                     
  1321.                                     // vedo se matcha il fruitore
  1322.                                     if (partErogatore.equals(partOld)) {
  1323.                                         partErogatore = partNew;
  1324.                                         matchURL = true;
  1325.                                     }
  1326.                                     
  1327.                                     if(matchURL){
  1328.                                         String newPatternAzione = patternAzionePrefixNew + partErogatore+ "/" + partServizio+ "/" + partVersione + rimanenteRegExp + patternAzioneSuffix1New;
  1329.                                         paAzione.setPattern(newPatternAzione);
  1330.                                         portaApplicativa.setAzione(paAzione);
  1331.                                     }
  1332.                                     
  1333.                                 }
  1334.                             }
  1335.                         }
  1336.                         
  1337.                         // DelegatedBy
  1338.                         String nomePortaDelegante = null;
  1339.                         if(paAzione!=null) {
  1340.                             nomePortaDelegante = paAzione.getNomePortaDelegante() != null ? paAzione.getNomePortaDelegante() : null;
  1341.                         }
  1342.                         if (PortaApplicativaAzioneIdentificazione.DELEGATED_BY.equals(identificazione) && nomePortaDelegante!=null ) {
  1343.                             
  1344.                             String regexDelegante = REGEXP_FRUITORE_EROGATORE_OTHER_MATCH;
  1345.                             if (nomePortaDelegante.matches(regexDelegante)) {

  1347.                                 String[] valDelegante = nomePortaDelegante.split("\\/");
  1348.                                 String patErogatoreDelegante = valDelegante[0];
  1349.                                 String patServizioDelegante = valDelegante[1];
  1350.                                 String patVersioneServizioDelegante = valDelegante[2];
  1351.                                 StringBuilder sbPatAzioneDelegante = new StringBuilder();
  1352.                                 if(valDelegante.length>3){
  1353.                                     for (int i = 3; i < valDelegante.length; i++) {
  1354.                                         if(i>3){
  1355.                                             sbPatAzioneDelegante.append("/");
  1356.                                         }
  1357.                                         sbPatAzioneDelegante.append(valDelegante[i]);
  1358.                                     }
  1359.                                 }
  1360.                                 String patAzioneDelegante = sbPatAzioneDelegante.toString();
  1361.                                 
  1362.                                 // erogatore
  1363.                                 if (patErogatoreDelegante.equals(this.oldtipoprov+ "_" +this.oldnomeprov)) {
  1364.                                     patErogatoreDelegante = this.tipoprov+ "_" +this.nomeprov;
  1365.                                 }
  1366.                                 else if (patErogatoreDelegante.equals("__"+this.oldtipoprov+ "_" +this.oldnomeprov)) {
  1367.                                     patErogatoreDelegante = "__"+this.tipoprov+ "_" +this.nomeprov;
  1368.                                 }

  1370.                                 String newNomeDelegante = patErogatoreDelegante + "/" + patServizioDelegante + "/" + patVersioneServizioDelegante ;
  1371.                                 if(patAzioneDelegante!=null && StringUtils.isNotEmpty(patAzioneDelegante)){
  1372.                                     newNomeDelegante = newNomeDelegante + "/" + patAzioneDelegante;
  1373.                                 }
  1374.                                 
  1375.                                 portaApplicativa.getAzione().setNomePortaDelegante(newNomeDelegante);
  1376.                             }
  1377.                             
  1378.                         }// fine controllo DelegatedBy
  1379.                                                 
  1380.                     }// fine controllo nome
  1381.                     
  1382.                     updateSoggettoInListeEngine(portaApplicativa);
  1383.                                         
  1384.                     portaApplicativa.setTipoSoggettoProprietario(this.tipoprov);
  1385.                     portaApplicativa.setNomeSoggettoProprietario(this.nomeprov);
  1386.                     listaPA.put(nomeAttuale, portaApplicativa);
  1387.                     
  1388.                     // modifica nome Servizi Applicativi che riflette il nome della PA
  1389.                     if(oldIDPortaApplicativaForUpdate!=null && portaApplicativa.sizeServizioApplicativoList()>0) {
  1390.                         for (PortaApplicativaServizioApplicativo portaApplicativaSA : portaApplicativa.getServizioApplicativoList()) {
  1391.                             
  1392.                             boolean nameEquals = portaApplicativaSA.getNome().equals(oldIDPortaApplicativaForUpdate.getNome());
  1393.                             
  1394.                             // __gw_ENTE/gw_TEST/v1__Specific2__SA3
  1395.                             boolean nameConnettoreMultiplo = portaApplicativaSA.getNome().startsWith(oldIDPortaApplicativaForUpdate.getNome()+ConnettoriCostanti.PARAMETRO_CONNETTORI_MULTIPLI_SAX_PREFIX);
  1396.                                                                 
  1397.                             if(nameEquals || nameConnettoreMultiplo) {
  1398.                                 // devo aggiornare il nome del SA
  1399.                                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  1400.                                 idSA.setNome(portaApplicativaSA.getNome());
  1401.                                 idSA.setIdSoggettoProprietario(new IDSoggetto(this.oldtipoprov, this.oldnomeprov));
  1402.                                 ServizioApplicativo sa = this.saCore.getServizioApplicativo(idSA);
  1403.                                 
  1404.                                 IDServizioApplicativo oldIDServizioApplicativoForUpdate = new IDServizioApplicativo();
  1405.                                 oldIDServizioApplicativoForUpdate.setNome(sa.getNome());
  1406.                                 oldIDServizioApplicativoForUpdate.setIdSoggettoProprietario(idSA.getIdSoggettoProprietario());
  1407.                                 sa.setOldIDServizioApplicativoForUpdate(oldIDServizioApplicativoForUpdate);
  1408.                                 sa.setTipoSoggettoProprietario(this.tipoprov);
  1409.                                 sa.setNomeSoggettoProprietario(this.nomeprov);
  1410.                                 
  1411.                                 if(nameEquals || nameConnettoreMultiplo) {
  1412.                                     // nameEquals: gw_ENTE/gw_TEST/1
  1413.                                     // nameConnettoreMultiplo: gw_ENTE/gw_TEST/v1__SA2
  1414.                                     if(sa.getNome().startsWith(this.oldtipoprov+"_"+this.oldnomeprov+"/")) {
  1415.                                         sa.setNome(sa.getNome().replace(this.oldtipoprov+"_"+this.oldnomeprov+"/", this.tipoprov+"_"+this.nomeprov+"/"));
  1416.                                     }
  1417.                                     // nameEquals: __gw_ENTE/gw_TEST/1__Specific2
  1418.                                     // nameConnettoreMultiplo: __gw_ENTE/gw_TEST/v1__Specific2__SA2
  1419.                                     else if(sa.getNome().startsWith("__"+this.oldtipoprov+"_"+this.oldnomeprov+"/")) {
  1420.                                         sa.setNome(sa.getNome().replace("__"+this.oldtipoprov+"_"+this.oldnomeprov+"/", "__"+this.tipoprov+"_"+this.nomeprov+"/"));
  1421.                                     }
  1422.                                 }
  1423.                                 
  1424.                                 /**NON SERVE, sono riferiti tramite id e prima modifico le porte applicative!! portaApplicativaSA.setNome(sa.getNome());
  1425.                                 // Inoltre anche se cambio il nome del soggetto, l'id del soggetto rimane lo stesso*/
  1426.                                 
  1427.                                 listaPAeSA.put(sa.getNome(), sa);
  1428.                                 /** ?? nei connettori multipli, salta break;*/
  1429.                             }
  1430.                         }
  1431.                     }
  1432.                     // modifica nome Servizi Applicativi che riflette il nome della PA
  1433.                     
  1434.                     // Controllo policy di Rate Limiting
  1435.                     ConsoleSearch ricercaPolicies = new ConsoleSearch(true);
  1436.                     List<AttivazionePolicy> listaPolicies = null;
  1437.                     try {
  1438.                         listaPolicies = this.confCore.attivazionePolicyList(ricercaPolicies, RuoloPolicy.APPLICATIVA, nomeAttuale);
  1439.                     }catch(Exception e) {
  1440.                         // ignore
  1441.                     }
  1442.                     if(listaPolicies!=null && !listaPolicies.isEmpty()) {
  1443.                         for (AttivazionePolicy ap : listaPolicies) {
  1444.                             if(ap.getFiltro()!=null && nomeAttuale.equals(ap.getFiltro().getNomePorta())) {
  1445.                                 
  1446.                                 // aggiorno nome porta
  1447.                                 if(newNome!=null) {
  1448.                                     ap.getFiltro().setNomePorta(newNome);
  1449.                                 }
  1450.                                 
  1451.                                 updateFiltroSoggettoEngine(ap);
  1452.                                                                 
  1453.                                 listaPolicyPA.put(ap.getIdActivePolicy(), ap);
  1454.                             }
  1455.                         }
  1456.                     }
  1457.                     // fine Controllo policy di Rate Limiting
  1458.                     
  1459.                     if(this.confCore.isConfigurazioneAllarmiEnabled()) {
  1460.                         // Controllo allarmi
  1461.                         ConsoleSearch ricercaAllarmi = new ConsoleSearch(true);
  1462.                         List<ConfigurazioneAllarmeBean> listaAllarmi = null;
  1463.                         try {
  1464.                             listaAllarmi = this.confCore.allarmiList(ricercaAllarmi, RuoloPorta.APPLICATIVA, nomeAttuale);
  1465.                         }catch(Exception e) {
  1466.                             // ignore
  1467.                         }
  1468.                         if(listaAllarmi!=null && !listaAllarmi.isEmpty()) {
  1469.                             for (ConfigurazioneAllarmeBean allarme : listaAllarmi) {
  1470.                                 if(allarme.getFiltro()!=null && nomeAttuale.equals(allarme.getFiltro().getNomePorta())) {
  1471.                                     
  1472.                                     // aggiorno nome porta
  1473.                                     if(newNome!=null) {
  1474.                                         allarme.getFiltro().setNomePorta(newNome);
  1475.                                     }
  1476.                                     
  1477.                                     updateFiltroSoggettoEngine(allarme);
  1478.                                                                     
  1479.                                     listaAllarmiPA.put(allarme.getNome(), allarme);
  1480.                                 }
  1481.                             }
  1482.                         }
  1483.                         // fine Controllo allarmi
  1484.                     }
  1485.                 }

  1487.                 // ** Fine Verifica per soggetto proprietario ** // 
  1488.                 
  1489.                 
  1490.                 // ** Verifica per soggetto proprietario differente da quello modificato ** // 
  1491.                 
  1492.                 // effettuo controlli per le porte applicative che hanno un proprietario differente
  1493.                 
  1494.                 List<IDPortaApplicativa> listDaVerificare = new ArrayList<>();
  1495.                 
  1496.                 // controllo SoggettoVirtuale
  1497.                 List<PortaApplicativa> tmpListSoggettiVirtuali = this.porteApplicativeCore.getPorteApplicativeBySoggettoVirtuale(new IDSoggetto(this.oldtipoprov,this.oldnomeprov));
  1498.                 if(tmpListSoggettiVirtuali!=null && !tmpListSoggettiVirtuali.isEmpty()) {
  1499.                     for (PortaApplicativa portaApplicativa : tmpListSoggettiVirtuali) {
  1500.                         if(listaPA.containsKey(portaApplicativa.getNome())) {
  1501.                             continue; // modifica gia' effettuata
  1502.                         }
  1503.                         IDPortaApplicativa idPortaApplicativa = new IDPortaApplicativa();
  1504.                         idPortaApplicativa.setNome(portaApplicativa.getNome());
  1505.                         listDaVerificare.add(idPortaApplicativa);
  1506.                     }
  1507.                 }
  1508.                 // Fine controllo SoggettoVirtuale
  1509.                 
  1510.                 // controlloSoggetti Autorizzati per le porte applicative che hanno un proprietario differente
  1511.                 FiltroRicercaPorteApplicative filtroRicercaPAConAuthSoggetti = new FiltroRicercaPorteApplicative();
  1512.                 filtroRicercaPAConAuthSoggetti.setIdSoggettoAutorizzato(new IDSoggetto(this.oldtipoprov, this.oldnomeprov));
  1513.                 List<IDPortaApplicativa> list = this.porteApplicativeCore.getAllIdPorteApplicative(filtroRicercaPAConAuthSoggetti);
  1514.                 if(list!=null && !list.isEmpty()) {
  1515.                     for (IDPortaApplicativa idPortaApplicativa : list) {
  1516.                         if(listaPA.containsKey(idPortaApplicativa.getNome())) {
  1517.                             continue; // modifica gia' effettuata
  1518.                         }
  1519.                         listDaVerificare.add(idPortaApplicativa);
  1520.                     }
  1521.                 }
  1522.                 // fine controlloSoggetti Autorizzati per le porte applicative che hanno un proprietario differente
  1523.                 
  1524.                 // controlloServiziApplicativi Autorizzati per le porte applicative che hanno un proprietario differente
  1525.                 // non serve, sono tramite id. Serve solo l'update interno delle Porte applicative se trovato con altri metodi
  1526.                 // fine controlloServiziApplicativi Autorizzati per le porte applicative che hanno un proprietario differente
  1527.                 
  1528.                 // controlloSoggetti riferiti nelle trasformazioni per le porte applicative che hanno un proprietario differente
  1529.                 FiltroRicercaPorteApplicative filtroRicercaPAConTrasformazioneSoggetti = new FiltroRicercaPorteApplicative();
  1530.                 filtroRicercaPAConTrasformazioneSoggetti.setIdSoggettoRiferitoApplicabilitaTrasformazione(new IDSoggetto(this.oldtipoprov, this.oldnomeprov));
  1531.                 list = this.porteApplicativeCore.getAllIdPorteApplicative(filtroRicercaPAConTrasformazioneSoggetti);
  1532.                 if(list!=null && !list.isEmpty()) {
  1533.                     for (IDPortaApplicativa idPortaApplicativa : list) {
  1534.                         if(listaPA.containsKey(idPortaApplicativa.getNome())) {
  1535.                             continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1536.                         }
  1537.                         listDaVerificare.add(idPortaApplicativa);
  1538.                     }
  1539.                 }
  1540.                 // fine controlloSoggetti riferiti nelle trasformazioni per le porte applicative che hanno un proprietario differente
  1541.                 
  1542.                 // controlloServiziApplicativi riferiti nelle trasformazioni per le porte applicative che hanno un proprietario differente
  1543.                 // non serve, sono tramite id. Serve solo l'update interno delle Porte applicative se trovato con altri metodi
  1544.                 // fine controlloServiziApplicativi riferiti nelle trasformazioni per le porte applicative che hanno un proprietario differente
  1545.                 
  1546.                 if(listDaVerificare!=null && !listDaVerificare.isEmpty()) {
  1547.                     for (IDPortaApplicativa idPortaApplicativa : listDaVerificare) {
  1548.                                                 
  1549.                         if(listaPA.containsKey(idPortaApplicativa.getNome())) {
  1550.                             continue; // modifica gia' effettuata
  1551.                         }
  1552.                         
  1553.                         PortaApplicativa pa = null;
  1554.                         try {
  1555.                             pa = this.porteApplicativeCore.getPortaApplicativa(idPortaApplicativa);
  1556.                         }catch(DriverConfigurazioneNotFound notFound) {
  1557.                             // ignore
  1558.                         }
  1559.                         if(pa!=null) {
  1560.                             
  1561.                             // soggetti virtuali
  1562.                             if(pa.getSoggettoVirtuale()!=null && 
  1563.                                     this.oldtipoprov.equals(pa.getSoggettoVirtuale().getTipo()) &&
  1564.                                     this.oldnomeprov.equals(pa.getSoggettoVirtuale().getNome())) {
  1565.                                 pa.getSoggettoVirtuale().setTipo(this.tipoprov);
  1566.                                 pa.getSoggettoVirtuale().setNome(this.nomeprov);
  1567.                             }
  1568.                             
  1569.                             updateSoggettoInListeEngine(pa);
  1570.                             
  1571.                             listaPA.put(pa.getNome(), pa);
  1572.                         }
  1573.                     }
  1574.                 }
  1575.                 
  1576.                 // Controllo policy di Rate Limiting
  1577.                 
  1578.                 List<AttivazionePolicy> listPolicyDaVerificare = new ArrayList<>();
  1579.                 
  1580.                 IDSoggetto filtroSoggettoFruitore = new IDSoggetto(this.oldtipoprov, this.oldnomeprov);
  1581.                 ConsoleSearch ricercaPolicies = new ConsoleSearch(true);
  1582.                 List<AttivazionePolicy> listaPolicies = null;
  1583.                 try {
  1584.                     listaPolicies = this.confCore.attivazionePolicyListByFilter(ricercaPolicies, RuoloPolicy.APPLICATIVA, null,
  1585.                             filtroSoggettoFruitore, null, null,
  1586.                             null, null,
  1587.                             null, null);
  1588.                 }catch(Exception e) {
  1589.                     // ignore
  1590.                 }
  1591.                 if(listaPolicies!=null && !listaPolicies.isEmpty()) {
  1592.                     for (AttivazionePolicy ap : listaPolicies) {
  1593.                         if(listaPolicyPA.containsKey(ap.getIdActivePolicy())) {
  1594.                             continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1595.                         }
  1596.                         listPolicyDaVerificare.add(ap);
  1597.                     }
  1598.                 }
  1599.                 
  1600.                 IDSoggetto filtroSoggettoErogatore = new IDSoggetto(this.oldtipoprov, this.oldnomeprov);
  1601.                 ricercaPolicies = new ConsoleSearch(true);
  1602.                 listaPolicies = null;
  1603.                 try {
  1604.                     listaPolicies = this.confCore.attivazionePolicyListByFilter(ricercaPolicies, RuoloPolicy.APPLICATIVA, null,
  1605.                             null, null, null,
  1606.                             filtroSoggettoErogatore, null,
  1607.                             null, null);
  1608.                 }catch(Exception e) {
  1609.                     // ignore
  1610.                 }
  1611.                 if(listaPolicies!=null && !listaPolicies.isEmpty()) {
  1612.                     for (AttivazionePolicy ap : listaPolicies) {
  1613.                         if(listaPolicyPA.containsKey(ap.getIdActivePolicy())) {
  1614.                             continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1615.                         }
  1616.                         listPolicyDaVerificare.add(ap);
  1617.                     }
  1618.                 }
  1619.                 
  1620.                 if(listPolicyDaVerificare!=null && !listPolicyDaVerificare.isEmpty()) {
  1621.                     for (AttivazionePolicy ap : listPolicyDaVerificare) {
  1622.                         
  1623.                         if(listaPolicyPA.containsKey(ap.getIdActivePolicy())) {
  1624.                             continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1625.                         }
  1626.                     
  1627.                         if(ap.getFiltro()!=null) {
  1628.                             
  1629.                             updateFiltroSoggettoEngine(ap);
  1630.                                                             
  1631.                             listaPolicyPA.put(ap.getIdActivePolicy(), ap);
  1632.                         }
  1633.                     }
  1634.                 }
  1635.                 // fine Controllo policy di Rate Limiting
  1636.                 
  1637.                 if(this.confCore.isConfigurazioneAllarmiEnabled()) {
  1638.                     // Controllo allarmi
  1639.                     
  1640.                     List<ConfigurazioneAllarmeBean> listAllarmiDaVerificare = new ArrayList<>();
  1641.                     
  1642.                     filtroSoggettoFruitore = new IDSoggetto(this.oldtipoprov, this.oldnomeprov);
  1643.                     ConsoleSearch ricercaAllarmi = new ConsoleSearch(true);
  1644.                     List<ConfigurazioneAllarmeBean> listaAllarmi = null;
  1645.                     try {
  1646.                         listaAllarmi = this.confCore.allarmiListByFilter(ricercaAllarmi, RuoloPorta.APPLICATIVA, null,
  1647.                                 filtroSoggettoFruitore, null, null,
  1648.                                 null, null,
  1649.                                 null, null);
  1650.                     }catch(Exception e) {
  1651.                         // ignore
  1652.                     }
  1653.                     if(listaAllarmi!=null && !listaAllarmi.isEmpty()) {
  1654.                         for (ConfigurazioneAllarmeBean allarme : listaAllarmi) {
  1655.                             if(listaAllarmiPA.containsKey(allarme.getNome())) {
  1656.                                 continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1657.                             }
  1658.                             listAllarmiDaVerificare.add(allarme);
  1659.                         }
  1660.                     }
  1661.                     
  1662.                     filtroSoggettoErogatore = new IDSoggetto(this.oldtipoprov, this.oldnomeprov);
  1663.                     ricercaAllarmi = new ConsoleSearch(true);
  1664.                     listaAllarmi = null;
  1665.                     try {
  1666.                         listaAllarmi = this.confCore.allarmiListByFilter(ricercaAllarmi, RuoloPorta.APPLICATIVA, null,
  1667.                                 null, null, null,
  1668.                                 filtroSoggettoErogatore, null,
  1669.                                 null, null);
  1670.                     }catch(Exception e) {
  1671.                         // ignore
  1672.                     }
  1673.                     if(listaAllarmi!=null && !listaAllarmi.isEmpty()) {
  1674.                         for (ConfigurazioneAllarmeBean allarme : listaAllarmi) {
  1675.                             if(listaAllarmiPA.containsKey(allarme.getNome())) {
  1676.                                 continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1677.                             }
  1678.                             listAllarmiDaVerificare.add(allarme);
  1679.                         }
  1680.                     }
  1681.                     
  1682.                     if(listAllarmiDaVerificare!=null && !listAllarmiDaVerificare.isEmpty()) {
  1683.                         for (ConfigurazioneAllarmeBean allarme : listAllarmiDaVerificare) {
  1684.                             
  1685.                             if(listaAllarmiPA.containsKey(allarme.getNome())) {
  1686.                                 continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1687.                             }
  1688.                         
  1689.                             if(allarme.getFiltro()!=null) {
  1690.                                 
  1691.                                 updateFiltroSoggettoEngine(allarme);
  1692.                                                                 
  1693.                                 listaAllarmiPA.put(allarme.getNome(), allarme);
  1694.                             }
  1695.                         }
  1696.                     }
  1697.                     // fine Controllo allarmi
  1698.                 }
  1699.                 
  1700.                 // ** Fine Verifica per soggetto proprietario differente da quello modificato ** // 
  1701.             }           

  1703.             // aggiorno le porte applicative
  1704.             if(listaPA!=null && !listaPA.isEmpty()) {
  1705.                 for (PortaApplicativa portaApplicativa : listaPA.values()) {
  1706.                     this.oggettiDaAggiornare.add(portaApplicativa);
  1707.                 }
  1708.             }
  1709.             // aggiorno i servizi applicativi associati alle porte applicative (vanno aggiornati dopo le PA poiche sono riferiti con i vecchi nomi dentro le pa)
  1710.             if(listaPAeSA!=null && !listaPAeSA.isEmpty()) {
  1711.                 for (ServizioApplicativo sa : listaPAeSA.values()) {
  1712.                     this.oggettiDaAggiornare.add(sa);
  1713.                 }
  1714.             }
  1715.             // aggiorno le policy di rate limiting associate alle porte applicative
  1716.             if(listaPolicyPA!=null && !listaPolicyPA.isEmpty()) {
  1717.                 for (AttivazionePolicy ap : listaPolicyPA.values()) {
  1718.                     this.oggettiDaAggiornare.add(ap);
  1719.                 }
  1720.             }
  1721.             if(this.confCore.isConfigurazioneAllarmiEnabled() &&
  1722.                 // aggiorno gli allarmi associati alle porte applicative
  1723.                 listaAllarmiPA!=null && !listaAllarmiPA.isEmpty()) {
  1724.                 for (ConfigurazioneAllarmeBean allarme : listaAllarmiPA.values()) {
  1725.                     this.oggettiDaAggiornare.add(allarme);
  1726.                 }
  1727.             }
  1728.         }
  1729.     }

  1731.     private void updateSoggettoInListeEngine(PortaApplicativa portaApplicativa) {
  1732.         
  1733.         // controlloSoggetti Autorizzati
  1734.         if(portaApplicativa.getSoggetti()!=null && portaApplicativa.getSoggetti().sizeSoggettoList()>0) {
  1735.             for (PortaApplicativaAutorizzazioneSoggetto portaApplicativaAuthSoggetto : portaApplicativa.getSoggetti().getSoggettoList()) {
  1736.                 if (this.oldtipoprov.equals(portaApplicativaAuthSoggetto.getTipo()) && 
  1737.                         this.oldnomeprov.equals(portaApplicativaAuthSoggetto.getNome())) {
  1738.                     portaApplicativaAuthSoggetto.setTipo(this.tipoprov);
  1739.                     portaApplicativaAuthSoggetto.setNome(this.nomeprov);
  1740.                     break;
  1741.                 }
  1742.             }
  1743.         }
  1744.         // fine controlloSoggetti Autorizzati   
  1745.         
  1746.         // controlloServiziApplicativi Autorizzati
  1747.         
  1748.         if(portaApplicativa.getServiziApplicativiAutorizzati()!=null && portaApplicativa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()>0) {
  1749.             for (PortaApplicativaAutorizzazioneServizioApplicativo portaApplicativaAuthSa : portaApplicativa.getServiziApplicativiAutorizzati().getServizioApplicativoList()) {
  1750.                 if (this.oldtipoprov.equals(portaApplicativaAuthSa.getTipoSoggettoProprietario()) && 
  1751.                         this.oldnomeprov.equals(portaApplicativaAuthSa.getNomeSoggettoProprietario())) {
  1752.                     portaApplicativaAuthSa.setTipoSoggettoProprietario(this.tipoprov);
  1753.                     portaApplicativaAuthSa.setNomeSoggettoProprietario(this.nomeprov);
  1754.                     break;
  1755.                 }
  1756.             }
  1757.         }
  1758.         
  1759.         // fine controlloServiziApplicativi Autorizzati
  1760.         
  1761.         // controlloSoggetti riferiti nelle Trasformazioni
  1762.         if(portaApplicativa.getTrasformazioni()!=null && portaApplicativa.getTrasformazioni().sizeRegolaList()>0) {
  1763.             for (TrasformazioneRegola trRegola : portaApplicativa.getTrasformazioni().getRegolaList()) {
  1764.                 if(trRegola.getApplicabilita()!=null && trRegola.getApplicabilita().sizeSoggettoList()>0) {
  1765.                     for (TrasformazioneRegolaApplicabilitaSoggetto trSoggetto : trRegola.getApplicabilita().getSoggettoList()) {
  1766.                         if (this.oldtipoprov.equals(trSoggetto.getTipo()) && 
  1767.                                 this.oldnomeprov.equals(trSoggetto.getNome())) {
  1768.                             trSoggetto.setTipo(this.tipoprov);
  1769.                             trSoggetto.setNome(this.nomeprov);
  1770.                             break;
  1771.                         }
  1772.                     }
  1773.                 }       
  1774.             }
  1775.         }
  1776.         // fine controlloSoggetti riferiti nelle Trasformazioni 
  1777.         
  1778.         // controlloServiziApplicativi riferiti nelle Trasformazioni
  1779.         
  1780.         if(portaApplicativa.getTrasformazioni()!=null && portaApplicativa.getTrasformazioni().sizeRegolaList()>0) {
  1781.             for (TrasformazioneRegola trRegola : portaApplicativa.getTrasformazioni().getRegolaList()) {
  1782.                 if(trRegola.getApplicabilita()!=null && trRegola.getApplicabilita().sizeServizioApplicativoList()>0) {
  1783.                     for (TrasformazioneRegolaApplicabilitaServizioApplicativo trSA : trRegola.getApplicabilita().getServizioApplicativoList()) {
  1784.                         if (this.oldtipoprov.equals(trSA.getTipoSoggettoProprietario()) && 
  1785.                                 this.oldnomeprov.equals(trSA.getNomeSoggettoProprietario())) {
  1786.                             trSA.setTipoSoggettoProprietario(this.tipoprov);
  1787.                             trSA.setNomeSoggettoProprietario(this.nomeprov);
  1788.                             break;
  1789.                         }
  1790.                     }
  1791.                 }
  1792.             }
  1793.         }
  1794.         
  1795.         // fine controlloSoggetti riferiti nelle Trasformazioni
  1796.     }
  1797.     
  1798.     private void updateFiltroSoggettoEngine(AttivazionePolicy ap) {
  1799.         if(ap.getFiltro()!=null) {
  1800.             
  1801.             // aggiorno soggetto fruitore
  1802.             if(ap.getFiltro().getTipoFruitore()!=null && ap.getFiltro().getNomeFruitore()!=null &&
  1803.                 this.oldtipoprov.equals(ap.getFiltro().getTipoFruitore()) && 
  1804.                 this.oldnomeprov.equals(ap.getFiltro().getNomeFruitore())) {
  1805.                 ap.getFiltro().setTipoFruitore(this.tipoprov);
  1806.                 ap.getFiltro().setNomeFruitore(this.nomeprov);
  1807.             }
  1808.             
  1809.             // aggiorno soggetto erogatore
  1810.             if(ap.getFiltro().getTipoErogatore()!=null && ap.getFiltro().getNomeErogatore()!=null &&
  1811.                 this.oldtipoprov.equals(ap.getFiltro().getTipoErogatore()) && 
  1812.                 this.oldnomeprov.equals(ap.getFiltro().getNomeErogatore())) {
  1813.                 ap.getFiltro().setTipoErogatore(this.tipoprov);
  1814.                 ap.getFiltro().setNomeErogatore(this.nomeprov);
  1815.             }
  1816.             
  1817.         }
  1818.     }
  1819.     private void updateFiltroSoggettoEngine(ConfigurazioneAllarmeBean allarme) {
  1820.         if(allarme.getFiltro()!=null) {
  1821.             
  1822.             // aggiorno soggetto fruitore
  1823.             if(allarme.getFiltro().getTipoFruitore()!=null && allarme.getFiltro().getNomeFruitore()!=null &&
  1824.                 this.oldtipoprov.equals(allarme.getFiltro().getTipoFruitore()) && 
  1825.                 this.oldnomeprov.equals(allarme.getFiltro().getNomeFruitore())) {
  1826.                 allarme.getFiltro().setTipoFruitore(this.tipoprov);
  1827.                 allarme.getFiltro().setNomeFruitore(this.nomeprov);
  1828.             }
  1829.             
  1830.             // aggiorno soggetto erogatore
  1831.             if(allarme.getFiltro().getTipoErogatore()!=null && allarme.getFiltro().getNomeErogatore()!=null &&
  1832.                 this.oldtipoprov.equals(allarme.getFiltro().getTipoErogatore()) && 
  1833.                 this.oldnomeprov.equals(allarme.getFiltro().getNomeErogatore())) {
  1834.                 allarme.getFiltro().setTipoErogatore(this.tipoprov);
  1835.                 allarme.getFiltro().setNomeErogatore(this.nomeprov);
  1836.             }
  1837.             
  1838.         }
  1839.     }

  1841.     public void checkFruitori() throws DriverRegistroServiziException{
  1842.         // Fruitori nei servizi 
  1843.         if(this.soggettiCore.isRegistroServiziLocale() &&
  1844.             (!this.oldnomeprov.equals(this.nomeprov) || !this.oldtipoprov.equals(this.tipoprov)) 
  1845.             ){
  1846.             
  1847.             List<AccordoServizioParteSpecifica> sfruitori = this.apsCore.servizioWithSoggettoFruitore(new IDSoggetto(this.oldtipoprov,this.oldnomeprov));
  1848.             for(int i=0; i<sfruitori.size(); i++){
  1849.                 AccordoServizioParteSpecifica asps = sfruitori.get(i);
  1850.                 if(asps.getTipoSoggettoErogatore().equals(this.oldtipoprov) &&
  1851.                         asps.getNomeSoggettoErogatore().equals(this.oldnomeprov)){
  1852.                     asps.setTipoSoggettoErogatore(this.tipoprov);
  1853.                     asps.setNomeSoggettoErogatore(this.nomeprov);
  1854.                 }
  1855.                 // Check accordo di Servizio
  1856.                 IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  1857.                 if(idAccordo.getSoggettoReferente()!=null && 
  1858.                         idAccordo.getSoggettoReferente().getTipo().equals(this.oldtipoprov) &&
  1859.                         idAccordo.getSoggettoReferente().getNome().equals(this.oldnomeprov)){
  1860.                     idAccordo.getSoggettoReferente().setTipo(this.tipoprov);
  1861.                     idAccordo.getSoggettoReferente().setNome(this.nomeprov);
  1862.                     asps.setAccordoServizioParteComune(IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordo));
  1863.                 }   
  1864.                 // Fruitori
  1865.                 for(int j=0; j<asps.sizeFruitoreList(); j++){
  1866.                     if(asps.getFruitore(j).getTipo().equals(this.oldtipoprov) && 
  1867.                             asps.getFruitore(j).getNome().equals(this.oldnomeprov)){
  1868.                         asps.getFruitore(j).setTipo(this.tipoprov);
  1869.                         asps.getFruitore(j).setNome(this.nomeprov);
  1870.                     }
  1871.                 }           
  1872.                 this.oggettiDaAggiornare.add(asps);
  1873.             }
  1874.                 
  1875.         }
  1876.     }

  1878.     public void checkPolicyGlobali() {
  1879.         if(this.soggettiCore.isRegistroServiziLocale() &&
  1880.                 (!this.oldnomeprov.equals(this.nomeprov) || !this.oldtipoprov.equals(this.tipoprov)) 
  1881.             ){
  1882.             
  1883.             Map<String, AttivazionePolicy> listaPolicyPA = new HashMap<>();
  1884.             
  1885.             
  1886.             IDSoggetto filtroSoggettoFruitore = new IDSoggetto(this.oldtipoprov, this.oldnomeprov);
  1887.             ConsoleSearch ricercaPolicies = new ConsoleSearch(true);
  1888.             List<AttivazionePolicy> listaPolicies = null;
  1889.             try {
  1890.                 listaPolicies = this.confCore.attivazionePolicyListByFilter(ricercaPolicies, null, null,
  1891.                         filtroSoggettoFruitore, null, null,
  1892.                         null, null,
  1893.                         null, null);
  1894.             }catch(Exception e) {
  1895.                 // ignore
  1896.             }
  1897.             if(listaPolicies!=null && !listaPolicies.isEmpty()) {
  1898.                 for (AttivazionePolicy ap : listaPolicies) {
  1899.                     if(listaPolicyPA.containsKey(ap.getIdActivePolicy())) {
  1900.                         continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1901.                     }
  1902.                                             
  1903.                     if(ap.getFiltro()!=null) {
  1904.                         
  1905.                         updateFiltroSoggettoEngine(ap);
  1906.                                                         
  1907.                         listaPolicyPA.put(ap.getIdActivePolicy(), ap);
  1908.                     }
  1909.                 }
  1910.             }
  1911.             
  1912.             IDSoggetto filtroSoggettoErogatore = new IDSoggetto(this.oldtipoprov, this.oldnomeprov);
  1913.             ricercaPolicies = new ConsoleSearch(true);
  1914.             listaPolicies = null;
  1915.             try {
  1916.                 listaPolicies = this.confCore.attivazionePolicyListByFilter(ricercaPolicies, null, null,
  1917.                         null, null, null,
  1918.                         filtroSoggettoErogatore, null,
  1919.                         null, null);
  1920.             }catch(Exception e) {
  1921.                 // ignore
  1922.             }
  1923.             if(listaPolicies!=null && !listaPolicies.isEmpty()) {
  1924.                 for (AttivazionePolicy ap : listaPolicies) {
  1925.                     if(listaPolicyPA.containsKey(ap.getIdActivePolicy())) {
  1926.                         continue; // modifica gia' effettuata o cmq gestita dopo poiche' porta gia trovata
  1927.                     }
  1928.                     
  1929.                     if(ap.getFiltro()!=null) {
  1930.                         
  1931.                         updateFiltroSoggettoEngine(ap);
  1932.                                                         
  1933.                         listaPolicyPA.put(ap.getIdActivePolicy(), ap);
  1934.                     }
  1935.                 }
  1936.             }
  1937.             
  1938.             // fine Controllo policy di Rate Limiting
  1939.             
  1940.             // aggiorno le policy di rate limiting globali
  1941.             if(listaPolicyPA!=null && !listaPolicyPA.isEmpty()) {
  1942.                 for (AttivazionePolicy ap : listaPolicyPA.values()) {
  1943.                     this.oggettiDaAggiornare.add(ap);
  1944.                 }
  1945.             }
  1946.             
  1947.         }
  1948.     }
  1949.     
  1950.     public void checkConfigurazione() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1951.         if(this.soggettiCore.isRegistroServiziLocale() &&
  1952.             (!this.oldnomeprov.equals(this.nomeprov) || !this.oldtipoprov.equals(this.tipoprov)) 
  1953.             ){
  1954.                 
  1955.             Configurazione configurazioneGenerale = this.confCore.getConfigurazioneGenerale();
  1956.             boolean updated = false;
  1957.             if(configurazioneGenerale!=null && configurazioneGenerale.getUrlInvocazione()!=null && configurazioneGenerale.getUrlInvocazione().sizeRegolaList()>0) {
  1958.                 for (ConfigurazioneUrlInvocazioneRegola regola : configurazioneGenerale.getUrlInvocazione().getRegolaList()) {
  1959.                     if(regola.getSoggetto()!=null && 
  1960.                             this.oldtipoprov.equals(regola.getSoggetto().getTipo()) && 
  1961.                             this.oldnomeprov.equals(regola.getSoggetto().getNome())
  1962.                             ) {
  1963.                         regola.getSoggetto().setTipo(this.tipoprov);
  1964.                         regola.getSoggetto().setNome(this.nomeprov);
  1965.                         updated = true;
  1966.                     }
  1967.                 }
  1968.             }
  1969.             
  1970.             if(updated) {
  1971.                 this.oggettiDaAggiornare.add(configurazioneGenerale);
  1972.             }
  1973.             
  1974.         }
  1975.     }
  1976.         
  1977. }
Created with JaCoCo 0.8.8.202204050719