GestoreRegistroThread.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.id.IDAccordo;
  39. import org.openspcoop2.core.id.IDAccordoCooperazione;
  40. import org.openspcoop2.core.registry.AccordoCooperazione;
  41. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  42. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  43. import org.openspcoop2.core.registry.IdAccordoCooperazione;
  44. import org.openspcoop2.core.registry.IdAccordoServizioParteComune;
  45. import org.openspcoop2.core.registry.IdAccordoServizioParteSpecifica;
  46. import org.openspcoop2.core.registry.IdPortaDominio;
  47. import org.openspcoop2.core.registry.IdSoggetto;
  48. import org.openspcoop2.core.registry.PortaDominio;
  49. import org.openspcoop2.core.registry.Soggetto;
  50. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  51. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  52. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  53. import org.openspcoop2.core.registry.ws.client.accordocooperazione.all.AccordoCooperazioneSoap11Service;
  54. import org.openspcoop2.core.registry.ws.client.accordoserviziopartecomune.all.AccordoServizioParteComuneSoap11Service;
  55. import org.openspcoop2.core.registry.ws.client.accordoserviziopartespecifica.all.AccordoServizioParteSpecificaSoap11Service;
  56. import org.openspcoop2.core.registry.ws.client.portadominio.all.PortaDominioSoap11Service;
  57. import org.openspcoop2.core.registry.ws.client.soggetto.all.SoggettoSoap11Service;
  58. import org.openspcoop2.pdd.config.OpenSPCoop2ConfigurationException;
  59. import org.openspcoop2.utils.Utilities;
  60. import org.openspcoop2.utils.transport.jms.ExceptionListenerJMS;
  61. import org.openspcoop2.web.ctrlstat.config.ConsoleProperties;
  62. import org.openspcoop2.web.ctrlstat.config.DatasourceProperties;
  63. import org.openspcoop2.web.ctrlstat.core.ControlStationCoreException;
  64. import org.openspcoop2.web.ctrlstat.core.ControlStationLogger;
  65. import org.openspcoop2.web.ctrlstat.core.DBManager;
  66. import org.openspcoop2.web.ctrlstat.core.QueueManager;
  67. import org.openspcoop2.web.ctrlstat.costanti.CostantiControlStation;
  68. import org.openspcoop2.web.ctrlstat.costanti.OperationsParameter;
  69. import org.openspcoop2.web.ctrlstat.costanti.TipoOggettoDaSmistare;
  70. import org.openspcoop2.web.ctrlstat.servlet.ac.AccordiCooperazioneCore;
  71. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCore;
  72. import org.openspcoop2.web.ctrlstat.servlet.aps.AccordiServizioParteSpecificaCore;
  73. import org.openspcoop2.web.ctrlstat.servlet.pdd.PddCore;
  74. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCore;
  75. import org.openspcoop2.web.lib.queue.ClassQueue;
  76. import org.openspcoop2.web.lib.queue.ClassQueueException;
  77. import org.openspcoop2.web.lib.queue.costanti.OperationStatus;
  78. import org.openspcoop2.web.lib.queue.costanti.Operazione;
  79. import org.openspcoop2.web.lib.queue.costanti.TipoOperazione;
  80. import org.openspcoop2.web.lib.queue.dao.FilterParameter;
  81. import org.openspcoop2.web.lib.queue.dao.Operation;
  82. import org.openspcoop2.web.lib.queue.dao.Parameter;
  83. import org.slf4j.Logger;

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

  97.     private ConsoleProperties consoleProperties;
  98.     private DatasourceProperties datasourceProperties;
  99.     
  100.     private String name = null;
  101.     
  102.     /** run */
  103.     public boolean stop = false;
  104.     private boolean isRunning = false;
  105.     public boolean isRunning() {
  106.         return this.isRunning;
  107.     }
  108.     
  109.     /** Gestore Registro Servizi */
  110.     private SoggettiCore soggettiCore;
  111.     private PddCore pddCore;
  112.     private AccordiServizioParteComuneCore apcCore;
  113.     private AccordiServizioParteSpecificaCore apsCore;
  114.     private AccordiCooperazioneCore acCore;

  116.     // JMS
  117.     private QueueReceiver receiver = null;
  118.     private Queue queue = null;
  119.     private QueueConnectionFactory qcf = null;
  120.     private QueueConnection qc = null;
  121.     private QueueSession qs = null;

  123.     // //DB
  124.     private DBManager dbm;
  125.     private Connection con;

  127.     /** Web Service */
  128.     private org.openspcoop2.core.registry.ws.client.accordocooperazione.all.AccordoCooperazioneSoap11Service accordoCooperazioneService;
  129.     private org.openspcoop2.core.registry.ws.client.accordoserviziopartecomune.all.AccordoServizioParteComuneSoap11Service accordoServizioParteComuneService;
  130.     private org.openspcoop2.core.registry.ws.client.accordoserviziopartespecifica.all.AccordoServizioParteSpecificaSoap11Service accordoServizioParteSpecificaService;
  131.     private org.openspcoop2.core.registry.ws.client.soggetto.all.SoggettoSoap11Service soggettoService;
  132.     private org.openspcoop2.core.registry.ws.client.portadominio.all.PortaDominioSoap11Service pddService;
  133.     
  134.     private org.openspcoop2.core.registry.ws.client.accordocooperazione.all.AccordoCooperazione accordoCooperazionePort;
  135.     private org.openspcoop2.core.registry.ws.client.accordoserviziopartecomune.all.AccordoServizioParteComune accordoServizioParteComunePort;
  136.     private org.openspcoop2.core.registry.ws.client.accordoserviziopartespecifica.all.AccordoServizioParteSpecifica accordoServizioParteSpecificaPort;
  137.     private org.openspcoop2.core.registry.ws.client.soggetto.all.Soggetto soggettoPort;
  138.     private org.openspcoop2.core.registry.ws.client.portadominio.all.PortaDominio pddPort;

  140.     private boolean singlePdD = false;

  142.     // Logger
  143.     private Logger log;

  145.     private ExceptionListenerJMS exceptionListenerJMS = new ExceptionListenerJMS();

  147.     /** Costruttore 
  148.      * @throws OpenSPCoop2ConfigurationException */
  149.     public GestoreRegistroThread() throws OpenSPCoop2ConfigurationException {
  150.         
  151.         this.log = ControlStationLogger.getGestoreRegistroLogger();
  152.         this.name = "GestoreRegistro";
  153.         
  154.         this.consoleProperties = ConsoleProperties.getInstance();
  155.         this.datasourceProperties = DatasourceProperties.getInstance();
  156.     }

  158.     /**
  159.      * Metodo che fa partire il Thread.
  160.      * 
  161.      * @since 0.4
  162.      */
  163.     @Override
  164.     public void run() {

  166.         this.isRunning = true;
  167.         
  168.         // effettuo inizializzazione
  169.         try {
  170.             this.initGestore();

  172.             if (this.singlePdD) {
  173.                 this.log.warn("GestoreRegistroServizi non avviato: govwayConsole avviata in singlePdD mode.");
  174.                 return;
  175.             }

  177.             this.dbm = DBManager.getInstance();

  179.             this.log.info(this.getClass().getName() + " Inizializzato ...");
  180.         } catch (GestoreNonAttivoException e) {
  181.             this.log.warn("Inizializzazione Gestore non effettuata : " + e.getMessage());
  182.             this.stop = true;
  183.         } catch (Exception e) {
  184.             this.log.error("Inizializzazione Gestore [" + this.getClass().getName() + "] Fallita : " + e.getMessage(), e);
  185.             this.stop = true;
  186.         }

  188.         // Avvio Gestione Registro
  189.         boolean riconnessioneConErrore = false;
  190.         while (this.stop == false) {
  191.             Operation operation = null;
  192.             ClassQueue operationManager = null;
  193.             try {

  195.                 // riconnessione precedente non riuscita.....
  196.                 if (riconnessioneConErrore) {
  197.                     throw new JMSException("RiconnessioneJMS non riuscita...");
  198.                 }

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

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

  218.                 // Attendo tempi di delay (TransazioneSimilXA)
  219.                 Utilities.sleep(CostantiControlStation.INTERVALLO_TRANSAZIONE_XA);

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

  232.                 int idOp = (int) Integer.parseInt(objOp.toString());
  233.                 if (idOp == 0) {
  234.                     this.log.error("GestoreRegistro: Ricevuta richiesta con parametri scorretti.");
  235.                     this.qs.commit();
  236.                     continue;
  237.                 }

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

  241.                 // Connessione al db
  242.                 this.con = this.dbm.getConnection();

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

  261.                 // Operazione in gestione
  262.                 GestioneOperazione operazioneInGestione = new GestioneOperazione(this.dbm, this.con, this.qs, operation, operationManager, 
  263.                         this.log, tipoOperazioneCRUDParam, "GestoreRegistro");

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

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

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

  330.                 
  331.                 if (!TipoOggettoDaSmistare.soggetto.equals(tipoOggettoDaSmistare) && 
  332.                         //!TipoOggettoDaSmistare.fruitore.equals(tipoOggettoDaSmistare) && 
  333.                         !TipoOggettoDaSmistare.servizio.equals(tipoOggettoDaSmistare) && 
  334.                         !TipoOggettoDaSmistare.accordo.equals(tipoOggettoDaSmistare) &&
  335.                         !TipoOggettoDaSmistare.accordoCooperazione.equals(tipoOggettoDaSmistare) &&
  336.                         !TipoOggettoDaSmistare.pdd.equals(tipoOggettoDaSmistare)) {
  337.                     operazioneInGestione.invalid("Ricevuta operazione con parametri scorretti (oggetto:" + tipoOggettoDaSmistare.name() + ")");
  338.                     continue;
  339.                 }
  340.                 
  341.                 if (!TipoOperazione.webService.equals(tipoOperazione)) {
  342.                     operazioneInGestione.invalid("Ricevuta operazione con parametri scorretti (tipo operazione:" + tipoOperazione.name() + " non supportata dal gestore)");
  343.                     continue;
  344.                 }


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

  350.                 FilterParameter idTableFiltro = new FilterParameter();
  351.                 idTableFiltro.addFilterParameter(new Parameter(OperationsParameter.ID_TABLE.getNome(), idTable + ""));
  352.                 filtroOrdine.add(idTableFiltro);

  354.                 if (TipoOggettoDaSmistare.pdd.equals(tipoOggettoDaSmistare)) {

  356.                     // Chiave primaria per il soggetto e' nome
  357.                     String nomePddFiltro = operation.getParameterValue(OperationsParameter.PORTA_DOMINIO.getNome());
  358.                     FilterParameter asPdd = new FilterParameter();
  359.                     asPdd.addFilterParameter(new Parameter(OperationsParameter.PORTA_DOMINIO.getNome(), nomePddFiltro));
  360.                     filtroOrdine.add(asPdd);

  362.                 } else if (TipoOggettoDaSmistare.soggetto.equals(tipoOggettoDaSmistare)) {

  364.                     // Chiave primaria per il soggetto e' tipo e nome
  365.                     String tipoSoggFiltro = operation.getParameterValue(OperationsParameter.TIPO_SOGGETTO.getNome());
  366.                     String nomeSoggFiltro = operation.getParameterValue(OperationsParameter.NOME_SOGGETTO.getNome());
  367.                     FilterParameter soggettoFiltro = new FilterParameter();
  368.                     soggettoFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SOGGETTO.getNome(), tipoSoggFiltro));
  369.                     soggettoFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SOGGETTO.getNome(), nomeSoggFiltro));
  370.                     filtroOrdine.add(soggettoFiltro);

  372.                     // OLD valori per tipo e nome se abbiamo una operazione di
  373.                     // change
  374.                     if (Operazione.change.equals(tipoOperazioneCRUD)) {
  375.                         String oldTipoSogg = operation.getParameterValue(OperationsParameter.OLD_TIPO_SOGGETTO.getNome());
  376.                         String oldNomeSogg = operation.getParameterValue(OperationsParameter.OLD_NOME_SOGGETTO.getNome());
  377.                         FilterParameter soggettoOldFiltro = new FilterParameter();
  378.                         soggettoOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_TIPO_SOGGETTO.getNome(), oldTipoSogg));
  379.                         soggettoOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SOGGETTO.getNome(), oldNomeSogg));
  380.                         filtroOrdine.add(soggettoOldFiltro);
  381.                     }
  382.                 } else if (TipoOggettoDaSmistare.servizio.equals(tipoOggettoDaSmistare) 
  383.                     //  || TipoOggettoDaSmistare.fruitore.equals(tipoOggettoDaSmistare)
  384.                         ) {

  386.                     // Chiave primaria che identifica un servizio e'
  387.                     // soggettoErogatore e servizio
  388.                     String tipoSoggFiltro = operation.getParameterValue(OperationsParameter.TIPO_SOGGETTO.getNome());
  389.                     String nomeSoggFiltro = operation.getParameterValue(OperationsParameter.NOME_SOGGETTO.getNome());
  390.                     String tipoServFiltro = operation.getParameterValue(OperationsParameter.TIPO_SERVIZIO.getNome());
  391.                     String nomeServFiltro = operation.getParameterValue(OperationsParameter.NOME_SERVIZIO.getNome());
  392.                     String nomeAccordo = operation.getParameterValue(OperationsParameter.NOME_ACCORDO.getNome());
  393.                     String versioneAccordo = operation.getParameterValue(OperationsParameter.VERSIONE_ACCORDO.getNome());
  394.                     
  395.                     //System.out.println("SERVIZIO  TS["+tipoSoggFiltro+"] NS["+nomeSoggFiltro+"] TSV["+tipoServFiltro+"] NSV["+nomeServFiltro+"]");
  396.                     
  397.                     FilterParameter servizioFiltro = new FilterParameter();
  398.                     servizioFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SOGGETTO.getNome(), tipoSoggFiltro));
  399.                     servizioFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SOGGETTO.getNome(), nomeSoggFiltro));
  400.                     servizioFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SERVIZIO.getNome(), tipoServFiltro));
  401.                     servizioFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SERVIZIO.getNome(), nomeServFiltro));
  402.                     servizioFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_ACCORDO.getNome(), nomeAccordo));
  403.                     servizioFiltro.addFilterParameter(new Parameter(OperationsParameter.VERSIONE_ACCORDO.getNome(), versioneAccordo));
  404.                     filtroOrdine.add(servizioFiltro);

  406.                     // OLD valori per tipo e nome se abbiamo una operazione di
  407.                     // change del servizio o add/del di fruitore
  408.                     if ((Operazione.change.equals(tipoOperazioneCRUD)) 
  409.                         //  || (TipoOggettoDaSmistare.fruitore.equals(tipoOggettoDaSmistare))
  410.                             ) {
  411.                         String oldtipoServizio = operation.getParameterValue(OperationsParameter.OLD_TIPO_SERVIZIO.getNome());
  412.                         String oldNomeServizio = operation.getParameterValue(OperationsParameter.OLD_NOME_SERVIZIO.getNome());

  414.                         String oldTipoSogg = operation.getParameterValue(OperationsParameter.OLD_TIPO_SOGGETTO.getNome());
  415.                         String oldNomeSogg = operation.getParameterValue(OperationsParameter.OLD_NOME_SOGGETTO.getNome());
  416.                         
  417.                         String oldNomeAccordo = operation.getParameterValue(OperationsParameter.OLD_NOME_ACCORDO.getNome());
  418.                         String oldVersioneAccordo = operation.getParameterValue(OperationsParameter.OLD_VERSIONE_ACCORDO.getNome());

  420.                         FilterParameter servizioOldFiltro = new FilterParameter();
  421.                         if( (oldTipoSogg!=null && oldNomeSogg!=null) || (oldtipoServizio!=null && oldNomeServizio!=null) || oldNomeAccordo!=null || oldVersioneAccordo!=null ){
  422.                             if(oldTipoSogg!=null && oldNomeSogg!=null){
  423.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SOGGETTO.getNome(), oldTipoSogg));
  424.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SOGGETTO.getNome(), oldNomeSogg));
  425.                             }else{
  426.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_SOGGETTO.getNome(), tipoSoggFiltro));
  427.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_SOGGETTO.getNome(), nomeSoggFiltro));
  428.                             }
  429.                             if(oldtipoServizio!=null && oldNomeServizio!=null){
  430.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_TIPO_SERVIZIO.getNome(), oldtipoServizio));
  431.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SERVIZIO.getNome(), oldNomeServizio));
  432.                             }else{
  433.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_TIPO_SERVIZIO.getNome(), tipoServFiltro));
  434.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_SERVIZIO.getNome(), nomeServFiltro));
  435.                             }
  436.                             if(oldNomeAccordo!=null){
  437.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_ACCORDO.getNome(), oldNomeAccordo));
  438.                             }
  439.                             else{
  440.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_ACCORDO.getNome(), nomeAccordo));
  441.                             }
  442.                             if(oldVersioneAccordo!=null){
  443.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_VERSIONE_ACCORDO.getNome(), oldVersioneAccordo));
  444.                             }
  445.                             else{
  446.                                 servizioOldFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_VERSIONE_ACCORDO.getNome(), versioneAccordo));
  447.                             }
  448.                             filtroOrdine.add(servizioOldFiltro);
  449.                         }
  450.                     }
  451.                 } else if (TipoOggettoDaSmistare.accordo.equals(tipoOggettoDaSmistare)) {

  453.                     // Chiave primaria che identifica l'accordo e' il nome
  454.                     String nomeAccFiltro = operation.getParameterValue(OperationsParameter.NOME_ACCORDO.getNome());
  455.                     String versioneAccFiltro = operation.getParameterValue(OperationsParameter.VERSIONE_ACCORDO.getNome());
  456.                     String tipoReferenteAccFiltro = operation.getParameterValue(OperationsParameter.TIPO_REFERENTE.getNome());
  457.                     String nomeReferenteAccFiltro = operation.getParameterValue(OperationsParameter.NOME_REFERENTE.getNome());
  458.                     //System.out.println("ACCORDO  ["+nomeAccFiltro+"] ["+versioneAccFiltro+"] ["+tipoReferenteAccFiltro+"] ["+nomeReferenteAccFiltro+"]");
  459.                     
  460.                     FilterParameter asFiltro = new FilterParameter();
  461.                     asFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_ACCORDO.getNome(), nomeAccFiltro));
  462.                     asFiltro.addFilterParameter(new Parameter(OperationsParameter.VERSIONE_ACCORDO.getNome(), versioneAccFiltro));
  463.                     asFiltro.addFilterParameter(new Parameter(OperationsParameter.TIPO_REFERENTE.getNome(), tipoReferenteAccFiltro));
  464.                     asFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_REFERENTE.getNome(), nomeReferenteAccFiltro));
  465.                     filtroOrdine.add(asFiltro);
  466.                     
  467.                     // OLD valori se siamo in una operazione di 
  468.                     // change dell'accordo
  469.                     if ((Operazione.change.equals(tipoOperazioneCRUD))){
  470.                         // Chiave primaria che identifica l'accordo e' il nome,soggettoreferente,versione
  471.                         String nomeOLDAccFiltro = operation.getParameterValue(OperationsParameter.OLD_NOME_ACCORDO.getNome());
  472.                         String versioneOLDAccFiltro = operation.getParameterValue(OperationsParameter.OLD_VERSIONE_ACCORDO.getNome());
  473.                         String tipoReferenteOLDAccFiltro = operation.getParameterValue(OperationsParameter.OLD_TIPO_REFERENTE.getNome());
  474.                         String nomeReferenteOLDAccFiltro = operation.getParameterValue(OperationsParameter.OLD_NOME_REFERENTE.getNome());
  475.                         //System.out.println("OLD ACCORDO  ["+nomeOLDAccFiltro+"] ["+versioneOLDAccFiltro+"] ["+tipoReferenteOLDAccFiltro+"] ["+nomeReferenteOLDAccFiltro+"]");
  476.                         
  477.                         FilterParameter asOLDFiltro = new FilterParameter();
  478.                         asOLDFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_ACCORDO.getNome(), nomeOLDAccFiltro));
  479.                         asOLDFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_VERSIONE_ACCORDO.getNome(), versioneOLDAccFiltro));
  480.                         asOLDFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_TIPO_REFERENTE.getNome(), tipoReferenteOLDAccFiltro));
  481.                         asOLDFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_REFERENTE.getNome(), nomeReferenteOLDAccFiltro));
  482.                         filtroOrdine.add(asOLDFiltro);
  483.                     }
  484.                 }else if (TipoOggettoDaSmistare.accordoCooperazione.equals(tipoOggettoDaSmistare)) {
  485.                     // Chiave primaria che identifica l'accordo e' il nome,versione
  486.                     String nomeAccFiltro = operation.getParameterValue(OperationsParameter.NOME_ACCORDO.getNome());
  487.                     String versioneAccFiltro = operation.getParameterValue(OperationsParameter.VERSIONE_ACCORDO.getNome());
  488.                     //System.out.println("ACCORDO COOPERAZIONE  ["+nomeAccFiltro+"] ["+versioneAccFiltro+"]");
  489.                         
  490.                     FilterParameter acFiltro = new FilterParameter();
  491.                     acFiltro.addFilterParameter(new Parameter(OperationsParameter.NOME_ACCORDO.getNome(), nomeAccFiltro));
  492.                     acFiltro.addFilterParameter(new Parameter(OperationsParameter.VERSIONE_ACCORDO.getNome(), versioneAccFiltro));
  493.                     filtroOrdine.add(acFiltro);
  494.                         
  495.                     // OLD valori se siamo in una operazione di 
  496.                     // change dell'accordo
  497.                     if ((Operazione.change.equals(tipoOperazioneCRUD))){
  498.                         // Chiave primaria che identifica l'accordo e' il nome,versione
  499.                         String nomeOLDAccFiltro = operation.getParameterValue(OperationsParameter.OLD_NOME_ACCORDO.getNome());
  500.                         String versioneOLDAccFiltro = operation.getParameterValue(OperationsParameter.OLD_VERSIONE_ACCORDO.getNome());
  501.                         //System.out.println("OLD ACCORDO COOPERAZIONE  ["+nomeOLDAccFiltro+"] ["+versioneOLDAccFiltro+"]");
  502.                         
  503.                         FilterParameter asOLDFiltro = new FilterParameter();
  504.                         asOLDFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_NOME_ACCORDO.getNome(), nomeOLDAccFiltro));
  505.                         asOLDFiltro.addFilterParameter(new Parameter(OperationsParameter.OLD_VERSIONE_ACCORDO.getNome(), versioneOLDAccFiltro));
  506.                         filtroOrdine.add(asOLDFiltro);
  507.                     }
  508.                 }else {
  509.                     operazioneInGestione.invalid("Ricevuta operazione con oggetto non conosciuto dal Gestore (oggetto:" + tipoOggettoDaSmistare.name() + ")");
  510.                     continue;
  511.                 }

  513.                 operationManager.setOperazioniPrecedentiByFilterSearch(operation, filtroOrdine.toArray(new FilterParameter[0]), false, tipoOggettoDaSmistare.name());
  514.                 if (operation.sizeOperazioniPrecedentiAncoraDaGestireList() > 0) {
  515.                     StringBuilder operazioniPrecedenti = new StringBuilder();
  516.                     for (int i = 0; i < operation.sizeOperazioniPrecedentiAncoraDaGestireList(); i++) {
  517.                         operazioniPrecedenti.append("\n" + operation.getOperazionePrecedenteAncoraDaGestire(i).toString());
  518.                     }
  519.                     operazioneInGestione.error("Ricevuta operazione su una entita' di cui esistono operazioni attivate precedentementi ancora in coda:\n" + operazioniPrecedenti.toString());
  520.                     continue;
  521.                 }

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

  525.                 // Se l'operazione e' stata marcata come deleted, la rimuovo
  526.                 // dalla coda (basta fare il commit)
  527.                 String statoOperazioneCancellata = "";
  528.                 if (deleted == 1) {

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

  533.                 } else {

  535.                     // Effettuo filtro di altre modifiche con stesso
  536.                     // idOperazione
  537.                     if (Operazione.change.equals(tipoOperazioneCRUD)) {
  538.                         
  539.                         List<Operation> listFilteredOperations = filterOperations(idOperazione, operationManager, operation, this.qs, this.queue, this.log);

  541.                         if (listFilteredOperations.size() > 0) {
  542.                             StringBuilder bf = new StringBuilder();
  543.                             for (Operation operationFiltered : listFilteredOperations) {
  544.                                 if(bf.length()>0){
  545.                                     bf.append(",");
  546.                                 }
  547.                                 bf.append(operationFiltered.getId());
  548.                             }
  549.                             this.log.debug(getName() + ": Filtrate [" + listFilteredOperations.size() + "] operation con stessa property jms ['ID'="+idOperazione+"] (ids: "+bf.toString()+")");
  550.                         }
  551.                     }

  553.                     /*  SOGGETTI */
  554.                     if (TipoOggettoDaSmistare.soggetto.equals(tipoOggettoDaSmistare)) {

  556.                         String oldTipoSogg = operation.getParameterValue(OperationsParameter.OLD_TIPO_SOGGETTO.getNome());
  557.                         String oldNomeSogg = operation.getParameterValue(OperationsParameter.OLD_NOME_SOGGETTO.getNome());
  558.                         String tipoSogg = operation.getParameterValue(OperationsParameter.TIPO_SOGGETTO.getNome());
  559.                         String nomeSogg = operation.getParameterValue(OperationsParameter.NOME_SOGGETTO.getNome());

  561.                         // CREAZIONE/MODIFICA
  562.                         if (Operazione.change.equals(tipoOperazioneCRUD) || Operazione.add.equals(tipoOperazioneCRUD)) {

  564.                             // Ottengo nuova immagine del soggetto
  565.                             Soggetto soggetto = null;
  566.                             try {
  567.                                 soggetto = this.soggettiCore.getSoggettoRegistro(idTable);
  568.                                 this.log.debug("Caricato soggetto :" + soggetto.getNome());
  569.                             } catch (DriverRegistroServiziNotFound de) {
  570.                                 operazioneInGestione.waitBeforeInvalid("Soggetto non esistente nel database della govwayConsole: " + de.toString());
  571.                                 continue;
  572.                             } catch (Exception e) {
  573.                                 operazioneInGestione.error("Riscontrato errore durante la get dell'immagine del soggetto: " + e.toString(), e);
  574.                                 continue;
  575.                             }

  577.                             // Propago in remoto sul registro
  578.                             try {
  579.                                 if (Operazione.add.equals(tipoOperazioneCRUD)) {
  580.                                     this.soggettoPort.create(soggetto);
  581.                                 } else if (Operazione.change.equals(tipoOperazioneCRUD)) {
  582.                                     IdSoggetto oldIdSoggetto = new IdSoggetto();
  583.                                     if(oldTipoSogg!=null)
  584.                                         oldIdSoggetto.setTipo(oldTipoSogg);
  585.                                     else
  586.                                         oldIdSoggetto.setTipo(tipoSogg);
  587.                                     if(oldNomeSogg!=null)
  588.                                         oldIdSoggetto.setNome(oldNomeSogg);
  589.                                     else
  590.                                         oldIdSoggetto.setNome(nomeSogg);
  591.                                     this.soggettoPort.update(oldIdSoggetto, soggetto);
  592.                                 }
  593.                             } catch (Exception e) {
  594.                                 operazioneInGestione.error("Riscontrato errore di creazione/update soggetto: " + e.toString(), e);
  595.                                 continue;
  596.                             }

  598.                         }
  599.                         // ELIMINAZIONE
  600.                         else if (Operazione.del.equals(tipoOperazioneCRUD)) {
  601.                             try {
  602.                                 // Effettuo operazione sul registro
  603.                                 IdSoggetto idSoggetto = new IdSoggetto();
  604.                                 idSoggetto.setTipo(tipoSogg);
  605.                                 idSoggetto.setNome(nomeSogg);
  606.                                 this.soggettoPort.deleteById(idSoggetto);
  607.                             } catch (Exception e) {
  608.                                 operazioneInGestione.error("Riscontrato errore di eliminazione soggetto: " + e.toString(), e);
  609.                                 continue;
  610.                             }

  612.                         }
  613.                     }

  615.                     /*  ACCORDO DI SERVIZIO PARTE SPECIFICA */
  616.                     if (TipoOggettoDaSmistare.servizio.equals(tipoOggettoDaSmistare) 
  617.                         //  || TipoOggettoDaSmistare.fruitore.equals(tipoOggettoDaSmistare)
  618.                             ) {

  620.                         AccordoServizioParteSpecifica accordoServizioParteSpecifica = null;
  621.                         
  622.                         String tipoServizio = operation.getParameterValue(OperationsParameter.TIPO_SERVIZIO.getNome());
  623.                         String nomeServizio = operation.getParameterValue(OperationsParameter.NOME_SERVIZIO.getNome());
  624.                         String tipoSogg = operation.getParameterValue(OperationsParameter.TIPO_SOGGETTO.getNome());
  625.                         String nomeSogg = operation.getParameterValue(OperationsParameter.NOME_SOGGETTO.getNome());
  626.                         String versioneServizio = operation.getParameterValue(OperationsParameter.VERSIONE_ACCORDO.getNome());
  627.                         
  628.                         String oldTipoServizio = operation.getParameterValue(OperationsParameter.OLD_TIPO_SERVIZIO.getNome());
  629.                         String oldNomeServizio = operation.getParameterValue(OperationsParameter.OLD_NOME_SERVIZIO.getNome());
  630.                         String oldTipoSogg = operation.getParameterValue(OperationsParameter.OLD_TIPO_SOGGETTO.getNome());
  631.                         String oldNomeSogg = operation.getParameterValue(OperationsParameter.OLD_NOME_SOGGETTO.getNome());
  632.                         String oldVersioneServizio = operation.getParameterValue(OperationsParameter.OLD_VERSIONE_ACCORDO.getNome());

  634.                         // CREAZIONE/MODIFICA
  635.                         if (
  636.                                 ( 
  637.                                         Operazione.change.equals(tipoOperazioneCRUD)
  638.                                 ) 
  639.                             || 
  640.                                 (
  641.                                         Operazione.add.equals(tipoOperazioneCRUD)
  642.                                 ) 
  643. //                          || 
  644. //                              (
  645. //                                      TipoOggettoDaSmistare.fruitore.equals(tipoOggettoDaSmistare) && Operazione.del.equals(tipoOperazioneCRUD)
  646. //                              )
  647.                             ) {

  649.                             // Ottengo nuova immagine del servizio
  650.                             try {
  651.                                 accordoServizioParteSpecifica = this.apsCore.getAccordoServizioParteSpecifica(idTable,true);
  652.                             } catch (DriverRegistroServiziNotFound de) {
  653.                                 operazioneInGestione.waitBeforeInvalid("Servizio non esistente nel database della govwayConsole: " + de.toString());
  654.                                 continue;
  655.                             } catch (Exception e) {
  656.                                 operazioneInGestione.error("Riscontrato errore durante la get dell'immagine del servizio: " + e.getMessage(), e);
  657.                                 continue;
  658.                             }

  660.                             // Propago in remoto sul registro
  661.                             try {
  662.                                 // Effettuo operazione sul registro
  663.                                 if (TipoOggettoDaSmistare.servizio.equals(tipoOggettoDaSmistare) && Operazione.add.equals(tipoOperazioneCRUD)) {

  665.                                     this.accordoServizioParteSpecificaPort.create(accordoServizioParteSpecifica);

  667.                                     // se operazione change oppure add (e
  668.                                     // ovviamente change) del fruitore
  669.                                     // allora eseguo la modificaServizio
  670.                                 } else if (TipoOggettoDaSmistare.servizio.equals(tipoOggettoDaSmistare) && Operazione.change.equals(tipoOperazioneCRUD)) {

  672.                                     IdAccordoServizioParteSpecifica idAccordoServizioParteSpecifica = new IdAccordoServizioParteSpecifica();
  673.                                     if(oldTipoServizio!=null){
  674.                                         idAccordoServizioParteSpecifica.setNome(oldTipoServizio);
  675.                                     }else{
  676.                                         idAccordoServizioParteSpecifica.setNome(tipoServizio);
  677.                                     }
  678.                                     if(oldNomeServizio!=null){
  679.                                         idAccordoServizioParteSpecifica.setNome(oldNomeServizio);
  680.                                     }else{
  681.                                         idAccordoServizioParteSpecifica.setNome(nomeServizio);
  682.                                     }
  683.                                     if(oldVersioneServizio!=null){
  684.                                         idAccordoServizioParteSpecifica.setVersione(Integer.parseInt(oldVersioneServizio));
  685.                                     }
  686.                                     else{
  687.                                         idAccordoServizioParteSpecifica.setVersione(Integer.parseInt(versioneServizio));
  688.                                     }
  689.                                     idAccordoServizioParteSpecifica.setSoggettoErogatore(new IdSoggetto());
  690.                                     idAccordoServizioParteSpecifica.getSoggettoErogatore().setTipo(tipoSogg);
  691.                                     idAccordoServizioParteSpecifica.getSoggettoErogatore().setNome(nomeSogg);
  692.                                     
  693.                                     if(oldTipoSogg!=null && oldNomeSogg!=null){
  694.                                         // Check se operazione di change che  l'operazione di modifica del soggetto non sia ancora in rollback.
  695.                                         // Se sussite, aspetto l'operazione.
  696.                                         FilterParameter filtro = operazioneInGestione.getFilterChangeIDSoggetto(tipoSogg,nomeSogg,oldTipoSogg,oldNomeSogg);                                     
  697.                                         if(operazioneInGestione.existsOperationNotCompleted("change", operation.getHostname(), filtro)){
  698.                                             idAccordoServizioParteSpecifica.getSoggettoErogatore().setTipo(oldTipoSogg);
  699.                                             idAccordoServizioParteSpecifica.getSoggettoErogatore().setNome(oldNomeSogg);
  700.                                             this.log.debug("ChangeServizio: operazione change ID Soggetto non ancora completata: utilizzo OLD nome");
  701.                                         }else{
  702.                                             this.log.debug("ChangeServizio: operazione change ID Soggetto completata: utilizzo nome");
  703.                                         }
  704.                                     }
  705.                                     
  706.                                     // NOTA: Il soggetto del servizio, nella govwayConsole non e' modificabile.
  707.                                     this.accordoServizioParteSpecificaPort.update(idAccordoServizioParteSpecifica, accordoServizioParteSpecifica);

  709.                                 } 
  710.                                 /*
  711.                                 else if (TipoOggettoDaSmistare.fruitore.equals(tipoOggettoDaSmistare)) {

  713.                                     IdAccordoServizioParteSpecifica idAccordoServizioParteSpecifica = new IdAccordoServizioParteSpecifica();
  714.                                     idAccordoServizioParteSpecifica.setNome(nomeAccordo);
  715.                                     idAccordoServizioParteSpecifica.setVersione(versioneAccordo);
  716.                                     idAccordoServizioParteSpecifica.setSoggettoErogatore(new IdSoggetto());
  717.                                     idAccordoServizioParteSpecifica.getSoggettoErogatore().setTipo(tipoSogg);
  718.                                     idAccordoServizioParteSpecifica.getSoggettoErogatore().setNome(nomeSogg);
  719.                                     
  720.                                     this.accordoServizioParteSpecificaPort.update(idAccordoServizioParteSpecifica, accordoServizioParteSpecifica);
  721.                                 }
  722.                                 */
  723.                                 
  724.                             } catch (Exception e) {
  725.                                 operazioneInGestione.error("Riscontrato errore di creazione/update servizio: " + e.toString(), e);
  726.                                 continue;
  727.                             }
  728.                         }

  730.                         // ELIMINAZIONE servizio
  731.                         else if (TipoOggettoDaSmistare.servizio.equals(tipoOggettoDaSmistare) && Operazione.del.equals(tipoOperazioneCRUD)) {

  733.                             try {
  734.                                 IdAccordoServizioParteSpecifica idAccordoServizioParteSpecifica = new IdAccordoServizioParteSpecifica();
  735.                                 idAccordoServizioParteSpecifica.setTipo(tipoServizio);
  736.                                 idAccordoServizioParteSpecifica.setNome(nomeServizio);
  737.                                 idAccordoServizioParteSpecifica.setVersione(Integer.parseInt(versioneServizio));
  738.                                 idAccordoServizioParteSpecifica.setSoggettoErogatore(new IdSoggetto());
  739.                                 idAccordoServizioParteSpecifica.getSoggettoErogatore().setTipo(tipoSogg);
  740.                                 idAccordoServizioParteSpecifica.getSoggettoErogatore().setNome(nomeSogg);
  741.                                 
  742.                                 this.accordoServizioParteSpecificaPort.deleteById(idAccordoServizioParteSpecifica);
  743.                                 
  744.                             } catch (Exception e) {
  745.                                 operazioneInGestione.error("Riscontrato errore di eliminazione servizio: " + e.toString(), e);
  746.                                 continue;
  747.                             }
  748.                         }
  749.                     }

  751.                     // * ***** ACCORDI DI SERVIZIO PARTE COMUNE ***** */
  752.                     if (TipoOggettoDaSmistare.accordo.equals(tipoOggettoDaSmistare)) {

  754.                         String nomeAcc = operation.getParameterValue(OperationsParameter.NOME_ACCORDO.getNome());
  755.                         String versioneAcc = operation.getParameterValue(OperationsParameter.VERSIONE_ACCORDO.getNome());
  756.                         Integer versioneAccordoInt = Integer.parseInt(versioneAcc);
  757.                         String tipoReferenteAcc = operation.getParameterValue(OperationsParameter.TIPO_REFERENTE.getNome());
  758.                         String nomeReferenteAcc = operation.getParameterValue(OperationsParameter.NOME_REFERENTE.getNome());
  759.                         IDAccordo idAccordoServizioParteComune = 
  760.                                 IDAccordoFactory.getInstance().getIDAccordoFromValues(nomeAcc,tipoReferenteAcc,nomeReferenteAcc,versioneAccordoInt);

  762.                         AccordoServizioParteComune accordoServizioParteComune = null;
  763.                         
  764.                         // CREAZIONE/MODIFICA
  765.                         if (Operazione.change.equals(tipoOperazioneCRUD) || Operazione.add.equals(tipoOperazioneCRUD)) {

  767.                             // Ottengo nuova immagine dell'accordo
  768.                             try {
  769.                                 accordoServizioParteComune = this.apcCore.getAccordoServizioFull(idAccordoServizioParteComune,true);
  770.                             } catch (DriverRegistroServiziNotFound de) {
  771.                                 operazioneInGestione.waitBeforeInvalid("Accordo di Servizio non esistente nel database della govwayConsole: " + de.toString());
  772.                                 continue;
  773.                             } catch (Exception e) {
  774.                                 operazioneInGestione.error("Riscontrato errore durante la get dell'immagine dell'accordo: " + e.getMessage(), e);
  775.                                 continue;
  776.                             }

  778.                             try {

  780.                                 if (Operazione.add.equals(tipoOperazioneCRUD)) {
  781.                                     
  782.                                     this.accordoServizioParteComunePort.create(accordoServizioParteComune);
  783.                                     
  784.                                 } else if (Operazione.change.equals(tipoOperazioneCRUD)) {
  785.                                     
  786.                                     String nomeOLDAcc = operation.getParameterValue(OperationsParameter.OLD_NOME_ACCORDO.getNome());
  787.                                     if(nomeOLDAcc!=null){
  788.                                         String versioneOLDAcc = operation.getParameterValue(OperationsParameter.OLD_VERSIONE_ACCORDO.getNome());
  789.                                         Integer versioneOldAccordoInt = Integer.parseInt(versioneOLDAcc);
  790.                                         String tipoReferenteOLDAcc = operation.getParameterValue(OperationsParameter.OLD_TIPO_REFERENTE.getNome());
  791.                                         String nomeReferenteOLDAcc = operation.getParameterValue(OperationsParameter.OLD_NOME_REFERENTE.getNome());
  792.                                         IDAccordo oldIdAccordoServizioParteComune = IDAccordoFactory.getInstance().
  793.                                                 getIDAccordoFromValues(nomeOLDAcc,tipoReferenteOLDAcc,nomeReferenteOLDAcc,versioneOldAccordoInt);
  794.                                         
  795.                                         if(tipoReferenteOLDAcc!=null && nomeReferenteOLDAcc!=null){
  796.                                             // Check se operazione di change che  l'operazione di modifica del soggetto non sia ancora in rollback.
  797.                                             // Se sussite, aspetto l'operazione.
  798.                                             FilterParameter filtro = operazioneInGestione.getFilterChangeIDSoggetto(tipoReferenteAcc,nomeReferenteAcc,tipoReferenteOLDAcc,nomeReferenteOLDAcc);                                     
  799.                                             if(operazioneInGestione.existsOperationNotCompleted("change", operation.getHostname(), filtro)){
  800.                                                 this.log.debug("ChangeServizio: operazione change ID Soggetto non ancora completata: utilizzo OLD nome");
  801.                                             }else{
  802.                                                 this.log.debug("ChangeServizio: operazione change ID Soggetto completata: utilizzo nome");
  803.                                                 oldIdAccordoServizioParteComune.getSoggettoReferente().setTipo(tipoReferenteAcc);
  804.                                                 oldIdAccordoServizioParteComune.getSoggettoReferente().setNome(nomeReferenteAcc);
  805.                                             }
  806.                                         }
  807.                                         
  808.                                         accordoServizioParteComune.setOldIDAccordoForUpdate(oldIdAccordoServizioParteComune);
  809.                                         
  810.                                         this.accordoServizioParteComunePort.update(new IdAccordoServizioParteComune(oldIdAccordoServizioParteComune), accordoServizioParteComune);
  811.                                     }
  812.                                     else{
  813.                                         
  814.                                         this.accordoServizioParteComunePort.update(new IdAccordoServizioParteComune(idAccordoServizioParteComune), accordoServizioParteComune);
  815.                                         
  816.                                     }
  817.                                 }

  819.                             } catch (Exception e) {
  820.                                 operazioneInGestione.error("Riscontrato errore di creazione/update accordo servizio: " + e.toString(), e);
  821.                                 continue;
  822.                             }
  823.                         }

  825.                         // ELIMINAZIONE
  826.                         else if (Operazione.del.equals(tipoOperazioneCRUD)) {
  827.                             try {

  829.                                 this.accordoServizioParteComunePort.deleteById(new IdAccordoServizioParteComune(idAccordoServizioParteComune));

  831.                             } catch (Exception e) {
  832.                                 operazioneInGestione.error("Riscontrato errore di cancellazione accordo servizio: " + e.toString(), e);
  833.                                 continue;
  834.                             }

  836.                         }
  837.                     }
  838.                     
  839.                     
  840.                     // * ***** ACCORDI DI COOPERAZIONE ***** */
  841.                     if (TipoOggettoDaSmistare.accordoCooperazione.equals(tipoOggettoDaSmistare)) {

  843.                         String nomeAcc = operation.getParameterValue(OperationsParameter.NOME_ACCORDO.getNome());
  844.                         String versioneAcc = operation.getParameterValue(OperationsParameter.VERSIONE_ACCORDO.getNome());
  845.                         Integer versioneAccordoInt = Integer.parseInt(versioneAcc);
  846.                         String tipoReferenteAcc = operation.getParameterValue(OperationsParameter.TIPO_REFERENTE.getNome());
  847.                         String nomeReferenteAcc = operation.getParameterValue(OperationsParameter.NOME_REFERENTE.getNome());
  848.                         IDAccordoCooperazione idAccordoCooperazione = 
  849.                                 IDAccordoCooperazioneFactory.getInstance().getIDAccordoFromValues(nomeAcc,tipoReferenteAcc,nomeReferenteAcc,versioneAccordoInt);

  851.                         AccordoCooperazione accordoCooperazione = null;
  852.                         
  853.                         // CREAZIONE/MODIFICA
  854.                         if (Operazione.change.equals(tipoOperazioneCRUD) || Operazione.add.equals(tipoOperazioneCRUD)) {

  856.                             // Ottengo nuova immagine dell'accordo
  857.                             try {
  858.                                 accordoCooperazione = this.acCore.getAccordoCooperazione(idAccordoCooperazione,true);
  859.                             } catch (DriverRegistroServiziNotFound de) {
  860.                                 operazioneInGestione.waitBeforeInvalid("Accordo di Cooperazione non esistente nel database della govwayConsole: " + de.toString());
  861.                                 continue;
  862.                             } catch (Exception e) {
  863.                                 operazioneInGestione.error("Riscontrato errore durante la get dell'immagine dell'accordo di cooperazione: " + e.getMessage(), e);
  864.                                 continue;
  865.                             }

  867.                             try {

  869.                                 if (Operazione.add.equals(tipoOperazioneCRUD)) {
  870.                                     
  871.                                     this.accordoCooperazionePort.create(accordoCooperazione);
  872.                                 
  873.                                 } else if (Operazione.change.equals(tipoOperazioneCRUD)) { 
  874.                                     
  875.                                     String nomeOLDAcc = operation.getParameterValue(OperationsParameter.OLD_NOME_ACCORDO.getNome());
  876.                                     if(nomeOLDAcc!=null){
  877.                                         String versioneOLDAcc = operation.getParameterValue(OperationsParameter.OLD_VERSIONE_ACCORDO.getNome());
  878.                                         Integer versioneOldAccordoInt = Integer.parseInt(versioneOLDAcc);
  879.                                         String tipoReferenteOLDAcc = operation.getParameterValue(OperationsParameter.OLD_TIPO_REFERENTE.getNome());
  880.                                         String nomeReferenteOLDAcc = operation.getParameterValue(OperationsParameter.OLD_NOME_REFERENTE.getNome());
  881.                                         IDAccordoCooperazione oldIdAccordoCooperazione = IDAccordoCooperazioneFactory.getInstance().
  882.                                                 getIDAccordoFromValues(nomeOLDAcc,tipoReferenteOLDAcc,nomeReferenteOLDAcc,versioneOldAccordoInt);
  883.                                         
  884.                                         if(tipoReferenteOLDAcc!=null && nomeReferenteOLDAcc!=null){
  885.                                             // Check se operazione di change che  l'operazione di modifica del soggetto non sia ancora in rollback.
  886.                                             // Se sussite, aspetto l'operazione.
  887.                                             FilterParameter filtro = operazioneInGestione.getFilterChangeIDSoggetto(tipoReferenteAcc,nomeReferenteAcc,tipoReferenteOLDAcc,nomeReferenteOLDAcc);                                     
  888.                                             if(operazioneInGestione.existsOperationNotCompleted("change", operation.getHostname(), filtro)){
  889.                                                 this.log.debug("ChangeServizio: operazione change ID Soggetto non ancora completata: utilizzo OLD nome");
  890.                                             }else{
  891.                                                 this.log.debug("ChangeServizio: operazione change ID Soggetto completata: utilizzo nome");
  892.                                                 oldIdAccordoCooperazione.getSoggettoReferente().setTipo(tipoReferenteAcc);
  893.                                                 oldIdAccordoCooperazione.getSoggettoReferente().setNome(nomeReferenteAcc);
  894.                                             }
  895.                                         }
  896.                                         
  897.                                         accordoCooperazione.setOldIDAccordoForUpdate(oldIdAccordoCooperazione);
  898.                                         
  899.                                         this.accordoCooperazionePort.update(new IdAccordoCooperazione(oldIdAccordoCooperazione), accordoCooperazione);
  900.                                     }
  901.                                     else{
  902.                                         this.accordoCooperazionePort.update(new IdAccordoCooperazione(idAccordoCooperazione), accordoCooperazione);
  903.                                     }
  904.                                     
  905.                                 }

  907.                             } catch (Exception e) {
  908.                                 operazioneInGestione.error("Riscontrato errore di creazione/update accordo di cooperazione: " + e.toString(), e);
  909.                                 continue;
  910.                             }
  911.                         }

  913.                         // ELIMINAZIONE
  914.                         else if (Operazione.del.equals(tipoOperazioneCRUD)) {
  915.                             try {

  917.                                 this.accordoCooperazionePort.deleteById(new IdAccordoCooperazione(idAccordoCooperazione));

  919.                             } catch (Exception e) {
  920.                                 operazioneInGestione.error("Riscontrato errore di cancellazione accordo di cooperazione: " + e.toString(), e);
  921.                                 continue;
  922.                             }

  924.                         }
  925.                     }
  926.                     

  928.                     // Operazione che riguarda la pdd
  929.                     if (TipoOggettoDaSmistare.pdd.equals(tipoOggettoDaSmistare)) {

  931.                         String nomePortaDominio = operation.getParameterValue(OperationsParameter.PORTA_DOMINIO.getNome());
  932.                         IdPortaDominio idPortaDominio = new IdPortaDominio(nomePortaDominio);
  933.                         PortaDominio portaDominio = null;

  935.                         // CREAZIONE/MODIFICA
  936.                         if (Operazione.change.equals(tipoOperazioneCRUD) || Operazione.add.equals(tipoOperazioneCRUD)) {

  938.                             // Ottengo nuova immagine della porta di dominio
  939.                             try {
  940.                                 portaDominio = this.pddCore.getPortaDominio(nomePortaDominio);
  941.                             } catch (DriverRegistroServiziNotFound de) {
  942.                                 operazioneInGestione.waitBeforeInvalid("Porta di dominio non esistente nel database: " + de.toString());
  943.                                 continue;
  944.                             } catch (Exception e) {
  945.                                 operazioneInGestione.error("Riscontrato errore durante la get della porta di dominio: " + e.getMessage(), e);
  946.                                 continue;
  947.                             }

  949.                             // Controllo elementi obbligatori
  950.                             try {
  951.                                 this.validazionePortaDominio(portaDominio);
  952.                             } catch (Exception e) {
  953.                                 operazioneInGestione.invalid(e.getMessage());
  954.                                 continue;
  955.                             }

  957.                             if (Operazione.add.equals(tipoOperazioneCRUD)) {
  958.                                 try {
  959.                                     this.pddPort.create(portaDominio);
  960.                                 } catch (Exception e) {
  961.                                     operazioneInGestione.error("Riscontrato errore di creazione porta di dominio: " + e.getMessage(), e);
  962.                                     continue;
  963.                                 }
  964.                             } else if (Operazione.change.equals(tipoOperazioneCRUD)) {
  965.                                 try {
  966.                                     
  967.                                     this.pddPort.update(idPortaDominio, portaDominio);
  968.                                 } catch (Exception e) {
  969.                                     operazioneInGestione.error("Riscontrato errore di update porta di dominio: " + e.getMessage(), e);
  970.                                     continue;
  971.                                 }
  972.                             }
  973.                         }

  975.                         // ELIMINAZIONE
  976.                         else if (Operazione.del.equals(tipoOperazioneCRUD)) {
  977.                             try {
  978.                                 this.pddPort.deleteById(idPortaDominio);
  979.                             } catch (Exception e) {
  980.                                 operazioneInGestione.error("Riscontrato errore di eliminazione porta di dominio: " + e.getMessage(), e);
  981.                                 continue;
  982.                             }
  983.                         }
  984.                     }

  986.                     // Se arrivo qui, significa che l'operazione non ha dato
  987.                     // errore,
  988.                     // aggiorno il db
  989.                     operazioneInGestione.success("Done.");

  991.                 }

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

  995.             } catch (javax.jms.JMSException e) {
  996.                 try {

  998.                     this.qs.rollback();
  999.                 } catch (Exception er) {
  1000.                 }
  1001.                 this.log.error("GestoreRegistro: Riscontrato errore durante la gestione di una richiesta: " + e.toString(), e);
  1002.                 try {
  1003.                     Utilities.sleep(5000);
  1004.                     this.log.debug("GestoreRegistro: Re-Inizializzazione Receiver ...");
  1005.                     try {
  1006.                         this.receiver.close();
  1007.                     } catch (Exception eclose) {
  1008.                     }
  1009.                     try {
  1010.                         this.qs.close();
  1011.                     } catch (Exception eclose) {
  1012.                     }
  1013.                     try {
  1014.                         this.qc.close();
  1015.                     } catch (Exception eclose) {
  1016.                     }
  1017.                     this.qc = this.qcf.createQueueConnection();
  1018.                     // Ripristino stato Exception Listener
  1019.                     if (this.exceptionListenerJMS.isConnessioneCorrotta()) {
  1020.                         this.exceptionListenerJMS.setConnessioneCorrotta(false);
  1021.                         this.exceptionListenerJMS.setException(null);
  1022.                     }
  1023.                     this.qc.setExceptionListener(this.exceptionListenerJMS);
  1024.                     this.qs = this.qc.createQueueSession(true, -1);
  1025.                     this.receiver = this.qs.createReceiver(this.queue);
  1026.                     this.qc.start();
  1027.                     this.log.debug("GestoreRegistro: Re-Inizializzazione Receiver effettuata.");
  1028.                     riconnessioneConErrore = false;
  1029.                 } catch (Exception er) {
  1030.                     this.log.error("GestoreRegistro: Re-Inizializzazione Receiver non effettuata:" + er.toString());
  1031.                     riconnessioneConErrore = true;
  1032.                 }
  1033.             } catch (ClassQueueException e) {
  1034.                 try {
  1035.                     if(operation!=null) {
  1036.                         operation.setStatus(OperationStatus.ERROR);
  1037.                         operation.setDetails(e.toString());
  1038.                         operation.setTimeExecute(new Timestamp(System.currentTimeMillis()));
  1039.                         operationManager.updateOperation(operation);
  1040.                     }
  1041.                     this.qs.rollback();
  1042.                 } catch (Exception er) {
  1043.                 }
  1044.                 this.log.error("GestoreRegistro: Riscontrato errore durante operazione sulla coda: " + e.toString(), e);
  1045.             } catch (Exception e) {
  1046.                 try {
  1047.                     this.qs.rollback();
  1048.                 } catch (Exception er) {
  1049.                 }
  1050.                 this.log.error("GestoreRegistro: Riscontrato errore durante la gestione di una richiesta: " + e.toString(), e);
  1051.             } finally {
  1052.                 try {
  1053.                     this.dbm.releaseConnection(this.con);
  1054.                 } catch (Exception eLogger) {
  1055.                 }
  1056.             }

  1058.         }// CHIUDO WHILE

  1060.         // Chiusura connessione
  1061.         try {
  1062.             if (this.receiver != null) {
  1063.                 this.receiver.close();
  1064.             }
  1065.             if (this.qs != null) {
  1066.                 this.qs.rollback();
  1067.                 this.qs.close();
  1068.             }
  1069.             if (this.qc != null) {
  1070.                 this.qc.stop();
  1071.                 this.qc.close();
  1072.             }
  1073.         } catch (Exception e) {
  1074.             try {
  1075.                 this.log.error("GestoreRegistro: Riscontrato errore durante la chiusura del Thread: " + e.toString());
  1076.             } catch (Exception eLogger) {
  1077.             }
  1078.         }
  1079.         
  1080.         this.isRunning = false;
  1081.         this.log.debug("Thread terminato");
  1082.     }

  1084.     /**
  1085.      * Inizializzazione Gestore
  1086.      */
  1087.     @Override
  1088.     public void initGestore() throws Exception {
  1089.         
  1090.         // Controllo se dbmanager inizializzato
  1091.         // Il DBManager viene inizializzato nell'InitListener
  1092.         if (!DBManager.isInitialized()) {
  1093.             this.log.info("Inizializzazione di " + this.getClass().getSimpleName() + " non riuscito perche' DBManager non INIZIALIZZATO");
  1094.             throw new Exception("Inizializzazione di " + this.getClass().getSimpleName() + "FALLITA");
  1095.         }
  1096.         
  1097.         this.log.debug("Lettura dei parametri da console.properties");
  1098.         String registroServiziQueue = this.consoleProperties.getGestioneCentralizzataNomeCodaRegistroServizi();
  1099.         boolean engineRegistro = this.consoleProperties.isGestioneCentralizzataSincronizzazioneRegistro();
  1100.         this.singlePdD = this.consoleProperties.isSinglePdD();
  1101.         boolean trovato = false;

  1103.         if (engineRegistro == false) {
  1104.             //this.log.info("Motore di sincronizzazione verso il Registro dei Servizi non attivo.");
  1105.             throw new GestoreNonAttivoException("Motore di sincronizzazione verso il Registro dei Servizi non attivo.");
  1106.         }

  1108.         // Leggo informazioni per queue.properties
  1109.         // Init JMS
  1110.         // readQueueProperties(cfName, cfProp);
  1111.         QueueManager queueMan = QueueManager.getInstance();
  1112.         if (queueMan == null) {
  1113.             this.log.debug("Impossibile avviare " + this.getClass().getSimpleName() + "QueueManager non inizializzato.");
  1114.             throw new Exception("Impossibile avviare " + this.getClass().getSimpleName() + "QueueManager non inizializzato.");
  1115.         }

  1117.         trovato = false;
  1118.         int i = 0;
  1119.         this.log.debug("Inizializzazione Receiver ...");
  1120.         while (!trovato && (i < 600000)) {
  1121.             try {
  1122.                 // InitialContext ctx = new InitialContext(cfProp);
  1123.                 // queue = (Queue) ctx.lookup(registroServiziQueue);
  1124.                 // qcf = (QueueConnectionFactory) ctx.lookup(cfName);
  1125.                 this.qcf = queueMan.getQueueConnectionFactory();
  1126.                 this.queue = queueMan.getQueue(registroServiziQueue);

  1128.                 this.qc = this.qcf.createQueueConnection();
  1129.                 this.qc.setExceptionListener(this.exceptionListenerJMS);
  1130.                 this.qs = this.qc.createQueueSession(true, -1);
  1131.                 this.receiver = this.qs.createReceiver(this.queue);
  1132.                 this.qc.start();
  1133.                 // ctx.close();
  1134.                 this.log.debug("GestoreRegistro: Inizializzazione Receiver effettuata.");
  1135.                 trovato = true;
  1136.             } catch (Exception e) {
  1137.                 i = i + 10000;
  1138.                 Utilities.sleep(10000);
  1139.                 this.log.debug("Ritento Inizializzazione Receiver ... causa: " + e.getMessage());
  1140.             }
  1141.         }

  1143.         if (!trovato) {
  1144.             this.log.error("Inizializzazione Receiver non effettuata");
  1145.             throw new Exception("Inizializzazione Receiver non effettuata");
  1146.         }

  1148.         // Init WebServiceCore
  1149.         try {
  1150.             // ws
  1151.             this.accordoCooperazioneService = new AccordoCooperazioneSoap11Service();
  1152.             this.accordoServizioParteComuneService = new AccordoServizioParteComuneSoap11Service();
  1153.             this.accordoServizioParteSpecificaService = new AccordoServizioParteSpecificaSoap11Service();
  1154.             this.soggettoService = new SoggettoSoap11Service();
  1155.             this.pddService = new PortaDominioSoap11Service();
  1156.             
  1157.             this.accordoCooperazionePort = this.accordoCooperazioneService.getAccordoCooperazionePortSoap11();
  1158.             this.accordoServizioParteComunePort = this.accordoServizioParteComuneService.getAccordoServizioParteComunePortSoap11();
  1159.             this.accordoServizioParteSpecificaPort = this.accordoServizioParteSpecificaService.getAccordoServizioParteSpecificaPortSoap11();
  1160.             this.soggettoPort = this.soggettoService.getSoggettoPortSoap11();
  1161.             this.pddPort = this.pddService.getPortaDominioPortSoap11();
  1162.             
  1163.             ((BindingProvider)this.accordoCooperazionePort).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
  1164.                     this.consoleProperties.getGestioneCentralizzataWSRegistroServiziEndpointAccordoCooperazione());
  1165.             ((BindingProvider)this.accordoServizioParteComunePort).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
  1166.                     this.consoleProperties.getGestioneCentralizzataWSRegistroServiziEndpointAccordoServizioParteComune());
  1167.             ((BindingProvider)this.accordoServizioParteSpecificaPort).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
  1168.                     this.consoleProperties.getGestioneCentralizzataWSRegistroServiziEndpointAccordoServizioParteSpecifica());
  1169.             ((BindingProvider)this.soggettoPort).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
  1170.                     this.consoleProperties.getGestioneCentralizzataWSRegistroServiziEndpointSoggetto());
  1171.             ((BindingProvider)this.pddPort).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
  1172.                     this.consoleProperties.getGestioneCentralizzataWSRegistroServiziEndpointPdd());
  1173.             
  1174.             ((BindingProvider)this.accordoCooperazionePort).getRequestContext().put("schema-validation-enabled", true);
  1175.             ((BindingProvider)this.accordoServizioParteComunePort).getRequestContext().put("schema-validation-enabled", true);
  1176.             ((BindingProvider)this.accordoServizioParteSpecificaPort).getRequestContext().put("schema-validation-enabled", true);
  1177.             ((BindingProvider)this.soggettoPort).getRequestContext().put("schema-validation-enabled", true);
  1178.             ((BindingProvider)this.pddPort).getRequestContext().put("schema-validation-enabled", true);
  1179.             
  1180.             String username = this.consoleProperties.getGestioneCentralizzataWSRegistroServiziCredenzialiBasicUsername();
  1181.             String password = this.consoleProperties.getGestioneCentralizzataWSRegistroServiziCredenzialiBasicPassword();
  1182.             if(username !=null && password!=null){
  1183.                 // to use Basic HTTP Authentication: 
  1184.                 
  1185.                 ((BindingProvider)this.accordoCooperazionePort).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
  1186.                 ((BindingProvider)this.accordoCooperazionePort).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
  1187.                 
  1188.                 ((BindingProvider)this.accordoServizioParteComunePort).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
  1189.                 ((BindingProvider)this.accordoServizioParteComunePort).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
  1190.                 
  1191.                 ((BindingProvider)this.accordoServizioParteSpecificaPort).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
  1192.                 ((BindingProvider)this.accordoServizioParteSpecificaPort).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
  1193.                 
  1194.                 ((BindingProvider)this.soggettoPort).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
  1195.                 ((BindingProvider)this.soggettoPort).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
  1196.                 
  1197.                 ((BindingProvider)this.pddPort).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
  1198.                 ((BindingProvider)this.pddPort).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
  1199.             }
  1200.             
  1201.             this.log.debug("GestoreRegistro: Inizializzato WebService. AccordoCooperazione: " + this.accordoCooperazioneService.getClass().getSimpleName());
  1202.             this.log.debug("GestoreRegistro: Inizializzato WebService. AccordoServizioParteComune: " + this.accordoServizioParteComuneService.getClass().getSimpleName());
  1203.             this.log.debug("GestoreRegistro: Inizializzato WebService. AccordoServizioParteSpecifica: " + this.accordoServizioParteSpecificaService.getClass().getSimpleName());
  1204.             this.log.debug("GestoreRegistro: Inizializzato WebService. Soggetto: " + this.soggettoService.getClass().getSimpleName());
  1205.             this.log.debug("GestoreRegistro: Inizializzato WebService. PortaDominio: " + this.pddService.getClass().getSimpleName());
  1206.             
  1207.         } catch (Exception e) {
  1208.             this.log.error("Riscontrato Errore durante la connessione al WebService.", e);
  1209.             this.log.info("GestoreRegistro non avviato.");
  1210.             throw new Exception("Riscontrato Errore durante la connessione al WebService.", e);
  1211.         }

  1213.         // Init ControlStationCore
  1214.         try {
  1215.             this.soggettiCore = new SoggettiCore();
  1216.             this.pddCore = new PddCore(this.soggettiCore);
  1217.             this.apcCore = new AccordiServizioParteComuneCore(this.soggettiCore);
  1218.             this.apsCore = new AccordiServizioParteSpecificaCore(this.soggettiCore);
  1219.             this.acCore = new AccordiCooperazioneCore(this.soggettiCore);

  1221.             this.log.debug("GestoreRegistro: Inizializzato Core. ");
  1222.             
  1223.         } catch (Exception e) {
  1224.             this.log.error("Riscontrato Errore durante l'inizializzazione di ControlStationCore.", e);
  1225.             this.log.info("GestoreRegistro non avviato.");
  1226.             throw new ControlStationCoreException("Riscontrato Errore durante l'inizializzazione di ControlStationCore.", e);
  1227.         }

  1229.     }

  1231.     @Override
  1232.     public void stopGestore() {
  1233.         this.stop = true;
  1234.         
  1235.         this.log.debug("Fermo il thread ...");
  1236.         int timeout = 60;
  1237.         for (int i = 0; i < timeout; i++) {
  1238.             if(this.isRunning()){
  1239.                 Utilities.sleep(1000);
  1240.             }
  1241.             else{
  1242.                 break;
  1243.             }
  1244.         }
  1245.         if(this.isRunning){
  1246.             this.log.debug("Sono trascorsi 60 secondi ed il thread non รจ ancora terminato??");
  1247.         }
  1248.     }

  1250.     @Override
  1251.     protected String getName() {
  1252.         return this.name;
  1253.     }

  1255.     private void validazionePortaDominio(PortaDominio pdd) throws Exception {

  1257.         if ((pdd.getNome() == null) || ("".equals(pdd.getNome()))) {
  1258.             throw new Exception("Riscontrato errore: Nome Porta di dominio, non definito");
  1259.         }

  1261.     }
  1262. }
Created with JaCoCo 0.8.8.202204050719