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 {

  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 IServiceManager statisticheSM = null;
  121.     protected IServiceWithoutId<?> statisticaServiceDAO = null;
  122.     protected IServiceSearchWithoutId<?> statisticaServiceSearchDAO = null;
  123.     protected StatisticaModel model = null;
  124.     private IStatisticaInfoServiceSearch statisticaInfoSearchDAO = null;
  125.     private IStatisticaInfoService statisticaInfoDAO = null;
  126.     private org.openspcoop2.core.transazioni.dao.IServiceManager transazioniSM = null;
  127.     private ITransazioneServiceSearch transazioneSearchDAO = null;
  128.     private org.openspcoop2.monitor.engine.config.statistiche.dao.IServiceManager pluginsStatisticheSM = null;
  129.     private org.openspcoop2.core.plugins.dao.IServiceManager pluginsBaseSM = null;
  130.     private org.openspcoop2.core.commons.search.dao.IServiceManager utilsSM = null;
  131.     private org.openspcoop2.monitor.engine.config.transazioni.dao.IServiceManager pluginsTransazioniSM;
  132.     @SuppressWarnings("unused")
  133.     private IConfigurazioneStatisticaService confStatisticaDAO =null;
  134.     private TipiDatabase databaseType;
  135.     private StatisticsForceIndexConfig forceIndexConfig;

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

  139.     private boolean initialized = false;
  140.     
  141.     AbstractStatistiche(){
  142.         
  143.     }
  144.     protected AbstractStatistiche(Logger logger,boolean debug,boolean useUnionForLatency, 
  145.             boolean generazioneStatisticheCustom, boolean analisiTransazioniCustom,
  146.             StatisticsForceIndexConfig forceIndexConfig,
  147.             org.openspcoop2.core.statistiche.dao.IServiceManager statisticheSM,
  148.             org.openspcoop2.core.transazioni.dao.IServiceManager transazioniSM,
  149.             org.openspcoop2.monitor.engine.config.statistiche.dao.IServiceManager pluginsStatisticheSM,
  150.             org.openspcoop2.core.plugins.dao.IServiceManager pluginsBaseSM,
  151.             org.openspcoop2.core.commons.search.dao.IServiceManager utilsSM,
  152.             org.openspcoop2.monitor.engine.config.transazioni.dao.IServiceManager pluginsTransazioniSM){
  153.         if(logger!=null){
  154.             this.logger = logger;
  155.         }
  156.         this.debug = debug;
  157.         this.useUnionForLatency = useUnionForLatency;
  158.         this.generazioneStatisticheCustom = generazioneStatisticheCustom;
  159.         this.analisiTransazioniCustom = analisiTransazioniCustom;
  160.         
  161.         try {
  162.             if(statisticheSM==null){
  163.                 throw new ServiceException("StatisticheServiceManager ["+org.openspcoop2.core.statistiche.dao.IServiceManager.class.getName()+SUFFIX_NON_INIZIALIZZATO);
  164.             }
  165.             if(transazioniSM==null){
  166.                 throw new ServiceException("TransazioniServiceManager ["+org.openspcoop2.core.transazioni.dao.IServiceManager.class.getName()+SUFFIX_NON_INIZIALIZZATO);
  167.             }
  168.             
  169.             this.statisticheSM = statisticheSM;
  170.             this.statisticaInfoSearchDAO = this.statisticheSM.getStatisticaInfoServiceSearch();
  171.             this.statisticaInfoDAO = this.statisticheSM.getStatisticaInfoService();

  173.             this.databaseType = DAOFactoryProperties.getInstance(this.logger).getTipoDatabaseEnum(org.openspcoop2.core.statistiche.utils.ProjectInfo.getInstance());
  174.             
  175.             this.transazioniSM = transazioniSM;
  176.             this.transazioneSearchDAO = this.transazioniSM.getTransazioneServiceSearch();

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

  213.     public boolean isDebug() {
  214.         return this.debug;
  215.     }
  216.     
  217.     protected TipiDatabase getDatabaseType() {
  218.         return this.databaseType;
  219.     }
  220.     
  221.     public void printDate(Date d){
  222.         Calendar c = Calendar.getInstance();
  223.         c.setTime(d);
  224.         printCalendar(c);
  225.     }

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

  241.     // METODI ASTRATTI
  242.     public abstract Date truncDate(Date date,boolean print);

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

  246.     public abstract Date decrementDate(Date date,boolean print);

  248.     public Date decrementDate1Millisecond(Date date){
  249.         Calendar cTmp = Calendar.getInstance();
  250.         cTmp.setTime(date);
  251.         cTmp.add(Calendar.MILLISECOND, -1);
  252.         return cTmp.getTime();
  253.     }

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

  257.     private String getIntervalloStatistica(Date date){
  258.         Date d = this.incrementDate(date, false);
  259.         return this.getIntervalloStatistica(d, false);
  260.     }

  262.     public abstract TipoIntervalloStatistico getTipoStatistiche();

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

  266.     public abstract String getStatisticPluginMethodName() throws StatisticException;


  269.     public void generaStatistiche( boolean gestioneUltimoIntervallo, long waitMsBeforeNextInterval, boolean waitStatiInConsegna) throws Exception{

  271.         if(!this.initialized){
  272.             throw new ServiceException("Inizializzazione fallita (verificare errori precedenti)");
  273.         }

  275.         try{
  276.             if(this.debug)
  277.                 this.logDebug("********************************************* "+this.getTipoStatistiche()+" *******************************************************");

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

  288.             Date dataAvvioBatch = DateManager.getDate();

  290.             // Now
  291.             // Tale data viene troncata in funzione della statistica che sto eseguendo 
  292.             Date now = new Date();
  293.             now = truncDate(now,false);
  294.             now = this.decrementDate1Millisecond(now);
  295.             Date nowMenoUno = decrementDate(now, false);

  297.             
  298.             // 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
  299.             boolean saveDataStatistica = true; 
  300.             
  301.             
  302.             // Genero statistiche per transazioni emessi in data > dataUltimaGenerazioneStatistiche AND data <= now
  303.             while(dataUltimaGenerazioneStatistiche.compareTo(nowMenoUno) <= 0){

  305.                 // genera
  306.                 boolean generazioneCompletataConSuccesso = generaStatistica(dataUltimaGenerazioneStatistiche, 
  307.                         dataAvvioBatch, waitMsBeforeNextInterval, 
  308.                         waitStatiInConsegna);
  309.                 if(!generazioneCompletataConSuccesso) {
  310.                     saveDataStatistica = false;
  311.                 }
  312.                                                 
  313.                 // increment
  314.                 dataUltimaGenerazioneStatistiche = incrementDate(dataUltimaGenerazioneStatistiche, false);
  315.                 if(this.debug)
  316.                     this.logDebug("-----------------------");

  318.                 // Salvo nuova data di ultima generazione statistiche (entro nel prossimo intervallo)
  319.                 if(saveDataStatistica) {
  320.                     Date next = this.truncDate(this.incrementDate(dataUltimaGenerazioneStatistiche, false),false);
  321.                     if(this.debug)
  322.                         this.logDebug("Save data ultima generazione statistiche: "+next.toString());
  323.                     StatisticsInfoUtils.updateDataUltimaGenerazioneStatistiche(this.statisticaInfoSearchDAO, this.statisticaInfoDAO, 
  324.                             this.getTipoStatistiche(), this.logger, next);
  325.                 }
  326.                 
  327.             }


  330.             // Genero statistiche parziali della data di oggi
  331.             if(gestioneUltimoIntervallo){

  333.                 Date dataUltimoIntervallo = dataUltimaGenerazioneStatistiche;

  335.                 // genera
  336.                 generaStatistica(dataUltimoIntervallo, 
  337.                         dataAvvioBatch, -1, 
  338.                         false);
  339.                 
  340.             }

  342.         }catch(Exception e){
  343.             this.logError(e.getMessage(), e);
  344.             throw e;
  345.         }
  346.     }

  348.     private boolean generaStatistica(Date dataUltimaGenerazioneStatistiche, 
  349.             Date dataAvvioBatch, long waitMsBeforeNextInterval, 
  350.             boolean waitStatiInConsegna) {
  351.         
  352.         // Algoritmo
  353.         // Per la data in fase di aggiornamento:
  354.         // - 1) si elimina eventuali record rimasti "sporchi" (stato_record <1)
  355.         // - 2) i record esistenti nell'intervallo vengono portati al valore stato_record=2
  356.         // - 3) i nuovi record aggiunti vengono creati con stato_record=0
  357.         // - 4) si fa un unico comando di update nell'intervallo con CASE WHEN stato_record==2 THEN -2 WHEN stato_record==0 THEN 1
  358.         // - 5) si eliminano i record nell'intervallo con stato_record=-2
  359.         
  360.         /**if(dataUltimaGenerazioneStatistiche.compareTo(nowMenoUno) == 0){*/
  361.         // 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
  362.         // Se ho la stessa data devo eliminare l'intervallo, posso gia' averlo generato
  363.         // Eliminazione (Fase 1)
  364.         if(this.debug)
  365.             this.logDebug("----------- pulizia Fase1 (DataUguale) ------------");
  366.         boolean esito = this.deleteFisicoStatistiche( TipoPdD.DELEGATA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_VALIDO, false);
  367.         if(!esito) {
  368.             return false;
  369.         }
  370.         if(this.debug)
  371.             this.logDebug("------------ pulizia Fase1 (DataUguale) -----------");
  372.         esito = this.deleteFisicoStatistiche( TipoPdD.APPLICATIVA, dataUltimaGenerazioneStatistiche, CostantiDB.STATISTICHE_STATO_RECORD_VALIDO, false);
  373.         if(!esito) {
  374.             return false;
  375.         }
  376.         //}

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

  418.         // Promozione Record (Fase4)
  419.         boolean unicaPromozione = true; // deve essere un unico comando sql
  420.         if(unicaPromozione) {
  421.             if(this.debug)
  422.                 this.logDebug("----------- promozione Fase4 (DataUguale) ------------");
  423.             esito = this.updateStatoRecordStatistiche( null, dataUltimaGenerazioneStatistiche, 
  424.                     CostantiDB.STATISTICHE_STATO_RECORD_ANCORA_VALIDO_IN_FASE_DI_AGGIORNAMENTO, CostantiDB.STATISTICHE_STATO_RECORD_ELIMINATO,
  425.                     CostantiDB.STATISTICHE_STATO_RECORD_IN_AGGIORNAMENTO, CostantiDB.STATISTICHE_STATO_RECORD_VALIDO);
  426.             if(!esito) {
  427.                 return false;
  428.             }
  429.         }
  430.         else {
  431.             if(this.debug)
  432.                 this.logDebug("----------- promozione Fase4 (DataUguale) ------------");
  433.             esito = this.updateStatoRecordStatistiche( TipoPdD.DELEGATA, dataUltimaGenerazioneStatistiche, 
  434.                     CostantiDB.STATISTICHE_STATO_RECORD_ANCORA_VALIDO_IN_FASE_DI_AGGIORNAMENTO, CostantiDB.STATISTICHE_STATO_RECORD_ELIMINATO,
  435.                     CostantiDB.STATISTICHE_STATO_RECORD_IN_AGGIORNAMENTO, CostantiDB.STATISTICHE_STATO_RECORD_VALIDO);
  436.             if(!esito) {
  437.                 return false;
  438.             }
  439.             if(this.debug)
  440.                 this.logDebug("------------ promozione Fase4 (DataUguale) -----------");
  441.             esito = this.updateStatoRecordStatistiche( TipoPdD.APPLICATIVA, 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.         }

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

  495.     
  496.     
  497.     
  498.     // ---- GENERAZIONE STATISTICHE BASE ----
  499.     
  500.     private boolean generaStatisticheUnion(TipoPdD tipoPdD, Date data, int statoRecord, BooleanNullable statiInCorso) {

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

  524.             // ** Where **
  525.             // Creo intervallo
  526.             Date dateNext = incrementDate(data, false);
  527.             
  528.             IExpression exprConLatenze = this.transazioneSearchDAO.newExpression();
  529.             StatisticsUtils.setExpressionNotNullDate(this.transazioneSearchDAO, exprConLatenze, data, dateNext, tipoPdD, null, fieldConverter);
  530.             
  531.             IExpression exprSenzaLatenze = this.transazioneSearchDAO.newExpression();
  532.             StatisticsUtils.setExpressionNullDate(this.transazioneSearchDAO, exprSenzaLatenze, data, dateNext, tipoPdD, null, fieldConverter);

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

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


  614.         } catch (ServiceException e){
  615.             this.logError(e.getMessage(),e);
  616.             generazioneOk = false;
  617.         } catch (NotImplementedException e) {
  618.             this.logError(e.getMessage(),e);
  619.             generazioneOk = false;
  620.         } catch (ExpressionNotImplementedException e) {
  621.             this.logError(e.getMessage(),e);
  622.             generazioneOk = false;
  623.         } catch (ExpressionException e) {
  624.             this.logError(e.getMessage(),e);
  625.             generazioneOk = false;
  626.         } catch (NotFoundException e) {
  627.             if(this.debug){
  628.                 this.logDebug(e.getMessage(),e);
  629.             }
  630.         }catch (Throwable e) {
  631.             this.logError(e.getMessage(),e);
  632.             generazioneOk = false;
  633.         }  

  635.         if(this.debug){
  636.             this.logDebug("Generazione statistiche ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") terminata");
  637.         }
  638.                 
  639.         return generazioneOk;
  640.     }
  641.     
  642.     private boolean generaStatistiche(  TipoPdD tipoPdD, Date data, int statoRecord, BooleanNullable statiInCorso) {

  644.         boolean generazioneOk = true;
  645.         
  646.         if(this.debug){
  647.             this.logDebug("Generazione statistiche ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") ...");
  648.         }
  649.         try{
  650.             IExpression expr = this.transazioneSearchDAO.newExpression();

  652.             ISQLFieldConverter fieldConverter = ((IDBServiceUtilities<?>)this.transazioneSearchDAO).getFieldConverter(); 
  653.             
  654.             // ** Select field **
  655.             List<FunctionField> selectList = new ArrayList<>();
  656.             StatisticsUtils.addSelectFieldCountTransaction(selectList);
  657.             StatisticsUtils.addSelectFieldSizeTransaction(tipoPdD, selectList);
  658.             
  659.             // ** Where **
  660.             // Creo intervallo
  661.             Date dateNext = incrementDate(data, false);
  662.             StatisticsUtils.setExpression(this.transazioneSearchDAO, expr, data, dateNext, tipoPdD, false, null, fieldConverter);

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

  669.             if(this.forceIndexConfig!=null){
  670.                 if(this.forceIndexConfig.getTransazioniForceIndexGroupByNumeroDimensione()!=null){
  671.                     List<Index> listForceIndexes = this.forceIndexConfig.getTransazioniForceIndexGroupByNumeroDimensione();
  672.                     if(!listForceIndexes.isEmpty()){
  673.                         for (Index index : listForceIndexes) {
  674.                             expr.addForceIndex(index);
  675.                         }
  676.                     }
  677.                 }
  678.             }
  679.             
  680.             List<Map<String, Object>> list = this.transazioneSearchDAO.groupBy(expr, selectList.toArray(new FunctionField[1]));

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


  728.         } catch (ServiceException e){
  729.             this.logError(e.getMessage(),e);
  730.             generazioneOk = false;
  731.         } catch (NotImplementedException e) {
  732.             this.logError(e.getMessage(),e);
  733.             generazioneOk = false;
  734.         } catch (ExpressionNotImplementedException e) {
  735.             this.logError(e.getMessage(),e);
  736.             generazioneOk = false;
  737.         } catch (ExpressionException e) {
  738.             this.logError(e.getMessage(),e);
  739.             generazioneOk = false;
  740.         } catch (NotFoundException e) {
  741.             if(this.debug){
  742.                 this.logDebug(e.getMessage(),e);
  743.             }
  744.         }catch (Throwable e) {
  745.             this.logError(e.getMessage(),e);
  746.             generazioneOk = false;
  747.         }  

  749.         if(this.debug){
  750.             this.logDebug("Generazione statistiche ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") terminata");
  751.         }
  752.                 
  753.         return generazioneOk;
  754.     }
  755.     
  756.     private StatisticBean readStatisticBean(Date data,Map<String, Object> row, ISQLFieldConverter fieldConverter, boolean useFieldConverter) throws ExpressionException{
  757.         StatisticBean stat = new StatisticBean();

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

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

  824.         /**IExpression expr;*/
  825.         try {
  826. /**         expr = this.confStatisticaDAO.newExpression();
  827. //          expr.and();
  828. //
  829. //          expr.equals(ConfigurazioneStatistica.model().ID_CONFIGURAZIONE_SERVIZIO_AZIONE.ID_CONFIGURAZIONE_SERVIZIO.SERVIZIO, stat.getServizio());
  830. //
  831. //          if ("*".equals(stat.getAzione())) {
  832. //              expr.and().equals(ConfigurazioneStatistica.model().ID_CONFIGURAZIONE_SERVIZIO_AZIONE.AZIONE, "*");
  833. //          } else {
  834. //              IExpression orExpr = this.confStatisticaDAO.newExpression();
  835. //              orExpr.or();
  836. //              orExpr.equals(ConfigurazioneStatistica.model().ID_CONFIGURAZIONE_SERVIZIO_AZIONE.AZIONE, "*");
  837. //              orExpr.equals(ConfigurazioneStatistica.model().ID_CONFIGURAZIONE_SERVIZIO_AZIONE.AZIONE, stat.getAzione());
  838. //
  839. //              expr.and(orExpr);
  840. //          }
  841. //          
  842. //          expr.equals(ConfigurazioneStatistica.model().ENABLED, true);
  843. //
  844. //          IPaginatedExpression pagExpr = this.confStatisticaDAO.toPaginatedExpression(expr);
  845. //          List<ConfigurazioneStatistica> list = this.confStatisticaDAO.findAll(pagExpr);*/

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

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

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

  940.         } catch (Exception e) {
  941.             this.logError(e.getMessage(), e);
  942.         } 

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

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

  1035.             IExpression expr = this.transazioneSearchDAO.newExpression();
  1036.             
  1037.             List<FunctionField> selectList = new ArrayList<>();
  1038.             StatisticsUtils.addSelectFieldCountTransaction(selectList);
  1039.             StatisticsUtils.addSelectFieldSizeTransaction(tipoPdD, selectList);
  1040.             
  1041.             // Creo espressione
  1042.             List<AliasFilter> aliases = new ArrayList<>();
  1043.             if(gropuByStato){
  1044.                 StatisticsUtils.setExpressionByStato(this.transazioneSearchDAO, expr, dateLeft, dateRight, tipoPdD, false, stat, fieldConverter);
  1045.             }else{
  1046.                 StatisticsUtils.setExpressionStatsPersonalizzate(this.transazioneSearchDAO, expr, dateLeft, dateRight, tipoPdD, false, stat, fieldConverter, 
  1047.                         aliases, idRisorsa, risorseFiltri);
  1048.             }

  1050.             // aggiungo eventuale filtro personalizzato
  1051.             if(risorsaAggregata!=null && (risorsaAggregata.getFiltro() instanceof FilterImpl)){
  1052.                 FilterImpl f = (FilterImpl) risorsaAggregata.getFiltro();
  1053.                 expr.and(f.getExpression());
  1054.             }
  1055.             
  1056.             if(this.debug){
  1057.                 this.logDebug("Analizzo dati di base statistica personalizzata ["+idStatisticaPersonalizzata+"]  ["+this.getTipoStatistiche()+
  1058.                         "] Intervallo date: ["+dateLeft.toString()+" - "+dateRight.toString()+"]");
  1059.                 this.logDebug("Valori query (ms) tr.data_ingresso_richiesta>["+dateLeft.getTime()+"] AND tr.data_ingresso_richiesta<=["+dateRight.getTime()+"]");
  1060.                 this.logDebug("Expr: "+expr.toString());
  1061.             }

  1063.             if(this.forceIndexConfig!=null){
  1064.                 if(this.forceIndexConfig.getTransazioniForceIndexGroupByCustomNumeroDimensione()!=null){
  1065.                     List<Index> listForceIndexes = this.forceIndexConfig.getTransazioniForceIndexGroupByCustomNumeroDimensione();
  1066.                     if(!listForceIndexes.isEmpty()){
  1067.                         for (Index index : listForceIndexes) {
  1068.                             expr.addForceIndex(index);
  1069.                         }
  1070.                     }
  1071.                 }
  1072.             }
  1073.             
  1074.             List<Map<String, Object>> list = this.transazioneSearchDAO.groupBy(expr, selectList.toArray(new FunctionField[1]));

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

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


  1207.         } catch (ServiceException e){
  1208.             this.logError(e.getMessage(),e);
  1209.         } catch (NotImplementedException e) {
  1210.             this.logError(e.getMessage(),e);
  1211.         } catch (ExpressionNotImplementedException e) {
  1212.             this.logError(e.getMessage(),e);
  1213.         } catch (ExpressionException e) {
  1214.             this.logError(e.getMessage(),e);
  1215.         } catch (NotFoundException e) {
  1216.             if(this.debug){
  1217.                 this.logDebug(e.getMessage(),e);
  1218.             }
  1219.         }catch (Exception e) {
  1220.             this.logError(e.getMessage(),e);
  1221.         }  

  1223.         if(this.debug){
  1224.             this.logDebug("Generazione statistica personalizzata ["+idStatisticaPersonalizzata+"] ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+
  1225.                     this.getIntervalloStatistica(dateStatistics,false)+") terminata");
  1226.         }
  1227.     }


  1230.     
  1231.     
  1232.     
  1233.     
  1234.     
  1235.     
  1236.     // ---- CRUD ----


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

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

  1245.         try{

  1247.             ISQLFieldConverter fieldConverter = ((IDBServiceUtilities<?>)this.statisticaServiceDAO).getFieldConverter();
  1248.             TipiDatabase tipoDB = fieldConverter.getDatabaseType();
  1249.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1250.             sqlQueryObject.addUpdateTable(fieldConverter.toTable(this.model));
  1251.             sqlQueryObject.addUpdateField(fieldConverter.toColumn(this.model.STATO_RECORD, false), "?");
  1252.             sqlQueryObject.addWhereCondition(fieldConverter.toColumn(this.model.DATA, false)+"=?");
  1253.             sqlQueryObject.addWhereCondition(fieldConverter.toColumn(this.model.TIPO_PORTA, false)+"=?");
  1254.             sqlQueryObject.setANDLogicOperator(true);
  1255.             
  1256.             Date next = this.truncDate(this.incrementDate(data, false),false);
  1257.             if(this.debug){
  1258.                 this.logDebug("Aggiorno statistiche ["+this.getTipoStatistiche()+"]");
  1259.                 this.logDebug("Valori update stato record = ("+stato+") tr.data_ingresso_richiesta=["+next.getTime()+"]");
  1260.             }
  1261.             int righeModificate = this.statisticaServiceDAO.nativeUpdate(sqlQueryObject.createSQLUpdate(), 
  1262.                     stato,
  1263.                     next, 
  1264.                     TipoPdD.DELEGATA.equals(tipoPdD)? PddRuolo.DELEGATA.getValue() : PddRuolo.APPLICATIVA.getValue());
  1265.             
  1266.             if(this.debug){
  1267.                 this.logDebug("Modificate ["+righeModificate+"] entry");
  1268.             }

  1270.             return true;

  1272.         }catch(Throwable e){
  1273.             this.logError(e.getMessage(), e);
  1274.             
  1275.             return false;
  1276.         }
  1277.         finally {
  1278.             if(this.debug){
  1279.                 this.logDebug("Update record statistiche allo stato '"+stato+"' ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") terminata");
  1280.             }
  1281.         }

  1283.     }
  1284.     
  1285.     private boolean updateStatoRecordStatistiche( TipoPdD tipoPdD, Date data, 
  1286.             int case1WhenStato, int case1ThenStato,
  1287.             int case2WhenStato, int case2ThenStato) {

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

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

  1330.             return true;

  1332.         }catch(Throwable e){
  1333.             this.logError(e.getMessage(), e);
  1334.             
  1335.             return false;
  1336.         }
  1337.         finally {
  1338.             if(this.debug){
  1339.                 this.logDebug("Update record statistiche negli stati con CASE ("+case1WhenStato+"->"+case1ThenStato+") e ("+case2WhenStato+"->"+case2ThenStato+") ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") terminata");
  1340.             }
  1341.         }

  1343.     }
  1344.     
  1345.     private boolean deleteFisicoStatistiche( TipoPdD tipoPdD, Date data , int statoRecord, boolean equalsStatoRecord) {

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

  1351.         try{

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

  1384.             return true;
  1385.             
  1386.         }catch (Throwable e) {
  1387.             this.logError(e.getMessage(), e);
  1388.             
  1389.             return false;
  1390.         }
  1391.         finally {
  1392.             if(this.debug){
  1393.                 this.logDebug("Eliminazione statistiche con stato record '"+statoRecord+"' equals_stato_record:"+equalsStatoRecord+" ["+this.getTipoStatistiche()+"] ["+tipoPdD+"]("+this.getIntervalloStatistica(data)+") terminata");
  1394.             }
  1395.         }

  1397.     }

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


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

  1405.         if(this.debug){
  1406.             this.logDebug("Inserimento statistica ["+stat.toString()+"] in corso ...");
  1407.         }

  1409.         Statistica statisticaBase = new Statistica();

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

  1516.     }
  1517.     
  1518. }
Created with JaCoCo 0.8.8.202204050719