GestorePdDThread.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.  */


  22. package org.openspcoop2.web.ctrlstat.gestori;

  24. import java.sql.Connection;
  25. import java.sql.Timestamp;
  26. import java.util.ArrayList;
  27. import java.util.List;

  29. import javax.jms.JMSException;
  30. import javax.jms.ObjectMessage;
  31. import javax.jms.Queue;
  32. import javax.jms.QueueConnection;
  33. import javax.jms.QueueConnectionFactory;
  34. import javax.jms.QueueReceiver;
  35. import javax.jms.QueueSession;
  36. import javax.xml.ws.BindingProvider;

  38. import org.openspcoop2.core.config.IdPortaApplicativa;
  39. import org.openspcoop2.core.config.IdPortaDelegata;
  40. import org.openspcoop2.core.config.IdServizioApplicativo;
  41. import org.openspcoop2.core.config.IdSoggetto;
  42. import org.openspcoop2.core.config.PortaApplicativa;
  43. import org.openspcoop2.core.config.PortaDelegata;
  44. import org.openspcoop2.core.config.ServizioApplicativo;
  45. import org.openspcoop2.core.config.Soggetto;
  46. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  47. import org.openspcoop2.core.config.ws.client.portaapplicativa.all.PortaApplicativaSoap11Service;
  48. import org.openspcoop2.core.config.ws.client.portadelegata.all.PortaDelegataSoap11Service;
  49. import org.openspcoop2.core.config.ws.client.servizioapplicativo.all.ServizioApplicativoSoap11Service;
  50. import org.openspcoop2.core.config.ws.client.soggetto.all.SoggettoSoap11Service;
  51. import org.openspcoop2.core.id.IDPortaApplicativa;
  52. import org.openspcoop2.core.id.IDPortaDelegata;
  53. import org.openspcoop2.core.id.IDServizioApplicativo;
  54. import org.openspcoop2.core.id.IDSoggetto;
  55. import org.openspcoop2.pdd.config.OpenSPCoop2ConfigurationException;
  56. import org.openspcoop2.utils.Utilities;
  57. import org.openspcoop2.utils.transport.jms.ExceptionListenerJMS;
  58. import org.openspcoop2.web.ctrlstat.config.ConsoleProperties;
  59. import org.openspcoop2.web.ctrlstat.config.DatasourceProperties;
  60. import org.openspcoop2.web.ctrlstat.core.ControlStationCoreException;
  61. import org.openspcoop2.web.ctrlstat.core.ControlStationLogger;
  62. import org.openspcoop2.web.ctrlstat.core.DBManager;
  63. import org.openspcoop2.web.ctrlstat.core.QueueManager;
  64. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  65. import org.openspcoop2.web.ctrlstat.costanti.OperationsParameter;
  66. import org.openspcoop2.web.ctrlstat.costanti.TipoOggettoDaSmistare;
  67. import org.openspcoop2.web.ctrlstat.dao.PdDControlStation;
  68. import org.openspcoop2.web.ctrlstat.servlet.pa.PorteApplicativeCore;
  69. import org.openspcoop2.web.ctrlstat.servlet.pd.PorteDelegateCore;
  70. import org.openspcoop2.web.ctrlstat.servlet.pdd.PddCore;
  71. import org.openspcoop2.web.ctrlstat.servlet.sa.ServiziApplicativiCore;
  72. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCore;
  73. import org.openspcoop2.web.lib.queue.ClassQueue;
  74. import org.openspcoop2.web.lib.queue.ClassQueueException;
  75. import org.openspcoop2.web.lib.queue.costanti.OperationStatus;
  76. import org.openspcoop2.web.lib.queue.costanti.Operazione;
  77. import org.openspcoop2.web.lib.queue.costanti.TipoOperazione;
  78. import org.openspcoop2.web.lib.queue.dao.FilterParameter;
  79. import org.openspcoop2.web.lib.queue.dao.Operation;
  80. import org.openspcoop2.web.lib.queue.dao.Parameter;
  81. import org.slf4j.Logger;

  83. /**
  84.  * GestorePdDThread
  85.  * 
  86.  * @author Andrea Poli (apoli@link.it)
  87.  * @author Stefano Corallo (corallo@link.it)
  88.  * @author Sandra Giangrandi (sandra@link.it)
  89.  * @author $Author$
  90.  * @version $Rev$, $Date$
  91.  * 
  92.  */
  93. public class GestorePdDThread extends GestoreGeneral {

  95.     private ConsoleProperties consoleProperties;
  96.     private DatasourceProperties datasourceProperties;
  97.     
  98.     /** Logger utilizzato per debug. */
  99.     private Logger log = null;

  101.     /** run */
  102.     private boolean stop = false;
  103.     private boolean isRunning = false;
  104.     public boolean isRunning() {
  105.         return this.isRunning;
  106.     }

  108.     /** Back End Connector */
  109.     // private BackendConnector backEndConnector;
  110.     private PddCore pddCore;
  111.     private SoggettiCore soggettiCore;
  112.     private PorteApplicativeCore paCore;
  113.     private PorteDelegateCore pdCore;
  114.     private ServiziApplicativiCore saCore;

  116.     /** Nome della coda (che corrisponde al nome del pdd) */
  117.     private String pddName;

  119.     private String nomeThread;

  121.     // JMS
  122.     private QueueReceiver receiver = null;
  123.     private Queue queue = null;
  124.     private QueueConnectionFactory qcf = null;
  125.     private QueueConnection qc = null;
  126.     private QueueSession qs = null;

  128.     // DB
  129.     private DBManager dbm;
  130.     private Connection con;

  132.     private boolean singlePdD = false;

  134.     /** Web Service */
  135.     private org.openspcoop2.core.config.ws.client.portaapplicativa.all.PortaApplicativaSoap11Service portaApplicativaService;
  136.     private org.openspcoop2.core.config.ws.client.portadelegata.all.PortaDelegataSoap11Service portaDelegataService;
  137.     private org.openspcoop2.core.config.ws.client.servizioapplicativo.all.ServizioApplicativoSoap11Service servizioApplicativoService;
  138.     private org.openspcoop2.core.config.ws.client.soggetto.all.SoggettoSoap11Service soggettoService;
  139.     
  140.     private org.openspcoop2.core.config.ws.client.portaapplicativa.all.PortaApplicativa portaApplicativaPort;
  141.     private org.openspcoop2.core.config.ws.client.portadelegata.all.PortaDelegata portaDelegataPort;
  142.     private org.openspcoop2.core.config.ws.client.servizioapplicativo.all.ServizioApplicativo servizioApplicativoPort;
  143.     private org.openspcoop2.core.config.ws.client.soggetto.all.Soggetto soggettoPort;

  145.     private ExceptionListenerJMS exceptionListenerJMS = new ExceptionListenerJMS();

  147.     /** Costruttore 
  148.      * @throws OpenSPCoop2ConfigurationException */
  149.     public GestorePdDThread(String nomeCoda) throws OpenSPCoop2ConfigurationException {

  151.         this.log = ControlStationLogger.getGestorePddLogger();

  153.         // setto il nome della coda
  154.         this.pddName = nomeCoda;

  156.         this.nomeThread = "GestorePDD[" + this.pddName + "]";
  157.         
  158.         this.consoleProperties = ConsoleProperties.getInstance();
  159.         this.datasourceProperties = DatasourceProperties.getInstance();

  161.     }

  163.     /**
  164.      * Metodo che fa partire il Thread.
  165.      * 
  166.      * @since 0.4
  167.      */
  168.     @Override
  169.     public void run() {

  171.         this.isRunning = true;
  172.         
  173.         try {
  174.             this.initGestore();

  176.             if (this.singlePdD) {
  177.                 this.log.warn(this.nomeThread + " non avviato: govwayConsole avviata in singlePdD mode.");
  178.                 return;
  179.             }

  181.             this.dbm = DBManager.getInstance();
  182.         } catch (GestoreNonAttivoException e) {
  183.             this.log.warn("Inizializzazione Gestore non effettuata : " + e.getMessage());
  184.             this.stop = true;
  185.         } catch (Exception e) {
  186.             this.log.error("Inizializzazione Gestore Fallita : " + e.getMessage(), e);
  187.             this.stop = true;
  188.         }

  190.         // Avvio Gestione Pdd
  191.         boolean riconnessioneConErrore = false;
  192.         while (this.stop == false) {
  193.             
  194.             ClassQueue operationManager = null;
  195.             Operation operation = null;
  196.             try {

  198.                 // riconnessione precedente non riuscita.....
  199.                 if (riconnessioneConErrore) {
  200.                     throw new JMSException("RiconnessioneJMS non riuscita...");
  201.                 }

  203.                 // Controllo ExceptionListenerJMS
  204.                 if (this.exceptionListenerJMS.isConnessioneCorrotta()) {
  205.                     this.log.error("ExceptionJMSListener ha rilevato una connessione jms corrotta", this.exceptionListenerJMS.getException());
  206.                     throw new JMSException("ExceptionJMSListener ha rilevato una connessione jms corrotta: " + this.exceptionListenerJMS.getException().getMessage());
  207.                 }

  209.                 this.log.info(this.nomeThread + ": Ricezione operazione...");
  210.                 ObjectMessage richiesta = null;
  211.                 while (this.stop == false) {
  212.                     richiesta = (ObjectMessage) this.receiver.receive(CostantiControlStation.INTERVALLO_RECEIVE);
  213.                     if (richiesta != null) {
  214.                         break;
  215.                     }
  216.                 }
  217.                 if (this.stop == true) {
  218.                     break;
  219.                 }

  221.                 // Attendo tempi di delay (TransazioneSimilXA)
  222.                 Utilities.sleep(CostantiControlStation.INTERVALLO_TRANSAZIONE_XA);

  224.                 // Ricezione Operazione
  225.                 Object objOp;
  226.                 try {
  227.                     objOp = (Object) richiesta.getObject();
  228.                 } catch (Exception e) {
  229.                     this.log.error(this.nomeThread + ": Ricevuta richiesta con tipo errato:" + e.toString());
  230.                     this.qs.commit();
  231.                     continue;
  232.                 }
  233.                 String idOperazione = richiesta.getStringProperty("ID");

  235.                 int idOp = (int) Integer.parseInt(objOp.toString());
  236.                 if (idOp == 0) {
  237.                     this.log.error(this.nomeThread + ": Ricevuta richiesta con parametri scorretti.");
  238.                     this.qs.commit();
  239.                     continue;
  240.                 }

  242.                 this.log.info(CostantiControlStation.OPERATIONS_DELIMITER+"GestorePDD: Ricevuta richiesta di operazione con ID: " + idOperazione + " id_operation [" + idOp + "]");

  244.                 this.con = this.dbm.getConnection();

  246.                 // Prendo i dati dell'operazione
  247.                 String tipoOperazioneParam = "", tipoOperazioneCRUDParam = "", singleSu = "";
  248.                 int deleted = 0;
  249.                 operationManager = new ClassQueue(this.con, this.datasourceProperties.getTipoDatabase());
  250.                 try {
  251.                     operation = operationManager.getOperation(idOp);
  252.                 } catch (Exception e) {
  253.                     this.log.error("Impossibile recuperare l'operation con id=" + idOp, e);
  254.                     this.qs.rollback();
  255.                     this.dbm.releaseConnection(this.con);
  256.                     continue;
  257.                 }

  259.                 tipoOperazioneParam = operation.getTipo();
  260.                 tipoOperazioneCRUDParam = operation.getOperation();
  261.                 singleSu = operation.getSuperUser();
  262.                 deleted = operation.isDeleted() ? 1 : 0;

  264.                 // Operazione in gestione
  265.                 GestioneOperazione operazioneInGestione = new GestioneOperazione(this.dbm, this.con, this.qs, operation, operationManager, this.log, tipoOperazioneCRUDParam, this.nomeThread);

  267.                 // Oggetto in Gestione
  268.                 String oggettoDaSmistare = operation.getParameterValue(OperationsParameter.OGGETTO.getNome());
  269.                 if (oggettoDaSmistare == null || "".equals(oggettoDaSmistare)) {
  270.                     operazioneInGestione.invalid("Ricevuta operazione con parametri scorretti (oggetto:" + oggettoDaSmistare + ") non valida");
  271.                     continue;
  272.                 }
  273.                 TipoOggettoDaSmistare tipoOggettoDaSmistare = null;
  274.                 try{
  275.                     tipoOggettoDaSmistare = TipoOggettoDaSmistare.valueOf(oggettoDaSmistare);
  276.                     if(tipoOggettoDaSmistare==null){
  277.                         throw new Exception("Conversione in Enumeration non riuscita");
  278.                     }
  279.                 }catch(Exception e){
  280.                     this.log.error("Ricevuta operazione con parametri scorretti (oggetto:" + oggettoDaSmistare + ") non valida: "+e.getMessage(), e);
  281.                     operazioneInGestione.invalid("Ricevuta operazione con parametri scorretti (oggetto:" + oggettoDaSmistare + ") non valida: "+e.getMessage());
  282.                     continue;
  283.                 }

  285.                 // Check valori operazioni
  286.                 if ((tipoOperazioneParam == null) || tipoOperazioneParam.equals("") || (tipoOperazioneCRUDParam == null) || tipoOperazioneCRUDParam.equals("") || (singleSu == null) || singleSu.equals("")) {
  287.                     operazioneInGestione.invalid("Ricevuta operazione con parametri scorretti :" + operation.toString());
  288.                     continue;
  289.                 }
  290.                 
  291.                 // Operazione CRUD      
  292.                 Operazione tipoOperazioneCRUD = null;
  293.                 try{
  294.                     tipoOperazioneCRUD = Operazione.valueOf(tipoOperazioneCRUDParam);
  295.                     if(tipoOperazioneCRUD==null){
  296.                         throw new Exception("Conversione in Enumeration non riuscita");
  297.                     }
  298.                 }catch(Exception e){
  299.                     this.log.error("Ricevuta operazione con parametri scorretti (tipoOperazioneCRUD:" + tipoOperazioneCRUDParam + ") non valida: "+e.getMessage(), e);
  300.                     operazioneInGestione.invalid("Ricevuta operazione con parametri scorretti (tipoOperazioneCRUD:" + tipoOperazioneCRUDParam + ") non valida: "+e.getMessage());
  301.                     continue;
  302.                 }
  303.                 
  304.                 // Operazione Queue
  305.                 TipoOperazione tipoOperazione = null;
  306.                 try{
  307.                     tipoOperazione = TipoOperazione.valueOf(tipoOperazioneParam);
  308.                     if(tipoOperazione==null){
  309.                         throw new Exception("Conversione in Enumeration non riuscita");
  310.                     }
  311.                 }catch(Exception e){
  312.                     this.log.error("Ricevuta operazione con parametri scorretti (tipoOperazione:" + tipoOperazioneParam + ") non valida: "+e.getMessage(), e);
  313.                     operazioneInGestione.invalid("Ricevuta operazione con parametri scorretti (tipoOperazione:" + tipoOperazioneParam + ") non valida: "+e.getMessage());
  314.                     continue;
  315.                 }
  316.                 

  318.                 this.log.debug("Ricevuta Operation:" + operation.toString());

  320.                 // ID Table
  321.                 int idTable = -1;
  322.                 String idTableString = null;
  323.                 try {
  324.                     idTableString = operation.getParameterValue(OperationsParameter.ID_TABLE.getNome());
  325.                     idTable = Integer.parseInt(idTableString);
  326.                     if (idTable <= 0)
  327.                         throw new Exception("IDTable <= 0");
  328.                 } catch (Exception e) {
  329.                     operazioneInGestione.invalid("Ricevuta operazione con parametri scorretti (idTable[" + idTableString + "]) non valida: " + e.getMessage());
  330.                     continue;
  331.                 }

  333.                 if (!TipoOggettoDaSmistare.soggetto.equals(tipoOggettoDaSmistare) && 
  334.                         !TipoOggettoDaSmistare.pa.equals(tipoOggettoDaSmistare) && 
  335.                         !TipoOggettoDaSmistare.pd.equals(tipoOggettoDaSmistare) && 
  336.                         !TipoOggettoDaSmistare.servizioApplicativo.equals(tipoOggettoDaSmistare)  ) {
  337.                     operazioneInGestione.invalid("Ricevuta operazione con parametri scorretti (oggetto:" + tipoOggettoDaSmistare.name() + ")");
  338.                     continue;
  339.                 }
  340.                 

  342.                 /* ----- filtro per mantenimento ordine operazioni ----- */
  343.                 List<FilterParameter> filtroOrdine = new ArrayList<FilterParameter>();

  345.                 FilterParameter idTableFiltro = new FilterParameter();
  346.                 idTableFiltro.addFilterParameter(new Parameter(OperationsParameter.ID_TABLE.getNome(), idTable + ""));
  347.                 filtroOrdine.add(idTableFiltro);

  349.                 if (TipoOggettoDaSmistare.soggetto.equals(tipoOggettoDaSmistare)) {

  351.                     // Chiave primaria per il soggetto e' tipo e nome
  352.                     String tipoSoggFiltro = operation.getParameterValue(OperationsParameter.TIPO_SOGGETTO.getNome());
  353.                     String nomeSoggFiltro = operation.getParameterValue(OperationsParameter.NOME_SOGGETTO.getNome());
  354.                     FilterParameter soggettoFiltro = new FilterParameter();
  355.                     soggettoFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SOGGETTO.getNome(), tipoSoggFiltro));
  356.                     soggettoFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SOGGETTO.getNome(), nomeSoggFiltro));
  357.                     filtroOrdine.add(soggettoFiltro);

  359.                     // OLD valori per tipo e nome se abbiamo una operazione di
  360.                     // change
  361.                     if (Operazione.change.equals(tipoOperazioneCRUD)) {
  362.                         String oldTipoSogg = operation.getParameterValue(OperationsParameter.OLD_TIPO_SOGGETTO.getNome());
  363.                         String oldNomeSogg = operation.getParameterValue(OperationsParameter.OLD_NOME_SOGGETTO.getNome());
  364.                         FilterParameter soggettoOldFiltro = new FilterParameter();
  365.                         soggettoOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_TIPO_SOGGETTO.getNome(), oldTipoSogg));
  366.                         soggettoOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SOGGETTO.getNome(), oldNomeSogg));
  367.                         filtroOrdine.add(soggettoOldFiltro);
  368.                     }
  369.                 } else if (TipoOggettoDaSmistare.pa.equals(tipoOggettoDaSmistare)) {

  371.                     // Chiave primaria che identifica una pa sono il nome e il soggetto proprietario
  372.                     String nomePAFiltro = operation.getParameterValue(OperationsParameter.NOME_PA.getNome());
  373.                     String tipoSoggFiltro = operation.getParameterValue(OperationsParameter.TIPO_SOGGETTO.getNome());
  374.                     String nomeSoggFiltro = operation.getParameterValue(OperationsParameter.NOME_SOGGETTO.getNome());
  375.                     FilterParameter paFiltro = new FilterParameter();
  376.                     paFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_PA.getNome(), nomePAFiltro));
  377.                     paFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SOGGETTO.getNome(), tipoSoggFiltro));
  378.                     paFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SOGGETTO.getNome(), nomeSoggFiltro));
  379.                     filtroOrdine.add(paFiltro);
  380.                     
  381.                     // OLD valori per tipo e nome soggetto proprietario o per
  382.                     // nome PA
  383.                     // se abbiamo una operazione di change
  384.                     if ((Operazione.change.equals(tipoOperazioneCRUD))) {
  385.                         String oldNomePAFiltro = operation.getParameterValue(OperationsParameter.OLD_NOME_PA.getNome());
  386.                         String oldTipoProprietarioFiltro = operation.getParameterValue(OperationsParameter.OLD_TIPO_SOGGETTO.getNome());
  387.                         String oldNomeProprietarioFiltro = operation.getParameterValue(OperationsParameter.OLD_NOME_SOGGETTO.getNome());

  389.                         FilterParameter proprietarioOldFiltro = new FilterParameter();
  390.                         proprietarioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_PA.getNome(), nomePAFiltro));
  391.                         proprietarioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_TIPO_SOGGETTO.getNome(), oldTipoProprietarioFiltro));
  392.                         proprietarioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SOGGETTO.getNome(), oldNomeProprietarioFiltro));
  393.                         filtroOrdine.add(proprietarioOldFiltro);

  395.                         FilterParameter nomeOldFiltro = new FilterParameter();
  396.                         nomeOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_PA.getNome(), oldNomePAFiltro));
  397.                         nomeOldFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SOGGETTO.getNome(), tipoSoggFiltro));
  398.                         nomeOldFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SOGGETTO.getNome(), nomeSoggFiltro));
  399.                         filtroOrdine.add(nomeOldFiltro);

  401.                         FilterParameter oldFiltro = new FilterParameter();
  402.                         oldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_PA.getNome(), oldNomePAFiltro));
  403.                         oldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_TIPO_SOGGETTO.getNome(), oldTipoProprietarioFiltro));
  404.                         oldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SOGGETTO.getNome(), oldNomeProprietarioFiltro));
  405.                         filtroOrdine.add(oldFiltro);
  406.                     }
  407.                     
  408.                 } else if (TipoOggettoDaSmistare.pd.equals(tipoOggettoDaSmistare)) {

  410.                     // Chiave primaria che identifica una pd sono il nome e il soggetto proprietario
  411.                     String nomePDFiltro = operation.getParameterValue(OperationsParameter.NOME_PD.getNome());
  412.                     String tipoSoggFiltro = operation.getParameterValue(OperationsParameter.TIPO_SOGGETTO.getNome());
  413.                     String nomeSoggFiltro = operation.getParameterValue(OperationsParameter.NOME_SOGGETTO.getNome());
  414.                     FilterParameter pdFiltro = new FilterParameter();
  415.                     pdFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_PD.getNome(), nomePDFiltro));
  416.                     pdFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SOGGETTO.getNome(), tipoSoggFiltro));
  417.                     pdFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SOGGETTO.getNome(), nomeSoggFiltro));
  418.                     filtroOrdine.add(pdFiltro);

  420.                     // OLD valori per tipo e nome soggetto proprietario o per
  421.                     // nome PD
  422.                     // se abbiamo una operazione di change
  423.                     if ((Operazione.change.equals(tipoOperazioneCRUD))) {
  424.                         String oldNomePDFiltro = operation.getParameterValue(OperationsParameter.OLD_NOME_PD.getNome());
  425.                         String oldTipoProprietarioFiltro = operation.getParameterValue(OperationsParameter.OLD_TIPO_SOGGETTO.getNome());
  426.                         String oldNomeProprietarioFiltro = operation.getParameterValue(OperationsParameter.OLD_NOME_SOGGETTO.getNome());

  428.                         FilterParameter proprietarioOldFiltro = new FilterParameter();
  429.                         proprietarioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_PD.getNome(), nomePDFiltro));
  430.                         proprietarioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_TIPO_SOGGETTO.getNome(), oldTipoProprietarioFiltro));
  431.                         proprietarioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SOGGETTO.getNome(), oldNomeProprietarioFiltro));
  432.                         filtroOrdine.add(proprietarioOldFiltro);

  434.                         FilterParameter nomeOldFiltro = new FilterParameter();
  435.                         nomeOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_PD.getNome(), oldNomePDFiltro));
  436.                         nomeOldFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SOGGETTO.getNome(), tipoSoggFiltro));
  437.                         nomeOldFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SOGGETTO.getNome(), nomeSoggFiltro));
  438.                         filtroOrdine.add(nomeOldFiltro);

  440.                         FilterParameter oldFiltro = new FilterParameter();
  441.                         oldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_PD.getNome(), oldNomePDFiltro));
  442.                         oldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_TIPO_SOGGETTO.getNome(), oldTipoProprietarioFiltro));
  443.                         oldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SOGGETTO.getNome(), oldNomeProprietarioFiltro));
  444.                         filtroOrdine.add(oldFiltro);
  445.                     }
  446.                 } else if (TipoOggettoDaSmistare.servizioApplicativo.equals(tipoOggettoDaSmistare)) {

  448.                     // Chiave che indentifica il servizio applicativo sono nome
  449.                     // e soggetto proprietario
  450.                     String nomeServizioApplicativoFiltro = operation.getParameterValue(OperationsParameter.NOME_SERVIZIO_APPLICATIVO.getNome());
  451.                     String tipoSoggettoFiltro = operation.getParameterValue(OperationsParameter.TIPO_SOGGETTO.getNome());
  452.                     String nomeSoggettoFiltro = operation.getParameterValue(OperationsParameter.NOME_SOGGETTO.getNome());
  453.                     FilterParameter saFiltro = new FilterParameter();
  454.                     saFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SERVIZIO_APPLICATIVO.getNome(), nomeServizioApplicativoFiltro));
  455.                     saFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SOGGETTO.getNome(), tipoSoggettoFiltro));
  456.                     saFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SOGGETTO.getNome(), nomeSoggettoFiltro));
  457.                     filtroOrdine.add(saFiltro);

  459.                     // OLD valori per tipo e nome soggetto proprietario o per
  460.                     // nome ServizioApplicativo
  461.                     // se abbiamo una operazione di change
  462.                     if ((Operazione.change.equals(tipoOperazioneCRUD))) {
  463.                         String oldNomeSAFiltro = operation.getParameterValue(OperationsParameter.OLD_NOME_SERVIZIO_APPLICATIVO.getNome());
  464.                         String oldTipoProprietarioFiltro = operation.getParameterValue(OperationsParameter.OLD_TIPO_SOGGETTO.getNome());
  465.                         String oldNomeProprietarioFiltro = operation.getParameterValue(OperationsParameter.OLD_NOME_SOGGETTO.getNome());

  467.                         FilterParameter proprietarioOldFiltro = new FilterParameter();
  468.                         proprietarioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SERVIZIO_APPLICATIVO.getNome(), nomeServizioApplicativoFiltro));
  469.                         proprietarioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_TIPO_SOGGETTO.getNome(), oldTipoProprietarioFiltro));
  470.                         proprietarioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SOGGETTO.getNome(), oldNomeProprietarioFiltro));
  471.                         filtroOrdine.add(proprietarioOldFiltro);

  473.                         FilterParameter nomeOldFiltro = new FilterParameter();
  474.                         nomeOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SERVIZIO_APPLICATIVO.getNome(), oldNomeSAFiltro));
  475.                         nomeOldFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SOGGETTO.getNome(), tipoSoggettoFiltro));
  476.                         nomeOldFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SOGGETTO.getNome(), nomeSoggettoFiltro));
  477.                         filtroOrdine.add(nomeOldFiltro);

  479.                         FilterParameter oldFiltro = new FilterParameter();
  480.                         oldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SERVIZIO_APPLICATIVO.getNome(), oldNomeSAFiltro));
  481.                         oldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_TIPO_SOGGETTO.getNome(), oldTipoProprietarioFiltro));
  482.                         oldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SOGGETTO.getNome(), oldNomeProprietarioFiltro));
  483.                         filtroOrdine.add(oldFiltro);
  484.                     }
  485.                     
  486.                 } else {
  487.                     operazioneInGestione.invalid("Ricevuta operazione con oggetto non conosciuto dal Gestore (oggetto:" + tipoOggettoDaSmistare.name() + ")");
  488.                     continue;
  489.                 }

  491.                 operationManager.setOperazioniPrecedentiByFilterSearch(operation, filtroOrdine.toArray(new FilterParameter[0]), false, tipoOggettoDaSmistare.name());
  492.                 if (operation.sizeOperazioniPrecedentiAncoraDaGestireList() > 0) {
  493.                     StringBuilder operazioniPrecedenti = new StringBuilder();
  494.                     for (int i = 0; i < operation.sizeOperazioniPrecedentiAncoraDaGestireList(); i++) {
  495.                         operazioniPrecedenti.append("\n" + operation.getOperazionePrecedenteAncoraDaGestire(i).toString());
  496.                     }
  497.                     operazioneInGestione.error("Ricevuta operazione su una entita' di cui esistono operazioni attivate precedentementi ancora in coda:\n" + operazioniPrecedenti.toString());
  498.                     continue;
  499.                 }

  501.                 /* ----- Fine filtro per mantenimento ordine operazioni ----- */

  503.                 // Se l'operazione e' stata marcata come deleted, la rimuovo
  504.                 // dalla coda (basta fare il commit)
  505.                 String statoOperazioneCancellata = "";
  506.                 if (deleted == 1) {

  508.                     operazioneInGestione.delete();
  509.                     statoOperazioneCancellata = " (L'operazione non e' stata propagata, possiede una stato 'deleted')";

  511.                 } else {

  513.                     // Effettuo filtro di altre modifiche con stesso
  514.                     // idOperazione
  515.                     if (Operazione.change.equals(tipoOperazioneCRUD)) {
  516.                         
  517.                         List<Operation> listFilteredOperations = filterOperations(idOperazione, operationManager, operation, this.qs, this.queue, this.log);

  519.                         if (listFilteredOperations.size() > 0) {
  520.                             StringBuilder bf = new StringBuilder();
  521.                             for (Operation operationFiltered : listFilteredOperations) {
  522.                                 if(bf.length()>0){
  523.                                     bf.append(",");
  524.                                 }
  525.                                 bf.append(operationFiltered.getId());
  526.                             }
  527.                             this.log.debug(getName() + ": Filtrate [" + listFilteredOperations.size() + "] operation con stessa property jms ['ID'="+idOperazione+"] (ids: "+bf.toString()+")");
  528.                         }
  529.                     }


  532.                     // OPERAZIONE CHE RIGUARDA IL SOGGETTO
  533.                     if (TipoOggettoDaSmistare.soggetto.equals(tipoOggettoDaSmistare)) {

  535.                         String oldTipoSoggetto = operation.getParameterValue(OperationsParameter.OLD_TIPO_SOGGETTO.getNome());
  536.                         String oldNomeSoggetto = operation.getParameterValue(OperationsParameter.OLD_NOME_SOGGETTO.getNome());
  537.                         String tipoSogg = operation.getParameterValue(OperationsParameter.TIPO_SOGGETTO.getNome());
  538.                         String nomeSogg = operation.getParameterValue(OperationsParameter.NOME_SOGGETTO.getNome());

  540.                         // Ottengo nuova immagine del soggetto
  541.                         // Soggetto soggetto = null;
  542.                         Soggetto soggetto = null;

  544.                         try {
  545.                             // soggetto =
  546.                             // backEndConnector.getDatiSoggetto(idTable);
  547.                             if (Operazione.add.equals(tipoOperazioneCRUD)) {

  549.                                 try {
  550.                                     soggetto = this.soggettiCore.getSoggetto(idTable);
  551.                                 } catch (DriverConfigurazioneNotFound de) {
  552.                                     operazioneInGestione.waitBeforeInvalid("Soggetto non esistente nel database della govwayConsole: " + de.toString());
  553.                                     continue;
  554.                                 } catch (Exception e) {
  555.                                     operazioneInGestione.error("Riscontrato errore durante la get dell'immagine del soggetto: " + e.toString(), e);
  556.                                     continue;
  557.                                 }

  559.                                 this.soggettoPort.create(soggetto);

  561.                             } else if (Operazione.change.equals(tipoOperazioneCRUD)) {

  563.                                 try {
  564.                                     soggetto = this.soggettiCore.getSoggetto(idTable);
  565.                                 } catch (DriverConfigurazioneNotFound de) {
  566.                                     operazioneInGestione.waitBeforeInvalid("Soggetto non esistente nel database della govwayConsole: " + de.toString());
  567.                                     continue;
  568.                                 } catch (Exception e) {
  569.                                     operazioneInGestione.error("Riscontrato errore durante la get dell'immagine del soggetto: " + e.toString(), e);
  570.                                     continue;
  571.                                 }
  572.                                 if(oldTipoSoggetto!=null && oldNomeSoggetto!=null){
  573.                                     IDSoggetto oldIDSoggettoForUpdate = new IDSoggetto(oldTipoSoggetto, oldNomeSoggetto);
  574.                                     soggetto.setOldIDSoggettoForUpdate(oldIDSoggettoForUpdate);
  575.                                 }

  577.                                 IdSoggetto idSoggetto = new IdSoggetto();
  578.                                 if(oldTipoSoggetto!=null)
  579.                                     idSoggetto.setTipo(oldTipoSoggetto);
  580.                                 else
  581.                                     idSoggetto.setTipo(tipoSogg);
  582.                                 if(oldNomeSoggetto!=null)
  583.                                     idSoggetto.setNome(oldNomeSoggetto);
  584.                                 else
  585.                                     idSoggetto.setNome(nomeSogg);
  586.                                 
  587.                                 this.soggettoPort.update(idSoggetto,soggetto);

  589.                             } else if (Operazione.del.equals(tipoOperazioneCRUD)) {
  590.                                 
  591.                                 IdSoggetto idSoggetto = new IdSoggetto();
  592.                                 idSoggetto.setTipo(tipoSogg);
  593.                                 idSoggetto.setNome(nomeSogg);

  595.                                 this.soggettoPort.deleteById(idSoggetto);

  597.                             }

  599.                         } catch (Exception e) {
  600.                             soggetto = null;
  601.                             operazioneInGestione.error("Riscontrato errore durante operazione su soggetto: " + e.toString(), e);
  602.                             continue;
  603.                         }

  605.                     }

  607.                     // OPERAZIONE CHE RIGUARDA LA PORTA APPLICATIVA
  608.                     if (TipoOggettoDaSmistare.pa.equals(tipoOggettoDaSmistare)) {

  610.                         String nomePA = operation.getParameterValue(OperationsParameter.NOME_PA.getNome());
  611.                         String oldNomePA = operation.getParameterValue(OperationsParameter.OLD_NOME_PA.getNome()); 

  613.                         // Ottengo nuova immagine della porta applicativa
  614.                         PortaApplicativa pa = null;
  615.                         try {
  616.                             // pa = backEndConnector.getDatiPA(idTable);
  617.                             if (Operazione.add.equals(tipoOperazioneCRUD)) {

  619.                                 try {
  620.                                     pa = this.paCore.getPortaApplicativa(idTable);
  621.                                 } catch (DriverConfigurazioneNotFound de) {
  622.                                     operazioneInGestione.waitBeforeInvalid("Porta Applicativa non esistente nel database della govwayConsole: " + de.toString());
  623.                                     continue;
  624.                                 } catch (Exception e) {
  625.                                     operazioneInGestione.error("Riscontrato errore durante la get dell'immagine della Porta Applicativa: " + e.toString(), e);
  626.                                     continue;
  627.                                 }

  629.                                 this.portaApplicativaPort.create(pa);

  631.                             } else if (Operazione.change.equals(tipoOperazioneCRUD)) {

  633.                                 try {
  634.                                     pa = this.paCore.getPortaApplicativa(idTable);
  635.                                 } catch (DriverConfigurazioneNotFound de) {
  636.                                     operazioneInGestione.waitBeforeInvalid("Porta Applicativa non esistente nel database della govwayConsole: " + de.toString());
  637.                                     continue;
  638.                                 } catch (Exception e) {
  639.                                     operazioneInGestione.error("Riscontrato errore durante la get dell'immagine della Porta Applicativa: " + e.toString(), e);
  640.                                     continue;
  641.                                 }

  643.                                 // soggetto proprietario
  644.                                 Soggetto soggettoProprietario = null;
  645.                                 try {
  646.                                     soggettoProprietario = this.soggettiCore.getSoggetto(pa.getIdSoggetto());
  647.                                 } catch (DriverConfigurazioneNotFound de) {
  648.                                     operazioneInGestione.waitBeforeInvalid("Soggetto proprietario non esistente nel database della govwayConsole: " + de.toString());
  649.                                     continue;
  650.                                 } catch (Exception e) {
  651.                                     operazioneInGestione.error("Riscontrato errore durante la get dell'immagine del Soggetto proprietario: " + e.toString(), e);
  652.                                     continue;
  653.                                 }
  654.                                 pa.setTipoSoggettoProprietario(soggettoProprietario.getTipo());
  655.                                 pa.setNomeSoggettoProprietario(soggettoProprietario.getNome());
  656.                                 
  657.                                 // vecchi dati per update
  658.                                 if(oldNomePA!=null){
  659.                                     IDPortaApplicativa oldIDPortaApplicativaForUpdate = new IDPortaApplicativa();
  660.                                     oldIDPortaApplicativaForUpdate.setNome(oldNomePA);
  661.                                     pa.setOldIDPortaApplicativaForUpdate(oldIDPortaApplicativaForUpdate);
  662.                                 }
  663.                                 
  664.                                 IdPortaApplicativa idPA = new IdPortaApplicativa();
  665.                                 if(oldNomePA!=null){
  666.                                     idPA.setNome(oldNomePA);
  667.                                 }
  668.                                 else{
  669.                                     idPA.setNome(pa.getNome());
  670.                                 }
  671.                                 
  672.                                 this.portaApplicativaPort.update(idPA, pa);
  673.                                 
  674.                             } else if (Operazione.del.equals(tipoOperazioneCRUD)) {

  676.                                 IdPortaApplicativa idPA = new IdPortaApplicativa();
  677.                                 idPA.setNome(nomePA);
  678.                                 this.portaApplicativaPort.deleteById(idPA);

  680.                             }
  681.                         } catch (Exception e) {
  682.                             operazioneInGestione.error("Riscontrato errore durante operazione su Porta Applicativa: " + e.toString(), e);
  683.                             continue;
  684.                         }

  686.                     }

  688.                     // OPERAZIONE CHE RIGUARDA LA PORTA DELEGATA
  689.                     if (TipoOggettoDaSmistare.pd.equals(tipoOggettoDaSmistare)) {

  691.                         String nomePD = operation.getParameterValue(OperationsParameter.NOME_PD.getNome());
  692.                         String oldNomePD = operation.getParameterValue(OperationsParameter.OLD_NOME_PD.getNome());
  693.                         // Ottengo nuova immagine della porta delegata
  694.                         PortaDelegata pd = null;
  695.                         try {
  696.                             // pd = backEndConnector.getDatiPD(idTable);

  698.                             if (Operazione.add.equals(tipoOperazioneCRUD)) {

  700.                                 try {
  701.                                     pd = this.pdCore.getPortaDelegata(idTable);
  702.                                 } catch (DriverConfigurazioneNotFound de) {
  703.                                     operazioneInGestione.waitBeforeInvalid("Porta Delegata non esistente nel database della govwayConsole: " + de.toString());
  704.                                     continue;
  705.                                 } catch (Exception e) {
  706.                                     operazioneInGestione.error("Riscontrato errore durante la get dell'immagine della Porta Delegata: " + e.toString(), e);
  707.                                     continue;
  708.                                 }

  710.                                 Soggetto soggettoProprietario = null;
  711.                                 try {
  712.                                     soggettoProprietario = this.soggettiCore.getSoggetto(pd.getIdSoggetto());
  713.                                 } catch (DriverConfigurazioneNotFound de) {
  714.                                     operazioneInGestione.waitBeforeInvalid("Soggetto proprietario non esistente nel database della govwayConsole: " + de.toString());
  715.                                     continue;
  716.                                 } catch (Exception e) {
  717.                                     operazioneInGestione.error("Riscontrato errore durante la get dell'immagine del Soggetto proprietario: " + e.toString(), e);
  718.                                     continue;
  719.                                 }

  721.                                 pd.setTipoSoggettoProprietario(soggettoProprietario.getTipo());
  722.                                 pd.setNomeSoggettoProprietario(soggettoProprietario.getNome());

  724.                                 this.portaDelegataPort.create(pd);

  726.                             } else if (Operazione.change.equals(tipoOperazioneCRUD)) {

  728.                                 try {
  729.                                     pd = this.pdCore.getPortaDelegata(idTable);
  730.                                 } catch (DriverConfigurazioneNotFound de) {
  731.                                     operazioneInGestione.waitBeforeInvalid("Porta Delegata non esistente nel database della govwayConsole: " + de.toString());
  732.                                     continue;
  733.                                 } catch (Exception e) {
  734.                                     operazioneInGestione.error("Riscontrato errore durante la get dell'immagine della Porta Delegata: " + e.toString(), e);
  735.                                     continue;
  736.                                 }

  738.                                 // soggetto proprietario
  739.                                 Soggetto soggettoProprietario = null;
  740.                                 try {
  741.                                     soggettoProprietario = this.soggettiCore.getSoggetto(pd.getIdSoggetto());
  742.                                 } catch (DriverConfigurazioneNotFound de) {
  743.                                     operazioneInGestione.waitBeforeInvalid("Soggetto proprietario non esistente nel database della govwayConsole: " + de.toString());
  744.                                     continue;
  745.                                 } catch (Exception e) {
  746.                                     operazioneInGestione.error("Riscontrato errore durante la get dell'immagine del Soggetto proprietario: " + e.toString(), e);
  747.                                     continue;
  748.                                 }
  749.                                 pd.setTipoSoggettoProprietario(soggettoProprietario.getTipo());
  750.                                 pd.setNomeSoggettoProprietario(soggettoProprietario.getNome());
  751.                                 
  752.                                 // vecchi dati per update
  753.                                 if(oldNomePD!=null){
  754.                                     IDPortaDelegata oldIDPortaDelegataForUpdate = new IDPortaDelegata();
  755.                                     oldIDPortaDelegataForUpdate.setNome(oldNomePD);
  756.                                     pd.setOldIDPortaDelegataForUpdate(oldIDPortaDelegataForUpdate);
  757.                                 }
  758.                                 
  759.                                 IdPortaDelegata idPD = new IdPortaDelegata();
  760.                                 if(oldNomePD!=null){
  761.                                     idPD.setNome(oldNomePD);
  762.                                 }
  763.                                 else{
  764.                                     idPD.setNome(pd.getNome());
  765.                                 }
  766.                                 
  767.                                 this.portaDelegataPort.update(idPD, pd);


  770.                             } else if (Operazione.del.equals(tipoOperazioneCRUD)) {

  772.                                 IdPortaDelegata idPD = new IdPortaDelegata();
  773.                                 idPD.setNome(nomePD);
  774.                                 
  775.                                 this.portaDelegataPort.deleteById(idPD);
  776.                                 
  777.                             }

  779.                         } catch (Exception e) {
  780.                             operazioneInGestione.error("Riscontrato errore durante operazione su Porta Delegata: " + e.toString(), e);
  781.                             continue;
  782.                         }

  784.                     }

  786.                     // OPERAZIONE CHE RIGUARDA IL SERVIZIOAPPLICATIVO
  787.                     if (TipoOggettoDaSmistare.servizioApplicativo.equals(tipoOggettoDaSmistare)) {

  789.                         String nomeServizioApplicativo = operation.getParameterValue(OperationsParameter.NOME_SERVIZIO_APPLICATIVO.getNome());
  790.                         String oldNomeServizioApplicativo = operation.getParameterValue(OperationsParameter.OLD_NOME_SERVIZIO_APPLICATIVO.getNome());
  791.                         String tipoSoggetto = operation.getParameterValue(OperationsParameter.TIPO_SOGGETTO.getNome());
  792.                         String nomeSoggetto = operation.getParameterValue(OperationsParameter.NOME_SOGGETTO.getNome());
  793.                         String oldTipoSoggetto = operation.getParameterValue(OperationsParameter.OLD_TIPO_SOGGETTO.getNome());
  794.                         String oldNomeSoggetto = operation.getParameterValue(OperationsParameter.OLD_NOME_SOGGETTO.getNome());

  796.                         // Ottengo nuova immagine del servizioApplicativo
  797.                         ServizioApplicativo servizioApplicativo = null;
  798.                         try {
  799.                             // s =
  800.                             // backEndConnector.getDatiServizioApplicativo(idTable);

  802.                             if (Operazione.add.equals(tipoOperazioneCRUD)) {

  804.                                 try {
  805.                                     servizioApplicativo = this.saCore.getServizioApplicativo(idTable);
  806.                                 } catch (DriverConfigurazioneNotFound de) {
  807.                                     operazioneInGestione.waitBeforeInvalid("Servizio Applicativo non esistente nel database della govwayConsole: " + de.toString());
  808.                                     continue;
  809.                                 } catch (Exception e) {
  810.                                     operazioneInGestione.error("Riscontrato errore durante la get dell'immagine del Servizio Applicativo: " + e.toString(), e);
  811.                                     continue;
  812.                                 }

  814.                                 this.servizioApplicativoPort.create(servizioApplicativo);

  816.                             } else if (Operazione.change.equals(tipoOperazioneCRUD)) {

  818.                                 try {
  819.                                     servizioApplicativo = this.saCore.getServizioApplicativo(idTable);
  820.                                 } catch (DriverConfigurazioneNotFound de) {
  821.                                     operazioneInGestione.waitBeforeInvalid("Servizio Applicativo non esistente nel database della govwayConsole: " + de.toString());
  822.                                     continue;
  823.                                 } catch (Exception e) {
  824.                                     operazioneInGestione.error("Riscontrato errore durante la get dell'immagine del Servizio Applicativo: " + e.toString(), e);
  825.                                     continue;
  826.                                 }
  827.                                 
  828.                                 IDServizioApplicativo oldIDServizioApplicativoForUpdate = new IDServizioApplicativo();
  829.                                 oldIDServizioApplicativoForUpdate.setIdSoggettoProprietario(new IDSoggetto());
  830.                                 servizioApplicativo.setOldIDServizioApplicativoForUpdate(oldIDServizioApplicativoForUpdate);
  831.                                 
  832.                                 oldIDServizioApplicativoForUpdate.setNome(nomeServizioApplicativo);
  833.                                 if (tipoSoggetto != null && !tipoSoggetto.equals(""))
  834.                                     oldIDServizioApplicativoForUpdate.getIdSoggettoProprietario().setTipo(tipoSoggetto);
  835.                                 if (nomeSoggetto != null && !nomeSoggetto.equals(""))
  836.                                     oldIDServizioApplicativoForUpdate.getIdSoggettoProprietario().setNome(nomeSoggetto);
  837.                                 
  838.                                 // vecchi dati per update
  839.                                 oldIDServizioApplicativoForUpdate.setNome(oldNomeServizioApplicativo);
  840.                                 
  841.                                 if(oldTipoSoggetto!=null && oldNomeSoggetto!=null){
  842.                                     // Check se operazione di change che  l'operazione di modifica del soggetto non sia ancora in rollback.
  843.                                     // Se sussite, aspetto l'operazione.
  844.                                     FilterParameter filtro = operazioneInGestione.getFilterChangeIDSoggetto(tipoSoggetto,
  845.                                             nomeSoggetto,oldTipoSoggetto,oldNomeSoggetto);                                      
  846.                                     if(operazioneInGestione.existsOperationNotCompleted("change", operation.getHostname(), filtro)){
  847.                                         oldIDServizioApplicativoForUpdate.getIdSoggettoProprietario().setTipo(oldTipoSoggetto);
  848.                                         oldIDServizioApplicativoForUpdate.getIdSoggettoProprietario().setNome(oldNomeSoggetto);
  849.                                         this.log.debug("ChangeServizioApplicativo: operazione change ID Soggetto non ancora completata: utilizzo OLD nome");
  850.                                     }else{
  851.                                         this.log.debug("ChangeServizioApplicativo: operazione change ID Soggetto completata: utilizzo nome");
  852.                                     }
  853.                                 }
  854.                                 
  855.                                 IdServizioApplicativo idSA = new IdServizioApplicativo();
  856.                                 if(oldIDServizioApplicativoForUpdate!=null && oldIDServizioApplicativoForUpdate.getNome()!=null){
  857.                                     idSA.setNome(oldIDServizioApplicativoForUpdate.getNome());
  858.                                 }
  859.                                 else{
  860.                                     idSA.setNome(servizioApplicativo.getNome());
  861.                                 }
  862.                                 idSA.setIdSoggetto(new IdSoggetto());
  863.                                 if(oldIDServizioApplicativoForUpdate.getIdSoggettoProprietario()!=null &&
  864.                                         oldIDServizioApplicativoForUpdate.getIdSoggettoProprietario().getTipo()!=null){
  865.                                     idSA.getIdSoggetto().setTipo(oldIDServizioApplicativoForUpdate.getIdSoggettoProprietario().getTipo());
  866.                                 }
  867.                                 else{
  868.                                     idSA.getIdSoggetto().setTipo(servizioApplicativo.getTipoSoggettoProprietario());
  869.                                 }
  870.                                 if(oldIDServizioApplicativoForUpdate.getIdSoggettoProprietario()!=null &&
  871.                                         oldIDServizioApplicativoForUpdate.getIdSoggettoProprietario().getNome()!=null){
  872.                                     idSA.getIdSoggetto().setNome(oldIDServizioApplicativoForUpdate.getIdSoggettoProprietario().getNome());
  873.                                 }
  874.                                 else{
  875.                                     idSA.getIdSoggetto().setNome(servizioApplicativo.getNomeSoggettoProprietario());
  876.                                 }
  877.                                 
  878.                                 this.servizioApplicativoPort.update(idSA, servizioApplicativo);

  880.                             } else if (Operazione.del.equals(tipoOperazioneCRUD)) {

  882.                                 IdServizioApplicativo idSA = new IdServizioApplicativo();
  883.                                 idSA.setNome(nomeServizioApplicativo);
  884.                                 idSA.setIdSoggetto(new IdSoggetto());
  885.                                 idSA.getIdSoggetto().setTipo(tipoSoggetto);
  886.                                 idSA.getIdSoggetto().setNome(nomeSoggetto);
  887.                                 
  888.                                 this.servizioApplicativoPort.deleteById(idSA);

  890.                             }

  892.                         } catch (Exception e) {
  893.                             operazioneInGestione.error("Riscontrato errore durante operazione su Servizio Applicativo: " + e.toString(), e);
  894.                             continue;
  895.                         }

  897.                     }

  899.                     // Se arrivo qui, significa che l'operazione non ha dato
  900.                     // errore,
  901.                     // aggiorno il db
  902.                     operazioneInGestione.success("Done.");
  903.                 }

  905.                 this.log.info(this.nomeThread + ": Operazione [" + idOperazione + "] completata"+statoOperazioneCancellata);

  907.             } catch (JMSException e) {
  908.                 try {
  909.                     this.qs.rollback();
  910.                 } catch (Exception er) {
  911.                 }

  913.                 this.log.error(this.nomeThread + ": Riscontrato errore durante la gestione di una richiesta: " + e.toString());
  914.                 this.log.debug(this.nomeThread + " : Eccezione :", e);
  915.                 try {
  916.                     Utilities.sleep(5000);
  917.                     this.log.debug(this.nomeThread + ": Re-Inizializzazione Receiver ...");
  918.                     try {
  919.                         this.receiver.close();
  920.                     } catch (Exception eclose) {
  921.                     }
  922.                     try {
  923.                         this.qs.close();
  924.                     } catch (Exception eclose) {
  925.                     }
  926.                     try {
  927.                         this.qc.close();
  928.                     } catch (Exception eclose) {
  929.                     }
  930.                     this.qc = this.qcf.createQueueConnection();
  931.                     // Ripristino stato Exception Listener
  932.                     if (this.exceptionListenerJMS.isConnessioneCorrotta()) {
  933.                         this.exceptionListenerJMS.setConnessioneCorrotta(false);
  934.                         this.exceptionListenerJMS.setException(null);
  935.                     }
  936.                     this.qc.setExceptionListener(this.exceptionListenerJMS);
  937.                     this.qs = this.qc.createQueueSession(true, -1);
  938.                     this.receiver = this.qs.createReceiver(this.queue);
  939.                     this.qc.start();
  940.                     this.log.debug(this.nomeThread + ": Re-Inizializzazione Receiver effettuata.");
  941.                     riconnessioneConErrore = false;
  942.                 } catch (Exception er) {
  943.                     this.log.error(this.nomeThread + ": Re-Inizializzazione Receiver non effettuata:" + er.toString());
  944.                     riconnessioneConErrore = true;
  945.                 }
  946.             } catch (ClassQueueException e) {
  947.                 try {
  948.                     if(operation!=null) {
  949.                         operation.setStatus(OperationStatus.ERROR);
  950.                         operation.setDetails(e.toString());
  951.                         operation.setTimeExecute(new Timestamp(System.currentTimeMillis()));
  952.                         operationManager.updateOperation(operation);
  953.                     }
  954.                     this.qs.rollback();
  955.                 } catch (Exception er) {
  956.                 }
  957.                 this.log.error("GestorePdD-"+this.pddName+": Riscontrato errore durante operazione sulla coda: " + e.toString(), e);
  958.             } catch (Exception e) {
  959.                 try {
  960.                     this.qs.rollback();
  961.                 } catch (Exception er) {
  962.                 }

  964.                 this.log.error(this.nomeThread + ": Riscontrato errore durante la gestione di una richiesta: " + e.toString());
  965.                 this.log.debug(this.nomeThread + " : Eccezione :", e);
  966.             } finally {
  967.                 try {
  968.                     this.dbm.releaseConnection(this.con);
  969.                 } catch (Exception eLogger) {
  970.                 }
  971.             }
  972.         }

  974.         // Chiusura connessione
  975.         try {
  976.             if (this.receiver != null) {
  977.                 this.receiver.close();
  978.             }
  979.             if (this.qs != null) {
  980.                 this.qs.rollback();
  981.                 this.qs.close();
  982.             }
  983.             if (this.qc != null) {
  984.                 this.qc.stop();
  985.                 this.qc.close();
  986.             }
  987.         } catch (Exception e) {
  988.             try {
  989.                 this.log.error(this.nomeThread + ": Riscontrato errore durante la chiusura del Thread: " + e.toString());
  990.             } catch (Exception eLogger) {
  991.             }
  992.         }

  994.         this.isRunning = false;
  995.         this.log.debug(this.nomeThread +" Thread terminato");
  996.     }

  998.     @Override
  999.     public void initGestore() throws Exception {

  1001.         // Controllo se dbmanager inizializzato
  1002.         // Il DBManager viene inizializzato nell'InitListener
  1003.         if (!DBManager.isInitialized()) {
  1004.             this.log.info("Inizializzazione di " + this.getClass().getSimpleName() + " non riuscito perche' DBManager non INIZIALIZZATO");
  1005.             throw new Exception("Inizializzazione di " + this.getClass().getSimpleName() + "FALLITA");
  1006.         }
  1007.         
  1008.         String pddQueuePrefix = this.consoleProperties.getGestioneCentralizzataPrefissoNomeCodaConfigurazionePdd();
  1009.         boolean enginePDD = this.consoleProperties.isGestioneCentralizzataSincronizzazionePdd();
  1010.         this.singlePdD = this.consoleProperties.isSinglePdD();
  1011.         
  1012.         if (enginePDD == false) {
  1013.             //this.log.info("Motore di sincronizzazione verso le Porte di Dominio non attivo.");
  1014.             throw new GestoreNonAttivoException("Motore di sincronizzazione verso le Porte di Dominio non attivo.");
  1015.         }

  1017.         // Leggo informazioni per queue.properties
  1018.         // Init JMS
  1019.         // readQueueProperties(cfName, cfProp);

  1021.         QueueManager queueMan = QueueManager.getInstance();
  1022.         if (queueMan == null) {
  1023.             this.log.debug("Impossibile avviare " + this.getClass().getSimpleName() + "QueueManager non inizializzato.");
  1024.             throw new Exception("Impossibile avviare " + this.getClass().getSimpleName() + "QueueManager non inizializzato.");
  1025.         }
  1026.         boolean trovato = false;
  1027.         int i = 0;
  1028.         this.log.debug("Inizializzazione Receiver [" + this.nomeThread + "] ...");
  1029.         while (!trovato && (i < 600000)) {
  1030.             try {
  1031.                 // InitialContext ctx = new InitialContext(cfProp);
  1032.                 // queue = (Queue) ctx.lookup(pddQueuePrefix + queueName);
  1033.                 // qcf = (QueueConnectionFactory) ctx.lookup(cfName);

  1035.                 this.queue = queueMan.getQueue(pddQueuePrefix + this.pddName);
  1036.                 this.qcf = queueMan.getQueueConnectionFactory();
  1037.                 this.qc = this.qcf.createQueueConnection();
  1038.                 this.qc.setExceptionListener(this.exceptionListenerJMS);
  1039.                 this.qs = this.qc.createQueueSession(true, -1);
  1040.                 this.receiver = this.qs.createReceiver(this.queue);
  1041.                 this.qc.start();
  1042.                 // ctx.close();
  1043.                 this.log.debug("GestorePdD: Inizializzazione Receiver [" + this.nomeThread + "] effettuata.");
  1044.                 trovato = true;
  1045.             } catch (Exception e) {
  1046.                 i = i + 10000;
  1047.                 Utilities.sleep(10000);
  1048.                 this.log.debug("Ritento Inizializzazione Receiver [" + this.nomeThread + "] ... causa: " + e.getMessage());
  1049.             }
  1050.         }

  1052.         if (!trovato) {
  1053.             this.log.error("Inizializzazione Receiver [" + this.nomeThread + "] non effettuata");
  1054.             throw new Exception("Inizializzazione Receiver [" + this.nomeThread + "] non effettuata");
  1055.         }

  1057.         
  1058.         // Init ControlStationCore
  1059.         try {
  1060.             this.pddCore = new PddCore();
  1061.             this.soggettiCore = new SoggettiCore(this.pddCore);
  1062.             this.paCore = new PorteApplicativeCore(this.pddCore);
  1063.             this.pdCore = new PorteDelegateCore(this.pddCore);
  1064.             this.saCore = new ServiziApplicativiCore(this.pddCore);

  1066.             this.log.debug("GestorePdD-"+this.pddName+": Inizializzato Core. ");
  1067.             
  1068.         } catch (Exception e) {
  1069.             this.log.error("Riscontrato Errore durante l'inizializzazione di ControlStationCore.", e);
  1070.             this.log.info("GestorePdD-"+this.pddName+" non avviato.");
  1071.             throw new ControlStationCoreException("Riscontrato Errore durante l'inizializzazione di ControlStationCore.", e);
  1072.         }
  1073.         
  1074.         
  1075.         // Init WebServiceCore
  1076.         try {
  1077.             String ipPdd = null;
  1078.             String protocollo = null;
  1079.             int porta = 80;
  1080.             try {
  1081.                 // ipPdd = backEndConnector.getIPPdd(queueName);
  1082.                 PdDControlStation pdd = this.pddCore.getPdDControlStation(this.pddName);
  1083.                 ipPdd = pdd.getIpGestione();
  1084.                 protocollo = pdd.getProtocolloGestione();
  1085.                 porta = pdd.getPortaGestione();

  1087.                 if (ipPdd == null || protocollo == null || porta <= 0)
  1088.                     throw new Exception("Parametri Porta di Dominio non validi.");

  1090.             } catch (Exception e) {
  1091.                 this.log.error("Riscontrato errore durante la get dell'ip del pdd(" + this.pddName + "): " + e.toString(), e);
  1092.                 throw new Exception("Riscontrato errore durante la get dell'ip del pdd(" + this.pddName + "): " + e.toString(), e);
  1093.             }
  1094.             String prefixUrl = protocollo + "://" + ipPdd + ":" + porta + "/";
  1095.             
  1096.             // ws
  1097.             this.portaApplicativaService = new PortaApplicativaSoap11Service();
  1098.             this.portaDelegataService = new PortaDelegataSoap11Service();
  1099.             this.servizioApplicativoService = new ServizioApplicativoSoap11Service();
  1100.             this.soggettoService = new SoggettoSoap11Service();
  1101.             
  1102.             this.portaApplicativaPort = this.portaApplicativaService.getPortaApplicativaPortSoap11();
  1103.             this.portaDelegataPort = this.portaDelegataService.getPortaDelegataPortSoap11();
  1104.             this.servizioApplicativoPort = this.servizioApplicativoService.getServizioApplicativoPortSoap11();
  1105.             this.soggettoPort = this.soggettoService.getSoggettoPortSoap11();
  1106.             
  1107.             ((BindingProvider)this.portaApplicativaPort).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
  1108.                     prefixUrl+this.consoleProperties.getGestioneCentralizzataWSConfigurazioneEndpointSuffixPortaApplicativa());
  1109.             ((BindingProvider)this.portaDelegataPort).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
  1110.                     prefixUrl+this.consoleProperties.getGestioneCentralizzataWSConfigurazioneEndpointSuffixPortaDelegata());
  1111.             ((BindingProvider)this.servizioApplicativoPort).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
  1112.                     prefixUrl+this.consoleProperties.getGestioneCentralizzataWSConfigurazioneEndpointSuffixServizioApplicativo());
  1113.             ((BindingProvider)this.soggettoPort).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
  1114.                     prefixUrl+this.consoleProperties.getGestioneCentralizzataWSConfigurazioneEndpointSuffixSoggetto());
  1115.             
  1116.             ((BindingProvider)this.portaApplicativaPort).getRequestContext().put("schema-validation-enabled", true);
  1117.             ((BindingProvider)this.portaDelegataPort).getRequestContext().put("schema-validation-enabled", true);
  1118.             ((BindingProvider)this.servizioApplicativoPort).getRequestContext().put("schema-validation-enabled", true);
  1119.             ((BindingProvider)this.soggettoPort).getRequestContext().put("schema-validation-enabled", true);
  1120.             
  1121.             String username = this.consoleProperties.getGestioneCentralizzataWSConfigurazioneCredenzialiBasicUsername();
  1122.             String password = this.consoleProperties.getGestioneCentralizzataWSConfigurazioneCredenzialiBasicPassword();
  1123.             if(username !=null && password!=null){
  1124.                 // to use Basic HTTP Authentication: 
  1125.                 
  1126.                 ((BindingProvider)this.portaApplicativaPort).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
  1127.                 ((BindingProvider)this.portaApplicativaPort).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
  1128.                 
  1129.                 ((BindingProvider)this.portaDelegataPort).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
  1130.                 ((BindingProvider)this.portaDelegataPort).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
  1131.                 
  1132.                 ((BindingProvider)this.servizioApplicativoPort).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
  1133.                 ((BindingProvider)this.servizioApplicativoPort).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
  1134.                 
  1135.                 ((BindingProvider)this.soggettoPort).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
  1136.                 ((BindingProvider)this.soggettoPort).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
  1137.             }
  1138.             
  1139.             this.log.debug("GestorePdD-"+this.pddName+": Inizializzato WebService. PortaApplicativa: " + this.portaApplicativaService.getClass().getSimpleName());
  1140.             this.log.debug("GestorePdD-"+this.pddName+": Inizializzato WebService. PortaDelegata: " + this.portaDelegataService.getClass().getSimpleName());
  1141.             this.log.debug("GestorePdD-"+this.pddName+": Inizializzato WebService. ServizioApplicativo: " + this.servizioApplicativoService.getClass().getSimpleName());
  1142.             this.log.debug("GestorePdD-"+this.pddName+": Inizializzato WebService. Soggetto: " + this.soggettoService.getClass().getSimpleName());
  1143.             
  1144.         } catch (Exception e) {
  1145.             this.log.error("Riscontrato Errore durante la connessione al WebService.", e);
  1146.             this.log.info("GestorePdD-"+this.pddName+" non avviato.");
  1147.             throw new Exception("Riscontrato Errore durante la connessione al WebService.", e);
  1148.         }
  1149.         
  1150.     }

  1152.     @Override
  1153.     public void stopGestore() {
  1154.         this.stop = true;
  1155.     }

  1157.     @Override
  1158.     protected String getName() {
  1159.         return this.nomeThread;
  1160.     }
  1161. }
Created with JaCoCo 0.8.8.202204050719