AbstractStatistiche.java

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

  22. import java.util.ArrayList;
  23. import java.util.Calendar;
  24. import java.util.Date;
  25. import java.util.HashMap;
  26. import java.util.List;
  27. import java.util.Map;

  29. import org.openspcoop2.core.commons.dao.DAOFactoryProperties;
  30. import org.openspcoop2.core.constants.CostantiDB;
  31. import org.openspcoop2.core.constants.TipoPdD;
  32. import org.openspcoop2.core.id.IDServizio;
  33. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  34. import org.openspcoop2.core.statistiche.Statistica;
  35. import org.openspcoop2.core.statistiche.StatisticaContenuti;
  36. import org.openspcoop2.core.statistiche.constants.TipoIntervalloStatistico;
  37. import org.openspcoop2.core.statistiche.dao.IServiceManager;
  38. import org.openspcoop2.core.statistiche.dao.IStatisticaInfoService;
  39. import org.openspcoop2.core.statistiche.dao.IStatisticaInfoServiceSearch;
  40. import org.openspcoop2.core.statistiche.model.StatisticaModel;
  41. import org.openspcoop2.core.transazioni.constants.PddRuolo;
  42. import org.openspcoop2.core.transazioni.dao.ITransazioneServiceSearch;
  43. import org.openspcoop2.generic_project.beans.ConstantField;
  44. import org.openspcoop2.generic_project.beans.FunctionField;
  45. import org.openspcoop2.generic_project.beans.Union;
  46. import org.openspcoop2.generic_project.beans.UnionExpression;
  47. import org.openspcoop2.generic_project.dao.IDBServiceUtilities;
  48. import org.openspcoop2.generic_project.dao.IServiceSearchWithoutId;
  49. import org.openspcoop2.generic_project.dao.IServiceWithoutId;
  50. import org.openspcoop2.generic_project.exception.ExpressionException;
  51. import org.openspcoop2.generic_project.exception.ExpressionNotImplementedException;
  52. import org.openspcoop2.generic_project.exception.MultipleResultException;
  53. import org.openspcoop2.generic_project.exception.NotFoundException;
  54. import org.openspcoop2.generic_project.exception.NotImplementedException;
  55. import org.openspcoop2.generic_project.exception.ServiceException;
  56. import org.openspcoop2.generic_project.expression.IExpression;
  57. import org.openspcoop2.generic_project.expression.Index;
  58. import org.openspcoop2.generic_project.expression.impl.sql.ISQLFieldConverter;
  59. import org.openspcoop2.monitor.engine.condition.EsitoUtils;
  60. import org.openspcoop2.monitor.engine.condition.FilterImpl;
  61. import org.openspcoop2.monitor.engine.config.BasicServiceLibrary;
  62. import org.openspcoop2.monitor.engine.config.BasicServiceLibraryReader;
  63. import org.openspcoop2.monitor.engine.config.StatisticsServiceLibrary;
  64. import org.openspcoop2.monitor.engine.config.StatisticsServiceLibraryReader;
  65. import org.openspcoop2.monitor.engine.config.TransactionServiceLibrary;
  66. import org.openspcoop2.monitor.engine.config.TransactionServiceLibraryReader;
  67. import org.openspcoop2.monitor.engine.config.statistiche.ConfigurazioneStatistica;
  68. import org.openspcoop2.monitor.engine.config.statistiche.dao.IConfigurazioneStatisticaService;
  69. import org.openspcoop2.monitor.engine.constants.Costanti;
  70. import org.openspcoop2.monitor.engine.dynamic.DynamicFactory;
  71. import org.openspcoop2.monitor.engine.dynamic.IDynamicLoader;
  72. import org.openspcoop2.monitor.sdk.constants.StatisticType;
  73. import org.openspcoop2.monitor.sdk.exceptions.StatisticException;
  74. import org.openspcoop2.monitor.sdk.plugins.IStatisticProcessing;
  75. import org.openspcoop2.monitor.sdk.statistic.StatisticResourceFilter;
  76. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  77. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  78. import org.openspcoop2.protocol.utils.EsitiProperties;
  79. import org.openspcoop2.utils.BooleanNullable;
  80. import org.openspcoop2.utils.LoggerWrapperFactory;
  81. import org.openspcoop2.utils.TipiDatabase;
  82. import org.openspcoop2.utils.date.DateManager;
  83. import org.openspcoop2.utils.sql.Case;
  84. import org.openspcoop2.utils.sql.CastColumnType;
  85. import org.openspcoop2.utils.sql.ISQLQueryObject;
  86. import org.openspcoop2.utils.sql.SQLObjectFactory;
  87. import org.slf4j.Logger;



  91. /**
  92.  * AbstractStatistiche
  93.  *
  94.  * @author Poli Andrea (apoli@link.it)
  95.  * @author $Author$
  96.  * @version $Rev$, $Date$
  97.  */
  98. public abstract class AbstractStatistiche implements IStatisticsEngine {

  100.     protected Logger logger = LoggerWrapperFactory.getLogger(AbstractStatistiche.class);
  101.     private void logDebug(String msg) {
  102.         if(this.logger!=null) {
  103.             this.logger.debug(msg);
  104.         }
  105.     }
  106.     private void logDebug(String msg, Throwable e) {
  107.         if(this.logger!=null) {
  108.             this.logger.debug(msg,e);
  109.         }
  110.     }
  111.     private void logError(String msg, Throwable e) {
  112.         if(this.logger!=null) {
  113.             this.logger.error(msg,e);
  114.         }
  115.     }
  116.     protected boolean debug = false;
  117.     protected boolean useUnionForLatency = true;
  118.     protected boolean generazioneStatisticheCustom = false;
  119.     protected boolean analisiTransazioniCustom = false;
  120.     protected long waitMsBeforeNextInterval = 0;
  121.     protected boolean waitStatiInConsegna = false;
  122.     protected boolean gestioneUltimoIntervallo = false;
  123.     protected IServiceManager statisticheSM = null;
  124.     protected IServiceWithoutId<?> statisticaServiceDAO = null;
  125.     protected IServiceSearchWithoutId<?> statisticaServiceSearchDAO = null;
  126.     protected StatisticaModel model = null;
  127.     private IStatisticaInfoServiceSearch statisticaInfoSearchDAO = null;
  128.     private IStatisticaInfoService statisticaInfoDAO = null;
  129.     private ITransazioneServiceSearch transazioneSearchDAO = null;
  130.     private org.openspcoop2.monitor.engine.config.statistiche.dao.IServiceManager pluginsStatisticheSM = null;
  131.     private org.openspcoop2.core.plugins.dao.IServiceManager pluginsBaseSM = null;
  132.     private org.openspcoop2.core.commons.search.dao.IServiceManager utilsSM = null;
  133.     private org.openspcoop2.monitor.engine.config.transazioni.dao.IServiceManager pluginsTransazioniSM;
  134.     @SuppressWarnings("unused")
  135.     private IConfigurazioneStatisticaService confStatisticaDAO =null;
  136.     private TipiDatabase databaseType;
  137.     private StatisticsForceIndexConfig forceIndexConfig;

  139.     private static final String SUFFIX_NON_INIZIALIZZATO = "] non inizializzato";

  141.     private boolean initialized = false;
  142.     
  143.     AbstractStatistiche(){
  144.         
  145.     }

  147.     @Override
  148.     public void init(StatisticsConfig config,
  149.             org.openspcoop2.core.statistiche.dao.IServiceManager statisticheSM,
  150.             org.openspcoop2.core.transazioni.dao.IServiceManager transazioniSM,
  151.             org.openspcoop2.monitor.engine.config.statistiche.dao.IServiceManager pluginsStatisticheSM,
  152.             org.openspcoop2.core.plugins.dao.IServiceManager pluginsBaseSM,
  153.             org.openspcoop2.core.commons.search.dao.IServiceManager utilsSM,
  154.             org.openspcoop2.monitor.engine.config.transazioni.dao.IServiceManager pluginsTransazioniSM){
  155.         if(config.getLogCore()!=null){
  156.             this.logger = config.getLogCore();
  157.         }
  158.         
  159.         this.debug = config.isDebug();
  160.         this.useUnionForLatency = config.isUseUnionForLatency();
  161.         this.generazioneStatisticheCustom = config.isGenerazioneStatisticheCustom();
  162.         this.analisiTransazioniCustom = config.isAnalisiTransazioniCustom();
  163.         this.waitMsBeforeNextInterval = config.getWaitMsBeforeNextInterval();
  164.         this.waitStatiInConsegna = config.isWaitStatiInConsegna();
  165.         this.gestioneUltimoIntervallo = this.isGestioneUltimoIntervallo(config);
  166.         
  167.         try {
  168.             if(statisticheSM==null){
  169.                 throw new ServiceException("StatisticheServiceManager ["+org.openspcoop2.core.statistiche.dao.IServiceManager.class.getName()+SUFFIX_NON_INIZIALIZZATO);
  170.             }
  171.             if(transazioniSM==null){
  172.                 throw new ServiceException("TransazioniServiceManager ["+org.openspcoop2.core.transazioni.dao.IServiceManager.class.getName()+SUFFIX_NON_INIZIALIZZATO);
  173.             }
  174.             
  175.             this.statisticheSM = statisticheSM;
  176.             this.statisticaInfoSearchDAO = this.statisticheSM.getStatisticaInfoServiceSearch();
  177.             this.statisticaInfoDAO = this.statisticheSM.getStatisticaInfoService();

  179.             this.databaseType = DAOFactoryProperties.getInstance(this.logger).getTipoDatabaseEnum(org.openspcoop2.core.statistiche.utils.ProjectInfo.getInstance());
  180.             
  181.             this.transazioneSearchDAO = transazioniSM.getTransazioneServiceSearch();

  183.             if(this.generazioneStatisticheCustom){
  184.                 
  185.                 if(pluginsStatisticheSM==null){
  186.                     throw new ServiceException("PluginStatisticheServiceManager ["+org.openspcoop2.monitor.engine.config.statistiche.dao.IServiceManager.class.getName()+SUFFIX_NON_INIZIALIZZATO);
  187.                 }
  188.                 this.pluginsStatisticheSM = pluginsStatisticheSM;
  189.                 this.confStatisticaDAO  = this. pluginsStatisticheSM.getConfigurazioneStatisticaService();
  190.                 
  191.                 if(utilsSM==null){
  192.                     throw new ServiceException("UtilsServiceManager ["+org.openspcoop2.core.commons.search.dao.IServiceManager.class.getName()+SUFFIX_NON_INIZIALIZZATO);
  193.                 }
  194.                 this.utilsSM = utilsSM;
  195.                 
  196.                 if(pluginsBaseSM==null){
  197.                     throw new ServiceException("PluginBaseServiceManager ["+org.openspcoop2.core.plugins.dao.IServiceManager.class.getName()+SUFFIX_NON_INIZIALIZZATO);
  198.                 }
  199.                 this.pluginsBaseSM = pluginsBaseSM;
  200.                 
  201.                 if(this.analisiTransazioniCustom){
  202.                     if(pluginsTransazioniSM==null){
  203.                         throw new ServiceException("PluginTransazioniServiceManager ["+org.openspcoop2.monitor.engine.config.transazioni.dao.IServiceManager.class.getName()+SUFFIX_NON_INIZIALIZZATO);
  204.                     }
  205.                     this.pluginsTransazioniSM = pluginsTransazioniSM;
  206.                 }
  207.             }
  208.             
  209.             this.forceIndexConfig = config.getForceIndexConfig();
  210.             
  211.             this.initialized = true;
  212.             
  213.         } catch (Exception e) {
  214.             this.logError(e.getMessage(),e);
  215.         }
  216.     }

  218.     public boolean isDebug() {
  219.         return this.debug;
  220.     }
  221.     
  222.     protected TipiDatabase getDatabaseType() {
  223.         return this.databaseType;
  224.     }
  225.     
  226.     public void printDate(Date d){
  227.         Calendar c = Calendar.getInstance();
  228.         c.setTime(d);
  229.         printCalendar(c);
  230.     }

  232.     public void printCalendar(Calendar c){
  233.         StringBuilder bf = new StringBuilder();
  234.         bf.append("DATA ["+c.getTime().toString()+"]");
  235.         bf.append(" DATA in millisecondi: "+c.getTime().getTime());
  236.         bf.append(" YEAR:"+c.get(Calendar.YEAR));
  237.         bf.append(" MONTH:"+(c.get(Calendar.MONTH)+1));
  238.         bf.append(" DAY_OF_MONTH:"+c.get(Calendar.DAY_OF_MONTH));
  239.         bf.append(" HOUR_OF_DAY:"+c.get(Calendar.HOUR_OF_DAY));
  240.         bf.append(" MINUTE:"+c.get(Calendar.MINUTE));
  241.         bf.append(" SECOND:"+c.get(Calendar.SECOND));
  242.         bf.append(" MILLISECOND:"+c.get(Calendar.MILLISECOND));
  243.         this.logDebug(bf.toString());
  244.     }

  246.     // METODI ASTRATTI
  247.     public abstract Date truncDate(Date date,boolean print);

  249.     public abstract Date incrementDate(Date date,boolean print);

  251.     public abstract Date decrementDate(Date date,boolean print);
  252.     
  253.     protected abstract boolean isGestioneUltimoIntervallo(StatisticsConfig config);

  255.     public Date decrementDate1Millisecond(Date date){
  256.         Calendar cTmp = Calendar.getInstance();
  257.         cTmp.setTime(date);
  258.         cTmp.add(Calendar.MILLISECOND, -1);
  259.         return cTmp.getTime();
  260.     }

  262.     public abstract String getIntervalloStatistica(Date date,boolean print);

  264.     private String getIntervalloStatistica(Date date){
  265.         Date d = this.incrementDate(date, false);
  266.         return this.getIntervalloStatistica(d, false);
  267.     }

  269.     public abstract TipoIntervalloStatistico getTipoStatistiche();

  271.     public abstract void callStatisticPluginMethod(IStatisticProcessing statProcessing, StatisticBean stat) throws StatisticException;

  273.     public abstract String getStatisticPluginMethodName() throws StatisticException;


  276.     @Override
  277.     public void generate() throws StatisticsEngineException {

  279.         if(!this.initialized){
  280.             throw new StatisticsEngineException("Inizializzazione fallita (verificare errori precedenti)");
  281.         }

  283.         try{
  284.             if(this.debug)
  285.                 this.logDebug("********************************************* "+this.getTipoStatistiche()+" *******************************************************");

  287.             // Ottengo data in cui e' stato fatto girare l'ultima volta la procedura di popolamento 
  288.             // Tale data viene troncata in funzione della statistica che sto eseguendo 
  289.             // (La prima insert potrebbe contenere informazioni maggiori di quelle che servono: es. in statistiche giornaliere ci potrebbero essere ora,minuti e secondi)
  290.             Date dataUltimaGenerazioneStatistiche = StatisticsInfoUtils.readDataUltimaGenerazioneStatistiche(this.statisticaInfoSearchDAO, this.getTipoStatistiche(), this.logger);
  291.             dataUltimaGenerazioneStatistiche = truncDate(dataUltimaGenerazioneStatistiche, false);
  292.             // Decremento la data di 1 millisecondo in modo da generare poi il SQL nella forma 
  293.             // statistiche per transazioni emessi in data > dataUltimaGenerazioneStatistiche
  294.             dataUltimaGenerazioneStatistiche = this.decrementDate1Millisecond(dataUltimaGenerazioneStatistiche); 

  296.             Date dataAvvioBatch = DateManager.getDate();

  298.             // Now
  299.             // Tale data viene troncata in funzione della statistica che sto eseguendo 
  300.             Date now = new Date();
  301.             now = truncDate(now,false);
  302.             now = this.decrementDate1Millisecond(now);
  303.             Date nowMenoUno = decrementDate(now, false);

  305.             
  306.             // Incremento la data sul database solamente se non sono avvenuti errori durante la generazione, altrimenti dovro' ricalcolarle tutti gli intervalli da quanto e' successo l'errore
  307.             boolean saveDataStatistica = true; 
  308.             
  309.             
  310.             // Genero statistiche per transazioni emessi in data > dataUltimaGenerazioneStatistiche AND data <= now
  311.             while(dataUltimaGenerazioneStatistiche.compareTo(nowMenoUno) <= 0){

  313.                 // genera
  314.                 boolean generazioneCompletataConSuccesso = generaStatistica(dataUltimaGenerazioneStatistiche, 
  315.                         dataAvvioBatch, this.waitMsBeforeNextInterval, 
  316.                         this.waitStatiInConsegna);
  317.                 if(!generazioneCompletataConSuccesso) {
  318.                     saveDataStatistica = false;
  319.                 }
  320.                                                 
  321.                 // increment
  322.                 dataUltimaGenerazioneStatistiche = incrementDate(dataUltimaGenerazioneStatistiche, false);
  323.                 if(this.debug)
  324.                     this.logDebug("-----------------------");

  326.                 // Salvo nuova data di ultima generazione statistiche (entro nel prossimo intervallo)
  327.                 if(saveDataStatistica) {
  328.                     Date next = this.truncDate(this.incrementDate(dataUltimaGenerazioneStatistiche, false),false);
  329.                     if(this.debug)
  330.                         this.logDebug("Save data ultima generazione statistiche: "+next.toString());
  331.                     StatisticsInfoUtils.updateDataUltimaGenerazioneStatistiche(this.statisticaInfoSearchDAO, this.statisticaInfoDAO, 
  332.                             this.getTipoStatistiche(), this.logger, next);
  333.                 }
  334.                 
  335.             }


  338.             // Genero statistiche parziali della data di oggi
  339.             if(this.gestioneUltimoIntervallo){

  341.                 Date dataUltimoIntervallo = dataUltimaGenerazioneStatistiche;

  343.                 // genera
  344.                 generaStatistica(dataUltimoIntervallo, 
  345.                         dataAvvioBatch, -1, 
  346.                         false);
  347.                 
  348.             }

  350.         }catch(Exception e){
  351.             this.logError(e.getMessage(), e);
  352.             throw new StatisticsEngineException(e);
  353.         }
  354.     }

  356.     private boolean generaStatistica(Date dataUltimaGenerazioneStatistiche, 
  357.             Date dataAvvioBatch, long waitMsBeforeNextInterval, 
  358.             boolean waitStatiInConsegna) {
  359.         
  360.         // Algoritmo
  361.         // Per la data in fase di aggiornamento:
  362.         // - 1) si elimina eventuali record rimasti "sporchi" (stato_record <1)
  363.         // - 2) i record esistenti nell'intervallo vengono portati al valore stato_record=2
  364.         // - 3) i nuovi record aggiunti vengono creati con stato_record=0
  365.         // - 4) si fa un unico comando di update nell'intervallo con CASE WHEN stato_record==2 THEN -2 WHEN stato_record==0 THEN 1
  366.         // - 5) si eliminano i record nell'intervallo con stato_record=-2
  367.         
  368.         /**if(dataUltimaGenerazioneStatistiche.compareTo(nowMenoUno) == 0){*/
  369.         // L'IF sopra non lo devo fare, se spengo la macchina, e la riaccendo dopo due ore, l'eliminazione delle statistiche gia' generate riguarda nowMenoDue
  370.         // Se ho la stessa data devo eliminare l'intervallo, posso gia' averlo generato
  371.         // Eliminazione (Fase 1)
  372.         if(this.debug)
  373.             this.logDebug("----------- pulizia Fase1 (DataUguale) ------------");
  374.         boolean esito = this.deleteFisicoStatistiche( TipoPdD.DELEGATA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_VALIDO, false);
  375.         if(!esito) {
  376.             return false;
  377.         }
  378.         if(this.debug)
  379.             this.logDebug("------------ pulizia Fase1 (DataUguale) -----------");
  380.         esito = this.deleteFisicoStatistiche( TipoPdD.APPLICATIVA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_VALIDO, false);
  381.         if(!esito) {
  382.             return false;
  383.         }
  384.         //}

  386.         // Aggiornamento (Fase 2)
  387.         if(this.debug)
  388.             this.logDebug("----------- aggiornamento Fase2 (DataUguale) ------------");
  389.         esito = this.updateStatoRecordStatistiche(TipoPdD.DELEGATA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_ANCORA_VALIDO_IN_FASE_DI_AGGIORNAMENTO);
  390.         if(!esito) {
  391.             return false;
  392.         }
  393.         if(this.debug)
  394.             this.logDebug("------------ aggiornamento Fase2 (DataUguale) -----------");
  395.         esito = this.updateStatoRecordStatistiche( TipoPdD.APPLICATIVA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_ANCORA_VALIDO_IN_FASE_DI_AGGIORNAMENTO);
  396.         if(!esito) {
  397.             return false;
  398.         }
  399.         
  400.         // Generazione (Fase 3)
  401.         BooleanNullable delegataStatiInCorso = BooleanNullable.NULL();
  402.         if(this.debug)
  403.             this.logDebug("----------- generazione Fase3 (DataUguale) ------------");
  404.         if(this.useUnionForLatency) {
  405.             esito = this.generaStatisticheUnion( TipoPdD.DELEGATA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_IN_AGGIORNAMENTO, delegataStatiInCorso );
  406.         }
  407.         else {
  408.             esito = this.generaStatistiche( TipoPdD.DELEGATA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_IN_AGGIORNAMENTO, delegataStatiInCorso );
  409.         }
  410.         if(!esito) {
  411.             return false;
  412.         }
  413.         BooleanNullable applicativaStatiInCorso = BooleanNullable.NULL();       
  414.         if(this.debug)
  415.             this.logDebug("------------ generazione Fase3 (DataUguale) -----------");
  416.         if(this.useUnionForLatency) {
  417.             esito = this.generaStatisticheUnion( TipoPdD.APPLICATIVA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_IN_AGGIORNAMENTO, applicativaStatiInCorso );
  418.         }
  419.         else {
  420.             esito = this.generaStatistiche( TipoPdD.APPLICATIVA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_IN_AGGIORNAMENTO, applicativaStatiInCorso );
  421.         }
  422.         if(!esito) {
  423.             return false;
  424.         }

  426.         // Promozione Record (Fase4)
  427.         boolean unicaPromozione = true; // deve essere un unico comando sql
  428.         if(unicaPromozione) {
  429.             if(this.debug)
  430.                 this.logDebug("----------- promozione Fase4 (DataUguale) ------------");
  431.             esito = this.updateStatoRecordStatistiche( null, dataUltimaGenerazioneStatistiche, 
  432.                     CostantiDB.STATISTICHE_STATO_RECORD_ANCORA_VALIDO_IN_FASE_DI_AGGIORNAMENTO, CostantiDB.STATISTICHE_STATO_RECORD_ELIMINATO,
  433.                     CostantiDB.STATISTICHE_STATO_RECORD_IN_AGGIORNAMENTO, CostantiDB.STATISTICHE_STATO_RECORD_VALIDO);
  434.             if(!esito) {
  435.                 return false;
  436.             }
  437.         }
  438.         else {
  439.             if(this.debug)
  440.                 this.logDebug("----------- promozione Fase4 (DataUguale) ------------");
  441.             esito = this.updateStatoRecordStatistiche( TipoPdD.DELEGATA, dataUltimaGenerazioneStatistiche, 
  442.                     CostantiDB.STATISTICHE_STATO_RECORD_ANCORA_VALIDO_IN_FASE_DI_AGGIORNAMENTO, CostantiDB.STATISTICHE_STATO_RECORD_ELIMINATO,
  443.                     CostantiDB.STATISTICHE_STATO_RECORD_IN_AGGIORNAMENTO, CostantiDB.STATISTICHE_STATO_RECORD_VALIDO);
  444.             if(!esito) {
  445.                 return false;
  446.             }
  447.             if(this.debug)
  448.                 this.logDebug("------------ promozione Fase4 (DataUguale) -----------");
  449.             esito = this.updateStatoRecordStatistiche( TipoPdD.APPLICATIVA, dataUltimaGenerazioneStatistiche, 
  450.                     CostantiDB.STATISTICHE_STATO_RECORD_ANCORA_VALIDO_IN_FASE_DI_AGGIORNAMENTO, CostantiDB.STATISTICHE_STATO_RECORD_ELIMINATO,
  451.                     CostantiDB.STATISTICHE_STATO_RECORD_IN_AGGIORNAMENTO, CostantiDB.STATISTICHE_STATO_RECORD_VALIDO);
  452.             if(!esito) {
  453.                 return false;
  454.             }
  455.         }

  457.         // Eliminazione (Fase 5)
  458.         boolean pulituraOk = true;
  459.         if(this.debug)
  460.             this.logDebug("----------- eliminazione Fase5 (DataUguale) ------------");
  461.         esito = this.deleteFisicoStatistiche( TipoPdD.DELEGATA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_ELIMINATO, true);
  462.         if(!esito) {
  463.             pulituraOk=false;
  464.         }
  465.         if(this.debug)
  466.             this.logDebug("------------ eliminazione Fase5 (DataUguale) -----------");
  467.         esito = this.deleteFisicoStatistiche( TipoPdD.APPLICATIVA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_ELIMINATO, true);
  468.         if(!esito) {
  469.             pulituraOk=false;
  470.         }
  471.         
  472.         // Verifica data attuale e record incontrati
  473.         /**System.out.println("CHECK ms'"+waitMsBeforeNextInterval+"' stati:"+waitStatiInConsegna+"");*/
  474.         if(waitMsBeforeNextInterval>0) {
  475.             Date dateNext = incrementDate(dataUltimaGenerazioneStatistiche, false);
  476.             Date valid = new Date( dataAvvioBatch.getTime() - waitMsBeforeNextInterval );
  477.             boolean block = !dateNext.before(valid);
  478.             /**System.out.println("CHECK STAT NOW["+org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+"] VALID["+
  479.                     org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(valid)+"] < ["+
  480.                     org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(dateNext)+"]: "+block);*/
  481.             if(block) {
  482.                 if(this.debug)
  483.                     this.logDebug("Tradeoff '"+waitMsBeforeNextInterval+"'; next interval update disabled");
  484.                 return false;
  485.             }
  486.         }
  487.         if(waitStatiInConsegna) {
  488.             if(delegataStatiInCorso!=null && delegataStatiInCorso.getValue()!=null && delegataStatiInCorso.getValue().booleanValue()) {
  489.                 if(this.debug)
  490.                     this.logDebug("Trovate transazioni di fruizioni ancora in consegna; next interval update disabled");
  491.                 return false;
  492.             }
  493.             if(applicativaStatiInCorso!=null && applicativaStatiInCorso.getValue()!=null && applicativaStatiInCorso.getValue().booleanValue()) {
  494.                 if(this.debug)
  495.                     this.logDebug("Trovate transazioni di erogazioni ancora in consegna; next interval update disabled");
  496.                 return false;
  497.             }
  498.         }
  499.         
  500.         return pulituraOk;
  501.     }

  503.     
  504.     
  505.     
  506.     // ---- GENERAZIONE STATISTICHE BASE ----
  507.     
  508.     private boolean generaStatisticheUnion(TipoPdD tipoPdD, Date data, int statoRecord, BooleanNullable statiInCorso) {

  510.         boolean generazioneOk = true;
  511.         
  512.         if(this.debug){
  513.             this.logDebug("Generazione statistiche (union) ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") ...");
  514.         }
  515.         try{
  516.             ISQLFieldConverter fieldConverter = ((IDBServiceUtilities<?>)this.transazioneSearchDAO).getFieldConverter(); 
  517.             
  518.             // ** Select field **
  519.             List<FunctionField> selectList = new ArrayList<>();
  520.             StatisticsUtils.addSelectFieldCountTransaction(selectList);
  521.             StatisticsUtils.addSelectFieldSizeTransaction(tipoPdD, selectList);
  522.             
  523.             List<FunctionField> selectListConLatenze = new ArrayList<>();
  524.             selectListConLatenze.addAll(selectList);
  525.             StatisticsUtils.addSelectFunctionFieldLatencyTransaction(tipoPdD, fieldConverter, selectListConLatenze);
  526.             
  527.             List<FunctionField> selectListSenzaLatenze = new ArrayList<>();
  528.             selectListSenzaLatenze.addAll(selectList);
  529.             List<ConstantField> selectListCostantiLatenze = new ArrayList<>();
  530.             StatisticsUtils.addSelectConstantFieldLatencyTransaction(tipoPdD, fieldConverter, selectListCostantiLatenze);

  532.             // ** Where **
  533.             // Creo intervallo
  534.             Date dateNext = incrementDate(data, false);
  535.             
  536.             IExpression exprConLatenze = this.transazioneSearchDAO.newExpression();
  537.             StatisticsUtils.setExpressionNotNullDate(this.transazioneSearchDAO, exprConLatenze, data, dateNext, tipoPdD, null, fieldConverter);
  538.             
  539.             IExpression exprSenzaLatenze = this.transazioneSearchDAO.newExpression();
  540.             StatisticsUtils.setExpressionNullDate(this.transazioneSearchDAO, exprSenzaLatenze, data, dateNext, tipoPdD, null, fieldConverter);

  542.             if(this.debug){
  543.                 this.logDebug("Genero statistiche ["+this.getTipoStatistiche()+"] Intervallo date: ["+data.toString()+" - "+dateNext.toString()+"]");
  544.                 this.logDebug("Valori query (ms) tr.data_ingresso_richiesta>["+data.getTime()+"] AND tr.data_ingresso_richiesta<=["+dateNext.getTime()+"]");
  545.             }

  547.             if(this.forceIndexConfig!=null){
  548.                 if(this.forceIndexConfig.getTransazioniForceIndexGroupByNumeroDimensione()!=null){
  549.                     List<Index> listForceIndexes = this.forceIndexConfig.getTransazioniForceIndexGroupByNumeroDimensione();
  550.                     if(!listForceIndexes.isEmpty()){
  551.                         for (Index index : listForceIndexes) {
  552.                             exprConLatenze.addForceIndex(index);
  553.                             exprSenzaLatenze.addForceIndex(index);
  554.                         }
  555.                     }
  556.                 }
  557.             }
  558.             
  559.             // ** Union **
  560.             
  561.             UnionExpression latenzeUnionExpr = new UnionExpression(exprConLatenze);
  562.             for (FunctionField functionField : selectListConLatenze) {
  563.                 latenzeUnionExpr.addSelectFunctionField(functionField);
  564.             }
  565.             StatisticsUtils.addSelectUnionField(latenzeUnionExpr, fieldConverter);
  566.             
  567.             UnionExpression senzaLatenzeUnionExpr = new UnionExpression(exprSenzaLatenze);
  568.             for (FunctionField functionField : selectListSenzaLatenze) {
  569.                 senzaLatenzeUnionExpr.addSelectFunctionField(functionField);
  570.             }
  571.             for (ConstantField constantField : selectListCostantiLatenze) {
  572.                 senzaLatenzeUnionExpr.addSelectField(constantField, constantField.getAlias());
  573.             }
  574.             StatisticsUtils.addSelectUnionField(senzaLatenzeUnionExpr, fieldConverter);
  575.             
  576.             Union union = new Union();
  577.             union.setUnionAll(true);
  578.             for (String alias : latenzeUnionExpr.getReturnFieldAliases()) {
  579.                 union.addField(alias);
  580.             }
  581.             
  582.             List<Map<String, Object>> list = this.transazioneSearchDAO.union(union, latenzeUnionExpr, senzaLatenzeUnionExpr);
  583.             
  584.             for (Map<String, Object> row : list) {
  585.                 
  586.                 StatisticBean stat = null;
  587.                 try {
  588.                 
  589.                     // Leggo informazioni di base dalla statistica
  590.                     stat = this.readStatisticBean(data, row, fieldConverter, true);
  591.                     
  592.                     // Aggiungo informazioni sul numero di transazioni e size delle transazioni
  593.                     StatisticsUtils.updateStatisticBeanCountTransactionInfo(stat, row);
  594.                     StatisticsUtils.updateStatisticBeanSizeTransactionInfo(stat, row);
  595.                     StatisticsUtils.updateStatisticsBeanLatencyTransactionInfo(stat, row);
  596.             
  597.                     // Check stati in corso
  598.                     if(EsitoUtils.isFaseIntermedia(stat.getEsitoContesto())) {
  599.                         statiInCorso.setValue(true);
  600.                     }
  601.                     
  602.                     // Inserisco statistica
  603.                     insertStatistica(stat, statoRecord);
  604.     
  605.                     if(this.generazioneStatisticheCustom){
  606.                         createCustomStatistic(stat);
  607.                     }
  608.                     
  609.                 }catch(Throwable eSingoloRecord) {
  610.                     String r = "";
  611.                     if(stat!=null) {
  612.                         try {
  613.                             r ="\nRecord: "+stat.toString();
  614.                         }catch(Throwable tPrint) {}
  615.                     }
  616.                     this.logError("Rilevato errore durante la registrazione del singolo record di informazione statistica: "+eSingoloRecord.getMessage()+r,eSingoloRecord);
  617.                     generazioneOk = false;
  618.                 }
  619.             }


  622.         } catch (ServiceException e){
  623.             this.logError(e.getMessage(),e);
  624.             generazioneOk = false;
  625.         } catch (NotImplementedException e) {
  626.             this.logError(e.getMessage(),e);
  627.             generazioneOk = false;
  628.         } catch (ExpressionNotImplementedException e) {
  629.             this.logError(e.getMessage(),e);
  630.             generazioneOk = false;
  631.         } catch (ExpressionException e) {
  632.             this.logError(e.getMessage(),e);
  633.             generazioneOk = false;
  634.         } catch (NotFoundException e) {
  635.             if(this.debug){
  636.                 this.logDebug(e.getMessage(),e);
  637.             }
  638.         }catch (Throwable e) {
  639.             this.logError(e.getMessage(),e);
  640.             generazioneOk = false;
  641.         }  

  643.         if(this.debug){
  644.             this.logDebug("Generazione statistiche ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") terminata");
  645.         }
  646.                 
  647.         return generazioneOk;
  648.     }
  649.     
  650.     private boolean generaStatistiche(  TipoPdD tipoPdD, Date data, int statoRecord, BooleanNullable statiInCorso) {

  652.         boolean generazioneOk = true;
  653.         
  654.         if(this.debug){
  655.             this.logDebug("Generazione statistiche ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") ...");
  656.         }
  657.         try{
  658.             IExpression expr = this.transazioneSearchDAO.newExpression();

  660.             ISQLFieldConverter fieldConverter = ((IDBServiceUtilities<?>)this.transazioneSearchDAO).getFieldConverter(); 
  661.             
  662.             // ** Select field **
  663.             List<FunctionField> selectList = new ArrayList<>();
  664.             StatisticsUtils.addSelectFieldCountTransaction(selectList);
  665.             StatisticsUtils.addSelectFieldSizeTransaction(tipoPdD, selectList);
  666.             
  667.             // ** Where **
  668.             // Creo intervallo
  669.             Date dateNext = incrementDate(data, false);
  670.             StatisticsUtils.setExpression(this.transazioneSearchDAO, expr, data, dateNext, tipoPdD, false, null, fieldConverter);

  672.             if(this.debug){
  673.                 this.logDebug("Genero statistiche ["+this.getTipoStatistiche()+"] Intervallo date: ["+data.toString()+" - "+dateNext.toString()+"]");
  674.                 this.logDebug("Valori query (ms) tr.data_ingresso_richiesta>["+data.getTime()+"] AND tr.data_ingresso_richiesta<=["+dateNext.getTime()+"]");
  675.             }

  677.             if(this.forceIndexConfig!=null){
  678.                 if(this.forceIndexConfig.getTransazioniForceIndexGroupByNumeroDimensione()!=null){
  679.                     List<Index> listForceIndexes = this.forceIndexConfig.getTransazioniForceIndexGroupByNumeroDimensione();
  680.                     if(!listForceIndexes.isEmpty()){
  681.                         for (Index index : listForceIndexes) {
  682.                             expr.addForceIndex(index);
  683.                         }
  684.                     }
  685.                 }
  686.             }
  687.             
  688.             List<Map<String, Object>> list = this.transazioneSearchDAO.groupBy(expr, selectList.toArray(new FunctionField[1]));

  690.             for (Map<String, Object> row : list) {
  691.                 
  692.                 StatisticBean stat = null;
  693.                 try {
  694.                 
  695.                     // Leggo informazioni di base dalla statistica
  696.                     stat = this.readStatisticBean(data, row, null, false);
  697.                     
  698.                     // Aggiungo informazioni sul numero di transazioni e size delle transazioni
  699.                     StatisticsUtils.updateStatisticBeanCountTransactionInfo(stat, row);
  700.                     StatisticsUtils.updateStatisticBeanSizeTransactionInfo(stat, row);
  701.     
  702.                     // Aggiungo informazioni che richiedono ulteriori condizioni di where (es. date not null) 
  703.                     try {
  704.                         this.addLatenze(data, dateNext, tipoPdD, stat, fieldConverter);
  705.                     }catch(Throwable eSingoloRecordAddLatenze) {
  706.                         this.logError("Rilevato errore durante la lettura delle latenze di un singolo record di informazione statistica: "+eSingoloRecordAddLatenze.getMessage()+
  707.                                 "\nRecord: "+stat.toString(),eSingoloRecordAddLatenze);
  708.                         generazioneOk = false;
  709.                     }
  710.                                     
  711.                     // Check stati in corso
  712.                     if(EsitoUtils.isFaseIntermedia(stat.getEsitoContesto())) {
  713.                         statiInCorso.setValue(true);
  714.                     }
  715.                     
  716.                     // Inserisco statistica
  717.                     insertStatistica(stat, statoRecord);
  718.     
  719.                     if(this.generazioneStatisticheCustom){
  720.                         createCustomStatistic(stat);
  721.                     }
  722.                     
  723.                 }catch(Throwable eSingoloRecord) {
  724.                     String r = "";
  725.                     if(stat!=null) {
  726.                         try {
  727.                             r ="\nRecord: "+stat.toString();
  728.                         }catch(Throwable tPrint) {}
  729.                     }
  730.                     this.logError("Rilevato errore durante la registrazione del singolo record di informazione statistica: "+eSingoloRecord.getMessage()+r,eSingoloRecord);
  731.                     generazioneOk = false;
  732.                 }
  733.             }


  736.         } catch (ServiceException e){
  737.             this.logError(e.getMessage(),e);
  738.             generazioneOk = false;
  739.         } catch (NotImplementedException e) {
  740.             this.logError(e.getMessage(),e);
  741.             generazioneOk = false;
  742.         } catch (ExpressionNotImplementedException e) {
  743.             this.logError(e.getMessage(),e);
  744.             generazioneOk = false;
  745.         } catch (ExpressionException e) {
  746.             this.logError(e.getMessage(),e);
  747.             generazioneOk = false;
  748.         } catch (NotFoundException e) {
  749.             if(this.debug){
  750.                 this.logDebug(e.getMessage(),e);
  751.             }
  752.         }catch (Throwable e) {
  753.             this.logError(e.getMessage(),e);
  754.             generazioneOk = false;
  755.         }  

  757.         if(this.debug){
  758.             this.logDebug("Generazione statistiche ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") terminata");
  759.         }
  760.                 
  761.         return generazioneOk;
  762.     }
  763.     
  764.     private StatisticBean readStatisticBean(Date data,Map<String, Object> row, ISQLFieldConverter fieldConverter, boolean useFieldConverter) throws ExpressionException{
  765.         StatisticBean stat = new StatisticBean();

  767.         stat.setDateIntervalLeft(data);
  768.         stat.setDateIntervalRight(this.incrementDate(data, false));
  769.         Date next = this.truncDate(this.incrementDate(data, false),false);
  770.         stat.setData(next);
  771.         if(this.debug)
  772.             this.logDebug("Salvo statistica con data ["+next+"]");
  773.     
  774.         return StatisticsUtils.readStatisticBean(stat, row, fieldConverter, useFieldConverter);
  775.     }
  776.     
  777.     private void addLatenze(Date data, Date dateNext, TipoPdD tipoPdD, StatisticBean stat, ISQLFieldConverter fieldConverter) throws Exception{
  778.         
  779.         IExpression exprDateNotNull = this.transazioneSearchDAO.newExpression();
  780.         StatisticsUtils.setExpression(this.transazioneSearchDAO, exprDateNotNull, data, dateNext, tipoPdD, true, stat, fieldConverter);
  781.         
  782.         List<FunctionField> selectListDateNotNull = new ArrayList<>();
  783.         
  784.         StatisticsUtils.addSelectFunctionFieldLatencyTransaction(tipoPdD, fieldConverter, selectListDateNotNull);
  785.         
  786.         if(this.debug){
  787.             this.logDebug("Leggo ulteriormente statistiche con campi data not null ["+this.getTipoStatistiche()+"] Intervallo date: ["+data.toString()+" - "+dateNext.toString()+"]");
  788.             this.logDebug("Valori query (ms) tr.data_ingresso_richiesta>["+data.getTime()+"] AND tr.data_ingresso_richiesta<=["+dateNext.getTime()+"]");
  789.         }

  791.         try{
  792.             if(this.forceIndexConfig!=null){
  793.                 if(this.forceIndexConfig.getTransazioniForceIndexGroupByLatenze()!=null){
  794.                     List<Index> listForceIndexes = this.forceIndexConfig.getTransazioniForceIndexGroupByLatenze();
  795.                     if(!listForceIndexes.isEmpty()){
  796.                         for (Index index : listForceIndexes) {
  797.                             exprDateNotNull.addForceIndex(index);
  798.                         }
  799.                     }
  800.                 }
  801.             }
  802.             
  803.             List<Map<String, Object>> listDateNotNull = this.transazioneSearchDAO.groupBy(exprDateNotNull, selectListDateNotNull.toArray(new FunctionField[1]));
  804.             
  805.             if(listDateNotNull.size()>1){
  806.                 throw new MultipleResultException("Attesa un solo gruppo, ritornati "+listDateNotNull.size()+" gruppi");
  807.             }
  808.             Map<String, Object> row = listDateNotNull.get(0);
  809.             
  810.             StatisticsUtils.updateStatisticsBeanLatencyTransactionInfo(stat, row);
  811.             
  812.         }catch(NotFoundException notFound){
  813.             // possono non esistere
  814.             if(this.debug){
  815.                 this.logDebug(notFound.getMessage(),notFound);
  816.             }
  817.             stat.setLatenzaPorta(Costanti.INFORMAZIONE_LATENZA_NON_DISPONIBILE);
  818.             stat.setLatenzaServizio(Costanti.INFORMAZIONE_LATENZA_NON_DISPONIBILE);
  819.             stat.setLatenzaTotale(Costanti.INFORMAZIONE_LATENZA_NON_DISPONIBILE);
  820.         }
  821.     }
  822.     
  823.     
  824.     
  825.     
  826.     
  827.     
  828.     // ---- RICERCA STATISTICHE PERSONALIZZATE ----
  829.     
  830.     private void createCustomStatistic(StatisticBean stat)   {

  832.         /**IExpression expr;*/
  833.         try {
  834. /**         expr = this.confStatisticaDAO.newExpression();
  835. //          expr.and();
  836. //
  837. //          expr.equals(ConfigurazioneStatistica.model().ID_CONFIGURAZIONE_SERVIZIO_AZIONE.ID_CONFIGURAZIONE_SERVIZIO.SERVIZIO, stat.getServizio());
  838. //
  839. //          if ("*".equals(stat.getAzione())) {
  840. //              expr.and().equals(ConfigurazioneStatistica.model().ID_CONFIGURAZIONE_SERVIZIO_AZIONE.AZIONE, "*");
  841. //          } else {
  842. //              IExpression orExpr = this.confStatisticaDAO.newExpression();
  843. //              orExpr.or();
  844. //              orExpr.equals(ConfigurazioneStatistica.model().ID_CONFIGURAZIONE_SERVIZIO_AZIONE.AZIONE, "*");
  845. //              orExpr.equals(ConfigurazioneStatistica.model().ID_CONFIGURAZIONE_SERVIZIO_AZIONE.AZIONE, stat.getAzione());
  846. //
  847. //              expr.and(orExpr);
  848. //          }
  849. //          
  850. //          expr.equals(ConfigurazioneStatistica.model().ENABLED, true);
  851. //
  852. //          IPaginatedExpression pagExpr = this.confStatisticaDAO.toPaginatedExpression(expr);
  853. //          List<ConfigurazioneStatistica> list = this.confStatisticaDAO.findAll(pagExpr);*/

  855.             if(stat.getDestinatario()==null || stat.getDestinatario().getTipo()==null || stat.getDestinatario().getNome()==null){
  856.                 if(this.debug){
  857.                     this.logDebug("Statistiche personalizzate non ricercate: destinatario non presente");
  858.                 }
  859.                 return;
  860.             }
  861.             if(stat.getTipoServizio()==null || stat.getServizio()==null){
  862.                 if(this.debug){
  863.                     this.logDebug("Statistiche personalizzate non ricercate: servizio non presente");
  864.                 }
  865.                 return;
  866.             }
  867.             
  868.             IDServizio idServizio = IDServizioFactory.getInstance().
  869.                     getIDServizioFromValues(stat.getTipoServizio(), stat.getServizio(), 
  870.                             stat.getDestinatario(), 
  871.                             stat.getVersioneServizio());
  872.             if (!("*".equals(stat.getAzione()))) {
  873.                 idServizio.setAzione(stat.getAzione());
  874.             }
  875.             
  876.             BasicServiceLibraryReader reader = new BasicServiceLibraryReader(this.pluginsBaseSM, this.utilsSM, this.debug);
  877.             BasicServiceLibrary basicLibrary = null;
  878.             try{
  879.                 basicLibrary = reader.read(idServizio, this.logger);
  880.                 if(basicLibrary==null){
  881.                     throw new NotFoundException("Null instance return");
  882.                 }
  883.             }catch(NotFoundException notFound){
  884.                 if(this.debug){
  885.                     this.logDebug("Statistiche personalizzate non ricercate: nessuna configurazione base presente per l'IDServizio: "+idServizio,notFound);
  886.                 }
  887.                 return;
  888.             }

  890.             TransactionServiceLibrary transactionLibrary = null;
  891.             if(this.analisiTransazioniCustom){
  892.                 TransactionServiceLibraryReader transactionReader = new TransactionServiceLibraryReader(this.pluginsTransazioniSM, this.debug);
  893.                 transactionLibrary = transactionReader.readConfigurazioneTransazione(basicLibrary, this.logger);
  894.             }
  895.             
  896.             StatisticsServiceLibraryReader statReader = new StatisticsServiceLibraryReader(this.pluginsStatisticheSM, this.debug);
  897.             StatisticsServiceLibrary statLibrary = null;
  898.             try{
  899.                 statLibrary = statReader.readConfigurazioneStatistiche(basicLibrary, transactionLibrary, this.logger);
  900.                 if(statLibrary==null){
  901.                     throw new NotFoundException("Null instance return");
  902.                 }
  903.             }catch(NotFoundException notFound){
  904.                 if(this.debug){
  905.                     this.logDebug("Statistiche personalizzate non ricercate: nessuna configurazione specifica per le statistiche presente per l'IDServizio: "+idServizio,notFound);
  906.                 }
  907.                 return;
  908.             }
  909.                         
  910.             List<ConfigurazioneStatistica> list = statLibrary.mergeServiceActionSearchLibrary(false,true); // si vuole registrare nei log che un plugin è disabilitato
  911.             
  912.             for (ConfigurazioneStatistica confStat : list) {

  914.                 String classNameStatisticaPersonalizzata = confStat.getPlugin().getClassName();
  915.                 String labelStatisticaPersonalizzata = confStat.getLabel();
  916.                 if(this.debug){
  917.                     this.logDebug("*** Inizio Gestione Statistica personalizzata ("+classNameStatisticaPersonalizzata+" ["+labelStatisticaPersonalizzata+"]) ****");
  918.                 }
  919.                 stat.setIdStatistica(confStat.getIdConfigurazioneStatistica());
  920.                 stat.setPluginClassname(classNameStatisticaPersonalizzata);
  921.                 IDynamicLoader cStatPersonalizzata = DynamicFactory.getInstance().newDynamicLoader(confStat.getPlugin().getTipoPlugin(), confStat.getPlugin().getTipo(),
  922.                         classNameStatisticaPersonalizzata, this.logger);
  923.                 IStatisticProcessing statProcessing = (IStatisticProcessing) cStatPersonalizzata.newInstance();
  924.                 if(this.isEnabledStatisticTypeCustom(statProcessing)){
  925.                     if(this.debug){
  926.                         this.logDebug("---- Invocazione ["+cStatPersonalizzata.getClassName()+"."+this.getStatisticPluginMethodName()+"()] ...");
  927.                     }
  928.                     try {
  929.                         this.callStatisticPluginMethod(statProcessing, stat);
  930.                         if(this.debug){
  931.                             this.logDebug("---- Invocazione ["+cStatPersonalizzata.getClassName()+"."+this.getStatisticPluginMethodName()+"()] terminata");
  932.                         }
  933.                     } catch (Exception e) {
  934.                         this.logError("---- Invocazione ["+cStatPersonalizzata.getClassName()+"."+this.getStatisticPluginMethodName()+"()] terminata con errori: "+e.getMessage(), e);
  935.                     } 
  936.                 }
  937.                 else{
  938.                     if(this.debug){
  939.                         this.logDebug("Tipo di statistica ["+this.getTipoStatistiche()+"] non abilitata nel plugin");
  940.                     }
  941.                 }
  942.                 if(this.debug){
  943.                     this.logDebug("*** Fine Gestione Statistica personalizzata ("+classNameStatisticaPersonalizzata+" ["+labelStatisticaPersonalizzata+"]) ****");
  944.                 }
  945.                 
  946.             }

  948.         } catch (Exception e) {
  949.             this.logError(e.getMessage(), e);
  950.         } 

  952.     }
  953.     
  954.     private boolean isEnabledStatisticTypeCustom(IStatisticProcessing statProcessing){
  955.         List<StatisticType> listEnabled = statProcessing.getEnabledStatisticType();
  956.         switch (this.getTipoStatistiche()) {
  957.             case STATISTICHE_ORARIE:
  958.                 for (StatisticType statisticType : listEnabled) {
  959.                     if(StatisticType.ORARIA.equals(statisticType)){
  960.                         return true;
  961.                     }
  962.                 }
  963.                 break;
  964.             case STATISTICHE_GIORNALIERE:
  965.                 for (StatisticType statisticType : listEnabled) {
  966.                     if(StatisticType.GIORNALIERA.equals(statisticType)){
  967.                         return true;
  968.                     }
  969.                 }
  970.                 break;
  971.             case STATISTICHE_SETTIMANALI:
  972.                 for (StatisticType statisticType : listEnabled) {
  973.                     if(StatisticType.SETTIMANALE.equals(statisticType)){
  974.                         return true;
  975.                     }
  976.                 }
  977.                 break;
  978.             case STATISTICHE_MENSILI:
  979.                 for (StatisticType statisticType : listEnabled) {
  980.                     if(StatisticType.MENSILE.equals(statisticType)){
  981.                         return true;
  982.                     }
  983.                 }
  984.                 break;
  985.             case PDND_GENERAZIONE_TRACCIAMENTO:
  986.             case PDND_PUBBLICAZIONE_TRACCIAMENTO:
  987.                 return false;
  988.         }
  989.         return false;
  990.     }
  991.     
  992.     
  993.     
  994.     
  995.     // ---- GENERAZIONE STATISTICHE PERSONALIZZATE ----
  996.     protected void generaStatisticaPersonalizzataByStato(StatisticBean stat) {
  997.         this.generaStatisticaPersonalizzata(stat, true, null, null);
  998.     }
  999.     protected void generaStatisticaPersonalizzata(StatisticBean stat,
  1000.             RisorsaSemplice risorsaSemplice) {
  1001.         this.generaStatisticaPersonalizzata(stat, false, risorsaSemplice, null);
  1002.     }
  1003.     protected void generaStatisticaPersonalizzata(StatisticBean stat,
  1004.             RisorsaAggregata risorsaAggregata) {
  1005.         this.generaStatisticaPersonalizzata(stat, false, null, risorsaAggregata);
  1006.     }
  1007.     private void generaStatisticaPersonalizzata(StatisticBean stat,
  1008.             boolean gropuByStato,
  1009.             RisorsaSemplice risorsaSemplice, RisorsaAggregata risorsaAggregata) {

  1011.         TipoPdD tipoPdD = null;
  1012.         String idStatisticaPersonalizzata = null;
  1013.         Date dateStatistics = null;
  1014.         try{
  1015.             tipoPdD = stat.getTipoPorta();
  1016.             Date dateLeft = stat.getDateIntervalLeft();
  1017.             Date dateRight = stat.getDateIntervalRight();
  1018.             dateStatistics = stat.getData();
  1019.             idStatisticaPersonalizzata = stat.getIdStatistica();
  1020.             
  1021.             if(this.debug){
  1022.                 this.logDebug("Generazione statistica personalizzata ["+idStatisticaPersonalizzata+"] ["+this.getTipoStatistiche()+"] ["+tipoPdD+
  1023.                         "]("+this.getIntervalloStatistica(dateStatistics,false)+") ...");
  1024.             }
  1025.             
  1026.             ISQLFieldConverter fieldConverter = ((IDBServiceUtilities<?>)this.transazioneSearchDAO).getFieldConverter(); 
  1027.             
  1028.             Map<String, StatisticaContenuti> statisticheContenuti = new HashMap<String, StatisticaContenuti>();
  1029.             
  1030.             
  1031.             String idRisorsa = null;
  1032.             StatisticResourceFilter [] risorseFiltri = null;
  1033.             if(risorsaSemplice!=null){
  1034.                 idRisorsa = risorsaSemplice.getIdRisorsa();
  1035.                 if(risorsaSemplice.getFiltri()!=null && !risorsaSemplice.getFiltri().isEmpty()){
  1036.                     risorseFiltri = risorsaSemplice.getFiltri().toArray(new StatisticResourceFilter[1]);
  1037.                 }
  1038.             }
  1039.             
  1040.             
  1041.             
  1042.             
  1043.             
  1044.             // ** Informazioni di Base (numero transazioni e dimensione) **

  1046.             IExpression expr = this.transazioneSearchDAO.newExpression();
  1047.             
  1048.             List<FunctionField> selectList = new ArrayList<>();
  1049.             StatisticsUtils.addSelectFieldCountTransaction(selectList);
  1050.             StatisticsUtils.addSelectFieldSizeTransaction(tipoPdD, selectList);
  1051.             
  1052.             // Creo espressione
  1053.             List<AliasFilter> aliases = new ArrayList<>();
  1054.             if(gropuByStato){
  1055.                 StatisticsUtils.setExpressionByStato(this.transazioneSearchDAO, expr, dateLeft, dateRight, tipoPdD, false, stat, fieldConverter);
  1056.             }else{
  1057.                 StatisticsUtils.setExpressionStatsPersonalizzate(this.transazioneSearchDAO, expr, dateLeft, dateRight, tipoPdD, false, stat, fieldConverter, 
  1058.                         aliases, idRisorsa, risorseFiltri);
  1059.             }

  1061.             // aggiungo eventuale filtro personalizzato
  1062.             if(risorsaAggregata!=null && (risorsaAggregata.getFiltro() instanceof FilterImpl)){
  1063.                 FilterImpl f = (FilterImpl) risorsaAggregata.getFiltro();
  1064.                 expr.and(f.getExpression());
  1065.             }
  1066.             
  1067.             if(this.debug){
  1068.                 this.logDebug("Analizzo dati di base statistica personalizzata ["+idStatisticaPersonalizzata+"]  ["+this.getTipoStatistiche()+
  1069.                         "] Intervallo date: ["+dateLeft.toString()+" - "+dateRight.toString()+"]");
  1070.                 this.logDebug("Valori query (ms) tr.data_ingresso_richiesta>["+dateLeft.getTime()+"] AND tr.data_ingresso_richiesta<=["+dateRight.getTime()+"]");
  1071.                 this.logDebug("Expr: "+expr.toString());
  1072.             }

  1074.             if(this.forceIndexConfig!=null){
  1075.                 if(this.forceIndexConfig.getTransazioniForceIndexGroupByCustomNumeroDimensione()!=null){
  1076.                     List<Index> listForceIndexes = this.forceIndexConfig.getTransazioniForceIndexGroupByCustomNumeroDimensione();
  1077.                     if(!listForceIndexes.isEmpty()){
  1078.                         for (Index index : listForceIndexes) {
  1079.                             expr.addForceIndex(index);
  1080.                         }
  1081.                     }
  1082.                 }
  1083.             }
  1084.             
  1085.             List<Map<String, Object>> list = this.transazioneSearchDAO.groupBy(expr, selectList.toArray(new FunctionField[1]));

  1087.             for (Map<String, Object> row : list) {
  1088.                 
  1089.                 if(list.size()>1 &&
  1090.                     risorsaAggregata!=null){
  1091.                     throw new ServiceException("Localizzata più di una entry?? Comportamento non atteso per una risorsa aggregata");
  1092.                 }
  1093.                 
  1094.                 // Update della statistica per quanto concerne i valori
  1095.                 StatisticaContenuti statisticaContenuti = new  StatisticaContenuti();
  1096.                 if(gropuByStato){
  1097.                     StatisticsUtils.fillStatisticsContenutiByStato(idStatisticaPersonalizzata, statisticaContenuti, row);
  1098.                 }
  1099.                 else if(risorsaSemplice!=null){
  1100.                     StatisticsUtils.fillStatisticsContenuti(idStatisticaPersonalizzata, statisticaContenuti, row, aliases, risorsaSemplice);
  1101.                 }
  1102.                 else{
  1103.                     StatisticsUtils.fillStatisticsContenuti(idStatisticaPersonalizzata, statisticaContenuti, risorsaAggregata);
  1104.                 }
  1105.                 
  1106.                 // Aggiungo informazioni sul numero di transazioni e size delle transazioni
  1107.                 StatisticBean tmp = new StatisticBean();
  1108.                 tmp.setTipoPorta(stat.getTipoPorta());
  1109.                 StatisticsUtils.updateStatisticBeanCountTransactionInfo(tmp, row);
  1110.                 StatisticsUtils.updateStatisticBeanSizeTransactionInfo(tmp, row);
  1111.                 statisticaContenuti.setNumeroTransazioni((int)tmp.getRichieste());
  1112.                 statisticaContenuti.setDimensioniBytesBandaComplessiva(tmp.getBytesBandaTotale());
  1113.                 statisticaContenuti.setDimensioniBytesBandaInterna(tmp.getBytesBandaInterna());
  1114.                 statisticaContenuti.setDimensioniBytesBandaEsterna(tmp.getBytesBandaEsterna());
  1115.                 
  1116.                 // Aggiungo in cache
  1117.                 String key = StatisticsUtils.buildKey(statisticaContenuti);
  1118.                 statisticheContenuti.put(key, statisticaContenuti);
  1119.                 
  1120.             }
  1121.             
  1122.             
  1123.             
  1124.             
  1125.             // ** Latenze **
  1126.             try{
  1127.                 expr = this.transazioneSearchDAO.newExpression();
  1128.                 
  1129.                 selectList = new ArrayList<>();
  1130.                 StatisticsUtils.addSelectFunctionFieldLatencyTransaction(tipoPdD, fieldConverter, selectList);
  1131.                 
  1132.                 // Creo espressione
  1133.                 aliases = new ArrayList<>();
  1134.                 if(gropuByStato){
  1135.                     StatisticsUtils.setExpressionByStato(this.transazioneSearchDAO, expr, dateLeft, dateRight, tipoPdD, false, stat, fieldConverter);
  1136.                 }else{
  1137.                     StatisticsUtils.setExpressionStatsPersonalizzate(this.transazioneSearchDAO, expr, dateLeft, dateRight, tipoPdD, true, stat, fieldConverter, 
  1138.                             aliases, idRisorsa, risorseFiltri);
  1139.                 }

  1141.                 // aggiungo eventuale filtro personalizzato
  1142.                 if(risorsaAggregata!=null && (risorsaAggregata.getFiltro() instanceof FilterImpl)){
  1143.                     FilterImpl f = (FilterImpl) risorsaAggregata.getFiltro();
  1144.                     expr.and(f.getExpression());
  1145.                 }
  1146.     
  1147.                 if(this.debug){
  1148.                     this.logDebug("Analizzo dati sulla latenza per la statistica personalizzata ["+idStatisticaPersonalizzata+"]  ["+
  1149.                             this.getTipoStatistiche()+"] Intervallo date: ["+dateLeft.toString()+" - "+dateRight.toString()+"]");
  1150.                     this.logDebug("Valori query (ms) tr.data_ingresso_richiesta>["+dateLeft.getTime()+"] AND tr.data_ingresso_richiesta<=["+dateRight.getTime()+"]");
  1151.                 }
  1152.     
  1153.                 if(this.forceIndexConfig!=null
  1154.                     && this.forceIndexConfig.getTransazioniForceIndexGroupByCustomLatenze()!=null){
  1155.                     List<Index> listForceIndexes = this.forceIndexConfig.getTransazioniForceIndexGroupByCustomLatenze();
  1156.                     if(!listForceIndexes.isEmpty()){
  1157.                         for (Index index : listForceIndexes) {
  1158.                             expr.addForceIndex(index);
  1159.                         }
  1160.                     }
  1161.                 }
  1162.                 
  1163.                 list = this.transazioneSearchDAO.groupBy(expr, selectList.toArray(new FunctionField[1]));
  1164.     
  1165.                 for (Map<String, Object> row : list) {
  1166.                     
  1167.                     if(list.size()>1){
  1168.                         if(risorsaAggregata!=null){
  1169.                             throw new Exception("Localizzata più di una entry?? Comportamento non atteso per una risorsa aggregata");
  1170.                         }
  1171.                     }
  1172.                     
  1173.                     // Update della statistica per quanto concerne i valori
  1174.                     StatisticaContenuti statisticaContenuti = new  StatisticaContenuti();
  1175.                     if(gropuByStato){
  1176.                         StatisticsUtils.fillStatisticsContenutiByStato(idStatisticaPersonalizzata, statisticaContenuti, row);
  1177.                     }
  1178.                     else if(risorsaSemplice!=null){
  1179.                         StatisticsUtils.fillStatisticsContenuti(idStatisticaPersonalizzata, statisticaContenuti, row, aliases, risorsaSemplice);
  1180.                     }
  1181.                     else{
  1182.                         StatisticsUtils.fillStatisticsContenuti(idStatisticaPersonalizzata, statisticaContenuti, risorsaAggregata);
  1183.                     }
  1184.                     
  1185.                     // Prelevo dalla cache (Deve esistere per forza)
  1186.                     String key = StatisticsUtils.buildKey(statisticaContenuti);
  1187.                     statisticaContenuti = statisticheContenuti.get(key);
  1188.                     if(statisticaContenuti==null){
  1189.                         throw new ServiceException("Statistica ["+key+"] non presente in cache??");
  1190.                     }
  1191.                     
  1192.                     // Aggiorno informazioni sulla latenza
  1193.                     StatisticBean tmp = new StatisticBean();
  1194.                     StatisticsUtils.updateStatisticsBeanLatencyTransactionInfo(tmp, row);
  1195.                     statisticaContenuti.setLatenzaPorta(tmp.getLatenzaPorta());
  1196.                     statisticaContenuti.setLatenzaServizio(tmp.getLatenzaServizio());
  1197.                     statisticaContenuti.setLatenzaTotale(tmp.getLatenzaTotale());
  1198.                     
  1199.                 }
  1200.             } catch (NotFoundException e) {
  1201.                 if(this.debug){
  1202.                     this.logDebug(e.getMessage(),e);
  1203.                 }
  1204.             }
  1205.             
  1206.             
  1207.             
  1208.             
  1209.             // ** Aggiorno statistiche **
  1210.             if(this.debug){
  1211.                 this.logDebug("Aggiorno ["+statisticheContenuti.size()+"] risultati statistiche personalizzate");
  1212.             }
  1213.             if(statisticheContenuti.size()>0){
  1214.                 this.updateStatistica(stat.getId(), statisticheContenuti.values().toArray(new StatisticaContenuti[1]));
  1215.             }


  1218.         } catch (ServiceException e){
  1219.             this.logError(e.getMessage(),e);
  1220.         } catch (NotImplementedException e) {
  1221.             this.logError(e.getMessage(),e);
  1222.         } catch (ExpressionNotImplementedException e) {
  1223.             this.logError(e.getMessage(),e);
  1224.         } catch (ExpressionException e) {
  1225.             this.logError(e.getMessage(),e);
  1226.         } catch (NotFoundException e) {
  1227.             if(this.debug){
  1228.                 this.logDebug(e.getMessage(),e);
  1229.             }
  1230.         }catch (Exception e) {
  1231.             this.logError(e.getMessage(),e);
  1232.         }  

  1234.         if(this.debug){
  1235.             this.logDebug("Generazione statistica personalizzata ["+idStatisticaPersonalizzata+"] ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+
  1236.                     this.getIntervalloStatistica(dateStatistics,false)+") terminata");
  1237.         }
  1238.     }


  1241.     
  1242.     
  1243.     
  1244.     
  1245.     
  1246.     
  1247.     // ---- CRUD ----


  1250.     private boolean updateStatoRecordStatistiche( TipoPdD tipoPdD, Date data, int stato) {

  1252.         if(this.debug){
  1253.             this.logDebug("Update record statistiche allo stato '"+stato+"' ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") ...");
  1254.         }

  1256.         try{

  1258.             ISQLFieldConverter fieldConverter = ((IDBServiceUtilities<?>)this.statisticaServiceDAO).getFieldConverter();
  1259.             TipiDatabase tipoDB = fieldConverter.getDatabaseType();
  1260.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1261.             sqlQueryObject.addUpdateTable(fieldConverter.toTable(this.model));
  1262.             sqlQueryObject.addUpdateField(fieldConverter.toColumn(this.model.STATO_RECORD, false), "?");
  1263.             sqlQueryObject.addWhereCondition(fieldConverter.toColumn(this.model.DATA, false)+"=?");
  1264.             sqlQueryObject.addWhereCondition(fieldConverter.toColumn(this.model.TIPO_PORTA, false)+"=?");
  1265.             sqlQueryObject.setANDLogicOperator(true);
  1266.             
  1267.             Date next = this.truncDate(this.incrementDate(data, false),false);
  1268.             if(this.debug){
  1269.                 this.logDebug("Aggiorno statistiche ["+this.getTipoStatistiche()+"]");
  1270.                 this.logDebug("Valori update stato record = ("+stato+") tr.data_ingresso_richiesta=["+next.getTime()+"]");
  1271.             }
  1272.             int righeModificate = this.statisticaServiceDAO.nativeUpdate(sqlQueryObject.createSQLUpdate(), 
  1273.                     stato,
  1274.                     next, 
  1275.                     TipoPdD.DELEGATA.equals(tipoPdD)? PddRuolo.DELEGATA.getValue() : PddRuolo.APPLICATIVA.getValue());
  1276.             
  1277.             if(this.debug){
  1278.                 this.logDebug("Modificate ["+righeModificate+"] entry");
  1279.             }

  1281.             return true;

  1283.         }catch(Throwable e){
  1284.             this.logError(e.getMessage(), e);
  1285.             
  1286.             return false;
  1287.         }
  1288.         finally {
  1289.             if(this.debug){
  1290.                 this.logDebug("Update record statistiche allo stato '"+stato+"' ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") terminata");
  1291.             }
  1292.         }

  1294.     }
  1295.     
  1296.     private boolean updateStatoRecordStatistiche( TipoPdD tipoPdD, Date data, 
  1297.             int case1WhenStato, int case1ThenStato,
  1298.             int case2WhenStato, int case2ThenStato) {

  1300.         if(this.debug){
  1301.             this.logDebug("Update record statistiche negli stati con CASE ("+case1WhenStato+"->"+case1ThenStato+") e ("+case2WhenStato+"->"+case2ThenStato+")  ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") ...");
  1302.         }

  1304.         try{
  1305.             ISQLFieldConverter fieldConverter = ((IDBServiceUtilities<?>)this.statisticaServiceDAO).getFieldConverter();
  1306.             TipiDatabase tipoDB = fieldConverter.getDatabaseType();
  1307.             String nomeColonna = fieldConverter.toColumn(this.model.STATO_RECORD, false);
  1308.             
  1309.             Case caseSql = new Case(CastColumnType.INT);
  1310.             caseSql.addCase(nomeColonna+"=?", "?");
  1311.             caseSql.addCase(nomeColonna+"=?", "?");
  1312.             
  1313.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1314.             sqlQueryObject.addUpdateTable(fieldConverter.toTable(this.model));
  1315.             sqlQueryObject.addUpdateField(nomeColonna, caseSql);
  1316.             sqlQueryObject.addWhereCondition(fieldConverter.toColumn(this.model.DATA, false)+"=?");
  1317.             if(tipoPdD!=null) {
  1318.                 sqlQueryObject.addWhereCondition(fieldConverter.toColumn(this.model.TIPO_PORTA, false)+"=?");
  1319.             }
  1320.             sqlQueryObject.setANDLogicOperator(true);
  1321.             
  1322.             Date next = this.truncDate(this.incrementDate(data, false),false);
  1323.             if(this.debug){
  1324.                 this.logDebug("Aggiorno statistiche ["+this.getTipoStatistiche()+"]");
  1325.                 this.logDebug("Valori update stato record CASE ("+case1WhenStato+"->"+case1ThenStato+") e ("+case2WhenStato+"->"+case2ThenStato+") tr.data_ingresso_richiesta=["+next.getTime()+"]");
  1326.             }
  1327.             List<Object> l = new ArrayList<>();
  1328.             l.add(case1WhenStato); l.add(case1ThenStato);
  1329.             l.add(case2WhenStato); l.add(case2ThenStato);
  1330.             l.add(next);
  1331.             if(tipoPdD!=null) {
  1332.                 l.add(TipoPdD.DELEGATA.equals(tipoPdD)? PddRuolo.DELEGATA.getValue() : PddRuolo.APPLICATIVA.getValue());
  1333.             }
  1334.             int righeModificate = this.statisticaServiceDAO.nativeUpdate(sqlQueryObject.createSQLUpdate(), 
  1335.                     l.toArray(new Object[1]));
  1336.             
  1337.             if(this.debug){
  1338.                 this.logDebug("Modificate ["+righeModificate+"] entry");
  1339.             }

  1341.             return true;

  1343.         }catch(Throwable e){
  1344.             this.logError(e.getMessage(), e);
  1345.             
  1346.             return false;
  1347.         }
  1348.         finally {
  1349.             if(this.debug){
  1350.                 this.logDebug("Update record statistiche negli stati con CASE ("+case1WhenStato+"->"+case1ThenStato+") e ("+case2WhenStato+"->"+case2ThenStato+") ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") terminata");
  1351.             }
  1352.         }

  1354.     }
  1355.     
  1356.     private boolean deleteFisicoStatistiche( TipoPdD tipoPdD, Date data , int statoRecord, boolean equalsStatoRecord) {

  1358.         if(this.debug){
  1359.             this.logDebug("Eliminazione statistiche con stato record '"+statoRecord+"' equals_stato_record:"+equalsStatoRecord+" ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") ...");
  1360.         }

  1362.         try{

  1364.             ISQLFieldConverter fieldConverter = ((IDBServiceUtilities<?>)this.statisticaServiceDAO).getFieldConverter();
  1365.             TipiDatabase tipoDB = fieldConverter.getDatabaseType();
  1366.             
  1367.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1368.             sqlQueryObject.addDeleteTable(fieldConverter.toTable(this.model));
  1369.             sqlQueryObject.addWhereCondition(fieldConverter.toColumn(this.model.DATA, false)+"=?");
  1370.             if(equalsStatoRecord) {
  1371.                 sqlQueryObject.addWhereCondition(fieldConverter.toColumn(this.model.STATO_RECORD, false)+"=?");
  1372.             }
  1373.             else {
  1374.                 /**sqlQueryObject.addWhereCondition(fieldConverter.toColumn(this.model.STATO_RECORD, false)+"<>?");*/
  1375.                 sqlQueryObject.addWhereCondition(fieldConverter.toColumn(this.model.STATO_RECORD, false)+"<?"); // non devo eliminare ne quelli nello stato 1 ne quello nello stato 2
  1376.             }
  1377.             sqlQueryObject.addWhereCondition(fieldConverter.toColumn(this.model.TIPO_PORTA, false)+"=?");
  1378.             sqlQueryObject.setANDLogicOperator(true);
  1379.             
  1380.             Date next = this.truncDate(this.incrementDate(data, false),false);
  1381.             if(this.debug){
  1382.                 this.logDebug("Elimino statistiche ["+this.getTipoStatistiche()+"]");
  1383.                 this.logDebug("Valori eliminazione (ms) tr.data_ingresso_richiesta=["+next.getTime()+"]");
  1384.             }
  1385.             
  1386.             int righeEliminate = this.statisticaServiceDAO.nativeUpdate(sqlQueryObject.createSQLDelete(), 
  1387.                     next, 
  1388.                     statoRecord,
  1389.                     TipoPdD.DELEGATA.equals(tipoPdD)? PddRuolo.DELEGATA.getValue() : PddRuolo.APPLICATIVA.getValue());
  1390.             
  1391.             if(this.debug){
  1392.                 this.logDebug("Eliminate ["+righeEliminate+"] entry");
  1393.             }

  1395.             return true;
  1396.             
  1397.         }catch (Throwable e) {
  1398.             this.logError(e.getMessage(), e);
  1399.             
  1400.             return false;
  1401.         }
  1402.         finally {
  1403.             if(this.debug){
  1404.                 this.logDebug("Eliminazione statistiche con stato record '"+statoRecord+"' equals_stato_record:"+equalsStatoRecord+" ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") terminata");
  1405.             }
  1406.         }

  1408.     }

  1410.     protected abstract Long insertStatistica(Statistica statistica) throws StatisticException;
  1411.     protected abstract void updateStatistica(long idStatistica, StatisticaContenuti ... statisticaContenuti) throws StatisticException;


  1414.     private void insertStatistica(StatisticBean stat, int statoRecord) throws StatisticException  {

  1416.         if(this.debug){
  1417.             this.logDebug("Inserimento statistica ["+stat.toString()+"] in corso ...");
  1418.         }

  1420.         Statistica statisticaBase = new Statistica();

  1422.         statisticaBase.setData(stat.getData());
  1423.         statisticaBase.setStatoRecord(statoRecord);
  1424.         
  1425.         statisticaBase.setTipoPorta(org.openspcoop2.core.statistiche.constants.TipoPorta.toEnumConstant(stat.getTipoPorta().getTipo()));
  1426.         statisticaBase.setIdPorta(stat.getIdPorta());
  1427.         
  1428.         statisticaBase.setTipoMittente(stat.getMittente().getTipo());
  1429.         statisticaBase.setMittente(stat.getMittente().getNome());
  1430.         
  1431.         statisticaBase.setTipoDestinatario(stat.getDestinatario().getTipo());
  1432.         statisticaBase.setDestinatario(stat.getDestinatario().getNome());
  1433.         
  1434.         statisticaBase.setTipoServizio(stat.getTipoServizio());
  1435.         statisticaBase.setServizio(stat.getServizio());
  1436.         statisticaBase.setVersioneServizio(stat.getVersioneServizio());
  1437.         
  1438.         statisticaBase.setAzione(stat.getAzione());
  1439.         
  1440.         statisticaBase.setServizioApplicativo(stat.getServizioApplicativo());
  1441.         
  1442.         statisticaBase.setTrasportoMittente(stat.getTrasportoMittente());
  1443.         
  1444.         statisticaBase.setTokenIssuer(stat.getTokenIssuer());
  1445.         statisticaBase.setTokenClientId(stat.getTokenClientId());
  1446.         statisticaBase.setTokenSubject(stat.getTokenSubject());
  1447.         statisticaBase.setTokenUsername(stat.getTokenUsername());
  1448.         statisticaBase.setTokenMail(stat.getTokenMail());
  1449.         
  1450.         statisticaBase.setClientAddress(stat.getClientAddress());
  1451.         
  1452.         statisticaBase.setGruppi(stat.getGruppo());
  1453.         
  1454.         statisticaBase.setUriApi(stat.getApi());
  1455.         
  1456.         statisticaBase.setClusterId(stat.getClusterId());
  1457.         
  1458.         if(stat.getDestinatario()!=null && stat.getDestinatario().getTipo()!=null) {
  1459.             EsitiProperties esitiProperties = null;
  1460.             int esitoConsegnaMultipla = -1;
  1461.             int esitoConsegnaMultiplaInCorso = -1;
  1462.             int esitoConsegnaMultiplaFallita = -1;
  1463.             int esitoConsegnaMultiplaCompletata = -1;
  1464.             try {
  1465.                 String protocollo = null;
  1466.                 if(stat.getDestinatario()!=null && 
  1467.                         stat.getDestinatario().getTipo()!=null && 
  1468.                         !"".equals(stat.getDestinatario().getTipo()) && 
  1469.                         !Costanti.INFORMAZIONE_NON_DISPONIBILE.equals(stat.getDestinatario().getTipo())) {
  1470.                     protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(stat.getDestinatario().getTipo());
  1471.                 }
  1472.                 else if(stat.getMittente()!=null && 
  1473.                         stat.getMittente().getTipo()!=null && 
  1474.                         !"".equals(stat.getMittente().getTipo()) && 
  1475.                         !Costanti.INFORMAZIONE_NON_DISPONIBILE.equals(stat.getMittente().getTipo())) {
  1476.                     protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(stat.getMittente().getTipo());
  1477.                 }
  1478.                 else {
  1479.                     protocollo = ProtocolFactoryManager.getInstance().getDefaultProtocolFactory().getProtocol();
  1480.                 }
  1481.                 esitiProperties = EsitiProperties.getInstanceFromProtocolName(this.logger, protocollo);
  1482.                 esitoConsegnaMultipla = esitiProperties.convertoToCode(EsitoTransazioneName.CONSEGNA_MULTIPLA);
  1483.                 esitoConsegnaMultiplaInCorso = esitiProperties.convertoToCode(EsitoTransazioneName.CONSEGNA_MULTIPLA_IN_CORSO);
  1484.                 esitoConsegnaMultiplaFallita = esitiProperties.convertoToCode(EsitoTransazioneName.CONSEGNA_MULTIPLA_FALLITA);
  1485.                 esitoConsegnaMultiplaCompletata = esitiProperties.convertoToCode(EsitoTransazioneName.CONSEGNA_MULTIPLA_COMPLETATA);
  1486.                 if(stat.getEsito().intValue() == esitoConsegnaMultiplaInCorso || 
  1487.                         stat.getEsito().intValue() == esitoConsegnaMultiplaFallita || 
  1488.                         stat.getEsito().intValue() == esitoConsegnaMultiplaCompletata) {
  1489.                     statisticaBase.setEsito(esitoConsegnaMultipla);
  1490.                 }
  1491.                 else {
  1492.                     statisticaBase.setEsito(stat.getEsito());
  1493.                 }
  1494.             }catch(Exception er) {
  1495.                 throw new StatisticException(er.getMessage(),er);
  1496.             }
  1497.         }
  1498.         else {
  1499.             statisticaBase.setEsito(stat.getEsito());
  1500.         }
  1501.         statisticaBase.setEsitoContesto(stat.getEsitoContesto());
  1502.         
  1503.         statisticaBase.setNumeroTransazioni((int)stat.getRichieste());
  1504.         
  1505.         statisticaBase.setDimensioniBytesBandaComplessiva(stat.getBytesBandaTotale());
  1506.         statisticaBase.setDimensioniBytesBandaInterna(stat.getBytesBandaInterna());
  1507.         statisticaBase.setDimensioniBytesBandaEsterna(stat.getBytesBandaEsterna());
  1508.         
  1509.         if(stat.getLatenzaServizio()!=Costanti.INFORMAZIONE_LATENZA_NON_DISPONIBILE) {
  1510.             statisticaBase.setLatenzaServizio(stat.getLatenzaServizio());
  1511.         }
  1512.         if(stat.getLatenzaPorta()!=Costanti.INFORMAZIONE_LATENZA_NON_DISPONIBILE) {
  1513.             statisticaBase.setLatenzaPorta(stat.getLatenzaPorta());
  1514.         }
  1515.         if(stat.getLatenzaTotale()!=Costanti.INFORMAZIONE_LATENZA_NON_DISPONIBILE) {
  1516.             statisticaBase.setLatenzaTotale(stat.getLatenzaTotale());
  1517.         }
  1518.         
  1519.         Long id = insertStatistica(statisticaBase);
  1520.         if(id!=null && id >0){
  1521.             stat.setId(id);
  1522.         }   
  1523.         if(this.debug){
  1524.             this.logDebug("Inserimento statistica effettuato con successo");
  1525.         }

  1527.     }
  1528.     
  1529. }
Created with JaCoCo 0.8.8.202204050719