StatoServiziPdD.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.pdd.core;

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

  26. import org.openspcoop2.core.config.StatoServiziPdd;
  27. import org.openspcoop2.core.config.StatoServiziPddIntegrationManager;
  28. import org.openspcoop2.core.config.StatoServiziPddPortaApplicativa;
  29. import org.openspcoop2.core.config.StatoServiziPddPortaDelegata;
  30. import org.openspcoop2.core.config.TipoFiltroAbilitazioneServizi;
  31. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  32. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  33. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  34. import org.openspcoop2.core.id.IDServizio;
  35. import org.openspcoop2.core.id.IDSoggetto;
  36. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  37. import org.openspcoop2.utils.SemaphoreLock;

  39. /**
  40.  * StatoServiziPdD
  41.  *
  42.  * @author Poli Andrea (apoli@link.it)
  43.  * @author $Author$
  44.  * @version $Rev$, $Date$
  45.  */
  46. public class StatoServiziPdD {
  47.     
  48.     private static ConfigurazionePdDManager configPdDReader = ConfigurazionePdDManager.getInstance();
  49.     
  50.     
  51.     /* **************** INIT ***************** */
  52.     
  53.     public static void initialize() throws DriverConfigurazioneException {
  54.         
  55.         StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  56.         
  57.         // *** aggiorno stato in ram ***
  58.         
  59.         // -- portaDelegata --
  60.         if(statoServiziPdd!=null && statoServiziPdd.getPortaDelegata()!=null){ 
  61.             if(CostantiConfigurazione.DISABILITATO.equals(statoServiziPdd.getPortaDelegata().getStato())){
  62.                 activePDService = false;
  63.             }
  64.             else{
  65.                 activePDService = true;
  66.             }
  67.             listaAbilitazioniPDService = statoServiziPdd.getPortaDelegata().getFiltroAbilitazioneList();
  68.             listaDisabilitazioniPDService = statoServiziPdd.getPortaDelegata().getFiltroDisabilitazioneList();
  69.         }
  70.         // se non si inizializza, tutte le transazioni effettuano un nuovo accesso al db
  71.         if(activePDService==null){
  72.             activePDService = true;
  73.         }
  74.         if(listaAbilitazioniPDService==null){
  75.             listaAbilitazioniPDService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  76.         }
  77.         if(listaDisabilitazioniPDService==null){
  78.             listaDisabilitazioniPDService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  79.         }
  80.         
  81.         // -- portaApplicativa --   
  82.         if(statoServiziPdd!=null && statoServiziPdd.getPortaApplicativa()!=null){ 
  83.             if(CostantiConfigurazione.DISABILITATO.equals(statoServiziPdd.getPortaApplicativa().getStato())){
  84.                 activePAService = false;
  85.             }
  86.             else{
  87.                 activePAService = true;
  88.             }
  89.             listaAbilitazioniPAService = statoServiziPdd.getPortaApplicativa().getFiltroAbilitazioneList();
  90.             listaDisabilitazioniPAService = statoServiziPdd.getPortaApplicativa().getFiltroDisabilitazioneList();
  91.         }
  92.         // se non si inizializza, tutte le transazioni effettuano un nuovo accesso al db
  93.         if(activePAService==null){
  94.             activePAService = true;
  95.         }
  96.         if(listaAbilitazioniPAService==null){
  97.             listaAbilitazioniPAService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  98.         }
  99.         if(listaDisabilitazioniPAService==null){
  100.             listaDisabilitazioniPAService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  101.         }
  102.         
  103.         // -- integrationManager --
  104.         if(statoServiziPdd!=null && statoServiziPdd.getIntegrationManager()!=null){ 
  105.             if(CostantiConfigurazione.DISABILITATO.equals(statoServiziPdd.getIntegrationManager().getStato())){
  106.                 activeIMService = false;
  107.             }
  108.             else{
  109.                 activeIMService = true;
  110.             }
  111.         }
  112.         if(activeIMService==null){
  113.             activeIMService = true;
  114.         }


  117.     }
  118.     
  119.     
  120.     
  121.     /* **************** PORTA DELEGATA (GET) ***************** */
  122.     
  123.     public static boolean isPDServiceActive() {
  124.         if(activePDService!=null){
  125.             return activePDService;
  126.         }
  127.         else{
  128.             return configPdDReader.isPDServiceActive();
  129.         }
  130.     }
  131.     
  132.     public static List<TipoFiltroAbilitazioneServizi> getPDServiceFiltriAbilitazioneAttiviList() throws DriverConfigurazioneException {
  133.         List<TipoFiltroAbilitazioneServizi> list = null;
  134.         if(listaAbilitazioniPDService!=null){
  135.             list = listaAbilitazioniPDService;
  136.         }
  137.         else{
  138.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  139.             if(statoServiziPdd!=null && statoServiziPdd.getPortaDelegata()!=null){
  140.                 list = statoServiziPdd.getPortaDelegata().getFiltroAbilitazioneList();
  141.             }
  142.         }
  143.         return list;
  144.     }   
  145.     public static String getPDServiceFiltriAbilitazioneAttivi() throws DriverConfigurazioneException {
  146.         
  147.         List<TipoFiltroAbilitazioneServizi> list = getPDServiceFiltriAbilitazioneAttiviList();          
  148.         if(list==null || list.size()<=0){
  149.             return "";
  150.         }
  151.         else{
  152.             StringBuilder bf = new StringBuilder();
  153.             for (TipoFiltroAbilitazioneServizi tipo : list) {
  154.                 bf.append(StatoServiziPdD.toString(tipo));
  155.             }
  156.             return bf.toString();
  157.         }
  158.     }
  159.     
  160.     public static List<TipoFiltroAbilitazioneServizi> getPDServiceFiltriDisabilitazioneAttiviList() throws DriverConfigurazioneException {
  161.         
  162.         List<TipoFiltroAbilitazioneServizi> list = null;
  163.         if(listaDisabilitazioniPDService!=null){
  164.             list = listaDisabilitazioniPDService;
  165.         }
  166.         else{
  167.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  168.             if(statoServiziPdd!=null && statoServiziPdd.getPortaDelegata()!=null){
  169.                 list = statoServiziPdd.getPortaDelegata().getFiltroDisabilitazioneList();
  170.             }
  171.         }
  172.         return list;
  173.         
  174.     }
  175.     public static String getPDServiceFiltriDisabilitazioneAttivi() throws DriverConfigurazioneException {
  176.         
  177.         List<TipoFiltroAbilitazioneServizi> list = getPDServiceFiltriDisabilitazioneAttiviList();       
  178.         if(list==null || list.size()<=0){
  179.             return "";
  180.         }
  181.         else{
  182.             StringBuilder bf = new StringBuilder();
  183.             for (TipoFiltroAbilitazioneServizi tipo : list) {
  184.                 bf.append(StatoServiziPdD.toString(tipo));
  185.             }
  186.             return bf.toString();
  187.         }
  188.     }
  189.     
  190.     /* **************** PORTA DELEGATA (MODIFY) ***************** */
  191.     
  192.     //private static Integer semaphoreActivePDService = 1;
  193.     private static final org.openspcoop2.utils.Semaphore lockActivePDService = new org.openspcoop2.utils.Semaphore("StatoServiziFruizioni");
  194.     
  195.     private static Boolean activePDService = null;  
  196.     public static void setPDServiceActive(boolean stato) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  197.         //synchronized (semaphoreActivePDService) {
  198.         SemaphoreLock lock = StatoServiziPdD.lockActivePDService.acquireThrowRuntime("setPDServiceActive");
  199.         try {
  200.                         
  201.             // rendo persistente modifica
  202.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  203.             if(statoServiziPdd==null){
  204.                 statoServiziPdd = new StatoServiziPdd();
  205.             }
  206.             if(statoServiziPdd.getPortaDelegata()==null){
  207.                 statoServiziPdd.setPortaDelegata(new StatoServiziPddPortaDelegata());
  208.             }
  209.             if(stato){
  210.                 statoServiziPdd.getPortaDelegata().setStato(CostantiConfigurazione.ABILITATO);
  211.             }else{
  212.                 statoServiziPdd.getPortaDelegata().setStato(CostantiConfigurazione.DISABILITATO);
  213.             }
  214.             StatoServiziPdD.configPdDReader.updateStatoServiziPdD(statoServiziPdd);
  215.             
  216.             // aggiorno stato in ram
  217.             activePDService = stato;
  218.         }finally {
  219.             StatoServiziPdD.lockActivePDService.release(lock, "setPDServiceActive");
  220.         }
  221.     }
  222.     
  223.     private static List<TipoFiltroAbilitazioneServizi> listaAbilitazioniPDService = null;
  224.     public static void addFiltroAbilitazionePD(TipoFiltroAbilitazioneServizi tipo) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  225.         //synchronized (semaphoreActivePDService) {
  226.         SemaphoreLock lock = StatoServiziPdD.lockActivePDService.acquireThrowRuntime("addFiltroAbilitazionePD");
  227.         try {
  228.                     
  229.             // rendo persistente modifica
  230.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  231.             if(statoServiziPdd==null){
  232.                 statoServiziPdd = new StatoServiziPdd();
  233.             }
  234.             if(statoServiziPdd.getPortaDelegata()==null){
  235.                 statoServiziPdd.setPortaDelegata(new StatoServiziPddPortaDelegata());
  236.             }
  237.             statoServiziPdd.getPortaDelegata().addFiltroAbilitazione(tipo);
  238.             StatoServiziPdD.configPdDReader.updateStatoServiziPdD(statoServiziPdd);
  239.             
  240.             // aggiorno stato in ram
  241.             listaAbilitazioniPDService = statoServiziPdd.getPortaDelegata().getFiltroAbilitazioneList();
  242.         }finally {
  243.             StatoServiziPdD.lockActivePDService.release(lock, "addFiltroAbilitazionePD");
  244.         }
  245.     }
  246.     public static void removeFiltroAbilitazionePD(TipoFiltroAbilitazioneServizi tipo) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  247.         //synchronized (semaphoreActivePDService) {
  248.         SemaphoreLock lock = StatoServiziPdD.lockActivePDService.acquireThrowRuntime("removeFiltroAbilitazionePD");
  249.         try {
  250.             
  251.             // rendo persistente modifica
  252.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  253.             if(statoServiziPdd==null){
  254.                 statoServiziPdd = new StatoServiziPdd();
  255.             }
  256.             if(statoServiziPdd.getPortaDelegata()==null){
  257.                 statoServiziPdd.setPortaDelegata(new StatoServiziPddPortaDelegata());
  258.             }
  259.             String daEliminare = StatoServiziPdD.toString(tipo);
  260.             for (int i = 0; i < statoServiziPdd.getPortaDelegata().sizeFiltroAbilitazioneList(); i++) {
  261.                 String tmp = StatoServiziPdD.toString(statoServiziPdd.getPortaDelegata().getFiltroAbilitazione(i));
  262.                 if(tmp.equals(daEliminare)){
  263.                     statoServiziPdd.getPortaDelegata().removeFiltroAbilitazione(i);
  264.                     break;
  265.                 }
  266.             }
  267.             StatoServiziPdD.configPdDReader.updateStatoServiziPdD(statoServiziPdd);
  268.             
  269.             // aggiorno stato in ram
  270.             listaAbilitazioniPDService = statoServiziPdd.getPortaDelegata().getFiltroAbilitazioneList();
  271.         }finally{
  272.             StatoServiziPdD.lockActivePDService.release(lock, "removeFiltroAbilitazionePD");
  273.         }
  274.     }
  275.     
  276.     private static List<TipoFiltroAbilitazioneServizi> listaDisabilitazioniPDService = null;
  277.     public static void addFiltroDisabilitazionePD(TipoFiltroAbilitazioneServizi tipo) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  278.         //synchronized (semaphoreActivePDService) {
  279.         SemaphoreLock lock = StatoServiziPdD.lockActivePDService.acquireThrowRuntime("addFiltroDisabilitazionePD");
  280.         try {
  281.             
  282.             // rendo persistente modifica
  283.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  284.             if(statoServiziPdd==null){
  285.                 statoServiziPdd = new StatoServiziPdd();
  286.             }
  287.             if(statoServiziPdd.getPortaDelegata()==null){
  288.                 statoServiziPdd.setPortaDelegata(new StatoServiziPddPortaDelegata());
  289.             }
  290.             statoServiziPdd.getPortaDelegata().addFiltroDisabilitazione(tipo);
  291.             StatoServiziPdD.configPdDReader.updateStatoServiziPdD(statoServiziPdd);
  292.             
  293.             // aggiorno stato in ram
  294.             listaDisabilitazioniPDService = statoServiziPdd.getPortaDelegata().getFiltroDisabilitazioneList();
  295.         }finally {
  296.             StatoServiziPdD.lockActivePDService.release(lock, "addFiltroDisabilitazionePD");
  297.         }
  298.     }
  299.     public static void removeFiltroDisabilitazionePD(TipoFiltroAbilitazioneServizi tipo) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  300.         //synchronized (semaphoreActivePDService) {
  301.         SemaphoreLock lock = StatoServiziPdD.lockActivePDService.acquireThrowRuntime("removeFiltroDisabilitazionePD");
  302.         try {
  303.             
  304.             // rendo persistente modifica
  305.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  306.             if(statoServiziPdd==null){
  307.                 statoServiziPdd = new StatoServiziPdd();
  308.             }
  309.             if(statoServiziPdd.getPortaDelegata()==null){
  310.                 statoServiziPdd.setPortaDelegata(new StatoServiziPddPortaDelegata());
  311.             }
  312.             String daEliminare = StatoServiziPdD.toString(tipo);
  313.             for (int i = 0; i < statoServiziPdd.getPortaDelegata().sizeFiltroDisabilitazioneList(); i++) {
  314.                 String tmp = StatoServiziPdD.toString(statoServiziPdd.getPortaDelegata().getFiltroDisabilitazione(i));
  315.                 if(tmp.equals(daEliminare)){
  316.                     statoServiziPdd.getPortaDelegata().removeFiltroDisabilitazione(i);
  317.                     break;
  318.                 }
  319.             }
  320.             StatoServiziPdD.configPdDReader.updateStatoServiziPdD(statoServiziPdd);
  321.             
  322.             // aggiorno stato in ram
  323.             listaDisabilitazioniPDService = statoServiziPdd.getPortaDelegata().getFiltroDisabilitazioneList();
  324.         }finally {
  325.             StatoServiziPdD.lockActivePDService.release(lock, "removeFiltroDisabilitazionePD");
  326.         }
  327.     }
  328.     
  329.     
  330.     
  331.     
  332.     
  333.     /* **************** PORTA APPLICATIVA (GET) ***************** */
  334.     
  335.     public static boolean isPAServiceActive() {
  336.         if(activePAService!=null){
  337.             return activePAService;
  338.         }
  339.         else{
  340.             return configPdDReader.isPAServiceActive();
  341.         }
  342.     }
  343.     
  344.     public static List<TipoFiltroAbilitazioneServizi> getPAServiceFiltriAbilitazioneAttiviList() throws DriverConfigurazioneException {
  345.         List<TipoFiltroAbilitazioneServizi> list = null;
  346.         if(listaAbilitazioniPAService!=null){
  347.             list = listaAbilitazioniPAService;
  348.         }
  349.         else{
  350.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  351.             if(statoServiziPdd!=null && statoServiziPdd.getPortaApplicativa()!=null){
  352.                 list = statoServiziPdd.getPortaApplicativa().getFiltroAbilitazioneList();
  353.             }
  354.         }
  355.         return list;
  356.     }   
  357.     public static String getPAServiceFiltriAbilitazioneAttivi() throws DriverConfigurazioneException {
  358.         
  359.         List<TipoFiltroAbilitazioneServizi> list = getPAServiceFiltriAbilitazioneAttiviList();          
  360.         if(list==null || list.size()<=0){
  361.             return "";
  362.         }
  363.         else{
  364.             StringBuilder bf = new StringBuilder();
  365.             for (TipoFiltroAbilitazioneServizi tipo : list) {
  366.                 bf.append(StatoServiziPdD.toString(tipo));
  367.             }
  368.             return bf.toString();
  369.         }
  370.     }
  371.     
  372.     public static List<TipoFiltroAbilitazioneServizi> getPAServiceFiltriDisabilitazioneAttiviList() throws DriverConfigurazioneException {
  373.         
  374.         List<TipoFiltroAbilitazioneServizi> list = null;
  375.         if(listaDisabilitazioniPAService!=null){
  376.             list = listaDisabilitazioniPAService;
  377.         }
  378.         else{
  379.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  380.             if(statoServiziPdd!=null && statoServiziPdd.getPortaApplicativa()!=null){
  381.                 list = statoServiziPdd.getPortaApplicativa().getFiltroDisabilitazioneList();
  382.             }
  383.         }
  384.         return list;
  385.         
  386.     }
  387.     public static String getPAServiceFiltriDisabilitazioneAttivi() throws DriverConfigurazioneException {
  388.         
  389.         List<TipoFiltroAbilitazioneServizi> list = getPAServiceFiltriDisabilitazioneAttiviList();       
  390.         if(list==null || list.size()<=0){
  391.             return "";
  392.         }
  393.         else{
  394.             StringBuilder bf = new StringBuilder();
  395.             for (TipoFiltroAbilitazioneServizi tipo : list) {
  396.                 bf.append(StatoServiziPdD.toString(tipo));
  397.             }
  398.             return bf.toString();
  399.         }
  400.     }
  401.     
  402.     /* **************** PORTA APPLICATIVA (MODIFY) ***************** */
  403.     
  404.     //private static Integer semaphoreActivePAService = 1;
  405.     private static final org.openspcoop2.utils.Semaphore lockActivePAService = new org.openspcoop2.utils.Semaphore("StatoServiziErogazioni");
  406.     
  407.     private static Boolean activePAService = null;  
  408.     public static void setPAServiceActive(boolean stato) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  409.         //synchronized (semaphoreActivePAService) {
  410.         SemaphoreLock lock = StatoServiziPdD.lockActivePAService.acquireThrowRuntime("setPAServiceActive");
  411.         try {
  412.                         
  413.             // rendo persistente modifica
  414.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  415.             if(statoServiziPdd==null){
  416.                 statoServiziPdd = new StatoServiziPdd();
  417.             }
  418.             if(statoServiziPdd.getPortaApplicativa()==null){
  419.                 statoServiziPdd.setPortaApplicativa(new StatoServiziPddPortaApplicativa());
  420.             }
  421.             if(stato){
  422.                 statoServiziPdd.getPortaApplicativa().setStato(CostantiConfigurazione.ABILITATO);
  423.             }else{
  424.                 statoServiziPdd.getPortaApplicativa().setStato(CostantiConfigurazione.DISABILITATO);
  425.             }
  426.             StatoServiziPdD.configPdDReader.updateStatoServiziPdD(statoServiziPdd);
  427.             
  428.             // aggiorno stato in ram
  429.             activePAService = stato;
  430.         }finally {
  431.             StatoServiziPdD.lockActivePAService.release(lock, "setPAServiceActive");
  432.         }
  433.     }
  434.     
  435.     private static List<TipoFiltroAbilitazioneServizi> listaAbilitazioniPAService = null;
  436.     public static void addFiltroAbilitazionePA(TipoFiltroAbilitazioneServizi tipo) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  437.         //synchronized (semaphoreActivePAService) {
  438.         SemaphoreLock lock = StatoServiziPdD.lockActivePAService.acquireThrowRuntime("addFiltroAbilitazionePA");
  439.         try {
  440.                     
  441.             // rendo persistente modifica
  442.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  443.             if(statoServiziPdd==null){
  444.                 statoServiziPdd = new StatoServiziPdd();
  445.             }
  446.             if(statoServiziPdd.getPortaApplicativa()==null){
  447.                 statoServiziPdd.setPortaApplicativa(new StatoServiziPddPortaApplicativa());
  448.             }
  449.             statoServiziPdd.getPortaApplicativa().addFiltroAbilitazione(tipo);
  450.             StatoServiziPdD.configPdDReader.updateStatoServiziPdD(statoServiziPdd);
  451.             
  452.             // aggiorno stato in ram
  453.             listaAbilitazioniPAService = statoServiziPdd.getPortaApplicativa().getFiltroAbilitazioneList();
  454.         }finally {
  455.             StatoServiziPdD.lockActivePAService.release(lock, "addFiltroAbilitazionePA");
  456.         }
  457.     }
  458.     public static void removeFiltroAbilitazionePA(TipoFiltroAbilitazioneServizi tipo) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  459.         //synchronized (semaphoreActivePAService) {
  460.         SemaphoreLock lock = StatoServiziPdD.lockActivePAService.acquireThrowRuntime("removeFiltroAbilitazionePA");
  461.         try {
  462.             
  463.             // rendo persistente modifica
  464.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  465.             if(statoServiziPdd==null){
  466.                 statoServiziPdd = new StatoServiziPdd();
  467.             }
  468.             if(statoServiziPdd.getPortaApplicativa()==null){
  469.                 statoServiziPdd.setPortaApplicativa(new StatoServiziPddPortaApplicativa());
  470.             }
  471.             String daEliminare = StatoServiziPdD.toString(tipo);
  472.             for (int i = 0; i < statoServiziPdd.getPortaApplicativa().sizeFiltroAbilitazioneList(); i++) {
  473.                 String tmp = StatoServiziPdD.toString(statoServiziPdd.getPortaApplicativa().getFiltroAbilitazione(i));
  474.                 if(tmp.equals(daEliminare)){
  475.                     statoServiziPdd.getPortaApplicativa().removeFiltroAbilitazione(i);
  476.                     break;
  477.                 }
  478.             }
  479.             StatoServiziPdD.configPdDReader.updateStatoServiziPdD(statoServiziPdd);
  480.             
  481.             // aggiorno stato in ram
  482.             listaAbilitazioniPAService = statoServiziPdd.getPortaApplicativa().getFiltroAbilitazioneList();
  483.         }finally {
  484.             StatoServiziPdD.lockActivePAService.release(lock, "removeFiltroAbilitazionePA");
  485.         }
  486.     }
  487.     
  488.     private static List<TipoFiltroAbilitazioneServizi> listaDisabilitazioniPAService = null;
  489.     public static void addFiltroDisabilitazionePA(TipoFiltroAbilitazioneServizi tipo) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  490.         //synchronized (semaphoreActivePAService) {
  491.         SemaphoreLock lock = StatoServiziPdD.lockActivePAService.acquireThrowRuntime("addFiltroDisabilitazionePA");
  492.         try {
  493.             
  494.             // rendo persistente modifica
  495.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  496.             if(statoServiziPdd==null){
  497.                 statoServiziPdd = new StatoServiziPdd();
  498.             }
  499.             if(statoServiziPdd.getPortaApplicativa()==null){
  500.                 statoServiziPdd.setPortaApplicativa(new StatoServiziPddPortaApplicativa());
  501.             }
  502.             statoServiziPdd.getPortaApplicativa().addFiltroDisabilitazione(tipo);
  503.             StatoServiziPdD.configPdDReader.updateStatoServiziPdD(statoServiziPdd);
  504.             
  505.             // aggiorno stato in ram
  506.             listaDisabilitazioniPAService = statoServiziPdd.getPortaApplicativa().getFiltroDisabilitazioneList();
  507.         }finally {
  508.             StatoServiziPdD.lockActivePAService.release(lock, "addFiltroDisabilitazionePA");
  509.         }
  510.     }
  511.     public static void removeFiltroDisabilitazionePA(TipoFiltroAbilitazioneServizi tipo) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  512.         //synchronized (semaphoreActivePAService) {
  513.         SemaphoreLock lock = StatoServiziPdD.lockActivePAService.acquireThrowRuntime("removeFiltroDisabilitazionePA");
  514.         try {
  515.             
  516.             // rendo persistente modifica
  517.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  518.             if(statoServiziPdd==null){
  519.                 statoServiziPdd = new StatoServiziPdd();
  520.             }
  521.             if(statoServiziPdd.getPortaApplicativa()==null){
  522.                 statoServiziPdd.setPortaApplicativa(new StatoServiziPddPortaApplicativa());
  523.             }
  524.             String daEliminare = StatoServiziPdD.toString(tipo);
  525.             for (int i = 0; i < statoServiziPdd.getPortaApplicativa().sizeFiltroDisabilitazioneList(); i++) {
  526.                 String tmp = StatoServiziPdD.toString(statoServiziPdd.getPortaApplicativa().getFiltroDisabilitazione(i));
  527.                 if(tmp.equals(daEliminare)){
  528.                     statoServiziPdd.getPortaApplicativa().removeFiltroDisabilitazione(i);
  529.                     break;
  530.                 }
  531.             }
  532.             StatoServiziPdD.configPdDReader.updateStatoServiziPdD(statoServiziPdd);
  533.             
  534.             // aggiorno stato in ram
  535.             listaDisabilitazioniPAService = statoServiziPdd.getPortaApplicativa().getFiltroDisabilitazioneList();
  536.         }finally {
  537.             StatoServiziPdD.lockActivePAService.release(lock, "removeFiltroDisabilitazionePA");
  538.         }
  539.     }
  540.     
  541.     
  542.     
  543.     
  544.     
  545.     /* **************** INTEGRATION MANAGER (GET) ***************** */
  546.     
  547.     public static boolean isIMServiceActive() {
  548.         if(activeIMService!=null){
  549.             return activeIMService;
  550.         }
  551.         else{
  552.             return configPdDReader.isIMServiceActive();
  553.         }
  554.     }
  555.     

  557.     
  558.     
  559.     /* **************** INTEGRATION MANAGER (MODIFY) ***************** */
  560.     
  561.     //private static Integer semaphoreActiveIMService = 1;
  562.     private static final org.openspcoop2.utils.Semaphore lockActiveIMService = new org.openspcoop2.utils.Semaphore("StatoServiziIntegrationManager");
  563.     
  564.     private static Boolean activeIMService = null;  
  565.     public static void setIMServiceActive(boolean stato) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  566.         //synchronized (semaphoreActiveIMService) {
  567.         SemaphoreLock lock = StatoServiziPdD.lockActiveIMService.acquireThrowRuntime("setIMServiceActive");
  568.         try {
  569.                         
  570.             // rendo persistente modifica
  571.             StatoServiziPdd statoServiziPdd = StatoServiziPdD.configPdDReader.getStatoServiziPdD();
  572.             if(statoServiziPdd==null){
  573.                 statoServiziPdd = new StatoServiziPdd();
  574.             }
  575.             if(statoServiziPdd.getIntegrationManager()==null){
  576.                 statoServiziPdd.setIntegrationManager(new StatoServiziPddIntegrationManager());
  577.             }
  578.             if(stato){
  579.                 statoServiziPdd.getIntegrationManager().setStato(CostantiConfigurazione.ABILITATO);
  580.             }else{
  581.                 statoServiziPdd.getIntegrationManager().setStato(CostantiConfigurazione.DISABILITATO);
  582.             }
  583.             StatoServiziPdD.configPdDReader.updateStatoServiziPdD(statoServiziPdd);
  584.             
  585.             // aggiorno stato in ram
  586.             activeIMService = stato;
  587.         }finally {
  588.             StatoServiziPdD.lockActiveIMService.release(lock, "setIMServiceActive");
  589.         }
  590.     }


  593.     
  594.     

  596.     
  597.     
  598.     
  599.     /* **************** UTILITIES ***************** */
  600.     
  601.     private static String toString(TipoFiltroAbilitazioneServizi tipo){
  602.         StringBuilder bf = new StringBuilder();
  603.         bf.append("(");
  604.         
  605.         if(tipo.getTipoSoggettoFruitore()!=null){
  606.             bf.append(" TIPO_FRUITORE:");
  607.             bf.append(tipo.getTipoSoggettoFruitore());
  608.         }
  609.         if(tipo.getSoggettoFruitore()!=null){
  610.             bf.append(" FRUITORE:");
  611.             bf.append(tipo.getSoggettoFruitore());
  612.         }
  613.         if(tipo.getIdentificativoPortaFruitore()!=null){
  614.             bf.append(" PORTA_FRUITORE:");
  615.             bf.append(tipo.getSoggettoFruitore());
  616.         }
  617.         
  618.         if(tipo.getTipoSoggettoErogatore()!=null){
  619.             bf.append(" TIPO_EROGATORE:");
  620.             bf.append(tipo.getTipoSoggettoErogatore());
  621.         }
  622.         if(tipo.getSoggettoErogatore()!=null){
  623.             bf.append(" EROGATORE:");
  624.             bf.append(tipo.getSoggettoErogatore());
  625.         }
  626.         if(tipo.getIdentificativoPortaErogatore()!=null){
  627.             bf.append(" PORTA_EROGATORE:");
  628.             bf.append(tipo.getSoggettoErogatore());
  629.         }
  630.         
  631.         if(tipo.getTipoServizio()!=null){
  632.             bf.append(" TIPO_SERVIZIO:");
  633.             bf.append(tipo.getTipoServizio());
  634.         }
  635.         if(tipo.getServizio()!=null){
  636.             bf.append(" SERVIZIO:");
  637.             bf.append(tipo.getServizio());
  638.         }
  639.         if(tipo.getVersioneServizio()!=null){
  640.             bf.append(" VERSIONE_SERVIZIO:");
  641.             bf.append(tipo.getVersioneServizio());
  642.         }
  643.         
  644.         if(tipo.getAzione()!=null){
  645.             bf.append(" AZIONE:");
  646.             bf.append(tipo.getAzione());
  647.         }
  648.         
  649.         bf.append(" )");
  650.         return bf.toString();
  651.     }
  652.     
  653.     
  654.     
  655.     
  656.     
  657.     
  658.     
  659.     /* **************** IS ENALBED ***************** */
  660.     
  661.     public static boolean isEnabledPortaDelegata(IDSoggetto soggettoFruitore,IDServizio idServizio) throws DriverConfigurazioneException{
  662.         return _isEnabled(isPDServiceActive(), 
  663.                 getPDServiceFiltriAbilitazioneAttiviList(),
  664.                 getPDServiceFiltriDisabilitazioneAttiviList(), 
  665.                 soggettoFruitore, idServizio);
  666.     }
  667.     public static boolean isEnabledPortaApplicativa(IDSoggetto soggettoFruitore,IDServizio idServizio) throws DriverConfigurazioneException{
  668.         return _isEnabled(isPAServiceActive(), 
  669.                 getPAServiceFiltriAbilitazioneAttiviList(),
  670.                 getPAServiceFiltriDisabilitazioneAttiviList(), 
  671.                 soggettoFruitore, idServizio);
  672.     }
  673.     public static boolean isEnabledIntegrationManager() throws DriverConfigurazioneException{
  674.         return _isEnabled(isIMServiceActive(), 
  675.                 null,null,null,null);
  676.     }
  677.     private static boolean _isEnabled(boolean statoServizioAbilitato,
  678.             List<TipoFiltroAbilitazioneServizi> filtriAbilitazioni,
  679.             List<TipoFiltroAbilitazioneServizi> filtriDisabilitazioni,
  680.             IDSoggetto soggettoFruitore,IDServizio idServizio){
  681.         
  682.         if(statoServizioAbilitato){
  683.             
  684.             // il servizio e' abilitato.
  685.             // Verifico se per caso esiste qualche regola puntuale di disabilitazione.
  686.             if(filtriDisabilitazioni!=null){
  687.                 for (TipoFiltroAbilitazioneServizi tipo : filtriDisabilitazioni) {          
  688.                     if(!StatoServiziPdD.isMatch(tipo, soggettoFruitore, idServizio)){
  689.                         continue;
  690.                     }
  691.                     return false; // la regola ha un match: disabilitato!
  692.                 }
  693.             }
  694.             
  695.             return true;
  696.             
  697.         }
  698.         else{
  699.             
  700.             // il servizio e' disabilitato.
  701.             // Verifico se per caso esiste qualche regola puntuale di abilitazione.
  702.             if(filtriAbilitazioni!=null){
  703.                 for (TipoFiltroAbilitazioneServizi tipo : filtriAbilitazioni) {         
  704.                     if(!StatoServiziPdD.isMatch(tipo, soggettoFruitore, idServizio)){
  705.                         continue;
  706.                     }
  707.                     return true; // la regola ha un match: abilitato!
  708.                 }
  709.             }       
  710.             
  711.             return false;
  712.             
  713.         }
  714.     }
  715.     
  716.     private static boolean isMatch(TipoFiltroAbilitazioneServizi tipo,IDSoggetto soggettoFruitore,IDServizio idServizio){
  717.         if(soggettoFruitore==null){
  718.             return false;
  719.         }
  720.         if(tipo.getTipoSoggettoFruitore()!=null){
  721.             if(!tipo.getTipoSoggettoFruitore().equals(soggettoFruitore.getTipo())){
  722.                 return false;
  723.             }
  724.         }
  725.         if(tipo.getSoggettoFruitore()!=null){
  726.             if(!tipo.getSoggettoFruitore().equals(soggettoFruitore.getNome())){
  727.                 return false;
  728.             }
  729.         }
  730.         if(tipo.getIdentificativoPortaFruitore()!=null){
  731.             if(!tipo.getIdentificativoPortaFruitore().equals(soggettoFruitore.getCodicePorta())){
  732.                 return false;
  733.             }
  734.         }

  736.         if(idServizio==null){
  737.             return false;
  738.         }
  739.         
  740.         if(idServizio.getSoggettoErogatore()==null){
  741.             return false;
  742.         }
  743.         if(tipo.getTipoSoggettoErogatore()!=null){
  744.             if(!tipo.getTipoSoggettoErogatore().equals(idServizio.getSoggettoErogatore().getTipo())){
  745.                 return false;
  746.             }
  747.         }
  748.         if(tipo.getSoggettoErogatore()!=null){
  749.             if(!tipo.getSoggettoErogatore().equals(idServizio.getSoggettoErogatore().getNome())){
  750.                 return false;
  751.             }
  752.         }
  753.         if(tipo.getIdentificativoPortaErogatore()!=null){
  754.             if(!tipo.getIdentificativoPortaErogatore().equals(idServizio.getSoggettoErogatore().getCodicePorta())){
  755.                 return false;
  756.             }
  757.         }
  758.         
  759.         if(tipo.getTipoServizio()!=null){
  760.             if(!tipo.getTipoServizio().equals(idServizio.getTipo())){
  761.                 return false;
  762.             }
  763.         }
  764.         if(tipo.getServizio()!=null){
  765.             if(!tipo.getServizio().equals(idServizio.getNome())){
  766.                 return false;
  767.             }
  768.         }
  769.         if(tipo.getVersioneServizio()!=null){
  770.             if(tipo.getVersioneServizio().intValue() != idServizio.getVersione().intValue() ){
  771.                 return false;
  772.             }
  773.         }
  774.         if(tipo.getAzione()!=null){
  775.             if(!tipo.getAzione().equals(idServizio.getAzione())){
  776.                 return false;
  777.             }
  778.         }
  779.         
  780.         return true;
  781.     }
  782. }
Created with JaCoCo 0.8.8.202204050719